tutorial in editor (mechanics only)

[fnpeditor.git] / src / wlxml / extensions / list / list.js

diff --git a/src/wlxml/extensions/list/list.js b/src/wlxml/extensions/list/list.js
index dd010a6..8d88115 100644 (file)
--- a/src/wlxml/extensions/list/list.js
+++ b/src/wlxml/extensions/list/list.js
@@ -2,12 +2,11 @@ define(function(require) {
 
 'use strict';
 
 
 'use strict';
 

+var _ = require('libs/underscore'),
+    extension = {document: {transformations: {}, methods: {}}, wlxmlClass: {list: {methods: {}}}};

 
 

-var wlxml = require('wlxml/wlxml'),
-    extension = {documentTransformations: [], classMethods: {}};

 
 

-
-extension.classMethods['list'] = {
+extension.wlxmlClass.list.methods = {

     itemIndex: function(listItem) {
         var toret = -1;
         this.contents('.item').some(function(item, index) {
     itemIndex: function(listItem) {
         var toret = -1;
         this.contents('.item').some(function(item, index) {


@@ -21,24 +20,59 @@ extension.classMethods['list'] = {
     getItem: function(index) {
         return this.contents('.item')[index];
     }
     getItem: function(index) {
         return this.contents('.item')[index];
     }

-}
+};
+
+extension.wlxmlClass.list.transformations = {
+    extractAllItems: function() {
+        var contents = this.contents();
+        return this.document.extractItems({item1: contents[0], item2: _.last(contents)});
+    }
+};
+
+extension.wlxmlClass.list.transformations = {
+    extractListItems: function() {
+        var contents = this.contents(),
+            first = contents[0],
+            last;
+        if(contents.length) {
+            last = contents[contents.length-1];
+            return this.document.extractItems({
+                item1: first,
+                item2: last
+            });
+        } else {
+            this.detach();
+        }
+    }
+};

 
 

-extension.documentTransformations.push({
-    name: 'createList',
-    impl: function(params) {          
+extension.document.methods = {
+    areItemsOfSameList: function(params) {
+        return params.node1.parent().sameNode(params.node2.parent()) && params.node2.parent().is('list');
+    }
+};
+
+extension.document.transformations.createList = {
+    impl: function(params) {
+        /* globals Node */

         var parent = params.node1.parent(),
             parentContents = parent.contents(),
         var parent = params.node1.parent(),
             parentContents = parent.contents(),

-            nodeIndexes = [params.node1.getIndex(), params.node2.getIndex()].sort(),
+            nodeIndexes = [params.node1.getIndex(), params.node2.getIndex()].sort(function(a,b) { return a-b; }),

             nodesToWrap = [],
             nodesToWrap = [],

-            listNode = params.node1.document.createDocumentNode({tagName: 'div', attrs: {'class': 'list.items'}}),
+            listClass = params.klass || 'list',
+            listNode = params.node1.document.createDocumentNode({tagName: 'div', attrs: {'class': listClass}}),
+            listPlacePtr = params.node1,

             node, i;
             node, i;

-
+        

         for(i = nodeIndexes[0]; i <= nodeIndexes[1]; i++) {
             node = parentContents[i];
             if(node.nodeType === Node.TEXT_NODE) {
         for(i = nodeIndexes[0]; i <= nodeIndexes[1]; i++) {
             node = parentContents[i];
             if(node.nodeType === Node.TEXT_NODE) {

-                node = node.wrapWith({tagName: 'div', attrs: {'class': 'item'}}); //t
+                node = node.wrapWith({tagName: 'div', attrs: {'class': 'item'}});
+                if(i === nodeIndexes[0]) {
+                    listPlacePtr = node;
+                }

             } else {
             } else {

-                node.setClass('item'); //t
+                node.setClass('item');

             }
             nodesToWrap.push(node);
         }
             }
             nodesToWrap.push(node);
         }


@@ -46,39 +80,39 @@ extension.documentTransformations.push({
         var toInsert;
         if(parent.is('list') && parent.object.itemIndex(nodesToWrap[0]) > 0) { // object api
             // var prevItem = parent.object.getItem(parent.object.itemIndex(nodesToWrap[0])-1); // object api
         var toInsert;
         if(parent.is('list') && parent.object.itemIndex(nodesToWrap[0]) > 0) { // object api
             // var prevItem = parent.object.getItem(parent.object.itemIndex(nodesToWrap[0])-1); // object api

-            // prevItem.append(listNode); //t
+            // prevItem.append(listNode);

             toInsert = listNode.wrapWith({tagName: 'div', attrs: {'class': 'item'}});
         } else {
             toInsert = listNode.wrapWith({tagName: 'div', attrs: {'class': 'item'}});
         } else {

-            //nodesToWrap[0].before(listNode); //t
+            //nodesToWrap[0].before(listNode);

             toInsert = listNode;
             toInsert = listNode;

-        }  
+        }

 
 

-        params.node1.before(toInsert);
+        listPlacePtr.before(toInsert);

 
         nodesToWrap.forEach(function(node) {
 
         nodesToWrap.forEach(function(node) {

-            listNode.append(node); //t
+            listNode.append(node);

         });
         });

+        return listNode;

     },
     getChangeRoot: function() {
     },
     getChangeRoot: function() {

-        return this.args.node1.parent();
+        return this.args[0].node1.parent();

     },
     isAllowed: function() {
     },
     isAllowed: function() {

-        return this.args.node1.parent().sameNode(this.args.node2.parent());
+        return this.args[0].node1.parent().sameNode(this.args[0].node2.parent());

     }
     }

-});
+};

 
 

-extension.documentTransformations.push({
-    name: 'extractItems',
+extension.document.transformations.extractItems = {

     impl: function(params) {
         params = _.extend({}, {merge: true}, params);
         var list = params.item1.parent(),
     impl: function(params) {
         params = _.extend({}, {merge: true}, params);
         var list = params.item1.parent(),

-            indexes = [params.item1.getIndex(), params.item2.getIndex()].sort(),
+            indexes = [params.item1.getIndex(), params.item2.getIndex()].sort(function(a,b) { return a-b;}),

             precedingItems = [],
             extractedItems = [],
             succeedingItems = [],
             precedingItems = [],
             extractedItems = [],
             succeedingItems = [],

-            items = list.contents(), // lub list.object.items()
-            listIsNested = list.parent().is('item'),
-            i;
+            items = list.contents(),
+            listIsNested = list.parent().is('item') && !list.parent().isContextRoot();
+

         
         items.forEach(function(item, idx) {
             if(idx < indexes[0]) {
         
         items.forEach(function(item, idx) {
             if(idx < indexes[0]) {


@@ -96,29 +130,31 @@ extension.documentTransformations.push({
         if(succeedingItems.length === 0) {
             var reference_orig = reference;
             extractedItems.forEach(function(item) {
         if(succeedingItems.length === 0) {
             var reference_orig = reference;
             extractedItems.forEach(function(item) {

-                reference.after(item); //t
+                reference.after(item);

                 reference = item;
                 if(!listIsNested) {
                 reference = item;
                 if(!listIsNested) {

-                    item.setClass(null); //t
+                    item.setClass('p');

                 }
             });
                 }
             });

-            if(precedingItems.length === 0)
-                reference_orig.detach(); //t
+            if(precedingItems.length === 0) {
+                reference_orig.detach();
+            }

         } else if(precedingItems.length === 0) {
             extractedItems.forEach(function(item) {
         } else if(precedingItems.length === 0) {
             extractedItems.forEach(function(item) {

-                reference.before(item); //t
+                reference.before(item);

                 if(!listIsNested) {
                 if(!listIsNested) {

-                    item.setClass(null); //t
+                    item.setClass('p');

                 }
             });
         } else {
             extractedItems.forEach(function(item) {
                 }
             });
         } else {
             extractedItems.forEach(function(item) {

-                reference.after(item); //t
-                if(!listIsNested)
-                    item.setClass(null); //t
+                reference.after(item);
+                if(!listIsNested) {
+                    item.setClass('p');
+                }

                 reference = item;
             });
                 reference = item;
             });

-            var secondList = params.item1.document.createDocumentNode({tagName: 'div', attrs: {'class':'list'}}),
+            var secondList = params.item1.document.createDocumentNode({tagName: 'div', attrs: {'class': list.getClass() || 'list'}}),

                 toAdd = secondList;
             
             if(listIsNested) {
                 toAdd = secondList;
             
             if(listIsNested) {


@@ -131,37 +167,17 @@ extension.documentTransformations.push({
             reference.after(toAdd);
         }
         if(!params.merge && listIsNested) {
             reference.after(toAdd);
         }
         if(!params.merge && listIsNested) {

-            debugger;
-            return this.transform('extractItems', {item1: extractedItems[0], item2: extractedItems[extractedItems.length-1]});
+            return this.extractItems({item1: extractedItems[0], item2: extractedItems[extractedItems.length-1]});

         }
         }

-        return true;
+        return extractedItems[0];

     },
     isAllowed: function() {
     },
     isAllowed: function() {

-        var parent = this.args.nodel1.parent();
-        return parent.is('list') && parent.sameNode(this.args.node2.parent());
+        var parent = this.args[0].nodel1.parent();
+        return parent.is('list') && parent.sameNode(this.args[0].node2.parent());

     }
     }

-});
-
-wlxml.registerExtension(extension);
-
-// wlxml.registerClassTransformation('list', {
-//     name: 'insertItem',
-//     impl: function(item) {
-//         if(!item.is('item')) {
-//             throw new Error ('...');
-//         }
-//         this.append(item);
-//     }
-// });
-
-// wlxml.registerClassMethod('list', {
-//     name: 'items',
-//     impl: function() {
-//         var node = this;
-//         return this.contents();    
-//     }
-// });
-
-//a atrybuty? registerClassAttrs? E... lepiej registerClassExtension({methods, attibutes})
+};
+
+return extension;
+

 
 });
\ No newline at end of file
 
 });
\ No newline at end of file