small refactor + fix brackets
[fnpeditor.git] / src / editor / modules / documentCanvas / canvas / documentElement.js
1 define([
2 'libs/jquery',
3 'libs/underscore',
4 'modules/documentCanvas/canvas/utils',
5 'modules/documentCanvas/canvas/container'
6 ], function($, _, utils, container) {
7     
8 'use strict';
9 /* global Node:false */
10
11 // DocumentElement represents a text or an element node from WLXML document rendered inside Canvas
12 var DocumentElement = function(wlxmlNode, canvas) {
13     this.wlxmlNode = wlxmlNode;
14     this.canvas = canvas;
15     this.state = {
16         exposed: false,
17         active: false
18     };
19
20     this.dom = this.createDOM();
21     this.dom.data('canvas-element', this);
22     this.wlxmlNode.setData('canvasElement', this);
23 };
24
25 $.extend(DocumentElement.prototype, {
26     refreshPath: function() {
27         this.parents().forEach(function(parent) {
28             parent.refresh();
29         });
30         this.refresh();
31     },
32     refresh: function() {
33         // noop
34     },
35     updateState: function(toUpdate) {
36         var changes = {};
37         _.keys(toUpdate)
38             .filter(function(key) {
39                 return this.state.hasOwnProperty(key);
40             }.bind(this))
41             .forEach(function(key) {
42                 if(this.state !== toUpdate[key]) {
43                     this.state[key] = changes[key] = toUpdate[key];
44                 }
45             }.bind(this));
46         // console.log(changes);
47         if(_.isFunction(this.onStateChange)) {
48             this.onStateChange(changes);
49             if(_.isBoolean(changes.active)) {
50                 if(changes.active) {
51                     var ptr = this;
52                     while(ptr && ptr.wlxmlNode.getTagName() === 'span') {
53                         ptr = ptr.parent();
54                     }
55                     if(ptr && ptr.gutterGroup) {
56                         ptr.gutterGroup.show();
57                     }
58                 }
59             }
60         }
61     },
62     parent: function() {
63         var parents = this.dom.parents('[document-node-element]');
64         if(parents.length) {
65             return this.canvas.getDocumentElement(parents[0]);
66         }
67         return null;
68     },
69
70     parents: function() {
71         var parents = [],
72             parent = this.parent();
73         while(parent) {
74             parents.push(parent);
75             parent = parent.parent();
76         }
77         return parents;
78     },
79
80     sameNode: function(other) {
81         return other && (typeof other === typeof this) && other.dom[0] === this.dom[0];
82     },
83     isRootElement: function() {
84         return this.sameNode(this.canvas.rootElement);
85     },
86
87     trigger: function() {
88         this.canvas.eventBus.trigger.apply(this.canvas.eventBus, Array.prototype.slice.call(arguments, 0));
89     }
90
91
92 });
93
94
95 // DocumentNodeElement represents an element node from WLXML document rendered inside Canvas
96 var DocumentNodeElement = function(wlxmlNode, canvas) {
97     DocumentElement.call(this, wlxmlNode, canvas);
98     this.containers = [];
99     this.elementsRegister = canvas.createElementsRegister();
100     this.contextMenuActions = [];
101     this.init(this.dom);
102 };
103
104
105 var manipulate = function(e, params, action) {
106     var element;
107     if(params instanceof DocumentElement) {
108         element = params;
109     } else {
110         element = e.createElement(params);
111     }
112     if(element.dom) {
113         e.dom[action](element.dom);
114         e.refreshPath();
115     }
116     return element;
117 };
118
119 DocumentNodeElement.prototype = Object.create(DocumentElement.prototype);
120
121
122 $.extend(DocumentNodeElement.prototype, {
123     defaultDisplayStyle: 'block',
124     init: function() {},
125     addWidget: function(widget) {
126         this.dom.children('.canvas-widgets').append(widget.DOM ? widget.DOM : widget);
127     },
128     clearWidgets: function() {
129         this.dom.children('.canvas-widgets').empty();
130     },
131     addToGutter: function(view) {
132         if(!this.gutterGroup) {
133             this.gutterGroup = this.canvas.gutter.createViewGroup({
134                 offsetHint: function() {
135                     return this.canvas.getElementOffset(this);
136                 }.bind(this)
137             }, this);
138         }
139         this.gutterGroup.addView(view);
140     },
141     createContainer: function(nodes, params) {
142         var toret = container.create(nodes, params, this);
143         this.containers.push(toret);
144         return toret;
145     },
146     removeContainer: function(container) {
147         var idx;
148         if((idx = this.containers.indexOf(container)) !== -1) {
149             this.containers.splice(idx, 1);
150         }
151     },
152     createElement: function(wlxmlNode) {
153         var parent = this.wlxmlNode.parent() ? utils.getElementForNode(this.wlxmlNode.parent()) : null;
154         return this.canvas.createElement(wlxmlNode, this.elementsRegister, !parent) || parent.createElement(wlxmlNode);
155     },
156     addToContextMenu: function(actionFqName) {
157         this.contextMenuActions.push(this.canvas.createAction(actionFqName));
158     },
159     handle: function(event) {
160         var method = 'on' + event.type[0].toUpperCase() + event.type.substr(1),
161             target;
162         if(event.type === 'nodeAdded' || event.type === 'nodeDetached') {
163             this.containers.some(function(container) {
164                 if(container.manages(event.meta.node, event.meta.parent)) {
165                     target = container;
166                     return true;
167                 }
168             });
169         }
170         
171         if(!target && this[method]) {
172             target = this;
173         }
174         
175         if(target) {
176             target[method](event);
177         }
178     },
179     createDOM: function() {
180         var wrapper = $('<div>').attr('document-node-element', ''),
181             widgetsContainer = $('<div>')
182                 .addClass('canvas-widgets'),
183             contentContainer = $('<div>')
184                 .attr('document-element-content', '');
185         
186         wrapper.append(contentContainer, widgetsContainer);
187         widgetsContainer.find('*').add(widgetsContainer).attr('tabindex', -1);
188         return wrapper;
189     },
190     _container: function() {
191         return this.dom.children('[document-element-content]');
192     },
193     detach: function(isChild) {
194         var parents;
195
196         if(this.gutterGroup) {
197             this.gutterGroup.remove();
198         }
199         if(_.isFunction(this.children)) {
200             this.children().forEach(function(child) {
201                 child.detach(true);
202             });
203         }
204
205         if(!isChild) {
206             parents = this.parents();
207             this.dom.detach();
208             if(parents[0]) {
209                 parents[0].refreshPath();
210             }
211         }
212         return this;
213     },
214     before: function(params) {
215         return manipulate(this, params, 'before');
216
217     },
218     after: function(params) {
219         return manipulate(this, params, 'after');
220     },
221
222     isBlock: function() {
223         return this.dom.css('display') === 'block';
224     },
225
226     displayAsBlock: function() {
227         this.dom.css('display', 'block');
228         this._container().css('display', 'block');
229     },
230     displayInline: function() {
231         this.dom.css('display', 'inline');
232         this._container().css('display', 'inline');
233     },
234     displayAs: function(what) {
235         // [this.dom(), this._container()].forEach(e) {
236         //     var isBlock = window.getComputedStyle(e).display === 'block';
237         //     if(!isBlock && what === 'block') {
238         //         e.css('display', what);
239         //     } else if(isBlock && what === 'inline') {
240         //         e.css('display')
241         //     }
242         // })
243         this.dom.css('display', what);
244         this._container().css('display', what);
245     },
246     children: function() {
247         return [];
248     }
249 });
250
251
252 // DocumentNodeElement represents a text node from WLXML document rendered inside Canvas
253 var DocumentTextElement = function(wlxmlTextNode, canvas) {
254     DocumentElement.call(this, wlxmlTextNode, canvas);
255 };
256
257 $.extend(DocumentTextElement, {
258     isContentContainer: function(htmlElement) {
259         return htmlElement.nodeType === Node.TEXT_NODE && $(htmlElement).parent().is('[document-text-element]');
260     }
261 });
262
263 DocumentTextElement.prototype = Object.create(DocumentElement.prototype);
264
265 $.extend(DocumentTextElement.prototype, {
266     createDOM: function() {
267         var dom = $('<div>')
268             .attr('document-text-element', '')
269             .text(this.wlxmlNode.getText() || utils.unicode.ZWS);
270         return dom;
271     },
272     detach: function(isChild) {
273         if(!isChild) {
274             this.dom.detach();
275         }
276         return this;
277     },
278     setText: function(text) {
279         if(text === '') {
280             text = utils.unicode.ZWS;
281         }
282         if(text !== this.getText()) {
283             this.dom.contents()[0].data = text;
284         }
285     },
286     handle: function(event) {
287         this.setText(event.meta.node.getText());
288     },
289     getText: function(options) {
290         options = _.extend({raw: false}, options || {});
291         var toret = this.dom.text();
292         if(!options.raw) {
293             toret = toret.replace(utils.unicode.ZWS, '');
294         }
295         return toret;
296     },
297     isEmpty: function() {
298         // Having at least Zero Width Space is guaranteed be Content Observer
299         return this.dom.contents()[0].data === utils.unicode.ZWS;
300     },
301     after: function(params) {
302         if(params instanceof DocumentTextElement || params.text) {
303             return false;
304         }
305         var element;
306         if(params instanceof DocumentNodeElement) {
307             element = params;
308         } else {
309             element = this.parent().createElement(params);
310         }
311         if(element.dom) {
312             this.dom.wrap('<div>');
313             this.dom.parent().after(element.dom);
314             this.dom.unwrap();
315             this.refreshPath();
316         }
317         return element;
318     },
319     before: function(params) {
320         if(params instanceof DocumentTextElement || params.text) {
321             return false;
322         }
323         var element;
324         if(params instanceof DocumentNodeElement) {
325             element = params;
326         } else {
327             element = this.createElement(params);
328         }
329         if(element.dom) {
330             this.dom.wrap('<div>');
331             this.dom.parent().before(element.dom);
332             this.dom.unwrap();
333             this.refreshPath();
334         }
335         return element;
336     },
337
338     children: function() {
339         return [];
340     }
341
342 });
343
344
345 return {
346     DocumentElement: DocumentElement,
347     DocumentNodeElement: DocumentNodeElement,
348     DocumentTextElement: DocumentTextElement
349 };
350
351 });