X-Git-Url: https://git.mdrn.pl/fnpeditor.git/blobdiff_plain/e1fef8a5849274a64f2c75ea4c7a261d67cea1a3..06ff71dcb6c913a66280ebf812481224ee461f8c:/src/smartxml/smartxml.js?ds=sidebyside diff --git a/src/smartxml/smartxml.js b/src/smartxml/smartxml.js index aa04fd7..05583c5 100644 --- a/src/smartxml/smartxml.js +++ b/src/smartxml/smartxml.js @@ -11,6 +11,16 @@ define([ var TEXT_NODE = Node.TEXT_NODE; +var INSERTION = function(implementation) { + var toret = function(node) { + var insertion = this.getNodeInsertion(node); + implementation.call(this, insertion.ofNode.nativeNode); + this.triggerChangeEvent(insertion.insertsNew ? 'nodeAdded' : 'nodeMoved', {node: insertion.ofNode}); + return insertion.ofNode; + }; + return toret; +}; + var DocumentNode = function(nativeNode, document) { if(!document) { throw new Error('undefined document for a node'); @@ -26,40 +36,132 @@ $.extend(DocumentNode.prototype, { this._$ = $(nativeNode); }, - detach: function() { this._$.detach(); }, + isRoot: function() { + return this.document.root.sameNode(this); + }, + + detach: function() { + var parent = this.parent(); + this._$.detach(); + this.triggerChangeEvent('nodeDetached', {parent: parent}); + return this; + }, sameNode: function(otherNode) { - return this.nativeNode === otherNode.nativeNode; + return otherNode && this.nativeNode === otherNode.nativeNode; }, parent: function() { - return this.nativeNode.parentNode ? this.document.createElementNode(this.nativeNode.parentNode) : null; + var parentNode = this.nativeNode.parentNode; + if(parentNode && parentNode.nodeType === Node.ELEMENT_NODE) { + return this.document.createElementNode(parentNode); + } + return null; + }, + + parents: function() { + var parent = this.parent(), + parents = parent ? parent.parents() : []; + if(parent) { + parents.unshift(parent); + } + return parents; }, - before: function(node) { - this._$.before(node.nativeNode); + prev: function() { + var myIdx = this.getIndex(); + return myIdx > 0 ? this.parent().contents()[myIdx-1] : null; }, + next: function() { + if(this.isRoot()) { + return null; + } + var myIdx = this.getIndex(), + parentContents = this.parent().contents(); + return myIdx < parentContents.length - 1 ? parentContents[myIdx+1] : null; + }, + + after: INSERTION(function(nativeNode) { + return this._$.after(nativeNode); + }), + + before: INSERTION(function(nativeNode) { + return this._$.before(nativeNode); + }), + wrapWith: function(node) { + var insertion = this.getNodeInsertion(node); if(this.parent()) { - this.before(node); + this.before(insertion.ofNode); + } + insertion.ofNode.append(this); + return insertion.ofNode; + }, + + /** + * Removes parent of a node if node has no siblings. + */ + unwrap: function() { + if(this.isRoot()) { + return; + } + var parent = this.parent(), + grandParent; + if(parent.contents().length === 1) { + grandParent = parent.parent(); + parent.unwrapContent(); + return grandParent; } - node.append(this); }, triggerChangeEvent: function(type, metaData) { var event = new events.ChangeEvent(type, $.extend({node: this}, metaData || {})); - this.document.trigger('change', event); + if(type === 'nodeDetached' || this.document.containsNode(event.meta.node)) { + 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; }, + + getIndex: function() { + if(this.isRoot()) { + return 0; + } + return this.parent().indexOf(this); + } }); var ElementNode = function(nativeNode, document) { DocumentNode.call(this, nativeNode, document); }; +ElementNode.prototype = Object.create(DocumentNode.prototype); -$.extend(ElementNode.prototype, DocumentNode.prototype, { +$.extend(ElementNode.prototype, { nodeType: Node.ELEMENT_NODE, + detach: function() { + var prev = this.prev(), + next = this.next(); + if(parent) { + if(prev && prev.nodeType === Node.TEXT_NODE && next && next.nodeType === Node.TEXT_NODE) { + prev.appendText(next.getText()); + next.detach(); + } + } + return DocumentNode.prototype.detach.call(this); + }, + setData: function(key, value) { if(value !== undefined) { this._$.data(key, value); @@ -100,7 +202,8 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { setTag: function(tagName) { var node = this.document.createElementNode({tagName: tagName}), - oldTagName = this.getTagName(); + oldTagName = this.getTagName(), + myContents = this._$.contents(); this.getAttrs().forEach(function(attribute) { node.setAttr(attribute.name, attribute.value, true); @@ -112,6 +215,7 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { } this._$.replaceWith(node._$); this._setNativeNode(node._$[0]); + this._$.append(myContents); this.triggerChangeEvent('nodeTagChange', {oldTagName: oldTagName, newTagName: this.getTagName()}); }, @@ -135,9 +239,13 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { return toret; }, - append: function(documentNode) { - this._$.append(documentNode.nativeNode); - }, + append: INSERTION(function(nativeNode) { + this._$.append(nativeNode); + }), + + prepend: INSERTION(function(nativeNode) { + this._$.prepend(nativeNode); + }), unwrapContent: function() { var parent = this.parent(); @@ -149,6 +257,7 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { myContents = this.contents(), myIdx = parent.indexOf(this); + if(myContents.length === 0) { return this.detach(); } @@ -185,30 +294,65 @@ $.extend(ElementNode.prototype, DocumentNode.prototype, { }; }, + wrapText: function(params) { + return this.document._wrapText(_.extend({inside: this}, params)); + }, + toXML: function() { var wrapper = $('
'); - wrapper.append(this._$); + wrapper.append(this._getXMLDOMToDump()); return wrapper.html(); + }, + + _getXMLDOMToDump: function() { + return this._$; } }); var TextNode = function(nativeNode, document) { DocumentNode.call(this, nativeNode, document); }; +TextNode.prototype = Object.create(DocumentNode.prototype); -$.extend(TextNode.prototype, DocumentNode.prototype, { +$.extend(TextNode.prototype, { nodeType: Node.TEXT_NODE, getText: function() { return this.nativeNode.data; }, + setText: function(text) { + this.nativeNode.data = text; + this.triggerTextChangeEvent(); + }, + appendText: function(text) { this.nativeNode.data = this.nativeNode.data + text; + this.triggerTextChangeEvent(); }, prependText: function(text) { this.nativeNode.data = text + this.nativeNode.data; + this.triggerTextChangeEvent(); + }, + + wrapWith: function(desc) { + if(typeof desc.start === 'number' && typeof desc.end === 'number') { + return this.document._wrapText({ + inside: this.parent(), + textNodeIdx: this.parent().indexOf(this), + offsetStart: Math.min(desc.start, desc.end), + offsetEnd: Math.max(desc.start, desc.end), + _with: {tagName: desc.tagName, attrs: desc.attrs} + }); + } else { + return DocumentNode.prototype.wrapWith.call(this, desc); + } + }, + + triggerTextChangeEvent: function() { + var event = new events.ChangeEvent('nodeTextChange', {node: this}); + this.document.trigger('change', event); } }); @@ -227,23 +371,155 @@ $.extend(Document.prototype, Backbone.Events, { createElementNode: function(from) { if(!(from instanceof HTMLElement)) { - from = $('<' + from.tagName + '>'); + if(from.text) { + from = document.createTextNode(from.text); + } else { + var node = $('<' + from.tagName + '>'); + + _.keys(from.attrs || {}).forEach(function(key) { + node.attr(key, from.attrs[key]); + }); + + from = node[0]; + } } - return new this.ElementNodeFactory(from, this); + var Factory; + if(from.nodeType === Node.TEXT_NODE) { + Factory = this.TextNodeFactory; + } else if(from.nodeType === Node.ELEMENT_NODE) { + Factory = this.ElementNodeFactory; + } + return new Factory(from, this); }, createTextNode: function(nativeNode) { return new this.TextNodeFactory(nativeNode, this); }, - loadXML: function(xml) { + loadXML: function(xml, options) { + options = options || {}; defineDocumentProperties(this, $(parseXML(xml))); - - this.trigger('contentSet'); + if(!options.silent) { + this.trigger('contentSet'); + } }, toXML: function() { return this.root.toXML(); + }, + + containsNode: function(node) { + return this.root && (node.nativeNode === this.root.nativeNode || node._$.parents().index(this.root._$) !== -1); + }, + + wrapNodes: function(params) { + if(!(params.element1.parent().sameNode(params.element2.parent()))) { + throw new Error('Wrapping non-sibling nodes not supported.'); + } + + var parent = params.element1.parent(), + parentContents = parent.contents(), + wrapper = this.createElementNode({ + tagName: params._with.tagName, + attrs: params._with.attrs}), + idx1 = parent.indexOf(params.element1), + idx2 = parent.indexOf(params.element2); + + if(idx1 > idx2) { + var tmp = idx1; + idx1 = idx2; + idx2 = tmp; + } + + var insertingMethod, insertingTarget; + if(idx1 === 0) { + insertingMethod = 'prepend'; + insertingTarget = parent; + } else { + insertingMethod = 'after'; + insertingTarget = parentContents[idx1-1]; + } + + for(var i = idx1; i <= idx2; i++) { + wrapper.append(parentContents[i].detach()); + } + + insertingTarget[insertingMethod](wrapper); + return wrapper; + }, + + getSiblingParents: function(params) { + var parents1 = [params.node1].concat(params.node1.parents()).reverse(), + parents2 = [params.node2].concat(params.node2.parents()).reverse(), + noSiblingParents = null; + + if(parents1.length === 0 || parents2.length === 0 || !(parents1[0].sameNode(parents2[0]))) { + return noSiblingParents; + } + + var i; + for(i = 0; i < Math.min(parents1.length, parents2.length); i++) { + if(parents1[i].sameNode(parents2[i])) { + continue; + } + break; + } + return {node1: parents1[i], node2: parents2[i]}; + }, + + _wrapText: function(params) { + params = _.extend({textNodeIdx: 0}, params); + if(typeof params.textNodeIdx === 'number') { + params.textNodeIdx = [params.textNodeIdx]; + } + + var contentsInside = params.inside.contents(), + idx1 = Math.min.apply(Math, params.textNodeIdx), + idx2 = Math.max.apply(Math, params.textNodeIdx), + textNode1 = contentsInside[idx1], + textNode2 = contentsInside[idx2], + sameNode = textNode1.sameNode(textNode2), + prefixOutside = textNode1.getText().substr(0, params.offsetStart), + prefixInside = textNode1.getText().substr(params.offsetStart), + suffixInside = textNode2.getText().substr(0, params.offsetEnd), + suffixOutside = textNode2.getText().substr(params.offsetEnd) + ; + + if(!(textNode1.parent().sameNode(textNode2.parent()))) { + throw new Error('Wrapping text in non-sibling text nodes not supported.'); + } + + var wrapperElement = this.createElementNode({tagName: params._with.tagName, attrs: params._with.attrs}); + textNode1.after(wrapperElement); + textNode1.detach(); + + if(prefixOutside.length > 0) { + wrapperElement.before({text:prefixOutside}); + } + if(sameNode) { + var core = textNode1.getText().substr(params.offsetStart, params.offsetEnd - params.offsetStart); + wrapperElement.append({text: core}); + } else { + textNode2.detach(); + if(prefixInside.length > 0) { + wrapperElement.append({text: prefixInside}); + } + for(var i = idx1 + 1; i < idx2; i++) { + wrapperElement.append(contentsInside[i]); + } + if(suffixInside.length > 0) { + wrapperElement.append({text: suffixInside}); + } + } + if(suffixOutside.length > 0) { + wrapperElement.after({text: suffixOutside}); + } + return wrapperElement; + }, + + trigger: function() { + //console.log('trigger: ' + arguments[0] + (arguments[1] ? ', ' + arguments[1].type : '')); + Backbone.Events.trigger.apply(this, arguments); } });