source: gs3-extensions/seaweed-debug/trunk/src/OperationManager.js@ 25160

/*
 * file: OperationManager.js
 *
 * @BEGINLICENSE
 * Copyright 2010 Brook Novak  (email : [email protected]) 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program 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 General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 * @ENDLICENSE
 */
bootstrap.provides("OperationManager");

    /* Read Only. Stores all undoable/redoable operation logic  */
var _operationRepository = {}, 

    /* Read Only. Stores the current list of operations. Null/undefined if there is none */
    _curOperationList,
    
    /* Set to true to record operations, false to ignore. Defaults to true. */
    _recordOperations = true;

/**
 * 
 * @param {Number} opCode    The unique operation code which identifies the operation.
 * 
 * @param {Function} exec    The execution function. The first argument will be the operation data.
 *                           The following arguments are specific execution arguemnts to the operation.
 * 
 * @param {Function} undo    The undo function. Given one argument: the operation data.
 * 
 * @param {Function} redo    The redo function. Given one argument: the operation data.
 * 
 * @return {Number} The operation code of the registered operation
 */
function _registerOperation(opCode, exec, undo, redo) {
    
    // Should generate operation code?
    if (!opCode) {
        opCode = _registerOperation.genOp + 1;
        do {
            opCode++;
        } while(_operationRepository[opCode]);
        _registerOperation.genOp = opCode;
    }
    
    debug.assert(!_operationRepository[opCode], "Attempted to override operation with op code: " + opCode);
    _operationRepository[opCode] = {exec:exec,undo:undo,redo:redo};
    
    return opCode;
}

_registerOperation.genOp = 100;

/**
 * Executes an undoable operation. If _recordOperations is on then the operation will be stored
 * in the _curOperationList list.
 * 
 * When ever dom is to be manipulated, it is always done here. The additional arguments after the given op code
 * are specific to the operation.
 * 
 * @param {Number} opCode The operation code of the operation to execute.
 */
function _execOp(opCode) {
        
    // Get the operation code
    var operation = _operationRepository[opCode];
    debug.assert(operation != null, "Unknown operation: " + opCode);
    
    // Create argument list... begin with the operation data object
    var args = Array.prototype.slice.call(arguments);
    args.shift();
    args.unshift({opCode:opCode});
    
    // Execute the operation
    var opRes = operation.exec.apply(operation, args);

    // Store the operation data
     if (_recordOperations) {
        // Create a new operation list if not appending
        if (!_curOperationList)
            _curOperationList = [];
         _curOperationList.push(args[0]);
     }
    
    // Return the operatoin-specific result
    return opRes;
    
}

/**
 * Note: Wipes current operation list.
 * @return {[Object]} The current list of operations. Null if there are none.
 */
function _getOperations() {
    var ops = _curOperationList;
    _curOperationList = null;
    return ops;
}

/**
 * Undoes a list of operations. Assumes that the effected DOM state is the same as it was after the operations were executed.
 * 
 * @param {[Object]} opList The list of operations to undo
 */
function _undoOperations(opList) {
    for (var i = opList.length - 1; i >= 0; i--) {
        var opData = opList[i];
        var operation = _operationRepository[opData.opCode];
        debug.assert(operation != null, "Unknown operation: " + opData.opCode);
        operation.undo(opData);
    }
}

/**
 * Redoes a list of operations. Assumes that the effected DOM state is the same as it was after the operations were undone.
 * 
 * @param {[Object]} opList The list of operations to redo
 */
function _redoOperations(opList) {
    for (var i in opList) {
        var opData = opList[i];
        var operation = _operationRepository[opData.opCode];
        debug.assert(operation != null, "Unknown operation: " + opData.opCode);
        operation.redo(opData);
    }
}

/**
 * Controls whether undoable operations should be recorded.
 * ONLY USE IF YOU KNOW WHAT YOU ARE DOING.
 * 
 * TODO: Detailed doc.
 * 
 * @param {Boolean} on True to turn on operation recording. False to turn off.
 */
de.recordOperations = function(on) {
    _recordOperations = on;
};

/* BASE OPERATIONS */

