Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.grid._grid.builder"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.grid._grid.builder"] = true;
dojo.provide("dojox.grid._grid.builder");
dojo.require("dojox.grid._grid.drag");

dojo.declare("dojox.grid.Builder", null, {
        // summary:
        //      Base class to produce html for grid content.
        //      Also provide event decoration, providing grid related information inside the event object
        // passed to grid events.
        constructor: function(inView){
                this.view = inView;
                this.grid = inView.grid;
        },
        view: null,
        // boilerplate HTML
        _table: '<table class="dojoxGrid-row-table" border="0" cellspacing="0" cellpadding="0" role="wairole:presentation">',
        // generate starting tags for a cell
        generateCellMarkup: function(inCell, inMoreStyles, inMoreClasses, isHeader){
                var result = [], html;
                if (isHeader){
                        html = [ '<th tabIndex="-1" role="wairole:columnheader"' ];
                }else{
                        html = [ '<td tabIndex="-1" role="wairole:gridcell"' ];
                }
                inCell.colSpan && html.push(' colspan="', inCell.colSpan, '"');
                inCell.rowSpan && html.push(' rowspan="', inCell.rowSpan, '"');
                html.push(' class="dojoxGrid-cell ');
                inCell.classes && html.push(inCell.classes, ' ');
                inMoreClasses && html.push(inMoreClasses, ' ');
                // result[0] => td opener, style
                result.push(html.join(''));
                // SLOT: result[1] => td classes 
                result.push('');
                html = ['" idx="', inCell.index, '" style="'];
                html.push(inCell.styles, inMoreStyles||'');
                inCell.unitWidth && html.push('width:', inCell.unitWidth, ';');
                // result[2] => markup
                result.push(html.join(''));
                // SLOT: result[3] => td style 
                result.push('');
                html = [ '"' ];
                inCell.attrs && html.push(" ", inCell.attrs);
                html.push('>');
                // result[4] => td postfix
                result.push(html.join(''));
                // SLOT: result[5] => content
                result.push('');
                // result[6] => td closes
                result.push('</td>');
                return result;
        },
        // cell finding
        isCellNode: function(inNode){
                return Boolean(inNode && inNode.getAttribute && inNode.getAttribute("idx"));
        },
        getCellNodeIndex: function(inCellNode){
                return inCellNode ? Number(inCellNode.getAttribute("idx")) : -1;
        },
        getCellNode: function(inRowNode, inCellIndex){
                for(var i=0, row; row=dojox.grid.getTr(inRowNode.firstChild, i); i++){
                        for(var j=0, cell; cell=row.cells[j]; j++){
                                if(this.getCellNodeIndex(cell) == inCellIndex){
                                        return cell;
                                }
                        }
                }
        },
        findCellTarget: function(inSourceNode, inTopNode){
                var n = inSourceNode;
                while(n && !this.isCellNode(n) && (n!=inTopNode)){
                        n = n.parentNode;
                }
                return n!=inTopNode ? n : null 
        },
        // event decoration
        baseDecorateEvent: function(e){
                e.dispatch = 'do' + e.type;
                e.grid = this.grid;
                e.sourceView = this.view;
                e.cellNode = this.findCellTarget(e.target, e.rowNode);
                e.cellIndex = this.getCellNodeIndex(e.cellNode);
                e.cell = (e.cellIndex >= 0 ? this.grid.getCell(e.cellIndex) : null);
        },
        // event dispatch
        findTarget: function(inSource, inTag){
                var n = inSource;
                while(n && !(inTag in n) && (n!=this.domNode)){
                        n = n.parentNode;
                }
                return (n != this.domNode) ? n : null; 
        },
        findRowTarget: function(inSource){
                return this.findTarget(inSource, dojox.grid.rowIndexTag);
        },
        isIntraNodeEvent: function(e){
                try{
                        return (e.cellNode && e.relatedTarget && dojo.isDescendant(e.relatedTarget, e.cellNode));
                }catch(x){
                        // e.relatedTarget has permission problem in FF if it's an input: https://bugzilla.mozilla.org/show_bug.cgi?id=208427
                        return false;
                }
        },
        isIntraRowEvent: function(e){
                try{
                        var row = e.relatedTarget && this.findRowTarget(e.relatedTarget);
                        return !row && (e.rowIndex==-1) || row && (e.rowIndex==row.gridRowIndex);                       
                }catch(x){
                        // e.relatedTarget on INPUT has permission problem in FF: https://bugzilla.mozilla.org/show_bug.cgi?id=208427
                        return false;
                }
        },
        dispatchEvent: function(e){
                if(e.dispatch in this){
                        return this[e.dispatch](e);
                }
        },
        // dispatched event handlers
        domouseover: function(e){
                if(e.cellNode && (e.cellNode!=this.lastOverCellNode)){
                        this.lastOverCellNode = e.cellNode;
                        this.grid.onMouseOver(e);
                }
                this.grid.onMouseOverRow(e);
        },
        domouseout: function(e){
                if(e.cellNode && (e.cellNode==this.lastOverCellNode) && !this.isIntraNodeEvent(e, this.lastOverCellNode)){
                        this.lastOverCellNode = null;
                        this.grid.onMouseOut(e);
                        if(!this.isIntraRowEvent(e)){
                                this.grid.onMouseOutRow(e);
                        }
                }
        }
});

