X-Git-Url: http://git.ithinksw.org/extjs.git/blobdiff_plain/ee06f37b0f6f6d94cd05a6ffae556660f7c4a2bc..c930e9176a5a85509c5b0230e2bff5c22a591432:/docs/source/GridView.html?ds=sidebyside diff --git a/docs/source/GridView.html b/docs/source/GridView.html new file mode 100644 index 00000000..97c50522 --- /dev/null +++ b/docs/source/GridView.html @@ -0,0 +1,1780 @@ + + + The source code + + + + +
/** + * @class Ext.grid.GridView + * @extends Ext.util.Observable + *

This class encapsulates the user interface of an {@link Ext.grid.GridPanel}. + * Methods of this class may be used to access user interface elements to enable + * special display effects. Do not change the DOM structure of the user interface.

+ *

This class does not provide ways to manipulate the underlying data. The data + * model of a Grid is held in an {@link Ext.data.Store}.

+ * @constructor + * @param {Object} config + */ +Ext.grid.GridView = function(config){ + Ext.apply(this, config); + // These events are only used internally by the grid components + this.addEvents( +
/** + * @event beforerowremoved + * Internal UI Event. Fired before a row is removed. + * @param {Ext.grid.GridView} view + * @param {Number} rowIndex The index of the row to be removed. + * @param {Ext.data.Record} record The Record to be removed + */ + "beforerowremoved", +
/** + * @event beforerowsinserted + * Internal UI Event. Fired before rows are inserted. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the first row to be inserted. + * @param {Number} lastRow The index of the last row to be inserted. + */ + "beforerowsinserted", +
/** + * @event beforerefresh + * Internal UI Event. Fired before the view is refreshed. + * @param {Ext.grid.GridView} view + */ + "beforerefresh", +
/** + * @event rowremoved + * Internal UI Event. Fired after a row is removed. + * @param {Ext.grid.GridView} view + * @param {Number} rowIndex The index of the row that was removed. + * @param {Ext.data.Record} record The Record that was removed + */ + "rowremoved", +
/** + * @event rowsinserted + * Internal UI Event. Fired after rows are inserted. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the first inserted. + * @param {Number} lastRow The index of the last row inserted. + */ + "rowsinserted", +
/** + * @event rowupdated + * Internal UI Event. Fired after a row has been updated. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the row updated. + * @param {Ext.data.record} record The Record backing the row updated. + */ + "rowupdated", +
/** + * @event refresh + * Internal UI Event. Fired after the GridView's body has been refreshed. + * @param {Ext.grid.GridView} view + */ + "refresh" + ); + Ext.grid.GridView.superclass.constructor.call(this); +}; + +Ext.extend(Ext.grid.GridView, Ext.util.Observable, { +
/** + * Override this function to apply custom CSS classes to rows during rendering. You can also supply custom + * parameters to the row template for the current row to customize how it is rendered using the rowParams + * parameter. This function should return the CSS class name (or empty string '' for none) that will be added + * to the row's wrapping div. To apply multiple class names, simply return them space-delimited within the string + * (e.g., 'my-class another-class'). Example usage: +

+viewConfig: {
+    forceFit: true,
+    showPreview: true, // custom property
+    enableRowBody: true, // required to create a second, full-width row to show expanded Record data
+    getRowClass: function(record, rowIndex, rp, ds){ // rp = rowParams
+        if(this.showPreview){
+            rp.body = '<p>'+record.data.excerpt+'</p>';
+            return 'x-grid3-row-expanded';
+        }
+        return 'x-grid3-row-collapsed';
+    }
+},     
+    
+ * @param {Record} record The {@link Ext.data.Record} corresponding to the current row. + * @param {Number} index The row index. + * @param {Object} rowParams A config object that is passed to the row template during rendering that allows + * customization of various aspects of a grid row. + *

If {@link #enableRowBody} is configured true, then the following properties may be set + * by this function, and will be used to render a full-width expansion row below each grid row:

+ * + * The following property will be passed in, and may be appended to: + * + * @param {Store} store The {@link Ext.data.Store} this grid is bound to + * @method getRowClass + * @return {String} a CSS class name to add to the row. + */ +
/** + * @cfg {Boolean} enableRowBody True to add a second TR element per row that can be used to provide a row body + * that spans beneath the data row. Use the {@link #getRowClass} method's rowParams config to customize the row body. + */ +
/** + * @cfg {String} emptyText Default text (html tags are accepted) to display in the grid body when no rows + * are available (defaults to ''). This value will be used to update the {@link #mainBody}: +

+    this.mainBody.update('<div class="x-grid-empty">' + this.emptyText + '</div>');
+    
+ */ +
/** + * @cfg {Boolean} headersDisabled True to disable the grid column headers (defaults to false). + * Use the {@link Ext.grid.ColumnModel ColumnModel} {@link Ext.grid.ColumnModel#menuDisabled menuDisabled} + * config to disable the menu for individual columns. While this config is true the + * following will be disabled:
+ */ +
/** + *

A customized implementation of a {@link Ext.dd.DragZone DragZone} which provides default implementations + * of the template methods of DragZone to enable dragging of the selected rows of a GridPanel. + * See {@link Ext.grid.GridDragZone} for details.

+ *

This will only be present:

+ * @property dragZone + * @type {Ext.grid.GridDragZone} + */ +
/** + * @cfg {Boolean} deferEmptyText True to defer {@link #emptyText} being applied until the store's + * first load (defaults to true). + */ + deferEmptyText : true, +
/** + * @cfg {Number} scrollOffset The amount of space to reserve for the vertical scrollbar + * (defaults to 19 pixels). + */ + scrollOffset : 19, +
/** + * @cfg {Boolean} autoFill + * Defaults to false. Specify true to have the column widths re-proportioned + * when the grid is initially rendered. The + * {@link Ext.grid.Column#width initially configured width} of each column will be adjusted + * to fit the grid width and prevent horizontal scrolling. If columns are later resized (manually + * or programmatically), the other columns in the grid will not be resized to fit the grid width. + * See {@link #forceFit} also. + */ + autoFill : false, +
/** + * @cfg {Boolean} forceFit + * Defaults to false. Specify true to have the column widths re-proportioned + * at all times. The {@link Ext.grid.Column#width initially configured width} of each + * column will be adjusted to fit the grid width and prevent horizontal scrolling. If columns are + * later resized (manually or programmatically), the other columns in the grid will be resized + * to fit the grid width. See {@link #autoFill} also. + */ + forceFit : false, +
/** + * @cfg {Array} sortClasses The CSS classes applied to a header when it is sorted. (defaults to ["sort-asc", "sort-desc"]) + */ + sortClasses : ["sort-asc", "sort-desc"], +
/** + * @cfg {String} sortAscText The text displayed in the "Sort Ascending" menu item (defaults to "Sort Ascending") + */ + sortAscText : "Sort Ascending", +
/** + * @cfg {String} sortDescText The text displayed in the "Sort Descending" menu item (defaults to "Sort Descending") + */ + sortDescText : "Sort Descending", +
/** + * @cfg {String} columnsText The text displayed in the "Columns" menu item (defaults to "Columns") + */ + columnsText : "Columns", + +
/** + * @cfg {String} selectedRowClass The CSS class applied to a selected row (defaults to "x-grid3-row-selected"). An + * example overriding the default styling: +

+    .x-grid3-row-selected {background-color: yellow;}
+    
+ * Note that this only controls the row, and will not do anything for the text inside it. To style inner + * facets (like text) use something like: +

+    .x-grid3-row-selected .x-grid3-cell-inner {
+        color: #FFCC00;
+    }
+    
+ * @type String + */ + selectedRowClass : "x-grid3-row-selected", + + // private + borderWidth : 2, + tdClass : 'x-grid3-cell', + hdCls : 'x-grid3-hd', + markDirty : true, + +
/** + * @cfg {Number} cellSelectorDepth The number of levels to search for cells in event delegation (defaults to 4) + */ + cellSelectorDepth : 4, +
/** + * @cfg {Number} rowSelectorDepth The number of levels to search for rows in event delegation (defaults to 10) + */ + rowSelectorDepth : 10, + +
/** + * @cfg {String} cellSelector The selector used to find cells internally (defaults to 'td.x-grid3-cell') + */ + cellSelector : 'td.x-grid3-cell', +
/** + * @cfg {String} rowSelector The selector used to find rows internally (defaults to 'div.x-grid3-row') + */ + rowSelector : 'div.x-grid3-row', + + // private + firstRowCls: 'x-grid3-row-first', + lastRowCls: 'x-grid3-row-last', + rowClsRe: /(?:^|\s+)x-grid3-row-(first|last|alt)(?:\s+|$)/g, + + /* -------------------------------- UI Specific ----------------------------- */ + + // private + initTemplates : function(){ + var ts = this.templates || {}; + if(!ts.master){ + ts.master = new Ext.Template( + '
', + '
', + '
{header}
', + '
{body}
', + '
', + '
 
', + '
 
', + '
' + ); + } + + if(!ts.header){ + ts.header = new Ext.Template( + '', + '{cells}', + '
' + ); + } + + if(!ts.hcell){ + ts.hcell = new Ext.Template( + '
', this.grid.enableHdMenu ? '' : '', + '{value}', + '
' + ); + } + + if(!ts.body){ + ts.body = new Ext.Template('{rows}'); + } + + if(!ts.row){ + ts.row = new Ext.Template( + '
', + '{cells}', + (this.enableRowBody ? '' : ''), + '
{body}
' + ); + } + + if(!ts.cell){ + ts.cell = new Ext.Template( + '', + '
{value}
', + '' + ); + } + + for(var k in ts){ + var t = ts[k]; + if(t && Ext.isFunction(t.compile) && !t.compiled){ + t.disableFormats = true; + t.compile(); + } + } + + this.templates = ts; + this.colRe = new RegExp("x-grid3-td-([^\\s]+)", ""); + }, + + // private + fly : function(el){ + if(!this._flyweight){ + this._flyweight = new Ext.Element.Flyweight(document.body); + } + this._flyweight.dom = el; + return this._flyweight; + }, + + // private + getEditorParent : function(){ + return this.scroller.dom; + }, + + // private + initElements : function(){ + var E = Ext.Element; + + var el = this.grid.getGridEl().dom.firstChild; + var cs = el.childNodes; + + this.el = new E(el); + + this.mainWrap = new E(cs[0]); + this.mainHd = new E(this.mainWrap.dom.firstChild); + + if(this.grid.hideHeaders){ + this.mainHd.setDisplayed(false); + } + + this.innerHd = this.mainHd.dom.firstChild; + this.scroller = new E(this.mainWrap.dom.childNodes[1]); + if(this.forceFit){ + this.scroller.setStyle('overflow-x', 'hidden'); + } +
/** + * Read-only. The GridView's body Element which encapsulates all rows in the Grid. + * This {@link Ext.Element Element} is only available after the GridPanel has been rendered. + * @type Ext.Element + * @property mainBody + */ + this.mainBody = new E(this.scroller.dom.firstChild); + + this.focusEl = new E(this.scroller.dom.childNodes[1]); + this.focusEl.swallowEvent("click", true); + + this.resizeMarker = new E(cs[1]); + this.resizeProxy = new E(cs[2]); + }, + + // private + getRows : function(){ + return this.hasRows() ? this.mainBody.dom.childNodes : []; + }, + + // finder methods, used with delegation + + // private + findCell : function(el){ + if(!el){ + return false; + } + return this.fly(el).findParent(this.cellSelector, this.cellSelectorDepth); + }, + +
/** + *

Return the index of the grid column which contains the passed HTMLElement.

+ * See also {@link #findRowIndex} + * @param {HTMLElement} el The target element + * @return The column index, or false if the target element is not within a row of this GridView. + */ + findCellIndex : function(el, requiredCls){ + var cell = this.findCell(el); + if(cell && (!requiredCls || this.fly(cell).hasClass(requiredCls))){ + return this.getCellIndex(cell); + } + return false; + }, + + // private + getCellIndex : function(el){ + if(el){ + var m = el.className.match(this.colRe); + if(m && m[1]){ + return this.cm.getIndexById(m[1]); + } + } + return false; + }, + + // private + findHeaderCell : function(el){ + var cell = this.findCell(el); + return cell && this.fly(cell).hasClass(this.hdCls) ? cell : null; + }, + + // private + findHeaderIndex : function(el){ + return this.findCellIndex(el, this.hdCls); + }, + +
/** + * Return the HtmlElement representing the grid row which contains the passed element. + * @param {HTMLElement} el The target HTMLElement + * @return The row element, or null if the target element is not within a row of this GridView. + */ + findRow : function(el){ + if(!el){ + return false; + } + return this.fly(el).findParent(this.rowSelector, this.rowSelectorDepth); + }, + +
/** + *

Return the index of the grid row which contains the passed HTMLElement.

+ * See also {@link #findCellIndex} + * @param {HTMLElement} el The target HTMLElement + * @return The row index, or false if the target element is not within a row of this GridView. + */ + findRowIndex : function(el){ + var r = this.findRow(el); + return r ? r.rowIndex : false; + }, + + // getter methods for fetching elements dynamically in the grid + +
/** + * Return the <div> HtmlElement which represents a Grid row for the specified index. + * @param {Number} index The row index + * @return {HtmlElement} The div element. + */ + getRow : function(row){ + return this.getRows()[row]; + }, + +
/** + * Returns the grid's <td> HtmlElement at the specified coordinates. + * @param {Number} row The row index in which to find the cell. + * @param {Number} col The column index of the cell. + * @return {HtmlElement} The td at the specified coordinates. + */ + getCell : function(row, col){ + return this.getRow(row).getElementsByTagName('td')[col]; + }, + +
/** + * Return the <td> HtmlElement which represents the Grid's header cell for the specified column index. + * @param {Number} index The column index + * @return {HtmlElement} The td element. + */ + getHeaderCell : function(index){ + return this.mainHd.dom.getElementsByTagName('td')[index]; + }, + + // manipulating elements + + // private - use getRowClass to apply custom row classes + addRowClass : function(row, cls){ + var r = this.getRow(row); + if(r){ + this.fly(r).addClass(cls); + } + }, + + // private + removeRowClass : function(row, cls){ + var r = this.getRow(row); + if(r){ + this.fly(r).removeClass(cls); + } + }, + + // private + removeRow : function(row){ + Ext.removeNode(this.getRow(row)); + this.syncFocusEl(row); + }, + + // private + removeRows : function(firstRow, lastRow){ + var bd = this.mainBody.dom; + for(var rowIndex = firstRow; rowIndex <= lastRow; rowIndex++){ + Ext.removeNode(bd.childNodes[firstRow]); + } + this.syncFocusEl(firstRow); + }, + + // scrolling stuff + + // private + getScrollState : function(){ + var sb = this.scroller.dom; + return {left: sb.scrollLeft, top: sb.scrollTop}; + }, + + // private + restoreScroll : function(state){ + var sb = this.scroller.dom; + sb.scrollLeft = state.left; + sb.scrollTop = state.top; + }, + +
/** + * Scrolls the grid to the top + */ + scrollToTop : function(){ + this.scroller.dom.scrollTop = 0; + this.scroller.dom.scrollLeft = 0; + }, + + // private + syncScroll : function(){ + this.syncHeaderScroll(); + var mb = this.scroller.dom; + this.grid.fireEvent("bodyscroll", mb.scrollLeft, mb.scrollTop); + }, + + // private + syncHeaderScroll : function(){ + var mb = this.scroller.dom; + this.innerHd.scrollLeft = mb.scrollLeft; + this.innerHd.scrollLeft = mb.scrollLeft; // second time for IE (1/2 time first fails, other browsers ignore) + }, + + // private + updateSortIcon : function(col, dir){ + var sc = this.sortClasses; + var hds = this.mainHd.select('td').removeClass(sc); + hds.item(col).addClass(sc[dir == "DESC" ? 1 : 0]); + }, + + // private + updateAllColumnWidths : function(){ + var tw = this.getTotalWidth(), + clen = this.cm.getColumnCount(), + ws = [], + len, + i; + for(i = 0; i < clen; i++){ + ws[i] = this.getColumnWidth(i); + } + this.innerHd.firstChild.style.width = this.getOffsetWidth(); + this.innerHd.firstChild.firstChild.style.width = tw; + this.mainBody.dom.style.width = tw; + for(i = 0; i < clen; i++){ + var hd = this.getHeaderCell(i); + hd.style.width = ws[i]; + } + + var ns = this.getRows(), row, trow; + for(i = 0, len = ns.length; i < len; i++){ + row = ns[i]; + row.style.width = tw; + if(row.firstChild){ + row.firstChild.style.width = tw; + trow = row.firstChild.rows[0]; + for (var j = 0; j < clen; j++) { + trow.childNodes[j].style.width = ws[j]; + } + } + } + + this.onAllColumnWidthsUpdated(ws, tw); + }, + + // private + updateColumnWidth : function(col, width){ + var w = this.getColumnWidth(col); + var tw = this.getTotalWidth(); + this.innerHd.firstChild.style.width = this.getOffsetWidth(); + this.innerHd.firstChild.firstChild.style.width = tw; + this.mainBody.dom.style.width = tw; + var hd = this.getHeaderCell(col); + hd.style.width = w; + + var ns = this.getRows(), row; + for(var i = 0, len = ns.length; i < len; i++){ + row = ns[i]; + row.style.width = tw; + if(row.firstChild){ + row.firstChild.style.width = tw; + row.firstChild.rows[0].childNodes[col].style.width = w; + } + } + + this.onColumnWidthUpdated(col, w, tw); + }, + + // private + updateColumnHidden : function(col, hidden){ + var tw = this.getTotalWidth(); + this.innerHd.firstChild.style.width = this.getOffsetWidth(); + this.innerHd.firstChild.firstChild.style.width = tw; + this.mainBody.dom.style.width = tw; + var display = hidden ? 'none' : ''; + + var hd = this.getHeaderCell(col); + hd.style.display = display; + + var ns = this.getRows(), row; + for(var i = 0, len = ns.length; i < len; i++){ + row = ns[i]; + row.style.width = tw; + if(row.firstChild){ + row.firstChild.style.width = tw; + row.firstChild.rows[0].childNodes[col].style.display = display; + } + } + + this.onColumnHiddenUpdated(col, hidden, tw); + delete this.lastViewWidth; // force recalc + this.layout(); + }, + + // private + doRender : function(cs, rs, ds, startRow, colCount, stripe){ + var ts = this.templates, ct = ts.cell, rt = ts.row, last = colCount-1; + var tstyle = 'width:'+this.getTotalWidth()+';'; + // buffers + var buf = [], cb, c, p = {}, rp = {tstyle: tstyle}, r; + for(var j = 0, len = rs.length; j < len; j++){ + r = rs[j]; cb = []; + var rowIndex = (j+startRow); + for(var i = 0; i < colCount; i++){ + c = cs[i]; + p.id = c.id; + p.css = i === 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : ''); + p.attr = p.cellAttr = ""; + p.value = c.renderer(r.data[c.name], p, r, rowIndex, i, ds); + p.style = c.style; + if(Ext.isEmpty(p.value)){ + p.value = " "; + } + if(this.markDirty && r.dirty && Ext.isDefined(r.modified[c.name])){ + p.css += ' x-grid3-dirty-cell'; + } + cb[cb.length] = ct.apply(p); + } + var alt = []; + if(stripe && ((rowIndex+1) % 2 === 0)){ + alt[0] = "x-grid3-row-alt"; + } + if(r.dirty){ + alt[1] = " x-grid3-dirty-row"; + } + rp.cols = colCount; + if(this.getRowClass){ + alt[2] = this.getRowClass(r, rowIndex, rp, ds); + } + rp.alt = alt.join(" "); + rp.cells = cb.join(""); + buf[buf.length] = rt.apply(rp); + } + return buf.join(""); + }, + + // private + processRows : function(startRow, skipStripe){ + if(!this.ds || this.ds.getCount() < 1){ + return; + } + var rows = this.getRows(); + skipStripe = skipStripe || !this.grid.stripeRows; + startRow = startRow || 0; + Ext.each(rows, function(row, idx){ + row.rowIndex = idx; + row.className = row.className.replace(this.rowClsRe, ' '); + if (!skipStripe && (idx + 1) % 2 === 0) { + row.className += ' x-grid3-row-alt'; + } + }); + // add first/last-row classes + if(startRow === 0){ + Ext.fly(rows[0]).addClass(this.firstRowCls); + } + Ext.fly(rows[rows.length - 1]).addClass(this.lastRowCls); + }, + + afterRender : function(){ + if(!this.ds || !this.cm){ + return; + } + this.mainBody.dom.innerHTML = this.renderRows() || ' '; + this.processRows(0, true); + + if(this.deferEmptyText !== true){ + this.applyEmptyText(); + } + }, + + // private + renderUI : function(){ + + var header = this.renderHeaders(); + var body = this.templates.body.apply({rows:' '}); + + + var html = this.templates.master.apply({ + body: body, + header: header, + ostyle: 'width:'+this.getOffsetWidth()+';', + bstyle: 'width:'+this.getTotalWidth()+';' + }); + + var g = this.grid; + + g.getGridEl().dom.innerHTML = html; + + this.initElements(); + + // get mousedowns early + Ext.fly(this.innerHd).on("click", this.handleHdDown, this); + this.mainHd.on({ + scope: this, + mouseover: this.handleHdOver, + mouseout: this.handleHdOut, + mousemove: this.handleHdMove + }); + + this.scroller.on('scroll', this.syncScroll, this); + if(g.enableColumnResize !== false){ + this.splitZone = new Ext.grid.GridView.SplitDragZone(g, this.mainHd.dom); + } + + if(g.enableColumnMove){ + this.columnDrag = new Ext.grid.GridView.ColumnDragZone(g, this.innerHd); + this.columnDrop = new Ext.grid.HeaderDropZone(g, this.mainHd.dom); + } + + if(g.enableHdMenu !== false){ + this.hmenu = new Ext.menu.Menu({id: g.id + "-hctx"}); + this.hmenu.add( + {itemId:"asc", text: this.sortAscText, cls: "xg-hmenu-sort-asc"}, + {itemId:"desc", text: this.sortDescText, cls: "xg-hmenu-sort-desc"} + ); + if(g.enableColumnHide !== false){ + this.colMenu = new Ext.menu.Menu({id:g.id + "-hcols-menu"}); + this.colMenu.on({ + scope: this, + beforeshow: this.beforeColMenuShow, + itemclick: this.handleHdMenuClick + }); + this.hmenu.add('-', { + itemId:"columns", + hideOnClick: false, + text: this.columnsText, + menu: this.colMenu, + iconCls: 'x-cols-icon' + }); + } + this.hmenu.on("itemclick", this.handleHdMenuClick, this); + } + + if(g.trackMouseOver){ + this.mainBody.on({ + scope: this, + mouseover: this.onRowOver, + mouseout: this.onRowOut + }); + } + + if(g.enableDragDrop || g.enableDrag){ + this.dragZone = new Ext.grid.GridDragZone(g, { + ddGroup : g.ddGroup || 'GridDD' + }); + } + + this.updateHeaderSortState(); + + }, + + // private + layout : function(){ + if(!this.mainBody){ + return; // not rendered + } + var g = this.grid; + var c = g.getGridEl(); + var csize = c.getSize(true); + var vw = csize.width; + + if(!g.hideHeaders && (vw < 20 || csize.height < 20)){ // display: none? + return; + } + + if(g.autoHeight){ + this.scroller.dom.style.overflow = 'visible'; + if(Ext.isWebKit){ + this.scroller.dom.style.position = 'static'; + } + }else{ + this.el.setSize(csize.width, csize.height); + + var hdHeight = this.mainHd.getHeight(); + var vh = csize.height - (hdHeight); + + this.scroller.setSize(vw, vh); + if(this.innerHd){ + this.innerHd.style.width = (vw)+'px'; + } + } + if(this.forceFit){ + if(this.lastViewWidth != vw){ + this.fitColumns(false, false); + this.lastViewWidth = vw; + } + }else { + this.autoExpand(); + this.syncHeaderScroll(); + } + this.onLayout(vw, vh); + }, + + // template functions for subclasses and plugins + // these functions include precalculated values + onLayout : function(vw, vh){ + // do nothing + }, + + onColumnWidthUpdated : function(col, w, tw){ + //template method + }, + + onAllColumnWidthsUpdated : function(ws, tw){ + //template method + }, + + onColumnHiddenUpdated : function(col, hidden, tw){ + // template method + }, + + updateColumnText : function(col, text){ + // template method + }, + + afterMove : function(colIndex){ + // template method + }, + + /* ----------------------------------- Core Specific -------------------------------------------*/ + // private + init : function(grid){ + this.grid = grid; + + this.initTemplates(); + this.initData(grid.store, grid.colModel); + this.initUI(grid); + }, + + // private + getColumnId : function(index){ + return this.cm.getColumnId(index); + }, + + // private + getOffsetWidth : function() { + return (this.cm.getTotalWidth() + this.scrollOffset) + 'px'; + }, + + // private + renderHeaders : function(){ + var cm = this.cm, + ts = this.templates, + ct = ts.hcell, + cb = [], + p = {}, + len = cm.getColumnCount(), + last = len - 1; + + for(var i = 0; i < len; i++){ + p.id = cm.getColumnId(i); + p.value = cm.getColumnHeader(i) || ""; + p.style = this.getColumnStyle(i, true); + p.tooltip = this.getColumnTooltip(i); + p.css = i === 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : ''); + if(cm.config[i].align == 'right'){ + p.istyle = 'padding-right:16px'; + } else { + delete p.istyle; + } + cb[cb.length] = ct.apply(p); + } + return ts.header.apply({cells: cb.join(""), tstyle:'width:'+this.getTotalWidth()+';'}); + }, + + // private + getColumnTooltip : function(i){ + var tt = this.cm.getColumnTooltip(i); + if(tt){ + if(Ext.QuickTips.isEnabled()){ + return 'ext:qtip="'+tt+'"'; + }else{ + return 'title="'+tt+'"'; + } + } + return ""; + }, + + // private + beforeUpdate : function(){ + this.grid.stopEditing(true); + }, + + // private + updateHeaders : function(){ + this.innerHd.firstChild.innerHTML = this.renderHeaders(); + this.innerHd.firstChild.style.width = this.getOffsetWidth(); + this.innerHd.firstChild.firstChild.style.width = this.getTotalWidth(); + }, + +
/** + * Focuses the specified row. + * @param {Number} row The row index + */ + focusRow : function(row){ + this.focusCell(row, 0, false); + }, + +
/** + * Focuses the specified cell. + * @param {Number} row The row index + * @param {Number} col The column index + */ + focusCell : function(row, col, hscroll){ + this.syncFocusEl(this.ensureVisible(row, col, hscroll)); + if(Ext.isGecko){ + this.focusEl.focus(); + }else{ + this.focusEl.focus.defer(1, this.focusEl); + } + }, + + resolveCell : function(row, col, hscroll){ + if(!Ext.isNumber(row)){ + row = row.rowIndex; + } + if(!this.ds){ + return null; + } + if(row < 0 || row >= this.ds.getCount()){ + return null; + } + col = (col !== undefined ? col : 0); + + var rowEl = this.getRow(row), + cm = this.cm, + colCount = cm.getColumnCount(), + cellEl; + if(!(hscroll === false && col === 0)){ + while(col < colCount && cm.isHidden(col)){ + col++; + } + cellEl = this.getCell(row, col); + } + + return {row: rowEl, cell: cellEl}; + }, + + getResolvedXY : function(resolved){ + if(!resolved){ + return null; + } + var s = this.scroller.dom, c = resolved.cell, r = resolved.row; + return c ? Ext.fly(c).getXY() : [this.el.getX(), Ext.fly(r).getY()]; + }, + + syncFocusEl : function(row, col, hscroll){ + var xy = row; + if(!Ext.isArray(xy)){ + row = Math.min(row, Math.max(0, this.getRows().length-1)); + xy = this.getResolvedXY(this.resolveCell(row, col, hscroll)); + } + this.focusEl.setXY(xy||this.scroller.getXY()); + }, + + ensureVisible : function(row, col, hscroll){ + var resolved = this.resolveCell(row, col, hscroll); + if(!resolved || !resolved.row){ + return; + } + + var rowEl = resolved.row, + cellEl = resolved.cell, + c = this.scroller.dom, + ctop = 0, + p = rowEl, + stop = this.el.dom; + + while(p && p != stop){ + ctop += p.offsetTop; + p = p.offsetParent; + } + ctop -= this.mainHd.dom.offsetHeight; + + var cbot = ctop + rowEl.offsetHeight, + ch = c.clientHeight, + sbot = stop + ch; + + stop = parseInt(c.scrollTop, 10); + + + if(ctop < stop){ + c.scrollTop = ctop; + }else if(cbot > sbot){ + c.scrollTop = cbot-ch; + } + + if(hscroll !== false){ + var cleft = parseInt(cellEl.offsetLeft, 10); + var cright = cleft + cellEl.offsetWidth; + + var sleft = parseInt(c.scrollLeft, 10); + var sright = sleft + c.clientWidth; + if(cleft < sleft){ + c.scrollLeft = cleft; + }else if(cright > sright){ + c.scrollLeft = cright-c.clientWidth; + } + } + return this.getResolvedXY(resolved); + }, + + // private + insertRows : function(dm, firstRow, lastRow, isUpdate){ + var last = dm.getCount() - 1; + if(!isUpdate && firstRow === 0 && lastRow >= last){ + this.refresh(); + }else{ + if(!isUpdate){ + this.fireEvent("beforerowsinserted", this, firstRow, lastRow); + } + var html = this.renderRows(firstRow, lastRow), + before = this.getRow(firstRow); + if(before){ + if(firstRow === 0){ + Ext.fly(this.getRow(0)).removeClass(this.firstRowCls); + } + Ext.DomHelper.insertHtml('beforeBegin', before, html); + }else{ + var r = this.getRow(last - 1); + if(r){ + Ext.fly(r).removeClass(this.lastRowCls); + } + Ext.DomHelper.insertHtml('beforeEnd', this.mainBody.dom, html); + } + if(!isUpdate){ + this.fireEvent("rowsinserted", this, firstRow, lastRow); + this.processRows(firstRow); + }else if(firstRow === 0 || firstRow >= last){ + //ensure first/last row is kept after an update. + Ext.fly(this.getRow(firstRow)).addClass(firstRow === 0 ? this.firstRowCls : this.lastRowCls); + } + } + this.syncFocusEl(firstRow); + }, + + // private + deleteRows : function(dm, firstRow, lastRow){ + if(dm.getRowCount()<1){ + this.refresh(); + }else{ + this.fireEvent("beforerowsdeleted", this, firstRow, lastRow); + + this.removeRows(firstRow, lastRow); + + this.processRows(firstRow); + this.fireEvent("rowsdeleted", this, firstRow, lastRow); + } + }, + + // private + getColumnStyle : function(col, isHeader){ + var style = !isHeader ? (this.cm.config[col].css || '') : ''; + style += 'width:'+this.getColumnWidth(col)+';'; + if(this.cm.isHidden(col)){ + style += 'display:none;'; + } + var align = this.cm.config[col].align; + if(align){ + style += 'text-align:'+align+';'; + } + return style; + }, + + // private + getColumnWidth : function(col){ + var w = this.cm.getColumnWidth(col); + if(Ext.isNumber(w)){ + return (Ext.isBorderBox ? w : (w-this.borderWidth > 0 ? w-this.borderWidth:0)) + 'px'; + } + return w; + }, + + // private + getTotalWidth : function(){ + return this.cm.getTotalWidth()+'px'; + }, + + // private + fitColumns : function(preventRefresh, onlyExpand, omitColumn){ + var cm = this.cm, i; + var tw = cm.getTotalWidth(false); + var aw = this.grid.getGridEl().getWidth(true)-this.scrollOffset; + + if(aw < 20){ // not initialized, so don't screw up the default widths + return; + } + var extra = aw - tw; + + if(extra === 0){ + return false; + } + + var vc = cm.getColumnCount(true); + var ac = vc-(Ext.isNumber(omitColumn) ? 1 : 0); + if(ac === 0){ + ac = 1; + omitColumn = undefined; + } + var colCount = cm.getColumnCount(); + var cols = []; + var extraCol = 0; + var width = 0; + var w; + for (i = 0; i < colCount; i++){ + if(!cm.isHidden(i) && !cm.isFixed(i) && i !== omitColumn){ + w = cm.getColumnWidth(i); + cols.push(i); + extraCol = i; + cols.push(w); + width += w; + } + } + var frac = (aw - cm.getTotalWidth())/width; + while (cols.length){ + w = cols.pop(); + i = cols.pop(); + cm.setColumnWidth(i, Math.max(this.grid.minColumnWidth, Math.floor(w + w*frac)), true); + } + + if((tw = cm.getTotalWidth(false)) > aw){ + var adjustCol = ac != vc ? omitColumn : extraCol; + cm.setColumnWidth(adjustCol, Math.max(1, + cm.getColumnWidth(adjustCol)- (tw-aw)), true); + } + + if(preventRefresh !== true){ + this.updateAllColumnWidths(); + } + + + return true; + }, + + // private + autoExpand : function(preventUpdate){ + var g = this.grid, cm = this.cm; + if(!this.userResized && g.autoExpandColumn){ + var tw = cm.getTotalWidth(false); + var aw = this.grid.getGridEl().getWidth(true)-this.scrollOffset; + if(tw != aw){ + var ci = cm.getIndexById(g.autoExpandColumn); + var currentWidth = cm.getColumnWidth(ci); + var cw = Math.min(Math.max(((aw-tw)+currentWidth), g.autoExpandMin), g.autoExpandMax); + if(cw != currentWidth){ + cm.setColumnWidth(ci, cw, true); + if(preventUpdate !== true){ + this.updateColumnWidth(ci, cw); + } + } + } + } + }, + + // private + getColumnData : function(){ + // build a map for all the columns + var cs = [], cm = this.cm, colCount = cm.getColumnCount(); + for(var i = 0; i < colCount; i++){ + var name = cm.getDataIndex(i); + cs[i] = { + name : (!Ext.isDefined(name) ? this.ds.fields.get(i).name : name), + renderer : cm.getRenderer(i), + id : cm.getColumnId(i), + style : this.getColumnStyle(i) + }; + } + return cs; + }, + + // private + renderRows : function(startRow, endRow){ + // pull in all the crap needed to render rows + var g = this.grid, cm = g.colModel, ds = g.store, stripe = g.stripeRows; + var colCount = cm.getColumnCount(); + + if(ds.getCount() < 1){ + return ""; + } + + var cs = this.getColumnData(); + + startRow = startRow || 0; + endRow = !Ext.isDefined(endRow) ? ds.getCount()-1 : endRow; + + // records to render + var rs = ds.getRange(startRow, endRow); + + return this.doRender(cs, rs, ds, startRow, colCount, stripe); + }, + + // private + renderBody : function(){ + var markup = this.renderRows() || ' '; + return this.templates.body.apply({rows: markup}); + }, + + // private + refreshRow : function(record){ + var ds = this.ds, index; + if(Ext.isNumber(record)){ + index = record; + record = ds.getAt(index); + if(!record){ + return; + } + }else{ + index = ds.indexOf(record); + if(index < 0){ + return; + } + } + this.insertRows(ds, index, index, true); + this.getRow(index).rowIndex = index; + this.onRemove(ds, record, index+1, true); + this.fireEvent("rowupdated", this, index, record); + }, + +
/** + * Refreshs the grid UI + * @param {Boolean} headersToo (optional) True to also refresh the headers + */ + refresh : function(headersToo){ + this.fireEvent("beforerefresh", this); + this.grid.stopEditing(true); + + var result = this.renderBody(); + this.mainBody.update(result).setWidth(this.getTotalWidth()); + if(headersToo === true){ + this.updateHeaders(); + this.updateHeaderSortState(); + } + this.processRows(0, true); + this.layout(); + this.applyEmptyText(); + this.fireEvent("refresh", this); + }, + + // private + applyEmptyText : function(){ + if(this.emptyText && !this.hasRows()){ + this.mainBody.update('
' + this.emptyText + '
'); + } + }, + + // private + updateHeaderSortState : function(){ + var state = this.ds.getSortState(); + if(!state){ + return; + } + if(!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)){ + this.grid.fireEvent('sortchange', this.grid, state); + } + this.sortState = state; + var sortColumn = this.cm.findColumnIndex(state.field); + if(sortColumn != -1){ + var sortDir = state.direction; + this.updateSortIcon(sortColumn, sortDir); + } + }, + + // private + destroy : function(){ + if(this.colMenu){ + Ext.menu.MenuMgr.unregister(this.colMenu); + this.colMenu.destroy(); + delete this.colMenu; + } + if(this.hmenu){ + Ext.menu.MenuMgr.unregister(this.hmenu); + this.hmenu.destroy(); + delete this.hmenu; + } + if(this.grid.enableColumnMove){ + var dds = Ext.dd.DDM.ids['gridHeader' + this.grid.getGridEl().id]; + if(dds){ + for(var dd in dds){ + if(!dds[dd].config.isTarget && dds[dd].dragElId){ + var elid = dds[dd].dragElId; + dds[dd].unreg(); + Ext.get(elid).remove(); + } else if(dds[dd].config.isTarget){ + dds[dd].proxyTop.remove(); + dds[dd].proxyBottom.remove(); + dds[dd].unreg(); + } + if(Ext.dd.DDM.locationCache[dd]){ + delete Ext.dd.DDM.locationCache[dd]; + } + } + delete Ext.dd.DDM.ids['gridHeader' + this.grid.getGridEl().id]; + } + } + + if(this.dragZone){ + this.dragZone.unreg(); + } + + Ext.fly(this.innerHd).removeAllListeners(); + Ext.removeNode(this.innerHd); + + Ext.destroy(this.resizeMarker, this.resizeProxy, this.focusEl, this.mainBody, + this.scroller, this.mainHd, this.mainWrap, this.dragZone, + this.splitZone, this.columnDrag, this.columnDrop); + + this.initData(null, null); + Ext.EventManager.removeResizeListener(this.onWindowResize, this); + this.purgeListeners(); + }, + + // private + onDenyColumnHide : function(){ + + }, + + // private + render : function(){ + if(this.autoFill){ + var ct = this.grid.ownerCt; + if (ct && ct.getLayout()){ + ct.on('afterlayout', function(){ + this.fitColumns(true, true); + this.updateHeaders(); + }, this, {single: true}); + }else{ + this.fitColumns(true, true); + } + }else if(this.forceFit){ + this.fitColumns(true, false); + }else if(this.grid.autoExpandColumn){ + this.autoExpand(true); + } + + this.renderUI(); + }, + + /* --------------------------------- Model Events and Handlers --------------------------------*/ + // private + initData : function(ds, cm){ + if(this.ds){ + this.ds.un("load", this.onLoad, this); + this.ds.un("datachanged", this.onDataChange, this); + this.ds.un("add", this.onAdd, this); + this.ds.un("remove", this.onRemove, this); + this.ds.un("update", this.onUpdate, this); + this.ds.un("clear", this.onClear, this); + if(this.ds !== ds && this.ds.autoDestroy){ + this.ds.destroy(); + } + } + if(ds){ + ds.on({ + scope: this, + load: this.onLoad, + datachanged: this.onDataChange, + add: this.onAdd, + remove: this.onRemove, + update: this.onUpdate, + clear: this.onClear + }); + } + this.ds = ds; + + if(this.cm){ + this.cm.un("configchange", this.onColConfigChange, this); + this.cm.un("widthchange", this.onColWidthChange, this); + this.cm.un("headerchange", this.onHeaderChange, this); + this.cm.un("hiddenchange", this.onHiddenChange, this); + this.cm.un("columnmoved", this.onColumnMove, this); + } + if(cm){ + delete this.lastViewWidth; + cm.on({ + scope: this, + configchange: this.onColConfigChange, + widthchange: this.onColWidthChange, + headerchange: this.onHeaderChange, + hiddenchange: this.onHiddenChange, + columnmoved: this.onColumnMove + }); + } + this.cm = cm; + }, + + // private + onDataChange : function(){ + this.refresh(); + this.updateHeaderSortState(); + this.syncFocusEl(0); + }, + + // private + onClear : function(){ + this.refresh(); + this.syncFocusEl(0); + }, + + // private + onUpdate : function(ds, record){ + this.refreshRow(record); + }, + + // private + onAdd : function(ds, records, index){ + this.insertRows(ds, index, index + (records.length-1)); + }, + + // private + onRemove : function(ds, record, index, isUpdate){ + if(isUpdate !== true){ + this.fireEvent("beforerowremoved", this, index, record); + } + this.removeRow(index); + if(isUpdate !== true){ + this.processRows(index); + this.applyEmptyText(); + this.fireEvent("rowremoved", this, index, record); + } + }, + + // private + onLoad : function(){ + this.scrollToTop(); + }, + + // private + onColWidthChange : function(cm, col, width){ + this.updateColumnWidth(col, width); + }, + + // private + onHeaderChange : function(cm, col, text){ + this.updateHeaders(); + }, + + // private + onHiddenChange : function(cm, col, hidden){ + this.updateColumnHidden(col, hidden); + }, + + // private + onColumnMove : function(cm, oldIndex, newIndex){ + this.indexMap = null; + var s = this.getScrollState(); + this.refresh(true); + this.restoreScroll(s); + this.afterMove(newIndex); + this.grid.fireEvent('columnmove', oldIndex, newIndex); + }, + + // private + onColConfigChange : function(){ + delete this.lastViewWidth; + this.indexMap = null; + this.refresh(true); + }, + + /* -------------------- UI Events and Handlers ------------------------------ */ + // private + initUI : function(grid){ + grid.on("headerclick", this.onHeaderClick, this); + }, + + // private + initEvents : function(){ + }, + + // private + onHeaderClick : function(g, index){ + if(this.headersDisabled || !this.cm.isSortable(index)){ + return; + } + g.stopEditing(true); + g.store.sort(this.cm.getDataIndex(index)); + }, + + // private + onRowOver : function(e, t){ + var row; + if((row = this.findRowIndex(t)) !== false){ + this.addRowClass(row, "x-grid3-row-over"); + } + }, + + // private + onRowOut : function(e, t){ + var row; + if((row = this.findRowIndex(t)) !== false && !e.within(this.getRow(row), true)){ + this.removeRowClass(row, "x-grid3-row-over"); + } + }, + + // private + handleWheel : function(e){ + e.stopPropagation(); + }, + + // private + onRowSelect : function(row){ + this.addRowClass(row, this.selectedRowClass); + }, + + // private + onRowDeselect : function(row){ + this.removeRowClass(row, this.selectedRowClass); + }, + + // private + onCellSelect : function(row, col){ + var cell = this.getCell(row, col); + if(cell){ + this.fly(cell).addClass("x-grid3-cell-selected"); + } + }, + + // private + onCellDeselect : function(row, col){ + var cell = this.getCell(row, col); + if(cell){ + this.fly(cell).removeClass("x-grid3-cell-selected"); + } + }, + + // private + onColumnSplitterMoved : function(i, w){ + this.userResized = true; + var cm = this.grid.colModel; + cm.setColumnWidth(i, w, true); + + if(this.forceFit){ + this.fitColumns(true, false, i); + this.updateAllColumnWidths(); + }else{ + this.updateColumnWidth(i, w); + this.syncHeaderScroll(); + } + + this.grid.fireEvent("columnresize", i, w); + }, + + // private + handleHdMenuClick : function(item){ + var index = this.hdCtxIndex; + var cm = this.cm, ds = this.ds; + switch(item.itemId){ + case "asc": + ds.sort(cm.getDataIndex(index), "ASC"); + break; + case "desc": + ds.sort(cm.getDataIndex(index), "DESC"); + break; + default: + index = cm.getIndexById(item.itemId.substr(4)); + if(index != -1){ + if(item.checked && cm.getColumnsBy(this.isHideableColumn, this).length <= 1){ + this.onDenyColumnHide(); + return false; + } + cm.setHidden(index, item.checked); + } + } + return true; + }, + + // private + isHideableColumn : function(c){ + return !c.hidden && !c.fixed; + }, + + // private + beforeColMenuShow : function(){ + var cm = this.cm, colCount = cm.getColumnCount(); + this.colMenu.removeAll(); + for(var i = 0; i < colCount; i++){ + if(cm.config[i].fixed !== true && cm.config[i].hideable !== false){ + this.colMenu.add(new Ext.menu.CheckItem({ + itemId: "col-"+cm.getColumnId(i), + text: cm.getColumnHeader(i), + checked: !cm.isHidden(i), + hideOnClick:false, + disabled: cm.config[i].hideable === false + })); + } + } + }, + + // private + handleHdDown : function(e, t){ + if(Ext.fly(t).hasClass('x-grid3-hd-btn')){ + e.stopEvent(); + var hd = this.findHeaderCell(t); + Ext.fly(hd).addClass('x-grid3-hd-menu-open'); + var index = this.getCellIndex(hd); + this.hdCtxIndex = index; + var ms = this.hmenu.items, cm = this.cm; + ms.get("asc").setDisabled(!cm.isSortable(index)); + ms.get("desc").setDisabled(!cm.isSortable(index)); + this.hmenu.on("hide", function(){ + Ext.fly(hd).removeClass('x-grid3-hd-menu-open'); + }, this, {single:true}); + this.hmenu.show(t, "tl-bl?"); + } + }, + + // private + handleHdOver : function(e, t){ + var hd = this.findHeaderCell(t); + if(hd && !this.headersDisabled){ + this.activeHd = hd; + this.activeHdIndex = this.getCellIndex(hd); + var fly = this.fly(hd); + this.activeHdRegion = fly.getRegion(); + if(!this.cm.isMenuDisabled(this.activeHdIndex)){ + fly.addClass("x-grid3-hd-over"); + this.activeHdBtn = fly.child('.x-grid3-hd-btn'); + if(this.activeHdBtn){ + this.activeHdBtn.dom.style.height = (hd.firstChild.offsetHeight-1)+'px'; + } + } + } + }, + + // private + handleHdMove : function(e, t){ + if(this.activeHd && !this.headersDisabled){ + var hw = this.splitHandleWidth || 5; + var r = this.activeHdRegion; + var x = e.getPageX(); + var ss = this.activeHd.style; + if(x - r.left <= hw && this.cm.isResizable(this.activeHdIndex-1)){ + ss.cursor = Ext.isAir ? 'move' : Ext.isWebKit ? 'e-resize' : 'col-resize'; // col-resize not always supported + }else if(r.right - x <= (!this.activeHdBtn ? hw : 2) && this.cm.isResizable(this.activeHdIndex)){ + ss.cursor = Ext.isAir ? 'move' : Ext.isWebKit ? 'w-resize' : 'col-resize'; + }else{ + ss.cursor = ''; + } + } + }, + + // private + handleHdOut : function(e, t){ + var hd = this.findHeaderCell(t); + if(hd && (!Ext.isIE || !e.within(hd, true))){ + this.activeHd = null; + this.fly(hd).removeClass("x-grid3-hd-over"); + hd.style.cursor = ''; + } + }, + + // private + hasRows : function(){ + var fc = this.mainBody.dom.firstChild; + return fc && fc.nodeType == 1 && fc.className != 'x-grid-empty'; + }, + + // back compat + bind : function(d, c){ + this.initData(d, c); + } +}); + + +// private +// This is a support class used internally by the Grid components +Ext.grid.GridView.SplitDragZone = function(grid, hd){ + this.grid = grid; + this.view = grid.getView(); + this.marker = this.view.resizeMarker; + this.proxy = this.view.resizeProxy; + Ext.grid.GridView.SplitDragZone.superclass.constructor.call(this, hd, + "gridSplitters" + this.grid.getGridEl().id, { + dragElId : Ext.id(this.proxy.dom), resizeFrame:false + }); + this.scroll = false; + this.hw = this.view.splitHandleWidth || 5; +}; +Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, { + + b4StartDrag : function(x, y){ + this.view.headersDisabled = true; + var h = this.view.mainWrap.getHeight(); + this.marker.setHeight(h); + this.marker.show(); + this.marker.alignTo(this.view.getHeaderCell(this.cellIndex), 'tl-tl', [-2, 0]); + this.proxy.setHeight(h); + var w = this.cm.getColumnWidth(this.cellIndex); + var minw = Math.max(w-this.grid.minColumnWidth, 0); + this.resetConstraints(); + this.setXConstraint(minw, 1000); + this.setYConstraint(0, 0); + this.minX = x - minw; + this.maxX = x + 1000; + this.startPos = x; + Ext.dd.DDProxy.prototype.b4StartDrag.call(this, x, y); + }, + + + handleMouseDown : function(e){ + var t = this.view.findHeaderCell(e.getTarget()); + if(t){ + var xy = this.view.fly(t).getXY(), x = xy[0], y = xy[1]; + var exy = e.getXY(), ex = exy[0]; + var w = t.offsetWidth, adjust = false; + if((ex - x) <= this.hw){ + adjust = -1; + }else if((x+w) - ex <= this.hw){ + adjust = 0; + } + if(adjust !== false){ + this.cm = this.grid.colModel; + var ci = this.view.getCellIndex(t); + if(adjust == -1){ + if (ci + adjust < 0) { + return; + } + while(this.cm.isHidden(ci+adjust)){ + --adjust; + if(ci+adjust < 0){ + return; + } + } + } + this.cellIndex = ci+adjust; + this.split = t.dom; + if(this.cm.isResizable(this.cellIndex) && !this.cm.isFixed(this.cellIndex)){ + Ext.grid.GridView.SplitDragZone.superclass.handleMouseDown.apply(this, arguments); + } + }else if(this.view.columnDrag){ + this.view.columnDrag.callHandleMouseDown(e); + } + } + }, + + endDrag : function(e){ + this.marker.hide(); + var v = this.view; + var endX = Math.max(this.minX, e.getPageX()); + var diff = endX - this.startPos; + v.onColumnSplitterMoved(this.cellIndex, this.cm.getColumnWidth(this.cellIndex)+diff); + setTimeout(function(){ + v.headersDisabled = false; + }, 50); + }, + + autoOffset : function(){ + this.setDelta(0,0); + } +}); +
+ + \ No newline at end of file