summaryrefslogtreecommitdiff
path: root/includes/js/dojox/grid/_data
diff options
context:
space:
mode:
authormensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>2008-11-13 09:49:11 +0000
committermensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>2008-11-13 09:49:11 +0000
commite44a7e37b6c7b5961adaffc62b9042b8d442938e (patch)
tree95b67c356e93163467db2451f2b8cce84ed5d582 /includes/js/dojox/grid/_data
parenta62b9742ee5e28bcec6872d88f50f25b820914f6 (diff)
downloadsemanticscuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.tar.gz
semanticscuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.tar.bz2
New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit
git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
Diffstat (limited to 'includes/js/dojox/grid/_data')
-rw-r--r--includes/js/dojox/grid/_data/dijitEditors.js170
-rw-r--r--includes/js/dojox/grid/_data/editors.js239
-rw-r--r--includes/js/dojox/grid/_data/fields.js104
-rw-r--r--includes/js/dojox/grid/_data/model.js762
4 files changed, 1275 insertions, 0 deletions
diff --git a/includes/js/dojox/grid/_data/dijitEditors.js b/includes/js/dojox/grid/_data/dijitEditors.js
new file mode 100644
index 0000000..695de44
--- /dev/null
+++ b/includes/js/dojox/grid/_data/dijitEditors.js
@@ -0,0 +1,170 @@
+if(!dojo._hasResource["dojox.grid._data.dijitEditors"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.grid._data.dijitEditors"] = true;
+dojo.provide("dojox.grid._data.dijitEditors");
+dojo.require("dojox.grid._data.editors");
+dojo.require("dijit.form.DateTextBox");
+dojo.require("dijit.form.TimeTextBox");
+dojo.require("dijit.form.ComboBox");
+dojo.require("dojo.data.ItemFileReadStore");
+dojo.require("dijit.form.CheckBox");
+dojo.require("dijit.form.TextBox");
+dojo.require("dijit.form.NumberSpinner");
+dojo.require("dijit.form.NumberTextBox");
+dojo.require("dijit.form.CurrencyTextBox");
+dojo.require("dijit.form.Slider");
+dojo.require("dijit.Editor");
+
+dojo.declare("dojox.grid.editors.Dijit", dojox.grid.editors.base, {
+ editorClass: "dijit.form.TextBox",
+ constructor: function(inCell){
+ this.editor = null;
+ this.editorClass = dojo.getObject(this.cell.editorClass || this.editorClass);
+ },
+ format: function(inDatum, inRowIndex){
+ this.needFormatNode(inDatum, inRowIndex);
+ return "<div></div>";
+ },
+ getValue: function(inRowIndex){
+ return this.editor.getValue();
+ },
+ setValue: function(inRowIndex, inValue){
+ if(this.editor&&this.editor.setValue){
+ this.editor.setValue(inValue);
+ }else{
+ this.inherited(arguments);
+ }
+ },
+ getEditorProps: function(inDatum){
+ return dojo.mixin({}, this.cell.editorProps||{}, {
+ constraints: dojo.mixin({}, this.cell.constraint) || {}, //TODO: really just for ValidationTextBoxes
+ value: inDatum
+ });
+ },
+ createEditor: function(inNode, inDatum, inRowIndex){
+ return new this.editorClass(this.getEditorProps(inDatum), inNode);
+
+ },
+ attachEditor: function(inNode, inDatum, inRowIndex){
+ inNode.appendChild(this.editor.domNode);
+ this.setValue(inRowIndex, inDatum);
+ },
+ formatNode: function(inNode, inDatum, inRowIndex){
+ if(!this.editorClass){
+ return inDatum;
+ }
+ if(!this.editor){
+ this.editor = this.createEditor.apply(this, arguments);
+ }else{
+ this.attachEditor.apply(this, arguments);
+ }
+ this.sizeEditor.apply(this, arguments);
+ this.cell.grid.rowHeightChanged(inRowIndex);
+ this.focus();
+ },
+ sizeEditor: function(inNode, inDatum, inRowIndex){
+ var
+ p = this.cell.getNode(inRowIndex),
+ box = dojo.contentBox(p);
+ dojo.marginBox(this.editor.domNode, {w: box.w});
+ },
+ focus: function(inRowIndex, inNode){
+ if(this.editor){
+ setTimeout(dojo.hitch(this.editor, function(){
+ dojox.grid.fire(this, "focus");
+ }), 0);
+ }
+ },
+ _finish: function(inRowIndex){
+ this.inherited(arguments);
+ dojox.grid.removeNode(this.editor.domNode);
+ }
+});
+
+dojo.declare("dojox.grid.editors.ComboBox", dojox.grid.editors.Dijit, {
+ editorClass: "dijit.form.ComboBox",
+ getEditorProps: function(inDatum){
+ var items=[];
+ dojo.forEach(this.cell.options, function(o){
+ items.push({name: o, value: o});
+ });
+ var store = new dojo.data.ItemFileReadStore({data: {identifier:"name", items: items}});
+ return dojo.mixin({}, this.cell.editorProps||{}, {
+ value: inDatum,
+ store: store
+ });
+ },
+ getValue: function(){
+ var e = this.editor;
+ // make sure to apply the displayed value
+ e.setDisplayedValue(e.getDisplayedValue());
+ return e.getValue();
+ }
+});
+
+dojo.declare("dojox.grid.editors.DateTextBox", dojox.grid.editors.Dijit, {
+ editorClass: "dijit.form.DateTextBox",
+ setValue: function(inRowIndex, inValue){
+ if(this.editor){
+ this.editor.setValue(new Date(inValue));
+ }else{
+ this.inherited(arguments);
+ }
+ },
+ getEditorProps: function(inDatum){
+ return dojo.mixin(this.inherited(arguments), {
+ value: new Date(inDatum)
+ });
+ }
+});
+
+
+dojo.declare("dojox.grid.editors.CheckBox", dojox.grid.editors.Dijit, {
+ editorClass: "dijit.form.CheckBox",
+ getValue: function(){
+ return this.editor.checked;
+ },
+ setValue: function(inRowIndex, inValue){
+ if(this.editor&&this.editor.setAttribute){
+ this.editor.setAttribute("checked", inValue);
+ }else{
+ this.inherited(arguments);
+ }
+ },
+ sizeEditor: function(inNode, inDatum, inRowIndex){
+ return;
+ }
+});
+
+
+dojo.declare("dojox.grid.editors.Editor", dojox.grid.editors.Dijit, {
+ editorClass: "dijit.Editor",
+ getEditorProps: function(inDatum){
+ return dojo.mixin({}, this.cell.editorProps||{}, {
+ height: this.cell.editorHeight || "100px"
+ });
+ },
+ createEditor: function(inNode, inDatum, inRowIndex){
+ // editor needs its value set after creation
+ var editor = new this.editorClass(this.getEditorProps(inDatum), inNode);
+ dojo.connect(editor, 'onLoad', dojo.hitch(this, 'populateEditor'));
+ return editor;
+ },
+ formatNode: function(inNode, inDatum, inRowIndex){
+ this.content = inDatum;
+ this.inherited(arguments);
+ if(dojo.isMoz){
+ // FIXME: seem to need to reopen the editor and display the toolbar
+ var e = this.editor;
+ e.open();
+ if(this.cell.editorToolbar){
+ dojo.place(e.toolbar.domNode, e.editingArea, "before");
+ }
+ }
+ },
+ populateEditor: function(){
+ this.editor.setValue(this.content);
+ this.editor.placeCursorAtEnd();
+ }
+});
+
+}
diff --git a/includes/js/dojox/grid/_data/editors.js b/includes/js/dojox/grid/_data/editors.js
new file mode 100644
index 0000000..48f76cc
--- /dev/null
+++ b/includes/js/dojox/grid/_data/editors.js
@@ -0,0 +1,239 @@
+if(!dojo._hasResource["dojox.grid._data.editors"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.grid._data.editors"] = true;
+dojo.provide("dojox.grid._data.editors");
+dojo.provide("dojox.grid.editors");
+
+dojo.declare("dojox.grid.editors.Base", null, {
+ // summary:
+ // base grid editor class. Other grid editors should inherited from this class.
+ constructor: function(inCell){
+ this.cell = inCell;
+ },
+ //private
+ _valueProp: "value",
+ _formatPending: false,
+ format: function(inDatum, inRowIndex){
+ // summary:
+ // formats the cell for editing
+ // inDatum: anything
+ // cell data to edit
+ // inRowIndex: int
+ // grid row index
+ // returns: string of html to place in grid cell
+ },
+ //protected
+ needFormatNode: function(inDatum, inRowIndex){
+ this._formatPending = true;
+ dojox.grid.whenIdle(this, "_formatNode", inDatum, inRowIndex);
+ },
+ cancelFormatNode: function(){
+ this._formatPending = false;
+ },
+ //private
+ _formatNode: function(inDatum, inRowIndex){
+ if(this._formatPending){
+ this._formatPending = false;
+ // make cell selectable
+ dojo.setSelectable(this.cell.grid.domNode, true);
+ this.formatNode(this.getNode(inRowIndex), inDatum, inRowIndex);
+ }
+ },
+ //protected
+ getNode: function(inRowIndex){
+ return (this.cell.getNode(inRowIndex) || 0).firstChild || 0;
+ },
+ formatNode: function(inNode, inDatum, inRowIndex){
+ // summary:
+ // format the editing dom node. Use when editor is a widget.
+ // inNode: dom node
+ // dom node for the editor
+ // inDatum: anything
+ // cell data to edit
+ // inRowIndex: int
+ // grid row index
+ if(dojo.isIE){
+ // IE sux bad
+ dojox.grid.whenIdle(this, "focus", inRowIndex, inNode);
+ }else{
+ this.focus(inRowIndex, inNode);
+ }
+ },
+ dispatchEvent: function(m, e){
+ if(m in this){
+ return this[m](e);
+ }
+ },
+ //public
+ getValue: function(inRowIndex){
+ // summary:
+ // returns value entered into editor
+ // inRowIndex: int
+ // grid row index
+ // returns:
+ // value of editor
+ return this.getNode(inRowIndex)[this._valueProp];
+ },
+ setValue: function(inRowIndex, inValue){
+ // summary:
+ // set the value of the grid editor
+ // inRowIndex: int
+ // grid row index
+ // inValue: anything
+ // value of editor
+ var n = this.getNode(inRowIndex);
+ if(n){
+ n[this._valueProp] = inValue
+ };
+ },
+ focus: function(inRowIndex, inNode){
+ // summary:
+ // focus the grid editor
+ // inRowIndex: int
+ // grid row index
+ // inNode: dom node
+ // editor node
+ dojox.grid.focusSelectNode(inNode || this.getNode(inRowIndex));
+ },
+ save: function(inRowIndex){
+ // summary:
+ // save editor state
+ // inRowIndex: int
+ // grid row index
+ this.value = this.value || this.getValue(inRowIndex);
+ //console.log("save", this.value, inCell.index, inRowIndex);
+ },
+ restore: function(inRowIndex){
+ // summary:
+ // restore editor state
+ // inRowIndex: int
+ // grid row index
+ this.setValue(inRowIndex, this.value);
+ //console.log("restore", this.value, inCell.index, inRowIndex);
+ },
+ //protected
+ _finish: function(inRowIndex){
+ // summary:
+ // called when editing is completed to clean up editor
+ // inRowIndex: int
+ // grid row index
+ dojo.setSelectable(this.cell.grid.domNode, false);
+ this.cancelFormatNode(this.cell);
+ },
+ //public
+ apply: function(inRowIndex){
+ // summary:
+ // apply edit from cell editor
+ // inRowIndex: int
+ // grid row index
+ this.cell.applyEdit(this.getValue(inRowIndex), inRowIndex);
+ this._finish(inRowIndex);
+ },
+ cancel: function(inRowIndex){
+ // summary:
+ // cancel cell edit
+ // inRowIndex: int
+ // grid row index
+ this.cell.cancelEdit(inRowIndex);
+ this._finish(inRowIndex);
+ }
+});
+dojox.grid.editors.base = dojox.grid.editors.Base; // back-compat
+
+dojo.declare("dojox.grid.editors.Input", dojox.grid.editors.Base, {
+ // summary
+ // grid cell editor that provides a standard text input box
+ constructor: function(inCell){
+ this.keyFilter = this.keyFilter || this.cell.keyFilter;
+ },
+ // keyFilter: object
+ // optional regex for disallowing keypresses
+ keyFilter: null,
+ format: function(inDatum, inRowIndex){
+ this.needFormatNode(inDatum, inRowIndex);
+ return '<input class="dojoxGrid-input" type="text" value="' + inDatum + '">';
+ },
+ formatNode: function(inNode, inDatum, inRowIndex){
+ this.inherited(arguments);
+ // FIXME: feels too specific for this interface
+ this.cell.registerOnBlur(inNode, inRowIndex);
+ },
+ doKey: function(e){
+ if(this.keyFilter){
+ var key = String.fromCharCode(e.charCode);
+ if(key.search(this.keyFilter) == -1){
+ dojo.stopEvent(e);
+ }
+ }
+ },
+ _finish: function(inRowIndex){
+ this.inherited(arguments);
+ var n = this.getNode(inRowIndex);
+ try{
+ dojox.grid.fire(n, "blur");
+ }catch(e){}
+ }
+});
+dojox.grid.editors.input = dojox.grid.editors.Input; // back compat
+
+dojo.declare("dojox.grid.editors.Select", dojox.grid.editors.Input, {
+ // summary:
+ // grid cell editor that provides a standard select
+ // options: text of each item
+ // values: value for each item
+ // returnIndex: editor returns only the index of the selected option and not the value
+ constructor: function(inCell){
+ this.options = this.options || this.cell.options;
+ this.values = this.values || this.cell.values || this.options;
+ },
+ format: function(inDatum, inRowIndex){
+ this.needFormatNode(inDatum, inRowIndex);
+ var h = [ '<select class="dojoxGrid-select">' ];
+ for (var i=0, o, v; ((o=this.options[i]) !== undefined)&&((v=this.values[i]) !== undefined); i++){
+ h.push("<option", (inDatum==v ? ' selected' : ''), ' value="' + v + '"', ">", o, "</option>");
+ }
+ h.push('</select>');
+ return h.join('');
+ },
+ getValue: function(inRowIndex){
+ var n = this.getNode(inRowIndex);
+ if(n){
+ var i = n.selectedIndex, o = n.options[i];
+ return this.cell.returnIndex ? i : o.value || o.innerHTML;
+ }
+ }
+});
+dojox.grid.editors.select = dojox.grid.editors.Select; // back compat
+
+dojo.declare("dojox.grid.editors.AlwaysOn", dojox.grid.editors.Input, {
+ // summary:
+ // grid cell editor that is always on, regardless of grid editing state
+ // alwaysOn: boolean
+ // flag to use editor to format grid cell regardless of editing state.
+ alwaysOn: true,
+ _formatNode: function(inDatum, inRowIndex){
+ this.formatNode(this.getNode(inRowIndex), inDatum, inRowIndex);
+ },
+ applyStaticValue: function(inRowIndex){
+ var e = this.cell.grid.edit;
+ e.applyCellEdit(this.getValue(inRowIndex), this.cell, inRowIndex);
+ e.start(this.cell, inRowIndex, true);
+ }
+});
+dojox.grid.editors.alwaysOn = dojox.grid.editors.AlwaysOn; // back-compat
+
+dojo.declare("dojox.grid.editors.Bool", dojox.grid.editors.AlwaysOn, {
+ // summary:
+ // grid cell editor that provides a standard checkbox that is always on
+ _valueProp: "checked",
+ format: function(inDatum, inRowIndex){
+ return '<input class="dojoxGrid-input" type="checkbox"' + (inDatum ? ' checked="checked"' : '') + ' style="width: auto" />';
+ },
+ doclick: function(e){
+ if(e.target.tagName == 'INPUT'){
+ this.applyStaticValue(e.rowIndex);
+ }
+ }
+});
+dojox.grid.editors.bool = dojox.grid.editors.Bool; // back-compat
+
+}
diff --git a/includes/js/dojox/grid/_data/fields.js b/includes/js/dojox/grid/_data/fields.js
new file mode 100644
index 0000000..230bede
--- /dev/null
+++ b/includes/js/dojox/grid/_data/fields.js
@@ -0,0 +1,104 @@
+if(!dojo._hasResource["dojox.grid._data.fields"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.grid._data.fields"] = true;
+dojo.provide("dojox.grid._data.fields");
+
+dojo.declare("dojox.grid.data.Mixer", null, {
+ // summary:
+ // basic collection class that provides a default value for items
+
+ constructor: function(){
+ this.defaultValue = {};
+ this.values = [];
+ },
+ count: function(){
+ return this.values.length;
+ },
+ clear: function(){
+ this.values = [];
+ },
+ build: function(inIndex){
+ var result = dojo.mixin({owner: this}, this.defaultValue);
+ result.key = inIndex;
+ this.values[inIndex] = result;
+ return result;
+ },
+ getDefault: function(){
+ return this.defaultValue;
+ },
+ setDefault: function(inField /*[, inField2, ... inFieldN] */){
+ for(var i=0, a; (a = arguments[i]); i++){
+ dojo.mixin(this.defaultValue, a);
+ }
+ },
+ get: function(inIndex){
+ return this.values[inIndex] || this.build(inIndex);
+ },
+ _set: function(inIndex, inField /*[, inField2, ... inFieldN] */){
+ // each field argument can be a single field object of an array of field objects
+ var v = this.get(inIndex);
+ for(var i=1; i<arguments.length; i++){
+ dojo.mixin(v, arguments[i]);
+ }
+ this.values[inIndex] = v;
+ },
+ set: function(/* inIndex, inField [, inField2, ... inFieldN] | inArray */){
+ if(arguments.length < 1){
+ return;
+ }
+ var a = arguments[0];
+ if(!dojo.isArray(a)){
+ this._set.apply(this, arguments);
+ }else{
+ if(a.length && a[0]["default"]){
+ this.setDefault(a.shift());
+ }
+ for(var i=0, l=a.length; i<l; i++){
+ this._set(i, a[i]);
+ }
+ }
+ },
+ insert: function(inIndex, inProps){
+ if (inIndex >= this.values.length){
+ this.values[inIndex] = inProps;
+ }else{
+ this.values.splice(inIndex, 0, inProps);
+ }
+ },
+ remove: function(inIndex){
+ this.values.splice(inIndex, 1);
+ },
+ swap: function(inIndexA, inIndexB){
+ dojox.grid.arraySwap(this.values, inIndexA, inIndexB);
+ },
+ move: function(inFromIndex, inToIndex){
+ dojox.grid.arrayMove(this.values, inFromIndex, inToIndex);
+ }
+});
+
+dojox.grid.data.compare = function(a, b){
+ return (a > b ? 1 : (a == b ? 0 : -1));
+}
+
+dojo.declare('dojox.grid.data.Field', null, {
+ constructor: function(inName){
+ this.name = inName;
+ this.compare = dojox.grid.data.compare;
+ },
+ na: dojox.grid.na
+});
+
+dojo.declare('dojox.grid.data.Fields', dojox.grid.data.Mixer, {
+ constructor: function(inFieldClass){
+ var fieldClass = inFieldClass ? inFieldClass : dojox.grid.data.Field;
+ this.defaultValue = new fieldClass();
+ },
+ indexOf: function(inKey){
+ for(var i=0; i<this.values.length; i++){
+ var v = this.values[i];
+ if(v && v.key == inKey){return i;}
+ }
+ return -1;
+ }
+});
+
+}
diff --git a/includes/js/dojox/grid/_data/model.js b/includes/js/dojox/grid/_data/model.js
new file mode 100644
index 0000000..c9bfcfa
--- /dev/null
+++ b/includes/js/dojox/grid/_data/model.js
@@ -0,0 +1,762 @@
+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;
+ },
+ 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);
+ }
+ },
+ 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];
+ }
+ }
+});
+
+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();
+ }
+ },
+ allChange: function(){
+ this.notify("FieldsChange");
+ this.inherited(arguments);
+ },
+ autoAssignFields: function(){
+ var d = this.data[0], i = 0, field;
+ for(var f in d){
+ field = this.fields.get(i++);
+ if (!dojo.isString(field.key)){
+ field.key = f;
+ }
+ }
+ },
+ setData: function(inData){
+ this.data = (inData || []);
+ this.autoAssignFields();
+ this.allChange();
+ },
+ 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.Dynamic;
+
+// 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 = {};
+ this._currentlyProcessing = [];
+ if(args){
+ dojo.mixin(this, args);
+ }
+ if(this.store){
+ var f = this.store.getFeatures();
+ this._canNotify = f['dojo.data.api.Notification'];
+ this._canWrite = f['dojo.data.api.Write'];
+ this._canIdentify = f['dojo.data.api.Identity'];
+ if(this._canNotify){
+ dojo.connect(this.store, "onSet", this, "_storeDatumChange");
+ dojo.connect(this.store, "onDelete", this, "_storeDatumDelete");
+ dojo.connect(this.store, "onNew", this, "_storeDatumNew");
+ }
+ if(this._canWrite) {
+ dojo.connect(this.store, "revert", this, "refresh");
+ }
+ }
+ },
+ markupFactory: function(args, node){
+ return new dojox.grid.data.DojoData(null, null, args);
+ },
+ query: { name: "*" }, // default, stupid query
+ store: null,
+ _currentlyProcessing: null,
+ _canNotify: false,
+ _canWrite: false,
+ _canIdentify: false,
+ _rowIdentities: {},
+ clientSort: false,
+ sortFields: null,
+ queryOptions: null,
+
+ // 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
+ },
+ _createRow: function(item){
+ var row = {};
+ row.__dojo_data_item = item;
+ dojo.forEach(this.fields.values, function(a){
+ value = this.store.getValue(item, a.name);
+ row[a.name] = (value === undefined || value === null)?"":value;
+ }, this);
+ return row;
+ },
+ processRows: function(items, request){
+ // console.debug(arguments);
+ if(!items || items.length == 0){ return; }
+ this._setupFields(items[0]);
+ dojo.forEach(items, function(item, idx){
+ var row = this._createRow(item);
+ this._setRowId(item, request.start, idx);
+ this.setRow(row, request.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,
+ sort: this.sortFields,
+ queryOptions: this.queryOptions,
+ onBegin: dojo.hitch(this, "beginReturn"),
+ onComplete: dojo.hitch(this, "processRows"), // add to deferred?
+ onError: dojo.hitch(this, "processError")
+ };
+ 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];
+ }
+ },
+ _setRowId: function(item, offset, idx){
+ // FIXME: where else do we need to keep this in sync?
+ //Handle stores that implement identity and try to handle those that do not.
+ if (this._canIdentify) {
+ this._rowIdentities[this.store.getIdentity(item)] = {rowId: offset+idx, item: item};
+ }else{
+ var identity = dojo.toJson(this.query) + ":start:" + offset + ":idx:" + idx + ":sort:" + dojo.toJson(this.sortFields);
+ this._rowIdentities[identity] = {rowId: offset+idx, item: item};
+ }
+ },
+ _getRowId: function(item, isNotItem){
+ // summary:
+ // Function determine the row index for a particular item
+ // item:
+ // The store item to examine to determine row index.
+ // isNotItem:
+ // Boolean flag to indicate if the item passed is a store item or not.
+ var rowId = null;
+ //Handle identity and nonidentity capable stores.
+ if(this._canIdentify && !isNotItem){
+ rowId = this._rowIdentities[this.store.getIdentity(item)].rowId;
+ }else{
+ //Not efficient, but without identity support,
+ //not a better way to do it. Basically, do our best to locate it
+ //This may or may not work, but best we can do here.
+ var id;
+ for(id in this._rowIdentities){
+ if(this._rowIdentities[id].item === item){
+ rowId = this._rowIdentities[id].rowId;
+ break;
+ }
+ }
+ }
+ return rowId;
+ },
+ _storeDatumChange: function(item, attr, oldVal, newVal){
+ // the store has changed some data under us, need to update the display
+ var rowId = this._getRowId(item);
+ var row = this.getRow(rowId);
+ if(row){
+ row[attr] = newVal;
+ var colId = this.fields._nameMaps[attr];
+ this.notify("DatumChange", [ newVal, rowId, colId ]);
+ }
+ },
+ _storeDatumDelete: function(item){
+ if(dojo.indexOf(this._currentlyProcessing, item) != -1)
+ return;
+ // the store has deleted some item under us, need to remove that item from
+ // the view if possible. It may be the deleted item isn't even in the grid.
+ var rowId = this._getRowId(item, true);
+ if(rowId != null){
+ this._removeItems([rowId]);
+ }
+ },
+ _storeDatumNew: function(item){
+ if(this._disableNew){
+ return;
+ }
+ // the store has added some item under us, need to add it to the view.
+ this._insertItem(item, this.data.length);
+ },
+ insert: function(item, index){
+ // Push the given item back to the store
+ this._disableNew = true;
+ var i = this.store.newItem(item);
+ this._disableNew = false;
+ this._insertItem(i, index);
+ },
+ _insertItem: function(storeItem, index){
+ // Set up our fields if we haven't already
+ if(!this.fields._nameMaps){
+ this._setupFields(storeItem);
+ }
+ var row = this._createRow(storeItem);
+ for(var i in this._rowIdentities){ //increment all the remaining row ids up one
+ var rowIdentity = this._rowIdentities[i];
+ if(rowIdentity.rowId >= index){
+ rowIdentity.rowId++;
+ }
+ }
+ this._setRowId(storeItem, 0, index);
+ dojox.grid.data.Dynamic.prototype.insert.apply(this, [row, index]);
+ },
+ 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);
+ },
+ remove: function(inRowIndexes){
+ // summary:
+ // Function to remove a set of items from the store based on the row index.
+ // inRowIndexes:
+ // An array of row indexes from the grid to remove from the store.
+ /* Call delete on the store */
+ for(var i=inRowIndexes.length-1; i>=0; i--){
+ // Need to find the item, then remove each from the data store
+ var item = this.data[inRowIndexes[i]].__dojo_data_item;
+ this._currentlyProcessing.push(item);
+ this.store.deleteItem(item);
+ }
+ /* Remove from internal data structure and the view */
+ this._removeItems(inRowIndexes);
+ this._currentlyProcessing = [];
+ },
+ _removeItems: function(inRowIndexes /*array*/){
+ // summary:
+ // Function to remove a set of items from the store based on the row index.
+ // inRowIndexes:
+ // An array of row indexes from the grid to remove from the store.
+ dojox.grid.data.Dynamic.prototype.remove.apply(this, arguments);
+ // Rebuild _rowIdentities
+ this._rowIdentities = {};
+ for (var i = 0; i < this.data.length; i++){
+ this._setRowId(this.data[i].__dojo_data_item, 0, i);
+ }
+ },
+ canSort: function(){
+ // Q: Return true and re-issue the queries?
+ // A: Return true only. Re-issue the query in 'sort'.
+ // Note, above are original comments :)
+ return true;
+ },
+ sort: function(colIndex){
+ var col = Math.abs(colIndex) - 1;
+ this.sortFields = [{'attribute': this.fields.values[col].name, 'descending': (colIndex>0)}];
+
+ // Since we're relying on the data store to sort, we have to refresh our data.
+ this.refresh();
+ },
+ refresh: function(){
+ // summary:
+ // Function to cause the model to re-query the store and rebuild the current viewport.
+ this.clearData(true);
+ this.requestRows();
+ },
+ clearData: function(/* boolean */ keepStore){
+ this._rowIdentities = {};
+ this.pages = [];
+ this.bop = this.eop = -1;
+ this.count = 0;
+ this.setData((keepStore?this.store:[]));
+ },
+ processError: function(error, request){
+ // summary:
+ // Hook function to trap error messages from the store and emit them.
+ // Intended for connecting to and handling the error object or at least reporting it.
+ //
+ // error:
+ // The error object returned by the store when a problem occurred.
+ // request:
+ // The request object that caused the error.
+ console.log(error);
+ }
+});
+
+}