dojo.declare("dojox.grid.contentBuilder", dojox.grid.Builder, {
        // summary:
        //      Produces html for grid data content. Owned by grid and used internally 
        //      for rendering data. Override to implement custom rendering.
        update: function(){
                this.prepareHtml();
        },
        // cache html for rendering data rows
        prepareHtml: function(){
                var defaultGet=this.grid.get, rows=this.view.structure.rows;
                for(var j=0, row; (row=rows[j]); j++){
                        for(var i=0, cell; (cell=row[i]); i++){
                                cell.get = cell.get || (cell.value == undefined) && defaultGet;
                                cell.markup = this.generateCellMarkup(cell, cell.cellStyles, cell.cellClasses, false);
                        }
                }
        },
        // time critical: generate html using cache and data source
        generateHtml: function(inDataIndex, inRowIndex){
                var
                        html = [ this._table ],
                        v = this.view,
                        obr = v.onBeforeRow,
                        rows = v.structure.rows;
                obr && obr(inRowIndex, rows);
                for(var j=0, row; (row=rows[j]); j++){
                        if(row.hidden || row.header){
                                continue;
                        }
                        html.push(!row.invisible ? '<tr>' : '<tr class="dojoxGrid-invisible">');
                        for(var i=0, cell, m, cc, cs; (cell=row[i]); i++){
                                m = cell.markup, cc = cell.customClasses = [], cs = cell.customStyles = [];
                                // content (format can fill in cc and cs as side-effects)
                                m[5] = cell.format(inDataIndex);
                                // classes
                                m[1] = cc.join(' ');
                                // styles
                                m[3] = cs.join(';');
                                // in-place concat
                                html.push.apply(html, m);
                        }
                        html.push('</tr>');
                }
                html.push('</table>');
                return html.join('');
        },
        decorateEvent: function(e){
                e.rowNode = this.findRowTarget(e.target);
                if(!e.rowNode){return false};
                e.rowIndex = e.rowNode[dojox.grid.rowIndexTag];
                this.baseDecorateEvent(e);
                e.cell = this.grid.getCell(e.cellIndex);
                return true;
        }
});

