Page MenuHomeCode
Files F885565

model.js
No OneTemporary
Actions

model.js
View Options

if(!dojo._hasResource['dojox.grid._data.model']){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource['dojox.grid._data.model'] = true;
dojo.provide('dojox.grid._data.model');
dojo.require('dojox.grid._data.fields');
dojo.declare("dojox.grid.data.Model", null, {
// summary:
// Base abstract grid data model.
// Makes no assumptions about the structure of grid data.
constructor: function(inFields, inData){
this.observers = [];
this.fields = new dojox.grid.data.Fields();
if(inFields){
this.fields.set(inFields);
}
this.setData(inData);
},
count: 0,
updating: 0,
// observers
observer: function(inObserver, inPrefix){
this.observers.push({o: inObserver, p: inPrefix||'model' });
},
notObserver: function(inObserver){
for(var i=0, m, o; (o=this.observers[i]); i++){
if(o.o==inObserver){
this.observers.splice(i, 1);
return;
}
}
},
notify: function(inMsg, inArgs){
if(!this.isUpdating()){
var a = inArgs || [];
for(var i=0, m, o; (o=this.observers[i]); i++){
m = o.p + inMsg, o = o.o;
(m in o)&&(o[m].apply(o, a));
}
}
},
// updates
clear: function(){
this.fields.clear();
this.clearData();
},
beginUpdate: function(){
this.updating++;
},
endUpdate: function(){
if(this.updating){
this.updating--;
}
/*if(this.updating){
if(!(--this.updating)){
this.change();
}
}
}*/
},
isUpdating: function(){
return Boolean(this.updating);
},
// data
clearData: function(){
this.setData(null);
},
// observer events
change: function(){
this.notify("Change", arguments);
},
insertion: function(/* index */){
this.notify("Insertion", arguments);
this.notify("Change", arguments);
},
removal: function(/* keys */){
this.notify("Removal", arguments);
this.notify("Change", arguments);
},
// insert
insert: function(inData /*, index */){
if(!this._insert.apply(this, arguments)){
return false;
}
this.insertion.apply(this, dojo._toArray(arguments, 1));
return true;
},
// remove
remove: function(inData /*, index */){
if(!this._remove.apply(this, arguments)){
return false;
}
this.removal.apply(this, arguments);
return true;
},
// sort
canSort: function(/* (+|-)column_index+1, ... */){
return this.sort != null;
},
makeComparator: function(inIndices){
var idx, col, field, result = null;
for(var i=inIndices.length-1; i>=0; i--){
idx = inIndices[i];
col = Math.abs(idx) - 1;
if(col >= 0){
field = this.fields.get(col);
result = this.generateComparator(field.compare, field.key, idx > 0, result);
}
}
return result;
},
sort: null,
dummy: 0
});
dojo.declare("dojox.grid.data.Rows", dojox.grid.data.Model, {
// observer events
allChange: function(){
this.notify("AllChange", arguments);
this.notify("Change", arguments);
},
rowChange: function(){
this.notify("RowChange", arguments);
},
datumChange: function(){
this.notify("DatumChange", arguments);
},
// copyRow: function(inRowIndex); // abstract
// update
beginModifyRow: function(inRowIndex){
if(!this.cache[inRowIndex]){
this.cache[inRowIndex] = this.copyRow(inRowIndex);
}
},
endModifyRow: function(inRowIndex){
var cache = this.cache[inRowIndex];
if(cache){
var data = this.getRow(inRowIndex);
if(!dojox.grid.arrayCompare(cache, data)){
this.update(cache, data, inRowIndex);
}
delete this.cache[inRowIndex];
}
},
cancelModifyRow: function(inRowIndex){
var cache = this.cache[inRowIndex];
if(cache){
this.setRow(cache, inRowIndex);
delete this.cache[inRowIndex];
}
},
generateComparator: function(inCompare, inField, inTrueForAscend, inSubCompare){
return function(a, b){
var ineq = inCompare(a[inField], b[inField]);
return ineq ? (inTrueForAscend ? ineq : -ineq) : inSubCompare && inSubCompare(a, b);
}
}
});
dojo.declare("dojox.grid.data.Table", dojox.grid.data.Rows, {
// summary:
// Basic grid data model for static data in the form of an array of rows
// that are arrays of cell data
constructor: function(){
this.cache = [];
},
colCount: 0, // tables introduce cols
data: null,
cache: null,
// morphology
measure: function(){
this.count = this.getRowCount();
this.colCount = this.getColCount();
this.allChange();
//this.notify("Measure");
},
getRowCount: function(){
return (this.data ? this.data.length : 0);
},
getColCount: function(){
return (this.data && this.data.length ? this.data[0].length : this.fields.count());
},
badIndex: function(inCaller, inDescriptor){
console.debug('dojox.grid.data.Table: badIndex');
},
isGoodIndex: function(inRowIndex, inColIndex){
return (inRowIndex >= 0 && inRowIndex < this.count && (arguments.length < 2 || (inColIndex >= 0 && inColIndex < this.colCount)));
},
// access
getRow: function(inRowIndex){
return this.data[inRowIndex];
},
copyRow: function(inRowIndex){
return this.getRow(inRowIndex).slice(0);
},
getDatum: function(inRowIndex, inColIndex){
return this.data[inRowIndex][inColIndex];
},
get: function(){
throw('Plain "get" no longer supported. Use "getRow" or "getDatum".');
},
setData: function(inData){
this.data = (inData || []);
this.allChange();
},
setRow: function(inData, inRowIndex){
this.data[inRowIndex] = inData;
this.rowChange(inData, inRowIndex);
this.change();
},
setDatum: function(inDatum, inRowIndex, inColIndex){
this.data[inRowIndex][inColIndex] = inDatum;
this.datumChange(inDatum, inRowIndex, inColIndex);
},
set: function(){
throw('Plain "set" no longer supported. Use "setData", "setRow", or "setDatum".');
},
setRows: function(inData, inRowIndex){
for(var i=0, l=inData.length, r=inRowIndex; i<l; i++, r++){
this.setRow(inData[i], r);
}
},
// update
update: function(inOldData, inNewData, inRowIndex){
//delete this.cache[inRowIndex];
//this.setRow(inNewData, inRowIndex);
return true;
},
// insert
_insert: function(inData, inRowIndex){
dojox.grid.arrayInsert(this.data, inRowIndex, inData);
this.count++;
return true;
},
// remove
_remove: function(inKeys){
for(var i=inKeys.length-1; i>=0; i--){
dojox.grid.arrayRemove(this.data, inKeys[i]);
}
this.count -= inKeys.length;
return true;
},
// sort
sort: function(/* (+|-)column_index+1, ... */){
this.data.sort(this.makeComparator(arguments));
},
swap: function(inIndexA, inIndexB){
dojox.grid.arraySwap(this.data, inIndexA, inIndexB);
this.rowChange(this.getRow(inIndexA), inIndexA);
this.rowChange(this.getRow(inIndexB), inIndexB);
this.change();
},
dummy: 0
});
dojo.declare("dojox.grid.data.Objects", dojox.grid.data.Table, {
constructor: function(inFields, inData, inKey){
if(!inFields){
this.autoAssignFields();
}
},
autoAssignFields: function(){
var d = this.data[0], i = 0;
for(var f in d){
this.fields.get(i++).key = f;
}
},
getDatum: function(inRowIndex, inColIndex){
return this.data[inRowIndex][this.fields.get(inColIndex).key];
}
});
dojo.declare("dojox.grid.data.Dynamic", dojox.grid.data.Table, {
// summary:
// Grid data model for dynamic data such as data retrieved from a server.
// Retrieves data automatically when requested and provides notification when data is received
constructor: function(){
this.page = [];
this.pages = [];
},
page: null,
pages: null,
rowsPerPage: 100,
requests: 0,
bop: -1,
eop: -1,
// data
clearData: function(){
this.pages = [];
this.bop = this.eop = -1;
this.setData([]);
},
getRowCount: function(){
return this.count;
},
getColCount: function(){
return this.fields.count();
},
setRowCount: function(inCount){
this.count = inCount;
this.change();
},
// paging
requestsPending: function(inBoolean){
},
rowToPage: function(inRowIndex){
return (this.rowsPerPage ? Math.floor(inRowIndex / this.rowsPerPage) : inRowIndex);
},
pageToRow: function(inPageIndex){
return (this.rowsPerPage ? this.rowsPerPage * inPageIndex : inPageIndex);
},
requestRows: function(inRowIndex, inCount){
// summary:
// stub. Fill in to perform actual data row fetching logic. The
// returning logic must provide the data back to the system via
// setRow
},
rowsProvided: function(inRowIndex, inCount){
this.requests--;
if(this.requests == 0){
this.requestsPending(false);
}
},
requestPage: function(inPageIndex){
var row = this.pageToRow(inPageIndex);
var count = Math.min(this.rowsPerPage, this.count - row);
if(count > 0){
this.requests++;
this.requestsPending(true);
setTimeout(dojo.hitch(this, "requestRows", row, count), 1);
//this.requestRows(row, count);
}
},
needPage: function(inPageIndex){
if(!this.pages[inPageIndex]){
this.pages[inPageIndex] = true;
this.requestPage(inPageIndex);
}
},
preparePage: function(inRowIndex, inColIndex){
if(inRowIndex < this.bop || inRowIndex >= this.eop){
var pageIndex = this.rowToPage(inRowIndex);
this.needPage(pageIndex);
this.bop = pageIndex * this.rowsPerPage;
this.eop = this.bop + (this.rowsPerPage || this.count);
}
},
isRowLoaded: function(inRowIndex){
return Boolean(this.data[inRowIndex]);
},
// removal
removePages: function(inRowIndexes){
for(var i=0, r; ((r=inRowIndexes[i]) != undefined); i++){
this.pages[this.rowToPage(r)] = false;
}
this.bop = this.eop =-1;
},
remove: function(inRowIndexes){
this.removePages(inRowIndexes);
dojox.grid.data.Table.prototype.remove.apply(this, arguments);
},
// access
getRow: function(inRowIndex){
var row = this.data[inRowIndex];
if(!row){
this.preparePage(inRowIndex);
}
return row;
},
getDatum: function(inRowIndex, inColIndex){
var row = this.getRow(inRowIndex);
return (row ? row[inColIndex] : this.fields.get(inColIndex).na);
},
setDatum: function(inDatum, inRowIndex, inColIndex){
var row = this.getRow(inRowIndex);
if(row){
row[inColIndex] = inDatum;
this.datumChange(inDatum, inRowIndex, inColIndex);
}else{
console.debug('[' + this.declaredClass + '] dojox.grid.data.dynamic.set: cannot set data on an non-loaded row');
}
},
// sort
canSort: function(){
return false;
}
});
// FIXME: deprecated: (included for backward compatibility only)
dojox.grid.data.table = dojox.grid.data.Table;
dojox.grid.data.dynamic = dojox.grid.data.Dyanamic;
// we treat dojo.data stores as dynamic stores because no matter how they got
// here, they should always fill that contract
dojo.declare("dojox.grid.data.DojoData", dojox.grid.data.Dynamic, {
// summary:
// A grid data model for dynamic data retreived from a store which
// implements the dojo.data API set. Retrieves data automatically when
// requested and provides notification when data is received
// description:
// This store subclasses the Dynamic grid data object in order to
// provide paginated data access support, notification and view
// updates for stores which support those features, and simple
// field/column mapping for all dojo.data stores.
constructor: function(inFields, inData, args){
this.count = 1;
this._rowIdentities = {};
if(args){
dojo.mixin(this, args);
}
if(this.store){
// NOTE: we assume Read and Identity APIs for all stores!
var f = this.store.getFeatures();
this._canNotify = f['dojo.data.api.Notification'];
this._canWrite = f['dojo.data.api.Write'];
if(this._canNotify){
dojo.connect(this.store, "onSet", this, "_storeDatumChange");
}
}
},
markupFactory: function(args, node){
return new dojox.grid.data.DojoData(null, null, args);
},
query: { name: "*" }, // default, stupid query
store: null,
_canNotify: false,
_canWrite: false,
_rowIdentities: {},
clientSort: false,
// data
setData: function(inData){
this.store = inData;
this.data = [];
this.allChange();
},
setRowCount: function(inCount){
//console.debug("inCount:", inCount);
this.count = inCount;
this.allChange();
},
beginReturn: function(inCount){
if(this.count != inCount){
// this.setRowCount(0);
// this.clear();
// console.debug(this.count, inCount);
this.setRowCount(inCount);
}
},
_setupFields: function(dataItem){
// abort if we already have setup fields
if(this.fields._nameMaps){
return;
}
// set up field/index mappings
var m = {};
//console.debug("setting up fields", m);
var fields = dojo.map(this.store.getAttributes(dataItem),
function(item, idx){
m[item] = idx;
m[idx+".idx"] = item;
// name == display name, key = property name
return { name: item, key: item };
},
this
);
this.fields._nameMaps = m;
// console.debug("new fields:", fields);
this.fields.set(fields);
this.notify("FieldsChange");
},
_getRowFromItem: function(item){
// gets us the row object (and row index) of an item
},
processRows: function(items, store){
// console.debug(arguments);
if(!items){ return; }
this._setupFields(items[0]);
dojo.forEach(items, function(item, idx){
var row = {};
row.__dojo_data_item = item;
dojo.forEach(this.fields.values, function(a){
row[a.name] = this.store.getValue(item, a.name)||"";
}, this);
// FIXME: where else do we need to keep this in sync?
this._rowIdentities[this.store.getIdentity(item)] = store.start+idx;
this.setRow(row, store.start+idx);
}, this);
// FIXME:
// Q: scott, steve, how the hell do we actually get this to update
// the visible UI for these rows?
// A: the goal is that Grid automatically updates to reflect changes
// in model. In this case, setRow -> rowChanged -> (observed by) Grid -> modelRowChange -> updateRow
},
// request data
requestRows: function(inRowIndex, inCount){
var row = inRowIndex || 0;
var params = {
start: row,
count: this.rowsPerPage,
query: this.query,
onBegin: dojo.hitch(this, "beginReturn"),
// onItem: dojo.hitch(console, "debug"),
onComplete: dojo.hitch(this, "processRows") // add to deferred?
}
// console.debug("requestRows:", row, this.rowsPerPage);
this.store.fetch(params);
},
getDatum: function(inRowIndex, inColIndex){
//console.debug("getDatum", inRowIndex, inColIndex);
var row = this.getRow(inRowIndex);
var field = this.fields.values[inColIndex];
return row && field ? row[field.name] : field ? field.na : '?';
//var idx = row && this.fields._nameMaps[inColIndex+".idx"];
//return (row ? row[idx] : this.fields.get(inColIndex).na);
},
setDatum: function(inDatum, inRowIndex, inColIndex){
var n = this.fields._nameMaps[inColIndex+".idx"];
// console.debug("setDatum:", "n:"+n, inDatum, inRowIndex, inColIndex);
if(n){
this.data[inRowIndex][n] = inDatum;
this.datumChange(inDatum, inRowIndex, inColIndex);
}
},
// modification, update and store eventing
copyRow: function(inRowIndex){
var row = {};
var backstop = {};
var src = this.getRow(inRowIndex);
for(var x in src){
if(src[x] != backstop[x]){
row[x] = src[x];
}
}
return row;
},
_attrCompare: function(cache, data){
dojo.forEach(this.fields.values, function(a){
if(cache[a.name] != data[a.name]){ return false; }
}, this);
return true;
},
endModifyRow: function(inRowIndex){
var cache = this.cache[inRowIndex];
if(cache){
var data = this.getRow(inRowIndex);
if(!this._attrCompare(cache, data)){
this.update(cache, data, inRowIndex);
}
delete this.cache[inRowIndex];
}
},
cancelModifyRow: function(inRowIndex){
// console.debug("cancelModifyRow", arguments);
var cache = this.cache[inRowIndex];
if(cache){
this.setRow(cache, inRowIndex);
delete this.cache[inRowIndex];
}
},
_storeDatumChange: function(item, attr, oldVal, newVal){
// the store has changed some data under us, need to update the display
var rowId = this._rowIdentities[this.store.getIdentity(item)];
var row = this.getRow(rowId);
row[attr] = newVal;
var colId = this.fields._nameMaps[attr];
this.notify("DatumChange", [ newVal, rowId, colId ]);
},
datumChange: function(value, rowIdx, colIdx){
if(this._canWrite){
// we're chaning some data, which means we need to write back
var row = this.getRow(rowIdx);
var field = this.fields._nameMaps[colIdx+".idx"];
this.store.setValue(row.__dojo_data_item, field, value);
// we don't need to call DatumChange, an eventing store will tell
// us about the row change events
}else{
// we can't write back, so just go ahead and change our local copy
// of the data
this.notify("DatumChange", arguments);
}
},
insertion: function(/* index */){
console.debug("Insertion", arguments);
this.notify("Insertion", arguments);
this.notify("Change", arguments);
},
removal: function(/* keys */){
console.debug("Removal", arguments);
this.notify("Removal", arguments);
this.notify("Change", arguments);
},
// sort
canSort: function(){
// Q: Return true and re-issue the queries?
// A: Return true only. Re-issue the query in 'sort'.
return this.clientSort;
}
});
}

File Metadata

Mime Type
text/plain
Expires
Sun, Apr 6, 17:06 (2 w, 6 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
26823
Default Alt Text
model.js (16 KB)

Event Timeline