refactoring
[fnpeditor.git] / src / smartxml / transformation_api_exp.js
1 //use case: edytor robi split, jesli split był na koncu (czyli druga czesc jest pusta)
2 // chce tam dodac wezel tekstowy
3
4 // flow: plugin_key_handler(enter, main-canvas-area) -> plugin_document_action('break-content')
5 // --w srodku--> refactoring tego co teraz w keyboard:
6
7 //1. jedna transformacja z warunkiem (Zarejestrowana przez plugin)
8
9
10
11 var breakContentTransformation = {
12     impl: function(args) {
13         var node = this.context;
14             emptyText = false,
15             newNodes,
16             emptyNode;
17
18         newNodes = node.transform('core.split', {offset: args.offset});
19
20         if(args.offset === 0)
21             emptyNode = newNodes.first;
22         else if(args.offset === node.getText().length); //@ nie ma atEnd :(
23             emptyNode = newNodes.second;
24         
25         if(emptyNode) {
26             emptyText = emptyNode.transform('core.append', {text: ''});
27         }
28
29         return _.extend(newNodes, {emptyText: emptyText});
30     }
31 };
32
33
34 var breakContentAction = function(document, context) {
35     var textNode = context.currentTextNode;
36     if(textNode) {
37         var result, goto;
38
39         result = textNode.transform('core.break-content', {offset: context.offset});
40
41         if(result.emptyText) {
42             goto = result.createdEmpty;
43             gotoOptions = {};
44         } else {
45             goto = result.second;
46             gotoOptions = {caretTo: 'start'};   
47         }
48
49         context.setCurrentElement(goto, gotoOptions);
50     }
51 }
52
53 var toret = {
54     keyHandlers: [
55         {key: 'ENTER', target: 'main-document-area', handler: function(editor) {
56             editor.getAction('core.break-document-content').execute();
57         }},
58     ],
59     
60     actions: [
61         {name: 'core.break-document-content', context: 'main-document-area', action: breakContentAction}
62     ],
63
64     // zapisywanie dokumentu:
65
66     contextTransformations: [
67         {name: 'core.break-content', textNode: true, t: breakContentTransformation},
68
69         // list plugin:
70         {name: 'list.remove-list', elementNode: 'list', t: null}
71         // hipotetyczna akcja na itemie listy
72         {name: 'list.extract', elementNode: 'item', requiresParent: 'list', requiresInParents: '?'}
73     ],
74
75 }
76
77
78 /// STARE
79
80 // 1. detach via totalny fallback
81 var DetachNodeTransformation = function(args) {
82     this.node = args.node;
83     this.document = this.node.document;
84 };
85 $.extend(DetachNodeTransformation.prototype, {
86     run: function() {
87         this.oldRoot = this.node.document.root.clone();
88         this.path = this.node.getPath();
89         this.node.detach(); // @TS
90         
91     },
92     undo: function() {
93         this.document.root.replaceWith(this.oldRoot); // this.getDocument?
94         this.node = this.document.getNodeByPath(this.path);
95     }
96 });
97 transformations['detach'] = DetachNodeTransformation;
98
99 //2. detach via wskazanie changeroot
100
101 var Detach2NodeTransformation = function(args) {
102     this.nodePath = args.node.getPath();
103     this.document = args.node.document;
104 };
105 $.extend(Detach2NodeTransformation.prototype, {
106     run: function() {
107         var node = this.document.getNodeByPath(this.nodePath),
108             root = node.parent() ? node.parent() : this.document.root;
109         
110         this.rootPath = root.getPath();
111         this.oldRoot = (root).clone();
112         node.detach();
113     },
114     undo: function() {
115         this.document.getNodeByPath(this.rootPath).replaceWith(this.oldRoot);
116     }
117 });
118 //transformations['detach2'] = Detach2NodeTransformation;
119
120 //2a. generyczna transformacja
121
122 var createTransformation = function(desc) {
123
124     var NodeTransformation = function(args) {
125         this.nodePath = args.node.getPath();
126         this.document = args.node.document;
127         this.args = args;
128     };
129     $.extend(NodeTransformation.prototype, {
130         run: function() {
131             var node = this.document.getNodeByPath(this.nodePath),
132                 root;
133
134             if(desc.getRoot) {
135                 root = desc.getRoot(node);
136             } else {
137                 root = this.document.root;
138             }
139             
140             this.rootPath = root.getPath();
141             this.oldRoot = (root).clone();
142             desc.impl.call(node, this.args);
143         },
144         undo: function() {
145             this.document.getNodeByPath(this.rootPath).replaceWith(this.oldRoot);
146         }
147     });
148
149     return NodeTransformation;
150 }
151
152
153
154 var contextTransformations = {};
155 contextTransformations['setText'] = createContextTransformation({
156     impl: function(args) {
157         this.setText(args.text);
158     },
159     getChangeRoot: function() {
160         return this.context;
161     }
162 });
163
164 contextTransformations['setAttr'] = createContextTransformation({
165     impl: function(args) {
166         this.setAttr(args.name, args.value);
167     },
168     getChangeRoot: function() {
169         return this.context;
170     }
171 });
172
173 contextTransformations['split'] = createContextTransformation({
174     impl: function(args) {
175         return this.split({offset: args.offset});
176     }//,
177     // getChangeRoot: function() {
178     //     return this.context.parent().parent();
179     // }
180 });
181
182
183 contextTransformations['before'] = createContextTransformation({
184     getChangeRoot: function() {
185         return this.context.parent();
186     },
187     impl: function(args) {
188         this.before(args.node)
189     },
190
191 });
192
193 contextTransformations['before'] = createContextTransformation({
194     impl: function(args) {
195         this.before(args.node)
196     },
197     undo: function() {
198         this.context.detach();
199     }
200 });
201
202
203
204 transformations['detach2'] = createTransformation({
205     // impl: function() {
206     //     //this.setAttr('class', 'cite'); //  
207     // },
208     impl: ElementNode.prototype.detach,
209     getRoot: function(node) {
210         return node.parent();
211     }
212
213 });
214
215 transformations['setText-old'] = createTransformation({
216     impl: function(args) {
217         this.setText(args.text)
218     },
219     getRoot: function(node) {
220         return node;
221     }
222
223 });
224
225 transformations['setClass-old'] = createTransformation({
226     impl: function(args) {
227         this.setClass(args.klass);
228     },
229     getRoot: function(node) {
230         return node;
231     }
232 })
233
234 //3. detach z pełnym własnym redo
235
236 var Detach3NodeTransformation = function(args) {
237     this.node = args.node;
238     this.document = this.node.document;
239 };
240 $.extend(Detach3NodeTransformation.prototype, {
241     run: function() {
242         //this.index = this.node.getIndex();
243         //this.parent = this.node.parent();
244         
245         this.path = this.node.getPath();
246         if(this.node.isSurroundedByTextElements()) {
247             this.prevText = this.node.prev().getText();
248             this.nextText = this.node.next().getText();
249             this.merge = true;
250         } else {
251             this.prevText = this.nextText = null;
252             this.merge = false;
253         }
254
255         this.node.detach();
256     },
257     undo: function() {
258         var parent = this.document.getNodeByPath(this.path.slice(0,-1)),
259             idx = _.last(this.path);
260         var inserted = parent.insertAtIndex(this.node, idx);
261         if(this.merge) {
262             if(inserted.next()) {
263                 inserted.before({text: this.prevText});
264                 inserted.next().setText(this.nextText);
265             } else {
266                 inserted.prev().setText(this.prevText);
267                 inserted.after({text: this.nextText});
268             }
269         }
270     }
271 });
272 transformations['detach3'] = Detach3NodeTransformation;
273
274
275 var registerTransformationsFromObject = function(object) {
276     _.pairs(object).filter(function(pair) {
277         var property = pair[1];
278         return typeof property === 'function' && property._isTransformation;
279     })
280     .forEach(function(pair) {
281         var name = pair[0],
282             method = pair[1];
283         object.registerTransformation(name, createContextTransformation(method));
284     });
285 };
286 registerTransformationsFromObject(ElementNode.prototype);
287 registerTransformationsFromObject(TextNode.prototype);
288 registerTransformationsFromObject(Document.prototype);