Subversion Repositories Applications.papyrus

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;
        }
});

}