DefaultDataModel.js
/**
* @class YAHOO.ext.grid.DefaultDataModel
* This is the default implementation of a DataModel used by the Grid. It works
* with multi-dimensional array based data. Using the event system in the base class
* {@link YAHOO.ext.grid.AbstractDataModel}, all updates to this DataModel are automatically
* reflected in the user interface.
* <br>Usage:<br>
* <pre><code>
* var myData = [
["MSFT","Microsoft Corporation", "314,571.156", "32,187.000", "55000"],
["ORCL", "Oracle Corporation", "62,615.266", "9,519.000", "40650"]
* ];
* var dataModel = new YAHOO.ext.grid.DefaultDataModel(myData);
* </code></pre>
* @extends YAHOO.ext.grid.AbstractDataModel
* @constructor
* @param {Array} data
*/
YAHOO.ext.grid.DefaultDataModel = function(data){
YAHOO.ext.grid.DefaultDataModel.superclass.constructor.call(this);
/**@private*/
this.data = data;
};
YAHOO.extendX(YAHOO.ext.grid.DefaultDataModel, YAHOO.ext.grid.AbstractDataModel, {
/**
* Returns the number of rows in the dataset
* @return {Number}
*/
getRowCount : function(){
return this.data.length;
},
/**
* Returns the ID of the specified row. By default it return the value of the first column.
* Override to provide more advanced ID handling.
* @return {Number}
*/
getRowId : function(rowIndex){
return this.data[rowIndex][0];
},
/**
* Returns the column data for the specified row.
* @return {Array}
*/
getRow : function(rowIndex){
return this.data[rowIndex];
},
/**
* Returns the column data for the specified rows as a
* multi-dimensional array: rows[3][0] would give you the value of row 4, column 0.
* @param {Array} indexes The row indexes to fetch
* @return {Array}
*/
getRows : function(indexes){
var data = this.data;
var r = [];
for(var i = 0; i < indexes.length; i++){
r.push(data[indexes[i]]);
}
return r;
},
/**
* Returns the value at the specified data position
* @param {Number} rowIndex
* @param {Number} colIndex
* @return {Object}
*/
getValueAt : function(rowIndex, colIndex){
return this.data[rowIndex][colIndex];
},
/**
* Sets the specified value at the specified data position
* @param {Object} value The new value
* @param {Number} rowIndex
* @param {Number} colIndex
*/
setValueAt: function(value, rowIndex, colIndex){
this.data[rowIndex][colIndex] = value;
this.fireCellUpdated(rowIndex, colIndex);
},
/**
* @private
* Removes the specified range of rows.
* @param {Number} startIndex
* @param {<i>Number</i>} endIndex (optional) Defaults to startIndex
*/
removeRows: function(startIndex, endIndex){
endIndex = endIndex || startIndex;
this.data.splice(startIndex, endIndex-startIndex+1);
this.fireRowsDeleted(startIndex, endIndex);
},
/**
* Remove a row.
* @param {Number} index
*/
removeRow: function(index){
this.data.splice(index, 1);
this.fireRowsDeleted(index, index);
},
/**
* @private
* Removes all rows.
*/
removeAll: function(){
var count = this.getRowCount();
if(count > 0){
this.removeRows(0, count-1);
}
},
/**
* Query the DataModel rows by the filters defined in spec, for example...
* <pre><code>
* // column 1 starts with Jack, column 2 filtered by myFcn, column 3 equals 'Fred'
* dataModel.filter({1: /^Jack.+/i}, 2: myFcn, 3: 'Fred'});
* </code></pre>
* @param {Object} spec The spec is generally an object literal consisting of
* column index and filter type. The filter type can be a string/number (exact match),
* a regular expression to test using String.search() or a function to call. If it's a function,
* it will be called with the value for the specified column and an array of the all column
* values for that row: yourFcn(value, columnData). If it returns anything other than true,
* the row is not a match. If you have modified Object.prototype this method may fail.
* @param {Boolean} returnUnmatched True to return rows which <b>don't</b> match the query instead
* of rows that do match
* @return {Array} An array of row indexes that match
*/
query: function(spec, returnUnmatched){
var d = this.data;
var r = [];
for(var i = 0; i < d.length; i++){
var row = d[i];
var isMatch = true;
for(var col in spec){
//if(typeof spec[col] != 'function'){
if(!isMatch) continue;
var filter = spec[col];
switch(typeof filter){
case 'string':
case 'number':
case 'boolean':
if(row[col] != filter){
isMatch = false;
}
break;
case 'function':
if(!filter(row[col], row)){
isMatch = false;
}
break;
case 'object':
if(filter instanceof RegExp){
if(String(row[col]).search(filter) === -1){
isMatch = false;
}
}
break;
}
//}
}
if(isMatch && !returnUnmatched){
r.push(i);
}else if(!isMatch && returnUnmatched){
r.push(i);
}
}
return r;
},
/**
* Filter the DataModel rows by the query defined in spec, see {@link #query} for more details
* on the query spec.
* @param {Object} query The query spec {@link #query}
* @return {Number} The number of rows removed
*/
filter: function(query){
var matches = this.query(query, true);
var data = this.data;
// go thru the data setting matches to deleted
// while not disturbing row indexes
for(var i = 0; i < matches.length; i++){
data[matches[i]]._deleted = true;
}
for(var i = 0; i < data.length; i++){
while(data[i] && data[i]._deleted === true){
this.removeRow(i);
}
}
return matches.length;
},
/**
* Adds a row to the dataset.
* @param {Array} cellValues The array of values for the new row
* @return {Number} The index of the added row
*/
addRow: function(cellValues){
this.data.push(cellValues);
var newIndex = this.data.length-1;
this.fireRowsInserted(newIndex, newIndex);
this.applySort();
return newIndex;
},
/**
* @private
* Adds a set of rows.
* @param {Array} rowData This should be an array of arrays like the constructor takes
*/
addRows: function(rowData){
this.data = this.data.concat(rowData);
var firstIndex = this.data.length-rowData.length;
this.fireRowsInserted(firstIndex, firstIndex+rowData.length-1);
this.applySort();
},
/**
* Inserts a row a the specified location in the dataset.
* @param {Number} index The index where the row should be inserted
* @param {Array} cellValues The array of values for the new row
* @return {Number} The index the row was inserted in
*/
insertRow: function(index, cellValues){
this.data.splice(index, 0, cellValues);
this.fireRowsInserted(index, index);
this.applySort();
return index;
},
/**
* @private
* Inserts a set of rows.
* @param {Number} index The index where the rows should be inserted
* @param {Array} rowData This should be an array of arrays like the constructor takes
*/
insertRows: function(index, rowData){
/*
if(index == this.data.length){ // try these two first since they are faster
this.data = this.data.concat(rowData);
}else if(index == 0){
this.data = rowData.concat(this.data);
}else{
var newData = this.data.slice(0, index);
newData.concat(rowData);
newData.concat(this.data.slice(index));
this.data = newData;
}*/
var args = rowData.concat();
args.splice(0, 0, index, 0);
this.data.splice.apply(this.data, args);
this.fireRowsInserted(index, index+rowData.length-1);
this.applySort();
},
/**
* Applies the last used sort to the current data.
*/
applySort: function(suppressEvent){
if(typeof this.sortColumn != 'undefined'){
this.sort(this.sortInfo, this.sortColumn, this.sortDir, suppressEvent);
}
},
/**
* Sets the default sort info. Note: this function does not actually apply the sort.
* @param {Function/Object} sortInfo A sort comparison function or null to use the default or A object that has a method getSortType(index) that returns a function like
* a grid column model.
* @param {Number} columnIndex The column index to sort by
* @param {String} direction The direction of the sort ('DESC' or 'ASC')
*/
setDefaultSort: function(sortInfo, columnIndex, direction){
this.sortInfo = sortInfo;
this.sortColumn = columnIndex;
this.sortDir = direction;
},
/**
* Sorts the data by the specified column - Uses the sortType specified for the column in the passed columnModel.
* @param {Function/Object} sortInfo A sort comparison function or null to use the default or A object that has a method getSortType(index) that returns a function like
* a grid column model.
* @param {Number} columnIndex The column index to sort by
* @param {String} direction The direction of the sort ('DESC' or 'ASC')
*/
sort: function(sortInfo, columnIndex, direction, suppressEvent){
// store these so we can maintain sorting when we load new data
this.sortInfo = sortInfo;
this.sortColumn = columnIndex;
this.sortDir = direction;
var dsc = (direction && direction.toUpperCase() == 'DESC');
var sortType = null;
if(sortInfo != null){
if(typeof sortInfo == 'function'){
sortType = sortInfo;
}else if(typeof sortInfo == 'object'){
sortType = sortInfo.getSortType(columnIndex);;
}
}
var fn = function(cells, cells2){
var v1 = sortType ? sortType(cells[columnIndex], cells) : cells[columnIndex];
var v2 = sortType ? sortType(cells2[columnIndex], cells2) : cells2[columnIndex];
if(v1 < v2)
return dsc ? +1 : -1;
if(v1 > v2)
return dsc ? -1 : +1;
return 0;
};
this.data.sort(fn);
if(!suppressEvent){
this.fireRowsSorted(columnIndex, direction);
}
},
/**
* Calls passed function with each rows data - if the function returns false it stops.
* @param {Function} fn
* @param {Object} scope (optional)
*/
each: function(fn, scope){
var d = this.data;
for(var i = 0, len = d.length; i < len; i++){
if(fn.call(scope || window, d[i], i) === false) break;
}
}
});
/**
* Alias to YAHOO.ext.grid.DefaultColumnModel.sortTypes
* @static
*/
if(YAHOO.ext.grid.DefaultColumnModel){
YAHOO.ext.grid.DefaultDataModel.sortTypes = YAHOO.ext.grid.DefaultColumnModel.sortTypes;
}
yui-ext - Copyright © 2006 Jack Slocum. |
Yahoo! UI - Copyright © 2006 Yahoo! Inc.
All rights reserved.