X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/59b807cd7a781fad54e66f1e59b09369d91d53b4..7a67ffc356936a4eec4243df03fab2ad1c66c9b9:/src/smartxml/smartxml.js?ds=sidebyside diff --git a/src/smartxml/smartxml.js b/src/smartxml/smartxml.js index e484070..831a96a 100644 --- a/src/smartxml/smartxml.js +++ b/src/smartxml/smartxml.js @@ -2,20 +2,26 @@ define([ 'libs/jquery', 'libs/underscore', 'libs/backbone', - 'smartxml/events' -], function($, _, Backbone, events) { + 'smartxml/events', + 'smartxml/transformations' +], function($, _, Backbone, events, transformations) { 'use strict'; - +/* globals Node */ var TEXT_NODE = Node.TEXT_NODE; var INSERTION = function(implementation) { var toret = function(node) { - var insertion = this.getNodeInsertion(node); + var insertion = this.getNodeInsertion(node), + nodeWasContained = this.document.containsNode(insertion.ofNode), + nodeParent; + if(!(this.document.containsNode(this))) { + nodeParent = insertion.ofNode.parent(); + } implementation.call(this, insertion.ofNode.nativeNode); - this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}); + this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}, nodeParent, nodeWasContained); return insertion.ofNode; }; return toret; @@ -31,11 +37,49 @@ var DocumentNode = function(nativeNode, document) { }; $.extend(DocumentNode.prototype, { + + transform: function(Transformation, args) { + var transformation = new Transformation(this.document, this, args); + return this.document.transform(transformation); + }, + _setNativeNode: function(nativeNode) { this.nativeNode = nativeNode; this._$ = $(nativeNode); }, + clone: function() { + var clone = this._$.clone(true, true); + // clone.find('*').addBack().each(function() { + // var n = $(this); + // if(n.data('canvasElement')) { + // n.data('canvasElement', $.extend(true, {}, n.data('canvasElement'))); + // n.data('canvasElement').$element = n.data('canvasElement').$element.clone(true, true); + // } + // }); + return this.document.createDocumentNode(clone[0]); + }, + + getPath: function(ancestor) { + var nodePath = [this].concat(this.parents()), + toret, idx; + ancestor = ancestor || this.document.root; + + nodePath.some(function(node, i) { + if(node.sameNode(ancestor)) { + idx = i; + return true; + } + }); + + if(idx !== 'undefined') { + nodePath = nodePath.slice(0, idx); + } + toret = nodePath.map(function(node) {return node.getIndex(); }); + toret.reverse(); + return toret; + }, + isRoot: function() { return this.document.root.sameNode(this); }, @@ -47,14 +91,24 @@ $.extend(DocumentNode.prototype, { return this; }, + replaceWith: function(node) { + var toret; + if(this.isRoot()) { + return this.document.replaceRoot(node); + } + toret = this.after(node); + this.detach(); + return toret; + }, + sameNode: function(otherNode) { - return otherNode && this.nativeNode === otherNode.nativeNode; + return !!(otherNode) && this.nativeNode === otherNode.nativeNode; }, parent: function() { var parentNode = this.nativeNode.parentNode; if(parentNode && parentNode.nodeType === Node.ELEMENT_NODE) { - return this.document.createElementNode(parentNode); + return this.document.createDocumentNode(parentNode); } return null; }, @@ -82,6 +136,12 @@ $.extend(DocumentNode.prototype, { return myIdx < parentContents.length - 1 ? parentContents[myIdx+1] : null; }, + isSurroundedByTextElements: function() { + var prev = this.prev(), + next = this.next(); + return prev && (prev.nodeType === Node.TEXT_NODE) && next && (next.nodeType === Node.TEXT_NODE); + }, + after: INSERTION(function(nativeNode) { return this._$.after(nativeNode); }), @@ -91,13 +151,12 @@ $.extend(DocumentNode.prototype, { }), wrapWith: function(node) { - node = node instanceof ElementNode ? node : this.document.createElementNode(node); - + var insertion = this.getNodeInsertion(node); if(this.parent()) { - this.before(node); + this.before(insertion.ofNode); } - node.append(this); - return node; + insertion.ofNode.append(this); + return insertion.ofNode; }, /** @@ -116,23 +175,20 @@ $.extend(DocumentNode.prototype, { } }, - triggerChangeEvent: function(type, metaData) { - var event = new events.ChangeEvent(type, $.extend({node: this}, metaData || {})); + triggerChangeEvent: function(type, metaData, origParent, nodeWasContained) { + var node = (metaData && metaData.node) ? metaData.node : this, + event = new events.ChangeEvent(type, $.extend({node: node}, metaData || {})); if(type === 'nodeDetached' || this.document.containsNode(event.meta.node)) { this.document.trigger('change', event); } + if((type === 'nodeAdded' || type === 'nodeMoved') && !this.document.containsNode(this) && nodeWasContained) { + event = new events.ChangeEvent('nodeDetached', {node: node, parent: origParent}); + this.document.trigger('change', event); + } }, getNodeInsertion: function(node) { - var insertion = {}; - if(node instanceof DocumentNode) { - insertion.ofNode = node; - insertion.insertsNew = !this.document.containsNode(node); - } else { - insertion.ofNode = this.document.createElementNode(node); - insertion.insertsNew = true; - } - return insertion; + return this.document.getNodeInsertion(node); }, getIndex: function() { @@ -152,13 +208,11 @@ $.extend(ElementNode.prototype, { nodeType: Node.ELEMENT_NODE, detach: function() { - var prev = this.prev(), + var next; + if(this.parent() && this.isSurroundedByTextElements()) { next = this.next(); - if(parent) { - if(prev && prev.nodeType === Node.TEXT_NODE && next && next.nodeType === Node.TEXT_NODE) { - prev.appendText(next.getText()); - next.detach(); - } + this.prev().appendText(next.getText()); + next.detach(); } return DocumentNode.prototype.detach.call(this); }, @@ -183,17 +237,18 @@ $.extend(ElementNode.prototype, { return this.nativeNode.tagName.toLowerCase(); }, - contents: function() { + contents: function(selector) { var toret = [], document = this.document; - this._$.contents().each(function() { - if(this.nodeType === Node.ELEMENT_NODE) { - toret.push(document.createElementNode(this)); - } - else if(this.nodeType === Node.TEXT_NODE) { - toret.push(document.createTextNode(this)); - } - }); + if(selector) { + this._$.children(selector).each(function() { + toret.push(document.createDocumentNode(this)); + }); + } else { + this._$.contents().each(function() { + toret.push(document.createDocumentNode(this)); + }); + } return toret; }, @@ -202,7 +257,7 @@ $.extend(ElementNode.prototype, { }, setTag: function(tagName) { - var node = this.document.createElementNode({tagName: tagName}), + var node = this.document.createDocumentNode({tagName: tagName}), oldTagName = this.getTagName(), myContents = this._$.contents(); @@ -248,14 +303,22 @@ $.extend(ElementNode.prototype, { this._$.prepend(nativeNode); }), + insertAtIndex: function(nativeNode, index) { + var contents = this.contents(); + if(index < contents.length) { + return contents[index].before(nativeNode); + } else if(index === contents.length) { + return this.append(nativeNode); + } + }, + unwrapContent: function() { var parent = this.parent(); if(!parent) { return; } - var parentContents = parent.contents(), - myContents = this.contents(), + var myContents = this.contents(), myIdx = parent.indexOf(this); @@ -263,10 +326,12 @@ $.extend(ElementNode.prototype, { return this.detach(); } - var moveLeftRange, moveRightRange, leftMerged; + var prev = this.prev(), + next = this.next(), + moveLeftRange, moveRightRange, leftMerged; - if(myIdx > 0 && (parentContents[myIdx-1].nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) { - parentContents[myIdx-1].appendText(myContents[0].getText()); + if(prev && (prev.nodeType === TEXT_NODE) && (myContents[0].nodeType === TEXT_NODE)) { + prev.appendText(myContents[0].getText()); myContents[0].detach(); moveLeftRange = true; leftMerged = true; @@ -275,9 +340,10 @@ $.extend(ElementNode.prototype, { } if(!(leftMerged && myContents.length === 1)) { - if(myIdx < parentContents.length - 1 && (parentContents[myIdx+1].nodeType === TEXT_NODE) && (myContents[myContents.length-1].nodeType === TEXT_NODE)) { - parentContents[myIdx+1].prependText(myContents[myContents.length-1].getText()); - myContents[myContents.length-1].detach(); + var lastContents = _.last(myContents); + if(next && (next.nodeType === TEXT_NODE) && (lastContents.nodeType === TEXT_NODE)) { + next.prependText(lastContents.getText()); + lastContents.detach(); moveRightRange = true; } } @@ -323,6 +389,7 @@ $.extend(TextNode.prototype, { }, setText: function(text) { + //console.log('smartxml: ' + text); this.nativeNode.data = text; this.triggerTextChangeEvent(); }, @@ -351,6 +418,44 @@ $.extend(TextNode.prototype, { } }, + split: function(params) { + var parentElement = this.parent(), + passed = false, + succeedingChildren = [], + prefix = this.getText().substr(0, params.offset), + suffix = this.getText().substr(params.offset); + + parentElement.contents().forEach(function(child) { + if(passed) { + succeedingChildren.push(child); + } + if(child.sameNode(this)) { + passed = true; + } + }.bind(this)); + + if(prefix.length > 0) { + this.setText(prefix); + } + else { + this.detach(); + } + + var attrs = {}; + parentElement.getAttrs().forEach(function(attr) {attrs[attr.name] = attr.value; }); + var newElement = this.document.createDocumentNode({tagName: parentElement.getTagName(), attrs: attrs}); + parentElement.after(newElement); + + if(suffix.length > 0) { + newElement.append({text: suffix}); + } + succeedingChildren.forEach(function(child) { + newElement.append(child); + }); + + return {first: parentElement, second: newElement}; + }, + triggerTextChangeEvent: function() { var event = new events.ChangeEvent('nodeTextChange', {node: this}); this.document.trigger('change', event); @@ -359,20 +464,46 @@ $.extend(TextNode.prototype, { var parseXML = function(xml) { - return $(xml)[0]; + return $($.trim(xml))[0]; +}; + +var registerTransformation = function(desc, name, target) { + var Transformation = transformations.createContextTransformation(desc, name); + target[name] = function(args) { + var instance = this; + return instance.transform(Transformation, args); + } +}; + +var registerMethod = function(methodName, method, target) { + if(target[methodName]) { + throw new Error('Cannot extend {target} with method name {methodName}. Name already exists.' + .replace('{target}', target) + .replace('{methodName}', methodName) + ); + } + target[methodName] = method; }; + var Document = function(xml) { this.loadXML(xml); + this.undoStack = []; + this.redoStack = []; + this._transformationLevel = 0; + + this._nodeMethods = {}; + this._nodeTransformations = {}; }; $.extend(Document.prototype, Backbone.Events, { ElementNodeFactory: ElementNode, TextNodeFactory: TextNode, - createElementNode: function(from) { - if(!(from instanceof HTMLElement)) { - if(from.text) { + createDocumentNode: function(from) { + if(!(from instanceof Node)) { + if(from.text !== undefined) { + /* globals document */ from = document.createTextNode(from.text); } else { var node = $('<' + from.tagName + '>'); @@ -390,11 +521,10 @@ $.extend(Document.prototype, Backbone.Events, { } else if(from.nodeType === Node.ELEMENT_NODE) { Factory = this.ElementNodeFactory; } - return new Factory(from, this); - }, - - createTextNode: function(nativeNode) { - return new this.TextNodeFactory(nativeNode, this); + var toret = new Factory(from, this); + _.extend(toret, this._nodeMethods); + _.extend(toret, this._nodeTransformations); + return toret; }, loadXML: function(xml, options) { @@ -414,17 +544,17 @@ $.extend(Document.prototype, Backbone.Events, { }, wrapNodes: function(params) { - if(!(params.element1.parent().sameNode(params.element2.parent()))) { + if(!(params.node1.parent().sameNode(params.node2.parent()))) { throw new Error('Wrapping non-sibling nodes not supported.'); } - var parent = params.element1.parent(), + var parent = params.node1.parent(), parentContents = parent.contents(), - wrapper = this.createElementNode({ + wrapper = this.createDocumentNode({ tagName: params._with.tagName, attrs: params._with.attrs}), - idx1 = parent.indexOf(params.element1), - idx2 = parent.indexOf(params.element2); + idx1 = parent.indexOf(params.node1), + idx2 = parent.indexOf(params.node2); if(idx1 > idx2) { var tmp = idx1; @@ -490,7 +620,7 @@ $.extend(Document.prototype, Backbone.Events, { throw new Error('Wrapping text in non-sibling text nodes not supported.'); } - var wrapperElement = this.createElementNode({tagName: params._with.tagName, attrs: params._with.attrs}); + var wrapperElement = this.createDocumentNode({tagName: params._with.tagName, attrs: params._with.attrs}); textNode1.after(wrapperElement); textNode1.detach(); @@ -521,21 +651,136 @@ $.extend(Document.prototype, Backbone.Events, { trigger: function() { //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : '')); Backbone.Events.trigger.apply(this, arguments); + }, + + getNodeInsertion: function(node) { + var insertion = {}; + if(node instanceof DocumentNode) { + insertion.ofNode = node; + insertion.insertsNew = !this.containsNode(node); + } else { + insertion.ofNode = this.createDocumentNode(node); + insertion.insertsNew = true; + } + return insertion; + }, + + replaceRoot: function(node) { + var insertion = this.getNodeInsertion(node); + this.root.detach(); + defineDocumentProperties(this, insertion.ofNode._$); + insertion.ofNode.triggerChangeEvent('nodeAdded'); + return insertion.ofNode; + }, + + registerMethod: function(methodName, method) { + registerMethod(methodName, method, this); + }, + + registerNodeMethod: function(methodName, method) { + registerMethod(methodName, method, this._nodeMethods); + }, + + registerDocumentTransformation: function(desc, name) { + registerTransformation(desc, name, this); + }, + + registerNodeTransformation: function(desc, name) { + registerTransformation(desc, name, this._nodeTransformations); + }, + + registerExtension: function(extension) { + //debugger; + var doc = this, + existingPropertyNames = _.values(this); + + ['document', 'documentNode'].forEach(function(dstName) { + var dstExtension = extension[dstName]; + if(dstExtension) { + if(dstExtension.methods) { + _.pairs(dstExtension.methods).forEach(function(pair) { + var methodName = pair[0], + method = pair[1], + operation; + operation = {document: 'registerMethod', documentNode: 'registerNodeMethod'}[dstName]; + doc[operation](methodName, method); + + }); + } + + if(dstExtension.transformations) { + _.pairs(dstExtension.transformations).forEach(function(pair) { + var name = pair[0], + desc = pair[1], + operation; + operation = {document: 'registerDocumentTransformation', documentNode: 'registerNodeTransformation'}[dstName]; + doc[operation](desc, name); + }); + } + } + }); + }, + + transform: function(Transformation, args) { + //console.log('transform'); + var toret, transformation; + + if(typeof Transformation === 'function') { + transformation = new Transformation(this, this, args); + } else { + transformation = Transformation; + } + if(transformation) { + this._transformationLevel++; + toret = transformation.run(); + if(this._transformationLevel === 1) { + this.undoStack.push(transformation); + } + this._transformationLevel--; + //console.log('clearing redo stack'); + this.redoStack = []; + return toret; + } else { + throw new Error('Transformation ' + transformation + ' doesn\'t exist!'); + } + }, + undo: function() { + var transformation = this.undoStack.pop(); + if(transformation) { + transformation.undo(); + this.redoStack.push(transformation); + } + }, + redo: function() { + var transformation = this.redoStack.pop(); + if(transformation) { + transformation.run(); + this.undoStack.push(transformation); + } + }, + + getNodeByPath: function(path) { + var toret = this.root; + path.forEach(function(idx) { + toret = toret.contents()[idx]; + }); + return toret; } }); var defineDocumentProperties = function(doc, $document) { Object.defineProperty(doc, 'root', {get: function() { - return doc.createElementNode($document[0]); + return doc.createDocumentNode($document[0]); }, configurable: true}); Object.defineProperty(doc, 'dom', {get: function() { return $document[0]; }, configurable: true}); }; + return { documentFromXML: function(xml) { - return new Document(parseXML(xml)); + return new Document(xml); }, elementNodeFromXML: function(xml) { @@ -544,7 +789,8 @@ return { Document: Document, DocumentNode: DocumentNode, - ElementNode: ElementNode + ElementNode: ElementNode, + TextNode: TextNode }; }); \ No newline at end of file