Merge branch 'master' into open-623

platform/features/autoflow/plugin.js

@@ -0,0 +1,54 @@
+define([
+    'text!./res/templates/autoflow-tabular.html',
+    './src/AutoflowTabularController',
+    './src/MCTAutoflowTable'
+], function (
+    autoflowTabularTemplate,
+    AutoflowTabularController,
+    MCTAutoflowTable
+) {
+    return function (options) {
+        return function (openmct) {
+            openmct.legacyRegistry.register("platform/features/autoflow", {
+                "name": "WARP Telemetry Adapter",
+                "description": "Retrieves telemetry from the WARP Server and provides related types and views.",
+                "resources": "res",
+                "extensions": {
+                    "views": [
+                        {
+                            "key": "autoflow",
+                            "name": "Autoflow Tabular",
+                            "cssClass": "icon-packet",
+                            "description": "A tabular view of packet contents.",
+                            "template": autoflowTabularTemplate,
+                            "type": options && options.type,
+                            "needs": [
+                                "telemetry"
+                            ],
+                            "delegation": true
+                        }
+                    ],
+                    "controllers": [
+                        {
+                            "key": "AutoflowTabularController",
+                            "implementation": AutoflowTabularController,
+                            "depends": [
+                                "$scope",
+                                "$timeout",
+                                "telemetrySubscriber"
+                            ]
+                        }
+                    ],
+                    "directives": [
+                        {
+                            "key": "mctAutoflowTable",
+                            "implementation": MCTAutoflowTable
+                        }
+                    ]
+                }
+            });
+            openmct.legacyRegistry.enable("platform/features/autoflow");
+        };
+    };
+});
+

platform/features/autoflow/res/templates/autoflow-tabular.html

@@ -0,0 +1,26 @@
+<div class="items-holder abs contents autoflow obj-value-format"
+     ng-controller="AutoflowTabularController as autoflow">
+    <div class="abs l-flex-row holder t-autoflow-header l-autoflow-header">
+        <mct-include key="'input-filter'"
+                     ng-model="autoflow.filter"
+                     class="flex-elem">
+        </mct-include>
+        <div class="flex-elem grows t-last-update" title="Last Update">{{autoflow.updated()}}</div>
+        <a title="Change column width"
+            class="s-button flex-elem icon-arrows-right-left change-column-width"
+            ng-click="autoflow.increaseColumnWidth()"></a>
+    </div>
+    <div class="abs t-autoflow-items l-autoflow-items"
+         mct-resize="autoflow.setBounds(bounds)"
+         mct-resize-interval="50">
+        <mct-autoflow-table values="autoflow.rangeValues()"
+                            objects="autoflow.getTelemetryObjects()"
+                            rows="autoflow.getRows()"
+                            classes="autoflow.classes()"
+                            updated="autoflow.updated()"
+                            column-width="autoflow.columnWidth()"
+                            counter="autoflow.counter()"
+                            >
+        </mct-autoflow-table>
+    </div>
+</div>

platform/features/autoflow/src/AutoflowTableLinker.js

@@ -0,0 +1,169 @@
+/*global angular*/
+define(
+    [],
+    function () {
+
+        /**
+         * The link step for the `mct-autoflow-table` directive;
+         * watches scope and updates the DOM appropriately.
+         * See documentation in `MCTAutoflowTable.js` for the rationale
+         * for including this directive, as well as for an explanation
+         * of which values are placed in scope.
+         *
+         * @constructor
+         * @param {Scope} scope the scope for this usage of the directive
+         * @param element the jqLite-wrapped element which used this directive
+         */
+        function AutoflowTableLinker(scope, element) {
+            var objects, // Domain objects at last structure refresh
+                rows, // Number of rows from last structure refresh
+                priorClasses = {},
+                valueSpans = {}; // Span elements to put data values in
+
+            // Create a new name-value pair in the specified column
+            function createListItem(domainObject, ul) {
+                // Create a new li, and spans to go in it.
+                var li = angular.element('<li>'),
+                    titleSpan = angular.element('<span>'),
+                    valueSpan = angular.element('<span>');
+
+                // Place spans in the li, and li into the column.
+                // valueSpan must precede titleSpan in the DOM due to new CSS float approach
+                li.append(valueSpan).append(titleSpan);
+                ul.append(li);
+
+                // Style appropriately
+                li.addClass('l-autoflow-row');
+                titleSpan.addClass('l-autoflow-item l');
+                valueSpan.addClass('l-autoflow-item r l-obj-val-format');
+
+                // Set text/tooltip for the name-value row
+                titleSpan.text(domainObject.getModel().name);
+                titleSpan.attr("title", domainObject.getModel().name);
+
+                // Keep a reference to the span which will hold the
+                // data value, to populate in the next refreshValues call
+                valueSpans[domainObject.getId()] = valueSpan;
+
+                return li;
+            }
+
+            // Create a new column of name-value pairs in this table.
+            function createColumn(el) {
+                // Create a ul
+                var ul = angular.element('<ul>');
+
+                // Add it into the mct-autoflow-table
+                el.append(ul);
+
+                // Style appropriately
+                ul.addClass('l-autoflow-col');
+
+                // Get the current col width and apply at time of column creation
+                // Important to do this here, as new columns could be created after
+                // the user has changed the width.
+                ul.css('width', scope.columnWidth + 'px');
+
+                // Return it, so some li elements can be added
+                return ul;
+            }
+
+            // Change the width of the columns when user clicks the resize button.
+            function resizeColumn() {
+                element.find('ul').css('width', scope.columnWidth + 'px');
+            }
+
+            // Rebuild the DOM associated with this table.
+            function rebuild(domainObjects, rowCount) {
+                var activeColumn;
+
+                // Empty out our cached span elements
+                valueSpans = {};
+
+                // Start with an empty DOM beneath this directive
+                element.html("");
+
+                // Add DOM elements for each domain object being displayed
+                // in this table.
+                domainObjects.forEach(function (object, index) {
+                    // Start a new column if we'd run out of room
+                    if (index % rowCount === 0) {
+                        activeColumn = createColumn(element);
+                    }
+                    // Add the DOM elements for that object to whichever
+                    // column (a `ul` element) is current.
+                    createListItem(object, activeColumn);
+                });
+            }
+
+            // Update spans with values, as made available via the
+            // `values` attribute of this directive.
+            function refreshValues() {
+                // Get the available values
+                var values = scope.values || {},
+                    classes = scope.classes || {};
+
+                // Populate all spans with those values (or clear
+                // those spans if no value is available)
+                (objects || []).forEach(function (object) {
+                    var id = object.getId(),
+                        span = valueSpans[id],
+                        value;
+
+                    if (span) {
+                        // Look up the value...
+                        value = values[id];
+                        // ...and convert to empty string if it's undefined
+                        value = value === undefined ? "" : value;
+                        span.attr("data-value", value);
+
+                        // Update the span
+                        span.text(value);
+                        span.attr("title", value);
+                        span.removeClass(priorClasses[id]);
+                        span.addClass(classes[id]);
+                        priorClasses[id] = classes[id];
+                    }
+                    // Also need stale/alert/ok class
+                    // on span
+                });
+            }
+
+            // Refresh the DOM for this table, if necessary
+            function refreshStructure() {
+                // Only rebuild if number of rows or set of objects
+                // has changed; otherwise, our structure is still valid.
+                if (scope.objects !== objects ||
+                        scope.rows !== rows) {
+
+                    // Track those values to support future refresh checks
+                    objects = scope.objects;
+                    rows = scope.rows;
+
+                    // Rebuild the DOM
+                    rebuild(objects || [], rows || 1);
+
+                    // Refresh all data values shown
+                    refreshValues();
+                }
+            }
+
+            // Changing the domain objects in use or the number
+            // of rows should trigger a structure change (DOM rebuild)
+            scope.$watch("objects", refreshStructure);
+            scope.$watch("rows", refreshStructure);
+
+            // When the current column width has been changed, resize the column
+            scope.$watch('columnWidth', resizeColumn);
+
+            // When the last-updated time ticks,
+            scope.$watch("updated", refreshValues);
+
+            // Update displayed values when the counter changes.
+            scope.$watch("counter", refreshValues);
+
+        }
+
+        return AutoflowTableLinker;
+    }
+);

platform/features/autoflow/src/AutoflowTabularController.js

@@ -0,0 +1,324 @@
+
+define(
+    ['moment'],
+    function (moment) {
+
+        var ROW_HEIGHT = 16,
+            SLIDER_HEIGHT = 10,
+            INITIAL_COLUMN_WIDTH = 225,
+            MAX_COLUMN_WIDTH = 525,
+            COLUMN_WIDTH_STEP = 25,
+            DEBOUNCE_INTERVAL = 100,
+            DATE_FORMAT = "YYYY-DDD HH:mm:ss.SSS\\Z",
+            NOT_UPDATED = "No updates",
+            EMPTY_ARRAY = [];
+
+        /**
+         * Responsible for supporting the autoflow tabular view.
+         * Implements the all-over logic which drives that view,
+         * mediating between template-provided areas, the included
+         * `mct-autoflow-table` directive, and the underlying
+         * domain object model.
+         * @constructor
+         */
+        function AutflowTabularController(
+            $scope,
+            $timeout,
+            telemetrySubscriber
+        ) {
+            var filterValue = "",
+                filterValueLowercase = "",
+                subscription,
+                filteredObjects = [],
+                lastUpdated = {},
+                updateText = NOT_UPDATED,
+                rangeValues = {},
+                classes = {},
+                limits = {},
+                updatePending = false,
+                lastBounce = Number.NEGATIVE_INFINITY,
+                columnWidth = INITIAL_COLUMN_WIDTH,
+                rows = 1,
+                counter = 0;
+
+            // Trigger an update of the displayed table by incrementing
+            // the counter that it watches.
+            function triggerDisplayUpdate() {
+                counter += 1;
+            }
+
+            // Check whether or not an object's name matches the
+            // user-entered filter value.
+            function filterObject(domainObject) {
+                return (domainObject.getModel().name || "")
+                    .toLowerCase()
+                    .indexOf(filterValueLowercase) !== -1;
+            }
+
+            // Comparator for sorting points back into packet order
+            function compareObject(objectA, objectB) {
+                var indexA = objectA.getModel().index || 0,
+                    indexB = objectB.getModel().index || 0;
+                return indexA - indexB;
+            }
+
+            // Update the list of currently-displayed objects; these
+            // will be the subset of currently subscribed-to objects
+            // which match a user-entered filter.
+            function doUpdateFilteredObjects() {
+                // Generate the list
+                filteredObjects = (
+                    subscription ?
+                            subscription.getTelemetryObjects() :
+                            []
+                ).filter(filterObject).sort(compareObject);
+
+                // Clear the pending flag
+                updatePending = false;
+
+                // Track when this occurred, so that we can wait
+                // a whole before updating again.
+                lastBounce = Date.now();
+
+                triggerDisplayUpdate();
+            }
+
+            // Request an update to the list of current objects; this may
+            // run on a timeout to avoid excessive calls, e.g. while the user
+            // is typing a filter.
+            function updateFilteredObjects() {
+                // Don't do anything if an update is already scheduled
+                if (!updatePending) {
+                    if (Date.now() > lastBounce + DEBOUNCE_INTERVAL) {
+                        // Update immediately if it's been long enough
+                        doUpdateFilteredObjects();
+                    } else {
+                        // Otherwise, update later, and track that we have
+                        // an update pending so that subsequent calls can
+                        // be ignored.
+                        updatePending = true;
+                        $timeout(doUpdateFilteredObjects, DEBOUNCE_INTERVAL);
+                    }
+                }
+            }
+
+            // Track the latest data values for this domain object
+            function recordData(telemetryObject) {
+                // Get latest domain/range values for this object.
+                var id = telemetryObject.getId(),
+                    domainValue = subscription.getDomainValue(telemetryObject),
+                    rangeValue = subscription.getRangeValue(telemetryObject);
+
+                // Track the most recent timestamp change observed...
+                if (domainValue !== undefined && domainValue !== lastUpdated[id]) {
+                    lastUpdated[id] = domainValue;
+                    // ... and update the displayable text for that timestamp
+                    updateText = isNaN(domainValue) ? "" :
+                            moment.utc(domainValue).format(DATE_FORMAT);
+                }
+
+                // Store data values into the rangeValues structure, which
+                // will be used to populate the table itself.
+                // Note that we want full precision here.
+                rangeValues[id] = rangeValue;
+
+                // Update limit states as well
+                classes[id] = limits[id] && (limits[id].evaluate({
+                    // This relies on external knowledge that the
+                    // range value of a telemetry point is encoded
+                    // in its datum as "value."
+                    value: rangeValue
+                }) || {}).cssClass;
+            }
+
+
+            // Look at telemetry objects from the subscription; this is watched
+            // to detect changes from the subscription.
+            function subscribedTelemetry() {
+                return subscription ?
+                        subscription.getTelemetryObjects() : EMPTY_ARRAY;
+            }
+
+            // Update the data values which will be used to populate the table
+            function updateValues() {
+                subscribedTelemetry().forEach(recordData);
+                triggerDisplayUpdate();
+            }
+
+            // Getter-setter function for user-entered filter text.
+            function filter(value) {
+                // If value was specified, we're a setter
+                if (value !== undefined) {
+                    // Store the new value
+                    filterValue = value;
+                    filterValueLowercase = value.toLowerCase();
+                    // Change which objects appear in the table
+                    updateFilteredObjects();
+                }
+
+                // Always act as a getter
+                return filterValue;
+            }
+
+            // Update the bounds (width and height) of this view;
+            // called from the mct-resize directive. Recalculates how
+            // many rows should appear in the contained table.
+            function setBounds(bounds) {
+                var availableSpace = bounds.height - SLIDER_HEIGHT;
+                rows = Math.max(1, Math.floor(availableSpace / ROW_HEIGHT));
+            }
+
+            // Increment the current column width, up to the defined maximum.
+            // When the max is hit, roll back to the default.
+            function increaseColumnWidth() {
+                columnWidth += COLUMN_WIDTH_STEP;
+                // Cycle down to the initial width instead of exceeding max
+                columnWidth = columnWidth > MAX_COLUMN_WIDTH ?
+                        INITIAL_COLUMN_WIDTH : columnWidth;
+            }
+
+            // Get displayable text for last-updated value
+            function updated() {
+                return updateText;
+            }
+
+            // Unsubscribe, if a subscription is active.
+            function releaseSubscription() {
+                if (subscription) {
+                    subscription.unsubscribe();
+                    subscription = undefined;
+                }
+            }
+
+            // Update set of telemetry objects managed by this view
+            function updateTelemetryObjects(telemetryObjects) {
+                updateFilteredObjects();
+                limits = {};
+                telemetryObjects.forEach(function (telemetryObject) {
+                    var id = telemetryObject.getId();
+                    limits[id] = telemetryObject.getCapability('limit');
+                });
+            }
+
+            // Create a subscription for the represented domain object.
+            // This will resolve capability delegation as necessary.
+            function makeSubscription(domainObject) {
+                // Unsubscribe, if there is an existing subscription
+                releaseSubscription();
+
+                // Clear updated timestamp
+                lastUpdated = {};
+                updateText = NOT_UPDATED;
+
+                // Create a new subscription; telemetrySubscriber gets
+                // to do the meaningful work here.
+                subscription = domainObject && telemetrySubscriber.subscribe(
+                    domainObject,
+                    updateValues
+                );
+
+                // Our set of in-view telemetry objects may have changed,
+                // so update the set that is being passed down to the table.
+                updateFilteredObjects();
+            }
+
+            // Watch for changes to the set of objects which have telemetry
+            $scope.$watch(subscribedTelemetry, updateTelemetryObjects);
+
+            // Watch for the represented domainObject (this field will
+            // be populated by mct-representation)
+            $scope.$watch("domainObject", makeSubscription);
+
+            // Make sure we unsubscribe when this view is destroyed.
+            $scope.$on("$destroy", releaseSubscription);
+
+            return {
+                /**
+                 * Get the number of rows which should be shown in this table.
+                 * @return {number} the number of rows to show
+                 */
+                getRows: function () {
+                    return rows;
+                },
+                /**
+                 * Get the objects which should currently be displayed in
+                 * this table. This will be watched, so the return value
+                 * should be stable when this list is unchanging. Only
+                 * objects which match the user-entered filter value should
+                 * be returned here.
+                 * @return {DomainObject[]} the domain objects to include in
+                 *         this table.
+                 */
+                getTelemetryObjects: function () {
+                    return filteredObjects;
+                },
+                /**
+                 * Set the bounds (width/height) of this autoflow tabular view.
+                 * The template must ensure that these bounds are tracked on
+                 * the table area only.
+                 * @param bounds the bounds; and object with `width` and
+                 *        `height` properties, both as numbers, in pixels.
+                 */
+                setBounds: setBounds,
+                /**
+                 * Increments the width of the autoflow column.
+                 * Setting does not yet persist.
+                 */
+                increaseColumnWidth: increaseColumnWidth,
+                /**
+                 * Get-or-set the user-supplied filter value.
+                 * @param {string} [value] the new filter value; omit to use
+                 *        as a getter
+                 * @returns {string} the user-supplied filter value
+                 */
+                filter: filter,
+                /**
+                 * Get all range values for use in this table. These will be
+                 * returned as an object of key-value pairs, where keys are
+                 * domain object IDs, and values are the most recently observed
+                 * data values associated with those objects, formatted for
+                 * display.
+                 * @returns {object.<string,string>} most recent values
+                 */
+                rangeValues: function () {
+                    return rangeValues;
+                },
+                /**
+                 * Get CSS classes to apply to specific rows, representing limit
+                 * states and/or stale states. These are returned as key-value
+                 * pairs where keys are domain object IDs, and values are CSS
+                 * classes to display for domain objects with those IDs.
+                 * @returns {object.<string,string>} CSS classes
+                 */
+                classes: function () {
+                    return classes;
+                },
+                /**
+                 * Get the "last updated" text for this view; this will be
+                 * the most recent timestamp observed for any telemetry-
+                 * providing object, formatted for display.
+                 * @returns {string} the time of the most recent update
+                 */
+                updated: updated,
+                /**
+                 * Get the current column width, in pixels.
+                 * @returns {number} column width
+                 */
+                columnWidth: function () {
+                    return columnWidth;
+                },
+                /**
+                 * Keep a counter and increment this whenever the display
+                 * should be updated; this will be watched by the
+                 * `mct-autoflow-table`.
+                 * @returns {number} a counter value
+                 */
+                counter: function () {
+                    return counter;
+                }
+            };
+        }
+
+        return AutflowTabularController;
+    }
+);

