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

/*
 * file: InsertHTMLAction.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
 */

// @DEPENDS: UndoMan
bootstrap.provides("actions.InsertHTMLAction");

_registerAction("InsertHTML", {

    /**
     * @class
     * An undoable insertion action. Inserts HTML into the document
     * 
     * @author Brook Novak
     * 
     * @param {String} html         The HTML to insert.
     * 
     * @param {Node} parentNode     The parent node of the HTML to insert into.
     * 
     * @param {Node} refNode        The node to insert next to, or inside of (if a text node). 
     *                              Null if parentNode has no children, in which case the HTML will be inserted
     *                              as the only children of parentNode.
     * 
     * @param {Number} index        If refNode is null this is not applicable. 
     *                              If refNode is a Element node, then index can either be 0 or 1. 0 indicates that the
     *                              HTML should be inserted before the refNode, and 1 indicates that it should be inserted after.
     *                              Otherwise, if refNode is a Text Node, then index can range from 0 to the length of the text.
     *                              Where the index indicates that the html should be inserted before the charactor at the given index.
     *                              If index is zero, then the html will be inserted before the text node. If index is the length of the
     *                              text, then the html will be inserted after the text node. Otherwise the HTML text will be
     *                              inserted within the text run... splitting the text node in two.
     * 
     */
    exec : function(html, parentNode, refNode, index) {
       
        debug.assert(refNode || (!refNode && parentNode.childNodes.length == 0));
        debug.assert(!refNode || index >= 0);
        debug.assert(!refNode || 
            (refNode.nodeType == Node.TEXT_NODE && index <= refNode.nodeValue.length) || 
            (refNode.nodeType != Node.TEXT_NODE && index <= 1)
        );
        
        var domRoots = [];
        
        // Get all root elements in HTML
        var domTree = parentNode == docBody ? $createElement("div") : parentNode.cloneNode(false);
        domTree.innerHTML = html;
    
        var root = domTree.firstChild;
        while(root) {
            domRoots.push(root);
            root = root.nextSibling;
        } 
        
        // Disconnect roots from temporary container
        for (var i = 0; i < domRoots.length; i++) {
            
            domTree.removeChild(domRoots[i]);
            
            var spanWrapper = 0;
            if (domRoots[i].nodeType == Node.TEXT_NODE) {
                spanWrapper = $createElement("span");
                spanWrapper.appendChild(domRoots[i]);
            }
            
            // Add a renderable char at the end of the container... this will avoid
            // consildation from changing existing contents
            var endNode = document.createTextNode("X");
            parentNode.appendChild(endNode);
            
            // Consolidate the dom root's whitespace sequences
            parentNode.appendChild(spanWrapper ? spanWrapper : domRoots[i]);
            
            _recordOperations = false;
            _consolidateWSSeqs(domRoots[i], false);
            _recordOperations = true;
            
            if (spanWrapper) {
                
                domRoots.splice(i, 1); // remove this dom root, it is to be replaced or entirly removes
                
                // Consolidation can completly remove nodes, so test each consolidated sub-tree to
                // see if they should be inserted
                if (!spanWrapper.firstChild) 
                    i --;
                    
                else {
                    // A text node can be split into several text nodes after consolidation
                    var wrappedChild;
                    while(wrappedChild = spanWrapper.firstChild) {
                        spanWrapper.removeChild(wrappedChild);
                        domRoots.splice(i, 0, wrappedChild);
                        i++;
                    }
                    i--;
                }
                
                parentNode.removeChild(spanWrapper);
                
            } else 
                parentNode.removeChild(domRoots[i]);


            parentNode.removeChild(endNode);

        }
        
        // If the target node is a placeholder, then the placeholder should be replaced with the new html
        var phRoot;
        if (de.doc.isESPlaceHolder(parentNode, false) || de.doc.isMNPlaceHolder(parentNode, false)) 
            phRoot = parentNode;
        else if (refNode && (de.doc.isESPlaceHolder(refNode, false) || de.doc.isMNPlaceHolder(refNode, false))) 
            phRoot = refNode;
            
        if (phRoot) { // Get the placeholder root and adjust the parent node / ref node 
            while (phRoot.parentNode &&
            (de.doc.isESPlaceHolder(phRoot.parentNode, false) || de.doc.isMNPlaceHolder(phRoot.parentNode, false))) {
                phRoot = phRoot.parentNode;
            }
            targetNode = phRoot;
            
            parentNode = phRoot.parentNode;
            refNode = phRoot; // See later .. it will be removed
        }
 
        var normalizeTargetWS;
        
        // Does the insertion point need to split a text node in two?
        if (refNode &&
        refNode.nodeType == Node.TEXT_NODE &&
        index > 0 &&
        index < _nodeLength(refNode)) {
            
            var rem = _execOp(_Operation.SPLIT_TEXT_NODE, refNode, index);
            
            // If inserting HTML an a whitespace point, then must convert to all NBSP then normalize later
            if (_isAllWhiteSpace(rem.nodeValue.charAt(0)) || _isAllWhiteSpace(refNode.nodeValue.charAt(index-1))) {
                normalizeTargetWS = refNode.parentNode;
                _convertWSToNBSP(normalizeTargetWS);
            }
                
        }
        
        // Get the sibling node to begin inserting the dom afterwards.
        var afterNode;
        if (!refNode) afterNode = null;
        else if (index == 0) afterNode = refNode.previousSibling;
        else afterNode = refNode;
        
        // Insert the DOM nodes
        for (var i in domRoots) {
            if (!afterNode)
                _execOp(_Operation.INSERT_NODE, domRoots[i], parentNode, parentNode.firstChild ? _indexInParent(parentNode.firstChild) : null)
            else _execOp(_Operation.INSERT_NODE, domRoots[i], parentNode, _indexInParent(afterNode) + 1);
            afterNode = domRoots[i];
        }
        
        // Normalize whitespace sequences if need to
        if (normalizeTargetWS)
            _consolidateWSSeqs(normalizeTargetWS);
        
        // Need to remove any place holders?
        if (refNode && (de.doc.isMNPlaceHolder(refNode) || de.doc.isESPlaceHolder(refNode)))
            _execOp(_Operation.REMOVE_NODE, refNode);
   
        if (this.flags & de.UndoMan.ExecFlag.UPDATE_SELECTION) {
            var cDesc = de.cursor.getNearestCursorDesc(
                domRoots[domRoots.length-1],
                _nodeLength(domRoots[domRoots.length-1], 2) - 1,
                true,
                _nodeName(domRoots[domRoots.length-1]) != "br");
            if (cDesc)
                this.selAfter = {startNode : cDesc.domNode, startIndex : cDesc.relIndex + (cDesc.domNode.nodeType == Node.TEXT_NODE && cDesc.isRightOf ? 1 : 0)};
        }

    }
});