ext-all-debug.js
上传用户:dawnssy
上传日期:2022-08-06
资源大小:9345k
文件大小:1167k
源码类别:

JavaScript

开发平台:

JavaScript

  1.     var me = this;
  2.     return !local ? me.getX() + me.getWidth() : (me.getLeft(true) + me.getWidth()) || 0;
  3.     },
  4.     
  5.     getTop : function(local) {
  6.     return !local ? this.getY() : parseInt(this.getStyle(TOP), 10) || 0;
  7.     },
  8.     
  9.     getBottom : function(local){
  10.     var me = this;
  11.     return !local ? me.getY() + me.getHeight() : (me.getTop(true) + me.getHeight()) || 0;
  12.     },
  13.     
  14.     position : function(pos, zIndex, x, y){
  15.     var me = this;
  16.     
  17.         if(!pos && me.isStyle(POSITION, STATIC)){           
  18.             me.setStyle(POSITION, RELATIVE);           
  19.         } else if(pos) {
  20.             me.setStyle(POSITION, pos);
  21.         }
  22.         if(zIndex){
  23.             me.setStyle(ZINDEX, zIndex);
  24.         }
  25.         if(x || y) me.setXY([x || false, y || false]);
  26.     },
  27.     
  28.     clearPositioning : function(value){
  29.         value = value || '';
  30.         this.setStyle({
  31.             left : value,
  32.             right : value,
  33.             top : value,
  34.             bottom : value,
  35.             "z-index" : "",
  36.             position : STATIC
  37.         });
  38.         return this;
  39.     },
  40.     
  41.     getPositioning : function(){
  42.         var l = this.getStyle(LEFT);
  43.         var t = this.getStyle(TOP);
  44.         return {
  45.             "position" : this.getStyle(POSITION),
  46.             "left" : l,
  47.             "right" : l ? "" : this.getStyle(RIGHT),
  48.             "top" : t,
  49.             "bottom" : t ? "" : this.getStyle(BOTTOM),
  50.             "z-index" : this.getStyle(ZINDEX)
  51.         };
  52.     },
  53.     
  54.     
  55.     setPositioning : function(pc){
  56.     var me = this,
  57.      style = me.dom.style;
  58.     
  59.         me.setStyle(pc);
  60.         
  61.         if(pc.right == AUTO){
  62.             style.right = "";
  63.         }
  64.         if(pc.bottom == AUTO){
  65.             style.bottom = "";
  66.         }
  67.         
  68.         return me;
  69.     },    
  70.     
  71.     translatePoints : function(x, y){              
  72.     y = isNaN(x[1]) ? y : x[1];
  73.         x = isNaN(x[0]) ? x : x[0];
  74.         var me = this,
  75.          relative = me.isStyle(POSITION, RELATIVE),
  76.          o = me.getXY(),
  77.          l = parseInt(me.getStyle(LEFT), 10),
  78.          t = parseInt(me.getStyle(TOP), 10);
  79.         
  80.         l = !isNaN(l) ? l : (relative ? 0 : me.dom.offsetLeft);
  81.         t = !isNaN(t) ? t : (relative ? 0 : me.dom.offsetTop);        
  82.         return {left: (x - o[0] + l), top: (y - o[1] + t)}; 
  83.     },
  84.     
  85.     animTest : function(args, animate, i) {
  86.         return !!animate && this.preanim ? this.preanim(args, i) : false;
  87.     }
  88. });
  89. })();
  90. Ext.Element.addMethods({
  91.     
  92.     setBox : function(box, adjust, animate){
  93.         var me = this,
  94.          w = box.width, 
  95.          h = box.height;
  96.         if((adjust && !me.autoBoxAdjust) && !me.isBorderBox()){
  97.            w -= (me.getBorderWidth("lr") + me.getPadding("lr"));
  98.            h -= (me.getBorderWidth("tb") + me.getPadding("tb"));
  99.         }
  100.         me.setBounds(box.x, box.y, w, h, me.animTest.call(me, arguments, animate, 2));
  101.         return me;
  102.     },
  103.     
  104. getBox : function(contentBox, local) {     
  105.     var me = this,
  106.          xy,
  107.          left,
  108.          top,
  109.          getBorderWidth = me.getBorderWidth,
  110.          getPadding = me.getPadding, 
  111.          l,
  112.          r,
  113.          t,
  114.          b;
  115.         if(!local){
  116.             xy = me.getXY();
  117.         }else{
  118.             left = parseInt(me.getStyle("left"), 10) || 0;
  119.             top = parseInt(me.getStyle("top"), 10) || 0;
  120.             xy = [left, top];
  121.         }
  122.         var el = me.dom, w = el.offsetWidth, h = el.offsetHeight, bx;
  123.         if(!contentBox){
  124.             bx = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: w, height: h};
  125.         }else{
  126.             l = getBorderWidth.call(me, "l") + getPadding.call(me, "l");
  127.             r = getBorderWidth.call(me, "r") + getPadding.call(me, "r");
  128.             t = getBorderWidth.call(me, "t") + getPadding.call(me, "t");
  129.             b = getBorderWidth.call(me, "b") + getPadding.call(me, "b");
  130.             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)};
  131.         }
  132.         bx.right = bx.x + bx.width;
  133.         bx.bottom = bx.y + bx.height;
  134.         return bx;
  135. },
  136.     
  137.      move : function(direction, distance, animate){
  138.         var me = this,        
  139.          xy = me.getXY(),
  140.          x = xy[0],
  141.          y = xy[1],        
  142.          left = [x - distance, y],
  143.          right = [x + distance, y],
  144.          top = [x, y - distance],
  145.          bottom = [x, y + distance],
  146.         hash = {
  147.          l : left,
  148.          left : left,
  149.          r : right,
  150.          right : right,
  151.          t : top,
  152.          top : top,
  153.          up : top,
  154.          b : bottom, 
  155.          bottom : bottom,
  156.          down : bottom         
  157.         };
  158.         
  159.       direction = direction.toLowerCase();    
  160.       me.moveTo(hash[direction][0], hash[direction][1], me.animTest.call(me, arguments, animate, 2));
  161.     },
  162.     
  163.     
  164.      setLeftTop : function(left, top){
  165.     var me = this,
  166.      style = me.dom.style;
  167.         style.left = me.addUnits(left);
  168.         style.top = me.addUnits(top);
  169.         return me;
  170.     },
  171.     
  172.     
  173.     getRegion : function(){
  174.         return Ext.lib.Dom.getRegion(this.dom);
  175.     },
  176.     
  177.     
  178.     setBounds : function(x, y, width, height, animate){
  179.     var me = this;
  180.         if (!animate || !me.anim) {
  181.             me.setSize(width, height);
  182.             me.setLocation(x, y);
  183.         } else {
  184.             me.anim({points: {to: [x, y]}, 
  185.               width: {to: me.adjustWidth(width)}, 
  186.               height: {to: me.adjustHeight(height)}},
  187.                      me.preanim(arguments, 4), 
  188.                      'motion');
  189.         }
  190.         return me;
  191.     },
  192.     
  193.     setRegion : function(region, animate) {
  194.         return this.setBounds(region.left, region.top, region.right-region.left, region.bottom-region.top, this.animTest.call(this, arguments, animate, 1));
  195.     }
  196. });
  197. Ext.Element.addMethods({
  198.     
  199.     isScrollable : function(){
  200.         var dom = this.dom;
  201.         return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
  202.     },
  203.     
  204.     scrollTo : function(side, value){
  205.         this.dom["scroll" + (/top/i.test(side) ? "Top" : "Left")] = value;
  206.         return this;
  207.     },
  208.     
  209.     getScroll : function(){
  210.         var d = this.dom, 
  211.             doc = document,
  212.             body = doc.body,
  213.             docElement = doc.documentElement,
  214.             l,
  215.             t,
  216.             ret;
  217.         if(d == doc || d == body){
  218.             if(Ext.isIE && Ext.isStrict){
  219.                 l = docElement.scrollLeft; 
  220.                 t = docElement.scrollTop;
  221.             }else{
  222.                 l = window.pageXOffset;
  223.                 t = window.pageYOffset;
  224.             }
  225.             ret = {left: l || (body ? body.scrollLeft : 0), top: t || (body ? body.scrollTop : 0)};
  226.         }else{
  227.             ret = {left: d.scrollLeft, top: d.scrollTop};
  228.         }
  229.         return ret;
  230.     }
  231. });
  232. Ext.Element.addMethods({
  233.     
  234.     scrollTo : function(side, value, animate){
  235.         var top = /top/i.test(side), 
  236.          me = this,
  237.          dom = me.dom,
  238.             prop;
  239.         if (!animate || !me.anim) {
  240.             prop = 'scroll' + (top ? 'Top' : 'Left'), 
  241.             dom[prop] = value;
  242.         }else{
  243.             prop = 'scroll' + (top ? 'Left' : 'Top'), 
  244.             me.anim({scroll: {to: top ? [dom[prop], value] : [value, dom[prop]]}},
  245.               me.preanim(arguments, 2), 'scroll');
  246.         }
  247.         return me;
  248.     },
  249.     
  250.     
  251.     scrollIntoView : function(container, hscroll){
  252.         var c = Ext.getDom(container) || Ext.getBody().dom,
  253.          el = this.dom,
  254.          o = this.getOffsetsTo(c),
  255.             l = o[0] + c.scrollLeft,
  256.             t = o[1] + c.scrollTop,
  257.             b = t + el.offsetHeight,
  258.             r = l + el.offsetWidth,
  259.          ch = c.clientHeight,
  260.          ct = parseInt(c.scrollTop, 10),
  261.          cl = parseInt(c.scrollLeft, 10),
  262.          cb = ct + ch,
  263.          cr = cl + c.clientWidth;
  264.         if (el.offsetHeight > ch || t < ct) {
  265.          c.scrollTop = t;
  266.         } else if (b > cb){
  267.             c.scrollTop = b-ch;
  268.         }
  269.         c.scrollTop = c.scrollTop; 
  270.         if(hscroll !== false){
  271. if(el.offsetWidth > c.clientWidth || l < cl){
  272.                 c.scrollLeft = l;
  273.             }else if(r > cr){
  274.                 c.scrollLeft = r - c.clientWidth;
  275.             }
  276.             c.scrollLeft = c.scrollLeft;
  277.         }
  278.         return this;
  279.     },
  280.     
  281.     scrollChildIntoView : function(child, hscroll){
  282.         Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);
  283.     },
  284.     
  285.     
  286.      scroll : function(direction, distance, animate){
  287.          if(!this.isScrollable()){
  288.              return;
  289.          }
  290.          var el = this.dom,
  291.             l = el.scrollLeft, t = el.scrollTop,
  292.             w = el.scrollWidth, h = el.scrollHeight,
  293.             cw = el.clientWidth, ch = el.clientHeight,
  294.             scrolled = false, v,
  295.             hash = {
  296.                 l: Math.min(l + distance, w-cw),
  297.                 r: v = Math.max(l - distance, 0),
  298.                 t: Math.max(t - distance, 0),
  299.                 b: Math.min(t + distance, h-ch)
  300.             };
  301.             hash.d = hash.b;
  302.             hash.u = hash.t;
  303.             
  304.          direction = direction.substr(0, 1);
  305.          if((v = hash[direction]) > -1){
  306.             scrolled = true;
  307.             this.scrollTo(direction == 'l' || direction == 'r' ? 'left' : 'top', v, this.preanim(arguments, 2));
  308.          }
  309.          return scrolled;
  310.     }
  311. });
  312. Ext.Element.VISIBILITY = 1;
  313. Ext.Element.DISPLAY = 2;
  314. Ext.Element.addMethods(function(){
  315.     var VISIBILITY = "visibility",
  316.         DISPLAY = "display",
  317.         HIDDEN = "hidden",
  318.         NONE = "none",      
  319.         ORIGINALDISPLAY = 'originalDisplay',
  320.         VISMODE = 'visibilityMode',
  321.         ELDISPLAY = Ext.Element.DISPLAY,
  322.         data = Ext.Element.data,
  323.         getDisplay = function(dom){
  324.             var d = data(dom, ORIGINALDISPLAY);
  325.             if(d === undefined){
  326.                 data(dom, ORIGINALDISPLAY, d = '');
  327.             }
  328.             return d;
  329.         },
  330.         getVisMode = function(dom){
  331.             var m = data(dom, VISMODE);
  332.             if(m === undefined){
  333.                 data(dom, VISMODE, m = 1)
  334.             }
  335.             return m;
  336.         };
  337.     
  338.     return {
  339.         
  340.         originalDisplay : "",
  341.         visibilityMode : 1,
  342.         
  343.         
  344.         setVisibilityMode : function(visMode){  
  345.             data(this.dom, VISMODE, visMode);
  346.             return this;
  347.         },
  348.         
  349.         
  350.         animate : function(args, duration, onComplete, easing, animType){       
  351.             this.anim(args, {duration: duration, callback: onComplete, easing: easing}, animType);
  352.             return this;
  353.         },
  354.     
  355.         
  356.         anim : function(args, opt, animType, defaultDur, defaultEase, cb){
  357.             animType = animType || 'run';
  358.             opt = opt || {};
  359.             var me = this,              
  360.                 anim = Ext.lib.Anim[animType](
  361.                     me.dom, 
  362.                     args,
  363.                     (opt.duration || defaultDur) || .35,
  364.                     (opt.easing || defaultEase) || 'easeOut',
  365.                     function(){
  366.                         if(cb) cb.call(me);
  367.                         if(opt.callback) opt.callback.call(opt.scope || me, me, opt);
  368.                     },
  369.                     me
  370.                 );
  371.             opt.anim = anim;
  372.             return anim;
  373.         },
  374.     
  375.         
  376.         preanim : function(a, i){
  377.             return !a[i] ? false : (Ext.isObject(a[i]) ? a[i]: {duration: a[i+1], callback: a[i+2], easing: a[i+3]});
  378.         },
  379.         
  380.         
  381.         isVisible : function() {
  382.             return !this.isStyle(VISIBILITY, HIDDEN) && !this.isStyle(DISPLAY, NONE);
  383.         },
  384.         
  385.         
  386.          setVisible : function(visible, animate){
  387.             var me = this,
  388.                 dom = me.dom,
  389.                 isDisplay = getVisMode(this.dom) == ELDISPLAY;
  390.                 
  391.             if (!animate || !me.anim) {
  392.                 if(isDisplay){
  393.                     me.setDisplayed(visible);
  394.                 }else{
  395.                     me.fixDisplay();
  396.                     dom.style.visibility = visible ? "visible" : HIDDEN;
  397.                 }
  398.             }else{
  399.                 
  400.                 if(visible){
  401.                     me.setOpacity(.01);
  402.                     me.setVisible(true);
  403.                 }
  404.                 me.anim({opacity: { to: (visible?1:0) }},
  405.                         me.preanim(arguments, 1),
  406.                         null,
  407.                         .35,
  408.                         'easeIn',
  409.                         function(){
  410.                              if(!visible){
  411.                                  dom.style[isDisplay ? DISPLAY : VISIBILITY] = (isDisplay) ? NONE : HIDDEN;                     
  412.                                  Ext.fly(dom).setOpacity(1);
  413.                              }
  414.                         });
  415.             }
  416.             return me;
  417.         },
  418.     
  419.         
  420.         toggle : function(animate){
  421.             var me = this;
  422.             me.setVisible(!me.isVisible(), me.preanim(arguments, 0));
  423.             return me;
  424.         },
  425.     
  426.         
  427.         setDisplayed : function(value) {            
  428.             if(typeof value == "boolean"){
  429.                value = value ? getDisplay(this.dom) : NONE;
  430.             }
  431.             this.setStyle(DISPLAY, value);
  432.             return this;
  433.         },
  434.         
  435.         
  436.         fixDisplay : function(){
  437.             var me = this;
  438.             if(me.isStyle(DISPLAY, NONE)){
  439.                 me.setStyle(VISIBILITY, HIDDEN);
  440.                 me.setStyle(DISPLAY, getDisplay(this.dom)); 
  441.                 if(me.isStyle(DISPLAY, NONE)){ 
  442.                     me.setStyle(DISPLAY, "block");
  443.                 }
  444.             }
  445.         },
  446.     
  447.         
  448.         hide : function(animate){
  449.             this.setVisible(false, this.preanim(arguments, 0));
  450.             return this;
  451.         },
  452.     
  453.         
  454.         show : function(animate){
  455.             this.setVisible(true, this.preanim(arguments, 0));
  456.             return this;
  457.         }
  458.     }
  459. }());
  460. Ext.Element.addMethods(
  461. function(){
  462.     var VISIBILITY = "visibility",
  463.         DISPLAY = "display",
  464.         HIDDEN = "hidden",
  465.         NONE = "none",
  466.     XMASKED = "x-masked",
  467. XMASKEDRELATIVE = "x-masked-relative",
  468.         data = Ext.Element.data;
  469. return {
  470.     isVisible : function(deep) {
  471.         var vis = !this.isStyle(VISIBILITY,HIDDEN) && !this.isStyle(DISPLAY,NONE),
  472.          p = this.dom.parentNode;
  473.         if(deep !== true || !vis){
  474.             return vis;
  475.         }         
  476.         while(p && !/body/i.test(p.tagName)){
  477.             if(!Ext.fly(p, '_isVisible').isVisible()){
  478.                 return false;
  479.             }
  480.             p = p.parentNode;
  481.         }
  482.         return true;
  483.     },
  484.     
  485.     
  486.     isDisplayed : function() {
  487.         return !this.isStyle(DISPLAY, NONE);
  488.     },
  489.     
  490.     enableDisplayMode : function(display){     
  491.         this.setVisibilityMode(Ext.Element.DISPLAY);
  492.         if(!Ext.isEmpty(display)){
  493.                 data(this.dom, 'originalDisplay', display);
  494.             }
  495.         return this;
  496.     },
  497.     
  498.     mask : function(msg, msgCls){
  499.     var me = this,
  500.      dom = me.dom,
  501.      dh = Ext.DomHelper,
  502.      EXTELMASKMSG = "ext-el-mask-msg",
  503.                 el, 
  504.                 mask;
  505.     
  506.         if(me.getStyle("position") == "static"){
  507.             me.addClass(XMASKEDRELATIVE);
  508.         }
  509.         if((el = data(dom, 'maskMsg'))){
  510.             el.remove();
  511.         }
  512.         if((el = data(dom, 'mask'))){
  513.             el.remove();
  514.         }
  515.             mask = dh.append(dom, {cls : "ext-el-mask"}, true);
  516.         data(dom, 'mask', mask);
  517.         me.addClass(XMASKED);
  518.         mask.setDisplayed(true);
  519.         if(typeof msg == 'string'){
  520.                 var mm = dh.append(dom, {cls : EXTELMASKMSG, cn:{tag:'div'}}, true);
  521.                 data(dom, 'maskMsg', mm);
  522.             mm.dom.className = msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG;
  523.             mm.dom.firstChild.innerHTML = msg;
  524.             mm.setDisplayed(true);
  525.             mm.center(me);
  526.         }
  527.         if(Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && me.getStyle('height') == 'auto'){ 
  528.             mask.setSize(undefined, me.getHeight());
  529.         }
  530.         return mask;
  531.     },
  532.     
  533.     unmask : function(){
  534.     var me = this,
  535.                 dom = me.dom,
  536.      mask = data(dom, 'mask'),
  537.      maskMsg = data(dom, 'maskMsg');
  538.         if(mask){
  539.             if(maskMsg){
  540.                 maskMsg.remove();
  541.                     data(dom, 'maskMsg', undefined);
  542.             }
  543.             mask.remove();
  544.                 data(dom, 'mask', undefined);
  545.         }
  546.         me.removeClass([XMASKED, XMASKEDRELATIVE]);
  547.     },
  548.     
  549.     isMasked : function(){
  550.             var m = data(this.dom, 'mask');
  551.         return m && m.isVisible();
  552.     },
  553.     
  554.     
  555.     createShim : function(){
  556.         var el = document.createElement('iframe'),        
  557.          shim;
  558.         el.frameBorder = '0';
  559.         el.className = 'ext-shim';
  560.         el.src = Ext.SSL_SECURE_URL;
  561.         shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
  562.         shim.autoBoxAdjust = false;
  563.         return shim;
  564.     }
  565.     };
  566. }());
  567. Ext.Element.addMethods({
  568.     
  569.     addKeyListener : function(key, fn, scope){
  570.         var config;
  571.         if(!Ext.isObject(key) || Ext.isArray(key)){
  572.             config = {
  573.                 key: key,
  574.                 fn: fn,
  575.                 scope: scope
  576.             };
  577.         }else{
  578.             config = {
  579.                 key : key.key,
  580.                 shift : key.shift,
  581.                 ctrl : key.ctrl,
  582.                 alt : key.alt,
  583.                 fn: fn,
  584.                 scope: scope
  585.             };
  586.         }
  587.         return new Ext.KeyMap(this, config);
  588.     },
  589.     
  590.     addKeyMap : function(config){
  591.         return new Ext.KeyMap(this, config);
  592.     }
  593. });(function(){
  594.     
  595.     var NULL = null,
  596.         UNDEFINED = undefined,
  597.         TRUE = true,
  598.         FALSE = false,
  599.         SETX = "setX",
  600.         SETY = "setY",
  601.         SETXY = "setXY",
  602.         LEFT = "left",
  603.         BOTTOM = "bottom",
  604.         TOP = "top",
  605.         RIGHT = "right",
  606.         HEIGHT = "height",
  607.         WIDTH = "width",
  608.         POINTS = "points",
  609.         HIDDEN = "hidden",
  610.         ABSOLUTE = "absolute",
  611.         VISIBLE = "visible",
  612.         MOTION = "motion",
  613.         POSITION = "position",
  614.         EASEOUT = "easeOut",
  615.         
  616.         flyEl = new Ext.Element.Flyweight(),
  617.         queues = {},
  618.         getObject = function(o){
  619.             return o || {};
  620.         },
  621.         fly = function(dom){
  622.             flyEl.dom = dom;
  623.             flyEl.id = Ext.id(dom);
  624.             return flyEl;
  625.         },
  626.         
  627.         getQueue = function(id){
  628.             if(!queues[id]){
  629.                 queues[id] = [];
  630.             }
  631.             return queues[id];
  632.         },
  633.         setQueue = function(id, value){
  634.             queues[id] = value;
  635.         };
  636.         
  637. Ext.enableFx = TRUE;
  638. Ext.Fx = {
  639.     
  640.     
  641.     
  642.     switchStatements : function(key, fn, argHash){
  643.         return fn.apply(this, argHash[key]);
  644.     },
  645.     
  646.     
  647.     slideIn : function(anchor, o){ 
  648.         o = getObject(o);
  649.         var me = this,
  650.             dom = me.dom,
  651.             st = dom.style,
  652.             xy,
  653.             r,
  654.             b,              
  655.             wrap,               
  656.             after,
  657.             st,
  658.             args, 
  659.             pt,
  660.             bw,
  661.             bh;
  662.             
  663.         anchor = anchor || "t";
  664.         me.queueFx(o, function(){            
  665.             xy = fly(dom).getXY();
  666.             
  667.             fly(dom).fixDisplay();            
  668.             
  669.             
  670.             r = fly(dom).getFxRestore();      
  671.             b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
  672.             b.right = b.x + b.width;
  673.             b.bottom = b.y + b.height;
  674.             
  675.             
  676.             fly(dom).setWidth(b.width).setHeight(b.height);            
  677.             
  678.             
  679.             wrap = fly(dom).fxWrap(r.pos, o, HIDDEN);
  680.             
  681.             st.visibility = VISIBLE;
  682.             st.position = ABSOLUTE;
  683.             
  684.             
  685.             function after(){
  686.                  fly(dom).fxUnwrap(wrap, r.pos, o);
  687.                  st.width = r.width;
  688.                  st.height = r.height;
  689.                  fly(dom).afterFx(o);
  690.             }
  691.             
  692.             
  693.             pt = {to: [b.x, b.y]}; 
  694.             bw = {to: b.width};
  695.             bh = {to: b.height};
  696.                 
  697.             function argCalc(wrap, style, ww, wh, sXY, sXYval, s1, s2, w, h, p){                    
  698.                 var ret = {};
  699.                 fly(wrap).setWidth(ww).setHeight(wh);
  700.                 if(fly(wrap)[sXY]){
  701.                     fly(wrap)[sXY](sXYval);                  
  702.                 }
  703.                 style[s1] = style[s2] = "0";                    
  704.                 if(w){
  705.                     ret.width = w
  706.                 };
  707.                 if(h){
  708.                     ret.height = h;
  709.                 }
  710.                 if(p){
  711.                     ret.points = p;
  712.                 }
  713.                 return ret;
  714.             };
  715.             args = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
  716.                     t  : [wrap, st, b.width, 0, NULL, NULL, LEFT, BOTTOM, NULL, bh, NULL],
  717.                     l  : [wrap, st, 0, b.height, NULL, NULL, RIGHT, TOP, bw, NULL, NULL],
  718.                     r  : [wrap, st, b.width, b.height, SETX, b.right, LEFT, TOP, NULL, NULL, pt],
  719.                     b  : [wrap, st, b.width, b.height, SETY, b.bottom, LEFT, TOP, NULL, bh, pt],
  720.                     tl : [wrap, st, 0, 0, NULL, NULL, RIGHT, BOTTOM, bw, bh, pt],
  721.                     bl : [wrap, st, 0, 0, SETY, b.y + b.height, RIGHT, TOP, bw, bh, pt],
  722.                     br : [wrap, st, 0, 0, SETXY, [b.right, b.bottom], LEFT, TOP, bw, bh, pt],
  723.                     tr : [wrap, st, 0, 0, SETX, b.x + b.width, LEFT, BOTTOM, bw, bh, pt]
  724.                 });
  725.             
  726.             st.visibility = VISIBLE;
  727.             fly(wrap).show();
  728.             arguments.callee.anim = fly(wrap).fxanim(args,
  729.                 o,
  730.                 MOTION,
  731.                 .5,
  732.                 EASEOUT, 
  733.                 after);
  734.         });
  735.         return me;
  736.     },
  737.     
  738.     
  739.     slideOut : function(anchor, o){
  740.         o = getObject(o);
  741.         var me = this,
  742.             dom = me.dom,
  743.             st = dom.style,
  744.             xy = me.getXY(),
  745.             wrap,
  746.             r,
  747.             b,
  748.             a,
  749.             zero = {to: 0}; 
  750.                     
  751.         anchor = anchor || "t";
  752.         me.queueFx(o, function(){
  753.             
  754.             
  755.             r = fly(dom).getFxRestore(); 
  756.             b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
  757.             b.right = b.x + b.width;
  758.             b.bottom = b.y + b.height;
  759.                 
  760.             
  761.             fly(dom).setWidth(b.width).setHeight(b.height);
  762.             
  763.             wrap = fly(dom).fxWrap(r.pos, o, VISIBLE);
  764.                 
  765.             st.visibility = VISIBLE;
  766.             st.position = ABSOLUTE;
  767.             fly(wrap).setWidth(b.width).setHeight(b.height);            
  768.             function after(){
  769.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();                
  770.                 fly(dom).fxUnwrap(wrap, r.pos, o);
  771.                 st.width = r.width;
  772.                 st.height = r.height;
  773.                 fly(dom).afterFx(o);
  774.             }            
  775.             
  776.             function argCalc(style, s1, s2, p1, v1, p2, v2, p3, v3){                    
  777.                 var ret = {};
  778.                 
  779.                 style[s1] = style[s2] = "0";
  780.                 ret[p1] = v1;               
  781.                 if(p2){
  782.                     ret[p2] = v2;               
  783.                 }
  784.                 if(p3){
  785.                     ret[p3] = v3;
  786.                 }
  787.                 
  788.                 return ret;
  789.             };
  790.             
  791.             a = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
  792.                 t  : [st, LEFT, BOTTOM, HEIGHT, zero],
  793.                 l  : [st, RIGHT, TOP, WIDTH, zero],
  794.                 r  : [st, LEFT, TOP, WIDTH, zero, POINTS, {to : [b.right, b.y]}],
  795.                 b  : [st, LEFT, TOP, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
  796.                 tl : [st, RIGHT, BOTTOM, WIDTH, zero, HEIGHT, zero],
  797.                 bl : [st, RIGHT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
  798.                 br : [st, LEFT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x + b.width, b.bottom]}],
  799.                 tr : [st, LEFT, BOTTOM, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.right, b.y]}]
  800.             });
  801.             
  802.             arguments.callee.anim = fly(wrap).fxanim(a,
  803.                 o,
  804.                 MOTION,
  805.                 .5,
  806.                 EASEOUT, 
  807.                 after);
  808.         });
  809.         return me;
  810.     },
  811.     
  812.     puff : function(o){
  813.         o = getObject(o);
  814.         var me = this,
  815.             dom = me.dom,
  816.             st = dom.style,
  817.             width,
  818.             height,
  819.             r;
  820.         me.queueFx(o, function(){
  821.             width = fly(dom).getWidth();
  822.             height = fly(dom).getHeight();
  823.             fly(dom).clearOpacity();
  824.             fly(dom).show();
  825.             
  826.             r = fly(dom).getFxRestore();                   
  827.             
  828.             function after(){
  829.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();                  
  830.                 fly(dom).clearOpacity();  
  831.                 fly(dom).setPositioning(r.pos);
  832.                 st.width = r.width;
  833.                 st.height = r.height;
  834.                 st.fontSize = '';
  835.                 fly(dom).afterFx(o);
  836.             }   
  837.             arguments.callee.anim = fly(dom).fxanim({
  838.                     width : {to : fly(dom).adjustWidth(width * 2)},
  839.                     height : {to : fly(dom).adjustHeight(height * 2)},
  840.                     points : {by : [-width * .5, -height * .5]},
  841.                     opacity : {to : 0},
  842.                     fontSize: {to : 200, unit: "%"}
  843.                 },
  844.                 o,
  845.                 MOTION,
  846.                 .5,
  847.                 EASEOUT,
  848.                  after);
  849.         });
  850.         return me;
  851.     },
  852.     
  853.     switchOff : function(o){
  854.         o = getObject(o);
  855.         var me = this,
  856.             dom = me.dom,
  857.             st = dom.style,
  858.             r;
  859.         me.queueFx(o, function(){
  860.             fly(dom).clearOpacity();
  861.             fly(dom).clip();
  862.             
  863.             r = fly(dom).getFxRestore();
  864.                 
  865.             function after(){
  866.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();  
  867.                 fly(dom).clearOpacity();
  868.                 fly(dom).setPositioning(r.pos);
  869.                 st.width = r.width;
  870.                 st.height = r.height;   
  871.                 fly(dom).afterFx(o);
  872.             };
  873.             fly(dom).fxanim({opacity : {to : 0.3}}, 
  874.                 NULL, 
  875.                 NULL, 
  876.                 .1, 
  877.                 NULL, 
  878.                 function(){                                 
  879.                     fly(dom).clearOpacity();
  880.                         (function(){                            
  881.                             fly(dom).fxanim({
  882.                                 height : {to : 1},
  883.                                 points : {by : [0, fly(dom).getHeight() * .5]}
  884.                             }, 
  885.                             o, 
  886.                             MOTION, 
  887.                             0.3, 
  888.                             'easeIn', 
  889.                             after);
  890.                         }).defer(100);
  891.                 });
  892.         });
  893.         return me;
  894.     },
  895.      
  896.     highlight : function(color, o){
  897.         o = getObject(o);
  898.         var me = this,
  899.             dom = me.dom,
  900.             attr = o.attr || "backgroundColor",
  901.             a = {},
  902.             restore;
  903.         me.queueFx(o, function(){
  904.             fly(dom).clearOpacity();
  905.             fly(dom).show();
  906.             function after(){
  907.                 dom.style[attr] = restore;
  908.                 fly(dom).afterFx(o);
  909.             }            
  910.             restore = dom.style[attr];
  911.             a[attr] = {from: color || "ffff9c", to: o.endColor || fly(dom).getColor(attr) || "ffffff"};
  912.             arguments.callee.anim = fly(dom).fxanim(a,
  913.                 o,
  914.                 'color',
  915.                 1,
  916.                 'easeIn', 
  917.                 after);
  918.         });
  919.         return me;
  920.     },
  921.    
  922.     frame : function(color, count, o){
  923.         o = getObject(o);
  924.         var me = this,
  925.             dom = me.dom,
  926.             proxy,
  927.             active;
  928.         me.queueFx(o, function(){
  929.             color = color || '#C3DAF9';
  930.             if(color.length == 6){
  931.                 color = '#' + color;
  932.             }            
  933.             count = count || 1;
  934.             fly(dom).show();
  935.             var xy = fly(dom).getXY(),
  936.                 b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight},
  937.                 queue = function(){
  938.                     proxy = fly(document.body || document.documentElement).createChild({
  939.                         style:{
  940.                             position : ABSOLUTE,
  941.                             'z-index': 35000, 
  942.                             border : '0px solid ' + color
  943.                         }
  944.                     });
  945.                     return proxy.queueFx({}, animFn);
  946.                 };
  947.             
  948.             
  949.             arguments.callee.anim = {
  950.                 isAnimated: true,
  951.                 stop: function() {
  952.                     count = 0;
  953.                     proxy.stopFx();
  954.                 }
  955.             };
  956.             
  957.             function animFn(){
  958.                 var scale = Ext.isBorderBox ? 2 : 1;
  959.                 active = proxy.anim({
  960.                     top : {from : b.y, to : b.y - 20},
  961.                     left : {from : b.x, to : b.x - 20},
  962.                     borderWidth : {from : 0, to : 10},
  963.                     opacity : {from : 1, to : 0},
  964.                     height : {from : b.height, to : b.height + 20 * scale},
  965.                     width : {from : b.width, to : b.width + 20 * scale}
  966.                 },{
  967.                     duration: o.duration || 1,
  968.                     callback: function() {
  969.                         proxy.remove();
  970.                         --count > 0 ? queue() : fly(dom).afterFx(o);
  971.                     }
  972.                 });
  973.                 arguments.callee.anim = {
  974.                     isAnimated: true,
  975.                     stop: function(){
  976.                         active.stop();
  977.                     }
  978.                 };
  979.             };
  980.             queue();
  981.         });
  982.         return me;
  983.     },
  984.    
  985.     pause : function(seconds){        
  986.         var dom = this.dom,
  987.             t;
  988.         this.queueFx({}, function(){
  989.             t = setTimeout(function(){
  990.                 fly(dom).afterFx({});
  991.             }, seconds * 1000);
  992.             arguments.callee.anim = {
  993.                 isAnimated: true,
  994.                 stop: function(){
  995.                     clearTimeout(t);
  996.                     fly(dom).afterFx({});
  997.                 }
  998.             };
  999.         });
  1000.         return this;
  1001.     },
  1002.    
  1003.     fadeIn : function(o){
  1004.         o = getObject(o);
  1005.         var me = this,
  1006.             dom = me.dom,
  1007.             to = o.endOpacity || 1;
  1008.         
  1009.         me.queueFx(o, function(){
  1010.             fly(dom).setOpacity(0);
  1011.             fly(dom).fixDisplay();
  1012.             dom.style.visibility = VISIBLE;
  1013.             arguments.callee.anim = fly(dom).fxanim({opacity:{to:to}},
  1014.                 o, NULL, .5, EASEOUT, function(){
  1015.                 if(to == 1){
  1016.                     fly(dom).clearOpacity();
  1017.                 }
  1018.                 fly(dom).afterFx(o);
  1019.             });
  1020.         });
  1021.         return me;
  1022.     },
  1023.    
  1024.     fadeOut : function(o){
  1025.         o = getObject(o);
  1026.         var me = this,
  1027.             dom = me.dom,
  1028.             style = dom.style,
  1029.             to = o.endOpacity || 0;         
  1030.         
  1031.         me.queueFx(o, function(){  
  1032.             arguments.callee.anim = fly(dom).fxanim({ 
  1033.                 opacity : {to : to}},
  1034.                 o, 
  1035.                 NULL, 
  1036.                 .5, 
  1037.                 EASEOUT, 
  1038.                 function(){
  1039.                     if(to == 0){
  1040.                         Ext.Element.data(dom, 'visibilityMode') == Ext.Element.DISPLAY || o.useDisplay ? 
  1041.                             style.display = "none" :
  1042.                             style.visibility = HIDDEN;
  1043.                             
  1044.                         fly(dom).clearOpacity();
  1045.                     }
  1046.                     fly(dom).afterFx(o);
  1047.             });
  1048.         });
  1049.         return me;
  1050.     },
  1051.    
  1052.     scale : function(w, h, o){
  1053.         this.shift(Ext.apply({}, o, {
  1054.             width: w,
  1055.             height: h
  1056.         }));
  1057.         return this;
  1058.     },
  1059.    
  1060.     shift : function(o){
  1061.         o = getObject(o);
  1062.         var dom = this.dom,
  1063.             a = {};
  1064.                 
  1065.         this.queueFx(o, function(){
  1066.             for (var prop in o) {
  1067.                 if (o[prop] != UNDEFINED) {                                                 
  1068.                     a[prop] = {to : o[prop]};                   
  1069.                 }
  1070.             } 
  1071.             
  1072.             a.width ? a.width.to = fly(dom).adjustWidth(o.width) : a;
  1073.             a.height ? a.height.to = fly(dom).adjustWidth(o.height) : a;   
  1074.             
  1075.             if (a.x || a.y || a.xy) {
  1076.                 a.points = a.xy || 
  1077.                            {to : [ a.x ? a.x.to : fly(dom).getX(),
  1078.                                    a.y ? a.y.to : fly(dom).getY()]};                  
  1079.             }
  1080.             arguments.callee.anim = fly(dom).fxanim(a,
  1081.                 o, 
  1082.                 MOTION, 
  1083.                 .35, 
  1084.                 EASEOUT, 
  1085.                 function(){
  1086.                     fly(dom).afterFx(o);
  1087.                 });
  1088.         });
  1089.         return this;
  1090.     },
  1091.     
  1092.     ghost : function(anchor, o){
  1093.         o = getObject(o);
  1094.         var me = this,
  1095.             dom = me.dom,
  1096.             st = dom.style,
  1097.             a = {opacity: {to: 0}, points: {}},
  1098.             pt = a.points,
  1099.             r,
  1100.             w,
  1101.             h;
  1102.             
  1103.         anchor = anchor || "b";
  1104.         me.queueFx(o, function(){
  1105.             
  1106.             r = fly(dom).getFxRestore();
  1107.             w = fly(dom).getWidth();
  1108.             h = fly(dom).getHeight();
  1109.             
  1110.             function after(){
  1111.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();   
  1112.                 fly(dom).clearOpacity();
  1113.                 fly(dom).setPositioning(r.pos);
  1114.                 st.width = r.width;
  1115.                 st.height = r.height;
  1116.                 fly(dom).afterFx(o);
  1117.             }
  1118.                 
  1119.             pt.by = fly(dom).switchStatements(anchor.toLowerCase(), function(v1,v2){ return [v1, v2];}, {
  1120.                t  : [0, -h],
  1121.                l  : [-w, 0],
  1122.                r  : [w, 0],
  1123.                b  : [0, h],
  1124.                tl : [-w, -h],
  1125.                bl : [-w, h],
  1126.                br : [w, h],
  1127.                tr : [w, -h] 
  1128.             });
  1129.                 
  1130.             arguments.callee.anim = fly(dom).fxanim(a,
  1131.                 o,
  1132.                 MOTION,
  1133.                 .5,
  1134.                 EASEOUT, after);
  1135.         });
  1136.         return me;
  1137.     },
  1138.     
  1139.     syncFx : function(){
  1140.         var me = this;
  1141.         me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
  1142.             block : FALSE,
  1143.             concurrent : TRUE,
  1144.             stopFx : FALSE
  1145.         });
  1146.         return me;
  1147.     },
  1148.     
  1149.     sequenceFx : function(){
  1150.         var me = this;
  1151.         me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
  1152.             block : FALSE,
  1153.             concurrent : FALSE,
  1154.             stopFx : FALSE
  1155.         });
  1156.         return me;
  1157.     },
  1158.     
  1159.     nextFx : function(){        
  1160.         var ef = getQueue(this.dom.id)[0];
  1161.         if(ef){
  1162.             ef.call(this);
  1163.         }
  1164.     },
  1165.     
  1166.     hasActiveFx : function(){
  1167.         return getQueue(this.dom.id)[0];
  1168.     },
  1169.     
  1170.     stopFx : function(finish){
  1171.         var me = this,
  1172.             id = me.dom.id;
  1173.         if(me.hasActiveFx()){
  1174.             var cur = getQueue(id)[0];
  1175.             if(cur && cur.anim){
  1176.                 if(cur.anim.isAnimated){
  1177.                     setQueue(id, [cur]); 
  1178.                     cur.anim.stop(finish !== undefined ? finish : TRUE);
  1179.                 }else{
  1180.                     setQueue(id, []);
  1181.                 }
  1182.             }
  1183.         }
  1184.         return me;
  1185.     },
  1186.     
  1187.     beforeFx : function(o){
  1188.         if(this.hasActiveFx() && !o.concurrent){
  1189.            if(o.stopFx){
  1190.                this.stopFx();
  1191.                return TRUE;
  1192.            }
  1193.            return FALSE;
  1194.         }
  1195.         return TRUE;
  1196.     },
  1197.     
  1198.     hasFxBlock : function(){
  1199.         var q = getQueue(this.dom.id);
  1200.         return q && q[0] && q[0].block;
  1201.     },
  1202.     
  1203.     queueFx : function(o, fn){
  1204.         var me = fly(this.dom);
  1205.         if(!me.hasFxBlock()){
  1206.             Ext.applyIf(o, me.fxDefaults);
  1207.             if(!o.concurrent){
  1208.                 var run = me.beforeFx(o);
  1209.                 fn.block = o.block;
  1210.                 getQueue(me.dom.id).push(fn);
  1211.                 if(run){
  1212.                     me.nextFx();
  1213.                 }
  1214.             }else{
  1215.                 fn.call(me);
  1216.             }
  1217.         }
  1218.         return me;
  1219.     },
  1220.     
  1221.     fxWrap : function(pos, o, vis){ 
  1222.         var dom = this.dom,
  1223.             wrap,
  1224.             wrapXY;
  1225.         if(!o.wrap || !(wrap = Ext.getDom(o.wrap))){            
  1226.             if(o.fixPosition){
  1227.                 wrapXY = fly(dom).getXY();
  1228.             }
  1229.             var div = document.createElement("div");
  1230.             div.style.visibility = vis;
  1231.             wrap = dom.parentNode.insertBefore(div, dom);
  1232.             fly(wrap).setPositioning(pos);
  1233.             if(fly(wrap).isStyle(POSITION, "static")){
  1234.                 fly(wrap).position("relative");
  1235.             }
  1236.             fly(dom).clearPositioning('auto');
  1237.             fly(wrap).clip();
  1238.             wrap.appendChild(dom);
  1239.             if(wrapXY){
  1240.                 fly(wrap).setXY(wrapXY);
  1241.             }
  1242.         }
  1243.         return wrap;
  1244.     },
  1245.     
  1246.     fxUnwrap : function(wrap, pos, o){      
  1247.         var dom = this.dom;
  1248.         fly(dom).clearPositioning();
  1249.         fly(dom).setPositioning(pos);
  1250.         if(!o.wrap){
  1251.             var pn = fly(wrap).dom.parentNode;
  1252.             pn.insertBefore(dom, wrap); 
  1253.             fly(wrap).remove();
  1254.         }
  1255.     },
  1256.     
  1257.     getFxRestore : function(){
  1258.         var st = this.dom.style;
  1259.         return {pos: this.getPositioning(), width: st.width, height : st.height};
  1260.     },
  1261.     
  1262.     afterFx : function(o){
  1263.         var dom = this.dom,
  1264.             id = dom.id;
  1265.         if(o.afterStyle){
  1266.             fly(dom).setStyle(o.afterStyle);            
  1267.         }
  1268.         if(o.afterCls){
  1269.             fly(dom).addClass(o.afterCls);
  1270.         }
  1271.         if(o.remove == TRUE){
  1272.             fly(dom).remove();
  1273.         }
  1274.         if(o.callback){
  1275.             o.callback.call(o.scope, fly(dom));
  1276.         }
  1277.         if(!o.concurrent){
  1278.             getQueue(id).shift();
  1279.             fly(dom).nextFx();
  1280.         }
  1281.     },
  1282.     
  1283.     fxanim : function(args, opt, animType, defaultDur, defaultEase, cb){
  1284.         animType = animType || 'run';
  1285.         opt = opt || {};
  1286.         var anim = Ext.lib.Anim[animType](
  1287.                 this.dom, 
  1288.                 args,
  1289.                 (opt.duration || defaultDur) || .35,
  1290.                 (opt.easing || defaultEase) || EASEOUT,
  1291.                 cb,            
  1292.                 this
  1293.             );
  1294.         opt.anim = anim;
  1295.         return anim;
  1296.     }
  1297. };
  1298. Ext.Fx.resize = Ext.Fx.scale;
  1299. Ext.Element.addMethods(Ext.Fx);
  1300. })();
  1301. Ext.CompositeElementLite = function(els, root){
  1302.     
  1303.     this.elements = [];
  1304.     this.add(els, root);
  1305.     this.el = new Ext.Element.Flyweight();
  1306. };
  1307. Ext.CompositeElementLite.prototype = {
  1308.     isComposite: true,    
  1309.     
  1310.     
  1311.     getElement : function(el){
  1312.         
  1313.         var e = this.el;
  1314.         e.dom = el;
  1315.         e.id = el.id;
  1316.         return e;
  1317.     },
  1318.     
  1319.     
  1320.     transformElement : function(el){
  1321.         return Ext.getDom(el);
  1322.     },
  1323.     
  1324.     
  1325.     getCount : function(){
  1326.         return this.elements.length;
  1327.     },    
  1328.     
  1329.     add : function(els, root){
  1330.         var me = this,
  1331.             elements = me.elements;
  1332.         if(!els){
  1333.             return this;
  1334.         }
  1335.         if(Ext.isString(els)){
  1336.             els = Ext.Element.selectorFunction(els, root);
  1337.         }else if(els.isComposite){
  1338.             els = els.elements;
  1339.         }else if(!Ext.isIterable(els)){
  1340.             els = [els];
  1341.         }
  1342.         
  1343.         for(var i = 0, len = els.length; i < len; ++i){
  1344.             elements.push(me.transformElement(els[i]));
  1345.         }
  1346.         return me;
  1347.     },
  1348.     
  1349.     invoke : function(fn, args){
  1350.         var me = this,
  1351.             els = me.elements,
  1352.             len = els.length, 
  1353.             e;
  1354.             
  1355.         for(i = 0; i<len; i++) {
  1356.             e = els[i];
  1357.             if(e){
  1358.                 Ext.Element.prototype[fn].apply(me.getElement(e), args);
  1359.             }
  1360.         }
  1361.         return me;
  1362.     },
  1363.     
  1364.     item : function(index){
  1365.         var me = this,
  1366.             el = me.elements[index],
  1367.             out = null;
  1368.         if(el){
  1369.             out = me.getElement(el);
  1370.         }
  1371.         return out;
  1372.     },
  1373.     
  1374.     addListener : function(eventName, handler, scope, opt){
  1375.         var els = this.elements,
  1376.             len = els.length,
  1377.             i, e;
  1378.         
  1379.         for(i = 0; i<len; i++) {
  1380.             e = els[i];
  1381.             if(e) {
  1382.                 Ext.EventManager.on(e, eventName, handler, scope || e, opt);
  1383.             }
  1384.         }
  1385.         return this;
  1386.     },
  1387.     
  1388.     each : function(fn, scope){       
  1389.         var me = this,
  1390.             els = me.elements,
  1391.             len = els.length,
  1392.             i, e;
  1393.         
  1394.         for(i = 0; i<len; i++) {
  1395.             e = els[i];
  1396.             if(e){
  1397.                 e = this.getElement(e);
  1398.                 if(fn.call(scope || e, e, me, i)){
  1399.                     break;
  1400.                 }
  1401.             }
  1402.         }
  1403.         return me;
  1404.     },
  1405.     
  1406.     
  1407.     fill : function(els){
  1408.         var me = this;
  1409.         me.elements = [];
  1410.         me.add(els);
  1411.         return me;
  1412.     },
  1413.     
  1414.     
  1415.     filter : function(selector){
  1416.         var els = [],
  1417.             me = this,
  1418.             elements = me.elements,
  1419.             fn = Ext.isFunction(selector) ? selector
  1420.                 : function(el){
  1421.                     return el.is(selector);
  1422.                 };
  1423.                 
  1424.         
  1425.         me.each(function(el, self, i){
  1426.             if(fn(el, i) !== false){
  1427.                 els[els.length] = me.transformElement(el);
  1428.             }
  1429.         });
  1430.         me.elements = els;
  1431.         return me;
  1432.     },
  1433.     
  1434.     
  1435.     indexOf : function(el){
  1436.         return this.elements.indexOf(this.transformElement(el));
  1437.     },
  1438.     
  1439.         
  1440.     replaceElement : function(el, replacement, domReplace){
  1441.         var index = !isNaN(el) ? el : this.indexOf(el),
  1442.             d;
  1443.         if(index > -1){
  1444.             replacement = Ext.getDom(replacement);
  1445.             if(domReplace){
  1446.                 d = this.elements[index];
  1447.                 d.parentNode.insertBefore(replacement, d);
  1448.                 Ext.removeNode(d);
  1449.             }
  1450.             this.elements.splice(index, 1, replacement);
  1451.         }
  1452.         return this;
  1453.     },
  1454.     
  1455.     
  1456.     clear : function(){
  1457.         this.elements = [];
  1458.     }
  1459. };
  1460. Ext.CompositeElementLite.prototype.on = Ext.CompositeElementLite.prototype.addListener;
  1461. (function(){
  1462. var fnName,
  1463.     ElProto = Ext.Element.prototype,
  1464.     CelProto = Ext.CompositeElementLite.prototype;
  1465.     
  1466. for(fnName in ElProto){
  1467.     if(Ext.isFunction(ElProto[fnName])){
  1468.         (function(fnName){ 
  1469.             CelProto[fnName] = CelProto[fnName] || function(){
  1470.                 return this.invoke(fnName, arguments);
  1471.             };
  1472.         }).call(CelProto, fnName);
  1473.         
  1474.     }
  1475. }
  1476. })();
  1477. if(Ext.DomQuery){
  1478.     Ext.Element.selectorFunction = Ext.DomQuery.select;
  1479. Ext.Element.select = function(selector, root){
  1480.     var els;
  1481.     if(typeof selector == "string"){
  1482.         els = Ext.Element.selectorFunction(selector, root);
  1483.     }else if(selector.length !== undefined){
  1484.         els = selector;
  1485.     }else{
  1486.         throw "Invalid selector";
  1487.     }
  1488.     return new Ext.CompositeElementLite(els);
  1489. };
  1490. Ext.select = Ext.Element.select;
  1491. Ext.apply(Ext.CompositeElementLite.prototype, {
  1492. addElements : function(els, root){
  1493.         if(!els){
  1494.             return this;
  1495.         }
  1496.         if(typeof els == "string"){
  1497.             els = Ext.Element.selectorFunction(els, root);
  1498.         }
  1499.         var yels = this.elements;        
  1500.     Ext.each(els, function(e) {
  1501.          yels.push(Ext.get(e));
  1502.         });
  1503.         return this;
  1504.     },
  1505.     
  1506.     
  1507.     first : function(){
  1508.         return this.item(0);
  1509.     },   
  1510.     
  1511.     
  1512.     last : function(){
  1513.         return this.item(this.getCount()-1);
  1514.     },
  1515.     
  1516.     
  1517.     contains : function(el){
  1518.         return this.indexOf(el) != -1;
  1519.     },
  1520.     
  1521.     
  1522.     removeElement : function(keys, removeDom){
  1523.         var me = this,
  1524.         els = this.elements,     
  1525.      el;     
  1526.     Ext.each(keys, function(val){
  1527.     if ((el = (els[val] || els[val = me.indexOf(val)]))) {
  1528.      if(removeDom){
  1529.                     if(el.dom){
  1530.                         el.remove();
  1531.                     }else{
  1532.                         Ext.removeNode(el);
  1533.                     }
  1534.                 }
  1535.      els.splice(val, 1);     
  1536. }
  1537.     });
  1538.         return this;
  1539.     }    
  1540. });
  1541. Ext.CompositeElement = function(els, root){
  1542.     this.elements = [];
  1543.     this.add(els, root);
  1544. };
  1545. Ext.extend(Ext.CompositeElement, Ext.CompositeElementLite, {
  1546.     
  1547.     
  1548.     getElement : function(el){
  1549.         
  1550.         return el;
  1551.     },
  1552.     
  1553.     
  1554.     transformElement : function(el){
  1555.         return Ext.get(el);
  1556.     }
  1557.     
  1558.     
  1559.     
  1560. });
  1561. Ext.Element.select = function(selector, unique, root){
  1562.     var els;
  1563.     if(typeof selector == "string"){
  1564.         els = Ext.Element.selectorFunction(selector, root);
  1565.     }else if(selector.length !== undefined){
  1566.         els = selector;
  1567.     }else{
  1568.         throw "Invalid selector";
  1569.     }
  1570.     return (unique === true) ? new Ext.CompositeElement(els) : new Ext.CompositeElementLite(els);
  1571. };
  1572. Ext.select = Ext.Element.select;(function(){
  1573.     var BEFOREREQUEST = "beforerequest",
  1574.         REQUESTCOMPLETE = "requestcomplete",
  1575.         REQUESTEXCEPTION = "requestexception",
  1576.         UNDEFINED = undefined,
  1577.         LOAD = 'load',
  1578.         POST = 'POST',
  1579.         GET = 'GET',
  1580.         WINDOW = window;
  1581.     
  1582.     
  1583.     Ext.data.Connection = function(config){    
  1584.         Ext.apply(this, config);
  1585.         this.addEvents(
  1586.             
  1587.             BEFOREREQUEST,
  1588.             
  1589.             REQUESTCOMPLETE,
  1590.             
  1591.             REQUESTEXCEPTION
  1592.         );
  1593.         Ext.data.Connection.superclass.constructor.call(this);
  1594.     };
  1595.     Ext.extend(Ext.data.Connection, Ext.util.Observable, {
  1596.         
  1597.         
  1598.         
  1599.         
  1600.         
  1601.         timeout : 30000,
  1602.         
  1603.         autoAbort:false,
  1604.     
  1605.         
  1606.         disableCaching: true,
  1607.         
  1608.         
  1609.         disableCachingParam: '_dc',
  1610.         
  1611.         
  1612.         request : function(o){
  1613.             var me = this;
  1614.             if(me.fireEvent(BEFOREREQUEST, me, o)){
  1615.                 if (o.el) {
  1616.                     if(!Ext.isEmpty(o.indicatorText)){
  1617.                         me.indicatorText = '<div class="loading-indicator">'+o.indicatorText+"</div>";
  1618.                     }
  1619.                     if(me.indicatorText) {
  1620.                         Ext.getDom(o.el).innerHTML = me.indicatorText;                        
  1621.                     }
  1622.                     o.success = (Ext.isFunction(o.success) ? o.success : function(){}).createInterceptor(function(response) {
  1623.                         Ext.getDom(o.el).innerHTML = response.responseText;
  1624.                     });
  1625.                 }
  1626.                 
  1627.                 var p = o.params,
  1628.                     url = o.url || me.url,                
  1629.                     method,
  1630.                     cb = {success: me.handleResponse,
  1631.                           failure: me.handleFailure,
  1632.                           scope: me,
  1633.                           argument: {options: o},
  1634.                           timeout : o.timeout || me.timeout
  1635.                     },
  1636.                     form,                    
  1637.                     serForm;                    
  1638.                   
  1639.                      
  1640.                 if (Ext.isFunction(p)) {
  1641.                     p = p.call(o.scope||WINDOW, o);
  1642.                 }
  1643.                                                            
  1644.                 p = Ext.urlEncode(me.extraParams, Ext.isObject(p) ? Ext.urlEncode(p) : p);    
  1645.                 
  1646.                 if (Ext.isFunction(url)) {
  1647.                     url = url.call(o.scope || WINDOW, o);
  1648.                 }
  1649.     
  1650.                 if((form = Ext.getDom(o.form))){
  1651.                     url = url || form.action;
  1652.                      if(o.isUpload || /multipart/form-data/i.test(form.getAttribute("enctype"))) { 
  1653.                          return me.doFormUpload.call(me, o, p, url);
  1654.                      }
  1655.                     serForm = Ext.lib.Ajax.serializeForm(form);                    
  1656.                     p = p ? (p + '&' + serForm) : serForm;
  1657.                 }
  1658.                 
  1659.                 method = o.method || me.method || ((p || o.xmlData || o.jsonData) ? POST : GET);
  1660.                 
  1661.                 if(method === GET && (me.disableCaching && o.disableCaching !== false) || o.disableCaching === true){
  1662.                     var dcp = o.disableCachingParam || me.disableCachingParam;
  1663.                     url = Ext.urlAppend(url, dcp + '=' + (new Date().getTime()));
  1664.                 }
  1665.                 
  1666.                 o.headers = Ext.apply(o.headers || {}, me.defaultHeaders || {});
  1667.                 
  1668.                 if(o.autoAbort === true || me.autoAbort) {
  1669.                     me.abort();
  1670.                 }
  1671.                  
  1672.                 if((method == GET || o.xmlData || o.jsonData) && p){
  1673.                     url = Ext.urlAppend(url, p);  
  1674.                     p = '';
  1675.                 }
  1676.                 return (me.transId = Ext.lib.Ajax.request(method, url, cb, p, o));
  1677.             }else{                
  1678.                 return o.callback ? o.callback.apply(o.scope, [o,UNDEFINED,UNDEFINED]) : null;
  1679.             }
  1680.         },
  1681.     
  1682.         
  1683.         isLoading : function(transId){
  1684.             return transId ? Ext.lib.Ajax.isCallInProgress(transId) : !! this.transId;            
  1685.         },
  1686.     
  1687.         
  1688.         abort : function(transId){
  1689.             if(transId || this.isLoading()){
  1690.                 Ext.lib.Ajax.abort(transId || this.transId);
  1691.             }
  1692.         },
  1693.         
  1694.         handleResponse : function(response){
  1695.             this.transId = false;
  1696.             var options = response.argument.options;
  1697.             response.argument = options ? options.argument : null;
  1698.             this.fireEvent(REQUESTCOMPLETE, this, response, options);
  1699.             if(options.success){
  1700.                 options.success.call(options.scope, response, options);
  1701.             }
  1702.             if(options.callback){
  1703.                 options.callback.call(options.scope, options, true, response);
  1704.             }
  1705.         },
  1706.         
  1707.         handleFailure : function(response, e){
  1708.             this.transId = false;
  1709.             var options = response.argument.options;
  1710.             response.argument = options ? options.argument : null;
  1711.             this.fireEvent(REQUESTEXCEPTION, this, response, options, e);
  1712.             if(options.failure){
  1713.                 options.failure.call(options.scope, response, options);
  1714.             }
  1715.             if(options.callback){
  1716.                 options.callback.call(options.scope, options, false, response);
  1717.             }
  1718.         },
  1719.         
  1720.         doFormUpload : function(o, ps, url){
  1721.             var id = Ext.id(),
  1722.                 doc = document,
  1723.                 frame = doc.createElement('iframe'),
  1724.                 form = Ext.getDom(o.form),
  1725.                 hiddens = [],
  1726.                 hd,
  1727.                 encoding = 'multipart/form-data',
  1728.                 buf = {
  1729.                     target: form.target,
  1730.                     method: form.method,
  1731.                     encoding: form.encoding,
  1732.                     enctype: form.enctype,
  1733.                     action: form.action
  1734.                 };
  1735.             Ext.fly(frame).set({
  1736.                 id: id,
  1737.                 name: id,
  1738.                 cls: 'x-hidden',
  1739.                 src: Ext.SSL_SECURE_URL 
  1740.             });
  1741.             doc.body.appendChild(frame);
  1742.             
  1743.             if(Ext.isIE){
  1744.                document.frames[id].name = id;
  1745.             }
  1746.             Ext.fly(form).set({
  1747.                 target: id,
  1748.                 method: POST,
  1749.                 enctype: encoding,
  1750.                 encoding: encoding,
  1751.                 action: url || buf.action
  1752.             });
  1753.             
  1754.             Ext.iterate(Ext.urlDecode(ps, false), function(k, v){
  1755.                 hd = doc.createElement('input');
  1756.                 Ext.fly(hd).set({
  1757.                     type: 'hidden',
  1758.                     value: v,
  1759.                     name: k
  1760.                 });
  1761.                 form.appendChild(hd);
  1762.                 hiddens.push(hd);
  1763.             });
  1764.             function cb(){
  1765.                 var me = this,
  1766.                     
  1767.                     r = {responseText : '',
  1768.                          responseXML : null,
  1769.                          argument : o.argument},
  1770.                     doc,
  1771.                     firstChild;
  1772.                 try{
  1773.                     doc = frame.contentWindow.document || frame.contentDocument || WINDOW.frames[id].document;
  1774.                     if(doc){
  1775.                         if(doc.body){
  1776.                             if(/textarea/i.test((firstChild = doc.body.firstChild || {}).tagName)){ 
  1777.                                 r.responseText = firstChild.value;
  1778.                             }else{
  1779.                                 r.responseText = doc.body.innerHTML;
  1780.                             }
  1781.                         }
  1782.                         
  1783.                         r.responseXML = doc.XMLDocument || doc;
  1784.                     }
  1785.                 }
  1786.                 catch(e) {}
  1787.                 Ext.EventManager.removeListener(frame, LOAD, cb, me);
  1788.                 me.fireEvent(REQUESTCOMPLETE, me, r, o);
  1789.                 function runCallback(fn, scope, args){
  1790.                     if(Ext.isFunction(fn)){
  1791.                         fn.apply(scope, args);
  1792.                     }
  1793.                 }
  1794.                 runCallback(o.success, o.scope, [r, o]);
  1795.                 runCallback(o.callback, o.scope, [o, true, r]);
  1796.                 if(!me.debugUploads){
  1797.                     setTimeout(function(){Ext.removeNode(frame);}, 100);
  1798.                 }
  1799.             }
  1800.             Ext.EventManager.on(frame, LOAD, cb, this);
  1801.             form.submit();
  1802.             Ext.fly(form).set(buf);
  1803.             Ext.each(hiddens, function(h) {
  1804.                 Ext.removeNode(h);
  1805.             });
  1806.         }
  1807.     });
  1808. })();
  1809. Ext.Ajax = new Ext.data.Connection({
  1810.     
  1811.     
  1812.     
  1813.     
  1814.     
  1815.     
  1816.     
  1817.     
  1818.     
  1819.     
  1820.     
  1821.     
  1822.     
  1823.     
  1824.     autoAbort : false,
  1825.     
  1826.     serializeForm : function(form){
  1827.         return Ext.lib.Ajax.serializeForm(form);
  1828.     }
  1829. });
  1830. Ext.UpdateManager = Ext.Updater = Ext.extend(Ext.util.Observable, 
  1831. function() {
  1832. var BEFOREUPDATE = "beforeupdate",
  1833. UPDATE = "update",
  1834. FAILURE = "failure";
  1835.     function processSuccess(response){     
  1836.     var me = this;
  1837.         me.transaction = null;
  1838.         if (response.argument.form && response.argument.reset) {
  1839.             try { 
  1840.                 response.argument.form.reset();
  1841.             } catch(e){}
  1842.         }
  1843.         if (me.loadScripts) {
  1844.             me.renderer.render(me.el, response, me,
  1845.                updateComplete.createDelegate(me, [response]));
  1846.         } else {
  1847.             me.renderer.render(me.el, response, me);
  1848.             updateComplete.call(me, response);
  1849.         }
  1850.     }
  1851.     
  1852.     
  1853.     function updateComplete(response, type, success){
  1854.         this.fireEvent(type || UPDATE, this.el, response);
  1855.         if(Ext.isFunction(response.argument.callback)){
  1856.             response.argument.callback.call(response.argument.scope, this.el, Ext.isEmpty(success) ? true : false, response, response.argument.options);
  1857.         }
  1858.     }
  1859.     
  1860.     function processFailure(response){             
  1861.         updateComplete.call(this, response, FAILURE, !!(this.transaction = null));
  1862.     }
  1863.     
  1864. return {
  1865.     constructor: function(el, forceNew){
  1866.     var me = this;
  1867.         el = Ext.get(el);
  1868.         if(!forceNew && el.updateManager){
  1869.             return el.updateManager;
  1870.         }
  1871.         
  1872.         me.el = el;
  1873.         
  1874.         me.defaultUrl = null;
  1875.         me.addEvents(
  1876.             
  1877.             BEFOREUPDATE,
  1878.             
  1879.             UPDATE,
  1880.             
  1881.             FAILURE
  1882.         );
  1883.         Ext.apply(me, Ext.Updater.defaults);
  1884.         
  1885.         
  1886.         
  1887.         
  1888.         
  1889.         
  1890.         
  1891.         me.transaction = null;
  1892.         
  1893.         me.refreshDelegate = me.refresh.createDelegate(me);
  1894.         
  1895.         me.updateDelegate = me.update.createDelegate(me);
  1896.         
  1897.         me.formUpdateDelegate = (me.formUpdate || function(){}).createDelegate(me);
  1898.         
  1899.         me.renderer = me.renderer || me.getDefaultRenderer();
  1900.         
  1901.         Ext.Updater.superclass.constructor.call(me);
  1902.     },
  1903.         
  1904.     setRenderer : function(renderer){
  1905.         this.renderer = renderer;
  1906.     },
  1907.         
  1908.     
  1909.     getRenderer : function(){
  1910.        return this.renderer;
  1911.     },
  1912.     
  1913.     getDefaultRenderer: function() {
  1914.         return new Ext.Updater.BasicRenderer();
  1915.     },
  1916.                 
  1917.     
  1918.     setDefaultUrl : function(defaultUrl){
  1919.         this.defaultUrl = defaultUrl;
  1920.     },
  1921.         
  1922.     
  1923.     getEl : function(){
  1924.         return this.el;
  1925.     },
  1926.     update : function(url, params, callback, discardUrl){
  1927.     var me = this,
  1928.      cfg, 
  1929.      callerScope;
  1930.     
  1931.         if(me.fireEvent(BEFOREUPDATE, me.el, url, params) !== false){             
  1932.             if(Ext.isObject(url)){ 
  1933.                 cfg = url;
  1934.                 url = cfg.url;
  1935.                 params = params || cfg.params;
  1936.                 callback = callback || cfg.callback;
  1937.                 discardUrl = discardUrl || cfg.discardUrl;
  1938.                 callerScope = cfg.scope;                 
  1939.                 if(!Ext.isEmpty(cfg.nocache)){me.disableCaching = cfg.nocache;};
  1940.                 if(!Ext.isEmpty(cfg.text)){me.indicatorText = '<div class="loading-indicator">'+cfg.text+"</div>";};
  1941.                 if(!Ext.isEmpty(cfg.scripts)){me.loadScripts = cfg.scripts;};
  1942.                 if(!Ext.isEmpty(cfg.timeout)){me.timeout = cfg.timeout;};
  1943.             }
  1944.             me.showLoading();
  1945.             if(!discardUrl){
  1946.                 me.defaultUrl = url;
  1947.             }
  1948.             if(Ext.isFunction(url)){
  1949.                 url = url.call(me);
  1950.             }
  1951.             var o = Ext.apply({}, {
  1952.                 url : url,
  1953.                 params: (Ext.isFunction(params) && callerScope) ? params.createDelegate(callerScope) : params,
  1954.                 success: processSuccess,
  1955.                 failure: processFailure,
  1956.                 scope: me,
  1957.                 callback: undefined,
  1958.                 timeout: (me.timeout*1000),
  1959.                 disableCaching: me.disableCaching,
  1960.                 argument: {
  1961.                     "options": cfg,
  1962.                     "url": url,
  1963.                     "form": null,
  1964.                     "callback": callback,
  1965.                     "scope": callerScope || window,
  1966.                     "params": params
  1967.                 }
  1968.             }, cfg);
  1969.             me.transaction = Ext.Ajax.request(o);
  1970.         }
  1971.     },     
  1972.     formUpdate : function(form, url, reset, callback){
  1973.     var me = this;
  1974.         if(me.fireEvent(BEFOREUPDATE, me.el, form, url) !== false){
  1975.             if(Ext.isFunction(url)){
  1976.                 url = url.call(me);
  1977.             }
  1978.             form = Ext.getDom(form)
  1979.             me.transaction = Ext.Ajax.request({
  1980.                 form: form,
  1981.                 url:url,
  1982.                 success: processSuccess,
  1983.                 failure: processFailure,
  1984.                 scope: me,
  1985.                 timeout: (me.timeout*1000),
  1986.                 argument: {
  1987.                     "url": url,
  1988.                     "form": form,
  1989.                     "callback": callback,
  1990.                     "reset": reset
  1991.                 }
  1992.             });
  1993.             me.showLoading.defer(1, me);
  1994.         }
  1995.     },
  1996.                 
  1997.     
  1998.     startAutoRefresh : function(interval, url, params, callback, refreshNow){
  1999.     var me = this;
  2000.         if(refreshNow){
  2001.             me.update(url || me.defaultUrl, params, callback, true);
  2002.         }
  2003.         if(me.autoRefreshProcId){
  2004.             clearInterval(me.autoRefreshProcId);
  2005.         }
  2006.         me.autoRefreshProcId = setInterval(me.update.createDelegate(me, [url || me.defaultUrl, params, callback, true]), interval * 1000);
  2007.     },
  2008.     
  2009.     stopAutoRefresh : function(){
  2010.         if(this.autoRefreshProcId){
  2011.             clearInterval(this.autoRefreshProcId);
  2012.             delete this.autoRefreshProcId;
  2013.         }
  2014.     },
  2015.     
  2016.     isAutoRefreshing : function(){
  2017.        return !!this.autoRefreshProcId;
  2018.     },
  2019.     
  2020.     showLoading : function(){
  2021.         if(this.showLoadIndicator){
  2022.              this.el.dom.innerHTML = this.indicatorText;
  2023.         }
  2024.     },
  2025.     
  2026.     abort : function(){
  2027.         if(this.transaction){
  2028.             Ext.Ajax.abort(this.transaction);
  2029.         }
  2030.     },
  2031.     
  2032.     isUpdating : function(){        
  2033.      return this.transaction ? Ext.Ajax.isLoading(this.transaction) : false;        
  2034.     },
  2035.     
  2036.     
  2037.     refresh : function(callback){
  2038.         if(this.defaultUrl){
  2039.          this.update(this.defaultUrl, null, callback, true);
  2040.      }
  2041.     }
  2042.     }
  2043. }());
  2044. Ext.Updater.defaults = {
  2045.    
  2046.     timeout : 30,    
  2047.     
  2048.     disableCaching : false,
  2049.     
  2050.     showLoadIndicator : true,
  2051.     
  2052.     indicatorText : '<div class="loading-indicator">Loading...</div>',
  2053.      
  2054.     loadScripts : false,
  2055.     
  2056.     sslBlankUrl : Ext.SSL_SECURE_URL      
  2057. };
  2058. Ext.Updater.updateElement = function(el, url, params, options){
  2059.     var um = Ext.get(el).getUpdater();
  2060.     Ext.apply(um, options);
  2061.     um.update(url, params, options ? options.callback : null);
  2062. };
  2063. Ext.Updater.BasicRenderer = function(){};
  2064. Ext.Updater.BasicRenderer.prototype = {
  2065.     
  2066.      render : function(el, response, updateManager, callback){      
  2067.         el.update(response.responseText, updateManager.loadScripts, callback);
  2068.     }
  2069. };
  2070. (function() {
  2071. Date.useStrict = false;
  2072. function xf(format) {
  2073.     var args = Array.prototype.slice.call(arguments, 1);
  2074.     return format.replace(/{(d+)}/g, function(m, i) {
  2075.         return args[i];
  2076.     });
  2077. }
  2078. Date.formatCodeToRegex = function(character, currentGroup) {
  2079.     
  2080.     var p = Date.parseCodes[character];
  2081.     if (p) {
  2082.       p = typeof p == 'function'? p() : p;
  2083.       Date.parseCodes[character] = p; 
  2084.     }
  2085.     return p? Ext.applyIf({
  2086.       c: p.c? xf(p.c, currentGroup || "{0}") : p.c
  2087.     }, p) : {
  2088.         g:0,
  2089.         c:null,
  2090.         s:Ext.escapeRe(character) 
  2091.     }
  2092. }
  2093. var $f = Date.formatCodeToRegex;
  2094. Ext.apply(Date, {
  2095.     
  2096.     parseFunctions: {
  2097.         "M$": function(input, strict) {
  2098.             
  2099.             
  2100.             var re = new RegExp('\/Date\(([-+])?(\d+)(?:[+-]\d{4})?\)\/');
  2101.             var r = (input || '').match(re);
  2102.             return r? new Date(((r[1] || '') + r[2]) * 1) : null;
  2103.         }
  2104.     },
  2105.     parseRegexes: [],
  2106.     
  2107.     formatFunctions: {
  2108.         "M$": function() {
  2109.             
  2110.             return '\/Date(' + this.getTime() + ')\/';
  2111.         }
  2112.     },
  2113.     y2kYear : 50,
  2114.     
  2115.     MILLI : "ms",
  2116.     
  2117.     SECOND : "s",
  2118.     
  2119.     MINUTE : "mi",
  2120.     
  2121.     HOUR : "h",
  2122.     
  2123.     DAY : "d",
  2124.     
  2125.     MONTH : "mo",
  2126.     
  2127.     YEAR : "y",
  2128.     
  2129.     defaults: {},
  2130.     
  2131.     dayNames : [
  2132.         "Sunday",
  2133.         "Monday",
  2134.         "Tuesday",
  2135.         "Wednesday",
  2136.         "Thursday",
  2137.         "Friday",
  2138.         "Saturday"
  2139.     ],
  2140.     
  2141.     monthNames : [
  2142.         "January",
  2143.         "February",
  2144.         "March",
  2145.         "April",
  2146.         "May",
  2147.         "June",
  2148.         "July",
  2149.         "August",
  2150.         "September",
  2151.         "October",
  2152.         "November",
  2153.         "December"
  2154.     ],
  2155.     
  2156.     monthNumbers : {
  2157.         Jan:0,
  2158.         Feb:1,
  2159.         Mar:2,
  2160.         Apr:3,
  2161.         May:4,
  2162.         Jun:5,
  2163.         Jul:6,
  2164.         Aug:7,
  2165.         Sep:8,
  2166.         Oct:9,
  2167.         Nov:10,
  2168.         Dec:11
  2169.     },
  2170.     
  2171.     getShortMonthName : function(month) {
  2172.         return Date.monthNames[month].substring(0, 3);
  2173.     },
  2174.     
  2175.     getShortDayName : function(day) {
  2176.         return Date.dayNames[day].substring(0, 3);
  2177.     },
  2178.     
  2179.     getMonthNumber : function(name) {
  2180.         
  2181.         return Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
  2182.     },
  2183.     
  2184.     formatCodes : {
  2185.         d: "String.leftPad(this.getDate(), 2, '0')",
  2186.         D: "Date.getShortDayName(this.getDay())", 
  2187.         j: "this.getDate()",
  2188.         l: "Date.dayNames[this.getDay()]",
  2189.         N: "(this.getDay() ? this.getDay() : 7)",
  2190.         S: "this.getSuffix()",
  2191.         w: "this.getDay()",
  2192.         z: "this.getDayOfYear()",
  2193.         W: "String.leftPad(this.getWeekOfYear(), 2, '0')",
  2194.         F: "Date.monthNames[this.getMonth()]",
  2195.         m: "String.leftPad(this.getMonth() + 1, 2, '0')",
  2196.         M: "Date.getShortMonthName(this.getMonth())", 
  2197.         n: "(this.getMonth() + 1)",
  2198.         t: "this.getDaysInMonth()",
  2199.         L: "(this.isLeapYear() ? 1 : 0)",
  2200.         o: "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))",
  2201.         Y: "this.getFullYear()",
  2202.         y: "('' + this.getFullYear()).substring(2, 4)",
  2203.         a: "(this.getHours() < 12 ? 'am' : 'pm')",
  2204.         A: "(this.getHours() < 12 ? 'AM' : 'PM')",
  2205.         g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
  2206.         G: "this.getHours()",
  2207.         h: "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
  2208.         H: "String.leftPad(this.getHours(), 2, '0')",
  2209.         i: "String.leftPad(this.getMinutes(), 2, '0')",
  2210.         s: "String.leftPad(this.getSeconds(), 2, '0')",
  2211.         u: "String.leftPad(this.getMilliseconds(), 3, '0')",
  2212.         O: "this.getGMTOffset()",
  2213.         P: "this.getGMTOffset(true)",
  2214.         T: "this.getTimezone()",
  2215.         Z: "(this.getTimezoneOffset() * -60)",
  2216.         c: function() { 
  2217.             for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
  2218.                 var e = c.charAt(i);
  2219.                 code.push(e == "T" ? "'T'" : Date.getFormatCode(e)); 
  2220.             }
  2221.             return code.join(" + ");
  2222.         },
  2223.         
  2224.         U: "Math.round(this.getTime() / 1000)"
  2225.     },
  2226.     
  2227.     isValid : function(y, m, d, h, i, s, ms) {
  2228.         
  2229.         h = h || 0;
  2230.         i = i || 0;
  2231.         s = s || 0;
  2232.         ms = ms || 0;
  2233.         var dt = new Date(y, m - 1, d, h, i, s, ms);
  2234.         return y == dt.getFullYear() &&
  2235.             m == dt.getMonth() + 1 &&
  2236.             d == dt.getDate() &&
  2237.             h == dt.getHours() &&
  2238.             i == dt.getMinutes() &&
  2239.             s == dt.getSeconds() &&
  2240.             ms == dt.getMilliseconds();
  2241.     },
  2242.     
  2243.     parseDate : function(input, format, strict) {
  2244.         var p = Date.parseFunctions;
  2245.         if (p[format] == null) {
  2246.             Date.createParser(format);
  2247.         }
  2248.         return p[format](input, Ext.isDefined(strict) ? strict : Date.useStrict);
  2249.     },
  2250.     
  2251.     getFormatCode : function(character) {
  2252.         var f = Date.formatCodes[character];
  2253.         if (f) {
  2254.           f = typeof f == 'function'? f() : f;
  2255.           Date.formatCodes[character] = f; 
  2256.         }
  2257.         
  2258.         return f || ("'" + String.escape(character) + "'");
  2259.     },
  2260.     
  2261.     createFormat : function(format) {
  2262.         var code = [],
  2263.             special = false,
  2264.             ch = '';
  2265.         for (var i = 0; i < format.length; ++i) {
  2266.             ch = format.charAt(i);
  2267.             if (!special && ch == "\") {
  2268.                 special = true;
  2269.             } else if (special) {
  2270.                 special = false;
  2271.                 code.push("'" + String.escape(ch) + "'");
  2272.             } else {
  2273.                 code.push(Date.getFormatCode(ch))
  2274.             }
  2275.         }
  2276.         Date.formatFunctions[format] = new Function("return " + code.join('+'));
  2277.     },
  2278.     
  2279.     createParser : function() {
  2280.         var code = [
  2281.             "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
  2282.                 "def = Date.defaults,",
  2283.                 "results = String(input).match(Date.parseRegexes[{0}]);", 
  2284.             "if(results){",
  2285.                 "{1}",
  2286.                 "if(u != null){", 
  2287.                     "v = new Date(u * 1000);", 
  2288.                 "}else{",
  2289.                     
  2290.                     
  2291.                     
  2292.                     "dt = (new Date()).clearTime();",
  2293.                     
  2294.                     "y = y >= 0? y : Ext.num(def.y, dt.getFullYear());",
  2295.                     "m = m >= 0? m : Ext.num(def.m - 1, dt.getMonth());",
  2296.                     "d = d >= 0? d : Ext.num(def.d, dt.getDate());",
  2297.                     
  2298.                     "h  = h || Ext.num(def.h, dt.getHours());",
  2299.                     "i  = i || Ext.num(def.i, dt.getMinutes());",
  2300.                     "s  = s || Ext.num(def.s, dt.getSeconds());",
  2301.                     "ms = ms || Ext.num(def.ms, dt.getMilliseconds());",
  2302.                     "if(z >= 0 && y >= 0){",
  2303.                         
  2304.                         
  2305.                         
  2306.                         "v = new Date(y, 0, 1, h, i, s, ms);",
  2307.                         
  2308.                         "v = !strict? v : (strict === true && (z <= 364 || (v.isLeapYear() && z <= 365))? v.add(Date.DAY, z) : null);",
  2309.                     "}else if(strict === true && !Date.isValid(y, m + 1, d, h, i, s, ms)){", 
  2310.                         "v = null;", 
  2311.                     "}else{",
  2312.                         
  2313.                         "v = new Date(y, m, d, h, i, s, ms);",
  2314.                     "}",
  2315.                 "}",
  2316.             "}",
  2317.             "if(v){",
  2318.                 
  2319.                 "if(zz != null){",
  2320.                     
  2321.                     "v = v.add(Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
  2322.                 "}else if(o){",
  2323.                     
  2324.                     "v = v.add(Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
  2325.                 "}",
  2326.             "}",
  2327.             "return v;"
  2328.         ].join('n');
  2329.         return function(format) {
  2330.             var regexNum = Date.parseRegexes.length,
  2331.                 currentGroup = 1,
  2332.                 calc = [],
  2333.                 regex = [],
  2334.                 special = false,
  2335.                 ch = "";
  2336.             for (var i = 0; i < format.length; ++i) {
  2337.                 ch = format.charAt(i);
  2338.                 if (!special && ch == "\") {
  2339.                     special = true;
  2340.                 } else if (special) {
  2341.                     special = false;
  2342.                     regex.push(String.escape(ch));
  2343.                 } else {
  2344.                     var obj = $f(ch, currentGroup);
  2345.                     currentGroup += obj.g;
  2346.                     regex.push(obj.s);
  2347.                     if (obj.g && obj.c) {
  2348.                         calc.push(obj.c);
  2349.                     }
  2350.                 }
  2351.             }
  2352.             Date.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", "i");
  2353.             Date.parseFunctions[format] = new Function("input", "strict", xf(code, regexNum, calc.join('')));
  2354.         }
  2355.     }(),
  2356.     
  2357.     parseCodes : {
  2358.         
  2359.         d: {
  2360.             g:1,
  2361.             c:"d = parseInt(results[{0}], 10);n",
  2362.             s:"(\d{2})" 
  2363.         },
  2364.         j: {
  2365.             g:1,
  2366.             c:"d = parseInt(results[{0}], 10);n",
  2367.             s:"(\d{1,2})" 
  2368.         },
  2369.         D: function() {
  2370.             for (var a = [], i = 0; i < 7; a.push(Date.getShortDayName(i)), ++i); 
  2371.             return {
  2372.                 g:0,
  2373.                 c:null,
  2374.                 s:"(?:" + a.join("|") +")"
  2375.             }
  2376.         },
  2377.         l: function() {
  2378.             return {
  2379.                 g:0,
  2380.                 c:null,
  2381.                 s:"(?:" + Date.dayNames.join("|") + ")"
  2382.             }
  2383.         },
  2384.         N: {
  2385.             g:0,
  2386.             c:null,
  2387.             s:"[1-7]" 
  2388.         },
  2389.         S: {
  2390.             g:0,
  2391.             c:null,
  2392.             s:"(?:st|nd|rd|th)"
  2393.         },
  2394.         w: {
  2395.             g:0,
  2396.             c:null,
  2397.             s:"[0-6]" 
  2398.         },
  2399.         z: {
  2400.             g:1,
  2401.             c:"z = parseInt(results[{0}], 10);n",
  2402.             s:"(\d{1,3})" 
  2403.         },
  2404.         W: {
  2405.             g:0,
  2406.             c:null,
  2407.             s:"(?:\d{2})" 
  2408.         },
  2409.         F: function() {
  2410.             return {
  2411.                 g:1,
  2412.                 c:"m = parseInt(Date.getMonthNumber(results[{0}]), 10);n", 
  2413.                 s:"(" + Date.monthNames.join("|") + ")"
  2414.             }
  2415.         },
  2416.         M: function() {
  2417.             for (var a = [], i = 0; i < 12; a.push(Date.getShortMonthName(i)), ++i); 
  2418.             return Ext.applyIf({
  2419.                 s:"(" + a.join("|") + ")"
  2420.             }, $f("F"));
  2421.         },
  2422.         m: {
  2423.             g:1,
  2424.             c:"m = parseInt(results[{0}], 10) - 1;n",
  2425.             s:"(\d{2})" 
  2426.         },
  2427.         n: {
  2428.             g:1,
  2429.             c:"m = parseInt(results[{0}], 10) - 1;n",
  2430.             s:"(\d{1,2})" 
  2431.         },
  2432.         t: {
  2433.             g:0,
  2434.             c:null,
  2435.             s:"(?:\d{2})" 
  2436.         },
  2437.         L: {
  2438.             g:0,
  2439.             c:null,
  2440.             s:"(?:1|0)"
  2441.         },
  2442.         o: function() {
  2443.             return $f("Y");
  2444.         },
  2445.         Y: {
  2446.             g:1,
  2447.             c:"y = parseInt(results[{0}], 10);n",
  2448.             s:"(\d{4})" 
  2449.         },
  2450.         y: {
  2451.             g:1,
  2452.             c:"var ty = parseInt(results[{0}], 10);n"
  2453.                 + "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;n", 
  2454.             s:"(\d{1,2})"
  2455.         },
  2456.         a: {
  2457.             g:1,
  2458.             c:"if (results[{0}] == 'am') {n"
  2459.                 + "if (!h || h == 12) { h = 0; }n"
  2460.                 + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
  2461.             s:"(am|pm)"
  2462.         },
  2463.         A: {
  2464.             g:1,
  2465.             c:"if (results[{0}] == 'AM') {n"
  2466.                 + "if (!h || h == 12) { h = 0; }n"
  2467.                 + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
  2468.             s:"(AM|PM)"
  2469.         },
  2470.         g: function() {
  2471.             return $f("G");
  2472.         },
  2473.         G: {
  2474.             g:1,
  2475.             c:"h = parseInt(results[{0}], 10);n",
  2476.             s:"(\d{1,2})" 
  2477.         },
  2478.         h: function() {
  2479.             return $f("H");
  2480.         },
  2481.         H: {
  2482.             g:1,
  2483.             c:"h = parseInt(results[{0}], 10);n",
  2484.             s:"(\d{2})" 
  2485.         },
  2486.         i: {
  2487.             g:1,
  2488.             c:"i = parseInt(results[{0}], 10);n",
  2489.             s:"(\d{2})" 
  2490.         },
  2491.         s: {
  2492.             g:1,
  2493.             c:"s = parseInt(results[{0}], 10);n",
  2494.             s:"(\d{2})" 
  2495.         },
  2496.         u: {
  2497.             g:1,
  2498.             c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);n",
  2499.             s:"(\d+)" 
  2500.         },
  2501.         O: {
  2502.             g:1,
  2503.             c:[
  2504.                 "o = results[{0}];",
  2505.                 "var sn = o.substring(0,1),", 
  2506.                     "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", 
  2507.                     "mn = o.substring(3,5) % 60;", 
  2508.                 "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;n" 
  2509.             ].join("n"),
  2510.             s: "([+-]\d{4})" 
  2511.         },
  2512.         P: {
  2513.             g:1,
  2514.             c:[
  2515.                 "o = results[{0}];",
  2516.                 "var sn = o.substring(0,1),", 
  2517.                     "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", 
  2518.                     "mn = o.substring(4,6) % 60;", 
  2519.                 "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;n" 
  2520.             ].join("n"),
  2521.             s: "([+-]\d{2}:\d{2})" 
  2522.         },
  2523.         T: {
  2524.             g:0,
  2525.             c:null,
  2526.             s:"[A-Z]{1,4}" 
  2527.         },
  2528.         Z: {
  2529.             g:1,
  2530.             c:"zz = results[{0}] * 1;n" 
  2531.                   + "zz = (-43200 <= zz && zz <= 50400)? zz : null;n",
  2532.             s:"([+-]?\d{1,5})" 
  2533.         },
  2534.         c: function() {
  2535.             var calc = [],
  2536.                 arr = [
  2537.                     $f("Y", 1), 
  2538.                     $f("m", 2), 
  2539.                     $f("d", 3), 
  2540.                     $f("h", 4), 
  2541.                     $f("i", 5), 
  2542.                     $f("s", 6), 
  2543.                     {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);n"}, 
  2544.                     {c:[ 
  2545.                         "if(results[8]) {", 
  2546.                             "if(results[8] == 'Z'){",
  2547.                                 "zz = 0;", 
  2548.                             "}else if (results[8].indexOf(':') > -1){",
  2549.                                 $f("P", 8).c, 
  2550.                             "}else{",
  2551.                                 $f("O", 8).c, 
  2552.                             "}",
  2553.                         "}"
  2554.                     ].join('n')}
  2555.                 ];
  2556.             for (var i = 0, l = arr.length; i < l; ++i) {
  2557.                 calc.push(arr[i].c);
  2558.             }
  2559.             return {
  2560.                 g:1,
  2561.                 c:calc.join(""),
  2562.                 s:[
  2563.                     arr[0].s, 
  2564.                     "(?:", "-", arr[1].s, 
  2565.                         "(?:", "-", arr[2].s, 
  2566.                             "(?:",
  2567.                                 "(?:T| )?", 
  2568.                                 arr[3].s, ":", arr[4].s,  
  2569.                                 "(?::", arr[5].s, ")?", 
  2570.                                 "(?:(?:\.|,)(\d+))?", 
  2571.                                 "(Z|(?:[-+]\d{2}(?::)?\d{2}))?", 
  2572.                             ")?",
  2573.                         ")?",
  2574.                     ")?"
  2575.                 ].join("")
  2576.             }
  2577.         },
  2578.         U: {
  2579.             g:1,
  2580.             c:"u = parseInt(results[{0}], 10);n",
  2581.             s:"(-?\d+)" 
  2582.         }
  2583.     }
  2584. });
  2585. }());
  2586. Ext.apply(Date.prototype, {
  2587.     
  2588.     dateFormat : function(format) {
  2589.         if (Date.formatFunctions[format] == null) {
  2590.             Date.createFormat(format);
  2591.         }
  2592.         return Date.formatFunctions[format].call(this);
  2593.     },
  2594.     
  2595.     getTimezone : function() {
  2596.         
  2597.         
  2598.         
  2599.         
  2600.         
  2601.         
  2602.         
  2603.         
  2604.         
  2605.         
  2606.         
  2607.         
  2608.         return this.toString().replace(/^.* (?:((.*))|([A-Z]{1,4})(?:[-+][0-9]{4})?(?: -?d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
  2609.     },
  2610.     
  2611.     getGMTOffset : function(colon) {
  2612.         return (this.getTimezoneOffset() > 0 ? "-" : "+")
  2613.             + String.leftPad(Math.floor(Math.abs(this.getTimezoneOffset()) / 60), 2, "0")
  2614.             + (colon ? ":" : "")
  2615.             + String.leftPad(Math.abs(this.getTimezoneOffset() % 60), 2, "0");
  2616.     },
  2617.     
  2618.     getDayOfYear: function() {
  2619.         var num = 0,
  2620.             d = this.clone(),
  2621.             m = this.getMonth(),
  2622.             i;
  2623.         for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
  2624.             num += d.getDaysInMonth();
  2625.         }
  2626.         return num + this.getDate() - 1;
  2627.     },
  2628.     
  2629.     getWeekOfYear : function() {
  2630.         
  2631.         var ms1d = 864e5, 
  2632.             ms7d = 7 * ms1d; 
  2633.         return function() { 
  2634.             var DC3 = Date.UTC(this.getFullYear(), this.getMonth(), this.getDate() + 3) / ms1d, 
  2635.                 AWN = Math.floor(DC3 / 7), 
  2636.                 Wyr = new Date(AWN * ms7d).getUTCFullYear();
  2637.             return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
  2638.         }
  2639.     }(),
  2640.     
  2641.     isLeapYear : function() {
  2642.         var year = this.getFullYear();
  2643.         return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
  2644.     },
  2645.     
  2646.     getFirstDayOfMonth : function() {
  2647.         var day = (this.getDay() - (this.getDate() - 1)) % 7;
  2648.         return (day < 0) ? (day + 7) : day;
  2649.     },
  2650.     
  2651.     getLastDayOfMonth : function() {
  2652.         return this.getLastDateOfMonth().getDay();
  2653.     },
  2654.     
  2655.     getFirstDateOfMonth : function() {
  2656.         return new Date(this.getFullYear(), this.getMonth(), 1);
  2657.     },
  2658.     
  2659.     getLastDateOfMonth : function() {
  2660.         return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth());
  2661.     },
  2662.     
  2663.     getDaysInMonth: function() {
  2664.         var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  2665.         return function() { 
  2666.             var m = this.getMonth();
  2667.             return m == 1 && this.isLeapYear() ? 29 : daysInMonth[m];
  2668.         }
  2669.     }(),
  2670.     
  2671.     getSuffix : function() {
  2672.         switch (this.getDate()) {
  2673.             case 1:
  2674.             case 21:
  2675.             case 31:
  2676.                 return "st";
  2677.             case 2:
  2678.             case 22:
  2679.                 return "nd";
  2680.             case 3:
  2681.             case 23:
  2682.                 return "rd";
  2683.             default:
  2684.                 return "th";
  2685.         }
  2686.     },
  2687.     
  2688.     clone : function() {
  2689.         return new Date(this.getTime());
  2690.     },
  2691.     
  2692.     isDST : function() {
  2693.         
  2694.         
  2695.         return new Date(this.getFullYear(), 0, 1).getTimezoneOffset() != this.getTimezoneOffset();
  2696.     },
  2697.     
  2698.     clearTime : function(clone) {
  2699.         if (clone) {
  2700.             return this.clone().clearTime();
  2701.         }
  2702.         
  2703.         var d = this.getDate();
  2704.         
  2705.         this.setHours(0);
  2706.         this.setMinutes(0);
  2707.         this.setSeconds(0);
  2708.         this.setMilliseconds(0);
  2709.         if (this.getDate() != d) { 
  2710.             
  2711.             
  2712.             
  2713.             for (var hr = 1, c = this.add(Date.HOUR, hr); c.getDate() != d; hr++, c = this.add(Date.HOUR, hr));
  2714.             this.setDate(d);
  2715.             this.setHours(c.getHours());
  2716.         }
  2717.         return this;
  2718.     },
  2719.     
  2720.     add : function(interval, value) {
  2721.         var d = this.clone();
  2722.         if (!interval || value === 0) return d;
  2723.         switch(interval.toLowerCase()) {
  2724.             case Date.MILLI:
  2725.                 d.setMilliseconds(this.getMilliseconds() + value);
  2726.                 break;
  2727.             case Date.SECOND:
  2728.                 d.setSeconds(this.getSeconds() + value);
  2729.                 break;
  2730.             case Date.MINUTE:
  2731.                 d.setMinutes(this.getMinutes() + value);
  2732.                 break;
  2733.             case Date.HOUR:
  2734.                 d.setHours(this.getHours() + value);
  2735.                 break;
  2736.             case Date.DAY:
  2737.                 d.setDate(this.getDate() + value);
  2738.                 break;
  2739.             case Date.MONTH:
  2740.                 var day = this.getDate();
  2741.                 if (day > 28) {
  2742.                     day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate());
  2743.                 }
  2744.                 d.setDate(day);
  2745.                 d.setMonth(this.getMonth() + value);
  2746.                 break;
  2747.             case Date.YEAR:
  2748.                 d.setFullYear(this.getFullYear() + value);
  2749.                 break;
  2750.         }
  2751.         return d;
  2752.     },
  2753.     
  2754.     between : function(start, end) {
  2755.         var t = this.getTime();
  2756.         return start.getTime() <= t && t <= end.getTime();
  2757.     }
  2758. });
  2759. Date.prototype.format = Date.prototype.dateFormat;
  2760. if (Ext.isSafari && (navigator.userAgent.match(/WebKit/(d+)/)[1] || NaN) < 420) {
  2761.     Ext.apply(Date.prototype, {
  2762.         _xMonth : Date.prototype.setMonth,
  2763.         _xDate  : Date.prototype.setDate,
  2764.         
  2765.         
  2766.         setMonth : function(num) {
  2767.             if (num <= -1) {
  2768.                 var n = Math.ceil(-num),
  2769.                     back_year = Math.ceil(n / 12),
  2770.                     month = (n % 12) ? 12 - n % 12 : 0;
  2771.                 this.setFullYear(this.getFullYear() - back_year);
  2772.                 return this._xMonth(month);
  2773.             } else {
  2774.                 return this._xMonth(num);
  2775.             }
  2776.         },
  2777.         
  2778.         
  2779.         
  2780.         setDate : function(d) {
  2781.             
  2782.             
  2783.             return this.setTime(this.getTime() - (this.getDate() - d) * 864e5);
  2784.         }
  2785.     });
  2786. }
  2787. Ext.util.MixedCollection = function(allowFunctions, keyFn){
  2788.     this.items = [];
  2789.     this.map = {};
  2790.     this.keys = [];
  2791.     this.length = 0;
  2792.     this.addEvents(
  2793.         
  2794.         'clear',
  2795.         
  2796.         'add',
  2797.         
  2798.         'replace',
  2799.         
  2800.         'remove',
  2801.         'sort'
  2802.     );
  2803.     this.allowFunctions = allowFunctions === true;
  2804.     if(keyFn){
  2805.         this.getKey = keyFn;
  2806.     }
  2807.     Ext.util.MixedCollection.superclass.constructor.call(this);
  2808. };
  2809. Ext.extend(Ext.util.MixedCollection, Ext.util.Observable, {
  2810.     
  2811.     allowFunctions : false,
  2812.     
  2813.     add : function(key, o){
  2814.         if(arguments.length == 1){
  2815.             o = arguments[0];
  2816.             key = this.getKey(o);
  2817.         }
  2818.         if(typeof key != 'undefined' && key !== null){
  2819.             var old = this.map[key];
  2820.             if(typeof old != 'undefined'){
  2821.                 return this.replace(key, o);
  2822.             }
  2823.             this.map[key] = o;
  2824.         }
  2825.         this.length++;
  2826.         this.items.push(o);
  2827.         this.keys.push(key);
  2828.         this.fireEvent('add', this.length-1, o, key);
  2829.         return o;
  2830.     },
  2831.     
  2832.     getKey : function(o){
  2833.          return o.id;
  2834.     },
  2835.     
  2836.     replace : function(key, o){
  2837.         if(arguments.length == 1){
  2838.             o = arguments[0];
  2839.             key = this.getKey(o);
  2840.         }
  2841.         var old = this.map[key];
  2842.         if(typeof key == 'undefined' || key === null || typeof old == 'undefined'){
  2843.              return this.add(key, o);
  2844.         }
  2845.         var index = this.indexOfKey(key);
  2846.         this.items[index] = o;
  2847.         this.map[key] = o;
  2848.         this.fireEvent('replace', key, old, o);
  2849.         return o;
  2850.     },
  2851.     
  2852.     addAll : function(objs){
  2853.         if(arguments.length > 1 || Ext.isArray(objs)){
  2854.             var args = arguments.length > 1 ? arguments : objs;
  2855.             for(var i = 0, len = args.length; i < len; i++){
  2856.                 this.add(args[i]);
  2857.             }
  2858.         }else{
  2859.             for(var key in objs){
  2860.                 if(this.allowFunctions || typeof objs[key] != 'function'){
  2861.                     this.add(key, objs[key]);
  2862.                 }
  2863.             }
  2864.         }
  2865.     },
  2866.     
  2867.     each : function(fn, scope){
  2868.         var items = [].concat(this.items); 
  2869.         for(var i = 0, len = items.length; i < len; i++){
  2870.             if(fn.call(scope || items[i], items[i], i, len) === false){
  2871.                 break;
  2872.             }
  2873.         }
  2874.     },
  2875.     
  2876.     eachKey : function(fn, scope){
  2877.         for(var i = 0, len = this.keys.length; i < len; i++){
  2878.             fn.call(scope || window, this.keys[i], this.items[i], i, len);
  2879.         }
  2880.     },
  2881.     
  2882.     find : function(fn, scope){
  2883.         for(var i = 0, len = this.items.length; i < len; i++){
  2884.             if(fn.call(scope || window, this.items[i], this.keys[i])){
  2885.                 return this.items[i];
  2886.             }
  2887.         }
  2888.         return null;
  2889.     },
  2890.     
  2891.     insert : function(index, key, o){
  2892.         if(arguments.length == 2){
  2893.             o = arguments[1];
  2894.             key = this.getKey(o);
  2895.         }
  2896.         if(this.containsKey(key)){
  2897.             this.suspendEvents();
  2898.             this.removeKey(key);
  2899.             this.resumeEvents();
  2900.         }
  2901.         if(index >= this.length){
  2902.             return this.add(key, o);
  2903.         }
  2904.         this.length++;
  2905.         this.items.splice(index, 0, o);
  2906.         if(typeof key != 'undefined' && key !== null){
  2907.             this.map[key] = o;
  2908.         }
  2909.         this.keys.splice(index, 0, key);
  2910.         this.fireEvent('add', index, o, key);
  2911.         return o;
  2912.     },
  2913.     
  2914.     remove : function(o){
  2915.         return this.removeAt(this.indexOf(o));
  2916.     },
  2917.     
  2918.     removeAt : function(index){
  2919.         if(index < this.length && index >= 0){
  2920.             this.length--;
  2921.             var o = this.items[index];
  2922.             this.items.splice(index, 1);
  2923.             var key = this.keys[index];
  2924.             if(typeof key != 'undefined'){
  2925.                 delete this.map[key];
  2926.             }
  2927.             this.keys.splice(index, 1);
  2928.             this.fireEvent('remove', o, key);
  2929.             return o;
  2930.         }
  2931.         return false;
  2932.     },
  2933.     
  2934.     removeKey : function(key){
  2935.         return this.removeAt(this.indexOfKey(key));
  2936.     },
  2937.     
  2938.     getCount : function(){
  2939.         return this.length;
  2940.     },
  2941.     
  2942.     indexOf : function(o){
  2943.         return this.items.indexOf(o);
  2944.     },
  2945.     
  2946.     indexOfKey : function(key){
  2947.         return this.keys.indexOf(key);
  2948.     },
  2949.     
  2950.     item : function(key){
  2951.         var mk = this.map[key],
  2952.             item = mk !== undefined ? mk : (typeof key == 'number') ? this.items[key] : undefined;
  2953.         return !Ext.isFunction(item) || this.allowFunctions ? item : null; 
  2954.     },
  2955.     
  2956.     itemAt : function(index){
  2957.         return this.items[index];
  2958.     },
  2959.     
  2960.     key : function(key){
  2961.         return this.map[key];
  2962.     },
  2963.     
  2964.     contains : function(o){
  2965.         return this.indexOf(o) != -1;
  2966.     },
  2967.     
  2968.     containsKey : function(key){
  2969.         return typeof this.map[key] != 'undefined';
  2970.     },
  2971.     
  2972.     clear : function(){
  2973.         this.length = 0;
  2974.         this.items = [];
  2975.         this.keys = [];
  2976.         this.map = {};
  2977.         this.fireEvent('clear');
  2978.     },
  2979.     
  2980.     first : function(){
  2981.         return this.items[0];
  2982.     },
  2983.     
  2984.     last : function(){
  2985.         return this.items[this.length-1];
  2986.     },
  2987.     
  2988.     _sort : function(property, dir, fn){
  2989.         var i,
  2990.             len,
  2991.             dsc = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
  2992.             c = [], k = this.keys, items = this.items;
  2993.         fn = fn || function(a, b){
  2994.             return a-b;
  2995.         };
  2996.         for(i = 0, len = items.length; i < len; i++){
  2997.             c[c.length] = {key: k[i], value: items[i], index: i};
  2998.         }
  2999.         c.sort(function(a, b){
  3000.             var v = fn(a[property], b[property]) * dsc;
  3001.             if(v === 0){
  3002.                 v = (a.index < b.index ? -1 : 1);
  3003.             }
  3004.             return v;
  3005.         });
  3006.         for(i = 0, len = c.length; i < len; i++){
  3007.             items[i] = c[i].value;
  3008.             k[i] = c[i].key;
  3009.         }
  3010.         this.fireEvent('sort', this);
  3011.     },
  3012.     
  3013.     sort : function(dir, fn){
  3014.         this._sort('value', dir, fn);
  3015.     },
  3016.     
  3017.     keySort : function(dir, fn){
  3018.         this._sort('key', dir, fn || function(a, b){
  3019.             var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
  3020.             return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
  3021.         });
  3022.     },
  3023.     
  3024.     getRange : function(start, end){
  3025.         var items = this.items;
  3026.         if(items.length < 1){
  3027.             return [];
  3028.         }
  3029.         start = start || 0;
  3030.         end = Math.min(typeof end == 'undefined' ? this.length-1 : end, this.length-1);
  3031.         var i, r = [];
  3032.         if(start <= end){
  3033.             for(i = start; i <= end; i++) {
  3034.                 r[r.length] = items[i];
  3035.             }
  3036.         }else{
  3037.             for(i = start; i >= end; i--) {
  3038.                 r[r.length] = items[i];
  3039.             }
  3040.         }
  3041.         return r;
  3042.     },
  3043.     
  3044.     filter : function(property, value, anyMatch, caseSensitive){
  3045.         if(Ext.isEmpty(value, false)){
  3046.             return this.clone();
  3047.         }
  3048.         value = this.createValueMatcher(value, anyMatch, caseSensitive);
  3049.         return this.filterBy(function(o){
  3050.             return o && value.test(o[property]);
  3051.         });
  3052.     },
  3053.     
  3054.     filterBy : function(fn, scope){
  3055.         var r = new Ext.util.MixedCollection();
  3056.         r.getKey = this.getKey;
  3057.         var k = this.keys, it = this.items;
  3058.         for(var i = 0, len = it.length; i < len; i++){
  3059.             if(fn.call(scope||this, it[i], k[i])){
  3060.                 r.add(k[i], it[i]);
  3061.             }
  3062.         }
  3063.         return r;
  3064.     },
  3065.     
  3066.     findIndex : function(property, value, start, anyMatch, caseSensitive){
  3067.         if(Ext.isEmpty(value, false)){
  3068.             return -1;
  3069.         }
  3070.         value = this.createValueMatcher(value, anyMatch, caseSensitive);
  3071.         return this.findIndexBy(function(o){
  3072.             return o && value.test(o[property]);
  3073.         }, null, start);
  3074.     },
  3075.     
  3076.     findIndexBy : function(fn, scope, start){
  3077.         var k = this.keys, it = this.items;
  3078.         for(var i = (start||0), len = it.length; i < len; i++){
  3079.             if(fn.call(scope||this, it[i], k[i])){
  3080.                 return i;
  3081.             }
  3082.         }
  3083.         return -1;
  3084.     },
  3085.     
  3086.     createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
  3087.         if (!value.exec) { 
  3088.             var er = Ext.escapeRe;
  3089.             value = String(value);
  3090.             if (anyMatch === true) {
  3091.                 value = er(value);
  3092.             } else {
  3093.                 value = '^' + er(value);
  3094.                 if (exactMatch === true) {
  3095.                     value += '$';
  3096.                 }
  3097.             }
  3098.             value = new RegExp(value, caseSensitive ? '' : 'i');
  3099.          }
  3100.          return value;
  3101.     },
  3102.     
  3103.     clone : function(){
  3104.         var r = new Ext.util.MixedCollection();
  3105.         var k = this.keys, it = this.items;
  3106.         for(var i = 0, len = it.length; i < len; i++){
  3107.             r.add(k[i], it[i]);
  3108.         }
  3109.         r.getKey = this.getKey;
  3110.         return r;
  3111.     }
  3112. });
  3113. Ext.util.MixedCollection.prototype.get = Ext.util.MixedCollection.prototype.item;
  3114. Ext.util.JSON = new (function(){
  3115.     var useHasOwn = !!{}.hasOwnProperty,
  3116.         isNative = function() {
  3117.             var useNative = null;
  3118.             return function() {
  3119.                 if (useNative === null) {
  3120.                     useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
  3121.                 }
  3122.         
  3123.                 return useNative;
  3124.             };
  3125.         }(),
  3126.         pad = function(n) {
  3127.             return n < 10 ? "0" + n : n;
  3128.         },
  3129.         doDecode = function(json){
  3130.             return eval("(" + json + ')');    
  3131.         },
  3132.         doEncode = function(o){
  3133.             if(!Ext.isDefined(o) || o === null){
  3134.                 return "null";
  3135.             }else if(Ext.isArray(o)){
  3136.                 return encodeArray(o);
  3137.             }else if(Ext.isDate(o)){
  3138.                 return Ext.util.JSON.encodeDate(o);
  3139.             }else if(Ext.isString(o)){
  3140.                 return encodeString(o);
  3141.             }else if(typeof o == "number"){
  3142.                 
  3143.                 return isFinite(o) ? String(o) : "null";
  3144.             }else if(Ext.isBoolean(o)){
  3145.                 return String(o);
  3146.             }else {
  3147.                 var a = ["{"], b, i, v;
  3148.                 for (i in o) {
  3149.                     
  3150.                     if(!o.getElementsByTagName){
  3151.                         if(!useHasOwn || o.hasOwnProperty(i)) {
  3152.                             v = o[i];
  3153.                             switch (typeof v) {
  3154.                             case "undefined":
  3155.                             case "function":
  3156.                             case "unknown":
  3157.                                 break;
  3158.                             default:
  3159.                                 if(b){
  3160.                                     a.push(',');
  3161.                                 }
  3162.                                 a.push(doEncode(i), ":",
  3163.                                         v === null ? "null" : doEncode(v));
  3164.                                 b = true;
  3165.                             }
  3166.                         }
  3167.                     }
  3168.                 }
  3169.                 a.push("}");
  3170.                 return a.join("");
  3171.             }    
  3172.         },
  3173.         m = {
  3174.             "b": '\b',
  3175.             "t": '\t',
  3176.             "n": '\n',
  3177.             "f": '\f',
  3178.             "r": '\r',
  3179.             '"' : '\"',
  3180.             "\": '\\'
  3181.         },
  3182.         encodeString = function(s){
  3183.             if (/["\x00-x1f]/.test(s)) {
  3184.                 return '"' + s.replace(/([x00-x1f\"])/g, function(a, b) {
  3185.                     var c = m[b];
  3186.                     if(c){
  3187.                         return c;
  3188.                     }
  3189.                     c = b.charCodeAt();
  3190.                     return "\u00" +
  3191.                         Math.floor(c / 16).toString(16) +
  3192.                         (c % 16).toString(16);
  3193.                 }) + '"';
  3194.             }
  3195.             return '"' + s + '"';
  3196.         },
  3197.         encodeArray = function(o){
  3198.             var a = ["["], b, i, l = o.length, v;
  3199.                 for (i = 0; i < l; i += 1) {
  3200.                     v = o[i];
  3201.                     switch (typeof v) {
  3202.                         case "undefined":
  3203.                         case "function":
  3204.                         case "unknown":
  3205.                             break;
  3206.                         default:
  3207.                             if (b) {
  3208.                                 a.push(',');
  3209.                             }
  3210.                             a.push(v === null ? "null" : Ext.util.JSON.encode(v));
  3211.                             b = true;
  3212.                     }
  3213.                 }
  3214.                 a.push("]");
  3215.                 return a.join("");
  3216.         };
  3217.     this.encodeDate = function(o){
  3218.         return '"' + o.getFullYear() + "-" +
  3219.                 pad(o.getMonth() + 1) + "-" +
  3220.                 pad(o.getDate()) + "T" +
  3221.                 pad(o.getHours()) + ":" +
  3222.                 pad(o.getMinutes()) + ":" +
  3223.                 pad(o.getSeconds()) + '"';
  3224.     };
  3225.     
  3226.     this.encode = function() {
  3227.         var ec;
  3228.         return function(o) {
  3229.             if (!ec) {
  3230.                 
  3231.                 ec = isNative() ? JSON.stringify : doEncode;
  3232.             }
  3233.             return ec(o);
  3234.         };
  3235.     }();
  3236.     
  3237.     this.decode = function() {
  3238.         var dc;
  3239.         return function(json) {
  3240.             if (!dc) {
  3241.                 
  3242.                 dc = isNative() ? JSON.parse : doDecode;
  3243.             }
  3244.             return dc(json);
  3245.         };
  3246.     }();
  3247. })();
  3248. Ext.encode = Ext.util.JSON.encode;
  3249. Ext.decode = Ext.util.JSON.decode;
  3250. Ext.util.Format = function(){
  3251.     var trimRe = /^s+|s+$/g,
  3252.         stripTagsRE = /</?[^>]+>/gi,
  3253.         stripScriptsRe = /(?:<script.*?>)((n|r|.)*?)(?:</script>)/ig,
  3254.         nl2brRe = /r?n/g;
  3255.         
  3256.     return {
  3257.         
  3258.         ellipsis : function(value, len, word){
  3259.             if(value && value.length > len){
  3260.                 if(word){
  3261.                     var vs = value.substr(0, len - 2),
  3262.                         index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
  3263.                     if(index == -1 || index < (len - 15)){
  3264.                         return value.substr(0, len - 3) + "...";
  3265.                     }else{
  3266.                         return vs.substr(0, index) + "...";
  3267.                     }
  3268.                 } else{
  3269.                     return value.substr(0, len - 3) + "...";
  3270.                 }
  3271.             }
  3272.             return value;
  3273.         },
  3274.         
  3275.         undef : function(value){
  3276.             return value !== undefined ? value : "";
  3277.         },
  3278.         
  3279.         defaultValue : function(value, defaultValue){
  3280.             return value !== undefined && value !== '' ? value : defaultValue;
  3281.         },
  3282.         
  3283.         htmlEncode : function(value){
  3284.             return !value ? value : String(value).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
  3285.         },
  3286.         
  3287.         htmlDecode : function(value){
  3288.             return !value ? value : String(value).replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
  3289.         },
  3290.         
  3291.         trim : function(value){
  3292.             return String(value).replace(trimRe, "");
  3293.         },
  3294.         
  3295.         substr : function(value, start, length){
  3296.             return String(value).substr(start, length);
  3297.         },
  3298.         
  3299.         lowercase : function(value){
  3300.             return String(value).toLowerCase();
  3301.         },
  3302.         
  3303.         uppercase : function(value){
  3304.             return String(value).toUpperCase();
  3305.         },
  3306.         
  3307.         capitalize : function(value){
  3308.             return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
  3309.         },
  3310.         
  3311.         call : function(value, fn){
  3312.             if(arguments.length > 2){
  3313.                 var args = Array.prototype.slice.call(arguments, 2);
  3314.                 args.unshift(value);
  3315.                 return eval(fn).apply(window, args);
  3316.             }else{
  3317.                 return eval(fn).call(window, value);
  3318.             }
  3319.         },
  3320.         
  3321.         usMoney : function(v){
  3322.             v = (Math.round((v-0)*100))/100;
  3323.             v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
  3324.             v = String(v);
  3325.             var ps = v.split('.'),
  3326.                 whole = ps[0],
  3327.                 sub = ps[1] ? '.'+ ps[1] : '.00',
  3328.                 r = /(d+)(d{3})/;
  3329.             while (r.test(whole)) {
  3330.                 whole = whole.replace(r, '$1' + ',' + '$2');
  3331.             }
  3332.             v = whole + sub;
  3333.             if(v.charAt(0) == '-'){
  3334.                 return '-$' + v.substr(1);
  3335.             }
  3336.             return "$" +  v;
  3337.         },
  3338.         
  3339.         date : function(v, format){
  3340.             if(!v){
  3341.                 return "";
  3342.             }
  3343.             if(!Ext.isDate(v)){
  3344.                 v = new Date(Date.parse(v));
  3345.             }
  3346.             return v.dateFormat(format || "m/d/Y");
  3347.         },
  3348.         
  3349.         dateRenderer : function(format){
  3350.             return function(v){
  3351.                 return Ext.util.Format.date(v, format);
  3352.             };
  3353.         },
  3354.         
  3355.         
  3356.         stripTags : function(v){
  3357.             return !v ? v : String(v).replace(stripTagsRE, "");
  3358.         },
  3359.         
  3360.         stripScripts : function(v){
  3361.             return !v ? v : String(v).replace(stripScriptsRe, "");
  3362.         },
  3363.         
  3364.         fileSize : function(size){
  3365.             if(size < 1024) {
  3366.                 return size + " bytes";
  3367.             } else if(size < 1048576) {
  3368.                 return (Math.round(((size*10) / 1024))/10) + " KB";
  3369.             } else {
  3370.                 return (Math.round(((size*10) / 1048576))/10) + " MB";
  3371.             }
  3372.         },
  3373.         
  3374.         math : function(){
  3375.             var fns = {};
  3376.             return function(v, a){
  3377.                 if(!fns[a]){
  3378.                     fns[a] = new Function('v', 'return v ' + a + ';');
  3379.                 }
  3380.                 return fns[a](v);
  3381.             }
  3382.         }(),
  3383.         
  3384.         round : function(value, precision) {
  3385.             var result = Number(value);
  3386.             if (typeof precision == 'number') {
  3387.                 precision = Math.pow(10, precision);
  3388.                 result = Math.round(value * precision) / precision;
  3389.             }
  3390.             return result;
  3391.         },
  3392.         
  3393.         number: function(v, format) {
  3394.             if(!format){
  3395.         return v;
  3396.     }
  3397.     v = Ext.num(v, NaN);
  3398.             if (isNaN(v)){
  3399.                 return '';
  3400.             }
  3401.     var comma = ',',
  3402.         dec = '.',
  3403.         i18n = false,
  3404.         neg = v < 0;
  3405.     v = Math.abs(v);
  3406.     if(format.substr(format.length - 2) == '/i'){
  3407.         format = format.substr(0, format.length - 2);
  3408.         i18n = true;
  3409.         comma = '.';
  3410.         dec = ',';
  3411.     }
  3412.     var hasComma = format.indexOf(comma) != -1, 
  3413.         psplit = (i18n ? format.replace(/[^d,]/g, '') : format.replace(/[^d.]/g, '')).split(dec);
  3414.     if(1 < psplit.length){
  3415.         v = v.toFixed(psplit[1].length);
  3416.     }else if(2 < psplit.length){
  3417.         throw ('NumberFormatException: invalid format, formats should have no more than 1 period: ' + format);
  3418.     }else{
  3419.         v = v.toFixed(0);
  3420.     }
  3421.     var fnum = v.toString();
  3422.     if(hasComma){
  3423.         psplit = fnum.split('.');
  3424.         var cnum = psplit[0], parr = [], j = cnum.length, m = Math.floor(j / 3), n = cnum.length % 3 || 3;
  3425.         for(var i = 0; i < j; i += n){
  3426.             if(i != 0){
  3427.                 n = 3;
  3428.             }
  3429.             parr[parr.length] = cnum.substr(i, n);
  3430.             m -= 1;
  3431.         }
  3432.         fnum = parr.join(comma);
  3433.         if(psplit[1]){
  3434.             fnum += dec + psplit[1];
  3435.         }
  3436.     }
  3437.     return (neg ? '-' : '') + format.replace(/[d,?.?]+/, fnum);
  3438.         },
  3439.         
  3440.         numberRenderer : function(format){
  3441.             return function(v){
  3442.                 return Ext.util.Format.number(v, format);
  3443.             };
  3444.         },
  3445.         
  3446.         plural : function(v, s, p){
  3447.             return v +' ' + (v == 1 ? s : (p ? p : s+'s'));
  3448.         },
  3449.         
  3450.         
  3451.         nl2br : function(v){
  3452.             return Ext.isEmpty(v) ? '' : v.replace(nl2brRe, '<br/>');
  3453.         }
  3454.     }
  3455. }();
  3456. Ext.XTemplate = function(){
  3457.     Ext.XTemplate.superclass.constructor.apply(this, arguments);
  3458.     var me = this,
  3459.      s = me.html,
  3460.      re = /<tplb[^>]*>((?:(?=([^<]+))2|<(?!tplb[^>]*>))*?)</tpl>/,
  3461.      nameRe = /^<tplb[^>]*?for="(.*?)"/,
  3462.      ifRe = /^<tplb[^>]*?if="(.*?)"/,
  3463.      execRe = /^<tplb[^>]*?exec="(.*?)"/,
  3464.      m,
  3465.      id = 0,
  3466.      tpls = [],
  3467.      VALUES = 'values',
  3468.      PARENT = 'parent',
  3469.      XINDEX = 'xindex',
  3470.      XCOUNT = 'xcount',
  3471.      RETURN = 'return ',
  3472.      WITHVALUES = 'with(values){ ';
  3473.     s = ['<tpl>', s, '</tpl>'].join('');
  3474.     while((m = s.match(re))){
  3475.         var m2 = m[0].match(nameRe),
  3476. m3 = m[0].match(ifRe),
  3477.         m4 = m[0].match(execRe),
  3478.         exp = null,
  3479.         fn = null,
  3480.         exec = null,
  3481.         name = m2 && m2[1] ? m2[1] : '';
  3482.        if (m3) {
  3483.            exp = m3 && m3[1] ? m3[1] : null;
  3484.            if(exp){
  3485.                fn = new Function(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES + RETURN +(Ext.util.Format.htmlDecode(exp))+'; }');
  3486.            }
  3487.        }
  3488.        if (m4) {
  3489.            exp = m4 && m4[1] ? m4[1] : null;
  3490.            if(exp){
  3491.                exec = new Function(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES +(Ext.util.Format.htmlDecode(exp))+'; }');
  3492.            }
  3493.        }
  3494.        if(name){
  3495.            switch(name){
  3496.                case '.': name = new Function(VALUES, PARENT, WITHVALUES + RETURN + VALUES + '; }'); break;
  3497.                case '..': name = new Function(VALUES, PARENT, WITHVALUES + RETURN + PARENT + '; }'); break;
  3498.                default: name = new Function(VALUES, PARENT, WITHVALUES + RETURN + name + '; }');
  3499.            }
  3500.        }
  3501.        tpls.push({
  3502.             id: id,
  3503.             target: name,
  3504.             exec: exec,
  3505.             test: fn,
  3506.             body: m[1]||''
  3507.         });
  3508.        s = s.replace(m[0], '{xtpl'+ id + '}');
  3509.        ++id;
  3510.     }
  3511. Ext.each(tpls, function(t) {
  3512.         me.compileTpl(t);
  3513.     });
  3514.     me.master = tpls[tpls.length-1];
  3515.     me.tpls = tpls;
  3516. };
  3517. Ext.extend(Ext.XTemplate, Ext.Template, {
  3518.     
  3519.     re : /{([w-.#]+)(?::([w.]*)(?:((.*?)?))?)?(s?[+-*\]s?[d.+-*\()]+)?}/g,
  3520.     
  3521.     codeRe : /{[((?:\]|.|n)*?)]}/g,
  3522.     
  3523.     applySubTemplate : function(id, values, parent, xindex, xcount){
  3524.         var me = this,
  3525.          len,
  3526.          t = me.tpls[id],
  3527.          vs,
  3528.          buf = [];
  3529.         if ((t.test && !t.test.call(me, values, parent, xindex, xcount)) ||
  3530.             (t.exec && t.exec.call(me, values, parent, xindex, xcount))) {
  3531.             return '';
  3532.         }
  3533.         vs = t.target ? t.target.call(me, values, parent) : values;
  3534.         len = vs.length;
  3535.         parent = t.target ? values : parent;
  3536.         if(t.target && Ext.isArray(vs)){
  3537.         Ext.each(vs, function(v, i) {
  3538.                 buf[buf.length] = t.compiled.call(me, v, parent, i+1, len);
  3539.             });
  3540.             return buf.join('');
  3541.         }
  3542.         return t.compiled.call(me, vs, parent, xindex, xcount);
  3543.     },
  3544.     
  3545.     compileTpl : function(tpl){
  3546.         var fm = Ext.util.Format,
  3547.         useF = this.disableFormats !== true,
  3548.             sep = Ext.isGecko ? "+" : ",",
  3549.             body;
  3550.         function fn(m, name, format, args, math){
  3551.             if(name.substr(0, 4) == 'xtpl'){
  3552.                 return "'"+ sep +'this.applySubTemplate('+name.substr(4)+', values, parent, xindex, xcount)'+sep+"'";
  3553.             }
  3554.             var v;
  3555.             if(name === '.'){
  3556.                 v = 'values';
  3557.             }else if(name === '#'){
  3558.                 v = 'xindex';
  3559.             }else if(name.indexOf('.') != -1){
  3560.                 v = name;
  3561.             }else{
  3562.                 v = "values['" + name + "']";
  3563.             }
  3564.             if(math){
  3565.                 v = '(' + v + math + ')';
  3566.             }
  3567.             if (format && useF) {
  3568.                 args = args ? ',' + args : "";
  3569.                 if(format.substr(0, 5) != "this."){
  3570.                     format = "fm." + format + '(';
  3571.                 }else{
  3572.                     format = 'this.call("'+ format.substr(5) + '", ';
  3573.                     args = ", values";
  3574.                 }
  3575.             } else {
  3576.                 args= ''; format = "("+v+" === undefined ? '' : ";
  3577.             }
  3578.             return "'"+ sep + format + v + args + ")"+sep+"'";
  3579.         }
  3580.         function codeFn(m, code){
  3581.             
  3582.             return "'" + sep + '(' + code.replace(/\'/g, "'") + ')' + sep + "'";
  3583.         }
  3584.         
  3585.         if(Ext.isGecko){
  3586.             body = "tpl.compiled = function(values, parent, xindex, xcount){ return '" +
  3587.                    tpl.body.replace(/(rn|n)/g, '\n').replace(/'/g, "\'").replace(this.re, fn).replace(this.codeRe, codeFn) +
  3588.                     "';};";
  3589.         }else{
  3590.             body = ["tpl.compiled = function(values, parent, xindex, xcount){ return ['"];
  3591.             body.push(tpl.body.replace(/(rn|n)/g, '\n').replace(/'/g, "\'").replace(this.re, fn).replace(this.codeRe, codeFn));
  3592.             body.push("'].join('');};");
  3593.             body = body.join('');
  3594.         }
  3595.         eval(body);
  3596.         return this;
  3597.     },
  3598.     
  3599.     applyTemplate : function(values){
  3600.         return this.master.compiled.call(this, values, {}, 1, 1);
  3601.     },
  3602.     
  3603.     compile : function(){return this;}
  3604.     
  3605.     
  3606.     
  3607. });
  3608. Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate;
  3609. Ext.XTemplate.from = function(el){
  3610.     el = Ext.getDom(el);
  3611.     return new Ext.XTemplate(el.value || el.innerHTML);
  3612. };
  3613. Ext.util.CSS = function(){
  3614. var rules = null;
  3615.     var doc = document;
  3616.     var camelRe = /(-[a-z])/gi;
  3617.     var camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };
  3618.    return {
  3619.    
  3620.    createStyleSheet : function(cssText, id){
  3621.        var ss;
  3622.        var head = doc.getElementsByTagName("head")[0];
  3623.        var rules = doc.createElement("style");
  3624.        rules.setAttribute("type", "text/css");
  3625.        if(id){
  3626.            rules.setAttribute("id", id);
  3627.        }
  3628.        if(Ext.isIE){
  3629.            head.appendChild(rules);
  3630.            ss = rules.styleSheet;
  3631.            ss.cssText = cssText;
  3632.        }else{
  3633.            try{
  3634.                 rules.appendChild(doc.createTextNode(cssText));
  3635.            }catch(e){
  3636.                rules.cssText = cssText;
  3637.            }
  3638.            head.appendChild(rules);
  3639.            ss = rules.styleSheet ? rules.styleSheet : (rules.sheet || doc.styleSheets[doc.styleSheets.length-1]);
  3640.        }
  3641.        this.cacheStyleSheet(ss);
  3642.        return ss;
  3643.    },
  3644.    
  3645.    removeStyleSheet : function(id){
  3646.        var existing = doc.getElementById(id);
  3647.        if(existing){
  3648.            existing.parentNode.removeChild(existing);
  3649.        }
  3650.    },
  3651.    
  3652.    swapStyleSheet : function(id, url){
  3653.        this.removeStyleSheet(id);
  3654.        var ss = doc.createElement("link");
  3655.        ss.setAttribute("rel", "stylesheet");
  3656.        ss.setAttribute("type", "text/css");
  3657.        ss.setAttribute("id", id);
  3658.        ss.setAttribute("href", url);
  3659.        doc.getElementsByTagName("head")[0].appendChild(ss);
  3660.    },
  3661.    
  3662.    
  3663.    refreshCache : function(){
  3664.        return this.getRules(true);
  3665.    },
  3666.    
  3667.    cacheStyleSheet : function(ss){
  3668.        if(!rules){
  3669.            rules = {};
  3670.        }
  3671.        try{
  3672.            var ssRules = ss.cssRules || ss.rules;
  3673.            for(var j = ssRules.length-1; j >= 0; --j){
  3674.                rules[ssRules[j].selectorText.toLowerCase()] = ssRules[j];
  3675.            }
  3676.        }catch(e){}
  3677.    },
  3678.    
  3679.    
  3680.    getRules : function(refreshCache){
  3681.     if(rules === null || refreshCache){
  3682.     rules = {};
  3683.     var ds = doc.styleSheets;
  3684.     for(var i =0, len = ds.length; i < len; i++){
  3685.         try{
  3686.              this.cacheStyleSheet(ds[i]);
  3687.          }catch(e){} 
  3688.         }
  3689.     }
  3690.     return rules;
  3691.     },
  3692.    
  3693.    
  3694.    getRule : function(selector, refreshCache){
  3695.     var rs = this.getRules(refreshCache);
  3696.     if(!Ext.isArray(selector)){
  3697.         return rs[selector.toLowerCase()];
  3698.     }
  3699.     for(var i = 0; i < selector.length; i++){
  3700. if(rs[selector[i]]){
  3701. return rs[selector[i].toLowerCase()];
  3702. }
  3703. }
  3704. return null;
  3705.     },
  3706.    
  3707.    
  3708.    
  3709.    updateRule : function(selector, property, value){
  3710.     if(!Ext.isArray(selector)){
  3711.     var rule = this.getRule(selector);
  3712.     if(rule){
  3713.     rule.style[property.replace(camelRe, camelFn)] = value;
  3714.     return true;
  3715.     }
  3716.     }else{
  3717.     for(var i = 0; i < selector.length; i++){
  3718.     if(this.updateRule(selector[i], property, value)){
  3719.     return true;
  3720.     }
  3721.     }
  3722.     }
  3723.     return false;
  3724.     }
  3725.    };
  3726. }();
  3727. Ext.util.ClickRepeater = function(el, config)
  3728. {
  3729.     this.el = Ext.get(el);
  3730.     this.el.unselectable();
  3731.     Ext.apply(this, config);
  3732.     this.addEvents(
  3733.     
  3734.         "mousedown",
  3735.     
  3736.         "click",
  3737.     
  3738.         "mouseup"
  3739.     );
  3740.     if(!this.disabled){
  3741.         this.disabled = true;
  3742.         this.enable();
  3743.     }
  3744.     
  3745.     if(this.handler){
  3746.         this.on("click", this.handler,  this.scope || this);
  3747.     }
  3748.     Ext.util.ClickRepeater.superclass.constructor.call(this);
  3749. };
  3750. Ext.extend(Ext.util.ClickRepeater, Ext.util.Observable, {
  3751.     interval : 20,
  3752.     delay: 250,
  3753.     preventDefault : true,
  3754.     stopDefault : false,
  3755.     timer : 0,
  3756.     
  3757.     enable: function(){
  3758.         if(this.disabled){
  3759.             this.el.on('mousedown', this.handleMouseDown, this);
  3760.             if(this.preventDefault || this.stopDefault){
  3761.                 this.el.on('click', this.eventOptions, this);
  3762.             }
  3763.         }
  3764.         this.disabled = false;
  3765.     },
  3766.     
  3767.     
  3768.     disable: function( force){
  3769.         if(force || !this.disabled){
  3770.             clearTimeout(this.timer);
  3771.             if(this.pressClass){
  3772.                 this.el.removeClass(this.pressClass);
  3773.             }
  3774.             Ext.getDoc().un('mouseup', this.handleMouseUp, this);
  3775.             this.el.removeAllListeners();
  3776.         }
  3777.         this.disabled = true;
  3778.     },
  3779.     
  3780.     
  3781.     setDisabled: function(disabled){
  3782.         this[disabled ? 'disable' : 'enable']();    
  3783.     },
  3784.     
  3785.     eventOptions: function(e){
  3786.         if(this.preventDefault){
  3787.             e.preventDefault();
  3788.         }
  3789.         if(this.stopDefault){
  3790.             e.stopEvent();
  3791.         }       
  3792.     },
  3793.     
  3794.     
  3795.     destroy : function() {
  3796.         this.disable(true);
  3797.         Ext.destroy(this.el);
  3798.         this.purgeListeners();
  3799.     },
  3800.     
  3801.     
  3802.     handleMouseDown : function(){
  3803.         clearTimeout(this.timer);
  3804.         this.el.blur();
  3805.         if(this.pressClass){
  3806.             this.el.addClass(this.pressClass);
  3807.         }
  3808.         this.mousedownTime = new Date();
  3809.         Ext.getDoc().on("mouseup", this.handleMouseUp, this);
  3810.         this.el.on("mouseout", this.handleMouseOut, this);
  3811.         this.fireEvent("mousedown", this);
  3812.         this.fireEvent("click", this);
  3813.         if (this.accelerate) {
  3814.             this.delay = 400;
  3815.     }
  3816.         this.timer = this.click.defer(this.delay || this.interval, this);
  3817.     },
  3818.     
  3819.     click : function(){
  3820.         this.fireEvent("click", this);
  3821.         this.timer = this.click.defer(this.accelerate ?
  3822.             this.easeOutExpo(this.mousedownTime.getElapsed(),
  3823.                 400,
  3824.                 -390,
  3825.                 12000) :
  3826.             this.interval, this);
  3827.     },
  3828.     easeOutExpo : function (t, b, c, d) {
  3829.         return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
  3830.     },
  3831.     
  3832.     handleMouseOut : function(){
  3833.         clearTimeout(this.timer);
  3834.         if(this.pressClass){
  3835.             this.el.removeClass(this.pressClass);
  3836.         }
  3837.         this.el.on("mouseover", this.handleMouseReturn, this);
  3838.     },
  3839.     
  3840.     handleMouseReturn : function(){
  3841.         this.el.un("mouseover", this.handleMouseReturn, this);
  3842.         if(this.pressClass){
  3843.             this.el.addClass(this.pressClass);
  3844.         }
  3845.         this.click();
  3846.     },
  3847.     
  3848.     handleMouseUp : function(){
  3849.         clearTimeout(this.timer);
  3850.         this.el.un("mouseover", this.handleMouseReturn, this);
  3851.         this.el.un("mouseout", this.handleMouseOut, this);
  3852.         Ext.getDoc().un("mouseup", this.handleMouseUp, this);
  3853.         this.el.removeClass(this.pressClass);
  3854.         this.fireEvent("mouseup", this);
  3855.     }
  3856. });
  3857. Ext.KeyNav = function(el, config){
  3858.     this.el = Ext.get(el);
  3859.     Ext.apply(this, config);
  3860.     if(!this.disabled){
  3861.         this.disabled = true;
  3862.         this.enable();
  3863.     }
  3864. };
  3865. Ext.KeyNav.prototype = {
  3866.     
  3867.     disabled : false,
  3868.     
  3869.     defaultEventAction: "stopEvent",
  3870.     
  3871.     forceKeyDown : false,
  3872.     
  3873.     relay : function(e){
  3874.         var k = e.getKey();
  3875.         var h = this.keyToHandler[k];
  3876.         if(h && this[h]){
  3877.             if(this.doRelay(e, this[h], h) !== true){
  3878.                 e[this.defaultEventAction]();
  3879.             }
  3880.         }
  3881.     },
  3882.     
  3883.     doRelay : function(e, h, hname){
  3884.         return h.call(this.scope || this, e);
  3885.     },
  3886.     
  3887.     enter : false,
  3888.     left : false,
  3889.     right : false,
  3890.     up : false,
  3891.     down : false,
  3892.     tab : false,
  3893.     esc : false,
  3894.     pageUp : false,
  3895.     pageDown : false,
  3896.     del : false,
  3897.     home : false,
  3898.     end : false,
  3899.     
  3900.     keyToHandler : {
  3901.         37 : "left",
  3902.         39 : "right",
  3903.         38 : "up",
  3904.         40 : "down",
  3905.         33 : "pageUp",
  3906.         34 : "pageDown",
  3907.         46 : "del",
  3908.         36 : "home",
  3909.         35 : "end",
  3910.         13 : "enter",
  3911.         27 : "esc",
  3912.         9  : "tab"
  3913.     },
  3914.     
  3915.     stopKeyUp: function(e) {
  3916.         var k = e.getKey();
  3917.         if (k >= 37 && k <= 40) {
  3918.             
  3919.             
  3920.             e.stopEvent();
  3921.         }
  3922.     },
  3923.     
  3924.     
  3925.     destroy: function(){
  3926.         this.disable();    
  3927.     },
  3928. enable: function() {
  3929.         if (this.disabled) {
  3930.             if (Ext.isSafari2) {
  3931.                 
  3932.                 this.el.on('keyup', this.stopKeyUp, this);
  3933.             }
  3934.             this.el.on(this.isKeydown()? 'keydown' : 'keypress', this.relay, this);
  3935.             this.disabled = false;
  3936.         }
  3937.     },
  3938. disable: function() {
  3939.         if (!this.disabled) {
  3940.             if (Ext.isSafari2) {
  3941.                 
  3942.                 this.el.un('keyup', this.stopKeyUp, this);
  3943.             }
  3944.             this.el.un(this.isKeydown()? 'keydown' : 'keypress', this.relay, this);
  3945.             this.disabled = true;
  3946.         }
  3947.     },
  3948.     
  3949.     
  3950.     setDisabled : function(disabled){
  3951.         this[disabled ? "disable" : "enable"]();
  3952.     },
  3953.     
  3954.     
  3955.     isKeydown: function(){
  3956.         return this.forceKeyDown || Ext.EventManager.useKeydown;
  3957.     }
  3958. };
  3959. Ext.KeyMap = function(el, config, eventName){
  3960.     this.el  = Ext.get(el);
  3961.     this.eventName = eventName || "keydown";
  3962.     this.bindings = [];
  3963.     if(config){
  3964.         this.addBinding(config);
  3965.     }
  3966.     this.enable();
  3967. };
  3968. Ext.KeyMap.prototype = {
  3969.     
  3970.     stopEvent : false,
  3971.     
  3972. addBinding : function(config){
  3973.         if(Ext.isArray(config)){
  3974.             Ext.each(config, function(c){
  3975.                 this.addBinding(c);
  3976.             }, this);
  3977.             return;
  3978.         }
  3979.         var keyCode = config.key,
  3980.             fn = config.fn || config.handler,
  3981.             scope = config.scope;
  3982. if (config.stopEvent) {
  3983.     this.stopEvent = config.stopEvent;    
  3984. }
  3985.         if(typeof keyCode == "string"){
  3986.             var ks = [];
  3987.             var keyString = keyCode.toUpperCase();
  3988.             for(var j = 0, len = keyString.length; j < len; j++){
  3989.                 ks.push(keyString.charCodeAt(j));
  3990.             }
  3991.             keyCode = ks;
  3992.         }
  3993.         var keyArray = Ext.isArray(keyCode);
  3994.         
  3995.         var handler = function(e){
  3996.             if(this.checkModifiers(config, e)){
  3997.                 var k = e.getKey();
  3998.                 if(keyArray){
  3999.                     for(var i = 0, len = keyCode.length; i < len; i++){
  4000.                         if(keyCode[i] == k){
  4001.                           if(this.stopEvent){
  4002.                               e.stopEvent();
  4003.                           }
  4004.                           fn.call(scope || window, k, e);
  4005.                           return;
  4006.                         }
  4007.                     }
  4008.                 }else{
  4009.                     if(k == keyCode){
  4010.                         if(this.stopEvent){
  4011.                            e.stopEvent();
  4012.                         }
  4013.                         fn.call(scope || window, k, e);
  4014.                     }
  4015.                 }
  4016.             }
  4017.         };
  4018.         this.bindings.push(handler);
  4019. },
  4020.     
  4021.     
  4022.     checkModifiers: function(config, e){
  4023.         var val, key, keys = ['shift', 'ctrl', 'alt'];
  4024.         for (var i = 0, len = keys.length; i < len; ++i){
  4025.             key = keys[i];
  4026.             val = config[key];
  4027.             if(!(val === undefined || (val === e[key + 'Key']))){
  4028.                 return false;
  4029.             }
  4030.         }
  4031.         return true;
  4032.     },
  4033.     
  4034.     on : function(key, fn, scope){
  4035.         var keyCode, shift, ctrl, alt;
  4036.         if(typeof key == "object" && !Ext.isArray(key)){
  4037.             keyCode = key.key;
  4038.             shift = key.shift;
  4039.             ctrl = key.ctrl;
  4040.             alt = key.alt;
  4041.         }else{
  4042.             keyCode = key;
  4043.         }
  4044.         this.addBinding({
  4045.             key: keyCode,
  4046.             shift: shift,
  4047.             ctrl: ctrl,
  4048.             alt: alt,
  4049.             fn: fn,
  4050.             scope: scope
  4051.         });
  4052.     },
  4053.     
  4054.     handleKeyDown : function(e){
  4055.     if(this.enabled){ 
  4056.          var b = this.bindings;
  4057.          for(var i = 0, len = b.length; i < len; i++){
  4058.              b[i].call(this, e);
  4059.          }
  4060.     }
  4061. },
  4062. isEnabled : function(){
  4063.     return this.enabled;
  4064. },
  4065. enable: function(){
  4066. if(!this.enabled){
  4067.     this.el.on(this.eventName, this.handleKeyDown, this);
  4068.     this.enabled = true;
  4069. }
  4070. },
  4071. disable: function(){
  4072. if(this.enabled){
  4073.     this.el.removeListener(this.eventName, this.handleKeyDown, this);
  4074.     this.enabled = false;
  4075. }
  4076. },
  4077.     
  4078.     
  4079.     setDisabled : function(disabled){
  4080.         this[disabled ? "disable" : "enable"]();
  4081.     }
  4082. };
  4083. Ext.util.TextMetrics = function(){
  4084.     var shared;
  4085.     return {
  4086.         
  4087.         measure : function(el, text, fixedWidth){
  4088.             if(!shared){
  4089.                 shared = Ext.util.TextMetrics.Instance(el, fixedWidth);
  4090.             }
  4091.             shared.bind(el);
  4092.             shared.setFixedWidth(fixedWidth || 'auto');
  4093.             return shared.getSize(text);
  4094.         },
  4095.         
  4096.         createInstance : function(el, fixedWidth){