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

/*
 * file: Changes.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("Changes");

(function() {
    
    /* All editable sections and their initial states since startup or the last clear. */
    var esStartStates = [];
    
    $enqueueInit("Changes", function() {
        
        de.Changes.clear();
        de.doc.addObserver({
            onSectionAdded : function(editSection) {
    
                // Safety check: make sure editSection is not already registered
                // @DEBUG ON
                for (var i in esStartStates) {
                    debug.assert(esStartStates[i].esNode != editSection);
                }
                // @DEBUG OFF
        
                // Add the new section to the state array
                esStartStates.push({
                    esNode : editSection,
                    initHTML : editSection.innerHTML
                });
                
            }
        });
        
    }, "Doc");

    /**
     * @class A singleton that records the editable sections that have been changed/added/removed over time
     */
    de.Changes = {

        /**
         * Gets all changes since last clear
         * 
         * @return {[Element]} A list of changed editable section nodes. NOTE:
         *                     Does not include removed editable sections .. it only checks the
         *                     editable section contents.
         * 
         * @see de.Changes.clear
         */
        getChangedEditableSections : function() {
            
            var changedSections = [],
                stipEmptiesRE = /(<\s*\w+\s[^>]*?)(?:style|class|id|value)\s*=\s*(?:""|'')([^<]*?>)/i,
                stipEmptiesREPresto = /(<\s*\w+\s[^>]*?)\s*(?:style|class|id|value)\s*(>|(?:[^=][^<]*?>))/i,
                stripAttribWSRE = /<[^\/][^<>]*?\s[^<>]*>/,
                wsRE = /(?:[\t\n\r ]|&nbsp;)/g;
                
            // Don't consider highlighting as part of HTML
            _toggleSectionHighlight(false);
            
            // Look for changes
            for (var i in esStartStates) {
                var esSection = esStartStates[i];
                if (stripIrrelevants(esSection.esNode.innerHTML) != stripIrrelevants(esSection.initHTML) || esSection.dirty) 
                    changedSections.push(esSection.esNode);             
            }
            
            _toggleSectionHighlight(true);
            
            return changedSections;
            
            /**
             * Strip irrelevent html from markup when comparing differences.
             * E.G. Empty attibutes or different whitespace encodings.
             * @param {String} str The html to stip irrelevent data from
             */
            function stripIrrelevants(str) {
                
                // Make all whitespaces normal whitespace
                str = str.replace(wsRE, " ");

                var match, i, re, newStr = "";
                
                // Strip empty attributes
                // One regexp matching pass for all browsers except for opera...
                // Opera can leave empty attrbiutes without ="".
                for (i = 0; i < (_engine == _Platform.PRESTO ? 2 : 1); i++) {
                    
                    // Select the regexp according to pass
                    re = i==0 ? stipEmptiesRE : stipEmptiesREPresto;
                    
                    while(match = re.exec(str)) {
                        str = str.substr(0, match.index) + match[1] + match[2] + str.substr(match.index + match[0].length);
                    }
                                        
                }
   
                if (match) {
                    
                    // Due to attributes from being stripped must clear whitespaces which separate attibutes in html tags..
                    // since whitespaces may only be present for the empty tags
                    while (match = stripAttribWSRE.exec(str)) {
                        newStr += str.substr(0, match.index) + match[0].replace(wsRE, "");
                        str = str.substr(match.index + match[0].length);
                    }
                    newStr += str;
                    
                } else newStr = str;

                return de.spell.stripSpellWrapperHTML(newStr);
            }
            
        },
        
        /**
         * Wipes all recorded changes and prepares for recording new changes for all or a specific edit section.
         * 
         * @param {Element} es  (Optional) The edit section to wipe. If not provided then all edit sections will be wiped
         * 
         * @see de.Changes.reset
         */
        clear : function(es) {
            
            // Exclude highlighting in HTML snapshots
            _toggleSectionHighlight(false);
            
            if (es) {
                
                // Locate specific editable section to wipe changes
                for (var i in esStartStates) {
                    if (esStartStates[i].esNode == es) {
                        esStartStates[i].initHTML = es.innerHTML;
                        esStartStates[i].dirty = 0;
                        break;
                    }
                }
                
            } else {
                
                // Wipe all previous state information
                esStartStates = [];
                
                // Build up the state information based on the current document state
                var editableSections = de.doc.getAllEditSections();
                
                for (var i in editableSections) {
                    var domNode = editableSections[i];
                    
                    esStartStates.push({
                        esNode: domNode,
                        initHTML: domNode.innerHTML
                    });
                }
            }
            
            _toggleSectionHighlight(true);
        },
        
        
        
        /**
         * Use to mark all or a specific editable section as being dirty.
         * 
         * If marked as dirty, then the next request for changed editable sections will also return the
         * editable section marked dirty even if they have not changed / have been cleared.
         * 
         * The next time the edit section is cleared it will be unmarked as being dirty.
         * 
         * @param {Object} es  (Optional) The edit section to dirty. If not provided then all edit sections will be made dirty.
         */
        dirty : function(es) {
            
            for (var i in esStartStates) {
                if (!es || esStartStates[i].esNode == es) {
                    esStartStates[i].dirty = 1;
                }
            }
            
        },
        
        /**
         * Clears the changes, and resets all edit sections html to their initial state since
         * start up or the last clear/reset operation. All undo/redo history will be cleared;
         * 
         * @see de.Changes.clear
         */
        reset : function() {
            
            // Clear undo/redo history
            de.UndoMan.clear();
            
            // Reset edit section html back to their last captured start states
            for (var i in esStartStates) {
                esStartStates[i].esNode.innerHTML = esStartStates[i].initHTML;
            }
            
            // Setup changes again
            this.clear();
        }

    };  // End de.Changes singleton
    
})();