// @DEBUG ON
_Operation = {
    // @REPLACE _Operation.INSERT_NODE 1
    INSERT_NODE : 1,
    
    // @REPLACE _Operation.REMOVE_NODE 2
    REMOVE_NODE : 2,
    
    // @REPLACE _Operation.SPLIT_TEXT_NODE 3
    SPLIT_TEXT_NODE : 3,
    
    // @REPLACE _Operation.INSERT_TEXT 4
    INSERT_TEXT : 4,
    
    // @REPLACE _Operation.REMOVE_TEXT 5
    REMOVE_TEXT : 5,
    
    // @REPLACE _Operation.SET_CSS_STYLE 6
    SET_CSS_STYLE : 6,
    
    // @REPLACE _Operation.SET_CLASS 7
    SET_CLASS : 7,
    
    // @REPLACE _Operation.INSERT_ROW 8
    INSERT_ROW : 8,
    
    // @REPLACE _Operation.INSERT_CELL 9
    INSERT_CELL : 9,
    
    // @REPLACE _Operation.DELETE_ROW 10
    DELETE_ROW : 10,
    
    // @REPLACE _Operation.DELETE_CELL 11
    DELETE_CELL : 11
    
};
// @DEBUG OFF


_registerOperation(_Operation.INSERT_NODE, 

    /**
     * Execute
     * @param {Object} data      The operation data
     * @param {Node} newNode     The new dom node to insert
     * @param {Node} parent      The parent of the dom node to insert into
     * @param {Number} index     The index in the parent to insert the dom node. Omit to append
     */
    function(data, newNode, parent, index){
        data.newNode = newNode;
        data.parent = parent;
        if (index || index === 0) // Is it an append operation?
            data.pos = index;
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        data.parent.removeChild(data.newNode);
    }, 
    
    /* Redo */
    function(data){
        if (data.pos || data.pos === 0)
            _insertAt(data.parent, data.newNode, data.pos);
        else data.parent.appendChild(data.newNode);
    }
    
);

_registerOperation(_Operation.REMOVE_NODE, 
    
    /**
     * Execute
     * @param {Object} data    The operation data
     * @param {Node} target    The Node to remove
     */
    function(data, target){
        data.parent = target.parentNode;
        data.pos = _indexInParent(target);
        data.target = target;
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        _insertAt(data.parent, data.target, data.pos);
    }, 
    
    /* Redo */
    function(data){
        data.parent.removeChild(data.target);
    }
);


_registerOperation(_Operation.SPLIT_TEXT_NODE, 
    
    /* Execute */
    function(data, target, index){
        data.target = target;
        data.index = index;
        data.rem = target.splitText(index);
        return data.rem;
    }, 
    
    /* Undo */
    function(data){
        // Restore target nodes full text value
        data.target.nodeValue += data.rem.nodeValue;
        
        // Get rid of the split text node
        data.rem.parentNode.removeChild(data.rem);
        data.rem.nodeValue = ""; // free some memory
    }, 
    
    /* Redo */
    function(data){
        
        var fullText = data.target.nodeValue;
        // Re-set the splitted nodes text
        data.rem.nodeValue = fullText.substr(data.index);
        data.target.nodeValue = fullText.substr(0, data.index);
        
        // Re-insert the split node
        _insertAfter(data.rem, data.target);
    }
);


_registerOperation(_Operation.INSERT_TEXT, 
    
    /* Execute */
    function(data, target, text, index){
        
        data.target = target;
        data.index = index;
        data.len = text.length;
        
        var pre = target.nodeValue.substr(0, index), 
            post = target.nodeValue.substr(index);
        
        target.nodeValue = pre + text + post;
    }, 
    
    /* Undo */
    function(data){
        
        data.text = data.target.nodeValue.substr(data.index, data.len);
        
        var pre = data.target.nodeValue.substr(0, data.index),
            post = data.target.nodeValue.substr(data.index + data.len);
            
        data.target.nodeValue = pre + post
        
        delete data["len"]; // Free some memory
    }, 
    
    /* Redo */
    function(data){
        
        data.len = data.text.length;
        
        var pre = data.target.nodeValue.substr(0, data.index), 
            post = data.target.nodeValue.substr(data.index);
        
        data.target.nodeValue = pre + data.text + post;

        delete data["text"]; // Free some memory        
    }
);


_registerOperation(_Operation.REMOVE_TEXT, 
    
    /* Execute */
    function(data, target, index, length){
        
        data.target = target;
        data.index = index;
        data.text = target.nodeValue.substr(index, length);
        
        var pre = target.nodeValue.substr(0, index),
            post = target.nodeValue.substr(index + length);
            
        target.nodeValue = pre + post
    }, 
    
    /* Undo - same as insert text's undo */
    _operationRepository[_Operation.INSERT_TEXT].redo,
    
    /* Redp - same as insert text's undo  */
   _operationRepository[_Operation.INSERT_TEXT].undo
   
);

