/** * @private * * Manages and provides information about a TablePanel's *visible leaf* columns. */Ext.define('Ext.grid.ColumnManager', { alternateClassName: ['Ext.grid.ColumnModel'], columns: null, constructor: function(visibleOnly, headerCt, secondHeaderCt) { //<debug> if (!headerCt.isRootHeader && !headerCt.isGroupHeader) { Ext.raise('ColumnManager must be passed an instantiated HeaderContainer or group header'); } //</debug> this.headerCt = headerCt; // We are managing columns for a lockable grid... if (secondHeaderCt) { //<debug> if (!headerCt.isRootHeader && !headerCt.isGroupHeader) { Ext.raise('ColumnManager must be passed an instantiated HeaderContainer or group header'); } //</debug> this.secondHeaderCt = secondHeaderCt; } this.visibleOnly = !!visibleOnly; }, getColumns: function() { if (!this.columns) { this.cacheColumns(); } return this.columns; }, hasVariableRowHeight: function() { var me = this, columns = me.getColumns(), len = columns.length, i; if (me.variableRowHeight == null) { me.variableRowHeight = false; for (i = 0; !me.variableRowHeight && i < len; i++) { me.variableRowHeight = !!columns[i].variableRowHeight; } } return me.variableRowHeight; }, /** * If called from a root header, returns the index of a leaf level header regardless of what the nesting * structure is. * * If called from a group header, returns the index of a leaf level header relative to the group header. * * If a group header is passed, the index of the first leaf level header within it is returned. * * @param {Ext.grid.column.Column} header The header to find the index of * @return {Number} The index of the specified column header */ getHeaderIndex: function (header) { if (header.isGroupHeader) { // Get the first header for the particular group header. The .getHeaderColumns API // will sort out if it's to be just visible columns or all columns. header = this.getHeaderColumns(header)[0]; } return Ext.Array.indexOf(this.getColumns(), header); }, /** * If called from a root header, gets a leaf level header by index regardless of what the nesting * structure is. * * If called from a group header, returns the index of a leaf level header relative to the group header. * * @param {Number} index The column index for which to retrieve the column. * @return {Ext.grid.column.Column} The header. `null` if it doesn't exist. */ getHeaderAtIndex: function(index) { var columns = this.getColumns(), col = columns[index]; return col || null; }, getPreviousSibling: function(header){ var index = this.getHeaderIndex(header), col = null; if (index > 0) { col = this.getColumns()[index - 1]; } return col; }, getNextSibling: function(header) { var index = this.getHeaderIndex(header), col; if (index !== -1) { col = this.getColumns()[index + 1]; } return col || null; }, /** * Get the first column. * @return {Ext.grid.column.Column} The header. `null` if it doesn't exist */ getFirst: function() { var columns = this.getColumns(); return columns.length > 0 ? columns[0] : null; }, /** * Get the last column. * @return {Ext.grid.column.Column} The header. `null` if it doesn't exist */ getLast: function(){ var columns = this.getColumns(), len = columns.length; return len > 0 ? columns[len - 1] : null; }, /** * Get a leaf level header by data index regardless of what the nesting * structure is. * @param {String} dataIndex The data index * @return {Ext.grid.column.Column} The header. `null` if it doesn't exist. */ getHeaderByDataIndex: function (dataIndex) { var columns = this.getColumns(), len = columns.length, i, header; // don't match on ambiguous empty or null values (e.g., template columns) if (Ext.isEmpty(dataIndex)) { return null; } for (i = 0; i < len; ++i) { header = columns[i]; if (header.dataIndex === dataIndex) { return header; } } return null; }, /** * Get a leaf level header by index regardless of what the nesting * structure is. * @param {String} id The id * @return {Ext.grid.column.Column} The header. `null` if it doesn't exist. */ getHeaderById: function(id) { var columns = this.getColumns(), len = columns.length, i, header; for (i = 0; i < len; ++i) { header = columns[i]; if (header.getItemId() === id) { return header; } } return null; }, /** * When passed a column index, returns the closet *visible* column to that. If the column at the passed index is visible, * that is returned. If it is hidden, either the next visible, or the previous visible column is returned. * * If called from a group header, returns the visible index of a leaf level header relative to the group header with the * same stipulations as outlined above. * * @param {Number} index Position at which to find the closest visible column. */ getVisibleHeaderClosestToIndex: function(index) { var result = this.getHeaderAtIndex(index); if (result && result.hidden) { result = result.next(':not([hidden])') || result.prev(':not([hidden])'); } return result; }, cacheColumns: function() { var columns = this.getHeaderColumns(this.headerCt), second = this.secondHeaderCt; if (second) { columns = columns.concat(this.getHeaderColumns(second)); } this.columns = columns; }, getHeaderColumns: function(header) { var result = this.visibleOnly ? header.getVisibleGridColumns() : header.getGridColumns(); return Ext.Array.clone(result); }, invalidate: function() { var root = this.rootColumns; this.columns = this.variableRowHeight = null; // If we are part of a lockable assembly, invalidate the root column manager if (root) { root.invalidate(); } }, destroy: function(){ this.columns = this.rootColumns = null; this.callParent(); }}, function() { this.createAlias('indexOf', 'getHeaderIndex');});