X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/87b31095331eab98415b37dbd2138cbd6a598b37..ae032450627538fabf7df31fbda6cf7bd097b94f:/src/smartxml/smartxml.js?ds=inline

diff --git a/src/smartxml/smartxml.js b/src/smartxml/smartxml.js
index 2fd4e41..000f722 100644
--- a/src/smartxml/smartxml.js
+++ b/src/smartxml/smartxml.js
@@ -34,6 +34,16 @@ $.extend(DocumentNode.prototype, {
 
     clone: function() {
         var clone = this._$.clone(true, true);
+        clone.find('*').addBack().each(function() {
+            var clonedData = $(this).data();
+            _.pairs(clonedData).forEach(function(pair) {
+                var key = pair[0],
+                    value = pair[1];
+                if(_.isFunction(value.clone)) {
+                    clonedData[key] = value.clone();
+                }
+            });
+        });
         return this.document.createDocumentNode(clone[0]);
     },
 
@@ -222,7 +232,12 @@ $.extend(TextNode.prototype, {
 
 
 var parseXML = function(xml) {
-    return $($.trim(xml))[0];
+    var toret = $($.trim(xml));
+    if(!toret.length) {
+        throw new Error('Unable to parse XML: ' + xml);
+    }
+    return toret[0];
+
 };
 
 var registerTransformation = function(desc, name, target) {
@@ -249,6 +264,7 @@ var Document = function(xml) {
     this.loadXML(xml);
     this.undoStack = [];
     this.redoStack = [];
+    this._transactionStack = [];
     this._transformationLevel = 0;
     
     this._nodeMethods = {};
@@ -267,17 +283,25 @@ $.extend(Document.prototype, Backbone.Events, {
 
     createDocumentNode: function(from) {
         if(!(from instanceof Node)) {
-            if(from.text !== undefined) {
-                /* globals document */
-                from = document.createTextNode(from.text);
+            if(typeof from === 'string') {
+                from = parseXML(from);
+                this.normalizeXML(from);
             } else {
-                var node = $('<' + from.tagName + '>');
-
-                _.keys(from.attrs || {}).forEach(function(key) {
-                    node.attr(key, from.attrs[key]);
-                });
+                if(from.text !== undefined) {
+                    /* globals document */
+                    from = document.createTextNode(from.text);
+                } else {
+                    if(!from.tagName) {
+                        throw new Error('tagName missing');
+                    }
+                    var node = $('<' + from.tagName + '>');
+
+                    _.keys(from.attrs || {}).forEach(function(key) {
+                        node.attr(key, from.attrs[key]);
+                    });
 
-                from = node[0];
+                    from = node[0];
+                }
             }
         }
         var Factory, typeMethods, typeTransformations;
@@ -308,11 +332,16 @@ $.extend(Document.prototype, Backbone.Events, {
     loadXML: function(xml, options) {
         options = options || {};
         this._defineDocumentProperties($(parseXML(xml)));
+        this.normalizeXML(this.dom);
         if(!options.silent) {
             this.trigger('contentSet');
         }
     },
 
+    normalizeXML: function(nativeNode) {
+        void(nativeNode); // noop
+    },
+
     toXML: function() {
         return this.root.toXML();
     },
@@ -417,7 +446,11 @@ $.extend(Document.prototype, Backbone.Events, {
             this._transformationLevel++;
             toret = transformation.run({beUndoable:this._transformationLevel === 1});
             if(this._transformationLevel === 1 && !this._undoInProgress) {
-                this.undoStack.push(transformation);
+                if(this._transactionInProgress) {
+                    this._transactionStack.push(transformation);
+                } else {
+                    this.undoStack.push(transformation);
+                }
             }
             if(!this._undoInProgress && this._transformationLevel === 1) {
                 this.redoStack = [];
@@ -429,22 +462,74 @@ $.extend(Document.prototype, Backbone.Events, {
         }
     },
     undo: function() {
-        var transformation = this.undoStack.pop();
-        if(transformation) {
+        var transformationObject = this.undoStack.pop(),
+            doc = this,
+            transformations, stopAt;
+
+        if(transformationObject) {
             this._undoInProgress = true;
-            transformation.undo();
+
+            if(_.isArray(transformationObject)) {
+                // We will modify this array in a minute so make sure we work on a copy.
+                transformations = transformationObject.slice(0);
+            } else {
+                // Lets normalize single transformation to a transaction containing one transformation.
+                transformations = [transformationObject];
+            }
+
+            if(transformations.length > 1) {
+                // In case of real transactions we don't want to run undo on all of transformations if we don't have to.
+                stopAt = undefined;
+                transformations.some(function(t, idx) {
+                    if(!t.undo && t.getChangeRoot().sameNode(doc.root)) {
+                        stopAt = idx;
+                        return true; //break
+                    }
+                });
+                if(stopAt !== undefined) {
+                    // We will get away with undoing only this transformations as the one at stopAt reverses the whole document.
+                    transformations = transformations.slice(0, stopAt+1);
+                }
+            }
+
+            transformations.reverse();
+            transformations.forEach(function(t) {
+                t.undo();
+            });
+
             this._undoInProgress = false;
-            this.redoStack.push(transformation);
+            this.redoStack.push(transformationObject);
         }
     },
     redo: function() {
-        var transformation = this.redoStack.pop();
-        if(transformation) {
+        var transformationObject = this.redoStack.pop(),
+            transformations;
+        if(transformationObject) {
             this._transformationLevel++;
-            transformation.run({beUndoable: true});
+            transformations = _.isArray(transformationObject) ? transformationObject : [transformationObject];
+            transformations.forEach(function(t) {
+                t.run({beUndoable: true});
+            });
             this._transformationLevel--;
-            this.undoStack.push(transformation);
+            this.undoStack.push(transformationObject);
+        }
+    },
 
+    startTransaction: function() {
+        if(this._transactionInProgress) {
+            throw new Error('Nested transactions not supported!');
+        }
+        this._transactionInProgress = true;
+    },
+
+    endTransaction: function() {
+        if(!this._transactionInProgress) {
+            throw new Error('End of transaction requested, but there is no transaction in progress!');
+        }
+        this._transactionInProgress = false;
+        if(this._transactionStack.length) {
+            this.undoStack.push(this._transactionStack);
+            this._transactionStack = [];
         }
     },