Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.grid.VirtualGrid"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.grid.VirtualGrid"] = true;
dojo.provide("dojox.grid.VirtualGrid");
dojo.require("dojox.grid._grid.lib");
dojo.require("dojox.grid._grid.scroller");
dojo.require("dojox.grid._grid.view");
dojo.require("dojox.grid._grid.views");
dojo.require("dojox.grid._grid.layout");
dojo.require("dojox.grid._grid.rows");
dojo.require("dojox.grid._grid.focus");
dojo.require("dojox.grid._grid.selection");
dojo.require("dojox.grid._grid.edit");
dojo.require("dojox.grid._grid.rowbar");
dojo.require("dojox.grid._grid.publicEvents");

dojo.declare('dojox.VirtualGrid', 
        [ dijit._Widget, dijit._Templated ], 
{
        // summary:
        //              A grid widget with virtual scrolling, cell editing, complex rows,
        //              sorting, fixed columns, sizeable columns, etc.
        //
        //      description:
        //              VirtualGrid provides the full set of grid features without any
        //              direct connection to a data store.
        //
        //              The grid exposes a get function for the grid, or optionally
        //              individual columns, to populate cell contents.
        //
        //              The grid is rendered based on its structure, an object describing
        //              column and cell layout.
        //
        //      example:
        //              A quick sample:
        //              
        //              define a get function
        //      |       function get(inRowIndex){ // called in cell context
        //      |               return [this.index, inRowIndex].join(', ');
        //      |       }
        //              
        //              define the grid structure:
        //      |       var structure = [ // array of view objects
        //      |               { cells: [// array of rows, a row is an array of cells
        //      |                       [
        //      |                               { name: "Alpha", width: 6 }, 
        //      |                               { name: "Beta" }, 
        //      |                               { name: "Gamma", get: get }]
        //      |               ]}
        //      |       ];
        //              
        //      |       <div id="grid" 
        //      |               rowCount="100" get="get" 
        //      |               structure="structure" 
        //      |               dojoType="dojox.VirtualGrid"></div>

        templateString: '<div class="dojoxGrid" hidefocus="hidefocus" role="wairole:grid"><div class="dojoxGrid-master-header" dojoAttachPoint="headerNode"></div><div class="dojoxGrid-master-view" dojoAttachPoint="viewsNode"></div><span dojoAttachPoint="lastFocusNode" tabindex="0"></span></div>',
        // classTag: string
        // css class applied to the grid's domNode
        classTag: 'dojoxGrid',
        get: function(inRowIndex){
                /* summary: Default data getter. 
                        description:
                                Provides data to display in a grid cell. Called in grid cell context.
                                So this.cell.index is the column index.
                        inRowIndex: integer
                                row for which to provide data
                        returns:
                                data to display for a given grid cell.
                */
        },
        // settings
        // rowCount: int
        //      Number of rows to display. 
        rowCount: 5,
        // keepRows: int
        //      Number of rows to keep in the rendering cache.
        keepRows: 75, 
        // rowsPerPage: int
        //      Number of rows to render at a time.
        rowsPerPage: 25,
        // autoWidth: boolean
        //      If autoWidth is true, grid width is automatically set to fit the data.
        autoWidth: false,
        // autoHeight: boolean
        //      If autoHeight is true, grid height is automatically set to fit the data.
        autoHeight: false,
        // autoRender: boolean
        //      If autoRender is true, grid will render itself after initialization.
        autoRender: true,
        // defaultHeight: string
        //      default height of the grid, measured in any valid css unit.
        defaultHeight: '15em',
        // structure: object or string
        //      View layout defintion. Can be set to a layout object, or to the (string) name of a layout object.
        structure: '',
        // elasticView: int
        //      Override defaults and make the indexed grid view elastic, thus filling available horizontal space.
        elasticView: -1,
        // singleClickEdit: boolean
        //      Single-click starts editing. Default is double-click
        singleClickEdit: false,
        // private
        sortInfo: 0,
        themeable: true,
        // initialization
        buildRendering: function(){
                this.inherited(arguments);
                // reset get from blank function (needed for markup parsing) to null, if not changed
                if(this.get == dojox.VirtualGrid.prototype.get){
                        this.get = null;
                }
                if(!this.domNode.getAttribute('tabIndex')){
                        this.domNode.tabIndex = "0";
                }
                this.createScroller();
                this.createLayout();
                this.createViews();
                this.createManagers();
                dojox.grid.initTextSizePoll();
                this.connect(dojox.grid, "textSizeChanged", "textSizeChanged");
                dojox.grid.funnelEvents(this.domNode, this, 'doKeyEvent', dojox.grid.keyEvents);
                this.connect(this, "onShow", "renderOnIdle");
        },
        postCreate: function(){
                // replace stock styleChanged with one that triggers an update
                this.styleChanged = this._styleChanged;
                this.setStructure(this.structure);
        },
        destroy: function(){
                this.domNode.onReveal = null;
                this.domNode.onSizeChange = null;
                this.edit.destroy();
                this.views.destroyViews();
                this.inherited(arguments);
        },
        styleChanged: function(){
                this.setStyledClass(this.domNode, '');
        },
        _styleChanged: function(){
                this.styleChanged();
                this.update();
        },
        textSizeChanged: function(){
                setTimeout(dojo.hitch(this, "_textSizeChanged"), 1);
        },
        _textSizeChanged: function(){
                if(this.domNode){
                        this.views.forEach(function(v){
                                v.content.update();
                        });
                        this.render();
                }
        },
        sizeChange: function(){
                dojox.grid.jobs.job(this.id + 'SizeChange', 50, dojo.hitch(this, "update"));
        },
        renderOnIdle: function() {
                setTimeout(dojo.hitch(this, "render"), 1);
        },
        // managers
        createManagers: function(){
                // summary:
                //      create grid managers for various tasks including rows, focus, selection, editing
                
                // row manager
                this.rows = new dojox.grid.rows(this);
                // focus manager
                this.focus = new dojox.grid.focus(this);
                // selection manager
                this.selection = new dojox.grid.selection(this);
                // edit manager
                this.edit = new dojox.grid.edit(this);
        },
        // virtual scroller
        createScroller: function(){
                this.scroller = new dojox.grid.scroller.columns();
                this.scroller.renderRow = dojo.hitch(this, "renderRow");
                this.scroller.removeRow = dojo.hitch(this, "rowRemoved");
        },
        // layout
        createLayout: function(){
                this.layout = new dojox.grid.layout(this);
        },
        // views
        createViews: function(){
                this.views = new dojox.grid.views(this);
                this.views.createView = dojo.hitch(this, "createView");
        },
        createView: function(inClass){
                var c = eval(inClass);
                var view = new c({ grid: this });
                this.viewsNode.appendChild(view.domNode);
                this.headerNode.appendChild(view.headerNode);
                this.views.addView(view);
                return view;
        },
        buildViews: function(){
                for(var i=0, vs; (vs=this.layout.structure[i]); i++){
                        this.createView(vs.type || "dojox.GridView").setStructure(vs);
                }
                this.scroller.setContentNodes(this.views.getContentNodes());
        },
        setStructure: function(inStructure){
                // summary:
                //              Install a new structure and rebuild the grid.
                // inStructure: Object
                //              Structure object defines the grid layout and provides various
                //              options for grid views and columns
                //      description:
                //              A grid structure is an array of view objects. A view object can
                //              specify a view type (view class), width, noscroll (boolean flag
                //              for view scrolling), and cells. Cells is an array of objects
                //              corresponding to each grid column. The view cells object is an
                //              array of subrows comprising a single row. Each subrow is an
                //              array of column objects. A column object can have a name,
                //              width, value (default), get function to provide data, styles,
                //              and span attributes (rowSpan, colSpan).

                this.views.destroyViews();
                this.structure = inStructure;
                if((this.structure)&&(dojo.isString(this.structure))){
                        this.structure=dojox.grid.getProp(this.structure);
                }
                if(!this.structure){
                        this.structure=window["layout"];
                }
                if(!this.structure){
                        return;
                }
                this.layout.setStructure(this.structure);
                this._structureChanged();
        },
        _structureChanged: function() {
                this.buildViews();
                if(this.autoRender){
                        this.render();
                }
        },
        // sizing
        resize: function(){
                // summary:
                //              Update the grid's rendering dimensions and resize it
                
                // FIXME: If grid is not sized explicitly, sometimes bogus scrollbars 
                // can appear in our container, which may require an extra call to 'resize'
                // to sort out.
                
                // if we have set up everything except the DOM, we cannot resize
                if(!this.domNode.parentNode){
                        return;
                }
                // useful measurement
                var padBorder = dojo._getPadBorderExtents(this.domNode);
                // grid height
                if(this.autoHeight){
                        this.domNode.style.height = 'auto';
                        this.viewsNode.style.height = '';
                }else if(this.flex > 0){
                }else if(this.domNode.clientHeight <= padBorder.h){
                        if(this.domNode.parentNode == document.body){
                                this.domNode.style.height = this.defaultHeight;
                        }else{
                                this.fitTo = "parent";
                        }
                }
                if(this.fitTo == "parent"){
                        var h = dojo._getContentBox(this.domNode.parentNode).h;
                        dojo.marginBox(this.domNode, { h: Math.max(0, h) });
                }
                // header height
                var t = this.views.measureHeader();
                this.headerNode.style.height = t + 'px';
                // content extent
                var l = 1, h = (this.autoHeight ? -1 : Math.max(this.domNode.clientHeight - t, 0) || 0);
                if(this.autoWidth){
                        // grid width set to total width
                        this.domNode.style.width = this.views.arrange(l, 0, 0, h) + 'px';
                }else{
                        // views fit to our clientWidth
                        var w = this.domNode.clientWidth || (this.domNode.offsetWidth - padBorder.w);
                        this.views.arrange(l, 0, w, h);
                }
                // virtual scroller height
                this.scroller.windowHeight = h; 
                // default row height (FIXME: use running average(?), remove magic #)
                this.scroller.defaultRowHeight = this.rows.getDefaultHeightPx() + 1;
                this.postresize();
        },
        resizeHeight: function(){
                var t = this.views.measureHeader();
                this.headerNode.style.height = t + 'px';
                // content extent
                var h = (this.autoHeight ? -1 : Math.max(this.domNode.clientHeight - t, 0) || 0);
                //this.views.arrange(0, 0, 0, h);
                this.views.onEach('setSize', [0, h]);
                this.views.onEach('resizeHeight');
                this.scroller.windowHeight = h; 
        },
        // render 
        render: function(){
                // summary:
                //      Render the grid, headers, and views. Edit and scrolling states are reset. To retain edit and 
                // scrolling states, see Update.

                if(!this.domNode){return;}
                //
                this.update = this.defaultUpdate;
                this.scroller.init(this.rowCount, this.keepRows, this.rowsPerPage);
                this.prerender();
                this.setScrollTop(0);
                this.postrender();
        },
        prerender: function(){
                this.views.render();
                this.resize();
        },
        postrender: function(){
                this.postresize();
                this.focus.initFocusView();
                // make rows unselectable
                dojo.setSelectable(this.domNode, false);
        },
        postresize: function(){
                // views are position absolute, so they do not inflate the parent
                if(this.autoHeight){
                        this.viewsNode.style.height = this.views.measureContent() + 'px';
                }
        },
        // private, used internally to render rows
        renderRow: function(inRowIndex, inNodes){
                this.views.renderRow(inRowIndex, inNodes);
        },
        // private, used internally to remove rows
        rowRemoved: function(inRowIndex){
                this.views.rowRemoved(inRowIndex);
        },
        invalidated: null,
        updating: false,
        beginUpdate: function(){
                // summary:
                //      Use to make multiple changes to rows while queueing row updating.
                // NOTE: not currently supporting nested begin/endUpdate calls
                this.invalidated = [];
                this.updating = true;
        },
        endUpdate: function(){
                // summary:
                //      Use after calling beginUpdate to render any changes made to rows.
                this.updating = false;
                var i = this.invalidated;
                if(i.all){
                        this.update();
                }else if(i.rowCount != undefined){
                        this.updateRowCount(i.rowCount);
                }else{
                        for(r in i){
                                this.updateRow(Number(r));
                        }
                }
                this.invalidated = null;
        },
        // update
        defaultUpdate: function(){
                // note: initial update calls render and subsequently this function.
                if(this.updating){
                        this.invalidated.all = true;
                        return;
                }
                //this.edit.saveState(inRowIndex);
                this.prerender();
                this.scroller.invalidateNodes();
                this.setScrollTop(this.scrollTop);
                this.postrender();
                //this.edit.restoreState(inRowIndex);
        },
        update: function(){
                // summary:
                //      Update the grid, retaining edit and scrolling states.
                this.render();
        },
        updateRow: function(inRowIndex){
                // summary:
                //      Render a single row.
                // inRowIndex: int
                //      index of the row to render
                inRowIndex = Number(inRowIndex);
                if(this.updating){
                        this.invalidated[inRowIndex]=true;
                        return;
                }
                this.views.updateRow(inRowIndex, this.rows.getHeight(inRowIndex));
                this.scroller.rowHeightChanged(inRowIndex);
        },
        updateRowCount: function(inRowCount){
                //summary: 
                //      Change the number of rows.
                // inRowCount: int
                //      Number of rows in the grid.
                if(this.updating){
                        this.invalidated.rowCount = inRowCount;
                        return;
                }
                this.rowCount = inRowCount;
                this.scroller.updateRowCount(inRowCount);
                this.setScrollTop(this.scrollTop);
                this.resize();
        },
        updateRowStyles: function(inRowIndex){
                // summary:
                //      Update the styles for a row after it's state has changed.
                
                this.views.updateRowStyles(inRowIndex);
        },
        rowHeightChanged: function(inRowIndex){
                // summary: 
                //      Update grid when the height of a row has changed. Row height is handled automatically as rows
                //      are rendered. Use this function only to update a row's height outside the normal rendering process.
                // inRowIndex: int
                // index of the row that has changed height
                
                this.views.renormalizeRow(inRowIndex);
                this.scroller.rowHeightChanged(inRowIndex);
        },
        // fastScroll: boolean
        //      flag modifies vertical scrolling behavior. Defaults to true but set to false for slower 
        //      scroll performance but more immediate scrolling feedback
        fastScroll: true,
        delayScroll: false,
        // scrollRedrawThreshold: int
        //      pixel distance a user must scroll vertically to trigger grid scrolling.
        scrollRedrawThreshold: (dojo.isIE ? 100 : 50),
        // scroll methods
        scrollTo: function(inTop){
                // summary:
                //      Vertically scroll the grid to a given pixel position
                // inTop: int
                //      vertical position of the grid in pixels
                if(!this.fastScroll){
                        this.setScrollTop(inTop);
                        return;
                }
                var delta = Math.abs(this.lastScrollTop - inTop);
                this.lastScrollTop = inTop;
                if(delta > this.scrollRedrawThreshold || this.delayScroll){
                        this.delayScroll = true;
                        this.scrollTop = inTop;
                        this.views.setScrollTop(inTop);
                        dojox.grid.jobs.job('dojoxGrid-scroll', 200, dojo.hitch(this, "finishScrollJob"));
                }else{
                        this.setScrollTop(inTop);
                }
        },
        finishScrollJob: function(){
                this.delayScroll = false;
                this.setScrollTop(this.scrollTop);
        },
        setScrollTop: function(inTop){
                this.scrollTop = this.views.setScrollTop(inTop);
                this.scroller.scroll(this.scrollTop);
        },
        scrollToRow: function(inRowIndex){
                // summary:
                //      Scroll the grid to a specific row.
                // inRowIndex: int
                // grid row index
                this.setScrollTop(this.scroller.findScrollTop(inRowIndex) + 1);
        },
        // styling (private, used internally to style individual parts of a row)
        styleRowNode: function(inRowIndex, inRowNode){
                if(inRowNode){
                        this.rows.styleRowNode(inRowIndex, inRowNode);
                }
        },
        // cells
        getCell: function(inIndex){
                // summary:
                //      retrieves the cell object for a given grid column.
                // inIndex: int
                // grid column index of cell to retrieve
                // returns:
                //      a grid cell
                return this.layout.cells[inIndex];
        },
        setCellWidth: function(inIndex, inUnitWidth) {
                this.getCell(inIndex).unitWidth = inUnitWidth;
        },
        getCellName: function(inCell){
                return "Cell " + inCell.index;
        },
        // sorting
        canSort: function(inSortInfo){
                // summary:
                //      determines if the grid can be sorted
                // inSortInfo: int
                //      Sort information, 1-based index of column on which to sort, positive for an ascending sort
                // and negative for a descending sort
                // returns:
                //      true if grid can be sorted on the given column in the given direction
        },
        sort: function(){
        },
        getSortAsc: function(inSortInfo){
                // summary:
                //      returns true if grid is sorted in an ascending direction.
                inSortInfo = inSortInfo == undefined ? this.sortInfo : inSortInfo;
                return Boolean(inSortInfo > 0);
        },
        getSortIndex: function(inSortInfo){
                // summary:
                //      returns the index of the column on which the grid is sorted
                inSortInfo = inSortInfo == undefined ? this.sortInfo : inSortInfo;
                return Math.abs(inSortInfo) - 1;
        },
        setSortIndex: function(inIndex, inAsc){
                // summary:
                // Sort the grid on a column in a specified direction
                // inIndex: int
                // Column index on which to sort.
                // inAsc: boolean
                // If true, sort the grid in ascending order, otherwise in descending order
                var si = inIndex +1;
                if(inAsc != undefined){
                        si *= (inAsc ? 1 : -1);
                } else if(this.getSortIndex() == inIndex){
                        si = -this.sortInfo;
                }
                this.setSortInfo(si);
        },
        setSortInfo: function(inSortInfo){
                if(this.canSort(inSortInfo)){
                        this.sortInfo = inSortInfo;
                        this.sort();
                        this.update();
                }
        },
        // DOM event handler
        doKeyEvent: function(e){
                e.dispatch = 'do' + e.type;
                this.onKeyEvent(e);
        },
        // event dispatch
        //: protected
        _dispatch: function(m, e){
                if(m in this){
                        return this[m](e);
                }
        },
        dispatchKeyEvent: function(e){
                this._dispatch(e.dispatch, e);
        },
        dispatchContentEvent: function(e){
                this.edit.dispatchEvent(e) || e.sourceView.dispatchContentEvent(e) || this._dispatch(e.dispatch, e);
        },
        dispatchHeaderEvent: function(e){
                e.sourceView.dispatchHeaderEvent(e) || this._dispatch('doheader' + e.type, e);
        },
        dokeydown: function(e){
                this.onKeyDown(e);
        },
        doclick: function(e){
                if(e.cellNode){
                        this.onCellClick(e);
                }else{
                        this.onRowClick(e);
                }
        },
        dodblclick: function(e){
                if(e.cellNode){
                        this.onCellDblClick(e);
                }else{
                        this.onRowDblClick(e);
                }
        },
        docontextmenu: function(e){
                if(e.cellNode){
                        this.onCellContextMenu(e);
                }else{
                        this.onRowContextMenu(e);
                }
        },
        doheaderclick: function(e){
                if(e.cellNode){
                        this.onHeaderCellClick(e);
                }else{
                        this.onHeaderClick(e);
                }
        },
        doheaderdblclick: function(e){
                if(e.cellNode){
                        this.onHeaderCellDblClick(e);
                }else{
                        this.onHeaderDblClick(e);
                }
        },
        doheadercontextmenu: function(e){
                if(e.cellNode){
                        this.onHeaderCellContextMenu(e);
                }else{
                        this.onHeaderContextMenu(e);
                }
        },
        // override to modify editing process
        doStartEdit: function(inCell, inRowIndex){
                this.onStartEdit(inCell, inRowIndex);
        },
        doApplyCellEdit: function(inValue, inRowIndex, inFieldIndex){
                this.onApplyCellEdit(inValue, inRowIndex, inFieldIndex);
        },
        doCancelEdit: function(inRowIndex){
                this.onCancelEdit(inRowIndex);
        },
        doApplyEdit: function(inRowIndex){
                this.onApplyEdit(inRowIndex);
        },
        // row editing
        addRow: function(){
                // summary:
                //      add a row to the grid.
                this.updateRowCount(this.rowCount+1);
        },
        removeSelectedRows: function(){
                // summary:
                //      remove the selected rows from the grid.
                this.updateRowCount(Math.max(0, this.rowCount - this.selection.getSelected().length));
                this.selection.clear();
        }
});

dojo.mixin(dojox.VirtualGrid.prototype, dojox.grid.publicEvents);

}