platform/features/autoflow/src/MCTAutoflowTable.js

@@ -0,0 +1,60 @@
+
+define(
+    ["./AutoflowTableLinker"],
+    function (AutoflowTableLinker) {
+
+        /**
+         * The `mct-autoflow-table` directive specifically supports
+         * autoflow tabular views; it is not intended for use outside
+         * of that view.
+         *
+         * This directive is responsible for creating the structure
+         * of the table in this view, and for updating its values.
+         * While this is achievable using a regular Angular template,
+         * this is undesirable from the perspective of performance
+         * due to the number of watches that can be involved for large
+         * tables. Instead, this directive will maintain a small number
+         * of watches, rebuilding table structure only when necessary,
+         * and updating displayed values in the more common case of
+         * new data arriving.
+         *
+         * @constructor
+         */
+        function MCTAutoflowTable() {
+            return {
+                // Only applicable at the element level
+                restrict: "E",
+
+                // The link function; handles DOM update/manipulation
+                link: AutoflowTableLinker,
+
+                // Parameters to pass from attributes into scope
+                scope: {
+                    // Set of domain objects to show in the table
+                    objects: "=",
+
+                    // Values for those objects, by ID
+                    values: "=",
+
+                    // CSS classes to show for objects, by ID
+                    classes: "=",
+
+                    // Number of rows to show before autoflowing
+                    rows: "=",
+
+                    // Time of last update; watched to refresh values
+                    updated: "=",
+
+                    // Current width of the autoflow column
+                    columnWidth: "=",
+
+                    // A counter used to trigger display updates
+                    counter: "="
+                }
+            };
+        }
+
+        return MCTAutoflowTable;
+
+    }
+);

platform/features/autoflow/test/AutoflowTableLinkerSpec.js

@@ -0,0 +1,178 @@
+
+define(
+    ["../src/AutoflowTableLinker"],
+    function (AutoflowTableLinker) {
+
+        describe("The mct-autoflow-table linker", function () {
+            var cachedAngular,
+                mockAngular,
+                mockScope,
+                mockElement,
+                mockElements,
+                linker;
+
+            // Utility function to generate more mock elements
+            function createMockElement(html) {
+                var mockEl = jasmine.createSpyObj(
+                    "element-" + html,
+                    [
+                        "append",
+                        "addClass",
+                        "removeClass",
+                        "text",
+                        "attr",
+                        "html",
+                        "css",
+                        "find"
+                    ]
+                );
+                mockEl.testHtml = html;
+                mockEl.append.andReturn(mockEl);
+                mockElements.push(mockEl);
+                return mockEl;
+            }
+
+            function createMockDomainObject(id) {
+                var mockDomainObject = jasmine.createSpyObj(
+                    "domainObject-" + id,
+                    ["getId", "getModel"]
+                );
+                mockDomainObject.getId.andReturn(id);
+                mockDomainObject.getModel.andReturn({name: id.toUpperCase()});
+                return mockDomainObject;
+            }
+
+            function fireWatch(watchExpression, value) {
+                mockScope.$watch.calls.forEach(function (call) {
+                    if (call.args[0] === watchExpression) {
+                        call.args[1](value);
+                    }
+                });
+            }
+
+            // AutoflowTableLinker accesses Angular in the global
+            // scope, since it is not injectable; we simulate that
+            // here by adding/removing it to/from the window object.
+            beforeEach(function () {
+                mockElements = [];
+
+                mockAngular = jasmine.createSpyObj("angular", ["element"]);
+                mockScope = jasmine.createSpyObj("scope", ["$watch"]);
+                mockElement = createMockElement('<div>');
+
+                mockAngular.element.andCallFake(createMockElement);
+
+                if (window.angular !== undefined) {
+                    cachedAngular = window.angular;
+                }
+                window.angular = mockAngular;
+
+                linker = new AutoflowTableLinker(mockScope, mockElement);
+            });
+
+            afterEach(function () {
+                if (cachedAngular !== undefined) {
+                    window.angular = cachedAngular;
+                } else {
+                    delete window.angular;
+                }
+            });
+
+            it("watches for changes in inputs", function () {
+                expect(mockScope.$watch).toHaveBeenCalledWith(
+                    "objects",
+                    jasmine.any(Function)
+                );
+                expect(mockScope.$watch).toHaveBeenCalledWith(
+                    "rows",
+                    jasmine.any(Function)
+                );
+                expect(mockScope.$watch).toHaveBeenCalledWith(
+                    "counter",
+                    jasmine.any(Function)
+                );
+            });
+
+            it("changes structure when domain objects change", function () {
+                // Set up scope
+                mockScope.rows = 4;
+                mockScope.objects = ['a', 'b', 'c', 'd', 'e', 'f']
+                    .map(createMockDomainObject);
+
+                // Fire an update to the set of objects
+                fireWatch("objects");
+
+                // Should have rebuilt with two columns of
+                // four and two rows each; first, by clearing...
+                expect(mockElement.html).toHaveBeenCalledWith("");
+
+                // Should have appended two columns...
+                expect(mockElement.append.calls.length).toEqual(2);
+
+                // ...which should have received two and four rows each
+                expect(mockElement.append.calls[0].args[0].append.calls.length)
+                    .toEqual(4);
+                expect(mockElement.append.calls[1].args[0].append.calls.length)
+                    .toEqual(2);
+            });
+
+            it("updates values", function () {
+                var mockSpans;
+
+                mockScope.objects = ['a', 'b', 'c', 'd', 'e', 'f']
+                    .map(createMockDomainObject);
+                mockScope.values = { a: 0 };
+
+                // Fire an update to the set of values
+                fireWatch("objects");
+                fireWatch("updated");
+
+                // Get all created spans
+                mockSpans = mockElements.filter(function (mockElem) {
+                    return mockElem.testHtml === '<span>';
+                });
+
+                // First span should be a, should have gotten this value.
+                // This test detects, in particular, WTD-749
+                expect(mockSpans[0].text).toHaveBeenCalledWith('A');
+                expect(mockSpans[1].text).toHaveBeenCalledWith(0);
+            });
+
+            it("listens for changes in column width", function () {
+                var mockUL = createMockElement("<ul>");
+                mockElement.find.andReturn(mockUL);
+                mockScope.columnWidth = 200;
+                fireWatch("columnWidth", mockScope.columnWidth);
+                expect(mockUL.css).toHaveBeenCalledWith("width", "200px");
+            });
+
+            it("updates CSS classes", function () {
+                var mockSpans;
+
+                mockScope.objects = ['a', 'b', 'c', 'd', 'e', 'f']
+                    .map(createMockDomainObject);
+                mockScope.values = { a: "a value to find" };
+                mockScope.classes = { a: 'class-a' };
+
+                // Fire an update to the set of values
+                fireWatch("objects");
+                fireWatch("updated");
+
+                // Figure out which span holds the relevant value...
+                mockSpans = mockElements.filter(function (mockElem) {
+                    return mockElem.testHtml === '<span>';
+                }).filter(function (mockSpan) {
+                    var attrCalls = mockSpan.attr.calls;
+                    return attrCalls.some(function (call) {
+                        return call.args[0] === 'title' &&
+                                call.args[1] === mockScope.values.a;
+                    });
+                });
+
+                // ...and make sure it also has had its class applied
+                expect(mockSpans[0].addClass)
+                    .toHaveBeenCalledWith(mockScope.classes.a);
+            });
+        });
+    }
+);

platform/features/autoflow/test/AutoflowTabularControllerSpec.js