_registerOperation(_Operation.SET_CSS_STYLE, 
    
   /**
    * Execute
    * @param {Object} data    The operation data
    * @param {Node} target    The target element to set CSS
    * @param {String} css     The CSS Field to set in javascript notation
    * @param {String} value   The value of the CSS to set
    */
    function(data, target, css, value){
        data.target = target;
        data.css = css;
        data.newValue = value;
        data.oldValue = _engine == _Platform.TRIDENT ? data.target.style.getAttribute(data.css) : data.target.style[data.css];
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        if (_engine == _Platform.TRIDENT) 
            data.target.style.setAttribute(data.css, data.oldValue);
        else 
            data.target.style[data.css] = data.oldValue;
    }, 
    
    /* Redo */
    function(data){
        if (_engine == _Platform.TRIDENT) 
            data.target.style.setAttribute(data.css, data.newValue);
        else 
            data.target.style[data.css] = data.newValue;
    }
);


_registerOperation(_Operation.SET_CLASS, 
    
   /**
    * Execute
    * @param {Object} data    The operation data
    * @param {Node} target    The target element to set CSS
    * @param {String} name    The class name to set (replaces full class name)
    */
    function(data, target, name){
        data.target = target;
        data.newName = name;
        data.oldName = _getClassName(target);
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        _setClassName(data.target, data.oldName);
    }, 
    
    /* Redo */
    function(data){
        _setClassName(data.target, data.newName);
    }
);


_registerOperation(_Operation.INSERT_CELL, 
    
   /**
    * Execute
    * @param {Object} data     The operation data
    * @param {Node} row        The target row element to insert the cell into
    * @param {Number} index    The index in the row to insert into. Clamped if out of bounds
    * @return {Node}           The new cell that was created
    */
    function(data, row, index){
        data.row = row;
        data.index = index > row.cells.length ? row.cells.length : index; // Safely clamp range
        if (data.index < 0) data.index = 0;
        return this.redo(data);
            
    }, 
    
    /* Undo */
    function(data){
        data.row.deleteCell(data.index);
    }, 
    
    /* Redo */
    function(data){
        return data.row.insertCell(data.index);
    }
);



_registerOperation(_Operation.INSERT_ROW, 
    
   /**
    * Execute
    * @param {Object} data     The operation data
    * @param {Node} table      The target table element to insert the row into
    * @param {Number} index    The index in the row to insert into. Clamped if out of bounds
    * @return {Node}           The new row that was created
    */
    function(data, table, index){
        data.table = table;
        data.index = index > table.rows.length ? table.rows.length : index; // Safely clamp range
        if (data.index < 0) data.index = 0;
        return this.redo(data);
            
    }, 
    
    /* Undo */
    function(data){
        data.table.deleteRow(data.index);
    }, 
    
    /* Redo */
    function(data){
        return data.table.insertRow(data.index);
    }
);


_registerOperation(_Operation.DELETE_ROW, 
    
   /**
    * Execute
    * @param {Object} data     The operation data
    * @param {Node} table      The target table element to insert the row into
    * @param {Number} index    The index in the row to delete. Clamped if out of bounds
    */
    function(data, table, index){
        data.table = table;
        data.index = index >= table.rows.length ? table.rows.length-1 : index; // Safely clamp range
        if (data.index < 0) data.index = 0;
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        var newRow = data.table.insertRow(data.index);
        
        // Migrate contents from old removed row into new row
        while(data.row.firstChild) {
            var migrant = data.row.firstChild;
            data.row.removeChild(migrant);
            newRow.appendChild(migrant);
        }
        
        // Save memory - get rid of old removed row reference
        delete data["row"];
    }, 
    
    /* Redo */
    function(data){
        data.row = data.table.rows[data.index]; // Save row - need to keep contents
        data.table.deleteRow(data.index);
    }
);


_registerOperation(_Operation.DELETE_CELL, 
    
   /**
    * Execute
    * @param {Object} data     The operation data
    * @param {Node} row        The target row element to delete the cell from
    * @param {Number} index    The cell index in the row to delete. Clamped if out of bounds
    */
    function(data, row, index){
        data.row = row;
        data.index = index >= row.cells.length ? row.cells.length-1 : index; // Safely clamp range
        if (data.index < 0) data.index = 0;
        this.redo(data);
    }, 
    
    /* Undo */
    function(data){
        var newCell = data.row.insertCell(data.index);
        
        // Migrate contents from old removed row into new row
        while(data.cell.firstChild) {
            var migrant = data.cell.firstChild;
            data.cell.removeChild(migrant);
            newCell.appendChild(migrant);
        }
        
        // Save memory - get rid of old removed row reference
        delete data["cell"];
    }, 
    
    /* Redo */
    function(data){
        data.cell = data.row.cells[data.index]; // Save cell - need to keep contents
        data.row.deleteCell(data.index);
    }
);