ext-all-debug.js
上传用户:zaktkj
上传日期:2022-08-08
资源大小:5770k
文件大小:910k
源码类别:

JavaScript

开发平台:

JavaScript

  1.         var w = this.win;
  2.         this.proxy = w.ghost();
  3.         if(w.constrain !== false){
  4.             var so = w.el.shadowOffset;
  5.             this.constrainTo(w.container, {right: so, left: so, bottom: so});
  6.         }else if(w.constrainHeader !== false){
  7.             var s = this.proxy.getSize();
  8.             this.constrainTo(w.container, {right: -(s.width-this.headerOffsets[0]), bottom: -(s.height-this.headerOffsets[1])});
  9.         }
  10.     },
  11.     b4Drag : Ext.emptyFn,
  12.     onDrag : function(e){
  13.         this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY());
  14.     },
  15.     endDrag : function(e){
  16.         this.win.unghost();
  17.         this.win.saveState();
  18.     }
  19. });
  20. Ext.WindowGroup = function(){
  21.     var list = {};
  22.     var accessList = [];
  23.     var front = null;
  24.         var sortWindows = function(d1, d2){
  25.         return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1 : 1;
  26.     };
  27.         var orderWindows = function(){
  28.         var a = accessList, len = a.length;
  29.         if(len > 0){
  30.             a.sort(sortWindows);
  31.             var seed = a[0].manager.zseed;
  32.             for(var i = 0; i < len; i++){
  33.                 var win = a[i];
  34.                 if(win && !win.hidden){
  35.                     win.setZIndex(seed + (i*10));
  36.                 }
  37.             }
  38.         }
  39.         activateLast();
  40.     };
  41.         var setActiveWin = function(win){
  42.         if(win != front){
  43.             if(front){
  44.                 front.setActive(false);
  45.             }
  46.             front = win;
  47.             if(win){
  48.                 win.setActive(true);
  49.             }
  50.         }
  51.     };
  52.         var activateLast = function(){
  53.         for(var i = accessList.length-1; i >=0; --i) {
  54.             if(!accessList[i].hidden){
  55.                 setActiveWin(accessList[i]);
  56.                 return;
  57.             }
  58.         }
  59.                 setActiveWin(null);
  60.     };
  61.     return {
  62.         zseed : 9000,
  63.                 register : function(win){
  64.             list[win.id] = win;
  65.             accessList.push(win);
  66.             win.on('hide', activateLast);
  67.         },
  68.                 unregister : function(win){
  69.             delete list[win.id];
  70.             win.un('hide', activateLast);
  71.             accessList.remove(win);
  72.         },
  73.         get : function(id){
  74.             return typeof id == "object" ? id : list[id];
  75.         },
  76.         bringToFront : function(win){
  77.             win = this.get(win);
  78.             if(win != front){
  79.                 win._lastAccess = new Date().getTime();
  80.                 orderWindows();
  81.                 return true;
  82.             }
  83.             return false;
  84.         },
  85.         sendToBack : function(win){
  86.             win = this.get(win);
  87.             win._lastAccess = -(new Date().getTime());
  88.             orderWindows();
  89.             return win;
  90.         },
  91.         hideAll : function(){
  92.             for(var id in list){
  93.                 if(list[id] && typeof list[id] != "function" && list[id].isVisible()){
  94.                     list[id].hide();
  95.                 }
  96.             }
  97.         },
  98.         getActive : function(){
  99.             return front;
  100.         },
  101.         getBy : function(fn, scope){
  102.             var r = [];
  103.             for(var i = accessList.length-1; i >=0; --i) {
  104.                 var win = accessList[i];
  105.                 if(fn.call(scope||win, win) !== false){
  106.                     r.push(win);
  107.                 }
  108.             }
  109.             return r;
  110.         },
  111.         each : function(fn, scope){
  112.             for(var id in list){
  113.                 if(list[id] && typeof list[id] != "function"){
  114.                     if(fn.call(scope || list[id], list[id]) === false){
  115.                         return;
  116.                     }
  117.                 }
  118.             }
  119.         }
  120.     };
  121. };
  122. Ext.WindowMgr = new Ext.WindowGroup();
  123. Ext.dd.PanelProxy = function(panel, config){
  124.     this.panel = panel;
  125.     this.id = this.panel.id +'-ddproxy';
  126.     Ext.apply(this, config);
  127. };
  128. Ext.dd.PanelProxy.prototype = {
  129.     insertProxy : true,
  130.     setStatus : Ext.emptyFn,
  131.     reset : Ext.emptyFn,
  132.     update : Ext.emptyFn,
  133.     stop : Ext.emptyFn,
  134.     sync: Ext.emptyFn,
  135.     getEl : function(){
  136.         return this.ghost;
  137.     },
  138.     getGhost : function(){
  139.         return this.ghost;
  140.     },
  141.     getProxy : function(){
  142.         return this.proxy;
  143.     },
  144.     hide : function(){
  145.         if(this.ghost){
  146.             if(this.proxy){
  147.                 this.proxy.remove();
  148.                 delete this.proxy;
  149.             }
  150.             this.panel.el.dom.style.display = '';
  151.             this.ghost.remove();
  152.             delete this.ghost;
  153.         }
  154.     },
  155.     show : function(){
  156.         if(!this.ghost){
  157.             this.ghost = this.panel.createGhost(undefined, undefined, Ext.getBody());
  158.             this.ghost.setXY(this.panel.el.getXY())
  159.             if(this.insertProxy){
  160.                 this.proxy = this.panel.el.insertSibling({cls:'x-panel-dd-spacer'});
  161.                 this.proxy.setSize(this.panel.getSize());
  162.             }
  163.             this.panel.el.dom.style.display = 'none';
  164.         }
  165.     },
  166.     repair : function(xy, callback, scope){
  167.         this.hide();
  168.         if(typeof callback == "function"){
  169.             callback.call(scope || this);
  170.         }
  171.     },
  172.     moveProxy : function(parentNode, before){
  173.         if(this.proxy){
  174.             parentNode.insertBefore(this.proxy.dom, before);
  175.         }
  176.     }
  177. };
  178. Ext.Panel.DD = function(panel, cfg){
  179.     this.panel = panel;
  180.     this.dragData = {panel: panel};
  181.     this.proxy = new Ext.dd.PanelProxy(panel, cfg);
  182.     Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg);
  183.     this.setHandleElId(panel.header.id);
  184.     panel.header.setStyle('cursor', 'move');
  185.     this.scroll = false;
  186. };
  187. Ext.extend(Ext.Panel.DD, Ext.dd.DragSource, {
  188.     showFrame: Ext.emptyFn,
  189.     startDrag: Ext.emptyFn,
  190.     b4StartDrag: function(x, y) {
  191.         this.proxy.show();
  192.     },
  193.     b4MouseDown: function(e) {
  194.         var x = e.getPageX();
  195.         var y = e.getPageY();
  196.         this.autoOffset(x, y);
  197.     },
  198.     onInitDrag : function(x, y){
  199.         this.onStartDrag(x, y);
  200.         return true;
  201.     },
  202.     createFrame : Ext.emptyFn,
  203.     getDragEl : function(e){
  204.         return this.proxy.ghost.dom;
  205.     },
  206.     endDrag : function(e){
  207.         this.proxy.hide();
  208.         this.panel.saveState();
  209.     },
  210.     autoOffset : function(x, y) {
  211.         x -= this.startPageX;
  212.         y -= this.startPageY;
  213.         this.setDelta(x, y);
  214.     }
  215. });
  216. Ext.state.Provider = function(){
  217.     this.addEvents("statechange");
  218.     this.state = {};
  219.     Ext.state.Provider.superclass.constructor.call(this);
  220. };
  221. Ext.extend(Ext.state.Provider, Ext.util.Observable, {
  222.     get : function(name, defaultValue){
  223.         return typeof this.state[name] == "undefined" ?
  224.             defaultValue : this.state[name];
  225.     },
  226.     clear : function(name){
  227.         delete this.state[name];
  228.         this.fireEvent("statechange", this, name, null);
  229.     },
  230.     set : function(name, value){
  231.         this.state[name] = value;
  232.         this.fireEvent("statechange", this, name, value);
  233.     },
  234.     decodeValue : function(cookie){
  235.         var re = /^(a|n|d|b|s|o):(.*)$/;
  236.         var matches = re.exec(unescape(cookie));
  237.         if(!matches || !matches[1]) return;
  238.         var type = matches[1];
  239.         var v = matches[2];
  240.         switch(type){
  241.             case "n":
  242.                 return parseFloat(v);
  243.             case "d":
  244.                 return new Date(Date.parse(v));
  245.             case "b":
  246.                 return (v == "1");
  247.             case "a":
  248.                 var all = [];
  249.                 var values = v.split("^");
  250.                 for(var i = 0, len = values.length; i < len; i++){
  251.                     all.push(this.decodeValue(values[i]));
  252.                 }
  253.                 return all;
  254.            case "o":
  255.                 var all = {};
  256.                 var values = v.split("^");
  257.                 for(var i = 0, len = values.length; i < len; i++){
  258.                     var kv = values[i].split("=");
  259.                     all[kv[0]] = this.decodeValue(kv[1]);
  260.                 }
  261.                 return all;
  262.            default:
  263.                 return v;
  264.         }
  265.     },
  266.     encodeValue : function(v){
  267.         var enc;
  268.         if(typeof v == "number"){
  269.             enc = "n:" + v;
  270.         }else if(typeof v == "boolean"){
  271.             enc = "b:" + (v ? "1" : "0");
  272.         }else if(Ext.isDate(v)){
  273.             enc = "d:" + v.toGMTString();
  274.         }else if(Ext.isArray(v)){
  275.             var flat = "";
  276.             for(var i = 0, len = v.length; i < len; i++){
  277.                 flat += this.encodeValue(v[i]);
  278.                 if(i != len-1) flat += "^";
  279.             }
  280.             enc = "a:" + flat;
  281.         }else if(typeof v == "object"){
  282.             var flat = "";
  283.             for(var key in v){
  284.                 if(typeof v[key] != "function" && v[key] !== undefined){
  285.                     flat += key + "=" + this.encodeValue(v[key]) + "^";
  286.                 }
  287.             }
  288.             enc = "o:" + flat.substring(0, flat.length-1);
  289.         }else{
  290.             enc = "s:" + v;
  291.         }
  292.         return escape(enc);
  293.     }
  294. });
  295. Ext.state.Manager = function(){
  296.     var provider = new Ext.state.Provider();
  297.     return {
  298.         setProvider : function(stateProvider){
  299.             provider = stateProvider;
  300.         },
  301.         get : function(key, defaultValue){
  302.             return provider.get(key, defaultValue);
  303.         },
  304.          set : function(key, value){
  305.             provider.set(key, value);
  306.         },
  307.         clear : function(key){
  308.             provider.clear(key);
  309.         },
  310.         getProvider : function(){
  311.             return provider;
  312.         }
  313.     };
  314. }();
  315. Ext.state.CookieProvider = function(config){
  316.     Ext.state.CookieProvider.superclass.constructor.call(this);
  317.     this.path = "/";
  318.     this.expires = new Date(new Date().getTime()+(1000*60*60*24*7));
  319.     this.domain = null;
  320.     this.secure = false;
  321.     Ext.apply(this, config);
  322.     this.state = this.readCookies();
  323. };
  324. Ext.extend(Ext.state.CookieProvider, Ext.state.Provider, {
  325.     set : function(name, value){
  326.         if(typeof value == "undefined" || value === null){
  327.             this.clear(name);
  328.             return;
  329.         }
  330.         this.setCookie(name, value);
  331.         Ext.state.CookieProvider.superclass.set.call(this, name, value);
  332.     },
  333.     clear : function(name){
  334.         this.clearCookie(name);
  335.         Ext.state.CookieProvider.superclass.clear.call(this, name);
  336.     },
  337.     readCookies : function(){
  338.         var cookies = {};
  339.         var c = document.cookie + ";";
  340.         var re = /s?(.*?)=(.*?);/g;
  341.         var matches;
  342.         while((matches = re.exec(c)) != null){
  343.             var name = matches[1];
  344.             var value = matches[2];
  345.             if(name && name.substring(0,3) == "ys-"){
  346.                 cookies[name.substr(3)] = this.decodeValue(value);
  347.             }
  348.         }
  349.         return cookies;
  350.     },
  351.     setCookie : function(name, value){
  352.         document.cookie = "ys-"+ name + "=" + this.encodeValue(value) +
  353.            ((this.expires == null) ? "" : ("; expires=" + this.expires.toGMTString())) +
  354.            ((this.path == null) ? "" : ("; path=" + this.path)) +
  355.            ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
  356.            ((this.secure == true) ? "; secure" : "");
  357.     },
  358.     clearCookie : function(name){
  359.         document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" +
  360.            ((this.path == null) ? "" : ("; path=" + this.path)) +
  361.            ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
  362.            ((this.secure == true) ? "; secure" : "");
  363.     }
  364. });
  365. Ext.DataView = Ext.extend(Ext.BoxComponent, {
  366.     selectedClass : "x-view-selected",
  367.     emptyText : "",
  368.     last: false,
  369.     initComponent : function(){
  370.         Ext.DataView.superclass.initComponent.call(this);
  371.         if(typeof this.tpl == "string"){
  372.             this.tpl = new Ext.XTemplate(this.tpl);
  373.         }
  374.         this.addEvents(
  375.             "beforeclick",
  376.             "click",
  377.             "containerclick",
  378.             "dblclick",
  379.             "contextmenu",
  380.             "selectionchange",
  381.             "beforeselect"
  382.         );
  383.         this.all = new Ext.CompositeElementLite();
  384.         this.selected = new Ext.CompositeElementLite();
  385.     },
  386.     onRender : function(){
  387.         if(!this.el){
  388.             this.el = document.createElement('div');
  389.         }
  390.         Ext.DataView.superclass.onRender.apply(this, arguments);
  391.     },
  392.     afterRender : function(){
  393.         Ext.DataView.superclass.afterRender.call(this);
  394.         this.el.on({
  395.             "click": this.onClick,
  396.             "dblclick": this.onDblClick,
  397.             "contextmenu": this.onContextMenu,
  398.             scope:this
  399.         });
  400.         if(this.overClass){
  401.             this.el.on({
  402.                 "mouseover": this.onMouseOver,
  403.                 "mouseout": this.onMouseOut,
  404.                 scope:this
  405.             });
  406.         }
  407.         if(this.store){
  408.             this.setStore(this.store, true);
  409.         }
  410.     },
  411.     refresh : function(){
  412.         this.clearSelections(false, true);
  413.         this.el.update("");
  414.         var html = [];
  415.         var records = this.store.getRange();
  416.         if(records.length < 1){
  417.             this.el.update(this.emptyText);
  418.             this.all.clear();
  419.             return;
  420.         }
  421.         this.tpl.overwrite(this.el, this.collectData(records, 0));
  422.         this.all.fill(Ext.query(this.itemSelector, this.el.dom));
  423.         this.updateIndexes(0);
  424.     },
  425.     prepareData : function(data){
  426.         return data;
  427.     },
  428.     collectData : function(records, startIndex){
  429.         var r = [];
  430.         for(var i = 0, len = records.length; i < len; i++){
  431.             r[r.length] = this.prepareData(records[i].data, startIndex+i, records[i]);
  432.         }
  433.         return r;
  434.     },
  435.     bufferRender : function(records){
  436.         var div = document.createElement('div');
  437.         this.tpl.overwrite(div, this.collectData(records));
  438.         return Ext.query(this.itemSelector, div);
  439.     },
  440.     onUpdate : function(ds, record){
  441.         var index = this.store.indexOf(record);
  442.         var sel = this.isSelected(index);
  443.         var original = this.all.elements[index];
  444.         var node = this.bufferRender([record], index)[0];
  445.         this.all.replaceElement(index, node, true);
  446.         if(sel){
  447.             this.selected.replaceElement(original, node);
  448.             this.all.item(index).addClass(this.selectedClass);
  449.         }
  450.         this.updateIndexes(index, index);
  451.     },
  452.     onAdd : function(ds, records, index){
  453.         if(this.all.getCount() == 0){
  454.             this.refresh();
  455.             return;
  456.         }
  457.         var nodes = this.bufferRender(records, index), n;
  458.         if(index < this.all.getCount()){
  459.             n = this.all.item(index).insertSibling(nodes, 'before', true);
  460.             this.all.elements.splice(index, 0, n);
  461.         }else{
  462.             n = this.all.last().insertSibling(nodes, 'after', true);
  463.             this.all.elements.push(n);
  464.         }
  465.         this.updateIndexes(index);
  466.     },
  467.     onRemove : function(ds, record, index){
  468.         this.deselect(index);
  469.         this.all.removeElement(index, true);
  470.         this.updateIndexes(index);
  471.     },
  472.     refreshNode : function(index){
  473.         this.onUpdate(this.store, this.store.getAt(index));
  474.     },
  475.     updateIndexes : function(startIndex, endIndex){
  476.         var ns = this.all.elements;
  477.         startIndex = startIndex || 0;
  478.         endIndex = endIndex || ((endIndex === 0) ? 0 : (ns.length - 1));
  479.         for(var i = startIndex; i <= endIndex; i++){
  480.             ns[i].viewIndex = i;
  481.         }
  482.     },
  483.     setStore : function(store, initial){
  484.         if(!initial && this.store){
  485.             this.store.un("beforeload", this.onBeforeLoad, this);
  486.             this.store.un("datachanged", this.refresh, this);
  487.             this.store.un("add", this.onAdd, this);
  488.             this.store.un("remove", this.onRemove, this);
  489.             this.store.un("update", this.onUpdate, this);
  490.             this.store.un("clear", this.refresh, this);
  491.         }
  492.         if(store){
  493.             store = Ext.StoreMgr.lookup(store);
  494.             store.on("beforeload", this.onBeforeLoad, this);
  495.             store.on("datachanged", this.refresh, this);
  496.             store.on("add", this.onAdd, this);
  497.             store.on("remove", this.onRemove, this);
  498.             store.on("update", this.onUpdate, this);
  499.             store.on("clear", this.refresh, this);
  500.         }
  501.         this.store = store;
  502.         if(store){
  503.             this.refresh();
  504.         }
  505.     },
  506.     findItemFromChild : function(node){
  507.         return Ext.fly(node).findParent(this.itemSelector, this.el);
  508.     },
  509.     onClick : function(e){
  510.         var item = e.getTarget(this.itemSelector, this.el);
  511.         if(item){
  512.             var index = this.indexOf(item);
  513.             if(this.onItemClick(item, index, e) !== false){
  514.                 this.fireEvent("click", this, index, item, e);
  515.             }
  516.         }else{
  517.             if(this.fireEvent("containerclick", this, e) !== false){
  518.                 this.clearSelections();
  519.             }
  520.         }
  521.     },
  522.     onContextMenu : function(e){
  523.         var item = e.getTarget(this.itemSelector, this.el);
  524.         if(item){
  525.             this.fireEvent("contextmenu", this, this.indexOf(item), item, e);
  526.         }
  527.     },
  528.     onDblClick : function(e){
  529.         var item = e.getTarget(this.itemSelector, this.el);
  530.         if(item){
  531.             this.fireEvent("dblclick", this, this.indexOf(item), item, e);
  532.         }
  533.     },
  534.     onMouseOver : function(e){
  535.         var item = e.getTarget(this.itemSelector, this.el);
  536.         if(item && item !== this.lastItem){
  537.             this.lastItem = item;
  538.             Ext.fly(item).addClass(this.overClass);
  539.         }
  540.     },
  541.     onMouseOut : function(e){
  542.         if(this.lastItem){
  543.             if(!e.within(this.lastItem, true)){
  544.                 Ext.fly(this.lastItem).removeClass(this.overClass);
  545.                 delete this.lastItem;
  546.             }
  547.         }
  548.     },
  549.     onItemClick : function(item, index, e){
  550.         if(this.fireEvent("beforeclick", this, index, item, e) === false){
  551.             return false;
  552.         }
  553.         if(this.multiSelect){
  554.             this.doMultiSelection(item, index, e);
  555.             e.preventDefault();
  556.         }else if(this.singleSelect){
  557.             this.doSingleSelection(item, index, e);
  558.             e.preventDefault();
  559.         }
  560.         return true;
  561.     },
  562.     doSingleSelection : function(item, index, e){
  563.         if(e.ctrlKey && this.isSelected(index)){
  564.             this.deselect(index);
  565.         }else{
  566.             this.select(index, false);
  567.         }
  568.     },
  569.     doMultiSelection : function(item, index, e){
  570.         if(e.shiftKey && this.last !== false){
  571.             var last = this.last;
  572.             this.selectRange(last, index, e.ctrlKey);
  573.             this.last = last;
  574.         }else{
  575.             if((e.ctrlKey||this.simpleSelect) && this.isSelected(index)){
  576.                 this.deselect(index);
  577.             }else{
  578.                 this.select(index, e.ctrlKey || e.shiftKey || this.simpleSelect);
  579.             }
  580.         }
  581.     },
  582.     getSelectionCount : function(){
  583.         return this.selected.getCount()
  584.     },
  585.     getSelectedNodes : function(){
  586.         return this.selected.elements;
  587.     },
  588.     getSelectedIndexes : function(){
  589.         var indexes = [], s = this.selected.elements;
  590.         for(var i = 0, len = s.length; i < len; i++){
  591.             indexes.push(s[i].viewIndex);
  592.         }
  593.         return indexes;
  594.     },
  595.     getSelectedRecords : function(){
  596.         var r = [], s = this.selected.elements;
  597.         for(var i = 0, len = s.length; i < len; i++){
  598.             r[r.length] = this.store.getAt(s[i].viewIndex);
  599.         }
  600.         return r;
  601.     },
  602.     getRecords : function(nodes){
  603.         var r = [], s = nodes;
  604.         for(var i = 0, len = s.length; i < len; i++){
  605.             r[r.length] = this.store.getAt(s[i].viewIndex);
  606.         }
  607.         return r;
  608.     },
  609.     getRecord : function(node){
  610.         return this.store.getAt(node.viewIndex);
  611.     },
  612.     clearSelections : function(suppressEvent, skipUpdate){
  613.         if(this.multiSelect || this.singleSelect){
  614.             if(!skipUpdate){
  615.                 this.selected.removeClass(this.selectedClass);
  616.             }
  617.             this.selected.clear();
  618.             this.last = false;
  619.             if(!suppressEvent){
  620.                 this.fireEvent("selectionchange", this, this.selected.elements);
  621.             }
  622.         }
  623.     },
  624.     isSelected : function(node){
  625.         return this.selected.contains(this.getNode(node));
  626.     },
  627.     deselect : function(node){
  628.         if(this.isSelected(node)){
  629.             var node = this.getNode(node);
  630.             this.selected.removeElement(node);
  631.             if(this.last == node.viewIndex){
  632.                 this.last = false;
  633.             }
  634.             Ext.fly(node).removeClass(this.selectedClass);
  635.             this.fireEvent("selectionchange", this, this.selected.elements);
  636.         }
  637.     },
  638.     select : function(nodeInfo, keepExisting, suppressEvent){
  639.         if(Ext.isArray(nodeInfo)){
  640.             if(!keepExisting){
  641.                 this.clearSelections(true);
  642.             }
  643.             for(var i = 0, len = nodeInfo.length; i < len; i++){
  644.                 this.select(nodeInfo[i], true, true);
  645.             }
  646.         } else{
  647.             var node = this.getNode(nodeInfo);
  648.             if(!keepExisting){
  649.                 this.clearSelections(true);
  650.             }
  651.             if(node && !this.isSelected(node)){
  652.                 if(this.fireEvent("beforeselect", this, node, this.selected.elements) !== false){
  653.                     Ext.fly(node).addClass(this.selectedClass);
  654.                     this.selected.add(node);
  655.                     this.last = node.viewIndex;
  656.                     if(!suppressEvent){
  657.                         this.fireEvent("selectionchange", this, this.selected.elements);
  658.                     }
  659.                 }
  660.             }
  661.         }
  662.     },
  663.     selectRange : function(start, end, keepExisting){
  664.         if(!keepExisting){
  665.             this.clearSelections(true);
  666.         }
  667.         this.select(this.getNodes(start, end), true);
  668.     },
  669.     getNode : function(nodeInfo){
  670.         if(typeof nodeInfo == "string"){
  671.             return document.getElementById(nodeInfo);
  672.         }else if(typeof nodeInfo == "number"){
  673.             return this.all.elements[nodeInfo];
  674.         }
  675.         return nodeInfo;
  676.     },
  677.     getNodes : function(start, end){
  678.         var ns = this.all.elements;
  679.         start = start || 0;
  680.         end = typeof end == "undefined" ? ns.length - 1 : end;
  681.         var nodes = [], i;
  682.         if(start <= end){
  683.             for(i = start; i <= end; i++){
  684.                 nodes.push(ns[i]);
  685.             }
  686.         } else{
  687.             for(i = start; i >= end; i--){
  688.                 nodes.push(ns[i]);
  689.             }
  690.         }
  691.         return nodes;
  692.     },
  693.     indexOf : function(node){
  694.         node = this.getNode(node);
  695.         if(typeof node.viewIndex == "number"){
  696.             return node.viewIndex;
  697.         }
  698.         return this.all.indexOf(node);
  699.     },
  700.     onBeforeLoad : function(){
  701.         if(this.loadingText){
  702.             this.clearSelections(false, true);
  703.             this.el.update('<div class="loading-indicator">'+this.loadingText+'</div>');
  704.             this.all.clear();
  705.         }
  706.     }
  707. });
  708. Ext.reg('dataview', Ext.DataView);
  709. Ext.ColorPalette = function(config){
  710.     Ext.ColorPalette.superclass.constructor.call(this, config);
  711.     this.addEvents(
  712.         'select'
  713.     );
  714.     if(this.handler){
  715.         this.on("select", this.handler, this.scope, true);
  716.     }
  717. };
  718. Ext.extend(Ext.ColorPalette, Ext.Component, {
  719.     itemCls : "x-color-palette",
  720.     value : null,
  721.     clickEvent:'click',
  722.         ctype: "Ext.ColorPalette",
  723.     allowReselect : false,
  724.     colors : [
  725.         "000000", "993300", "333300", "003300", "003366", "000080", "333399", "333333",
  726.         "800000", "FF6600", "808000", "008000", "008080", "0000FF", "666699", "808080",
  727.         "FF0000", "FF9900", "99CC00", "339966", "33CCCC", "3366FF", "800080", "969696",
  728.         "FF00FF", "FFCC00", "FFFF00", "00FF00", "00FFFF", "00CCFF", "993366", "C0C0C0",
  729.         "FF99CC", "FFCC99", "FFFF99", "CCFFCC", "CCFFFF", "99CCFF", "CC99FF", "FFFFFF"
  730.     ],
  731.         onRender : function(container, position){
  732.         var t = this.tpl || new Ext.XTemplate(
  733.             '<tpl for="."><a href="#" class="color-{.}" hidefocus="on"><em><span style="background:#{.}" unselectable="on">&#160;</span></em></a></tpl>'
  734.         );
  735.         var el = document.createElement("div");
  736.         el.className = this.itemCls;
  737.         t.overwrite(el, this.colors);
  738.         container.dom.insertBefore(el, position);
  739.         this.el = Ext.get(el);
  740.         this.el.on(this.clickEvent, this.handleClick,  this, {delegate: "a"});
  741.         if(this.clickEvent != 'click'){
  742.             this.el.on('click', Ext.emptyFn,  this, {delegate: "a", preventDefault:true});
  743.         }
  744.     },
  745.         afterRender : function(){
  746.         Ext.ColorPalette.superclass.afterRender.call(this);
  747.         if(this.value){
  748.             var s = this.value;
  749.             this.value = null;
  750.             this.select(s);
  751.         }
  752.     },
  753.         handleClick : function(e, t){
  754.         e.preventDefault();
  755.         if(!this.disabled){
  756.             var c = t.className.match(/(?:^|s)color-(.{6})(?:s|$)/)[1];
  757.             this.select(c.toUpperCase());
  758.         }
  759.     },
  760.     select : function(color){
  761.         color = color.replace("#", "");
  762.         if(color != this.value || this.allowReselect){
  763.             var el = this.el;
  764.             if(this.value){
  765.                 el.child("a.color-"+this.value).removeClass("x-color-palette-sel");
  766.             }
  767.             el.child("a.color-"+color).addClass("x-color-palette-sel");
  768.             this.value = color;
  769.             this.fireEvent("select", this, color);
  770.         }
  771.     }
  772. });
  773. Ext.reg('colorpalette', Ext.ColorPalette);
  774. Ext.DatePicker = Ext.extend(Ext.Component, {
  775.     todayText : "Today",
  776.     okText : "&#160;OK&#160;",
  777.     cancelText : "Cancel",
  778.     todayTip : "{0} (Spacebar)",
  779.     minDate : null,
  780.     maxDate : null,
  781.     minText : "This date is before the minimum date",
  782.     maxText : "This date is after the maximum date",
  783.     format : "m/d/y",
  784.     disabledDays : null,
  785.     disabledDaysText : "",
  786.     disabledDatesRE : null,
  787.     disabledDatesText : "",
  788.     constrainToViewport : true,
  789.     monthNames : Date.monthNames,
  790.     dayNames : Date.dayNames,
  791.     nextText: 'Next Month (Control+Right)',
  792.     prevText: 'Previous Month (Control+Left)',
  793.     monthYearText: 'Choose a month (Control+Up/Down to move years)',
  794.     startDay : 0,
  795.     initComponent : function(){
  796.         Ext.DatePicker.superclass.initComponent.call(this);
  797.         this.value = this.value ?
  798.                  this.value.clearTime() : new Date().clearTime();
  799.         this.addEvents(
  800.             'select'
  801.         );
  802.         if(this.handler){
  803.             this.on("select", this.handler,  this.scope || this);
  804.         }
  805.         this.initDisabledDays();
  806.     },
  807.     initDisabledDays : function(){
  808.         if(!this.disabledDatesRE && this.disabledDates){
  809.             var dd = this.disabledDates;
  810.             var re = "(?:";
  811.             for(var i = 0; i < dd.length; i++){
  812.                 re += dd[i];
  813.                 if(i != dd.length-1) re += "|";
  814.             }
  815.             this.disabledDatesRE = new RegExp(re + ")");
  816.         }
  817.     },
  818.     setValue : function(value){
  819.         var old = this.value;
  820.         this.value = value.clearTime(true);
  821.         if(this.el){
  822.             this.update(this.value);
  823.         }
  824.     },
  825.     getValue : function(){
  826.         return this.value;
  827.     },
  828.     focus : function(){
  829.         if(this.el){
  830.             this.update(this.activeDate);
  831.         }
  832.     },
  833.     onRender : function(container, position){
  834.         var m = [
  835.              '<table cellspacing="0">',
  836.                 '<tr><td class="x-date-left"><a href="#" title="', this.prevText ,'">&#160;</a></td><td class="x-date-middle" align="center"></td><td class="x-date-right"><a href="#" title="', this.nextText ,'">&#160;</a></td></tr>',
  837.                 '<tr><td colspan="3"><table class="x-date-inner" cellspacing="0"><thead><tr>'];
  838.         var dn = this.dayNames;
  839.         for(var i = 0; i < 7; i++){
  840.             var d = this.startDay+i;
  841.             if(d > 6){
  842.                 d = d-7;
  843.             }
  844.             m.push("<th><span>", dn[d].substr(0,1), "</span></th>");
  845.         }
  846.         m[m.length] = "</tr></thead><tbody><tr>";
  847.         for(var i = 0; i < 42; i++) {
  848.             if(i % 7 == 0 && i != 0){
  849.                 m[m.length] = "</tr><tr>";
  850.             }
  851.             m[m.length] = '<td><a href="#" hidefocus="on" class="x-date-date" tabIndex="1"><em><span></span></em></a></td>';
  852.         }
  853.         m[m.length] = '</tr></tbody></table></td></tr><tr><td colspan="3" class="x-date-bottom" align="center"></td></tr></table><div class="x-date-mp"></div>';
  854.         var el = document.createElement("div");
  855.         el.className = "x-date-picker";
  856.         el.innerHTML = m.join("");
  857.         container.dom.insertBefore(el, position);
  858.         this.el = Ext.get(el);
  859.         this.eventEl = Ext.get(el.firstChild);
  860.         new Ext.util.ClickRepeater(this.el.child("td.x-date-left a"), {
  861.             handler: this.showPrevMonth,
  862.             scope: this,
  863.             preventDefault:true,
  864.             stopDefault:true
  865.         });
  866.         new Ext.util.ClickRepeater(this.el.child("td.x-date-right a"), {
  867.             handler: this.showNextMonth,
  868.             scope: this,
  869.             preventDefault:true,
  870.             stopDefault:true
  871.         });
  872.         this.eventEl.on("mousewheel", this.handleMouseWheel,  this);
  873.         this.monthPicker = this.el.down('div.x-date-mp');
  874.         this.monthPicker.enableDisplayMode('block');
  875.         var kn = new Ext.KeyNav(this.eventEl, {
  876.             "left" : function(e){
  877.                 e.ctrlKey ?
  878.                     this.showPrevMonth() :
  879.                     this.update(this.activeDate.add("d", -1));
  880.             },
  881.             "right" : function(e){
  882.                 e.ctrlKey ?
  883.                     this.showNextMonth() :
  884.                     this.update(this.activeDate.add("d", 1));
  885.             },
  886.             "up" : function(e){
  887.                 e.ctrlKey ?
  888.                     this.showNextYear() :
  889.                     this.update(this.activeDate.add("d", -7));
  890.             },
  891.             "down" : function(e){
  892.                 e.ctrlKey ?
  893.                     this.showPrevYear() :
  894.                     this.update(this.activeDate.add("d", 7));
  895.             },
  896.             "pageUp" : function(e){
  897.                 this.showNextMonth();
  898.             },
  899.             "pageDown" : function(e){
  900.                 this.showPrevMonth();
  901.             },
  902.             "enter" : function(e){
  903.                 e.stopPropagation();
  904.                 return true;
  905.             },
  906.             scope : this
  907.         });
  908.         this.eventEl.on("click", this.handleDateClick,  this, {delegate: "a.x-date-date"});
  909.         this.eventEl.addKeyListener(Ext.EventObject.SPACE, this.selectToday,  this);
  910.         this.el.unselectable();
  911.         this.cells = this.el.select("table.x-date-inner tbody td");
  912.         this.textNodes = this.el.query("table.x-date-inner tbody span");
  913.         this.mbtn = new Ext.Button({
  914.             text: "&#160;",
  915.             tooltip: this.monthYearText,
  916.             renderTo: this.el.child("td.x-date-middle", true)
  917.         });
  918.         this.mbtn.on('click', this.showMonthPicker, this);
  919.         this.mbtn.el.child(this.mbtn.menuClassTarget).addClass("x-btn-with-menu");
  920.         var today = (new Date()).dateFormat(this.format);
  921.         this.todayBtn = new Ext.Button({
  922.             renderTo: this.el.child("td.x-date-bottom", true),
  923.             text: String.format(this.todayText, today),
  924.             tooltip: String.format(this.todayTip, today),
  925.             handler: this.selectToday,
  926.             scope: this
  927.         });
  928.         if(Ext.isIE){
  929.             this.el.repaint();
  930.         }
  931.         this.update(this.value);
  932.     },
  933.     createMonthPicker : function(){
  934.         if(!this.monthPicker.dom.firstChild){
  935.             var buf = ['<table border="0" cellspacing="0">'];
  936.             for(var i = 0; i < 6; i++){
  937.                 buf.push(
  938.                     '<tr><td class="x-date-mp-month"><a href="#">', this.monthNames[i].substr(0, 3), '</a></td>',
  939.                     '<td class="x-date-mp-month x-date-mp-sep"><a href="#">', this.monthNames[i+6].substr(0, 3), '</a></td>',
  940.                     i == 0 ?
  941.                     '<td class="x-date-mp-ybtn" align="center"><a class="x-date-mp-prev"></a></td><td class="x-date-mp-ybtn" align="center"><a class="x-date-mp-next"></a></td></tr>' :
  942.                     '<td class="x-date-mp-year"><a href="#"></a></td><td class="x-date-mp-year"><a href="#"></a></td></tr>'
  943.                 );
  944.             }
  945.             buf.push(
  946.                 '<tr class="x-date-mp-btns"><td colspan="4"><button type="button" class="x-date-mp-ok">',
  947.                     this.okText,
  948.                     '</button><button type="button" class="x-date-mp-cancel">',
  949.                     this.cancelText,
  950.                     '</button></td></tr>',
  951.                 '</table>'
  952.             );
  953.             this.monthPicker.update(buf.join(''));
  954.             this.monthPicker.on('click', this.onMonthClick, this);
  955.             this.monthPicker.on('dblclick', this.onMonthDblClick, this);
  956.             this.mpMonths = this.monthPicker.select('td.x-date-mp-month');
  957.             this.mpYears = this.monthPicker.select('td.x-date-mp-year');
  958.             this.mpMonths.each(function(m, a, i){
  959.                 i += 1;
  960.                 if((i%2) == 0){
  961.                     m.dom.xmonth = 5 + Math.round(i * .5);
  962.                 }else{
  963.                     m.dom.xmonth = Math.round((i-1) * .5);
  964.                 }
  965.             });
  966.         }
  967.     },
  968.     showMonthPicker : function(){
  969.         this.createMonthPicker();
  970.         var size = this.el.getSize();
  971.         this.monthPicker.setSize(size);
  972.         this.monthPicker.child('table').setSize(size);
  973.         this.mpSelMonth = (this.activeDate || this.value).getMonth();
  974.         this.updateMPMonth(this.mpSelMonth);
  975.         this.mpSelYear = (this.activeDate || this.value).getFullYear();
  976.         this.updateMPYear(this.mpSelYear);
  977.         this.monthPicker.slideIn('t', {duration:.2});
  978.     },
  979.     updateMPYear : function(y){
  980.         this.mpyear = y;
  981.         var ys = this.mpYears.elements;
  982.         for(var i = 1; i <= 10; i++){
  983.             var td = ys[i-1], y2;
  984.             if((i%2) == 0){
  985.                 y2 = y + Math.round(i * .5);
  986.                 td.firstChild.innerHTML = y2;
  987.                 td.xyear = y2;
  988.             }else{
  989.                 y2 = y - (5-Math.round(i * .5));
  990.                 td.firstChild.innerHTML = y2;
  991.                 td.xyear = y2;
  992.             }
  993.             this.mpYears.item(i-1)[y2 == this.mpSelYear ? 'addClass' : 'removeClass']('x-date-mp-sel');
  994.         }
  995.     },
  996.     updateMPMonth : function(sm){
  997.         this.mpMonths.each(function(m, a, i){
  998.             m[m.dom.xmonth == sm ? 'addClass' : 'removeClass']('x-date-mp-sel');
  999.         });
  1000.     },
  1001.     selectMPMonth: function(m){
  1002.     },
  1003.     onMonthClick : function(e, t){
  1004.         e.stopEvent();
  1005.         var el = new Ext.Element(t), pn;
  1006.         if(el.is('button.x-date-mp-cancel')){
  1007.             this.hideMonthPicker();
  1008.         }
  1009.         else if(el.is('button.x-date-mp-ok')){
  1010.             this.update(new Date(this.mpSelYear, this.mpSelMonth, (this.activeDate || this.value).getDate()));
  1011.             this.hideMonthPicker();
  1012.         }
  1013.         else if(pn = el.up('td.x-date-mp-month', 2)){
  1014.             this.mpMonths.removeClass('x-date-mp-sel');
  1015.             pn.addClass('x-date-mp-sel');
  1016.             this.mpSelMonth = pn.dom.xmonth;
  1017.         }
  1018.         else if(pn = el.up('td.x-date-mp-year', 2)){
  1019.             this.mpYears.removeClass('x-date-mp-sel');
  1020.             pn.addClass('x-date-mp-sel');
  1021.             this.mpSelYear = pn.dom.xyear;
  1022.         }
  1023.         else if(el.is('a.x-date-mp-prev')){
  1024.             this.updateMPYear(this.mpyear-10);
  1025.         }
  1026.         else if(el.is('a.x-date-mp-next')){
  1027.             this.updateMPYear(this.mpyear+10);
  1028.         }
  1029.     },
  1030.     onMonthDblClick : function(e, t){
  1031.         e.stopEvent();
  1032.         var el = new Ext.Element(t), pn;
  1033.         if(pn = el.up('td.x-date-mp-month', 2)){
  1034.             this.update(new Date(this.mpSelYear, pn.dom.xmonth, (this.activeDate || this.value).getDate()));
  1035.             this.hideMonthPicker();
  1036.         }
  1037.         else if(pn = el.up('td.x-date-mp-year', 2)){
  1038.             this.update(new Date(pn.dom.xyear, this.mpSelMonth, (this.activeDate || this.value).getDate()));
  1039.             this.hideMonthPicker();
  1040.         }
  1041.     },
  1042.     hideMonthPicker : function(disableAnim){
  1043.         if(this.monthPicker){
  1044.             if(disableAnim === true){
  1045.                 this.monthPicker.hide();
  1046.             }else{
  1047.                 this.monthPicker.slideOut('t', {duration:.2});
  1048.             }
  1049.         }
  1050.     },
  1051.     showPrevMonth : function(e){
  1052.         this.update(this.activeDate.add("mo", -1));
  1053.     },
  1054.     showNextMonth : function(e){
  1055.         this.update(this.activeDate.add("mo", 1));
  1056.     },
  1057.     showPrevYear : function(){
  1058.         this.update(this.activeDate.add("y", -1));
  1059.     },
  1060.     showNextYear : function(){
  1061.         this.update(this.activeDate.add("y", 1));
  1062.     },
  1063.     handleMouseWheel : function(e){
  1064.         var delta = e.getWheelDelta();
  1065.         if(delta > 0){
  1066.             this.showPrevMonth();
  1067.             e.stopEvent();
  1068.         } else if(delta < 0){
  1069.             this.showNextMonth();
  1070.             e.stopEvent();
  1071.         }
  1072.     },
  1073.     handleDateClick : function(e, t){
  1074.         e.stopEvent();
  1075.         if(t.dateValue && !Ext.fly(t.parentNode).hasClass("x-date-disabled")){
  1076.             this.setValue(new Date(t.dateValue));
  1077.             this.fireEvent("select", this, this.value);
  1078.         }
  1079.     },
  1080.     selectToday : function(){
  1081.         this.setValue(new Date().clearTime());
  1082.         this.fireEvent("select", this, this.value);
  1083.     },
  1084.     update : function(date){
  1085.         var vd = this.activeDate;
  1086.         this.activeDate = date;
  1087.         if(vd && this.el){
  1088.             var t = date.getTime();
  1089.             if(vd.getMonth() == date.getMonth() && vd.getFullYear() == date.getFullYear()){
  1090.                 this.cells.removeClass("x-date-selected");
  1091.                 this.cells.each(function(c){
  1092.                    if(c.dom.firstChild.dateValue == t){
  1093.                        c.addClass("x-date-selected");
  1094.                        setTimeout(function(){
  1095.                             try{c.dom.firstChild.focus();}catch(e){}
  1096.                        }, 50);
  1097.                        return false;
  1098.                    }
  1099.                 });
  1100.                 return;
  1101.             }
  1102.         }
  1103.         var days = date.getDaysInMonth();
  1104.         var firstOfMonth = date.getFirstDateOfMonth();
  1105.         var startingPos = firstOfMonth.getDay()-this.startDay;
  1106.         if(startingPos <= this.startDay){
  1107.             startingPos += 7;
  1108.         }
  1109.         var pm = date.add("mo", -1);
  1110.         var prevStart = pm.getDaysInMonth()-startingPos;
  1111.         var cells = this.cells.elements;
  1112.         var textEls = this.textNodes;
  1113.         days += startingPos;
  1114.         var day = 86400000;
  1115.         var d = (new Date(pm.getFullYear(), pm.getMonth(), prevStart)).clearTime();
  1116.         var today = new Date().clearTime().getTime();
  1117.         var sel = date.clearTime().getTime();
  1118.         var min = this.minDate ? this.minDate.clearTime() : Number.NEGATIVE_INFINITY;
  1119.         var max = this.maxDate ? this.maxDate.clearTime() : Number.POSITIVE_INFINITY;
  1120.         var ddMatch = this.disabledDatesRE;
  1121.         var ddText = this.disabledDatesText;
  1122.         var ddays = this.disabledDays ? this.disabledDays.join("") : false;
  1123.         var ddaysText = this.disabledDaysText;
  1124.         var format = this.format;
  1125.         var setCellClass = function(cal, cell){
  1126.             cell.title = "";
  1127.             var t = d.getTime();
  1128.             cell.firstChild.dateValue = t;
  1129.             if(t == today){
  1130.                 cell.className += " x-date-today";
  1131.                 cell.title = cal.todayText;
  1132.             }
  1133.             if(t == sel){
  1134.                 cell.className += " x-date-selected";
  1135.                 setTimeout(function(){
  1136.                     try{cell.firstChild.focus();}catch(e){}
  1137.                 }, 50);
  1138.             }
  1139.             if(t < min) {
  1140.                 cell.className = " x-date-disabled";
  1141.                 cell.title = cal.minText;
  1142.                 return;
  1143.             }
  1144.             if(t > max) {
  1145.                 cell.className = " x-date-disabled";
  1146.                 cell.title = cal.maxText;
  1147.                 return;
  1148.             }
  1149.             if(ddays){
  1150.                 if(ddays.indexOf(d.getDay()) != -1){
  1151.                     cell.title = ddaysText;
  1152.                     cell.className = " x-date-disabled";
  1153.                 }
  1154.             }
  1155.             if(ddMatch && format){
  1156.                 var fvalue = d.dateFormat(format);
  1157.                 if(ddMatch.test(fvalue)){
  1158.                     cell.title = ddText.replace("%0", fvalue);
  1159.                     cell.className = " x-date-disabled";
  1160.                 }
  1161.             }
  1162.         };
  1163.         var i = 0;
  1164.         for(; i < startingPos; i++) {
  1165.             textEls[i].innerHTML = (++prevStart);
  1166.             d.setDate(d.getDate()+1);
  1167.             cells[i].className = "x-date-prevday";
  1168.             setCellClass(this, cells[i]);
  1169.         }
  1170.         for(; i < days; i++){
  1171.             intDay = i - startingPos + 1;
  1172.             textEls[i].innerHTML = (intDay);
  1173.             d.setDate(d.getDate()+1);
  1174.             cells[i].className = "x-date-active";
  1175.             setCellClass(this, cells[i]);
  1176.         }
  1177.         var extraDays = 0;
  1178.         for(; i < 42; i++) {
  1179.              textEls[i].innerHTML = (++extraDays);
  1180.              d.setDate(d.getDate()+1);
  1181.              cells[i].className = "x-date-nextday";
  1182.              setCellClass(this, cells[i]);
  1183.         }
  1184.         this.mbtn.setText(this.monthNames[date.getMonth()] + " " + date.getFullYear());
  1185.         if(!this.internalRender){
  1186.             var main = this.el.dom.firstChild;
  1187.             var w = main.offsetWidth;
  1188.             this.el.setWidth(w + this.el.getBorderWidth("lr"));
  1189.             Ext.fly(main).setWidth(w);
  1190.             this.internalRender = true;
  1191.             if(Ext.isOpera && !this.secondPass){
  1192.                 main.rows[0].cells[1].style.width = (w - (main.rows[0].cells[0].offsetWidth+main.rows[0].cells[2].offsetWidth)) + "px";
  1193.                 this.secondPass = true;
  1194.                 this.update.defer(10, this, [date]);
  1195.             }
  1196.         }
  1197.     },
  1198.     beforeDestroy : function() {
  1199.         this.mbtn.destroy();
  1200.         this.todayBtn.destroy();
  1201.     }
  1202. });
  1203. Ext.reg('datepicker', Ext.DatePicker);
  1204. Ext.TabPanel = Ext.extend(Ext.Panel,  {
  1205.     monitorResize : true,
  1206.     deferredRender : true,
  1207.     tabWidth: 120,
  1208.     minTabWidth: 30,
  1209.     resizeTabs:false,
  1210.     enableTabScroll: false,
  1211.     scrollIncrement : 0,
  1212.     scrollRepeatInterval : 400,
  1213.     scrollDuration : .35,
  1214.     animScroll : true,
  1215.     tabPosition: 'top',
  1216.     baseCls: 'x-tab-panel',
  1217.     autoTabs : false,
  1218.     autoTabSelector:'div.x-tab',
  1219.     activeTab : null,
  1220.     tabMargin : 2,
  1221.     plain: false,
  1222.     wheelIncrement : 20,
  1223.     idDelimiter : '__',
  1224.         itemCls : 'x-tab-item',
  1225.         elements: 'body',
  1226.     headerAsText: false,
  1227.     frame: false,
  1228.     hideBorders:true,
  1229.         initComponent : function(){
  1230.         this.frame = false;
  1231.         Ext.TabPanel.superclass.initComponent.call(this);
  1232.         this.addEvents(
  1233.             'beforetabchange',
  1234.             'tabchange',
  1235.             'contextmenu'
  1236.         );
  1237.         this.setLayout(new Ext.layout.CardLayout({
  1238.             deferredRender: this.deferredRender
  1239.         }));
  1240.         if(this.tabPosition == 'top'){
  1241.             this.elements += ',header';
  1242.             this.stripTarget = 'header';
  1243.         }else {
  1244.             this.elements += ',footer';
  1245.             this.stripTarget = 'footer';
  1246.         }
  1247.         if(!this.stack){
  1248.             this.stack = Ext.TabPanel.AccessStack();
  1249.         }
  1250.         this.initItems();
  1251.     },
  1252.         render : function(){
  1253.         Ext.TabPanel.superclass.render.apply(this, arguments);
  1254.         if(this.activeTab !== undefined){
  1255.             var item = this.activeTab;
  1256.             delete this.activeTab;
  1257.             this.setActiveTab(item);
  1258.         }
  1259.     },
  1260.         onRender : function(ct, position){
  1261.         Ext.TabPanel.superclass.onRender.call(this, ct, position);
  1262.         if(this.plain){
  1263.             var pos = this.tabPosition == 'top' ? 'header' : 'footer';
  1264.             this[pos].addClass('x-tab-panel-'+pos+'-plain');
  1265.         }
  1266.         var st = this[this.stripTarget];
  1267.         this.stripWrap = st.createChild({cls:'x-tab-strip-wrap', cn:{
  1268.             tag:'ul', cls:'x-tab-strip x-tab-strip-'+this.tabPosition}});
  1269.         this.stripSpacer = st.createChild({cls:'x-tab-strip-spacer'});
  1270.         this.strip = new Ext.Element(this.stripWrap.dom.firstChild);
  1271.         this.edge = this.strip.createChild({tag:'li', cls:'x-tab-edge'});
  1272.         this.strip.createChild({cls:'x-clear'});
  1273.         this.body.addClass('x-tab-panel-body-'+this.tabPosition);
  1274.         if(!this.itemTpl){
  1275.             var tt = new Ext.Template(
  1276.                  '<li class="{cls}" id="{id}"><a class="x-tab-strip-close" onclick="return false;"></a>',
  1277.                  '<a class="x-tab-right" href="#" onclick="return false;"><em class="x-tab-left">',
  1278.                  '<span class="x-tab-strip-inner"><span class="x-tab-strip-text {iconCls}">{text}</span></span>',
  1279.                  '</em></a></li>'
  1280.             );
  1281.             tt.disableFormats = true;
  1282.             tt.compile();
  1283.             Ext.TabPanel.prototype.itemTpl = tt;
  1284.         }
  1285.         this.items.each(this.initTab, this);
  1286.     },
  1287.         afterRender : function(){
  1288.         Ext.TabPanel.superclass.afterRender.call(this);
  1289.         if(this.autoTabs){
  1290.             this.readTabs(false);
  1291.         }
  1292.     },
  1293.         initEvents : function(){
  1294.         Ext.TabPanel.superclass.initEvents.call(this);
  1295.         this.on('add', this.onAdd, this);
  1296.         this.on('remove', this.onRemove, this);
  1297.         this.strip.on('mousedown', this.onStripMouseDown, this);
  1298.         this.strip.on('click', this.onStripClick, this);
  1299.         this.strip.on('contextmenu', this.onStripContextMenu, this);
  1300.         if(this.enableTabScroll){
  1301.             this.strip.on('mousewheel', this.onWheel, this);
  1302.         }
  1303.     },
  1304.         findTargets : function(e){
  1305.         var item = null;
  1306.         var itemEl = e.getTarget('li', this.strip);
  1307.         if(itemEl){
  1308.             item = this.getComponent(itemEl.id.split(this.idDelimiter)[1]);
  1309.             if(item.disabled){
  1310.                 return {
  1311.                     close : null,
  1312.                     item : null,
  1313.                     el : null
  1314.                 };
  1315.             }
  1316.         }
  1317.         return {
  1318.             close : e.getTarget('.x-tab-strip-close', this.strip),
  1319.             item : item,
  1320.             el : itemEl
  1321.         };
  1322.     },
  1323.         onStripMouseDown : function(e){
  1324.         e.preventDefault();
  1325.         if(e.button != 0){
  1326.             return;
  1327.         }
  1328.         var t = this.findTargets(e);
  1329.         if(t.close){
  1330.             this.remove(t.item);
  1331.             return;
  1332.         }
  1333.         if(t.item && t.item != this.activeTab){
  1334.             this.setActiveTab(t.item);
  1335.         }
  1336.     },
  1337.         onStripClick : function(e){
  1338.         var t = this.findTargets(e);
  1339.         if(!t.close && t.item && t.item != this.activeTab){
  1340.             this.setActiveTab(t.item);
  1341.         }
  1342.     },
  1343.         onStripContextMenu : function(e){
  1344.         e.preventDefault();
  1345.         var t = this.findTargets(e);
  1346.         if(t.item){
  1347.             this.fireEvent('contextmenu', this, t.item, e);
  1348.         }
  1349.     },
  1350.     readTabs : function(removeExisting){
  1351.         if(removeExisting === true){
  1352.             this.items.each(function(item){
  1353.                 this.remove(item);
  1354.             }, this);
  1355.         }
  1356.         var tabs = this.el.query(this.autoTabSelector);
  1357.         for(var i = 0, len = tabs.length; i < len; i++){
  1358.             var tab = tabs[i];
  1359.             var title = tab.getAttribute('title');
  1360.             tab.removeAttribute('title');
  1361.             this.add({
  1362.                 title: title,
  1363.                 el: tab
  1364.             });
  1365.         }
  1366.     },
  1367.         initTab : function(item, index){
  1368.         var before = this.strip.dom.childNodes[index];
  1369.         var cls = item.closable ? 'x-tab-strip-closable' : '';
  1370.         if(item.disabled){
  1371.             cls += ' x-item-disabled';
  1372.         }
  1373.         if(item.iconCls){
  1374.             cls += ' x-tab-with-icon';
  1375.         }
  1376.         if(item.tabCls){
  1377.             cls += ' ' + item.tabCls;
  1378.         }
  1379.         var p = {
  1380.             id: this.id + this.idDelimiter + item.getItemId(),
  1381.             text: item.title,
  1382.             cls: cls,
  1383.             iconCls: item.iconCls || ''
  1384.         };
  1385.         var el = before ?
  1386.                  this.itemTpl.insertBefore(before, p) :
  1387.                  this.itemTpl.append(this.strip, p);
  1388.         Ext.fly(el).addClassOnOver('x-tab-strip-over');
  1389.         if(item.tabTip){
  1390.             Ext.fly(el).child('span.x-tab-strip-text', true).qtip = item.tabTip;
  1391.         }
  1392.         item.on('disable', this.onItemDisabled, this);
  1393.         item.on('enable', this.onItemEnabled, this);
  1394.         item.on('titlechange', this.onItemTitleChanged, this);
  1395.         item.on('beforeshow', this.onBeforeShowItem, this);
  1396.     },
  1397.         onAdd : function(tp, item, index){
  1398.         this.initTab(item, index);
  1399.         if(this.items.getCount() == 1){
  1400.             this.syncSize();
  1401.         }
  1402.         this.delegateUpdates();
  1403.     },
  1404.         onBeforeAdd : function(item){
  1405.         var existing = item.events ? (this.items.containsKey(item.getItemId()) ? item : null) : this.items.get(item);
  1406.         if(existing){
  1407.             this.setActiveTab(item);
  1408.             return false;
  1409.         }
  1410.         Ext.TabPanel.superclass.onBeforeAdd.apply(this, arguments);
  1411.         var es = item.elements;
  1412.         item.elements = es ? es.replace(',header', '') : es;
  1413.         item.border = (item.border === true);
  1414.     },
  1415.         onRemove : function(tp, item){
  1416.         Ext.removeNode(this.getTabEl(item));
  1417.         this.stack.remove(item);
  1418.         if(item == this.activeTab){
  1419.             var next = this.stack.next();
  1420.             if(next){
  1421.                 this.setActiveTab(next);
  1422.             }else{
  1423.                 this.setActiveTab(0);
  1424.             }
  1425.         }
  1426.         this.delegateUpdates();
  1427.     },
  1428.         onBeforeShowItem : function(item){
  1429.         if(item != this.activeTab){
  1430.             this.setActiveTab(item);
  1431.             return false;
  1432.         }
  1433.     },
  1434.         onItemDisabled : function(item){
  1435.         var el = this.getTabEl(item);
  1436.         if(el){
  1437.             Ext.fly(el).addClass('x-item-disabled');
  1438.         }
  1439.         this.stack.remove(item);
  1440.     },
  1441.         onItemEnabled : function(item){
  1442.         var el = this.getTabEl(item);
  1443.         if(el){
  1444.             Ext.fly(el).removeClass('x-item-disabled');
  1445.         }
  1446.     },
  1447.         onItemTitleChanged : function(item){
  1448.         var el = this.getTabEl(item);
  1449.         if(el){
  1450.             Ext.fly(el).child('span.x-tab-strip-text', true).innerHTML = item.title;
  1451.         }
  1452.     },
  1453.     getTabEl : function(item){
  1454.         var itemId = (typeof item === 'number')?this.items.items[item].getItemId() : item.getItemId();
  1455.         return document.getElementById(this.id+this.idDelimiter+itemId);
  1456.     },
  1457.         onResize : function(){
  1458.         Ext.TabPanel.superclass.onResize.apply(this, arguments);
  1459.         this.delegateUpdates();
  1460.     },
  1461.     beginUpdate : function(){
  1462.         this.suspendUpdates = true;
  1463.     },
  1464.     endUpdate : function(){
  1465.         this.suspendUpdates = false;
  1466.         this.delegateUpdates();
  1467.     },
  1468.     hideTabStripItem : function(item){
  1469.         item = this.getComponent(item);
  1470.         var el = this.getTabEl(item);
  1471.         if(el){
  1472.             el.style.display = 'none';
  1473.             this.delegateUpdates();
  1474.         }
  1475.     },
  1476.     unhideTabStripItem : function(item){
  1477.         item = this.getComponent(item);
  1478.         var el = this.getTabEl(item);
  1479.         if(el){
  1480.             el.style.display = '';
  1481.             this.delegateUpdates();
  1482.         }
  1483.     },
  1484.         delegateUpdates : function(){
  1485.         if(this.suspendUpdates){
  1486.             return;
  1487.         }
  1488.         if(this.resizeTabs && this.rendered){
  1489.             this.autoSizeTabs();
  1490.         }
  1491.         if(this.enableTabScroll && this.rendered){
  1492.             this.autoScrollTabs();
  1493.         }
  1494.     },
  1495.         autoSizeTabs : function(){
  1496.         var count = this.items.length;
  1497.         var ce = this.tabPosition != 'bottom' ? 'header' : 'footer';
  1498.         var ow = this[ce].dom.offsetWidth;
  1499.         var aw = this[ce].dom.clientWidth;
  1500.         if(!this.resizeTabs || count < 1 || !aw){             return;
  1501.         }
  1502.         var each = Math.max(Math.min(Math.floor((aw-4) / count) - this.tabMargin, this.tabWidth), this.minTabWidth);         this.lastTabWidth = each;
  1503.         var lis = this.stripWrap.dom.getElementsByTagName('li');
  1504.         for(var i = 0, len = lis.length-1; i < len; i++) {             var li = lis[i];
  1505.             var inner = li.childNodes[1].firstChild.firstChild;
  1506.             var tw = li.offsetWidth;
  1507.             var iw = inner.offsetWidth;
  1508.             inner.style.width = (each - (tw-iw)) + 'px';
  1509.         }
  1510.     },
  1511.         adjustBodyWidth : function(w){
  1512.         if(this.header){
  1513.             this.header.setWidth(w);
  1514.         }
  1515.         if(this.footer){
  1516.             this.footer.setWidth(w);
  1517.         }
  1518.         return w;
  1519.     },
  1520.     setActiveTab : function(item){
  1521.         item = this.getComponent(item);
  1522.         if(!item || this.fireEvent('beforetabchange', this, item, this.activeTab) === false){
  1523.             return;
  1524.         }
  1525.         if(!this.rendered){
  1526.             this.activeTab = item;
  1527.             return;
  1528.         }
  1529.         if(this.activeTab != item){
  1530.             if(this.activeTab){
  1531.                 var oldEl = this.getTabEl(this.activeTab);
  1532.                 if(oldEl){
  1533.                     Ext.fly(oldEl).removeClass('x-tab-strip-active');
  1534.                 }
  1535.                 this.activeTab.fireEvent('deactivate', this.activeTab);
  1536.             }
  1537.             var el = this.getTabEl(item);
  1538.             Ext.fly(el).addClass('x-tab-strip-active');
  1539.             this.activeTab = item;
  1540.             this.stack.add(item);
  1541.             this.layout.setActiveItem(item);
  1542.             if(this.layoutOnTabChange && item.doLayout){
  1543.                 item.doLayout();
  1544.             }
  1545.             if(this.scrolling){
  1546.                 this.scrollToTab(item, this.animScroll);
  1547.             }
  1548.             item.fireEvent('activate', item);
  1549.             this.fireEvent('tabchange', this, item);
  1550.         }
  1551.     },
  1552.     getActiveTab : function(){
  1553.         return this.activeTab || null;
  1554.     },
  1555.     getItem : function(item){
  1556.         return this.getComponent(item);
  1557.     },
  1558.         autoScrollTabs : function(){
  1559.         var count = this.items.length;
  1560.         var ow = this.header.dom.offsetWidth;
  1561.         var tw = this.header.dom.clientWidth;
  1562.         var wrap = this.stripWrap;
  1563.         var wd = wrap.dom;
  1564.         var cw = wd.offsetWidth;
  1565.         var pos = this.getScrollPos();
  1566.         var l = this.edge.getOffsetsTo(this.stripWrap)[0] + pos;
  1567.         if(!this.enableTabScroll || count < 1 || cw < 20){             return;
  1568.         }
  1569.         if(l <= tw){
  1570.             wd.scrollLeft = 0;
  1571.             wrap.setWidth(tw);
  1572.             if(this.scrolling){
  1573.                 this.scrolling = false;
  1574.                 this.header.removeClass('x-tab-scrolling');
  1575.                 this.scrollLeft.hide();
  1576.                 this.scrollRight.hide();
  1577.                 if(Ext.isAir){
  1578.                     wd.style.marginLeft = '';
  1579.                     wd.style.marginRight = '';
  1580.                 }
  1581.             }
  1582.         }else{
  1583.             if(!this.scrolling){
  1584.                 this.header.addClass('x-tab-scrolling');
  1585.                 if(Ext.isAir){
  1586.                     wd.style.marginLeft = '18px';
  1587.                     wd.style.marginRight = '18px';
  1588.                 }
  1589.             }
  1590.             tw -= wrap.getMargins('lr');
  1591.             wrap.setWidth(tw > 20 ? tw : 20);
  1592.             if(!this.scrolling){
  1593.                 if(!this.scrollLeft){
  1594.                     this.createScrollers();
  1595.                 }else{
  1596.                     this.scrollLeft.show();
  1597.                     this.scrollRight.show();
  1598.                 }
  1599.             }
  1600.             this.scrolling = true;
  1601.             if(pos > (l-tw)){                 wd.scrollLeft = l-tw;
  1602.             }else{                 this.scrollToTab(this.activeTab, false);
  1603.             }
  1604.             this.updateScrollButtons();
  1605.         }
  1606.     },
  1607.         createScrollers : function(){
  1608.         var h = this.stripWrap.dom.offsetHeight;
  1609.                 var sl = this.header.insertFirst({
  1610.             cls:'x-tab-scroller-left'
  1611.         });
  1612.         sl.setHeight(h);
  1613.         sl.addClassOnOver('x-tab-scroller-left-over');
  1614.         this.leftRepeater = new Ext.util.ClickRepeater(sl, {
  1615.             interval : this.scrollRepeatInterval,
  1616.             handler: this.onScrollLeft,
  1617.             scope: this
  1618.         });
  1619.         this.scrollLeft = sl;
  1620.                 var sr = this.header.insertFirst({
  1621.             cls:'x-tab-scroller-right'
  1622.         });
  1623.         sr.setHeight(h);
  1624.         sr.addClassOnOver('x-tab-scroller-right-over');
  1625.         this.rightRepeater = new Ext.util.ClickRepeater(sr, {
  1626.             interval : this.scrollRepeatInterval,
  1627.             handler: this.onScrollRight,
  1628.             scope: this
  1629.         });
  1630.         this.scrollRight = sr;
  1631.     },
  1632.         getScrollWidth : function(){
  1633.         return this.edge.getOffsetsTo(this.stripWrap)[0] + this.getScrollPos();
  1634.     },
  1635.         getScrollPos : function(){
  1636.         return parseInt(this.stripWrap.dom.scrollLeft, 10) || 0;
  1637.     },
  1638.         getScrollArea : function(){
  1639.         return parseInt(this.stripWrap.dom.clientWidth, 10) || 0;
  1640.     },
  1641.         getScrollAnim : function(){
  1642.         return {duration:this.scrollDuration, callback: this.updateScrollButtons, scope: this};
  1643.     },
  1644.         getScrollIncrement : function(){
  1645.         return this.scrollIncrement || (this.resizeTabs ? this.lastTabWidth+2 : 100);
  1646.     },
  1647.     scrollToTab : function(item, animate){
  1648.         if(!item){ return; }
  1649.         var el = this.getTabEl(item);
  1650.         var pos = this.getScrollPos(), area = this.getScrollArea();
  1651.         var left = Ext.fly(el).getOffsetsTo(this.stripWrap)[0] + pos;
  1652.         var right = left + el.offsetWidth;
  1653.         if(left < pos){
  1654.             this.scrollTo(left, animate);
  1655.         }else if(right > (pos + area)){
  1656.             this.scrollTo(right - area, animate);
  1657.         }
  1658.     },
  1659.         scrollTo : function(pos, animate){
  1660.         this.stripWrap.scrollTo('left', pos, animate ? this.getScrollAnim() : false);
  1661.         if(!animate){
  1662.             this.updateScrollButtons();
  1663.         }
  1664.     },
  1665.     onWheel : function(e){
  1666.         var d = e.getWheelDelta()*this.wheelIncrement*-1;
  1667.         e.stopEvent();
  1668.         var pos = this.getScrollPos();
  1669.         var newpos = pos + d;
  1670.         var sw = this.getScrollWidth()-this.getScrollArea();
  1671.         var s = Math.max(0, Math.min(sw, newpos));
  1672.         if(s != pos){
  1673.             this.scrollTo(s, false);
  1674.         }
  1675.     },
  1676.         onScrollRight : function(){
  1677.         var sw = this.getScrollWidth()-this.getScrollArea();
  1678.         var pos = this.getScrollPos();
  1679.         var s = Math.min(sw, pos + this.getScrollIncrement());
  1680.         if(s != pos){
  1681.             this.scrollTo(s, this.animScroll);
  1682.         }
  1683.     },
  1684.         onScrollLeft : function(){
  1685.         var pos = this.getScrollPos();
  1686.         var s = Math.max(0, pos - this.getScrollIncrement());
  1687.         if(s != pos){
  1688.             this.scrollTo(s, this.animScroll);
  1689.         }
  1690.     },
  1691.         updateScrollButtons : function(){
  1692.         var pos = this.getScrollPos();
  1693.         this.scrollLeft[pos == 0 ? 'addClass' : 'removeClass']('x-tab-scroller-left-disabled');
  1694.         this.scrollRight[pos >= (this.getScrollWidth()-this.getScrollArea()) ? 'addClass' : 'removeClass']('x-tab-scroller-right-disabled');
  1695.     }
  1696. });
  1697. Ext.reg('tabpanel', Ext.TabPanel);
  1698. Ext.TabPanel.prototype.activate = Ext.TabPanel.prototype.setActiveTab;
  1699. Ext.TabPanel.AccessStack = function(){
  1700.     var items = [];
  1701.     return {
  1702.         add : function(item){
  1703.             items.push(item);
  1704.             if(items.length > 10){
  1705.                 items.shift();
  1706.             }
  1707.         },
  1708.         remove : function(item){
  1709.             var s = [];
  1710.             for(var i = 0, len = items.length; i < len; i++) {
  1711.                 if(items[i] != item){
  1712.                     s.push(items[i]);
  1713.                 }
  1714.             }
  1715.             items = s;
  1716.         },
  1717.         next : function(){
  1718.             return items.pop();
  1719.         }
  1720.     };
  1721. };
  1722. Ext.Button = Ext.extend(Ext.Component, {
  1723.     hidden : false,
  1724.     disabled : false,
  1725.     pressed : false,
  1726.     enableToggle: false,
  1727.     menuAlign : "tl-bl?",
  1728.     type : 'button',
  1729.         menuClassTarget: 'tr',
  1730.     clickEvent : 'click',
  1731.     handleMouseEvents : true,
  1732.     tooltipType : 'qtip',
  1733.     buttonSelector : "button:first",
  1734.     initComponent : function(){
  1735.         Ext.Button.superclass.initComponent.call(this);
  1736.         this.addEvents(
  1737.             "click",
  1738.             "toggle",
  1739.             'mouseover',
  1740.             'mouseout',
  1741.             'menushow',
  1742.             'menuhide',
  1743.             'menutriggerover',
  1744.             'menutriggerout'
  1745.         );
  1746.         if(this.menu){
  1747.             this.menu = Ext.menu.MenuMgr.get(this.menu);
  1748.         }
  1749.         if(typeof this.toggleGroup === 'string'){
  1750.             this.enableToggle = true;
  1751.         }
  1752.     },
  1753.         onRender : function(ct, position){
  1754.         if(!this.template){
  1755.             if(!Ext.Button.buttonTemplate){
  1756.                                 Ext.Button.buttonTemplate = new Ext.Template(
  1757.                     '<table border="0" cellpadding="0" cellspacing="0" class="x-btn-wrap"><tbody><tr>',
  1758.                     '<td class="x-btn-left"><i>&#160;</i></td><td class="x-btn-center"><em unselectable="on"><button class="x-btn-text" type="{1}">{0}</button></em></td><td class="x-btn-right"><i>&#160;</i></td>',
  1759.                     "</tr></tbody></table>");
  1760.             }
  1761.             this.template = Ext.Button.buttonTemplate;
  1762.         }
  1763.         var btn, targs = [this.text || '&#160;', this.type];
  1764.         if(position){
  1765.             btn = this.template.insertBefore(position, targs, true);
  1766.         }else{
  1767.             btn = this.template.append(ct, targs, true);
  1768.         }
  1769.         var btnEl = btn.child(this.buttonSelector);
  1770.         btnEl.on('focus', this.onFocus, this);
  1771.         btnEl.on('blur', this.onBlur, this);
  1772.         this.initButtonEl(btn, btnEl);
  1773.         if(this.menu){
  1774.             this.el.child(this.menuClassTarget).addClass("x-btn-with-menu");
  1775.         }
  1776.         Ext.ButtonToggleMgr.register(this);
  1777.     },
  1778.         initButtonEl : function(btn, btnEl){
  1779.         this.el = btn;
  1780.         btn.addClass("x-btn");
  1781.         if(this.icon){
  1782.             btnEl.setStyle('background-image', 'url(' +this.icon +')');
  1783.         }
  1784.         if(this.iconCls){
  1785.             btnEl.addClass(this.iconCls);
  1786.             if(!this.cls){
  1787.                 btn.addClass(this.text ? 'x-btn-text-icon' : 'x-btn-icon');
  1788.             }
  1789.         }
  1790.         if(this.tabIndex !== undefined){
  1791.             btnEl.dom.tabIndex = this.tabIndex;
  1792.         }
  1793.         if(this.tooltip){
  1794.             if(typeof this.tooltip == 'object'){
  1795.                 Ext.QuickTips.register(Ext.apply({
  1796.                       target: btnEl.id
  1797.                 }, this.tooltip));
  1798.             } else {
  1799.                 btnEl.dom[this.tooltipType] = this.tooltip;
  1800.             }
  1801.         }
  1802.         if(this.pressed){
  1803.             this.el.addClass("x-btn-pressed");
  1804.         }
  1805.         if(this.handleMouseEvents){
  1806.             btn.on("mouseover", this.onMouseOver, this);
  1807.                                     btn.on("mousedown", this.onMouseDown, this);
  1808.         }
  1809.         if(this.menu){
  1810.             this.menu.on("show", this.onMenuShow, this);
  1811.             this.menu.on("hide", this.onMenuHide, this);
  1812.         }
  1813.         if(this.id){
  1814.             this.el.dom.id = this.el.id = this.id;
  1815.         }
  1816.         if(this.repeat){
  1817.             var repeater = new Ext.util.ClickRepeater(btn,
  1818.                 typeof this.repeat == "object" ? this.repeat : {}
  1819.             );
  1820.             repeater.on("click", this.onClick,  this);
  1821.         }
  1822.         btn.on(this.clickEvent, this.onClick, this);
  1823.     },
  1824.         afterRender : function(){
  1825.         Ext.Button.superclass.afterRender.call(this);
  1826.         if(Ext.isIE6){
  1827.             this.autoWidth.defer(1, this);
  1828.         }else{
  1829.             this.autoWidth();
  1830.         }
  1831.     },
  1832.     setIconClass : function(cls){
  1833.         if(this.el){
  1834.             this.el.child(this.buttonSelector).replaceClass(this.iconCls, cls);
  1835.         }
  1836.         this.iconCls = cls;
  1837.     },
  1838.         beforeDestroy: function(){
  1839.         if(this.rendered){
  1840.             var btn = this.el.child(this.buttonSelector);
  1841.             if(btn){
  1842.                 btn.removeAllListeners();
  1843.             }
  1844.         }
  1845.         if(this.menu){
  1846.             Ext.destroy(this.menu);
  1847.         }
  1848.     },
  1849.         onDestroy : function(){
  1850.         if(this.rendered){
  1851.             Ext.ButtonToggleMgr.unregister(this);
  1852.         }
  1853.     },
  1854.         autoWidth : function(){
  1855.         if(this.el){
  1856.             this.el.setWidth("auto");
  1857.             if(Ext.isIE7 && Ext.isStrict){
  1858.                 var ib = this.el.child(this.buttonSelector);
  1859.                 if(ib && ib.getWidth() > 20){
  1860.                     ib.clip();
  1861.                     ib.setWidth(Ext.util.TextMetrics.measure(ib, this.text).width+ib.getFrameWidth('lr'));
  1862.                 }
  1863.             }
  1864.             if(this.minWidth){
  1865.                 if(this.el.getWidth() < this.minWidth){
  1866.                     this.el.setWidth(this.minWidth);
  1867.                 }
  1868.             }
  1869.         }
  1870.     },
  1871.     setHandler : function(handler, scope){
  1872.         this.handler = handler;
  1873.         this.scope = scope;
  1874.     },
  1875.     setText : function(text){
  1876.         this.text = text;
  1877.         if(this.el){
  1878.             this.el.child("td.x-btn-center " + this.buttonSelector).update(text);
  1879.         }
  1880.         this.autoWidth();
  1881.     },
  1882.     getText : function(){
  1883.         return this.text;
  1884.     },
  1885.     toggle : function(state){
  1886.         state = state === undefined ? !this.pressed : state;
  1887.         if(state != this.pressed){
  1888.             if(state){
  1889.                 this.el.addClass("x-btn-pressed");
  1890.                 this.pressed = true;
  1891.                 this.fireEvent("toggle", this, true);
  1892.             }else{
  1893.                 this.el.removeClass("x-btn-pressed");
  1894.                 this.pressed = false;
  1895.                 this.fireEvent("toggle", this, false);
  1896.             }
  1897.             if(this.toggleHandler){
  1898.                 this.toggleHandler.call(this.scope || this, this, state);
  1899.             }
  1900.         }
  1901.     },
  1902.     focus : function(){
  1903.         this.el.child(this.buttonSelector).focus();
  1904.     },
  1905.         onDisable : function(){
  1906.         if(this.el){
  1907.             if(!Ext.isIE6 || !this.text){
  1908.                 this.el.addClass(this.disabledClass);
  1909.             }
  1910.             this.el.dom.disabled = true;
  1911.         }
  1912.         this.disabled = true;
  1913.     },
  1914.         onEnable : function(){
  1915.         if(this.el){
  1916.             if(!Ext.isIE6 || !this.text){
  1917.                 this.el.removeClass(this.disabledClass);
  1918.             }
  1919.             this.el.dom.disabled = false;
  1920.         }
  1921.         this.disabled = false;
  1922.     },
  1923.     showMenu : function(){
  1924.         if(this.menu){
  1925.             this.menu.show(this.el, this.menuAlign);
  1926.         }
  1927.         return this;
  1928.     },
  1929.     hideMenu : function(){
  1930.         if(this.menu){
  1931.             this.menu.hide();
  1932.         }
  1933.         return this;
  1934.     },
  1935.     hasVisibleMenu : function(){
  1936.         return this.menu && this.menu.isVisible();
  1937.     },
  1938.         onClick : function(e){
  1939.         if(e){
  1940.             e.preventDefault();
  1941.         }
  1942.         if(e.button != 0){
  1943.             return;
  1944.         }
  1945.         if(!this.disabled){
  1946.             if(this.enableToggle && (this.allowDepress !== false || !this.pressed)){
  1947.                 this.toggle();
  1948.             }
  1949.             if(this.menu && !this.menu.isVisible() && !this.ignoreNextClick){
  1950.                 this.showMenu();
  1951.             }
  1952.             this.fireEvent("click", this, e);
  1953.             if(this.handler){
  1954.                                 this.handler.call(this.scope || this, this, e);
  1955.             }
  1956.         }
  1957.     },
  1958.         isMenuTriggerOver : function(e, internal){
  1959.         return this.menu && !internal;
  1960.     },
  1961.         isMenuTriggerOut : function(e, internal){
  1962.         return this.menu && !internal;
  1963.     },
  1964.         onMouseOver : function(e){
  1965.         if(!this.disabled){
  1966.             var internal = e.within(this.el,  true);
  1967.             if(!internal){
  1968.                 this.el.addClass("x-btn-over");
  1969.                 Ext.getDoc().on('mouseover', this.monitorMouseOver, this);
  1970.                 this.fireEvent('mouseover', this, e);
  1971.             }
  1972.             if(this.isMenuTriggerOver(e, internal)){
  1973.                 this.fireEvent('menutriggerover', this, this.menu, e);
  1974.             }
  1975.         }
  1976.     },
  1977.         monitorMouseOver : function(e){
  1978.         if(e.target != this.el.dom && !e.within(this.el)){
  1979.             Ext.getDoc().un('mouseover', this.monitorMouseOver, this);
  1980.             this.onMouseOut(e);
  1981.         }
  1982.     },
  1983.         onMouseOut : function(e){
  1984.         var internal = e.within(this.el) && e.target != this.el.dom;
  1985.         this.el.removeClass("x-btn-over");
  1986.         this.fireEvent('mouseout', this, e);
  1987.         if(this.isMenuTriggerOut(e, internal)){
  1988.             this.fireEvent('menutriggerout', this, this.menu, e);
  1989.         }
  1990.     },
  1991.         onFocus : function(e){
  1992.         if(!this.disabled){
  1993.             this.el.addClass("x-btn-focus");
  1994.         }
  1995.     },
  1996.         onBlur : function(e){
  1997.         this.el.removeClass("x-btn-focus");
  1998.     },
  1999.         getClickEl : function(e, isUp){
  2000.        return this.el;
  2001.     },
  2002.         onMouseDown : function(e){
  2003.         if(!this.disabled && e.button == 0){
  2004.             this.getClickEl(e).addClass("x-btn-click");
  2005.             Ext.getDoc().on('mouseup', this.onMouseUp, this);
  2006.         }
  2007.     },
  2008.         onMouseUp : function(e){
  2009.         if(e.button == 0){
  2010.             this.getClickEl(e, true).removeClass("x-btn-click");
  2011.             Ext.getDoc().un('mouseup', this.onMouseUp, this);
  2012.         }
  2013.     },
  2014.         onMenuShow : function(e){
  2015.         this.ignoreNextClick = 0;
  2016.         this.el.addClass("x-btn-menu-active");
  2017.         this.fireEvent('menushow', this, this.menu);
  2018.     },
  2019.         onMenuHide : function(e){
  2020.         this.el.removeClass("x-btn-menu-active");
  2021.         this.ignoreNextClick = this.restoreClick.defer(250, this);
  2022.         this.fireEvent('menuhide', this, this.menu);
  2023.     },
  2024.         restoreClick : function(){
  2025.         this.ignoreNextClick = 0;
  2026.     }
  2027. });
  2028. Ext.reg('button', Ext.Button);
  2029. Ext.ButtonToggleMgr = function(){
  2030.    var groups = {};
  2031.    function toggleGroup(btn, state){
  2032.        if(state){
  2033.            var g = groups[btn.toggleGroup];
  2034.            for(var i = 0, l = g.length; i < l; i++){
  2035.                if(g[i] != btn){
  2036.                    g[i].toggle(false);
  2037.                }
  2038.            }
  2039.        }
  2040.    }
  2041.    return {
  2042.        register : function(btn){
  2043.            if(!btn.toggleGroup){
  2044.                return;
  2045.            }
  2046.            var g = groups[btn.toggleGroup];
  2047.            if(!g){
  2048.                g = groups[btn.toggleGroup] = [];
  2049.            }
  2050.            g.push(btn);
  2051.            btn.on("toggle", toggleGroup);
  2052.        },
  2053.        unregister : function(btn){
  2054.            if(!btn.toggleGroup){
  2055.                return;
  2056.            }
  2057.            var g = groups[btn.toggleGroup];
  2058.            if(g){
  2059.                g.remove(btn);
  2060.                btn.un("toggle", toggleGroup);
  2061.            }
  2062.        }
  2063.    };
  2064. }();
  2065. Ext.SplitButton = Ext.extend(Ext.Button, {
  2066.     arrowSelector : 'button:last',
  2067.     initComponent : function(){
  2068.         Ext.SplitButton.superclass.initComponent.call(this);
  2069.         this.addEvents("arrowclick");
  2070.     },
  2071.     onRender : function(ct, position){
  2072.         var tpl = new Ext.Template(
  2073.             '<table cellspacing="0" class="x-btn-menu-wrap x-btn"><tr><td>',
  2074.             '<table cellspacing="0" class="x-btn-wrap x-btn-menu-text-wrap"><tbody>',
  2075.             '<tr><td class="x-btn-left"><i>&#160;</i></td><td class="x-btn-center"><button class="x-btn-text" type="{1}">{0}</button></td></tr>',
  2076.             "</tbody></table></td><td>",
  2077.             '<table cellspacing="0" class="x-btn-wrap x-btn-menu-arrow-wrap"><tbody>',
  2078.             '<tr><td class="x-btn-center"><button class="x-btn-menu-arrow-el" type="button">&#160;</button></td><td class="x-btn-right"><i>&#160;</i></td></tr>',
  2079.             "</tbody></table></td></tr></table>"
  2080.         );
  2081.         var btn, targs = [this.text || '&#160;', this.type];
  2082.         if(position){
  2083.             btn = tpl.insertBefore(position, targs, true);
  2084.         }else{
  2085.             btn = tpl.append(ct, targs, true);
  2086.         }
  2087.         var btnEl = btn.child(this.buttonSelector);
  2088.         this.initButtonEl(btn, btnEl);
  2089.         this.arrowBtnTable = btn.child("table:last");
  2090.         if(this.arrowTooltip){
  2091.             btn.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip;
  2092.         }
  2093.     },
  2094.     autoWidth : function(){
  2095.         if(this.el){
  2096.             var tbl = this.el.child("table:first");
  2097.             var tbl2 = this.el.child("table:last");
  2098.             this.el.setWidth("auto");
  2099.             tbl.setWidth("auto");
  2100.             if(Ext.isIE7 && Ext.isStrict){
  2101.                 var ib = this.el.child(this.buttonSelector);
  2102.                 if(ib && ib.getWidth() > 20){
  2103.                     ib.clip();
  2104.                     ib.setWidth(Ext.util.TextMetrics.measure(ib, this.text).width+ib.getFrameWidth('lr'));
  2105.                 }
  2106.             }
  2107.             if(this.minWidth){
  2108.                 if((tbl.getWidth()+tbl2.getWidth()) < this.minWidth){
  2109.                     tbl.setWidth(this.minWidth-tbl2.getWidth());
  2110.                 }
  2111.             }
  2112.             this.el.setWidth(tbl.getWidth()+tbl2.getWidth());
  2113.         }
  2114.     },
  2115.     setArrowHandler : function(handler, scope){
  2116.         this.arrowHandler = handler;
  2117.         this.scope = scope;
  2118.     },
  2119.     onClick : function(e){
  2120.         e.preventDefault();
  2121.         if(!this.disabled){
  2122.             if(e.getTarget(".x-btn-menu-arrow-wrap")){
  2123.                 if(this.menu && !this.menu.isVisible() && !this.ignoreNextClick){
  2124.                     this.showMenu();
  2125.                 }
  2126.                 this.fireEvent("arrowclick", this, e);
  2127.                 if(this.arrowHandler){
  2128.                     this.arrowHandler.call(this.scope || this, this, e);
  2129.                 }
  2130.             }else{
  2131.                 if(this.enableToggle){
  2132.                     this.toggle();
  2133.                 }
  2134.                 this.fireEvent("click", this, e);
  2135.                 if(this.handler){
  2136.                     this.handler.call(this.scope || this, this, e);
  2137.                 }
  2138.             }
  2139.         }
  2140.     },
  2141.     getClickEl : function(e, isUp){
  2142.         if(!isUp){
  2143.             return (this.lastClickEl = e.getTarget("table", 10, true));
  2144.         }
  2145.         return this.lastClickEl;
  2146.     },
  2147.     onDisable : function(){
  2148.         if(this.el){
  2149.             if(!Ext.isIE6){
  2150.                 this.el.addClass("x-item-disabled");
  2151.             }
  2152.             this.el.child(this.buttonSelector).dom.disabled = true;
  2153.             this.el.child(this.arrowSelector).dom.disabled = true;
  2154.         }
  2155.         this.disabled = true;
  2156.     },
  2157.     onEnable : function(){
  2158.         if(this.el){
  2159.             if(!Ext.isIE6){
  2160.                 this.el.removeClass("x-item-disabled");
  2161.             }
  2162.             this.el.child(this.buttonSelector).dom.disabled = false;
  2163.             this.el.child(this.arrowSelector).dom.disabled = false;
  2164.         }
  2165.         this.disabled = false;
  2166.     },
  2167.     isMenuTriggerOver : function(e){
  2168.         return this.menu && e.within(this.arrowBtnTable) && !e.within(this.arrowBtnTable, true);
  2169.     },
  2170.     isMenuTriggerOut : function(e, internal){
  2171.         return this.menu && !e.within(this.arrowBtnTable);
  2172.     },
  2173.     onDestroy : function(){
  2174.         Ext.destroy(this.arrowBtnTable);
  2175.         Ext.SplitButton.superclass.onDestroy.call(this);
  2176.     }
  2177. });
  2178. Ext.MenuButton = Ext.SplitButton;
  2179. Ext.reg('splitbutton', Ext.SplitButton);
  2180. Ext.CycleButton = Ext.extend(Ext.SplitButton, {
  2181.     getItemText : function(item){
  2182.         if(item && this.showText === true){
  2183.             var text = '';
  2184.             if(this.prependText){
  2185.                 text += this.prependText;
  2186.             }
  2187.             text += item.text;
  2188.             return text;
  2189.         }
  2190.         return undefined;
  2191.     },
  2192.     setActiveItem : function(item, suppressEvent){
  2193.         if(typeof item != 'object'){
  2194.             item = this.menu.items.get(item);
  2195.         }
  2196.         if(item){
  2197.             if(!this.rendered){
  2198.                 this.text = this.getItemText(item);
  2199.                 this.iconCls = item.iconCls;
  2200.             }else{
  2201.                 var t = this.getItemText(item);
  2202.                 if(t){
  2203.                     this.setText(t);
  2204.                 }
  2205.                 this.setIconClass(item.iconCls);
  2206.             }
  2207.             this.activeItem = item;
  2208.             if(!item.checked){
  2209.                 item.setChecked(true, true);
  2210.             }
  2211.             if(this.forceIcon){
  2212.                 this.setIconClass(this.forceIcon);
  2213.             }
  2214.             if(!suppressEvent){
  2215.                 this.fireEvent('change', this, item);
  2216.             }
  2217.         }
  2218.     },
  2219.     getActiveItem : function(){
  2220.         return this.activeItem;
  2221.     },
  2222.     initComponent : function(){
  2223.         this.addEvents(
  2224.             "change"
  2225.         );
  2226.         if(this.changeHandler){
  2227.             this.on('change', this.changeHandler, this.scope||this);
  2228.             delete this.changeHandler;
  2229.         }
  2230.         this.itemCount = this.items.length;
  2231.         this.menu = {cls:'x-cycle-menu', items:[]};
  2232.         var checked;
  2233.         for(var i = 0, len = this.itemCount; i < len; i++){
  2234.             var item = this.items[i];
  2235.             item.group = item.group || this.id;
  2236.             item.itemIndex = i;
  2237.             item.checkHandler = this.checkHandler;
  2238.             item.scope = this;
  2239.             item.checked = item.checked || false;
  2240.             this.menu.items.push(item);
  2241.             if(item.checked){
  2242.                 checked = item;
  2243.             }
  2244.         }
  2245.         this.setActiveItem(checked, true);
  2246.         Ext.CycleButton.superclass.initComponent.call(this);
  2247.         this.on('click', this.toggleSelected, this);
  2248.     },
  2249.     checkHandler : function(item, pressed){
  2250.         if(pressed){
  2251.             this.setActiveItem(item);
  2252.         }
  2253.     },
  2254.     toggleSelected : function(){
  2255.         this.menu.render();
  2256.         var nextIdx, checkItem;
  2257.         for (var i = 1; i < this.itemCount; i++) {
  2258.             nextIdx = (this.activeItem.itemIndex + i) % this.itemCount;
  2259.             checkItem = this.menu.items.itemAt(nextIdx);
  2260.             if (!checkItem.disabled) {
  2261.                 checkItem.setChecked(true);
  2262.                 break;
  2263.             }
  2264.         }
  2265.     }
  2266. });
  2267. Ext.reg('cycle', Ext.CycleButton);
  2268.  Ext.Toolbar = function(config){
  2269.     if(Ext.isArray(config)){
  2270.         config = {buttons:config};
  2271.     }
  2272.     Ext.Toolbar.superclass.constructor.call(this, config);
  2273. };
  2274. (function(){
  2275. var T = Ext.Toolbar;
  2276. Ext.extend(T, Ext.BoxComponent, {
  2277.     trackMenus : true,
  2278.     initComponent : function(){
  2279.         T.superclass.initComponent.call(this);
  2280.         if(this.items){
  2281.             this.buttons = this.items;
  2282.         }
  2283.         this.items = new Ext.util.MixedCollection(false, function(o){
  2284.             return o.itemId || o.id || Ext.id();
  2285.         });
  2286.     },
  2287.     autoCreate: {
  2288.         cls:'x-toolbar x-small-editor',
  2289.         html:'<table cellspacing="0"><tr></tr></table>'
  2290.     },
  2291.     onRender : function(ct, position){
  2292.         this.el = ct.createChild(Ext.apply({ id: this.id },this.autoCreate), position);
  2293.         this.tr = this.el.child("tr", true);
  2294.     },
  2295.     afterRender : function(){
  2296.         T.superclass.afterRender.call(this);
  2297.         if(this.buttons){
  2298.             this.add.apply(this, this.buttons);
  2299.             delete this.buttons;
  2300.         }
  2301.     },
  2302.     add : function(){
  2303.         var a = arguments, l = a.length;
  2304.         for(var i = 0; i < l; i++){
  2305.             var el = a[i];
  2306.             if(el.isFormField){
  2307.                 this.addField(el);
  2308.             }else if(el.render){
  2309.                 this.addItem(el);
  2310.             }else if(typeof el == "string"){
  2311.                 if(el == "separator" || el == "-"){
  2312.                     this.addSeparator();
  2313.                 }else if(el == " "){
  2314.                     this.addSpacer();
  2315.                 }else if(el == "->"){
  2316.                     this.addFill();
  2317.                 }else{
  2318.                     this.addText(el);
  2319.                 }
  2320.             }else if(el.tagName){
  2321.                 this.addElement(el);
  2322.             }else if(typeof el == "object"){
  2323.                 if(el.xtype){
  2324.                     this.addField(Ext.ComponentMgr.create(el, 'button'));
  2325.                 }else{
  2326.                     this.addButton(el);
  2327.                 }
  2328.             }
  2329.         }
  2330.     },
  2331.     addSeparator : function(){
  2332.         return this.addItem(new T.Separator());
  2333.     },
  2334.     addSpacer : function(){
  2335.         return this.addItem(new T.Spacer());
  2336.     },
  2337.     addFill : function(){
  2338.         return this.addItem(new T.Fill());
  2339.     },
  2340.     addElement : function(el){
  2341.         return this.addItem(new T.Item(el));
  2342.     },
  2343.     addItem : function(item){
  2344.         var td = this.nextBlock();
  2345.         this.initMenuTracking(item);
  2346.         item.render(td);
  2347.         this.items.add(item);
  2348.         return item;
  2349.     },
  2350.     addButton : function(config){
  2351.         if(Ext.isArray(config)){
  2352.             var buttons = [];
  2353.             for(var i = 0, len = config.length; i < len; i++) {
  2354.                 buttons.push(this.addButton(config[i]));
  2355.             }
  2356.             return buttons;
  2357.         }
  2358.         var b = config;
  2359.         if(!(config instanceof T.Button)){
  2360.             b = config.split ?
  2361.                 new T.SplitButton(config) :
  2362.                 new T.Button(config);
  2363.         }
  2364.         var td = this.nextBlock();
  2365.         this.initMenuTracking(b);
  2366.         b.render(td);
  2367.         this.items.add(b);
  2368.         return b;
  2369.     },
  2370.     initMenuTracking : function(item){
  2371.         if(this.trackMenus && item.menu){
  2372.             item.on({
  2373.                 'menutriggerover' : this.onButtonTriggerOver,
  2374.                 'menushow' : this.onButtonMenuShow,
  2375.                 'menuhide' : this.onButtonMenuHide,
  2376.                 scope: this
  2377.             })
  2378.         }
  2379.     },
  2380.     addText : function(text){
  2381.         return this.addItem(new T.TextItem(text));
  2382.     },
  2383.     insertButton : function(index, item){
  2384.         if(Ext.isArray(item)){
  2385.             var buttons = [];
  2386.             for(var i = 0, len = item.length; i < len; i++) {
  2387.                buttons.push(this.insertButton(index + i, item[i]));
  2388.             }
  2389.             return buttons;
  2390.         }
  2391.         if (!(item instanceof T.Button)){
  2392.            item = new T.Button(item);
  2393.         }
  2394.         var td = document.createElement("td");
  2395.         this.tr.insertBefore(td, this.tr.childNodes[index]);
  2396.         this.initMenuTracking(item);
  2397.         item.render(td);
  2398.         this.items.insert(index, item);
  2399.         return item;
  2400.     },
  2401.     addDom : function(config, returnEl){
  2402.         var td = this.nextBlock();
  2403.         Ext.DomHelper.overwrite(td, config);
  2404.         var ti = new T.Item(td.firstChild);
  2405.         ti.render(td);
  2406.         this.items.add(ti);
  2407.         return ti;
  2408.     },
  2409.     addField : function(field){
  2410.         var td = this.nextBlock();
  2411.         field.render(td);
  2412.         var ti = new T.Item(td.firstChild);
  2413.         ti.render(td);
  2414.         this.items.add(ti);
  2415.         return ti;
  2416.     },
  2417.     nextBlock : function(){
  2418.         var td = document.createElement("td");
  2419.         this.tr.appendChild(td);
  2420.         return td;
  2421.     },
  2422.     onDestroy : function(){
  2423.         Ext.Toolbar.superclass.onDestroy.call(this);
  2424.         if(this.rendered){
  2425.             if(this.items){
  2426.                 Ext.destroy.apply(Ext, this.items.items);
  2427.             }
  2428.             Ext.Element.uncache(this.tr);
  2429.         }
  2430.     },
  2431.     onDisable : function(){
  2432.         this.items.each(function(item){
  2433.              if(item.disable){
  2434.                  item.disable();
  2435.              }
  2436.         });
  2437.     },
  2438.     onEnable : function(){
  2439.         this.items.each(function(item){
  2440.              if(item.enable){
  2441.                  item.enable();
  2442.              }
  2443.         });
  2444.     },
  2445.     onButtonTriggerOver : function(btn){
  2446.         if(this.activeMenuBtn && this.activeMenuBtn != btn){
  2447.             this.activeMenuBtn.hideMenu();
  2448.             btn.showMenu();
  2449.             this.activeMenuBtn = btn;
  2450.         }
  2451.     },
  2452.     onButtonMenuShow : function(btn){
  2453.         this.activeMenuBtn = btn;
  2454.     },
  2455.     onButtonMenuHide : function(btn){
  2456.         delete this.activeMenuBtn;
  2457.     }
  2458. });
  2459. Ext.reg('toolbar', Ext.Toolbar);
  2460. T.Item = function(el){
  2461.     this.el = Ext.getDom(el);
  2462.     this.id = Ext.id(this.el);
  2463.     this.hidden = false;
  2464. };
  2465. T.Item.prototype = {
  2466.     getEl : function(){
  2467.        return this.el;
  2468.     },
  2469.     render : function(td){
  2470.         this.td = td;
  2471.         td.appendChild(this.el);
  2472.     },
  2473.     destroy : function(){
  2474.         if(this.td && this.td.parentNode){
  2475.             this.td.parentNode.removeChild(this.td);
  2476.         }
  2477.     },
  2478.     show: function(){
  2479.         this.hidden = false;
  2480.         this.td.style.display = "";
  2481.     },
  2482.     hide: function(){
  2483.         this.hidden = true;
  2484.         this.td.style.display = "none";
  2485.     },
  2486.     setVisible: function(visible){
  2487.         if(visible) {
  2488.             this.show();
  2489.         }else{
  2490.             this.hide();
  2491.         }
  2492.     },
  2493.     focus : function(){
  2494.         Ext.fly(this.el).focus();
  2495.     },
  2496.     disable : function(){
  2497.         Ext.fly(this.td).addClass("x-item-disabled");
  2498.         this.disabled = true;
  2499.         this.el.disabled = true;
  2500.     },
  2501.     enable : function(){
  2502.         Ext.fly(this.td).removeClass("x-item-disabled");
  2503.         this.disabled = false;
  2504.         this.el.disabled = false;
  2505.     }
  2506. };
  2507. Ext.reg('tbitem', T.Item);
  2508. T.Separator = function(){
  2509.     var s = document.createElement("span");
  2510.     s.className = "ytb-sep";
  2511.     T.Separator.superclass.constructor.call(this, s);
  2512. };
  2513. Ext.extend(T.Separator, T.Item, {
  2514.     enable:Ext.emptyFn,
  2515.     disable:Ext.emptyFn,
  2516.     focus:Ext.emptyFn
  2517. });
  2518. Ext.reg('tbseparator', T.Separator);
  2519. T.Spacer = function(){
  2520.     var s = document.createElement("div");
  2521.     s.className = "ytb-spacer";
  2522.     T.Spacer.superclass.constructor.call(this, s);
  2523. };
  2524. Ext.extend(T.Spacer, T.Item, {
  2525.     enable:Ext.emptyFn,
  2526.     disable:Ext.emptyFn,
  2527.     focus:Ext.emptyFn
  2528. });
  2529. Ext.reg('tbspacer', T.Spacer);
  2530. T.Fill = Ext.extend(T.Spacer, {
  2531.     render : function(td){
  2532.         td.style.width = '100%';
  2533.         T.Fill.superclass.render.call(this, td);
  2534.     }
  2535. });
  2536. Ext.reg('tbfill', T.Fill);
  2537. T.TextItem = function(t){
  2538.     var s = document.createElement("span");
  2539.     s.className = "ytb-text";
  2540.     s.innerHTML = t.text ? t.text : t;
  2541.     T.TextItem.superclass.constructor.call(this, s);
  2542. };
  2543. Ext.extend(T.TextItem, T.Item, {
  2544.     enable:Ext.emptyFn,
  2545.     disable:Ext.emptyFn,
  2546.     focus:Ext.emptyFn
  2547. });
  2548. Ext.reg('tbtext', T.TextItem);
  2549. T.Button = Ext.extend(Ext.Button, {
  2550.     hideParent : true,
  2551.     onDestroy : function(){
  2552.         T.Button.superclass.onDestroy.call(this);
  2553.         if(this.container){
  2554.             this.container.remove();
  2555.         }
  2556.     }
  2557. });
  2558. Ext.reg('tbbutton', T.Button);
  2559. T.SplitButton = Ext.extend(Ext.SplitButton, {
  2560.     hideParent : true,
  2561.     onDestroy : function(){
  2562.         T.SplitButton.superclass.onDestroy.call(this);
  2563.         if(this.container){
  2564.             this.container.remove();
  2565.         }
  2566.     }
  2567. });
  2568. Ext.reg('tbsplit', T.SplitButton);
  2569. T.MenuButton = T.SplitButton;
  2570. })();
  2571. Ext.PagingToolbar = Ext.extend(Ext.Toolbar, {
  2572.     pageSize: 20,
  2573.     displayMsg : 'Displaying {0} - {1} of {2}',
  2574.     emptyMsg : 'No data to display',
  2575.     beforePageText : "Page",
  2576.     afterPageText : "of {0}",
  2577.     firstText : "First Page",
  2578.     prevText : "Previous Page",
  2579.     nextText : "Next Page",
  2580.     lastText : "Last Page",
  2581.     refreshText : "Refresh",
  2582.     paramNames : {start: 'start', limit: 'limit'},
  2583.     initComponent : function(){
  2584.         Ext.PagingToolbar.superclass.initComponent.call(this);
  2585.         this.cursor = 0;
  2586.         this.bind(this.store);
  2587.     },
  2588.         onRender : function(ct, position){
  2589.         Ext.PagingToolbar.superclass.onRender.call(this, ct, position);
  2590.         this.first = this.addButton({
  2591.             tooltip: this.firstText,
  2592.             iconCls: "x-tbar-page-first",
  2593.             disabled: true,
  2594.             handler: this.onClick.createDelegate(this, ["first"])
  2595.         });
  2596.         this.prev = this.addButton({
  2597.             tooltip: this.prevText,
  2598.             iconCls: "x-tbar-page-prev",
  2599.             disabled: true,
  2600.             handler: this.onClick.createDelegate(this, ["prev"])
  2601.         });
  2602.         this.addSeparator();
  2603.         this.add(this.beforePageText);
  2604.         this.field = Ext.get(this.addDom({
  2605.            tag: "input",
  2606.            type: "text",
  2607.            size: "3",
  2608.            value: "1",
  2609.            cls: "x-tbar-page-number"
  2610.         }).el);
  2611.         this.field.on("keydown", this.onPagingKeydown, this);
  2612.         this.field.on("focus", function(){this.dom.select();});
  2613.         this.afterTextEl = this.addText(String.format(this.afterPageText, 1));
  2614.         this.field.setHeight(18);
  2615.         this.addSeparator();
  2616.         this.next = this.addButton({
  2617.             tooltip: this.nextText,
  2618.             iconCls: "x-tbar-page-next",
  2619.             disabled: true,
  2620.             handler: this.onClick.createDelegate(this, ["next"])
  2621.         });
  2622.         this.last = this.addButton({
  2623.             tooltip: this.lastText,
  2624.             iconCls: "x-tbar-page-last",
  2625.             disabled: true,
  2626.             handler: this.onClick.createDelegate(this, ["last"])
  2627.         });
  2628.         this.addSeparator();
  2629.         this.loading = this.addButton({
  2630.             tooltip: this.refreshText,
  2631.             iconCls: "x-tbar-loading",
  2632.             handler: this.onClick.createDelegate(this, ["refresh"])
  2633.         });
  2634.         if(this.displayInfo){
  2635.             this.displayEl = Ext.fly(this.el.dom).createChild({cls:'x-paging-info'});
  2636.         }
  2637.         if(this.dsLoaded){
  2638.             this.onLoad.apply(this, this.dsLoaded);
  2639.         }
  2640.     },
  2641.         updateInfo : function(){
  2642.         if(this.displayEl){
  2643.             var count = this.store.getCount();
  2644.             var msg = count == 0 ?
  2645.                 this.emptyMsg :
  2646.                 String.format(
  2647.                     this.displayMsg,
  2648.                     this.cursor+1, this.cursor+count, this.store.getTotalCount()
  2649.                 );
  2650.             this.displayEl.update(msg);
  2651.         }
  2652.     },
  2653.         onLoad : function(store, r, o){
  2654.         if(!this.rendered){
  2655.             this.dsLoaded = [store, r, o];
  2656.             return;
  2657.         }
  2658.        this.cursor = o.params ? o.params[this.paramNames.start] : 0;
  2659.        var d = this.getPageData(), ap = d.activePage, ps = d.pages;
  2660.        this.afterTextEl.el.innerHTML = String.format(this.afterPageText, d.pages);
  2661.        this.field.dom.value = ap;
  2662.        this.first.setDisabled(ap == 1);
  2663.        this.prev.setDisabled(ap == 1);
  2664.        this.next.setDisabled(ap == ps);
  2665.        this.last.setDisabled(ap == ps);
  2666.        this.loading.enable();
  2667.        this.updateInfo();
  2668.     },
  2669.         getPageData : function(){
  2670.         var total = this.store.getTotalCount();
  2671.         return {
  2672.             total : total,
  2673.             activePage : Math.ceil((this.cursor+this.pageSize)/this.pageSize),
  2674.             pages :  total < this.pageSize ? 1 : Math.ceil(total/this.pageSize)
  2675.         };
  2676.     },
  2677.         onLoadError : function(){
  2678.         if(!this.rendered){
  2679.             return;
  2680.         }
  2681.         this.loading.enable();
  2682.     },
  2683.     readPage : function(d){
  2684.         var v = this.field.dom.value, pageNum;
  2685.         if (!v || isNaN(pageNum = parseInt(v, 10))) {
  2686.             this.field.dom.value = d.activePage;
  2687.             return false;
  2688.         }
  2689.         return pageNum;
  2690.     },
  2691.         onPagingKeydown : function(e){
  2692.         var k = e.getKey(), d = this.getPageData(), pageNum;
  2693.         if (k == e.RETURN) {
  2694.             e.stopEvent();
  2695.             if(pageNum = this.readPage(d)){
  2696.                 pageNum = Math.min(Math.max(1, pageNum), d.pages) - 1;
  2697.                 this.doLoad(pageNum * this.pageSize);
  2698.             }
  2699.         }else if (k == e.HOME || k == e.END){
  2700.             e.stopEvent();
  2701.             pageNum = k == e.HOME ? 1 : d.pages;
  2702.             this.field.dom.value = pageNum;
  2703.         }else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN){
  2704.             e.stopEvent();
  2705.             if(pageNum = this.readPage(d)){
  2706.                 var increment = e.shiftKey ? 10 : 1;
  2707.                 if(k == e.DOWN || k == e.PAGEDOWN){
  2708.                     increment *= -1;
  2709.                 }
  2710.                 pageNum += increment;
  2711.                 if(pageNum >= 1 & pageNum <= d.pages){
  2712.                     this.field.dom.value = pageNum;
  2713.                 }
  2714.             }
  2715.         }
  2716.     },
  2717.         beforeLoad : function(){
  2718.         if(this.rendered && this.loading){
  2719.             this.loading.disable();
  2720.         }
  2721.     },
  2722.     doLoad : function(start){
  2723.         var o = {}, pn = this.paramNames;
  2724.         o[pn.start] = start;
  2725.         o[pn.limit] = this.pageSize;
  2726.         this.store.load({params:o});
  2727.     },
  2728.         onClick : function(which){
  2729.         var store = this.store;
  2730.         switch(which){
  2731.             case "first":
  2732.                 this.doLoad(0);
  2733.             break;
  2734.             case "prev":
  2735.                 this.doLoad(Math.max(0, this.cursor-this.pageSize));
  2736.             break;
  2737.             case "next":
  2738.                 this.doLoad(this.cursor+this.pageSize);
  2739.             break;
  2740.             case "last":
  2741.                 var total = store.getTotalCount();
  2742.                 var extra = total % this.pageSize;
  2743.                 var lastStart = extra ? (total - extra) : total-this.pageSize;
  2744.                 this.doLoad(lastStart);
  2745.             break;
  2746.             case "refresh":
  2747.                 this.doLoad(this.cursor);
  2748.             break;
  2749.         }
  2750.     },
  2751.     unbind : function(store){
  2752.         store = Ext.StoreMgr.lookup(store);
  2753.         store.un("beforeload", this.beforeLoad, this);
  2754.         store.un("load", this.onLoad, this);
  2755.         store.un("loadexception", this.onLoadError, this);
  2756.         this.store = undefined;
  2757.     },
  2758.     bind : function(store){
  2759.         store = Ext.StoreMgr.lookup(store);
  2760.         store.on("beforeload", this.beforeLoad, this);
  2761.         store.on("load", this.onLoad, this);
  2762.         store.on("loadexception", this.onLoadError, this);
  2763.         this.store = store;
  2764.     }
  2765. });
  2766. Ext.reg('paging', Ext.PagingToolbar);
  2767. Ext.Resizable = function(el, config){
  2768.     this.el = Ext.get(el);
  2769.     if(config && config.wrap){
  2770.         config.resizeChild = this.el;
  2771.         this.el = this.el.wrap(typeof config.wrap == "object" ? config.wrap : {cls:"xresizable-wrap"});
  2772.         this.el.id = this.el.dom.id = config.resizeChild.id + "-rzwrap";
  2773.         this.el.setStyle("overflow", "hidden");
  2774.         this.el.setPositioning(config.resizeChild.getPositioning());
  2775.         config.resizeChild.clearPositioning();
  2776.         if(!config.width || !config.height){
  2777.             var csize = config.resizeChild.getSize();
  2778.             this.el.setSize(csize.width, csize.height);
  2779.         }
  2780.         if(config.pinned && !config.adjustments){
  2781.             config.adjustments = "auto";
  2782.         }
  2783.     }
  2784.     this.proxy = this.el.createProxy({tag: "div", cls: "x-resizable-proxy", id: this.el.id + "-rzproxy"});
  2785.     this.proxy.unselectable();
  2786.     this.proxy.enableDisplayMode('block');
  2787.     Ext.apply(this, config);
  2788.     if(this.pinned){
  2789.         this.disableTrackOver = true;
  2790.         this.el.addClass("x-resizable-pinned");
  2791.     }
  2792.     var position = this.el.getStyle("position");
  2793.     if(position != "absolute" && position != "fixed"){
  2794.         this.el.setStyle("position", "relative");
  2795.     }
  2796.     if(!this.handles){
  2797.         this.handles = 's,e,se';
  2798.         if(this.multiDirectional){
  2799.             this.handles += ',n,w';
  2800.         }
  2801.     }
  2802.     if(this.handles == "all"){
  2803.         this.handles = "n s e w ne nw se sw";
  2804.     }
  2805.     var hs = this.handles.split(/s*?[,;]s*?| /);
  2806.     var ps = Ext.Resizable.positions;
  2807.     for(var i = 0, len = hs.length; i < len; i++){
  2808.         if(hs[i] && ps[hs[i]]){
  2809.             var pos = ps[hs[i]];
  2810.             this[pos] = new Ext.Resizable.Handle(this, pos, this.disableTrackOver, this.transparent);
  2811.         }
  2812.     }
  2813.     this.corner = this.southeast;
  2814.     if(this.handles.indexOf("n") != -1 || this.handles.indexOf("w") != -1){
  2815.         this.updateBox = true;
  2816.     }
  2817.     this.activeHandle = null;
  2818.     if(this.resizeChild){
  2819.         if(typeof this.resizeChild == "boolean"){
  2820.             this.resizeChild = Ext.get(this.el.dom.firstChild, true);
  2821.         }else{
  2822.             this.resizeChild = Ext.get(this.resizeChild, true);
  2823.         }
  2824.     }
  2825.     if(this.adjustments == "auto"){
  2826.         var rc = this.resizeChild;
  2827.         var hw = this.west, he = this.east, hn = this.north, hs = this.south;
  2828.         if(rc && (hw || hn)){
  2829.             rc.position("relative");
  2830.             rc.setLeft(hw ? hw.el.getWidth() : 0);
  2831.             rc.setTop(hn ? hn.el.getHeight() : 0);
  2832.         }
  2833.         this.adjustments = [
  2834.             (he ? -he.el.getWidth() : 0) + (hw ? -hw.el.getWidth() : 0),
  2835.             (hn ? -hn.el.getHeight() : 0) + (hs ? -hs.el.getHeight() : 0) -1
  2836.         ];
  2837.     }
  2838.     if(this.draggable){
  2839.         this.dd = this.dynamic ?
  2840.             this.el.initDD(null) : this.el.initDDProxy(null, {dragElId: this.proxy.id});
  2841.         this.dd.setHandleElId(this.resizeChild ? this.resizeChild.id : this.el.id);
  2842.     }
  2843.     this.addEvents(
  2844.         "beforeresize",
  2845.         "resize"
  2846.     );
  2847.     if(this.width !== null && this.height !== null){
  2848.         this.resizeTo(this.width, this.height);
  2849.     }else{
  2850.         this.updateChildSize();
  2851.     }
  2852.     if(Ext.isIE){
  2853.         this.el.dom.style.zoom = 1;
  2854.     }
  2855.     Ext.Resizable.superclass.constructor.call(this);
  2856. };
  2857. Ext.extend(Ext.Resizable, Ext.util.Observable, {
  2858.         resizeChild : false,
  2859.         adjustments : [0, 0],
  2860.         minWidth : 5,
  2861.         minHeight : 5,
  2862.         maxWidth : 10000,
  2863.         maxHeight : 10000,
  2864.         enabled : true,
  2865.         animate : false,
  2866.         duration : .35,
  2867.         dynamic : false,
  2868.         handles : false,
  2869.         multiDirectional : false,
  2870.         disableTrackOver : false,
  2871.         easing : 'easeOutStrong',
  2872.         widthIncrement : 0,
  2873.         heightIncrement : 0,
  2874.         pinned : false,
  2875.         width : null,
  2876.         height : null,
  2877.         preserveRatio : false,
  2878.         transparent: false,
  2879.         minX: 0,
  2880.         minY: 0,
  2881.         draggable: false,
  2882.     resizeTo : function(width, height){
  2883.         this.el.setSize(width, height);
  2884.         this.updateChildSize();
  2885.         this.fireEvent("resize", this, width, height, null);
  2886.     },
  2887.     startSizing : function(e, handle){
  2888.         this.fireEvent("beforeresize", this, e);
  2889.         if(this.enabled){
  2890.             if(!this.overlay){
  2891.                 this.overlay = this.el.createProxy({tag: "div", cls: "x-resizable-overlay", html: "&#160;"}, Ext.getBody());
  2892.                 this.overlay.unselectable();
  2893.                 this.overlay.enableDisplayMode("block");
  2894.                 this.overlay.on("mousemove", this.onMouseMove, this);
  2895.                 this.overlay.on("mouseup", this.onMouseUp, this);
  2896.             }
  2897.             this.overlay.setStyle("cursor", handle.el.getStyle("cursor"));
  2898.             this.resizing = true;
  2899.             this.startBox = this.el.getBox();
  2900.             this.startPoint = e.getXY();
  2901.             this.offsets = [(this.startBox.x + this.startBox.width) - this.startPoint[0],
  2902.                             (this.startBox.y + this.startBox.height) - this.startPoint[1]];
  2903.             this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
  2904.             this.overlay.show();
  2905.             if(this.constrainTo) {
  2906.                 var ct = Ext.get(this.constrainTo);
  2907.                 this.resizeRegion = ct.getRegion().adjust(
  2908.                     ct.getFrameWidth('t'),
  2909.                     ct.getFrameWidth('l'),
  2910.                     -ct.getFrameWidth('b'),
  2911.                     -ct.getFrameWidth('r')
  2912.                 );
  2913.             }
  2914.             this.proxy.setStyle('visibility', 'hidden');
  2915.             this.proxy.show();
  2916.             this.proxy.setBox(this.startBox);
  2917.             if(!this.dynamic){
  2918.                 this.proxy.setStyle('visibility', 'visible');
  2919.             }
  2920.         }
  2921.     },
  2922.     onMouseDown : function(handle, e){
  2923.         if(this.enabled){
  2924.             e.stopEvent();
  2925.             this.activeHandle = handle;
  2926.             this.startSizing(e, handle);
  2927.         }
  2928.     },
  2929.     onMouseUp : function(e){
  2930.         var size = this.resizeElement();
  2931.         this.resizing = false;
  2932.         this.handleOut();
  2933.         this.overlay.hide();
  2934.         this.proxy.hide();
  2935.         this.fireEvent("resize", this, size.width, size.height, e);
  2936.     },
  2937.     updateChildSize : function(){
  2938.         if(this.resizeChild){
  2939.             var el = this.el;
  2940.             var child = this.resizeChild;
  2941.             var adj = this.adjustments;
  2942.             if(el.dom.offsetWidth){
  2943.                 var b = el.getSize(true);
  2944.                 child.setSize(b.width+adj[0], b.height+adj[1]);
  2945.             }
  2946.             if(Ext.isIE){
  2947.                 setTimeout(function(){
  2948.                     if(el.dom.offsetWidth){
  2949.                         var b = el.getSize(true);
  2950.                         child.setSize(b.width+adj[0], b.height+adj[1]);
  2951.                     }
  2952.                 }, 10);
  2953.             }
  2954.         }
  2955.     },
  2956.     snap : function(value, inc, min){
  2957.         if(!inc || !value) return value;
  2958.         var newValue = value;
  2959.         var m = value % inc;
  2960.         if(m > 0){
  2961.             if(m > (inc/2)){
  2962.                 newValue = value + (inc-m);
  2963.             }else{
  2964.                 newValue = value - m;
  2965.             }
  2966.         }
  2967.         return Math.max(min, newValue);
  2968.     },
  2969.     resizeElement : function(){
  2970.         var box = this.proxy.getBox();
  2971.         if(this.updateBox){
  2972.             this.el.setBox(box, false, this.animate, this.duration, null, this.easing);
  2973.         }else{
  2974.             this.el.setSize(box.width, box.height, this.animate, this.duration, null, this.easing);
  2975.         }
  2976.         this.updateChildSize();
  2977.         if(!this.dynamic){
  2978.             this.proxy.hide();
  2979.         }
  2980.         return box;
  2981.     },
  2982.     constrain : function(v, diff, m, mx){
  2983.         if(v - diff < m){
  2984.             diff = v - m;
  2985.         }else if(v - diff > mx){
  2986.             diff = mx - v;
  2987.         }
  2988.         return diff;
  2989.     },
  2990.     onMouseMove : function(e){
  2991.         if(this.enabled){
  2992.             try{
  2993.             if(this.resizeRegion && !this.resizeRegion.contains(e.getPoint())) {
  2994.                 return;
  2995.             }
  2996.             var curSize = this.curSize || this.startBox;
  2997.             var x = this.startBox.x, y = this.startBox.y;
  2998.             var ox = x, oy = y;
  2999.             var w = curSize.width, h = curSize.height;
  3000.             var ow = w, oh = h;
  3001.             var mw = this.minWidth, mh = this.minHeight;
  3002.             var mxw = this.maxWidth, mxh = this.maxHeight;
  3003.             var wi = this.widthIncrement;
  3004.             var hi = this.heightIncrement;
  3005.             var eventXY = e.getXY();
  3006.             var diffX = -(this.startPoint[0] - Math.max(this.minX, eventXY[0]));
  3007.             var diffY = -(this.startPoint[1] - Math.max(this.minY, eventXY[1]));
  3008.             var pos = this.activeHandle.position;
  3009.             switch(pos){
  3010.                 case "east":
  3011.                     w += diffX;
  3012.                     w = Math.min(Math.max(mw, w), mxw);
  3013.                     break;
  3014.                 case "south":
  3015.                     h += diffY;
  3016.                     h = Math.min(Math.max(mh, h), mxh);
  3017.                     break;
  3018.                 case "southeast":
  3019.                     w += diffX;
  3020.                     h += diffY;
  3021.                     w = Math.min(Math.max(mw, w), mxw);
  3022.                     h = Math.min(Math.max(mh, h), mxh);
  3023.                     break;
  3024.                 case "north":
  3025.                     diffY = this.constrain(h, diffY, mh, mxh);
  3026.                     y += diffY;
  3027.                     h -= diffY;
  3028.                     break;
  3029.                 case "west":
  3030.                     diffX = this.constrain(w, diffX, mw, mxw);
  3031.                     x += diffX;
  3032.                     w -= diffX;
  3033.                     break;
  3034.                 case "northeast":
  3035.                     w += diffX;
  3036.                     w = Math.min(Math.max(mw, w), mxw);
  3037.                     diffY = this.constrain(h, diffY, mh, mxh);
  3038.                     y += diffY;
  3039.                     h -= diffY;
  3040.                     break;
  3041.                 case "northwest":
  3042.                     diffX = this.constrain(w, diffX, mw, mxw);
  3043.                     diffY = this.constrain(h, diffY, mh, mxh);
  3044.                     y += diffY;
  3045.                     h -= diffY;
  3046.                     x += diffX;
  3047.                     w -= diffX;
  3048.                     break;
  3049.                case "southwest":
  3050.                     diffX = this.constrain(w, diffX, mw, mxw);
  3051.                     h += diffY;
  3052.                     h = Math.min(Math.max(mh, h), mxh);
  3053.                     x += diffX;
  3054.                     w -= diffX;
  3055.                     break;
  3056.             }
  3057.             var sw = this.snap(w, wi, mw);
  3058.             var sh = this.snap(h, hi, mh);
  3059.             if(sw != w || sh != h){
  3060.                 switch(pos){
  3061.                     case "northeast":
  3062.                         y -= sh - h;
  3063.                     break;
  3064.                     case "north":
  3065.                         y -= sh - h;
  3066.                         break;
  3067.                     case "southwest":
  3068.                         x -= sw - w;
  3069.                     break;
  3070.                     case "west":
  3071.                         x -= sw - w;
  3072.                         break;
  3073.                     case "northwest":
  3074.                         x -= sw - w;
  3075.                         y -= sh - h;
  3076.                     break;
  3077.                 }
  3078.                 w = sw;
  3079.                 h = sh;
  3080.             }
  3081.             if(this.preserveRatio){
  3082.                 switch(pos){
  3083.                     case "southeast":
  3084.                     case "east":
  3085.                         h = oh * (w/ow);
  3086.                         h = Math.min(Math.max(mh, h), mxh);
  3087.                         w = ow * (h/oh);
  3088.                        break;
  3089.                     case "south":
  3090.                         w = ow * (h/oh);
  3091.                         w = Math.min(Math.max(mw, w), mxw);
  3092.                         h = oh * (w/ow);
  3093.                         break;
  3094.                     case "northeast":
  3095.                         w = ow * (h/oh);
  3096.                         w = Math.min(Math.max(mw, w), mxw);
  3097.                         h = oh * (w/ow);
  3098.                     break;
  3099.                     case "north":
  3100.                         var tw = w;
  3101.                         w = ow * (h/oh);
  3102.                         w = Math.min(Math.max(mw, w), mxw);
  3103.                         h = oh * (w/ow);
  3104.                         x += (tw - w) / 2;
  3105.                         break;
  3106.                     case "southwest":
  3107.                         h = oh * (w/ow);
  3108.                         h = Math.min(Math.max(mh, h), mxh);
  3109.                         var tw = w;
  3110.                         w = ow * (h/oh);
  3111.                         x += tw - w;
  3112.                         break;
  3113.                     case "west":
  3114.                         var th = h;
  3115.                         h = oh * (w/ow);
  3116.                         h = Math.min(Math.max(mh, h), mxh);
  3117.                         y += (th - h) / 2;
  3118.                         var tw = w;
  3119.                         w = ow * (h/oh);
  3120.                         x += tw - w;
  3121.                        break;
  3122.                     case "northwest":
  3123.                         var tw = w;
  3124.                         var th = h;
  3125.                         h = oh * (w/ow);
  3126.                         h = Math.min(Math.max(mh, h), mxh);
  3127.                         w = ow * (h/oh);
  3128.                         y += th - h;
  3129.                          x += tw - w;
  3130.                        break;
  3131.                 }
  3132.             }
  3133.             this.proxy.setBounds(x, y, w, h);
  3134.             if(this.dynamic){
  3135.                 this.resizeElement();
  3136.             }
  3137.             }catch(e){}
  3138.         }
  3139.     },
  3140.     handleOver : function(){
  3141.         if(this.enabled){
  3142.             this.el.addClass("x-resizable-over");
  3143.         }
  3144.     },
  3145.     handleOut : function(){
  3146.         if(!this.resizing){
  3147.             this.el.removeClass("x-resizable-over");
  3148.         }
  3149.     },
  3150.     getEl : function(){
  3151.         return this.el;
  3152.     },
  3153.     getResizeChild : function(){
  3154.         return this.resizeChild;
  3155.     },
  3156.     destroy : function(removeEl){
  3157.         this.proxy.remove();
  3158.         if(this.overlay){
  3159.             this.overlay.removeAllListeners();
  3160.             this.overlay.remove();
  3161.         }
  3162.         var ps = Ext.Resizable.positions;
  3163.         for(var k in ps){
  3164.             if(typeof ps[k] != "function" && this[ps[k]]){
  3165.                 var h = this[ps[k]];
  3166.                 h.el.removeAllListeners();
  3167.                 h.el.remove();
  3168.             }
  3169.         }
  3170.         if(removeEl){
  3171.             this.el.update("");
  3172.             this.el.remove();
  3173.         }
  3174.     },
  3175.     syncHandleHeight : function(){
  3176.         var h = this.el.getHeight(true);
  3177.         if(this.west){
  3178.             this.west.el.setHeight(h);
  3179.         }
  3180.         if(this.east){
  3181.             this.east.el.setHeight(h);
  3182.         }
  3183.     }
  3184. });
  3185. Ext.Resizable.positions = {
  3186.     n: "north", s: "south", e: "east", w: "west", se: "southeast", sw: "southwest", nw: "northwest", ne: "northeast"
  3187. };
  3188. Ext.Resizable.Handle = function(rz, pos, disableTrackOver, transparent){
  3189.     if(!this.tpl){
  3190.         var tpl = Ext.DomHelper.createTemplate(
  3191.             {tag: "div", cls: "x-resizable-handle x-resizable-handle-{0}"}
  3192.         );
  3193.         tpl.compile();
  3194.         Ext.Resizable.Handle.prototype.tpl = tpl;
  3195.     }
  3196.     this.position = pos;
  3197.     this.rz = rz;
  3198.     this.el = this.tpl.append(rz.el.dom, [this.position], true);
  3199.     this.el.unselectable();
  3200.     if(transparent){
  3201.         this.el.setOpacity(0);
  3202.     }
  3203.     this.el.on("mousedown", this.onMouseDown, this);
  3204.     if(!disableTrackOver){
  3205.         this.el.on("mouseover", this.onMouseOver, this);
  3206.         this.el.on("mouseout", this.onMouseOut, this);
  3207.     }
  3208. };
  3209. Ext.Resizable.Handle.prototype = {
  3210.     afterResize : function(rz){
  3211.     },
  3212.     onMouseDown : function(e){
  3213.         this.rz.onMouseDown(this, e);
  3214.     },
  3215.     onMouseOver : function(e){
  3216.         this.rz.handleOver(this, e);
  3217.     },
  3218.     onMouseOut : function(e){
  3219.         this.rz.handleOut(this, e);
  3220.     }
  3221. };
  3222. Ext.Editor = function(field, config){
  3223.     this.field = field;
  3224.     Ext.Editor.superclass.constructor.call(this, config);
  3225. };
  3226. Ext.extend(Ext.Editor, Ext.Component, {
  3227.     value : "",
  3228.     alignment: "c-c?",
  3229.     shadow : "frame",
  3230.     constrain : false,
  3231.     swallowKeys : true,
  3232.     completeOnEnter : false,
  3233.     cancelOnEsc : false,
  3234.     updateEl : false,
  3235.     initComponent : function(){
  3236.         Ext.Editor.superclass.initComponent.call(this);
  3237.         this.addEvents(
  3238.             "beforestartedit",
  3239.             "startedit",
  3240.             "beforecomplete",
  3241.             "complete",
  3242.             "specialkey"
  3243.         );
  3244.     },
  3245.         onRender : function(ct, position){
  3246.         this.el = new Ext.Layer({
  3247.             shadow: this.shadow,
  3248.             cls: "x-editor",
  3249.             parentEl : ct,
  3250.             shim : this.shim,
  3251.             shadowOffset:4,
  3252.             id: this.id,
  3253.             constrain: this.constrain
  3254.         });
  3255.         this.el.setStyle("overflow", Ext.isGecko ? "auto" : "hidden");
  3256.         if(this.field.msgTarget != 'title'){
  3257.             this.field.msgTarget = 'qtip';
  3258.         }
  3259.         this.field.inEditor = true;
  3260.         this.field.render(this.el);
  3261.         if(Ext.isGecko){
  3262.             this.field.el.dom.setAttribute('autocomplete', 'off');
  3263.         }
  3264.         this.field.on("specialkey", this.onSpecialKey, this);
  3265.         if(this.swallowKeys){
  3266.             this.field.el.swallowEvent(['keydown','keypress']);
  3267.         }
  3268.         this.field.show();
  3269.         this.field.on("blur", this.onBlur, this);
  3270.         if(this.field.grow){
  3271.             this.field.on("autosize", this.el.sync,  this.el, {delay:1});
  3272.         }
  3273.     },
  3274.     onSpecialKey : function(field, e){
  3275.         if(this.completeOnEnter && e.getKey() == e.ENTER){
  3276.             e.stopEvent();
  3277.             this.completeEdit();
  3278.         }else if(this.cancelOnEsc && e.getKey() == e.ESC){
  3279.             this.cancelEdit();
  3280.         }else{
  3281.             this.fireEvent('specialkey', field, e);
  3282.         }
  3283.     },
  3284.     startEdit : function(el, value){
  3285.         if(this.editing){
  3286.             this.completeEdit();
  3287.         }
  3288.         this.boundEl = Ext.get(el);
  3289.         var v = value !== undefined ? value : this.boundEl.dom.innerHTML;
  3290.         if(!this.rendered){
  3291.             this.render(this.parentEl || document.body);
  3292.         }
  3293.         if(this.fireEvent("beforestartedit", this, this.boundEl, v) === false){
  3294.             return;
  3295.         }
  3296.         this.startValue = v;
  3297.         this.field.setValue(v);
  3298.         this.doAutoSize();
  3299.         this.el.alignTo(this.boundEl, this.alignment);
  3300.         this.editing = true;
  3301.         this.show();
  3302.     },
  3303.         doAutoSize : function(){
  3304.         if(this.autoSize){
  3305.             var sz = this.boundEl.getSize();
  3306.             switch(this.autoSize){
  3307.                 case "width":
  3308.                     this.setSize(sz.width,  "");
  3309.                 break;
  3310.                 case "height":
  3311.                     this.setSize("",  sz.height);
  3312.                 break;
  3313.                 default:
  3314.                     this.setSize(sz.width,  sz.height);
  3315.             }
  3316.         }
  3317.     },
  3318.     setSize : function(w, h){
  3319.         delete this.field.lastSize;
  3320.         this.field.setSize(w, h);
  3321.         if(this.el){
  3322.             this.el.sync();
  3323.         }
  3324.     },
  3325.     realign : function(){
  3326.         this.el.alignTo(this.boundEl, this.alignment);
  3327.     },
  3328.     completeEdit : function(remainVisible){
  3329.         if(!this.editing){
  3330.             return;
  3331.         }
  3332.         var v = this.getValue();
  3333.         if(this.revertInvalid !== false && !this.field.isValid()){
  3334.             v = this.startValue;
  3335.             this.cancelEdit(true);
  3336.         }
  3337.         if(String(v) === String(this.startValue) && this.ignoreNoChange){
  3338.             this.editing = false;
  3339.             this.hide();
  3340.             return;
  3341.         }
  3342.         if(this.fireEvent("beforecomplete", this, v, this.startValue) !== false){
  3343.             this.editing = false;
  3344.             if(this.updateEl && this.boundEl){
  3345.                 this.boundEl.update(v);
  3346.             }
  3347.             if(remainVisible !== true){
  3348.                 this.hide();
  3349.             }
  3350.             this.fireEvent("complete", this, v, this.startValue);
  3351.         }
  3352.     },
  3353.         onShow : function(){
  3354.         this.el.show();
  3355.         if(this.hideEl !== false){
  3356.             this.boundEl.hide();
  3357.         }
  3358.         this.field.show();
  3359.         if(Ext.isIE && !this.fixIEFocus){             this.fixIEFocus = true;
  3360.             this.deferredFocus.defer(50, this);
  3361.         }else{
  3362.             this.field.focus();
  3363.         }
  3364.         this.fireEvent("startedit", this.boundEl, this.startValue);
  3365.     },
  3366.     deferredFocus : function(){
  3367.         if(this.editing){
  3368.             this.field.focus();
  3369.         }
  3370.     },
  3371.     cancelEdit : function(remainVisible){
  3372.         if(this.editing){
  3373.             this.setValue(this.startValue);
  3374.             if(remainVisible !== true){
  3375.                 this.hide();
  3376.             }
  3377.         }
  3378.     },
  3379.         onBlur : function(){
  3380.         if(this.allowBlur !== true && this.editing){
  3381.             this.completeEdit();
  3382.         }
  3383.     },
  3384.         onHide : function(){
  3385.         if(this.editing){
  3386.             this.completeEdit();
  3387.             return;
  3388.         }
  3389.         this.field.blur();
  3390.         if(this.field.collapse){
  3391.             this.field.collapse();
  3392.         }
  3393.         this.el.hide();