Operations for adding and removing lists

These operations work on the level of top level lists only

Added tests for the new operations and changed the op test code to parse
any op parameter containing "length" or "position" in the name as an integer

Author: Satvik Kumar

programs/editor/widgets/toggleLists.js

@@ -45,7 +45,13 @@ define("webodf/editor/widgets/toggleLists", [
                 showLabel: false,
                 checked: false,
                 iconClass: "dijitEditorIcon dijitEditorIconInsertOrderedList",
-                onChange: function () {
+                onChange: function (checked) {
+                    var success = listController.setNumberedList(checked);
+                    //TODO: remove this when the list controller supports all use cases triggered by this button
+                    if(!success) {
+                        numberedList.set("checked", !checked, false);
+                    }
+                    self.onToolDone();
                 }
             });
 
@@ -55,7 +61,13 @@ define("webodf/editor/widgets/toggleLists", [
                 showLabel: false,
                 checked: false,
                 iconClass: "dijitEditorIcon dijitEditorIconInsertUnorderedList",
-                onChange: function () {
+                onChange: function (checked) {
+                    var success = listController.setBulletedList(checked);
+                    //TODO: remove this when the list controller supports all use cases triggered by this button
+                    if(!success) {
+                        bulletedList.set("checked", !checked, false);
+                    }
+                    self.onToolDone();
                 }
             });
 

webodf/lib/gui/ListController.js

@@ -22,7 +22,7 @@
  * @source: https://github.com/kogmbh/WebODF/
  */
 
-/*global core, ops, gui, odf, runtime*/
+/*global core, ops, gui, odf, NodeFilter, runtime*/
 
 /**
  * @implements {core.Destroyable}
@@ -36,14 +36,17 @@ gui.ListController = function ListController(session, sessionConstraints, sessio
     "use strict";
     var odtDocument = session.getOdtDocument(),
         odfUtils = odf.OdfUtils,
+        domUtils = core.DomUtils,
         eventNotifier = new core.EventNotifier([
             gui.ListController.listStylingChanged,
             gui.ListController.enabledChanged
         ]),
         /**@type{!gui.ListController.SelectionInfo}*/
         lastSignalledSelectionInfo,
         /**@type{!core.LazyProperty.<!gui.ListController.SelectionInfo>}*/
-        cachedSelectionInfo;
+        cachedSelectionInfo,
+        /**@const*/
+        NEXT = core.StepDirection.NEXT;
 
     /**
      * @param {!ops.OdtCursor|!string} cursorOrId
@@ -136,6 +139,161 @@ gui.ListController = function ListController(session, sessionConstraints, sessio
         emitSelectionChanges();
     }
 
+    /**
+     * Find all top level text:list elements in the given range.
+     * This includes any elements that contain the start or end containers of the range.
+     * @param {!Range} range
+     * @return {!Array.<!Element>}
+     */
+    function getTopLevelListElementsInRange(range) {
+        var elements,
+            topLevelList,
+            rootNode = odtDocument.getRootNode();
+
+        /**
+         * @param {!Node} node
+         * @return {!number}
+         */
+        function isListOrListItem(node) {
+            var result = NodeFilter.FILTER_REJECT;
+            if (odfUtils.isListElement(node) && !odfUtils.isListItemElement(node.parentNode)) {
+                result = NodeFilter.FILTER_ACCEPT;
+            } else if (odfUtils.isTextContentContainingNode(node) || odfUtils.isGroupingElement(node)) {
+                result = NodeFilter.FILTER_SKIP;
+            }
+            return result;
+        }
+
+        // ignore the list element if it is nested within another list
+        elements = domUtils.getNodesInRange(range, isListOrListItem, NodeFilter.SHOW_ELEMENT);
+
+        // add any top level lists that contain the start or end containers of the range
+        // check in the elements collection for duplicates in case these top level lists intersected the specified range
+        topLevelList = odfUtils.getTopLevelListElement(/**@type{!Node}*/(range.startContainer), rootNode);
+        if (topLevelList && topLevelList !== elements[0]) {
+            elements.unshift(topLevelList);
+        }
+
+        topLevelList = odfUtils.getTopLevelListElement(/**@type{!Node}*/(range.endContainer), rootNode);
+        if (topLevelList && topLevelList !== elements[elements.length - 1]) {
+            elements.push(topLevelList);
+        }
+
+        return elements;
+    }
+
+    /**
+     * @param {!Element} initialParagraph
+     * @return {!{startParagraph: !Element, endParagraph: !Element}}
+     */
+    function createParagraphGroup(initialParagraph) {
+        return {
+            startParagraph: initialParagraph,
+            endParagraph: initialParagraph
+        };
+    }
+
+    /**
+     * Takes all the paragraph elements in the current selection and breaks
+     * them into add list operations based on their common ancestors. Paragraph elements
+     * with the same common ancestor will be grouped into the same operation
+     * @return {!Array.<!ops.Operation>}
+     */
+    function determineOpsForAddingLists() {
+        var paragraphElements,
+            /**@type{!Array.<!{startParagraph: !Element, endParagraph: !Element}>}*/
+            paragraphGroups = [],
+            paragraphParent,
+            commonAncestor,
+            i;
+
+        paragraphElements = odfUtils.getParagraphElements(odtDocument.getCursor(inputMemberId).getSelectedRange());
+
+        for (i = 0; i < paragraphElements.length; i += 1) {
+            paragraphParent = paragraphElements[i].parentNode;
+
+            //TODO: handle selections that intersect with existing lists
+            if (odfUtils.isListItemElement(paragraphParent)) {
+                runtime.log("DEBUG: Current selection intersects with an existing list which is not supported at this time");
+                paragraphGroups.length = 0;
+                break;
+            }
+
+            if (paragraphParent === commonAncestor) {
+                // if the current paragraph has the same common ancestor as the current group of paragraphs
+                // then the paragraph group gets extended to include the current paragraph
+                paragraphGroups[paragraphGroups.length - 1].endParagraph = paragraphElements[i];
+            } else {
+                // if the ancestor of this paragraph does not match then begin a new group of paragraphs
+                commonAncestor = paragraphParent;
+                paragraphGroups.push(createParagraphGroup(paragraphElements[i]));
+            }
+        }
+
+        // each paragraph group becomes one add list operation
+        return paragraphGroups.map(function (group) {
+            // take the first step of the start and end paragraph of each group and
+            // pass them in as the coordinates for the add list operation
+            var newOp = new ops.OpAddList();
+            newOp.init({
+                memberid: inputMemberId,
+                startParagraphPosition: odtDocument.convertDomPointToCursorStep(group.startParagraph, 0, NEXT),
+                endParagraphPosition: odtDocument.convertDomPointToCursorStep(group.endParagraph, 0, NEXT)
+            });
+            return newOp;
+        });
+    }
+
+    /**
+     * Finds all the lists to be removed in the current selection and creates an operation for each
+     * top level list element found
+     * @return {!Array.<!ops.Operation>}
+     */
+    function determineOpsForRemovingLists() {
+        var topLevelListElements,
+            stepIterator = odtDocument.createStepIterator(
+                odtDocument.getRootNode(),
+                0,
+                [odtDocument.getPositionFilter()],
+                odtDocument.getRootNode());
+
+        topLevelListElements = getTopLevelListElementsInRange(odtDocument.getCursor(inputMemberId).getSelectedRange());
+
+        return topLevelListElements.map(function (listElement) {
+            var newOp = new ops.OpRemoveList();
+
+            stepIterator.setPosition(listElement, 0);
+            runtime.assert(stepIterator.roundToNextStep(), "Top level list element contains no steps");
+
+            newOp.init({
+                memberid: inputMemberId,
+                firstParagraphPosition: odtDocument.convertDomPointToCursorStep(stepIterator.container(), stepIterator.offset())
+            });
+            return newOp;
+        });
+    }
+
+    /**
+     * @param {function():!Array.<!ops.Operation>} executeFunc
+     * @return {!boolean}
+     */
+    function executeListOperations(executeFunc) {
+        var newOps;
+
+        if (!cachedSelectionInfo.value().isEnabled) {
+            return false;
+        }
+
+        newOps = executeFunc();
+
+        if (newOps.length > 0) {
+            session.enqueue(newOps);
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * @return {!boolean}
      */
@@ -161,6 +319,47 @@ gui.ListController = function ListController(session, sessionConstraints, sessio
         eventNotifier.unsubscribe(eventid, cb);
     };
 
+    /**
+     * @return {!boolean}
+     */
+    function makeList() {
+        return executeListOperations(determineOpsForAddingLists);
+    }
+
+    this.makeList = makeList;
+
+    /**
+     * @return {!boolean}
+     */
+    function removeList() {
+        return executeListOperations(determineOpsForRemovingLists);
+    }
+
+    this.removeList = removeList;
+
+    /**
+     * @param {!boolean} checked
+     * @return {!boolean}
+     */
+    this.setNumberedList = function (checked) {
+        if (checked) {
+            return makeList();
+        }
+        return removeList();
+
+    };
+
+    /**
+     * @param {!boolean} checked
+     * @return {!boolean}
+     */
+    this.setBulletedList = function (checked) {
+        if (checked) {
+            return makeList();
+        }
+        return removeList();
+    };
+
     /**
      * @param {!function(!Error=)} callback
      * @return {undefined}

webodf/lib/manifest.json

@@ -412,6 +412,9 @@
     "ops.OpAddCursor": [
         "ops.OdtDocument"
     ],
+    "ops.OpAddList": [
+        "ops.OdtDocument"
+    ],
     "ops.OpAddMember": [
         "ops.OdtDocument"
     ],
@@ -453,6 +456,9 @@
     "ops.OpRemoveHyperlink": [
         "ops.OdtDocument"
     ],
+    "ops.OpRemoveList": [
+        "ops.OdtDocument"
+    ],
     "ops.OpRemoveMember": [
         "ops.OdtDocument"
     ],
@@ -487,6 +493,7 @@
     "ops.OperationFactory": [
         "ops.OpAddAnnotation",
         "ops.OpAddCursor",
+        "ops.OpAddList",
         "ops.OpAddMember",
         "ops.OpAddStyle",
         "ops.OpApplyDirectStyling",
@@ -500,6 +507,7 @@
         "ops.OpRemoveBlob",
         "ops.OpRemoveCursor",
         "ops.OpRemoveHyperlink",
+        "ops.OpRemoveList",
         "ops.OpRemoveMember",
         "ops.OpRemoveStyle",
         "ops.OpRemoveText",

webodf/lib/odf/OdfUtils.js

@@ -1066,6 +1066,30 @@ odf.OdfUtilsImpl = function OdfUtilsImpl() {
         return fontFamilyName;
     };
     /*jslint regexp: false*/
+
+    /**
+     * Finds the top level text:list element for a given node
+     * @param {!Node} node
+     * @param {!Element} container Root container to stop searching at.
+     * @return {?Element}
+     */
+    this.getTopLevelListElement = function(node, container) {
+        var currentNode = node,
+            listNode = null;
+
+        while(currentNode) {
+            if(isListElement(currentNode)) {
+                listNode = /**@type{!Element}*/(currentNode);
+            }
+
+            if(currentNode === container) {
+                break;
+            }
+            currentNode = currentNode.parentNode;
+        }
+
+        return listNode;
+    };
 };
 
 /**