ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-02-20 17:33:23 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge branch 'open-master' into open1388

Browse Source
This commit is contained in:
Victor Woeltjen 2015-06-27 12:17:45 -07:00
commit a752a21bf8
20 changed files with 553 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
platform/commonUI/general/src/directives/MCTDrag.js
View File

@ -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;
}
@ -148,4 +156,4 @@ define(
return MCTDrag;
}
);
);

19
platform/commonUI/general/test/directives/MCTDragSpec.js
View File

@ -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
@ -147,4 +152,4 @@ define(
});
}
);
);

6
platform/core/bundle.json
View File

@ -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": [

23
platform/core/src/capabilities/MutationCapability.js
View File

@ -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,10 +147,19 @@ 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
};
}
return MutationCapability;
}
);
);

21
platform/core/src/services/Throttle.js
View File

@ -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(

87
platform/core/src/services/Topic.js Normal file
View File

@ -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;
}
);

58
platform/core/test/capabilities/MutationCapabilitySpec.js
View File

@ -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);
});
});
}
);
);

21
platform/core/test/services/ThrottleSpec.js
View File

@ -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(

70
platform/core/test/services/TopicSpec.js Normal file
View File

@ -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);
});
});
}
);

3
platform/core/test/suite.json
View File

@ -25,6 +25,7 @@
"services/Now",
"services/Throttle",
"services/Topic",
"types/MergeModels",
"types/TypeCapability",
@ -35,4 +36,4 @@
"views/ViewCapability",
"views/ViewProvider"
]
]

16
platform/features/plot/bundle.json
View File

@ -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": [

5
platform/features/plot/res/templates/plot.html
View File

@ -82,8 +82,9 @@
<mct-chart draw="subplot.getDrawingObject()"
ng-mousemove="subplot.hover($event)"
ng-mousedown="subplot.startMarquee($event)"
ng-mouseup="subplot.endMarquee($event); plot.update()">
mct-drag="subplot.continueDrag($event)"
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 -->

15
platform/features/plot/src/PlotController.js
View File

@ -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
);
}
@ -161,7 +168,7 @@ define(
// Unsubscribe when the plot is destroyed
$scope.$on("$destroy", releaseSubscription);
// Create a throttled update function
scheduleUpdate = throttle(function () {
modeOptions.getModeHandler().getSubPlots()
@ -248,4 +255,4 @@ define(
return PlotController;
}
);
);

81
platform/features/plot/src/SubPlot.js
View File

@ -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,
bounds = target.getBoundingClientRect();
var bounds = subPlotBounds;
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) {
mousePosition = marqueeStart = toMousePosition($event);
updateMarqueeBox();
startDrag: function ($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;
}
},
/**
@ -311,4 +378,4 @@ define(
return SubPlot;
}
);
);

6
platform/features/plot/src/elements/PlotLineBuffer.js
View File

@ -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,
@ -258,4 +258,4 @@ define(
return PlotLineBuffer;
}
);
);

75
platform/features/plot/src/elements/PlotUpdater.js
View File

@ -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[index] === id;
}).reduce(function (a, b) {
return a && b;
}, true);
return ids.length === nextIds.length &&
nextIds.every(function (id, index) {
return ids[index] === id;
});
}
// 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(
domainOffset,
INITIAL_SIZE,
maxPoints
);
next[id] = lines[id] || new PlotLine(buffer);
return buffer;
buffers[id] = buffers[id] || new PlotLineBuffer(
domainOffset,
INITIAL_SIZE,
maxPoints
);
next[id] = lines[id] || new PlotLine(buffers[id]);
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
updateExtrema();
// Then, update extrema
updateBounds();
}
// Add historical data for this domain object
@ -213,12 +246,12 @@ define(
line.addSeries(series, domain, range);
}
// Finally, update extrema
updateExtrema();
// Update extrema
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,
@ -290,4 +323,4 @@ define(
return PlotUpdater;
}
);
);

10
platform/features/plot/test/SubPlotSpec.js
View File

@ -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
@ -198,4 +198,4 @@ define(
});
}
);
);

5
platform/features/plot/test/elements/PlotLineBufferSpec.js
View File

@ -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 () {
@ -169,4 +166,4 @@ define(
});
}
);
);

70
platform/telemetry/src/TelemetrySubscription.js
View File

@ -59,6 +59,7 @@ define(
telemetryObjects = [],
pool = lossless ? new TelemetryQueue() : new TelemetryTable(),
metadatas,
unlistenToMutation,
updatePending;
// Look up domain objects which have telemetry capabilities.
@ -146,23 +147,59 @@ 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;
}
// 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
// will be unsubscribe functions. (This must be a promise
// because delegation is supported, and retrieving delegate
// telemetry-capable objects may be an asynchronous operation.)
telemetryObjectPromise = promiseRelevantObjects(domainObject);
unsubscribePromise = telemetryObjectPromise
.then(cacheObjectReferences)
.then(subscribeAll);
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
// will be unsubscribe functions. (This must be a promise
// because delegation is supported, and retrieving delegate
// telemetry-capable objects may be an asynchronous operation.)
telemetryObjectPromise = promiseRelevantObjects(domainObject);
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) {
return $q.all(unsubscribes.map(function (unsubscribe) {
return unsubscribe();
}));
});
if (unlistenToMutation) {
unlistenToMutation();
}
return unsubscribeAll();
},
/**
* Get the most recent domain value that has been observed
@ -264,4 +300,4 @@ define(
return TelemetrySubscription;
}
);
);

34
platform/telemetry/test/TelemetrySubscriptionSpec.js
View File

@ -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();
});
});
}
);
);