From 7fced99390d9601258e2c80f9f48d25bb739847c Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Tue, 17 Feb 2015 16:15:25 -0800
Subject: [PATCH 01/26] [Fixed Position] Add placeholder toolbar definition

Add a mostly-empty toolbar definition to Fixed Position view,
WTD-879.
---
 platform/features/layout/bundle.json | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/platform/features/layout/bundle.json b/platform/features/layout/bundle.json
index 0ce44d3016..890a2438a4 100644
--- a/platform/features/layout/bundle.json
+++ b/platform/features/layout/bundle.json
@@ -19,7 +19,27 @@
                 "type": "telemetry.panel",
                 "templateUrl": "templates/fixed.html",
                 "uses": [ "composition" ],
-                "gestures": [ "drop" ]
+                "gestures": [ "drop" ],
+                "toolbar": {
+                    "sections": [
+                        {
+                            "items": [
+                                {
+                                    "property": "add",
+                                    "control": "button"
+                                }
+                            ]
+                        },
+                        {
+                            "items": [
+                                {
+                                    "property": "z",
+                                    "control": "textfield"
+                                }
+                            ]
+                        }
+                    ]
+                }
             }
         ],
         "representations": [

From db2f2eb0980f4fe26a1bd281616dd2b08be47812 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Tue, 17 Feb 2015 16:20:02 -0800
Subject: [PATCH 02/26] [Fixed Position] Improve button support

Improve button support from toolbars by adding a click
function when generating structures for mct-toolbar based
on view definitions. WTD-879.
---
 platform/commonUI/edit/README.md              |  2 ++
 .../edit/src/representers/EditToolbar.js      | 24 ++++++++++++++++---
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/platform/commonUI/edit/README.md b/platform/commonUI/edit/README.md
index 3691e8211a..a8c552fb3e 100644
--- a/platform/commonUI/edit/README.md
+++ b/platform/commonUI/edit/README.md
@@ -15,6 +15,8 @@ view's scope.) These additional properties are:
   then that function is assumed to be an accessor-mutator function
   (that is, it will be called with no arguments to get, and with
   an argument to set.)
+* `method`: Name of a method to invoke upon a selected object when
+  a control is activated, e.g. on a button click.
 * `inclusive`: Optional; true if this control should be considered
   applicable whenever at least one element in the selection has
   the associated property. Otherwise, all members of the current
diff --git a/platform/commonUI/edit/src/representers/EditToolbar.js b/platform/commonUI/edit/src/representers/EditToolbar.js
index 591a312aa3..23bc7e8ed7 100644
--- a/platform/commonUI/edit/src/representers/EditToolbar.js
+++ b/platform/commonUI/edit/src/representers/EditToolbar.js
@@ -106,23 +106,41 @@ define(
             // to the current selection.
             function isApplicable(item) {
                 var property = (item || {}).property,
+                    method = (item || {}).method,
                     exclusive = !(item || {}).inclusive;
 
                 // Check if a selected item defines this property
                 function hasProperty(selected) {
-                    return selected[property] !== undefined;
+                    return (property && (selected[property] !== undefined)) ||
+                            (method && (typeof selected[method] === 'function'));
                 }
 
-                return property && selection.map(hasProperty).reduce(
+                return selection.map(hasProperty).reduce(
                     exclusive ? and : or,
                     exclusive
                 ) && isConsistent(property);
             }
 
+            // Invoke all functions in selections with the given name
+            function invoke(method, value) {
+                if (method) {
+                    selection.forEach(function (selected) {
+                        if (typeof selected[method] === 'function') {
+                            selected[method](value);
+                        }
+                    });
+                }
+            }
+
             // Prepare a toolbar item based on current selection
             function convertItem(item) {
                 var converted = Object.create(item || {});
-                converted.key = addKey(item.property);
+                if (item.property) {
+                    converted.key = addKey(item.property);
+                }
+                if (item.method) {
+                    converted.click = function (v) { invoke(item.method, v); };
+                }
                 return converted;
             }
 

From 7a680873e31b9582aa7115d5bf333ac23530bbde Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Tue, 17 Feb 2015 16:29:42 -0800
Subject: [PATCH 03/26] [Fixed Position] Begin adding placeholder toolbar

Begin adding placeholder toolbar for fixed position view,
WTD-879.
---
 platform/features/layout/bundle.json            | 5 +++--
 platform/features/layout/src/FixedController.js | 8 ++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/platform/features/layout/bundle.json b/platform/features/layout/bundle.json
index 890a2438a4..18686ebc83 100644
--- a/platform/features/layout/bundle.json
+++ b/platform/features/layout/bundle.json
@@ -25,8 +25,9 @@
                         {
                             "items": [
                                 {
-                                    "property": "add",
-                                    "control": "button"
+                                    "method": "add",
+                                    "control": "button",
+                                    "text": "Add"
                                 }
                             ]
                         },
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 07f0f99731..8e9fb5936e 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -194,6 +194,14 @@ define(
             // Initialize styles (position etc.) for cells
             refreshCellStyles();
 
+            if (Array.isArray($scope.selection)) {
+                $scope.selection.push({
+                    add: function () {
+                        window.alert("Placeholder; not yet implemented");
+                    }
+                });
+            }
+
             return {
                 /**
                  * Get styles for all background cells, as will populate the

From 4be2a3f1cdb7e6ba1e2be19e66df7d0ea1a7ece6 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 08:55:58 -0800
Subject: [PATCH 04/26] [Fixed Position] Add selection manager

Add utility class so that layouts/fixed position views
can track their current selection state more simply.
WTD-879.
---
 .../features/layout/src/LayoutSelection.js    | 110 ++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 platform/features/layout/src/LayoutSelection.js

diff --git a/platform/features/layout/src/LayoutSelection.js b/platform/features/layout/src/LayoutSelection.js
new file mode 100644
index 0000000000..747694d50b
--- /dev/null
+++ b/platform/features/layout/src/LayoutSelection.js
@@ -0,0 +1,110 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Tracks selection state for Layout and Fixed Position views.
+         * @param {Array} selection the selection array from the view's scope
+         * @param [proxy] an object which represents the selection of the view
+         *        itself (which handles view-level toolbar behavior)
+         */
+        function LayoutSelection(selection, proxy) {
+            var selecting = false,
+                selected;
+
+            // Find the proxy in the array; our selected objects will be
+            // positioned next to that
+            function proxyIndex() {
+                return selection.indexOf(proxy);
+            }
+
+            // Remove the currently-selected object
+            function deselect() {
+                // Nothing to do if we don't have a selected object
+                if (selecting) {
+                    // Clear state tracking
+                    selecting = false;
+                    selected = undefined;
+
+                    // Remove the selection
+                    selection.splice(proxyIndex() + 1, 1);
+
+                    return true;
+                }
+                return false;
+            }
+
+            // Select an object
+            function select(obj) {
+                // We want this selection to end up near the proxy
+                var index = proxyIndex() + 1;
+
+                // Proxy is always selected
+                if (obj === proxy) {
+                    return false;
+                }
+
+                // Clear any existing selection
+                deselect();
+
+                // Note the current selection state
+                selected = obj;
+                selecting = true;
+
+                // Are we at the end of the array?
+                if (selection.length === index) {
+                    // Add it to the end
+                    selection.push(obj);
+                } else {
+                    // Splice it into the array
+                    selection.splice(index, 0, obj);
+                }
+            }
+
+            // Remove any selected object, and the proxy itself
+            function destroy() {
+                deselect();
+                selection.splice(proxyIndex(), 1);
+            }
+
+            // Check if an object is selected
+            function isSelected(obj) {
+                return (obj === selected) || (obj === proxy);
+            }
+
+            // Start with the proxy selected
+            selection.push(proxy);
+
+            return {
+                /**
+                 * Check if an object is currently selected.
+                 * @returns true if selected, otherwise false
+                 */
+                selected: isSelected,
+                /**
+                 * Select an object.
+                 * @param obj the object to select
+                 * @returns {boolean} true if selection changed
+                 */
+                select: select,
+                /**
+                 * Clear the current selection.
+                 * @returns {boolean} true if selection changed
+                 */
+                deselect: deselect,
+                /**
+                 * Clear the selection, including the proxy, and dispose
+                 * of this selection scope. No other calls to methods on
+                 * this object are expected after `destroy` has been
+                 * called; their behavior will be undefined.
+                 */
+                destroy: destroy
+            };
+        }
+
+        return LayoutSelection;
+    }
+);
\ No newline at end of file

From 97b844563d8dea3e141cb264e53f7e1280803736 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 09:03:50 -0800
Subject: [PATCH 05/26] [Fixed Position] Add proxy object

Add proxy object to represent the selection of the fixed position
view itself, WTD-879.
---
 .../features/layout/src/FixedController.js    | 23 ++++++++--------
 platform/features/layout/src/FixedProxy.js    | 26 +++++++++++++++++++
 2 files changed, 38 insertions(+), 11 deletions(-)
 create mode 100644 platform/features/layout/src/FixedProxy.js

diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 8e9fb5936e..afcf8b312e 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -1,8 +1,8 @@
 /*global define*/
 
 define(
-    ['./LayoutDrag'],
-    function (LayoutDrag) {
+    ['./LayoutDrag', './LayoutSelection', './FixedProxy'],
+    function (LayoutDrag, LayoutSelection, FixedProxy) {
         "use strict";
 
         var DEFAULT_DIMENSIONS = [ 2, 1 ],
@@ -26,7 +26,8 @@ define(
                 values = {},
                 cellStyles = [],
                 rawPositions = {},
-                positions = {};
+                positions = {},
+                selection;
 
             // Utility function to copy raw positions from configuration,
             // without writing directly to configuration (to avoid triggering
@@ -179,6 +180,14 @@ define(
                 populatePosition(id);
             }
 
+            //  Track current selection state
+            if (Array.isArray($scope.selection)) {
+                selection = new LayoutSelection(
+                    $scope.selection,
+                    new FixedProxy($scope.configuration)
+                );
+            }
+
             // Position panes when the model field changes
             $scope.$watch("model.composition", updateComposition);
 
@@ -194,14 +203,6 @@ define(
             // Initialize styles (position etc.) for cells
             refreshCellStyles();
 
-            if (Array.isArray($scope.selection)) {
-                $scope.selection.push({
-                    add: function () {
-                        window.alert("Placeholder; not yet implemented");
-                    }
-                });
-            }
-
             return {
                 /**
                  * Get styles for all background cells, as will populate the
diff --git a/platform/features/layout/src/FixedProxy.js b/platform/features/layout/src/FixedProxy.js
new file mode 100644
index 0000000000..a6c1583cf7
--- /dev/null
+++ b/platform/features/layout/src/FixedProxy.js
@@ -0,0 +1,26 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Proxy for configuring a fixed position view via the toolbar.
+         * @constructor
+         * @param configuration the view configuration object
+         */
+        function FixedProxy(configuration) {
+            return {
+                /**
+                 * Add a new visual element to this view.
+                 */
+                add: function (type) {
+                    window.alert("Placeholder. Should add a " + type + ".");
+                }
+            };
+        }
+
+        return FixedProxy;
+    }
+);
\ No newline at end of file

From 8662689974d2151f0cd20872950f5d25201eeb12 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 13:19:59 -0800
Subject: [PATCH 06/26] [Fixed Position] Begin breaking apart template

Begin breaking apart template to allow multiple
types of fixed position elements, WTD-879.
---
 .../res/templates/elements/telemetry.html     |  8 +++++
 .../features/layout/res/templates/fixed.html  | 35 +++++++------------
 2 files changed, 21 insertions(+), 22 deletions(-)
 create mode 100644 platform/features/layout/res/templates/elements/telemetry.html

diff --git a/platform/features/layout/res/templates/elements/telemetry.html b/platform/features/layout/res/templates/elements/telemetry.html
new file mode 100644
index 0000000000..cb12e916b7
--- /dev/null
+++ b/platform/features/layout/res/templates/elements/telemetry.html
@@ -0,0 +1,8 @@
+<div style="background: #444;">
+    <div style="position: absolute; left: 0px; top: 0px; bottom: 0px; width: 50%; overflow: hidden;">
+        {{ngModel.name}}
+    </div>
+    <div style="position: absolute; right: 0px; top: 0px; bottom: 0px; width: 50%; overflow: hidden;">
+        {{ngModel.value}}
+    </div>
+</div>
\ No newline at end of file
diff --git a/platform/features/layout/res/templates/fixed.html b/platform/features/layout/res/templates/fixed.html
index b91f3e524b..f89b7171d7 100644
--- a/platform/features/layout/res/templates/fixed.html
+++ b/platform/features/layout/res/templates/fixed.html
@@ -1,5 +1,3 @@
-
-
 <div style="width: 100%; height: 100%; position: absolute; left: 0px; top: 0px;"
      ng-controller="FixedController as controller"
      mct-resize="controller.setBounds(bounds)">
@@ -11,26 +9,19 @@
     </div>
 
     <!-- Telemetry elements -->
-    <div ng-repeat="childObject in composition"
-         style="position: absolute; background: #444;"
-         ng-style="controller.getStyle(childObject.getId())">
+    <mct-include ng-repeat="element in controller.getDecoratedElements()"
+                 style="position: absolute;"
+                 ng-style="element.style"
+                 key="element.template"
+                 ng-model="element">
+    </mct-include>
 
-        <div style="position: absolute; left: 0px; top: 0px; bottom: 0px; width: 50%; overflow: hidden;">
-            {{childObject.getModel().name}}
-        </div>
-        <div style="position: absolute; right: 0px; top: 0px; bottom: 0px; width: 50%; overflow: hidden;">
-            {{controller.getValue(childObject.getId())}}
-        </div>
-
-        <!-- Drag handles -->
-        <span ng-show="domainObject.hasCapability('editor')">
-            <span style="position: absolute; left: 0px; right: 0px; top: 0px; bottom: 0px; cursor: move;"
-                  mct-drag-down="controller.startDrag(childObject.getId(), [1,1], [0,0])"
-                  mct-drag="controller.continueDrag(delta)"
-                  mct-drag-up="controller.endDrag()">
-            </span>
+    <!-- Drag handles -->
+    <span ng-show="false && domainObject.hasCapability('editor')">
+        <span style="position: absolute; left: 0px; right: 0px; top: 0px; bottom: 0px; cursor: move;"
+              mct-drag-down="controller.startDrag(element, [1,1], [0,0])"
+              mct-drag="controller.continueDrag(element)"
+              mct-drag-up="controller.endDrag()">
         </span>
-
-    </div>
-
+    </span>
 </div>
\ No newline at end of file

From bf36141e911dcf2f960bb5e64ebc7cc996f937fb Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 13:50:25 -0800
Subject: [PATCH 07/26] [Fixed Position] Begin refactoring controller

Begin refactoring Fixed Position controller to facilitate
selection support, as well as multiple types of elements;
WTD-879.
---
 .../features/layout/src/FixedController.js    | 192 +++++++-----------
 1 file changed, 68 insertions(+), 124 deletions(-)

diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index afcf8b312e..e8a9aef12d 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -23,23 +23,10 @@ define(
                 activeDrag,
                 activeDragId,
                 subscription,
-                values = {},
                 cellStyles = [],
-                rawPositions = {},
-                positions = {},
+                elementProxies = [],
                 selection;
 
-            // Utility function to copy raw positions from configuration,
-            // without writing directly to configuration (to avoid triggering
-            // persistence from watchers during drags).
-            function shallowCopy(obj, keys) {
-                var copy = {};
-                keys.forEach(function (k) {
-                    copy[k] = obj[k];
-                });
-                return copy;
-            }
-
             // Refresh cell styles (e.g. because grid extent changed)
             function refreshCellStyles() {
                 var x, y;
@@ -59,62 +46,27 @@ define(
                 }
             }
 
-            // Convert from { positions: ..., dimensions: ... } to an
-            // apropriate ng-style argument, to position frames.
+            // Convert from element x/y/width/height to an
+            // apropriate ng-style argument, to position elements.
             function convertPosition(raw) {
                 // Multiply position/dimensions by grid size
                 return {
-                    left: (gridSize[0] * raw.position[0]) + 'px',
-                    top: (gridSize[1] * raw.position[1]) + 'px',
-                    width: (gridSize[0] * raw.dimensions[0]) + 'px',
-                    height: (gridSize[1] * raw.dimensions[1]) + 'px'
+                    left: (gridSize[0] * raw.x) + 'px',
+                    top: (gridSize[1] * raw.y) + 'px',
+                    width: (gridSize[0] * raw.width) + 'px',
+                    height: (gridSize[1] * raw.height) + 'px'
                 };
             }
 
-            // Generate a default position (in its raw format) for a frame.
-            // Use an index to ensure that default positions are unique.
-            function defaultPosition(index) {
-                return {
-                    position: [index, index],
-                    dimensions: DEFAULT_DIMENSIONS
-                };
-            }
-
-            // Store a computed position for a contained frame by its
-            // domain object id. Called in a forEach loop, so arguments
-            // are as expected there.
-            function populatePosition(id, index) {
-                rawPositions[id] =
-                    rawPositions[id] || defaultPosition(index || 0);
-                positions[id] =
-                    convertPosition(rawPositions[id]);
-            }
-
-            // Compute panel positions based on the layout's object model
-            function lookupPanels(ids) {
-                var configuration = $scope.configuration || {};
-                ids = ids || [];
-
-                // Pull panel positions from configuration
-                rawPositions = shallowCopy(configuration.elements || {}, ids);
-
-                // Clear prior computed positions
-                positions = {};
-
-                // Update width/height that we are tracking
-                gridSize = ($scope.model || {}).layoutGrid || DEFAULT_GRID_SIZE;
-
-                // Compute positions and add defaults where needed
-                ids.forEach(populatePosition);
-            }
-
             // Update the displayed value for this object
             function updateValue(telemetryObject) {
                 var id = telemetryObject && telemetryObject.getId();
                 if (id) {
-                    values[id] = telemetryFormatter.formatRangeValue(
-                        subscription.getRangeValue(telemetryObject)
-                    );
+                    elementProxies.forEach(function (element) {
+                        element.value = telemetryFormatter.formatRangeValue(
+                            subscription.getRangeValue(telemetryObject)
+                        );
+                    });
                 }
             }
 
@@ -125,6 +77,18 @@ define(
                 }
             }
 
+            // Decorate an element for display
+            function makeProxyElement(element) {
+                return element; // TODO: Use proxy!
+            }
+
+            // Decorate elements in the current configuration
+            function refreshElements() {
+                elementProxies = (($scope.configuration || {}).elements || [])
+                        .map(makeProxyElement);
+                // TODO: Ensure elements for all domain objects?
+            }
+
             // Free up subscription to telemetry
             function releaseSubscription() {
                 if (subscription) {
@@ -135,9 +99,6 @@ define(
 
             // Subscribe to telemetry updates for this domain object
             function subscribe(domainObject) {
-                // Clear any old values
-                values = {};
-
                 // Release existing subscription (if any)
                 if (subscription) {
                     subscription.unsubscribe();
@@ -151,7 +112,7 @@ define(
             // Handle changes in the object's composition
             function updateComposition(ids) {
                 // Populate panel positions
-                lookupPanels(ids);
+                // TODO: Ensure defaults here
                 // Resubscribe - objects in view have changed
                 subscribe($scope.domainObject);
             }
@@ -163,21 +124,20 @@ define(
                 // Make sure there is a "elements" field in the
                 // view configuration.
                 $scope.configuration.elements =
-                    $scope.configuration.elements || {};
+                    $scope.configuration.elements || [];
                 // Store the position of this element.
-                $scope.configuration.elements[id] = {
-                    position: [
-                        Math.floor(position.x / gridSize[0]),
-                        Math.floor(position.y / gridSize[1])
-                    ],
-                    dimensions: DEFAULT_DIMENSIONS
-                };
+                $scope.configuration.elements.push({
+                    type: "fixed.telemetry",
+                    x: Math.floor(position.x / gridSize[0]),
+                    y: Math.floor(position.y / gridSize[1]),
+                    id: id,
+                    width: DEFAULT_DIMENSIONS[0],
+                    height: DEFAULT_DIMENSIONS[1]
+                });
                 // Mark change as persistable
                 if ($scope.commit) {
-                    $scope.commit("Dropped a frame.");
+                    $scope.commit("Dropped an element.");
                 }
-                // Populate template-facing position for this id
-                populatePosition(id);
             }
 
             //  Track current selection state
@@ -188,6 +148,9 @@ define(
                 );
             }
 
+            // Refresh list of elements whenever model changes
+            $scope.$watch("model.modified", refreshElements);
+
             // Position panes when the model field changes
             $scope.$watch("model.composition", updateComposition);
 
@@ -213,15 +176,6 @@ define(
                 getCellStyles: function () {
                     return cellStyles;
                 },
-                /**
-                 * Get the current data value for the specified domain object.
-                 * @memberof FixedController#
-                 * @param {string} id the domain object identifier
-                 * @returns {string} the displayable data value
-                 */
-                getValue: function (id) {
-                    return values[id];
-                },
                 /**
                  * Set the size of the viewable fixed position area.
                  * @memberof FixedController#
@@ -235,19 +189,6 @@ define(
                         refreshCellStyles();
                     }
                 },
-                /**
-                 * Get a style object for a frame with the specified domain
-                 * object identifier, suitable for use in an `ng-style`
-                 * directive to position a frame as configured for this layout.
-                 * @param {string} id the object identifier
-                 * @returns {Object.<string, string>} an object with
-                 *          appropriate left, width, etc fields for positioning
-                 */
-                getStyle: function (id) {
-                    // Called in a loop, so just look up; the "positions"
-                    // object is kept up to date by a watch.
-                    return positions[id];
-                },
                 /**
                  * Start a drag gesture to move/resize a frame.
                  *
@@ -269,13 +210,14 @@ define(
                  * @param {number[]} dimFactor the dimensions factor
                  */
                 startDrag: function (id, posFactor, dimFactor) {
-                    activeDragId = id;
-                    activeDrag = new LayoutDrag(
-                        rawPositions[id],
-                        posFactor,
-                        dimFactor,
-                        gridSize
-                    );
+                    // TODO: Drag!
+//                    activeDragId = id;
+//                    activeDrag = new LayoutDrag(
+//                        rawPositions[id],
+//                        posFactor,
+//                        dimFactor,
+//                        gridSize
+//                    );
                 },
                 /**
                  * Continue an active drag gesture.
@@ -284,32 +226,34 @@ define(
                  *        to its position when the drag started
                  */
                 continueDrag: function (delta) {
-                    if (activeDrag) {
-                        rawPositions[activeDragId] =
-                            activeDrag.getAdjustedPosition(delta);
-                        populatePosition(activeDragId);
-                    }
+                    // TODO: Drag!
+//                    if (activeDrag) {
+//                        rawPositions[activeDragId] =
+//                            activeDrag.getAdjustedPosition(delta);
+//                        populatePosition(activeDragId);
+//                    }
                 },
                 /**
                  * End the active drag gesture. This will update the
                  * view configuration.
                  */
                 endDrag: function () {
-                    // Write to configuration; this is watched and
-                    // saved by the EditRepresenter.
-                    $scope.configuration =
-                        $scope.configuration || {};
-                    // Make sure there is a "panels" field in the
-                    // view configuration.
-                    $scope.configuration.elements =
-                        $scope.configuration.elements || {};
-                    // Store the position of this panel.
-                    $scope.configuration.elements[activeDragId] =
-                        rawPositions[activeDragId];
-                    // Mark this object as dirty to encourage persistence
-                    if ($scope.commit) {
-                        $scope.commit("Moved element.");
-                    }
+                    // TODO: Drag!
+//                    // Write to configuration; this is watched and
+//                    // saved by the EditRepresenter.
+//                    $scope.configuration =
+//                        $scope.configuration || {};
+//                    // Make sure there is a "panels" field in the
+//                    // view configuration.
+//                    $scope.configuration.elements =
+//                        $scope.configuration.elements || {};
+//                    // Store the position of this panel.
+//                    $scope.configuration.elements[activeDragId] =
+//                        rawPositions[activeDragId];
+//                    // Mark this object as dirty to encourage persistence
+//                    if ($scope.commit) {
+//                        $scope.commit("Moved element.");
+//                    }
                 }
             };
 

From 466a169562945752105d2c783c2822fb8d6c681f Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 15:11:52 -0800
Subject: [PATCH 08/26] [Fixed Position] Continue refactoring controller

Continue refactoring Fixed Position controller for
selection support, WTD-879.
---
 .../features/layout/src/FixedController.js    | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index e8a9aef12d..b2efd53157 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -79,6 +79,14 @@ define(
 
             // Decorate an element for display
             function makeProxyElement(element) {
+                // var ElementProxy = ElementProxies[element.type],
+                //     e = new ElementProxy(element);
+                // e.style = convertPosition(element);
+                element = Object.create(element);
+                // Provide a displayable position (convert from grid to px)
+                element.style = convertPosition(element);
+                // Template names are same as type names, presently
+                element.template = element.type;
                 return element; // TODO: Use proxy!
             }
 
@@ -189,6 +197,27 @@ define(
                         refreshCellStyles();
                     }
                 },
+                /**
+                 * Get an array of elements in this panel, decorated for
+                 * display.
+                 * @returns {Array} elements in this panel
+                 */
+                getDecoratedElements: function () {
+                    return elementProxies;
+                },
+                /**
+                 * Set the active user selection in this view.
+                 * @param element the element to select
+                 */
+                select: function (element) {
+                    selection.select(element);
+                },
+                /**
+                 * Clear the current user selection.
+                 */
+                clearSelection: function () {
+                    selection.deselect();
+                },
                 /**
                  * Start a drag gesture to move/resize a frame.
                  *

From f24f62dedcaa49cf87143296b65c0fe6509a09bd Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 19:26:06 -0800
Subject: [PATCH 09/26] [Fixed Position] Begin adding element proxy classes

Begin adding proxy classes to allow the toolbar to interact with
elements in a fixed position view, WTD-879.
---
 .../features/layout/src/elements/Accessor.js  | 26 ++++++++++++++
 .../layout/src/elements/ElementProxies.js     | 12 +++++++
 .../layout/src/elements/ElementProxy.js       | 35 +++++++++++++++++++
 .../layout/src/elements/TelemetryProxy.js     | 21 +++++++++++
 4 files changed, 94 insertions(+)
 create mode 100644 platform/features/layout/src/elements/Accessor.js
 create mode 100644 platform/features/layout/src/elements/ElementProxies.js
 create mode 100644 platform/features/layout/src/elements/ElementProxy.js
 create mode 100644 platform/features/layout/src/elements/TelemetryProxy.js

diff --git a/platform/features/layout/src/elements/Accessor.js b/platform/features/layout/src/elements/Accessor.js
new file mode 100644
index 0000000000..e2fa6564c6
--- /dev/null
+++ b/platform/features/layout/src/elements/Accessor.js
@@ -0,0 +1,26 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Utility function for creating getter-setter functions,
+         * since these are frequently useful for element proxies.
+         * @constructor
+         * @param {Object} object the object to get/set values upon
+         * @param {string} key the property to get/set
+         */
+        function Accessor(object, key) {
+            return function (value) {
+                if (arguments.length > 0) {
+                    object[key] = value;
+                }
+                return value;
+            };
+        }
+
+        return Accessor;
+    }
+);
\ No newline at end of file
diff --git a/platform/features/layout/src/elements/ElementProxies.js b/platform/features/layout/src/elements/ElementProxies.js
new file mode 100644
index 0000000000..e8d6b032e5
--- /dev/null
+++ b/platform/features/layout/src/elements/ElementProxies.js
@@ -0,0 +1,12 @@
+/*global define*/
+
+define(
+    ['./TelemetryProxy'],
+    function (TelemetryProxy) {
+        "use strict";
+
+        return {
+            "fixed.telemetry": TelemetryProxy
+        };
+    }
+);
\ No newline at end of file
diff --git a/platform/features/layout/src/elements/ElementProxy.js b/platform/features/layout/src/elements/ElementProxy.js
new file mode 100644
index 0000000000..963ff31706
--- /dev/null
+++ b/platform/features/layout/src/elements/ElementProxy.js
@@ -0,0 +1,35 @@
+/*global define*/
+
+define(
+    ['./Accessor'],
+    function (Accessor) {
+        "use strict";
+
+        /**
+         * Abstract superclass for other classes which provide useful
+         * interfaces upon an elements in a fixed position view.
+         * This handles the generic operations (e.g. remove) so that
+         * subclasses only need to implement element-specific behaviors.
+         * @constructor
+         * @param element the telemetry element
+         * @param index the element's index within its array
+         * @param {Array} elements the full array of elements
+         */
+        function ElementProxy(element, index, elements) {
+            return {
+                x: new Accessor(element, 'x'),
+                y: new Accessor(element, 'y'),
+                z: new Accessor(element, 'z'),
+                width: new Accessor(element, 'width'),
+                height: new Accessor(element, 'height'),
+                remove: function () {
+                    if (elements[index] === element) {
+                        elements.splice(index, 1);
+                    }
+                }
+            };
+        }
+
+        return ElementProxy;
+    }
+);
\ No newline at end of file
diff --git a/platform/features/layout/src/elements/TelemetryProxy.js b/platform/features/layout/src/elements/TelemetryProxy.js
new file mode 100644
index 0000000000..610edb895c
--- /dev/null
+++ b/platform/features/layout/src/elements/TelemetryProxy.js
@@ -0,0 +1,21 @@
+/*global define*/
+
+define(
+    ['./ElementProxy'],
+    function (ElementProxy) {
+        'use strict';
+
+        /**
+         *
+         */
+        function TelemetryProxy(element, index, elements) {
+            var proxy = new ElementProxy(element, index, elements);
+
+            proxy.id = element.id;
+
+            return proxy;
+        }
+
+        return TelemetryProxy;
+    }
+);
\ No newline at end of file

From cd98fd475d2d1b2b1b8540541b831d3f63a757bc Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 19:41:27 -0800
Subject: [PATCH 10/26] [Fixed Position] Begin using proxies

Begin using proxies for elements in fixed position view,
WTD-879.
---
 platform/features/layout/bundle.json          |  6 ++++
 .../features/layout/res/templates/fixed.html  |  6 ++--
 .../features/layout/src/FixedController.js    | 32 ++++++++++++-------
 3 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/platform/features/layout/bundle.json b/platform/features/layout/bundle.json
index 18686ebc83..221dad1ca5 100644
--- a/platform/features/layout/bundle.json
+++ b/platform/features/layout/bundle.json
@@ -61,6 +61,12 @@
                 "depends": [ "$scope", "telemetrySubscriber", "telemetryFormatter" ]
             }
         ],
+        "templates": [
+            {
+                "key": "fixed.telemetry",
+                "templateUrl": "templates/elements/telemetry.html"
+            }
+        ],
         "types": [
             {
                 "key": "layout",
diff --git a/platform/features/layout/res/templates/fixed.html b/platform/features/layout/res/templates/fixed.html
index f89b7171d7..5ebdccaf82 100644
--- a/platform/features/layout/res/templates/fixed.html
+++ b/platform/features/layout/res/templates/fixed.html
@@ -5,14 +5,16 @@
     <!-- Background grid -->
     <div ng-repeat="cell in controller.getCellStyles()"
          style="position: absolute; border: 1px gray solid; background: black;"
+         ng-click="controller.deselect()"
          ng-style="cell">
     </div>
 
-    <!-- Telemetry elements -->
+    <!-- Fixed position elements -->
     <mct-include ng-repeat="element in controller.getDecoratedElements()"
                  style="position: absolute;"
-                 ng-style="element.style"
                  key="element.template"
+                 ng-style="element.style"
+                 ng-click="controller.select(element)"
                  ng-model="element">
     </mct-include>
 
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index b2efd53157..3899f40b4e 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -1,8 +1,8 @@
 /*global define*/
 
 define(
-    ['./LayoutDrag', './LayoutSelection', './FixedProxy'],
-    function (LayoutDrag, LayoutSelection, FixedProxy) {
+    ['./LayoutDrag', './LayoutSelection', './FixedProxy', './elements/ElementProxies'],
+    function (LayoutDrag, LayoutSelection, FixedProxy, ElementProxies) {
         "use strict";
 
         var DEFAULT_DIMENSIONS = [ 2, 1 ],
@@ -63,6 +63,7 @@ define(
                 var id = telemetryObject && telemetryObject.getId();
                 if (id) {
                     elementProxies.forEach(function (element) {
+                        element.name = telemetryObject.getModel().name;
                         element.value = telemetryFormatter.formatRangeValue(
                             subscription.getRangeValue(telemetryObject)
                         );
@@ -79,15 +80,17 @@ define(
 
             // Decorate an element for display
             function makeProxyElement(element) {
-                // var ElementProxy = ElementProxies[element.type],
-                //     e = new ElementProxy(element);
-                // e.style = convertPosition(element);
-                element = Object.create(element);
-                // Provide a displayable position (convert from grid to px)
-                element.style = convertPosition(element);
-                // Template names are same as type names, presently
-                element.template = element.type;
-                return element; // TODO: Use proxy!
+                var ElementProxy = ElementProxies[element.type],
+                    e = ElementProxy && new ElementProxy(element);
+
+                if (e) {
+                    // Provide a displayable position (convert from grid to px)
+                    e.style = convertPosition(element);
+                    // Template names are same as type names, presently
+                    e.template = element.type;
+                }
+
+                return e;
             }
 
             // Decorate elements in the current configuration
@@ -205,6 +208,13 @@ define(
                 getDecoratedElements: function () {
                     return elementProxies;
                 },
+                /**
+                 * Check if the element is currently selected.
+                 * @returns {boolean} true if selected
+                 */
+                selected: function (element) {
+                    return selection.selected(element);
+                },
                 /**
                  * Set the active user selection in this view.
                  * @param element the element to select

From a4dd7307649cd3e64dcaa5a2485575dfbca183ff Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 19:51:42 -0800
Subject: [PATCH 11/26] [Fixed Position] Allow select/deselect

Allow select/deselect of individual elements in fixed position
view, WTD-879.
---
 platform/features/layout/res/templates/fixed.html | 12 +++++++-----
 platform/features/layout/src/FixedController.js   | 12 +++++++-----
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/platform/features/layout/res/templates/fixed.html b/platform/features/layout/res/templates/fixed.html
index 5ebdccaf82..379fecb198 100644
--- a/platform/features/layout/res/templates/fixed.html
+++ b/platform/features/layout/res/templates/fixed.html
@@ -3,16 +3,18 @@
      mct-resize="controller.setBounds(bounds)">
 
     <!-- Background grid -->
-    <div ng-repeat="cell in controller.getCellStyles()"
-         style="position: absolute; border: 1px gray solid; background: black;"
-         ng-click="controller.deselect()"
-         ng-style="cell">
-    </div>
+    <span ng-click="controller.clearSelection()">
+        <div ng-repeat="cell in controller.getCellStyles()"
+             style="position: absolute; border: 1px gray solid; background: black;"
+             ng-style="cell">
+        </div>
+    </span>
 
     <!-- Fixed position elements -->
     <mct-include ng-repeat="element in controller.getDecoratedElements()"
                  style="position: absolute;"
                  key="element.template"
+                 ng-class="{ test: controller.selected(element) }"
                  ng-style="element.style"
                  ng-click="controller.select(element)"
                  ng-model="element">
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 3899f40b4e..982d06fddc 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -20,8 +20,6 @@ define(
         function FixedController($scope, telemetrySubscriber, telemetryFormatter) {
             var gridSize = DEFAULT_GRID_SIZE,
                 gridExtent = DEFAULT_GRID_EXTENT,
-                activeDrag,
-                activeDragId,
                 subscription,
                 cellStyles = [],
                 elementProxies = [],
@@ -213,20 +211,24 @@ define(
                  * @returns {boolean} true if selected
                  */
                 selected: function (element) {
-                    return selection.selected(element);
+                    return selection && selection.selected(element);
                 },
                 /**
                  * Set the active user selection in this view.
                  * @param element the element to select
                  */
                 select: function (element) {
-                    selection.select(element);
+                    if (selection) {
+                        selection.select(element);
+                    }
                 },
                 /**
                  * Clear the current user selection.
                  */
                 clearSelection: function () {
-                    selection.deselect();
+                    if (selection) {
+                        selection.deselect();
+                    }
                 },
                 /**
                  * Start a drag gesture to move/resize a frame.

From f66fb0a32d73ef58bbea59763b9b381ee153bf56 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 19:56:54 -0800
Subject: [PATCH 12/26] [Fixed Position] Add remove button

Add a 'remove' button when elements are selected in
fixed position view, WTD-879.
---
 platform/features/layout/bundle.json            | 9 ++++++---
 platform/features/layout/src/FixedController.js | 4 ++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/platform/features/layout/bundle.json b/platform/features/layout/bundle.json
index 221dad1ca5..8ded0c2f6f 100644
--- a/platform/features/layout/bundle.json
+++ b/platform/features/layout/bundle.json
@@ -27,15 +27,18 @@
                                 {
                                     "method": "add",
                                     "control": "button",
-                                    "text": "Add"
+                                    "text": "Add",
+                                    "inclusive": true
                                 }
                             ]
                         },
                         {
                             "items": [
                                 {
-                                    "property": "z",
-                                    "control": "textfield"
+                                    "method": "remove",
+                                    "control": "button",
+                                    "text": "Remove",
+                                    "inclusive": true
                                 }
                             ]
                         }
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 982d06fddc..1ccc2a5f55 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -77,9 +77,9 @@ define(
             }
 
             // Decorate an element for display
-            function makeProxyElement(element) {
+            function makeProxyElement(element, index, elements) {
                 var ElementProxy = ElementProxies[element.type],
-                    e = ElementProxy && new ElementProxy(element);
+                    e = ElementProxy && new ElementProxy(element, index, elements);
 
                 if (e) {
                     // Provide a displayable position (convert from grid to px)

From 5680710c068b0881ba592ac0f589ace6b7f0d1e6 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 20:12:55 -0800
Subject: [PATCH 13/26] [Fixed Position] Implement remove

Implement remove button for selected elements in fixed
position view. WTD-879.
---
 .../edit/src/representers/EditToolbar.js      | 10 ++++++--
 .../representers/EditToolbarRepresenter.js    | 10 +++++++-
 .../features/layout/src/FixedController.js    | 24 +++++++++++++++++--
 .../features/layout/src/LayoutSelection.js    | 10 ++++++++
 .../layout/src/elements/ElementProxy.js       |  1 +
 5 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/platform/commonUI/edit/src/representers/EditToolbar.js b/platform/commonUI/edit/src/representers/EditToolbar.js
index 23bc7e8ed7..60d6990bb6 100644
--- a/platform/commonUI/edit/src/representers/EditToolbar.js
+++ b/platform/commonUI/edit/src/representers/EditToolbar.js
@@ -17,9 +17,10 @@ define(
          *
          * @param structure toolbar structure, as provided by view definition
          * @param {Array} selection the current selection state
+         * @param {Function} commit callback to invoke after changes
          * @constructor
          */
-        function EditToolbar(structure, selection) {
+        function EditToolbar(structure, selection, commit) {
             var toolbarStructure = Object.create(structure || {}),
                 toolbarState,
                 properties = [];
@@ -124,11 +125,14 @@ define(
             // Invoke all functions in selections with the given name
             function invoke(method, value) {
                 if (method) {
+                    // Make the change in the selection
                     selection.forEach(function (selected) {
                         if (typeof selected[method] === 'function') {
                             selected[method](value);
                         }
                     });
+                    // ...and commit!
+                    commit();
                 }
             }
 
@@ -139,7 +143,9 @@ define(
                     converted.key = addKey(item.property);
                 }
                 if (item.method) {
-                    converted.click = function (v) { invoke(item.method, v); };
+                    converted.click = function (v) {
+                        invoke(item.method, v);
+                    };
                 }
                 return converted;
             }
diff --git a/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js b/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
index feeb5bcd53..4c983bcd41 100644
--- a/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
+++ b/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
@@ -20,6 +20,13 @@ define(
                 toolbar,
                 toolbarObject = {};
 
+            // Mark changes as ready to persist
+            function commit(message) {
+                if (scope.commit) {
+                    scope.commit(message);
+                }
+            }
+
             // Handle changes to the current selection
             function updateSelection(selection) {
                 // Make sure selection is array-like
@@ -28,7 +35,7 @@ define(
                         (selection ? [selection] : []);
 
                 // Instantiate a new toolbar...
-                toolbar = new EditToolbar(definition, selection);
+                toolbar = new EditToolbar(definition, selection, commit);
 
                 // ...and expose its structure/state
                 toolbarObject.structure = toolbar.getStructure();
@@ -37,6 +44,7 @@ define(
 
             // Update selection models to match changed toolbar state
             function updateState(state) {
+                // Update underlying state based on toolbar changes
                 state.forEach(function (value, index) {
                     toolbar.updateState(index, value);
                 });
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 1ccc2a5f55..9df91e9762 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -93,8 +93,28 @@ define(
 
             // Decorate elements in the current configuration
             function refreshElements() {
-                elementProxies = (($scope.configuration || {}).elements || [])
-                        .map(makeProxyElement);
+                // Cache selection; we are instantiating new proxies
+                // so we may want to restore this.
+                var selected = selection && selection.get(),
+                    elements = (($scope.configuration || {}).elements || []),
+                    index = -1; // Start with a 'not-found' value
+
+                // Find the selection in the new array
+                if (selected !== undefined) {
+                    index = elements.indexOf(selected.element);
+                }
+
+                // Create the new proxies...
+                elementProxies = elements.map(makeProxyElement);
+
+                // Clear old selection, and restore if appropriate
+                if (selection) {
+                    selection.deselect();
+                    if (index > -1) {
+                        selection.select(elementProxies[index]);
+                    }
+                }
+
                 // TODO: Ensure elements for all domain objects?
             }
 
diff --git a/platform/features/layout/src/LayoutSelection.js b/platform/features/layout/src/LayoutSelection.js
index 747694d50b..0398d3d308 100644
--- a/platform/features/layout/src/LayoutSelection.js
+++ b/platform/features/layout/src/LayoutSelection.js
@@ -75,6 +75,11 @@ define(
                 return (obj === selected) || (obj === proxy);
             }
 
+            // Getter for current selection
+            function get() {
+                return selected;
+            }
+
             // Start with the proxy selected
             selection.push(proxy);
 
@@ -95,6 +100,11 @@ define(
                  * @returns {boolean} true if selection changed
                  */
                 deselect: deselect,
+                /**
+                 * Get the currently-selected object.
+                 * @returns the currently selected object
+                 */
+                get: get,
                 /**
                  * Clear the selection, including the proxy, and dispose
                  * of this selection scope. No other calls to methods on
diff --git a/platform/features/layout/src/elements/ElementProxy.js b/platform/features/layout/src/elements/ElementProxy.js
index 963ff31706..a628c90ad8 100644
--- a/platform/features/layout/src/elements/ElementProxy.js
+++ b/platform/features/layout/src/elements/ElementProxy.js
@@ -17,6 +17,7 @@ define(
          */
         function ElementProxy(element, index, elements) {
             return {
+                element: element,
                 x: new Accessor(element, 'x'),
                 y: new Accessor(element, 'y'),
                 z: new Accessor(element, 'z'),

From 7bd41a9f80cee18da38c4415e536f5235fc6813d Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 20:29:54 -0800
Subject: [PATCH 14/26] [Fixed Position] Allow dragging of elements

Restore dragging behavior to elements in a fixed position
view, WTD-879.
---
 .../features/layout/res/templates/fixed.html  | 14 ++---
 .../features/layout/src/FixedController.js    | 57 +++++++------------
 .../features/layout/src/elements/Accessor.js  |  2 +-
 3 files changed, 27 insertions(+), 46 deletions(-)

diff --git a/platform/features/layout/res/templates/fixed.html b/platform/features/layout/res/templates/fixed.html
index 379fecb198..78b2edc5f7 100644
--- a/platform/features/layout/res/templates/fixed.html
+++ b/platform/features/layout/res/templates/fixed.html
@@ -17,15 +17,9 @@
                  ng-class="{ test: controller.selected(element) }"
                  ng-style="element.style"
                  ng-click="controller.select(element)"
-                 ng-model="element">
+                 ng-model="element"
+                 mct-drag-down="controller.startDrag(element); controller.select(element)"
+                 mct-drag="controller.continueDrag(delta)"
+                 mct-drag-up="controller.endDrag()">
     </mct-include>
-
-    <!-- Drag handles -->
-    <span ng-show="false && domainObject.hasCapability('editor')">
-        <span style="position: absolute; left: 0px; right: 0px; top: 0px; bottom: 0px; cursor: move;"
-              mct-drag-down="controller.startDrag(element, [1,1], [0,0])"
-              mct-drag="controller.continueDrag(element)"
-              mct-drag-up="controller.endDrag()">
-        </span>
-    </span>
 </div>
\ No newline at end of file
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 9df91e9762..2fc798d891 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -20,6 +20,7 @@ define(
         function FixedController($scope, telemetrySubscriber, telemetryFormatter) {
             var gridSize = DEFAULT_GRID_SIZE,
                 gridExtent = DEFAULT_GRID_EXTENT,
+                dragging,
                 subscription,
                 cellStyles = [],
                 elementProxies = [],
@@ -265,20 +266,18 @@ define(
                  * with the mouse while the horizontal dimensions shrink in
                  * kind (and vertical properties remain unmodified.)
                  *
-                 * @param {string} id the identifier of the domain object
-                 *        in the frame being manipulated
-                 * @param {number[]} posFactor the position factor
-                 * @param {number[]} dimFactor the dimensions factor
+                 * @param element the raw (undecorated) element to drag
                  */
-                startDrag: function (id, posFactor, dimFactor) {
-                    // TODO: Drag!
-//                    activeDragId = id;
-//                    activeDrag = new LayoutDrag(
-//                        rawPositions[id],
-//                        posFactor,
-//                        dimFactor,
-//                        gridSize
-//                    );
+                startDrag: function (element) {
+                    // Only allow dragging in edit mode
+                    if ($scope.domainObject &&
+                            $scope.domainObject.hasCapability('editor')) {
+                        dragging = {
+                            element: element,
+                            x: element.x(),
+                            y: element.y()
+                        };
+                    }
                 },
                 /**
                  * Continue an active drag gesture.
@@ -287,34 +286,22 @@ define(
                  *        to its position when the drag started
                  */
                 continueDrag: function (delta) {
-                    // TODO: Drag!
-//                    if (activeDrag) {
-//                        rawPositions[activeDragId] =
-//                            activeDrag.getAdjustedPosition(delta);
-//                        populatePosition(activeDragId);
-//                    }
+                    if (dragging) {
+                        dragging.element.x(dragging.x + Math.round(delta[0] / gridSize[0]));
+                        dragging.element.y(dragging.y + Math.round(delta[1] / gridSize[1]));
+                        dragging.element.style = convertPosition(dragging.element.element);
+                    }
                 },
                 /**
                  * End the active drag gesture. This will update the
                  * view configuration.
                  */
                 endDrag: function () {
-                    // TODO: Drag!
-//                    // Write to configuration; this is watched and
-//                    // saved by the EditRepresenter.
-//                    $scope.configuration =
-//                        $scope.configuration || {};
-//                    // Make sure there is a "panels" field in the
-//                    // view configuration.
-//                    $scope.configuration.elements =
-//                        $scope.configuration.elements || {};
-//                    // Store the position of this panel.
-//                    $scope.configuration.elements[activeDragId] =
-//                        rawPositions[activeDragId];
-//                    // Mark this object as dirty to encourage persistence
-//                    if ($scope.commit) {
-//                        $scope.commit("Moved element.");
-//                    }
+                    // Mark this object as dirty to encourage persistence
+                    if (dragging && $scope.commit) {
+                        dragging = undefined;
+                        $scope.commit("Moved element.");
+                    }
                 }
             };
 
diff --git a/platform/features/layout/src/elements/Accessor.js b/platform/features/layout/src/elements/Accessor.js
index e2fa6564c6..20f6e08838 100644
--- a/platform/features/layout/src/elements/Accessor.js
+++ b/platform/features/layout/src/elements/Accessor.js
@@ -17,7 +17,7 @@ define(
                 if (arguments.length > 0) {
                     object[key] = value;
                 }
-                return value;
+                return object[key];
             };
         }
 

From 035b2e36c35ef47652c1f179ccd2869f15863380 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Wed, 18 Feb 2015 20:37:23 -0800
Subject: [PATCH 15/26] [Telemetry] Fire callback when objects are available

Fire callback from telemetry subscriber when the set of
object references changes. This allows views which use
the subscriber to register one callback, while still
ensuring that they are notified when there is new
information to show. Supports fixed position view, WTD-879.
---
 platform/telemetry/src/TelemetrySubscription.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/platform/telemetry/src/TelemetrySubscription.js b/platform/telemetry/src/TelemetrySubscription.js
index b7deb5d449..cce24d48dd 100644
--- a/platform/telemetry/src/TelemetrySubscription.js
+++ b/platform/telemetry/src/TelemetrySubscription.js
@@ -138,6 +138,11 @@ define(
             function cacheObjectReferences(objects) {
                 telemetryObjects = objects;
                 metadatas = objects.map(lookupMetadata);
+                // Fire callback, as this will be the first time that
+                // telemetry objects are available
+                if (callback) {
+                    callback();
+                }
                 return objects;
             }
 

From 81159a8801a4a7e4e26ec437d7cd89196b33bb2b Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 09:11:59 -0800
Subject: [PATCH 16/26] [Telemetry] Update subscription spec

Update spec for TelemetrySubscription to account for the fact
that it initially calls back when the set of telemetry objects
is available (which supports views such as Fixed Position
which want to defer all telemetry-handling responsibility to
the subscription.) WTD-879.
---
 .../test/TelemetrySubscriptionSpec.js         | 24 +++++++++++++++----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/platform/telemetry/test/TelemetrySubscriptionSpec.js b/platform/telemetry/test/TelemetrySubscriptionSpec.js
index 469015ee93..6dd27320c9 100644
--- a/platform/telemetry/test/TelemetrySubscriptionSpec.js
+++ b/platform/telemetry/test/TelemetrySubscriptionSpec.js
@@ -76,7 +76,10 @@ define(
             });
 
             it("fires callbacks when subscriptions update", function () {
-                expect(mockCallback).not.toHaveBeenCalled();
+                // Callback fires when telemetry objects become available,
+                // so track initial call count instead of verifying that
+                // it hasn't been called at all.
+                var initialCalls = mockCallback.calls.length;
                 mockTelemetry.subscribe.mostRecentCall.args[0](mockSeries);
                 // This gets fired via a timeout, so trigger that
                 expect(mockTimeout).toHaveBeenCalledWith(
@@ -86,12 +89,15 @@ define(
                 mockTimeout.mostRecentCall.args[0]();
                 // Should have triggered the callback to alert that
                 // new data was available
-                expect(mockCallback).toHaveBeenCalled();
+                expect(mockCallback.calls.length).toEqual(initialCalls + 1);
             });
 
             it("fires subscription callbacks once per cycle", function () {
                 var i;
 
+                // Verify precondition - one call for telemetryObjects
+                expect(mockCallback.calls.length).toEqual(1);
+
                 for (i = 0; i < 100; i += 1) {
                     mockTelemetry.subscribe.mostRecentCall.args[0](mockSeries);
                 }
@@ -100,7 +106,7 @@ define(
                     call.args[0]();
                 });
                 // Should have only triggered the
-                expect(mockCallback.calls.length).toEqual(1);
+                expect(mockCallback.calls.length).toEqual(2);
             });
 
             it("reports its latest observed data values", function () {
@@ -129,7 +135,8 @@ define(
             // telemetrySubscription, where failure to callback
             // once-per-update results in loss of data, WTD-784
             it("fires one event per update if requested", function () {
-                var i, domains = [], ranges = [], lastCall;
+                var i, domains = [], ranges = [], lastCall, initialCalls;
+
 
                 // Clear out the subscription from beforeEach
                 subscription.unsubscribe();
@@ -142,6 +149,9 @@ define(
                     true // Don't drop updates!
                 );
 
+                // Track calls at this point
+                initialCalls = mockCallback.calls.length;
+
                 // Snapshot getDomainValue, getRangeValue at time of callback
                 mockCallback.andCallFake(function () {
                     domains.push(subscription.getDomainValue(mockDomainObject));
@@ -163,13 +173,17 @@ define(
                 }
 
                 // Should have only triggered the
-                expect(mockCallback.calls.length).toEqual(100);
+                expect(mockCallback.calls.length).toEqual(100 + initialCalls);
             });
 
             it("provides domain object metadata", function () {
                 expect(subscription.getMetadata()[0])
                     .toEqual(testMetadata);
             });
+
+            it("fires callback when telemetry objects are available", function () {
+                expect(mockCallback.calls.length).toEqual(1);
+            });
         });
     }
 );
\ No newline at end of file

From 5df41966a4a88b13d8214cac0b843a7b0605b812 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 09:13:45 -0800
Subject: [PATCH 17/26] [Fixed Position] Disable failing specs

Disable failing specs after significant rewrite of
FixedController to handle element selection, WTD-879.
---
 platform/features/layout/test/FixedControllerSpec.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/platform/features/layout/test/FixedControllerSpec.js b/platform/features/layout/test/FixedControllerSpec.js
index 61c8773907..a4e67ac347 100644
--- a/platform/features/layout/test/FixedControllerSpec.js
+++ b/platform/features/layout/test/FixedControllerSpec.js
@@ -1,4 +1,4 @@
-/*global define,describe,it,expect,beforeEach,jasmine*/
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
 
 define(
     ["../src/FixedController"],
@@ -108,7 +108,7 @@ define(
                 );
             });
 
-            it("releases subscriptions when domain objects change", function () {
+            xit("releases subscriptions when domain objects change", function () {
                 mockScope.domainObject = mockDomainObject;
 
                 // First pass - should simply should subscribe
@@ -122,7 +122,7 @@ define(
                 expect(mockSubscriber.subscribe.calls.length).toEqual(2);
             });
 
-            it("configures view based on model", function () {
+            xit("configures view based on model", function () {
                 mockScope.model = testModel;
                 findWatch("model.composition")(mockScope.model.composition);
                 // Should have styles for all elements of composition
@@ -132,7 +132,7 @@ define(
                 expect(controller.getStyle('d')).not.toBeDefined();
             });
 
-            it("provides values for telemetry elements", function () {
+            xit("provides values for telemetry elements", function () {
                 // Initialize
                 mockScope.domainObject = mockDomainObject;
                 mockScope.model = testModel;
@@ -169,7 +169,7 @@ define(
                 expect(controller.getCellStyles().length).toEqual(60); // 10 * 6
             });
 
-            it("listens for drop events", function () {
+            xit("listens for drop events", function () {
                 // Layout should position panels according to
                 // where the user dropped them, so it needs to
                 // listen for drop events.

From 9a50f6d84df15573873500c6e99cda0394a8ce83 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 09:37:02 -0800
Subject: [PATCH 18/26] [Fixed Position] Fix globals

Fix globals to pass JSLint check in command line build. WTD-879.
---
 platform/features/layout/src/FixedProxy.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/features/layout/src/FixedProxy.js b/platform/features/layout/src/FixedProxy.js
index a6c1583cf7..c99a0e3f92 100644
--- a/platform/features/layout/src/FixedProxy.js
+++ b/platform/features/layout/src/FixedProxy.js
@@ -1,4 +1,4 @@
-/*global define*/
+/*global define,window*/
 
 define(
     [],

From 83872946bf8f31896182204dc225e9df709ee7e7 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 10:22:12 -0800
Subject: [PATCH 19/26] [Fixed Position] Fix grid size spec

Fix spec which ensures that FixedController correctly
populates background grid based on user-defined grid
size, after changes for WTD-879.
---
 platform/features/layout/src/FixedController.js      | 4 ++++
 platform/features/layout/test/FixedControllerSpec.js | 1 +
 2 files changed, 5 insertions(+)

diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 2fc798d891..88da08537a 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -30,8 +30,12 @@ define(
             function refreshCellStyles() {
                 var x, y;
 
+                // Clear previous styles
                 cellStyles = [];
 
+                // Update grid size from model
+                gridSize = ($scope.model || {}).layoutGrid || gridSize;
+
                 for (x = 0; x < gridExtent[0]; x += 1) {
                     for (y = 0; y < gridExtent[1]; y += 1) {
                         // Position blocks; subtract out border size from w/h
diff --git a/platform/features/layout/test/FixedControllerSpec.js b/platform/features/layout/test/FixedControllerSpec.js
index a4e67ac347..693c1c46d5 100644
--- a/platform/features/layout/test/FixedControllerSpec.js
+++ b/platform/features/layout/test/FixedControllerSpec.js
@@ -86,6 +86,7 @@ define(
                 mockFormatter.formatRangeValue.andCallFake(function (v) {
                     return "Formatted " + v;
                 });
+                mockScope.model = testModel;
 
                 controller = new FixedController(
                     mockScope,

From 7498e340d6c69b6c30517646ade830bc06163fb9 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 12:10:43 -0800
Subject: [PATCH 20/26] [Fixed Position] Rename accessor

Rename utility function used by fixed position elements
to be more accurate. WTD-879.
---
 .../layout/src/elements/{Accessor.js => AccessorMutator.js}   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
 rename platform/features/layout/src/elements/{Accessor.js => AccessorMutator.js} (88%)

diff --git a/platform/features/layout/src/elements/Accessor.js b/platform/features/layout/src/elements/AccessorMutator.js
similarity index 88%
rename from platform/features/layout/src/elements/Accessor.js
rename to platform/features/layout/src/elements/AccessorMutator.js
index 20f6e08838..ac296ddd05 100644
--- a/platform/features/layout/src/elements/Accessor.js
+++ b/platform/features/layout/src/elements/AccessorMutator.js
@@ -12,7 +12,7 @@ define(
          * @param {Object} object the object to get/set values upon
          * @param {string} key the property to get/set
          */
-        function Accessor(object, key) {
+        function AccessorMutator(object, key) {
             return function (value) {
                 if (arguments.length > 0) {
                     object[key] = value;
@@ -21,6 +21,6 @@ define(
             };
         }
 
-        return Accessor;
+        return AccessorMutator;
     }
 );
\ No newline at end of file

From 14cbb9fb400d63ce56ff50178ac19e67075c91b3 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 12:19:46 -0800
Subject: [PATCH 21/26] [Fixed Position] Add placeholder specs

Add placeholder specs for classes added to support
selection of elements in a fixed position view,
WTD-879.
---
 .../features/layout/src/elements/ElementProxy.js   | 14 +++++++-------
 platform/features/layout/test/FixedProxySpec.js    | 12 ++++++++++++
 .../features/layout/test/LayoutSelectionSpec.js    | 12 ++++++++++++
 .../layout/test/elements/AccessorMutatorSpec.js    | 12 ++++++++++++
 .../layout/test/elements/ElementProxiesSpec.js     | 12 ++++++++++++
 .../layout/test/elements/ElementProxySpec.js       | 12 ++++++++++++
 .../layout/test/elements/TelemetryProxySpec.js     | 12 ++++++++++++
 platform/features/layout/test/suite.json           |  8 +++++++-
 8 files changed, 86 insertions(+), 8 deletions(-)
 create mode 100644 platform/features/layout/test/FixedProxySpec.js
 create mode 100644 platform/features/layout/test/LayoutSelectionSpec.js
 create mode 100644 platform/features/layout/test/elements/AccessorMutatorSpec.js
 create mode 100644 platform/features/layout/test/elements/ElementProxiesSpec.js
 create mode 100644 platform/features/layout/test/elements/ElementProxySpec.js
 create mode 100644 platform/features/layout/test/elements/TelemetryProxySpec.js

diff --git a/platform/features/layout/src/elements/ElementProxy.js b/platform/features/layout/src/elements/ElementProxy.js
index a628c90ad8..f580b509cd 100644
--- a/platform/features/layout/src/elements/ElementProxy.js
+++ b/platform/features/layout/src/elements/ElementProxy.js
@@ -1,8 +1,8 @@
 /*global define*/
 
 define(
-    ['./Accessor'],
-    function (Accessor) {
+    ['./AccessorMutator'],
+    function (AccessorMutator) {
         "use strict";
 
         /**
@@ -18,11 +18,11 @@ define(
         function ElementProxy(element, index, elements) {
             return {
                 element: element,
-                x: new Accessor(element, 'x'),
-                y: new Accessor(element, 'y'),
-                z: new Accessor(element, 'z'),
-                width: new Accessor(element, 'width'),
-                height: new Accessor(element, 'height'),
+                x: new AccessorMutator(element, 'x'),
+                y: new AccessorMutator(element, 'y'),
+                z: new AccessorMutator(element, 'z'),
+                width: new AccessorMutator(element, 'width'),
+                height: new AccessorMutator(element, 'height'),
                 remove: function () {
                     if (elements[index] === element) {
                         elements.splice(index, 1);
diff --git a/platform/features/layout/test/FixedProxySpec.js b/platform/features/layout/test/FixedProxySpec.js
new file mode 100644
index 0000000000..d1b2daff0d
--- /dev/null
+++ b/platform/features/layout/test/FixedProxySpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
+
+define(
+    ['../src/FixedProxy'],
+    function (FixedProxy) {
+        "use strict";
+
+        describe("Fixed Position view's selection proxy", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/LayoutSelectionSpec.js b/platform/features/layout/test/LayoutSelectionSpec.js
new file mode 100644
index 0000000000..54742a0531
--- /dev/null
+++ b/platform/features/layout/test/LayoutSelectionSpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
+
+define(
+    ['../src/LayoutSelection'],
+    function (LayoutSelection) {
+        "use strict";
+
+        describe("Layout/fixed position selection manager", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/elements/AccessorMutatorSpec.js b/platform/features/layout/test/elements/AccessorMutatorSpec.js
new file mode 100644
index 0000000000..0936034e98
--- /dev/null
+++ b/platform/features/layout/test/elements/AccessorMutatorSpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ['../../src/elements/AccessorMutator'],
+    function (AccessorMutator) {
+        "use strict";
+
+        describe("An accessor-mutator", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/elements/ElementProxiesSpec.js b/platform/features/layout/test/elements/ElementProxiesSpec.js
new file mode 100644
index 0000000000..4382b8dbf9
--- /dev/null
+++ b/platform/features/layout/test/elements/ElementProxiesSpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ['../../src/elements/ElementProxies'],
+    function (ElementProxies) {
+        "use strict";
+
+        describe("The set of element proxies", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/elements/ElementProxySpec.js b/platform/features/layout/test/elements/ElementProxySpec.js
new file mode 100644
index 0000000000..02c948940f
--- /dev/null
+++ b/platform/features/layout/test/elements/ElementProxySpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ['../../src/elements/ElementProxy'],
+    function (ElementProxy) {
+        "use strict";
+
+        describe("A fixed position element proxy", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/elements/TelemetryProxySpec.js b/platform/features/layout/test/elements/TelemetryProxySpec.js
new file mode 100644
index 0000000000..ad63f34a67
--- /dev/null
+++ b/platform/features/layout/test/elements/TelemetryProxySpec.js
@@ -0,0 +1,12 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ['../../src/elements/TelemetryProxy'],
+    function (TelemetryProxy) {
+        "use strict";
+
+        describe("A fixed position telemetry proxy", function () {
+
+        });
+    }
+);
diff --git a/platform/features/layout/test/suite.json b/platform/features/layout/test/suite.json
index 6e62994ff5..af82513e01 100644
--- a/platform/features/layout/test/suite.json
+++ b/platform/features/layout/test/suite.json
@@ -1,5 +1,11 @@
 [
     "FixedController",
+    "FixedProxy",
     "LayoutController",
-    "LayoutDrag"
+    "LayoutDrag",
+    "LayoutSelection",
+    "elements/AccessorMutator",
+    "elements/ElementProxies",
+    "elements/ElementProxy",
+    "elements/TelemetryProxy"
 ]
\ No newline at end of file

From 280c854658cc4a45de2e5c13c2919220ee37aa7c Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 12:34:22 -0800
Subject: [PATCH 22/26] [Fixed Position] Update drop gesture spec

Update drop gesture spec for changes made for WTD-879
---
 .../test/gestures/DropGestureSpec.js          | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/platform/representation/test/gestures/DropGestureSpec.js b/platform/representation/test/gestures/DropGestureSpec.js
index 2182cf0997..d24dcf2132 100644
--- a/platform/representation/test/gestures/DropGestureSpec.js
+++ b/platform/representation/test/gestures/DropGestureSpec.js
@@ -10,7 +10,7 @@ define(
 
 
         // Methods to mock
-        var JQLITE_FUNCTIONS = [ "on", "off", "attr", "removeAttr" ],
+        var JQLITE_FUNCTIONS = [ "on", "off", "attr", "removeAttr", "scope" ],
             DOMAIN_OBJECT_METHODS = [ "getId", "getModel", "getCapability", "hasCapability", "useCapability"],
             TEST_ID = "test-id",
             DROP_ID = "drop-id";
@@ -21,7 +21,10 @@ define(
                 mockDomainObject,
                 mockPersistence,
                 mockEvent,
+                mockScope,
+                mockUnwrappedElement,
                 testModel,
+                testRect,
                 gesture,
                 callbacks;
 
@@ -35,6 +38,7 @@ define(
 
             beforeEach(function () {
                 testModel = { composition: [] };
+                testRect = {};
 
                 mockQ = { when: mockPromise };
                 mockElement = jasmine.createSpyObj("element", JQLITE_FUNCTIONS);
@@ -42,11 +46,17 @@ define(
                 mockPersistence = jasmine.createSpyObj("persistence", [ "persist" ]);
                 mockEvent = jasmine.createSpyObj("event", ["preventDefault"]);
                 mockEvent.dataTransfer = jasmine.createSpyObj("dataTransfer", [ "getData" ]);
+                mockScope = jasmine.createSpyObj("$scope", ["$broadcast"]);
+                mockUnwrappedElement = jasmine.createSpyObj("unwrapped", ["getBoundingClientRect"]);
 
                 mockDomainObject.getId.andReturn(TEST_ID);
                 mockDomainObject.getModel.andReturn(testModel);
                 mockDomainObject.getCapability.andReturn(mockPersistence);
+                mockDomainObject.useCapability.andReturn(true);
                 mockEvent.dataTransfer.getData.andReturn(DROP_ID);
+                mockElement[0] = mockUnwrappedElement;
+                mockElement.scope.andReturn(mockScope);
+                mockUnwrappedElement.getBoundingClientRect.andReturn(testRect);
 
                 gesture = new DropGesture(mockQ, mockElement, mockDomainObject);
 
@@ -114,6 +124,19 @@ define(
                 expect(mockDomainObject.getCapability).toHaveBeenCalledWith("persistence");
             });
 
+            it("broadcasts drop position", function () {
+                testRect.left = 42;
+                testRect.top = 36;
+                mockEvent.pageX = 52;
+                mockEvent.pageY = 64;
+                callbacks.drop(mockEvent);
+                expect(mockScope.$broadcast).toHaveBeenCalledWith(
+                    'mctDrop',
+                    DROP_ID,
+                    { x: 10, y: 28 }
+                );
+            });
+
         });
     }
 );
\ No newline at end of file

From 8c653d39d79fa7948acc05b68f25f5d9dd17d00e Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 12:44:00 -0800
Subject: [PATCH 23/26] [Edit] Update specs

Update specs for toolbars in Edit mode to reflect
changes for WTD-879.
---
 .../representers/EditToolbarRepresenter.js    |  2 ++
 .../EditToolbarRepresenterSpec.js             |  2 +-
 .../edit/test/representers/EditToolbarSpec.js | 22 ++++++++++++++++++-
 3 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js b/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
index 4c983bcd41..8e4958d5df 100644
--- a/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
+++ b/platform/commonUI/edit/src/representers/EditToolbarRepresenter.js
@@ -48,6 +48,8 @@ define(
                 state.forEach(function (value, index) {
                     toolbar.updateState(index, value);
                 });
+                // Commit the changes.
+                commit("Changes from toolbar.");
             }
 
             // Represent a domain object using this definition
diff --git a/platform/commonUI/edit/test/representers/EditToolbarRepresenterSpec.js b/platform/commonUI/edit/test/representers/EditToolbarRepresenterSpec.js
index 134f5c0261..9ca9bb65d4 100644
--- a/platform/commonUI/edit/test/representers/EditToolbarRepresenterSpec.js
+++ b/platform/commonUI/edit/test/representers/EditToolbarRepresenterSpec.js
@@ -15,7 +15,7 @@ define(
             beforeEach(function () {
                 mockScope = jasmine.createSpyObj(
                     '$scope',
-                    [ '$on', '$watch', '$watchCollection' ]
+                    [ '$on', '$watch', '$watchCollection', "commit" ]
                 );
                 mockElement = {};
                 testAttrs = { toolbar: 'testToolbar' };
diff --git a/platform/commonUI/edit/test/representers/EditToolbarSpec.js b/platform/commonUI/edit/test/representers/EditToolbarSpec.js
index de22fe03e4..6f93bf04e8 100644
--- a/platform/commonUI/edit/test/representers/EditToolbarSpec.js
+++ b/platform/commonUI/edit/test/representers/EditToolbarSpec.js
@@ -11,7 +11,8 @@ define(
                 testABC,
                 testABC2,
                 testABCXYZ,
-                testABCYZ;
+                testABCYZ,
+                testM;
 
             beforeEach(function () {
                 testStructure = {
@@ -29,6 +30,11 @@ define(
                                 { name: "Y", property: "y" },
                                 { name: "Z", property: "z" }
                             ]
+                        },
+                        {
+                            items: [
+                                { name: "M", method: "m" }
+                            ]
                         }
                     ]
                 };
@@ -37,6 +43,7 @@ define(
                 testABC2 = { a: 4, b: 1, c: 2 }; // For inconsistent-state checking
                 testABCXYZ = { a: 0, b: 1, c: 2, x: 'X!', y: 'Y!', z: 'Z!' };
                 testABCYZ = { a: 0, b: 1, c: 2, y: 'Y!', z: 'Z!' };
+                testM = { m: jasmine.createSpy("method") };
             });
 
             it("provides properties from the original structure", function () {
@@ -182,6 +189,19 @@ define(
                         .length
                 ).toEqual(2);
             });
+
+            it("adds click functions when a method is specified", function () {
+                var testCommit = jasmine.createSpy('commit'),
+                    toolbar = new EditToolbar(testStructure, [ testM ], testCommit);
+                // Verify precondition
+                expect(testM.m).not.toHaveBeenCalled();
+                // Click!
+                toolbar.getStructure().sections[0].items[0].click();
+                // Should have called the underlying function
+                expect(testM.m).toHaveBeenCalled();
+                // Should also have committed the change
+                expect(testCommit).toHaveBeenCalled();
+            });
         });
     }
 );

From 7882dd14013400de3a0a3dda3396e69eb758cffe Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 13:06:55 -0800
Subject: [PATCH 24/26] [Fixed Position] Add spec for selection

Add spec for selection manager for layout and fixed position
views, WTD-879.
---
 .../features/layout/src/LayoutSelection.js    |  6 ++
 .../layout/test/LayoutSelectionSpec.js        | 73 +++++++++++++++++++
 2 files changed, 79 insertions(+)

diff --git a/platform/features/layout/src/LayoutSelection.js b/platform/features/layout/src/LayoutSelection.js
index 0398d3d308..bb1574f0ff 100644
--- a/platform/features/layout/src/LayoutSelection.js
+++ b/platform/features/layout/src/LayoutSelection.js
@@ -7,6 +7,12 @@ define(
 
         /**
          * Tracks selection state for Layout and Fixed Position views.
+         * This manages and mutates the provided selection array in-place,
+         * and takes care to only modify the array elements it manages
+         * (the view's proxy, and the single selection); selections may be
+         * added or removed elsewhere provided that similar care is taken
+         * elsewhere.
+         *
          * @param {Array} selection the selection array from the view's scope
          * @param [proxy] an object which represents the selection of the view
          *        itself (which handles view-level toolbar behavior)
diff --git a/platform/features/layout/test/LayoutSelectionSpec.js b/platform/features/layout/test/LayoutSelectionSpec.js
index 54742a0531..3712afec3f 100644
--- a/platform/features/layout/test/LayoutSelectionSpec.js
+++ b/platform/features/layout/test/LayoutSelectionSpec.js
@@ -6,6 +6,79 @@ define(
         "use strict";
 
         describe("Layout/fixed position selection manager", function () {
+            var testSelection,
+                testProxy,
+                testElement,
+                otherElement,
+                selection;
+
+            beforeEach(function () {
+                testSelection = [];
+                testProxy = { someKey: "some value" };
+                testElement = { someOtherKey: "some other value" };
+                otherElement = { yetAnotherKey: 42 };
+                selection = new LayoutSelection(testSelection, testProxy);
+            });
+
+            it("adds the proxy to the selection array", function () {
+                expect(testSelection).toEqual([testProxy]);
+            });
+
+            it("includes selected objects alongside the proxy", function () {
+                selection.select(testElement);
+                expect(testSelection).toEqual([testProxy, testElement]);
+            });
+
+            it("allows elements to be deselected", function () {
+                selection.select(testElement);
+                selection.deselect();
+                expect(testSelection).toEqual([testProxy]);
+            });
+
+            it("replaces old selections with new ones", function () {
+                selection.select(testElement);
+                selection.select(otherElement);
+                expect(testSelection).toEqual([testProxy, otherElement]);
+            });
+
+            it("allows retrieval of the current selection", function () {
+                selection.select(testElement);
+                expect(selection.get()).toBe(testElement);
+                selection.select(otherElement);
+                expect(selection.get()).toBe(otherElement);
+            });
+
+            it("can check if an element is selected", function () {
+                selection.select(testElement);
+                expect(selection.selected(testElement)).toBeTruthy();
+                expect(selection.selected(otherElement)).toBeFalsy();
+                selection.select(otherElement);
+                expect(selection.selected(testElement)).toBeFalsy();
+                expect(selection.selected(otherElement)).toBeTruthy();
+            });
+
+            it("cleans up the selection on destroy", function () {
+                selection.destroy();
+                expect(testSelection).toEqual([]);
+            });
+
+            it("preserves other elements in the array", function () {
+                testSelection.push(42);
+                selection.select(testElement);
+                expect(testSelection).toEqual([testProxy, testElement, 42]);
+            });
+
+            it("considers the proxy to be selected", function () {
+                expect(selection.selected(testProxy)).toBeTruthy();
+                selection.select(testElement);
+                // Even when something else is selected...
+                expect(selection.selected(testProxy)).toBeTruthy();
+            });
+
+            it("treats selection of the proxy as a no-op", function () {
+                selection.select(testProxy);
+                expect(testSelection).toEqual([testProxy]);
+            });
 
         });
     }

From 3cfcd027e0c7581c33ed288a90306d5a9496b92e Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 13:29:43 -0800
Subject: [PATCH 25/26] [Fixed Position] Fill in specs for selection proxies

Fill in specs for fixed position views selection proxies,
WTD-879.
---
 .../features/layout/test/FixedProxySpec.js    |  8 ++++-
 .../test/elements/AccessorMutatorSpec.js      | 19 ++++++++++++
 .../test/elements/ElementProxiesSpec.js       | 17 ++++++++++-
 .../layout/test/elements/ElementProxySpec.js  | 29 +++++++++++++++++++
 .../test/elements/TelemetryProxySpec.js       | 23 +++++++++++++++
 5 files changed, 94 insertions(+), 2 deletions(-)

diff --git a/platform/features/layout/test/FixedProxySpec.js b/platform/features/layout/test/FixedProxySpec.js
index d1b2daff0d..224b19f022 100644
--- a/platform/features/layout/test/FixedProxySpec.js
+++ b/platform/features/layout/test/FixedProxySpec.js
@@ -6,7 +6,13 @@ define(
         "use strict";
 
         describe("Fixed Position view's selection proxy", function () {
-
+            it("has a placeholder message when clicked", function () {
+                var oldAlert = window.alert;
+                window.alert = jasmine.createSpy('alert');
+                new FixedProxy({}).add('');
+                expect(window.alert).toHaveBeenCalledWith(jasmine.any(String));
+                window.alert = oldAlert;
+            });
         });
     }
 );
diff --git a/platform/features/layout/test/elements/AccessorMutatorSpec.js b/platform/features/layout/test/elements/AccessorMutatorSpec.js
index 0936034e98..afcede7176 100644
--- a/platform/features/layout/test/elements/AccessorMutatorSpec.js
+++ b/platform/features/layout/test/elements/AccessorMutatorSpec.js
@@ -6,6 +6,25 @@ define(
         "use strict";
 
         describe("An accessor-mutator", function () {
+            var testObject,
+                am;
+
+            beforeEach(function () {
+                testObject = { t: 42, other: 100 };
+                am = new AccessorMutator(testObject, 't');
+            });
+
+            it("allows access to a property", function () {
+                expect(am()).toEqual(42);
+            });
+
+            it("allows mutation of a property", function () {
+                expect(am("some other value")).toEqual("some other value");
+                expect(testObject).toEqual({
+                    t: "some other value",
+                    other: 100
+                });
+            });
 
         });
     }
diff --git a/platform/features/layout/test/elements/ElementProxiesSpec.js b/platform/features/layout/test/elements/ElementProxiesSpec.js
index 4382b8dbf9..cf771a043a 100644
--- a/platform/features/layout/test/elements/ElementProxiesSpec.js
+++ b/platform/features/layout/test/elements/ElementProxiesSpec.js
@@ -5,8 +5,23 @@ define(
     function (ElementProxies) {
         "use strict";
 
-        describe("The set of element proxies", function () {
+        var ELEMENT_TYPES = [
+            "fixed.telemetry"
+        ];
 
+        // Verify that the set of proxies exposed matches the specific
+        // list above.
+        describe("The set of element proxies", function () {
+            ELEMENT_TYPES.forEach(function (t) {
+                it("exposes a proxy wrapper for " + t + " elements", function () {
+                    expect(typeof ElementProxies[t]).toEqual('function');
+                });
+            });
+
+            it("exposes no additional wrappers", function () {
+                expect(Object.keys(ElementProxies).length)
+                    .toEqual(ELEMENT_TYPES.length);
+            });
         });
     }
 );
diff --git a/platform/features/layout/test/elements/ElementProxySpec.js b/platform/features/layout/test/elements/ElementProxySpec.js
index 02c948940f..e2a9c2880e 100644
--- a/platform/features/layout/test/elements/ElementProxySpec.js
+++ b/platform/features/layout/test/elements/ElementProxySpec.js
@@ -6,7 +6,36 @@ define(
         "use strict";
 
         describe("A fixed position element proxy", function () {
+            var testElement,
+                testElements,
+                proxy;
 
+            beforeEach(function () {
+                testElement = {
+                    x: 1,
+                    y: 2,
+                    z: 3,
+                    width: 42,
+                    height: 24
+                };
+                testElements = [ {}, {}, testElement, {} ];
+                proxy = new ElementProxy(
+                    testElement,
+                    testElements.indexOf(testElement),
+                    testElements
+                );
+            });
+
+            it("exposes element properties", function () {
+                Object.keys(testElement).forEach(function (k) {
+                    expect(proxy[k]()).toEqual(testElement[k]);
+                });
+            });
+
+            it("allows elements to be removed", function () {
+                proxy.remove();
+                expect(testElements).toEqual([{}, {}, {}]);
+            });
         });
     }
 );
diff --git a/platform/features/layout/test/elements/TelemetryProxySpec.js b/platform/features/layout/test/elements/TelemetryProxySpec.js
index ad63f34a67..fdd7e555d0 100644
--- a/platform/features/layout/test/elements/TelemetryProxySpec.js
+++ b/platform/features/layout/test/elements/TelemetryProxySpec.js
@@ -6,7 +6,30 @@ define(
         "use strict";
 
         describe("A fixed position telemetry proxy", function () {
+            var testElement,
+                testElements,
+                proxy;
 
+            beforeEach(function () {
+                testElement = {
+                    x: 1,
+                    y: 2,
+                    z: 3,
+                    width: 42,
+                    height: 24,
+                    id: "test-id"
+                };
+                testElements = [ {}, {}, testElement, {} ];
+                proxy = new TelemetryProxy(
+                    testElement,
+                    testElements.indexOf(testElement),
+                    testElements
+                );
+            });
+
+            it("exposes the element's id", function () {
+                expect(proxy.id).toEqual('test-id');
+            });
         });
     }
 );

From 1015e97b3e8de6016a6ac8ba58f132fd12da9730 Mon Sep 17 00:00:00 2001
From: Victor Woeltjen <victor.woeltjen@nasa.gov>
Date: Thu, 19 Feb 2015 16:24:45 -0800
Subject: [PATCH 26/26] [Fixed Position] Add tests for FixedController

Add additional test cases for controller for Fixed Position
view to meet code coverage after changes for WTD-879.
---
 .../features/layout/res/templates/fixed.html  |   2 +-
 .../features/layout/src/FixedController.js    |  20 +++-
 .../layout/test/FixedControllerSpec.js        | 111 +++++++++++++++---
 3 files changed, 112 insertions(+), 21 deletions(-)

diff --git a/platform/features/layout/res/templates/fixed.html b/platform/features/layout/res/templates/fixed.html
index 78b2edc5f7..0b7e1ef056 100644
--- a/platform/features/layout/res/templates/fixed.html
+++ b/platform/features/layout/res/templates/fixed.html
@@ -11,7 +11,7 @@
     </span>
 
     <!-- Fixed position elements -->
-    <mct-include ng-repeat="element in controller.getDecoratedElements()"
+    <mct-include ng-repeat="element in controller.getElements()"
                  style="position: absolute;"
                  key="element.template"
                  ng-class="{ test: controller.selected(element) }"
diff --git a/platform/features/layout/src/FixedController.js b/platform/features/layout/src/FixedController.js
index 88da08537a..d18d286840 100644
--- a/platform/features/layout/src/FixedController.js
+++ b/platform/features/layout/src/FixedController.js
@@ -24,6 +24,7 @@ define(
                 subscription,
                 cellStyles = [],
                 elementProxies = [],
+                elementProxiesById = {},
                 selection;
 
             // Refresh cell styles (e.g. because grid extent changed)
@@ -65,7 +66,7 @@ define(
             function updateValue(telemetryObject) {
                 var id = telemetryObject && telemetryObject.getId();
                 if (id) {
-                    elementProxies.forEach(function (element) {
+                    (elementProxiesById[id] || []).forEach(function (element) {
                         element.name = telemetryObject.getModel().name;
                         element.value = telemetryFormatter.formatRangeValue(
                             subscription.getRangeValue(telemetryObject)
@@ -120,6 +121,17 @@ define(
                     }
                 }
 
+                // Finally, rebuild lists of elements by id to
+                // facilitate faster update when new telemetry comes in.
+                elementProxiesById = {};
+                elementProxies.forEach(function (elementProxy) {
+                    var id = elementProxy.id;
+                    if (elementProxy.element.type === 'fixed.telemetry') {
+                        elementProxiesById[id] = elementProxiesById[id] || [];
+                        elementProxiesById[id].push(elementProxy);
+                    }
+                });
+
                 // TODO: Ensure elements for all domain objects?
             }
 
@@ -224,11 +236,11 @@ define(
                     }
                 },
                 /**
-                 * Get an array of elements in this panel, decorated for
-                 * display.
+                 * Get an array of elements in this panel; these are
+                 * decorated proxies for both selection and display.
                  * @returns {Array} elements in this panel
                  */
-                getDecoratedElements: function () {
+                getElements: function () {
                     return elementProxies;
                 },
                 /**
diff --git a/platform/features/layout/test/FixedControllerSpec.js b/platform/features/layout/test/FixedControllerSpec.js
index 693c1c46d5..460228e362 100644
--- a/platform/features/layout/test/FixedControllerSpec.js
+++ b/platform/features/layout/test/FixedControllerSpec.js
@@ -14,6 +14,7 @@ define(
                 testGrid,
                 testModel,
                 testValues,
+                testConfiguration,
                 controller;
 
             // Utility function; find a watch for a given expression
@@ -41,9 +42,10 @@ define(
             function makeMockDomainObject(id) {
                 var mockObject = jasmine.createSpyObj(
                     'domainObject-' + id,
-                    [ 'getId' ]
+                    [ 'getId', 'getModel' ]
                 );
                 mockObject.getId.andReturn(id);
+                mockObject.getModel.andReturn({ name: "Point " + id});
                 return mockObject;
             }
 
@@ -75,6 +77,11 @@ define(
                     layoutGrid: testGrid
                 };
                 testValues = { a: 10, b: 42, c: 31.42 };
+                testConfiguration = { elements: [
+                    { type: "fixed.telemetry", id: 'a', x: 1, y: 1 },
+                    { type: "fixed.telemetry", id: 'b', x: 1, y: 1 },
+                    { type: "fixed.telemetry", id: 'c', x: 1, y: 1 }
+                ]};
 
                 mockSubscriber.subscribe.andReturn(mockSubscription);
                 mockSubscription.getTelemetryObjects.andReturn(
@@ -87,6 +94,8 @@ define(
                     return "Formatted " + v;
                 });
                 mockScope.model = testModel;
+                mockScope.configuration = testConfiguration;
+                mockScope.selection = []; // Act like edit mode
 
                 controller = new FixedController(
                     mockScope,
@@ -109,7 +118,7 @@ define(
                 );
             });
 
-            xit("releases subscriptions when domain objects change", function () {
+            it("releases subscriptions when domain objects change", function () {
                 mockScope.domainObject = mockDomainObject;
 
                 // First pass - should simply should subscribe
@@ -123,30 +132,85 @@ define(
                 expect(mockSubscriber.subscribe.calls.length).toEqual(2);
             });
 
-            xit("configures view based on model", function () {
+            it("exposes visible elements based on configuration", function () {
+                var elements;
+
                 mockScope.model = testModel;
-                findWatch("model.composition")(mockScope.model.composition);
-                // Should have styles for all elements of composition
-                expect(controller.getStyle('a')).toBeDefined();
-                expect(controller.getStyle('b')).toBeDefined();
-                expect(controller.getStyle('c')).toBeDefined();
-                expect(controller.getStyle('d')).not.toBeDefined();
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                expect(elements.length).toEqual(3);
+                expect(elements[0].id).toEqual('a');
+                expect(elements[1].id).toEqual('b');
+                expect(elements[2].id).toEqual('c');
             });
 
-            xit("provides values for telemetry elements", function () {
+            it("allows elements to be selected", function () {
+                var elements;
+
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                controller.select(elements[1]);
+                expect(controller.selected(elements[0])).toBeFalsy();
+                expect(controller.selected(elements[1])).toBeTruthy();
+            });
+
+            it("allows selections to be cleared", function () {
+                var elements;
+
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                controller.select(elements[1]);
+                controller.clearSelection();
+                expect(controller.selected(elements[1])).toBeFalsy();
+            });
+
+            it("retains selections during refresh", function () {
+                // Get elements; remove one of them; trigger refresh.
+                // Same element (at least by index) should still be selected.
+                var elements;
+
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                controller.select(elements[1]);
+
+                elements[2].remove();
+                testModel.modified = 2;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                // Verify removal, as test assumes this
+                expect(elements.length).toEqual(2);
+
+                expect(controller.selected(elements[1])).toBeTruthy();
+            });
+
+            it("provides values for telemetry elements", function () {
+                var elements;
                 // Initialize
                 mockScope.domainObject = mockDomainObject;
                 mockScope.model = testModel;
                 findWatch("domainObject")(mockDomainObject);
+                findWatch("model.modified")(1);
                 findWatch("model.composition")(mockScope.model.composition);
 
                 // Invoke the subscription callback
                 mockSubscriber.subscribe.mostRecentCall.args[1]();
 
+                // Get elements that controller is now exposing
+                elements = controller.getElements();
+
                 // Formatted values should be available
-                expect(controller.getValue('a')).toEqual("Formatted 10");
-                expect(controller.getValue('b')).toEqual("Formatted 42");
-                expect(controller.getValue('c')).toEqual("Formatted 31.42");
+                expect(elements[0].value).toEqual("Formatted 10");
+                expect(elements[1].value).toEqual("Formatted 42");
+                expect(elements[2].value).toEqual("Formatted 31.42");
             });
 
             it("adds grid cells to fill boundaries", function () {
@@ -170,7 +234,7 @@ define(
                 expect(controller.getCellStyles().length).toEqual(60); // 10 * 6
             });
 
-            xit("listens for drop events", function () {
+            it("listens for drop events", function () {
                 // Layout should position panels according to
                 // where the user dropped them, so it needs to
                 // listen for drop events.
@@ -180,7 +244,7 @@ define(
                 );
 
                 // Verify precondition
-                expect(controller.getStyle('d')).not.toBeDefined();
+                expect(testConfiguration.elements.length).toEqual(3);
 
                 // Notify that a drop occurred
                 testModel.composition.push('d');
@@ -189,13 +253,28 @@ define(
                     'd',
                     { x: 300, y: 100 }
                 );
-                expect(controller.getStyle('d')).toBeDefined();
+
+                // Should have added an element
+                expect(testConfiguration.elements.length).toEqual(4);
 
                 // Should have triggered commit (provided by
                 // EditRepresenter) with some message.
                 expect(mockScope.commit)
                     .toHaveBeenCalledWith(jasmine.any(String));
             });
+
+
+
+            it("unsubscribes when destroyed", function () {
+                // Make an object available
+                findWatch('domainObject')(mockDomainObject);
+                // Also verify precondition
+                expect(mockSubscription.unsubscribe).not.toHaveBeenCalled();
+                // Destroy the scope
+                findOn('$destroy')();
+                // Should have unsubscribed
+                expect(mockSubscription.unsubscribe).toHaveBeenCalled();
+            });
         });
     }
 );
\ No newline at end of file