Merge branch 'open-master' into open1388

platform/commonUI/general/src/directives/MCTDrag.js

@@ -57,13 +57,17 @@ define(
                 // mouse may leave this element during the drag.
                 var body = $document.find('body'),
                     initialPosition,
+                    $event,
                     delta;
 
                 // Utility function to cause evaluation of mctDrag,
                 // mctDragUp, etc
                 function fireListener(name) {
                     // Evaluate the expression, with current delta
-                    scope.$eval(attrs[name], { delta: delta });
+                    scope.$eval(attrs[name], {
+                        delta: delta,
+                        $event: $event
+                    });
 
                     // Trigger prompt digestion
                     scope.$apply();
@@ -82,6 +86,9 @@ define(
                     delta = currentPosition.map(function (v, i) {
                         return v - initialPosition[i];
                     });
+
+                    // Also track the plain event for firing listeners
+                    $event = event;
                 }
 
                 // Called during a drag, on mousemove
@@ -106,7 +113,7 @@ define(
 
                     fireListener("mctDragUp");
 
-                    // Clear out start-of-drag position
+                    // Clear out start-of-drag position, target
                     initialPosition = undefined;
 
                     // Don't show selection highlights, etc
@@ -131,6 +138,7 @@ define(
 
                     // Don't show selection highlights, etc
                     event.preventDefault();
+
                     return false;
                 }
 

platform/commonUI/general/test/directives/MCTDragSpec.js

@@ -81,10 +81,11 @@ define(
             });
 
             it("invokes mctDragDown when dragging begins", function () {
-                mockElement.on.mostRecentCall.args[1](testEvent(42, 60));
+                var event = testEvent(42, 60);
+                mockElement.on.mostRecentCall.args[1](event);
                 expect(mockScope.$eval).toHaveBeenCalledWith(
                     testAttrs.mctDragDown,
-                    { delta: [0, 0] }
+                    { delta: [0, 0], $event: event }
                 );
             });
 
@@ -101,23 +102,27 @@ define(
             });
 
             it("invokes mctDrag expression during drag", function () {
+                var event;
+
                 mockElement.on.mostRecentCall.args[1](testEvent(42, 60));
 
                 // Find and invoke the mousemove listener
                 mockBody.on.calls.forEach(function (call) {
                     if (call.args[0] === 'mousemove') {
-                        call.args[1](testEvent(52, 200));
+                        call.args[1](event = testEvent(52, 200));
                     }
                 });
 
                 // Should have passed that delta to mct-drag expression
                 expect(mockScope.$eval).toHaveBeenCalledWith(
                     testAttrs.mctDrag,
-                    { delta: [10, 140] }
+                    { delta: [10, 140], $event: event }
                 );
             });
 
             it("invokes mctDragUp expression after drag", function () {
+                var event;
+
                 mockElement.on.mostRecentCall.args[1](testEvent(42, 60));
 
                 // Find and invoke the mousemove listener
@@ -129,7 +134,7 @@ define(
                 // Find and invoke the mousemove listener
                 mockBody.on.calls.forEach(function (call) {
                     if (call.args[0] === 'mouseup') {
-                        call.args[1](testEvent(40, 71));
+                        call.args[1](event = testEvent(40, 71));
                     }
                 });
 
@@ -138,7 +143,7 @@ define(
                 // initial position
                 expect(mockScope.$eval).toHaveBeenCalledWith(
                     testAttrs.mctDragUp,
-                    { delta: [-2, 11] }
+                    { delta: [-2, 11], $event: event }
                 );
 
                 // Should also have unregistered listeners

platform/core/bundle.json

@@ -183,7 +183,7 @@
             {
                 "key": "mutation",
                 "implementation": "capabilities/MutationCapability.js",
-                "depends": [ "now" ]
+                "depends": [ "topic", "now" ]
             },
             {
                 "key": "delegation",
@@ -200,6 +200,10 @@
                 "key": "throttle",
                 "implementation": "services/Throttle.js",
                 "depends": [ "$timeout" ]
+            },
+            {
+                "key": "topic",
+                "implementation": "services/Topic.js"
             }
         ],
         "roots": [

platform/core/src/capabilities/MutationCapability.js

@@ -29,6 +29,8 @@ define(
     function () {
         "use strict";
 
+        var TOPIC_PREFIX = "mutation:";
+
         // Utility function to overwrite a destination object
         // with the contents of a source object.
         function copyValues(destination, source) {
@@ -71,7 +73,8 @@ define(
          *        which will expose this capability
          * @constructor
          */
-        function MutationCapability(now, domainObject) {
+        function MutationCapability(topic, now, domainObject) {
+            var t = topic(TOPIC_PREFIX + domainObject.getId());
 
             function mutate(mutator, timestamp) {
                 // Get the object's model and clone it, so the
@@ -96,6 +99,7 @@ define(
                             copyValues(model, result);
                         }
                         model.modified = useTimestamp ? timestamp : now();
+                        t.notify(model);
                     }
 
                     // Report the result of the mutation
@@ -107,6 +111,10 @@ define(
                 return fastPromise(mutator(clone)).then(handleMutation);
             }
 
+            function listen(listener) {
+                return t.listen(listener);
+            }
+
             return {
                 /**
                  * Alias of `mutate`, used to support useCapability.
@@ -139,7 +147,16 @@ define(
                  * @returns {Promise.<boolean>} a promise for the result
                  *         of the mutation; true if changes were made.
                  */
-                mutate: mutate
+                mutate: mutate,
+                /**
+                 * Listen for mutations of this domain object's model.
+                 * The provided listener will be invoked with the domain
+                 * object's new model after any changes. To stop listening,
+                 * invoke the function returned by this method.
+                 * @param {Function} listener function to call on mutation
+                 * @returns {Function} a function to stop listening
+                 */
+                listen: listen
             };
         }
 

platform/core/src/services/Throttle.js

@@ -1,3 +1,24 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
 /*global define*/
 
 define(

platform/core/src/services/Topic.js

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * The `topic` service provides a way to create both named,
+         * shared listeners and anonymous, private listeners.
+         *
+         * Usage:
+         *
+         * ```
+         * var t = topic('foo'); // Use/create a named topic
+         * t.listen(function () { ... });
+         * t.notify({ some: "message" });
+         * ```
+         *
+         * Named topics are shared; multiple calls to `topic`
+         * with the same argument will return a single object instance.
+         * Anonymous topics (where `topic` has been called with no
+         * arguments) are private; each call returns a new instance.
+         *
+         * @returns {Function}
+         */
+        function Topic() {
+            var topics = {};
+
+            function createTopic() {
+                var listeners = [];
+
+                return {
+                    listen: function (listener) {
+                        listeners.push(listener);
+                        return function unlisten() {
+                            listeners = listeners.filter(function (l) {
+                                return l !== listener;
+                            });
+                        };
+                    },
+                    notify: function (message) {
+                        listeners.forEach(function (listener) {
+                            listener(message);
+                        });
+                    }
+                };
+            }
+
+            /**
+             * Use and (if necessary) create a new topic.
+             * @param {string} [key] name of the topic to use
+             */
+            return function (key) {
+                if (arguments.length < 1) {
+                    return createTopic();
+                } else {
+                    topics[key] = topics[key] || createTopic();
+                    return topics[key];
+                }
+            };
+        }
+
+        return Topic;
+    }
+);

platform/core/test/capabilities/MutationCapabilitySpec.js

@@ -25,21 +25,33 @@
  * MutationCapabilitySpec. Created by vwoeltje on 11/6/14.
  */
 define(
-    ["../../src/capabilities/MutationCapability"],
+    [
-    function (MutationCapability) {
+        "../../src/capabilities/MutationCapability",
+        "../../src/services/Topic"
+    ],
+    function (MutationCapability, Topic) {
         "use strict";
 
         describe("The mutation capability", function () {
             var testModel,
+                topic,
                 mockNow,
-                domainObject = { getModel: function () { return testModel; } },
+                domainObject = {
+                    getId: function () { return "test-id"; },
+                    getModel: function () { return testModel; }
+                },
                 mutation;
 
             beforeEach(function () {
                 testModel = { number: 6 };
+                topic = new Topic();
                 mockNow = jasmine.createSpy('now');
                 mockNow.andReturn(12321);
-                mutation = new MutationCapability(mockNow, domainObject);
+                mutation = new MutationCapability(
+                    topic,
+                    mockNow,
+                    domainObject
+                );
             });
 
             it("allows mutation of a model", function () {
@@ -83,6 +95,42 @@ define(
                 // Should have gotten a timestamp from 'now'
                 expect(testModel.modified).toEqual(42);
             });
+
+            it("notifies listeners of mutation", function () {
+                var mockCallback = jasmine.createSpy('callback');
+                mutation.listen(mockCallback);
+                mutation.invoke(function (m) {
+                    m.number = 8;
+                });
+                expect(mockCallback).toHaveBeenCalled();
+                expect(mockCallback.mostRecentCall.args[0].number)
+                    .toEqual(8);
+            });
+
+            it("allows listeners to stop listening", function () {
+                var mockCallback = jasmine.createSpy('callback');
+                mutation.listen(mockCallback)(); // Unlisten immediately
+                mutation.invoke(function (m) {
+                    m.number = 8;
+                });
+                expect(mockCallback).not.toHaveBeenCalled();
+            });
+
+            it("shares listeners across instances", function () {
+                var mockCallback = jasmine.createSpy('callback'),
+                    otherMutation = new MutationCapability(
+                        topic,
+                        mockNow,
+                        domainObject
+                    );
+                mutation.listen(mockCallback);
+                otherMutation.invoke(function (m) {
+                    m.number = 8;
+                });
+                expect(mockCallback).toHaveBeenCalled();
+                expect(mockCallback.mostRecentCall.args[0].number)
+                    .toEqual(8);
+            });
         });
     }
 );

platform/core/test/services/ThrottleSpec.js

@@ -1,3 +1,24 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
 /*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
 
 define(

platform/core/test/services/TopicSpec.js

@@ -0,0 +1,70 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+
+define(
+    ["../../src/services/Topic"],
+    function (Topic) {
+        "use strict";
+
+        describe("The 'topic' service", function () {
+            var topic,
+                testMessage,
+                mockCallback;
+
+            beforeEach(function () {
+                testMessage = { someKey: "some value"};
+                mockCallback = jasmine.createSpy('callback');
+                topic = new Topic();
+            });
+
+            it("notifies listeners on a topic", function () {
+                topic("abc").listen(mockCallback);
+                topic("abc").notify(testMessage);
+                expect(mockCallback).toHaveBeenCalledWith(testMessage);
+            });
+
+            it("does not notify listeners across topics", function () {
+                topic("abc").listen(mockCallback);
+                topic("xyz").notify(testMessage);
+                expect(mockCallback).not.toHaveBeenCalledWith(testMessage);
+            });
+
+            it("does not notify listeners after unlistening", function () {
+                topic("abc").listen(mockCallback)(); // Unlisten immediately
+                topic("abc").notify(testMessage);
+                expect(mockCallback).not.toHaveBeenCalledWith(testMessage);
+            });
+
+            it("provides anonymous private topics", function () {
+                var t1 = topic(), t2 = topic();
+
+                t1.listen(mockCallback);
+                t2.notify(testMessage);
+                expect(mockCallback).not.toHaveBeenCalledWith(testMessage);
+                t1.notify(testMessage);
+                expect(mockCallback).toHaveBeenCalledWith(testMessage);
+            });
+
+        });
+    }
+);

platform/core/test/suite.json

@@ -25,6 +25,7 @@
 
     "services/Now",
     "services/Throttle",
+    "services/Topic",
 
     "types/MergeModels",
     "types/TypeCapability",

platform/features/plot/bundle.json

@@ -23,7 +23,21 @@
             {
                 "key": "PlotController",
                 "implementation": "PlotController.js",
-                "depends": [ "$scope", "telemetryFormatter", "telemetryHandler", "throttle" ]
+                "depends": [
+                    "$scope",
+                    "telemetryFormatter",
+                    "telemetryHandler",
+                    "throttle",
+                    "PLOT_FIXED_DURATION"
+                ]
+            }
+        ],
+        "constants": [
+            {
+                "key": "PLOT_FIXED_DURATION",
+                "value": 900000,
+                "priority": "fallback",
+                "comment": "Fifteen minutes."
             }
         ],
         "policies": [

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

@@ -82,8 +82,9 @@
 
                 <mct-chart draw="subplot.getDrawingObject()"
                            ng-mousemove="subplot.hover($event)"
-                           ng-mousedown="subplot.startMarquee($event)"
+                           mct-drag="subplot.continueDrag($event)"
-                           ng-mouseup="subplot.endMarquee($event); plot.update()">
+                           mct-drag-down="subplot.startDrag($event)"
+                           mct-drag-up="subplot.endDrag($event); plot.update()">
                 </mct-chart>
 
                 <!-- TODO: Move into correct position; make part of group; infer from set of actions -->

platform/features/plot/src/PlotController.js

@@ -51,7 +51,13 @@ define(
          *
          * @constructor
          */
-        function PlotController($scope, telemetryFormatter, telemetryHandler, throttle) {
+        function PlotController(
+            $scope,
+            telemetryFormatter,
+            telemetryHandler,
+            throttle,
+            PLOT_FIXED_DURATION
+        ) {
             var subPlotFactory = new SubPlotFactory(telemetryFormatter),
                 modeOptions = new PlotModeOptions([], subPlotFactory),
                 subplots = [],
@@ -99,7 +105,8 @@ define(
                 updater = new PlotUpdater(
                     handle,
                     ($scope.axes[0].active || {}).key,
-                    ($scope.axes[1].active || {}).key
+                    ($scope.axes[1].active || {}).key,
+                    PLOT_FIXED_DURATION
                 );
             }
 

platform/features/plot/src/SubPlot.js

@@ -56,6 +56,9 @@ define(
                 domainOffset,
                 mousePosition,
                 marqueeStart,
+                panStart,
+                panStartBounds,
+                subPlotBounds,
                 hoverCoordinates,
                 isHovering = false;
 
@@ -88,8 +91,7 @@ define(
             // pixel coordinates in the canvas area) from a mouse
             // event object.
             function toMousePosition($event) {
-                var target = $event.target,
+                var bounds = subPlotBounds;
-                    bounds = target.getBoundingClientRect();
 
                 return {
                     x: $event.clientX - bounds.left,
@@ -155,6 +157,25 @@ define(
                     tickGenerator.generateRangeTicks(RANGE_TICKS);
             }
 
+            function updatePan() {
+                var start, current, delta, nextOrigin;
+
+                // Clear the previous panning pan-zoom state
+                panZoomStack.popPanZoom();
+
+                // Calculate what the new resulting pan-zoom should be
+                start = mousePositionToDomainRange(panStart);
+                current = mousePositionToDomainRange(mousePosition);
+                delta = [ current[0] - start[0], current[1] - start[1] ];
+                nextOrigin = [
+                    panStartBounds.origin[0] - delta[0],
+                    panStartBounds.origin[1] - delta[1]
+                ];
+
+                // ...and push a new one at the current mouse position
+                panZoomStack.pushPanZoom(nextOrigin, panStartBounds.dimensions);
+            }
+
 
             // Perform a marquee zoom.
             function marqueeZoom(start, end) {
@@ -241,31 +262,77 @@ define(
                  */
                 hover: function ($event) {
                     isHovering = true;
+                    subPlotBounds = $event.target.getBoundingClientRect();
                     mousePosition = toMousePosition($event);
                     updateHoverCoordinates();
                     if (marqueeStart) {
                         updateMarqueeBox();
                     }
+                    if (panStart) {
+                        updatePan();
+                        updateDrawingBounds();
+                        updateTicks();
+                    }
+                },
+                /**
+                 * Continue a previously-start pan or zoom gesture.
+                 * @param $event the mouse event
+                 */
+                continueDrag: function ($event) {
+                    mousePosition = toMousePosition($event);
+                    if (marqueeStart) {
+                        updateMarqueeBox();
+                    }
+                    if (panStart) {
+                        updatePan();
+                        updateDrawingBounds();
+                        updateTicks();
+                    }
                 },
                 /**
                  * Initiate a marquee zoom action.
                  * @param $event the mouse event
                  */
-                startMarquee: function ($event) {
+                startDrag: function ($event) {
-                    mousePosition = marqueeStart = toMousePosition($event);
+                    subPlotBounds = $event.target.getBoundingClientRect();
+                    mousePosition = toMousePosition($event);
+                    // Treat any modifier key as a pan
+                    if ($event.altKey || $event.shiftKey || $event.ctrlKey) {
+                        // Start panning
+                        panStart = mousePosition;
+                        panStartBounds = panZoomStack.getPanZoom();
+                        // We're starting a pan, so add this back as a
+                        // state on the stack; it will get replaced
+                        // during the pan.
+                        panZoomStack.pushPanZoom(
+                            panStartBounds.origin,
+                            panStartBounds.dimensions
+                        );
+                        $event.preventDefault();
+                    } else {
+                        // Start marquee zooming
+                        marqueeStart = mousePosition;
                         updateMarqueeBox();
+                    }
                 },
                 /**
                  * Complete a marquee zoom action.
                  * @param $event the mouse event
                  */
-                endMarquee: function ($event) {
+                endDrag: function ($event) {
                     mousePosition = toMousePosition($event);
+                    subPlotBounds = undefined;
                     if (marqueeStart) {
                         marqueeZoom(marqueeStart, mousePosition);
                         marqueeStart = undefined;
                         updateMarqueeBox();
                         updateDrawingBounds();
+                        updateTicks();
+                    }
+                    if (panStart) {
+                        // End panning
+                        panStart = undefined;
+                        panStartBounds = undefined;
                     }
                 },
                 /**

platform/features/plot/src/elements/PlotLineBuffer.js

@@ -43,9 +43,9 @@ define(
                 var mid = Math.floor((min + max) / 2),
                     found = buffer[mid * 2];
 
-                // Collisions are not wanted
+                // On collisions, insert at same index
                 if (found === value) {
-                    return -1;
+                    return mid;
                 }
 
                 // Otherwise, if we're down to a single index,

platform/features/plot/src/elements/PlotUpdater.js

@@ -42,14 +42,17 @@ define(
          * @param {TelemetryHandle} handle the handle to telemetry access
          * @param {string} domain the key to use when looking up domain values
          * @param {string} range the key to use when looking up range values
+         * @param {number} maxDuration maximum plot duration to display
+         * @param {number} maxPoints maximum number of points to display
          */
-        function PlotUpdater(handle, domain, range, maxPoints) {
+        function PlotUpdater(handle, domain, range, fixedDuration, maxPoints) {
             var ids = [],
                 lines = {},
                 dimensions = [0, 0],
                 origin = [0, 0],
                 domainExtrema,
                 rangeExtrema,
+                buffers = {},
                 bufferArray = [],
                 domainOffset;
 
@@ -61,11 +64,10 @@ define(
             // Check if this set of ids matches the current set of ids
             // (used to detect if line preparation can be skipped)
             function idsMatch(nextIds) {
-                return nextIds.map(function (id, index) {
+                return ids.length === nextIds.length &&
+                    nextIds.every(function (id, index) {
                         return ids[index] === id;
-                }).reduce(function (a, b) {
+                    });
-                    return a && b;
-                }, true);
             }
 
             // Prepare plot lines for this group of telemetry objects
@@ -74,7 +76,7 @@ define(
                     next = {};
 
                 // Detect if we already have everything we need prepared
-                if (ids.length === nextIds.length && idsMatch(nextIds)) {
+                if (idsMatch(nextIds)) {
                     // Nothing to prepare, move on
                     return;
                 }
@@ -88,13 +90,13 @@ define(
 
                     // Create buffers for these objects
                     bufferArray = ids.map(function (id) {
-                        var buffer = new PlotLineBuffer(
+                        buffers[id] = buffers[id] || new PlotLineBuffer(
                             domainOffset,
                             INITIAL_SIZE,
                             maxPoints
                         );
-                        next[id] = lines[id] || new PlotLine(buffer);
+                        next[id] = lines[id] || new PlotLine(buffers[id]);
-                        return buffer;
+                        return buffers[id];
                     });
                 }
 
@@ -107,6 +109,7 @@ define(
                 lines = next;
             }
 
+
             // Initialize the domain offset, based on these observed values
             function initializeDomainOffset(values) {
                 domainOffset =
@@ -133,7 +136,7 @@ define(
             }
 
             // Update dimensions and origin based on extrema of plots
-            function updateExtrema() {
+            function updateBounds() {
                 if (bufferArray.length > 0) {
                     domainExtrema = bufferArray.map(function (lineBuffer) {
                         return lineBuffer.getDomainExtrema();
@@ -143,10 +146,40 @@ define(
                         return lineBuffer.getRangeExtrema();
                     }).reduce(reduceExtrema);
 
+                    // Calculate best-fit dimensions
                     dimensions = (rangeExtrema[0] === rangeExtrema[1]) ?
                             [dimensionsOf(domainExtrema), 2.0 ] :
                             [dimensionsOf(domainExtrema), dimensionsOf(rangeExtrema)];
                     origin = [originOf(domainExtrema), originOf(rangeExtrema)];
+
+                    // ...then enforce a fixed duration if needed
+                    if (fixedDuration !== undefined) {
+                        origin[0] = origin[0] + dimensions[0] - fixedDuration;
+                        dimensions[0] = fixedDuration;
+                    }
+                }
+            }
+
+            // Enforce maximum duration on all plot lines; not that
+            // domain extrema must be up-to-date for this to behave correctly.
+            function enforceDuration() {
+                var cutoff;
+
+                function enforceDurationForBuffer(plotLineBuffer) {
+                    var index = plotLineBuffer.findInsertionIndex(cutoff);
+                    if (index > 0) {
+                        // Leave one point untrimmed, such that line will
+                        // continue off left edge of visible plot area.
+                        plotLineBuffer.trim(index - 1);
+                    }
+                }
+
+                if (fixedDuration !== undefined &&
+                        domainExtrema !== undefined &&
+                            (domainExtrema[1] - domainExtrema[0] > fixedDuration)) {
+                    cutoff = domainExtrema[1] - fixedDuration;
+                    bufferArray.forEach(enforceDurationForBuffer);
+                    updateBounds(); // Extrema may have changed now
                 }
             }
 
@@ -180,8 +213,8 @@ define(
                 // Add new data
                 objects.forEach(addPointFor);
 
-                // Finally, update extrema
+                // Then, update extrema
-                updateExtrema();
+                updateBounds();
             }
 
             // Add historical data for this domain object
@@ -213,12 +246,12 @@ define(
                     line.addSeries(series, domain, range);
                 }
 
-                // Finally, update extrema
+                // Update extrema
-                updateExtrema();
+                updateBounds();
             }
 
             // Use a default MAX_POINTS if none is provided
-            maxPoints = maxPoints || MAX_POINTS;
+            maxPoints = maxPoints !== undefined ? maxPoints : MAX_POINTS;
 
             // Initially prepare state for these objects.
             // Note that this may be an empty array at this time,

platform/features/plot/test/SubPlotSpec.js

@@ -127,7 +127,7 @@ define(
 
                 // Simulate a marquee zoom. Note that the mockElement
                 // is 100 by 100 and starts at 10,20
-                subplot.startMarquee({
+                subplot.startDrag({
                     target: mockElement,
                     clientX: 60,
                     clientY: 45
@@ -137,7 +137,7 @@ define(
                     clientX: 75,
                     clientY: 85
                 });
-                subplot.endMarquee({
+                subplot.endDrag({
                     target: mockElement,
                     clientX: 80,
                     clientY: 95
@@ -162,7 +162,7 @@ define(
 
                 // Simulate a marquee zoom. Note that the mockElement
                 // is 100 by 100 and starts at 10,20
-                subplot.startMarquee({
+                subplot.startDrag({
                     target: mockElement,
                     clientX: 60,
                     clientY: 45
@@ -172,7 +172,7 @@ define(
                     clientX: 75,
                     clientY: 85
                 });
-                subplot.endMarquee({
+                subplot.endDrag({
                     target: mockElement,
                     clientX: 60,
                     clientY: 45

platform/features/plot/test/elements/PlotLineBufferSpec.js

@@ -83,9 +83,6 @@ define(
                 expect(buffer.findInsertionIndex(10)).toEqual(4);
                 expect(buffer.findInsertionIndex(14.5)).toEqual(5);
                 expect(buffer.findInsertionIndex(20)).toEqual(6);
-
-                // 9 is already in there, disallow insertion
-                expect(buffer.findInsertionIndex(9)).toEqual(-1);
             });
 
             it("allows insertion in the middle", function () {

platform/telemetry/src/TelemetrySubscription.js

@@ -59,6 +59,7 @@ define(
                 telemetryObjects = [],
                 pool = lossless ? new TelemetryQueue() : new TelemetryTable(),
                 metadatas,
+                unlistenToMutation,
                 updatePending;
 
             // Look up domain objects which have telemetry capabilities.
@@ -146,13 +147,23 @@ define(
                 telemetryObjects = objects;
                 metadatas = objects.map(lookupMetadata);
                 // Fire callback, as this will be the first time that
-                // telemetry objects are available
+                // telemetry objects are available, or these objects
+                // will have changed.
                 if (callback) {
                     callback();
                 }
                 return objects;
             }
 
+            function unsubscribeAll() {
+                return unsubscribePromise.then(function (unsubscribes) {
+                    return $q.all(unsubscribes.map(function (unsubscribe) {
+                        return unsubscribe();
+                    }));
+                });
+            }
+
+            function initialize() {
                 // Get a reference to relevant objects (those with telemetry
                 // capabilities) and subscribe to their telemetry updates.
                 // Keep a reference to their promised return values, as these
@@ -163,6 +174,32 @@ define(
                 unsubscribePromise = telemetryObjectPromise
                         .then(cacheObjectReferences)
                         .then(subscribeAll);
+            }
+
+            function idsMatch(ids) {
+                return ids.length === telemetryObjects.length &&
+                    ids.every(function (id, index) {
+                        return telemetryObjects[index].getId() === id;
+                    });
+            }
+
+            function modelChange(model) {
+                if (!idsMatch((model || {}).composition || [])) {
+                    // Reinitialize if composition has changed
+                    unsubscribeAll().then(initialize);
+                }
+            }
+
+            function addMutationListener() {
+                var mutation = domainObject &&
+                    domainObject.getCapability('mutation');
+                if (mutation) {
+                    return mutation.listen(modelChange);
+                }
+            }
+
+            initialize();
+            unlistenToMutation = addMutationListener();
 
             return {
                 /**
@@ -172,11 +209,10 @@ define(
                  * @memberof TelemetrySubscription
                  */
                 unsubscribe: function () {
-                    return unsubscribePromise.then(function (unsubscribes) {
+                    if (unlistenToMutation) {
-                        return $q.all(unsubscribes.map(function (unsubscribe) {
+                        unlistenToMutation();
-                            return unsubscribe();
+                    }
-                        }));
+                    return unsubscribeAll();
-                    });
                 },
                 /**
                  * Get the most recent domain value that has been observed

platform/telemetry/test/TelemetrySubscriptionSpec.js

@@ -32,7 +32,9 @@ define(
                 mockDomainObject,
                 mockCallback,
                 mockTelemetry,
+                mockMutation,
                 mockUnsubscribe,
+                mockUnlisten,
                 mockSeries,
                 testMetadata,
                 subscription;
@@ -59,7 +61,12 @@ define(
                     "telemetry",
                     ["subscribe", "getMetadata"]
                 );
+                mockMutation = jasmine.createSpyObj(
+                    "mutation",
+                    ["mutate", "listen"]
+                );
                 mockUnsubscribe = jasmine.createSpy("unsubscribe");
+                mockUnlisten = jasmine.createSpy("unlisten");
                 mockSeries = jasmine.createSpyObj(
                     "series",
                     [ "getPointCount", "getDomainValue", "getRangeValue" ]
@@ -68,12 +75,19 @@ define(
                 mockQ.when.andCallFake(mockPromise);
 
                 mockDomainObject.hasCapability.andReturn(true);
-                mockDomainObject.getCapability.andReturn(mockTelemetry);
+                mockDomainObject.getCapability.andCallFake(function (c) {
+                    return {
+                        telemetry: mockTelemetry,
+                        mutation: mockMutation
+                    }[c];
+                });
                 mockDomainObject.getId.andReturn('test-id');
 
                 mockTelemetry.subscribe.andReturn(mockUnsubscribe);
                 mockTelemetry.getMetadata.andReturn(testMetadata);
 
+                mockMutation.listen.andReturn(mockUnlisten);
+
                 mockSeries.getPointCount.andReturn(42);
                 mockSeries.getDomainValue.andReturn(123456);
                 mockSeries.getRangeValue.andReturn(789);
@@ -213,6 +227,22 @@ define(
                 expect(mockCallback2)
                     .toHaveBeenCalledWith([ mockDomainObject ]);
             });
+
+            it("reinitializes on mutation", function () {
+                expect(mockTelemetry.subscribe.calls.length).toEqual(1);
+                // Notify of a mutation which appears to change composition
+                mockMutation.listen.mostRecentCall.args[0]({
+                    composition: ['Z']
+                });
+                // Use subscribe call as an indication of reinitialization
+                expect(mockTelemetry.subscribe.calls.length).toEqual(2);
+            });
+
+            it("stops listening for mutation on unsubscribe", function () {
+                expect(mockUnlisten).not.toHaveBeenCalled();
+                subscription.unsubscribe();
+                expect(mockUnlisten).toHaveBeenCalled();
+            });
         });
     }
 );