@@ -0,0 +1,341 @@
+
+define(
+    ["../src/AutoflowTabularController"],
+    function (AutoflowTabularController) {
+
+        describe("The autoflow tabular controller", function () {
+            var mockScope,
+                mockTimeout,
+                mockSubscriber,
+                mockDomainObject,
+                mockSubscription,
+                controller;
+
+            // Fire watches that are registered as functions.
+            function fireFnWatches() {
+                mockScope.$watch.calls.forEach(function (call) {
+                    if (typeof call.args[0] === 'function') {
+                        call.args[1](call.args[0]());
+                    }
+                });
+            }
+
+            beforeEach(function () {
+                mockScope = jasmine.createSpyObj(
+                    "$scope",
+                    ["$on", "$watch"]
+                );
+                mockTimeout = jasmine.createSpy("$timeout");
+                mockSubscriber = jasmine.createSpyObj(
+                    "telemetrySubscriber",
+                    ["subscribe"]
+                );
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "getCapability"]
+                );
+                mockSubscription = jasmine.createSpyObj(
+                    "subscription",
+                    [
+                        "unsubscribe",
+                        "getTelemetryObjects",
+                        "getDomainValue",
+                        "getRangeValue"
+                    ]
+                );
+
+                mockSubscriber.subscribe.andReturn(mockSubscription);
+                mockDomainObject.getModel.andReturn({name: "something"});
+
+                controller = new AutoflowTabularController(
+                    mockScope,
+                    mockTimeout,
+                    mockSubscriber
+                );
+            });
+
+            it("listens for the represented domain object", function () {
+                expect(mockScope.$watch).toHaveBeenCalledWith(
+                    "domainObject",
+                    jasmine.any(Function)
+                );
+            });
+
+            it("provides a getter-setter function for filtering", function () {
+                expect(controller.filter()).toEqual("");
+                controller.filter("something");
+                expect(controller.filter()).toEqual("something");
+            });
+
+            it("tracks bounds and adjust number of rows accordingly", function () {
+                // Rows are 15px high, and need room for an 10px slider
+                controller.setBounds({ width: 700, height: 120 });
+                expect(controller.getRows()).toEqual(6); // 110 usable height / 16px
+                controller.setBounds({ width: 700, height: 240 });
+                expect(controller.getRows()).toEqual(14); // 230 usable height / 16px
+            });
+
+            it("subscribes to a represented object's telemetry", function () {
+                // Set up subscription, scope
+                mockSubscription.getTelemetryObjects
+                    .andReturn([mockDomainObject]);
+                mockScope.domainObject = mockDomainObject;
+
+                // Invoke the watcher with represented domain object
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
+                // Should have subscribed to it
+                expect(mockSubscriber.subscribe).toHaveBeenCalledWith(
+                    mockDomainObject,
+                    jasmine.any(Function)
+                );
+
+                // Should report objects as reported from subscription
+                expect(controller.getTelemetryObjects())
+                    .toEqual([mockDomainObject]);
+            });
+
+            it("releases subscriptions on destroy", function () {
+                // Set up subscription...
+                mockSubscription.getTelemetryObjects
+                    .andReturn([mockDomainObject]);
+                mockScope.domainObject = mockDomainObject;
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
+                // Verify precondition
+                expect(mockSubscription.unsubscribe).not.toHaveBeenCalled();
+
+                // Make sure we're listening for $destroy
+                expect(mockScope.$on).toHaveBeenCalledWith(
+                    "$destroy",
+                    jasmine.any(Function)
+                );
+
+                // Fire a destroy event
+                mockScope.$on.mostRecentCall.args[1]();
+
+                // Should have unsubscribed
+                expect(mockSubscription.unsubscribe).toHaveBeenCalled();
+            });
+
+            it("presents latest values and latest update state", function () {
+                // Make sure values are available
+                mockSubscription.getDomainValue.andReturn(402654321123);
+                mockSubscription.getRangeValue.andReturn(789);
+                mockDomainObject.getId.andReturn('testId');
+
+                // Set up subscription...
+                mockSubscription.getTelemetryObjects
+                    .andReturn([mockDomainObject]);
+                mockScope.domainObject = mockDomainObject;
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
+                // Fire subscription callback
+                mockSubscriber.subscribe.mostRecentCall.args[1]();
+
+                // ...and exposed the results for template to consume
+                expect(controller.updated()).toEqual("1982-278 08:25:21.123Z");
+                expect(controller.rangeValues().testId).toEqual(789);
+            });
+
+            it("sorts domain objects by index", function () {
+                var testIndexes = { a: 2, b: 1, c: 3, d: 0 },
+                    mockDomainObjects = Object.keys(testIndexes).sort().map(function (id) {
+                        var mockDomainObj = jasmine.createSpyObj(
+                            "domainObject",
+                            ["getId", "getModel"]
+                        );
+
+                        mockDomainObj.getId.andReturn(id);
+                        mockDomainObj.getModel.andReturn({ index: testIndexes[id] });
+
+                        return mockDomainObj;
+                    });
+
+                // Expose those domain objects...
+                mockSubscription.getTelemetryObjects.andReturn(mockDomainObjects);
+                mockScope.domainObject = mockDomainObject;
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
+                // Fire subscription callback
+                mockSubscriber.subscribe.mostRecentCall.args[1]();
+
+                // Controller should expose same objects, but sorted by index from model
+                expect(controller.getTelemetryObjects()).toEqual([
+                    mockDomainObjects[3], // d, index=0
+                    mockDomainObjects[1], // b, index=1
+                    mockDomainObjects[0], // a, index=2
+                    mockDomainObjects[2]  // c, index=3
+                ]);
+            });
+
+            it("uses a timeout to throttle update", function () {
+                // Set up subscription...
+                mockSubscription.getTelemetryObjects
+                    .andReturn([mockDomainObject]);
+                mockScope.domainObject = mockDomainObject;
+
+                // Set the object in view; should not need a timeout
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                expect(mockTimeout.calls.length).toEqual(0);
+
+                // Next call should schedule an update on a timeout
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                expect(mockTimeout.calls.length).toEqual(1);
+
+                // ...but this last one should not, since existing
+                // timeout will cover it
+                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                expect(mockTimeout.calls.length).toEqual(1);
+            });
+
+            it("allows changing column width", function () {
+                var initialWidth = controller.columnWidth();
+                controller.increaseColumnWidth();
+                expect(controller.columnWidth()).toBeGreaterThan(initialWidth);
+            });
+
+            describe("filter", function () {
+                var doFilter,
+                    filteredObjects,
+                    filteredObjectNames;
+
+                beforeEach(function () {
+                    var telemetryObjects,
+                        updateFilteredObjects;
+
+                    telemetryObjects = [
+                        'DEF123',
+                        'abc789',
+                        '456abc',
+                        '4ab3cdef',
+                        'hjs[12].*(){}^\\'
+                    ].map(function (objectName, index) {
+                        var mockTelemetryObject = jasmine.createSpyObj(
+                            objectName,
+                            ["getId", "getModel"]
+                        );
+
+                        mockTelemetryObject.getId.andReturn(objectName);
+                        mockTelemetryObject.getModel.andReturn({
+                            name: objectName,
+                            index: index
+                        });
+
+                        return mockTelemetryObject;
+                    });
+
+                    mockSubscription
+                        .getTelemetryObjects
+                        .andReturn(telemetryObjects);
+
+                    // Trigger domainObject change to create subscription.
+                    mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+
+                    updateFilteredObjects = function () {
+                        filteredObjects = controller.getTelemetryObjects();
+                        filteredObjectNames = filteredObjects.map(function (o) {
+                            return o.getModel().name;
+                        });
+                    };
+
+                    doFilter = function (term) {
+                        controller.filter(term);
+                        // Filter is debounced so we have to force it to occur.
+                        mockTimeout.mostRecentCall.args[0]();
+                        updateFilteredObjects();
+                    };
+
+                    updateFilteredObjects();
+                });
+
+                it("initially shows all objects", function () {
+                    expect(filteredObjectNames).toEqual([
+                        'DEF123',
+                        'abc789',
+                        '456abc',
+                        '4ab3cdef',
+                        'hjs[12].*(){}^\\'
+                    ]);
+                });
+
+                it("by blank string matches all objects", function () {
+                    doFilter('');
+                    expect(filteredObjectNames).toEqual([
+                        'DEF123',
+                        'abc789',
+                        '456abc',
+                        '4ab3cdef',
+                        'hjs[12].*(){}^\\'
+                    ]);
+                });
+
+                it("exactly matches an object name", function () {
+                    doFilter('4ab3cdef');
+                    expect(filteredObjectNames).toEqual(['4ab3cdef']);
+                });
+
+                it("partially matches object names", function () {
+                    doFilter('abc');
+                    expect(filteredObjectNames).toEqual([
+                        'abc789',
+                        '456abc'
+                    ]);
+                });
+
+                it("matches case insensitive names", function () {
+                    doFilter('def');
+                    expect(filteredObjectNames).toEqual([
+                        'DEF123',
+                        '4ab3cdef'
+                    ]);
+                });
+
+                it("works as expected with special characters", function () {
+                    doFilter('[12]');
+                    expect(filteredObjectNames).toEqual(['hjs[12].*(){}^\\']);
+                    doFilter('.*');
+                    expect(filteredObjectNames).toEqual(['hjs[12].*(){}^\\']);
+                    doFilter('.*()');
+                    expect(filteredObjectNames).toEqual(['hjs[12].*(){}^\\']);
+                    doFilter('.*?');
+                    expect(filteredObjectNames).toEqual([]);
+                    doFilter('.+');
+                    expect(filteredObjectNames).toEqual([]);
+                });
+
+                it("exposes CSS classes from limits", function () {
+                    var id = mockDomainObject.getId(),
+                        testClass = "some-css-class",
+                        mockLimitCapability =
+                            jasmine.createSpyObj('limit', ['evaluate']);
+
+                    mockDomainObject.getCapability.andCallFake(function (key) {
+                        return key === 'limit' && mockLimitCapability;
+                    });
+                    mockLimitCapability.evaluate
+                        .andReturn({ cssClass: testClass });
+
+                    mockSubscription.getTelemetryObjects
+                        .andReturn([mockDomainObject]);
+
+                    fireFnWatches();
+                    mockSubscriber.subscribe.mostRecentCall.args[1]();
+
+                    expect(controller.classes()[id]).toEqual(testClass);
+                });
+
+                it("exposes a counter that changes with each update", function () {
+                    var i, prior;
+
+                    for (i = 0; i < 10; i += 1) {
+                        prior = controller.counter();
+                        expect(controller.counter()).toEqual(prior);
+                        mockSubscriber.subscribe.mostRecentCall.args[1]();
+                        expect(controller.counter()).not.toEqual(prior);
+                    }
+                });
+            });
+        });
+    }
+);

platform/features/autoflow/test/MCTAutoflowTableSpec.js

@@ -0,0 +1,39 @@
+
+define(
+    ["../src/MCTAutoflowTable"],
+    function (MCTAutoflowTable) {
+
+        describe("The mct-autoflow-table directive", function () {
+            var mctAutoflowTable;
+
+            beforeEach(function () {
+                mctAutoflowTable = new MCTAutoflowTable();
+            });
+
+            // Real functionality is contained/tested in the linker,
+            // so just check to make sure we're exposing the directive
+            // appropriately.
+            it("is applicable at the element level", function () {
+                expect(mctAutoflowTable.restrict).toEqual("E");
+            });
+
+            it("two-ways binds needed scope variables", function () {
+                expect(mctAutoflowTable.scope).toEqual({
+                    objects: "=",
+                    values: "=",
+                    rows: "=",
+                    updated: "=",
+                    classes: "=",
+                    columnWidth: "=",
+                    counter: "="
+                });
+            });
+
+            it("provides a link function", function () {
+                expect(mctAutoflowTable.link).toEqual(jasmine.any(Function));
+            });
+
+
+        });
+    }
+);

