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';
+ }
+},
+ 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:
+ *body : String bodyStyle : String tstyle : String
+ this.mainBody.update('<div class="x-grid-empty">' + this.emptyText + '</div>');
+ 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:
+ .x-grid3-row-selected {background-color: yellow;}
+
+ .x-grid3-row-selected .x-grid3-cell-inner {
+ color: #FFCC00;
+ }
+ {body} |
Return the index of the grid column which contains the passed element.
+ * See also {@link #findRowIndex} + * @param {Element} 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 {Element} el The target element + * @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 element.
+ * See also {@link #findCellIndex} + * @param {Element} el The target element + * @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 && typeof r.modified[c.name] !== 'undefined'){ + 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(typeof row != "number"){ + 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(typeof w == 'number'){ + 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-(typeof omitColumn == 'number' ? 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 : (typeof name == 'undefined' ? 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 = typeof endRow == "undefined"? 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(typeof record == 'number'){ + 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('