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

JavaScript

开发平台:

JavaScript

  1.             }
  2.         } else {
  3.             if(col >= clen){
  4.                 row++;
  5.                 first = false;
  6.             }
  7.             while(row < rlen){
  8.                 if(!first){
  9.                     col = 0;
  10.                 }
  11.                 first = false;
  12.                 while(col < clen){
  13.                     if(fn.call(scope || this, row, col, cm) === true){
  14.                         return [row, col];
  15.                     }
  16.                     col++;
  17.                 }
  18.                 row++;
  19.             }
  20.         }
  21.         return null;
  22.     },
  23.     getSelections : function(){
  24.         return this.selModel.getSelections();
  25.     },
  26.     onResize : function(){
  27.         Ext.grid.GridPanel.superclass.onResize.apply(this, arguments);
  28.         if(this.viewReady){
  29.             this.view.layout();
  30.         }
  31.     },
  32.     getGridEl : function(){
  33.         return this.body;
  34.     },
  35.     stopEditing : function(){},
  36.     getSelectionModel : function(){
  37.         if(!this.selModel){
  38.             this.selModel = new Ext.grid.RowSelectionModel(
  39.                     this.disableSelection ? {selectRow: Ext.emptyFn} : null);
  40.         }
  41.         return this.selModel;
  42.     },
  43.     getStore : function(){
  44.         return this.store;
  45.     },
  46.     getColumnModel : function(){
  47.         return this.colModel;
  48.     },
  49.     getView : function(){
  50.         if(!this.view){
  51.             this.view = new Ext.grid.GridView(this.viewConfig);
  52.         }
  53.         return this.view;
  54.     },
  55.     getDragDropText : function(){
  56.         var count = this.selModel.getCount();
  57.         return String.format(this.ddText, count, count == 1 ? '' : 's');
  58.     }
  59. });
  60. Ext.reg('grid', Ext.grid.GridPanel);
  61. Ext.grid.GridView = function(config){
  62.     Ext.apply(this, config);
  63.         this.addEvents(
  64.       "beforerowremoved",
  65.       "beforerowsinserted",
  66.       "beforerefresh",
  67.       "rowremoved",
  68.       "rowsinserted",
  69.       "rowupdated",
  70.       "refresh"
  71.   );
  72.     Ext.grid.GridView.superclass.constructor.call(this);
  73. };
  74. Ext.extend(Ext.grid.GridView, Ext.util.Observable, {
  75.     scrollOffset: 19,
  76.     autoFill: false,
  77.     forceFit: false,
  78.     sortClasses : ["sort-asc", "sort-desc"],
  79.     sortAscText : "Sort Ascending",
  80.     sortDescText : "Sort Descending",
  81.     columnsText : "Columns",
  82.         borderWidth: 2,
  83.         initTemplates : function(){
  84.         var ts = this.templates || {};
  85.         if(!ts.master){
  86.             ts.master = new Ext.Template(
  87.                     '<div class="x-grid3" hidefocus="true">',
  88.                         '<div class="x-grid3-viewport">',
  89.                             '<div class="x-grid3-header"><div class="x-grid3-header-inner"><div class="x-grid3-header-offset">{header}</div></div><div class="x-clear"></div></div>',
  90.                             '<div class="x-grid3-scroller"><div class="x-grid3-body">{body}</div><a href="#" class="x-grid3-focus" tabIndex="-1"></a></div>',
  91.                         "</div>",
  92.                         '<div class="x-grid3-resize-marker">&#160;</div>',
  93.                         '<div class="x-grid3-resize-proxy">&#160;</div>',
  94.                     "</div>"
  95.                     );
  96.         }
  97.         if(!ts.header){
  98.             ts.header = new Ext.Template(
  99.                     '<table border="0" cellspacing="0" cellpadding="0" style="{tstyle}">',
  100.                     '<thead><tr class="x-grid3-hd-row">{cells}</tr></thead>',
  101.                     "</table>"
  102.                     );
  103.         }
  104.         if(!ts.hcell){
  105.             ts.hcell = new Ext.Template(
  106.                     '<td class="x-grid3-hd x-grid3-cell x-grid3-td-{id}" style="{style}"><div {tooltip} {attr} class="x-grid3-hd-inner x-grid3-hd-{id}" unselectable="on" style="{istyle}">', this.grid.enableHdMenu ? '<a class="x-grid3-hd-btn" href="#"></a>' : '',
  107.                     '{value}<img class="x-grid3-sort-icon" src="', Ext.BLANK_IMAGE_URL, '" />',
  108.                     "</div></td>"
  109.                     );
  110.         }
  111.         if(!ts.body){
  112.             ts.body = new Ext.Template('{rows}');
  113.         }
  114.         if(!ts.row){
  115.             ts.row = new Ext.Template(
  116.                     '<div class="x-grid3-row {alt}" style="{tstyle}"><table class="x-grid3-row-table" border="0" cellspacing="0" cellpadding="0" style="{tstyle}">',
  117.                     '<tbody><tr>{cells}</tr>',
  118.                     (this.enableRowBody ? '<tr class="x-grid3-row-body-tr" style="{bodyStyle}"><td colspan="{cols}" class="x-grid3-body-cell" tabIndex="0" hidefocus="on"><div class="x-grid3-row-body">{body}</div></td></tr>' : ''),
  119.                     '</tbody></table></div>'
  120.                     );
  121.         }
  122.         if(!ts.cell){
  123.             ts.cell = new Ext.Template(
  124.                     '<td class="x-grid3-col x-grid3-cell x-grid3-td-{id} {css}" style="{style}" tabIndex="0" {cellAttr}>',
  125.                     '<div class="x-grid3-cell-inner x-grid3-col-{id}" unselectable="on" {attr}>{value}</div>',
  126.                     "</td>"
  127.                     );
  128.         }
  129.         for(var k in ts){
  130.             var t = ts[k];
  131.             if(t && typeof t.compile == 'function' && !t.compiled){
  132.                 t.disableFormats = true;
  133.                 t.compile();
  134.             }
  135.         }
  136.         this.templates = ts;
  137.         this.tdClass = 'x-grid3-cell';
  138.         this.cellSelector = 'td.x-grid3-cell';
  139.         this.hdCls = 'x-grid3-hd';
  140.         this.rowSelector = 'div.x-grid3-row';
  141.         this.colRe = new RegExp("x-grid3-td-([^\s]+)", "");
  142.     },
  143.         fly : function(el){
  144.         if(!this._flyweight){
  145.             this._flyweight = new Ext.Element.Flyweight(document.body);
  146.         }
  147.         this._flyweight.dom = el;
  148.         return this._flyweight;
  149.     },
  150.         getEditorParent : function(ed){
  151.         return this.scroller.dom;
  152.     },
  153.         initElements : function(){
  154.         var E = Ext.Element;
  155.         var el = this.grid.getGridEl().dom.firstChild;
  156.         var cs = el.childNodes;
  157.         this.el = new E(el);
  158.         this.mainWrap = new E(cs[0]);
  159.         this.mainHd = new E(this.mainWrap.dom.firstChild);
  160.         if(this.grid.hideHeaders){
  161.             this.mainHd.setDisplayed(false);
  162.         }
  163.         this.innerHd = this.mainHd.dom.firstChild;
  164.         this.scroller = new E(this.mainWrap.dom.childNodes[1]);
  165.         if(this.forceFit){
  166.             this.scroller.setStyle('overflow-x', 'hidden');
  167.         }
  168.         this.mainBody = new E(this.scroller.dom.firstChild);
  169.         this.focusEl = new E(this.scroller.dom.childNodes[1]);
  170.         this.focusEl.swallowEvent("click", true);
  171.         this.resizeMarker = new E(cs[1]);
  172.         this.resizeProxy = new E(cs[2]);
  173.     },
  174.         getRows : function(){
  175.         return this.hasRows() ? this.mainBody.dom.childNodes : [];
  176.     },
  177.         findCell : function(el){
  178.         if(!el){
  179.             return false;
  180.         }
  181.         return this.fly(el).findParent(this.cellSelector, 3);
  182.     },
  183.         findCellIndex : function(el, requiredCls){
  184.         var cell = this.findCell(el);
  185.         if(cell && (!requiredCls || this.fly(cell).hasClass(requiredCls))){
  186.             return this.getCellIndex(cell);
  187.         }
  188.         return false;
  189.     },
  190.         getCellIndex : function(el){
  191.         if(el){
  192.             var m = el.className.match(this.colRe);
  193.             if(m && m[1]){
  194.                 return this.cm.getIndexById(m[1]);
  195.             }
  196.         }
  197.         return false;
  198.     },
  199.         findHeaderCell : function(el){
  200.         var cell = this.findCell(el);
  201.         return cell && this.fly(cell).hasClass(this.hdCls) ? cell : null;
  202.     },
  203.         findHeaderIndex : function(el){
  204.         return this.findCellIndex(el, this.hdCls);
  205.     },
  206.         findRow : function(el){
  207.         if(!el){
  208.             return false;
  209.         }
  210.         return this.fly(el).findParent(this.rowSelector, 10);
  211.     },
  212.         findRowIndex : function(el){
  213.         var r = this.findRow(el);
  214.         return r ? r.rowIndex : false;
  215.     },
  216.     getRow : function(row){
  217.         return this.getRows()[row];
  218.     },
  219.     getCell : function(row, col){
  220.         return this.getRow(row).getElementsByTagName('td')[col];
  221.     },
  222.     getHeaderCell : function(index){
  223.       return this.mainHd.dom.getElementsByTagName('td')[index];
  224.     },
  225.         addRowClass : function(row, cls){
  226.         var r = this.getRow(row);
  227.         if(r){
  228.             this.fly(r).addClass(cls);
  229.         }
  230.     },
  231.         removeRowClass : function(row, cls){
  232.         var r = this.getRow(row);
  233.         if(r){
  234.             this.fly(r).removeClass(cls);
  235.         }
  236.     },
  237.         removeRow : function(row){
  238.         Ext.removeNode(this.getRow(row));
  239.     },
  240.         removeRows : function(firstRow, lastRow){
  241.         var bd = this.mainBody.dom;
  242.         for(var rowIndex = firstRow; rowIndex <= lastRow; rowIndex++){
  243.             Ext.removeNode(bd.childNodes[firstRow]);
  244.         }
  245.     },
  246.         getScrollState : function(){
  247.         var sb = this.scroller.dom;
  248.         return {left: sb.scrollLeft, top: sb.scrollTop};
  249.     },
  250.         restoreScroll : function(state){
  251.         var sb = this.scroller.dom;
  252.         sb.scrollLeft = state.left;
  253.         sb.scrollTop = state.top;
  254.     },
  255.     scrollToTop : function(){
  256.         this.scroller.dom.scrollTop = 0;
  257.         this.scroller.dom.scrollLeft = 0;
  258.     },
  259.         syncScroll : function(){
  260.       this.syncHeaderScroll();
  261.       var mb = this.scroller.dom;
  262.         this.grid.fireEvent("bodyscroll", mb.scrollLeft, mb.scrollTop);
  263.     },
  264.         syncHeaderScroll : function(){
  265.         var mb = this.scroller.dom;
  266.         this.innerHd.scrollLeft = mb.scrollLeft;
  267.         this.innerHd.scrollLeft = mb.scrollLeft;     },
  268.         updateSortIcon : function(col, dir){
  269.         var sc = this.sortClasses;
  270.         var hds = this.mainHd.select('td').removeClass(sc);
  271.         hds.item(col).addClass(sc[dir == "DESC" ? 1 : 0]);
  272.     },
  273.         updateAllColumnWidths : function(){
  274.         var tw = this.getTotalWidth();
  275.         var clen = this.cm.getColumnCount();
  276.         var ws = [];
  277.         for(var i = 0; i < clen; i++){
  278.             ws[i] = this.getColumnWidth(i);
  279.         }
  280.         this.innerHd.firstChild.firstChild.style.width = tw;
  281.         for(var i = 0; i < clen; i++){
  282.             var hd = this.getHeaderCell(i);
  283.             hd.style.width = ws[i];
  284.         }
  285.         var ns = this.getRows();
  286.         for(var i = 0, len = ns.length; i < len; i++){
  287.             ns[i].style.width = tw;
  288.             ns[i].firstChild.style.width = tw;
  289.             var row = ns[i].firstChild.rows[0];
  290.             for(var j = 0; j < clen; j++){
  291.                 row.childNodes[j].style.width = ws[j];
  292.             }
  293.         }
  294.         this.onAllColumnWidthsUpdated(ws, tw);
  295.     },
  296.         updateColumnWidth : function(col, width){
  297.         var w = this.getColumnWidth(col);
  298.         var tw = this.getTotalWidth();
  299.         this.innerHd.firstChild.firstChild.style.width = tw;
  300.         var hd = this.getHeaderCell(col);
  301.         hd.style.width = w;
  302.         var ns = this.getRows();
  303.         for(var i = 0, len = ns.length; i < len; i++){
  304.             ns[i].style.width = tw;
  305.             ns[i].firstChild.style.width = tw;
  306.             ns[i].firstChild.rows[0].childNodes[col].style.width = w;
  307.         }
  308.         this.onColumnWidthUpdated(col, w, tw);
  309.     },
  310.         updateColumnHidden : function(col, hidden){
  311.         var tw = this.getTotalWidth();
  312.         this.innerHd.firstChild.firstChild.style.width = tw;
  313.         var display = hidden ? 'none' : '';
  314.         var hd = this.getHeaderCell(col);
  315.         hd.style.display = display;
  316.         var ns = this.getRows();
  317.         for(var i = 0, len = ns.length; i < len; i++){
  318.             ns[i].style.width = tw;
  319.             ns[i].firstChild.style.width = tw;
  320.             ns[i].firstChild.rows[0].childNodes[col].style.display = display;
  321.         }
  322.         this.onColumnHiddenUpdated(col, hidden, tw);
  323.         delete this.lastViewWidth;         this.layout();
  324.     },
  325.         doRender : function(cs, rs, ds, startRow, colCount, stripe){
  326.         var ts = this.templates, ct = ts.cell, rt = ts.row, last = colCount-1;
  327.         var tstyle = 'width:'+this.getTotalWidth()+';';
  328.                 var buf = [], cb, c, p = {}, rp = {tstyle: tstyle}, r;
  329.         for(var j = 0, len = rs.length; j < len; j++){
  330.             r = rs[j]; cb = [];
  331.             var rowIndex = (j+startRow);
  332.             for(var i = 0; i < colCount; i++){
  333.                 c = cs[i];
  334.                 p.id = c.id;
  335.                 p.css = i == 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : '');
  336.                 p.attr = p.cellAttr = "";
  337.                 p.value = c.renderer(r.data[c.name], p, r, rowIndex, i, ds);
  338.                 p.style = c.style;
  339.                 if(p.value == undefined || p.value === "") p.value = "&#160;";
  340.                 if(r.dirty && typeof r.modified[c.name] !== 'undefined'){
  341.                     p.css += ' x-grid3-dirty-cell';
  342.                 }
  343.                 cb[cb.length] = ct.apply(p);
  344.             }
  345.             var alt = [];
  346.             if(stripe && ((rowIndex+1) % 2 == 0)){
  347.                 alt[0] = "x-grid3-row-alt";
  348.             }
  349.             if(r.dirty){
  350.                 alt[1] = " x-grid3-dirty-row";
  351.             }
  352.             rp.cols = colCount;
  353.             if(this.getRowClass){
  354.                 alt[2] = this.getRowClass(r, rowIndex, rp, ds);
  355.             }
  356.             rp.alt = alt.join(" ");
  357.             rp.cells = cb.join("");
  358.             buf[buf.length] =  rt.apply(rp);
  359.         }
  360.         return buf.join("");
  361.     },
  362.         processRows : function(startRow, skipStripe){
  363.         if(this.ds.getCount() < 1){
  364.             return;
  365.         }
  366.         skipStripe = skipStripe || !this.grid.stripeRows;
  367.         startRow = startRow || 0;
  368.         var rows = this.getRows();
  369.         var cls = ' x-grid3-row-alt ';
  370.         for(var i = startRow, len = rows.length; i < len; i++){
  371.             var row = rows[i];
  372.             row.rowIndex = i;
  373.             if(!skipStripe){
  374.                 var isAlt = ((i+1) % 2 == 0);
  375.                 var hasAlt = (' '+row.className + ' ').indexOf(cls) != -1;
  376.                 if(isAlt == hasAlt){
  377.                     continue;
  378.                 }
  379.                 if(isAlt){
  380.                     row.className += " x-grid3-row-alt";
  381.                 }else{
  382.                     row.className = row.className.replace("x-grid3-row-alt", "");
  383.                 }
  384.             }
  385.         }
  386.     },
  387.         renderUI : function(){
  388.         var header = this.renderHeaders();
  389.         var body = this.templates.body.apply({rows:''});
  390.         var html = this.templates.master.apply({
  391.             body: body,
  392.             header: header
  393.         });
  394.         var g = this.grid;
  395.         g.getGridEl().dom.innerHTML = html;
  396.         this.initElements();
  397.         this.mainBody.dom.innerHTML = this.renderRows();
  398.         this.processRows(0, true);
  399.                 Ext.fly(this.innerHd).on("click", this.handleHdDown, this);
  400.         this.mainHd.on("mouseover", this.handleHdOver, this);
  401.         this.mainHd.on("mouseout", this.handleHdOut, this);
  402.         this.mainHd.on("mousemove", this.handleHdMove, this);
  403.         this.scroller.on('scroll', this.syncScroll,  this);
  404.         if(g.enableColumnResize !== false){
  405.             this.splitone = new Ext.grid.GridView.SplitDragZone(g, this.mainHd.dom);
  406.         }
  407.         if(g.enableColumnMove){
  408.             this.columnDrag = new Ext.grid.GridView.ColumnDragZone(g, this.innerHd);
  409.             this.columnDrop = new Ext.grid.HeaderDropZone(g, this.mainHd.dom);
  410.         }
  411.         if(g.enableHdMenu !== false){
  412.             if(g.enableColumnHide !== false){
  413.                 this.colMenu = new Ext.menu.Menu({id:g.id + "-hcols-menu"});
  414.                 this.colMenu.on("beforeshow", this.beforeColMenuShow, this);
  415.                 this.colMenu.on("itemclick", this.handleHdMenuClick, this);
  416.             }
  417.             this.hmenu = new Ext.menu.Menu({id: g.id + "-hctx"});
  418.             this.hmenu.add(
  419.                 {id:"asc", text: this.sortAscText, cls: "xg-hmenu-sort-asc"},
  420.                 {id:"desc", text: this.sortDescText, cls: "xg-hmenu-sort-desc"}
  421.             );
  422.             if(g.enableColumnHide !== false){
  423.                 this.hmenu.add('-',
  424.                     {id:"columns", text: this.columnsText, menu: this.colMenu, iconCls: 'x-cols-icon'}
  425.                 );
  426.             }
  427.             this.hmenu.on("itemclick", this.handleHdMenuClick, this);
  428.                     }
  429.         if(g.enableDragDrop || g.enableDrag){
  430.             var dd = new Ext.grid.GridDragZone(g, {
  431.                 ddGroup : g.ddGroup || 'GridDD'
  432.             });
  433.         }
  434.         this.updateHeaderSortState();
  435.     },
  436.         layout : function(){
  437.         if(!this.mainBody){
  438.             return;         }
  439.         var g = this.grid;
  440.         var c = g.getGridEl(), cm = this.cm,
  441.                 expandCol = g.autoExpandColumn,
  442.                 gv = this;
  443.         var csize = c.getSize(true);
  444.         var vw = csize.width;
  445.         if(vw < 20 || csize.height < 20){             return;
  446.         }
  447.         if(g.autoHeight){
  448.             this.scroller.dom.style.overflow = 'visible';
  449.         }else{
  450.             this.el.setSize(csize.width, csize.height);
  451.             var hdHeight = this.mainHd.getHeight();
  452.             var vh = csize.height - (hdHeight);
  453.             this.scroller.setSize(vw, vh);
  454.             if(this.innerHd){
  455.                 this.innerHd.style.width = (vw)+'px';
  456.             }
  457.         }
  458.         if(this.forceFit){
  459.             if(this.lastViewWidth != vw){
  460.                 this.fitColumns(false, false);
  461.                 this.lastViewWidth = vw;
  462.             }
  463.         }else {
  464.             this.autoExpand();
  465.             this.syncHeaderScroll();
  466.         }
  467.         this.onLayout(vw, vh);
  468.     },
  469.             onLayout : function(vw, vh){
  470.             },
  471.     onColumnWidthUpdated : function(col, w, tw){
  472.             },
  473.     onAllColumnWidthsUpdated : function(ws, tw){
  474.             },
  475.     onColumnHiddenUpdated : function(col, hidden, tw){
  476.             },
  477.     updateColumnText : function(col, text){
  478.             },
  479.     afterMove : function(colIndex){
  480.             },
  481.         init: function(grid){
  482.         this.grid = grid;
  483.         this.initTemplates();
  484.         this.initData(grid.store, grid.colModel);
  485.         this.initUI(grid);
  486.     },
  487.         getColumnId : function(index){
  488.       return this.cm.getColumnId(index);
  489.     },
  490.         renderHeaders : function(){
  491.         var cm = this.cm, ts = this.templates;
  492.         var ct = ts.hcell;
  493.         var cb = [], sb = [], p = {};
  494.         for(var i = 0, len = cm.getColumnCount(); i < len; i++){
  495.             p.id = cm.getColumnId(i);
  496.             p.value = cm.getColumnHeader(i) || "";
  497.             p.style = this.getColumnStyle(i, true);
  498.             p.tooltip = this.getColumnTooltip(i);
  499.             if(cm.config[i].align == 'right'){
  500.                 p.istyle = 'padding-right:16px';
  501.             } else {
  502.                 delete p.istyle;
  503.             }
  504.             cb[cb.length] = ct.apply(p);
  505.         }
  506.         return ts.header.apply({cells: cb.join(""), tstyle:'width:'+this.getTotalWidth()+';'});
  507.     },
  508.         getColumnTooltip : function(i){
  509.         var tt = this.cm.getColumnTooltip(i);
  510.         if(tt){
  511.             if(Ext.QuickTips.isEnabled()){
  512.                 return 'ext:qtip="'+tt+'"';
  513.             }else{
  514.                 return 'title="'+tt+'"';
  515.             }
  516.         }
  517.         return "";
  518.     },
  519.         beforeUpdate : function(){
  520.         this.grid.stopEditing(true);
  521.     },
  522.         updateHeaders : function(){
  523.         this.innerHd.firstChild.innerHTML = this.renderHeaders();
  524.     },
  525.     focusRow : function(row){
  526.         this.focusCell(row, 0, false);
  527.     },
  528.     focusCell : function(row, col, hscroll){
  529.         var xy = this.ensureVisible(row, col, hscroll);
  530.         this.focusEl.setXY(xy);
  531.         if(Ext.isGecko){
  532.             this.focusEl.focus();
  533.         }else{
  534.             this.focusEl.focus.defer(1, this.focusEl);
  535.         }
  536.     },
  537.         ensureVisible : function(row, col, hscroll){
  538.         if(typeof row != "number"){
  539.             row = row.rowIndex;
  540.         }
  541.         if(!this.ds){
  542.             return;
  543.         }
  544.         if(row < 0 || row >= this.ds.getCount()){
  545.             return;
  546.         }
  547.         col = (col !== undefined ? col : 0);
  548.         var rowEl = this.getRow(row), cellEl;
  549.         if(!(hscroll === false && col === 0)){
  550.             while(this.cm.isHidden(col)){
  551.                 col++;
  552.             }
  553.             cellEl = this.getCell(row, col);
  554.         }
  555.         if(!rowEl){
  556.             return;
  557.         }
  558.         var c = this.scroller.dom;
  559.         var ctop = 0;
  560.         var p = rowEl, stop = this.el.dom;
  561.         while(p && p != stop){
  562.             ctop += p.offsetTop;
  563.             p = p.offsetParent;
  564.         }
  565.         ctop -= this.mainHd.dom.offsetHeight;
  566.         var cbot = ctop + rowEl.offsetHeight;
  567.         var ch = c.clientHeight;
  568.         var stop = parseInt(c.scrollTop, 10);
  569.         var sbot = stop + ch;
  570.         if(ctop < stop){
  571.           c.scrollTop = ctop;
  572.         }else if(cbot > sbot){
  573.             c.scrollTop = cbot-ch;
  574.         }
  575.         if(hscroll !== false){
  576.             var cleft = parseInt(cellEl.offsetLeft, 10);
  577.             var cright = cleft + cellEl.offsetWidth;
  578.             var sleft = parseInt(c.scrollLeft, 10);
  579.             var sright = sleft + c.clientWidth;
  580.             if(cleft < sleft){
  581.                 c.scrollLeft = cleft;
  582.             }else if(cright > sright){
  583.                 c.scrollLeft = cright-c.clientWidth;
  584.             }
  585.         }
  586.         return cellEl ? Ext.fly(cellEl).getXY() : [c.scrollLeft, Ext.fly(rowEl).getY()];
  587.     },
  588.         insertRows : function(dm, firstRow, lastRow, isUpdate){
  589.         if(!isUpdate && firstRow === 0 && lastRow == dm.getCount()-1){
  590.             this.refresh();
  591.         }else{
  592.             if(!isUpdate){
  593.                 this.fireEvent("beforerowsinserted", this, firstRow, lastRow);
  594.             }
  595.             var html = this.renderRows(firstRow, lastRow);
  596.             var before = this.getRow(firstRow);
  597.             if(before){
  598.                 Ext.DomHelper.insertHtml('beforeBegin', before, html);
  599.             }else{
  600.                 Ext.DomHelper.insertHtml('beforeEnd', this.mainBody.dom, html);
  601.             }
  602.             if(!isUpdate){
  603.                 this.fireEvent("rowsinserted", this, firstRow, lastRow);
  604.                 this.processRows(firstRow);
  605.             }
  606.         }
  607.     },
  608.         deleteRows : function(dm, firstRow, lastRow){
  609.         if(dm.getRowCount()<1){
  610.             this.refresh();
  611.         }else{
  612.             this.fireEvent("beforerowsdeleted", this, firstRow, lastRow);
  613.             this.removeRows(firstRow, lastRow);
  614.             this.processRows(firstRow);
  615.             this.fireEvent("rowsdeleted", this, firstRow, lastRow);
  616.         }
  617.     },
  618.         getColumnStyle : function(col, isHeader){
  619.         var style = !isHeader ? (this.cm.config[col].css || '') : '';
  620.         style += 'width:'+this.getColumnWidth(col)+';';
  621.         if(this.cm.isHidden(col)){
  622.             style += 'display:none;';
  623.         }
  624.         var align = this.cm.config[col].align;
  625.         if(align){
  626.             style += 'text-align:'+align+';';
  627.         }
  628.         return style;
  629.     },
  630.         getColumnWidth : function(col){
  631.         var w = this.cm.getColumnWidth(col);
  632.         if(typeof w == 'number'){
  633.             return (Ext.isBorderBox ? w : (w-this.borderWidth > 0 ? w-this.borderWidth:0)) + 'px';
  634.         }
  635.         return w;
  636.     },
  637.         getTotalWidth : function(){
  638.         return this.cm.getTotalWidth()+'px';
  639.     },
  640.         fitColumns : function(preventRefresh, onlyExpand, omitColumn){
  641.         var cm = this.cm, leftOver, dist, i;
  642.         var tw = cm.getTotalWidth(false);
  643.         var aw = this.grid.getGridEl().getWidth(true)-this.scrollOffset;
  644.         if(aw < 20){             return;
  645.         }
  646.         var extra = aw - tw;
  647.         if(extra === 0){
  648.             return false;
  649.         }
  650.         var vc = cm.getColumnCount(true);
  651.         var ac = vc-(typeof omitColumn == 'number' ? 1 : 0);
  652.         if(ac === 0){
  653.             ac = 1;
  654.             omitColumn = undefined;
  655.         }
  656.         var colCount = cm.getColumnCount();
  657.         var cols = [];
  658.         var extraCol = 0;
  659.         var width = 0;
  660.         var w;
  661.         for (i = 0; i < colCount; i++){
  662.             if(!cm.isHidden(i) && !cm.isFixed(i) && i !== omitColumn){
  663.                 w = cm.getColumnWidth(i);
  664.                 cols.push(i);
  665.                 extraCol = i;
  666.                 cols.push(w);
  667.                 width += w;
  668.             }
  669.         }
  670.         var frac = (aw - cm.getTotalWidth())/width;
  671.         while (cols.length){
  672.             w = cols.pop();
  673.             i = cols.pop();
  674.             cm.setColumnWidth(i, Math.max(this.grid.minColumnWidth, Math.floor(w + w*frac)), true);
  675.         }
  676.         if((tw = cm.getTotalWidth(false)) > aw){
  677.             var adjustCol = ac != vc ? omitColumn : extraCol;
  678.              cm.setColumnWidth(adjustCol, Math.max(1,
  679.                      cm.getColumnWidth(adjustCol)- (tw-aw)), true);
  680.         }
  681.         if(preventRefresh !== true){
  682.             this.updateAllColumnWidths();
  683.         }
  684.         return true;
  685.     },
  686.         autoExpand : function(preventUpdate){
  687.         var g = this.grid, cm = this.cm;
  688.         if(!this.userResized && g.autoExpandColumn){
  689.             var tw = cm.getTotalWidth(false);
  690.             var aw = this.grid.getGridEl().getWidth(true)-this.scrollOffset;
  691.             if(tw != aw){
  692.                 var ci = cm.getIndexById(g.autoExpandColumn);
  693.                 var currentWidth = cm.getColumnWidth(ci);
  694.                 var cw = Math.min(Math.max(((aw-tw)+currentWidth), g.autoExpandMin), g.autoExpandMax);
  695.                 if(cw != currentWidth){
  696.                     cm.setColumnWidth(ci, cw, true);
  697.                     if(preventUpdate !== true){
  698.                         this.updateColumnWidth(ci, cw);
  699.                     }
  700.                 }
  701.             }
  702.         }
  703.     },
  704.         getColumnData : function(){
  705.                 var cs = [], cm = this.cm, colCount = cm.getColumnCount();
  706.         for(var i = 0; i < colCount; i++){
  707.             var name = cm.getDataIndex(i);
  708.             cs[i] = {
  709.                 name : (typeof name == 'undefined' ? this.ds.fields.get(i).name : name),
  710.                 renderer : cm.getRenderer(i),
  711.                 id : cm.getColumnId(i),
  712.                 style : this.getColumnStyle(i)
  713.             };
  714.         }
  715.         return cs;
  716.     },
  717.         renderRows : function(startRow, endRow){
  718.                 var g = this.grid, cm = g.colModel, ds = g.store, stripe = g.stripeRows;
  719.         var colCount = cm.getColumnCount();
  720.         if(ds.getCount() < 1){
  721.             return "";
  722.         }
  723.         var cs = this.getColumnData();
  724.         startRow = startRow || 0;
  725.         endRow = typeof endRow == "undefined"? ds.getCount()-1 : endRow;
  726.                 var rs = ds.getRange(startRow, endRow);
  727.         return this.doRender(cs, rs, ds, startRow, colCount, stripe);
  728.     },
  729.         renderBody : function(){
  730.         var markup = this.renderRows();
  731.         return this.templates.body.apply({rows: markup});
  732.     },
  733.         refreshRow : function(record){
  734.         var ds = this.ds, index;
  735.         if(typeof record == 'number'){
  736.             index = record;
  737.             record = ds.getAt(index);
  738.         }else{
  739.             index = ds.indexOf(record);
  740.         }
  741.         var cls = [];
  742.         this.insertRows(ds, index, index, true);
  743.         this.getRow(index).rowIndex = index;
  744.         this.onRemove(ds, record, index+1, true);
  745.         this.fireEvent("rowupdated", this, index, record);
  746.     },
  747.     refresh : function(headersToo){
  748.         this.fireEvent("beforerefresh", this);
  749.         this.grid.stopEditing(true);
  750.         var result = this.renderBody();
  751.         this.mainBody.update(result);
  752.         if(headersToo === true){
  753.             this.updateHeaders();
  754.             this.updateHeaderSortState();
  755.         }
  756.         this.processRows(0, true);
  757.         this.layout();
  758.         this.applyEmptyText();
  759.         this.fireEvent("refresh", this);
  760.     },
  761.         applyEmptyText : function(){
  762.         if(this.emptyText && !this.hasRows()){
  763.             this.mainBody.update('<div class="x-grid-empty">' + this.emptyText + '</div>');
  764.         }
  765.     },
  766.         updateHeaderSortState : function(){
  767.         var state = this.ds.getSortState();
  768.         if(!state){
  769.             return;
  770.         }
  771.         if(!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)){
  772.             this.grid.fireEvent('sortchange', this.grid, state);
  773.         }
  774.         this.sortState = state;
  775.         var sortColumn = this.cm.findColumnIndex(state.field);
  776.         if(sortColumn != -1){
  777.             var sortDir = state.direction;
  778.             this.updateSortIcon(sortColumn, sortDir);
  779.         }
  780.     },
  781.         destroy : function(){
  782.         if(this.colMenu){
  783.             this.colMenu.removeAll();
  784.             Ext.menu.MenuMgr.unregister(this.colMenu);
  785.             this.colMenu.getEl().remove();
  786.             delete this.colMenu;
  787.         }
  788.         if(this.hmenu){
  789.             this.hmenu.removeAll();
  790.             Ext.menu.MenuMgr.unregister(this.hmenu);
  791.             this.hmenu.getEl().remove();
  792.             delete this.hmenu;
  793.         }
  794.         if(this.grid.enableColumnMove){
  795.             var dds = Ext.dd.DDM.ids['gridHeader' + this.grid.getGridEl().id];
  796.             if(dds){
  797.                 for(var dd in dds){
  798.                     if(!dds[dd].config.isTarget && dds[dd].dragElId){
  799.                         var elid = dds[dd].dragElId;
  800.                         dds[dd].unreg();
  801.                         Ext.get(elid).remove();
  802.                     } else if(dds[dd].config.isTarget){
  803.                         dds[dd].proxyTop.remove();
  804.                         dds[dd].proxyBottom.remove();
  805.                         dds[dd].unreg();
  806.                     }
  807.                     if(Ext.dd.DDM.locationCache[dd]){
  808.                         delete Ext.dd.DDM.locationCache[dd];
  809.                     }
  810.                 }
  811.                 delete Ext.dd.DDM.ids['gridHeader' + this.grid.getGridEl().id];
  812.             }
  813.         }
  814.         Ext.destroy(this.resizeMarker, this.resizeProxy);
  815.         this.initData(null, null);
  816.         Ext.EventManager.removeResizeListener(this.onWindowResize, this);
  817.     },
  818.         onDenyColumnHide : function(){
  819.     },
  820.         render : function(){
  821.         var cm = this.cm;
  822.         var colCount = cm.getColumnCount();
  823.         if(this.autoFill){
  824.             this.fitColumns(true, true);
  825.         }else if(this.forceFit){
  826.             this.fitColumns(true, false);
  827.         }else if(this.grid.autoExpandColumn){
  828.             this.autoExpand(true);
  829.         }
  830.         this.renderUI();
  831.     },
  832.         initData : function(ds, cm){
  833.         if(this.ds){
  834.             this.ds.un("load", this.onLoad, this);
  835.             this.ds.un("datachanged", this.onDataChange, this);
  836.             this.ds.un("add", this.onAdd, this);
  837.             this.ds.un("remove", this.onRemove, this);
  838.             this.ds.un("update", this.onUpdate, this);
  839.             this.ds.un("clear", this.onClear, this);
  840.         }
  841.         if(ds){
  842.             ds.on("load", this.onLoad, this);
  843.             ds.on("datachanged", this.onDataChange, this);
  844.             ds.on("add", this.onAdd, this);
  845.             ds.on("remove", this.onRemove, this);
  846.             ds.on("update", this.onUpdate, this);
  847.             ds.on("clear", this.onClear, this);
  848.         }
  849.         this.ds = ds;
  850.         if(this.cm){
  851.             this.cm.un("configchange", this.onColConfigChange, this);
  852.             this.cm.un("widthchange", this.onColWidthChange, this);
  853.             this.cm.un("headerchange", this.onHeaderChange, this);
  854.             this.cm.un("hiddenchange", this.onHiddenChange, this);
  855.             this.cm.un("columnmoved", this.onColumnMove, this);
  856.             this.cm.un("columnlockchange", this.onColumnLock, this);
  857.         }
  858.         if(cm){
  859.             cm.on("configchange", this.onColConfigChange, this);
  860.             cm.on("widthchange", this.onColWidthChange, this);
  861.             cm.on("headerchange", this.onHeaderChange, this);
  862.             cm.on("hiddenchange", this.onHiddenChange, this);
  863.             cm.on("columnmoved", this.onColumnMove, this);
  864.             cm.on("columnlockchange", this.onColumnLock, this);
  865.         }
  866.         this.cm = cm;
  867.     },
  868.         onDataChange : function(){
  869.         this.refresh();
  870.         this.updateHeaderSortState();
  871.     },
  872.         onClear : function(){
  873.         this.refresh();
  874.     },
  875.         onUpdate : function(ds, record){
  876.         this.refreshRow(record);
  877.     },
  878.         onAdd : function(ds, records, index){
  879.         this.insertRows(ds, index, index + (records.length-1));
  880.     },
  881.         onRemove : function(ds, record, index, isUpdate){
  882.         if(isUpdate !== true){
  883.             this.fireEvent("beforerowremoved", this, index, record);
  884.         }
  885.         this.removeRow(index);
  886.         if(isUpdate !== true){
  887.             this.processRows(index);
  888.             this.applyEmptyText();
  889.             this.fireEvent("rowremoved", this, index, record);
  890.         }
  891.     },
  892.         onLoad : function(){
  893.         this.scrollToTop();
  894.     },
  895.         onColWidthChange : function(cm, col, width){
  896.         this.updateColumnWidth(col, width);
  897.     },
  898.         onHeaderChange : function(cm, col, text){
  899.         this.updateHeaders();
  900.     },
  901.         onHiddenChange : function(cm, col, hidden){
  902.         this.updateColumnHidden(col, hidden);
  903.     },
  904.         onColumnMove : function(cm, oldIndex, newIndex){
  905.         this.indexMap = null;
  906.         var s = this.getScrollState();
  907.         this.refresh(true);
  908.         this.restoreScroll(s);
  909.         this.afterMove(newIndex);
  910.     },
  911.         onColConfigChange : function(){
  912.         delete this.lastViewWidth;
  913.         this.indexMap = null;
  914.         this.refresh(true);
  915.     },
  916.         initUI : function(grid){
  917.         grid.on("headerclick", this.onHeaderClick, this);
  918.         if(grid.trackMouseOver){
  919.             grid.on("mouseover", this.onRowOver, this);
  920.           grid.on("mouseout", this.onRowOut, this);
  921.       }
  922.     },
  923.         initEvents : function(){
  924.     },
  925.         onHeaderClick : function(g, index){
  926.         if(this.headersDisabled || !this.cm.isSortable(index)){
  927.             return;
  928.         }
  929.         g.stopEditing(true);
  930.         g.store.sort(this.cm.getDataIndex(index));
  931.     },
  932.         onRowOver : function(e, t){
  933.         var row;
  934.         if((row = this.findRowIndex(t)) !== false){
  935.             this.addRowClass(row, "x-grid3-row-over");
  936.         }
  937.     },
  938.         onRowOut : function(e, t){
  939.         var row;
  940.         if((row = this.findRowIndex(t)) !== false && row !== this.findRowIndex(e.getRelatedTarget())){
  941.             this.removeRowClass(row, "x-grid3-row-over");
  942.         }
  943.     },
  944.         handleWheel : function(e){
  945.         e.stopPropagation();
  946.     },
  947.         onRowSelect : function(row){
  948.         this.addRowClass(row, "x-grid3-row-selected");
  949.     },
  950.         onRowDeselect : function(row){
  951.         this.removeRowClass(row, "x-grid3-row-selected");
  952.     },
  953.         onCellSelect : function(row, col){
  954.         var cell = this.getCell(row, col);
  955.         if(cell){
  956.             this.fly(cell).addClass("x-grid3-cell-selected");
  957.         }
  958.     },
  959.         onCellDeselect : function(row, col){
  960.         var cell = this.getCell(row, col);
  961.         if(cell){
  962.             this.fly(cell).removeClass("x-grid3-cell-selected");
  963.         }
  964.     },
  965.         onColumnSplitterMoved : function(i, w){
  966.         this.userResized = true;
  967.         var cm = this.grid.colModel;
  968.         cm.setColumnWidth(i, w, true);
  969.         if(this.forceFit){
  970.             this.fitColumns(true, false, i);
  971.             this.updateAllColumnWidths();
  972.         }else{
  973.             this.updateColumnWidth(i, w);
  974.         }
  975.         this.grid.fireEvent("columnresize", i, w);
  976.     },
  977.         handleHdMenuClick : function(item){
  978.         var index = this.hdCtxIndex;
  979.         var cm = this.cm, ds = this.ds;
  980.         switch(item.id){
  981.             case "asc":
  982.                 ds.sort(cm.getDataIndex(index), "ASC");
  983.                 break;
  984.             case "desc":
  985.                 ds.sort(cm.getDataIndex(index), "DESC");
  986.                 break;
  987.             default:
  988.                 index = cm.getIndexById(item.id.substr(4));
  989.                 if(index != -1){
  990.                     if(item.checked && cm.getColumnsBy(this.isHideableColumn, this).length <= 1){
  991.                         this.onDenyColumnHide();
  992.                         return false;
  993.                     }
  994.                     cm.setHidden(index, item.checked);
  995.                 }
  996.         }
  997.         return true;
  998.     },
  999.         isHideableColumn : function(c){
  1000.         return !c.hidden && !c.fixed;
  1001.     },
  1002.         beforeColMenuShow : function(){
  1003.         var cm = this.cm,  colCount = cm.getColumnCount();
  1004.         this.colMenu.removeAll();
  1005.         for(var i = 0; i < colCount; i++){
  1006.             if(cm.config[i].fixed !== true && cm.config[i].hideable !== false){
  1007.                 this.colMenu.add(new Ext.menu.CheckItem({
  1008.                     id: "col-"+cm.getColumnId(i),
  1009.                     text: cm.getColumnHeader(i),
  1010.                     checked: !cm.isHidden(i),
  1011.                     hideOnClick:false,
  1012.                     disabled: cm.config[i].hideable === false
  1013.                 }));
  1014.             }
  1015.         }
  1016.     },
  1017.         handleHdDown : function(e, t){
  1018.         if(Ext.fly(t).hasClass('x-grid3-hd-btn')){
  1019.             e.stopEvent();
  1020.             var hd = this.findHeaderCell(t);
  1021.             Ext.fly(hd).addClass('x-grid3-hd-menu-open');
  1022.             var index = this.getCellIndex(hd);
  1023.             this.hdCtxIndex = index;
  1024.             var ms = this.hmenu.items, cm = this.cm;
  1025.             ms.get("asc").setDisabled(!cm.isSortable(index));
  1026.             ms.get("desc").setDisabled(!cm.isSortable(index));
  1027.             this.hmenu.on("hide", function(){
  1028.                 Ext.fly(hd).removeClass('x-grid3-hd-menu-open');
  1029.             }, this, {single:true});
  1030.             this.hmenu.show(t, "tl-bl?");
  1031.         }
  1032.     },
  1033.         handleHdOver : function(e, t){
  1034.         var hd = this.findHeaderCell(t);
  1035.         if(hd && !this.headersDisabled){
  1036.             this.activeHd = hd;
  1037.             this.activeHdIndex = this.getCellIndex(hd);
  1038.             var fly = this.fly(hd);
  1039.             this.activeHdRegion = fly.getRegion();
  1040.             if(!this.cm.isMenuDisabled(this.activeHdIndex)){
  1041.                 fly.addClass("x-grid3-hd-over");
  1042.                 this.activeHdBtn = fly.child('.x-grid3-hd-btn');
  1043.                 if(this.activeHdBtn){
  1044.                     this.activeHdBtn.dom.style.height = (hd.firstChild.offsetHeight-1)+'px';
  1045.                 }
  1046.             }
  1047.         }
  1048.     },
  1049.         handleHdMove : function(e, t){
  1050.         if(this.activeHd && !this.headersDisabled){
  1051.             var hw = this.splitHandleWidth || 5;
  1052.             var r = this.activeHdRegion;
  1053.             var x = e.getPageX();
  1054.             var ss = this.activeHd.style;
  1055.             if(x - r.left <= hw && this.cm.isResizable(this.activeHdIndex-1)){
  1056.                 ss.cursor = Ext.isAir ? 'move' : Ext.isSafari ? 'e-resize' : 'col-resize';             }else if(r.right - x <= (!this.activeHdBtn ? hw : 2) && this.cm.isResizable(this.activeHdIndex)){
  1057.                 ss.cursor = Ext.isAir ? 'move' : Ext.isSafari ? 'w-resize' : 'col-resize';
  1058.             }else{
  1059.                 ss.cursor = '';
  1060.             }
  1061.         }
  1062.     },
  1063.         handleHdOut : function(e, t){
  1064.         var hd = this.findHeaderCell(t);
  1065.         if(hd && (!Ext.isIE || !e.within(hd, true))){
  1066.             this.activeHd = null;
  1067.             this.fly(hd).removeClass("x-grid3-hd-over");
  1068.             hd.style.cursor = '';
  1069.         }
  1070.     },
  1071.         hasRows : function(){
  1072.         var fc = this.mainBody.dom.firstChild;
  1073.         return fc && fc.className != 'x-grid-empty';
  1074.     },
  1075.         bind : function(d, c){
  1076.         this.initData(d, c);
  1077.     }
  1078. });
  1079. Ext.grid.GridView.SplitDragZone = function(grid, hd){
  1080.     this.grid = grid;
  1081.     this.view = grid.getView();
  1082.     this.marker = this.view.resizeMarker;
  1083.     this.proxy = this.view.resizeProxy;
  1084.     Ext.grid.GridView.SplitDragZone.superclass.constructor.call(this, hd,
  1085.         "gridSplitters" + this.grid.getGridEl().id, {
  1086.         dragElId : Ext.id(this.proxy.dom), resizeFrame:false
  1087.     });
  1088.     this.scroll = false;
  1089.     this.hw = this.view.splitHandleWidth || 5;
  1090. };
  1091. Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, {
  1092.     b4StartDrag : function(x, y){
  1093.         this.view.headersDisabled = true;
  1094.         var h = this.view.mainWrap.getHeight();
  1095.         this.marker.setHeight(h);
  1096.         this.marker.show();
  1097.         this.marker.alignTo(this.view.getHeaderCell(this.cellIndex), 'tl-tl', [-2, 0]);
  1098.         this.proxy.setHeight(h);
  1099.         var w = this.cm.getColumnWidth(this.cellIndex);
  1100.         var minw = Math.max(w-this.grid.minColumnWidth, 0);
  1101.         this.resetConstraints();
  1102.         this.setXConstraint(minw, 1000);
  1103.         this.setYConstraint(0, 0);
  1104.         this.minX = x - minw;
  1105.         this.maxX = x + 1000;
  1106.         this.startPos = x;
  1107.         Ext.dd.DDProxy.prototype.b4StartDrag.call(this, x, y);
  1108.     },
  1109.     handleMouseDown : function(e){
  1110.         var t = this.view.findHeaderCell(e.getTarget());
  1111.         if(t){
  1112.             var xy = this.view.fly(t).getXY(), x = xy[0], y = xy[1];
  1113.             var exy = e.getXY(), ex = exy[0], ey = exy[1];
  1114.             var w = t.offsetWidth, adjust = false;
  1115.             if((ex - x) <= this.hw){
  1116.                 adjust = -1;
  1117.             }else if((x+w) - ex <= this.hw){
  1118.                 adjust = 0;
  1119.             }
  1120.             if(adjust !== false){
  1121.                 this.cm = this.grid.colModel;
  1122.                 var ci = this.view.getCellIndex(t);
  1123.                 if(adjust == -1){
  1124.                   if (ci + adjust < 0) {
  1125.                     return;
  1126.                   }
  1127.                     while(this.cm.isHidden(ci+adjust)){
  1128.                         --adjust;
  1129.                         if(ci+adjust < 0){
  1130.                             return;
  1131.                         }
  1132.                     }
  1133.                 }
  1134.                 this.cellIndex = ci+adjust;
  1135.                 this.split = t.dom;
  1136.                 if(this.cm.isResizable(this.cellIndex) && !this.cm.isFixed(this.cellIndex)){
  1137.                     Ext.grid.GridView.SplitDragZone.superclass.handleMouseDown.apply(this, arguments);
  1138.                 }
  1139.             }else if(this.view.columnDrag){
  1140.                 this.view.columnDrag.callHandleMouseDown(e);
  1141.             }
  1142.         }
  1143.     },
  1144.     endDrag : function(e){
  1145.         this.marker.hide();
  1146.         var v = this.view;
  1147.         var endX = Math.max(this.minX, e.getPageX());
  1148.         var diff = endX - this.startPos;
  1149.         v.onColumnSplitterMoved(this.cellIndex, this.cm.getColumnWidth(this.cellIndex)+diff);
  1150.         setTimeout(function(){
  1151.             v.headersDisabled = false;
  1152.         }, 50);
  1153.     },
  1154.     autoOffset : function(){
  1155.         this.setDelta(0,0);
  1156.     }
  1157. });
  1158. Ext.grid.GroupingView = Ext.extend(Ext.grid.GridView, {
  1159.     hideGroupedColumn:false,
  1160.     showGroupName:true,
  1161.     startCollapsed:false,
  1162.     enableGrouping:true,
  1163.     enableGroupingMenu:true,
  1164.     enableNoGroups:true,
  1165.     emptyGroupText : '(None)',
  1166.     ignoreAdd: false,
  1167.     groupTextTpl : '{text}',
  1168.     gidSeed : 1000,
  1169.     initTemplates : function(){
  1170.         Ext.grid.GroupingView.superclass.initTemplates.call(this);
  1171.         this.state = {};
  1172.         var sm = this.grid.getSelectionModel();
  1173.         sm.on(sm.selectRow ? 'beforerowselect' : 'beforecellselect',
  1174.                 this.onBeforeRowSelect, this);
  1175.         if(!this.startGroup){
  1176.             this.startGroup = new Ext.XTemplate(
  1177.                 '<div id="{groupId}" class="x-grid-group {cls}">',
  1178.                     '<div id="{groupId}-hd" class="x-grid-group-hd" style="{style}"><div>', this.groupTextTpl ,'</div></div>',
  1179.                     '<div id="{groupId}-bd" class="x-grid-group-body">'
  1180.             );
  1181.         }
  1182.         this.startGroup.compile();
  1183.         this.endGroup = '</div></div>';
  1184.     },
  1185.     findGroup : function(el){
  1186.         return Ext.fly(el).up('.x-grid-group', this.mainBody.dom);
  1187.     },
  1188.     getGroups : function(){
  1189.         return this.hasRows() ? this.mainBody.dom.childNodes : [];
  1190.     },
  1191.     onAdd : function(){
  1192.         if(this.enableGrouping && !this.ignoreAdd){
  1193.             var ss = this.getScrollState();
  1194.             this.refresh();
  1195.             this.restoreScroll(ss);
  1196.         }else if(!this.enableGrouping){
  1197.             Ext.grid.GroupingView.superclass.onAdd.apply(this, arguments);
  1198.         }
  1199.     },
  1200.     onRemove : function(ds, record, index, isUpdate){
  1201.         Ext.grid.GroupingView.superclass.onRemove.apply(this, arguments);
  1202.         var g = document.getElementById(record._groupId);
  1203.         if(g && g.childNodes[1].childNodes.length < 1){
  1204.             Ext.removeNode(g);
  1205.         }
  1206.         this.applyEmptyText();
  1207.     },
  1208.     refreshRow : function(record){
  1209.         if(this.ds.getCount()==1){
  1210.             this.refresh();
  1211.         }else{
  1212.             this.isUpdating = true;
  1213.             Ext.grid.GroupingView.superclass.refreshRow.apply(this, arguments);
  1214.             this.isUpdating = false;
  1215.         }
  1216.     },
  1217.     beforeMenuShow : function(){
  1218.         var field = this.getGroupField();
  1219.         var g = this.hmenu.items.get('groupBy');
  1220.         if(g){
  1221.             g.setDisabled(this.cm.config[this.hdCtxIndex].groupable === false);
  1222.         }
  1223.         var s = this.hmenu.items.get('showGroups');
  1224.         if(s){
  1225.             if (!!field){
  1226.                 s.setDisabled(this.cm.config[this.hdCtxIndex].groupable === false)
  1227.             }
  1228.             s.setChecked(!!field);
  1229.         }
  1230.     },
  1231.     renderUI : function(){
  1232.         Ext.grid.GroupingView.superclass.renderUI.call(this);
  1233.         this.mainBody.on('mousedown', this.interceptMouse, this);
  1234.         if(this.enableGroupingMenu && this.hmenu){
  1235.             this.hmenu.add('-',{
  1236.                 id:'groupBy',
  1237.                 text: this.groupByText,
  1238.                 handler: this.onGroupByClick,
  1239.                 scope: this,
  1240.                 iconCls:'x-group-by-icon'
  1241.             });
  1242.             if(this.enableNoGroups){
  1243.                 this.hmenu.add({
  1244.                     id:'showGroups',
  1245.                     text: this.showGroupsText,
  1246.                     checked: true,
  1247.                     checkHandler: this.onShowGroupsClick,
  1248.                     scope: this
  1249.                 });
  1250.             }
  1251.             this.hmenu.on('beforeshow', this.beforeMenuShow, this);
  1252.         }
  1253.     },
  1254.     onGroupByClick : function(){
  1255.         this.grid.store.groupBy(this.cm.getDataIndex(this.hdCtxIndex));
  1256.         this.beforeMenuShow();
  1257.     },
  1258.     onShowGroupsClick : function(mi, checked){
  1259.         if(checked){
  1260.             this.onGroupByClick();
  1261.         }else{
  1262.             this.grid.store.clearGrouping();
  1263.         }
  1264.     },
  1265.     toggleGroup : function(group, expanded){
  1266.         this.grid.stopEditing(true);
  1267.         group = Ext.getDom(group);
  1268.         var gel = Ext.fly(group);
  1269.         expanded = expanded !== undefined ?
  1270.                 expanded : gel.hasClass('x-grid-group-collapsed');
  1271.         this.state[gel.dom.id] = expanded;
  1272.         gel[expanded ? 'removeClass' : 'addClass']('x-grid-group-collapsed');
  1273.     },
  1274.     toggleAllGroups : function(expanded){
  1275.         var groups = this.getGroups();
  1276.         for(var i = 0, len = groups.length; i < len; i++){
  1277.             this.toggleGroup(groups[i], expanded);
  1278.         }
  1279.     },
  1280.     expandAllGroups : function(){
  1281.         this.toggleAllGroups(true);
  1282.     },
  1283.     collapseAllGroups : function(){
  1284.         this.toggleAllGroups(false);
  1285.     },
  1286.     interceptMouse : function(e){
  1287.         var hd = e.getTarget('.x-grid-group-hd', this.mainBody);
  1288.         if(hd){
  1289.             e.stopEvent();
  1290.             this.toggleGroup(hd.parentNode);
  1291.         }
  1292.     },
  1293.     getGroup : function(v, r, groupRenderer, rowIndex, colIndex, ds){
  1294.         var g = groupRenderer ? groupRenderer(v, {}, r, rowIndex, colIndex, ds) : String(v);
  1295.         if(g === ''){
  1296.             g = this.cm.config[colIndex].emptyGroupText || this.emptyGroupText;
  1297.         }
  1298.         return g;
  1299.     },
  1300.     getGroupField : function(){
  1301.         return this.grid.store.getGroupState();
  1302.     },
  1303.     renderRows : function(){
  1304.         var groupField = this.getGroupField();
  1305.         var eg = !!groupField;
  1306.         if(this.hideGroupedColumn) {
  1307.             var colIndex = this.cm.findColumnIndex(groupField);
  1308.             if(!eg && this.lastGroupField !== undefined) {
  1309.                 this.mainBody.update('');
  1310.                 this.cm.setHidden(this.cm.findColumnIndex(this.lastGroupField), false);
  1311.                 delete this.lastGroupField;
  1312.             }else if (eg && this.lastGroupField === undefined) {
  1313.                 this.lastGroupField = groupField;
  1314.                 this.cm.setHidden(colIndex, true);
  1315.             }else if (eg && this.lastGroupField !== undefined && groupField !== this.lastGroupField) {
  1316.                 this.mainBody.update('');
  1317.                 var oldIndex = this.cm.findColumnIndex(this.lastGroupField);
  1318.                 this.cm.setHidden(oldIndex, false);
  1319.                 this.lastGroupField = groupField;
  1320.                 this.cm.setHidden(colIndex, true);
  1321.             }
  1322.         }
  1323.         return Ext.grid.GroupingView.superclass.renderRows.apply(
  1324.                     this, arguments);
  1325.     },
  1326.     doRender : function(cs, rs, ds, startRow, colCount, stripe){
  1327.         if(rs.length < 1){
  1328.             return '';
  1329.         }
  1330.         var groupField = this.getGroupField();
  1331.         var colIndex = this.cm.findColumnIndex(groupField);
  1332.         this.enableGrouping = !!groupField;
  1333.         if(!this.enableGrouping || this.isUpdating){
  1334.             return Ext.grid.GroupingView.superclass.doRender.apply(
  1335.                     this, arguments);
  1336.         }
  1337.         var gstyle = 'width:'+this.getTotalWidth()+';';
  1338.         var gidPrefix = this.grid.getGridEl().id;
  1339.         var cfg = this.cm.config[colIndex];
  1340.         var groupRenderer = cfg.groupRenderer || cfg.renderer;
  1341.         var prefix = this.showGroupName ?
  1342.                      (cfg.groupName || cfg.header)+': ' : '';
  1343.         var groups = [], curGroup, i, len, gid;
  1344.         for(i = 0, len = rs.length; i < len; i++){
  1345.             var rowIndex = startRow + i;
  1346.             var r = rs[i],
  1347.                 gvalue = r.data[groupField],
  1348.                 g = this.getGroup(gvalue, r, groupRenderer, rowIndex, colIndex, ds);
  1349.             if(!curGroup || curGroup.group != g){
  1350.                 gid = gidPrefix + '-gp-' + groupField + '-' + Ext.util.Format.htmlEncode(g);
  1351.                 var isCollapsed  = typeof this.state[gid] !== 'undefined' ? !this.state[gid] : this.startCollapsed;
  1352.                 var gcls = isCollapsed ? 'x-grid-group-collapsed' : '';
  1353.                 curGroup = {
  1354.                     group: g,
  1355.                     gvalue: gvalue,
  1356.                     text: prefix + g,
  1357.                     groupId: gid,
  1358.                     startRow: rowIndex,
  1359.                     rs: [r],
  1360.                     cls: gcls,
  1361.                     style: gstyle
  1362.                 };
  1363.                 groups.push(curGroup);
  1364.             }else{
  1365.                 curGroup.rs.push(r);
  1366.             }
  1367.             r._groupId = gid;
  1368.         }
  1369.         var buf = [];
  1370.         for(i = 0, len = groups.length; i < len; i++){
  1371.             var g = groups[i];
  1372.             this.doGroupStart(buf, g, cs, ds, colCount);
  1373.             buf[buf.length] = Ext.grid.GroupingView.superclass.doRender.call(
  1374.                     this, cs, g.rs, ds, g.startRow, colCount, stripe);
  1375.             this.doGroupEnd(buf, g, cs, ds, colCount);
  1376.         }
  1377.         return buf.join('');
  1378.     },
  1379.     getGroupId : function(value){
  1380.         var gidPrefix = this.grid.getGridEl().id;
  1381.         var groupField = this.getGroupField();
  1382.         var colIndex = this.cm.findColumnIndex(groupField);
  1383.         var cfg = this.cm.config[colIndex];
  1384.         var groupRenderer = cfg.groupRenderer || cfg.renderer;
  1385.         var gtext = this.getGroup(value, {data:{}}, groupRenderer, 0, colIndex, this.ds);
  1386.         return gidPrefix + '-gp-' + groupField + '-' + Ext.util.Format.htmlEncode(value);
  1387.     },
  1388.     doGroupStart : function(buf, g, cs, ds, colCount){
  1389.         buf[buf.length] = this.startGroup.apply(g);
  1390.     },
  1391.     doGroupEnd : function(buf, g, cs, ds, colCount){
  1392.         buf[buf.length] = this.endGroup;
  1393.     },
  1394.     getRows : function(){
  1395.         if(!this.enableGrouping){
  1396.             return Ext.grid.GroupingView.superclass.getRows.call(this);
  1397.         }
  1398.         var r = [];
  1399.         var g, gs = this.getGroups();
  1400.         for(var i = 0, len = gs.length; i < len; i++){
  1401.             g = gs[i].childNodes[1].childNodes;
  1402.             for(var j = 0, jlen = g.length; j < jlen; j++){
  1403.                 r[r.length] = g[j];
  1404.             }
  1405.         }
  1406.         return r;
  1407.     },
  1408.     updateGroupWidths : function(){
  1409.         if(!this.enableGrouping || !this.hasRows()){
  1410.             return;
  1411.         }
  1412.         var tw = Math.max(this.cm.getTotalWidth(), this.el.dom.offsetWidth-this.scrollOffset) +'px';
  1413.         var gs = this.getGroups();
  1414.         for(var i = 0, len = gs.length; i < len; i++){
  1415.             gs[i].firstChild.style.width = tw;
  1416.         }
  1417.     },
  1418.     onColumnWidthUpdated : function(col, w, tw){
  1419.         this.updateGroupWidths();
  1420.     },
  1421.     onAllColumnWidthsUpdated : function(ws, tw){
  1422.         this.updateGroupWidths();
  1423.     },
  1424.     onColumnHiddenUpdated : function(col, hidden, tw){
  1425.         this.updateGroupWidths();
  1426.     },
  1427.     onLayout : function(){
  1428.         this.updateGroupWidths();
  1429.     },
  1430.     onBeforeRowSelect : function(sm, rowIndex){
  1431.         if(!this.enableGrouping){
  1432.             return;
  1433.         }
  1434.         var row = this.getRow(rowIndex);
  1435.         if(row && !row.offsetParent){
  1436.             var g = this.findGroup(row);
  1437.             this.toggleGroup(g, true);
  1438.         }
  1439.     },
  1440.     groupByText: 'Group By This Field',
  1441.     showGroupsText: 'Show in Groups'
  1442. });
  1443. Ext.grid.GroupingView.GROUP_ID = 1000;
  1444. Ext.grid.HeaderDragZone = function(grid, hd, hd2){
  1445.     this.grid = grid;
  1446.     this.view = grid.getView();
  1447.     this.ddGroup = "gridHeader" + this.grid.getGridEl().id;
  1448.     Ext.grid.HeaderDragZone.superclass.constructor.call(this, hd);
  1449.     if(hd2){
  1450.         this.setHandleElId(Ext.id(hd));
  1451.         this.setOuterHandleElId(Ext.id(hd2));
  1452.     }
  1453.     this.scroll = false;
  1454. };
  1455. Ext.extend(Ext.grid.HeaderDragZone, Ext.dd.DragZone, {
  1456.     maxDragWidth: 120,
  1457.     getDragData : function(e){
  1458.         var t = Ext.lib.Event.getTarget(e);
  1459.         var h = this.view.findHeaderCell(t);
  1460.         if(h){
  1461.             return {ddel: h.firstChild, header:h};
  1462.         }
  1463.         return false;
  1464.     },
  1465.     onInitDrag : function(e){
  1466.         this.view.headersDisabled = true;
  1467.         var clone = this.dragData.ddel.cloneNode(true);
  1468.         clone.id = Ext.id();
  1469.         clone.style.width = Math.min(this.dragData.header.offsetWidth,this.maxDragWidth) + "px";
  1470.         this.proxy.update(clone);
  1471.         return true;
  1472.     },
  1473.     afterValidDrop : function(){
  1474.         var v = this.view;
  1475.         setTimeout(function(){
  1476.             v.headersDisabled = false;
  1477.         }, 50);
  1478.     },
  1479.     afterInvalidDrop : function(){
  1480.         var v = this.view;
  1481.         setTimeout(function(){
  1482.             v.headersDisabled = false;
  1483.         }, 50);
  1484.     }
  1485. });
  1486. Ext.grid.HeaderDropZone = function(grid, hd, hd2){
  1487.     this.grid = grid;
  1488.     this.view = grid.getView();
  1489.     this.proxyTop = Ext.DomHelper.append(document.body, {
  1490.         cls:"col-move-top", html:"&#160;"
  1491.     }, true);
  1492.     this.proxyBottom = Ext.DomHelper.append(document.body, {
  1493.         cls:"col-move-bottom", html:"&#160;"
  1494.     }, true);
  1495.     this.proxyTop.hide = this.proxyBottom.hide = function(){
  1496.         this.setLeftTop(-100,-100);
  1497.         this.setStyle("visibility", "hidden");
  1498.     };
  1499.     this.ddGroup = "gridHeader" + this.grid.getGridEl().id;
  1500.     Ext.grid.HeaderDropZone.superclass.constructor.call(this, grid.getGridEl().dom);
  1501. };
  1502. Ext.extend(Ext.grid.HeaderDropZone, Ext.dd.DropZone, {
  1503.     proxyOffsets : [-4, -9],
  1504.     fly: Ext.Element.fly,
  1505.     getTargetFromEvent : function(e){
  1506.         var t = Ext.lib.Event.getTarget(e);
  1507.         var cindex = this.view.findCellIndex(t);
  1508.         if(cindex !== false){
  1509.             return this.view.getHeaderCell(cindex);
  1510.         }
  1511.     },
  1512.     nextVisible : function(h){
  1513.         var v = this.view, cm = this.grid.colModel;
  1514.         h = h.nextSibling;
  1515.         while(h){
  1516.             if(!cm.isHidden(v.getCellIndex(h))){
  1517.                 return h;
  1518.             }
  1519.             h = h.nextSibling;
  1520.         }
  1521.         return null;
  1522.     },
  1523.     prevVisible : function(h){
  1524.         var v = this.view, cm = this.grid.colModel;
  1525.         h = h.prevSibling;
  1526.         while(h){
  1527.             if(!cm.isHidden(v.getCellIndex(h))){
  1528.                 return h;
  1529.             }
  1530.             h = h.prevSibling;
  1531.         }
  1532.         return null;
  1533.     },
  1534.     positionIndicator : function(h, n, e){
  1535.         var x = Ext.lib.Event.getPageX(e);
  1536.         var r = Ext.lib.Dom.getRegion(n.firstChild);
  1537.         var px, pt, py = r.top + this.proxyOffsets[1];
  1538.         if((r.right - x) <= (r.right-r.left)/2){
  1539.             px = r.right+this.view.borderWidth;
  1540.             pt = "after";
  1541.         }else{
  1542.             px = r.left;
  1543.             pt = "before";
  1544.         }
  1545.         var oldIndex = this.view.getCellIndex(h);
  1546.         var newIndex = this.view.getCellIndex(n);
  1547.         if(this.grid.colModel.isFixed(newIndex)){
  1548.             return false;
  1549.         }
  1550.         var locked = this.grid.colModel.isLocked(newIndex);
  1551.         if(pt == "after"){
  1552.             newIndex++;
  1553.         }
  1554.         if(oldIndex < newIndex){
  1555.             newIndex--;
  1556.         }
  1557.         if(oldIndex == newIndex && (locked == this.grid.colModel.isLocked(oldIndex))){
  1558.             return false;
  1559.         }
  1560.         px +=  this.proxyOffsets[0];
  1561.         this.proxyTop.setLeftTop(px, py);
  1562.         this.proxyTop.show();
  1563.         if(!this.bottomOffset){
  1564.             this.bottomOffset = this.view.mainHd.getHeight();
  1565.         }
  1566.         this.proxyBottom.setLeftTop(px, py+this.proxyTop.dom.offsetHeight+this.bottomOffset);
  1567.         this.proxyBottom.show();
  1568.         return pt;
  1569.     },
  1570.     onNodeEnter : function(n, dd, e, data){
  1571.         if(data.header != n){
  1572.             this.positionIndicator(data.header, n, e);
  1573.         }
  1574.     },
  1575.     onNodeOver : function(n, dd, e, data){
  1576.         var result = false;
  1577.         if(data.header != n){
  1578.             result = this.positionIndicator(data.header, n, e);
  1579.         }
  1580.         if(!result){
  1581.             this.proxyTop.hide();
  1582.             this.proxyBottom.hide();
  1583.         }
  1584.         return result ? this.dropAllowed : this.dropNotAllowed;
  1585.     },
  1586.     onNodeOut : function(n, dd, e, data){
  1587.         this.proxyTop.hide();
  1588.         this.proxyBottom.hide();
  1589.     },
  1590.     onNodeDrop : function(n, dd, e, data){
  1591.         var h = data.header;
  1592.         if(h != n){
  1593.             var cm = this.grid.colModel;
  1594.             var x = Ext.lib.Event.getPageX(e);
  1595.             var r = Ext.lib.Dom.getRegion(n.firstChild);
  1596.             var pt = (r.right - x) <= ((r.right-r.left)/2) ? "after" : "before";
  1597.             var oldIndex = this.view.getCellIndex(h);
  1598.             var newIndex = this.view.getCellIndex(n);
  1599.             var locked = cm.isLocked(newIndex);
  1600.             if(pt == "after"){
  1601.                 newIndex++;
  1602.             }
  1603.             if(oldIndex < newIndex){
  1604.                 newIndex--;
  1605.             }
  1606.             if(oldIndex == newIndex && (locked == cm.isLocked(oldIndex))){
  1607.                 return false;
  1608.             }
  1609.             cm.setLocked(oldIndex, locked, true);
  1610.             cm.moveColumn(oldIndex, newIndex);
  1611.             this.grid.fireEvent("columnmove", oldIndex, newIndex);
  1612.             return true;
  1613.         }
  1614.         return false;
  1615.     }
  1616. });
  1617. Ext.grid.GridView.ColumnDragZone = function(grid, hd){
  1618.     Ext.grid.GridView.ColumnDragZone.superclass.constructor.call(this, grid, hd, null);
  1619.     this.proxy.el.addClass('x-grid3-col-dd');
  1620. };
  1621. Ext.extend(Ext.grid.GridView.ColumnDragZone, Ext.grid.HeaderDragZone, {
  1622.     handleMouseDown : function(e){
  1623.     },
  1624.     callHandleMouseDown : function(e){
  1625.         Ext.grid.GridView.ColumnDragZone.superclass.handleMouseDown.call(this, e);
  1626.     }
  1627. });
  1628. Ext.grid.SplitDragZone = function(grid, hd, hd2){
  1629.     this.grid = grid;
  1630.     this.view = grid.getView();
  1631.     this.proxy = this.view.resizeProxy;
  1632.     Ext.grid.SplitDragZone.superclass.constructor.call(this, hd,
  1633.         "gridSplitters" + this.grid.getGridEl().id, {
  1634.         dragElId : Ext.id(this.proxy.dom), resizeFrame:false
  1635.     });
  1636.     this.setHandleElId(Ext.id(hd));
  1637.     this.setOuterHandleElId(Ext.id(hd2));
  1638.     this.scroll = false;
  1639. };
  1640. Ext.extend(Ext.grid.SplitDragZone, Ext.dd.DDProxy, {
  1641.     fly: Ext.Element.fly,
  1642.     b4StartDrag : function(x, y){
  1643.         this.view.headersDisabled = true;
  1644.         this.proxy.setHeight(this.view.mainWrap.getHeight());
  1645.         var w = this.cm.getColumnWidth(this.cellIndex);
  1646.         var minw = Math.max(w-this.grid.minColumnWidth, 0);
  1647.         this.resetConstraints();
  1648.         this.setXConstraint(minw, 1000);
  1649.         this.setYConstraint(0, 0);
  1650.         this.minX = x - minw;
  1651.         this.maxX = x + 1000;
  1652.         this.startPos = x;
  1653.         Ext.dd.DDProxy.prototype.b4StartDrag.call(this, x, y);
  1654.     },
  1655.     handleMouseDown : function(e){
  1656.         ev = Ext.EventObject.setEvent(e);
  1657.         var t = this.fly(ev.getTarget());
  1658.         if(t.hasClass("x-grid-split")){
  1659.             this.cellIndex = this.view.getCellIndex(t.dom);
  1660.             this.split = t.dom;
  1661.             this.cm = this.grid.colModel;
  1662.             if(this.cm.isResizable(this.cellIndex) && !this.cm.isFixed(this.cellIndex)){
  1663.                 Ext.grid.SplitDragZone.superclass.handleMouseDown.apply(this, arguments);
  1664.             }
  1665.         }
  1666.     },
  1667.     endDrag : function(e){
  1668.         this.view.headersDisabled = false;
  1669.         var endX = Math.max(this.minX, Ext.lib.Event.getPageX(e));
  1670.         var diff = endX - this.startPos;
  1671.         this.view.onColumnSplitterMoved(this.cellIndex, this.cm.getColumnWidth(this.cellIndex)+diff);
  1672.     },
  1673.     autoOffset : function(){
  1674.         this.setDelta(0,0);
  1675.     }
  1676. });
  1677. Ext.grid.GridDragZone = function(grid, config){
  1678.     this.view = grid.getView();
  1679.     Ext.grid.GridDragZone.superclass.constructor.call(this, this.view.mainBody.dom, config);
  1680.     if(this.view.lockedBody){
  1681.         this.setHandleElId(Ext.id(this.view.mainBody.dom));
  1682.         this.setOuterHandleElId(Ext.id(this.view.lockedBody.dom));
  1683.     }
  1684.     this.scroll = false;
  1685.     this.grid = grid;
  1686.     this.ddel = document.createElement('div');
  1687.     this.ddel.className = 'x-grid-dd-wrap';
  1688. };
  1689. Ext.extend(Ext.grid.GridDragZone, Ext.dd.DragZone, {
  1690.     ddGroup : "GridDD",
  1691.     getDragData : function(e){
  1692.         var t = Ext.lib.Event.getTarget(e);
  1693.         var rowIndex = this.view.findRowIndex(t);
  1694.         if(rowIndex !== false){
  1695.             var sm = this.grid.selModel;
  1696.             if(!sm.isSelected(rowIndex) || e.hasModifier()){
  1697.                 sm.handleMouseDown(this.grid, rowIndex, e);
  1698.             }
  1699.             return {grid: this.grid, ddel: this.ddel, rowIndex: rowIndex, selections:sm.getSelections()};
  1700.         }
  1701.         return false;
  1702.     },
  1703.     onInitDrag : function(e){
  1704.         var data = this.dragData;
  1705.         this.ddel.innerHTML = this.grid.getDragDropText();
  1706.         this.proxy.update(this.ddel);
  1707.             },
  1708.     afterRepair : function(){
  1709.         this.dragging = false;
  1710.     },
  1711.     getRepairXY : function(e, data){
  1712.         return false;
  1713.     },
  1714.     onEndDrag : function(data, e){
  1715.             },
  1716.     onValidDrop : function(dd, e, id){
  1717.                 this.hideProxy();
  1718.     },
  1719.     beforeInvalidDrop : function(e, id){
  1720.     }
  1721. });
  1722. Ext.grid.ColumnModel = function(config){
  1723.     this.defaultWidth = 100;
  1724.     this.defaultSortable = false;
  1725.     if(config.columns){
  1726.         Ext.apply(this, config);
  1727.         this.setConfig(config.columns, true);
  1728.     }else{
  1729.         this.setConfig(config, true);
  1730.     }
  1731.     this.addEvents(
  1732.         "widthchange",
  1733.         "headerchange",
  1734.         "hiddenchange",
  1735.         "columnmoved",
  1736.         "columnlockchange",
  1737.         "configchange"
  1738.     );
  1739.     Ext.grid.ColumnModel.superclass.constructor.call(this);
  1740. };
  1741. Ext.extend(Ext.grid.ColumnModel, Ext.util.Observable, {
  1742.     getColumnId : function(index){
  1743.         return this.config[index].id;
  1744.     },
  1745.     setConfig : function(config, initial){
  1746.         if(!initial){
  1747.             delete this.totalWidth;
  1748.             for(var i = 0, len = this.config.length; i < len; i++){
  1749.                 var c = this.config[i];
  1750.                 if(c.editor){
  1751.                     c.editor.destroy();
  1752.                 }
  1753.             }
  1754.         }
  1755.         this.config = config;
  1756.         this.lookup = {};
  1757.         for(var i = 0, len = config.length; i < len; i++){
  1758.             var c = config[i];
  1759.             if(typeof c.renderer == "string"){
  1760.                 c.renderer = Ext.util.Format[c.renderer];
  1761.             }
  1762.             if(typeof c.id == "undefined"){
  1763.                 c.id = i;
  1764.             }
  1765.             if(c.editor && c.editor.isFormField){
  1766.                 c.editor = new Ext.grid.GridEditor(c.editor);
  1767.             }
  1768.             this.lookup[c.id] = c;
  1769.         }
  1770.         if(!initial){
  1771.             this.fireEvent('configchange', this);
  1772.         }
  1773.     },
  1774.     getColumnById : function(id){
  1775.         return this.lookup[id];
  1776.     },
  1777.     getIndexById : function(id){
  1778.         for(var i = 0, len = this.config.length; i < len; i++){
  1779.             if(this.config[i].id == id){
  1780.                 return i;
  1781.             }
  1782.         }
  1783.         return -1;
  1784.     },
  1785.     moveColumn : function(oldIndex, newIndex){
  1786.         var c = this.config[oldIndex];
  1787.         this.config.splice(oldIndex, 1);
  1788.         this.config.splice(newIndex, 0, c);
  1789.         this.dataMap = null;
  1790.         this.fireEvent("columnmoved", this, oldIndex, newIndex);
  1791.     },
  1792.     isLocked : function(colIndex){
  1793.         return this.config[colIndex].locked === true;
  1794.     },
  1795.     setLocked : function(colIndex, value, suppressEvent){
  1796.         if(this.isLocked(colIndex) == value){
  1797.             return;
  1798.         }
  1799.         this.config[colIndex].locked = value;
  1800.         if(!suppressEvent){
  1801.             this.fireEvent("columnlockchange", this, colIndex, value);
  1802.         }
  1803.     },
  1804.     getTotalLockedWidth : function(){
  1805.         var totalWidth = 0;
  1806.         for(var i = 0; i < this.config.length; i++){
  1807.             if(this.isLocked(i) && !this.isHidden(i)){
  1808.                 this.totalWidth += this.getColumnWidth(i);
  1809.             }
  1810.         }
  1811.         return totalWidth;
  1812.     },
  1813.     getLockedCount : function(){
  1814.         for(var i = 0, len = this.config.length; i < len; i++){
  1815.             if(!this.isLocked(i)){
  1816.                 return i;
  1817.             }
  1818.         }
  1819.     },
  1820.     getColumnCount : function(visibleOnly){
  1821.         if(visibleOnly === true){
  1822.             var c = 0;
  1823.             for(var i = 0, len = this.config.length; i < len; i++){
  1824.                 if(!this.isHidden(i)){
  1825.                     c++;
  1826.                 }
  1827.             }
  1828.             return c;
  1829.         }
  1830.         return this.config.length;
  1831.     },
  1832.     getColumnsBy : function(fn, scope){
  1833.         var r = [];
  1834.         for(var i = 0, len = this.config.length; i < len; i++){
  1835.             var c = this.config[i];
  1836.             if(fn.call(scope||this, c, i) === true){
  1837.                 r[r.length] = c;
  1838.             }
  1839.         }
  1840.         return r;
  1841.     },
  1842.     isSortable : function(col){
  1843.         if(typeof this.config[col].sortable == "undefined"){
  1844.             return this.defaultSortable;
  1845.         }
  1846.         return this.config[col].sortable;
  1847.     },
  1848.     isMenuDisabled : function(col){
  1849.         return !!this.config[col].menuDisabled;
  1850.     },
  1851.     getRenderer : function(col){
  1852.         if(!this.config[col].renderer){
  1853.             return Ext.grid.ColumnModel.defaultRenderer;
  1854.         }
  1855.         return this.config[col].renderer;
  1856.     },
  1857.     setRenderer : function(col, fn){
  1858.         this.config[col].renderer = fn;
  1859.     },
  1860.     getColumnWidth : function(col){
  1861.         return this.config[col].width || this.defaultWidth;
  1862.     },
  1863.     setColumnWidth : function(col, width, suppressEvent){
  1864.         this.config[col].width = width;
  1865.         this.totalWidth = null;
  1866.         if(!suppressEvent){
  1867.              this.fireEvent("widthchange", this, col, width);
  1868.         }
  1869.     },
  1870.     getTotalWidth : function(includeHidden){
  1871.         if(!this.totalWidth){
  1872.             this.totalWidth = 0;
  1873.             for(var i = 0, len = this.config.length; i < len; i++){
  1874.                 if(includeHidden || !this.isHidden(i)){
  1875.                     this.totalWidth += this.getColumnWidth(i);
  1876.                 }
  1877.             }
  1878.         }
  1879.         return this.totalWidth;
  1880.     },
  1881.     getColumnHeader : function(col){
  1882.         return this.config[col].header;
  1883.     },
  1884.     setColumnHeader : function(col, header){
  1885.         this.config[col].header = header;
  1886.         this.fireEvent("headerchange", this, col, header);
  1887.     },
  1888.     getColumnTooltip : function(col){
  1889.             return this.config[col].tooltip;
  1890.     },
  1891.     setColumnTooltip : function(col, tooltip){
  1892.             this.config[col].tooltip = tooltip;
  1893.     },
  1894.     getDataIndex : function(col){
  1895.         return this.config[col].dataIndex;
  1896.     },
  1897.     setDataIndex : function(col, dataIndex){
  1898.         this.config[col].dataIndex = dataIndex;
  1899.     },
  1900.     findColumnIndex : function(dataIndex){
  1901.         var c = this.config;
  1902.         for(var i = 0, len = c.length; i < len; i++){
  1903.             if(c[i].dataIndex == dataIndex){
  1904.                 return i;
  1905.             }
  1906.         }
  1907.         return -1;
  1908.     },
  1909.     isCellEditable : function(colIndex, rowIndex){
  1910.         return (this.config[colIndex].editable || (typeof this.config[colIndex].editable == "undefined" && this.config[colIndex].editor)) ? true : false;
  1911.     },
  1912.     getCellEditor : function(colIndex, rowIndex){
  1913.         return this.config[colIndex].editor;
  1914.     },
  1915.     setEditable : function(col, editable){
  1916.         this.config[col].editable = editable;
  1917.     },
  1918.     isHidden : function(colIndex){
  1919.         return this.config[colIndex].hidden;
  1920.     },
  1921.     isFixed : function(colIndex){
  1922.         return this.config[colIndex].fixed;
  1923.     },
  1924.     isResizable : function(colIndex){
  1925.         return colIndex >= 0 && this.config[colIndex].resizable !== false && this.config[colIndex].fixed !== true;
  1926.     },
  1927.     setHidden : function(colIndex, hidden){
  1928.         var c = this.config[colIndex];
  1929.         if(c.hidden !== hidden){
  1930.             c.hidden = hidden;
  1931.             this.totalWidth = null;
  1932.             this.fireEvent("hiddenchange", this, colIndex, hidden);
  1933.         }
  1934.     },
  1935.     setEditor : function(col, editor){
  1936.         this.config[col].editor = editor;
  1937.     }
  1938. });
  1939. Ext.grid.ColumnModel.defaultRenderer = function(value){
  1940.     if(typeof value == "string" && value.length < 1){
  1941.         return "&#160;";
  1942.     }
  1943.     return value;
  1944. };
  1945. Ext.grid.DefaultColumnModel = Ext.grid.ColumnModel;
  1946. Ext.grid.AbstractSelectionModel = function(){
  1947.     this.locked = false;
  1948.     Ext.grid.AbstractSelectionModel.superclass.constructor.call(this);
  1949. };
  1950. Ext.extend(Ext.grid.AbstractSelectionModel, Ext.util.Observable,  {
  1951.     init : function(grid){
  1952.         this.grid = grid;
  1953.         this.initEvents();
  1954.     },
  1955.     lock : function(){
  1956.         this.locked = true;
  1957.     },
  1958.     unlock : function(){
  1959.         this.locked = false;
  1960.     },
  1961.     isLocked : function(){
  1962.         return this.locked;
  1963.     }
  1964. });
  1965. Ext.grid.RowSelectionModel = function(config){
  1966.     Ext.apply(this, config);
  1967.     this.selections = new Ext.util.MixedCollection(false, function(o){
  1968.         return o.id;
  1969.     });
  1970.     this.last = false;
  1971.     this.lastActive = false;
  1972.     this.addEvents(
  1973.         "selectionchange",
  1974.         "beforerowselect",
  1975.         "rowselect",
  1976.         "rowdeselect"
  1977.     );
  1978.     Ext.grid.RowSelectionModel.superclass.constructor.call(this);
  1979. };
  1980. Ext.extend(Ext.grid.RowSelectionModel, Ext.grid.AbstractSelectionModel,  {
  1981.     singleSelect : false,
  1982.         initEvents : function(){
  1983.         if(!this.grid.enableDragDrop && !this.grid.enableDrag){
  1984.             this.grid.on("rowmousedown", this.handleMouseDown, this);
  1985.         }else{             this.grid.on("rowclick", function(grid, rowIndex, e) {
  1986.                 if(e.button === 0 && !e.shiftKey && !e.ctrlKey) {
  1987.                     this.selectRow(rowIndex, false);
  1988.                     grid.view.focusRow(rowIndex);
  1989.                 }
  1990.             }, this);
  1991.         }
  1992.         this.rowNav = new Ext.KeyNav(this.grid.getGridEl(), {
  1993.             "up" : function(e){
  1994.                 if(!e.shiftKey){
  1995.                     this.selectPrevious(e.shiftKey);
  1996.                 }else if(this.last !== false && this.lastActive !== false){
  1997.                     var last = this.last;
  1998.                     this.selectRange(this.last,  this.lastActive-1);
  1999.                     this.grid.getView().focusRow(this.lastActive);
  2000.                     if(last !== false){
  2001.                         this.last = last;
  2002.                     }
  2003.                 }else{
  2004.                     this.selectFirstRow();
  2005.                 }
  2006.             },
  2007.             "down" : function(e){
  2008.                 if(!e.shiftKey){
  2009.                     this.selectNext(e.shiftKey);
  2010.                 }else if(this.last !== false && this.lastActive !== false){
  2011.                     var last = this.last;
  2012.                     this.selectRange(this.last,  this.lastActive+1);
  2013.                     this.grid.getView().focusRow(this.lastActive);
  2014.                     if(last !== false){
  2015.                         this.last = last;
  2016.                     }
  2017.                 }else{
  2018.                     this.selectFirstRow();
  2019.                 }
  2020.             },
  2021.             scope: this
  2022.         });
  2023.         var view = this.grid.view;
  2024.         view.on("refresh", this.onRefresh, this);
  2025.         view.on("rowupdated", this.onRowUpdated, this);
  2026.         view.on("rowremoved", this.onRemove, this);
  2027.     },
  2028.         onRefresh : function(){
  2029.         var ds = this.grid.store, index;
  2030.         var s = this.getSelections();
  2031.         this.clearSelections(true);
  2032.         for(var i = 0, len = s.length; i < len; i++){
  2033.             var r = s[i];
  2034.             if((index = ds.indexOfId(r.id)) != -1){
  2035.                 this.selectRow(index, true);
  2036.             }
  2037.         }
  2038.         if(s.length != this.selections.getCount()){
  2039.             this.fireEvent("selectionchange", this);
  2040.         }
  2041.     },
  2042.         onRemove : function(v, index, r){
  2043.         if(this.selections.remove(r) !== false){
  2044.             this.fireEvent('selectionchange', this);
  2045.         }
  2046.     },
  2047.         onRowUpdated : function(v, index, r){
  2048.         if(this.isSelected(r)){
  2049.             v.onRowSelect(index);
  2050.         }
  2051.     },
  2052.     selectRecords : function(records, keepExisting){
  2053.         if(!keepExisting){
  2054.             this.clearSelections();
  2055.         }
  2056.         var ds = this.grid.store;
  2057.         for(var i = 0, len = records.length; i < len; i++){
  2058.             this.selectRow(ds.indexOf(records[i]), true);
  2059.         }
  2060.     },
  2061.     getCount : function(){
  2062.         return this.selections.length;
  2063.     },
  2064.     selectFirstRow : function(){
  2065.         this.selectRow(0);
  2066.     },
  2067.     selectLastRow : function(keepExisting){
  2068.         this.selectRow(this.grid.store.getCount() - 1, keepExisting);
  2069.     },
  2070.     selectNext : function(keepExisting){
  2071.         if(this.hasNext()){
  2072.             this.selectRow(this.last+1, keepExisting);
  2073.             this.grid.getView().focusRow(this.last);
  2074.             return true;
  2075.         }
  2076.         return false;
  2077.     },
  2078.     selectPrevious : function(keepExisting){
  2079.         if(this.hasPrevious()){
  2080.             this.selectRow(this.last-1, keepExisting);
  2081.             this.grid.getView().focusRow(this.last);
  2082.             return true;
  2083.         }
  2084.         return false;
  2085.     },
  2086.     hasNext : function(){
  2087.         return this.last !== false && (this.last+1) < this.grid.store.getCount();
  2088.     },
  2089.     hasPrevious : function(){
  2090.         return !!this.last;
  2091.     },
  2092.     getSelections : function(){
  2093.         return [].concat(this.selections.items);
  2094.     },
  2095.     getSelected : function(){
  2096.         return this.selections.itemAt(0);
  2097.     },
  2098.     each : function(fn, scope){
  2099.         var s = this.getSelections();
  2100.         for(var i = 0, len = s.length; i < len; i++){
  2101.             if(fn.call(scope || this, s[i], i) === false){
  2102.                 return false;
  2103.             }
  2104.         }
  2105.         return true;
  2106.     },
  2107.     clearSelections : function(fast){
  2108.         if(this.locked) return;
  2109.         if(fast !== true){
  2110.             var ds = this.grid.store;
  2111.             var s = this.selections;
  2112.             s.each(function(r){
  2113.                 this.deselectRow(ds.indexOfId(r.id));
  2114.             }, this);
  2115.             s.clear();
  2116.         }else{
  2117.             this.selections.clear();
  2118.         }
  2119.         this.last = false;
  2120.     },
  2121.     selectAll : function(){
  2122.         if(this.locked) return;
  2123.         this.selections.clear();
  2124.         for(var i = 0, len = this.grid.store.getCount(); i < len; i++){
  2125.             this.selectRow(i, true);
  2126.         }
  2127.     },
  2128.     hasSelection : function(){
  2129.         return this.selections.length > 0;
  2130.     },
  2131.     isSelected : function(index){
  2132.         var r = typeof index == "number" ? this.grid.store.getAt(index) : index;
  2133.         return (r && this.selections.key(r.id) ? true : false);
  2134.     },
  2135.     isIdSelected : function(id){
  2136.         return (this.selections.key(id) ? true : false);
  2137.     },
  2138.         handleMouseDown : function(g, rowIndex, e){
  2139.         if(e.button !== 0 || this.isLocked()){
  2140.             return;
  2141.         };
  2142.         var view = this.grid.getView();
  2143.         if(e.shiftKey && this.last !== false){
  2144.             var last = this.last;
  2145.             this.selectRange(last, rowIndex, e.ctrlKey);
  2146.             this.last = last;             view.focusRow(rowIndex);
  2147.         }else{
  2148.             var isSelected = this.isSelected(rowIndex);
  2149.             if(e.ctrlKey && isSelected){
  2150.                 this.deselectRow(rowIndex);
  2151.             }else if(!isSelected || this.getCount() > 1){
  2152.                 this.selectRow(rowIndex, e.ctrlKey || e.shiftKey);
  2153.                 view.focusRow(rowIndex);
  2154.             }
  2155.         }
  2156.     },
  2157.     selectRows : function(rows, keepExisting){
  2158.         if(!keepExisting){
  2159.             this.clearSelections();
  2160.         }
  2161.         for(var i = 0, len = rows.length; i < len; i++){
  2162.             this.selectRow(rows[i], true);
  2163.         }
  2164.     },
  2165.     selectRange : function(startRow, endRow, keepExisting){
  2166.         if(this.locked) return;
  2167.         if(!keepExisting){
  2168.             this.clearSelections();
  2169.         }
  2170.         if(startRow <= endRow){
  2171.             for(var i = startRow; i <= endRow; i++){
  2172.                 this.selectRow(i, true);
  2173.             }
  2174.         }else{
  2175.             for(var i = startRow; i >= endRow; i--){
  2176.                 this.selectRow(i, true);
  2177.             }
  2178.         }
  2179.     },
  2180.     deselectRange : function(startRow, endRow, preventViewNotify){
  2181.         if(this.locked) return;
  2182.         for(var i = startRow; i <= endRow; i++){
  2183.             this.deselectRow(i, preventViewNotify);
  2184.         }
  2185.     },
  2186.     selectRow : function(index, keepExisting, preventViewNotify){
  2187.         if(this.locked || (index < 0 || index >= this.grid.store.getCount())) return;
  2188.         var r = this.grid.store.getAt(index);
  2189.         if(r && this.fireEvent("beforerowselect", this, index, keepExisting, r) !== false){
  2190.             if(!keepExisting || this.singleSelect){
  2191.                 this.clearSelections();
  2192.             }
  2193.             this.selections.add(r);
  2194.             this.last = this.lastActive = index;
  2195.             if(!preventViewNotify){
  2196.                 this.grid.getView().onRowSelect(index);
  2197.             }
  2198.             this.fireEvent("rowselect", this, index, r);
  2199.             this.fireEvent("selectionchange", this);
  2200.         }
  2201.     },
  2202.     deselectRow : function(index, preventViewNotify){
  2203.         if(this.locked) return;
  2204.         if(this.last == index){
  2205.             this.last = false;
  2206.         }
  2207.         if(this.lastActive == index){
  2208.             this.lastActive = false;
  2209.         }
  2210.         var r = this.grid.store.getAt(index);
  2211.         if(r){
  2212.             this.selections.remove(r);
  2213.             if(!preventViewNotify){
  2214.                 this.grid.getView().onRowDeselect(index);
  2215.             }
  2216.             this.fireEvent("rowdeselect", this, index, r);
  2217.             this.fireEvent("selectionchange", this);
  2218.         }
  2219.     },
  2220.         restoreLast : function(){
  2221.         if(this._last){
  2222.             this.last = this._last;
  2223.         }
  2224.     },
  2225.         acceptsNav : function(row, col, cm){
  2226.         return !cm.isHidden(col) && cm.isCellEditable(col, row);
  2227.     },
  2228.         onEditorKey : function(field, e){
  2229.         var k = e.getKey(), newCell, g = this.grid, ed = g.activeEditor;
  2230.         var shift = e.shiftKey;
  2231.         if(k == e.TAB){
  2232.             e.stopEvent();
  2233.             ed.completeEdit();
  2234.             if(shift){
  2235.                 newCell = g.walkCells(ed.row, ed.col-1, -1, this.acceptsNav, this);
  2236.             }else{
  2237.                 newCell = g.walkCells(ed.row, ed.col+1, 1, this.acceptsNav, this);
  2238.             }
  2239.         }else if(k == e.ENTER){
  2240.             e.stopEvent();
  2241.             ed.completeEdit();
  2242.             if(this.moveEditorOnEnter !== false){
  2243.                 if(shift){
  2244.                     newCell = g.walkCells(ed.row - 1, ed.col, -1, this.acceptsNav, this);
  2245.                 }else{
  2246.                     newCell = g.walkCells(ed.row + 1, ed.col, 1, this.acceptsNav, this);
  2247.                 }
  2248.             }
  2249.         }else if(k == e.ESC){
  2250.             ed.cancelEdit();
  2251.         }
  2252.         if(newCell){
  2253.             g.startEditing(newCell[0], newCell[1]);
  2254.         }
  2255.     }
  2256. });
  2257. Ext.grid.CellSelectionModel = function(config){
  2258.     Ext.apply(this, config);
  2259.     this.selection = null;
  2260.     this.addEvents(
  2261.         "beforecellselect",
  2262.         "cellselect",
  2263.         "selectionchange"
  2264.     );
  2265.     Ext.grid.CellSelectionModel.superclass.constructor.call(this);
  2266. };
  2267. Ext.extend(Ext.grid.CellSelectionModel, Ext.grid.AbstractSelectionModel,  {
  2268.     initEvents : function(){
  2269.         this.grid.on("cellmousedown", this.handleMouseDown, this);
  2270.         this.grid.getGridEl().on(Ext.isIE ? "keydown" : "keypress", this.handleKeyDown, this);
  2271.         var view = this.grid.view;
  2272.         view.on("refresh", this.onViewChange, this);
  2273.         view.on("rowupdated", this.onRowUpdated, this);
  2274.         view.on("beforerowremoved", this.clearSelections, this);
  2275.         view.on("beforerowsinserted", this.clearSelections, this);
  2276.         if(this.grid.isEditor){
  2277.             this.grid.on("beforeedit", this.beforeEdit,  this);
  2278.         }
  2279.     },
  2280.         beforeEdit : function(e){
  2281.         this.select(e.row, e.column, false, true, e.record);
  2282.     },
  2283.         onRowUpdated : function(v, index, r){
  2284.         if(this.selection && this.selection.record == r){
  2285.             v.onCellSelect(index, this.selection.cell[1]);
  2286.         }
  2287.     },
  2288.         onViewChange : function(){
  2289.         this.clearSelections(true);
  2290.     },
  2291.     getSelectedCell : function(){
  2292.         return this.selection ? this.selection.cell : null;
  2293.     },
  2294.     clearSelections : function(preventNotify){
  2295.         var s = this.selection;
  2296.         if(s){
  2297.             if(preventNotify !== true){
  2298.                 this.grid.view.onCellDeselect(s.cell[0], s.cell[1]);
  2299.             }
  2300.             this.selection = null;
  2301.             this.fireEvent("selectionchange", this, null);
  2302.         }
  2303.     },
  2304.     hasSelection : function(){
  2305.         return this.selection ? true : false;
  2306.     },
  2307.     handleMouseDown : function(g, row, cell, e){
  2308.         if(e.button !== 0 || this.isLocked()){
  2309.             return;
  2310.         };
  2311.         this.select(row, cell);
  2312.     },
  2313.     select : function(rowIndex, colIndex, preventViewNotify, preventFocus,  r){
  2314.         if(this.fireEvent("beforecellselect", this, rowIndex, colIndex) !== false){
  2315.             this.clearSelections();
  2316.             r = r || this.grid.store.getAt(rowIndex);
  2317.             this.selection = {
  2318.                 record : r,
  2319.                 cell : [rowIndex, colIndex]
  2320.             };
  2321.             if(!preventViewNotify){
  2322.                 var v = this.grid.getView();
  2323.                 v.onCellSelect(rowIndex, colIndex);
  2324.                 if(preventFocus !== true){
  2325.                     v.focusCell(rowIndex, colIndex);
  2326.                 }
  2327.             }
  2328.             this.fireEvent("cellselect", this, rowIndex, colIndex);
  2329.             this.fireEvent("selectionchange", this, this.selection);
  2330.         }
  2331.     },
  2332.         isSelectable : function(rowIndex, colIndex, cm){
  2333.         return !cm.isHidden(colIndex);
  2334.     },
  2335.     handleKeyDown : function(e){
  2336.         if(!e.isNavKeyPress()){
  2337.             return;
  2338.         }
  2339.         var g = this.grid, s = this.selection;
  2340.         if(!s){
  2341.             e.stopEvent();
  2342.             var cell = g.walkCells(0, 0, 1, this.isSelectable,  this);
  2343.             if(cell){
  2344.                 this.select(cell[0], cell[1]);
  2345.             }
  2346.             return;
  2347.         }
  2348.         var sm = this;
  2349.         var walk = function(row, col, step){
  2350.             return g.walkCells(row, col, step, sm.isSelectable,  sm);
  2351.         };
  2352.         var k = e.getKey(), r = s.cell[0], c = s.cell[1];
  2353.         var newCell;
  2354.         switch(k){
  2355.              case e.TAB:
  2356.                  if(e.shiftKey){
  2357.                      newCell = walk(r, c-1, -1);
  2358.                  }else{
  2359.                      newCell = walk(r, c+1, 1);
  2360.                  }
  2361.              break;
  2362.              case e.DOWN:
  2363.                  newCell = walk(r+1, c, 1);
  2364.              break;
  2365.              case e.UP:
  2366.                  newCell = walk(r-1, c, -1);
  2367.              break;
  2368.              case e.RIGHT:
  2369.                  newCell = walk(r, c+1, 1);
  2370.              break;
  2371.              case e.LEFT:
  2372.                  newCell = walk(r, c-1, -1);
  2373.              break;
  2374.              case e.ENTER:
  2375.                  if(g.isEditor && !g.editing){
  2376.                     g.startEditing(r, c);
  2377.                     e.stopEvent();
  2378.                     return;
  2379.                 }
  2380.              break;
  2381.         };
  2382.         if(newCell){
  2383.             this.select(newCell[0], newCell[1]);
  2384.             e.stopEvent();
  2385.         }
  2386.     },
  2387.     acceptsNav : function(row, col, cm){
  2388.         return !cm.isHidden(col) && cm.isCellEditable(col, row);
  2389.     },
  2390.     onEditorKey : function(field, e){
  2391.         var k = e.getKey(), newCell, g = this.grid, ed = g.activeEditor;
  2392.         if(k == e.TAB){
  2393.             if(e.shiftKey){
  2394.                 newCell = g.walkCells(ed.row, ed.col-1, -1, this.acceptsNav, this);
  2395.             }else{
  2396.                 newCell = g.walkCells(ed.row, ed.col+1, 1, this.acceptsNav, this);
  2397.             }
  2398.             e.stopEvent();
  2399.         }else if(k == e.ENTER){
  2400.             ed.completeEdit();
  2401.             e.stopEvent();
  2402.         }else if(k == e.ESC){
  2403.             e.stopEvent();
  2404.             ed.cancelEdit();
  2405.         }
  2406.         if(newCell){
  2407.             g.startEditing(newCell[0], newCell[1]);
  2408.         }
  2409.     }
  2410. });
  2411. Ext.grid.EditorGridPanel = Ext.extend(Ext.grid.GridPanel, {
  2412.     clicksToEdit: 2,
  2413.     isEditor : true,
  2414.     detectEdit: false,
  2415.     autoEncode : false,
  2416.     trackMouseOver: false,
  2417.     initComponent : function(){
  2418.         Ext.grid.EditorGridPanel.superclass.initComponent.call(this);
  2419.         if(!this.selModel){
  2420.             this.selModel = new Ext.grid.CellSelectionModel();
  2421.         }
  2422.         this.activeEditor = null;
  2423.         this.addEvents(
  2424.             "beforeedit",
  2425.             "afteredit",
  2426.             "validateedit"
  2427.         );
  2428.     },
  2429.     initEvents : function(){
  2430.         Ext.grid.EditorGridPanel.superclass.initEvents.call(this);
  2431.         this.on("bodyscroll", this.stopEditing, this, [true]);
  2432.         if(this.clicksToEdit == 1){
  2433.             this.on("cellclick", this.onCellDblClick, this);
  2434.         }else {
  2435.             if(this.clicksToEdit == 'auto' && this.view.mainBody){
  2436.                 this.view.mainBody.on("mousedown", this.onAutoEditClick, this);
  2437.             }
  2438.             this.on("celldblclick", this.onCellDblClick, this);
  2439.         }
  2440.         this.getGridEl().addClass("xedit-grid");
  2441.     },
  2442.     onCellDblClick : function(g, row, col){
  2443.         this.startEditing(row, col);
  2444.     },
  2445.     onAutoEditClick : function(e, t){
  2446.         if(e.button !== 0){
  2447.             return;
  2448.         }
  2449.         var row = this.view.findRowIndex(t);
  2450.         var col = this.view.findCellIndex(t);
  2451.         if(row !== false && col !== false){
  2452.             this.stopEditing();
  2453.             if(this.selModel.getSelectedCell){
  2454.                 var sc = this.selModel.getSelectedCell();
  2455.                 if(sc && sc.cell[0] === row && sc.cell[1] === col){
  2456.                     this.startEditing(row, col);
  2457.                 }
  2458.             }else{
  2459.                 if(this.selModel.isSelected(row)){
  2460.                     this.startEditing(row, col);
  2461.                 }
  2462.             }
  2463.         }
  2464.     },
  2465.     onEditComplete : function(ed, value, startValue){
  2466.         this.editing = false;
  2467.         this.activeEditor = null;
  2468.         ed.un("specialkey", this.selModel.onEditorKey, this.selModel);
  2469.         var r = ed.record;
  2470.         var field = this.colModel.getDataIndex(ed.col);
  2471.         value = this.postEditValue(value, startValue, r, field);
  2472.         if(String(value) !== String(startValue)){
  2473.             var e = {
  2474.                 grid: this,
  2475.                 record: r,
  2476.                 field: field,
  2477.                 originalValue: startValue,
  2478.                 value: value,
  2479.                 row: ed.row,
  2480.                 column: ed.col,
  2481.                 cancel:false
  2482.             };
  2483.             if(this.fireEvent("validateedit", e) !== false && !e.cancel){
  2484.                 r.set(field, e.value);
  2485.                 delete e.cancel;
  2486.                 this.fireEvent("afteredit", e);
  2487.             }
  2488.         }
  2489.         this.view.focusCell(ed.row, ed.col);
  2490.     },
  2491.     startEditing : function(row, col){
  2492.         this.stopEditing();
  2493.         if(this.colModel.isCellEditable(col, row)){
  2494.             this.view.ensureVisible(row, col, true);
  2495.             var r = this.store.getAt(row);
  2496.             var field = this.colModel.getDataIndex(col);
  2497.             var e = {
  2498.                 grid: this,
  2499.                 record: r,
  2500.                 field: field,
  2501.                 value: r.data[field],
  2502.                 row: row,
  2503.                 column: col,
  2504.                 cancel:false
  2505.             };
  2506.             if(this.fireEvent("beforeedit", e) !== false && !e.cancel){
  2507.                 this.editing = true;
  2508.                 var ed = this.colModel.getCellEditor(col, row);
  2509.                 if(!ed.rendered){
  2510.                     ed.render(this.view.getEditorParent(ed));
  2511.                 }
  2512.                 (function(){
  2513.                     ed.row = row;
  2514.                     ed.col = col;
  2515.                     ed.record = r;
  2516.                     ed.on("complete", this.onEditComplete, this, {single: true});
  2517.                     ed.on("specialkey", this.selModel.onEditorKey, this.selModel);
  2518.                     this.activeEditor = ed;
  2519.                     var v = this.preEditValue(r, field);
  2520.                     ed.startEdit(this.view.getCell(row, col), v);
  2521.                 }).defer(50, this);
  2522.             }
  2523.         }
  2524.     },
  2525.     preEditValue : function(r, field){
  2526.         return this.autoEncode && typeof value == 'string' ? Ext.util.Format.htmlDecode(r.data[field]) : r.data[field];
  2527.     },
  2528.     postEditValue : function(value, originalValue, r, field){
  2529.         return this.autoEncode && typeof value == 'string' ? Ext.util.Format.htmlEncode(value) : value;
  2530.     },
  2531.     stopEditing : function(cancel){
  2532.         if(this.activeEditor){
  2533.             this.activeEditor[cancel === true ? 'cancelEdit' : 'completeEdit']();
  2534.         }
  2535.         this.activeEditor = null;
  2536.     }
  2537. });
  2538. Ext.reg('editorgrid', Ext.grid.EditorGridPanel);
  2539. Ext.grid.GridEditor = function(field, config){
  2540.     Ext.grid.GridEditor.superclass.constructor.call(this, field, config);
  2541.     field.monitorTab = false;
  2542. };
  2543. Ext.extend(Ext.grid.GridEditor, Ext.Editor, {
  2544.     alignment: "tl-tl",
  2545.     autoSize: "width",
  2546.     hideEl : false,
  2547.     cls: "x-small-editor x-grid-editor",
  2548.     shim:false,
  2549.     shadow:false
  2550. });
  2551. Ext.grid.PropertyRecord = Ext.data.Record.create([
  2552.     {name:'name',type:'string'}, 'value'
  2553. ]);
  2554. Ext.grid.PropertyStore = function(grid, source){
  2555.     this.grid = grid;
  2556.     this.store = new Ext.data.Store({
  2557.         recordType : Ext.grid.PropertyRecord
  2558.     });
  2559.     this.store.on('update', this.onUpdate,  this);
  2560.     if(source){
  2561.         this.setSource(source);
  2562.     }
  2563.     Ext.grid.PropertyStore.superclass.constructor.call(this);
  2564. };
  2565. Ext.extend(Ext.grid.PropertyStore, Ext.util.Observable, {
  2566.         setSource : function(o){
  2567.         this.source = o;
  2568.         this.store.removeAll();
  2569.         var data = [];
  2570.         for(var k in o){
  2571.             if(this.isEditableValue(o[k])){
  2572.                 data.push(new Ext.grid.PropertyRecord({name: k, value: o[k]}, k));
  2573.             }
  2574.         }
  2575.         this.store.loadRecords({records: data}, {}, true);
  2576.     },
  2577.         onUpdate : function(ds, record, type){
  2578.         if(type == Ext.data.Record.EDIT){
  2579.             var v = record.data['value'];
  2580.             var oldValue = record.modified['value'];
  2581.             if(this.grid.fireEvent('beforepropertychange', this.source, record.id, v, oldValue) !== false){
  2582.                 this.source[record.id] = v;
  2583.                 record.commit();
  2584.                 this.grid.fireEvent('propertychange', this.source, record.id, v, oldValue);
  2585.             }else{
  2586.                 record.reject();
  2587.             }
  2588.         }
  2589.     },
  2590.         getProperty : function(row){
  2591.        return this.store.getAt(row);
  2592.     },
  2593.         isEditableValue: function(val){
  2594.         if(Ext.isDate(val)){
  2595.             return true;
  2596.         }else if(typeof val == 'object' || typeof val == 'function'){
  2597.             return false;
  2598.         }
  2599.         return true;
  2600.     },
  2601.         setValue : function(prop, value){
  2602.         this.source[prop] = value;
  2603.         this.store.getById(prop).set('value', value);
  2604.     },
  2605.         getSource : function(){
  2606.         return this.source;
  2607.     }
  2608. });
  2609. Ext.grid.PropertyColumnModel = function(grid, store){
  2610.     this.grid = grid;
  2611.     var g = Ext.grid;
  2612.     g.PropertyColumnModel.superclass.constructor.call(this, [
  2613.         {header: this.nameText, width:50, sortable: true, dataIndex:'name', id: 'name', menuDisabled:true},
  2614.         {header: this.valueText, width:50, resizable:false, dataIndex: 'value', id: 'value', menuDisabled:true}
  2615.     ]);
  2616.     this.store = store;
  2617.     this.bselect = Ext.DomHelper.append(document.body, {
  2618.         tag: 'select', cls: 'x-grid-editor x-hide-display', children: [
  2619.             {tag: 'option', value: 'true', html: 'true'},
  2620.             {tag: 'option', value: 'false', html: 'false'}
  2621.         ]
  2622.     });
  2623.     var f = Ext.form;
  2624.     var bfield = new f.Field({
  2625.         el:this.bselect,
  2626.         bselect : this.bselect,
  2627.         autoShow: true,
  2628.         getValue : function(){
  2629.             return this.bselect.value == 'true';
  2630.         }
  2631.     });
  2632.     this.editors = {
  2633.         'date' : new g.GridEditor(new f.DateField({selectOnFocus:true})),
  2634.         'string' : new g.GridEditor(new f.TextField({selectOnFocus:true})),
  2635.         'number' : new g.GridEditor(new f.NumberField({selectOnFocus:true, style:'text-align:left;'})),
  2636.         'boolean' : new g.GridEditor(bfield)
  2637.     };
  2638.     this.renderCellDelegate = this.renderCell.createDelegate(this);
  2639.     this.renderPropDelegate = this.renderProp.createDelegate(this);
  2640. };
  2641. Ext.extend(Ext.grid.PropertyColumnModel, Ext.grid.ColumnModel, {
  2642.         nameText : 'Name',
  2643.     valueText : 'Value',
  2644.     dateFormat : 'm/j/Y',
  2645.         renderDate : function(dateVal){
  2646.         return dateVal.dateFormat(this.dateFormat);
  2647.     },
  2648.         renderBool : function(bVal){
  2649.         return bVal ? 'true' : 'false';
  2650.     },
  2651.         isCellEditable : function(colIndex, rowIndex){
  2652.         return colIndex == 1;
  2653.     },
  2654.         getRenderer : function(col){
  2655.         return col == 1 ?
  2656.             this.renderCellDelegate : this.renderPropDelegate;
  2657.     },
  2658.         renderProp : function(v){
  2659.         return this.getPropertyName(v);
  2660.     },
  2661.         renderCell : function(val){
  2662.         var rv = val;
  2663.         if(Ext.isDate(val)){
  2664.             rv = this.renderDate(val);
  2665.         }else if(typeof val == 'boolean'){
  2666.             rv = this.renderBool(val);
  2667.         }
  2668.         return Ext.util.Format.htmlEncode(rv);
  2669.     },
  2670.         getPropertyName : function(name){
  2671.         var pn = this.grid.propertyNames;
  2672.         return pn && pn[name] ? pn[name] : name;
  2673.     },
  2674.         getCellEditor : function(colIndex, rowIndex){
  2675.         var p = this.store.getProperty(rowIndex);
  2676.         var n = p.data['name'], val = p.data['value'];
  2677.         if(this.grid.customEditors[n]){
  2678.             return this.grid.customEditors[n];
  2679.         }
  2680.         if(Ext.isDate(val)){
  2681.             return this.editors['date'];
  2682.         }else if(typeof val == 'number'){
  2683.             return this.editors['number'];
  2684.         }else if(typeof val == 'boolean'){
  2685.             return this.editors['boolean'];
  2686.         }else{
  2687.             return this.editors['string'];
  2688.         }
  2689.     }
  2690. });
  2691. Ext.grid.PropertyGrid = Ext.extend(Ext.grid.EditorGridPanel, {
  2692.         enableColumnMove:false,
  2693.     stripeRows:false,
  2694.     trackMouseOver: false,
  2695.     clicksToEdit:1,
  2696.     enableHdMenu : false,
  2697.     viewConfig : {
  2698.         forceFit:true
  2699.     },
  2700.         initComponent : function(){
  2701.         this.customEditors = this.customEditors || {};
  2702.         this.lastEditRow = null;
  2703.         var store = new Ext.grid.PropertyStore(this);
  2704.         this.propStore = store;
  2705.         var cm = new Ext.grid.PropertyColumnModel(this, store);
  2706.         store.store.sort('name', 'ASC');
  2707.         this.addEvents(
  2708.             'beforepropertychange',
  2709.             'propertychange'
  2710.         );
  2711.         this.cm = cm;
  2712.         this.ds = store.store;
  2713.         Ext.grid.PropertyGrid.superclass.initComponent.call(this);
  2714.         this.selModel.on('beforecellselect', function(sm, rowIndex, colIndex){
  2715.             if(colIndex === 0){
  2716.                 this.startEditing.defer(200, this, [rowIndex, 1]);
  2717.                 return false;
  2718.             }
  2719.         }, this);
  2720.     },
  2721.         onRender : function(){
  2722.         Ext.grid.PropertyGrid.superclass.onRender.apply(this, arguments);
  2723.         this.getGridEl().addClass('x-props-grid');
  2724.     },
  2725.         afterRender: function(){
  2726.         Ext.grid.PropertyGrid.superclass.afterRender.apply(this, arguments);
  2727.         if(this.source){
  2728.             this.setSource(this.source);
  2729.         }
  2730.     },
  2731.     setSource : function(source){
  2732.         this.propStore.setSource(source);
  2733.     },
  2734.     getSource : function(){
  2735.         return this.propStore.getSource();
  2736.     }
  2737. });
  2738. Ext.grid.RowNumberer = function(config){
  2739.     Ext.apply(this, config);
  2740.     if(this.rowspan){
  2741.         this.renderer = this.renderer.createDelegate(this);
  2742.     }
  2743. };
  2744. Ext.grid.RowNumberer.prototype = {
  2745.     header: "",
  2746.     width: 23,
  2747.     sortable: false,
  2748.     fixed:true,
  2749.     menuDisabled:true,
  2750.     dataIndex: '',
  2751.     id: 'numberer',
  2752.     rowspan: undefined,
  2753.     renderer : function(v, p, record, rowIndex){
  2754.         if(this.rowspan){
  2755.             p.cellAttr = 'rowspan="'+this.rowspan+'"';
  2756.         }
  2757.         return rowIndex+1;
  2758.     }
  2759. };
  2760. Ext.grid.CheckboxSelectionModel = Ext.extend(Ext.grid.RowSelectionModel, {
  2761.     header: '<div class="x-grid3-hd-checker">&#160;</div>',
  2762.     width: 20,
  2763.     sortable: false,
  2764.     menuDisabled:true,
  2765.     fixed:true,
  2766.     dataIndex: '',
  2767.     id: 'checker',
  2768.     initEvents : function(){
  2769.         Ext.grid.CheckboxSelectionModel.superclass.initEvents.call(this);
  2770.         this.grid.on('render', function(){
  2771.             var view = this.grid.getView();
  2772.             view.mainBody.on('mousedown', this.onMouseDown, this);
  2773.             Ext.fly(view.innerHd).on('mousedown', this.onHdMouseDown, this);
  2774.         }, this);
  2775.     },
  2776.     onMouseDown : function(e, t){
  2777.         if(e.button === 0 && t.className == 'x-grid3-row-checker'){
  2778.             e.stopEvent();
  2779.             var row = e.getTarget('.x-grid3-row');
  2780.             if(row){
  2781.                 var index = row.rowIndex;
  2782.                 if(this.isSelected(index)){
  2783.                     this.deselectRow(index);
  2784.                 }else{
  2785.                     this.selectRow(index, true);
  2786.                 }
  2787.             }
  2788.         }
  2789.     },
  2790.     onHdMouseDown : function(e, t){
  2791.         if(t.className == 'x-grid3-hd-checker'){
  2792.             e.stopEvent();
  2793.             var hd = Ext.fly(t.parentNode);
  2794.             var isChecked = hd.hasClass('x-grid3-hd-checker-on');
  2795.             if(isChecked){
  2796.                 hd.removeClass('x-grid3-hd-checker-on');
  2797.                 this.clearSelections();
  2798.             }else{
  2799.                 hd.addClass('x-grid3-hd-checker-on');
  2800.                 this.selectAll();
  2801.             }
  2802.         }
  2803.     },
  2804.     renderer : function(v, p, record){
  2805.         return '<div class="x-grid3-row-checker">&#160;</div>';
  2806.     }
  2807. });
  2808. Ext.LoadMask = function(el, config){
  2809.     this.el = Ext.get(el);
  2810.     Ext.apply(this, config);
  2811.     if(this.store){
  2812.         this.store.on('beforeload', this.onBeforeLoad, this);
  2813.         this.store.on('load', this.onLoad, this);
  2814.         this.store.on('loadexception', this.onLoad, this);
  2815.         this.removeMask = Ext.value(this.removeMask, false);
  2816.     }else{
  2817.         var um = this.el.getUpdater();
  2818.         um.showLoadIndicator = false;         um.on('beforeupdate', this.onBeforeLoad, this);
  2819.         um.on('update', this.onLoad, this);
  2820.         um.on('failure', this.onLoad, this);
  2821.         this.removeMask = Ext.value(this.removeMask, true);
  2822.     }
  2823. };
  2824. Ext.LoadMask.prototype = {
  2825.     msg : 'Loading...',
  2826.     msgCls : 'x-mask-loading',
  2827.     disabled: false,
  2828.     disable : function(){
  2829.        this.disabled = true;
  2830.     },
  2831.     enable : function(){
  2832.         this.disabled = false;
  2833.     },
  2834.         onLoad : function(){
  2835.         this.el.unmask(this.removeMask);
  2836.     },
  2837.         onBeforeLoad : function(){
  2838.         if(!this.disabled){
  2839.             this.el.mask(this.msg, this.msgCls);
  2840.         }
  2841.     },
  2842.     show: function(){
  2843.         this.onBeforeLoad();
  2844.     },
  2845.     hide: function(){
  2846.         this.onLoad();
  2847.     },
  2848.         destroy : function(){
  2849.         if(this.store){
  2850.             this.store.un('beforeload', this.onBeforeLoad, this);
  2851.             this.store.un('load', this.onLoad, this);
  2852.             this.store.un('loadexception', this.onLoad, this);
  2853.         }else{
  2854.             var um = this.el.getUpdater();
  2855.             um.un('beforeupdate', this.onBeforeLoad, this);
  2856.             um.un('update', this.onLoad, this);
  2857.             um.un('failure', this.onLoad, this);
  2858.         }
  2859.     }
  2860. };
  2861. Ext.ProgressBar = Ext.extend(Ext.BoxComponent, {
  2862.     baseCls : 'x-progress',
  2863.     waitTimer : null,
  2864.     initComponent : function(){
  2865.         Ext.ProgressBar.superclass.initComponent.call(this);
  2866.         this.addEvents(
  2867.             "update"
  2868.         );
  2869.     },
  2870.     onRender : function(ct, position){
  2871.         Ext.ProgressBar.superclass.onRender.call(this, ct, position);
  2872.         var tpl = new Ext.Template(
  2873.             '<div class="{cls}-wrap">',
  2874.                 '<div class="{cls}-inner">',
  2875.                     '<div class="{cls}-bar">',
  2876.                         '<div class="{cls}-text">',
  2877.                             '<div>&#160;</div>',
  2878.                         '</div>',
  2879.                     '</div>',
  2880.                     '<div class="{cls}-text {cls}-text-back">',
  2881.                         '<div>&#160;</div>',
  2882.                     '</div>',
  2883.                 '</div>',
  2884.             '</div>'
  2885.         );
  2886.         if(position){
  2887.             this.el = tpl.insertBefore(position, {cls: this.baseCls}, true);
  2888.         }else{
  2889.             this.el = tpl.append(ct, {cls: this.baseCls}, true);
  2890.         }
  2891.         if(this.id){
  2892.             this.el.dom.id = this.id;
  2893.         }
  2894.         var inner = this.el.dom.firstChild;
  2895.         this.progressBar = Ext.get(inner.firstChild);
  2896.         if(this.textEl){
  2897.             this.textEl = Ext.get(this.textEl);
  2898.             delete this.textTopEl;
  2899.         }else{
  2900.             this.textTopEl = Ext.get(this.progressBar.dom.firstChild);
  2901.             var textBackEl = Ext.get(inner.childNodes[1]);
  2902.             this.textTopEl.setStyle("z-index", 99).addClass('x-hidden');
  2903.             this.textEl = new Ext.CompositeElement([this.textTopEl.dom.firstChild, textBackEl.dom.firstChild]);
  2904.             this.textEl.setWidth(inner.offsetWidth);
  2905.         }
  2906.         if(this.value){
  2907.             this.updateProgress(this.value, this.text);
  2908.         }else{
  2909.             this.updateText(this.text);
  2910.         }
  2911.         this.setSize(this.width || 'auto', 'auto');
  2912.         this.progressBar.setHeight(inner.offsetHeight);
  2913.     },
  2914.     updateProgress : function(value, text){
  2915.         this.value = value || 0;
  2916.         if(text){
  2917.             this.updateText(text);
  2918.         }
  2919.         var w = Math.floor(value*this.el.dom.firstChild.offsetWidth);
  2920.         this.progressBar.setWidth(w);
  2921.         if(this.textTopEl){
  2922.             this.textTopEl.removeClass('x-hidden').setWidth(w);
  2923.         }
  2924.         this.fireEvent('update', this, value, text);
  2925.         return this;
  2926.     },
  2927.     wait : function(o){
  2928.         if(!this.waitTimer){
  2929.             var scope = this;
  2930.             o = o || {};
  2931.             this.waitTimer = Ext.TaskMgr.start({
  2932.                 run: function(i){
  2933.                     var inc = o.increment || 10;
  2934.                     this.updateProgress(((((i+inc)%inc)+1)*(100/inc))*.01);
  2935.                 },
  2936.                 interval: o.interval || 1000,
  2937.                 duration: o.duration,
  2938.                 onStop: function(){
  2939.                     if(o.fn){
  2940.                         o.fn.apply(o.scope || this);
  2941.                     }
  2942.                     this.reset();
  2943.                 },
  2944.                 scope: scope
  2945.             });
  2946.         }
  2947.         return this;
  2948.     },
  2949.     isWaiting : function(){
  2950.         return this.waitTimer != null;
  2951.     },
  2952.     updateText : function(text){
  2953.         this.text = text || '&#160;';
  2954.         this.textEl.update(this.text);
  2955.         return this;
  2956.     },
  2957.     setSize : function(w, h){
  2958.         Ext.ProgressBar.superclass.setSize.call(this, w, h);
  2959.         if(this.textTopEl){
  2960.             var inner = this.el.dom.firstChild;
  2961.             this.textEl.setSize(inner.offsetWidth, inner.offsetHeight);
  2962.         }
  2963.         return this;
  2964.     },
  2965.     reset : function(hide){
  2966.         this.updateProgress(0);
  2967.         if(this.textTopEl){
  2968.             this.textTopEl.addClass('x-hidden');
  2969.         }
  2970.         if(this.waitTimer){
  2971.             this.waitTimer.onStop = null;
  2972.             Ext.TaskMgr.stop(this.waitTimer);
  2973.             this.waitTimer = null;
  2974.         }
  2975.         if(hide === true){
  2976.             this.hide();
  2977.         }
  2978.         return this;
  2979.     }
  2980. });
  2981. Ext.reg('progress', Ext.ProgressBar);
  2982. Ext.debug = {};
  2983. (function(){
  2984. var cp;
  2985. function createConsole(){
  2986.     var scriptPanel = new Ext.debug.ScriptsPanel();
  2987.     var logView = new Ext.debug.LogPanel();
  2988.     var tree = new Ext.debug.DomTree();
  2989.     var tabs = new Ext.TabPanel({
  2990.         activeTab: 0,
  2991.         border: false,
  2992.         tabPosition: 'bottom',
  2993.         items: [{
  2994.             title: 'Debug Console',
  2995.             layout:'border',
  2996.             items: [logView, scriptPanel]
  2997.         },{
  2998.             title: 'DOM Inspector',
  2999.             layout:'border',
  3000.             items: [tree]
  3001.         }]
  3002.     });
  3003.     cp = new Ext.Panel({
  3004.         id: 'x-debug-browser',
  3005.         title: 'Console',
  3006.         collapsible: true,
  3007.         animCollapse: false,
  3008.         style: 'position:absolute;left:0;bottom:0;',
  3009.         height:200,
  3010.         logView: logView,
  3011.         layout: 'fit',
  3012.         tools:[{
  3013.             id: 'close',
  3014.             handler: function(){
  3015.                 cp.destroy();
  3016.                 cp = null;
  3017.                 Ext.EventManager.removeResizeListener(handleResize);
  3018.             }
  3019.         }],
  3020.         items: tabs
  3021.     });
  3022.     cp.render(document.body);
  3023.     cp.resizer = new Ext.Resizable(cp.el, {
  3024.         minHeight:50,
  3025.         handles: "n",
  3026.         pinned: true,
  3027.         transparent:true,
  3028.         resizeElement : function(){
  3029.             var box = this.proxy.getBox();
  3030.             this.proxy.hide();
  3031.             cp.setHeight(box.height);
  3032.             return box;
  3033.         }
  3034.     });
  3035.     function handleResize(){
  3036.         cp.setWidth(Ext.getBody().getViewSize().width);
  3037.     }
  3038.     Ext.EventManager.onWindowResize(handleResize);
  3039.     handleResize();
  3040. }
  3041. Ext.apply(Ext, {
  3042.     log : function(){
  3043.         if(!cp){
  3044.             createConsole();
  3045.         }
  3046.         cp.logView.log.apply(cp.logView, arguments);
  3047.     },
  3048.     logf : function(format, arg1, arg2, etc){
  3049.         Ext.log(String.format.apply(String, arguments));
  3050.     },
  3051.     dump : function(o){
  3052.         if(typeof o == 'string' || typeof o == 'number' || typeof o == 'undefined' || Ext.isDate(o)){
  3053.             Ext.log(o);
  3054.         }else if(!o){
  3055.             Ext.log("null");
  3056.         }else if(typeof o != "object"){
  3057.             Ext.log('Unknown return type');
  3058.         }else if(Ext.isArray(o)){
  3059.             Ext.log('['+o.join(',')+']');
  3060.         }else{
  3061.             var b = ["{n"];
  3062.             for(var key in o){
  3063.                 var to = typeof o[key];
  3064.                 if(to != "function" && to != "object"){
  3065.                     b.push(String.format("  {0}: {1},n", key, o[key]));
  3066.                 }
  3067.             }
  3068.             var s = b.join("");
  3069.             if(s.length > 3){
  3070.                 s = s.substr(0, s.length-2);
  3071.             }
  3072.             Ext.log(s + "n}");
  3073.         }
  3074.     },
  3075.     _timers : {},
  3076.     time : function(name){
  3077.         name = name || "def";
  3078.         Ext._timers[name] = new Date().getTime();
  3079.     },
  3080.     timeEnd : function(name, printResults){
  3081.         var t = new Date().getTime();
  3082.         name = name || "def";
  3083.         var v = String.format("{0} ms", t-Ext._timers[name]);
  3084.         Ext._timers[name] = new Date().getTime();
  3085.         if(printResults !== false){
  3086.             Ext.log('Timer ' + (name == "def" ? v : name + ": " + v));
  3087.         }
  3088.         return v;
  3089.     }
  3090. });
  3091. })();
  3092. Ext.debug.ScriptsPanel = Ext.extend(Ext.Panel, {
  3093.     id:'x-debug-scripts',
  3094.     region: 'east',
  3095.     minWidth: 200,
  3096.     split: true,
  3097.     width: 350,
  3098.     border: false,
  3099.     layout:'anchor',
  3100.     style:'border-width:0 0 0 1px;',
  3101.     initComponent : function(){
  3102.         this.scriptField = new Ext.form.TextArea({
  3103.             anchor: '100% -26',
  3104.             style:'border-width:0;'
  3105.         });
  3106.         this.trapBox = new Ext.form.Checkbox({
  3107.             id: 'console-trap',
  3108.             boxLabel: 'Trap Errors',
  3109.             checked: true
  3110.         });
  3111.         this.toolbar = new Ext.Toolbar([{
  3112.                 text: 'Run',
  3113.                 scope: this,
  3114.                 handler: this.evalScript
  3115.             },{
  3116.                 text: 'Clear',
  3117.                 scope: this,
  3118.                 handler: this.clear
  3119.             },
  3120.             '->',
  3121.             this.trapBox,
  3122.             ' ', ' '
  3123.         ]);
  3124.         this.items = [this.toolbar, this.scriptField];
  3125.         Ext.debug.ScriptsPanel.superclass.initComponent.call(this);
  3126.     },
  3127.     evalScript : function(){
  3128.         var s = this.scriptField.getValue();
  3129.         if(this.trapBox.getValue()){
  3130.             try{
  3131.                 var rt = eval(s);
  3132.                 Ext.dump(rt === undefined? '(no return)' : rt);
  3133.             }catch(e){
  3134.                 Ext.log(e.message || e.descript);
  3135.             }
  3136.         }else{
  3137.             var rt = eval(s);
  3138.             Ext.dump(rt === undefined? '(no return)' : rt);
  3139.         }
  3140.     },
  3141.     clear : function(){
  3142.         this.scriptField.setValue('');
  3143.         this.scriptField.focus();
  3144.     }
  3145. });
  3146. Ext.debug.LogPanel = Ext.extend(Ext.Panel, {
  3147.     autoScroll: true,
  3148.     region: 'center',
  3149.     border: false,
  3150.     style:'border-width:0 1px 0 0',
  3151.     log : function(){
  3152.         var markup = [  '<div style="padding:5px !important;border-bottom:1px solid #ccc;">',
  3153.                     Ext.util.Format.htmlEncode(Array.prototype.join.call(arguments, ', ')).replace(/n/g, '<br />').replace(/s/g, '&#160;'),
  3154.                     '</div>'].join('');
  3155.         this.body.insertHtml('beforeend', markup);
  3156.         this.body.scrollTo('top', 100000);
  3157.     },
  3158.     clear : function(){
  3159.         this.body.update('');
  3160.         this.body.dom.scrollTop = 0;
  3161.     }
  3162. });
  3163. Ext.debug.DomTree = Ext.extend(Ext.tree.TreePanel, {
  3164.     enableDD:false ,
  3165.     lines:false,
  3166.     rootVisible:false,
  3167.     animate:false,
  3168.     hlColor:'ffff9c',
  3169.     autoScroll: true,
  3170.     region:'center',
  3171.     border:false,
  3172.     initComponent : function(){
  3173.         Ext.debug.DomTree.superclass.initComponent.call(this);
  3174.                 var styles = false, hnode;
  3175.         var nonSpace = /^s*$/;
  3176.         var html = Ext.util.Format.htmlEncode;
  3177.         var ellipsis = Ext.util.Format.ellipsis;
  3178.         var styleRe = /s?([a-z-]*):([^;]*)(?:[;snr]*)/gi;
  3179.         function findNode(n){
  3180.             if(!n || n.nodeType != 1 || n == document.body || n == document){
  3181.                 return false;
  3182.             }
  3183.             var pn = [n], p = n;
  3184.             while((p = p.parentNode) && p.nodeType == 1 && p.tagName.toUpperCase() != 'HTML'){
  3185.                 pn.unshift(p);
  3186.             }
  3187.             var cn = hnode;
  3188.             for(var i = 0, len = pn.length; i < len; i++){
  3189.                 cn.expand();
  3190.                 cn = cn.findChild('htmlNode', pn[i]);
  3191.                 if(!cn){                     return false;
  3192.                 }
  3193.             }
  3194.             cn.select();
  3195.             var a = cn.ui.anchor;
  3196.             treeEl.dom.scrollTop = Math.max(0 ,a.offsetTop-10);
  3197.                         cn.highlight();
  3198.             return true;
  3199.         }
  3200.         function nodeTitle(n){
  3201.             var s = n.tagName;
  3202.             if(n.id){
  3203.                 s += '#'+n.id;
  3204.             }else if(n.className){
  3205.                 s += '.'+n.className;
  3206.             }
  3207.             return s;
  3208.         }
  3209.         function onNodeSelect(t, n, last){
  3210.             return;
  3211.             if(last && last.unframe){
  3212.                 last.unframe();
  3213.             }
  3214.             var props = {};
  3215.             if(n && n.htmlNode){
  3216.                 if(frameEl.pressed){
  3217.                     n.frame();
  3218.                 }
  3219.                 if(inspecting){
  3220.                     return;
  3221.                 }
  3222.                 addStyle.enable();
  3223.                 reload.setDisabled(n.leaf);
  3224.                 var dom = n.htmlNode;
  3225.                 stylePanel.setTitle(nodeTitle(dom));
  3226.                 if(styles && !showAll.pressed){
  3227.                     var s = dom.style ? dom.style.cssText : '';
  3228.                     if(s){
  3229.                         var m;
  3230.                         while ((m = styleRe.exec(s)) != null){
  3231.                             props[m[1].toLowerCase()] = m[2];
  3232.                         }
  3233.                     }
  3234.                 }else if(styles){
  3235.                     var cl = Ext.debug.cssList;
  3236.                     var s = dom.style, fly = Ext.fly(dom);
  3237.                     if(s){
  3238.                         for(var i = 0, len = cl.length; i<len; i++){
  3239.                             var st = cl[i];
  3240.                             var v = s[st] || fly.getStyle(st);
  3241.                             if(v != undefined && v !== null && v !== ''){
  3242.                                 props[st] = v;
  3243.                             }
  3244.                         }
  3245.                     }
  3246.                 }else{
  3247.                     for(var a in dom){
  3248.                         var v = dom[a];
  3249.                         if((isNaN(a+10)) && v != undefined && v !== null && v !== '' && !(Ext.isGecko && a[0] == a[0].toUpperCase())){
  3250.                             props[a] = v;
  3251.                         }
  3252.                     }
  3253.                 }
  3254.             }else{
  3255.                 if(inspecting){
  3256.                     return;
  3257.                 }
  3258.                 addStyle.disable();
  3259.                 reload.disabled();
  3260.             }
  3261.             stylesGrid.setSource(props);
  3262.             stylesGrid.treeNode = n;
  3263.             stylesGrid.view.fitColumns();
  3264.         }
  3265.         this.loader = new Ext.tree.TreeLoader();
  3266.         this.loader.load = function(n, cb){
  3267.             var isBody = n.htmlNode == document.body;
  3268.             var cn = n.htmlNode.childNodes;
  3269.             for(var i = 0, c; c = cn[i]; i++){
  3270.                 if(isBody && c.id == 'x-debug-browser'){
  3271.                     continue;
  3272.                 }
  3273.                 if(c.nodeType == 1){
  3274.                     n.appendChild(new Ext.debug.HtmlNode(c));
  3275.                 }else if(c.nodeType == 3 && !nonSpace.test(c.nodeValue)){
  3276.                     n.appendChild(new Ext.tree.TreeNode({
  3277.                         text:'<em>' + ellipsis(html(String(c.nodeValue)), 35) + '</em>',
  3278.                         cls: 'x-tree-noicon'
  3279.                     }));
  3280.                 }
  3281.             }
  3282.             cb();
  3283.         };
  3284.         this.root = this.setRootNode(new Ext.tree.TreeNode('Ext'));
  3285.         hnode = this.root.appendChild(new Ext.debug.HtmlNode(
  3286.                 document.getElementsByTagName('html')[0]
  3287.         ));
  3288.     }
  3289. });
  3290. Ext.debug.HtmlNode = function(){
  3291.     var html = Ext.util.Format.htmlEncode;
  3292.     var ellipsis = Ext.util.Format.ellipsis;
  3293.     var nonSpace = /^s*$/;
  3294.     var attrs = [
  3295.         {n: 'id', v: 'id'},
  3296.         {n: 'className', v: 'class'},
  3297.         {n: 'name', v: 'name'},
  3298.         {n: 'type', v: 'type'},
  3299.         {n: 'src', v: 'src'},
  3300.         {n: 'href', v: 'href'}
  3301.     ];
  3302.     function hasChild(n){
  3303.         for(var i = 0, c; c = n.childNodes[i]; i++){
  3304.             if(c.nodeType == 1){
  3305.                 return true;
  3306.             }
  3307.         }
  3308.         return false;
  3309.     }
  3310.     function renderNode(n, leaf){
  3311.         var tag = n.tagName.toLowerCase();
  3312.         var s = '&lt;' + tag;
  3313.         for(var i = 0, len = attrs.length; i < len; i++){
  3314.             var a = attrs[i];
  3315.             var v = n[a.n];
  3316.             if(v && !nonSpace.test(v)){
  3317.                 s += ' ' + a.v + '=&quot;<i>' + html(v) +'</i>&quot;';
  3318.             }
  3319.         }
  3320.         var style = n.style ? n.style.cssText : '';
  3321.         if(style){
  3322.             s += ' style=&quot;<i>' + html(style.toLowerCase()) +'</i>&quot;';
  3323.         }
  3324.         if(leaf && n.childNodes.length > 0){
  3325.             s+='&gt;<em>' + ellipsis(html(String(n.innerHTML)), 35) + '</em>&lt;/'+tag+'&gt;';
  3326.         }else if(leaf){
  3327.             s += ' /&gt;';
  3328.         }else{
  3329.             s += '&gt;';
  3330.         }
  3331.         return s;
  3332.     }
  3333.     var HtmlNode = function(n){
  3334.         var leaf = !hasChild(n);
  3335.         this.htmlNode = n;
  3336.         this.tagName = n.tagName.toLowerCase();
  3337.         var attr = {
  3338.             text : renderNode(n, leaf),
  3339.             leaf : leaf,
  3340.             cls: 'x-tree-noicon'
  3341.         };
  3342.         HtmlNode.superclass.constructor.call(this, attr);
  3343.         this.attributes.htmlNode = n;         if(!leaf){
  3344.             this.on('expand', this.onExpand,  this);
  3345.             this.on('collapse', this.onCollapse,  this);
  3346.         }
  3347.     };
  3348.     Ext.extend(HtmlNode, Ext.tree.AsyncTreeNode, {
  3349.         cls: 'x-tree-noicon',
  3350.         preventHScroll: true,
  3351.         refresh : function(highlight){
  3352.             var leaf = !hasChild(this.htmlNode);
  3353.             this.setText(renderNode(this.htmlNode, leaf));
  3354.             if(highlight){
  3355.                 Ext.fly(this.ui.textNode).highlight();
  3356.             }
  3357.         },
  3358.         onExpand : function(){
  3359.             if(!this.closeNode && this.parentNode){
  3360.                 this.closeNode = this.parentNode.insertBefore(new Ext.tree.TreeNode({
  3361.                     text:'&lt;/' + this.tagName + '&gt;',
  3362.                     cls: 'x-tree-noicon'
  3363.                 }), this.nextSibling);
  3364.             }else if(this.closeNode){
  3365.                 this.closeNode.ui.show();
  3366.             }
  3367.         },
  3368.         onCollapse : function(){
  3369.             if(this.closeNode){
  3370.                 this.closeNode.ui.hide();
  3371.             }
  3372.         },
  3373.         render : function(bulkRender){
  3374.             HtmlNode.superclass.render.call(this, bulkRender);
  3375.         },
  3376.         highlightNode : function(){
  3377.                     },
  3378.         highlight : function(){
  3379.                     },
  3380.         frame : function(){
  3381.             this.htmlNode.style.border = '1px solid #0000ff';
  3382.                     },
  3383.         unframe : function(){
  3384.                         this.htmlNode.style.border = '';
  3385.         }
  3386.     });
  3387.     return HtmlNode;
  3388. }();