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

JavaScript

开发平台:

JavaScript

  1.         );
  2.     },
  3.     
  4.     collapse : function(){
  5.         this.updateExpandIcon();
  6.         this.ctNode.style.display = "none";
  7.     },
  8.     
  9.     animCollapse : function(callback){
  10.         var ct = Ext.get(this.ctNode);
  11.         ct.enableDisplayMode('block');
  12.         ct.stopFx();
  13.         this.animating = true;
  14.         this.updateExpandIcon();
  15.         ct.slideOut('t', {
  16.             callback : function(){
  17.                this.animating = false;
  18.                Ext.callback(callback);
  19.             },
  20.             scope: this,
  21.             duration: this.node.ownerTree.duration || .25
  22.         });
  23.     },
  24.     
  25.     getContainer : function(){
  26.         return this.ctNode;  
  27.     },
  28.     getEl : function(){
  29.         return this.wrap;  
  30.     },
  31.     
  32.     appendDDGhost : function(ghostNode){
  33.         ghostNode.appendChild(this.elNode.cloneNode(true));
  34.     },
  35.     
  36.     getDDRepairXY : function(){
  37.         return Ext.lib.Dom.getXY(this.iconNode);
  38.     },
  39.     
  40.     onRender : function(){
  41.         this.render();    
  42.     },
  43.     
  44.     render : function(bulkRender){
  45.         var n = this.node, a = n.attributes;
  46.         var targetNode = n.parentNode ? 
  47.               n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom;
  48.         
  49.         if(!this.rendered){
  50.             this.rendered = true;
  51.             this.renderElements(n, a, targetNode, bulkRender);
  52.             if(a.qtip){
  53.                if(this.textNode.setAttributeNS){
  54.                    this.textNode.setAttributeNS("ext", "qtip", a.qtip);
  55.                    if(a.qtipTitle){
  56.                        this.textNode.setAttributeNS("ext", "qtitle", a.qtipTitle);
  57.                    }
  58.                }else{
  59.                    this.textNode.setAttribute("ext:qtip", a.qtip);
  60.                    if(a.qtipTitle){
  61.                        this.textNode.setAttribute("ext:qtitle", a.qtipTitle);
  62.                    }
  63.                } 
  64.             }else if(a.qtipCfg){
  65.                 a.qtipCfg.target = Ext.id(this.textNode);
  66.                 Ext.QuickTips.register(a.qtipCfg);
  67.             }
  68.             this.initEvents();
  69.             if(!this.node.expanded){
  70.                 this.updateExpandIcon(true);
  71.             }
  72.         }else{
  73.             if(bulkRender === true) {
  74.                 targetNode.appendChild(this.wrap);
  75.             }
  76.         }
  77.     },
  78.     
  79.     renderElements : function(n, a, targetNode, bulkRender){
  80.         
  81.         this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : '';
  82.         var cb = Ext.isBoolean(a.checked),
  83.             nel,
  84.             href = a.href ? a.href : Ext.isGecko ? "" : "#",
  85.             buf = ['<li class="x-tree-node"><div ext:tree-node-id="',n.id,'" class="x-tree-node-el x-tree-node-leaf x-unselectable ', a.cls,'" unselectable="on">',
  86.             '<span class="x-tree-node-indent">',this.indentMarkup,"</span>",
  87.             '<img src="', this.emptyIcon, '" class="x-tree-ec-icon x-tree-elbow" />',
  88.             '<img src="', a.icon || this.emptyIcon, '" class="x-tree-node-icon',(a.icon ? " x-tree-node-inline-icon" : ""),(a.iconCls ? " "+a.iconCls : ""),'" unselectable="on" />',
  89.             cb ? ('<input class="x-tree-node-cb" type="checkbox" ' + (a.checked ? 'checked="checked" />' : '/>')) : '',
  90.             '<a hidefocus="on" class="x-tree-node-anchor" href="',href,'" tabIndex="1" ',
  91.              a.hrefTarget ? ' target="'+a.hrefTarget+'"' : "", '><span unselectable="on">',n.text,"</span></a></div>",
  92.             '<ul class="x-tree-node-ct" style="display:none;"></ul>',
  93.             "</li>"].join('');
  94.         if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){
  95.             this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf);
  96.         }else{
  97.             this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf);
  98.         }
  99.         
  100.         this.elNode = this.wrap.childNodes[0];
  101.         this.ctNode = this.wrap.childNodes[1];
  102.         var cs = this.elNode.childNodes;
  103.         this.indentNode = cs[0];
  104.         this.ecNode = cs[1];
  105.         this.iconNode = cs[2];
  106.         var index = 3;
  107.         if(cb){
  108.             this.checkbox = cs[3];
  109.             
  110.             this.checkbox.defaultChecked = this.checkbox.checked;
  111.             index++;
  112.         }
  113.         this.anchor = cs[index];
  114.         this.textNode = cs[index].firstChild;
  115.     },
  116.     getAnchor : function(){
  117.         return this.anchor;
  118.     },
  119.     
  120.     getTextEl : function(){
  121.         return this.textNode;
  122.     },
  123.     
  124.     getIconEl : function(){
  125.         return this.iconNode;
  126.     },
  127.     isChecked : function(){
  128.         return this.checkbox ? this.checkbox.checked : false; 
  129.     },
  130.     
  131.     updateExpandIcon : function(){
  132.         if(this.rendered){
  133.             var n = this.node, 
  134.                 c1, 
  135.                 c2,
  136.                 cls = n.isLast() ? "x-tree-elbow-end" : "x-tree-elbow",
  137.                 hasChild = n.hasChildNodes();
  138.             if(hasChild || n.attributes.expandable){
  139.                 if(n.expanded){
  140.                     cls += "-minus";
  141.                     c1 = "x-tree-node-collapsed";
  142.                     c2 = "x-tree-node-expanded";
  143.                 }else{
  144.                     cls += "-plus";
  145.                     c1 = "x-tree-node-expanded";
  146.                     c2 = "x-tree-node-collapsed";
  147.                 }
  148.                 if(this.wasLeaf){
  149.                     this.removeClass("x-tree-node-leaf");
  150.                     this.wasLeaf = false;
  151.                 }
  152.                 if(this.c1 != c1 || this.c2 != c2){
  153.                     Ext.fly(this.elNode).replaceClass(c1, c2);
  154.                     this.c1 = c1; this.c2 = c2;
  155.                 }
  156.             }else{
  157.                 if(!this.wasLeaf){
  158.                     Ext.fly(this.elNode).replaceClass("x-tree-node-expanded", "x-tree-node-leaf");
  159.                     delete this.c1;
  160.                     delete this.c2;
  161.                     this.wasLeaf = true;
  162.                 }
  163.             }
  164.             var ecc = "x-tree-ec-icon "+cls;
  165.             if(this.ecc != ecc){
  166.                 this.ecNode.className = ecc;
  167.                 this.ecc = ecc;
  168.             }
  169.         }
  170.     },
  171.     
  172.     
  173.     onIdChange: function(id){
  174.         if(this.rendered){
  175.             this.elNode.setAttribute('ext:tree-node-id', id);
  176.         }
  177.     },
  178.     
  179.     getChildIndent : function(){
  180.         if(!this.childIndent){
  181.             var buf = [],
  182.                 p = this.node;
  183.             while(p){
  184.                 if(!p.isRoot || (p.isRoot && p.ownerTree.rootVisible)){
  185.                     if(!p.isLast()) {
  186.                         buf.unshift('<img src="'+this.emptyIcon+'" class="x-tree-elbow-line" />');
  187.                     } else {
  188.                         buf.unshift('<img src="'+this.emptyIcon+'" class="x-tree-icon" />');
  189.                     }
  190.                 }
  191.                 p = p.parentNode;
  192.             }
  193.             this.childIndent = buf.join("");
  194.         }
  195.         return this.childIndent;
  196.     },
  197.     
  198.     renderIndent : function(){
  199.         if(this.rendered){
  200.             var indent = "",
  201.                 p = this.node.parentNode;
  202.             if(p){
  203.                 indent = p.ui.getChildIndent();
  204.             }
  205.             if(this.indentMarkup != indent){ 
  206.                 this.indentNode.innerHTML = indent;
  207.                 this.indentMarkup = indent;
  208.             }
  209.             this.updateExpandIcon();
  210.         }
  211.     },
  212.     destroy : function(){
  213.         if(this.elNode){
  214.             Ext.dd.Registry.unregister(this.elNode.id);
  215.         }
  216.         
  217.         Ext.each(['textnode', 'anchor', 'checkbox', 'indentNode', 'ecNode', 'iconNode', 'elNode', 'ctNode', 'wrap', 'holder'], function(el){
  218.             if(this[el]){
  219.                 Ext.fly(this[el]).remove();
  220.                 delete this[el];
  221.             }
  222.         }, this);
  223.         delete this.node;
  224.     }
  225. };
  226. Ext.tree.RootTreeNodeUI = Ext.extend(Ext.tree.TreeNodeUI, {
  227.     
  228.     render : function(){
  229.         if(!this.rendered){
  230.             var targetNode = this.node.ownerTree.innerCt.dom;
  231.             this.node.expanded = true;
  232.             targetNode.innerHTML = '<div class="x-tree-root-node"></div>';
  233.             this.wrap = this.ctNode = targetNode.firstChild;
  234.         }
  235.     },
  236.     collapse : Ext.emptyFn,
  237.     expand : Ext.emptyFn
  238. });
  239. Ext.tree.TreeLoader = function(config){
  240.     this.baseParams = {};
  241.     Ext.apply(this, config);
  242.     this.addEvents(
  243.         
  244.         "beforeload",
  245.         
  246.         "load",
  247.         
  248.         "loadexception"
  249.     );
  250.     Ext.tree.TreeLoader.superclass.constructor.call(this);
  251.     if(Ext.isString(this.paramOrder)){
  252.         this.paramOrder = this.paramOrder.split(/[s,|]/);
  253.     }
  254. };
  255. Ext.extend(Ext.tree.TreeLoader, Ext.util.Observable, {
  256.     
  257.     
  258.     
  259.     
  260.     
  261.     
  262.     
  263.     uiProviders : {},
  264.     
  265.     clearOnLoad : true,
  266.     
  267.     paramOrder: undefined,
  268.     
  269.     paramsAsHash: false,
  270.     
  271.     
  272.     nodeParameter: 'node',
  273.     
  274.     directFn : undefined,
  275.     
  276.     load : function(node, callback, scope){
  277.         if(this.clearOnLoad){
  278.             while(node.firstChild){
  279.                 node.removeChild(node.firstChild);
  280.             }
  281.         }
  282.         if(this.doPreload(node)){ 
  283.             this.runCallback(callback, scope || node, [node]);
  284.         }else if(this.directFn || this.dataUrl || this.url){
  285.             this.requestData(node, callback, scope || node);
  286.         }
  287.     },
  288.     doPreload : function(node){
  289.         if(node.attributes.children){
  290.             if(node.childNodes.length < 1){ 
  291.                 var cs = node.attributes.children;
  292.                 node.beginUpdate();
  293.                 for(var i = 0, len = cs.length; i < len; i++){
  294.                     var cn = node.appendChild(this.createNode(cs[i]));
  295.                     if(this.preloadChildren){
  296.                         this.doPreload(cn);
  297.                     }
  298.                 }
  299.                 node.endUpdate();
  300.             }
  301.             return true;
  302.         }
  303.         return false;
  304.     },
  305.     getParams: function(node){
  306.         var buf = [], bp = this.baseParams;
  307.         if(this.directFn){
  308.             buf.push(node.id);
  309.             if(bp){
  310.                 if(this.paramOrder){
  311.                     for(var i = 0, len = this.paramOrder.length; i < len; i++){
  312.                         buf.push(bp[this.paramOrder[i]]);
  313.                     }
  314.                 }else if(this.paramsAsHash){
  315.                     buf.push(bp);
  316.                 }
  317.             }
  318.             return buf;
  319.         }else{
  320.             var o = Ext.apply({}, bp);
  321.             o[this.nodeParameter] = node.id;
  322.             return o;
  323.         }
  324.     },
  325.     requestData : function(node, callback, scope){
  326.         if(this.fireEvent("beforeload", this, node, callback) !== false){
  327.             if(this.directFn){
  328.                 var args = this.getParams(node);
  329.                 args.push(this.processDirectResponse.createDelegate(this, [{callback: callback, node: node, scope: scope}], true));
  330.                 this.directFn.apply(window, args);
  331.             }else{
  332.                 this.transId = Ext.Ajax.request({
  333.                     method:this.requestMethod,
  334.                     url: this.dataUrl||this.url,
  335.                     success: this.handleResponse,
  336.                     failure: this.handleFailure,
  337.                     scope: this,
  338.                     argument: {callback: callback, node: node, scope: scope},
  339.                     params: this.getParams(node)
  340.                 });
  341.             }
  342.         }else{
  343.             
  344.             
  345.             this.runCallback(callback, scope || node, []);
  346.         }
  347.     },
  348.     processDirectResponse: function(result, response, args){
  349.         if(response.status){
  350.             this.handleResponse({
  351.                 responseData: Ext.isArray(result) ? result : null,
  352.                 responseText: result,
  353.                 argument: args
  354.             });
  355.         }else{
  356.             this.handleFailure({
  357.                 argument: args
  358.             });
  359.         }
  360.     },
  361.     
  362.     runCallback: function(cb, scope, args){
  363.         if(Ext.isFunction(cb)){
  364.             cb.apply(scope, args);
  365.         }
  366.     },
  367.     isLoading : function(){
  368.         return !!this.transId;
  369.     },
  370.     abort : function(){
  371.         if(this.isLoading()){
  372.             Ext.Ajax.abort(this.transId);
  373.         }
  374.     },
  375.     
  376.     createNode : function(attr){
  377.         
  378.         if(this.baseAttrs){
  379.             Ext.applyIf(attr, this.baseAttrs);
  380.         }
  381.         if(this.applyLoader !== false && !attr.loader){
  382.             attr.loader = this;
  383.         }
  384.         if(Ext.isString(attr.uiProvider)){
  385.            attr.uiProvider = this.uiProviders[attr.uiProvider] || eval(attr.uiProvider);
  386.         }
  387.         if(attr.nodeType){
  388.             return new Ext.tree.TreePanel.nodeTypes[attr.nodeType](attr);
  389.         }else{
  390.             return attr.leaf ?
  391.                         new Ext.tree.TreeNode(attr) :
  392.                         new Ext.tree.AsyncTreeNode(attr);
  393.         }
  394.     },
  395.     processResponse : function(response, node, callback, scope){
  396.         var json = response.responseText;
  397.         try {
  398.             var o = response.responseData || Ext.decode(json);
  399.             node.beginUpdate();
  400.             for(var i = 0, len = o.length; i < len; i++){
  401.                 var n = this.createNode(o[i]);
  402.                 if(n){
  403.                     node.appendChild(n);
  404.                 }
  405.             }
  406.             node.endUpdate();
  407.             this.runCallback(callback, scope || node, [node]);
  408.         }catch(e){
  409.             this.handleFailure(response);
  410.         }
  411.     },
  412.     handleResponse : function(response){
  413.         this.transId = false;
  414.         var a = response.argument;
  415.         this.processResponse(response, a.node, a.callback, a.scope);
  416.         this.fireEvent("load", this, a.node, response);
  417.     },
  418.     handleFailure : function(response){
  419.         this.transId = false;
  420.         var a = response.argument;
  421.         this.fireEvent("loadexception", this, a.node, response);
  422.         this.runCallback(a.callback, a.scope || a.node, [a.node]);
  423.     },
  424.     
  425.     destroy : function(){
  426.         this.purgeListeners();
  427.     }
  428. });
  429. Ext.tree.TreeFilter = function(tree, config){
  430.     this.tree = tree;
  431.     this.filtered = {};
  432.     Ext.apply(this, config);
  433. };
  434. Ext.tree.TreeFilter.prototype = {
  435.     clearBlank:false,
  436.     reverse:false,
  437.     autoClear:false,
  438.     remove:false,
  439.      
  440.     filter : function(value, attr, startNode){
  441.         attr = attr || "text";
  442.         var f;
  443.         if(typeof value == "string"){
  444.             var vlen = value.length;
  445.             
  446.             if(vlen == 0 && this.clearBlank){
  447.                 this.clear();
  448.                 return;
  449.             }
  450.             value = value.toLowerCase();
  451.             f = function(n){
  452.                 return n.attributes[attr].substr(0, vlen).toLowerCase() == value;
  453.             };
  454.         }else if(value.exec){ 
  455.             f = function(n){
  456.                 return value.test(n.attributes[attr]);
  457.             };
  458.         }else{
  459.             throw 'Illegal filter type, must be string or regex';
  460.         }
  461.         this.filterBy(f, null, startNode);
  462. },
  463.     
  464.     filterBy : function(fn, scope, startNode){
  465.         startNode = startNode || this.tree.root;
  466.         if(this.autoClear){
  467.             this.clear();
  468.         }
  469.         var af = this.filtered, rv = this.reverse;
  470.         var f = function(n){
  471.             if(n == startNode){
  472.                 return true;
  473.             }
  474.             if(af[n.id]){
  475.                 return false;
  476.             }
  477.             var m = fn.call(scope || n, n);
  478.             if(!m || rv){
  479.                 af[n.id] = n;
  480.                 n.ui.hide();
  481.                 return false;
  482.             }
  483.             return true;
  484.         };
  485.         startNode.cascade(f);
  486.         if(this.remove){
  487.            for(var id in af){
  488.                if(typeof id != "function"){
  489.                    var n = af[id];
  490.                    if(n && n.parentNode){
  491.                        n.parentNode.removeChild(n);
  492.                    }
  493.                }
  494.            }
  495.         }
  496.     },
  497.     
  498.     clear : function(){
  499.         var t = this.tree;
  500.         var af = this.filtered;
  501.         for(var id in af){
  502.             if(typeof id != "function"){
  503.                 var n = af[id];
  504.                 if(n){
  505.                     n.ui.show();
  506.                 }
  507.             }
  508.         }
  509.         this.filtered = {};
  510.     }
  511. };
  512. Ext.tree.TreeSorter = function(tree, config){
  513.     
  514.     
  515.     
  516.     
  517.     
  518.     
  519.     
  520.     Ext.apply(this, config);
  521.     tree.on("beforechildrenrendered", this.doSort, this);
  522.     tree.on("append", this.updateSort, this);
  523.     tree.on("insert", this.updateSort, this);
  524.     tree.on("textchange", this.updateSortParent, this);
  525.     
  526.     var dsc = this.dir && this.dir.toLowerCase() == "desc";
  527.     var p = this.property || "text";
  528.     var sortType = this.sortType;
  529.     var fs = this.folderSort;
  530.     var cs = this.caseSensitive === true;
  531.     var leafAttr = this.leafAttr || 'leaf';
  532.     this.sortFn = function(n1, n2){
  533.         if(fs){
  534.             if(n1.attributes[leafAttr] && !n2.attributes[leafAttr]){
  535.                 return 1;
  536.             }
  537.             if(!n1.attributes[leafAttr] && n2.attributes[leafAttr]){
  538.                 return -1;
  539.             }
  540.         }
  541.      var v1 = sortType ? sortType(n1.attributes[p]) : (cs ? n1.attributes[p] : n1.attributes[p].toUpperCase());
  542.      var v2 = sortType ? sortType(n2.attributes[p]) : (cs ? n2.attributes[p] : n2.attributes[p].toUpperCase());
  543.      if(v1 < v2){
  544. return dsc ? +1 : -1;
  545. }else if(v1 > v2){
  546. return dsc ? -1 : +1;
  547.         }else{
  548.      return 0;
  549.         }
  550.     };
  551. };
  552. Ext.tree.TreeSorter.prototype = {
  553.     doSort : function(node){
  554.         node.sort(this.sortFn);
  555.     },
  556.     
  557.     compareNodes : function(n1, n2){
  558.         return (n1.text.toUpperCase() > n2.text.toUpperCase() ? 1 : -1);
  559.     },
  560.     
  561.     updateSort : function(tree, node){
  562.         if(node.childrenRendered){
  563.             this.doSort.defer(1, this, [node]);
  564.         }
  565.     },
  566.     
  567.     updateSortParent : function(node){
  568. var p = node.parentNode;
  569. if(p && p.childrenRendered){
  570.             this.doSort.defer(1, this, [p]);
  571.         }
  572.     }
  573. };
  574. if(Ext.dd.DropZone){
  575.     
  576. Ext.tree.TreeDropZone = function(tree, config){
  577.     
  578.     this.allowParentInsert = config.allowParentInsert || false;
  579.     
  580.     this.allowContainerDrop = config.allowContainerDrop || false;
  581.     
  582.     this.appendOnly = config.appendOnly || false;
  583.     Ext.tree.TreeDropZone.superclass.constructor.call(this, tree.getTreeEl(), config);
  584.     
  585.     this.tree = tree;
  586.     
  587.     this.dragOverData = {};
  588.     
  589.     this.lastInsertClass = "x-tree-no-status";
  590. };
  591. Ext.extend(Ext.tree.TreeDropZone, Ext.dd.DropZone, {
  592.     
  593.     ddGroup : "TreeDD",
  594.     
  595.     expandDelay : 1000,
  596.     
  597.     expandNode : function(node){
  598.         if(node.hasChildNodes() && !node.isExpanded()){
  599.             node.expand(false, null, this.triggerCacheRefresh.createDelegate(this));
  600.         }
  601.     },
  602.     
  603.     queueExpand : function(node){
  604.         this.expandProcId = this.expandNode.defer(this.expandDelay, this, [node]);
  605.     },
  606.     
  607.     cancelExpand : function(){
  608.         if(this.expandProcId){
  609.             clearTimeout(this.expandProcId);
  610.             this.expandProcId = false;
  611.         }
  612.     },
  613.     
  614.     isValidDropPoint : function(n, pt, dd, e, data){
  615.         if(!n || !data){ return false; }
  616.         var targetNode = n.node;
  617.         var dropNode = data.node;
  618.         
  619.         if(!(targetNode && targetNode.isTarget && pt)){
  620.             return false;
  621.         }
  622.         if(pt == "append" && targetNode.allowChildren === false){
  623.             return false;
  624.         }
  625.         if((pt == "above" || pt == "below") && (targetNode.parentNode && targetNode.parentNode.allowChildren === false)){
  626.             return false;
  627.         }
  628.         if(dropNode && (targetNode == dropNode || dropNode.contains(targetNode))){
  629.             return false;
  630.         }
  631.         
  632.         var overEvent = this.dragOverData;
  633.         overEvent.tree = this.tree;
  634.         overEvent.target = targetNode;
  635.         overEvent.data = data;
  636.         overEvent.point = pt;
  637.         overEvent.source = dd;
  638.         overEvent.rawEvent = e;
  639.         overEvent.dropNode = dropNode;
  640.         overEvent.cancel = false;  
  641.         var result = this.tree.fireEvent("nodedragover", overEvent);
  642.         return overEvent.cancel === false && result !== false;
  643.     },
  644.     
  645.     getDropPoint : function(e, n, dd){
  646.         var tn = n.node;
  647.         if(tn.isRoot){
  648.             return tn.allowChildren !== false ? "append" : false; 
  649.         }
  650.         var dragEl = n.ddel;
  651.         var t = Ext.lib.Dom.getY(dragEl), b = t + dragEl.offsetHeight;
  652.         var y = Ext.lib.Event.getPageY(e);
  653.         var noAppend = tn.allowChildren === false || tn.isLeaf();
  654.         if(this.appendOnly || tn.parentNode.allowChildren === false){
  655.             return noAppend ? false : "append";
  656.         }
  657.         var noBelow = false;
  658.         if(!this.allowParentInsert){
  659.             noBelow = tn.hasChildNodes() && tn.isExpanded();
  660.         }
  661.         var q = (b - t) / (noAppend ? 2 : 3);
  662.         if(y >= t && y < (t + q)){
  663.             return "above";
  664.         }else if(!noBelow && (noAppend || y >= b-q && y <= b)){
  665.             return "below";
  666.         }else{
  667.             return "append";
  668.         }
  669.     },
  670.     
  671.     onNodeEnter : function(n, dd, e, data){
  672.         this.cancelExpand();
  673.     },
  674.     
  675.     onContainerOver : function(dd, e, data) {
  676.         if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) {
  677.             return this.dropAllowed;
  678.         }
  679.         return this.dropNotAllowed;
  680.     },
  681.     
  682.     onNodeOver : function(n, dd, e, data){
  683.         var pt = this.getDropPoint(e, n, dd);
  684.         var node = n.node;
  685.         
  686.         
  687.         if(!this.expandProcId && pt == "append" && node.hasChildNodes() && !n.node.isExpanded()){
  688.             this.queueExpand(node);
  689.         }else if(pt != "append"){
  690.             this.cancelExpand();
  691.         }
  692.         
  693.         
  694.         var returnCls = this.dropNotAllowed;
  695.         if(this.isValidDropPoint(n, pt, dd, e, data)){
  696.            if(pt){
  697.                var el = n.ddel;
  698.                var cls;
  699.                if(pt == "above"){
  700.                    returnCls = n.node.isFirst() ? "x-tree-drop-ok-above" : "x-tree-drop-ok-between";
  701.                    cls = "x-tree-drag-insert-above";
  702.                }else if(pt == "below"){
  703.                    returnCls = n.node.isLast() ? "x-tree-drop-ok-below" : "x-tree-drop-ok-between";
  704.                    cls = "x-tree-drag-insert-below";
  705.                }else{
  706.                    returnCls = "x-tree-drop-ok-append";
  707.                    cls = "x-tree-drag-append";
  708.                }
  709.                if(this.lastInsertClass != cls){
  710.                    Ext.fly(el).replaceClass(this.lastInsertClass, cls);
  711.                    this.lastInsertClass = cls;
  712.                }
  713.            }
  714.        }
  715.        return returnCls;
  716.     },
  717.     
  718.     onNodeOut : function(n, dd, e, data){
  719.         this.cancelExpand();
  720.         this.removeDropIndicators(n);
  721.     },
  722.     
  723.     onNodeDrop : function(n, dd, e, data){
  724.         var point = this.getDropPoint(e, n, dd);
  725.         var targetNode = n.node;
  726.         targetNode.ui.startDrop();
  727.         if(!this.isValidDropPoint(n, point, dd, e, data)){
  728.             targetNode.ui.endDrop();
  729.             return false;
  730.         }
  731.         
  732.         var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, point, e) : null);
  733.         return this.processDrop(targetNode, data, point, dd, e, dropNode);
  734.     },
  735.     
  736.     onContainerDrop : function(dd, e, data){
  737.         if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) {
  738.             var targetNode = this.tree.getRootNode();       
  739.             targetNode.ui.startDrop();
  740.             var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, 'append', e) : null);
  741.             return this.processDrop(targetNode, data, 'append', dd, e, dropNode);
  742.         }
  743.         return false;
  744.     },
  745.     
  746.     
  747.     processDrop: function(target, data, point, dd, e, dropNode){
  748.         var dropEvent = {
  749.             tree : this.tree,
  750.             target: target,
  751.             data: data,
  752.             point: point,
  753.             source: dd,
  754.             rawEvent: e,
  755.             dropNode: dropNode,
  756.             cancel: !dropNode,
  757.             dropStatus: false
  758.         };
  759.         var retval = this.tree.fireEvent("beforenodedrop", dropEvent);
  760.         if(retval === false || dropEvent.cancel === true || !dropEvent.dropNode){
  761.             target.ui.endDrop();
  762.             return dropEvent.dropStatus;
  763.         }
  764.     
  765.         target = dropEvent.target;
  766.         if(point == 'append' && !target.isExpanded()){
  767.             target.expand(false, null, function(){
  768.                 this.completeDrop(dropEvent);
  769.             }.createDelegate(this));
  770.         }else{
  771.             this.completeDrop(dropEvent);
  772.         }
  773.         return true;
  774.     },
  775.     
  776.     completeDrop : function(de){
  777.         var ns = de.dropNode, p = de.point, t = de.target;
  778.         if(!Ext.isArray(ns)){
  779.             ns = [ns];
  780.         }
  781.         var n;
  782.         for(var i = 0, len = ns.length; i < len; i++){
  783.             n = ns[i];
  784.             if(p == "above"){
  785.                 t.parentNode.insertBefore(n, t);
  786.             }else if(p == "below"){
  787.                 t.parentNode.insertBefore(n, t.nextSibling);
  788.             }else{
  789.                 t.appendChild(n);
  790.             }
  791.         }
  792.         n.ui.focus();
  793.         if(Ext.enableFx && this.tree.hlDrop){
  794.             n.ui.highlight();
  795.         }
  796.         t.ui.endDrop();
  797.         this.tree.fireEvent("nodedrop", de);
  798.     },
  799.     
  800.     afterNodeMoved : function(dd, data, e, targetNode, dropNode){
  801.         if(Ext.enableFx && this.tree.hlDrop){
  802.             dropNode.ui.focus();
  803.             dropNode.ui.highlight();
  804.         }
  805.         this.tree.fireEvent("nodedrop", this.tree, targetNode, data, dd, e);
  806.     },
  807.     
  808.     getTree : function(){
  809.         return this.tree;
  810.     },
  811.     
  812.     removeDropIndicators : function(n){
  813.         if(n && n.ddel){
  814.             var el = n.ddel;
  815.             Ext.fly(el).removeClass([
  816.                     "x-tree-drag-insert-above",
  817.                     "x-tree-drag-insert-below",
  818.                     "x-tree-drag-append"]);
  819.             this.lastInsertClass = "_noclass";
  820.         }
  821.     },
  822.     
  823.     beforeDragDrop : function(target, e, id){
  824.         this.cancelExpand();
  825.         return true;
  826.     },
  827.     
  828.     afterRepair : function(data){
  829.         if(data && Ext.enableFx){
  830.             data.node.ui.highlight();
  831.         }
  832.         this.hideProxy();
  833.     }    
  834. });
  835. }
  836. if(Ext.dd.DragZone){
  837. Ext.tree.TreeDragZone = function(tree, config){
  838.     Ext.tree.TreeDragZone.superclass.constructor.call(this, tree.innerCt, config);
  839.     
  840.     this.tree = tree;
  841. };
  842. Ext.extend(Ext.tree.TreeDragZone, Ext.dd.DragZone, {
  843.     
  844.     ddGroup : "TreeDD",
  845.     
  846.     onBeforeDrag : function(data, e){
  847.         var n = data.node;
  848.         return n && n.draggable && !n.disabled;
  849.     },
  850.     
  851.     onInitDrag : function(e){
  852.         var data = this.dragData;
  853.         this.tree.getSelectionModel().select(data.node);
  854.         this.tree.eventModel.disable();
  855.         this.proxy.update("");
  856.         data.node.ui.appendDDGhost(this.proxy.ghost.dom);
  857.         this.tree.fireEvent("startdrag", this.tree, data.node, e);
  858.     },
  859.     
  860.     getRepairXY : function(e, data){
  861.         return data.node.ui.getDDRepairXY();
  862.     },
  863.     
  864.     onEndDrag : function(data, e){
  865.         this.tree.eventModel.enable.defer(100, this.tree.eventModel);
  866.         this.tree.fireEvent("enddrag", this.tree, data.node, e);
  867.     },
  868.     
  869.     onValidDrop : function(dd, e, id){
  870.         this.tree.fireEvent("dragdrop", this.tree, this.dragData.node, dd, e);
  871.         this.hideProxy();
  872.     },
  873.     
  874.     beforeInvalidDrop : function(e, id){
  875.         
  876.         var sm = this.tree.getSelectionModel();
  877.         sm.clearSelections();
  878.         sm.select(this.dragData.node);
  879.     },
  880.     
  881.     
  882.     afterRepair : function(){
  883.         if (Ext.enableFx && this.tree.hlDrop) {
  884.             Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9");
  885.         }
  886.         this.dragging = false;
  887.     }
  888. });
  889. }
  890. Ext.tree.TreeEditor = function(tree, fc, config){
  891.     fc = fc || {};
  892.     var field = fc.events ? fc : new Ext.form.TextField(fc);
  893.     Ext.tree.TreeEditor.superclass.constructor.call(this, field, config);
  894.     this.tree = tree;
  895.     if(!tree.rendered){
  896.         tree.on('render', this.initEditor, this);
  897.     }else{
  898.         this.initEditor(tree);
  899.     }
  900. };
  901. Ext.extend(Ext.tree.TreeEditor, Ext.Editor, {
  902.     
  903.     alignment: "l-l",
  904.     
  905.     autoSize: false,
  906.     
  907.     hideEl : false,
  908.     
  909.     cls: "x-small-editor x-tree-editor",
  910.     
  911.     shim:false,
  912.     
  913.     shadow:"frame",
  914.     
  915.     maxWidth: 250,
  916.     
  917.     editDelay : 350,
  918.     initEditor : function(tree){
  919.         tree.on({
  920.             scope: this,
  921.             beforeclick: this.beforeNodeClick,
  922.             dblclick: this.onNodeDblClick
  923.         });
  924.         this.on({
  925.             scope: this,
  926.             complete: this.updateNode,
  927.             beforestartedit: this.fitToTree,
  928.             specialkey: this.onSpecialKey
  929.         });
  930.         this.on('startedit', this.bindScroll, this, {delay:10});
  931.     },
  932.     
  933.     fitToTree : function(ed, el){
  934.         var td = this.tree.getTreeEl().dom, nd = el.dom;
  935.         if(td.scrollLeft >  nd.offsetLeft){ 
  936.             td.scrollLeft = nd.offsetLeft;
  937.         }
  938.         var w = Math.min(
  939.                 this.maxWidth,
  940.                 (td.clientWidth > 20 ? td.clientWidth : td.offsetWidth) - Math.max(0, nd.offsetLeft-td.scrollLeft) - 5);
  941.         this.setSize(w, '');
  942.     },
  943.     
  944.     triggerEdit : function(node, defer){
  945.         this.completeEdit();
  946. if(node.attributes.editable !== false){
  947.            
  948. this.editNode = node;
  949.             if(this.tree.autoScroll){
  950.                 Ext.fly(node.ui.getEl()).scrollIntoView(this.tree.body);
  951.             }
  952.             var value = node.text || '';
  953.             if (!Ext.isGecko && Ext.isEmpty(node.text)){
  954.                 node.setText('&#160;');
  955.             }
  956.             this.autoEditTimer = this.startEdit.defer(this.editDelay, this, [node.ui.textNode, value]);
  957.             return false;
  958.         }
  959.     },
  960.     
  961.     bindScroll : function(){
  962.         this.tree.getTreeEl().on('scroll', this.cancelEdit, this);
  963.     },
  964.     
  965.     beforeNodeClick : function(node, e){
  966.         clearTimeout(this.autoEditTimer);
  967.         if(this.tree.getSelectionModel().isSelected(node)){
  968.             e.stopEvent();
  969.             return this.triggerEdit(node);
  970.         }
  971.     },
  972.     onNodeDblClick : function(node, e){
  973.         clearTimeout(this.autoEditTimer);
  974.     },
  975.     
  976.     updateNode : function(ed, value){
  977.         this.tree.getTreeEl().un('scroll', this.cancelEdit, this);
  978.         this.editNode.setText(value);
  979.     },
  980.     
  981.     onHide : function(){
  982.         Ext.tree.TreeEditor.superclass.onHide.call(this);
  983.         if(this.editNode){
  984.             this.editNode.ui.focus.defer(50, this.editNode.ui);
  985.         }
  986.     },
  987.     
  988.     onSpecialKey : function(field, e){
  989.         var k = e.getKey();
  990.         if(k == e.ESC){
  991.             e.stopEvent();
  992.             this.cancelEdit();
  993.         }else if(k == e.ENTER && !e.hasModifier()){
  994.             e.stopEvent();
  995.             this.completeEdit();
  996.         }
  997.     },
  998.     
  999.     onDestroy : function(){
  1000.         clearTimeout(this.autoEditTimer);
  1001.         Ext.tree.TreeEditor.superclass.onDestroy.call(this);
  1002.         var tree = this.tree;
  1003.         tree.un('beforeclick', this.beforeNodeClick, this);
  1004.         tree.un('dblclick', this.onNodeDblClick, this);
  1005.     }
  1006. });
  1007. var swfobject = function() {
  1008.     
  1009.     var UNDEF = "undefined",
  1010.         OBJECT = "object",
  1011.         SHOCKWAVE_FLASH = "Shockwave Flash",
  1012.         SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash",
  1013.         FLASH_MIME_TYPE = "application/x-shockwave-flash",
  1014.         EXPRESS_INSTALL_ID = "SWFObjectExprInst",
  1015.         ON_READY_STATE_CHANGE = "onreadystatechange",
  1016.         
  1017.         win = window,
  1018.         doc = document,
  1019.         nav = navigator,
  1020.         
  1021.         plugin = false,
  1022.         domLoadFnArr = [main],
  1023.         regObjArr = [],
  1024.         objIdArr = [],
  1025.         listenersArr = [],
  1026.         storedAltContent,
  1027.         storedAltContentId,
  1028.         storedCallbackFn,
  1029.         storedCallbackObj,
  1030.         isDomLoaded = false,
  1031.         isExpressInstallActive = false,
  1032.         dynamicStylesheet,
  1033.         dynamicStylesheetMedia,
  1034.         autoHideShow = true,
  1035.     
  1036.       
  1037.     ua = function() {
  1038.         var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF,
  1039.             u = nav.userAgent.toLowerCase(),
  1040.             p = nav.platform.toLowerCase(),
  1041.             windows = p ? /win/.test(p) : /win/.test(u),
  1042.             mac = p ? /mac/.test(p) : /mac/.test(u),
  1043.             webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit/(d+(.d+)?).*$/, "$1")) : false, 
  1044.             ie = !+"v1", 
  1045.             playerVersion = [0,0,0],
  1046.             d = null;
  1047.         if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) {
  1048.             d = nav.plugins[SHOCKWAVE_FLASH].description;
  1049.             if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) { 
  1050.                 plugin = true;
  1051.                 ie = false; 
  1052.                 d = d.replace(/^.*s+(S+s+S+$)/, "$1");
  1053.                 playerVersion[0] = parseInt(d.replace(/^(.*)..*$/, "$1"), 10);
  1054.                 playerVersion[1] = parseInt(d.replace(/^.*.(.*)s.*$/, "$1"), 10);
  1055.                 playerVersion[2] = /[a-zA-Z]/.test(d) ? parseInt(d.replace(/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0;
  1056.             }
  1057.         }
  1058.         else if (typeof win.ActiveXObject != UNDEF) {
  1059.             try {
  1060.                 var a = new ActiveXObject(SHOCKWAVE_FLASH_AX);
  1061.                 if (a) { 
  1062.                     d = a.GetVariable("$version");
  1063.                     if (d) {
  1064.                         ie = true; 
  1065.                         d = d.split(" ")[1].split(",");
  1066.                         playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
  1067.                     }
  1068.                 }
  1069.             }
  1070.             catch(e) {}
  1071.         }
  1072.         return { w3:w3cdom, pv:playerVersion, wk:webkit, ie:ie, win:windows, mac:mac };
  1073.     }(),
  1074.     
  1075.      
  1076.     onDomLoad = function() {
  1077.         if (!ua.w3) { return; }
  1078.         if ((typeof doc.readyState != UNDEF && doc.readyState == "complete") || (typeof doc.readyState == UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) { 
  1079.             callDomLoadFunctions();
  1080.         }
  1081.         if (!isDomLoaded) {
  1082.             if (typeof doc.addEventListener != UNDEF) {
  1083.                 doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false);
  1084.             }       
  1085.             if (ua.ie && ua.win) {
  1086.                 doc.attachEvent(ON_READY_STATE_CHANGE, function() {
  1087.                     if (doc.readyState == "complete") {
  1088.                         doc.detachEvent(ON_READY_STATE_CHANGE, arguments.callee);
  1089.                         callDomLoadFunctions();
  1090.                     }
  1091.                 });
  1092.                 if (win == top) { 
  1093.                     (function(){
  1094.                         if (isDomLoaded) { return; }
  1095.                         try {
  1096.                             doc.documentElement.doScroll("left");
  1097.                         }
  1098.                         catch(e) {
  1099.                             setTimeout(arguments.callee, 0);
  1100.                             return;
  1101.                         }
  1102.                         callDomLoadFunctions();
  1103.                     })();
  1104.                 }
  1105.             }
  1106.             if (ua.wk) {
  1107.                 (function(){
  1108.                     if (isDomLoaded) { return; }
  1109.                     if (!/loaded|complete/.test(doc.readyState)) {
  1110.                         setTimeout(arguments.callee, 0);
  1111.                         return;
  1112.                     }
  1113.                     callDomLoadFunctions();
  1114.                 })();
  1115.             }
  1116.             addLoadEvent(callDomLoadFunctions);
  1117.         }
  1118.     }();
  1119.     
  1120.     function callDomLoadFunctions() {
  1121.         if (isDomLoaded) { return; }
  1122.         try { 
  1123.             var t = doc.getElementsByTagName("body")[0].appendChild(createElement("span"));
  1124.             t.parentNode.removeChild(t);
  1125.         }
  1126.         catch (e) { return; }
  1127.         isDomLoaded = true;
  1128.         var dl = domLoadFnArr.length;
  1129.         for (var i = 0; i < dl; i++) {
  1130.             domLoadFnArr[i]();
  1131.         }
  1132.     }
  1133.     
  1134.     function addDomLoadEvent(fn) {
  1135.         if (isDomLoaded) {
  1136.             fn();
  1137.         }
  1138.         else { 
  1139.             domLoadFnArr[domLoadFnArr.length] = fn; 
  1140.         }
  1141.     }
  1142.     
  1143.     
  1144.     function addLoadEvent(fn) {
  1145.         if (typeof win.addEventListener != UNDEF) {
  1146.             win.addEventListener("load", fn, false);
  1147.         }
  1148.         else if (typeof doc.addEventListener != UNDEF) {
  1149.             doc.addEventListener("load", fn, false);
  1150.         }
  1151.         else if (typeof win.attachEvent != UNDEF) {
  1152.             addListener(win, "onload", fn);
  1153.         }
  1154.         else if (typeof win.onload == "function") {
  1155.             var fnOld = win.onload;
  1156.             win.onload = function() {
  1157.                 fnOld();
  1158.                 fn();
  1159.             };
  1160.         }
  1161.         else {
  1162.             win.onload = fn;
  1163.         }
  1164.     }
  1165.     
  1166.     
  1167.     function main() { 
  1168.         if (plugin) {
  1169.             testPlayerVersion();
  1170.         }
  1171.         else {
  1172.             matchVersions();
  1173.         }
  1174.     }
  1175.     
  1176.     
  1177.     function testPlayerVersion() {
  1178.         var b = doc.getElementsByTagName("body")[0];
  1179.         var o = createElement(OBJECT);
  1180.         o.setAttribute("type", FLASH_MIME_TYPE);
  1181.         var t = b.appendChild(o);
  1182.         if (t) {
  1183.             var counter = 0;
  1184.             (function(){
  1185.                 if (typeof t.GetVariable != UNDEF) {
  1186.                     var d = t.GetVariable("$version");
  1187.                     if (d) {
  1188.                         d = d.split(" ")[1].split(",");
  1189.                         ua.pv = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
  1190.                     }
  1191.                 }
  1192.                 else if (counter < 10) {
  1193.                     counter++;
  1194.                     setTimeout(arguments.callee, 10);
  1195.                     return;
  1196.                 }
  1197.                 b.removeChild(o);
  1198.                 t = null;
  1199.                 matchVersions();
  1200.             })();
  1201.         }
  1202.         else {
  1203.             matchVersions();
  1204.         }
  1205.     }
  1206.     
  1207.     
  1208.     function matchVersions() {
  1209.         var rl = regObjArr.length;
  1210.         if (rl > 0) {
  1211.             for (var i = 0; i < rl; i++) { 
  1212.                 var id = regObjArr[i].id;
  1213.                 var cb = regObjArr[i].callbackFn;
  1214.                 var cbObj = {success:false, id:id};
  1215.                 if (ua.pv[0] > 0) {
  1216.                     var obj = getElementById(id);
  1217.                     if (obj) {
  1218.                         if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) { 
  1219.                             setVisibility(id, true);
  1220.                             if (cb) {
  1221.                                 cbObj.success = true;
  1222.                                 cbObj.ref = getObjectById(id);
  1223.                                 cb(cbObj);
  1224.                             }
  1225.                         }
  1226.                         else if (regObjArr[i].expressInstall && canExpressInstall()) { 
  1227.                             var att = {};
  1228.                             att.data = regObjArr[i].expressInstall;
  1229.                             att.width = obj.getAttribute("width") || "0";
  1230.                             att.height = obj.getAttribute("height") || "0";
  1231.                             if (obj.getAttribute("class")) { att.styleclass = obj.getAttribute("class"); }
  1232.                             if (obj.getAttribute("align")) { att.align = obj.getAttribute("align"); }
  1233.                             
  1234.                             var par = {};
  1235.                             var p = obj.getElementsByTagName("param");
  1236.                             var pl = p.length;
  1237.                             for (var j = 0; j < pl; j++) {
  1238.                                 if (p[j].getAttribute("name").toLowerCase() != "movie") {
  1239.                                     par[p[j].getAttribute("name")] = p[j].getAttribute("value");
  1240.                                 }
  1241.                             }
  1242.                             showExpressInstall(att, par, id, cb);
  1243.                         }
  1244.                         else { 
  1245.                             displayAltContent(obj);
  1246.                             if (cb) { cb(cbObj); }
  1247.                         }
  1248.                     }
  1249.                 }
  1250.                 else {  
  1251.                     setVisibility(id, true);
  1252.                     if (cb) {
  1253.                         var o = getObjectById(id); 
  1254.                         if (o && typeof o.SetVariable != UNDEF) { 
  1255.                             cbObj.success = true;
  1256.                             cbObj.ref = o;
  1257.                         }
  1258.                         cb(cbObj);
  1259.                     }
  1260.                 }
  1261.             }
  1262.         }
  1263.     }
  1264.     
  1265.     function getObjectById(objectIdStr) {
  1266.         var r = null;
  1267.         var o = getElementById(objectIdStr);
  1268.         if (o && o.nodeName == "OBJECT") {
  1269.             if (typeof o.SetVariable != UNDEF) {
  1270.                 r = o;
  1271.             }
  1272.             else {
  1273.                 var n = o.getElementsByTagName(OBJECT)[0];
  1274.                 if (n) {
  1275.                     r = n;
  1276.                 }
  1277.             }
  1278.         }
  1279.         return r;
  1280.     }
  1281.     
  1282.     
  1283.     function canExpressInstall() {
  1284.         return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312);
  1285.     }
  1286.     
  1287.     
  1288.     function showExpressInstall(att, par, replaceElemIdStr, callbackFn) {
  1289.         isExpressInstallActive = true;
  1290.         storedCallbackFn = callbackFn || null;
  1291.         storedCallbackObj = {success:false, id:replaceElemIdStr};
  1292.         var obj = getElementById(replaceElemIdStr);
  1293.         if (obj) {
  1294.             if (obj.nodeName == "OBJECT") { 
  1295.                 storedAltContent = abstractAltContent(obj);
  1296.                 storedAltContentId = null;
  1297.             }
  1298.             else { 
  1299.                 storedAltContent = obj;
  1300.                 storedAltContentId = replaceElemIdStr;
  1301.             }
  1302.             att.id = EXPRESS_INSTALL_ID;
  1303.             if (typeof att.width == UNDEF || (!/%$/.test(att.width) && parseInt(att.width, 10) < 310)) { att.width = "310"; }
  1304.             if (typeof att.height == UNDEF || (!/%$/.test(att.height) && parseInt(att.height, 10) < 137)) { att.height = "137"; }
  1305.             doc.title = doc.title.slice(0, 47) + " - Flash Player Installation";
  1306.             var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn",
  1307.                 fv = "MMredirectURL=" + win.location.toString().replace(/&/g,"%26") + "&MMplayerType=" + pt + "&MMdoctitle=" + doc.title;
  1308.             if (typeof par.flashvars != UNDEF) {
  1309.                 par.flashvars += "&" + fv;
  1310.             }
  1311.             else {
  1312.                 par.flashvars = fv;
  1313.             }
  1314.             
  1315.             
  1316.             if (ua.ie && ua.win && obj.readyState != 4) {
  1317.                 var newObj = createElement("div");
  1318.                 replaceElemIdStr += "SWFObjectNew";
  1319.                 newObj.setAttribute("id", replaceElemIdStr);
  1320.                 obj.parentNode.insertBefore(newObj, obj); 
  1321.                 obj.style.display = "none";
  1322.                 (function(){
  1323.                     if (obj.readyState == 4) {
  1324.                         obj.parentNode.removeChild(obj);
  1325.                     }
  1326.                     else {
  1327.                         setTimeout(arguments.callee, 10);
  1328.                     }
  1329.                 })();
  1330.             }
  1331.             createSWF(att, par, replaceElemIdStr);
  1332.         }
  1333.     }
  1334.     
  1335.     
  1336.     function displayAltContent(obj) {
  1337.         if (ua.ie && ua.win && obj.readyState != 4) {
  1338.             
  1339.             
  1340.             var el = createElement("div");
  1341.             obj.parentNode.insertBefore(el, obj); 
  1342.             el.parentNode.replaceChild(abstractAltContent(obj), el);
  1343.             obj.style.display = "none";
  1344.             (function(){
  1345.                 if (obj.readyState == 4) {
  1346.                     obj.parentNode.removeChild(obj);
  1347.                 }
  1348.                 else {
  1349.                     setTimeout(arguments.callee, 10);
  1350.                 }
  1351.             })();
  1352.         }
  1353.         else {
  1354.             obj.parentNode.replaceChild(abstractAltContent(obj), obj);
  1355.         }
  1356.     } 
  1357.     function abstractAltContent(obj) {
  1358.         var ac = createElement("div");
  1359.         if (ua.win && ua.ie) {
  1360.             ac.innerHTML = obj.innerHTML;
  1361.         }
  1362.         else {
  1363.             var nestedObj = obj.getElementsByTagName(OBJECT)[0];
  1364.             if (nestedObj) {
  1365.                 var c = nestedObj.childNodes;
  1366.                 if (c) {
  1367.                     var cl = c.length;
  1368.                     for (var i = 0; i < cl; i++) {
  1369.                         if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) {
  1370.                             ac.appendChild(c[i].cloneNode(true));
  1371.                         }
  1372.                     }
  1373.                 }
  1374.             }
  1375.         }
  1376.         return ac;
  1377.     }
  1378.     
  1379.     
  1380.     function createSWF(attObj, parObj, id) {
  1381.         var r, el = getElementById(id);
  1382.         if (ua.wk && ua.wk < 312) { return r; }
  1383.         if (el) {
  1384.             if (typeof attObj.id == UNDEF) { 
  1385.                 attObj.id = id;
  1386.             }
  1387.             if (ua.ie && ua.win) { 
  1388.                 var att = "";
  1389.                 for (var i in attObj) {
  1390.                     if (attObj[i] != Object.prototype[i]) { 
  1391.                         if (i.toLowerCase() == "data") {
  1392.                             parObj.movie = attObj[i];
  1393.                         }
  1394.                         else if (i.toLowerCase() == "styleclass") { 
  1395.                             att += ' class="' + attObj[i] + '"';
  1396.                         }
  1397.                         else if (i.toLowerCase() != "classid") {
  1398.                             att += ' ' + i + '="' + attObj[i] + '"';
  1399.                         }
  1400.                     }
  1401.                 }
  1402.                 var par = "";
  1403.                 for (var j in parObj) {
  1404.                     if (parObj[j] != Object.prototype[j]) { 
  1405.                         par += '<param name="' + j + '" value="' + parObj[j] + '" />';
  1406.                     }
  1407.                 }
  1408.                 el.outerHTML = '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"' + att + '>' + par + '</object>';
  1409.                 objIdArr[objIdArr.length] = attObj.id; 
  1410.                 r = getElementById(attObj.id);  
  1411.             }
  1412.             else { 
  1413.                 var o = createElement(OBJECT);
  1414.                 o.setAttribute("type", FLASH_MIME_TYPE);
  1415.                 for (var m in attObj) {
  1416.                     if (attObj[m] != Object.prototype[m]) { 
  1417.                         if (m.toLowerCase() == "styleclass") { 
  1418.                             o.setAttribute("class", attObj[m]);
  1419.                         }
  1420.                         else if (m.toLowerCase() != "classid") { 
  1421.                             o.setAttribute(m, attObj[m]);
  1422.                         }
  1423.                     }
  1424.                 }
  1425.                 for (var n in parObj) {
  1426.                     if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") { 
  1427.                         createObjParam(o, n, parObj[n]);
  1428.                     }
  1429.                 }
  1430.                 el.parentNode.replaceChild(o, el);
  1431.                 r = o;
  1432.             }
  1433.         }
  1434.         return r;
  1435.     }
  1436.     
  1437.     function createObjParam(el, pName, pValue) {
  1438.         var p = createElement("param");
  1439.         p.setAttribute("name", pName);  
  1440.         p.setAttribute("value", pValue);
  1441.         el.appendChild(p);
  1442.     }
  1443.     
  1444.     
  1445.     function removeSWF(id) {
  1446.         var obj = getElementById(id);
  1447.         if (obj && obj.nodeName == "OBJECT") {
  1448.             if (ua.ie && ua.win) {
  1449.                 obj.style.display = "none";
  1450.                 (function(){
  1451.                     if (obj.readyState == 4) {
  1452.                         removeObjectInIE(id);
  1453.                     }
  1454.                     else {
  1455.                         setTimeout(arguments.callee, 10);
  1456.                     }
  1457.                 })();
  1458.             }
  1459.             else {
  1460.                 obj.parentNode.removeChild(obj);
  1461.             }
  1462.         }
  1463.     }
  1464.     
  1465.     function removeObjectInIE(id) {
  1466.         var obj = getElementById(id);
  1467.         if (obj) {
  1468.             for (var i in obj) {
  1469.                 if (typeof obj[i] == "function") {
  1470.                     obj[i] = null;
  1471.                 }
  1472.             }
  1473.             obj.parentNode.removeChild(obj);
  1474.         }
  1475.     }
  1476.     
  1477.     
  1478.     function getElementById(id) {
  1479.         var el = null;
  1480.         try {
  1481.             el = doc.getElementById(id);
  1482.         }
  1483.         catch (e) {}
  1484.         return el;
  1485.     }
  1486.     
  1487.     function createElement(el) {
  1488.         return doc.createElement(el);
  1489.     }
  1490.     
  1491.       
  1492.     function addListener(target, eventType, fn) {
  1493.         target.attachEvent(eventType, fn);
  1494.         listenersArr[listenersArr.length] = [target, eventType, fn];
  1495.     }
  1496.     
  1497.     
  1498.     function hasPlayerVersion(rv) {
  1499.         var pv = ua.pv, v = rv.split(".");
  1500.         v[0] = parseInt(v[0], 10);
  1501.         v[1] = parseInt(v[1], 10) || 0; 
  1502.         v[2] = parseInt(v[2], 10) || 0;
  1503.         return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false;
  1504.     }
  1505.     
  1506.       
  1507.     function createCSS(sel, decl, media, newStyle) {
  1508.         if (ua.ie && ua.mac) { return; }
  1509.         var h = doc.getElementsByTagName("head")[0];
  1510.         if (!h) { return; } 
  1511.         var m = (media && typeof media == "string") ? media : "screen";
  1512.         if (newStyle) {
  1513.             dynamicStylesheet = null;
  1514.             dynamicStylesheetMedia = null;
  1515.         }
  1516.         if (!dynamicStylesheet || dynamicStylesheetMedia != m) { 
  1517.             
  1518.             var s = createElement("style");
  1519.             s.setAttribute("type", "text/css");
  1520.             s.setAttribute("media", m);
  1521.             dynamicStylesheet = h.appendChild(s);
  1522.             if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) {
  1523.                 dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1];
  1524.             }
  1525.             dynamicStylesheetMedia = m;
  1526.         }
  1527.         
  1528.         if (ua.ie && ua.win) {
  1529.             if (dynamicStylesheet && typeof dynamicStylesheet.addRule == OBJECT) {
  1530.                 dynamicStylesheet.addRule(sel, decl);
  1531.             }
  1532.         }
  1533.         else {
  1534.             if (dynamicStylesheet && typeof doc.createTextNode != UNDEF) {
  1535.                 dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}"));
  1536.             }
  1537.         }
  1538.     }
  1539.     
  1540.     function setVisibility(id, isVisible) {
  1541.         if (!autoHideShow) { return; }
  1542.         var v = isVisible ? "visible" : "hidden";
  1543.         if (isDomLoaded && getElementById(id)) {
  1544.             getElementById(id).style.visibility = v;
  1545.         }
  1546.         else {
  1547.             createCSS("#" + id, "visibility:" + v);
  1548.         }
  1549.     }
  1550.     
  1551.     function urlEncodeIfNecessary(s) {
  1552.         var regex = /[\"<>.;]/;
  1553.         var hasBadChars = regex.exec(s) != null;
  1554.         return hasBadChars && typeof encodeURIComponent != UNDEF ? encodeURIComponent(s) : s;
  1555.     }
  1556.     
  1557.     
  1558.     var cleanup = function() {
  1559.         if (ua.ie && ua.win) {
  1560.             window.attachEvent("onunload", function() {
  1561.                 
  1562.                 var ll = listenersArr.length;
  1563.                 for (var i = 0; i < ll; i++) {
  1564.                     listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]);
  1565.                 }
  1566.                 
  1567.                 var il = objIdArr.length;
  1568.                 for (var j = 0; j < il; j++) {
  1569.                     removeSWF(objIdArr[j]);
  1570.                 }
  1571.                 
  1572.                 for (var k in ua) {
  1573.                     ua[k] = null;
  1574.                 }
  1575.                 ua = null;
  1576.                 for (var l in swfobject) {
  1577.                     swfobject[l] = null;
  1578.                 }
  1579.                 swfobject = null;
  1580.             });
  1581.         }
  1582.     }();
  1583.     
  1584.     return {
  1585.          
  1586.         registerObject: function(objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) {
  1587.             if (ua.w3 && objectIdStr && swfVersionStr) {
  1588.                 var regObj = {};
  1589.                 regObj.id = objectIdStr;
  1590.                 regObj.swfVersion = swfVersionStr;
  1591.                 regObj.expressInstall = xiSwfUrlStr;
  1592.                 regObj.callbackFn = callbackFn;
  1593.                 regObjArr[regObjArr.length] = regObj;
  1594.                 setVisibility(objectIdStr, false);
  1595.             }
  1596.             else if (callbackFn) {
  1597.                 callbackFn({success:false, id:objectIdStr});
  1598.             }
  1599.         },
  1600.         
  1601.         getObjectById: function(objectIdStr) {
  1602.             if (ua.w3) {
  1603.                 return getObjectById(objectIdStr);
  1604.             }
  1605.         },
  1606.         
  1607.         embedSWF: function(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) {
  1608.             var callbackObj = {success:false, id:replaceElemIdStr};
  1609.             if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) {
  1610.                 setVisibility(replaceElemIdStr, false);
  1611.                 addDomLoadEvent(function() {
  1612.                     widthStr += ""; 
  1613.                     heightStr += "";
  1614.                     var att = {};
  1615.                     if (attObj && typeof attObj === OBJECT) {
  1616.                         for (var i in attObj) { 
  1617.                             att[i] = attObj[i];
  1618.                         }
  1619.                     }
  1620.                     att.data = swfUrlStr;
  1621.                     att.width = widthStr;
  1622.                     att.height = heightStr;
  1623.                     var par = {}; 
  1624.                     if (parObj && typeof parObj === OBJECT) {
  1625.                         for (var j in parObj) { 
  1626.                             par[j] = parObj[j];
  1627.                         }
  1628.                     }
  1629.                     if (flashvarsObj && typeof flashvarsObj === OBJECT) {
  1630.                         for (var k in flashvarsObj) { 
  1631.                             if (typeof par.flashvars != UNDEF) {
  1632.                                 par.flashvars += "&" + k + "=" + flashvarsObj[k];
  1633.                             }
  1634.                             else {
  1635.                                 par.flashvars = k + "=" + flashvarsObj[k];
  1636.                             }
  1637.                         }
  1638.                     }
  1639.                     if (hasPlayerVersion(swfVersionStr)) { 
  1640.                         var obj = createSWF(att, par, replaceElemIdStr);
  1641.                         if (att.id == replaceElemIdStr) {
  1642.                             setVisibility(replaceElemIdStr, true);
  1643.                         }
  1644.                         callbackObj.success = true;
  1645.                         callbackObj.ref = obj;
  1646.                     }
  1647.                     else if (xiSwfUrlStr && canExpressInstall()) { 
  1648.                         att.data = xiSwfUrlStr;
  1649.                         showExpressInstall(att, par, replaceElemIdStr, callbackFn);
  1650.                         return;
  1651.                     }
  1652.                     else { 
  1653.                         setVisibility(replaceElemIdStr, true);
  1654.                     }
  1655.                     if (callbackFn) { callbackFn(callbackObj); }
  1656.                 });
  1657.             }
  1658.             else if (callbackFn) { callbackFn(callbackObj); }
  1659.         },
  1660.         
  1661.         switchOffAutoHideShow: function() {
  1662.             autoHideShow = false;
  1663.         },
  1664.         
  1665.         ua: ua,
  1666.         
  1667.         getFlashPlayerVersion: function() {
  1668.             return { major:ua.pv[0], minor:ua.pv[1], release:ua.pv[2] };
  1669.         },
  1670.         
  1671.         hasFlashPlayerVersion: hasPlayerVersion,
  1672.         
  1673.         createSWF: function(attObj, parObj, replaceElemIdStr) {
  1674.             if (ua.w3) {
  1675.                 return createSWF(attObj, parObj, replaceElemIdStr);
  1676.             }
  1677.             else {
  1678.                 return undefined;
  1679.             }
  1680.         },
  1681.         
  1682.         showExpressInstall: function(att, par, replaceElemIdStr, callbackFn) {
  1683.             if (ua.w3 && canExpressInstall()) {
  1684.                 showExpressInstall(att, par, replaceElemIdStr, callbackFn);
  1685.             }
  1686.         },
  1687.         
  1688.         removeSWF: function(objElemIdStr) {
  1689.             if (ua.w3) {
  1690.                 removeSWF(objElemIdStr);
  1691.             }
  1692.         },
  1693.         
  1694.         createCSS: function(selStr, declStr, mediaStr, newStyleBoolean) {
  1695.             if (ua.w3) {
  1696.                 createCSS(selStr, declStr, mediaStr, newStyleBoolean);
  1697.             }
  1698.         },
  1699.         
  1700.         addDomLoadEvent: addDomLoadEvent,
  1701.         
  1702.         addLoadEvent: addLoadEvent,
  1703.         
  1704.         getQueryParamValue: function(param) {
  1705.             var q = doc.location.search || doc.location.hash;
  1706.             if (q) {
  1707.                 if (/?/.test(q)) { q = q.split("?")[1]; } 
  1708.                 if (param == null) {
  1709.                     return urlEncodeIfNecessary(q);
  1710.                 }
  1711.                 var pairs = q.split("&");
  1712.                 for (var i = 0; i < pairs.length; i++) {
  1713.                     if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) {
  1714.                         return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1)));
  1715.                     }
  1716.                 }
  1717.             }
  1718.             return "";
  1719.         },
  1720.         
  1721.         
  1722.         expressInstallCallback: function() {
  1723.             if (isExpressInstallActive) {
  1724.                 var obj = getElementById(EXPRESS_INSTALL_ID);
  1725.                 if (obj && storedAltContent) {
  1726.                     obj.parentNode.replaceChild(storedAltContent, obj);
  1727.                     if (storedAltContentId) {
  1728.                         setVisibility(storedAltContentId, true);
  1729.                         if (ua.ie && ua.win) { storedAltContent.style.display = "block"; }
  1730.                     }
  1731.                     if (storedCallbackFn) { storedCallbackFn(storedCallbackObj); }
  1732.                 }
  1733.                 isExpressInstallActive = false;
  1734.             } 
  1735.         }
  1736.     };
  1737. }();
  1738. Ext.FlashComponent = Ext.extend(Ext.BoxComponent, {
  1739.     
  1740.     flashVersion : '9.0.115',
  1741.     
  1742.     backgroundColor: '#ffffff',
  1743.     
  1744.     wmode: 'opaque',
  1745.     
  1746.     
  1747.     flashVars: undefined,
  1748.     
  1749.     
  1750.     flashParams: undefined,
  1751.     
  1752.     url: undefined,
  1753.     swfId : undefined,
  1754.     swfWidth: '100%',
  1755.     swfHeight: '100%',
  1756.     
  1757.     expressInstall: false,
  1758.     initComponent : function(){
  1759.         Ext.FlashComponent.superclass.initComponent.call(this);
  1760.         this.addEvents(
  1761.             
  1762.             'initialize'
  1763.         );
  1764.     },
  1765.     onRender : function(){
  1766.         Ext.FlashComponent.superclass.onRender.apply(this, arguments);
  1767.         var params = Ext.apply({
  1768.             allowScriptAccess: 'always',
  1769.             bgcolor: this.backgroundColor,
  1770.             wmode: this.wmode
  1771.         }, this.flashParams), vars = Ext.apply({
  1772.             allowedDomain: document.location.hostname,
  1773.             elementID: this.getId(),
  1774.             eventHandler: 'Ext.FlashEventProxy.onEvent'
  1775.         }, this.flashVars);
  1776.         new swfobject.embedSWF(this.url, this.id, this.swfWidth, this.swfHeight, this.flashVersion,
  1777.             this.expressInstall ? Ext.FlashComponent.EXPRESS_INSTALL_URL : undefined, vars, params);
  1778.         this.swf = Ext.getDom(this.id);
  1779.         this.el = Ext.get(this.swf);
  1780.     },
  1781.     getSwfId : function(){
  1782.         return this.swfId || (this.swfId = "extswf" + (++Ext.Component.AUTO_ID));
  1783.     },
  1784.     getId : function(){
  1785.         return this.id || (this.id = "extflashcmp" + (++Ext.Component.AUTO_ID));
  1786.     },
  1787.     onFlashEvent : function(e){
  1788.         switch(e.type){
  1789.             case "swfReady":
  1790.                 this.initSwf();
  1791.                 return;
  1792.             case "log":
  1793.                 return;
  1794.         }
  1795.         e.component = this;
  1796.         this.fireEvent(e.type.toLowerCase().replace(/event$/, ''), e);
  1797.     },
  1798.     initSwf : function(){
  1799.         this.onSwfReady(!!this.isInitialized);
  1800.         this.isInitialized = true;
  1801.         this.fireEvent('initialize', this);
  1802.     },
  1803.     beforeDestroy: function(){
  1804.         if(this.rendered){
  1805.             swfobject.removeSWF(this.swf.id);
  1806.         }
  1807.         Ext.FlashComponent.superclass.beforeDestroy.call(this);
  1808.     },
  1809.     onSwfReady : Ext.emptyFn
  1810. });
  1811. Ext.FlashComponent.EXPRESS_INSTALL_URL = 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf';
  1812. Ext.reg('flash', Ext.FlashComponent);
  1813. Ext.FlashEventProxy = {
  1814.     onEvent : function(id, e){
  1815.         var fp = Ext.getCmp(id);
  1816.         if(fp){
  1817.             fp.onFlashEvent(e);
  1818.         }else{
  1819.             arguments.callee.defer(10, this, [id, e]);
  1820.         }
  1821.     }
  1822. }
  1823.  
  1824.  Ext.chart.Chart = Ext.extend(Ext.FlashComponent, {
  1825.     refreshBuffer: 100,
  1826.     
  1827.     
  1828.     
  1829.     chartStyle: {
  1830.         padding: 10,
  1831.         animationEnabled: true,
  1832.         font: {
  1833.             name: 'Tahoma',
  1834.             color: 0x444444,
  1835.             size: 11
  1836.         },
  1837.         dataTip: {
  1838.             padding: 5,
  1839.             border: {
  1840.                 color: 0x99bbe8,
  1841.                 size:1
  1842.             },
  1843.             background: {
  1844.                 color: 0xDAE7F6,
  1845.                 alpha: .9
  1846.             },
  1847.             font: {
  1848.                 name: 'Tahoma',
  1849.                 color: 0x15428B,
  1850.                 size: 10,
  1851.                 bold: true
  1852.             }
  1853.         }
  1854.     },
  1855.     
  1856.     
  1857.     
  1858.     
  1859.     extraStyle: null,
  1860.     
  1861.     
  1862.     seriesStyles: null,
  1863.     
  1864.     
  1865.     disableCaching: Ext.isIE || Ext.isOpera,
  1866.     disableCacheParam: '_dc',
  1867.     initComponent : function(){
  1868.         Ext.chart.Chart.superclass.initComponent.call(this);
  1869.         if(!this.url){
  1870.             this.url = Ext.chart.Chart.CHART_URL;
  1871.         }
  1872.         if(this.disableCaching){
  1873.             this.url = Ext.urlAppend(this.url, String.format('{0}={1}', this.disableCacheParam, new Date().getTime()));
  1874.         }
  1875.         this.addEvents(
  1876.             'itemmouseover',
  1877.             'itemmouseout',
  1878.             'itemclick',
  1879.             'itemdoubleclick',
  1880.             'itemdragstart',
  1881.             'itemdrag',
  1882.             'itemdragend',
  1883.             
  1884.             'beforerefresh',
  1885.             
  1886.             'refresh'
  1887.         );
  1888.         this.store = Ext.StoreMgr.lookup(this.store);
  1889.     },
  1890.     
  1891.      setStyle: function(name, value){
  1892.          this.swf.setStyle(name, Ext.encode(value));
  1893.      },
  1894.     
  1895.     setStyles: function(styles){
  1896.         this.swf.setStyles(Ext.encode(styles));
  1897.     },
  1898.     
  1899.     setSeriesStyles: function(styles){
  1900.         this.seriesStyles = styles;
  1901.         var s = [];
  1902.         Ext.each(styles, function(style){
  1903.             s.push(Ext.encode(style));
  1904.         });
  1905.         this.swf.setSeriesStyles(s);
  1906.     },
  1907.     setCategoryNames : function(names){
  1908.         this.swf.setCategoryNames(names);
  1909.     },
  1910.     setTipRenderer : function(fn){
  1911.         var chart = this;
  1912.         this.tipFnName = this.createFnProxy(function(item, index, series){
  1913.             var record = chart.store.getAt(index);
  1914.             return fn(chart, record, index, series);
  1915.         }, this.tipFnName);
  1916.         this.swf.setDataTipFunction(this.tipFnName);
  1917.     },
  1918.     setSeries : function(series){
  1919.         this.series = series;
  1920.         this.refresh();
  1921.     },
  1922.     
  1923.     bindStore : function(store, initial){
  1924.         if(!initial && this.store){
  1925.             if(store !== this.store && this.store.autoDestroy){
  1926.                 this.store.destroy();
  1927.             }else{
  1928.                 this.store.un("datachanged", this.refresh, this);
  1929.                 this.store.un("add", this.delayRefresh, this);
  1930.                 this.store.un("remove", this.delayRefresh, this);
  1931.                 this.store.un("update", this.delayRefresh, this);
  1932.                 this.store.un("clear", this.refresh, this);
  1933.             }
  1934.         }
  1935.         if(store){
  1936.             store = Ext.StoreMgr.lookup(store);
  1937.             store.on({
  1938.                 scope: this,
  1939.                 datachanged: this.refresh,
  1940.                 add: this.delayRefresh,
  1941.                 remove: this.delayRefresh,
  1942.                 update: this.delayRefresh,
  1943.                 clear: this.refresh
  1944.             });
  1945.         }
  1946.         this.store = store;
  1947.         if(store && !initial){
  1948.             this.refresh();
  1949.         }
  1950.     },
  1951.     onSwfReady : function(isReset){
  1952.         Ext.chart.Chart.superclass.onSwfReady.call(this, isReset);
  1953.         this.swf.setType(this.type);
  1954.         if(this.chartStyle){
  1955.             this.setStyles(Ext.apply({}, this.extraStyle, this.chartStyle));
  1956.         }
  1957.         if(this.categoryNames){
  1958.             this.setCategoryNames(this.categoryNames);
  1959.         }
  1960.         if(this.tipRenderer){
  1961.             this.setTipRenderer(this.tipRenderer);
  1962.         }
  1963.         if(!isReset){
  1964.             this.bindStore(this.store, true);
  1965.         }
  1966.         this.refresh.defer(10, this);
  1967.     },
  1968.     delayRefresh : function(){
  1969.         if(!this.refreshTask){
  1970.             this.refreshTask = new Ext.util.DelayedTask(this.refresh, this);
  1971.         }
  1972.         this.refreshTask.delay(this.refreshBuffer);
  1973.     },
  1974.     refresh : function(){
  1975.         if(this.fireEvent('beforerefresh', this) !== false){
  1976.         var styleChanged = false;
  1977.         
  1978.         var data = [], rs = this.store.data.items;
  1979.         for(var j = 0, len = rs.length; j < len; j++){
  1980.             data[j] = rs[j].data;
  1981.         }
  1982.         
  1983.         
  1984.         var dataProvider = [];
  1985.         var seriesCount = 0;
  1986.         var currentSeries = null;
  1987.         var i = 0;
  1988.         if(this.series){
  1989.             seriesCount = this.series.length;
  1990.             for(i = 0; i < seriesCount; i++){
  1991.                 currentSeries = this.series[i];
  1992.                 var clonedSeries = {};
  1993.                 for(var prop in currentSeries){
  1994.                     if(prop == "style" && currentSeries.style !== null){
  1995.                         clonedSeries.style = Ext.encode(currentSeries.style);
  1996.                         styleChanged = true;
  1997.                         
  1998.                         
  1999.                         
  2000.                         
  2001.                     } else{
  2002.                         clonedSeries[prop] = currentSeries[prop];
  2003.                     }
  2004.                 }
  2005.                 dataProvider.push(clonedSeries);
  2006.             }
  2007.         }
  2008.         if(seriesCount > 0){
  2009.             for(i = 0; i < seriesCount; i++){
  2010.                 currentSeries = dataProvider[i];
  2011.                 if(!currentSeries.type){
  2012.                     currentSeries.type = this.type;
  2013.                 }
  2014.                 currentSeries.dataProvider = data;
  2015.             }
  2016.         } else{
  2017.             dataProvider.push({type: this.type, dataProvider: data});
  2018.         }
  2019.         this.swf.setDataProvider(dataProvider);
  2020.         if(this.seriesStyles){
  2021.             this.setSeriesStyles(this.seriesStyles);
  2022.         }
  2023.             this.fireEvent('refresh', this);
  2024.         }
  2025.     },
  2026.     createFnProxy : function(fn, old){
  2027.         if(old){
  2028.             delete window[old];
  2029.         }
  2030.         var fnName = "extFnProxy" + (++Ext.chart.Chart.PROXY_FN_ID);
  2031.         window[fnName] = fn;
  2032.         return fnName;
  2033.     },
  2034.     
  2035.     onDestroy: function(){
  2036.         Ext.chart.Chart.superclass.onDestroy.call(this);
  2037.         this.bindStore(null);
  2038.         var tip = this.tipFnName;
  2039.         if(!Ext.isEmpty(tip)){
  2040.             delete window[tip];
  2041.         }
  2042.     }
  2043. });
  2044. Ext.reg('chart', Ext.chart.Chart);
  2045. Ext.chart.Chart.PROXY_FN_ID = 0;
  2046. Ext.chart.Chart.CHART_URL = 'http:/' + '/yui.yahooapis.com/2.7.0/build/charts/assets/charts.swf';
  2047. Ext.chart.PieChart = Ext.extend(Ext.chart.Chart, {
  2048.     type: 'pie',
  2049.     onSwfReady : function(isReset){
  2050.         Ext.chart.PieChart.superclass.onSwfReady.call(this, isReset);
  2051.         this.setDataField(this.dataField);
  2052.         this.setCategoryField(this.categoryField);
  2053.     },
  2054.     setDataField : function(field){
  2055.         this.dataField = field;
  2056.         this.swf.setDataField(field);
  2057.     },
  2058.     setCategoryField : function(field){
  2059.         this.categoryField = field;
  2060.         this.swf.setCategoryField(field);
  2061.     }
  2062. });
  2063. Ext.reg('piechart', Ext.chart.PieChart);
  2064. Ext.chart.CartesianChart = Ext.extend(Ext.chart.Chart, {
  2065.     onSwfReady : function(isReset){
  2066.         Ext.chart.CartesianChart.superclass.onSwfReady.call(this, isReset);
  2067.         if(this.xField){
  2068.             this.setXField(this.xField);
  2069.         }
  2070.         if(this.yField){
  2071.             this.setYField(this.yField);
  2072.         }
  2073.         if(this.xAxis){
  2074.             this.setXAxis(this.xAxis);
  2075.         }
  2076.         if(this.yAxis){
  2077.             this.setYAxis(this.yAxis);
  2078.         }
  2079.     },
  2080.     setXField : function(value){
  2081.         this.xField = value;
  2082.         this.swf.setHorizontalField(value);
  2083.     },
  2084.     setYField : function(value){
  2085.         this.yField = value;
  2086.         this.swf.setVerticalField(value);
  2087.     },
  2088.     setXAxis : function(value){
  2089.         this.xAxis = this.createAxis('xAxis', value);
  2090.         this.swf.setHorizontalAxis(this.xAxis);
  2091.     },
  2092.     setYAxis : function(value){
  2093.         this.yAxis = this.createAxis('yAxis', value);
  2094.         this.swf.setVerticalAxis(this.yAxis);
  2095.     },
  2096.     createAxis : function(axis, value){
  2097.         var o = Ext.apply({}, value), oldFn = null;
  2098.         if(this[axis]){
  2099.             oldFn = this[axis].labelFunction;
  2100.         }
  2101.         if(o.labelRenderer){
  2102.             var fn = o.labelRenderer;
  2103.             o.labelFunction = this.createFnProxy(function(v){
  2104.                 return fn(v);
  2105.             }, oldFn);
  2106.             delete o.labelRenderer;
  2107.         }
  2108.         return o;
  2109.     }
  2110. });
  2111. Ext.reg('cartesianchart', Ext.chart.CartesianChart);
  2112. Ext.chart.LineChart = Ext.extend(Ext.chart.CartesianChart, {
  2113.     type: 'line'
  2114. });
  2115. Ext.reg('linechart', Ext.chart.LineChart);
  2116. Ext.chart.ColumnChart = Ext.extend(Ext.chart.CartesianChart, {
  2117.     type: 'column'
  2118. });
  2119. Ext.reg('columnchart', Ext.chart.ColumnChart);
  2120. Ext.chart.StackedColumnChart = Ext.extend(Ext.chart.CartesianChart, {
  2121.     type: 'stackcolumn'
  2122. });
  2123. Ext.reg('stackedcolumnchart', Ext.chart.StackedColumnChart);
  2124. Ext.chart.BarChart = Ext.extend(Ext.chart.CartesianChart, {
  2125.     type: 'bar'
  2126. });
  2127. Ext.reg('barchart', Ext.chart.BarChart);
  2128. Ext.chart.StackedBarChart = Ext.extend(Ext.chart.CartesianChart, {
  2129.     type: 'stackbar'
  2130. });
  2131. Ext.reg('stackedbarchart', Ext.chart.StackedBarChart);
  2132. Ext.chart.Axis = function(config){
  2133.     Ext.apply(this, config);
  2134. };
  2135. Ext.chart.Axis.prototype =
  2136. {
  2137.     
  2138.     type: null,
  2139.     
  2140.     orientation: "horizontal",
  2141.     
  2142.     reverse: false,
  2143.     
  2144.     labelFunction: null,
  2145.     
  2146.     hideOverlappingLabels: true
  2147. };
  2148. Ext.chart.NumericAxis = Ext.extend(Ext.chart.Axis, {
  2149.     type: "numeric",
  2150.     
  2151.     minimum: NaN,
  2152.     
  2153.     maximum: NaN,
  2154.     
  2155.     majorUnit: NaN,
  2156.     
  2157.     minorUnit: NaN,
  2158.     
  2159.     snapToUnits: true,
  2160.     
  2161.     alwaysShowZero: true,
  2162.     
  2163.     scale: "linear"
  2164. });
  2165. Ext.chart.TimeAxis = Ext.extend(Ext.chart.Axis, {
  2166.     type: "time",
  2167.     
  2168.     minimum: null,
  2169.     
  2170.     maximum: null,
  2171.     
  2172.     majorUnit: NaN,
  2173.     
  2174.     majorTimeUnit: null,
  2175.     
  2176.     minorUnit: NaN,
  2177.     
  2178.     minorTimeUnit: null,
  2179.     
  2180.     snapToUnits: true
  2181. });
  2182. Ext.chart.CategoryAxis = Ext.extend(Ext.chart.Axis, {
  2183.     type: "category",
  2184.     
  2185.     categoryNames: null
  2186. });
  2187. Ext.chart.Series = function(config) { Ext.apply(this, config); };
  2188. Ext.chart.Series.prototype =
  2189. {
  2190.     
  2191.     type: null,
  2192.     
  2193.     displayName: null
  2194. };
  2195. Ext.chart.CartesianSeries = Ext.extend(Ext.chart.Series, {
  2196.     
  2197.     xField: null,
  2198.     
  2199.     yField: null
  2200. });
  2201. Ext.chart.ColumnSeries = Ext.extend(Ext.chart.CartesianSeries, {
  2202.     type: "column"
  2203. });
  2204. Ext.chart.LineSeries = Ext.extend(Ext.chart.CartesianSeries, {
  2205.     type: "line"
  2206. });
  2207. Ext.chart.BarSeries = Ext.extend(Ext.chart.CartesianSeries, {
  2208.     type: "bar"
  2209. });
  2210. Ext.chart.PieSeries = Ext.extend(Ext.chart.Series, {
  2211.     type: "pie",
  2212.     dataField: null,
  2213.     categoryField: null
  2214. });
  2215.  Ext.layout.MenuLayout = Ext.extend(Ext.layout.ContainerLayout, {
  2216.     monitorResize : true,
  2217.     setContainer : function(ct){
  2218.         this.monitorResize = !ct.floating;
  2219.         
  2220.         
  2221.         ct.on('autosize', this.doAutoSize, this);
  2222.         Ext.layout.MenuLayout.superclass.setContainer.call(this, ct);
  2223.     },
  2224.     renderItem : function(c, position, target){
  2225.         if (!this.itemTpl) {
  2226.             this.itemTpl = Ext.layout.MenuLayout.prototype.itemTpl = new Ext.XTemplate(
  2227.                 '<li id="{itemId}" class="{itemCls}">',
  2228.                     '<tpl if="needsIcon">',
  2229.                         '<img src="{icon}" class="{iconCls}"/>',
  2230.                     '</tpl>',
  2231.                 '</li>'
  2232.             );
  2233.         }
  2234.         if(c && !c.rendered){
  2235.             if(Ext.isNumber(position)){
  2236.                 position = target.dom.childNodes[position];
  2237.             }
  2238.             var a = this.getItemArgs(c);
  2239.             c.render(c.positionEl = position ?
  2240.                 this.itemTpl.insertBefore(position, a, true) :
  2241.                 this.itemTpl.append(target, a, true));
  2242.             c.positionEl.menuItemId = c.getItemId();
  2243.             if (!a.isMenuItem && a.needsIcon) {
  2244.                 c.positionEl.addClass('x-menu-list-item-indent');
  2245.             }
  2246.             this.configureItem(c, position);
  2247.         }else if(c && !this.isValidParent(c, target)){
  2248.             if(Ext.isNumber(position)){
  2249.                 position = target.dom.childNodes[position];
  2250.             }
  2251.             target.dom.insertBefore(c.getActionEl().dom, position || null);
  2252.         }
  2253.     },
  2254.     getItemArgs : function(c) {
  2255.         var isMenuItem = c instanceof Ext.menu.Item;
  2256.         return {
  2257.             isMenuItem: isMenuItem,
  2258.             needsIcon: !isMenuItem && (c.icon || c.iconCls),
  2259.             icon: c.icon || Ext.BLANK_IMAGE_URL,
  2260.             iconCls: 'x-menu-item-icon ' + (c.iconCls || ''),
  2261.             itemId: 'x-menu-el-' + c.id,
  2262.             itemCls: 'x-menu-list-item '
  2263.         };
  2264.     },
  2265.     isValidParent : function(c, target) {
  2266.         return c.el.up('li.x-menu-list-item', 5).dom.parentNode === (target.dom || target);
  2267.     },
  2268.     onLayout : function(ct, target){
  2269.         this.renderAll(ct, target);
  2270.         this.doAutoSize();
  2271.     },
  2272.     doAutoSize : function(){
  2273.         var ct = this.container, w = ct.width;
  2274.         if(ct.floating){
  2275.             if(w){
  2276.                 ct.setWidth(w);
  2277.             }else if(Ext.isIE){
  2278.                 ct.setWidth(Ext.isStrict && (Ext.isIE7 || Ext.isIE8) ? 'auto' : ct.minWidth);
  2279.                 var el = ct.getEl(), t = el.dom.offsetWidth; 
  2280.                 ct.setWidth(ct.getLayoutTarget().getWidth() + el.getFrameWidth('lr'));
  2281.             }
  2282.         }
  2283.     }
  2284. });
  2285. Ext.Container.LAYOUTS['menu'] = Ext.layout.MenuLayout;
  2286. Ext.menu.Menu = Ext.extend(Ext.Container, {
  2287.     
  2288.     
  2289.     
  2290.     minWidth : 120,
  2291.     
  2292.     shadow : 'sides',
  2293.     
  2294.     subMenuAlign : 'tl-tr?',
  2295.     
  2296.     defaultAlign : 'tl-bl?',
  2297.     
  2298.     allowOtherMenus : false,
  2299.     
  2300.     ignoreParentClicks : false,
  2301.     
  2302.     enableScrolling : true,
  2303.     
  2304.     maxHeight : null,
  2305.     
  2306.     scrollIncrement : 24,
  2307.     
  2308.     showSeparator : true,
  2309.     
  2310.     defaultOffsets : [0, 0],
  2311.     
  2312.     plain : false,
  2313.     
  2314.     floating : true,
  2315.     
  2316.     hidden : true,
  2317.     
  2318.     layout : 'menu',
  2319.     hideMode : 'offsets',    
  2320.     scrollerHeight : 8,
  2321.     autoLayout : true,       
  2322.     defaultType : 'menuitem',
  2323.     bufferResize : false,
  2324.     initComponent : function(){
  2325.         if(Ext.isArray(this.initialConfig)){
  2326.             Ext.apply(this, {items:this.initialConfig});
  2327.         }
  2328.         this.addEvents(
  2329.             
  2330.             'click',
  2331.             
  2332.             'mouseover',
  2333.             
  2334.             'mouseout',
  2335.             
  2336.             'itemclick'
  2337.         );
  2338.         Ext.menu.MenuMgr.register(this);
  2339.         if(this.floating){
  2340.             Ext.EventManager.onWindowResize(this.hide, this);
  2341.         }else{
  2342.             if(this.initialConfig.hidden !== false){
  2343.                 this.hidden = false;
  2344.             }
  2345.             this.internalDefaults = {hideOnClick: false};
  2346.         }
  2347.         Ext.menu.Menu.superclass.initComponent.call(this);
  2348.         if(this.autoLayout){
  2349.             this.on({
  2350.                 add: this.doLayout,
  2351.                 remove: this.doLayout,
  2352.                 scope: this
  2353.             });
  2354.         }
  2355.     },
  2356.     
  2357.     getLayoutTarget : function() {
  2358.         return this.ul;
  2359.     },
  2360.     
  2361.     onRender : function(ct, position){
  2362.         if(!ct){
  2363.             ct = Ext.getBody();
  2364.         }
  2365.         var dh = {
  2366.             id: this.getId(),
  2367.             cls: 'x-menu ' + ((this.floating) ? 'x-menu-floating x-layer ' : '') + (this.cls || '') + (this.plain ? ' x-menu-plain' : '') + (this.showSeparator ? '' : ' x-menu-nosep'),
  2368.             style: this.style,
  2369.             cn: [
  2370.                 {tag: 'a', cls: 'x-menu-focus', href: '#', onclick: 'return false;', tabIndex: '-1'},
  2371.                 {tag: 'ul', cls: 'x-menu-list'}
  2372.             ]
  2373.         };
  2374.         if(this.floating){
  2375.             this.el = new Ext.Layer({
  2376.                 shadow: this.shadow,
  2377.                 dh: dh,
  2378.                 constrain: false,
  2379.                 parentEl: ct,
  2380.                 zindex:15000
  2381.             });
  2382.         }else{
  2383.             this.el = ct.createChild(dh);
  2384.         }
  2385.         Ext.menu.Menu.superclass.onRender.call(this, ct, position);
  2386.         if(!this.keyNav){
  2387.             this.keyNav = new Ext.menu.MenuNav(this);
  2388.         }
  2389.         
  2390.         this.focusEl = this.el.child('a.x-menu-focus');
  2391.         this.ul = this.el.child('ul.x-menu-list');
  2392.         this.mon(this.ul, {
  2393.             scope: this,
  2394.             click: this.onClick,
  2395.             mouseover: this.onMouseOver,
  2396.             mouseout: this.onMouseOut
  2397.         });
  2398.         if(this.enableScrolling){
  2399.             this.mon(this.el, {
  2400.                 scope: this,
  2401.                 delegate: '.x-menu-scroller',
  2402.                 click: this.onScroll,
  2403.                 mouseover: this.deactivateActive
  2404.             });
  2405.         }
  2406.     },
  2407.     
  2408.     findTargetItem : function(e){
  2409.         var t = e.getTarget('.x-menu-list-item', this.ul, true);
  2410.         if(t && t.menuItemId){
  2411.             return this.items.get(t.menuItemId);
  2412.         }
  2413.     },
  2414.     
  2415.     onClick : function(e){
  2416.         var t = this.findTargetItem(e);
  2417.         if(t){
  2418.             if(t.isFormField){
  2419.                 this.setActiveItem(t);
  2420.             }else if(t instanceof Ext.menu.BaseItem){
  2421.                 if(t.menu && this.ignoreParentClicks){
  2422.                     t.expandMenu();
  2423.                     e.preventDefault();
  2424.                 }else if(t.onClick){
  2425.                     t.onClick(e);
  2426.                     this.fireEvent('click', this, t, e);
  2427.                 }
  2428.             }
  2429.         }
  2430.     },
  2431.     
  2432.     setActiveItem : function(item, autoExpand){
  2433.         if(item != this.activeItem){
  2434.             this.deactivateActive();
  2435.             if((this.activeItem = item).isFormField){
  2436.                 item.focus();
  2437.             }else{
  2438.                 item.activate(autoExpand);
  2439.             }
  2440.         }else if(autoExpand){
  2441.             item.expandMenu();
  2442.         }
  2443.     },
  2444.     deactivateActive : function(){
  2445.         var a = this.activeItem;
  2446.         if(a){
  2447.             if(a.isFormField){
  2448.                 
  2449.                 if(a.collapse){
  2450.                     a.collapse();
  2451.                 }
  2452.             }else{
  2453.                 a.deactivate();
  2454.             }
  2455.             delete this.activeItem;
  2456.         }
  2457.     },
  2458.     
  2459.     tryActivate : function(start, step){
  2460.         var items = this.items;
  2461.         for(var i = start, len = items.length; i >= 0 && i < len; i+= step){
  2462.             var item = items.get(i);
  2463.             if(!item.disabled && (item.canActivate || item.isFormField)){
  2464.                 this.setActiveItem(item, false);
  2465.                 return item;
  2466.             }
  2467.         }
  2468.         return false;
  2469.     },
  2470.     
  2471.     onMouseOver : function(e){
  2472.         var t = this.findTargetItem(e);
  2473.         if(t){
  2474.             if(t.canActivate && !t.disabled){
  2475.                 this.setActiveItem(t, true);
  2476.             }
  2477.         }
  2478.         this.over = true;
  2479.         this.fireEvent('mouseover', this, e, t);
  2480.     },
  2481.     
  2482.     onMouseOut : function(e){
  2483.         var t = this.findTargetItem(e);
  2484.         if(t){
  2485.             if(t == this.activeItem && t.shouldDeactivate && t.shouldDeactivate(e)){
  2486.                 this.activeItem.deactivate();
  2487.                 delete this.activeItem;
  2488.             }
  2489.         }
  2490.         this.over = false;
  2491.         this.fireEvent('mouseout', this, e, t);
  2492.     },
  2493.     
  2494.     onScroll : function(e, t){
  2495.         if(e){
  2496.             e.stopEvent();
  2497.         }
  2498.         var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top');
  2499.         ul.scrollTop += this.scrollIncrement * (top ? -1 : 1);
  2500.         if(top ? ul.scrollTop <= 0 : ul.scrollTop + this.activeMax >= ul.scrollHeight){
  2501.            this.onScrollerOut(null, t);
  2502.         }
  2503.     },
  2504.     
  2505.     onScrollerIn : function(e, t){
  2506.         var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top');
  2507.         if(top ? ul.scrollTop > 0 : ul.scrollTop + this.activeMax < ul.scrollHeight){
  2508.             Ext.fly(t).addClass(['x-menu-item-active', 'x-menu-scroller-active']);
  2509.         }
  2510.     },
  2511.     
  2512.     onScrollerOut : function(e, t){
  2513.         Ext.fly(t).removeClass(['x-menu-item-active', 'x-menu-scroller-active']);
  2514.     },
  2515.     
  2516.     show : function(el, pos, parentMenu){
  2517.         if(this.floating){
  2518.             this.parentMenu = parentMenu;
  2519.             if(!this.el){
  2520.                 this.render();
  2521.                 this.doLayout(false, true);
  2522.             }
  2523.             this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign, this.defaultOffsets), parentMenu);
  2524.         }else{
  2525.             Ext.menu.Menu.superclass.show.call(this);
  2526.         }
  2527.     },
  2528.     
  2529.     showAt : function(xy, parentMenu){
  2530.         if(this.fireEvent('beforeshow', this) !== false){
  2531.             this.parentMenu = parentMenu;
  2532.             if(!this.el){
  2533.                 this.render();
  2534.             }
  2535.             if(this.enableScrolling){
  2536.                 
  2537.                 this.el.setXY(xy);
  2538.                 
  2539.                 this.constrainScroll(xy[1]);
  2540.                 xy = [this.el.adjustForConstraints(xy)[0], xy[1]];
  2541.             }else{
  2542.                 
  2543.                 xy = this.el.adjustForConstraints(xy);
  2544.             }
  2545.             this.el.setXY(xy);
  2546.             this.el.show();
  2547.             Ext.menu.Menu.superclass.onShow.call(this);
  2548.             if(Ext.isIE){
  2549.                 
  2550.                 this.fireEvent('autosize', this);
  2551.                 if(!Ext.isIE8){
  2552.                     this.el.repaint();
  2553.                 }
  2554.             }
  2555.             this.hidden = false;
  2556.             this.focus();
  2557.             this.fireEvent('show', this);
  2558.         }
  2559.     },
  2560.     constrainScroll : function(y){
  2561.         var max, full = this.ul.setHeight('auto').getHeight();
  2562.         if(this.floating){
  2563.             max = this.maxHeight ? this.maxHeight : Ext.fly(this.el.dom.parentNode).getViewSize(false).height - y;
  2564.         }else{
  2565.             max = this.getHeight();
  2566.         }
  2567.         if(full > max && max > 0){
  2568.             this.activeMax = max - this.scrollerHeight * 2 - this.el.getFrameWidth('tb') - Ext.num(this.el.shadowOffset, 0);
  2569.             this.ul.setHeight(this.activeMax);
  2570.             this.createScrollers();
  2571.             this.el.select('.x-menu-scroller').setDisplayed('');
  2572.         }else{
  2573.             this.ul.setHeight(full);
  2574.             this.el.select('.x-menu-scroller').setDisplayed('none');
  2575.         }
  2576.         this.ul.dom.scrollTop = 0;
  2577.     },
  2578.     createScrollers : function(){
  2579.         if(!this.scroller){
  2580.             this.scroller = {
  2581.                 pos: 0,
  2582.                 top: this.el.insertFirst({
  2583.                     tag: 'div',
  2584.                     cls: 'x-menu-scroller x-menu-scroller-top',
  2585.                     html: '&#160;'
  2586.                 }),
  2587.                 bottom: this.el.createChild({
  2588.                     tag: 'div',
  2589.                     cls: 'x-menu-scroller x-menu-scroller-bottom',
  2590.                     html: '&#160;'
  2591.                 })
  2592.             };
  2593.             this.scroller.top.hover(this.onScrollerIn, this.onScrollerOut, this);
  2594.             this.scroller.topRepeater = new Ext.util.ClickRepeater(this.scroller.top, {
  2595.                 listeners: {
  2596.                     click: this.onScroll.createDelegate(this, [null, this.scroller.top], false)
  2597.                 }
  2598.             });
  2599.             this.scroller.bottom.hover(this.onScrollerIn, this.onScrollerOut, this);
  2600.             this.scroller.bottomRepeater = new Ext.util.ClickRepeater(this.scroller.bottom, {
  2601.                 listeners: {
  2602.                     click: this.onScroll.createDelegate(this, [null, this.scroller.bottom], false)
  2603.                 }
  2604.             });
  2605.         }
  2606.     },
  2607.     onLayout : function(){
  2608.         if(this.isVisible()){
  2609.             if(this.enableScrolling){
  2610.                 this.constrainScroll(this.el.getTop());
  2611.             }
  2612.             if(this.floating){
  2613.                 this.el.sync();
  2614.             }
  2615.         }
  2616.     },
  2617.     focus : function(){
  2618.         if(!this.hidden){
  2619.             this.doFocus.defer(50, this);
  2620.         }
  2621.     },
  2622.     doFocus : function(){
  2623.         if(!this.hidden){
  2624.             this.focusEl.focus();
  2625.         }
  2626.     },
  2627.     
  2628.     hide : function(deep){
  2629.         this.deepHide = deep;
  2630.         Ext.menu.Menu.superclass.hide.call(this);
  2631.         delete this.deepHide;
  2632.     },
  2633.     
  2634.     onHide : function(){
  2635.         Ext.menu.Menu.superclass.onHide.call(this);
  2636.         this.deactivateActive();
  2637.         if(this.el && this.floating){
  2638.             this.el.hide();
  2639.         }
  2640.         var pm = this.parentMenu;
  2641.         if(this.deepHide === true && pm){
  2642.             if(pm.floating){
  2643.                 pm.hide(true);
  2644.             }else{
  2645.                 pm.deactivateActive();
  2646.             }
  2647.         }
  2648.     },
  2649.     
  2650.     lookupComponent : function(c){
  2651.          if(Ext.isString(c)){
  2652.             c = (c == 'separator' || c == '-') ? new Ext.menu.Separator() : new Ext.menu.TextItem(c);
  2653.              this.applyDefaults(c);
  2654.          }else{
  2655.             if(Ext.isObject(c)){
  2656.                 c = this.getMenuItem(c);
  2657.             }else if(c.tagName || c.el){ 
  2658.                 c = new Ext.BoxComponent({
  2659.                     el: c
  2660.                 });
  2661.             }
  2662.          }
  2663.          return c;
  2664.     },
  2665.     applyDefaults : function(c){
  2666.         if(!Ext.isString(c)){
  2667.             c = Ext.menu.Menu.superclass.applyDefaults.call(this, c);
  2668.             var d = this.internalDefaults;
  2669.             if(d){
  2670.                 if(c.events){
  2671.                     Ext.applyIf(c.initialConfig, d);
  2672.                     Ext.apply(c, d);
  2673.                 }else{
  2674.                     Ext.applyIf(c, d);
  2675.                 }
  2676.             }
  2677.         }
  2678.         return c;
  2679.     },
  2680.     
  2681.     getMenuItem : function(config){
  2682.        if(!config.isXType){
  2683.             if(!config.xtype && Ext.isBoolean(config.checked)){
  2684.                 return new Ext.menu.CheckItem(config)
  2685.             }
  2686.             return Ext.create(config, this.defaultType);
  2687.         }
  2688.         return config;
  2689.     },
  2690.     
  2691.     addSeparator : function(){
  2692.         return this.add(new Ext.menu.Separator());
  2693.     },
  2694.     
  2695.     addElement : function(el){
  2696.         return this.add(new Ext.menu.BaseItem(el));
  2697.     },
  2698.     
  2699.     addItem : function(item){
  2700.         return this.add(item);
  2701.     },
  2702.     
  2703.     addMenuItem : function(config){
  2704.         return this.add(this.getMenuItem(config));
  2705.     },
  2706.     
  2707.     addText : function(text){
  2708.         return this.add(new Ext.menu.TextItem(text));
  2709.     },
  2710.     
  2711.     onDestroy : function(){
  2712.         var pm = this.parentMenu;
  2713.         if(pm && pm.activeChild == this){
  2714.             delete pm.activeChild;
  2715.         }
  2716.         delete this.parentMenu;
  2717.         Ext.menu.Menu.superclass.onDestroy.call(this);
  2718.         Ext.menu.MenuMgr.unregister(this);
  2719.         Ext.EventManager.removeResizeListener(this.hide, this);
  2720.         if(this.keyNav) {
  2721.             this.keyNav.disable();
  2722.         }
  2723.         var s = this.scroller;
  2724.         if(s){
  2725.             Ext.destroy(s.topRepeater, s.bottomRepeater, s.top, s.bottom);
  2726.         }
  2727.         Ext.destroy(
  2728.             this.el,
  2729.             this.focusEl,
  2730.             this.ul
  2731.         );
  2732.     }
  2733. });
  2734. Ext.reg('menu', Ext.menu.Menu);
  2735. Ext.menu.MenuNav = Ext.extend(Ext.KeyNav, function(){
  2736.     function up(e, m){
  2737.         if(!m.tryActivate(m.items.indexOf(m.activeItem)-1, -1)){
  2738.             m.tryActivate(m.items.length-1, -1);
  2739.         }
  2740.     }
  2741.     function down(e, m){
  2742.         if(!m.tryActivate(m.items.indexOf(m.activeItem)+1, 1)){
  2743.             m.tryActivate(0, 1);
  2744.         }
  2745.     }
  2746.     return {
  2747.         constructor : function(menu){
  2748.             Ext.menu.MenuNav.superclass.constructor.call(this, menu.el);
  2749.             this.scope = this.menu = menu;
  2750.         },
  2751.         doRelay : function(e, h){
  2752.             var k = e.getKey();
  2753.             if (this.menu.activeItem && this.menu.activeItem.isFormField && k != e.TAB) {
  2754.                 return false;
  2755.             }
  2756.             if(!this.menu.activeItem && e.isNavKeyPress() && k != e.SPACE && k != e.RETURN){
  2757.                 this.menu.tryActivate(0, 1);
  2758.                 return false;
  2759.             }
  2760.             return h.call(this.scope || this, e, this.menu);
  2761.         },
  2762.         tab: function(e, m) {
  2763.             e.stopEvent();
  2764.             if (e.shiftKey) {
  2765.                 up(e, m);
  2766.             } else {
  2767.                 down(e, m);
  2768.             }
  2769.         },
  2770.         up : up,
  2771.         down : down,
  2772.         right : function(e, m){
  2773.             if(m.activeItem){
  2774.                 m.activeItem.expandMenu(true);
  2775.             }
  2776.         },
  2777.         left : function(e, m){
  2778.             m.hide();
  2779.             if(m.parentMenu && m.parentMenu.activeItem){
  2780.                 m.parentMenu.activeItem.activate();
  2781.             }
  2782.         },
  2783.         enter : function(e, m){
  2784.             if(m.activeItem){
  2785.                 e.stopPropagation();
  2786.                 m.activeItem.onClick(e);
  2787.                 m.fireEvent('click', this, m.activeItem);
  2788.                 return true;
  2789.             }
  2790.         }
  2791.     };
  2792. }());
  2793. Ext.menu.MenuMgr = function(){
  2794.    var menus, active, groups = {}, attached = false, lastShow = new Date();
  2795.    
  2796.    function init(){
  2797.        menus = {};
  2798.        active = new Ext.util.MixedCollection();
  2799.        Ext.getDoc().addKeyListener(27, function(){
  2800.            if(active.length > 0){
  2801.                hideAll();
  2802.            }
  2803.        });
  2804.    }
  2805.    
  2806.    function hideAll(){
  2807.        if(active && active.length > 0){
  2808.            var c = active.clone();
  2809.            c.each(function(m){
  2810.                m.hide();
  2811.            });
  2812.            return true;
  2813.        }
  2814.        return false;
  2815.    }
  2816.    
  2817.    function onHide(m){
  2818.        active.remove(m);
  2819.        if(active.length < 1){
  2820.            Ext.getDoc().un("mousedown", onMouseDown);
  2821.            attached = false;
  2822.        }
  2823.    }
  2824.    
  2825.    function onShow(m){
  2826.        var last = active.last();
  2827.        lastShow = new Date();
  2828.        active.add(m);
  2829.        if(!attached){
  2830.            Ext.getDoc().on("mousedown", onMouseDown);
  2831.            attached = true;
  2832.        }
  2833.        if(m.parentMenu){
  2834.           m.getEl().setZIndex(parseInt(m.parentMenu.getEl().getStyle("z-index"), 10) + 3);
  2835.           m.parentMenu.activeChild = m;
  2836.        }else if(last && last.isVisible()){
  2837.           m.getEl().setZIndex(parseInt(last.getEl().getStyle("z-index"), 10) + 3);
  2838.        }
  2839.    }
  2840.    
  2841.    function onBeforeHide(m){
  2842.        if(m.activeChild){
  2843.            m.activeChild.hide();
  2844.        }
  2845.        if(m.autoHideTimer){
  2846.            clearTimeout(m.autoHideTimer);
  2847.            delete m.autoHideTimer;
  2848.        }
  2849.    }
  2850.    
  2851.    function onBeforeShow(m){
  2852.        var pm = m.parentMenu;
  2853.        if(!pm && !m.allowOtherMenus){
  2854.            hideAll();
  2855.        }else if(pm && pm.activeChild){
  2856.            pm.activeChild.hide();
  2857.        }
  2858.    }
  2859.    
  2860.    function onMouseDown(e){
  2861.        if(lastShow.getElapsed() > 50 && active.length > 0 && !e.getTarget(".x-menu")){
  2862.            hideAll();
  2863.        }
  2864.    }
  2865.    
  2866.    function onBeforeCheck(mi, state){
  2867.        if(state){
  2868.            var g = groups[mi.group];
  2869.            for(var i = 0, l = g.length; i < l; i++){
  2870.                if(g[i] != mi){
  2871.                    g[i].setChecked(false);
  2872.                }
  2873.            }
  2874.        }
  2875.    }
  2876.    return {
  2877.        
  2878.        hideAll : function(){
  2879.             return hideAll();  
  2880.        },
  2881.        
  2882.        register : function(menu){
  2883.            if(!menus){
  2884.                init();
  2885.            }
  2886.            menus[menu.id] = menu;
  2887.            menu.on({
  2888.                beforehide: onBeforeHide,
  2889.                hide: onHide,
  2890.                beforeshow: onBeforeShow,
  2891.                show: onShow
  2892.            });
  2893.        },
  2894.         
  2895.        get : function(menu){
  2896.            if(typeof menu == "string"){ 
  2897.                if(!menus){  
  2898.                    return null;
  2899.                }
  2900.                return menus[menu];
  2901.            }else if(menu.events){  
  2902.                return menu;
  2903.            }else if(typeof menu.length == 'number'){ 
  2904.                return new Ext.menu.Menu({items:menu});
  2905.            }else{ 
  2906.                return Ext.create(menu, 'menu');
  2907.            }
  2908.        },
  2909.        
  2910.        unregister : function(menu){
  2911.            delete menus[menu.id];
  2912.            menu.un("beforehide", onBeforeHide);
  2913.            menu.un("hide", onHide);
  2914.            menu.un("beforeshow", onBeforeShow);
  2915.            menu.un("show", onShow);
  2916.        },
  2917.        
  2918.        registerCheckable : function(menuItem){
  2919.            var g = menuItem.group;
  2920.            if(g){
  2921.                if(!groups[g]){
  2922.                    groups[g] = [];
  2923.                }
  2924.                groups[g].push(menuItem);
  2925.                menuItem.on("beforecheckchange", onBeforeCheck);
  2926.            }
  2927.        },
  2928.        
  2929.        unregisterCheckable : function(menuItem){
  2930.            var g = menuItem.group;
  2931.            if(g){
  2932.                groups[g].remove(menuItem);
  2933.                menuItem.un("beforecheckchange", onBeforeCheck);
  2934.            }
  2935.        },
  2936.        getCheckedItem : function(groupId){
  2937.            var g = groups[groupId];
  2938.            if(g){
  2939.                for(var i = 0, l = g.length; i < l; i++){
  2940.                    if(g[i].checked){
  2941.                        return g[i];
  2942.                    }
  2943.                }
  2944.            }
  2945.            return null;
  2946.        },
  2947.        setCheckedItem : function(groupId, itemId){
  2948.            var g = groups[groupId];
  2949.            if(g){
  2950.                for(var i = 0, l = g.length; i < l; i++){
  2951.                    if(g[i].id == itemId){
  2952.                        g[i].setChecked(true);
  2953.                    }
  2954.                }
  2955.            }
  2956.            return null;
  2957.        }
  2958.    };
  2959. }();
  2960. Ext.menu.BaseItem = Ext.extend(Ext.Component, {
  2961.     
  2962.     
  2963.     
  2964.     
  2965.     canActivate : false,
  2966.     
  2967.     activeClass : "x-menu-item-active",
  2968.     
  2969.     hideOnClick : true,
  2970.     
  2971.     clickHideDelay : 1,
  2972.     
  2973.     ctype : "Ext.menu.BaseItem",
  2974.     
  2975.     actionMode : "container",
  2976.     
  2977.     initComponent : function(){
  2978.         Ext.menu.BaseItem.superclass.initComponent.call(this);
  2979.         this.addEvents(
  2980.         
  2981.         'click',
  2982.         
  2983.         'activate',
  2984.         
  2985.         'deactivate'
  2986.     );
  2987.     if(this.handler){
  2988.         this.on("click", this.handler, this.scope);
  2989.     }
  2990.     },
  2991.     
  2992.     onRender : function(container, position){
  2993.         Ext.menu.BaseItem.superclass.onRender.apply(this, arguments);
  2994.         if(this.ownerCt && this.ownerCt instanceof Ext.menu.Menu){
  2995.             this.parentMenu = this.ownerCt;
  2996.         }else{
  2997.             this.container.addClass('x-menu-list-item');
  2998.             this.mon(this.el, {
  2999.                 scope: this,
  3000.                 click: this.onClick,
  3001.                 mouseenter: this.activate,
  3002.                 mouseleave: this.deactivate
  3003.             });
  3004.         }
  3005.     },
  3006.     
  3007.     setHandler : function(handler, scope){
  3008.         if(this.handler){
  3009.             this.un("click", this.handler, this.scope);
  3010.         }
  3011.         this.on("click", this.handler = handler, this.scope = scope);
  3012.     },
  3013.     
  3014.     onClick : function(e){
  3015.         if(!this.disabled && this.fireEvent("click", this, e) !== false
  3016.                 && (this.parentMenu && this.parentMenu.fireEvent("itemclick", this, e) !== false)){
  3017.             this.handleClick(e);
  3018.         }else{
  3019.             e.stopEvent();
  3020.         }
  3021.     },
  3022.     
  3023.     activate : function(){
  3024.         if(this.disabled){
  3025.             return false;
  3026.         }
  3027.         var li = this.container;
  3028.         li.addClass(this.activeClass);
  3029.         this.region = li.getRegion().adjust(2, 2, -2, -2);
  3030.         this.fireEvent("activate", this);
  3031.         return true;
  3032.     },
  3033.     
  3034.     deactivate : function(){
  3035.         this.container.removeClass(this.activeClass);
  3036.         this.fireEvent("deactivate", this);
  3037.     },
  3038.     
  3039.     shouldDeactivate : function(e){
  3040.         return !this.region || !this.region.contains(e.getPoint());
  3041.     },
  3042.     
  3043.     handleClick : function(e){
  3044.         var pm = this.parentMenu;
  3045.         if(this.hideOnClick){
  3046.             if(pm.floating){
  3047.                 pm.hide.defer(this.clickHideDelay, pm, [true]);
  3048.             }else{
  3049.                 pm.deactivateActive();
  3050.             }
  3051.         }
  3052.     },
  3053.     
  3054.     expandMenu : Ext.emptyFn,
  3055.     
  3056.     hideMenu : Ext.emptyFn
  3057. });
  3058. Ext.reg('menubaseitem', Ext.menu.BaseItem);
  3059. Ext.menu.TextItem = Ext.extend(Ext.menu.BaseItem, {
  3060.     
  3061.     
  3062.     hideOnClick : false,
  3063.     
  3064.     itemCls : "x-menu-text",
  3065.     
  3066.     constructor : function(config){
  3067.         if(typeof config == 'string'){
  3068.             config = {text: config}
  3069.         }
  3070.         Ext.menu.TextItem.superclass.constructor.call(this, config);
  3071.     },
  3072.     
  3073.     onRender : function(){
  3074.         var s = document.createElement("span");
  3075.         s.className = this.itemCls;
  3076.         s.innerHTML = this.text;
  3077.         this.el = s;
  3078.         Ext.menu.TextItem.superclass.onRender.apply(this, arguments);
  3079.     }
  3080. });
  3081. Ext.reg('menutextitem', Ext.menu.TextItem);
  3082. Ext.menu.Separator = Ext.extend(Ext.menu.BaseItem, {
  3083.     
  3084.     itemCls : "x-menu-sep",
  3085.     
  3086.     hideOnClick : false,
  3087.     
  3088.     
  3089.     activeClass: '',
  3090.     
  3091.     onRender : function(li){
  3092.         var s = document.createElement("span");
  3093.         s.className = this.itemCls;
  3094.         s.innerHTML = "&#160;";
  3095.         this.el = s;
  3096.         li.addClass("x-menu-sep-li");
  3097.         Ext.menu.Separator.superclass.onRender.apply(this, arguments);
  3098.     }
  3099. });
  3100. Ext.reg('menuseparator', Ext.menu.Separator);
  3101. Ext.menu.Item = Ext.extend(Ext.menu.BaseItem, {
  3102.     
  3103.     
  3104.     
  3105.     
  3106.     
  3107.     
  3108.     
  3109.     
  3110.     itemCls : 'x-menu-item',
  3111.     
  3112.     canActivate : true,
  3113.     
  3114.     showDelay: 200,
  3115.     
  3116.     hideDelay: 200,
  3117.     
  3118.     ctype: 'Ext.menu.Item',
  3119.     initComponent : function(){
  3120.         Ext.menu.Item.superclass.initComponent.call(this);
  3121.         if(this.menu){
  3122.             this.menu = Ext.menu.MenuMgr.get(this.menu);
  3123.             this.menu.ownerCt = this;
  3124.         }
  3125.     },
  3126.     
  3127.     onRender : function(container, position){
  3128.         if (!this.itemTpl) {
  3129.             this.itemTpl = Ext.menu.Item.prototype.itemTpl = new Ext.XTemplate(
  3130.                 '<a id="{id}" class="{cls}" hidefocus="true" unselectable="on" href="{href}"',
  3131.                     '<tpl if="hrefTarget">',
  3132.                         ' target="{hrefTarget}"',
  3133.                     '</tpl>',
  3134.                  '>',
  3135.                      '<img src="{icon}" class="x-menu-item-icon {iconCls}"/>',
  3136.                      '<span class="x-menu-item-text">{text}</span>',
  3137.                  '</a>'
  3138.              );
  3139.         }
  3140.         var a = this.getTemplateArgs();
  3141.         this.el = position ? this.itemTpl.insertBefore(position, a, true) : this.itemTpl.append(container, a, true);
  3142.         this.iconEl = this.el.child('img.x-menu-item-icon');
  3143.         this.textEl = this.el.child('.x-menu-item-text');
  3144.         if(!this.href) { 
  3145.             this.mon(this.el, 'click', Ext.emptyFn, null, { preventDefault: true });
  3146.         }
  3147.         Ext.menu.Item.superclass.onRender.call(this, container, position);
  3148.     },
  3149.     getTemplateArgs: function() {
  3150.         return {
  3151.             id: this.id,
  3152.             cls: this.itemCls + (this.menu ?  ' x-menu-item-arrow' : '') + (this.cls ?  ' ' + this.cls : ''),
  3153.             href: this.href || '#',
  3154.             hrefTarget: this.hrefTarget,
  3155.             icon: this.icon || Ext.BLANK_IMAGE_URL,
  3156.             iconCls: this.iconCls || '',
  3157.             text: this.itemText||this.text||'&#160;'
  3158.         };
  3159.     },
  3160.     
  3161.     setText : function(text){
  3162.         this.text = text||'&#160;';
  3163.         if(this.rendered){
  3164.             this.textEl.update(this.text);
  3165.             this.parentMenu.layout.doAutoSize();
  3166.         }
  3167.     },
  3168.     
  3169.     setIconClass : function(cls){
  3170.         var oldCls = this.iconCls;
  3171.         this.iconCls = cls;
  3172.         if(this.rendered){
  3173.             this.iconEl.replaceClass(oldCls, this.iconCls);
  3174.         }
  3175.     },
  3176.     
  3177.     beforeDestroy: function(){
  3178.         if (this.menu){
  3179.             delete this.menu.ownerCt;
  3180.             this.menu.destroy();
  3181.         }
  3182.         Ext.menu.Item.superclass.beforeDestroy.call(this);
  3183.     },
  3184.     
  3185.     handleClick : function(e){
  3186.         if(!this.href){ 
  3187.             e.stopEvent();
  3188.         }
  3189.         Ext.menu.Item.superclass.handleClick.apply(this, arguments);
  3190.     },
  3191.     
  3192.     activate : function(autoExpand){
  3193.         if(Ext.menu.Item.superclass.activate.apply(this, arguments)){
  3194.             this.focus();
  3195.             if(autoExpand){
  3196.                 this.expandMenu();
  3197.             }
  3198.         }
  3199.         return true;
  3200.     },
  3201.     
  3202.     shouldDeactivate : function(e){
  3203.         if(Ext.menu.Item.superclass.shouldDeactivate.call(this, e)){
  3204.             if(this.menu && this.menu.isVisible()){
  3205.                 return !this.menu.getEl().getRegion().contains(e.getPoint());
  3206.             }
  3207.             return true;
  3208.         }
  3209.         return false;
  3210.     },
  3211.     
  3212.     deactivate : function(){
  3213.         Ext.menu.Item.superclass.deactivate.apply(this, arguments);
  3214.         this.hideMenu();
  3215.     },
  3216.     
  3217.     expandMenu : function(autoActivate){
  3218.         if(!this.disabled && this.menu){
  3219.             clearTimeout(this.hideTimer);
  3220.             delete this.hideTimer;
  3221.             if(!this.menu.isVisible() && !this.showTimer){
  3222.                 this.showTimer = this.deferExpand.defer(this.showDelay, this, [autoActivate]);
  3223.             }else if (this.menu.isVisible() && autoActivate){
  3224.                 this.menu.tryActivate(0, 1);
  3225.             }
  3226.         }
  3227.     },
  3228.     
  3229.     deferExpand : function(autoActivate){
  3230.         delete this.showTimer;
  3231.         this.menu.show(this.container, this.parentMenu.subMenuAlign || 'tl-tr?', this.parentMenu);
  3232.         if(autoActivate){
  3233.             this.menu.tryActivate(0, 1);
  3234.         }
  3235.     },
  3236.     
  3237.     hideMenu : function(){
  3238.         clearTimeout(this.showTimer);
  3239.         delete this.showTimer;
  3240.         if(!this.hideTimer && this.menu && this.menu.isVisible()){
  3241.             this.hideTimer = this.deferHide.defer(this.hideDelay, this);
  3242.         }
  3243.     },
  3244.     
  3245.     deferHide : function(){
  3246.         delete this.hideTimer;
  3247.         if(this.menu.over){
  3248.             this.parentMenu.setActiveItem(this, false);
  3249.         }else{
  3250.             this.menu.hide();
  3251.         }
  3252.     }
  3253. });
  3254. Ext.reg('menuitem', Ext.menu.Item);
  3255. Ext.menu.CheckItem = Ext.extend(Ext.menu.Item, {
  3256.     
  3257.     
  3258.     itemCls : "x-menu-item x-menu-check-item",
  3259.     
  3260.     groupClass : "x-menu-group-item",
  3261.     
  3262.     checked: false,
  3263.     
  3264.     ctype: "Ext.menu.CheckItem",
  3265.     
  3266.     initComponent : function(){
  3267.         Ext.menu.CheckItem.superclass.initComponent.call(this);
  3268.     this.addEvents(
  3269.         
  3270.         "beforecheckchange" ,
  3271.         
  3272.         "checkchange"
  3273.     );
  3274.     
  3275.     if(this.checkHandler){
  3276.         this.on('checkchange', this.checkHandler, this.scope);
  3277.     }
  3278.     Ext.menu.MenuMgr.registerCheckable(this);
  3279.     },
  3280.     
  3281.     onRender : function(c){
  3282.         Ext.menu.CheckItem.superclass.onRender.apply(this, arguments);
  3283.         if(this.group){
  3284.             this.el.addClass(this.groupClass);
  3285.         }
  3286.         if(this.checked){
  3287.             this.checked = false;
  3288.             this.setChecked(true, true);
  3289.         }
  3290.     },
  3291.     
  3292.     destroy : function(){
  3293.         Ext.menu.MenuMgr.unregisterCheckable(this);
  3294.         Ext.menu.CheckItem.superclass.destroy.apply(this, arguments);
  3295.     },
  3296.     
  3297.     setChecked : function(state, suppressEvent){
  3298.         if(this.checked != state && this.fireEvent("beforecheckchange", this, state) !== false){
  3299.             if(this.container){
  3300.                 this.container[state ? "addClass" : "removeClass"]("x-menu-item-checked");
  3301.             }
  3302.             this.checked = state;
  3303.             if(suppressEvent !== true){
  3304.                 this.fireEvent("checkchange", this, state);
  3305.             }
  3306.         }
  3307.     },
  3308.     
  3309.     handleClick : function(e){
  3310.        if(!this.disabled && !(this.checked && this.group)){
  3311.            this.setChecked(!this.checked);
  3312.        }
  3313.        Ext.menu.CheckItem.superclass.handleClick.apply(this, arguments);
  3314.     }
  3315. });
  3316. Ext.reg('menucheckitem', Ext.menu.CheckItem);
  3317.  Ext.menu.DateMenu = Ext.extend(Ext.menu.Menu, {
  3318.     
  3319.     enableScrolling : false,
  3320.     
  3321.         
  3322.     
  3323.     hideOnClick : true,
  3324.     
  3325.     
  3326.     pickerId : null,
  3327.     
  3328.     
  3329.     
  3330.     
  3331.     cls : 'x-date-menu',
  3332.     
  3333.     
  3334.     
  3335.     
  3336.     initComponent : function(){
  3337.         this.on('beforeshow', this.onBeforeShow, this);
  3338.         if(this.strict = (Ext.isIE7 && Ext.isStrict)){
  3339.             this.on('show', this.onShow, this, {single: true, delay: 20});
  3340.         }
  3341.         Ext.apply(this, {
  3342.             plain: true,
  3343.             showSeparator: false,
  3344.             items: this.picker = new Ext.DatePicker(Ext.applyIf({
  3345.                 internalRender: this.strict || !Ext.isIE,
  3346.                 ctCls: 'x-menu-date-item',
  3347.                 id: this.pickerId
  3348.             }, this.initialConfig))
  3349.         });
  3350.         this.picker.purgeListeners();
  3351.         Ext.menu.DateMenu.superclass.initComponent.call(this);
  3352.         
  3353.         this.relayEvents(this.picker, ['select']);
  3354.         this.on('show', this.picker.focus, this.picker);
  3355.         this.on('select', this.menuHide, this);
  3356.         if(this.handler){
  3357.             this.on('select', this.handler, this.scope || this);
  3358.         }
  3359.     },
  3360.     menuHide : function() {
  3361.         if(this.hideOnClick){
  3362.             this.hide(true);
  3363.         }
  3364.     },
  3365.     onBeforeShow : function(){
  3366.         if(this.picker){
  3367.             this.picker.hideMonthPicker(true);
  3368.         }
  3369.     },
  3370.     onShow : function(){
  3371.         var el = this.picker.getEl();
  3372.         el.setWidth(el.getWidth()); 
  3373.     }
  3374.  });
  3375.  Ext.reg('datemenu', Ext.menu.DateMenu);
  3376.  
  3377.  Ext.menu.ColorMenu = Ext.extend(Ext.menu.Menu, {
  3378.     
  3379.     enableScrolling : false,
  3380.     
  3381.         
  3382.     
  3383.     
  3384.     hideOnClick : true,
  3385.     
  3386.     cls : 'x-color-menu',
  3387.     
  3388.     
  3389.     paletteId : null,
  3390.     
  3391.     
  3392.     
  3393.     
  3394.     
  3395.     
  3396.     
  3397.     
  3398.     
  3399.     
  3400.     initComponent : function(){
  3401.         Ext.apply(this, {
  3402.             plain: true,
  3403.             showSeparator: false,
  3404.             items: this.palette = new Ext.ColorPalette(Ext.applyIf({
  3405.                 id: this.paletteId
  3406.             }, this.initialConfig))
  3407.         });
  3408.         this.palette.purgeListeners();
  3409.         Ext.menu.ColorMenu.superclass.initComponent.call(this);
  3410.         
  3411.         this.relayEvents(this.palette, ['select']);
  3412.         this.on('select', this.menuHide, this);
  3413.         if(this.handler){
  3414.             this.on('select', this.handler, this.scope || this);
  3415.         }
  3416.     },
  3417.     menuHide : function(){
  3418.         if(this.hideOnClick){
  3419.             this.hide(true);
  3420.         }
  3421.     }
  3422. });
  3423. Ext.reg('colormenu', Ext.menu.ColorMenu);
  3424. Ext.form.Field = Ext.extend(Ext.BoxComponent,  {
  3425.     
  3426.     
  3427.     
  3428.     
  3429.     
  3430.     
  3431.     
  3432.     invalidClass : 'x-form-invalid',
  3433.     
  3434.     invalidText : 'The value in this field is invalid',
  3435.     
  3436.     focusClass : 'x-form-focus',
  3437.     
  3438.     
  3439.     validationEvent : 'keyup',
  3440.     
  3441.     validateOnBlur : true,
  3442.     
  3443.     validationDelay : 250,
  3444.     
  3445.     defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'},
  3446.     
  3447.     fieldClass : 'x-form-field',
  3448.     
  3449.     msgTarget : 'qtip',
  3450.     
  3451.     msgFx : 'normal',
  3452.     
  3453.     readOnly : false,
  3454.     
  3455.     disabled : false,
  3456.     
  3457.     submitValue: true,
  3458.     
  3459.     isFormField : true,
  3460.     
  3461.     msgDisplay: '',
  3462.     
  3463.     hasFocus : false,
  3464.     
  3465.     initComponent : function(){
  3466.         Ext.form.Field.superclass.initComponent.call(this);
  3467.         this.addEvents(
  3468.             
  3469.             'focus',
  3470.             
  3471.             'blur',
  3472.             
  3473.             'specialkey',
  3474.             
  3475.             'change',
  3476.             
  3477.             'invalid',
  3478.             
  3479.             'valid'
  3480.         );
  3481.     },
  3482.     
  3483.     getName : function(){
  3484.         return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || '';
  3485.     },
  3486.     
  3487.     onRender : function(ct, position){
  3488.         if(!this.el){
  3489.             var cfg = this.getAutoCreate();
  3490.             if(!cfg.name){
  3491.                 cfg.name = this.name || this.id;
  3492.             }
  3493.             if(this.inputType){
  3494.                 cfg.type = this.inputType;
  3495.             }
  3496.             this.autoEl = cfg;
  3497.         }
  3498.         Ext.form.Field.superclass.onRender.call(this, ct, position);
  3499.         if(this.submitValue === false){
  3500.             this.el.dom.removeAttribute('name');
  3501.         }
  3502.         var type = this.el.dom.type;
  3503.         if(type){
  3504.             if(type == 'password'){
  3505.                 type = 'text';
  3506.             }
  3507.             this.el.addClass('x-form-'+type);
  3508.         }
  3509.         if(this.readOnly){
  3510.             this.setReadOnly(true);
  3511.         }
  3512.         if(this.tabIndex !== undefined){
  3513.             this.el.dom.setAttribute('tabIndex', this.tabIndex);
  3514.         }
  3515.         this.el.addClass([this.fieldClass, this.cls]);
  3516.     },
  3517.     
  3518.     getItemCt : function(){
  3519.         return this.itemCt;
  3520.     },
  3521.     
  3522.     initValue : function(){
  3523.         if(this.value !== undefined){
  3524.             this.setValue(this.value);
  3525.         }else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){
  3526.             this.setValue(this.el.dom.value);
  3527.         }
  3528.         
  3529.         this.originalValue = this.getValue();
  3530.     },
  3531.     
  3532.     isDirty : function() {
  3533.         if(this.disabled || !this.rendered) {
  3534.             return false;
  3535.         }
  3536.         return String(this.getValue()) !== String(this.originalValue);
  3537.     },
  3538.     
  3539.     
  3540.     setReadOnly : function(readOnly){
  3541.         if(this.rendered){
  3542.             this.el.dom.readOnly = readOnly;
  3543.         }
  3544.         this.readOnly = readOnly;
  3545.     },
  3546.     
  3547.     afterRender : function(){
  3548.         Ext.form.Field.superclass.afterRender.call(this);
  3549.         this.initEvents();
  3550.         this.initValue();
  3551.     },
  3552.     
  3553.     fireKey : function(e){
  3554.         if(e.isSpecialKey()){
  3555.             this.fireEvent('specialkey', this, e);
  3556.         }
  3557.     },
  3558.     
  3559.     reset : function(){
  3560.         this.setValue(this.originalValue);
  3561.         this.clearInvalid();
  3562.     },
  3563.     
  3564.     initEvents : function(){
  3565.         this.mon(this.el, Ext.EventManager.useKeydown ? 'keydown' : 'keypress', this.fireKey,  this);
  3566.         this.mon(this.el, 'focus', this.onFocus, this);
  3567.         
  3568.         
  3569.         this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null);
  3570.     },
  3571.     
  3572.     preFocus: Ext.emptyFn,
  3573.     
  3574.     onFocus : function(){
  3575.         this.preFocus();
  3576.         if(this.focusClass){
  3577.             this.el.addClass(this.focusClass);
  3578.         }
  3579.         if(!this.hasFocus){
  3580.             this.hasFocus = true;
  3581.             
  3582.             this.startValue = this.getValue();
  3583.             this.fireEvent('focus', this);
  3584.         }
  3585.     },
  3586.     
  3587.     beforeBlur : Ext.emptyFn,
  3588.     
  3589.     onBlur : function(){
  3590.         this.beforeBlur();
  3591.         if(this.focusClass){
  3592.             this.el.removeClass(this.focusClass);
  3593.         }
  3594.         this.hasFocus = false;
  3595.         if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){
  3596.             this.validate();
  3597.         }
  3598.         var v = this.getValue();
  3599.         if(String(v) !== String(this.startValue)){
  3600.             this.fireEvent('change', this, v, this.startValue);
  3601.         }
  3602.         this.fireEvent('blur', this);
  3603.         this.postBlur();
  3604.     },
  3605.     
  3606.     postBlur : Ext.emptyFn,
  3607.     
  3608.     isValid : function(preventMark){
  3609.         if(this.disabled){
  3610.             return true;
  3611.         }
  3612.         var restore = this.preventMark;
  3613.         this.preventMark = preventMark === true;
  3614.         var v = this.validateValue(this.processValue(this.getRawValue()));
  3615.         this.preventMark = restore;
  3616.         return v;
  3617.     },
  3618.     
  3619.     validate : function(){
  3620.         if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){
  3621.             this.clearInvalid();
  3622.             return true;
  3623.         }
  3624.         return false;
  3625.     },
  3626.     
  3627.     processValue : function(value){
  3628.         return value;
  3629.     },
  3630.     
  3631.     validateValue : function(value){
  3632.         return true;
  3633.     },
  3634.     
  3635.     
  3636.     getActiveError : function(){
  3637.         return this.activeError || '';    
  3638.     },
  3639.     
  3640.     markInvalid : function(msg){
  3641.         if(!this.rendered || this.preventMark){ 
  3642.             return;
  3643.         }
  3644.         msg = msg || this.invalidText;
  3645.         var mt = this.getMessageHandler();
  3646.         if(mt){
  3647.             mt.mark(this, msg);
  3648.         }else if(this.msgTarget){
  3649.             this.el.addClass(this.invalidClass);
  3650.             var t = Ext.getDom(this.msgTarget);
  3651.             if(t){
  3652.                 t.innerHTML = msg;
  3653.                 t.style.display = this.msgDisplay;
  3654.             }
  3655.         }
  3656.         this.activeError = msg;
  3657.         this.fireEvent('invalid', this, msg);
  3658.     },
  3659.     
  3660.     clearInvalid : function(){
  3661.         if(!this.rendered || this.preventMark){ 
  3662.             return;
  3663.         }
  3664.         this.el.removeClass(this.invalidClass);
  3665.         var mt = this.getMessageHandler();
  3666.         if(mt){
  3667.             mt.clear(this);
  3668.         }else if(this.msgTarget){
  3669.             this.el.removeClass(this.invalidClass);
  3670.             var t = Ext.getDom(this.msgTarget);
  3671.             if(t){
  3672.                 t.innerHTML = '';
  3673.                 t.style.display = 'none';
  3674.             }
  3675.         }
  3676.         delete this.activeError;
  3677.         this.fireEvent('valid', this);
  3678.     },
  3679.     
  3680.     getMessageHandler : function(){
  3681.         return Ext.form.MessageTargets[this.msgTarget];
  3682.     },
  3683.     
  3684.     getErrorCt : function(){
  3685.         return this.el.findParent('.x-form-element', 5, true) || 
  3686.             this.el.findParent('.x-form-field-wrap', 5, true);   
  3687.     },
  3688.     
  3689.     alignErrorIcon : function(){
  3690.         this.errorIcon.alignTo(this.el, 'tl-tr', [2, 0]);
  3691.     },
  3692.     
  3693.     getRawValue : function(){
  3694.         var v = this.rendered ? this.el.getValue() : Ext.value(this.value, '');
  3695.         if(v === this.emptyText){
  3696.             v = '';
  3697.         }
  3698.         return v;
  3699.     },
  3700.     
  3701.     getValue : function(){
  3702.         if(!this.rendered) {
  3703.             return this.value;
  3704.         }
  3705.         var v = this.el.getValue();
  3706.         if(v === this.emptyText || v === undefined){
  3707.             v = '';
  3708.         }
  3709.         return v;
  3710.     },
  3711.     
  3712.     setRawValue : function(v){
  3713.         return this.rendered ? (this.el.dom.value = (Ext.isEmpty(v) ? '' : v)) : '';
  3714.     },
  3715.     
  3716.     setValue : function(v){
  3717.         this.value = v;
  3718.         if(this.rendered){
  3719.             this.el.dom.value = (Ext.isEmpty(v) ? '' : v);
  3720.             this.validate();
  3721.         }
  3722.         return this;
  3723.     },
  3724.     
  3725.     append : function(v){
  3726.          this.setValue([this.getValue(), v].join(''));
  3727.     }
  3728.     
  3729.     
  3730.     
  3731. });
  3732. Ext.form.MessageTargets = {
  3733.     'qtip' : {
  3734.         mark: function(field, msg){
  3735.             field.el.addClass(field.invalidClass);
  3736.             field.el.dom.qtip = msg;
  3737.             field.el.dom.qclass = 'x-form-invalid-tip';
  3738.             if(Ext.QuickTips){ 
  3739.                 Ext.QuickTips.enable();
  3740.             }
  3741.         },
  3742.         clear: function(field){
  3743.             field.el.removeClass(field.invalidClass);
  3744.             field.el.dom.qtip = '';
  3745.         }
  3746.     },
  3747.     'title' : {
  3748.         mark: function(field, msg){
  3749.             field.el.addClass(field.invalidClass);
  3750.             field.el.dom.title = msg;
  3751.         },
  3752.         clear: function(field){
  3753.             field.el.dom.title = '';
  3754.         }
  3755.     },
  3756.     'under' : {
  3757.         mark: function(field, msg){
  3758.             field.el.addClass(field.invalidClass);
  3759.             if(!field.errorEl){
  3760.                 var elp = field.getErrorCt();
  3761.                 if(!elp){ 
  3762.                     field.el.dom.title = msg;
  3763.                     return;
  3764.                 }
  3765.                 field.errorEl = elp.createChild({cls:'x-form-invalid-msg'});
  3766.                 field.errorEl.setWidth(elp.getWidth(true)-20);
  3767.             }
  3768.             field.errorEl.update(msg);
  3769.             Ext.form.Field.msgFx[field.msgFx].show(field.errorEl, field);
  3770.         },
  3771.         clear: function(field){
  3772.             field.el.removeClass(field.invalidClass);
  3773.             if(field.errorEl){
  3774.                 Ext.form.Field.msgFx[field.msgFx].hide(field.errorEl, field);
  3775.             }else{
  3776.                 field.el.dom.title = '';
  3777.             }
  3778.         }
  3779.     },
  3780.     'side' : {
  3781.         mark: function(field, msg){
  3782.             field.el.addClass(field.invalidClass);
  3783.             if(!field.errorIcon){
  3784.                 var elp = field.getErrorCt();
  3785.                 if(!elp){ 
  3786.                     field.el.dom.title = msg;
  3787.                     return;
  3788.                 }
  3789.                 field.errorIcon = elp.createChild({cls:'x-form-invalid-icon'});
  3790.             }
  3791.             field.alignErrorIcon();
  3792.             field.errorIcon.dom.qtip = msg;
  3793.             field.errorIcon.dom.qclass = 'x-form-invalid-tip';
  3794.             field.errorIcon.show();
  3795.             field.on('resize', field.alignErrorIcon, field);
  3796.         },
  3797.         clear: function(field){
  3798.             field.el.removeClass(field.invalidClass);
  3799.             if(field.errorIcon){
  3800.                 field.errorIcon.dom.qtip = '';
  3801.                 field.errorIcon.hide();
  3802.                 field.un('resize', field.alignErrorIcon, field);
  3803.             }else{
  3804.                 field.el.dom.title = '';
  3805.             }
  3806.         }
  3807.     }
  3808. };
  3809. Ext.form.Field.msgFx = {
  3810.     normal : {
  3811.         show: function(msgEl, f){
  3812.             msgEl.setDisplayed('block');
  3813.         },
  3814.         hide : function(msgEl, f){
  3815.             msgEl.setDisplayed(false).update('');
  3816.         }
  3817.     },
  3818.     slide : {
  3819.         show: function(msgEl, f){
  3820.             msgEl.slideIn('t', {stopFx:true});
  3821.         },
  3822.         hide : function(msgEl, f){
  3823.             msgEl.slideOut('t', {stopFx:true,useDisplay:true});
  3824.         }
  3825.     },
  3826.     slideRight : {
  3827.         show: function(msgEl, f){
  3828.             msgEl.fixDisplay();
  3829.             msgEl.alignTo(f.el, 'tl-tr');
  3830.             msgEl.slideIn('l', {stopFx:true});
  3831.         },
  3832.         hide : function(msgEl, f){
  3833.             msgEl.slideOut('l', {stopFx:true,useDisplay:true});
  3834.         }
  3835.     }
  3836. };
  3837. Ext.reg('field', Ext.form.Field);
  3838. Ext.form.TextField = Ext.extend(Ext.form.Field,  {
  3839.     
  3840.     
  3841.     
  3842.     grow : false,
  3843.     
  3844.     growMin : 30,
  3845.     
  3846.     growMax : 800,
  3847.     
  3848.     vtype : null,
  3849.     
  3850.     maskRe : null,
  3851.     
  3852.     disableKeyFilter : false,
  3853.     
  3854.     allowBlank : true,
  3855.     
  3856.     minLength : 0,
  3857.     
  3858.     maxLength : Number.MAX_VALUE,
  3859.     
  3860.     minLengthText : 'The minimum length for this field is {0}',
  3861.     
  3862.     maxLengthText : 'The maximum length for this field is {0}',
  3863.     
  3864.     selectOnFocus : false,
  3865.     
  3866.     blankText : 'This field is required',
  3867.     
  3868.     validator : null,
  3869.     
  3870.     regex : null,
  3871.     
  3872.     regexText : '',
  3873.     
  3874.     emptyText : null,
  3875.     
  3876.     emptyClass : 'x-form-empty-field',
  3877.     
  3878.     initComponent : function(){
  3879.         Ext.form.TextField.superclass.initComponent.call(this);
  3880.         this.addEvents(
  3881.             
  3882.             'autosize',
  3883.             
  3884.             'keydown',
  3885.             
  3886.             'keyup',
  3887.             
  3888.             'keypress'
  3889.         );
  3890.     },
  3891.     
  3892.     initEvents : function(){
  3893.         Ext.form.TextField.superclass.initEvents.call(this);
  3894.         if(this.validationEvent == 'keyup'){
  3895.             this.validationTask = new Ext.util.DelayedTask(this.validate, this);
  3896.             this.mon(this.el, 'keyup', this.filterValidation, this);
  3897.         }
  3898.         else if(this.validationEvent !== false && this.validationEvent != 'blur'){
  3899.          this.mon(this.el, this.validationEvent, this.validate, this, {buffer: this.validationDelay});
  3900.         }
  3901.         if(this.selectOnFocus || this.emptyText){            
  3902.             this.mon(this.el, 'mousedown', this.onMouseDown, this);
  3903.             
  3904.             if(this.emptyText){
  3905.                 this.applyEmptyText();
  3906.             }
  3907.         }
  3908.         if(this.maskRe || (this.vtype && this.disableKeyFilter !== true && (this.maskRe = Ext.form.VTypes[this.vtype+'Mask']))){
  3909.          this.mon(this.el, 'keypress', this.filterKeys, this);
  3910.         }
  3911.         if(this.grow){
  3912.          this.mon(this.el, 'keyup', this.onKeyUpBuffered, this, {buffer: 50});
  3913. this.mon(this.el, 'click', this.autoSize, this);
  3914.         }
  3915.         if(this.enableKeyEvents){
  3916.             this.mon(this.el, {
  3917.                 scope: this,
  3918.                 keyup: this.onKeyUp,
  3919.                 keydown: this.onKeyDown,
  3920.                 keypress: this.onKeyPress
  3921.             });
  3922.         }
  3923.     },
  3924.     
  3925.     onMouseDown: function(e){
  3926.         if(!this.hasFocus){
  3927.             this.mon(this.el, 'mouseup', Ext.emptyFn, this, { single: true, preventDefault: true });
  3928.         }
  3929.     },
  3930.     processValue : function(value){
  3931.         if(this.stripCharsRe){
  3932.             var newValue = value.replace(this.stripCharsRe, '');
  3933.             if(newValue !== value){
  3934.                 this.setRawValue(newValue);
  3935.                 return newValue;
  3936.             }
  3937.         }
  3938.         return value;
  3939.     },
  3940.     filterValidation : function(e){
  3941.         if(!e.isNavKeyPress()){
  3942.             this.validationTask.delay(this.validationDelay);
  3943.         }
  3944.     },
  3945.     
  3946.     
  3947.     onDisable: function(){
  3948.         Ext.form.TextField.superclass.onDisable.call(this);
  3949.         if(Ext.isIE){
  3950.             this.el.dom.unselectable = 'on';
  3951.         }
  3952.     },
  3953.     
  3954.     
  3955.     onEnable: function(){
  3956.         Ext.form.TextField.superclass.onEnable.call(this);
  3957.         if(Ext.isIE){
  3958.             this.el.dom.unselectable = '';
  3959.         }
  3960.     },
  3961.     
  3962.     onKeyUpBuffered : function(e){
  3963.         if(this.doAutoSize(e)){
  3964.             this.autoSize();
  3965.         }
  3966.     },
  3967.     
  3968.     
  3969.     doAutoSize : function(e){
  3970.         return !e.isNavKeyPress();
  3971.     },
  3972.     
  3973.     onKeyUp : function(e){
  3974.         this.fireEvent('keyup', this, e);
  3975.     },
  3976.     
  3977.     onKeyDown : function(e){
  3978.         this.fireEvent('keydown', this, e);
  3979.     },
  3980.     
  3981.     onKeyPress : function(e){
  3982.         this.fireEvent('keypress', this, e);
  3983.     },
  3984.     
  3985.     reset : function(){
  3986.         Ext.form.TextField.superclass.reset.call(this);
  3987.         this.applyEmptyText();
  3988.     },
  3989.     applyEmptyText : function(){
  3990.         if(this.rendered && this.emptyText && this.getRawValue().length < 1 && !this.hasFocus){
  3991.             this.setRawValue(this.emptyText);
  3992.             this.el.addClass(this.emptyClass);
  3993.         }
  3994.     },
  3995.     
  3996.     preFocus : function(){
  3997.         var el = this.el;
  3998.         if(this.emptyText){
  3999.             if(el.dom.value == this.emptyText){
  4000.                 this.setRawValue('');
  4001.             }
  4002.             el.removeClass(this.emptyClass);
  4003.         }
  4004.         if(this.selectOnFocus){
  4005.             el.dom.select();
  4006.         }
  4007.     },
  4008.     
  4009.     postBlur : function(){
  4010.         this.applyEmptyText();
  4011.     },
  4012.     
  4013.     filterKeys : function(e){
  4014.         if(e.ctrlKey){
  4015.             return;
  4016.         }
  4017.         var k = e.getKey();
  4018.         if(Ext.isGecko && (e.isNavKeyPress() || k == e.BACKSPACE || (k == e.DELETE && e.button == -1))){
  4019.             return;
  4020.         }
  4021.         var cc = String.fromCharCode(e.getCharCode());
  4022.         if(!Ext.isGecko && e.isSpecialKey() && !cc){
  4023.             return;
  4024.         }
  4025.         if(!this.maskRe.test(cc)){
  4026.             e.stopEvent();
  4027.         }
  4028.     },
  4029.     setValue : function(v){
  4030.         if(this.emptyText && this.el && !Ext.isEmpty(v)){
  4031.             this.el.removeClass(this.emptyClass);
  4032.         }
  4033.         Ext.form.TextField.superclass.setValue.apply(this, arguments);
  4034.         this.applyEmptyText();
  4035.         this.autoSize();
  4036.         return this;
  4037.     },
  4038.     
  4039.     validateValue : function(value){
  4040.         if(Ext.isFunction(this.validator)){
  4041.             var msg = this.validator(value);
  4042.             if(msg !== true){
  4043.                 this.markInvalid(msg);
  4044.                 return false;
  4045.             }
  4046.         }
  4047.         if(value.length < 1 || value === this.emptyText){ 
  4048.              if(this.allowBlank){
  4049.                  this.clearInvalid();
  4050.                  return true;
  4051.              }else{
  4052.                  this.markInvalid(this.blankText);
  4053.                  return false;
  4054.              }
  4055.         }
  4056.         if(value.length < this.minLength){
  4057.             this.markInvalid(String.format(this.minLengthText, this.minLength));
  4058.             return false;
  4059.         }
  4060.         if(value.length > this.maxLength){
  4061.             this.markInvalid(String.format(this.maxLengthText, this.maxLength));
  4062.             return false;
  4063.         }
  4064.         if(this.vtype){
  4065.             var vt = Ext.form.VTypes;
  4066.             if(!vt[this.vtype](value, this)){
  4067.                 this.markInvalid(this.vtypeText || vt[this.vtype +'Text']);
  4068.                 return false;
  4069.             }
  4070.         }
  4071.         if(this.regex && !this.regex.test(value)){
  4072.             this.markInvalid(this.regexText);
  4073.             return false;
  4074.         }
  4075.         return true;
  4076.     },
  4077.     
  4078.     selectText : function(start, end){
  4079.         var v = this.getRawValue();
  4080.         var doFocus = false;
  4081.         if(v.length > 0){
  4082.             start = start === undefined ? 0 : start;
  4083.             end = end === undefined ? v.length : end;
  4084.             var d = this.el.dom;
  4085.             if(d.setSelectionRange){
  4086.                 d.setSelectionRange(start, end);
  4087.             }else if(d.createTextRange){
  4088.                 var range = d.createTextRange();
  4089.                 range.moveStart('character', start);
  4090.                 range.moveEnd('character', end-v.length);
  4091.                 range.select();
  4092.             }
  4093.             doFocus = Ext.isGecko || Ext.isOpera;
  4094.         }else{
  4095.             doFocus = true;
  4096.         }
  4097.         if(doFocus){