Subversion Repositories jquery

 /****************************************************************

  *  jquery.tableHelper.js                                       *

  *                                                              *

  *  by: Dan VerWeire                                            *

  *  email: [email protected]                                  *

  *                                                              *

  *  sponsored by: Pavilion Gift Company                         *

  *  www.paviliongift.com                                        *

  *                                                              *

  *  This library is free software; you can redistribute         *

  *  it and/or modify it under the terms of the GNU              *

  *  Lesser General Public License as published by the           *

  *  Free Software Foundation; either version 2.1 of the         *

  *  License, or (at your option) any later version.             *

  *                                                              *

  *  This library is distributed in the hope that it will        *

  *  be useful, but WITHOUT ANY WARRANTY; without even the       *

  *  implied warranty of MERCHANTABILITY or FITNESS FOR A        *

  *  PARTICULAR PURPOSE. See the GNU Lesser General Public       *

  *  License for more details.                                   *

  *                                                              *

  *  You should have received a copy of the GNU Lesser           *

  *  General Public License along with this library;             *

  *  Inc., 59 Temple Place, Suite 330, Boston,                   *

  *  MA 02111-1307 USA                                           *

  ****************************************************************/

(function () {

        var alphaColLookup = {}

        var colIndex = 0;

        for (var x = 97; x <= 122; x++) {

            alphaColLookup[String.fromCharCode(x)] = colIndex++;         

        }

        for (var x = 97; x <= 122; x++) {

            for (var y = 97; y <= 122; y++) {

                alphaColLookup[String.fromCharCode(x) + String.fromCharCode(y)] = colIndex++;    

            }

        }

        //helper function to quickly determine if an element is a table

        isTable = function (el) {

                return (el.nodeName == 'TABLE') ? true : false;

        }

        //helper function to quickly determine if an element is a tbody

        isTbody = function (el) {

                return (el.nodeName == 'TBODY') ? true : false;

        }

        //helper function to quickly determine if an element is a tfoot

        isTfoot = function (el) {

                return (el.nodeName == 'TFOOT') ? true : false;

        }

        //helper function to quickly determine if an element is a thead

        isThead = function (el) {

                return (el.nodeName == 'THEAD') ? true : false;

        }

        //helper function to quickly determine if an element is a table cell

        isCell = function (el) {

                return (el.nodeName == 'TD') ? true : false;

        }

        //helper function to quickly determine if an element is a table row

        isRow = function (el) {

                return (el.nodeName == 'TR') ? true : false;

        }

        getTable = function (el,jq) {

                var tbl;

                if (isTable(el) || isThead(el) || isTbody(el) || isTfoot(el)) {

                        jq = jq.not(el);

                        tbl = el;

                }

                else if (isCell(el)) {

                        tbl = el.parentNode.parentNode;

                }

                else if (isRow(el)) {

                        tbl = el.parentNode;

                }

                return { table : tbl, jq : jq }

        }

        getVirtTable = function (tbl) {

                //tables which contain cells that have a rowSpan or cellSpan make the indices not friendly for

                //any type of coordinate system. What this section does is loop through the actual table, building

                //a map of that table where a 'merged cell' has a reference at every coordinate which it takes up.

                //i tried other methods, but this is the one that ended up working. not sure if this is the most efficient.

                //

                //this method helps with including merged cells in an overlapping range

                var virtTable  = {};

                if (tbl.rowLength) {

                        rowLength = tbl.rowLength+1;

                }

                else {

                        rowLength = tbl.rows.length

                }

                if (tbl.cellLength) {

                        colLength = tbl.cellLength+1;

                }

                else {

                        colLength = tbl.rows[0].cells.length;

                }

                for (var y = 0; y < rowLength; y++) {

                        var row = tbl.rows[y];

                        for (var x = 0; x < colLength; x++) {

                                var cell = row.cells[x];

                                if (cell) {

                                        //this loop is for setting the references of a cell that might have a rowSpan or cellSpan

                                        for (var a = 0; a < cell.rowSpan; a++) {

                                                for (var b = 0; b < cell.colSpan; b++) {

                                                        if (!virtTable[y + a]) virtTable[y + a] = {};

                                                        if (!virtTable[y + a][x + b]) {

                                                                virtTable[y + a][x + b] = cell;

                                                                cell.x = x + b;

                                                                cell.y = y + a;

                                                        }

                                                        else {

                                                                var c = 0;

                                                                while (virtTable[y + a][x + b + c]) {

                                                                        c++;

                                                                }

                                                                virtTable[y + a][x + b + c] = cell;

                                                                cell.x = x + b + c;

                                                                cell.y = y + a;

                                                        }

                                                }

                                        }

                                }

                        }

                }

                return virtTable;

        }

        //add the cell method to the jQuery object

        //this method adds the cell at row,col in any tables in the current

        //selection to the selection

        //

        //it will remove the table from the selection

        jQuery.fn.cell = function (col,row) {

                var jq = this;

                this.each(function(i,el) {

                        var obj = getTable(this,jq);

                        jq = obj.jq;

                        tbl = obj.table;

                        var virtTable = getVirtTable(tbl);

                        if (virtTable && virtTable[row] && virtTable[row][col]) {

                                var cell = virtTable[row][col];

                                jq = jq.add(cell);

                        }

                });

                return jq;

        };

        jQuery.fn.row = function (row) {

                var jq = this;

                jq.each(function (i,el) {

                        var obj = getTable(this,jq);

                        jq = obj.jq;

                        tbl = obj.table;

                        var tmp = Array();

                        var rw = tbl.rows.item(row);

                        if (rw) {

                                for (var x = 0; x < rw.cells.length; x++) {

                                        var cell = rw.cells.item(x);

                                        tmp.push(cell);

                                }

                                jq = jq.add(tmp);

                        }

                });

                return jq;

        }

        jQuery.fn.alternate = function(start, interval) {

                var jq = this;

                jq.each(function (i,el) {

                        var obj = getTable(this,jq);

                        jq = obj.jq;

                        tbl = obj.table;

                        var tmp = Array();

                        for (var x = start; x < tbl.rows.length; x += interval) {

                                var rw = tbl.rows.item(x);

                                for (var y = 0; y < rw.cells.length; y++) {

                                        var cell = rw.cells.item(y);

                                        tmp.push(cell);

                                }

                        }

                        jq = jq.add(tmp);

                });

                return jq;

        }

        jQuery.fn.even = function () {

                return this.alternate(0,2);

        }

        jQuery.fn.odd = function () {

                return this.alternate(1,2);

        }

        jQuery.fn.all = function () {

                return this.alternate(0,1);

        }

        jQuery.fn.col = function (col) {

                var jq = this;

                jq.each(function (i,el) {

                        var obj = getTable(this,jq);

                        jq = obj.jq;

                        tbl = obj.table;

                        var tmp = Array();

                        for (var y = 0; y < tbl.rows.length; y++) {

                                var cell = tbl.rows.item(y).cells.item(col)

                                tmp.push(cell);

                        }

                        jq = jq.add(tmp);

                });

                return jq;

        }

        jQuery.fn.tableEnd  = function () {

                var jq = this;

                while (jq.length > 0 ) {

                //      jq.each(function (i, el) {

                                jq = jq.end();

                //      });

                }

                jq = jq.end();

                return jq;

        }

        //resize the table, only grows the table at the moment

        jQuery.fn.resize = function (cols,rows) {

                var jq = this;

                //fix off by one issue

                cols--;

                rows--;

                result = this.each(function(i,el) {

                        this.cellLength = cols;

                        this.rowLength = rows;

                        for (var y = this.rows.length; y < rows + 1; y++) {

                                var rw = this.insertRow(-1);

                        }

                        //now for each row, check all the cells

                        for (var y = 0; y < this.rows.length; y++) {

                                var rw = this.rows.item(y);

                                for (var x = rw.cells.length; x < cols + 1; x ++) {

                                        var td = rw.insertCell(-1);

                                }

                        }

                });

                return jq;

        }

        jQuery.fn.range = function (stRange) { //yes i called this stRange for fun reasons.

                var jq = this;

                if (stRange.indexOf(':') >= 0) {

                        var tokens = stRange.split(':');

                        var range = []

                        for (var x = 0; x < tokens.length; x++) {

                                var token = tokens[x];

                                var col = alphaColLookup[/[a-zA-Z]{1,2}/.exec(token)];

                                var row = (/[0-9]{1,}/.exec(token)) - 1;

                                range.push({row : row, col : col});

                        }

                        if (range.length == 2) {

                                //we have a start coord and a stop coord

                                jq.each(function(i,el) {

                                        var cells = [];

                                        var obj = getTable(this,jq);

                                        jq = obj.jq;

                                        tbl = obj.table;

                                        var virtTable = getVirtTable(tbl);

                                        //now grab the cells in the range from the virtual table.

                                        for (var y = range[0].row ; y <= range[1].row ; y ++) {

                                                for (var x = range[0].col; x <= range[1].col; x++) {

                                                        try {

                                                                if (virtTable[y][x]) {

                                                                        cells.push(virtTable[y][x]);

                                                                }

                                                        }

                                                        catch (e) { alert('.range error: '  + e + ': ' + y + ', ' + x) };

                                                }

                                        }

                                        //add the cells we collected to the jquery object

                                        jq = jq.add(cells);

                                });

                        }

                }

                return jq;

        }

        jQuery.fn.merge = function (copyContents) {

                var jq = this;

                var contents = '';

                var tl = {}, br = {};

                var cells = [];

                jq.each(function (i, el) {

                        if (isCell(this)) cells.push(this);

                })

                //find the top left most cell

                if (cells.length > 0) {

                        var tl = {row : cells[0].y, col : cells[0].x, cell : cells[0]};

                        var br = {row : cells[0].y, col : cells[0].x, cell : cells[0]};

                        for (var x = 0; x < cells.length; x ++){

                                var cell = cells[x];

                                var row = cell.y;

                                var col = cell.x;

                                if (row < tl.row || col < tl.col ) tl = {row : row, col : col, cell : cell};

                                if (row > br.row || col > br.col ) br = {row : row, col : col, cell : cell};

                        }

                        for (var x = 0; x < cells.length; x ++){

                                var cell = cells[x];

                                if (cell != tl.cell) {

                                        if (copyContents) contents += cell.innerHTML;

                                        cell.parentNode.removeChild(cell);

                                }

                        }

                        tl.cell.colSpan = br.col - tl.col + 1;

                        tl.cell.rowSpan = br.row - tl.row + 1;

                        if (copyContents) tl.cell.innerHTML += contents;

                }

                //remove all the td's and then just add back in the topleft cell

                jq = jq.not('td').add(tl.cell);

                return jq;

        }

        jQuery.fn.unMerge = function () {

                var jq = this;

                var contents = '';

                var cells = [];

                jq.each(function (i, el) {

                        var done = false;

                        if (isCell(this)) {

                                var tbl = getTable(this).table;

                                var virtTable = getVirtTable(tbl);

                                //loop through the virtual table to find the top leftest reference to this merged cell.

                                for ( var y in virtTable ) {

                                        var row = virtTable[y];

                                        for (var x in row) {

                                                var cell = row[x];

                                                if (cell == this) {

                                                        rowSpan = this.rowSpan;

                                                        colSpan = this.colSpan;

                                                        //

                                                        //loop through the size of this cell and insert new cells

                                                        for ( var a = 0; a < rowSpan; a++ ) {

                                                                for ( var b = 0 ; b < colSpan; b++ ) {

                                                                        //alert(parseInt(x) + colSpan);

                                                                        //alert((parseInt(y) + a) + ' ' + y + ' ' + a)// + virtTable[String(y + a)][x])

                                                                        var cell = jQuery('<td />').insertBefore(virtTable[(parseInt(y) + a)][parseInt(x) + colSpan]).get(0)

                                                                        cells.push(cell);

                                                                }

                                                        }

                                                        $(this).remove();

                                                        done = true;

                                                        break;

                                                }

                                        }

                                        if (done) break;

                                }

                        }

                })

                return jq.add(cells);

        }

})();