[Common UI] Reorganize general UI bundle

Reorganize sources for bundle platform/commonUI/general;
number of classes here has grown as a consequence of
additions for WTD-614 and so an additional layer of
organization is helpful.

Conflicts:
	platform/commonUI/general/bundle.json
	platform/commonUI/general/src/directives/MCTResize.js

platform/commonUI/general/src/controllers/TreeNodeController.js

@@ -0,0 +1,154 @@
+/*global define,Promise*/
+
+/**
+ * Module defining TreeNodeController. Created by vwoeltje on 11/10/14.
+ */
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * The TreeNodeController supports the tree node representation;
+         * a tree node has a label for the current object as well as a
+         * subtree which shows (and is not loaded until) the node is
+         * expanded.
+         *
+         * This controller tracks the following, so that the tree node
+         * template may update its state accordingly:
+         *
+         * * Whether or not the tree node has ever been expanded (this
+         *   is used to lazily load, exactly once, the subtree)
+         * * Whether or not the node is currently the domain object
+         *   of navigation (this gets highlighted differently to
+         *   provide the user with visual feedback.)
+         *
+         * Additionally, this controller will automatically trigger
+         * node expansion when this tree node's _subtree_ will contain
+         * the navigated object (recursively, this becomes an
+         * expand-to-show-navigated-object behavior.)
+         * @constructor
+         */
+        function TreeNodeController($scope, $timeout) {
+            var selectedObject = ($scope.ngModel || {}).selectedObject,
+                isSelected = false,
+                hasBeenExpanded = false;
+
+            // Look up the id for a domain object. A convenience
+            // for mapping; additionally does some undefined-checking.
+            function getId(obj) {
+                return obj && obj.getId && obj.getId();
+            }
+
+            // Verify that id paths are equivalent, staring at
+            // index, ending at the end of the node path.
+            function checkPath(nodePath, navPath, index) {
+                index = index || 0;
+
+                // The paths overlap if we have made it past the
+                // end of the node's path; otherwise, check the
+                // id at the current index for equality and perform
+                // a recursive step for subsequent ids in the paths,
+                // until we exceed path length or hit a mismatch.
+                return (index >= nodePath.length) ||
+                        ((navPath[index] === nodePath[index]) &&
+                                checkPath(nodePath, navPath, index + 1));
+            }
+
+            // Track that a node has been expanded, either by the
+            // user or automatically to show a selection.
+            function trackExpansion() {
+                if (!hasBeenExpanded) {
+                    // Run on a timeout; if a lot of expansion needs to
+                    // occur (e.g. if the selection is several nodes deep) we
+                    // want this to be spread across multiple digest cycles.
+                    $timeout(function () { hasBeenExpanded = true; }, 0);
+                }
+            }
+
+            // Consider the currently-navigated object and update
+            // parameters which support display.
+            function checkSelection() {
+                var nodeObject = $scope.domainObject,
+                    navObject = selectedObject,
+                    nodeContext = nodeObject &&
+                            nodeObject.getCapability('context'),
+                    navContext = navObject &&
+                            navObject.getCapability('context'),
+                    nodePath,
+                    navPath;
+
+                // Deselect; we will reselect below, iff we are
+                // exactly at the end of the path.
+                isSelected = false;
+
+                // Expand if necessary (if the navigated object will
+                // be in this node's subtree)
+                if (nodeContext && navContext) {
+                    // Get the paths as arrays of identifiers
+                    nodePath = nodeContext.getPath().map(getId);
+                    navPath = navContext.getPath().map(getId);
+
+                    // Check to see if the node's path lies entirely
+                    // within the navigation path; otherwise, navigation
+                    // has happened in some other subtree.
+                    if (navPath.length >= nodePath.length &&
+                            checkPath(nodePath, navPath)) {
+
+                        // nodePath is along the navPath; if it's
+                        // at the end of the path, highlight;
+                        // otherwise, expand.
+                        if (nodePath.length === navPath.length) {
+                            isSelected = true;
+                        } else { // node path is shorter: Expand!
+                            if ($scope.toggle) {
+                                $scope.toggle.setState(true);
+                            }
+                            trackExpansion();
+                        }
+
+                    }
+                }
+            }
+
+            // Callback for the selection updates; track the currently
+            // navigated object and update display parameters as needed.
+            function setSelection(object) {
+                selectedObject = object;
+                checkSelection();
+            }
+
+            // Listen for changes which will effect display parameters
+            $scope.$watch("ngModel.selectedObject", setSelection);
+            $scope.$watch("domainObject", checkSelection);
+
+            return {
+                /**
+                 * This method should be called when a node is expanded
+                 * to record that this has occurred, to support one-time
+                 * lazy loading of the node's subtree.
+                 */
+                trackExpansion: trackExpansion,
+                /**
+                 * Check if this not has ever been expanded.
+                 * @returns true if it has been expanded
+                 */
+                hasBeenExpanded: function () {
+                    return hasBeenExpanded;
+                },
+                /**
+                 * Check whether or not the domain object represented by
+                 * this tree node should be highlighted.
+                 * An object will be highlighted if it matches
+                 * ngModel.selectedObject
+                 * @returns true if this should be highlighted
+                 */
+                isSelected: function () {
+                    return isSelected;
+                }
+            };
+        }
+
+        return TreeNodeController;
+    }
+);