dojo.declare("dojox.grid.headerBuilder", dojox.grid.Builder, {
        // summary:
        //      Produces html for grid header content. Owned by grid and used internally 
        //      for rendering data. Override to implement custom rendering.
        bogusClickTime: 0,
        overResizeWidth: 4,
        minColWidth: 1,
        _table: '<table class="dojoxGrid-row-table" border="0" cellspacing="0" cellpadding="0" role="wairole:presentation"',
        update: function(){
                this.tableMap = new dojox.grid.tableMap(this.view.structure.rows);
        },
        generateHtml: function(inGetValue, inValue){
                var html = [this._table], rows = this.view.structure.rows;
                
                // render header with appropriate width, if possible so that views with flex columns are correct height
                if(this.view.viewWidth){
                        html.push([' style="width:', this.view.viewWidth, ';"'].join(''));
                }
                html.push('>');
                dojox.grid.fire(this.view, "onBeforeRow", [-1, rows]);
                for(var j=0, row; (row=rows[j]); j++){
                        if(row.hidden){
                                continue;
                        }
                        html.push(!row.invisible ? '<tr>' : '<tr class="dojoxGrid-invisible">');
                        for(var i=0, cell, markup; (cell=row[i]); i++){
                                cell.customClasses = [];
                                cell.customStyles = [];
                                markup = this.generateCellMarkup(cell, cell.headerStyles, cell.headerClasses, true);
                                // content
                                markup[5] = (inValue != undefined ? inValue : inGetValue(cell));
                                // styles
                                markup[3] = cell.customStyles.join(';');
                                // classes
                                markup[1] = cell.customClasses.join(' '); //(cell.customClasses ? ' ' + cell.customClasses : '');
                                html.push(markup.join(''));
                        }
                        html.push('</tr>');
                }
                html.push('</table>');
                return html.join('');
        },
        // event helpers
        getCellX: function(e){
                var x = e.layerX;
                if(dojo.isMoz){
                        var n = dojox.grid.ascendDom(e.target, dojox.grid.makeNotTagName("th"));
                        x -= (n && n.offsetLeft) || 0;
                        //x -= getProp(ascendDom(e.target, mkNotTagName("td")), "offsetLeft") || 0;
                }
                var n = dojox.grid.ascendDom(e.target, function(){
                        if(!n || n == e.cellNode){
                                return false;
                        }
                        // Mozilla 1.8 (FF 1.5) has a bug that makes offsetLeft = -parent border width
                        // when parent has border, overflow: hidden, and is positioned
                        // handle this problem here ... not a general solution!
                        x += (n.offsetLeft < 0 ? 0 : n.offsetLeft);
                        return true;
                });
                return x;
        },
        // event decoration
        decorateEvent: function(e){
                this.baseDecorateEvent(e);
                e.rowIndex = -1;
                e.cellX = this.getCellX(e);
                return true;
        },
        // event handlers
        // resizing
        prepareLeftResize: function(e){
                var i = dojox.grid.getTdIndex(e.cellNode);
                e.cellNode = (i ? e.cellNode.parentNode.cells[i-1] : null);
                e.cellIndex = (e.cellNode ? this.getCellNodeIndex(e.cellNode) : -1);
                return Boolean(e.cellNode);
        },
        canResize: function(e){
                if(!e.cellNode || e.cellNode.colSpan > 1){
                        return false;
                }
                var cell = this.grid.getCell(e.cellIndex); 
                return !cell.noresize && !cell.isFlex();
        },
        overLeftResizeArea: function(e){
                return (e.cellIndex>0) && (e.cellX < this.overResizeWidth) && this.prepareLeftResize(e);
        },
        overRightResizeArea: function(e){
                return e.cellNode && (e.cellX >= e.cellNode.offsetWidth - this.overResizeWidth);
        },
        domousemove: function(e){
                //console.log(e.cellIndex, e.cellX, e.cellNode.offsetWidth);
                var c = (this.overRightResizeArea(e) ? 'e-resize' : (this.overLeftResizeArea(e) ? 'w-resize' : ''));
                if(c && !this.canResize(e)){
                        c = 'not-allowed';
                }
                e.sourceView.headerNode.style.cursor = c || ''; //'default';
        },
        domousedown: function(e){
                if(!dojox.grid.drag.dragging){
                        if((this.overRightResizeArea(e) || this.overLeftResizeArea(e)) && this.canResize(e)){
                                this.beginColumnResize(e);
                        }
                        //else{
                        //      this.beginMoveColumn(e);
                        //}
                }
        },
        doclick: function(e) {
                if (new Date().getTime() < this.bogusClickTime) {
                        dojo.stopEvent(e);
                        return true;
                }
        },
        // column resizing
        beginColumnResize: function(e){
                dojo.stopEvent(e);
                var spanners = [], nodes = this.tableMap.findOverlappingNodes(e.cellNode);
                for(var i=0, cell; (cell=nodes[i]); i++){
                        spanners.push({ node: cell, index: this.getCellNodeIndex(cell), width: cell.offsetWidth });
                        //console.log("spanner: " + this.getCellNodeIndex(cell));
                }
                var drag = {
                        view: e.sourceView,
                        node: e.cellNode,
                        index: e.cellIndex,
                        w: e.cellNode.clientWidth,
                        spanners: spanners
                };
                //console.log(drag.index, drag.w);
                dojox.grid.drag.start(e.cellNode, dojo.hitch(this, 'doResizeColumn', drag), dojo.hitch(this, 'endResizeColumn', drag), e);
        },
        doResizeColumn: function(inDrag, inEvent){
                var w = inDrag.w + inEvent.deltaX;
                if(w >= this.minColWidth){
                        for(var i=0, s, sw; (s=inDrag.spanners[i]); i++){
                                sw = s.width + inEvent.deltaX;
                                s.node.style.width = sw + 'px';
                                inDrag.view.setColWidth(s.index, sw);
                                //console.log('setColWidth', '#' + s.index, sw + 'px');
                        }
                        inDrag.node.style.width = w + 'px';
                        inDrag.view.setColWidth(inDrag.index, w);
                }
                if(inDrag.view.flexCells && !inDrag.view.testFlexCells()){
                        var t = dojox.grid.findTable(inDrag.node);
                        t && (t.style.width = '');
                }
        },
        endResizeColumn: function(inDrag){
                this.bogusClickTime = new Date().getTime() + 30;
                setTimeout(dojo.hitch(inDrag.view, "update"), 50);
        }
});