platform/features/clock/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -140,7 +140,7 @@ define([
                     ],
                     "category": "contextual",
                     "name": "Start",
-                    "cssclass": "icon-play",
+                    "cssClass": "icon-play",
                     "priority": "preferred"
                 },
                 {
@@ -162,7 +162,7 @@ define([
                     ],
                     "category": "contextual",
                     "name": "Restart at 0",
-                    "cssclass": "icon-refresh",
+                    "cssClass": "icon-refresh",
                     "priority": "preferred"
                 },
                 {
@@ -181,7 +181,7 @@ define([
                 {
                     "key": "clock",
                     "name": "Clock",
-                    "cssclass": "icon-clock",
+                    "cssClass": "icon-clock",
                     "description": "A UTC-based clock that supports a variety of display formats. Clocks can be added to Display Layouts.",
                     "priority": 101,
                     "features": [
@@ -209,7 +209,7 @@ define([
                                             "name": "hh:mm:ss"
                                         }
                                     ],
-                                    "cssclass": "l-inline"
+                                    "cssClass": "l-inline"
                                 },
                                 {
                                     "control": "select",
@@ -223,7 +223,7 @@ define([
                                             "name": "24hr"
                                         }
                                     ],
-                                    "cssclass": "l-inline"
+                                    "cssClass": "l-inline"
                                 }
                             ]
                         }
@@ -238,7 +238,7 @@ define([
                 {
                     "key": "timer",
                     "name": "Timer",
-                    "cssclass": "icon-timer",
+                    "cssClass": "icon-timer",
                     "description": "A timer that counts up or down to a datetime. Timers can be started, stopped and reset whenever needed, and support a variety of display formats. Each Timer displays the same value to all users. Timers can be added to Display Layouts.",
                     "priority": 100,
                     "features": [

platform/features/clock/res/templates/clock.html

@@ -31,4 +31,4 @@
 	        {{clock.ampm()}}
 	    </span>
 	</div>
-</div>
+</div>

platform/features/clock/res/templates/timer.html

@@ -36,4 +36,4 @@
 	    </span>
 	    <span ng-controller="RefreshingController"></span>
 	</div>
-</div>
+</div>

platform/features/clock/test/controllers/TimerControllerSpec.js

@@ -91,6 +91,7 @@ define(
                         'timer.stop': mockStop
                     }[k]];
                 });
+
                 mockStart.getMetadata.andReturn({cssclass: "icon-play", name: "Start"});
                 mockPause.getMetadata.andReturn({cssclass: "icon-pause", name: "Pause"});
                 mockStop.getMetadata.andReturn({cssclass: "icon-box", name: "Stop"});

platform/features/conductor/compatibility/bundle.js

@@ -21,11 +21,9 @@
  *****************************************************************************/
 
 define([
-    "./src/ConductorTelemetryDecorator",
     "./src/ConductorRepresenter",
     'legacyRegistry'
 ], function (
-    ConductorTelemetryDecorator,
     ConductorRepresenter,
     legacyRegistry
 ) {
@@ -39,16 +37,6 @@ define([
                         "openmct"
                     ]
                 }
-            ],
-            "components": [
-                {
-                    "type": "decorator",
-                    "provides": "telemetryService",
-                    "implementation": ConductorTelemetryDecorator,
-                    "depends": [
-                        "openmct"
-                    ]
-                }
             ]
         }
     });

platform/features/conductor/compatibility/src/ConductorTelemetryDecorator.js

@@ -1,87 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    function () {
-
-        /**
-         * Decorates the `telemetryService` such that requests are
-         * mediated by the time conductor. This is a modified version of the
-         * decorator used in the old TimeConductor that integrates with the
-         * new TimeConductor API.
-         *
-         * @constructor
-         * @memberof platform/features/conductor
-         * @implements {TelemetryService}
-         * @param {platform/features/conductor.TimeConductor} conductor
-         *        the service which exposes the global time conductor
-         * @param {TelemetryService} telemetryService the decorated service
-         */
-        function ConductorTelemetryDecorator(openmct, telemetryService) {
-            this.conductor = openmct.conductor;
-            this.telemetryService = telemetryService;
-
-            this.amendRequests = ConductorTelemetryDecorator.prototype.amendRequests.bind(this);
-        }
-
-        function amendRequest(request, bounds, timeSystem) {
-            request = request || {};
-            request.start = bounds.start;
-            request.end = bounds.end;
-            request.domain = timeSystem.metadata.key;
-
-            return request;
-        }
-
-        ConductorTelemetryDecorator.prototype.amendRequests = function (requests) {
-            var bounds = this.conductor.bounds(),
-                timeSystem = this.conductor.timeSystem();
-
-            return (requests || []).map(function (request) {
-                return amendRequest(request, bounds, timeSystem);
-            });
-        };
-
-        ConductorTelemetryDecorator.prototype.requestTelemetry = function (requests) {
-            return this.telemetryService
-                .requestTelemetry(this.amendRequests(requests));
-        };
-
-        ConductorTelemetryDecorator.prototype.subscribe = function (callback, requests) {
-            var unsubscribeFunc = this.telemetryService.subscribe(callback, this.amendRequests(requests)),
-                conductor = this.conductor,
-                self = this;
-
-            function amendRequests() {
-                return self.amendRequests(requests);
-            }
-
-            conductor.on('bounds', amendRequests);
-            return function () {
-                unsubscribeFunc();
-                conductor.off('bounds', amendRequests);
-            };
-        };
-
-        return ConductorTelemetryDecorator;
-    }
-);

platform/features/conductor/core/bundle.js

@@ -70,8 +70,9 @@ define([
                         "$location",
                         "openmct",
                         "timeConductorViewService",
-                        "timeSystems[]",
-                        "formatService"
+                        "formatService",
+                        "DEFAULT_TIMECONDUCTOR_MODE",
+                        "SHOW_TIMECONDUCTOR"
                     ]
                 },
                 {
@@ -150,6 +151,13 @@ define([
                     "link": "https://github.com/d3/d3/blob/master/LICENSE"
                 }
             ],
+            "constants": [
+                {
+                    "key": "DEFAULT_TIMECONDUCTOR_MODE",
+                    "value": "realtime",
+                    "priority": "fallback"
+                }
+            ],
             "formats": [
                 {
                     "key": "number",

platform/features/conductor/core/res/sass/_constants.scss

@@ -8,4 +8,4 @@ $ticksBlockerFadeW: 50px;
 $toiBlockerFadeW: 10px;
 $toiH: 12px;  // Needs to be an even number to avoid sub-pixel antialiasing of the vertical line
 $toiPad: 4px;
-$timeCondAxisLROffset: (($toiH / 2) + $toiPad, ($toiH / 2) + $toiPad); // Margin to left, right of tick axis and vis bar. For paging, use 15, 20px
+$timeCondAxisLROffset: (($toiH / 2) + $toiPad, ($toiH / 2) + $toiPad); // Margin to left, right of tick axis and vis bar. For paging, use 15, 20px

platform/features/conductor/core/res/sass/_time-conductor-base.scss

@@ -346,7 +346,28 @@
             content: $i;
         }
         .l-axis-holder {
+            $c0: rgba($colorBodyFg, 0.1);
+            $c2: transparent;
+            $grabTicksH: 3px;
+            $grabTicksXSpace: 4px;
+            $grabTicksYOffset: 0;
             @include cursorGrab();
+            svg {
+                $c1: rgba($colorBodyFg, 0.2);
+                $angle: 90deg;
+                @include background-image(linear-gradient($angle,
+                    $c1 1px, $c2 1px,
+                    $c2 100%
+                ));
+                background-position: center $grabTicksYOffset;
+                background-repeat: repeat-x;
+                background-size: $grabTicksXSpace $grabTicksH;
+            }
+            &:hover {
+                @include background-image(linear-gradient(
+                    $c0 70%, $c2 100%
+                ));
+            }
         }
     }
 

platform/features/conductor/core/res/sass/_time-of-interest.scss

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/conductor/core/res/sass/time-conductor-espresso.scss

@@ -19,6 +19,7 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
 @import "bourbon";
 @import "../../../../../commonUI/general/res/sass/constants";
 @import "../../../../../commonUI/general/res/sass/mixins";
@@ -47,4 +48,4 @@ $colorTimeCondTOIBg: darken($toiColorBg, 20%);
 $colorTimeCondTOIBgHov: $toiColorBg;
 
 @import "time-conductor-base";
-@import "time-of-interest";
+@import "time-of-interest";

platform/features/conductor/core/res/sass/time-conductor-snow.scss

@@ -19,6 +19,7 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
 @import "bourbon";
 @import "../../../../../commonUI/general/res/sass/constants";
 @import "../../../../../commonUI/general/res/sass/mixins";
@@ -47,4 +48,4 @@ $colorTimeCondTOIBg: darken($toiColorBg, 20%);
 $colorTimeCondTOIBgHov: $toiColorBg;
 
 @import "time-conductor-base";
-@import "time-of-interest";
+@import "time-of-interest";

platform/features/conductor/core/res/templates/mode-selector/mode-menu.html

@@ -26,7 +26,7 @@
                 ng-click="ngModel.selectedKey=key">
                 <a ng-mouseover="ngModel.activeMetadata = metadata"
                    ng-mouseleave="ngModel.activeMetadata = undefined"
-                   class="menu-item-a {{metadata.cssclass}}">
+                   class="menu-item-a {{metadata.cssClass}}">
                     {{metadata.name}}
                 </a>
             </li>
@@ -34,7 +34,7 @@
     </div>
     <div class="pane right menu-item-description">
         <div
-                class="desc-area ui-symbol icon type-icon {{ngModel.activeMetadata.cssclass}}"></div>
+                class="desc-area ui-symbol icon type-icon {{ngModel.activeMetadata.cssClass}}"></div>
         <div class="desc-area title">
             {{ngModel.activeMetadata.name}}
         </div>

platform/features/conductor/core/res/templates/mode-selector/mode-selector.html

@@ -31,4 +31,4 @@
                      ng-model="ngModel">
         </mct-include>
     </div>
-</span>
+</span>

platform/features/conductor/core/res/templates/time-conductor.html

@@ -1,8 +1,7 @@
 <!-- Parent holder for time conductor. follow-mode | fixed-mode -->
 <div ng-controller="TimeConductorController as tcController"
     class="holder grows flex-elem l-flex-row l-time-conductor {{modeModel.selectedKey}}-mode {{timeSystemModel.selected.metadata.key}}-time-system"
-        ng-class="{'status-panning': tcController.panning}">
-
+        ng-class="{'status-panning': tcController.panning}" ng-show="showTimeConductor">
     <div class="flex-elem holder time-conductor-icon">
         <div class="hand-little"></div>
         <div class="hand-big"></div>

platform/features/conductor/core/res/templates/time-of-interest.html

@@ -9,4 +9,4 @@
         </span>
         <span class="flex-elem l-toi-val">{{toi.toiText}}</span>
     </div>
-</div>
+</div>

platform/features/conductor/core/src/timeSystems/LocalClock.js

@@ -31,7 +31,7 @@ define(['./TickSource'], function (TickSource) {
         this.metadata = {
             key: 'local',
             mode: 'realtime',
-            cssclass: 'icon-clock',
+            cssClass: 'icon-clock',
             label: 'Real-time',
             name: 'Real-time Mode',
             description: 'Monitor real-time streaming data as it comes in. The Time Conductor and displays will automatically advance themselves based on a UTC clock.'

platform/features/conductor/core/src/ui/ConductorAxisController.js

@@ -22,9 +22,11 @@
 
 define(
     [
-        "d3"
+        "d3-selection",
+        "d3-scale",
+        "d3-axis"
     ],
-    function (d3) {
+    function (d3Selection, d3Scale, d3Axis) {
         var PADDING = 1;
 
         /**
@@ -70,12 +72,12 @@ define(
         ConductorAxisController.prototype.initialize = function (element) {
             this.target = element[0].firstChild;
             var height = this.target.offsetHeight;
-            var vis = d3.select(this.target)
+            var vis = d3Selection.select(this.target)
                 .append("svg:svg")
                 .attr("width", "100%")
                 .attr("height", height);
 
-            this.xAxis = d3.axisTop();
+            this.xAxis = d3Axis.axisTop();
 
             // draw x axis with labels and move to the bottom of the chart area
             this.axisElement = vis.append("g")
@@ -115,10 +117,10 @@ define(
             var bounds = this.bounds;
 
             if (timeSystem.isUTCBased()) {
-                this.xScale = this.xScale || d3.scaleUtc();
+                this.xScale = this.xScale || d3Scale.scaleUtc();
                 this.xScale.domain([new Date(bounds.start), new Date(bounds.end)]);
             } else {
-                this.xScale = this.xScale || d3.scaleLinear();
+                this.xScale = this.xScale || d3Scale.scaleLinear();
                 this.xScale.domain([bounds.start, bounds.end]);
             }
 
@@ -145,9 +147,9 @@ define(
                 //The D3 scale used depends on the type of time system as d3
                 // supports UTC out of the box.
                 if (timeSystem.isUTCBased()) {
-                    this.xScale = d3.scaleUtc();
+                    this.xScale = d3Scale.scaleUtc();
                 } else {
-                    this.xScale = d3.scaleLinear();
+                    this.xScale = d3Scale.scaleLinear();
                 }
 
                 this.xAxis.scale(this.xScale);

platform/features/conductor/core/src/ui/ConductorAxisControllerSpec.js

@@ -23,11 +23,13 @@
 define([
     './ConductorAxisController',
     'zepto',
-    'd3'
+    'd3-selection',
+    'd3-scale'
 ], function (
     ConductorAxisController,
     $,
-    d3
+    d3Selection,
+    d3Scale
 ) {
     describe("The ConductorAxisController", function () {
         var controller,
@@ -84,8 +86,8 @@ define([
                 "emit"
             ]);
 
-            spyOn(d3, 'scaleUtc').andCallThrough();
-            spyOn(d3, 'scaleLinear').andCallThrough();
+            spyOn(d3Scale, 'scaleUtc').andCallThrough();
+            spyOn(d3Scale, 'scaleLinear').andCallThrough();
 
             element = $('<div style="width: 100px;"><div style="width: 100%;"></div></div>');
             $(document).find('body').append(element);
@@ -122,15 +124,15 @@ define([
                 mockTimeSystem.isUTCBased.andReturn(true);
                 controller.changeTimeSystem(mockTimeSystem);
 
-                expect(d3.scaleUtc).toHaveBeenCalled();
-                expect(d3.scaleLinear).not.toHaveBeenCalled();
+                expect(d3Scale.scaleUtc).toHaveBeenCalled();
+                expect(d3Scale.scaleLinear).not.toHaveBeenCalled();
             });
 
             it("uses a linear scale for non-UTC time systems", function () {
                 mockTimeSystem.isUTCBased.andReturn(false);
                 controller.changeTimeSystem(mockTimeSystem);
-                expect(d3.scaleLinear).toHaveBeenCalled();
-                expect(d3.scaleUtc).not.toHaveBeenCalled();
+                expect(d3Scale.scaleLinear).toHaveBeenCalled();
+                expect(d3Scale.scaleUtc).not.toHaveBeenCalled();
             });
 
             it("sets axis domain to time conductor bounds", function () {

platform/features/conductor/core/src/ui/NumberFormat.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/conductor/core/src/ui/TimeConductorController.js

@@ -40,7 +40,16 @@ define(
          * @memberof platform.features.conductor
          * @constructor
          */
-        function TimeConductorController($scope, $window, $location, openmct, conductorViewService, timeSystems, formatService) {
+        function TimeConductorController(
+            $scope,
+            $window,
+            $location,
+            openmct,
+            conductorViewService,
+            formatService,
+            DEFAULT_MODE,
+            SHOW_TIMECONDUCTOR
+        ) {
 
             var self = this;
 
@@ -60,10 +69,14 @@ define(
             this.validation = new TimeConductorValidation(this.conductor);
             this.formatService = formatService;
 
+            //Check if the default mode defined is actually available
+            if (this.modes[DEFAULT_MODE] === undefined) {
+                DEFAULT_MODE = 'fixed';
+            }
+            this.DEFAULT_MODE = DEFAULT_MODE;
+
             // Construct the provided time system definitions
-            this.timeSystems = timeSystems.map(function (timeSystemConstructor) {
-                return timeSystemConstructor();
-            });
+            this.timeSystems = conductorViewService.systems;
 
             this.initializeScope();
             var searchParams = JSON.parse(JSON.stringify(this.$location.search()));
@@ -94,6 +107,8 @@ define(
             //Respond to any subsequent conductor changes
             this.conductor.on('bounds', this.changeBounds);
             this.conductor.on('timeSystem', this.changeTimeSystem);
+
+            this.$scope.showTimeConductor = SHOW_TIMECONDUCTOR;
         }
 
         /**
@@ -139,7 +154,7 @@ define(
             //Set mode from url if changed
             if (searchParams[SEARCH.MODE] === undefined ||
                 searchParams[SEARCH.MODE] !== this.$scope.modeModel.selectedKey) {
-                this.setMode(searchParams[SEARCH.MODE] || "fixed");
+                this.setMode(searchParams[SEARCH.MODE] || this.DEFAULT_MODE);
             }
 
             if (searchParams[SEARCH.TIME_SYSTEM] &&

platform/features/conductor/core/src/ui/TimeConductorControllerSpec.js

@@ -130,8 +130,10 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystems,
-                    mockFormatService
+                    mockFormatService,
+                    'fixed',
+                    true
+
                 );
 
                 tsListener = getListener(mockTimeConductor.on, "timeSystem");
@@ -244,7 +246,6 @@ define(['./TimeConductorController'], function (TimeConductorController) {
             var ts1Metadata;
             var ts2Metadata;
             var ts3Metadata;
-            var mockTimeSystemConstructors;
 
             beforeEach(function () {
                 mode = "realtime";
@@ -276,11 +277,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                 ];
 
                 //Wrap in mock constructors
-                mockTimeSystemConstructors = mockTimeSystems.map(function (mockTimeSystem) {
-                    return function () {
-                        return mockTimeSystem;
-                    };
-                });
+                mockConductorViewService.systems = mockTimeSystems;
 
                 controller = new TimeConductorController(
                     mockScope,
@@ -288,8 +285,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystemConstructors,
-                    mockFormatService
+                    mockFormatService,
+                    "fixed",
+                    true
                 );
             });
 
@@ -434,12 +432,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     }
                 };
 
-                mockTimeSystems.push(function () {
-                    return timeSystem;
-                });
-                mockTimeSystems.push(function () {
-                    return otherTimeSystem;
-                });
+                mockConductorViewService.systems = [timeSystem, otherTimeSystem];
 
                 urlBounds = {
                     start: 100,
@@ -467,8 +460,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystems,
-                    mockFormatService
+                    mockFormatService,
+                    "fixed",
+                    true
                 );
 
                 spyOn(controller, "setMode");

platform/features/conductor/core/src/ui/TimeConductorViewService.js

@@ -60,7 +60,7 @@ define(
             this.availModes = {
                 'fixed': {
                     key: 'fixed',
-                    cssclass: 'icon-calendar',
+                    cssClass: 'icon-calendar',
                     label: 'Fixed',
                     name: 'Fixed Timespan Mode',
                     description: 'Query and explore data that falls between two fixed datetimes.'
@@ -81,7 +81,7 @@ define(
             if (timeSystemsForMode('realtime').length > 0) {
                 var realtimeMode = {
                     key: 'realtime',
-                    cssclass: 'icon-clock',
+                    cssClass: 'icon-clock',
                     label: 'Real-time',
                     name: 'Real-time Mode',
                     description: 'Monitor real-time streaming data as it comes in. The Time Conductor and displays will automatically advance themselves based on a UTC clock.'
@@ -93,7 +93,7 @@ define(
             if (timeSystemsForMode('lad').length > 0) {
                 var ladMode = {
                     key: 'lad',
-                    cssclass: 'icon-database',
+                    cssClass: 'icon-database',
                     label: 'LAD',
                     name: 'LAD Mode',
                     description: 'Latest Available Data mode monitors real-time streaming data as it comes in. The Time Conductor and displays will only advance when data becomes available.'

platform/features/conductor/utcTimeSystem/bundle.js

@@ -22,7 +22,7 @@
 
 define([
     "./src/UTCTimeSystem",
-    'legacyRegistry'
+    "legacyRegistry"
 ], function (
     UTCTimeSystem,
     legacyRegistry

platform/features/conductor/utcTimeSystem/src/UTCTimeSystem.js

@@ -25,7 +25,7 @@ define([
     '../../core/src/timeSystems/LocalClock'
 ], function (TimeSystem, LocalClock) {
     var FIFTEEN_MINUTES = 15 * 60 * 1000,
-        DEFAULT_PERIOD = 1000;
+        DEFAULT_PERIOD = 100;
 
     /**
      * This time system supports UTC dates and provides a ticking clock source.
@@ -38,12 +38,12 @@ define([
         /**
          * Some metadata, which will be used to identify the time system in
          * the UI
-         * @type {{key: string, name: string, cssclass: string}}
+         * @type {{key: string, name: string, cssClass: string}}
          */
         this.metadata = {
             'key': 'utc',
             'name': 'UTC',
-            'cssclass': 'icon-clock'
+            'cssClass': 'icon-clock'
         };
 
         this.fmts = ['utc'];

platform/features/fixed/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -36,7 +36,7 @@ define([
                 {
                     "key": "fixed-display",
                     "name": "Fixed Position Display",
-                    "cssclass": "icon-box-with-dashed-lines",
+                    "cssClass": "icon-box-with-dashed-lines",
                     "type": "telemetry.fixed",
                     "template": fixedTemplate,
                     "uses": [
@@ -49,28 +49,28 @@ define([
                                 "items": [
                                     {
                                         "method": "add",
-                                        "cssclass": "icon-plus",
+                                        "cssClass": "icon-plus",
                                         "control": "menu-button",
                                         "text": "Add",
                                         "options": [
                                             {
                                                 "name": "Box",
-                                                "cssclass": "icon-box",
+                                                "cssClass": "icon-box",
                                                 "key": "fixed.box"
                                             },
                                             {
                                                 "name": "Line",
-                                                "cssclass": "icon-line-horz",
+                                                "cssClass": "icon-line-horz",
                                                 "key": "fixed.line"
                                             },
                                             {
                                                 "name": "Text",
-                                                "cssclass": "icon-T",
+                                                "cssClass": "icon-T",
                                                 "key": "fixed.text"
                                             },
                                             {
                                                 "name": "Image",
-                                                "cssclass": "icon-image",
+                                                "cssClass": "icon-image",
                                                 "key": "fixed.image"
                                             }
                                         ]
@@ -81,50 +81,50 @@ define([
                                 "items": [
                                     {
                                         "method": "order",
-                                        "cssclass": "icon-layers",
+                                        "cssClass": "icon-layers",
                                         "control": "menu-button",
                                         "title": "Layering",
                                         "description": "Move the selected object above or below other objects",
                                         "options": [
                                             {
                                                 "name": "Move to Top",
-                                                "cssclass": "icon-arrow-double-up",
+                                                "cssClass": "icon-arrow-double-up",
                                                 "key": "top"
                                             },
                                             {
                                                 "name": "Move Up",
-                                                "cssclass": "icon-arrow-up",
+                                                "cssClass": "icon-arrow-up",
                                                 "key": "up"
                                             },
                                             {
                                                 "name": "Move Down",
-                                                "cssclass": "icon-arrow-down",
+                                                "cssClass": "icon-arrow-down",
                                                 "key": "down"
                                             },
                                             {
                                                 "name": "Move to Bottom",
-                                                "cssclass": "icon-arrow-double-down",
+                                                "cssClass": "icon-arrow-double-down",
                                                 "key": "bottom"
                                             }
                                         ]
                                     },
                                     {
                                         "property": "fill",
-                                        "cssclass": "icon-paint-bucket",
+                                        "cssClass": "icon-paint-bucket",
                                         "title": "Fill color",
                                         "description": "Set fill color",
                                         "control": "color"
                                     },
                                     {
                                         "property": "stroke",
-                                        "cssclass": "icon-line-horz",
+                                        "cssClass": "icon-line-horz",
                                         "title": "Border color",
                                         "description": "Set border color",
                                         "control": "color"
                                     },
                                     {
                                         "property": "color",
-                                        "cssclass": "icon-T",
+                                        "cssClass": "icon-T",
                                         "title": "Text color",
                                         "description": "Set text color",
                                         "mandatory": true,
@@ -132,20 +132,20 @@ define([
                                     },
                                     {
                                         "property": "url",
-                                        "cssclass": "icon-image",
+                                        "cssClass": "icon-image",
                                         "control": "dialog-button",
                                         "title": "Image Properties",
                                         "description": "Edit image properties",
                                         "dialog": {
                                             "control": "textfield",
                                             "name": "Image URL",
-                                            "cssclass": "l-input-lg",
+                                            "cssClass": "l-input-lg",
                                             "required": true
                                         }
                                     },
                                     {
                                         "property": "text",
-                                        "cssclass": "icon-gear",
+                                        "cssClass": "icon-gear",
                                         "control": "dialog-button",
                                         "title": "Text Properties",
                                         "description": "Edit text properties",
@@ -157,14 +157,14 @@ define([
                                     },
                                     {
                                         "method": "showTitle",
-                                        "cssclass": "icon-two-parts-both",
+                                        "cssClass": "icon-two-parts-both",
                                         "control": "button",
                                         "title": "Show title",
                                         "description": "Show telemetry element title"
                                     },
                                     {
                                         "method": "hideTitle",
-                                        "cssclass": "icon-two-parts-one-only",
+                                        "cssClass": "icon-two-parts-one-only",
                                         "control": "button",
                                         "title": "Hide title",
                                         "description": "Hide telemetry element title"
@@ -176,7 +176,7 @@ define([
                                     {
                                         "method": "remove",
                                         "control": "button",
-                                        "cssclass": "icon-trash"
+                                        "cssClass": "icon-trash"
                                     }
                                 ]
                             }
@@ -188,7 +188,7 @@ define([
                 {
                     "key": "telemetry.fixed",
                     "name": "Fixed Position Display",
-                    "cssclass": "icon-box-with-dashed-lines",
+                    "cssClass": "icon-box-with-dashed-lines",
                     "description": "Collect and display telemetry elements in " +
                     "alphanumeric format in a simple canvas workspace. " +
                     "Elements can be positioned and sized. " +
@@ -215,12 +215,12 @@ define([
                                 {
                                     "name": "Horizontal grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 },
                                 {
                                     "name": "Vertical grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 }
                             ],
                             "pattern": "^(\\d*[1-9]\\d*)?$",

platform/features/imagery/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -41,7 +41,7 @@ define([
                 {
                     "name": "Imagery",
                     "key": "imagery",
-                    "cssclass": "icon-image",
+                    "cssClass": "icon-image",
                     "template": imageryTemplate,
                     "priority": "preferred",
                     "needs": [

platform/features/imagery/src/controllers/ImageryController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/imagery/src/directives/MCTBackgroundImage.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/imagery/src/policies/ImageryViewPolicy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/imagery/test/controllers/ImageryControllerSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/imagery/test/directives/MCTBackgroundImageSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/imagery/test/policies/ImageryViewPolicySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -56,7 +56,7 @@ define([
                 {
                     "key": "layout",
                     "name": "Display Layout",
-                    "cssclass": "icon-layout",
+                    "cssClass": "icon-layout",
                     "type": "layout",
                     "template": layoutTemplate,
                     "editable": true,
@@ -65,7 +65,7 @@ define([
                 {
                     "key": "fixed",
                     "name": "Fixed Position",
-                    "cssclass": "icon-box-with-dashed-lines",
+                    "cssClass": "icon-box-with-dashed-lines",
                     "type": "telemetry.panel",
                     "template": fixedTemplate,
                     "uses": [
@@ -77,7 +77,7 @@ define([
                                 "items": [
                                     {
                                         "method": "add",
-                                        "cssclass": "icon-plus",
+                                        "cssClass": "icon-plus",
                                         "control": "menu-button",
                                         "text": "Add",
                                         "title": "Add",
@@ -85,22 +85,22 @@ define([
                                         "options": [
                                             {
                                                 "name": "Box",
-                                                "cssclass": "icon-box",
+                                                "cssClass": "icon-box",
                                                 "key": "fixed.box"
                                             },
                                             {
                                                 "name": "Line",
-                                                "cssclass": "icon-line-horz",
+                                                "cssClass": "icon-line-horz",
                                                 "key": "fixed.line"
                                             },
                                             {
                                                 "name": "Text",
-                                                "cssclass": "icon-T",
+                                                "cssClass": "icon-T",
                                                 "key": "fixed.text"
                                             },
                                             {
                                                 "name": "Image",
-                                                "cssclass": "icon-image",
+                                                "cssClass": "icon-image",
                                                 "key": "fixed.image"
                                             }
                                         ]
@@ -111,50 +111,50 @@ define([
                                 "items": [
                                     {
                                         "method": "order",
-                                        "cssclass": "icon-layers",
+                                        "cssClass": "icon-layers",
                                         "control": "menu-button",
                                         "title": "Layering",
                                         "description": "Move the selected object above or below other objects",
                                         "options": [
                                             {
                                                 "name": "Move to Top",
-                                                "cssclass": "icon-arrow-double-up",
+                                                "cssClass": "icon-arrow-double-up",
                                                 "key": "top"
                                             },
                                             {
                                                 "name": "Move Up",
-                                                "cssclass": "icon-arrow-up",
+                                                "cssClass": "icon-arrow-up",
                                                 "key": "up"
                                             },
                                             {
                                                 "name": "Move Down",
-                                                "cssclass": "icon-arrow-down",
+                                                "cssClass": "icon-arrow-down",
                                                 "key": "down"
                                             },
                                             {
                                                 "name": "Move to Bottom",
-                                                "cssclass": "icon-arrow-double-down",
+                                                "cssClass": "icon-arrow-double-down",
                                                 "key": "bottom"
                                             }
                                         ]
                                     },
                                     {
                                         "property": "fill",
-                                        "cssclass": "icon-paint-bucket",
+                                        "cssClass": "icon-paint-bucket",
                                         "title": "Fill color",
                                         "description": "Set fill color",
                                         "control": "color"
                                     },
                                     {
                                         "property": "stroke",
-                                        "cssclass": "icon-line-horz",
+                                        "cssClass": "icon-line-horz",
                                         "title": "Border color",
                                         "description": "Set border color",
                                         "control": "color"
                                     },
                                     {
                                         "property": "color",
-                                        "cssclass": "icon-T",
+                                        "cssClass": "icon-T",
                                         "title": "Text color",
                                         "description": "Set text color",
                                         "mandatory": true,
@@ -162,20 +162,20 @@ define([
                                     },
                                     {
                                         "property": "url",
-                                        "cssclass": "icon-image",
+                                        "cssClass": "icon-image",
                                         "control": "dialog-button",
                                         "title": "Image Properties",
                                         "description": "Edit image properties",
                                         "dialog": {
                                             "control": "textfield",
                                             "name": "Image URL",
-                                            "cssclass": "l-input-lg",
+                                            "cssClass": "l-input-lg",
                                             "required": true
                                         }
                                     },
                                     {
                                         "property": "text",
-                                        "cssclass": "icon-gear",
+                                        "cssClass": "icon-gear",
                                         "control": "dialog-button",
                                         "title": "Text Properties",
                                         "description": "Edit text properties",
@@ -187,14 +187,14 @@ define([
                                     },
                                     {
                                         "method": "showTitle",
-                                        "cssclass": "icon-two-parts-both",
+                                        "cssClass": "icon-two-parts-both",
                                         "control": "button",
                                         "title": "Show title",
                                         "description": "Show telemetry element title"
                                     },
                                     {
                                         "method": "hideTitle",
-                                        "cssclass": "icon-two-parts-one-only",
+                                        "cssClass": "icon-two-parts-one-only",
                                         "control": "button",
                                         "title": "Hide title",
                                         "description": "Hide telemetry element title"
@@ -206,7 +206,7 @@ define([
                                     {
                                         "method": "remove",
                                         "control": "button",
-                                        "cssclass": "icon-trash",
+                                        "cssClass": "icon-trash",
                                         "title": "Delete",
                                         "description": "Delete the selected item"
                                     }
@@ -237,9 +237,7 @@ define([
                         "$scope",
                         "$q",
                         "dialogService",
-                        "telemetryHandler",
-                        "telemetryFormatter",
-                        "throttle"
+                        "openmct"
                     ]
                 }
             ],
@@ -275,7 +273,7 @@ define([
                 {
                     "key": "layout",
                     "name": "Display Layout",
-                    "cssclass": "icon-layout",
+                    "cssClass": "icon-layout",
                     "description": "Assemble other objects and components together into a reusable screen layout. Working in a simple canvas workspace, simply drag in the objects you want, position and size them. Save your design and view or edit it at any time.",
                     "priority": 900,
                     "features": "creation",
@@ -291,12 +289,12 @@ define([
                                 {
                                     "name": "Horizontal grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 },
                                 {
                                     "name": "Vertical grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 }
                             ],
                             "key": "layoutGrid",
@@ -307,7 +305,7 @@ define([
                 {
                     "key": "telemetry.panel",
                     "name": "Telemetry Panel",
-                    "cssclass": "icon-telemetry-panel",
+                    "cssClass": "icon-telemetry-panel",
                     "description": "A panel for collecting telemetry elements.",
                     "priority": 899,
                     "delegates": [
@@ -330,12 +328,12 @@ define([
                                 {
                                     "name": "Horizontal grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 },
                                 {
                                     "name": "Vertical grid (px)",
                                     "control": "textfield",
-                                    "cssclass": "l-input-sm l-numeric"
+                                    "cssClass": "l-input-sm l-numeric"
                                 }
                             ],
                             "pattern": "^(\\d*[1-9]\\d*)?$",

platform/features/layout/res/templates/elements/box.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -23,4 +23,4 @@
 	class="l-fixed-position-box"
 	ng-style="{ background: ngModel.fill(), border: '1px ' + ngModel.stroke() + ' solid' }"
 	>
-</div>
+</div>

platform/features/layout/res/templates/elements/image.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 

platform/features/layout/res/templates/elements/line.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -28,4 +28,4 @@
           ng-attr-stroke="{{ngModel.stroke()}}"
           stroke-width="2">
     </line>
-</svg>
+</svg>

platform/features/layout/res/templates/elements/telemetry.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 

platform/features/layout/res/templates/elements/text.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -24,4 +24,4 @@
 	ng-style="{ background: ngModel.fill(), 'border-color': ngModel.stroke(), color: ngModel.color() }"
 	>
     {{ngModel.element.text}}
-</div>
+</div>

platform/features/layout/res/templates/fixed.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 

platform/features/layout/res/templates/frame.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -40,4 +40,4 @@
                             mct-object="representation.selected.key && domainObject">
         </mct-representation>
     </div>
-</div>
+</div>

platform/features/layout/res/templates/layout.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -62,4 +62,4 @@
 
     </div>
 
-</div>
+</div>

platform/features/layout/src/FixedController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -21,8 +21,20 @@
  *****************************************************************************/
 
 define(
-    ['./FixedProxy', './elements/ElementProxies', './FixedDragHandle'],
-    function (FixedProxy, ElementProxies, FixedDragHandle) {
+    [
+        'lodash',
+        './FixedProxy',
+        './elements/ElementProxies',
+        './FixedDragHandle',
+        '../../../../src/api/objects/object-utils'
+    ],
+    function (
+        _,
+        FixedProxy,
+        ElementProxies,
+        FixedDragHandle,
+        objectUtils
+    ) {
 
         var DEFAULT_DIMENSIONS = [2, 1];
 
@@ -35,13 +47,30 @@ define(
          * @constructor
          * @param {Scope} $scope the controller's Angular scope
          */
-        function FixedController($scope, $q, dialogService, telemetryHandler, telemetryFormatter) {
-            var self = this,
-                handle,
-                names = {}, // Cache names by ID
-                values = {}, // Cache values by ID
-                elementProxiesById = {},
-                maxDomainValue = Number.POSITIVE_INFINITY;
+        function FixedController($scope, $q, dialogService, openmct) {
+            this.names = {}; // Cache names by ID
+            this.values = {}; // Cache values by ID
+            this.elementProxiesById = {};
+
+            this.telemetryObjects = [];
+            this.subscriptions = [];
+            this.openmct = openmct;
+            this.$scope = $scope;
+
+            this.gridSize = $scope.domainObject && $scope.domainObject.getModel().layoutGrid;
+
+            var self = this;
+            [
+                'digest',
+                'fetchHistoricalData',
+                'getTelemetry',
+                'setDisplayedValue',
+                'subscribeToObjects',
+                'unsubscribe',
+                'updateView'
+            ].forEach(function (name) {
+                self[name] = self[name].bind(self);
+            });
 
             // Convert from element x/y/width/height to an
             // appropriate ng-style argument, to position elements.
@@ -79,55 +108,6 @@ define(
                 return element.handles().map(generateDragHandle);
             }
 
-            // Update the value displayed in elements of this telemetry object
-            function setDisplayedValue(telemetryObject, value, alarm) {
-                var id = telemetryObject.getId();
-                (elementProxiesById[id] || []).forEach(function (element) {
-                    names[id] = telemetryObject.getModel().name;
-                    values[id] = telemetryFormatter.formatRangeValue(value);
-                    element.name = names[id];
-                    element.value = values[id];
-                    element.cssClass = alarm && alarm.cssClass;
-                });
-            }
-
-            // Update the displayed value for this object, from a specific
-            // telemetry series
-            function updateValueFromSeries(telemetryObject, telemetrySeries) {
-                var index = telemetrySeries.getPointCount() - 1,
-                    limit = telemetryObject &&
-                        telemetryObject.getCapability('limit'),
-                    datum = telemetryObject && handle.getDatum(
-                        telemetryObject,
-                        index
-                    );
-
-                if (index >= 0) {
-                    setDisplayedValue(
-                        telemetryObject,
-                        telemetrySeries.getRangeValue(index),
-                        limit && datum && limit.evaluate(datum)
-                    );
-                }
-            }
-
-            // Update the displayed value for this object
-            function updateValue(telemetryObject) {
-                var limit = telemetryObject &&
-                        telemetryObject.getCapability('limit'),
-                    datum = telemetryObject &&
-                        handle.getDatum(telemetryObject);
-
-                if (telemetryObject &&
-                        (handle.getDomainValue(telemetryObject) < maxDomainValue)) {
-                    setDisplayedValue(
-                        telemetryObject,
-                        handle.getRangeValue(telemetryObject),
-                        limit && datum && limit.evaluate(datum)
-                    );
-                }
-            }
-
             // Update element positions when grid size changes
             function updateElementPositions(layoutGrid) {
                 // Update grid size from model
@@ -138,13 +118,6 @@ define(
                 });
             }
 
-            // Update telemetry values based on new data available
-            function updateValues() {
-                if (handle) {
-                    handle.getTelemetryObjects().forEach(updateValue);
-                }
-            }
-
             // Decorate an element for display
             function makeProxyElement(element, index, elements) {
                 var ElementProxy = ElementProxies[element.type],
@@ -186,64 +159,57 @@ define(
 
                 // Finally, rebuild lists of elements by id to
                 // facilitate faster update when new telemetry comes in.
-                elementProxiesById = {};
+                self.elementProxiesById = {};
                 self.elementProxies.forEach(function (elementProxy) {
                     var id = elementProxy.id;
                     if (elementProxy.element.type === 'fixed.telemetry') {
                         // Provide it a cached name/value to avoid flashing
-                        elementProxy.name = names[id];
-                        elementProxy.value = values[id];
-                        elementProxiesById[id] = elementProxiesById[id] || [];
-                        elementProxiesById[id].push(elementProxy);
+                        elementProxy.name = self.names[id];
+                        elementProxy.value = self.values[id];
+                        self.elementProxiesById[id] = self.elementProxiesById[id] || [];
+                        self.elementProxiesById[id].push(elementProxy);
                     }
                 });
-
-                // TODO: Ensure elements for all domain objects?
             }
 
-            // Free up subscription to telemetry
-            function releaseSubscription() {
-                if (handle) {
-                    handle.unsubscribe();
-                    handle = undefined;
-                }
-            }
+            function removeObjects(ids) {
+                var configuration = self.$scope.configuration;
 
-            // Subscribe to telemetry updates for this domain object
-            function subscribe(domainObject) {
-                // Release existing subscription (if any)
-                if (handle) {
-                    handle.unsubscribe();
+                if (configuration &&
+                    configuration.elements) {
+                    configuration.elements = configuration.elements.filter(function (proxy) {
+                        return ids.indexOf(proxy.id) === -1;
+                    });
+                }
+                self.getTelemetry($scope.domainObject);
+                refreshElements();
+                // Mark change as persistable
+                if (self.$scope.commit) {
+                    self.$scope.commit("Objects removed.");
                 }
-
-                // Make a new subscription
-                handle = domainObject && telemetryHandler.handle(
-                    domainObject,
-                    updateValues
-                );
-                // Request an initial historical telemetry value
-                handle.request(
-                    { size: 1 }, // Only need a single data point
-                    updateValueFromSeries
-                );
             }
 
             // Handle changes in the object's composition
-            function updateComposition() {
-                // Populate panel positions
-                // TODO: Ensure defaults here
+            function updateComposition(composition, previousComposition) {
+                var removedIds = [];
                 // Resubscribe - objects in view have changed
-                subscribe($scope.domainObject);
+                if (composition !== previousComposition) {
+                    //remove any elements no longer in the composition
+                    removedIds = _.difference(previousComposition, composition);
+                    if (removedIds.length > 0) {
+                        removeObjects(removedIds);
+                    }
+                }
             }
 
             // Trigger a new query for telemetry data
-            function updateDisplayBounds(event, bounds) {
-                maxDomainValue = bounds.end;
-                if (handle) {
-                    handle.request(
-                        { size: 1 }, // Only need a single data point
-                        updateValueFromSeries
-                    );
+            function updateDisplayBounds(bounds) {
+                if (!self.openmct.conductor.follow()) {
+                    //Reset values
+                    self.values = {};
+                    refreshElements();
+                    //Fetch new data
+                    self.fetchHistoricalData(self.telemetryObjects);
                 }
             }
 
@@ -290,6 +256,9 @@ define(
                     width: DEFAULT_DIMENSIONS[0],
                     height: DEFAULT_DIMENSIONS[1]
                 });
+
+                //Re-initialize objects, and subscribe to new object
+                self.getTelemetry($scope.domainObject);
             }
 
             this.elementProxies = [];
@@ -311,25 +280,167 @@ define(
             // Detect changes to grid size
             $scope.$watch("model.layoutGrid", updateElementPositions);
 
-            // Refresh list of elements whenever model changes
-            $scope.$watch("model.modified", refreshElements);
+            // Position panes where they are dropped
+            $scope.$on("mctDrop", handleDrop);
 
             // Position panes when the model field changes
             $scope.$watch("model.composition", updateComposition);
 
+            // Refresh list of elements whenever model changes
+            $scope.$watch("model.modified", refreshElements);
+
             // Subscribe to telemetry when an object is available
-            $scope.$watch("domainObject", subscribe);
+            $scope.$watch("domainObject", this.getTelemetry);
 
             // Free up subscription on destroy
-            $scope.$on("$destroy", releaseSubscription);
-
-            // Position panes where they are dropped
-            $scope.$on("mctDrop", handleDrop);
+            $scope.$on("$destroy", function () {
+                self.unsubscribe();
+                self.openmct.conductor.off("bounds", updateDisplayBounds);
+            });
 
             // Respond to external bounds changes
-            $scope.$on("telemetry:display:bounds", updateDisplayBounds);
+            this.openmct.conductor.on("bounds", updateDisplayBounds);
         }
 
+        /**
+         * A rate-limited digest function. Caps digests at 60Hz
+         * @private
+         */
+        FixedController.prototype.digest = function () {
+            var self = this;
+
+            if (!this.digesting) {
+                this.digesting = true;
+                requestAnimationFrame(function () {
+                    self.$scope.$digest();
+                    self.digesting = false;
+                });
+            }
+        };
+
+        /**
+         * Unsubscribe all listeners
+         * @private
+         */
+        FixedController.prototype.unsubscribe = function () {
+            this.subscriptions.forEach(function (unsubscribeFunc) {
+                unsubscribeFunc();
+            });
+            this.subscriptions = [];
+            this.telemetryObjects = [];
+        };
+
+        /**
+         * Subscribe to all given domain objects
+         * @private
+         * @param {object[]} objects  Domain objects to subscribe to
+         * @returns {object[]} The provided objects, for chaining.
+         */
+        FixedController.prototype.subscribeToObjects = function (objects) {
+            var self = this;
+            this.subscriptions = objects.map(function (object) {
+                return self.openmct.telemetry.subscribe(object, function (datum) {
+                    if (self.openmct.conductor.follow()) {
+                        self.updateView(object, datum);
+                    }
+                }, {});
+            });
+            return objects;
+        };
+
+        /**
+         * Print the values from the given datum against the provided object in the view.
+         * @private
+         * @param {object} telemetryObject The domain object associated with the given telemetry data
+         * @param {object} datum The telemetry datum containing the values to print
+         */
+        FixedController.prototype.updateView = function (telemetryObject, datum) {
+            var metadata = this.openmct.telemetry.getMetadata(telemetryObject);
+            var rangeMetadata = metadata.valuesForHints(['range'])[0];
+            var rangeKey = rangeMetadata.source || rangeMetadata.key;
+            var valueMetadata = metadata.value(rangeKey);
+            var limitEvaluator = this.openmct.telemetry.limitEvaluator(telemetryObject);
+            var formatter = this.openmct.telemetry.getValueFormatter(valueMetadata);
+            var value = datum[valueMetadata.key];
+            var alarm = limitEvaluator && limitEvaluator.evaluate(datum, rangeKey);
+
+            this.setDisplayedValue(
+                telemetryObject,
+                formatter.format(value),
+                alarm && alarm.cssClass
+            );
+            this.digest();
+        };
+
+        /**
+         * Request the last historical data point for the given domain objects
+         * @param {object[]} objects
+         * @returns {object[]} the provided objects for chaining.
+         */
+        FixedController.prototype.fetchHistoricalData = function (objects) {
+            var bounds = this.openmct.conductor.bounds();
+            var self = this;
+
+            objects.forEach(function (object) {
+                self.openmct.telemetry.request(object, {start: bounds.start, end: bounds.end, size: 1})
+                    .then(function (data) {
+                        self.updateView(object, data[data.length - 1]);
+                    });
+            });
+            return objects;
+        };
+
+
+        /**
+         * Print a value to the onscreen element associated with a given telemetry object.
+         * @private
+         * @param {object} telemetryObject The telemetry object associated with the value
+         * @param {string | number} value The value to print to screen
+         * @param {string} [cssClass] an optional CSS class to apply to the onscreen element.
+         */
+        FixedController.prototype.setDisplayedValue = function (telemetryObject, value, cssClass) {
+            var id = objectUtils.makeKeyString(telemetryObject.identifier);
+            var self = this;
+
+            (self.elementProxiesById[id] || []).forEach(function (element) {
+                self.names[id] = telemetryObject.name;
+                self.values[id] = value;
+                element.name = self.names[id];
+                element.value = self.values[id];
+                element.cssClass = cssClass;
+            });
+        };
+
+        FixedController.prototype.getTelemetry = function (domainObject) {
+            var newObject = domainObject.useCapability('adapter');
+            var self = this;
+
+            if (this.subscriptions.length > 0) {
+                this.unsubscribe();
+            }
+
+            function filterForTelemetryObjects(objects) {
+                return objects.filter(function (object) {
+                    return self.openmct.telemetry.canProvideTelemetry(object);
+                });
+            }
+
+            function initializeDisplay(objects) {
+                self.telemetryObjects = objects;
+                objects.forEach(function (object) {
+                    // Initialize values
+                    self.setDisplayedValue(object, "");
+                });
+                return objects;
+            }
+
+            return this.openmct.composition.get(newObject).load()
+                .then(filterForTelemetryObjects)
+                .then(initializeDisplay)
+                .then(this.fetchHistoricalData)
+                .then(this.subscribeToObjects);
+        };
+
         /**
          * Get the size of the grid, in pixels. The returned array
          * is in the form `[x, y]`.

platform/features/layout/src/FixedDragHandle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/FixedProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/LayoutCompositionPolicy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -34,13 +34,15 @@ define(
         function LayoutCompositionPolicy() {
         }
 
-        LayoutCompositionPolicy.prototype.allow = function (candidate, context) {
-            var isFolderInLayout =
-                candidate &&
-                context &&
-                candidate.instanceOf('layout') &&
-                context.instanceOf('folder');
-            return !isFolderInLayout;
+        LayoutCompositionPolicy.prototype.allow = function (parent, child) {
+            var parentType = parent.getCapability('type');
+            if (parentType.instanceOf('layout') &&
+                child.getCapability('type').instanceOf('folder')) {
+
+                return false;
+            }
+
+            return true;
         };
 
         return LayoutCompositionPolicy;

platform/features/layout/src/LayoutController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/LayoutDrag.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/AccessorMutator.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/BoxProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/ElementFactory.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -55,7 +55,7 @@ define(
                                     key: "url",
                                     control: "textfield",
                                     name: "Image URL",
-                                    "cssclass": "l-input-lg",
+                                    "cssClass": "l-input-lg",
                                     required: true
                                 }
                             ]

platform/features/layout/src/elements/ElementProxies.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/ElementProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/ImageProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/LineHandle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/LineProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/ResizeHandle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/TelemetryProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/src/elements/TextProxy.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/FixedControllerSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -37,6 +37,15 @@ define(
                 testModel,
                 testValues,
                 testConfiguration,
+                mockOpenMCT,
+                mockTelemetryAPI,
+                mockCompositionAPI,
+                mockCompositionCollection,
+                mockChildren,
+                mockConductor,
+                mockMetadata,
+                mockTimeSystem,
+                mockLimitEvaluator,
                 controller;
 
             // Utility function; find a watch for a given expression
@@ -62,19 +71,18 @@ define(
             }
 
             function makeMockDomainObject(id) {
-                var mockObject = jasmine.createSpyObj(
-                    'domainObject-' + id,
-                    ['getId', 'getModel', 'getCapability']
-                );
-                mockObject.getId.andReturn(id);
-                mockObject.getModel.andReturn({ name: "Point " + id});
-                return mockObject;
+                return {
+                    identifier: {
+                        key: "domainObject-" + id
+                    },
+                    name: "Point " + id
+                };
             }
 
             beforeEach(function () {
                 mockScope = jasmine.createSpyObj(
                     '$scope',
-                    ["$on", "$watch", "commit"]
+                    ["$on", "$watch", "$digest", "commit"]
                 );
                 mockHandler = jasmine.createSpyObj(
                     'telemetryHandler',
@@ -87,12 +95,17 @@ define(
                 );
                 mockFormatter = jasmine.createSpyObj(
                     'telemetryFormatter',
-                    ['formatDomainValue', 'formatRangeValue']
+                    ['format']
                 );
+                mockFormatter.format.andCallFake(function (value) {
+                    return "Formatted " + value;
+                });
+
                 mockDomainObject = jasmine.createSpyObj(
                     'domainObject',
-                    ['getId', 'getModel', 'getCapability']
+                    ['getId', 'getModel', 'getCapability', 'useCapability']
                 );
+
                 mockHandle = jasmine.createSpyObj(
                     'subscription',
                     [
@@ -104,11 +117,39 @@ define(
                         'request'
                     ]
                 );
+                mockConductor = jasmine.createSpyObj('conductor', [
+                    'on',
+                    'off',
+                    'bounds',
+                    'timeSystem',
+                    'follow'
+                ]);
+                mockConductor.bounds.andReturn({});
+                mockTimeSystem = {
+                    metadata: {
+                        key: 'key'
+                    }
+                };
+                mockConductor.timeSystem.andReturn(mockTimeSystem);
+
                 mockEvent = jasmine.createSpyObj(
                     'event',
                     ['preventDefault']
                 );
 
+                mockTelemetryAPI = jasmine.createSpyObj('telemetry',
+                    [
+                        'subscribe',
+                        'request',
+                        'canProvideTelemetry',
+                        'getMetadata',
+                        'limitEvaluator',
+                        'getValueFormatter'
+                    ]
+                );
+                mockTelemetryAPI.canProvideTelemetry.andReturn(true);
+                mockTelemetryAPI.request.andReturn(Promise.resolve([]));
+
                 testGrid = [123, 456];
                 testModel = {
                     composition: ['a', 'b', 'c'],
@@ -121,17 +162,23 @@ define(
                     { type: "fixed.telemetry", id: 'c', x: 1, y: 1 }
                 ]};
 
-                mockHandler.handle.andReturn(mockHandle);
-                mockHandle.getTelemetryObjects.andReturn(
-                    testModel.composition.map(makeMockDomainObject)
+                mockChildren = testModel.composition.map(makeMockDomainObject);
+                mockCompositionCollection = jasmine.createSpyObj('compositionCollection',
+                    [
+                        'load'
+                    ]
                 );
-                mockHandle.getRangeValue.andCallFake(function (o) {
-                    return testValues[o.getId()];
-                });
-                mockHandle.getDomainValue.andReturn(12321);
-                mockFormatter.formatRangeValue.andCallFake(function (v) {
-                    return "Formatted " + v;
-                });
+                mockCompositionAPI = jasmine.createSpyObj('composition',
+                    [
+                        'get'
+                    ]
+                );
+                mockCompositionAPI.get.andReturn(mockCompositionCollection);
+                mockCompositionCollection.load.andReturn(
+                    Promise.resolve(mockChildren)
+                );
+
+
                 mockScope.model = testModel;
                 mockScope.configuration = testConfiguration;
                 mockScope.selection = jasmine.createSpyObj(
@@ -139,12 +186,47 @@ define(
                     ['select', 'get', 'selected', 'deselect', 'proxy']
                 );
 
+                mockOpenMCT = {
+                    conductor: mockConductor,
+                    telemetry: mockTelemetryAPI,
+                    composition: mockCompositionAPI
+                };
+
+                mockMetadata = jasmine.createSpyObj('mockMetadata', [
+                    'valuesForHints',
+                    'value'
+                ]);
+                mockMetadata.value.andReturn({
+                    key: 'value'
+                });
+
+                mockMetadata.valuesForHints.andCallFake(function (hints) {
+                    if (hints === ['domain']) {
+                        return [{
+                            key: 'time'
+                        }];
+                    } else {
+                        return [{
+                            key: 'value'
+                        }];
+                    }
+                });
+
+                mockLimitEvaluator = jasmine.createSpyObj('limitEvaluator', [
+                    'evaluate'
+                ]);
+
+                mockLimitEvaluator.evaluate.andReturn({});
+
+                mockTelemetryAPI.getMetadata.andReturn(mockMetadata);
+                mockTelemetryAPI.limitEvaluator.andReturn(mockLimitEvaluator);
+                mockTelemetryAPI.getValueFormatter.andReturn(mockFormatter);
+
                 controller = new FixedController(
                     mockScope,
                     mockQ,
                     mockDialogService,
-                    mockHandler,
-                    mockFormatter
+                    mockOpenMCT
                 );
 
                 findWatch("model.layoutGrid")(testModel.layoutGrid);
@@ -152,26 +234,61 @@ define(
             });
 
             it("subscribes when a domain object is available", function () {
+                var dunzo = false;
+
                 mockScope.domainObject = mockDomainObject;
-                findWatch("domainObject")(mockDomainObject);
-                expect(mockHandler.handle).toHaveBeenCalledWith(
-                    mockDomainObject,
-                    jasmine.any(Function)
-                );
+                findWatch("domainObject")(mockDomainObject).then(function () {
+                    dunzo = true;
+                });
+
+                waitsFor(function () {
+                    return dunzo;
+                }, "Telemetry fetched", 200);
+
+                runs(function () {
+                    mockChildren.forEach(function (child) {
+                        expect(mockTelemetryAPI.subscribe).toHaveBeenCalledWith(
+                            child,
+                            jasmine.any(Function),
+                            jasmine.any(Object)
+                        );
+                    });
+                });
             });
 
             it("releases subscriptions when domain objects change", function () {
+                var dunzo = false;
+                var unsubscribe = jasmine.createSpy('unsubscribe');
+
+                mockTelemetryAPI.subscribe.andReturn(unsubscribe);
+
                 mockScope.domainObject = mockDomainObject;
+                findWatch("domainObject")(mockDomainObject).then(function () {
+                    dunzo = true;
+                });
 
-                // First pass - should simply should subscribe
-                findWatch("domainObject")(mockDomainObject);
-                expect(mockHandle.unsubscribe).not.toHaveBeenCalled();
-                expect(mockHandler.handle.calls.length).toEqual(1);
+                waitsFor(function () {
+                    return dunzo;
+                }, "Telemetry fetched", 200);
 
-                // Object changes - should unsubscribe then resubscribe
-                findWatch("domainObject")(mockDomainObject);
-                expect(mockHandle.unsubscribe).toHaveBeenCalled();
-                expect(mockHandler.handle.calls.length).toEqual(2);
+                runs(function () {
+                    expect(unsubscribe).not.toHaveBeenCalled();
+
+                    dunzo = false;
+
+                    findWatch("domainObject")(mockDomainObject).then(function () {
+                        dunzo = true;
+                    });
+
+                    waitsFor(function () {
+                        return dunzo;
+                    }, "Telemetry fetched", 200);
+
+                    runs(function () {
+                        expect(unsubscribe.calls.length).toBe(mockChildren.length);
+                    });
+
+                });
             });
 
             it("exposes visible elements based on configuration", function () {
@@ -254,25 +371,38 @@ define(
                 expect(mockScope.selection.select.calls.length).toEqual(2);
             });
 
-            it("provides values for telemetry elements", function () {
+            it("Displays received 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);
+                var mockTelemetry = {
+                    time: 100,
+                    value: 200
+                };
+                var testElement = {};
+                var telemetryObject = {
+                    identifier: {
+                        key: '12345'
+                    }
+                };
+                controller.elementProxiesById = {};
+                controller.elementProxiesById['12345'] = [testElement];
+                controller.elementProxies = [testElement];
 
-                // Invoke the subscription callback
-                mockHandler.handle.mostRecentCall.args[1]();
+                controller.subscribeToObjects([telemetryObject]);
+                mockConductor.follow.andReturn(true);
+                mockTelemetryAPI.subscribe.mostRecentCall.args[1](mockTelemetry);
 
-                // Get elements that controller is now exposing
-                elements = controller.getElements();
+                waitsFor(function () {
+                    return controller.digesting === false;
+                }, "digest to complete", 100);
+
+                runs(function () {
+                    // Get elements that controller is now exposing
+                    elements = controller.getElements();
+
+                    // Formatted values should be available
+                    expect(elements[0].value).toEqual("Formatted 200");
+                });
 
-                // Formatted values should be available
-                expect(elements[0].value).toEqual("Formatted 10");
-                expect(elements[1].value).toEqual("Formatted 42");
-                expect(elements[2].value).toEqual("Formatted 31.42");
             });
 
             it("updates elements styles when grid size changes", function () {
@@ -291,6 +421,9 @@ define(
             });
 
             it("listens for drop events", function () {
+                mockScope.domainObject = mockDomainObject;
+                mockScope.model = testModel;
+
                 // Layout should position panels according to
                 // where the user dropped them, so it needs to
                 // listen for drop events.
@@ -339,14 +472,29 @@ define(
             });
 
             it("unsubscribes when destroyed", function () {
-                // Make an object available
-                findWatch('domainObject')(mockDomainObject);
-                // Also verify precondition
-                expect(mockHandle.unsubscribe).not.toHaveBeenCalled();
-                // Destroy the scope
-                findOn('$destroy')();
-                // Should have unsubscribed
-                expect(mockHandle.unsubscribe).toHaveBeenCalled();
+
+                var dunzo = false;
+                var unsubscribe = jasmine.createSpy('unsubscribe');
+
+                mockTelemetryAPI.subscribe.andReturn(unsubscribe);
+
+                mockScope.domainObject = mockDomainObject;
+                findWatch("domainObject")(mockDomainObject).then(function () {
+                    dunzo = true;
+                });
+
+                waitsFor(function () {
+                    return dunzo;
+                }, "Telemetry fetched", 200);
+
+                runs(function () {
+                    expect(unsubscribe).not.toHaveBeenCalled();
+                    // Destroy the scope
+                    findOn('$destroy')();
+
+                    //Check that the same unsubscribe function returned by the
+                    expect(unsubscribe.calls.length).toBe(mockChildren.length);
+                });
             });
 
             it("exposes its grid size", function () {
@@ -427,92 +575,102 @@ define(
 
             describe("on display bounds changes", function () {
                 var testBounds;
+                var boundsChangeCallback;
+                var objectOne;
+                var objectTwo;
 
                 beforeEach(function () {
                     testBounds = { start: 123, end: 321 };
-                    mockScope.domainObject = mockDomainObject;
-                    mockScope.model = testModel;
-                    findWatch("domainObject")(mockDomainObject);
-                    findWatch("model.modified")(testModel.modified);
-                    findWatch("model.composition")(mockScope.model.composition);
-                    findOn('telemetry:display:bounds')({}, testBounds);
+                    boundsChangeCallback = mockConductor.on.mostRecentCall.args[1];
+                    objectOne = {};
+                    objectTwo = {};
+                    controller.telemetryObjects = [
+                        objectOne,
+                        objectTwo
+                    ];
+                    spyOn(controller, "fetchHistoricalData");
+                    controller.fetchHistoricalData.andCallThrough();
                 });
 
-                it("issues new requests", function () {
-                    expect(mockHandle.request).toHaveBeenCalled();
+                it("registers a bounds change listener", function () {
+                    expect(mockConductor.on).toHaveBeenCalledWith("bounds", jasmine.any(Function));
                 });
 
                 it("requests only a single point", function () {
-                    expect(mockHandle.request.mostRecentCall.args[0].size)
-                        .toEqual(1);
+                    mockConductor.follow.andReturn(false);
+                    boundsChangeCallback(testBounds);
+                    expect(mockTelemetryAPI.request.calls.length).toBe(2);
+
+                    mockTelemetryAPI.request.calls.forEach(function (call) {
+                        expect(call.args[1].size).toBe(1);
+                    });
                 });
 
-                describe("and after data has been received", function () {
-                    var mockSeries,
-                        testValue;
+                it("Does not fetch historical data on tick", function () {
+                    mockConductor.follow.andReturn(true);
+                    boundsChangeCallback(testBounds);
+                    expect(mockTelemetryAPI.request.calls.length).toBe(0);
+                });
+            });
 
-                    beforeEach(function () {
-                        testValue = 12321;
+            describe("on receipt of telemetry", function () {
+                var mockTelemetryObject;
+                var testValue;
+                var testElement;
 
-                        mockSeries = jasmine.createSpyObj('series', [
-                            'getPointCount',
-                            'getDomainValue',
-                            'getRangeValue'
-                        ]);
-                        mockSeries.getPointCount.andReturn(1);
-                        mockSeries.getRangeValue.andReturn(testValue);
+                beforeEach(function () {
+                    mockTelemetryObject = {
+                        identifier: {
+                            key: '12345'
+                        }
+                    };
+                    testValue = 30;
+                    testElement = {};
 
-                        // Fire the callback associated with the request
-                        mockHandle.request.mostRecentCall.args[1](
-                            mockHandle.getTelemetryObjects()[0],
-                            mockSeries
-                        );
+                    controller.elementProxiesById = {};
+                    controller.elementProxiesById['12345'] = [testElement];
+                    controller.elementProxies = [testElement];
+                });
+
+                it("updates displayed values from historical telemetry", function () {
+                    spyOn(controller, "updateView");
+                    controller.updateView.andCallThrough();
+
+                    mockTelemetryAPI.request.andReturn(Promise.resolve([{
+                        time: 100,
+                        value: testValue
+                    }]));
+
+                    controller.fetchHistoricalData([mockTelemetryObject]);
+
+                    waitsFor(function () {
+                        return controller.digesting === false;
                     });
 
-                    it("updates displayed values", function () {
+                    runs(function () {
+                        expect(controller.updateView).toHaveBeenCalled();
                         expect(controller.getElements()[0].value)
                             .toEqual("Formatted " + testValue);
                     });
                 });
 
-            });
+                it("reflects limit status", function () {
+                    mockLimitEvaluator.evaluate.andReturn({cssClass: "alarm-a"});
+                    controller.updateView(mockTelemetryObject, [{
+                        time: 100,
+                        value: testValue
+                    }]);
 
-            it("reflects limit status", function () {
-                var elements;
-
-                mockHandle.getDatum.andReturn({});
-                mockHandle.getTelemetryObjects().forEach(function (mockObject) {
-                    var id = mockObject.getId(),
-                        mockLimitCapability =
-                            jasmine.createSpyObj('limit-' + id, ['evaluate']);
-
-                    mockObject.getCapability.andCallFake(function (key) {
-                        return (key === 'limit') && mockLimitCapability;
+                    waitsFor(function () {
+                        return controller.digesting === false;
                     });
 
-                    mockLimitCapability.evaluate
-                        .andReturn({ cssClass: 'alarm-' + id });
+                    runs(function () {
+                        // Limit-based CSS classes should be available
+                        expect(controller.getElements()[0].cssClass).toEqual("alarm-a");
+                    });
                 });
-
-                // Initialize
-                mockScope.domainObject = mockDomainObject;
-                mockScope.model = testModel;
-                findWatch("domainObject")(mockDomainObject);
-                findWatch("model.modified")(1);
-                findWatch("model.composition")(mockScope.model.composition);
-
-                // Invoke the subscription callback
-                mockHandler.handle.mostRecentCall.args[1]();
-
-                // Get elements that controller is now exposing
-                elements = controller.getElements();
-
-                // Limit-based CSS classes should be available
-                expect(elements[0].cssClass).toEqual("alarm-a");
-                expect(elements[1].cssClass).toEqual("alarm-b");
-                expect(elements[2].cssClass).toEqual("alarm-c");
             });
-
         });
     }
 );

platform/features/layout/test/FixedDragHandleSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/FixedProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/LayoutCompositionPolicySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -24,18 +24,31 @@ define(
     ["../src/LayoutCompositionPolicy"],
     function (LayoutCompositionPolicy) {
         describe("Layout's composition policy", function () {
-            var mockCandidate,
+            var mockChild,
+                mockCandidateObj,
+                mockCandidate,
                 mockContext,
                 candidateType,
                 contextType,
                 policy;
 
             beforeEach(function () {
+                mockChild = jasmine.createSpyObj(
+                    'childObject',
+                    ['getCapability']
+                );
                 mockCandidate =
                     jasmine.createSpyObj('candidateType', ['instanceOf']);
                 mockContext =
                     jasmine.createSpyObj('contextType', ['instanceOf']);
 
+                mockCandidateObj = jasmine.createSpyObj('domainObj', [
+                    'getCapability'
+                ]);
+                mockCandidateObj.getCapability.andReturn(mockCandidate);
+
+                mockChild.getCapability.andReturn(mockContext);
+
                 mockCandidate.instanceOf.andCallFake(function (t) {
                     return t === candidateType;
                 });
@@ -49,19 +62,19 @@ define(
             it("disallows folders in layouts", function () {
                 candidateType = 'layout';
                 contextType = 'folder';
-                expect(policy.allow(mockCandidate, mockContext)).toBe(false);
+                expect(policy.allow(mockCandidateObj, mockChild)).toBe(false);
             });
 
             it("does not disallow folders elsewhere", function () {
                 candidateType = 'nonlayout';
                 contextType = 'folder';
-                expect(policy.allow(mockCandidate, mockContext)).toBe(true);
+                expect(policy.allow(mockCandidateObj, mockChild)).toBe(true);
             });
 
             it("allows things other than folders in layouts", function () {
                 candidateType = 'layout';
                 contextType = 'nonfolder';
-                expect(policy.allow(mockCandidate, mockContext)).toBe(true);
+                expect(policy.allow(mockCandidateObj, mockChild)).toBe(true);
             });
 
         });

platform/features/layout/test/LayoutControllerSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/LayoutDragSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/AccessorMutatorSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/BoxProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/ElementFactorySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/ElementProxiesSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/ElementProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/ImageProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/LineHandleSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/LineProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/ResizeHandleSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/TelemetryProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/layout/test/elements/TextProxySpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/my-items/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/pages/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -36,7 +36,7 @@ define([
                 {
                     "key": "example.page",
                     "name": "Web Page",
-                    "cssclass": "icon-page",
+                    "cssClass": "icon-page",
                     "description": "Embed a web page or web-based image in a resizeable window component. Can be added to Display Layouts. Note that the URL being embedded must allow iframing.",
                     "priority": 50,
                     "features": [
@@ -47,9 +47,9 @@ define([
                             "key": "url",
                             "name": "URL",
                             "control": "textfield",
-                            "pattern": "^(ftp|https?)\\:\\/\\/\\w+(\\.\\w+)*(\\:\\d+)?(\\/\\S*)*$",
+                            "pattern": "^(ftp|https?)\\:\\/\\/",
                             "required": true,
-                            "cssclass": "l-input-lg"
+                            "cssClass": "l-input-lg"
                         }
                     ]
                 }

platform/features/pages/res/iframe.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -23,4 +23,4 @@
 <iframe ng-controller="EmbeddedPageController as ctl"
         ng-src="{{ctl.trust(model.url)}}">
 </iframe>
-</div>
+</div>

platform/features/pages/src/EmbeddedPageController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/pages/test/EmbeddedPageControllerSpec.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/README.md

@@ -0,0 +1,37 @@
+# Plot README
+
+## Chart 
+
+The `mct-chart` directive is used to support drawing of simple charts. It is 
+present to support the Plot view, and its functionality is limited to the 
+functionality that is relevant for that view.
+
+This directive is used at the element level and takes one attribute, `draw` 
+which is an Angular expression which will should evaluate to a drawing object. 
+This drawing object should contain the following properties:
+
+* `dimensions`: The size, in logical coordinates, of the chart area. A 
+two-element array or numbers. 
+* `origin`: The position, in logical coordinates, of the lower-left corner of 
+the chart area. A two-element array or numbers. 
+* `lines`: An array of lines (e.g. as a plot line) to draw, where each line is 
+expressed as an object containing: 
+    * `buffer`: A Float32Array containing points in the line, in logical 
+    coordinates, in sequential x,y pairs. 
+    * `color`: The color of the line, as a four-element RGBA array, where 
+    each element is a number in the range of 0.0-1.0. 
+    * `points`: The number of points in the line. 
+* `boxes`: An array of rectangles to draw in the chart area. Each is an object 
+containing: 
+    * `start`: The first corner of the rectangle, as a two-element array of 
+    numbers, in logical coordinates. 
+    * `end`: The opposite corner of the rectangle, as a two-element array of 
+    numbers, in logical coordinates. color : The color of the line, as a 
+    four-element RGBA array, where each element is a number in the range of 
+    0.0-1.0. 
+
+While `mct-chart` is intended to support plots specifically, it does perform 
+some useful management of canvas objects (e.g. choosing between WebGL and Canvas 
+2D APIs for drawing based on browser support) so its usage is recommended when 
+its supported drawing primitives are sufficient for other charting tasks. 
+ 

platform/features/plot/bundle.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -47,7 +47,7 @@ define([
                 {
                     "name": "Plot",
                     "key": "plot",
-                    "cssclass": "icon-sine",
+                    "cssClass": "icon-sine",
                     "template": plotTemplate,
                     "needs": [
                         "telemetry"

platform/features/plot/res/templates/plot-options-browse.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -67,4 +67,4 @@
             </ul>
         </ul>
     </div>
-</div>
+</div>

platform/features/plot/res/templates/plot.html

@@ -1,5 +1,5 @@
 <!--
- Open MCT, Copyright (c) 2014-2016, United States Government
+ Open MCT, Copyright (c) 2014-2017, United States Government
  as represented by the Administrator of the National Aeronautics and Space
  Administration. All rights reserved.
 
@@ -121,7 +121,7 @@
                            ng-show="plot.isZoomed()"
                            title="Reset pan/zoom">
                         </a>
-                        <div class="menu-element s-menu-button menus-to-left {{plot.getMode().cssclass}}"
+                        <div class="menu-element s-menu-button menus-to-left {{plot.getMode().cssClass}}"
                              ng-if="plot.getModeOptions().length > 1"
                              ng-controller="ClickAwayController as toggle">
                             <span class="l-click-area" ng-click="toggle.toggle()"></span>
@@ -130,7 +130,7 @@
                                 <ul>
                                     <li ng-repeat="option in plot.getModeOptions()"
                                         ng-click="plot.setMode(option); toggle.setState(false)"
-                                        class="{{option.cssclass}}">
+                                        class="{{option.cssClass}}">
                                         {{option.name}}
                                     </li>
                                 </ul>

platform/features/plot/src/Canvas2DChart.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/src/GLChart.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/src/MCTChart.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/src/PlotController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -217,8 +217,8 @@ define(
                 if (handle) {
                     handle.unsubscribe();
                     handle = undefined;
-                    conductor.off("timeOfInterest", changeTimeOfInterest);
                 }
+                conductor.off("timeOfInterest", changeTimeOfInterest);
             }
 
             function requery() {
@@ -352,7 +352,7 @@ define(
 
         /**
          * Get the current mode that is applicable to this plot. This
-         * will include key, name, and cssclass fields.
+         * will include key, name, and cssClass fields.
          */
         PlotController.prototype.getMode = function () {
             return this.modeOptions.getMode();

platform/features/plot/src/PlotOptionsController.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/src/PlotOptionsForm.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *

platform/features/plot/src/SubPlot.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
+ * Open MCT, Copyright (c) 2014-2017, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *