wip

example/generator/GeneratorMetadataProvider.js

@@ -33,7 +33,8 @@ define([
                     formatString: '%0.2f',
                     hints: {
                         range: 1
-                    }
+                    },
+                    filters: ['equals']
                 },
                 {
                     key: "cos",

index.html

@@ -84,9 +84,8 @@
         openmct.install(openmct.plugins.Tabs());
         openmct.install(openmct.plugins.FlexibleLayout());
         openmct.install(openmct.plugins.LADTable());
-        openmct.install(openmct.plugins.Filters(['table', 'telemetry.plot.overlay']));
+        openmct.install(openmct.plugins.Filters(['table', 'telemetry.plot.overlay', 'telemetry.plot.stacked']));
         openmct.install(openmct.plugins.ObjectMigration());
-        openmct.install(openmct.plugins.GoToOriginalAction());
         openmct.start();
     </script>
 </html>

package.json

@@ -55,7 +55,7 @@
     "node-bourbon": "^4.2.3",
     "node-sass": "^4.9.2",
     "painterro": "^0.2.65",
-    "printj": "^1.2.1",
+    "printj": "^1.1.0",
     "raw-loader": "^0.5.1",
     "request": "^2.69.0",
     "split": "^1.0.0",

platform/commonUI/dialog/res/templates/notification-message.html

@@ -9,17 +9,17 @@
                          ng-model="ngModel"
                          ng-show="ngModel.progressPerc !== undefined"></mct-include>
         </div>
-    </div>
-    <div class="c-overlay__button-bar">
-        <button ng-repeat="dialogOption in ngModel.options"
+        <div class="c-overlay__button-bar">
+            <button ng-repeat="dialogOption in ngModel.options"
                 class="c-button"
                 ng-click="dialogOption.callback()">
-            {{dialogOption.label}}
-        </button>
-        <button class="c-button c-button--major"
+                    {{dialogOption.label}}
+            </button>
+            <button class="c-button c-button--major"
                 ng-if="ngModel.primaryOption"
                 ng-click="ngModel.primaryOption.callback()">
-            {{ngModel.primaryOption.label}}
-        </button>
+                    {{ngModel.primaryOption.label}}
+            </button>
+        </div>
     </div>
 </div>

platform/commonUI/edit/src/capabilities/EditorCapability.js

@@ -64,6 +64,7 @@ define(
          * @returns boolean
          */
         EditorCapability.prototype.inEditContext = function () {
+            console.warn('DEPRECATION WARNING: isEditing checks must be done via openmct.editor.');
             return this.openmct.editor.isEditing();
         };
 
@@ -73,6 +74,7 @@ define(
          * @returns {*}
          */
         EditorCapability.prototype.isEditContextRoot = function () {
+            console.warn('DEPRECATION WARNING: isEditing checks must be done via openmct.editor.');
             return this.openmct.editor.isEditing();
         };
 

platform/commonUI/edit/src/services/TransactionManager.js

@@ -77,19 +77,14 @@ define([], function () {
                 return promiseFn().then(nextFn);
             };
         }
-        /**
-         * Clear any existing persistence calls for object with given ID. This ensures only the most recent persistence
-         * call is executed. This should prevent stale objects being persisted and overwriting fresh ones.
-         */
-        if (this.isScheduled(id)) {
-            this.clearTransactionsFor(id);
-        }
 
-        this.clearTransactionFns[id] =
-            this.transactionService.addToTransaction(
-                chain(onCommit, release),
-                chain(onCancel, release)
-            );
+        if (!this.isScheduled(id)) {
+            this.clearTransactionFns[id] =
+                this.transactionService.addToTransaction(
+                    chain(onCommit, release),
+                    chain(onCancel, release)
+                );
+        }
     };
 
     /**

platform/commonUI/edit/test/services/TransactionManagerSpec.js

@@ -93,33 +93,24 @@ define(
                     expect(mockOnCancel).toHaveBeenCalled();
                 });
 
-                describe("Adds callbacks to transaction", function () {
-                    beforeEach(function () {
-                        spyOn(manager, 'clearTransactionsFor');
-                        manager.clearTransactionsFor.and.callThrough();
-                    });
+                it("ignores subsequent calls for the same object", function () {
+                    manager.addToTransaction(
+                        testId,
+                        jasmine.createSpy(),
+                        jasmine.createSpy()
+                    );
+                    expect(mockTransactionService.addToTransaction.calls.count())
+                        .toEqual(1);
+                });
 
-                    it("and clears pending calls if same object", function () {
-                        manager.addToTransaction(
-                            testId,
-                            jasmine.createSpy(),
-                            jasmine.createSpy()
-                        );
-                        expect(manager.clearTransactionsFor).toHaveBeenCalledWith(testId);
-                    });
-
-                    it("and does not clear pending calls if different object", function () {
-                        manager.addToTransaction(
-                            'other-id',
-                            jasmine.createSpy(),
-                            jasmine.createSpy()
-                        );
-                        expect(manager.clearTransactionsFor).not.toHaveBeenCalled();
-                    });
-
-                    afterEach(function () {
-                        expect(mockTransactionService.addToTransaction.calls.count()).toEqual(2);
-                    });
+                it("accepts subsequent calls for other objects", function () {
+                    manager.addToTransaction(
+                        'other-id',
+                        jasmine.createSpy(),
+                        jasmine.createSpy()
+                    );
+                    expect(mockTransactionService.addToTransaction.calls.count())
+                        .toEqual(2);
                 });
 
                 it("does not remove callbacks from the transaction", function () {

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

@@ -54,7 +54,6 @@ define(
                     if (isDestroyed) {
                         return;
                     }
-
                     var removeSelectable = openmct.selection.selectable(
                         element[0],
                         scope.$eval(attrs.mctSelectable),

platform/core/src/runs/TransactingMutationListener.js

@@ -43,10 +43,23 @@ define([], function () {
         var mutationTopic = topic('mutation');
         mutationTopic.listen(function (domainObject) {
             var persistence = domainObject.getCapability('persistence');
+            var wasActive = transactionService.isActive();
             cacheService.put(domainObject.getId(), domainObject.getModel());
 
             if (hasChanged(domainObject)) {
-                persistence.persist();
+
+                if (!wasActive) {
+                    transactionService.startTransaction();
+                }
+
+                transactionService.addToTransaction(
+                    persistence.persist.bind(persistence),
+                    persistence.refresh.bind(persistence)
+                );
+
+                if (!wasActive) {
+                    transactionService.commit();
+                }
             }
         });
     }

platform/core/test/runs/TransactingMutationListenerSpec.js

@@ -24,27 +24,22 @@ define(
     ["../../src/runs/TransactingMutationListener"],
     function (TransactingMutationListener) {
 
-        describe("TransactingMutationListener", function () {
+        xdescribe("TransactingMutationListener", function () {
             var mockTopic,
                 mockMutationTopic,
-                mockCacheService,
                 mockTransactionService,
                 mockDomainObject,
-                mockModel,
                 mockPersistence;
 
             beforeEach(function () {
                 mockTopic = jasmine.createSpy('topic');
                 mockMutationTopic =
                     jasmine.createSpyObj('mutation', ['listen']);
-                mockCacheService =
-                    jasmine.createSpyObj('cacheService', [
-                        'put'
-                    ]);
                 mockTransactionService =
                     jasmine.createSpyObj('transactionService', [
                         'isActive',
                         'startTransaction',
+                        'addToTransaction',
                         'commit'
                     ]);
                 mockDomainObject = jasmine.createSpyObj(
@@ -57,24 +52,18 @@ define(
                 );
 
                 mockTopic.and.callFake(function (t) {
-                    expect(t).toBe('mutation');
-                    return mockMutationTopic;
+                    return (t === 'mutation') && mockMutationTopic;
                 });
 
-                mockDomainObject.getId.and.returnValue('mockId');
                 mockDomainObject.getCapability.and.callFake(function (c) {
-                    expect(c).toBe('persistence');
-                    return mockPersistence;
+                    return (c === 'persistence') && mockPersistence;
                 });
-                mockModel = {};
-                mockDomainObject.getModel.and.returnValue(mockModel);
 
                 mockPersistence.persisted.and.returnValue(true);
 
                 return new TransactingMutationListener(
                     mockTopic,
-                    mockTransactionService,
-                    mockCacheService
+                    mockTransactionService
                 );
             });
 
@@ -83,27 +72,48 @@ define(
                     .toHaveBeenCalledWith(jasmine.any(Function));
             });
 
-            it("calls persist if the model has changed", function () {
-                mockModel.persisted = Date.now();
+            [false, true].forEach(function (isActive) {
+                var verb = isActive ? "is" : "isn't";
 
-                //Mark the model dirty by setting the mutated date later than the last persisted date.
-                mockModel.modified = mockModel.persisted + 1;
+                function onlyWhenInactive(expectation) {
+                    return isActive ? expectation.not : expectation;
+                }
 
-                mockMutationTopic.listen.calls.mostRecent()
-                    .args[0](mockDomainObject);
+                describe("when a transaction " + verb + " active", function () {
+                    var innerVerb = isActive ? "does" : "doesn't";
 
-                expect(mockPersistence.persist).toHaveBeenCalled();
-            });
+                    beforeEach(function () {
+                        mockTransactionService.isActive.and.returnValue(isActive);
+                    });
 
-            it("does not call persist if the model has not changed", function () {
-                mockModel.persisted = Date.now();
+                    describe("and mutation occurs", function () {
+                        beforeEach(function () {
+                            mockMutationTopic.listen.calls.mostRecent()
+                                .args[0](mockDomainObject);
+                        });
 
-                mockModel.modified = mockModel.persisted;
 
-                mockMutationTopic.listen.calls.mostRecent()
-                    .args[0](mockDomainObject);
+                        it(innerVerb + " start a new transaction", function () {
+                            onlyWhenInactive(
+                                expect(mockTransactionService.startTransaction)
+                            ).toHaveBeenCalled();
+                        });
 
-                expect(mockPersistence.persist).not.toHaveBeenCalled();
+                        it("adds to the active transaction", function () {
+                            expect(mockTransactionService.addToTransaction)
+                                .toHaveBeenCalledWith(
+                                    jasmine.any(Function),
+                                    jasmine.any(Function)
+                                );
+                        });
+
+                        it(innerVerb + " immediately commit", function () {
+                            onlyWhenInactive(
+                                expect(mockTransactionService.commit)
+                            ).toHaveBeenCalled();
+                        });
+                    });
+                });
             });
         });
     }

platform/entanglement/bundle.js

@@ -24,6 +24,7 @@ define([
     "./src/actions/MoveAction",
     "./src/actions/CopyAction",
     "./src/actions/LinkAction",
+    "./src/actions/GoToOriginalAction",
     "./src/actions/SetPrimaryLocationAction",
     "./src/services/LocatingCreationDecorator",
     "./src/services/LocatingObjectDecorator",
@@ -40,6 +41,7 @@ define([
     MoveAction,
     CopyAction,
     LinkAction,
+    GoToOriginalAction,
     SetPrimaryLocationAction,
     LocatingCreationDecorator,
     LocatingObjectDecorator,
@@ -102,6 +104,14 @@ define([
                         "linkService"
                     ]
                 },
+                {
+                    "key": "follow",
+                    "name": "Go To Original",
+                    "description": "Go to the original, un-linked instance of this object.",
+                    "cssClass": "",
+                    "category": "contextual",
+                    "implementation": GoToOriginalAction
+                },
                 {
                     "key": "locate",
                     "name": "Set Primary Location",

platform/entanglement/src/actions/GoToOriginalAction.js

@@ -0,0 +1,60 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2018, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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 () {
+
+        /**
+         * Implements the "Go To Original" action, which follows a link back
+         * to an original instance of an object.
+         *
+         * @implements {Action}
+         * @constructor
+         * @private
+         * @memberof platform/entanglement
+         * @param {ActionContext} context the context in which the action
+         *        will be performed
+         */
+        function GoToOriginalAction(context) {
+            this.domainObject = context.domainObject;
+        }
+
+        GoToOriginalAction.prototype.perform = function () {
+            return this.domainObject.getCapability("location").getOriginal()
+                .then(function (originalObject) {
+                    var actionCapability =
+                        originalObject.getCapability("action");
+                    return actionCapability &&
+                            actionCapability.perform("navigate");
+                });
+        };
+
+        GoToOriginalAction.appliesTo = function (context) {
+            var domainObject = context.domainObject;
+            return domainObject && domainObject.hasCapability("location") &&
+                domainObject.getCapability("location").isLink();
+        };
+
+        return GoToOriginalAction;
+    }
+);
+

platform/entanglement/test/actions/GoToOriginalActionSpec.js

@@ -0,0 +1,93 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2018, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT 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 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(
+    [
+        '../../src/actions/GoToOriginalAction',
+        '../DomainObjectFactory',
+        '../ControlledPromise'
+    ],
+    function (GoToOriginalAction, domainObjectFactory, ControlledPromise) {
+
+        describe("The 'go to original' action", function () {
+            var testContext,
+                originalDomainObject,
+                mockLocationCapability,
+                mockOriginalActionCapability,
+                originalPromise,
+                action;
+
+            beforeEach(function () {
+                mockLocationCapability = jasmine.createSpyObj(
+                    'location',
+                    ['isLink', 'isOriginal', 'getOriginal']
+                );
+                mockOriginalActionCapability = jasmine.createSpyObj(
+                    'action',
+                    ['perform', 'getActions']
+                );
+                originalPromise = new ControlledPromise();
+                mockLocationCapability.getOriginal.and.returnValue(originalPromise);
+                mockLocationCapability.isLink.and.returnValue(true);
+                mockLocationCapability.isOriginal.and.callFake(function () {
+                    return !mockLocationCapability.isLink();
+                });
+                testContext = {
+                    domainObject: domainObjectFactory({
+                        capabilities: {
+                            location: mockLocationCapability
+                        }
+                    })
+                };
+                originalDomainObject = domainObjectFactory({
+                    capabilities: {
+                        action: mockOriginalActionCapability
+                    }
+                });
+
+                action = new GoToOriginalAction(testContext);
+            });
+
+            it("is applicable to links", function () {
+                expect(GoToOriginalAction.appliesTo(testContext))
+                    .toBeTruthy();
+            });
+
+            it("is not applicable to originals", function () {
+                mockLocationCapability.isLink.and.returnValue(false);
+                expect(GoToOriginalAction.appliesTo(testContext))
+                    .toBeFalsy();
+            });
+
+            it("navigates to original objects when performed", function () {
+                expect(mockOriginalActionCapability.perform)
+                    .not.toHaveBeenCalled();
+                action.perform();
+                originalPromise.resolve(originalDomainObject);
+                expect(mockOriginalActionCapability.perform)
+                    .toHaveBeenCalledWith('navigate');
+            });
+
+        });
+    }
+);

platform/import-export/src/actions/ImportAsJSONAction.js

@@ -80,17 +80,15 @@ define(['zepto'], function ($) {
             var newObj;
 
             seen.push(parent.getId());
-
-            parentModel.composition.forEach(function (childId) {
-                let keystring = this.openmct.objects.makeKeyString(childId);
-
-                if (!tree[keystring] || seen.includes(keystring)) {
+            parentModel.composition.forEach(function (childId, index) {
+                if (!tree[childId] || seen.includes(childId)) {
                     return;
                 }
 
-                newObj = this.instantiate(tree[keystring], keystring);
+                newObj = this.instantiate(tree[childId], childId);
+                parent.getCapability("composition").add(newObj);
                 newObj.getCapability("location")
-                    .setPrimaryLocation(tree[keystring].location);
+                    .setPrimaryLocation(tree[childId].location);
                 this.deepInstantiate(newObj, tree, seen);
             }, this);
         }

src/adapter/actions/LegacyContextMenuAction.js

@@ -33,25 +33,20 @@ export default class LegacyContextMenuAction {
     }
 
     invoke(objectPath) {
-        this.openmct.objects.getRoot().then((root) => {
-            let pathWithRoot = objectPath.slice();
-            pathWithRoot.push(root);
+        let context = {
+            category: 'contextual',
+            domainObject: this.openmct.legacyObject(objectPath)
+        }
+        let legacyAction = new this.LegacyAction(context);
 
-            let context = {
-                category: 'contextual',
-                domainObject: this.openmct.legacyObject(pathWithRoot)
-            }
-            let legacyAction = new this.LegacyAction(context);
-
-            if (!legacyAction.getMetadata) {
-                let metadata = Object.create(this.LegacyAction.definition);
-                metadata.context = context;
-                legacyAction.getMetadata = function () {
-                    return metadata;
-                }.bind(legacyAction);
-            }
-            legacyAction.perform();
-        });
+        if (!legacyAction.getMetadata) {
+            let metadata = Object.create(this.LegacyAction.definition);
+            metadata.context = context;
+            legacyAction.getMetadata = function () {
+                return metadata;
+            }.bind(legacyAction);
+        }
+        legacyAction.perform();
     }
 
     appliesTo(objectPath) {

src/adapter/bundle.js

@@ -36,7 +36,7 @@ define([
     './runs/RegisterLegacyTypes',
     './services/LegacyObjectAPIInterceptor',
     './views/installLegacyViews',
-    './policies/LegacyCompositionPolicyAdapter',
+    './policies/legacyCompositionPolicyAdapter',
     './actions/LegacyActionAdapter'
 ], function (
     legacyRegistry,

src/adapter/views/LegacyViewProvider.js

@@ -45,30 +45,15 @@ define([
             view: function (domainObject) {
                 let $rootScope = openmct.$injector.get('$rootScope');
                 let templateLinker = openmct.$injector.get('templateLinker');
-                let scope = $rootScope.$new(true);
+                let scope = $rootScope.$new();
                 let legacyObject = convertToLegacyObject(domainObject);
                 let isDestroyed = false;
-                let unlistenToStatus;
-                let element;
                 scope.domainObject = legacyObject;
                 scope.model = legacyObject.getModel();
-                let child;
-                let parent;
+
 
                 return {
                     show: function (container) {
-                        parent = container;
-                        child = document.createElement('div');
-                        parent.appendChild(child);
-                        let statusCapability = legacyObject.getCapability('status');
-                        unlistenToStatus = statusCapability.listen((newStatus) => {
-                            child.classList.remove('s-status-timeconductor-unsynced');
-
-                            if (newStatus.includes('timeconductor-unsynced')) {
-                                child.classList.add('s-status-timeconductor-unsynced');
-                            }
-                        });
-
                         // TODO: implement "gestures" support ?
                         let uses = legacyView.uses || [];
                         let promises = [];
@@ -89,13 +74,12 @@ define([
                             uses.forEach(function (key, i) {
                                 scope[key] = results[i];
                             });
-                            element = openmct.$angular.element(child);
                             templateLinker.link(
                                 scope,
-                                element,
+                                openmct.$angular.element(container),
                                 legacyView
                             );
-                            child.classList.add('u-contents');
+                            container.classList.add('u-contents');
                         }
 
                         if (promises.length) {
@@ -109,12 +93,7 @@ define([
                         }
                     },
                     destroy: function () {
-                        element.off();
-                        element.remove();
                         scope.$destroy();
-                        element = null;
-                        scope = null;
-                        unlistenToStatus();
                     }
                 }
             },

src/adapter/views/TypeInspectorViewProvider.js

@@ -41,18 +41,15 @@ define([
                 let domainObject = selection[0][0].context.item;
                 let $rootScope = openmct.$injector.get('$rootScope');
                 let templateLinker = openmct.$injector.get('templateLinker');
-                let scope = $rootScope.$new(true);
+                let scope = $rootScope.$new();
                 let legacyObject = convertToLegacyObject(domainObject);
                 let isDestroyed = false;
-                let element;
                 scope.domainObject = legacyObject;
                 scope.model = legacyObject.getModel();
 
 
                 return {
                     show: function (container) {
-                        let child = document.createElement('div');
-                        container.appendChild(child);
                         // TODO: implement "gestures" support ?
                         let uses = representation.uses || [];
                         let promises = [];
@@ -73,10 +70,9 @@ define([
                             uses.forEach(function (key, i) {
                                 scope[key] = results[i];
                             });
-                            element = openmct.$angular.element(child)
                             templateLinker.link(
                                 scope,
-                                element,
+                                openmct.$angular.element(container),
                                 representation
                             );
                             container.style.height = '100%';
@@ -93,11 +89,7 @@ define([
                         }
                     },
                     destroy: function () {
-                        element.off();
-                        element.remove();
                         scope.$destroy();
-                        element = null;
-                        scope = null;
                     }
                 }
             }

src/api/Editor.js

@@ -28,6 +28,11 @@ export default class Editor extends EventEmitter {
         super();
         this.editing = false;
         this.openmct = openmct;
+        document.addEventListener('drop', (event) => {
+            if (!this.isEditing()) {
+                this.edit();
+            }
+        }, {capture: true});
     }
 
     /**

src/api/composition/CompositionAPISpec.js

@@ -22,20 +22,8 @@ define([
             publicAPI = {};
             publicAPI.objects = jasmine.createSpyObj('ObjectAPI', [
                 'get',
-                'mutate',
-                'observe',
-                'areIdsEqual'
+                'mutate'
             ]);
-
-            publicAPI.objects.areIdsEqual.and.callFake(function (id1, id2) {
-                return id1.namespace === id2.namespace && id1.key === id2.key;
-            });
-
-            publicAPI.composition = jasmine.createSpyObj('CompositionAPI', [
-                'checkPolicy'
-            ]);
-            publicAPI.composition.checkPolicy.and.returnValue(true);
-
             publicAPI.objects.eventEmitter = jasmine.createSpyObj('eventemitter', [
                 'on'
             ]);
@@ -103,7 +91,7 @@ define([
                 beforeEach(function () {
                     listener = jasmine.createSpy('reorderListener');
                     composition.on('reorder', listener);
-
+                    
                     return composition.load();
                 });
                 it('', function () {
@@ -131,16 +119,49 @@ define([
                     expect(newComposition[2].key).toEqual('a');
                 })
             });
-            it('supports adding an object to composition', function () {
-                let addListener = jasmine.createSpy('addListener');
-                let mockChildObject = {
-                    identifier: {key: 'mock-key', namespace: ''}
-                };
-                composition.on('add', addListener);
-                composition.add(mockChildObject);
 
-                expect(domainObject.composition.length).toBe(4);
-                expect(domainObject.composition[3]).toEqual(mockChildObject.identifier);
+            // TODO: Implement add/removal in new default provider.
+            xit('synchronizes changes between instances', function () {
+                var otherComposition = compositionAPI.get(domainObject);
+                var addListener = jasmine.createSpy('addListener');
+                var removeListener = jasmine.createSpy('removeListener');
+                var otherAddListener = jasmine.createSpy('otherAddListener');
+                var otherRemoveListener = jasmine.createSpy('otherRemoveListener');
+                composition.on('add', addListener);
+                composition.on('remove', removeListener);
+                otherComposition.on('add', otherAddListener);
+                otherComposition.on('remove', otherRemoveListener);
+
+                return Promise.all([composition.load(), otherComposition.load()])
+                    .then(function () {
+                        expect(addListener).toHaveBeenCalled();
+                        expect(otherAddListener).toHaveBeenCalled();
+                        expect(removeListener).not.toHaveBeenCalled();
+                        expect(otherRemoveListener).not.toHaveBeenCalled();
+
+                        var object = addListener.calls.mostRecent().args[0];
+                        composition.remove(object);
+                        expect(removeListener).toHaveBeenCalled();
+                        expect(otherRemoveListener).toHaveBeenCalled();
+
+                        addListener.reset();
+                        otherAddListener.reset();
+                        composition.add(object);
+                        expect(addListener).toHaveBeenCalled();
+                        expect(otherAddListener).toHaveBeenCalled();
+
+                        removeListener.reset();
+                        otherRemoveListener.reset();
+                        otherComposition.remove(object);
+                        expect(removeListener).toHaveBeenCalled();
+                        expect(otherRemoveListener).toHaveBeenCalled();
+
+                        addListener.reset();
+                        otherAddListener.reset();
+                        otherComposition.add(object);
+                        expect(addListener).toHaveBeenCalled();
+                        expect(otherAddListener).toHaveBeenCalled();
+                    });
             });
         });
 
@@ -163,9 +184,7 @@ define([
                                 key: 'thing'
                             }
                         ]);
-                    },
-                    add: jasmine.createSpy('add'),
-                    remove: jasmine.createSpy('remove')
+                    }
                 };
                 domainObject = {
                     identifier: {
@@ -195,25 +214,6 @@ define([
                     });
                 });
             });
-            describe('Calling add or remove', function () {
-                let mockChildObject;
-
-                beforeEach(function () {
-                    mockChildObject = {
-                        identifier: {key: 'mock-key', namespace: ''}
-                    };
-                    composition.add(mockChildObject);
-                });
-
-                it('calls add on the provider', function () {
-                    expect(customProvider.add).toHaveBeenCalledWith(domainObject, mockChildObject.identifier);
-                });
-
-                it('calls remove on the provider', function () {
-                    composition.remove(mockChildObject);
-                    expect(customProvider.remove).toHaveBeenCalledWith(domainObject, mockChildObject.identifier);
-                });
-            });
         });
 
         describe('dynamic custom composition', function () {

src/api/composition/CompositionCollection.js

@@ -75,7 +75,9 @@ define([
             throw new Error('Event not supported by composition: ' + event);
         }
         if (!this.mutationListener) {
-            this._synchronize();
+            this.mutationListener = this.publicAPI.objects.observe(this.domainObject, '*', (newDomainObject) => {
+                this.domainObject = newDomainObject;
+            })
         }
         if (this.provider.on && this.provider.off) {
             if (event === 'add') {
@@ -132,8 +134,10 @@ define([
 
         this.listeners[event].splice(index, 1);
         if (this.listeners[event].length === 0) {
-            this._destroy();
-
+            if (this.mutationListener) {
+                this.mutationListener();
+                delete this.mutationListener;
+            }
             // Remove provider listener if this is the last callback to
             // be removed.
             if (this.provider.off && this.provider.on) {
@@ -177,9 +181,6 @@ define([
      */
     CompositionCollection.prototype.add = function (child, skipMutate) {
         if (!skipMutate) {
-            if (!this.publicAPI.composition.checkPolicy(this.domainObject, child)) {
-                throw `Object of type ${child.type} cannot be added to object of type ${this.domainObject.type}`;
-            }
             this.provider.add(this.domainObject, child.identifier);
         } else {
             this.emit('add', child);
@@ -271,19 +272,6 @@ define([
         this.remove(child, true);
     };
 
-    CompositionCollection.prototype._synchronize = function () {
-        this.mutationListener = this.publicAPI.objects.observe(this.domainObject, '*', (newDomainObject) => {
-            this.domainObject = JSON.parse(JSON.stringify(newDomainObject));
-        });
-    };
-
-    CompositionCollection.prototype._destroy = function () {
-        if (this.mutationListener) {
-            this.mutationListener();
-            delete this.mutationListener;
-        }
-    };
-
     /**
      * Emit events.
      * @private

src/api/composition/DefaultCompositionProvider.js

@@ -48,11 +48,24 @@ define([
         this.listeningTo = {};
         this.onMutation = this.onMutation.bind(this);
 
+        this.cannotContainDuplicates = this.cannotContainDuplicates.bind(this);
         this.cannotContainItself = this.cannotContainItself.bind(this);
 
+        compositionAPI.addPolicy(this.cannotContainDuplicates);
         compositionAPI.addPolicy(this.cannotContainItself);
     }
 
+    /**
+     * @private
+     */
+    DefaultCompositionProvider.prototype.cannotContainDuplicates = function (parent, child) {
+        return this.appliesTo(parent) &&
+            parent.composition.findIndex((composeeId) => {
+                return composeeId.namespace === child.identifier.namespace &&
+                    composeeId.key === child.identifier.key;
+            }) === -1;
+    }
+
     /**
      * @private
      */
@@ -186,18 +199,9 @@ define([
      * @memberof module:openmct.CompositionProvider#
      * @method add
      */
-    DefaultCompositionProvider.prototype.add = function (parent, childId) {
-        if (!this.includes(parent, childId)) {
-            parent.composition.push(childId);
-            this.publicAPI.objects.mutate(parent, 'composition', parent.composition);
-        }
-    };
-    /**
-     * @private
-     */
-    DefaultCompositionProvider.prototype.includes = function (parent, childId) {
-        return parent.composition.findIndex(composee =>
-            this.publicAPI.objects.areIdsEqual(composee, childId)) !== -1;
+    DefaultCompositionProvider.prototype.add = function (domainObject, child) {
+        throw new Error('Default Provider does not implement adding.');
+        // TODO: this needs to be synchronized via mutation
     };
 
     DefaultCompositionProvider.prototype.reorder = function (domainObject, oldIndex, newIndex) {

src/api/overlays/components/OverlayComponent.vue

@@ -92,7 +92,6 @@
             display: flex;
             flex-direction: column;
             flex: 1 1 auto;
-            height: 0; // Chrome 73 overflow bug fix
             overflow: auto;
             padding-right: $interiorMargin; // fend off scroll bar
         }

src/plugins/LADTable/LADTableViewProvider.js

@@ -21,7 +21,7 @@
  *****************************************************************************/
 
 define([
-    './components/LADTable.vue',
+    './components/LadTable.vue',
     'vue'
 ], function (
     LadTableComponent,

src/plugins/LADTable/components/LADTable.vue

@@ -41,7 +41,7 @@
 
 <script>
 import lodash from 'lodash';
-import LadRow from './LADRow.vue';
+import LadRow from './LadRow.vue';
 
 export default {
     inject: ['openmct', 'domainObject'],

src/plugins/LADTable/components/LadTableSet.vue

@@ -52,7 +52,7 @@
 
 <script>
     import lodash from 'lodash';
-    import LadRow from './LADRow.vue';
+    import LadRow from './LadRow.vue';
 
     export default {
     inject: ['openmct', 'domainObject'],

src/plugins/displayLayout/AlphanumericFormatViewProvider.js

@@ -1,77 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2018, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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([
-    './components/AlphanumericFormatView.vue',
-    'vue'
-], function (AlphanumericFormatView, Vue) {
-
-    function AlphanumericFormatViewProvider(openmct, options) {
-        function isTelemetryObject(selectionPath) {
-            let selectedObject = selectionPath[0].context.item;
-            let parentObject = selectionPath[1].context.item;
-            return parentObject && 
-                parentObject.type === 'layout' &&
-                selectedObject &&
-                openmct.telemetry.isTelemetryObject(selectedObject) &&
-                !options.showAsView.includes(selectedObject.type)
-        }
-
-        return {
-            key: 'alphanumeric-format',
-            name: 'Alphanumeric Format',
-            canView: function (selection) {
-                if (selection.length === 0 || selection[0].length === 1) {
-                    return false;
-                }
-
-                return selection.every(isTelemetryObject);
-            },
-            view: function (selection) {
-                let component;
-                return {
-                    show: function (element) {
-                        component = new Vue({
-                            provide: {
-                                openmct
-                            },
-                            components: {
-                                AlphanumericFormatView: AlphanumericFormatView.default
-                            },
-                            template: '<alphanumeric-format-view></alphanumeric-format-view>',
-                            el: element
-                        });
-                    },
-                    destroy: function () {
-                        component.$destroy();
-                        component = undefined;
-                    }
-                }
-            },
-            priority: function () {
-                return 1;
-            }
-        }
-    }
-
-    return AlphanumericFormatViewProvider;
-});

src/plugins/displayLayout/components/AlphanumericFormatView.vue

@@ -1,80 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2018, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-<template>
-    <div class="c-properties" v-if="isEditing">
-        <div class="c-properties__header">Alphanumeric Format</div>
-        <ul class="c-properties__section" v-if="!multiSelect">
-            <li class="c-properties__row">
-                <div class="c-properties__label" title="Printf formatting for the selected telemetry">
-                    <label for="telemetryPrintfFormat">Format</label>
-                </div>
-                <div class="c-properties__value">
-                    <input id="telemetryPrintfFormat" type="text" @change="formatTelemetry" :value="telemetryFormat">
-                </div>
-            </li>
-        </ul>
-        <div class="c-properties__row--span-all" v-if="multiSelect">No format to display for multiple items</div>
-    </div>
-</template>
-
-<script>
-    export default {
-        inject: ['openmct'],
-        data() {
-            let selectionPath = this.openmct.selection.get()[0];
-            return {
-                isEditing: this.openmct.editor.isEditing(),
-                telemetryFormat: selectionPath[0].context.layoutItem.format,
-                multiSelect: false
-            }
-        },
-        methods: {
-            toggleEdit(isEditing) {
-                this.isEditing = isEditing;
-            },
-            formatTelemetry(event) {
-                let selectionPath = this.openmct.selection.get()[0];
-                let newFormat = event.currentTarget.value;
-                selectionPath[0].context.updateTelemetryFormat(newFormat);
-                this.telemetryFormat = newFormat;
-            },
-            handleSelection(selection) {
-                if (selection.length === 0 || selection[0].length === 0) {
-                    return;
-                }
-
-                this.multiSelect = selection.length > 1 ? true : false;
-            }
-        },
-        mounted() {
-            this.openmct.editor.on('isEditing', this.toggleEdit);
-            this.openmct.selection.on('change', this.handleSelection);
-            this.handleSelection(this.openmct.selection.get());
-        },
-        destroyed() {
-            this.openmct.editor.off('isEditing', this.toggleEdit);
-            this.openmct.selection.off('change', this.handleSelection);
-        }
-    }
-
-</script>

src/plugins/displayLayout/components/DisplayLayout.vue

@@ -48,8 +48,7 @@
                    :multiSelect="selectedLayoutItems.length > 1"
                    @move="move"
                    @endMove="endMove"
-                   @endLineResize='endLineResize'
-                   @formatChanged='updateTelemetryFormat'>
+                   @endLineResize='endLineResize'>
         </component>
         <edit-marquee v-if='showMarquee'
                       :gridSize="gridSize"
@@ -270,63 +269,33 @@
                     _.cloneDeep(this.selectedLayoutItems).forEach(selectedItem => {
                         if (selectedItem.type === 'line-view') {
                             this.initialPositions[selectedItem.id] = [selectedItem.x, selectedItem.y, selectedItem.x2, selectedItem.y2];
-                            this.startingMinX2 = this.startingMinX2 !== undefined ? Math.min(this.startingMinX2, selectedItem.x2) : selectedItem.x2;
-                            this.startingMinY2 = this.startingMinY2 !== undefined ? Math.min(this.startingMinY2, selectedItem.y2) : selectedItem.y2;
                         } else {
                             this.initialPositions[selectedItem.id] = [selectedItem.x, selectedItem.y];
                         }
-
-                        this.startingMinX = this.startingMinX !== undefined ? Math.min(this.startingMinX, selectedItem.x) : selectedItem.x;
-                        this.startingMinY = this.startingMinY !== undefined ? Math.min(this.startingMinY, selectedItem.y) : selectedItem.y;
                     });
                 }
 
                 let layoutItems = this.layoutItems.map(item => {
                     if (this.initialPositions[item.id]) {
-                        this.updateItemPosition(item, gridDelta);
+                        let startingPosition = this.initialPositions[item.id];
+                        let [startingX, startingY, startingX2, startingY2] = startingPosition;
+                        item.x = startingX + gridDelta[0];
+                        item.y = startingY + gridDelta[1];
+
+                        if (item.x2) {
+                            item.x2 = startingX2 + gridDelta[0];
+                        }
+
+                        if (item.y2) {
+                            item.y2 = startingY2 + gridDelta[1];
+                        }
                     }
                     return item;
                 });
             },
-            updateItemPosition(item, gridDelta) {
-                let startingPosition = this.initialPositions[item.id];
-                let [startingX, startingY, startingX2, startingY2] = startingPosition;
-
-                if (this.startingMinX + gridDelta[0] >= 0) {
-                    if (item.x2 !== undefined) {
-                        if (this.startingMinX2 + gridDelta[0] >= 0) {
-                            item.x = startingX + gridDelta[0];
-                        }
-                    } else {
-                        item.x = startingX + gridDelta[0];
-                    }
-                }
-
-                if (this.startingMinY + gridDelta[1] >= 0) {
-                    if (item.y2 !== undefined) {
-                        if (this.startingMinY2 + gridDelta[1] >= 0) {
-                            item.y = startingY + gridDelta[1];
-                        }
-                    } else {
-                        item.y = startingY + gridDelta[1];
-                    }
-                }
-
-                if (item.x2 !== undefined && this.startingMinX2 + gridDelta[0] >= 0 && this.startingMinX + gridDelta[0] >= 0) {
-                    item.x2 = startingX2 + gridDelta[0];
-                }
-
-                if (item.y2 !== undefined && this.startingMinY2 + gridDelta[1] >= 0 && this.startingMinY + gridDelta[1] >= 0) {
-                    item.y2 = startingY2 + gridDelta[1];
-                }
-            },
             endMove() {
                 this.mutate('configuration.items', this.layoutItems);
                 this.initialPositions = undefined;
-                this.startingMinX = undefined;
-                this.startingMinY = undefined;
-                this.startingMinX2 = undefined;
-                this.startingMinY2 = undefined;
             },
             mutate(path, value) {
                 this.openmct.objects.mutate(this.internalDomainObject, path, value);
@@ -558,11 +527,6 @@
                     this.layoutItems.splice(itemIndex, 1);
                     this.layoutItems.splice(newIndex, 0, items[itemIndex]);
                 }
-            },
-            updateTelemetryFormat(item, format) {
-                let index = this.layoutItems.indexOf(item);
-                item.format = format;
-                this.mutate(`configuration.items[${index}]`, item);
             }
         },
         mounted() {

src/plugins/displayLayout/components/EditMarquee.vue

@@ -116,7 +116,7 @@
                 let height = Number.NEGATIVE_INFINITY;
 
                 this.selectedLayoutItems.forEach(item => {
-                    if (item.x2 !== undefined) {
+                    if (item.x2) {
                         let lineWidth = Math.abs(item.x - item.x2);
                         let lineMinX = Math.min(item.x, item.x2);
                         x = Math.min(lineMinX, x);
@@ -126,7 +126,7 @@
                         width = Math.max(item.width + item.x, width);
                     }
 
-                    if (item.y2 !== undefined) {
+                    if (item.y2) {
                         let lineHeight = Math.abs(item.y - item.y2);
                         let lineMinY = Math.min(item.y, item.y2);
                         y = Math.min(lineMinY, y);

src/plugins/displayLayout/components/SubobjectView.vue

@@ -22,7 +22,6 @@
 <template>
     <layout-frame :item="item"
                   :grid-size="gridSize"
-                  :title="domainObject && domainObject.name"
                   @move="(gridDelta) => $emit('move', gridDelta)"
                   @endMove="() => $emit('endMove')">
         <object-frame v-if="domainObject"

src/plugins/displayLayout/components/TelemetryView.vue

@@ -79,7 +79,6 @@
 
  <script>
     import LayoutFrame from './LayoutFrame.vue'
-    import printj from 'printj'
 
     const DEFAULT_TELEMETRY_DIMENSIONS = [10, 5],
           DEFAULT_POSITION = [1, 1];
@@ -144,10 +143,6 @@
                     return;
                 }
 
-                if (this.item.format) {
-                    return printj.sprintf(this.item.format, this.datum[this.valueMetadata.key]);
-                }
-
                 return this.valueFormatter && this.valueFormatter.format(this.datum);
             },
             telemetryClass() {
@@ -173,9 +168,6 @@
                 }
 
                 this.context.index = newIndex;
-            },
-            item(newItem) {
-                this.context.layoutItem = newItem;
             }
         },
         methods: {
@@ -184,8 +176,7 @@
                 let options = {
                     start: bounds.start,
                     end: bounds.end,
-                    size: 1,
-                    strategy: 'latest'
+                    size: 1
                 };
                 this.openmct.telemetry.request(this.domainObject, options)
                     .then(data => {
@@ -202,7 +193,6 @@
                 }.bind(this));
             },
             updateView(datum) {
-                // TODO: normalize datum
                 this.datum = datum;
             },
             removeSubscription() {
@@ -228,14 +218,10 @@
                 this.context = {
                     item: domainObject,
                     layoutItem: this.item,
-                    index: this.index,
-                    updateTelemetryFormat: this.updateTelemetryFormat
+                    index: this.index
                 };
                 this.removeSelectable = this.openmct.selection.selectable(
                     this.$el, this.context, this.initSelect);
-            },
-            updateTelemetryFormat(format) {
-                this.$emit('formatChanged', this.item, format);
             }
         },
         mounted() {

src/plugins/displayLayout/plugin.js

@@ -25,8 +25,6 @@ import Vue from 'vue'
 import objectUtils from '../../api/objects/object-utils.js'
 import DisplayLayoutType from './DisplayLayoutType.js'
 import DisplayLayoutToolbar from './DisplayLayoutToolbar.js'
-import AlphaNumericFormatViewProvider from './AlphaNumericFormatViewProvider.js'
-
 export default function DisplayLayoutPlugin(options) {
     return function (openmct) {
         openmct.objectViews.addProvider({
@@ -78,8 +76,7 @@ export default function DisplayLayoutPlugin(options) {
             }
         });
         openmct.types.addType('layout', DisplayLayoutType());
-        openmct.toolbars.addProvider(new DisplayLayoutToolbar(openmct, options));
-        openmct.inspectorViews.addProvider(new AlphaNumericFormatViewProvider(openmct, options));
+        openmct.toolbars.addProvider(new DisplayLayoutToolbar(openmct));
         openmct.composition.addPolicy((parent, child) => {
             if (parent.type === 'layout' && child.type === 'folder') {
                 return false;

src/plugins/filters/components/FilterField.vue

@@ -42,10 +42,7 @@
 
                 <!-- Checkbox list, NOT editing -->
                 <template v-if="filter.possibleValues && !isEditing">
-                    <span 
-                        v-if="persistedFilters[filter.comparator]">
-                        {{persistedFilters[filter.comparator].join(', ')}}
-                    </span>
+                    <span>{{persistedFilters[filter.comparator].join(', ')}}</span>
                 </template>
             </div>
         </li>

src/plugins/filters/components/FilterObject.vue

@@ -69,17 +69,16 @@ export default {
                 }
             } else {
                 if (!this.updatedFilters[key]) {
-                    this.$set(this.updatedFilters, key, {});
+                    this.updatedFilters[key] = {};
                 }
-                this.$set(this.updatedFilters[key], comparator, [value ? valueName : undefined]);
+                this.updatedFilters[key][comparator] = [value ? valueName : undefined];
             }
 
             this.$emit('updateFilters', this.keyString, this.updatedFilters);
         },
         updateTextFilter(key, comparator, value) {
             if (!this.updatedFilters[key]) {
-                this.$set(this.updatedFilters, key, {});
-                this.$set(this.updatedFilters[key], comparator, '');
+                this.updatedFilters[key] = {};
             }
             this.updatedFilters[key][comparator] = value;
             this.$emit('updateFilters', this.keyString, this.updatedFilters);

src/plugins/flexibleLayout/components/flexibleLayout.vue

@@ -113,8 +113,7 @@
 
         &__container-holder {
             display: flex;
-            flex: 1 1 100%; // Must be 100% to work
-            overflow: auto;
+            flex: 1 1 100%; // Must needs to be 100% to work
 
             // Columns by default
             flex-direction: row;

src/plugins/goToOriginalAction/goToOriginalAction.js

@@ -1,53 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2018, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-
-export default class GoToOriginalAction {
-    constructor(openmct) {
-        this.name = 'Go To Original';
-        this.description = 'Go to the original unlinked instance of this object';
-
-        this._openmct = openmct;
-    }
-    invoke(objectPath) {
-        this._openmct.objects.getOriginalPath(objectPath[0].identifier)
-            .then((originalPath) => {
-                let url = '#/browse/' + originalPath
-                    .map(function (o) {
-                        return o && this._openmct.objects.makeKeyString(o.identifier);
-                    }.bind(this))
-                    .reverse()
-                    .slice(1)
-                    .join('/');
-
-                window.location.href = url;
-            });
-    }
-    appliesTo(objectPath) {
-        let parentKeystring = objectPath[1] && this._openmct.objects.makeKeyString(objectPath[1].identifier);
-
-        if (!parentKeystring) {
-            return false;
-        }
-
-        return (parentKeystring !== objectPath[0].location);
-    }
-}

src/plugins/goToOriginalAction/plugin.js

@@ -1,28 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2018, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT 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 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.
- *****************************************************************************/
-import GoToOriginalAction from './goToOriginalAction';
-
-export default function () {
-    return function (openmct) {
-        openmct.contextMenu.registerAction(new GoToOriginalAction(openmct));
-    };
-}

src/plugins/objectMigration/Migrations.js

@@ -64,45 +64,35 @@ define([
             Object.keys(panels).forEach(key => {
                 let panel = panels[key];
                 let domainObject = childObjects[key];
-                let identifier = undefined;
 
                 if (isTelemetry(domainObject)) {
-                    // If object is a telemetry point, convert it to a plot and
-                    // replace the object in migratedObject composition with the plot.
-                    identifier = {
-                        key: uuid(),
-                        namespace: migratedObject.identifier.namespace
-                    };
-                    let plotObject = {
-                        identifier: identifier,
-                        location: domainObject.location,
-                        name: domainObject.name,
-                        type: "telemetry.plot.overlay"
-                    };
-                    let plotType = openmct.types.get('telemetry.plot.overlay');
-                    plotType.definition.initialize(plotObject);
-                    plotObject.composition.push(domainObject.identifier);
-                    openmct.objects.mutate(plotObject, 'persisted', Date.now());
-
-                    let keyString = openmct.objects.makeKeyString(domainObject.identifier);
-                    let clonedComposition = Object.assign([], migratedObject.composition);
-                    clonedComposition.forEach((identifier, index) => {
-                        if (openmct.objects.makeKeyString(identifier) === keyString) {
-                            migratedObject.composition[index] = plotObject.identifier;
-                        }
+                    items.push({
+                        width: panel.dimensions[0],
+                        height: panel.dimensions[1],
+                        x: panel.position[0],
+                        y: panel.position[1],
+                        identifier: domainObject.identifier,
+                        id: uuid(),
+                        type: 'telemetry-view',
+                        displayMode: 'all',
+                        value: openmct.telemetry.getMetadata(domainObject).getDefaultDisplayValue(),
+                        stroke: "transparent",
+                        fill: "",
+                        color: "",
+                        size: "13px"
+                    });
+                } else {
+                    items.push({
+                        width: panel.dimensions[0],
+                        height: panel.dimensions[1],
+                        x: panel.position[0],
+                        y: panel.position[1],
+                        identifier: domainObject.identifier,
+                        id: uuid(),
+                        type: 'subobject-view',
+                        hasFrame: panel.hasFrame
                     });
                 }
-
-                items.push({
-                    width: panel.dimensions[0],
-                    height: panel.dimensions[1],
-                    x: panel.position[0],
-                    y: panel.position[1],
-                    identifier: identifier || domainObject.identifier,
-                    id: uuid(),
-                    type: 'subobject-view',
-                    hasFrame: panel.hasFrame
-                });
             });
 
             migratedObject.configuration.items = items;
@@ -177,9 +167,7 @@ define([
         return [
             {
                 check(domainObject) {
-                    return domainObject.type === 'layout' &&
-                        domainObject.configuration &&
-                        domainObject.configuration.layout;
+                    return domainObject.type === 'layout' && domainObject.configuration.layout;
                 },
                 migrate(domainObject) {
                     let childObjects = {};
@@ -198,9 +186,7 @@ define([
             },
             {
                 check(domainObject) {
-                    return domainObject.type === 'telemetry.fixed' &&
-                        domainObject.configuration &&
-                        domainObject.configuration['fixed-display'];
+                    return domainObject.type === 'telemetry.fixed' && domainObject.configuration['fixed-display'];
                 },
                 migrate(domainObject) {
                     const DEFAULT_GRID_SIZE = [64, 16];
@@ -238,7 +224,6 @@ define([
             {
                 check(domainObject) {
                     return domainObject.type === 'table' &&
-                        domainObject.configuration &&
                         domainObject.configuration.table;
                 },
                 migrate(domainObject) {

src/plugins/plot/res/templates/stacked-plot.html

@@ -43,16 +43,12 @@
     <div class="l-view-section">
         <div class="c-loading--overlay loading"
              ng-show="!!currentRequest.pending"></div>
-        <div class="gl-plot child-frame u-inspectable"
+        <div class="gl-plot child-frame"
             ng-repeat="telemetryObject in telemetryObjects"
             ng-class="{
                 's-status-timeconductor-unsynced': telemetryObject
                     .getCapability('status')
                     .get('timeconductor-unsynced')
-            }"
-            mct-selectable="{
-                item: telemetryObject.useCapability('adapter'),
-                oldItem: telemetryObject
             }">
             <mct-overlay-plot domain-object="telemetryObject"></mct-overlay-plot>
         </div>

src/plugins/plot/src/configuration/Collection.js

@@ -115,13 +115,11 @@ define([
 
     Collection.prototype.remove = function (model) {
         var index = this.indexOf(model);
-
         if (index === -1) {
             throw new Error('model not found in collection.');
         }
-
-        this.emit('remove', model, index);
         this.models.splice(index, 1);
+        this.emit('remove', model, index);
     };
 
     Collection.prototype.destroy = function (model) {

src/plugins/plot/src/configuration/SeriesCollection.js

@@ -100,33 +100,19 @@ define([
         removeTelemetryObject: function (identifier) {
             var plotObject = this.plot.get('domainObject');
             if (plotObject.type === 'telemetry.plot.overlay') {
-
-                var persistedIndex = _.findIndex(plotObject.configuration.series, function (s) {
+                var index = _.findIndex(plotObject.configuration.series, function (s) {
                     return _.isEqual(identifier, s.identifier);
                 });
-
-                var configIndex = _.findIndex(this.models, function (m) {
-                    return _.isEqual(m.domainObject.identifier, identifier);
-                });
-
-                /*
-                    when cancelling out of edit mode, the config store and domain object are out of sync
-                    thus it is necesarry to check both and remove the models that are no longer in composition
-                */
-                if (persistedIndex === -1) {
-                    this.remove(this.at(configIndex));
-                } else {
-                    this.remove(this.at(persistedIndex));
-                    // Because this is triggered by a composition change, we have
-                    // to defer mutation of our plot object, otherwise we might
-                    // mutate an outdated version of the plotObject.
-                    setTimeout(function () {
-                        var newPlotObject = this.plot.get('domainObject');
-                        var cSeries = newPlotObject.configuration.series.slice();
-                        cSeries.splice(persistedIndex, 1);
-                        this.openmct.objects.mutate(newPlotObject, 'configuration.series', cSeries);
-                    }.bind(this));
-                }
+                this.remove(this.at(index));
+                // Because this is triggered by a composition change, we have
+                // to defer mutation of our plot object, otherwise we might
+                // mutate an outdated version of the plotObject.
+                setTimeout(function () {
+                    var newPlotObject = this.plot.get('domainObject');
+                    var cSeries = newPlotObject.configuration.series.slice();
+                    cSeries.splice(index, 1);
+                    this.openmct.objects.mutate(newPlotObject, 'configuration.series', cSeries);
+                }.bind(this));
             }
         },
         onSeriesAdd: function (series) {

src/plugins/plot/src/configuration/configStore.js

@@ -25,11 +25,23 @@ define([
 
     function ConfigStore() {
         this.store = {};
+        this.tracking = {};
     }
 
-    ConfigStore.prototype.deleteStore = function (id) {
-        this.store[id].destroy();
-        delete this.store[id];
+    ConfigStore.prototype.track = function (id) {
+        if (!this.tracking[id]) {
+            this.tracking[id] = 0;
+        }
+        this.tracking[id] += 1;
+    };
+
+    ConfigStore.prototype.untrack = function (id) {
+        this.tracking[id] -= 1;
+        if (this.tracking[id] <= 0) {
+            delete this.tracking[id];
+            this.store[id].destroy();
+            delete this.store[id];
+        }
     };
 
     ConfigStore.prototype.add = function (id, config) {

src/plugins/plot/src/inspector/PlotOptionsController.js

@@ -49,6 +49,7 @@ define([
     };
 
     PlotOptionsController.prototype.destroy = function () {
+        configStore.untrack(this.configId);
         this.stopListening();
         this.unlisten();
     };
@@ -59,7 +60,7 @@ define([
             this.$timeout(this.setUpScope.bind(this));
             return;
         }
-
+        configStore.track(this.configId);
         this.config = this.$scope.config = config;
         this.$scope.plotSeries = [];
 

src/plugins/plot/src/plot/MCTPlotController.js

@@ -282,19 +282,11 @@ define([
     };
 
     MCTPlotController.prototype.zoom = function (zoomDirection, zoomFactor) {
-        var currentXaxis = this.$scope.xAxis.get('displayRange'),
-            currentYaxis = this.$scope.yAxis.get('displayRange');
-
-        // when there is no plot data, the ranges can be undefined
-        // in which case we should not perform zoom
-        if (!currentXaxis || !currentYaxis) {
-            return;
-        }
-
         this.freeze();
         this.trackHistory();
-
-        var xAxisDist= (currentXaxis.max - currentXaxis.min) * zoomFactor,
+        var currentXaxis = this.$scope.xAxis.get('displayRange'),
+            currentYaxis = this.$scope.yAxis.get('displayRange'),
+            xAxisDist= (currentXaxis.max - currentXaxis.min) * zoomFactor,
             yAxisDist = (currentYaxis.max - currentYaxis.min) * zoomFactor;
 
         if (zoomDirection === 'in') {
@@ -330,19 +322,12 @@ define([
             return;
         }
 
-        let xDisplayRange = this.$scope.xAxis.get('displayRange'),
-            yDisplayRange = this.$scope.yAxis.get('displayRange');
-
-        // when there is no plot data, the ranges can be undefined
-        // in which case we should not perform zoom
-        if (!xDisplayRange || !yDisplayRange) {
-            return;
-        }
-
         this.freeze();
         window.clearTimeout(this.stillZooming);
 
-        let xAxisDist = (xDisplayRange.max - xDisplayRange.min),
+        let xDisplayRange = this.$scope.xAxis.get('displayRange'),
+            yDisplayRange = this.$scope.yAxis.get('displayRange'),
+            xAxisDist = (xDisplayRange.max - xDisplayRange.min),
             yAxisDist = (yDisplayRange.max - yDisplayRange.min),
             xDistMouseToMax = xDisplayRange.max - this.positionOverPlot.x,
             xDistMouseToMin = this.positionOverPlot.x - xDisplayRange.min,

src/plugins/plot/src/telemetry/PlotController.js

@@ -80,6 +80,8 @@ define([
             'configuration.filters',
             this.updateFiltersAndResubscribe.bind(this)
         );
+
+        this.listenTo($scope, 'filters:update', this.onFiltersUpdate, this);
     }
 
     eventHelpers.extend(PlotController.prototype);
@@ -148,6 +150,7 @@ define([
             });
             configStore.add(configId, config);
         }
+        configStore.track(configId);
         return config;
     };
 
@@ -156,8 +159,7 @@ define([
     };
 
     PlotController.prototype.destroy = function () {
-        configStore.deleteStore(this.config.id);
-
+        configStore.untrack(this.config.id);
         this.stopListening();
         if (this.checkForSize) {
             clearInterval(this.checkForSize);
@@ -263,6 +265,10 @@ define([
         });
     };
 
+    PlotController.prototype.onFiltersUpdate = function ($event, updatedFilters) {
+        this.updateFiltersAndResubscribe(updatedFilters);
+    };
+
     /**
      * Export view as JPG.
      */

src/plugins/plot/src/telemetry/StackedPlotController.js

@@ -37,6 +37,11 @@ define([
         this.exportImageService = exportImageService;
         this.$scope = $scope;
         this.cursorGuide = false;
+        this.domainObject = $scope.domainObject.useCapability('adapter');
+        
+        var currentFilters = this.domainObject.configuration.filters;
+
+        $scope.currentFilters = this.currentFilters;
 
         $scope.telemetryObjects = [];
 
@@ -79,15 +84,6 @@ define([
                     $scope.$broadcast('plot:tickWidth', _.max(tickWidthMap));
                 }
             }
-
-            function compositionReorder(reorderPlan) {
-                let oldComposition = telemetryObjects.slice();
-
-                reorderPlan.forEach((reorder) => {
-                    telemetryObjects[reorder.newIndex] = oldComposition[reorder.oldIndex];
-                });
-            }
-
             thisRequest.pending += 1;
             openmct.objects.get(domainObject.getId())
                 .then(function (obj) {
@@ -98,12 +94,10 @@ define([
                     composition = openmct.composition.get(obj);
                     composition.on('add', addChild);
                     composition.on('remove', removeChild);
-                    composition.on('reorder', compositionReorder);
                     composition.load();
                     unlisten = function () {
                         composition.off('add', addChild);
                         composition.off('remove', removeChild);
-                        composition.off('reorder', compositionReorder);
                     };
                 });
         }
@@ -121,6 +115,12 @@ define([
             }
         }
 
+        function onFilterUpdate(filters) {
+            $scope.$broadcast('filters:update', filters);
+
+            currentFilters = filters;
+        }
+
         $scope.$watch('domainObject', onDomainObjectChange);
         $scope.$watch('domainObject.getModel().composition', onCompositionChange);
 
@@ -140,6 +140,12 @@ define([
         $scope.$on('plot:highlight:update', function ($e, point) {
             $scope.$broadcast('plot:highlight:set', point);
         });
+
+        var unobserve = openmct.objects.observe(this.domainObject, 'configuration.filters', onFilterUpdate);
+
+        $scope.$on('$destroy', function () {
+            unobserve();
+        });
     }
 
     StackedPlotController.prototype.exportJPG = function () {

src/plugins/plugins.js

@@ -23,7 +23,6 @@
 define([
     'lodash',
     './utcTimeSystem/plugin',
-    './localTimeSystem/plugin',
     '../../example/generator/plugin',
     './autoflow/AutoflowTabularPlugin',
     './timeConductor/plugin',
@@ -42,12 +41,10 @@ define([
     './tabs/plugin',
     './LADTable/plugin',
     './filters/plugin',
-    './objectMigration/plugin',
-    './goToOriginalAction/plugin'
+    './objectMigration/plugin'
 ], function (
     _,
     UTCTimeSystem,
-    LocalTimeSystem,
     GeneratorPlugin,
     AutoflowPlugin,
     TimeConductorPlugin,
@@ -66,8 +63,7 @@ define([
     Tabs,
     LADTable,
     Filters,
-    ObjectMigration,
-    GoToOriginalAction
+    ObjectMigration
 ) {
     var bundleMap = {
         LocalStorage: 'platform/persistence/local',
@@ -83,7 +79,6 @@ define([
     });
 
     plugins.UTCTimeSystem = UTCTimeSystem;
-    plugins.LocalTimeSystem = LocalTimeSystem;
 
     plugins.ImportExport = ImportExport;
 
@@ -165,7 +160,6 @@ define([
     plugins.LADTable = LADTable;
     plugins.Filters = Filters;
     plugins.ObjectMigration = ObjectMigration.default;
-    plugins.GoToOriginalAction = GoToOriginalAction.default;
 
     return plugins;
 });

src/plugins/summaryWidget/src/Condition.js

@@ -70,14 +70,16 @@ define([
          */
         function onValueInput(event) {
             var elem = event.target,
-                value = isNaN(Number(elem.value)) ? elem.value : Number(elem.value),
+                value = (isNaN(elem.valueAsNumber) ? elem.value : elem.valueAsNumber),
                 inputIndex = self.valueInputs.indexOf(elem);
 
-            self.eventEmitter.emit('change', {
-                value: value,
-                property: 'values[' + inputIndex + ']',
-                index: self.index
-            });
+            if (elem.tagName.toUpperCase() === 'INPUT') {
+                self.eventEmitter.emit('change', {
+                    value: value,
+                    property: 'values[' + inputIndex + ']',
+                    index: self.index
+                });
+            }
         }
 
         this.listenTo(this.deleteButton, 'click', this.remove, this);
@@ -106,7 +108,8 @@ define([
         Object.values(this.selects).forEach(function (select) {
             $('.t-configuration', self.domElement).append(select.getDOM());
         });
-        this.listenTo($('.t-value-inputs', this.domElement), 'input', onValueInput);
+
+        this.listenTo($(this.domElement), 'input', onValueInput);
     }
 
     Condition.prototype.getDOM = function (container) {
@@ -164,9 +167,7 @@ define([
 
     /**
      * When an operation is selected, create the appropriate value inputs
-     * and add them to the view. If an operation is of type enum, create
-     * a drop-down menu instead.
-     *
+     * and add them to the view
      * @param {string} operation The key of currently selected operation
      */
     Condition.prototype.generateValueInputs = function (operation) {
@@ -175,49 +176,25 @@ define([
             inputCount,
             inputType,
             newInput,
-            index = 0,
-            emitChange = false;
+            index = 0;
 
         inputArea.html('');
         this.valueInputs = [];
-        this.config.values = [];
 
         if (evaluator.getInputCount(operation)) {
             inputCount = evaluator.getInputCount(operation);
             inputType = evaluator.getInputType(operation);
-
             while (index < inputCount) {
-                if (inputType === 'select') {
-                    newInput = $('<select>' + this.generateSelectOptions() + '</select>');
-                    emitChange = true;
-                } else {
-                    this.config.values[index] = inputType === 'number' ? 0 : '';
-                    newInput = $('<input type = "' + inputType + '" value = "' + this.config.values[index] + '"> </input>');
+                if (!this.config.values[index]) {
+                    this.config.values[index] = (inputType === 'number' ? 0 : '');
                 }
-
+                newInput = $('<input type = "' + inputType + '" value = "' + this.config.values[index] + '"> </input>');
                 this.valueInputs.push(newInput.get(0));
                 inputArea.append(newInput);
                 index += 1;
             }
-
-            if (emitChange) {
-                this.eventEmitter.emit('change', {
-                    value: Number(newInput[0].options[0].value),
-                    property: 'values[0]',
-                    index: this.index
-                });
-            }
         }
     };
 
-    Condition.prototype.generateSelectOptions = function () {
-        let telemetryMetadata = this.conditionManager.getTelemetryMetadata(this.config.object);
-        let options = '';
-        telemetryMetadata[this.config.key].enumerations.forEach(enumeration => {
-            options += '<option value="' + enumeration.value + '">'+ enumeration.string + '</option>';
-        });
-        return options;
-    };
-
     return Condition;
 });

src/plugins/summaryWidget/src/ConditionEvaluator.js

@@ -24,8 +24,7 @@ define([], function () {
          */
         this.inputTypes = {
             number: 'number',
-            string: 'text',
-            enum: 'select'
+            string: 'text'
         };
 
         /**
@@ -35,8 +34,7 @@ define([], function () {
          */
         this.inputValidators = {
             number: this.validateNumberInput,
-            string: this.validateStringInput,
-            enum: this.validateNumberInput
+            string: this.validateStringInput
         };
 
         /**
@@ -203,7 +201,7 @@ define([], function () {
                     return typeof input[0] === 'undefined';
                 },
                 text: 'is undefined',
-                appliesTo: ['string', 'number', 'enum'],
+                appliesTo: ['string', 'number'],
                 inputCount: 0,
                 getDescription: function () {
                     return ' is undefined';
@@ -214,33 +212,11 @@ define([], function () {
                     return typeof input[0] !== 'undefined';
                 },
                 text: 'is defined',
-                appliesTo: ['string', 'number', 'enum'],
+                appliesTo: ['string', 'number'],
                 inputCount: 0,
                 getDescription: function () {
                     return ' is defined';
                 }
-            },
-            enumValueIs: {
-                operation: function (input) {
-                    return input[0] === input[1];
-                },
-                text: 'is',
-                appliesTo: ['enum'],
-                inputCount: 1,
-                getDescription: function (values) {
-                    return ' == ' + values[0];
-                }
-            },
-            enumValueIsNot: {
-                operation: function (input) {
-                    return input[0] !== input[1];
-                },
-                text: 'is not',
-                appliesTo: ['enum'],
-                inputCount: 1,
-                getDescription: function (values) {
-                    return ' != ' + values[0];
-                }
             }
         };
     }
@@ -334,16 +310,13 @@ define([], function () {
             validator;
 
         if (cache[object] && typeof cache[object][key] !== 'undefined') {
-            let value = cache[object][key];
-            telemetryValue = [isNaN(Number(value)) ? value : Number(value)];
+            telemetryValue = [cache[object][key]];
         }
-
         op = this.operations[operation] && this.operations[operation].operation;
         input = telemetryValue && telemetryValue.concat(values);
         validator = op && this.inputValidators[this.operations[operation].appliesTo[0]];
-
         if (op && input && validator) {
-            if (this.operations[operation].appliesTo.length > 1) {
+            if (this.operations[operation].appliesTo.length === 2) {
                 return (this.validateNumberInput(input) || this.validateStringInput(input)) && op(input);
             } else {
                 return validator(input) && op(input);
@@ -399,7 +372,7 @@ define([], function () {
     };
 
     /**
-     * Returns true only if the given operation applies to a given type
+     * Returns true only of the given operation applies to a given type
      * @param {string} key The key of the operation
      * @param {string} type The value type to query
      * @returns {boolean} True if the condition applies, false otherwise

src/plugins/summaryWidget/src/ConditionManager.js

@@ -130,9 +130,7 @@ define ([
         this.telemetryTypesById[objectId] = {};
         Object.values(this.telemetryMetadataById[objectId]).forEach(function (valueMetadata) {
             var type;
-            if (valueMetadata.enumerations !== undefined) {
-                type = 'enum';
-            } else if (valueMetadata.hints.hasOwnProperty('range')) {
+            if (valueMetadata.hints.hasOwnProperty('range')) {
                 type = 'number';
             } else if (valueMetadata.hints.hasOwnProperty('domain')) {
                 type = 'number';
@@ -165,18 +163,11 @@ define ([
      * @param {datum} datum The new data from the telemetry source
      * @private
      */
-    ConditionManager.prototype.handleSubscriptionCallback = function (objId, telemetryDatum) {
-        this.subscriptionCache[objId] = this.createNormalizedDatum(objId, telemetryDatum);
+    ConditionManager.prototype.handleSubscriptionCallback = function (objId, datum) {
+        this.subscriptionCache[objId] = datum;
         this.eventEmitter.emit('receiveTelemetry');
     };
 
-    ConditionManager.prototype.createNormalizedDatum = function (objId, telemetryDatum) {
-        return Object.values(this.telemetryMetadataById[objId]).reduce((normalizedDatum, metadatum) => {
-            normalizedDatum[metadatum.key] = telemetryDatum[metadatum.source];
-            return normalizedDatum;
-        }, {});
-    };
-
     /**
      * Event handler for an add event in this Summary Widget's composition.
      * Sets up subscription handlers and parses its property types.
@@ -245,7 +236,6 @@ define ([
                 id.namespace === identifier.namespace;
         });
         delete this.compositionObjs[objectId];
-        delete this.subscriptionCache[objectId];
         this.subscriptions[objectId](); //unsubscribe from telemetry source
         delete this.subscriptions[objectId];
         this.eventEmitter.emit('remove', identifier);

src/plugins/summaryWidget/src/input/OperationSelect.js

@@ -110,11 +110,9 @@ define([
 
         type = self.manager.getTelemetryPropertyType(self.config.object, key);
 
-        if (type !== undefined) {
-            self.operationKeys = operations.filter(function (operation) {
-                return self.evaluator.operationAppliesTo(operation, type);
-            });
-        }
+        self.operationKeys = operations.filter(function (operation) {
+            return self.evaluator.operationAppliesTo(operation, type);
+        });
     };
 
     OperationSelect.prototype.destroy = function () {

src/plugins/summaryWidget/src/telemetry/SummaryWidgetMetadataProvider.js

@@ -38,7 +38,7 @@ define([
         return this.openmct.time.getAllTimeSystems().map(function (ts, i) {
             return {
                 key: ts.key,
-                name: ts.name,
+                name: 'UTC',
                 format: ts.timeFormat,
                 hints: {
                     domain: i
@@ -64,7 +64,7 @@ define([
             // Generally safe assumption is that we have one domain per timeSystem.
             values: this.getDomains().concat([
                 {
-                    name: 'State',
+                    name: 'state',
                     key: 'state',
                     source: 'ruleIndex',
                     format: 'enum',

src/plugins/summaryWidget/src/telemetry/operations.js

@@ -174,7 +174,7 @@ define([
                 return typeof input[0] === 'undefined';
             },
             text: 'is undefined',
-            appliesTo: ['string', 'number', 'enum'],
+            appliesTo: ['string', 'number'],
             inputCount: 0,
             getDescription: function () {
                 return ' is undefined';
@@ -185,33 +185,11 @@ define([
                 return typeof input[0] !== 'undefined';
             },
             text: 'is defined',
-            appliesTo: ['string', 'number', 'enum'],
+            appliesTo: ['string', 'number'],
             inputCount: 0,
             getDescription: function () {
                 return ' is defined';
             }
-        },
-        enumValueIs: {
-            operation: function (input) {
-                return input[0] === input[1];
-            },
-            text: 'is',
-            appliesTo: ['enum'],
-            inputCount: 1,
-            getDescription: function (values) {
-                return ' == ' + values[0];
-            }
-        },
-        enumValueIsNot: {
-            operation: function (input) {
-                return input[0] !== input[1];
-            },
-            text: 'is not',
-            appliesTo: ['enum'],
-            inputCount: 1,
-            getDescription: function (values) {
-                return ' != ' + values[0];
-            }
         }
     };
 

src/plugins/tabs/components/tabs.vue

@@ -7,8 +7,7 @@
             }">
             <div class="c-drop-hint"
                  @drop="onDrop"
-                 @dragenter="dragenter"
-                 @dragleave="dragleave">
+                 ref="dropHint">
             </div>
             <div class="c-tabs-view__empty-message"
                  v-if="!tabsList.length > 0">Drag objects here to add them to this view.</div>
@@ -198,6 +197,13 @@ export default {
 
         document.addEventListener('dragstart', this.dragstart);
         document.addEventListener('dragend', this.dragend);
+
+        let dropHint = this.$refs.dropHint;
+
+        if (dropHint) {
+            dropHint.addEventListener('dragenter', this.dragenter);
+            dropHint.addEventListener('dragleave', this.dragleave);
+        }
     },
     destroyed() {
         this.composition.off('add', this.addItem);
@@ -206,6 +212,12 @@ export default {
 
         document.removeEventListener('dragstart', this.dragstart);
         document.removeEventListener('dragend', this.dragend);
+    },
+    beforeDestroy() {
+        let dropHint = this.$refs.dropHint;
+
+        dropHint.removeEventListener('dragenter', this.dragenter);
+        dropHint.removeEventListener('dragleave', this.dragleave);
     }
 }
 </script>

src/plugins/telemetryTable/TelemetryTable.js

@@ -239,7 +239,7 @@ define([
             this.filteredRows.destroy();
             Object.keys(this.subscriptions).forEach(this.unsubscribe, this);
             this.openmct.time.off('bounds', this.refreshData);
-            this.openmct.time.off('timeSystem', this.refreshData);
+            this.openmct.time.on('timeSystem', this.refreshData);
             if (this.filterObserver) {
                 this.filterObserver();
             }

src/plugins/telemetryTable/collections/BoundedTableRowCollection.js

@@ -31,9 +31,9 @@ define(
     ) {
 
         class BoundedTableRowCollection extends SortedTableRowCollection {
-            constructor(openmct) {
+            constructor (openmct) {
                 super();
-
+                
                 this.futureBuffer = new SortedTableRowCollection();
                 this.openmct = openmct;
 
@@ -46,13 +46,12 @@ define(
                 openmct.time.on('bounds', this.bounds);
             }
 
-            addOne(item) {
-                let parsedValue = this.getValueForSortColumn(item);
+            addOne (item) {
                 // Insert into either in-bounds array, or the future buffer.
-                // Data in the future buffer will be re-evaluated for possible
+                // Data in the future buffer will be re-evaluated for possible 
                 // insertion on next bounds change
-                let beforeStartOfBounds = parsedValue < this.lastBounds.start;
-                let afterEndOfBounds = parsedValue > this.lastBounds.end;
+                let beforeStartOfBounds = this.parseTime(item.datum[this.sortOptions.key]) < this.lastBounds.start;
+                let afterEndOfBounds = this.parseTime(item.datum[this.sortOptions.key]) > this.lastBounds.end;
 
                 if (!afterEndOfBounds && !beforeStartOfBounds) {
                     return super.addOne(item);
@@ -87,13 +86,13 @@ define(
              * @fires TelemetryCollection#discarded
              * @param bounds
              */
-            bounds(bounds) {
+            bounds (bounds) {
                 let startChanged = this.lastBounds.start !== bounds.start;
                 let endChanged = this.lastBounds.end !== bounds.end;
-
+                
                 let startIndex = 0;
                 let endIndex = 0;
-
+                
                 let discarded = [];
                 let added = [];
                 let testValue = {
@@ -136,13 +135,9 @@ define(
                 }
             }
 
-            getValueForSortColumn(row) {
-                return this.parseTime(row.datum[this.sortOptions.key]);
-            }
-
             destroy() {
                 this.openmct.time.off('bounds', this.bounds);
             }
         }
-        return BoundedTableRowCollection;
-    });
+    return BoundedTableRowCollection;
+});

src/plugins/telemetryTable/collections/SortedTableRowCollection.js

@@ -60,7 +60,7 @@ define(
                     if (rowsAdded.length > 0) {
                         this.emit('add', rowsAdded);
                     }
-                    this.dupeCheck = true;
+                    this.dupeCheck = true;    
                 } else {
                     let wasAdded = this.addOne(rows);
                     if (wasAdded) {
@@ -115,10 +115,11 @@ define(
                 if (this.rows.length === 0) {
                     return 0;
                 }
-
-                const testRowValue = this.getValueForSortColumn(testRow);
-                const firstValue = this.getValueForSortColumn(this.rows[0]);
-                const lastValue = this.getValueForSortColumn(this.rows[this.rows.length - 1]);
+                
+                const sortOptionsKey = this.sortOptions.key;
+                const testRowValue = testRow.datum[sortOptionsKey];
+                const firstValue = this.rows[0].datum[sortOptionsKey];
+                const lastValue = this.rows[this.rows.length - 1].datum[sortOptionsKey];
 
                 lodashFunction = lodashFunction || _.sortedIndex;
 
@@ -132,7 +133,7 @@ define(
                         return 0;
                     } else {
                         return lodashFunction(rows, testRow, (thisRow) => {
-                            return this.getValueForSortColumn(thisRow);
+                            return thisRow.datum[sortOptionsKey];
                         });
                     }
                 } else {
@@ -146,7 +147,7 @@ define(
                     } else {
                         // Use a custom comparison function to support descending sort.
                         return lodashFunction(rows, testRow, (thisRow) => {
-                            const thisRowValue = this.getValueForSortColumn(thisRow);
+                            const thisRowValue = thisRow.datum[sortOptionsKey];
                             if (testRowValue === thisRowValue) {
                                 return EQUAL;
                             } else if (testRowValue < thisRowValue) {
@@ -205,7 +206,7 @@ define(
                     this.emit('sort');
                 }
                 // Return duplicate to avoid direct modification of underlying object
-                return Object.assign({}, this.sortOptions);
+                return Object.assign({}, this.sortOptions); 
             }
 
             removeAllRowsForObject(objectKeyString) {
@@ -217,32 +218,25 @@ define(
                     }
                     return true;
                 });
-
                 this.emit('remove', removed);
             }
 
-            getValueForSortColumn(row) {
-                return row.datum[this.sortOptions.key];
-            }
-
             remove(removedRows) {
                 this.rows = this.rows.filter(row => {
                     return removedRows.indexOf(row) === -1;
                 });
-
                 this.emit('remove', removedRows);
             }
 
-            getRows() {
+            getRows () {
                 return this.rows;
             }
 
             clear() {
                 let removedRows = this.rows;
                 this.rows = [];
-
                 this.emit('remove', removedRows);
             }
         }
-        return SortedTableRowCollection;
-    });
+    return SortedTableRowCollection;
+});

src/plugins/telemetryTable/components/table.vue

@@ -78,7 +78,7 @@
     <!-- Content table -->
     <div class="c-table__body-w c-telemetry-table__body-w js-telemetry-table__body-w" @scroll="scroll" :style="{ 'max-width': widthWithScroll}">
         <div class="c-telemetry-table__scroll-forcer" :style="{ width: totalWidth + 'px' }"></div>
-        <table class="c-table__body c-telemetry-table__body js-telemetry-table__content"
+        <table class="c-table__body c-telemetry-table__body"
                :style="{ height: totalHeight + 'px'}">
             <tbody>
                 <telemetry-table-row v-for="(row, rowIndex) in visibleRows"
@@ -284,7 +284,7 @@ import _ from 'lodash';
 const VISIBLE_ROW_COUNT = 100;
 const ROW_HEIGHT = 17;
 const RESIZE_POLL_INTERVAL = 200;
-const AUTO_SCROLL_TRIGGER_HEIGHT = 100;
+const AUTO_SCROLL_TRIGGER_HEIGHT = 20;
 const RESIZE_HOT_ZONE = 10;
 const MOVE_TRIGGER_WAIT = 500;
 const VERTICAL_SCROLL_WIDTH = 30;
@@ -364,48 +364,42 @@ export default {
     },
     methods: {
         updateVisibleRows() {
-            if (!this.updatingView) {
-                this.updatingView = true;
-                requestAnimationFrame(()=> {
 
-                    let start = 0;
-                    let end = VISIBLE_ROW_COUNT;
-                    let filteredRows = this.table.filteredRows.getRows();
-                    let filteredRowsLength = filteredRows.length;
+            let start = 0;
+            let end = VISIBLE_ROW_COUNT;
+            let filteredRows = this.table.filteredRows.getRows();
+            let filteredRowsLength = filteredRows.length;
 
-                    if (filteredRowsLength < VISIBLE_ROW_COUNT) {
-                        end = filteredRowsLength;
-                    } else {
-                        let firstVisible = this.calculateFirstVisibleRow();
-                        let lastVisible = this.calculateLastVisibleRow();
-                        let totalVisible = lastVisible - firstVisible;
+            this.totalHeight = this.rowHeight * filteredRowsLength - 1;
 
-                        let numberOffscreen = VISIBLE_ROW_COUNT - totalVisible;
-                        start = firstVisible - Math.floor(numberOffscreen / 2);
-                        end = lastVisible + Math.ceil(numberOffscreen / 2);
+            if (filteredRowsLength < VISIBLE_ROW_COUNT) {
+                end = filteredRowsLength;
+            } else {
+                let firstVisible = this.calculateFirstVisibleRow();
+                let lastVisible = this.calculateLastVisibleRow();
+                let totalVisible = lastVisible - firstVisible;
 
-                        if (start < 0) {
-                            start = 0;
-                            end = Math.min(VISIBLE_ROW_COUNT, filteredRowsLength);
-                        } else if (end >= filteredRowsLength) {
-                            end = filteredRowsLength;
-                            start = end - VISIBLE_ROW_COUNT + 1;
-                        }
-                    }
-                    this.rowOffset = start;
-                    this.visibleRows = filteredRows.slice(start, end);
+                let numberOffscreen = VISIBLE_ROW_COUNT - totalVisible;
+                start = firstVisible - Math.floor(numberOffscreen / 2);
+                end = lastVisible + Math.ceil(numberOffscreen / 2);
 
-                    this.updatingView = false;
-                });
+                if (start < 0) {
+                    start = 0;
+                    end = Math.min(VISIBLE_ROW_COUNT, filteredRowsLength);
+                } else if (end >= filteredRowsLength) {
+                    end = filteredRowsLength;
+                    start = end - VISIBLE_ROW_COUNT + 1;
+                }
             }
+            this.rowOffset = start;
+            this.visibleRows = filteredRows.slice(start, end);
         },
         calculateFirstVisibleRow() {
-            let scrollTop = this.scrollable.scrollTop;
-            return Math.floor(scrollTop / this.rowHeight);
+            return Math.floor(this.scrollable.scrollTop / this.rowHeight);
         },
         calculateLastVisibleRow() {
-            let scrollBottom = this.scrollable.scrollTop + this.scrollable.offsetHeight;
-            return Math.ceil(scrollBottom / this.rowHeight);
+            let bottomScroll = this.scrollable.scrollTop + this.scrollable.offsetHeight;
+            return Math.floor(bottomScroll / this.rowHeight);
         },
         updateHeaders() {
             this.headers = this.table.configuration.getVisibleHeaders();
@@ -449,70 +443,71 @@ export default {
             }
             this.table.sortBy(this.sortOptions);
         },
-        scroll () {
-            this.updateVisibleRows();
-            this.synchronizeScrollX();
+        scroll() {
+            if (!this.processingScroll) {
+                this.processingScroll = true;
+                requestAnimationFrame(()=> {
+                    this.updateVisibleRows();
+                    this.synchronizeScrollX();
 
-            if (this.shouldSnapToBottom()) {
-                this.autoScroll = true;
-            } else {
-                // If user scrolls away from bottom, disable auto-scroll.
-                // Auto-scroll will be re-enabled if user scrolls to bottom again.
-                this.autoScroll = false;
+                    if (this.shouldSnapToBottom()) {
+                        this.autoScroll = true;
+                    } else {
+                        // If user scrolls away from bottom, disable auto-scroll.
+                        // Auto-scroll will be re-enabled if user scrolls to bottom again.
+                        this.autoScroll = false;
+                    }
+                    this.processingScroll = false;
+                });
             }
         },
         shouldSnapToBottom() {
             return this.scrollable.scrollTop >= (this.scrollable.scrollHeight - this.scrollable.offsetHeight - AUTO_SCROLL_TRIGGER_HEIGHT);
         },
         scrollToBottom() {
-            this.scrollable.scrollTop = Number.MAX_SAFE_INTEGER;
+            this.scrollable.scrollTop = this.scrollable.scrollHeight;
         },
         synchronizeScrollX() {
             this.headersHolderEl.scrollLeft = this.scrollable.scrollLeft;
         },
         filterChanged(columnKey) {
             this.table.filteredRows.setColumnFilter(columnKey, this.filters[columnKey]);
-            this.setHeight();
         },
         clearFilter(columnKey) {
             this.filters[columnKey] = '';
             this.table.filteredRows.setColumnFilter(columnKey, '');
-            this.setHeight();
         },
-        rowsAdded (rows) {
-            this.setHeight();
-
+        rowsAdded(rows) {
             let sizingRow;
             if (Array.isArray(rows)) {
                 sizingRow = rows[0];
             } else {
                 sizingRow = rows;
             }
-
             if (!this.sizingRows[sizingRow.objectKeyString]) {
                 this.sizingRows[sizingRow.objectKeyString] = sizingRow;
                 this.$nextTick().then(this.calculateColumnWidths);
             }
 
-            if (this.autoScroll) {
-                this.scrollToBottom();
+            if (!this.updatingView) {
+                this.updatingView = true;
+                requestAnimationFrame(()=> {
+                    this.updateVisibleRows();
+                    if (this.autoScroll) {
+                        this.$nextTick().then(this.scrollToBottom);
+                    }
+                    this.updatingView = false;
+                });
             }
-
-            this.updateVisibleRows();
         },
-        rowsRemoved (rows) {
-            this.setHeight();
-            this.updateVisibleRows();
-        },
-        /**
-         * Calculates height based on total number of rows, and sets table height.
-         */
-        setHeight() {
-            let filteredRowsLength = this.table.filteredRows.getRows().length;
-            this.totalHeight = this.rowHeight * filteredRowsLength - 1;
-            // Set element height directly to avoid having to wait for Vue to update DOM 
-            // which causes subsequent scroll to use an out of date height.
-            this.contentTable.style.height = this.totalHeight + 'px'; 
+        rowsRemoved(rows) {
+            if (!this.updatingView) {
+                this.updatingView = true;
+                requestAnimationFrame(()=> {
+                    this.updateVisibleRows();
+                    this.updatingView = false;
+                });
+            }
         },
         exportAsCSV() {
             const headerKeys = Object.keys(this.headers);
@@ -600,11 +595,7 @@ export default {
                     this.calculateTableSize();
                     // On some resize events scrollTop is reset to 0. Possibly due to a transition we're using?
                     // Need to preserve scroll position in this case.
-                    if (this.autoScroll) {
-                        this.scrollToBottom();
-                    } else {
-                        this.scrollable.scrollTop = scrollTop;
-                    }
+                    this.scrollable.scrollTop = scrollTop;
                     width = el.clientWidth;
                     height = el.clientHeight;
                 }
@@ -617,9 +608,6 @@ export default {
         this.filterChanged = _.debounce(this.filterChanged, 500);
     },
     mounted() {
-        this.rowsAdded = _.throttle(this.rowsAdded, 200);
-        this.rowsRemoved = _.throttle(this.rowsRemoved, 200);
-        this.scroll = _.throttle(this.scroll, 100);
 
         this.table.on('object-added', this.addObject);
         this.table.on('object-removed', this.removeObject);
@@ -633,7 +621,6 @@ export default {
         //Default sort
         this.sortOptions = this.table.filteredRows.sortBy();
         this.scrollable = this.$el.querySelector('.js-telemetry-table__body-w');
-        this.contentTable = this.$el.querySelector('.js-telemetry-table__content');
         this.sizingTable = this.$el.querySelector('.js-telemetry-table__sizing');
         this.headersHolderEl = this.$el.querySelector('.js-table__headers-w');
 

src/styles-new/_about.scss

@@ -54,11 +54,10 @@
 
     &:after {
         // App logo
-        $d: 25%;
-        top: $d;
-        right: $d;
-        bottom: $d;
-        left: $d;
+        top: 0;
+        right: 15%;
+        bottom: 0;
+        left: 15%;
     }
 }
 
@@ -76,20 +75,12 @@
 
     &__image,
     &__text {
-        flex: 1 1 auto;
-    }
-
-    &__image {
-        height: 35%;
+        height: 50%;
+        flex: 1 1 0;
     }
 
     &__text {
-        height: 65%;
         overflow: auto;
-        > * + * {
-            border-top: 1px solid $colorInteriorBorder;
-            margin-top: 1em;
-        }
     }
 
     &--licenses {
@@ -116,7 +107,7 @@
 
     h1, h2, h3 {
         font-weight: normal;
-        margin-bottom: .25em;
+        margin-bottom: 1em;
     }
 
     h1 {

src/styles-new/_controls.scss

@@ -393,11 +393,6 @@ select {
             color: $colorMenuIc;
             font-size: 1em;
             margin-right: $interiorMargin;
-            min-width: 1em;
-        }
-
-        &:not([class]):before {
-             content: ''; // Add this element so that menu items without an icon still indent properly
         }
     }
 }

src/styles-new/_legacy-plots.scss

@@ -51,22 +51,6 @@ mct-plot {
     }
 }
 
-.is-editing {
-    .gl-plot.child-frame {
-        &:hover {
-            background: rgba($editUIColorBg, 0.1);
-            box-shadow: inset rgba($editUIColorBg, 0.8) 0 0 0 1px;
-        }
-
-        &[s-selected] {
-            border: 1px solid $editUIColorFg !important;
-            color: $editUIColorFg !important;
-            box-shadow: $editFrameSelectedShdw;
-            z-index: 2;
-        }
-    }
-}
-
 .gl-plot {
     color: $colorPlotFg;
     display: flex;
@@ -564,10 +548,3 @@ mct-plot {
         top: 0; bottom: 0;
     }
 }
-
-.s-status-timeconductor-unsynced {
-    .t-object-alert.t-alert-unsynced {
-        @extend .icon-alert-triangle;
-        color: $colorPausedBg;
-    }
-}

src/styles-new/_mixins.scss

@@ -425,13 +425,12 @@
     // Background is displayed on hover
     // Padding is included to facilitate a bigger hit area
     // Make the icon bigger relative to its container
-    $pLR: 4px;
-    $pTB: 4px;
-
     @include cControl();
     background: none;
     box-shadow: none;
     cursor: pointer;
+    $pLR: 4px;
+    $pTB: 4px;
     transition: $transOut;
     border-radius: $controlCr;
     padding: $pTB $pLR;

src/styles-new/core.scss

@@ -33,4 +33,3 @@
 @import "table";
 @import "legacy";
 @import "legacy-plots";
-@import "legacy-messages";

src/ui/components/ObjectFrame.vue

@@ -26,8 +26,8 @@
             'has-complex-content': complexContent
         }">
         <div class="c-so-view__header">
-            <div class="c-so-view__header__icon" :class="cssClass"></div>
-            <div class="c-so-view__header__name">
+            <div class="c-so-view__header__name"
+                 :class="cssClass">
                 {{ domainObject && domainObject.name }}
             </div>
             <context-menu-drop-down
@@ -63,16 +63,12 @@
             align-items: center;
             margin-bottom: $interiorMargin;
 
-            &__icon {
-                flex: 0 0 auto;
-                margin-right: $interiorMarginSm;
-                opacity: 0.5;
-            }
-
             &__name {
                 @include headerFont(1em);
-                @include ellipsize();
-                flex: 0 1 auto;
+                display: flex;
+                &:before {
+                    margin-right: $interiorMarginSm;
+                }
             }
         }
 
@@ -92,6 +88,19 @@
             }
         }
 
+        &__name {
+            @include ellipsize();
+            @include headerFont(1.2em);
+            flex: 0 1 auto;
+
+            &:before {
+                // Object type icon
+                flex: 0 0 auto;
+                margin-right: $interiorMarginSm;
+                opacity: 0.5;
+            }
+        }
+
         &__local-controls {
             position: absolute;
             top: $interiorMargin; right: $interiorMargin;

src/ui/components/ObjectView.vue

@@ -34,10 +34,7 @@ export default {
         this.currentObject = this.object;
         this.updateView();
         this.$el.addEventListener('dragover', this.onDragOver);
-        this.$el.addEventListener('drop', this.editIfEditable, {
-            capture: true
-        });
-        this.$el.addEventListener('drop', this.addObjectToParent);
+        this.$el.addEventListener('drop', this.onDrop);
     },
     methods: {
         clear() {
@@ -57,10 +54,6 @@ export default {
                 this.removeSelectable();
                 delete this.removeSelectable;
             }
-
-            if (this.composition) {
-                this.composition._destroy();
-            }
         },
         invokeEditModeHandler(editMode) {
             this.currentView.onEditModeChange(editMode);
@@ -74,28 +67,25 @@ export default {
             if (!this.currentObject) {
                 return;
             }
-            
-            this.composition = this.openmct.composition.get(this.currentObject);
-            if (this.composition) {
-                this.composition._synchronize();
-                this.loadComposition();
-            }
-
             this.viewContainer = document.createElement('div');
             this.viewContainer.classList.add('c-object-view','u-contents');
             this.$el.append(this.viewContainer);
-            let provider = this.getViewProvider();
+            let provider = this.openmct.objectViews.getByProviderKey(this.viewKey);
+
             if (!provider) {
-                return;
+                provider = this.openmct.objectViews.get(this.currentObject)[0];
+                if (!provider) {
+                    return;
+                }
             }
 
+
             if (provider.edit && this.showEditView) {
                 if (this.openmct.editor.isEditing()) {
                     this.currentView = provider.edit(this.currentObject);
                 } else {
                     this.currentView = provider.view(this.currentObject, false);    
                 }
-
                 this.openmct.editor.on('isEditing', this.toggleEditView);
                 this.releaseEditModeHandler = () => this.openmct.editor.off('isEditing', this.toggleEditView);
             } else {
@@ -123,10 +113,6 @@ export default {
                 delete this.removeSelectable;
             }
 
-            if (this.composition) {
-                this.composition._destroy();
-            }
-
             this.currentObject = object;
             this.unlisten = this.openmct.objects.observe(this.currentObject, '*', (mutatedObject) => {
                 this.currentObject = mutatedObject;
@@ -135,9 +121,6 @@ export default {
             this.viewKey = viewKey;
             this.updateView(immediatelySelect);
         },
-        loadComposition() {
-            return this.composition.load();
-        },
         getSelectionContext() {
             if (this.currentView.getSelectionContext) {
                 return this.currentView.getSelectionContext();
@@ -150,37 +133,15 @@ export default {
                 event.preventDefault();
             }
         },
-        addObjectToParent(event) {
-            if (this.hasComposableDomainObject(event) && this.composition) {
+        onDrop(event) {
+            if (this.hasComposableDomainObject(event)) {
                 let composableDomainObject = this.getComposableDomainObject(event);
-                this.loadComposition().then(() => {
-                    this.composition.add(composableDomainObject);
-                });
-
+                this.currentObject.composition.push(composableDomainObject.identifier);
+                this.openmct.objects.mutate(this.currentObject, 'composition', this.currentObject.composition);
                 event.preventDefault();
                 event.stopPropagation();
             }
         },
-        getViewProvider() {
-            let provider = this.openmct.objectViews.getByProviderKey(this.viewKey);
-
-            if (!provider) {
-                provider = this.openmct.objectViews.get(this.currentObject)[0];
-                if (!provider) {
-                    return;
-                }
-            }
-            return provider;
-        },
-        editIfEditable(event) {
-            let provider = this.getViewProvider();
-            if (provider && 
-                provider.canEdit &&
-                provider.canEdit(this.currentObject) &&
-                !this.openmct.editor.isEditing()) {
-                    this.openmct.editor.edit();
-            }
-        },
         hasComposableDomainObject(event) {
             return event.dataTransfer.types.includes('openmct/composable-domain-object')
         },

src/ui/inspector/Elements.vue

@@ -67,7 +67,6 @@
     }
 </style>
 <script>
-import _ from 'lodash';
 import Search from '../components/search.vue';
 import ObjectLabel from '../components/ObjectLabel.vue';
 
@@ -83,8 +82,7 @@ export default {
             isEditing: this.openmct.editor.isEditing(),
             parentObject: undefined,
             currentSearch: '',
-            isDragging: false,
-            selection: []
+            isDragging: false
         }
     },
     mounted() {
@@ -101,10 +99,6 @@ export default {
             this.showSelection(this.openmct.selection.get());
         },
         showSelection(selection) {
-            if (_.isEqual(this.selection, selection)) {
-                return;
-            }
-            this.selection = selection;
             this.elements = [];
             this.elementsCache = {};
             this.listeners = [];

src/ui/inspector/InspectorViews.vue

@@ -25,6 +25,10 @@ import _ from 'lodash';
         },
         methods: {
             updateSelection(selection) {
+                if (_.isEqual(this.selection, selection)) {
+                    return;
+                }
+
                 this.selection = selection;
 
                 if (this.selectedViews) {
@@ -34,6 +38,10 @@ import _ from 'lodash';
                     this.$el.innerHTML = '';
                 }
 
+                if (selection.length > 1) {
+                    return;
+                }
+
                 this.selectedViews = this.openmct.inspectorViews.get(selection);
                 this.selectedViews.forEach(selectedView => {
                     let viewContainer = document.createElement('div');

src/ui/layout/AboutDialog.vue

@@ -1,24 +1,23 @@
 <template>
 <div class="c-about c-about--splash">
-    <div class="c-about__image c-splash-image"></div>
+    <div v-if="branding.aboutHtml" class="s-text l-content" v-html="branding.aboutHtml"></div>
+    <div v-else class="c-about__image c-splash-image"></div>
+
     <div class="c-about__text s-text">
-        <div class="c-about__text__element" v-if="branding.aboutHtml" v-html="branding.aboutHtml"></div>
-        <div class="c-about__text__element">
-            <h1 class="l-title s-title">Open MCT</h1>
-            <div class="l-description s-description">
-                <p>Open MCT, Copyright &copy; 2014-2019, United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All rights reserved.</p>
-                <p>Open MCT 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 <a target="_blank" href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>.</p>
-                <p>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.</p>
-                <p>Open MCT includes source code licensed under additional open source licenses. See the Open Source Licenses file included with this distribution or <a @click="showLicenses">click here for third party licensing information</a>.</p>
-            </div>
-            <h2>Version Information</h2>
-            <ul class="t-info l-info s-info">
-                <li>Version: {{buildInfo.version || 'Unknown'}}</li>
-                <li>Build Date: {{buildInfo.buildDate || 'Unknown'}}</li>
-                <li>Revision: {{buildInfo.revision || 'Unknown'}}</li>
-                <li>Branch: {{buildInfo.branch || 'Unknown'}}</li>
-            </ul>
+        <h1 class="l-title s-title">Open MCT</h1>
+        <div class="l-description s-description">
+	        <p>Open MCT, Copyright &copy; 2014-2019, United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All rights reserved.</p>
+	        <p>Open MCT 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 <a target="_blank" href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>.</p>
+	        <p>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.</p>
+	        <p>Open MCT includes source code licensed under additional open source licenses. See the Open Source Licenses file included with this distribution or <a @click="showLicenses">click here for third party licensing information</a>.</p>
         </div>
+        <h2>Version Information</h2>
+        <ul class="t-info l-info s-info">
+            <li>Version: {{buildInfo.version || 'Unknown'}}</li>
+            <li>Build Date: {{buildInfo.buildDate || 'Unknown'}}</li>
+            <li>Revision: {{buildInfo.revision || 'Unknown'}}</li>
+            <li>Branch: {{buildInfo.branch || 'Unknown'}}</li>
+        </ul>
     </div>
 </div>
 </template>

src/ui/layout/BrowseBar.vue

@@ -289,14 +289,10 @@ const PLACEHOLDER_OBJECT = {};
 
         &__nav-to-parent-button {
             // This is an icon-button
-            $p: $interiorMargin;
+            $p: $interiorMarginLg;
             margin-right: $interiorMargin;
             padding-left: $p;
             padding-right: $p;
-
-            .is-editing & {
-                display: none;
-            }
         }
 
         &__object-name--w {

src/ui/layout/Layout.vue

@@ -64,6 +64,7 @@
         &__status {
             background: $colorStatusBarBg;
             color: $colorStatusBarFg;
+            height: 24px;
             padding: $interiorMarginSm;
         }
 
@@ -74,7 +75,6 @@
                 // For mobile, collapse button becomes menu icon
                 body.mobile & {
                     @include cClickIconButton();
-                    color: $colorKey !important;
                     position: absolute;
                     right: -2 * nth($shellPanePad, 2); // Needs to be -1 * when pane is collapsed
                     top: 0;
@@ -186,7 +186,6 @@
         &__main-container {
             // Wrapper for main views
             flex: 1 1 auto !important;
-            height: 0; // Chrome 73 overflow bug fix
             overflow: auto;
         }
 

src/ui/layout/mct-tree.vue

@@ -52,12 +52,13 @@
 
         &__tree {
             flex: 1 1 auto;
-            height: 0; // Chrome 73 overflow bug fix
+            height: 100%;
         }
     }
 
     .c-tree {
         @include userSelectNone();
+        height: 100%; // Chrome 73 overflow bug fix
         overflow-x: hidden;
         overflow-y: auto;
         padding-right: $interiorMargin;
@@ -222,23 +223,18 @@
                         
                         let context = child.object.getCapability('context'),
                             object = child.object.useCapability('adapter'),
-                            objectPath = [],
-                            navigateToParent;
+                            objectPath = [];
 
                         if (context) {
                             objectPath = context.getPath().slice(1)
                                 .map(oldObject => oldObject.useCapability('adapter'))
-                                .reverse();
-                            navigateToParent = '/browse/' + objectPath.slice(1)
-                                .map((parent) => this.openmct.objects.makeKeyString(parent.identifier))
-                                .join('/');
+                                .reverse();  
                         }
 
                         return {
                             id: this.openmct.objects.makeKeyString(object.identifier),
                             object,
-                            objectPath,
-                            navigateToParent
+                            objectPath
                         }
                     });
                 });

src/ui/layout/pane.vue

@@ -194,8 +194,8 @@
                 /********************************* STYLES FOR DESKTOP COLLAPSED PANES, ALL ORIENTATIONS */
                 $d: nth($splitterBtnD, 1);
                 flex-basis: $d;
-                min-width: $d;
-                min-height: $d;
+                min-width: $d !important;
+                min-height: $d !important;
 
                 > .l-pane__handle {
                     display: none;

src/ui/layout/tree-item.vue

@@ -70,18 +70,17 @@
                 this.domainObject = newObject;
             });
             this.$once('hook:destroyed', removeListener);
-
             if (this.openmct.composition.get(this.node.object)) {
                 this.hasChildren = true;
             }
 
             this.openmct.router.on('change:path', this.highlightIfNavigated);
         },
-        destroyed() {
-            this.openmct.router.off('change:path', this.highlightIfNavigated);
+        destroy() {
             if (this.composition) {
                 this.composition.off('add', this.addChild);
                 this.composition.off('remove', this.removeChild);
+                this.openmct.router.off('change:path', this.highlightIfNavigated);
                 delete this.composition;
             }
         },

src/ui/mixins/context-menu-gesture.js

@@ -18,7 +18,7 @@ export default {
 
         this.objectPath.forEach(object => {
             if (object) {
-                this.$once('hook:destroyed',
+                this.$once('hook:destroy',
                     this.openmct.objects.observe(object, '*', updateObject.bind(this, object)))
             }
         });

src/ui/preview/Preview.vue

@@ -33,8 +33,7 @@
             </div>
             <div class="l-browse-bar__end">
                 <div class="l-browse-bar__actions">
-                    <button v-if="notebookEnabled"
-                        class="l-browse-bar__actions__edit c-button icon-notebook" 
+                    <button class="l-browse-bar__actions__edit c-button icon-notebook" 
                         title="New Notebook entry" 
                         @click="snapshot">
                     </button>
@@ -102,21 +101,16 @@
 
             return {
                 domainObject: domainObject,
-                type: type,
-                notebookEnabled: false
+                type: type
             };
         },
         mounted() {
             let viewProvider = this.openmct.objectViews.get(this.domainObject)[0];
             this.view = viewProvider.view(this.domainObject);
             this.view.show(this.$refs.objectView, false);
-
-            if (this.openmct.types.get('notebook')) {
-                this.notebookSnapshot = new NotebookSnapshot(this.openmct);
-                this.notebookEnabled = true;
-            }
+            this.notebookSnapshot = new NotebookSnapshot(this.openmct);
         },
-        destroyed() {
+        destroy() {
             this.view.destroy();
         }
     }

webpack.config.js

@@ -35,7 +35,6 @@ const webpackConfig = {
             "bourbon": "bourbon.scss",
             "vue": path.join(__dirname, "node_modules/vue/dist/vue.js"),
             "d3-scale": path.join(__dirname, "node_modules/d3-scale/build/d3-scale.min.js"),
-            "printj": path.join(__dirname, "node_modules/printj/dist/printj.min.js"),
             "styles": path.join(__dirname, "src/styles-new")
         }
     },