dojo.declare("dojox.grid.tableMap", null, {
        // summary:
        //      Maps an html table into a structure parsable for information about cell row and col spanning.
        //      Used by headerBuilder
        constructor: function(inRows){
                this.mapRows(inRows);
        },
        map: null,
        // map table topography
        mapRows: function(inRows){
                //console.log('mapRows');
                // # of rows
                var rowCount = inRows.length;
                if(!rowCount){
                        return;
                }
                // map which columns and rows fill which cells
                this.map = [ ];
                for(var j=0, row; (row=inRows[j]); j++){
                        this.map[j] = [];
                }
                for(var j=0, row; (row=inRows[j]); j++){
                        for(var i=0, x=0, cell, colSpan, rowSpan; (cell=row[i]); i++){
                                while (this.map[j][x]){x++};
                                this.map[j][x] = { c: i, r: j };
                                rowSpan = cell.rowSpan || 1;
                                colSpan = cell.colSpan || 1;
                                for(var y=0; y<rowSpan; y++){
                                        for(var s=0; s<colSpan; s++){
                                                this.map[j+y][x+s] = this.map[j][x];
                                        }
                                }
                                x += colSpan;
                        }
                }
                //this.dumMap();
        },
        dumpMap: function(){
                for(var j=0, row, h=''; (row=this.map[j]); j++,h=''){
                        for(var i=0, cell; (cell=row[i]); i++){
                                h += cell.r + ',' + cell.c + '   ';
                        }
                        console.log(h);
                }
        },
        // find node's map coords by it's structure coords
        getMapCoords: function(inRow, inCol){
                for(var j=0, row; (row=this.map[j]); j++){
                        for(var i=0, cell; (cell=row[i]); i++){
                                if(cell.c==inCol && cell.r == inRow){
                                        return { j: j, i: i };
                                }
                                //else{console.log(inRow, inCol, ' : ', i, j, " : ", cell.r, cell.c); };
                        }
                }
                return { j: -1, i: -1 };
        },
        // find a node in inNode's table with the given structure coords
        getNode: function(inTable, inRow, inCol){
                var row = inTable && inTable.rows[inRow];
                return row && row.cells[inCol];
        },
        _findOverlappingNodes: function(inTable, inRow, inCol){
                var nodes = [];
                var m = this.getMapCoords(inRow, inCol);
                //console.log("node j: %d, i: %d", m.j, m.i);
                var row = this.map[m.j];
                for(var j=0, row; (row=this.map[j]); j++){
                        if(j == m.j){ continue; }
                        with(row[m.i]){
                                //console.log("overlaps: r: %d, c: %d", r, c);
                                var n = this.getNode(inTable, r, c);
                                if(n){ nodes.push(n); }
                        }
                }
                //console.log(nodes);
                return nodes;
        },
        findOverlappingNodes: function(inNode){
                return this._findOverlappingNodes(dojox.grid.findTable(inNode), dojox.grid.getTrIndex(inNode.parentNode), dojox.grid.getTdIndex(inNode));
        }
});

dojox.grid.rowIndexTag = "gridRowIndex";

}