Version 1.4.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmct",
-  "version": "1.4.1-SNAPSHOT",
+  "version": "1.4.0",
   "description": "The Open MCT core platform",
   "dependencies": {},
   "devDependencies": {

platform/commonUI/browse/bundle.js

@@ -143,8 +143,8 @@ define([
                             "$window"
                         ],
                         "group": "windowing",
-                        "priority": 10,
-                        "cssClass": "icon-new-window"
+                        "cssClass": "icon-new-window",
+                        "priority": "preferred"
                     }
                 ],
                 "runs": [

platform/commonUI/edit/bundle.js

@@ -139,9 +139,7 @@ define([
                         ],
                         "description": "Edit",
                         "category": "view-control",
-                        "cssClass": "major icon-pencil",
-                        "group": "action",
-                        "priority": 10
+                        "cssClass": "major icon-pencil"
                     },
                     {
                         "key": "properties",
@@ -152,8 +150,6 @@ define([
                         "implementation": PropertiesAction,
                         "cssClass": "major icon-pencil",
                         "name": "Edit Properties...",
-                        "group": "action",
-                        "priority": 10,
                         "description": "Edit properties of this object.",
                         "depends": [
                             "dialogService"

platform/commonUI/general/res/templates/label.html

@@ -20,12 +20,12 @@
  at runtime from the About dialog for additional information.
 -->
 <div class="c-object-label"
-     ng-class="{ 'is-status--missing': model.status === 'missing' }"
+     ng-class="{ 'is-missing': model.status === 'missing' }"
 >
     <div class="c-object-label__type-icon {{type.getCssClass()}}"
          ng-class="{ 'l-icon-link':location.isLink() }"
     >
-        <span class="is-status__indicator" title="This item is missing or suspect"></span>
+        <span class="is-missing__indicator" title="This item is missing"></span>
     </div>
     <div class='c-object-label__name'>{{model.name}}</div>
 </div>

platform/entanglement/bundle.js

@@ -22,6 +22,7 @@
 
 define([
     "./src/actions/MoveAction",
+    "./src/actions/CopyAction",
     "./src/actions/LinkAction",
     "./src/actions/SetPrimaryLocationAction",
     "./src/services/LocatingCreationDecorator",
@@ -36,6 +37,7 @@ define([
     "./src/services/LocationService"
 ], function (
     MoveAction,
+    CopyAction,
     LinkAction,
     SetPrimaryLocationAction,
     LocatingCreationDecorator,
@@ -64,8 +66,6 @@ define([
                         "description": "Move object to another location.",
                         "cssClass": "icon-move",
                         "category": "contextual",
-                        "group": "action",
-                        "priority": 9,
                         "implementation": MoveAction,
                         "depends": [
                             "policyService",
@@ -73,14 +73,28 @@ define([
                             "moveService"
                         ]
                     },
+                    {
+                        "key": "copy",
+                        "name": "Duplicate",
+                        "description": "Duplicate object to another location.",
+                        "cssClass": "icon-duplicate",
+                        "category": "contextual",
+                        "implementation": CopyAction,
+                        "depends": [
+                            "$log",
+                            "policyService",
+                            "locationService",
+                            "copyService",
+                            "dialogService",
+                            "notificationService"
+                        ]
+                    },
                     {
                         "key": "link",
                         "name": "Create Link",
                         "description": "Create Link to object in another location.",
                         "cssClass": "icon-link",
                         "category": "contextual",
-                        "group": "action",
-                        "priority": 7,
                         "implementation": LinkAction,
                         "depends": [
                             "policyService",

platform/entanglement/src/actions/CopyAction.js

@@ -0,0 +1,168 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, 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(
+    ['./AbstractComposeAction', './CancelError'],
+    function (AbstractComposeAction, CancelError) {
+
+        /**
+         * The CopyAction is available from context menus and allows a user to
+         * deep copy an object to another location of their choosing.
+         *
+         * @implements {Action}
+         * @constructor
+         * @memberof platform/entanglement
+         */
+        function CopyAction(
+            $log,
+            policyService,
+            locationService,
+            copyService,
+            dialogService,
+            notificationService,
+            context
+        ) {
+            this.dialog = undefined;
+            this.notification = undefined;
+            this.dialogService = dialogService;
+            this.notificationService = notificationService;
+            this.$log = $log;
+            //Extend the behaviour of the Abstract Compose Action
+            AbstractComposeAction.call(
+                this,
+                policyService,
+                locationService,
+                copyService,
+                context,
+                "Duplicate",
+                "To a Location"
+            );
+        }
+
+        CopyAction.prototype = Object.create(AbstractComposeAction.prototype);
+
+        /**
+         * Updates user about progress of copy. Should not be invoked by
+         * client code under any circumstances.
+         *
+         * @private
+         * @param phase
+         * @param totalObjects
+         * @param processed
+         */
+        CopyAction.prototype.progress = function (phase, totalObjects, processed) {
+            /*
+             Copy has two distinct phases. In the first phase a copy plan is
+             made in memory. During this phase of execution, the user is
+             shown a blocking 'modal' dialog.
+
+             In the second phase, the copying is taking place, and the user
+             is shown non-invasive banner notifications at the bottom of the screen.
+             */
+            if (phase.toLowerCase() === 'preparing' && !this.dialog) {
+                this.dialog = this.dialogService.showBlockingMessage({
+                    title: "Preparing to copy objects",
+                    hint: "Do not navigate away from this page or close this browser tab while this message is displayed.",
+                    unknownProgress: true,
+                    severity: "info"
+                });
+            } else if (phase.toLowerCase() === "copying") {
+                if (this.dialog) {
+                    this.dialog.dismiss();
+                }
+
+                if (!this.notification) {
+                    this.notification = this.notificationService
+                        .notify({
+                            title: "Copying objects",
+                            unknownProgress: false,
+                            severity: "info"
+                        });
+                }
+
+                this.notification.model.progress = (processed / totalObjects) * 100;
+                this.notification.model.title = ["Copied ", processed, "of ",
+                    totalObjects, "objects"].join(" ");
+            }
+        };
+
+        /**
+         * Executes the CopyAction. The CopyAction uses the default behaviour of
+         * the AbstractComposeAction, but extends it to support notification
+         * updates of progress on copy.
+         */
+        CopyAction.prototype.perform = function () {
+            var self = this;
+
+            function success(domainObject) {
+                var domainObjectName = domainObject.model.name;
+
+                self.notification.dismiss();
+                self.notificationService.info(domainObjectName + " copied successfully.");
+            }
+
+            function error(errorDetails) {
+                // No need to notify user of their own cancellation
+                if (errorDetails instanceof CancelError) {
+                    return;
+                }
+
+                var errorDialog,
+                    errorMessage = {
+                        title: "Error copying objects.",
+                        severity: "error",
+                        hint: errorDetails.message,
+                        minimized: true, // want the notification to be minimized initially (don't show banner)
+                        options: [{
+                            label: "OK",
+                            callback: function () {
+                                errorDialog.dismiss();
+                            }
+                        }]
+                    };
+
+                self.dialog.dismiss();
+                if (self.notification) {
+                    self.notification.dismiss(); // Clear the progress notification
+                }
+
+                self.$log.error("Error copying objects. ", errorDetails);
+                //Show a minimized notification of error for posterity
+                self.notificationService.notify(errorMessage);
+                //Display a blocking message
+                errorDialog = self.dialogService.showBlockingMessage(errorMessage);
+
+            }
+
+            function notification(details) {
+                self.progress(details.phase, details.totalObjects, details.processed);
+            }
+
+            return AbstractComposeAction.prototype.perform.call(this)
+                .then(success, error, notification);
+        };
+
+        CopyAction.appliesTo = AbstractComposeAction.appliesTo;
+
+        return CopyAction;
+    }
+);

platform/entanglement/test/actions/CopyActionSpec.js

@@ -0,0 +1,243 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, 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/CopyAction',
+        '../services/MockCopyService',
+        '../DomainObjectFactory'
+    ],
+    function (CopyAction, MockCopyService, domainObjectFactory) {
+
+        describe("Copy Action", function () {
+
+            var copyAction,
+                policyService,
+                locationService,
+                locationServicePromise,
+                copyService,
+                context,
+                selectedObject,
+                selectedObjectContextCapability,
+                currentParent,
+                newParent,
+                notificationService,
+                notification,
+                dialogService,
+                mockDialog,
+                mockLog,
+                abstractComposePromise,
+                domainObject = {model: {name: "mockObject"}},
+                progress = {
+                    phase: "copying",
+                    totalObjects: 10,
+                    processed: 1
+                };
+
+            beforeEach(function () {
+                policyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                policyService.allow.and.returnValue(true);
+
+                selectedObjectContextCapability = jasmine.createSpyObj(
+                    'selectedObjectContextCapability',
+                    [
+                        'getParent'
+                    ]
+                );
+
+                selectedObject = domainObjectFactory({
+                    name: 'selectedObject',
+                    model: {
+                        name: 'selectedObject'
+                    },
+                    capabilities: {
+                        context: selectedObjectContextCapability
+                    }
+                });
+
+                currentParent = domainObjectFactory({
+                    name: 'currentParent'
+                });
+
+                selectedObjectContextCapability
+                    .getParent
+                    .and.returnValue(currentParent);
+
+                newParent = domainObjectFactory({
+                    name: 'newParent'
+                });
+
+                locationService = jasmine.createSpyObj(
+                    'locationService',
+                    [
+                        'getLocationFromUser'
+                    ]
+                );
+
+                locationServicePromise = jasmine.createSpyObj(
+                    'locationServicePromise',
+                    [
+                        'then'
+                    ]
+                );
+
+                abstractComposePromise = jasmine.createSpyObj(
+                    'abstractComposePromise',
+                    [
+                        'then'
+                    ]
+                );
+
+                abstractComposePromise.then.and.callFake(function (success, error, notify) {
+                    notify(progress);
+                    success(domainObject);
+                });
+
+                locationServicePromise.then.and.callFake(function (callback) {
+                    callback(newParent);
+
+                    return abstractComposePromise;
+                });
+
+                locationService
+                    .getLocationFromUser
+                    .and.returnValue(locationServicePromise);
+
+                dialogService = jasmine.createSpyObj('dialogService',
+                    ['showBlockingMessage']
+                );
+
+                mockDialog = jasmine.createSpyObj("dialog", ["dismiss"]);
+                dialogService.showBlockingMessage.and.returnValue(mockDialog);
+
+                notification = jasmine.createSpyObj('notification',
+                    ['dismiss', 'model']
+                );
+
+                notificationService = jasmine.createSpyObj('notificationService',
+                    ['notify', 'info']
+                );
+
+                notificationService.notify.and.returnValue(notification);
+
+                mockLog = jasmine.createSpyObj('log', ['error']);
+
+                copyService = new MockCopyService();
+            });
+
+            describe("with context from context-action", function () {
+                beforeEach(function () {
+                    context = {
+                        domainObject: selectedObject
+                    };
+
+                    copyAction = new CopyAction(
+                        mockLog,
+                        policyService,
+                        locationService,
+                        copyService,
+                        dialogService,
+                        notificationService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(copyAction).toBeDefined();
+                });
+
+                describe("when performed it", function () {
+                    beforeEach(function () {
+                        spyOn(copyAction, 'progress').and.callThrough();
+                        copyAction.perform();
+                    });
+
+                    it("prompts for location", function () {
+                        expect(locationService.getLocationFromUser)
+                            .toHaveBeenCalledWith(
+                                "Duplicate selectedObject To a Location",
+                                "Duplicate To",
+                                jasmine.any(Function),
+                                currentParent
+                            );
+                    });
+
+                    it("waits for location and handles cancellation by user", function () {
+                        expect(locationServicePromise.then)
+                            .toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
+                    });
+
+                    it("copies object to selected location", function () {
+                        locationServicePromise
+                            .then
+                            .calls.mostRecent()
+                            .args[0](newParent);
+
+                        expect(copyService.perform)
+                            .toHaveBeenCalledWith(selectedObject, newParent);
+                    });
+
+                    it("notifies the user of progress", function () {
+                        expect(notificationService.info).toHaveBeenCalled();
+                    });
+
+                    it("notifies the user with name of object copied", function () {
+                        expect(notificationService.info)
+                            .toHaveBeenCalledWith("mockObject copied successfully.");
+                    });
+                });
+            });
+
+            describe("with context from drag-drop", function () {
+                beforeEach(function () {
+                    context = {
+                        selectedObject: selectedObject,
+                        domainObject: newParent
+                    };
+
+                    copyAction = new CopyAction(
+                        mockLog,
+                        policyService,
+                        locationService,
+                        copyService,
+                        dialogService,
+                        notificationService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(copyAction).toBeDefined();
+                });
+
+                it("performs copy immediately", function () {
+                    copyAction.perform();
+                    expect(copyService.perform)
+                        .toHaveBeenCalledWith(selectedObject, newParent);
+                });
+            });
+        });
+    }
+);

platform/import-export/bundle.js

@@ -47,8 +47,6 @@ define([
                             "implementation": ExportAsJSONAction,
                             "category": "contextual",
                             "cssClass": "icon-export",
-                            "group": "json",
-                            "priority": 2,
                             "depends": [
                                 "openmct",
                                 "exportService",
@@ -63,8 +61,6 @@ define([
                             "implementation": ImportAsJSONAction,
                             "category": "contextual",
                             "cssClass": "icon-import",
-                            "group": "json",
-                            "priority": 2,
                             "depends": [
                                 "exportService",
                                 "identifierService",

src/MCT.js

@@ -46,7 +46,6 @@ define([
     './api/Branding',
     './plugins/licenses/plugin',
     './plugins/remove/plugin',
-    './plugins/duplicate/plugin',
     'vue'
 ], function (
     EventEmitter,
@@ -74,7 +73,6 @@ define([
     BrandingAPI,
     LicensesPlugin,
     RemoveActionPlugin,
-    DuplicateActionPlugin,
     Vue
 ) {
     /**
@@ -244,11 +242,7 @@ define([
 
         this.overlays = new OverlayAPI.default();
 
-        this.menus = new api.MenuAPI(this);
-
-        this.actions = new api.ActionsAPI(this);
-
-        this.status = new api.StatusAPI(this);
+        this.contextMenu = new api.ContextMenuRegistry();
 
         this.router = new ApplicationRouter();
 
@@ -265,7 +259,6 @@ define([
         this.install(LegacyIndicatorsPlugin());
         this.install(LicensesPlugin.default());
         this.install(RemoveActionPlugin.default());
-        this.install(DuplicateActionPlugin.default());
         this.install(this.plugins.FolderView());
         this.install(this.plugins.Tabs());
         this.install(ImageryPlugin.default());
@@ -278,7 +271,6 @@ define([
         this.install(this.plugins.URLTimeSettingsSynchronizer());
         this.install(this.plugins.NotificationIndicator());
         this.install(this.plugins.NewFolderAction());
-        this.install(this.plugins.ViewDatumAction());
     }
 
     MCT.prototype = Object.create(EventEmitter.prototype);

src/adapter/actions/LegacyActionAdapter.js

@@ -35,5 +35,5 @@ export default function LegacyActionAdapter(openmct, legacyActions) {
 
     legacyActions.filter(contextualCategoryOnly)
         .map(LegacyAction => new LegacyContextMenuAction(openmct, LegacyAction))
-        .forEach(openmct.actions.register);
+        .forEach(openmct.contextMenu.registerAction);
 }

src/adapter/actions/LegacyContextMenuAction.js

@@ -31,8 +31,6 @@ export default class LegacyContextMenuAction {
         this.description = LegacyAction.definition.description;
         this.cssClass = LegacyAction.definition.cssClass;
         this.LegacyAction = LegacyAction;
-        this.group = LegacyAction.definition.group;
-        this.priority = LegacyAction.definition.priority;
     }
 
     invoke(objectPath) {

src/api/actions/ActionCollection.js

@@ -1,189 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 EventEmitter from 'EventEmitter';
-import _ from 'lodash';
-
-class ActionCollection extends EventEmitter {
-    constructor(applicableActions, objectPath, view, openmct, skipEnvironmentObservers) {
-        super();
-
-        this.applicableActions = applicableActions;
-        this.openmct = openmct;
-        this.objectPath = objectPath;
-        this.view = view;
-        this.skipEnvironmentObservers = skipEnvironmentObservers;
-        this.objectUnsubscribes = [];
-
-        let debounceOptions = {
-            leading: false,
-            trailing: true
-        };
-
-        this._updateActions = _.debounce(this._updateActions.bind(this), 150, debounceOptions);
-        this._update = _.debounce(this._update.bind(this), 150, debounceOptions);
-
-        if (!skipEnvironmentObservers) {
-            this._observeObjectPath();
-            this.openmct.editor.on('isEditing', this._updateActions);
-        }
-
-        this._initializeActions();
-    }
-
-    disable(actionKeys) {
-        actionKeys.forEach(actionKey => {
-            if (this.applicableActions[actionKey]) {
-                this.applicableActions[actionKey].isDisabled = true;
-            }
-        });
-        this._update();
-    }
-
-    enable(actionKeys) {
-        actionKeys.forEach(actionKey => {
-            if (this.applicableActions[actionKey]) {
-                this.applicableActions[actionKey].isDisabled = false;
-            }
-        });
-        this._update();
-    }
-
-    hide(actionKeys) {
-        actionKeys.forEach(actionKey => {
-            if (this.applicableActions[actionKey]) {
-                this.applicableActions[actionKey].isHidden = true;
-            }
-        });
-        this._update();
-    }
-
-    show(actionKeys) {
-        actionKeys.forEach(actionKey => {
-            if (this.applicableActions[actionKey]) {
-                this.applicableActions[actionKey].isHidden = false;
-            }
-        });
-        this._update();
-    }
-
-    destroy() {
-        super.removeAllListeners();
-
-        if (!this.skipEnvironmentObservers) {
-            this.objectUnsubscribes.forEach(unsubscribe => {
-                unsubscribe();
-            });
-
-            this.openmct.editor.off('isEditing', this._updateActions);
-        }
-
-        this.emit('destroy', this.view);
-    }
-
-    getVisibleActions() {
-        let actionsArray = Object.keys(this.applicableActions);
-        let visibleActions = [];
-
-        actionsArray.forEach(actionKey => {
-            let action = this.applicableActions[actionKey];
-
-            if (!action.isHidden) {
-                visibleActions.push(action);
-            }
-        });
-
-        return visibleActions;
-    }
-
-    getStatusBarActions() {
-        let actionsArray = Object.keys(this.applicableActions);
-        let statusBarActions = [];
-
-        actionsArray.forEach(actionKey => {
-            let action = this.applicableActions[actionKey];
-
-            if (action.showInStatusBar && !action.isDisabled && !action.isHidden) {
-                statusBarActions.push(action);
-            }
-        });
-
-        return statusBarActions;
-    }
-
-    getActionsObject() {
-        return this.applicableActions;
-    }
-
-    _update() {
-        this.emit('update', this.applicableActions);
-    }
-
-    _observeObjectPath() {
-        let actionCollection = this;
-
-        function updateObject(oldObject, newObject) {
-            Object.assign(oldObject, newObject);
-
-            actionCollection._updateActions();
-        }
-
-        this.objectPath.forEach(object => {
-            if (object) {
-                let unsubscribe = this.openmct.objects.observe(object, '*', updateObject.bind(this, object));
-
-                this.objectUnsubscribes.push(unsubscribe);
-            }
-        });
-    }
-
-    _initializeActions() {
-        Object.keys(this.applicableActions).forEach(key => {
-            this.applicableActions[key].callBack = () => {
-                return this.applicableActions[key].invoke(this.objectPath, this.view);
-            };
-        });
-    }
-
-    _updateActions() {
-        let newApplicableActions = this.openmct.actions._applicableActions(this.objectPath, this.view);
-
-        this.applicableActions = this._mergeOldAndNewActions(this.applicableActions, newApplicableActions);
-        this._initializeActions();
-        this._update();
-    }
-
-    _mergeOldAndNewActions(oldActions, newActions) {
-        let mergedActions = {};
-        Object.keys(newActions).forEach(key => {
-            if (oldActions[key]) {
-                mergedActions[key] = oldActions[key];
-            } else {
-                mergedActions[key] = newActions[key];
-            }
-        });
-
-        return mergedActions;
-    }
-}
-
-export default ActionCollection;

src/api/actions/ActionsAPI.js

@@ -1,144 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 EventEmitter from 'EventEmitter';
-import ActionCollection from './ActionCollection';
-import _ from 'lodash';
-
-class ActionsAPI extends EventEmitter {
-    constructor(openmct) {
-        super();
-
-        this._allActions = {};
-        this._actionCollections = new WeakMap();
-        this._openmct = openmct;
-
-        this._groupOrder = ['windowing', 'undefined', 'view', 'action', 'json'];
-
-        this.register = this.register.bind(this);
-        this.get = this.get.bind(this);
-        this._applicableActions = this._applicableActions.bind(this);
-        this._updateCachedActionCollections = this._updateCachedActionCollections.bind(this);
-    }
-
-    register(actionDefinition) {
-        this._allActions[actionDefinition.key] = actionDefinition;
-    }
-
-    get(objectPath, view) {
-        if (view) {
-
-            return this._getCachedActionCollection(objectPath, view) || this._newActionCollection(objectPath, view, true);
-        } else {
-
-            return this._newActionCollection(objectPath, view, true);
-        }
-    }
-
-    updateGroupOrder(groupArray) {
-        this._groupOrder = groupArray;
-    }
-
-    _get(objectPath, view) {
-        let actionCollection = this._newActionCollection(objectPath, view);
-
-        this._actionCollections.set(view, actionCollection);
-        actionCollection.on('destroy', this._updateCachedActionCollections);
-
-        return actionCollection;
-    }
-
-    _getCachedActionCollection(objectPath, view) {
-        let cachedActionCollection = this._actionCollections.get(view);
-
-        return cachedActionCollection;
-    }
-
-    _newActionCollection(objectPath, view, skipEnvironmentObservers) {
-        let applicableActions = this._applicableActions(objectPath, view);
-
-        return new ActionCollection(applicableActions, objectPath, view, this._openmct, skipEnvironmentObservers);
-    }
-
-    _updateCachedActionCollections(key) {
-        if (this._actionCollections.has(key)) {
-            let actionCollection = this._actionCollections.get(key);
-            actionCollection.off('destroy', this._updateCachedActionCollections);
-
-            this._actionCollections.delete(key);
-        }
-    }
-
-    _applicableActions(objectPath, view) {
-        let actionsObject = {};
-
-        let keys = Object.keys(this._allActions).filter(key => {
-            let actionDefinition = this._allActions[key];
-
-            if (actionDefinition.appliesTo === undefined) {
-                return true;
-            } else {
-                return actionDefinition.appliesTo(objectPath, view);
-            }
-        });
-
-        keys.forEach(key => {
-            let action = _.clone(this._allActions[key]);
-
-            actionsObject[key] = action;
-        });
-
-        return actionsObject;
-    }
-
-    _groupAndSortActions(actionsArray) {
-        if (!Array.isArray(actionsArray) && typeof actionsArray === 'object') {
-            actionsArray = Object.keys(actionsArray).map(key => actionsArray[key]);
-        }
-
-        let actionsObject = {};
-        let groupedSortedActionsArray = [];
-
-        function sortDescending(a, b) {
-            return b.priority - a.priority;
-        }
-
-        actionsArray.forEach(action => {
-            if (actionsObject[action.group] === undefined) {
-                actionsObject[action.group] = [action];
-            } else {
-                actionsObject[action.group].push(action);
-            }
-        });
-
-        this._groupOrder.forEach(group => {
-            let groupArray = actionsObject[group];
-
-            if (groupArray) {
-                groupedSortedActionsArray.push(groupArray.sort(sortDescending));
-            }
-        });
-
-        return groupedSortedActionsArray;
-    }
-}
-
-export default ActionsAPI;

src/api/actions/ActionsAPISpec.js

@@ -1,113 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 ActionsAPI from './ActionsAPI';
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-
-describe('The Actions API', () => {
-    let openmct;
-    let actionsAPI;
-    let mockAction;
-    let mockObjectPath;
-    let mockViewContext1;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        actionsAPI = new ActionsAPI(openmct);
-        mockAction = {
-            name: 'Test Action',
-            key: 'test-action',
-            cssClass: 'test-action',
-            description: 'This is a test action',
-            group: 'action',
-            priority: 9,
-            appliesTo: (objectPath, view = {}) => {
-                if (view.getViewContext) {
-                    let viewContext = view.getViewContext();
-
-                    return viewContext.onlyAppliesToTestCase;
-                } else if (objectPath.length) {
-                    return objectPath[0].type === 'fake-folder';
-                }
-
-                return false;
-            },
-            invoke: () => {
-            }
-        };
-        mockObjectPath = [
-            {
-                name: 'mock folder',
-                type: 'fake-folder',
-                identifier: {
-                    key: 'mock-folder',
-                    namespace: ''
-                }
-            },
-            {
-                name: 'mock parent folder',
-                type: 'fake-folder',
-                identifier: {
-                    key: 'mock-parent-folder',
-                    namespace: ''
-                }
-            }
-        ];
-        mockViewContext1 = {
-            getViewContext: () => {
-                return {
-                    onlyAppliesToTestCase: true
-                };
-            }
-        };
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    describe("register method", () => {
-        it("adds action to ActionsAPI", () => {
-            actionsAPI.register(mockAction);
-
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let action = actionCollection.getActionsObject()[mockAction.key];
-
-            expect(action.key).toEqual(mockAction.key);
-            expect(action.name).toEqual(mockAction.name);
-        });
-    });
-
-    describe("get method", () => {
-        beforeEach(() => {
-            actionsAPI.register(mockAction);
-        });
-
-        it("returns an object with relevant actions when invoked with objectPath only", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let action = actionCollection.getActionsObject()[mockAction.key];
-
-            expect(action.key).toEqual(mockAction.key);
-            expect(action.name).toEqual(mockAction.name);
-        });
-    });
-});

src/api/api.js

@@ -28,10 +28,9 @@ define([
     './telemetry/TelemetryAPI',
     './indicators/IndicatorAPI',
     './notifications/NotificationAPI',
-    './Editor',
-    './menu/MenuAPI',
-    './actions/ActionsAPI',
-    './status/StatusAPI'
+    './contextMenu/ContextMenuAPI',
+    './Editor'
+
 ], function (
     TimeAPI,
     ObjectAPI,
@@ -40,10 +39,8 @@ define([
     TelemetryAPI,
     IndicatorAPI,
     NotificationAPI,
-    EditorAPI,
-    MenuAPI,
-    ActionsAPI,
-    StatusAPI
+    ContextMenuAPI,
+    EditorAPI
 ) {
     return {
         TimeAPI: TimeAPI,
@@ -54,8 +51,6 @@ define([
         IndicatorAPI: IndicatorAPI,
         NotificationAPI: NotificationAPI.default,
         EditorAPI: EditorAPI,
-        MenuAPI: MenuAPI.default,
-        ActionsAPI: ActionsAPI.default,
-        StatusAPI: StatusAPI.default
+        ContextMenuRegistry: ContextMenuAPI.default
     };
 });

src/api/contextMenu/ContextMenu.vue

@@ -0,0 +1,24 @@
+<template>
+<div class="c-menu">
+    <ul>
+        <li
+            v-for="action in actions"
+            :key="action.name"
+            :class="action.cssClass"
+            :title="action.description"
+            @click="action.invoke(objectPath)"
+        >
+            {{ action.name }}
+        </li>
+        <li v-if="actions.length === 0">
+            No actions defined.
+        </li>
+    </ul>
+</div>
+</template>
+
+<script>
+export default {
+    inject: ['actions', 'objectPath']
+};
+</script>

src/api/contextMenu/ContextMenuAPI.js

@@ -0,0 +1,159 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, 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 ContextMenuComponent from './ContextMenu.vue';
+import Vue from 'vue';
+
+/**
+ * The ContextMenuAPI allows the addition of new context menu actions, and for the context menu to be launched from
+ * custom HTML elements.
+ * @interface ContextMenuAPI
+ * @memberof module:openmct
+ */
+class ContextMenuAPI {
+    constructor() {
+        this._allActions = [];
+        this._activeContextMenu = undefined;
+
+        this._hideActiveContextMenu = this._hideActiveContextMenu.bind(this);
+        this.registerAction = this.registerAction.bind(this);
+    }
+
+    /**
+     * Defines an item to be added to context menus. Allows specification of text, appearance, and behavior when
+     * selected. Applicabilioty can be restricted by specification of an `appliesTo` function.
+     *
+     * @interface ContextMenuAction
+     * @memberof module:openmct
+     * @property {string} name the human-readable name of this view
+     * @property {string} description a longer-form description (typically
+     *           a single sentence or short paragraph) of this kind of view
+     * @property {string} cssClass the CSS class to apply to labels for this
+     *           view (to add icons, for instance)
+     * @property {string} key unique key to identify the context menu action
+     *           (used in custom context menu eg table rows, to identify which actions to include)
+     * @property {boolean} hideInDefaultMenu optional flag to hide action from showing in the default context menu (tree item)
+     */
+    /**
+     * @method appliesTo
+     * @memberof module:openmct.ContextMenuAction#
+     * @param {DomainObject[]} objectPath the path of the object that the context menu has been invoked on.
+     * @returns {boolean} true if the action applies to the objects specified in the 'objectPath', otherwise false.
+     */
+    /**
+     * Code to be executed when the action is selected from a context menu
+     * @method invoke
+     * @memberof module:openmct.ContextMenuAction#
+     * @param {DomainObject[]} objectPath the path of the object to invoke the action on.
+     */
+    /**
+     * @param {ContextMenuAction} actionDefinition
+     */
+    registerAction(actionDefinition) {
+        this._allActions.push(actionDefinition);
+    }
+
+    /**
+     * @private
+     */
+    _showContextMenuForObjectPath(objectPath, x, y, actionsToBeIncluded) {
+
+        let applicableActions = this._allActions.filter((action) => {
+
+            if (actionsToBeIncluded) {
+                if (action.appliesTo === undefined && actionsToBeIncluded.includes(action.key)) {
+                    return true;
+                }
+
+                return action.appliesTo(objectPath, actionsToBeIncluded) && actionsToBeIncluded.includes(action.key);
+            } else {
+                if (action.appliesTo === undefined) {
+                    return true;
+                }
+
+                return action.appliesTo(objectPath) && !action.hideInDefaultMenu;
+            }
+        });
+
+        if (this._activeContextMenu) {
+            this._hideActiveContextMenu();
+        }
+
+        this._activeContextMenu = this._createContextMenuForObject(objectPath, applicableActions);
+        this._activeContextMenu.$mount();
+        document.body.appendChild(this._activeContextMenu.$el);
+
+        let position = this._calculatePopupPosition(x, y, this._activeContextMenu.$el);
+        this._activeContextMenu.$el.style.left = `${position.x}px`;
+        this._activeContextMenu.$el.style.top = `${position.y}px`;
+
+        document.addEventListener('click', this._hideActiveContextMenu);
+    }
+
+    /**
+     * @private
+     */
+    _calculatePopupPosition(eventPosX, eventPosY, menuElement) {
+        let menuDimensions = menuElement.getBoundingClientRect();
+        let overflowX = (eventPosX + menuDimensions.width) - document.body.clientWidth;
+        let overflowY = (eventPosY + menuDimensions.height) - document.body.clientHeight;
+
+        if (overflowX > 0) {
+            eventPosX = eventPosX - overflowX;
+        }
+
+        if (overflowY > 0) {
+            eventPosY = eventPosY - overflowY;
+        }
+
+        return {
+            x: eventPosX,
+            y: eventPosY
+        };
+    }
+    /**
+     * @private
+     */
+    _hideActiveContextMenu() {
+        document.removeEventListener('click', this._hideActiveContextMenu);
+        document.body.removeChild(this._activeContextMenu.$el);
+        this._activeContextMenu.$destroy();
+        this._activeContextMenu = undefined;
+    }
+
+    /**
+     * @private
+     */
+    _createContextMenuForObject(objectPath, actions) {
+        return new Vue({
+            components: {
+                ContextMenu: ContextMenuComponent
+            },
+            provide: {
+                actions: actions,
+                objectPath: objectPath
+            },
+            template: '<ContextMenu></ContextMenu>'
+        });
+    }
+}
+export default ContextMenuAPI;

src/api/menu/MenuAPI.js

@@ -1,67 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 Menu from './menu.js';
-
-/**
- * The MenuAPI allows the addition of new context menu actions, and for the context menu to be launched from
- * custom HTML elements.
- * @interface MenuAPI
- * @memberof module:openmct
- */
-
-class MenuAPI {
-    constructor(openmct) {
-        this.openmct = openmct;
-
-        this.showMenu = this.showMenu.bind(this);
-        this._clearMenuComponent = this._clearMenuComponent.bind(this);
-        this._showObjectMenu = this._showObjectMenu.bind(this);
-    }
-
-    showMenu(x, y, actions) {
-        if (this.menuComponent) {
-            this.menuComponent.dismiss();
-        }
-
-        let options = {
-            x,
-            y,
-            actions
-        };
-
-        this.menuComponent = new Menu(options);
-        this.menuComponent.once('destroy', this._clearMenuComponent);
-    }
-
-    _clearMenuComponent() {
-        this.menuComponent = undefined;
-        delete this.menuComponent;
-    }
-
-    _showObjectMenu(objectPath, x, y, actionsToBeIncluded) {
-        let applicableActions = this.openmct.actions._groupedAndSortedObjectActions(objectPath, actionsToBeIncluded);
-
-        this.showMenu(x, y, applicableActions);
-    }
-}
-export default MenuAPI;

src/api/menu/MenuAPISpec.js

@@ -1,125 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 MenuAPI from './MenuAPI';
-import Menu from './menu';
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-
-describe ('The Menu API', () => {
-    let openmct;
-    let menuAPI;
-    let actionsArray;
-    let x;
-    let y;
-    let result;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        menuAPI = new MenuAPI(openmct);
-        actionsArray = [
-            {
-                name: 'Test Action 1',
-                cssClass: 'test-css-class-1',
-                description: 'This is a test action',
-                callBack: () => {
-                    result = 'Test Action 1 Invoked';
-                }
-            },
-            {
-                name: 'Test Action 2',
-                cssClass: 'test-css-class-2',
-                description: 'This is a test action',
-                callBack: () => {
-                    result = 'Test Action 2 Invoked';
-                }
-            }
-        ];
-        x = 8;
-        y = 16;
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    describe("showMenu method", () => {
-        it("creates an instance of Menu when invoked", () => {
-            menuAPI.showMenu(x, y, actionsArray);
-
-            expect(menuAPI.menuComponent).toBeInstanceOf(Menu);
-        });
-
-        describe("creates a menu component", () => {
-            let menuComponent;
-            let vueComponent;
-
-            beforeEach(() => {
-                menuAPI.showMenu(x, y, actionsArray);
-                vueComponent = menuAPI.menuComponent.component;
-                menuComponent = document.querySelector(".c-menu");
-
-                spyOn(vueComponent, '$destroy');
-            });
-
-            it("renders a menu component in the expected x and y coordinates", () => {
-                let boundingClientRect = menuComponent.getBoundingClientRect();
-                let left = boundingClientRect.left;
-                let top = boundingClientRect.top;
-
-                expect(left).toEqual(x);
-                expect(top).toEqual(y);
-            });
-
-            it("with all the actions passed in", () => {
-                expect(menuComponent).toBeDefined();
-
-                let listItems = menuComponent.children[0].children;
-
-                expect(listItems.length).toEqual(actionsArray.length);
-            });
-
-            it("with click-able menu items, that will invoke the correct callBacks", () => {
-                let listItem1 = menuComponent.children[0].children[0];
-
-                listItem1.click();
-
-                expect(result).toEqual("Test Action 1 Invoked");
-            });
-
-            it("dismisses the menu when action is clicked on", () => {
-                let listItem1 = menuComponent.children[0].children[0];
-
-                listItem1.click();
-
-                let menu = document.querySelector('.c-menu');
-
-                expect(menu).toBeNull();
-            });
-
-            it("invokes the destroy method when menu is dismissed", () => {
-                document.body.click();
-
-                expect(vueComponent.$destroy).toHaveBeenCalled();
-            });
-        });
-    });
-});

src/api/menu/components/Menu.vue

@@ -1,52 +0,0 @@
-<template>
-<div class="c-menu">
-    <ul v-if="actions.length && actions[0].length">
-        <template
-            v-for="(actionGroups, index) in actions"
-        >
-            <li
-                v-for="action in actionGroups"
-                :key="action.name"
-                :class="[action.cssClass, action.isDisabled ? 'disabled' : '']"
-                :title="action.description"
-                @click="action.callBack"
-            >
-                {{ action.name }}
-            </li>
-            <div
-                v-if="index !== actions.length - 1"
-                :key="index"
-                class="c-menu__section-separator"
-            >
-            </div>
-            <li
-                v-if="actionGroups.length === 0"
-                :key="index"
-            >
-                No actions defined.
-            </li>
-        </template>
-    </ul>
-
-    <ul v-else>
-        <li
-            v-for="action in actions"
-            :key="action.name"
-            :class="action.cssClass"
-            :title="action.description"
-            @click="action.callBack"
-        >
-            {{ action.name }}
-        </li>
-        <li v-if="actions.length === 0">
-            No actions defined.
-        </li>
-    </ul>
-</div>
-</template>
-
-<script>
-export default {
-    inject: ['actions']
-};
-</script>

src/api/menu/menu.js

@@ -1,94 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 EventEmitter from 'EventEmitter';
-import MenuComponent from './components/Menu.vue';
-import Vue from 'vue';
-
-class Menu extends EventEmitter {
-    constructor(options) {
-        super();
-
-        this.options = options;
-
-        this.component = new Vue({
-            provide: {
-                actions: options.actions
-            },
-            components: {
-                MenuComponent
-            },
-            template: '<menu-component />'
-        });
-
-        if (options.onDestroy) {
-            this.once('destroy', options.onDestroy);
-        }
-
-        this.dismiss = this.dismiss.bind(this);
-        this.show = this.show.bind(this);
-
-        this.show();
-    }
-
-    dismiss() {
-        this.emit('destroy');
-        document.body.removeChild(this.component.$el);
-        document.removeEventListener('click', this.dismiss);
-        this.component.$destroy();
-    }
-
-    show() {
-        this.component.$mount();
-        document.body.appendChild(this.component.$el);
-
-        let position = this._calculatePopupPosition(this.options.x, this.options.y, this.component.$el);
-
-        this.component.$el.style.left = `${position.x}px`;
-        this.component.$el.style.top = `${position.y}px`;
-
-        document.addEventListener('click', this.dismiss);
-    }
-
-    /**
-     * @private
-     */
-    _calculatePopupPosition(eventPosX, eventPosY, menuElement) {
-        let menuDimensions = menuElement.getBoundingClientRect();
-        let overflowX = (eventPosX + menuDimensions.width) - document.body.clientWidth;
-        let overflowY = (eventPosY + menuDimensions.height) - document.body.clientHeight;
-
-        if (overflowX > 0) {
-            eventPosX = eventPosX - overflowX;
-        }
-
-        if (overflowY > 0) {
-            eventPosY = eventPosY - overflowY;
-        }
-
-        return {
-            x: eventPosX,
-            y: eventPosY
-        };
-    }
-}
-
-export default Menu;

src/api/overlays/OverlayAPI.js

@@ -22,7 +22,6 @@ class OverlayAPI {
                 this.dismissLastOverlay();
             }
         });
-
     }
 
     /**
@@ -128,7 +127,6 @@ class OverlayAPI {
 
         return progressDialog;
     }
-
 }
 
 export default OverlayAPI;

src/api/status/StatusAPI.js

@@ -1,67 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 EventEmitter from 'EventEmitter';
-
-export default class StatusAPI extends EventEmitter {
-    constructor(openmct) {
-        super();
-
-        this._openmct = openmct;
-        this._statusCache = {};
-
-        this.get = this.get.bind(this);
-        this.set = this.set.bind(this);
-        this.observe = this.observe.bind(this);
-    }
-
-    get(identifier) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        return this._statusCache[keyString];
-    }
-
-    set(identifier, value) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        this._statusCache[keyString] = value;
-        this.emit(keyString, value);
-    }
-
-    delete(identifier) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        this._statusCache[keyString] = undefined;
-        this.emit(keyString, undefined);
-        delete this._statusCache[keyString];
-    }
-
-    observe(identifier, callback) {
-        let key = this._openmct.objects.makeKeyString(identifier);
-
-        this.on(key, callback);
-
-        return () => {
-            this.off(key, callback);
-        };
-    }
-}

src/api/status/StatusAPISpec.js

@@ -1,85 +0,0 @@
-import StatusAPI from './StatusAPI.js';
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-
-describe("The Status API", () => {
-    let statusAPI;
-    let openmct;
-    let identifier;
-    let status;
-    let status2;
-    let callback;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        statusAPI = new StatusAPI(openmct);
-        identifier = {
-            namespace: "test-namespace",
-            key: "test-key"
-        };
-        status = "test-status";
-        status2 = 'test-status-deux';
-        callback = jasmine.createSpy('callback', (statusUpdate) => statusUpdate);
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    describe("set function", () => {
-        it("sets status for identifier", () => {
-            statusAPI.set(identifier, status);
-
-            let resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toEqual(status);
-        });
-    });
-
-    describe("get function", () => {
-        it("returns status for identifier", () => {
-            statusAPI.set(identifier, status2);
-
-            let resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toEqual(status2);
-        });
-    });
-
-    describe("delete function", () => {
-        it("deletes status for identifier", () => {
-            statusAPI.set(identifier, status);
-
-            let resultingStatus = statusAPI.get(identifier);
-            expect(resultingStatus).toEqual(status);
-
-            statusAPI.delete(identifier);
-            resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toBeUndefined();
-        });
-    });
-
-    describe("observe function", () => {
-
-        it("allows callbacks to be attached to status set and delete events", () => {
-            let unsubscribe = statusAPI.observe(identifier, callback);
-            statusAPI.set(identifier, status);
-
-            expect(callback).toHaveBeenCalledWith(status);
-
-            statusAPI.delete(identifier);
-
-            expect(callback).toHaveBeenCalledWith(undefined);
-            unsubscribe();
-        });
-
-        it("returns a unsubscribe function", () => {
-            let unsubscribe = statusAPI.observe(identifier, callback);
-            unsubscribe();
-
-            statusAPI.set(identifier, status);
-
-            expect(callback).toHaveBeenCalledTimes(0);
-        });
-    });
-});

src/api/telemetry/TelemetryAPI.js

@@ -21,14 +21,12 @@
  *****************************************************************************/
 
 define([
-    '../../plugins/displayLayout/CustomStringFormatter',
     './TelemetryMetadataManager',
     './TelemetryValueFormatter',
     './DefaultMetadataProvider',
     'objectUtils',
     'lodash'
 ], function (
-    CustomStringFormatter,
     TelemetryMetadataManager,
     TelemetryValueFormatter,
     DefaultMetadataProvider,
@@ -144,17 +142,6 @@ define([
         this.valueFormatterCache = new WeakMap();
     }
 
-    /**
-     * Return Custom String Formatter
-     *
-     * @param {Object} valueMetadata valueMetadata for given telemetry object
-     * @param {string} format custom formatter string (eg: %.4f, &lts etc.)
-     * @returns {CustomStringFormatter}
-     */
-    TelemetryAPI.prototype.customStringFormatter = function (valueMetadata, format) {
-        return new CustomStringFormatter.default(this.openmct, valueMetadata, format);
-    };
-
     /**
      * Return true if the given domainObject is a telemetry object.  A telemetry
      * object is any object which has telemetry metadata-- regardless of whether
@@ -413,17 +400,6 @@ define([
         return _.sortBy(options, sortKeys);
     };
 
-    /**
-     * @private
-     */
-    TelemetryAPI.prototype.getFormatService = function () {
-        if (!this.formatService) {
-            this.formatService = this.openmct.$injector.get('formatService');
-        }
-
-        return this.formatService;
-    };
-
     /**
      * Get a value formatter for a given valueMetadata.
      *
@@ -431,27 +407,19 @@ define([
      */
     TelemetryAPI.prototype.getValueFormatter = function (valueMetadata) {
         if (!this.valueFormatterCache.has(valueMetadata)) {
+            if (!this.formatService) {
+                this.formatService = this.openmct.$injector.get('formatService');
+            }
+
             this.valueFormatterCache.set(
                 valueMetadata,
-                new TelemetryValueFormatter(valueMetadata, this.getFormatService())
+                new TelemetryValueFormatter(valueMetadata, this.formatService)
             );
         }
 
         return this.valueFormatterCache.get(valueMetadata);
     };
 
-    /**
-     * Get a value formatter for a given key.
-     * @param {string} key
-     *
-     * @returns {Format}
-     */
-    TelemetryAPI.prototype.getFormatter = function (key) {
-        const formatMap = this.getFormatService().formatMap;
-
-        return formatMap[key];
-    };
-
     /**
      * Get a format map of all value formatters for a given piece of telemetry
      * metadata.

src/plugins/LADTable/components/LADRow.vue

@@ -44,7 +44,6 @@
 <script>
 
 const CONTEXT_MENU_ACTIONS = [
-    'viewDatumAction',
     'viewHistoricalData',
     'remove'
 ];
@@ -130,7 +129,6 @@ export default {
             let limit;
 
             if (this.shouldUpdate(newTimestamp)) {
-                this.datum = datum;
                 this.timestamp = newTimestamp;
                 this.value = this.formats[this.valueKey].format(datum);
                 limit = this.limitEvaluator.evaluate(datum, this.valueMetadata);
@@ -177,25 +175,8 @@ export default {
             this.resetValues();
             this.timestampKey = timeSystem.key;
         },
-        getView() {
-            return {
-                getViewContext: () => {
-                    return {
-                        viewHistoricalData: true,
-                        viewDatumAction: true,
-                        getDatum: () => {
-                            return this.datum;
-                        }
-                    };
-                }
-            };
-        },
         showContextMenu(event) {
-            let actionCollection = this.openmct.actions.get(this.currentObjectPath, this.getView());
-            let allActions = actionCollection.getActionsObject();
-            let applicableActions = CONTEXT_MENU_ACTIONS.map(key => allActions[key]);
-
-            this.openmct.menus.showMenu(event.x, event.y, applicableActions);
+            this.openmct.contextMenu._showContextMenuForObjectPath(this.currentObjectPath, event.x, event.y, CONTEXT_MENU_ACTIONS);
         },
         resetValues() {
             this.value = '---';

src/plugins/autoflow/AutoflowTabularPluginSpec.js

@@ -19,352 +19,342 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-import AutoflowTabularPlugin from './AutoflowTabularPlugin';
-import AutoflowTabularConstants from './AutoflowTabularConstants';
-import $ from 'zepto';
-import DOMObserver from './dom-observer';
-import {
-    createOpenMct,
-    resetApplicationState,
-    spyOnBuiltins
-} from 'utils/testing';
 
-describe("AutoflowTabularPlugin", () => {
-    let testType;
-    let testObject;
-    let mockmct;
+define([
+    './AutoflowTabularPlugin',
+    './AutoflowTabularConstants',
+    '../../MCT',
+    'zepto',
+    './dom-observer'
+], function (AutoflowTabularPlugin, AutoflowTabularConstants, MCT, $, DOMObserver) {
+    describe("AutoflowTabularPlugin", function () {
+        let testType;
+        let testObject;
+        let mockmct;
 
-    beforeEach(() => {
-        testType = "some-type";
-        testObject = { type: testType };
-        mockmct = createOpenMct();
-        spyOn(mockmct.composition, 'get');
-        spyOn(mockmct.objectViews, 'addProvider');
-        spyOn(mockmct.telemetry, 'getMetadata');
-        spyOn(mockmct.telemetry, 'getValueFormatter');
-        spyOn(mockmct.telemetry, 'limitEvaluator');
-        spyOn(mockmct.telemetry, 'request');
-        spyOn(mockmct.telemetry, 'subscribe');
+        beforeEach(function () {
+            testType = "some-type";
+            testObject = { type: testType };
+            mockmct = new MCT();
+            spyOn(mockmct.composition, 'get');
+            spyOn(mockmct.objectViews, 'addProvider');
+            spyOn(mockmct.telemetry, 'getMetadata');
+            spyOn(mockmct.telemetry, 'getValueFormatter');
+            spyOn(mockmct.telemetry, 'limitEvaluator');
+            spyOn(mockmct.telemetry, 'request');
+            spyOn(mockmct.telemetry, 'subscribe');
 
-        const plugin = new AutoflowTabularPlugin({ type: testType });
-        plugin(mockmct);
-    });
-
-    afterEach(() => {
-        resetApplicationState(mockmct);
-    });
-
-    it("installs a view provider", () => {
-        expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
-    });
-
-    describe("installs a view provider which", () => {
-        let provider;
-
-        beforeEach(() => {
-            provider =
-                mockmct.objectViews.addProvider.calls.mostRecent().args[0];
+            const plugin = new AutoflowTabularPlugin({ type: testType });
+            plugin(mockmct);
         });
 
-        it("applies its view to the type from options", () => {
-            expect(provider.canView(testObject)).toBe(true);
+        it("installs a view provider", function () {
+            expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
         });
 
-        it("does not apply to other types", () => {
-            expect(provider.canView({ type: 'foo' })).toBe(false);
-        });
+        describe("installs a view provider which", function () {
+            let provider;
 
-        describe("provides a view which", () => {
-            let testKeys;
-            let testChildren;
-            let testContainer;
-            let testHistories;
-            let mockComposition;
-            let mockMetadata;
-            let mockEvaluator;
-            let mockUnsubscribes;
-            let callbacks;
-            let view;
-            let domObserver;
+            beforeEach(function () {
+                provider =
+                    mockmct.objectViews.addProvider.calls.mostRecent().args[0];
+            });
 
-            function waitsForChange() {
-                return new Promise(function (resolve) {
-                    window.requestAnimationFrame(resolve);
+            it("applies its view to the type from options", function () {
+                expect(provider.canView(testObject)).toBe(true);
+            });
+
+            it("does not apply to other types", function () {
+                expect(provider.canView({ type: 'foo' })).toBe(false);
+            });
+
+            describe("provides a view which", function () {
+                let testKeys;
+                let testChildren;
+                let testContainer;
+                let testHistories;
+                let mockComposition;
+                let mockMetadata;
+                let mockEvaluator;
+                let mockUnsubscribes;
+                let callbacks;
+                let view;
+                let domObserver;
+
+                function waitsForChange() {
+                    return new Promise(function (resolve) {
+                        window.requestAnimationFrame(resolve);
+                    });
+                }
+
+                function emitEvent(mockEmitter, type, event) {
+                    mockEmitter.on.calls.all().forEach(function (call) {
+                        if (call.args[0] === type) {
+                            call.args[1](event);
+                        }
+                    });
+                }
+
+                beforeEach(function () {
+                    callbacks = {};
+
+                    testObject = { type: 'some-type' };
+                    testKeys = ['abc', 'def', 'xyz'];
+                    testChildren = testKeys.map(function (key) {
+                        return {
+                            identifier: {
+                                namespace: "test",
+                                key: key
+                            },
+                            name: "Object " + key
+                        };
+                    });
+                    testContainer = $('<div>')[0];
+                    domObserver = new DOMObserver(testContainer);
+
+                    testHistories = testKeys.reduce(function (histories, key, index) {
+                        histories[key] = {
+                            key: key,
+                            range: index + 10,
+                            domain: key + index
+                        };
+
+                        return histories;
+                    }, {});
+
+                    mockComposition =
+                        jasmine.createSpyObj('composition', ['load', 'on', 'off']);
+                    mockMetadata =
+                        jasmine.createSpyObj('metadata', ['valuesForHints']);
+
+                    mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
+                    mockUnsubscribes = testKeys.reduce(function (map, key) {
+                        map[key] = jasmine.createSpy('unsubscribe-' + key);
+
+                        return map;
+                    }, {});
+
+                    mockmct.composition.get.and.returnValue(mockComposition);
+                    mockComposition.load.and.callFake(function () {
+                        testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
+
+                        return Promise.resolve(testChildren);
+                    });
+
+                    mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
+                    mockmct.telemetry.getValueFormatter.and.callFake(function (metadatum) {
+                        const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
+                        mockFormatter.format.and.callFake(function (datum) {
+                            return datum[metadatum.hint];
+                        });
+
+                        return mockFormatter;
+                    });
+                    mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
+                    mockmct.telemetry.subscribe.and.callFake(function (obj, callback) {
+                        const key = obj.identifier.key;
+                        callbacks[key] = callback;
+
+                        return mockUnsubscribes[key];
+                    });
+                    mockmct.telemetry.request.and.callFake(function (obj, request) {
+                        const key = obj.identifier.key;
+
+                        return Promise.resolve([testHistories[key]]);
+                    });
+                    mockMetadata.valuesForHints.and.callFake(function (hints) {
+                        return [{ hint: hints[0] }];
+                    });
+
+                    view = provider.view(testObject);
+                    view.show(testContainer);
+
+                    return waitsForChange();
                 });
-            }
 
-            function emitEvent(mockEmitter, type, event) {
-                mockEmitter.on.calls.all().forEach((call) => {
-                    if (call.args[0] === type) {
-                        call.args[1](event);
+                afterEach(function () {
+                    domObserver.destroy();
+                });
+
+                it("populates its container", function () {
+                    expect(testContainer.children.length > 0).toBe(true);
+                });
+
+                describe("when rows have been populated", function () {
+                    function rowsMatch() {
+                        const rows = $(testContainer).find(".l-autoflow-row").length;
+
+                        return rows === testChildren.length;
                     }
-                });
-            }
 
-            beforeEach((done) => {
-                callbacks = {};
-
-                spyOnBuiltins(['requestAnimationFrame']);
-                window.requestAnimationFrame.and.callFake((callBack) => {
-                    callBack();
-                });
-
-                testObject = { type: 'some-type' };
-                testKeys = ['abc', 'def', 'xyz'];
-                testChildren = testKeys.map((key) => {
-                    return {
-                        identifier: {
-                            namespace: "test",
-                            key: key
-                        },
-                        name: "Object " + key
-                    };
-                });
-                testContainer = $('<div>')[0];
-                domObserver = new DOMObserver(testContainer);
-
-                testHistories = testKeys.reduce((histories, key, index) => {
-                    histories[key] = {
-                        key: key,
-                        range: index + 10,
-                        domain: key + index
-                    };
-
-                    return histories;
-                }, {});
-
-                mockComposition =
-                    jasmine.createSpyObj('composition', ['load', 'on', 'off']);
-                mockMetadata =
-                    jasmine.createSpyObj('metadata', ['valuesForHints']);
-
-                mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
-                mockUnsubscribes = testKeys.reduce((map, key) => {
-                    map[key] = jasmine.createSpy('unsubscribe-' + key);
-
-                    return map;
-                }, {});
-
-                mockmct.composition.get.and.returnValue(mockComposition);
-                mockComposition.load.and.callFake(() => {
-                    testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
-
-                    return Promise.resolve(testChildren);
-                });
-
-                mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
-                mockmct.telemetry.getValueFormatter.and.callFake((metadatum) => {
-                    const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
-                    mockFormatter.format.and.callFake((datum) => {
-                        return datum[metadatum.hint];
+                    it("shows one row per child object", function () {
+                        return domObserver.when(rowsMatch);
                     });
 
-                    return mockFormatter;
-                });
-                mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
-                mockmct.telemetry.subscribe.and.callFake((obj, callback) => {
-                    const key = obj.identifier.key;
-                    callbacks[key] = callback;
+                    it("adds rows on composition change", function () {
+                        const child = {
+                            identifier: {
+                                namespace: "test",
+                                key: "123"
+                            },
+                            name: "Object 123"
+                        };
+                        testChildren.push(child);
+                        emitEvent(mockComposition, 'add', child);
 
-                    return mockUnsubscribes[key];
-                });
-                mockmct.telemetry.request.and.callFake((obj, request) => {
-                    const key = obj.identifier.key;
-
-                    return Promise.resolve([testHistories[key]]);
-                });
-                mockMetadata.valuesForHints.and.callFake((hints) => {
-                    return [{ hint: hints[0] }];
-                });
-
-                view = provider.view(testObject);
-                view.show(testContainer);
-
-                return done();
-            });
-
-            afterEach(() => {
-                domObserver.destroy();
-            });
-
-            it("populates its container", () => {
-                expect(testContainer.children.length > 0).toBe(true);
-            });
-
-            describe("when rows have been populated", () => {
-                function rowsMatch() {
-                    const rows = $(testContainer).find(".l-autoflow-row").length;
-
-                    return rows === testChildren.length;
-                }
-
-                it("shows one row per child object", () => {
-                    return domObserver.when(rowsMatch);
-                });
-
-                // it("adds rows on composition change", () => {
-                //     const child = {
-                //         identifier: {
-                //             namespace: "test",
-                //             key: "123"
-                //         },
-                //         name: "Object 123"
-                //     };
-                //     testChildren.push(child);
-                //     emitEvent(mockComposition, 'add', child);
-
-                //     return domObserver.when(rowsMatch);
-                // });
-
-                it("removes rows on composition change", () => {
-                    const child = testChildren.pop();
-                    emitEvent(mockComposition, 'remove', child.identifier);
-
-                    return domObserver.when(rowsMatch);
-                });
-            });
-
-            it("removes subscriptions when destroyed", () => {
-                testKeys.forEach((key) => {
-                    expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
-                });
-                view.destroy();
-                testKeys.forEach((key) => {
-                    expect(mockUnsubscribes[key]).toHaveBeenCalled();
-                });
-            });
-
-            it("provides a button to change column width", () => {
-                const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
-                const nextWidth =
-                    initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;
-
-                expect($(testContainer).find('.l-autoflow-col').css('width'))
-                    .toEqual(initialWidth + 'px');
-
-                $(testContainer).find('.change-column-width').click();
-
-                function widthHasChanged() {
-                    const width = $(testContainer).find('.l-autoflow-col').css('width');
-
-                    return width !== initialWidth + 'px';
-                }
-
-                return domObserver.when(widthHasChanged)
-                    .then(() => {
-                        expect($(testContainer).find('.l-autoflow-col').css('width'))
-                            .toEqual(nextWidth + 'px');
+                        return domObserver.when(rowsMatch);
                     });
-            });
 
-            it("subscribes to all child objects", () => {
-                testKeys.forEach((key) => {
-                    expect(callbacks[key]).toEqual(jasmine.any(Function));
-                });
-            });
+                    it("removes rows on composition change", function () {
+                        const child = testChildren.pop();
+                        emitEvent(mockComposition, 'remove', child.identifier);
 
-            it("displays historical telemetry", () => {
-                function rowTextDefined() {
-                    return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
-                }
-
-                return domObserver.when(rowTextDefined).then(() => {
-                    testKeys.forEach((key, index) => {
-                        const datum = testHistories[key];
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.text()).toEqual(String(datum.range));
-                    });
-                });
-            });
-
-            it("displays incoming telemetry", () => {
-                const testData = testKeys.map((key, index) => {
-                    return {
-                        key: key,
-                        range: index * 100,
-                        domain: key + index
-                    };
-                });
-
-                testData.forEach((datum) => {
-                    callbacks[datum.key](datum);
-                });
-
-                return waitsForChange().then(() => {
-                    testData.forEach((datum, index) => {
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.text()).toEqual(String(datum.range));
-                    });
-                });
-            });
-
-            it("updates classes for limit violations", () => {
-                const testClass = "some-limit-violation";
-                mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
-                testKeys.forEach((key) => {
-                    callbacks[key]({
-                        range: 'foo',
-                        domain: 'bar'
+                        return domObserver.when(rowsMatch);
                     });
                 });
 
-                return waitsForChange().then(() => {
-                    testKeys.forEach((datum, index) => {
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.hasClass(testClass)).toBe(true);
+                it("removes subscriptions when destroyed", function () {
+                    testKeys.forEach(function (key) {
+                        expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
+                    });
+                    view.destroy();
+                    testKeys.forEach(function (key) {
+                        expect(mockUnsubscribes[key]).toHaveBeenCalled();
                     });
                 });
-            });
 
-            it("automatically flows to new columns", () => {
-                const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
-                const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
-                const count = testKeys.length;
-                const $container = $(testContainer);
-                let promiseChain = Promise.resolve();
+                it("provides a button to change column width", function () {
+                    const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
+                    const nextWidth =
+                        initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;
 
-                function columnsHaveAutoflowed() {
-                    const itemsHeight = $container.find('.l-autoflow-items').height();
-                    const availableHeight = itemsHeight - sliderHeight;
-                    const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
-                    const columns = Math.ceil(count / availableRows);
+                    expect($(testContainer).find('.l-autoflow-col').css('width'))
+                        .toEqual(initialWidth + 'px');
 
-                    return $container.find('.l-autoflow-col').length === columns;
-                }
+                    $(testContainer).find('.change-column-width').click();
 
-                $container.find('.abs').css({
-                    position: 'absolute',
-                    left: '0px',
-                    right: '0px',
-                    top: '0px',
-                    bottom: '0px'
+                    function widthHasChanged() {
+                        const width = $(testContainer).find('.l-autoflow-col').css('width');
+
+                        return width !== initialWidth + 'px';
+                    }
+
+                    return domObserver.when(widthHasChanged)
+                        .then(function () {
+                            expect($(testContainer).find('.l-autoflow-col').css('width'))
+                                .toEqual(nextWidth + 'px');
+                        });
                 });
-                $container.css({ position: 'absolute' });
 
-                $container.appendTo(document.body);
-
-                function setHeight(height) {
-                    $container.css('height', height + 'px');
-
-                    return domObserver.when(columnsHaveAutoflowed);
-                }
-
-                for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
-                    // eslint-disable-next-line no-invalid-this
-                    promiseChain = promiseChain.then(setHeight.bind(this, height));
-                }
-
-                return promiseChain.then(() => {
-                    $container.remove();
+                it("subscribes to all child objects", function () {
+                    testKeys.forEach(function (key) {
+                        expect(callbacks[key]).toEqual(jasmine.any(Function));
+                    });
                 });
-            });
 
-            it("loads composition exactly once", () => {
-                const testObj = testChildren.pop();
-                emitEvent(mockComposition, 'remove', testObj.identifier);
-                testChildren.push(testObj);
-                emitEvent(mockComposition, 'add', testObj);
-                expect(mockComposition.load.calls.count()).toEqual(1);
+                it("displays historical telemetry", function () {
+                    function rowTextDefined() {
+                        return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
+                    }
+
+                    return domObserver.when(rowTextDefined).then(function () {
+                        testKeys.forEach(function (key, index) {
+                            const datum = testHistories[key];
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.text()).toEqual(String(datum.range));
+                        });
+                    });
+                });
+
+                it("displays incoming telemetry", function () {
+                    const testData = testKeys.map(function (key, index) {
+                        return {
+                            key: key,
+                            range: index * 100,
+                            domain: key + index
+                        };
+                    });
+
+                    testData.forEach(function (datum) {
+                        callbacks[datum.key](datum);
+                    });
+
+                    return waitsForChange().then(function () {
+                        testData.forEach(function (datum, index) {
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.text()).toEqual(String(datum.range));
+                        });
+                    });
+                });
+
+                it("updates classes for limit violations", function () {
+                    const testClass = "some-limit-violation";
+                    mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
+                    testKeys.forEach(function (key) {
+                        callbacks[key]({
+                            range: 'foo',
+                            domain: 'bar'
+                        });
+                    });
+
+                    return waitsForChange().then(function () {
+                        testKeys.forEach(function (datum, index) {
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.hasClass(testClass)).toBe(true);
+                        });
+                    });
+                });
+
+                it("automatically flows to new columns", function () {
+                    const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
+                    const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
+                    const count = testKeys.length;
+                    const $container = $(testContainer);
+                    let promiseChain = Promise.resolve();
+
+                    function columnsHaveAutoflowed() {
+                        const itemsHeight = $container.find('.l-autoflow-items').height();
+                        const availableHeight = itemsHeight - sliderHeight;
+                        const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
+                        const columns = Math.ceil(count / availableRows);
+
+                        return $container.find('.l-autoflow-col').length === columns;
+                    }
+
+                    $container.find('.abs').css({
+                        position: 'absolute',
+                        left: '0px',
+                        right: '0px',
+                        top: '0px',
+                        bottom: '0px'
+                    });
+                    $container.css({ position: 'absolute' });
+
+                    $container.appendTo(document.body);
+
+                    function setHeight(height) {
+                        $container.css('height', height + 'px');
+
+                        return domObserver.when(columnsHaveAutoflowed);
+                    }
+
+                    for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
+                        // eslint-disable-next-line no-invalid-this
+                        promiseChain = promiseChain.then(setHeight.bind(this, height));
+                    }
+
+                    return promiseChain.then(function () {
+                        $container.remove();
+                    });
+                });
+
+                it("loads composition exactly once", function () {
+                    const testObj = testChildren.pop();
+                    emitEvent(mockComposition, 'remove', testObj.identifier);
+                    testChildren.push(testObj);
+                    emitEvent(mockComposition, 'add', testObj);
+                    expect(mockComposition.load.calls.count()).toEqual(1);
+                });
             });
         });
     });

src/plugins/clearData/clearDataAction.js

@@ -23,7 +23,6 @@
 export default class ClearDataAction {
     constructor(openmct, appliesToObjects) {
         this.name = 'Clear Data for Object';
-        this.key = 'clear-data-action';
         this.description = 'Clears current data for object, unsubscribes and resubscribes to data';
         this.cssClass = 'icon-clear-data';
 

src/plugins/clearData/plugin.js

@@ -53,7 +53,7 @@ define([
                 openmct.indicators.add(indicator);
             }
 
-            openmct.actions.register(new ClearDataAction.default(openmct, appliesToObjects));
+            openmct.contextMenu.registerAction(new ClearDataAction.default(openmct, appliesToObjects));
         };
     };
 });

src/plugins/clearData/test/clearDataActionSpec.js

@@ -26,12 +26,12 @@ import ClearDataAction from '../clearDataAction.js';
 describe('When the Clear Data Plugin is installed,', function () {
     const mockObjectViews = jasmine.createSpyObj('objectViews', ['emit']);
     const mockIndicatorProvider = jasmine.createSpyObj('indicators', ['add']);
-    const mockActionsProvider = jasmine.createSpyObj('actions', ['register']);
+    const mockContextMenuProvider = jasmine.createSpyObj('contextMenu', ['registerAction']);
 
     const openmct = {
         objectViews: mockObjectViews,
         indicators: mockIndicatorProvider,
-        actions: mockActionsProvider,
+        contextMenu: mockContextMenuProvider,
         install: function (plugin) {
             plugin(this);
         }
@@ -51,7 +51,7 @@ describe('When the Clear Data Plugin is installed,', function () {
     it('Clear Data context menu action is installed', function () {
         openmct.install(ClearDataActionPlugin([]));
 
-        expect(mockActionsProvider.register).toHaveBeenCalled();
+        expect(mockContextMenuProvider.registerAction).toHaveBeenCalled();
     });
 
     it('clear data action emits a clearData event when invoked', function () {

src/plugins/displayLayout/AlphanumericFormatViewProvider.js

@@ -64,16 +64,9 @@ define([
                             components: {
                                 AlphanumericFormatView: AlphanumericFormatView.default
                             },
-                            template: '<alphanumeric-format-view ref="alphanumericFormatView"></alphanumeric-format-view>'
+                            template: '<alphanumeric-format-view></alphanumeric-format-view>'
                         });
                     },
-                    getViewContext() {
-                        if (component) {
-                            return component.$refs.alphanumericFormatView.getViewContext();
-                        } else {
-                            return {};
-                        }
-                    },
                     destroy: function () {
                         component.$destroy();
                         component = undefined;

src/plugins/displayLayout/CustomStringFormatter.js

@@ -1,38 +0,0 @@
-import printj from 'printj';
-
-export default class CustomStringFormatter {
-    constructor(openmct, valueMetadata, itemFormat) {
-        this.openmct = openmct;
-
-        this.itemFormat = itemFormat;
-        this.valueMetadata = valueMetadata;
-    }
-
-    format(datum) {
-        if (!this.itemFormat) {
-            return;
-        }
-
-        if (!this.itemFormat.startsWith('&')) {
-            return printj.sprintf(this.itemFormat, datum[this.valueMetadata.key]);
-        }
-
-        try {
-            const key = this.itemFormat.slice(1);
-            const customFormatter = this.openmct.telemetry.getFormatter(key);
-            if (!customFormatter) {
-                throw new Error('Custom Formatter not found');
-            }
-
-            return customFormatter.format(datum[this.valueMetadata.key]);
-        } catch (e) {
-            console.error(e);
-
-            return datum[this.valueMetadata.key];
-        }
-    }
-
-    setFormat(itemFormat) {
-        this.itemFormat = itemFormat;
-    }
-}

src/plugins/displayLayout/CustomStringFormatterSpec.js

@@ -1,82 +0,0 @@
-import CustomStringFormatter from './CustomStringFormatter';
-import { createOpenMct, resetApplicationState } from 'utils/testing';
-
-const CUSTOM_FORMATS = [
-    {
-        key: 'sclk',
-        format: (value) => 2 * value
-    },
-    {
-        key: 'lts',
-        format: (value) => 3 * value
-    }
-];
-
-const valueMetadata = {
-    key: "sin",
-    name: "Sine",
-    unit: "Hz",
-    formatString: "%0.2f",
-    hints: {
-        range: 1,
-        priority: 3
-    },
-    source: "sin"
-};
-
-const datum = {
-    name: "1 Sine Wave Generator",
-    utc: 1603930354000,
-    yesterday: 1603843954000,
-    sin: 0.587785209686822,
-    cos: -0.8090170253297632
-};
-
-describe('CustomStringFormatter', function () {
-    let element;
-    let child;
-    let openmct;
-    let customStringFormatter;
-
-    beforeEach((done) => {
-        openmct = createOpenMct();
-
-        element = document.createElement('div');
-        child = document.createElement('div');
-        element.appendChild(child);
-        CUSTOM_FORMATS.forEach(openmct.telemetry.addFormat.bind({openmct}));
-        openmct.on('start', done);
-        openmct.startHeadless();
-
-        spyOn(openmct.telemetry, 'getFormatter');
-        openmct.telemetry.getFormatter.and.callFake((key) => CUSTOM_FORMATS.find(d => d.key === key));
-
-        customStringFormatter = new CustomStringFormatter(openmct, valueMetadata);
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it('adds custom format sclk', () => {
-        const format = openmct.telemetry.getFormatter('sclk');
-        expect(format.key).toEqual('sclk');
-    });
-
-    it('adds custom format lts', () => {
-        const format = openmct.telemetry.getFormatter('lts');
-        expect(format.key).toEqual('lts');
-    });
-
-    it('returns correct value for custom format sclk', () => {
-        customStringFormatter.setFormat('&sclk');
-        const value = customStringFormatter.format(datum, valueMetadata);
-        expect(datum.sin * 2).toEqual(value);
-    });
-
-    it('returns correct value for custom format lts', () => {
-        customStringFormatter.setFormat('&lts');
-        const value = customStringFormatter.format(datum, valueMetadata);
-        expect(datum.sin * 3).toEqual(value);
-    });
-});

src/plugins/displayLayout/actions/CopyToClipboardAction.js

@@ -1,34 +0,0 @@
-import clipboard from '@/utils/clipboard';
-
-export default class CopyToClipboardAction {
-    constructor(openmct) {
-        this.openmct = openmct;
-
-        this.cssClass = 'icon-duplicate';
-        this.description = 'Copy value to clipboard';
-        this.group = "action";
-        this.key = 'copyToClipboard';
-        this.name = 'Copy to Clipboard';
-        this.priority = 1;
-    }
-
-    invoke(objectPath, view = {}) {
-        const viewContext = view.getViewContext && view.getViewContext();
-        const formattedValue = viewContext.formattedValueForCopy();
-
-        clipboard.updateClipboard(formattedValue)
-            .then(() => {
-                this.openmct.notifications.info(`Success : copied '${formattedValue}' to clipboard `);
-            })
-            .catch(() => {
-                this.openmct.notifications.error(`Failed : to copy '${formattedValue}' to clipboard `);
-            });
-    }
-
-    appliesTo(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
-
-        return viewContext && viewContext.formattedValueForCopy
-            && typeof viewContext.formattedValueForCopy === 'function';
-    }
-}

src/plugins/displayLayout/components/SubobjectView.vue

@@ -142,18 +142,14 @@ export default {
             this.domainObject = domainObject;
             this.currentObjectPath = [this.domainObject].concat(this.objectPath.slice());
             this.$nextTick(() => {
-                let reference = this.$refs.objectFrame;
-
-                if (reference) {
-                    let childContext = this.$refs.objectFrame.getSelectionContext();
-                    childContext.item = domainObject;
-                    childContext.layoutItem = this.item;
-                    childContext.index = this.index;
-                    this.context = childContext;
-                    this.removeSelectable = this.openmct.selection.selectable(
-                        this.$el, this.context, this.immediatelySelect || this.initSelect);
-                    delete this.immediatelySelect;
-                }
+                let childContext = this.$refs.objectFrame.getSelectionContext();
+                childContext.item = domainObject;
+                childContext.layoutItem = this.item;
+                childContext.index = this.index;
+                this.context = childContext;
+                this.removeSelectable = this.openmct.selection.selectable(
+                    this.$el, this.context, this.immediatelySelect || this.initSelect);
+                delete this.immediatelySelect;
             });
         }
     }

src/plugins/displayLayout/components/TelemetryView.vue

@@ -30,15 +30,18 @@
 >
     <div
         v-if="domainObject"
-        class="c-telemetry-view"
-        :class="[statusClass]"
+        class="u-style-receiver c-telemetry-view"
+        :class="{
+            styleClass,
+            'is-missing': domainObject.status === 'missing'
+        }"
         :style="styleObject"
         :data-font-size="item.fontSize"
         :data-font="item.font"
         @contextmenu.prevent="showContextMenu"
     >
-        <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+        <div class="is-missing__indicator"
+             title="This item is missing"
         ></div>
         <div
             v-if="showLabel"
@@ -71,12 +74,12 @@
 
 <script>
 import LayoutFrame from './LayoutFrame.vue';
+import printj from 'printj';
 import conditionalStylesMixin from "../mixins/objectStyles-mixin";
-import { getDefaultNotebook } from '@/plugins/notebook/utils/notebook-storage.js';
 
 const DEFAULT_TELEMETRY_DIMENSIONS = [10, 5];
 const DEFAULT_POSITION = [1, 1];
-const CONTEXT_MENU_ACTIONS = ['copyToClipboard', 'copyToNotebook', 'viewHistoricalData'];
+const CONTEXT_MENU_ACTIONS = ['viewHistoricalData'];
 
 export default {
     makeDefinition(openmct, gridSize, domainObject, position) {
@@ -126,18 +129,13 @@ export default {
     },
     data() {
         return {
-            currentObjectPath: undefined,
             datum: undefined,
-            domainObject: undefined,
             formats: undefined,
-            viewKey: `alphanumeric-format-${Math.random()}`,
-            status: ''
+            domainObject: undefined,
+            currentObjectPath: undefined
         };
     },
     computed: {
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
-        },
         showLabel() {
             let displayMode = this.item.displayMode;
 
@@ -171,11 +169,7 @@ export default {
         valueMetadata() {
             return this.datum && this.metadata.value(this.item.value);
         },
-        formatter() {
-            if (this.item.format) {
-                return this.customStringformatter;
-            }
-
+        valueFormatter() {
             return this.formats[this.item.value];
         },
         telemetryValue() {
@@ -183,7 +177,11 @@ export default {
                 return;
             }
 
-            return this.formatter && this.formatter.format(this.datum);
+            if (this.item.format) {
+                return printj.sprintf(this.item.format, this.datum[this.valueMetadata.key]);
+            }
+
+            return this.valueFormatter && this.valueFormatter.format(this.datum);
         },
         telemetryClass() {
             if (!this.datum) {
@@ -215,13 +213,9 @@ export default {
         this.openmct.objects.get(this.item.identifier)
             .then(this.setObject);
         this.openmct.time.on("bounds", this.refreshData);
-
-        this.status = this.openmct.status.get(this.item.identifier);
-        this.removeStatusListener = this.openmct.status.observe(this.item.identifier, this.setStatus);
     },
     destroyed() {
         this.removeSubscription();
-        this.removeStatusListener();
 
         if (this.removeSelectable) {
             this.removeSelectable();
@@ -230,12 +224,6 @@ export default {
         this.openmct.time.off("bounds", this.refreshData);
     },
     methods: {
-        formattedValueForCopy() {
-            const timeFormatterKey = this.openmct.time.timeSystem().key;
-            const timeFormatter = this.formats[timeFormatterKey];
-
-            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue} ${this.unit}`;
-        },
         requestHistoricalData() {
             let bounds = this.openmct.time.bounds();
             let options = {
@@ -273,26 +261,12 @@ export default {
                 this.requestHistoricalData(this.domainObject);
             }
         },
-        getView() {
-            return {
-                getViewContext: () => {
-                    return {
-                        viewHistoricalData: true,
-                        formattedValueForCopy: this.formattedValueForCopy
-                    };
-                }
-            };
-        },
         setObject(domainObject) {
             this.domainObject = domainObject;
             this.keyString = this.openmct.objects.makeKeyString(domainObject.identifier);
             this.metadata = this.openmct.telemetry.getMetadata(this.domainObject);
             this.limitEvaluator = this.openmct.telemetry.limitEvaluator(this.domainObject);
             this.formats = this.openmct.telemetry.getFormatMap(this.metadata);
-
-            const valueMetadata = this.metadata.value(this.item.value);
-            this.customStringformatter = this.openmct.telemetry.customStringFormatter(valueMetadata, this.item.format);
-
             this.requestHistoricalData();
             this.subscribeToObject();
 
@@ -312,37 +286,10 @@ export default {
             delete this.immediatelySelect;
         },
         updateTelemetryFormat(format) {
-            this.customStringformatter.setFormat(format);
-
             this.$emit('formatChanged', this.item, format);
         },
-        async getContextMenuActions() {
-            const defaultNotebook = getDefaultNotebook();
-            const domainObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
-            const actionCollection = this.openmct.actions.get(this.currentObjectPath, this.getView());
-            const actionsObject = actionCollection.getActionsObject();
-
-            let copyToNotebookAction = actionsObject.copyToNotebook;
-
-            if (defaultNotebook) {
-                const defaultPath = domainObject && `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
-                copyToNotebookAction.name = `Copy to Notebook ${defaultPath}`;
-            } else {
-                actionsObject.copyToNotebook = undefined;
-                delete actionsObject.copyToNotebook;
-            }
-
-            return CONTEXT_MENU_ACTIONS.map(actionKey => {
-                return actionsObject[actionKey];
-            }).filter(action => action !== undefined);
-        },
-        async showContextMenu(event) {
-            const contextMenuActions = await this.getContextMenuActions();
-
-            this.openmct.menus.showMenu(event.x, event.y, contextMenuActions);
-        },
-        setStatus(status) {
-            this.status = status;
+        showContextMenu(event) {
+            this.openmct.contextMenu._showContextMenuForObjectPath(this.currentObjectPath, event.x, event.y, CONTEXT_MENU_ACTIONS);
         }
     }
 };

src/plugins/displayLayout/components/telemetry-view.scss

@@ -7,6 +7,7 @@
         flex: 1 1 auto;
         display: flex;
         flex-direction: row;
+       // justify-content: center;
         align-items: center;
         overflow: hidden;
         padding: $interiorMargin;
@@ -26,13 +27,14 @@
         border: 1px solid transparent;
     }
 
-    .is-status__indicator {
-        position: absolute;
+    @include isMissing($absPos: true);
+
+    .is-missing__indicator {
         top: 0;
         left: 0;
     }
 
-    &[class*='is-status'] {
+    &.is-missing {
         border: $borderMissing;
     }
 }

src/plugins/displayLayout/plugin.js

@@ -26,12 +26,9 @@ import objectUtils from 'objectUtils';
 import DisplayLayoutType from './DisplayLayoutType.js';
 import DisplayLayoutToolbar from './DisplayLayoutToolbar.js';
 import AlphaNumericFormatViewProvider from './AlphanumericFormatViewProvider.js';
-import CopyToClipboardAction from './actions/CopyToClipboardAction';
 
 export default function DisplayLayoutPlugin(options) {
     return function (openmct) {
-        openmct.actions.register(new CopyToClipboardAction(openmct));
-
         openmct.objectViews.addProvider({
             key: 'layout.view',
             canView: function (domainObject) {

src/plugins/duplicate/DuplicateAction.js

@@ -1,156 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 DuplicateTask from './DuplicateTask';
-
-export default class DuplicateAction {
-    constructor(openmct) {
-        this.name = 'Duplicate';
-        this.key = 'duplicate';
-        this.description = 'Duplicate this object.';
-        this.cssClass = "icon-duplicate";
-        this.group = "action";
-        this.priority = 7;
-
-        this.openmct = openmct;
-    }
-
-    async invoke(objectPath) {
-        let duplicationTask = new DuplicateTask(this.openmct);
-        let originalObject = objectPath[0];
-        let parent = objectPath[1];
-        let userInput = await this.getUserInput(originalObject, parent);
-        let newParent = userInput.location;
-        let inNavigationPath = this.inNavigationPath(originalObject);
-
-        // legacy check
-        if (this.isLegacyDomainObject(newParent)) {
-            newParent = await this.convertFromLegacy(newParent);
-        }
-
-        // if editing, save
-        if (inNavigationPath && this.openmct.editor.isEditing()) {
-            this.openmct.editor.save();
-        }
-
-        // duplicate
-        let newObject = await duplicationTask.duplicate(originalObject, newParent);
-        this.updateNameCheck(newObject, userInput.name);
-
-        return;
-    }
-
-    async getUserInput(originalObject, parent) {
-        let dialogService = this.openmct.$injector.get('dialogService');
-        let dialogForm = this.getDialogForm(originalObject, parent);
-        let formState = {
-            name: originalObject.name
-        };
-        let userInput = await dialogService.getUserInput(dialogForm, formState);
-
-        return userInput;
-    }
-
-    updateNameCheck(object, name) {
-        if (object.name !== name) {
-            this.openmct.objects.mutate(object, 'name', name);
-        }
-    }
-
-    inNavigationPath(object) {
-        return this.openmct.router.path
-            .some(objectInPath => this.openmct.objects.areIdsEqual(objectInPath.identifier, object.identifier));
-    }
-
-    getDialogForm(object, parent) {
-        return {
-            name: "Duplicate Item",
-            sections: [
-                {
-                    rows: [
-                        {
-                            key: "name",
-                            control: "textfield",
-                            name: "Folder Name",
-                            pattern: "\\S+",
-                            required: true,
-                            cssClass: "l-input-lg"
-                        },
-                        {
-                            name: "location",
-                            cssClass: "grows",
-                            control: "locator",
-                            validate: this.validate(object, parent),
-                            key: 'location'
-                        }
-                    ]
-                }
-            ]
-        };
-    }
-
-    validate(object, currentParent) {
-        return (parentCandidate) => {
-            let currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
-            let parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.getId());
-            let objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
-
-            if (!parentCandidate || !currentParentKeystring) {
-                return false;
-            }
-
-            if (parentCandidateKeystring === objectKeystring) {
-                return false;
-            }
-
-            return this.openmct.composition.checkPolicy(
-                parentCandidate.useCapability('adapter'),
-                object
-            );
-        };
-    }
-
-    isLegacyDomainObject(domainObject) {
-        return domainObject.getCapability !== undefined;
-    }
-
-    async convertFromLegacy(legacyDomainObject) {
-        let objectContext = legacyDomainObject.getCapability('context');
-        let domainObject = await this.openmct.objects.get(objectContext.domainObject.id);
-
-        return domainObject;
-    }
-
-    appliesTo(objectPath) {
-        let parent = objectPath[1];
-        let parentType = parent && this.openmct.types.get(parent.type);
-        let child = objectPath[0];
-        let locked = child.locked ? child.locked : parent && parent.locked;
-
-        if (locked) {
-            return false;
-        }
-
-        return parentType
-            && parentType.definition.creatable
-            && Array.isArray(parent.composition);
-    }
-}

src/plugins/duplicate/DuplicateTask.js

@@ -1,270 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 uuid from 'uuid';
-
-/**
- * This class encapsulates the process of  duplicating/copying a domain object
- * and all of its children.
- *
- * @param {DomainObject} domainObject The object to duplicate
- * @param {DomainObject} parent The new location of the cloned object tree
- * @param {src/plugins/duplicate.DuplicateService~filter} filter
- *        a function used to filter out objects from
- *        the cloning process
- * @constructor
- */
-export default class DuplicateTask {
-
-    constructor(openmct) {
-        this.domainObject = undefined;
-        this.parent = undefined;
-        this.firstClone = undefined;
-        this.filter = undefined;
-        this.persisted = 0;
-        this.clones = [];
-        this.idMap = {};
-
-        this.openmct = openmct;
-    }
-
-    /**
-     * Execute the duplicate/copy task with the objects provided in the constructor.
-     * @returns {promise} Which will resolve with a clone of the object
-     * once complete.
-     */
-    async duplicate(domainObject, parent, filter) {
-        this.domainObject = domainObject;
-        this.parent = parent;
-        this.filter = filter || this.isCreatable;
-
-        await this.buildDuplicationPlan();
-        await this.persistObjects();
-        await this.addClonesToParent();
-
-        return this.firstClone;
-    }
-
-    /**
-     * Will build a graph of an object and all of its child objects in
-     * memory
-     * @private
-     * @param domainObject The original object to be copied
-     * @param parent The parent of the original object to be copied
-     * @returns {Promise} resolved with an array of clones of the models
-     * of the object tree being copied. Duplicating is done in a bottom-up
-     * fashion, so that the last member in the array is a clone of the model
-     * object being copied. The clones are all full composed with
-     * references to their own children.
-     */
-    async buildDuplicationPlan() {
-        let domainObjectClone = await this.duplicateObject(this.domainObject);
-        if (domainObjectClone !== this.domainObject) {
-            domainObjectClone.location = this.getId(this.parent);
-        }
-
-        this.firstClone = domainObjectClone;
-
-        return;
-    }
-
-    /**
-     * Will persist a list of {@link objectClones}. It will persist all
-     * simultaneously, irrespective of order in the list. This may
-     * result in automatic request batching by the browser.
-     */
-    async persistObjects() {
-        let initialCount = this.clones.length;
-        let dialog = this.openmct.overlays.progressDialog({
-            progressPerc: 0,
-            message: `Duplicating ${initialCount} files.`,
-            iconClass: 'info',
-            title: 'Duplicating'
-        });
-        let clonesDone = Promise.all(this.clones.map(clone => {
-            let percentPersisted = Math.ceil(100 * (++this.persisted / initialCount));
-            let message = `Duplicating ${initialCount - this.persisted} files.`;
-
-            dialog.updateProgress(percentPersisted, message);
-
-            return this.openmct.objects.save(clone);
-        }));
-
-        await clonesDone;
-        dialog.dismiss();
-        this.openmct.notifications.info(`Duplicated ${this.persisted} objects.`);
-
-        return;
-    }
-
-    /**
-     * Will add a list of clones to the specified parent's composition
-     */
-    async addClonesToParent() {
-        let parentComposition = this.openmct.composition.get(this.parent);
-        await parentComposition.load();
-        parentComposition.add(this.firstClone);
-
-        return;
-    }
-
-    /**
-     * A recursive function that will perform a bottom-up duplicate of
-     * the object tree with originalObject at the root. Recurses to
-     * the farthest leaf, then works its way back up again,
-     * cloning objects, and composing them with their child clones
-     * as it goes
-     * @private
-     * @returns {DomainObject} If the type of the original object allows for
-     * duplication, then a duplicate of the object, otherwise the object
-     * itself (to allow linking to non duplicatable objects).
-     */
-    async duplicateObject(originalObject) {
-        // Check if the creatable (or other passed in filter).
-        if (this.filter(originalObject)) {
-            // Clone original object
-            let clone = this.cloneObjectModel(originalObject);
-
-            // Get children, if any
-            let composeesCollection = this.openmct.composition.get(originalObject);
-            let composees;
-
-            if (composeesCollection) {
-                composees = await composeesCollection.load();
-            }
-
-            // Recursively duplicate children
-            return this.duplicateComposees(clone, composees);
-        }
-
-        // Not creatable, creating a link, no need to iterate children
-        return originalObject;
-    }
-
-    /**
-     * Update identifiers in a cloned object model (or part of
-     * a cloned object model) to reflect new identifiers after
-     * duplicating.
-     * @private
-     */
-    rewriteIdentifiers(obj, idMap) {
-        function lookupValue(value) {
-            return (typeof value === 'string' && idMap[value]) || value;
-        }
-
-        if (Array.isArray(obj)) {
-            obj.forEach((value, index) => {
-                obj[index] = lookupValue(value);
-                this.rewriteIdentifiers(obj[index], idMap);
-            });
-        } else if (obj && typeof obj === 'object') {
-            Object.keys(obj).forEach((key) => {
-                let value = obj[key];
-                obj[key] = lookupValue(value);
-                if (idMap[key]) {
-                    delete obj[key];
-                    obj[idMap[key]] = value;
-                }
-
-                this.rewriteIdentifiers(value, idMap);
-            });
-        }
-    }
-
-    /**
-     * Given an array of objects composed by a parent, clone them, then
-     * add them to the parent.
-     * @private
-     * @returns {*}
-     */
-    async duplicateComposees(clonedParent, composees = []) {
-        let idMap = {};
-
-        let allComposeesDuplicated = composees.reduce(async (previousPromise, nextComposee) => {
-            await previousPromise;
-            let clonedComposee = await this.duplicateObject(nextComposee);
-            idMap[this.getId(nextComposee)] = this.getId(clonedComposee);
-            await this.composeChild(clonedComposee, clonedParent, clonedComposee !== nextComposee);
-
-            return;
-        }, Promise.resolve());
-
-        await allComposeesDuplicated;
-
-        this.rewriteIdentifiers(clonedParent, idMap);
-        this.clones.push(clonedParent);
-
-        return clonedParent;
-    }
-
-    async composeChild(child, parent, setLocation) {
-        const PERSIST_BOOL = false;
-        let parentComposition = this.openmct.composition.get(parent);
-        await parentComposition.load();
-        parentComposition.add(child, PERSIST_BOOL);
-
-        //If a location is not specified, set it.
-        if (setLocation && child.location === undefined) {
-            let parentKeyString = this.getId(parent);
-            child.location = parentKeyString;
-        }
-    }
-
-    getTypeDefinition(domainObject, definition) {
-        let typeDefinitions = this.openmct.types.get(domainObject.type).definition;
-
-        return typeDefinitions[definition] || false;
-    }
-
-    cloneObjectModel(domainObject) {
-        let clone = JSON.parse(JSON.stringify(domainObject));
-        let identifier = {
-            key: uuid(),
-            namespace: domainObject.identifier.namespace
-        };
-
-        if (clone.modified || clone.persisted || clone.location) {
-            clone.modified = undefined;
-            clone.persisted = undefined;
-            clone.location = undefined;
-            delete clone.modified;
-            delete clone.persisted;
-            delete clone.location;
-        }
-
-        if (clone.composition) {
-            clone.composition = [];
-        }
-
-        clone.identifier = identifier;
-
-        return clone;
-    }
-
-    getId(domainObject) {
-        return this.openmct.objects.makeKeyString(domainObject.identifier);
-    }
-
-    isCreatable(domainObject) {
-        return this.getTypeDefinition(domainObject, 'creatable');
-    }
-}

src/plugins/duplicate/plugin.js

@@ -1,28 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2019, 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 DuplicateAction from "./DuplicateAction";
-
-export default function () {
-    return function (openmct) {
-        openmct.actions.register(new DuplicateAction(openmct));
-    };
-}

src/plugins/duplicate/pluginSpec.js

@@ -1,157 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 DuplicateActionPlugin from './plugin.js';
-import DuplicateAction from './DuplicateAction.js';
-import DuplicateTask from './DuplicateTask.js';
-import {
-    createOpenMct,
-    resetApplicationState,
-    getMockObjects
-} from 'utils/testing';
-
-describe("The Duplicate Action plugin", () => {
-
-    let openmct;
-    let duplicateTask;
-    let childObject;
-    let parentObject;
-    let anotherParentObject;
-
-    // this setups up the app
-    beforeEach((done) => {
-        openmct = createOpenMct();
-
-        childObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Child Folder",
-                    identifier: {
-                        namespace: "",
-                        key: "child-folder-object"
-                    }
-                }
-            }
-        }).folder;
-        parentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Parent Folder",
-                    composition: [childObject.identifier]
-                }
-            }
-        }).folder;
-        anotherParentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Another Parent Folder"
-                }
-            }
-        }).folder;
-
-        let objectGet = openmct.objects.get.bind(openmct.objects);
-        spyOn(openmct.objects, 'get').and.callFake((identifier) => {
-            let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === identifier.key);
-
-            if (!obj) {
-                // not one of the mocked objs, callthrough basically
-                return objectGet(identifier);
-            }
-
-            return Promise.resolve(obj);
-        });
-
-        spyOn(openmct.composition, 'get').and.callFake((domainObject) => {
-            return {
-                load: async () => {
-                    let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === domainObject.identifier.key);
-                    let children = [];
-
-                    if (obj) {
-                        for (let i = 0; i < obj.composition.length; i++) {
-                            children.push(await openmct.objects.get(obj.composition[i]));
-                        }
-                    }
-
-                    return Promise.resolve(children);
-                },
-                add: (child) => {
-                    domainObject.composition.push(child.identifier);
-                }
-            };
-        });
-
-        // already installed by default, but never hurts, just adds to context menu
-        openmct.install(DuplicateActionPlugin());
-
-        openmct.on('start', done);
-        openmct.startHeadless();
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    it("should be defined", () => {
-        expect(DuplicateActionPlugin).toBeDefined();
-    });
-
-    describe("when moving an object to a new parent", () => {
-
-        beforeEach(async (done) => {
-            duplicateTask = new DuplicateTask(openmct);
-            await duplicateTask.duplicate(parentObject, anotherParentObject);
-            done();
-        });
-
-        it("the duplicate child object's name (when not changing) should be the same as the original object", async () => {
-            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
-            let duplicatedObject = await openmct.objects.get(duplicatedObjectIdentifier);
-            let duplicateObjectName = duplicatedObject.name;
-
-            expect(duplicateObjectName).toEqual(parentObject.name);
-        });
-
-        it("the duplicate child object's identifier should be new", () => {
-            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
-
-            expect(duplicatedObjectIdentifier.key).not.toEqual(parentObject.identifier.key);
-        });
-    });
-
-    describe("when a new name is provided for the duplicated object", () => {
-        const NEW_NAME = 'New Name';
-
-        beforeEach(() => {
-            duplicateTask = new DuplicateAction(openmct);
-            duplicateTask.updateNameCheck(parentObject, NEW_NAME);
-        });
-
-        it("the name is updated", () => {
-            let childName = parentObject.name;
-            expect(childName).toEqual(NEW_NAME);
-        });
-    });
-
-});

src/plugins/folderView/components/GridItem.vue

@@ -1,10 +1,11 @@
 <template>
 <a
     class="l-grid-view__item c-grid-item"
-    :class="[{
+    :class="{
         'is-alias': item.isAlias === true,
+        'is-missing': item.model.status === 'missing',
         'c-grid-item--unknown': item.type.cssClass === undefined || item.type.cssClass.indexOf('unknown') !== -1
-    }, statusClass]"
+    }"
     :href="objectLink"
 >
     <div
@@ -26,8 +27,8 @@
         </div>
     </div>
     <div class="c-grid-item__controls">
-        <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+        <div class="is-missing__indicator"
+             title="This item is missing"
         ></div>
         <div
             class="icon-people"
@@ -45,10 +46,9 @@
 <script>
 import contextMenuGesture from '../../../ui/mixins/context-menu-gesture';
 import objectLink from '../../../ui/mixins/object-link';
-import statusListener from './status-listener';
 
 export default {
-    mixins: [contextMenuGesture, objectLink, statusListener],
+    mixins: [contextMenuGesture, objectLink],
     props: {
         item: {
             type: Object,

src/plugins/folderView/components/ListItem.vue

@@ -8,18 +8,18 @@
         <a
             ref="objectLink"
             class="c-object-label"
-            :class="[statusClass]"
+            :class="{ 'is-missing': item.model.status === 'missing' }"
             :href="objectLink"
         >
             <div
-                class="c-object-label__type-icon c-list-item__name__type-icon"
+                class="c-object-label__type-icon c-list-item__type-icon"
                 :class="item.type.cssClass"
             >
-                <span class="is-status__indicator"
-                      :title="`This item is ${status}`"
+                <span class="is-missing__indicator"
+                      title="This item is missing"
                 ></span>
             </div>
-            <div class="c-object-label__name c-list-item__name__name">{{ item.model.name }}</div>
+            <div class="c-object-label__name c-list-item__name">{{ item.model.name }}</div>
         </a>
     </td>
     <td class="c-list-item__type">
@@ -39,10 +39,9 @@
 import moment from 'moment';
 import contextMenuGesture from '../../../ui/mixins/context-menu-gesture';
 import objectLink from '../../../ui/mixins/object-link';
-import statusListener from './status-listener';
 
 export default {
-    mixins: [contextMenuGesture, objectLink, statusListener],
+    mixins: [contextMenuGesture, objectLink],
     props: {
         item: {
             type: Object,

src/plugins/folderView/components/grid-item.scss

@@ -0,0 +1,121 @@
+/******************************* GRID ITEMS */
+.c-grid-item {
+    // Mobile-first
+    @include button($bg: $colorItemBg, $fg: $colorItemFg);
+    cursor: pointer;
+    display: flex;
+    padding: $interiorMarginLg;
+
+    &__type-icon {
+        filter: $colorKeyFilter;
+        flex: 0 0 $gridItemMobile;
+        font-size: floor($gridItemMobile / 2);
+        margin-right: $interiorMarginLg;
+    }
+
+    &.is-alias {
+        // Object is an alias to an original.
+        [class*='__type-icon'] {
+            @include isAlias();
+            color: $colorIconAliasForKeyFilter;
+        }
+    }
+
+    &__details {
+        display: flex;
+        flex-flow: column nowrap;
+        flex: 1 1 auto;
+    }
+
+    &__name {
+        @include ellipsize();
+        color: $colorItemFg;
+        @include headerFont(1.2em);
+        margin-bottom: $interiorMarginSm;
+    }
+
+    &__metadata {
+        color: $colorItemFgDetails;
+        font-size: 0.9em;
+
+        body.mobile & {
+            [class*='__item-count'] {
+                &:before {
+                    content: ' - ';
+                }
+            }
+        }
+    }
+
+    &__controls {
+        color: $colorItemFgDetails;
+        flex: 0 0 64px;
+        font-size: 1.2em;
+        display: flex;
+        align-items: center;
+        justify-content: flex-end;
+
+        > * + * {
+            margin-left: $interiorMargin;
+        }
+    }
+
+    body.desktop & {
+        $transOutMs: 300ms;
+        flex-flow: column nowrap;
+        transition: background $transOutMs ease-in-out;
+
+        &:hover {
+            background: $colorItemBgHov;
+            transition: $transIn;
+
+            .c-grid-item__type-icon {
+                filter: $colorKeyFilterHov;
+                transform: scale(1);
+                transition: $transInBounce;
+            }
+        }
+
+        > * {
+            margin: 0; // Reset from mobile
+        }
+
+        &__controls {
+            align-items: start;
+            flex: 0 0 auto;
+            order: 1;
+            .c-info-button,
+            .c-pointer-icon { display: none; }
+        }
+
+        &__type-icon {
+            flex: 1 1 auto;
+            font-size: floor($gridItemDesk / 3);
+            margin: $interiorMargin 22.5% $interiorMargin * 3 22.5%;
+            order: 2;
+            transform: scale(0.9);
+            transform-origin: center;
+            transition: all $transOutMs ease-in-out;
+        }
+
+        &__details {
+            flex: 0 0 auto;
+            justify-content: flex-end;
+            order: 3;
+        }
+
+        &__metadata {
+            display: flex;
+
+            &__type {
+                flex: 1 1 auto;
+                @include ellipsize();
+            }
+
+            &__item-count {
+                opacity: 0.7;
+                flex: 0 0 auto;
+            }
+        }
+    }
+}

src/plugins/folderView/components/grid-view.scss

@@ -43,20 +43,9 @@
         }
     }
 
-    &.is-status--notebook-default {
-        .is-status__indicator {
-            display: block;
+    &.is-missing {
+        @include isMissing();
 
-            &:before {
-                color: $colorFilter;
-                content: $glyph-icon-notebook-page;
-                font-family: symbolsfont;
-            }
-        }
-    }
-
-    &[class*='is-status--missing'],
-    &[class*='is-status--suspect']{
         [class*='__type-icon'],
         [class*='__details'] {
             opacity: $opacityMissing;

src/plugins/folderView/components/list-item.scss

@@ -1,19 +1,11 @@
 /******************************* LIST ITEM */
 .c-list-item {
-    &__name__type-icon {
+    &__type-icon {
         color: $colorItemTreeIcon;
     }
 
-    &__name__name {
+    &__name {
         @include ellipsize();
-
-        a & {
-            color: $colorItemFg;
-        }
-    }
-
-    &:not(.c-list-item__name) {
-        color: $colorItemFgDetails;
     }
 
     &.is-alias {

src/plugins/folderView/components/list-view.scss

@@ -28,5 +28,9 @@
         padding-top: $p;
         padding-bottom: $p;
         width: 25%;
+
+        &:not(.c-list-item__name) {
+            color: $colorItemFgDetails;
+        }
     }
 }

src/plugins/folderView/components/status-listener.js

@@ -1,33 +0,0 @@
-export default {
-    inject: ['openmct'],
-    props: {
-        item: {
-            type: Object,
-            required: true
-        }
-    },
-    computed: {
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
-        }
-    },
-    data() {
-        return {
-            status: ''
-        };
-    },
-    methods: {
-        setStatus(status) {
-            this.status = status;
-        }
-    },
-    mounted() {
-        let identifier = this.item.model.identifier;
-
-        this.status = this.openmct.status.get(identifier);
-        this.removeStatusListener = this.openmct.status.observe(identifier, this.setStatus);
-    },
-    destroyed() {
-        this.removeStatusListener();
-    }
-};

src/plugins/goToOriginalAction/goToOriginalAction.js

@@ -25,8 +25,6 @@ export default class GoToOriginalAction {
         this.name = 'Go To Original';
         this.key = 'goToOriginal';
         this.description = 'Go to the original unlinked instance of this object';
-        this.group = 'action';
-        this.priority = 4;
 
         this._openmct = openmct;
     }

src/plugins/goToOriginalAction/plugin.js

@@ -23,6 +23,6 @@ import GoToOriginalAction from './goToOriginalAction';
 
 export default function () {
     return function (openmct) {
-        openmct.actions.register(new GoToOriginalAction(openmct));
+        openmct.contextMenu.registerAction(new GoToOriginalAction(openmct));
     };
 }

src/plugins/newFolderAction/newFolderAction.js

@@ -28,8 +28,6 @@ export default class NewFolderAction {
         this.key = 'newFolder';
         this.description = 'Create a new folder';
         this.cssClass = 'icon-folder-new';
-        this.group = "action";
-        this.priority = 9;
 
         this._openmct = openmct;
         this._dialogForm = {

src/plugins/newFolderAction/plugin.js

@@ -23,6 +23,6 @@ import NewFolderAction from './newFolderAction';
 
 export default function () {
     return function (openmct) {
-        openmct.actions.register(new NewFolderAction(openmct));
+        openmct.contextMenu.registerAction(new NewFolderAction(openmct));
     };
 }

src/plugins/newFolderAction/pluginSpec.js

@@ -40,7 +40,9 @@ describe("the plugin", () => {
         openmct.on('start', done);
         openmct.startHeadless();
 
-        newFolderAction = openmct.actions._allActions.newFolder;
+        newFolderAction = openmct.contextMenu._allActions.filter(action => {
+            return action.key === 'newFolder';
+        })[0];
     });
 
     afterEach(() => {

src/plugins/notebook/actions/CopyToNotebookAction.js

@@ -1,40 +0,0 @@
-import { getDefaultNotebook } from '../utils/notebook-storage';
-import { addNotebookEntry } from '../utils/notebook-entries';
-
-export default class CopyToNotebookAction {
-    constructor(openmct) {
-        this.openmct = openmct;
-
-        this.cssClass = 'icon-duplicate';
-        this.description = 'Copy value to notebook as an entry';
-        this.group = "action";
-        this.key = 'copyToNotebook';
-        this.name = 'Copy to Notebook';
-        this.priority = 1;
-    }
-
-    copyToNotebook(entryText) {
-        const notebookStorage = getDefaultNotebook();
-        this.openmct.objects.get(notebookStorage.notebookMeta.identifier)
-            .then(domainObject => {
-                addNotebookEntry(this.openmct, domainObject, notebookStorage, null, entryText);
-
-                const defaultPath = `${domainObject.name} - ${notebookStorage.section.name} - ${notebookStorage.page.name}`;
-                const msg = `Saved to Notebook ${defaultPath}`;
-                this.openmct.notifications.info(msg);
-            });
-    }
-
-    invoke(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
-
-        this.copyToNotebook(viewContext.formattedValueForCopy());
-    }
-
-    appliesTo(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
-
-        return viewContext && viewContext.formattedValueForCopy
-            && typeof viewContext.formattedValueForCopy === 'function';
-    }
-}

src/plugins/notebook/components/Notebook.vue

@@ -24,12 +24,12 @@
                  :default-section-id="defaultSectionId"
                  :domain-object="internalDomainObject"
                  :page-title="internalDomainObject.configuration.pageTitle"
+                 :pages="pages"
                  :section-title="internalDomainObject.configuration.sectionTitle"
                  :sections="sections"
-                 :selected-section="selectedSection"
                  :sidebar-covers-entries="sidebarCoversEntries"
-                 @pagesChanged="pagesChanged"
-                 @sectionsChanged="sectionsChanged"
+                 @updatePage="updatePage"
+                 @updateSection="updateSection"
                  @toggleNav="toggleNav"
         />
         <div class="c-notebook__page-view">
@@ -111,7 +111,7 @@ import Search from '@/ui/components/search.vue';
 import SearchResults from './SearchResults.vue';
 import Sidebar from './Sidebar.vue';
 import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaultNotebookSection, setDefaultNotebookPage } from '../utils/notebook-storage';
-import { addNotebookEntry, createNewEmbed, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
+import { DEFAULT_CLASS, addNotebookEntry, createNewEmbed, getNotebookEntries } from '../utils/notebook-entries';
 import objectUtils from 'objectUtils';
 
 import { throttle } from 'lodash';
@@ -220,7 +220,7 @@ export default {
                 return s;
             });
 
-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
             this.throttledSearchItem('');
         },
         createNotebookStorageObject() {
@@ -309,7 +309,7 @@ export default {
                 return null;
             }
 
-            return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier);
+            return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier).then(d => d);
         },
         getPage(section, id) {
             return section.pages.find(p => p.id === id);
@@ -379,6 +379,9 @@ export default {
 
             return this.sections.find(section => section.isSelected);
         },
+        mutateObject(key, value) {
+            this.openmct.objects.mutate(this.internalDomainObject, key, value);
+        },
         navigateToSectionPage() {
             const { pageId, sectionId } = this.openmct.router.getParams();
             if (!pageId || !sectionId) {
@@ -395,7 +398,7 @@ export default {
                 return s;
             });
 
-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
         },
         newEntry(embed = null) {
             this.search = '';
@@ -408,30 +411,19 @@ export default {
         orientationChange() {
             this.formatSidebar();
         },
-        pagesChanged({ pages = [], id = null}) {
-            const selectedSection = this.getSelectedSection();
-            if (!selectedSection) {
-                return;
-            }
-
-            selectedSection.pages = pages;
-            const sections = this.sections.map(section => {
-                if (section.id === selectedSection.id) {
-                    section = selectedSection;
-                }
-
-                return section;
-            });
-
-            this.sectionsChanged({ sections });
-            this.updateDefaultNotebookPage(pages, id);
-        },
         removeDefaultClass(domainObject) {
             if (!domainObject) {
                 return;
             }
 
-            this.openmct.status.delete(domainObject.identifier);
+            const classList = domainObject.classList || [];
+            const index = classList.indexOf(DEFAULT_CLASS);
+            if (!classList.length || index < 0) {
+                return;
+            }
+
+            classList.splice(index, 1);
+            this.openmct.objects.mutate(domainObject, 'classList', classList);
         },
         searchItem(input) {
             this.search = input;
@@ -448,14 +440,12 @@ export default {
                 setDefaultNotebook(this.openmct, notebookStorage);
             }
 
-            if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
+            if (this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
                 this.defaultSectionId = notebookStorage.section.id;
-                setDefaultNotebookSection(notebookStorage.section);
             }
 
-            if (this.defaultPageId && this.defaultPageId.length === 0 || this.defaultPageId !== notebookStorage.page.id) {
+            if (this.defaultPageId.length === 0 || this.defaultPageId !== notebookStorage.page.id) {
                 this.defaultPageId = notebookStorage.page.id;
-                setDefaultNotebookPage(notebookStorage.page);
             }
         },
         updateDefaultNotebookPage(pages, id) {
@@ -519,11 +509,29 @@ export default {
             const notebookEntries = configuration.entries || {};
             notebookEntries[this.selectedSection.id][this.selectedPage.id] = entries;
 
-            mutateObject(this.openmct, this.internalDomainObject, 'configuration.entries', notebookEntries);
+            this.mutateObject('configuration.entries', notebookEntries);
         },
         updateInternalDomainObject(domainObject) {
             this.internalDomainObject = domainObject;
         },
+        updatePage({ pages = [], id = null}) {
+            const selectedSection = this.getSelectedSection();
+            if (!selectedSection) {
+                return;
+            }
+
+            selectedSection.pages = pages;
+            const sections = this.sections.map(section => {
+                if (section.id === selectedSection.id) {
+                    section = selectedSection;
+                }
+
+                return section;
+            });
+
+            this.updateSection({ sections });
+            this.updateDefaultNotebookPage(pages, id);
+        },
         updateParams(sections) {
             const selectedSection = sections.find(s => s.isSelected);
             if (!selectedSection) {
@@ -547,8 +555,8 @@ export default {
                 pageId
             });
         },
-        sectionsChanged({ sections, id = null }) {
-            mutateObject(this.openmct, this.internalDomainObject, 'configuration.sections', sections);
+        updateSection({ sections, id = null }) {
+            this.mutateObject('configuration.sections', sections);
 
             this.updateParams(sections);
             this.updateDefaultNotebookSection(sections, id);

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -1,17 +1,29 @@
 <template>
 <div class="c-menu-button c-ctrl-wrapper c-ctrl-wrapper--menus-left">
     <button
-        class="c-icon-button c-button--menu icon-camera"
+        class="c-button--menu icon-notebook"
         title="Take a Notebook Snapshot"
-        @click.stop.prevent="showMenu"
+        @click="setNotebookTypes"
+        @click.stop="toggleMenu"
     >
-        <span
-            title="Take Notebook Snapshot"
-            class="c-icon-button__label"
-        >
-            Snapshot
-        </span>
+        <span class="c-button__label"></span>
     </button>
+    <div
+        v-show="showMenu"
+        class="c-menu"
+    >
+        <ul>
+            <li
+                v-for="(type, index) in notebookTypes"
+                :key="index"
+                :class="type.cssClass"
+                :title="type.name"
+                @click="snapshot(type)"
+            >
+                {{ type.name }}
+            </li>
+        </ul>
+    </div>
 </div>
 </template>
 
@@ -45,20 +57,22 @@ export default {
     data() {
         return {
             notebookSnapshot: null,
-            notebookTypes: []
+            notebookTypes: [],
+            showMenu: false
         };
     },
     mounted() {
         this.notebookSnapshot = new Snapshot(this.openmct);
-        this.setDefaultNotebookStatus();
+
+        document.addEventListener('click', this.hideMenu);
+    },
+    destroyed() {
+        document.removeEventListener('click', this.hideMenu);
     },
     methods: {
-        showMenu(event) {
+        setNotebookTypes() {
             const notebookTypes = [];
             const defaultNotebook = getDefaultNotebook();
-            const elementBoundingClientRect = this.$el.getBoundingClientRect();
-            const x = elementBoundingClientRect.x;
-            const y = elementBoundingClientRect.y + elementBoundingClientRect.height;
 
             if (defaultNotebook) {
                 const domainObject = defaultNotebook.domainObject;
@@ -69,24 +83,28 @@ export default {
                     notebookTypes.push({
                         cssClass: 'icon-notebook',
                         name: `Save to Notebook ${defaultPath}`,
-                        callBack: () => {
-                            return this.snapshot(NOTEBOOK_DEFAULT);
-                        }
+                        type: NOTEBOOK_DEFAULT
                     });
                 }
             }
 
             notebookTypes.push({
-                cssClass: 'icon-camera',
+                cssClass: 'icon-notebook',
                 name: 'Save to Notebook Snapshots',
-                callBack: () => {
-                    return this.snapshot(NOTEBOOK_SNAPSHOT);
-                }
+                type: NOTEBOOK_SNAPSHOT
             });
 
-            this.openmct.menus.showMenu(x, y, notebookTypes);
+            this.notebookTypes = notebookTypes;
         },
-        snapshot(notebookType) {
+        toggleMenu() {
+            this.showMenu = !this.showMenu;
+        },
+        hideMenu() {
+            this.showMenu = false;
+        },
+        snapshot(notebook) {
+            this.hideMenu();
+
             this.$nextTick(() => {
                 const element = document.querySelector('.c-overlay__contents')
                     || document.getElementsByClassName('l-shell__main-container')[0];
@@ -104,17 +122,8 @@ export default {
                     openmct: this.openmct
                 };
 
-                this.notebookSnapshot.capture(snapshotMeta, notebookType, element);
+                this.notebookSnapshot.capture(snapshotMeta, notebook.type, element);
             });
-        },
-        setDefaultNotebookStatus() {
-            let defaultNotebookObject = getDefaultNotebook();
-
-            if (defaultNotebookObject && defaultNotebookObject.notebookMeta) {
-                let notebookIdentifier = defaultNotebookObject.notebookMeta.identifier;
-
-                this.openmct.status.set(notebookIdentifier, 'notebook-default');
-            }
         }
     }
 };

src/plugins/notebook/components/NotebookSnapshotContainer.vue

@@ -4,7 +4,7 @@
         <div class="l-browse-bar__start">
             <div class="l-browse-bar__object-name--w">
                 <div class="l-browse-bar__object-name c-object-label">
-                    <div class="c-object-label__type-icon icon-camera"></div>
+                    <div class="c-object-label__type-icon icon-notebook"></div>
                     <div class="c-object-label__name">
                         Notebook Snapshots
                         <span v-if="snapshots.length"

src/plugins/notebook/components/NotebookSnapshotIndicator.vue

@@ -1,5 +1,5 @@
 <template>
-<div class="c-indicator c-indicator--clickable icon-camera"
+<div class="c-indicator c-indicator--clickable icon-notebook"
      :class="[
          { 's-status-off': snapshotCount === 0 },
          { 's-status-on': snapshotCount > 0 },

src/plugins/notebook/components/PageCollection.vue

@@ -66,10 +66,14 @@ export default {
             }
         }
     },
+    data() {
+        return {
+        };
+    },
     methods: {
         deletePage(id) {
             const selectedSection = this.sections.find(s => s.isSelected);
-            const page = this.pages.find(p => p.id !== id);
+            const page = this.pages.filter(p => p.id !== id);
             deleteNotebookEntries(this.openmct, this.domainObject, selectedSection, page);
 
             const selectedPage = this.pages.find(p => p.isSelected);

src/plugins/notebook/components/SectionCollection.vue

@@ -53,6 +53,10 @@ export default {
             }
         }
     },
+    data() {
+        return {
+        };
+    },
     methods: {
         deleteSection(id) {
             const section = this.sections.find(s => s.id === id);

src/plugins/notebook/components/Sidebar.vue

@@ -18,7 +18,7 @@
                                :domain-object="domainObject"
                                :sections="sections"
                                :section-title="sectionTitle"
-                               @updateSection="sectionsChanged"
+                               @updateSection="updateSection"
             />
         </div>
     </div>
@@ -48,7 +48,7 @@
                             :sidebar-covers-entries="sidebarCoversEntries"
                             :page-title="pageTitle"
                             @toggleNav="toggleNav"
-                            @updatePage="pagesChanged"
+                            @updatePage="updatePage"
             />
         </div>
     </div>
@@ -85,6 +85,13 @@ export default {
                 return {};
             }
         },
+        pages: {
+            type: Array,
+            required: true,
+            default() {
+                return [];
+            }
+        },
         pageTitle: {
             type: String,
             default() {
@@ -115,16 +122,9 @@ export default {
         return {
         };
     },
-    computed: {
-        pages() {
-            const selectedSection = this.sections.find(section => section.isSelected);
-
-            return selectedSection && selectedSection.pages || [];
-        }
-    },
     watch: {
-        pages(newPages) {
-            if (!newPages.length) {
+        pages(newpages) {
+            if (!newpages.length) {
                 this.addPage();
             }
         },
@@ -141,79 +141,55 @@ export default {
     },
     methods: {
         addPage() {
-            const newPage = this.createNewPage();
-            const pages = this.addNewPage(newPage);
-
-            this.pagesChanged({
-                pages,
-                id: newPage.id
-            });
-        },
-        addSection() {
-            const newSection = this.createNewSection();
-            const sections = this.addNewSection(newSection);
-
-            this.sectionsChanged({
-                sections,
-                id: newSection.id
-            });
-        },
-        addNewPage(page) {
-            const pages = this.pages.map(p => {
-                p.isSelected = false;
-
-                return p;
-            });
-
-            return pages.concat(page);
-        },
-        addNewSection(section) {
-            const sections = this.sections.map(s => {
-                s.isSelected = false;
-
-                return s;
-            });
-
-            return sections.concat(section);
-        },
-        createNewPage() {
             const pageTitle = this.pageTitle;
             const id = uuid();
-
-            return {
+            const page = {
                 id,
                 isDefault: false,
                 isSelected: true,
                 name: `Unnamed ${pageTitle}`,
                 pageTitle
             };
-        },
-        createNewSection() {
-            const sectionTitle = this.sectionTitle;
-            const id = uuid();
-            const page = this.createNewPage();
-            const pages = [page];
 
-            return {
-                id,
-                isDefault: false,
-                isSelected: true,
-                name: `Unnamed ${sectionTitle}`,
-                pages,
-                sectionTitle
-            };
-        },
-        toggleNav() {
-            this.$emit('toggleNav');
-        },
-        pagesChanged({ pages, id }) {
-            this.$emit('pagesChanged', {
+            this.pages.forEach(p => p.isSelected = false);
+            const pages = this.pages.concat(page);
+
+            this.updatePage({
                 pages,
                 id
             });
         },
-        sectionsChanged({ sections, id }) {
-            this.$emit('sectionsChanged', {
+        addSection() {
+            const sectionTitle = this.sectionTitle;
+            const id = uuid();
+            const section = {
+                id,
+                isDefault: false,
+                isSelected: true,
+                name: `Unnamed ${sectionTitle}`,
+                pages: [],
+                sectionTitle
+            };
+
+            this.sections.forEach(s => s.isSelected = false);
+            const sections = this.sections.concat(section);
+
+            this.updateSection({
+                sections,
+                id
+            });
+        },
+        toggleNav() {
+            this.$emit('toggleNav');
+        },
+        updatePage({ pages, id }) {
+            this.$emit('updatePage', {
+                pages,
+                id
+            });
+        },
+        updateSection({ sections, id }) {
+            this.$emit('updateSection', {
                 sections,
                 id
             });

src/plugins/notebook/plugin.js

@@ -1,4 +1,3 @@
-import CopyToNotebookAction from './actions/CopyToNotebookAction';
 import Notebook from './components/Notebook.vue';
 import NotebookSnapshotIndicator from './components/NotebookSnapshotIndicator.vue';
 import SnapshotContainer from './snapshot-container';
@@ -14,8 +13,6 @@ export default function NotebookPlugin() {
 
         installed = true;
 
-        openmct.actions.register(new CopyToNotebookAction(openmct));
-
         const notebookType = {
             name: 'Notebook',
             description: 'Create and save timestamped notes with embedded object snapshots.',

src/plugins/notebook/pluginSpec.js

@@ -20,7 +20,7 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import { createOpenMct, resetApplicationState } from 'utils/testing';
+import { createOpenMct, createMouseEvent, resetApplicationState } from 'utils/testing';
 import NotebookPlugin from './plugin';
 import Vue from 'vue';
 
@@ -133,4 +133,90 @@ describe("Notebook plugin:", () => {
             expect(hasMajorElements).toBe(true);
         });
     });
+
+    describe("Notebook Snapshots view:", () => {
+        let snapshotIndicator;
+        let drawerElement;
+
+        function clickSnapshotIndicator() {
+            const indicator = element.querySelector('.icon-notebook');
+            const button = indicator.querySelector('button');
+            const clickEvent = createMouseEvent('click');
+
+            button.dispatchEvent(clickEvent);
+        }
+
+        beforeAll(() => {
+            snapshotIndicator = openmct.indicators.indicatorObjects
+                .find(indicator => indicator.key === 'notebook-snapshot-indicator').element;
+
+            element.append(snapshotIndicator);
+
+            return Vue.nextTick();
+        });
+
+        afterAll(() => {
+            snapshotIndicator.remove();
+            if (drawerElement) {
+                drawerElement.remove();
+            }
+        });
+
+        beforeEach(() => {
+            drawerElement = document.querySelector('.l-shell__drawer');
+        });
+
+        afterEach(() => {
+            if (drawerElement) {
+                drawerElement.classList.remove('is-expanded');
+            }
+        });
+
+        it("has Snapshots indicator", () => {
+            const hasSnapshotIndicator = snapshotIndicator !== null && snapshotIndicator !== undefined;
+            expect(hasSnapshotIndicator).toBe(true);
+        });
+
+        it("snapshots container has class isExpanded", () => {
+            let classes = drawerElement.classList;
+            const isExpandedBefore = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterFirstClick = classes.contains('is-expanded');
+
+            const success = isExpandedBefore === false
+                && isExpandedAfterFirstClick === true;
+
+            expect(success).toBe(true);
+        });
+
+        it("snapshots container does not have class isExpanded", () => {
+            let classes = drawerElement.classList;
+            const isExpandedBefore = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterFirstClick = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterSecondClick = classes.contains('is-expanded');
+
+            const success = isExpandedBefore === false
+                && isExpandedAfterFirstClick === true
+                && isExpandedAfterSecondClick === false;
+
+            expect(success).toBe(true);
+        });
+
+        it("show notebook snapshots container text", () => {
+            clickSnapshotIndicator();
+
+            const notebookSnapshots = drawerElement.querySelector('.l-browse-bar__object-name');
+            const snapshotsText = notebookSnapshots.textContent.trim();
+
+            expect(snapshotsText).toBe('Notebook Snapshots');
+        });
+    });
 });

src/plugins/notebook/snapshot.js

@@ -49,7 +49,7 @@ export default class Snapshot {
             .then(domainObject => {
                 addNotebookEntry(this.openmct, domainObject, notebookStorage, embed);
 
-                const defaultPath = `${domainObject.name} - ${notebookStorage.section.name} - ${notebookStorage.page.name}`;
+                const defaultPath = `${domainObject.name} > ${notebookStorage.section.name} > ${notebookStorage.page.name}`;
                 const msg = `Saved to Notebook ${defaultPath}`;
                 this._showNotification(msg);
             });

src/plugins/notebook/utils/notebook-entries.js

@@ -1,6 +1,6 @@
 import objectLink from '../../../ui/mixins/object-link';
 
-export const DEFAULT_CLASS = 'notebook-default';
+export const DEFAULT_CLASS = 'is-notebook-default';
 const TIME_BOUNDS = {
     START_BOUND: 'tc.startBound',
     END_BOUND: 'tc.endBound',
@@ -8,29 +8,6 @@ const TIME_BOUNDS = {
     END_DELTA: 'tc.endDelta'
 };
 
-export function addEntryIntoPage(notebookStorage, entries, entry) {
-    const defaultSection = notebookStorage.section;
-    const defaultPage = notebookStorage.page;
-    if (!defaultSection || !defaultPage) {
-        return;
-    }
-
-    const newEntries = JSON.parse(JSON.stringify(entries));
-    let section = newEntries[defaultSection.id];
-    if (!section) {
-        newEntries[defaultSection.id] = {};
-    }
-
-    let page = newEntries[defaultSection.id][defaultPage.id];
-    if (!page) {
-        newEntries[defaultSection.id][defaultPage.id] = [];
-    }
-
-    newEntries[defaultSection.id][defaultPage.id].push(entry);
-
-    return newEntries;
-}
-
 export function getHistoricLinkInFixedMode(openmct, bounds, historicLink) {
     if (historicLink.includes('tc.mode=fixed')) {
         return historicLink;
@@ -61,6 +38,35 @@ export function getHistoricLinkInFixedMode(openmct, bounds, historicLink) {
     return params.join('&');
 }
 
+export function getNotebookDefaultEntries(notebookStorage, domainObject) {
+    if (!notebookStorage || !domainObject) {
+        return null;
+    }
+
+    const defaultSection = notebookStorage.section;
+    const defaultPage = notebookStorage.page;
+    if (!defaultSection || !defaultPage) {
+        return null;
+    }
+
+    const configuration = domainObject.configuration;
+    const entries = configuration.entries || {};
+
+    let section = entries[defaultSection.id];
+    if (!section) {
+        section = {};
+        entries[defaultSection.id] = section;
+    }
+
+    let page = entries[defaultSection.id][defaultPage.id];
+    if (!page) {
+        page = [];
+        entries[defaultSection.id][defaultPage.id] = [];
+    }
+
+    return entries[defaultSection.id][defaultPage.id];
+}
+
 export function createNewEmbed(snapshotMeta, snapshot = '') {
     const {
         bounds,
@@ -97,7 +103,7 @@ export function createNewEmbed(snapshotMeta, snapshot = '') {
     };
 }
 
-export function addNotebookEntry(openmct, domainObject, notebookStorage, embed = null, entryText = '') {
+export function addNotebookEntry(openmct, domainObject, notebookStorage, embed = null) {
     if (!openmct || !domainObject || !notebookStorage) {
         return;
     }
@@ -114,25 +120,24 @@ export function addNotebookEntry(openmct, domainObject, notebookStorage, embed =
         ? [embed]
         : [];
 
+    const defaultEntries = getNotebookDefaultEntries(notebookStorage, domainObject);
     const id = `entry-${date}`;
-    const entry = {
+    defaultEntries.push({
         id,
         createdOn: date,
-        text: entryText,
+        text: '',
         embeds
-    };
+    });
 
-    const newEntries = addEntryIntoPage(notebookStorage, entries, entry);
-
-    addDefaultClass(domainObject, openmct);
-    openmct.objects.mutate(domainObject, 'configuration.entries', newEntries);
+    addDefaultClass(domainObject);
+    openmct.objects.mutate(domainObject, 'configuration.entries', entries);
 
     return id;
 }
 
 export function getNotebookEntries(domainObject, selectedSection, selectedPage) {
     if (!domainObject || !selectedSection || !selectedPage) {
-        return;
+        return null;
     }
 
     const configuration = domainObject.configuration;
@@ -140,12 +145,12 @@ export function getNotebookEntries(domainObject, selectedSection, selectedPage)
 
     let section = entries[selectedSection.id];
     if (!section) {
-        return;
+        return null;
     }
 
     let page = entries[selectedSection.id][selectedPage.id];
     if (!page) {
-        return;
+        return null;
     }
 
     return entries[selectedSection.id][selectedPage.id];
@@ -191,13 +196,14 @@ export function deleteNotebookEntries(openmct, domainObject, selectedSection, se
 
     delete entries[selectedSection.id][selectedPage.id];
 
-    mutateObject(openmct, domainObject, 'configuration.entries', entries);
+    openmct.objects.mutate(domainObject, 'configuration.entries', entries);
 }
 
-export function mutateObject(openmct, object, key, value) {
-    openmct.objects.mutate(object, key, value);
-}
+function addDefaultClass(domainObject) {
+    const classList = domainObject.classList || [];
+    if (classList.includes(DEFAULT_CLASS)) {
+        return;
+    }
 
-function addDefaultClass(domainObject, openmct) {
-    openmct.status.set(domainObject.identifier, DEFAULT_CLASS);
+    classList.push(DEFAULT_CLASS);
 }

src/plugins/notebook/utils/notebook-entriesSpec.js

@@ -20,7 +20,7 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 import * as NotebookEntries from './notebook-entries';
-import { createOpenMct, resetApplicationState } from 'utils/testing';
+import { createOpenMct, spyOnBuiltins, resetApplicationState } from 'utils/testing';
 
 const notebookStorage = {
     domainObject: {
@@ -121,6 +121,7 @@ describe('Notebook Entries:', () => {
     beforeEach(done => {
         openmct = createOpenMct();
         window.localStorage.setItem('notebook-storage', null);
+        spyOnBuiltins(['mutate'], openmct.objects);
 
         done();
     });
@@ -136,16 +137,24 @@ describe('Notebook Entries:', () => {
         expect(entries.length).toEqual(0);
     });
 
-    it('addNotebookEntry adds entry', (done) => {
-        const unlisten = openmct.objects.observe(notebookDomainObject, '*', (object) => {
-            const entries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);
-
-            expect(entries.length).toEqual(1);
-            done();
-            unlisten();
-        });
-
+    it('addNotebookEntry mutates object', () => {
         NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+
+        expect(openmct.objects.mutate).toHaveBeenCalled();
+    });
+
+    it('addNotebookEntry adds entry', () => {
+        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        const entries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);
+
+        expect(entries.length).toEqual(1);
+    });
+
+    it('getEntryPosById returns valid position', () => {
+        const entryId = NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        const position = NotebookEntries.getEntryPosById(entryId, notebookDomainObject, selectedSection, selectedPage);
+
+        expect(position).toEqual(0);
     });
 
     it('getEntryPosById returns valid position', () => {
@@ -165,13 +174,22 @@ describe('Notebook Entries:', () => {
         expect(success).toBe(true);
     });
 
-    it('deleteNotebookEntries deletes correct page entries', () => {
+    it('deleteNotebookEntries mutates object', () => {
+        openmct.objects.mutate.calls.reset();
+
+        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        NotebookEntries.deleteNotebookEntries(openmct, notebookDomainObject, selectedSection, selectedPage);
+
+        expect(openmct.objects.mutate).toHaveBeenCalledTimes(2);
+    });
+
+    it('deleteNotebookEntries deletes correct entry', () => {
         NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
         NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
 
         NotebookEntries.deleteNotebookEntries(openmct, notebookDomainObject, selectedSection, selectedPage);
         const afterEntries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);
 
-        expect(afterEntries).toEqual(undefined);
+        expect(afterEntries).toEqual(null);
     });
 });

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

@@ -40,7 +40,7 @@
                 <div class="c-state-indicator__alert-cursor-lock icon-cursor-lock" title="Cursor is point locked. Click anywhere in the plot to unlock."></div>
                 <div class="plot-legend-item"
                      ng-class="{
-                        'is-status--missing': series.domainObject.status === 'missing'
+                        'is-missing': series.domainObject.status === 'missing'
                     }"
                      ng-repeat="series in series track by $index"
                 >
@@ -48,7 +48,7 @@
                         <span class="plot-series-color-swatch"
                               ng-style="{ 'background-color': series.get('color').asHexString() }">
                         </span>
-                        <span class="is-status__indicator" title="This item is missing or suspect"></span>
+                        <span class="is-missing__indicator" title="This item is missing"></span>
                         <span class="plot-series-name">{{ series.nameWithUnit() }}</span>
                     </div>
                     <div class="plot-series-value hover-value-enabled value-to-display-{{ legend.get('valueToShowWhenCollapsed') }} {{ series.closest.mctLimitState.cssClass }}"
@@ -95,14 +95,14 @@
                     <tr ng-repeat="series in series"
                         class="plot-legend-item"
                         ng-class="{
-                            'is-status--missing': series.domainObject.status === 'missing'
+                            'is-missing': series.domainObject.status === 'missing'
                         }"
                     >
                         <td class="plot-series-swatch-and-name">
                             <span class="plot-series-color-swatch"
                                   ng-style="{ 'background-color': series.get('color').asHexString() }">
                             </span>
-                            <span class="is-status__indicator" title="This item is missing or suspect"></span>
+                            <span class="is-missing__indicator" title="This item is missing"></span>
                             <span class="plot-series-name">{{ series.get('name') }}</span>
                         </td>
 

src/plugins/plot/src/configuration/YAxisModel.js

@@ -171,7 +171,6 @@ define([
          * Update yAxis format, values, and label from known series.
          */
         updateFromSeries: function (series) {
-            this.unset('displayRange');
             const plotModel = this.plot.get('domainObject');
             const label = _.get(plotModel, 'configuration.yAxis.label');
             const sampleSeries = series.first();

src/plugins/plugins.js

@@ -58,8 +58,7 @@ define([
     './newFolderAction/plugin',
     './persistence/couch/plugin',
     './defaultRootName/plugin',
-    './timeline/plugin',
-    './viewDatumAction/plugin'
+    './timeline/plugin'
 ], function (
     _,
     UTCTimeSystem,
@@ -98,8 +97,7 @@ define([
     NewFolderAction,
     CouchDBPlugin,
     DefaultRootName,
-    Timeline,
-    ViewDatumAction
+    Timeline
 ) {
     const bundleMap = {
         LocalStorage: 'platform/persistence/local',
@@ -193,7 +191,6 @@ define([
     plugins.ISOTimeFormat = ISOTimeFormat.default;
     plugins.DefaultRootName = DefaultRootName.default;
     plugins.Timeline = Timeline.default;
-    plugins.ViewDatumAction = ViewDatumAction.default;
 
     return plugins;
 });

src/plugins/remove/RemoveAction.js

@@ -25,8 +25,6 @@ export default class RemoveAction {
         this.key = 'remove';
         this.description = 'Remove this object from its containing object.';
         this.cssClass = "icon-trash";
-        this.group = "action";
-        this.priority = 1;
 
         this.openmct = openmct;
     }
@@ -105,16 +103,6 @@ export default class RemoveAction {
         let parentType = parent && this.openmct.types.get(parent.type);
         let child = objectPath[0];
         let locked = child.locked ? child.locked : parent && parent.locked;
-        let isEditing = this.openmct.editor.isEditing();
-
-        if (isEditing) {
-            let currentItemInView = this.openmct.router.path[0];
-            let domainObject = objectPath[0];
-
-            if (this.openmct.objects.areIdsEqual(currentItemInView.identifier, domainObject.identifier)) {
-                return false;
-            }
-        }
 
         if (locked) {
             return false;

src/plugins/remove/plugin.js

@@ -23,6 +23,6 @@ import RemoveAction from "./RemoveAction";
 
 export default function () {
     return function (openmct) {
-        openmct.actions.register(new RemoveAction(openmct));
+        openmct.contextMenu.registerAction(new RemoveAction(openmct));
     };
 }

src/plugins/tabs/components/tabs.vue

@@ -20,8 +20,8 @@
             Drag objects here to add them to this view.
         </div>
         <div
-            v-for="(tab, index) in tabsList"
-            :key="tab.keyString"
+            v-for="(tab,index) in tabsList"
+            :key="index"
             class="c-tab c-tabs-view__tab"
             :class="{
                 'is-current': isCurrent(tab)
@@ -29,13 +29,13 @@
             @click="showTab(tab, index)"
         >
             <div class="c-tabs-view__tab__label c-object-label"
-                 :class="[tab.status ? `is-status--${tab.status}` : '']"
+                 :class="{'is-missing': tab.domainObject.status === 'missing'}"
             >
                 <div class="c-object-label__type-icon"
                      :class="tab.type.definition.cssClass"
                 >
-                    <span class="is-status__indicator"
-                          :title="`This item is ${tab.status}`"
+                    <span class="is-missing__indicator"
+                          title="This item is missing"
                     ></span>
                 </div>
                 <span class="c-button__label c-object-label__name">{{ tab.domainObject.name }}</span>
@@ -47,8 +47,8 @@
         </div>
     </div>
     <div
-        v-for="tab in tabsList"
-        :key="tab.keyString"
+        v-for="(tab, index) in tabsList"
+        :key="index"
         class="c-tabs-view__object-holder"
         :class="{'c-tabs-view__object-holder--hidden': !isCurrent(tab)}"
     >
@@ -56,7 +56,6 @@
             v-if="internalDomainObject.keep_alive ? currentTab : isCurrent(tab)"
             class="c-tabs-view__object"
             :object="tab.domainObject"
-            :object-path="tab.objectPath"
         />
     </div>
 </div>
@@ -79,7 +78,7 @@ const unknownObjectType = {
 };
 
 export default {
-    inject: ['openmct', 'domainObject', 'composition', 'objectPath'],
+    inject: ['openmct', 'domainObject', 'composition'],
     components: {
         ObjectView
     },
@@ -140,10 +139,6 @@ export default {
         this.composition.off('remove', this.removeItem);
         this.composition.off('reorder', this.onReorder);
 
-        this.tabsList.forEach(tab => {
-            tab.statusUnsubscribe();
-        });
-
         this.unsubscribe();
         this.clearCurrentTabIndexFromURL();
 
@@ -197,19 +192,10 @@ export default {
         },
         addItem(domainObject) {
             let type = this.openmct.types.get(domainObject.type) || unknownObjectType;
-            let keyString = this.openmct.objects.makeKeyString(domainObject.identifier);
-            let status = this.openmct.status.get(domainObject.identifier);
-            let statusUnsubscribe = this.openmct.status.observe(keyString, (updatedStatus) => {
-                this.updateStatus(keyString, updatedStatus);
-            });
-            let objectPath = [domainObject].concat(this.objectPath.slice());
             let tabItem = {
                 domainObject,
-                status,
-                statusUnsubscribe,
-                objectPath,
-                type,
-                keyString
+                type: type,
+                key: this.openmct.objects.makeKeyString(domainObject.identifier)
             };
 
             this.tabsList.push(tabItem);
@@ -225,12 +211,10 @@ export default {
         },
         removeItem(identifier) {
             let pos = this.tabsList.findIndex(tab =>
-                tab.domainObject.identifier.namespace === identifier.namespace && tab.domainObject.identifier.keyString === identifier.keyString
+                tab.domainObject.identifier.namespace === identifier.namespace && tab.domainObject.identifier.key === identifier.key
             );
             let tabToBeRemoved = this.tabsList[pos];
 
-            tabToBeRemoved.statusUnsubscribe();
-
             this.tabsList.splice(pos, 1);
 
             if (this.isCurrent(tabToBeRemoved)) {
@@ -268,7 +252,7 @@ export default {
             this.allowDrop = false;
         },
         isCurrent(tab) {
-            return this.currentTab.keyString === tab.keyString;
+            return this.currentTab.key === tab.key;
         },
         updateInternalDomainObject(domainObject) {
             this.internalDomainObject = domainObject;
@@ -286,16 +270,6 @@ export default {
         },
         clearCurrentTabIndexFromURL() {
             deleteSearchParam(this.searchTabKey);
-        },
-        updateStatus(keyString, status) {
-            let tabPos = this.tabsList.findIndex((tab) => {
-                return tab.keyString === keyString;
-            });
-
-            if (tabPos !== -1) {
-                let tab = this.tabsList[tabPos];
-                this.$set(tab, 'status', status);
-            }
         }
     }
 };

src/plugins/tabs/tabs.js

@@ -38,7 +38,7 @@ define([
             canEdit: function (domainObject) {
                 return domainObject.type === 'tabs';
             },
-            view: function (domainObject, objectPath) {
+            view: function (domainObject) {
                 let component;
 
                 return {
@@ -56,7 +56,6 @@ define([
                             provide: {
                                 openmct,
                                 domainObject,
-                                objectPath,
                                 composition: openmct.composition.get(domainObject)
                             },
                             template: '<tabs-component :isEditing="isEditing"></tabs-component>'

src/plugins/telemetryTable/TelemetryTable.js

@@ -180,6 +180,7 @@ define([
         processHistoricalData(telemetryData, columnMap, keyString, limitEvaluator) {
             let telemetryRows = telemetryData.map(datum => new TelemetryTableRow(datum, columnMap, keyString, limitEvaluator));
             this.boundedRows.add(telemetryRows);
+            this.emit('historical-rows-processed');
         }
 
         /**

src/plugins/telemetryTable/TelemetryTableRow.js

@@ -26,7 +26,6 @@ define([], function () {
             this.columns = columns;
 
             this.datum = createNormalizedDatum(datum, columns);
-            this.fullDatum = datum;
             this.limitEvaluator = limitEvaluator;
             this.objectKeyString = objectKeyString;
         }
@@ -88,7 +87,7 @@ define([], function () {
         }
 
         getContextMenuActions() {
-            return ['viewDatumAction'];
+            return [];
         }
     }
 

src/plugins/telemetryTable/TelemetryTableViewProvider.js

@@ -54,13 +54,15 @@ define([
             view(domainObject, objectPath) {
                 let table = new TelemetryTable(domainObject, openmct);
                 let component;
+
                 let markingProp = {
                     enable: true,
                     useAlternateControlBar: false,
                     rowName: '',
                     rowNamePlural: ''
                 };
-                const view = {
+
+                return {
                     show: function (element, editMode) {
                         component = new Vue({
                             el: element,
@@ -70,8 +72,7 @@ define([
                             data() {
                                 return {
                                     isEditing: editMode,
-                                    markingProp,
-                                    view
+                                    markingProp
                                 };
                             },
                             provide: {
@@ -79,7 +80,7 @@ define([
                                 table,
                                 objectPath
                             },
-                            template: '<table-component ref="tableComponent" :isEditing="isEditing" :marking="markingProp" :view="view"/>'
+                            template: '<table-component :isEditing="isEditing" :marking="markingProp"/>'
                         });
                     },
                     onEditModeChange(editMode) {
@@ -88,22 +89,11 @@ define([
                     onClearData() {
                         table.clearData();
                     },
-                    getViewContext() {
-                        if (component) {
-                            return component.$refs.tableComponent.getViewContext();
-                        } else {
-                            return {
-                                type: 'telemetry-table'
-                            };
-                        }
-                    },
                     destroy: function (element) {
                         component.$destroy();
                         component = undefined;
                     }
                 };
-
-                return view;
             },
             priority() {
                 return 1;

src/plugins/telemetryTable/ViewActions.js

@@ -1,123 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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.
- *****************************************************************************/
-
-let exportCSV = {
-    name: 'Export Table Data',
-    key: 'export-csv-all',
-    description: "Export this view's data",
-    cssClass: 'icon-download labeled',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().exportAllDataAsCSV();
-    },
-    group: 'view'
-};
-let exportMarkedRows = {
-    name: 'Export Marked Rows',
-    key: 'export-csv-marked',
-    description: "Export marked rows as CSV",
-    cssClass: 'icon-download labeled',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().exportMarkedRows();
-    },
-    group: 'view'
-};
-let unmarkAllRows = {
-    name: 'Unmark All Rows',
-    key: 'unmark-all-rows',
-    description: 'Unmark all rows',
-    cssClass: 'icon-x labeled',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().unmarkAllRows();
-    },
-    showInStatusBar: true,
-    group: 'view'
-};
-let pause = {
-    name: 'Pause',
-    key: 'pause-data',
-    description: 'Pause real-time data flow',
-    cssClass: 'icon-pause',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().togglePauseByButton();
-    },
-    showInStatusBar: true,
-    group: 'view'
-};
-let play = {
-    name: 'Play',
-    key: 'play-data',
-    description: 'Continue real-time data flow',
-    cssClass: 'c-button pause-play is-paused',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().togglePauseByButton();
-    },
-    showInStatusBar: true,
-    group: 'view'
-};
-let expandColumns = {
-    name: 'Expand Columns',
-    key: 'expand-columns',
-    description: "Increase column widths to fit currently available data.",
-    cssClass: 'icon-arrows-right-left labeled',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().expandColumns();
-    },
-    showInStatusBar: true,
-    group: 'view'
-};
-let autosizeColumns = {
-    name: 'Autosize Columns',
-    key: 'autosize-columns',
-    description: "Automatically size columns to fit the table into the available space.",
-    cssClass: 'icon-expand labeled',
-    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().autosizeColumns();
-    },
-    showInStatusBar: true,
-    group: 'view'
-};
-
-let viewActions = [
-    exportCSV,
-    exportMarkedRows,
-    unmarkAllRows,
-    pause,
-    play,
-    expandColumns,
-    autosizeColumns
-];
-
-viewActions.forEach(action => {
-    action.appliesTo = (objectPath, viewProvider = {}) => {
-        let viewContext = viewProvider.getViewContext && viewProvider.getViewContext();
-
-        if (viewContext) {
-            let type = viewContext.type;
-
-            return type === 'telemetry-table';
-        }
-
-        return false;
-    };
-});
-
-export default viewActions;

src/plugins/telemetryTable/components/table-row.vue

@@ -102,16 +102,7 @@ export default {
                 selectable[columnKeys] = this.row.columns[columnKeys].selectable;
 
                 return selectable;
-            }, {}),
-            actionsViewContext: {
-                getViewContext: () => {
-                    return {
-                        viewHistoricalData: true,
-                        viewDatumAction: true,
-                        getDatum: this.getDatum
-                    };
-                }
-            }
+            }, {})
         };
     },
     computed: {
@@ -179,25 +170,14 @@ export default {
                 event.stopPropagation();
             }
         },
-        getDatum() {
-            return this.row.fullDatum;
-        },
         showContextMenu: function (event) {
             event.preventDefault();
 
-            this.markRow(event);
-
             this.row.getContextualDomainObject(this.openmct, this.row.objectKeyString).then(domainObject => {
                 let contextualObjectPath = this.objectPath.slice();
                 contextualObjectPath.unshift(domainObject);
 
-                let actionsCollection = this.openmct.actions.get(contextualObjectPath, this.actionsViewContext);
-                let allActions = actionsCollection.getActionsObject();
-                let applicableActions = this.row.getContextMenuActions().map(key => allActions[key]);
-
-                if (applicableActions.length) {
-                    this.openmct.menus.showMenu(event.x, event.y, applicableActions);
-                }
+                this.openmct.contextMenu._showContextMenuForObjectPath(contextualObjectPath, event.x, event.y, this.row.getContextMenuActions());
             });
         }
     }

src/plugins/telemetryTable/components/table.vue

@@ -23,7 +23,8 @@
 <div class="c-table-wrapper"
      :class="{ 'is-paused': paused }"
 >
-    <div v-if="enableLegacyToolbar"
+    <!-- main contolbar  start-->
+    <div v-if="!marking.useAlternateControlBar"
          class="c-table-control-bar c-control-bar"
     >
         <button
@@ -93,6 +94,7 @@
 
         <slot name="buttons"></slot>
     </div>
+    <!-- main controlbar end -->
 
     <!-- alternate controlbar start -->
     <div v-if="marking.useAlternateControlBar"
@@ -111,11 +113,11 @@
 
         <button
             :class="{'hide-nice': !markedRows.length}"
-            class="c-icon-button icon-x labeled"
+            class="c-button icon-x labeled"
             title="Deselect All"
             @click="unmarkAllRows()"
         >
-            <span class="c-icon-button__label">{{ `Deselect ${marking.disableMultiSelect ? '' : 'All'}` }} </span>
+            <span class="c-button__label">{{ `Deselect ${marking.disableMultiSelect ? '' : 'All'}` }} </span>
         </button>
 
         <slot name="buttons"></slot>
@@ -299,12 +301,12 @@ export default {
             default: true
         },
         allowFiltering: {
-            type: Boolean,
-            default: true
+            'type': Boolean,
+            'default': true
         },
         allowSorting: {
-            type: Boolean,
-            default: true
+            'type': Boolean,
+            'default': true
         },
         marking: {
             type: Object,
@@ -317,17 +319,6 @@ export default {
                     rowNamePlural: ""
                 };
             }
-        },
-        enableLegacyToolbar: {
-            type: Boolean,
-            default: false
-        },
-        view: {
-            type: Object,
-            required: false,
-            default() {
-                return {};
-            }
         }
     },
     data() {
@@ -403,40 +394,6 @@ export default {
         markedRows: {
             handler(newVal, oldVal) {
                 this.$emit('marked-rows-updated', newVal, oldVal);
-
-                if (this.viewActionsCollection) {
-                    if (newVal.length > 0) {
-                        this.viewActionsCollection.enable(['export-csv-marked', 'unmark-all-rows']);
-                    } else if (newVal.length === 0) {
-                        this.viewActionsCollection.disable(['export-csv-marked', 'unmark-all-rows']);
-                    }
-                }
-            }
-        },
-        paused: {
-            handler(newVal) {
-                if (this.viewActionsCollection) {
-                    if (newVal) {
-                        this.viewActionsCollection.hide(['pause-data']);
-                        this.viewActionsCollection.show(['play-data']);
-                    } else {
-                        this.viewActionsCollection.hide(['play-data']);
-                        this.viewActionsCollection.show(['pause-data']);
-                    }
-                }
-            }
-        },
-        isAutosizeEnabled: {
-            handler(newVal) {
-                if (this.viewActionsCollection) {
-                    if (newVal) {
-                        this.viewActionsCollection.show(['expand-columns']);
-                        this.viewActionsCollection.hide(['autosize-columns']);
-                    } else {
-                        this.viewActionsCollection.show(['autosize-columns']);
-                        this.viewActionsCollection.hide(['expand-columns']);
-                    }
-                }
             }
         }
     },
@@ -449,11 +406,6 @@ export default {
         this.rowsRemoved = _.throttle(this.rowsRemoved, 200);
         this.scroll = _.throttle(this.scroll, 100);
 
-        if (!this.marking.useAlternateControlBar && !this.enableLegacyToolbar) {
-            this.viewActionsCollection = this.openmct.actions.get(this.objectPath, this.view);
-            this.initializeViewActions();
-        }
-
         this.table.on('object-added', this.addObject);
         this.table.on('object-removed', this.removeObject);
         this.table.on('outstanding-requests', this.outstandingRequests);
@@ -894,7 +846,7 @@ export default {
 
                 for (let i = firstRowIndex; i <= lastRowIndex; i++) {
                     let row = allRows[i];
-                    this.$set(row, 'marked', true);
+                    row.marked = true;
 
                     if (row !== baseRow) {
                         this.markedRows.push(row);
@@ -956,40 +908,6 @@ export default {
 
             this.$nextTick().then(this.calculateColumnWidths);
         },
-        getViewContext() {
-            return {
-                type: 'telemetry-table',
-                exportAllDataAsCSV: this.exportAllDataAsCSV,
-                exportMarkedRows: this.exportMarkedRows,
-                unmarkAllRows: this.unmarkAllRows,
-                togglePauseByButton: this.togglePauseByButton,
-                expandColumns: this.recalculateColumnWidths,
-                autosizeColumns: this.autosizeColumns
-            };
-        },
-        initializeViewActions() {
-            if (this.markedRows.length > 0) {
-                this.viewActionsCollection.enable(['export-csv-marked', 'unmark-all-rows']);
-            } else if (this.markedRows.length === 0) {
-                this.viewActionsCollection.disable(['export-csv-marked', 'unmark-all-rows']);
-            }
-
-            if (this.paused) {
-                this.viewActionsCollection.hide(['pause-data']);
-                this.viewActionsCollection.show(['play-data']);
-            } else {
-                this.viewActionsCollection.hide(['play-data']);
-                this.viewActionsCollection.show(['pause-data']);
-            }
-
-            if (this.isAutosizeEnabled) {
-                this.viewActionsCollection.show(['expand-columns']);
-                this.viewActionsCollection.hide(['autosize-columns']);
-            } else {
-                this.viewActionsCollection.show(['autosize-columns']);
-                this.viewActionsCollection.hide(['expand-columns']);
-            }
-        },
         setRowHeight(height) {
             this.rowHeight = height;
             this.setHeight();

src/plugins/telemetryTable/plugin.js

@@ -23,13 +23,11 @@
 define([
     './TelemetryTableViewProvider',
     './TableConfigurationViewProvider',
-    './TelemetryTableType',
-    './ViewActions'
+    './TelemetryTableType'
 ], function (
     TelemetryTableViewProvider,
     TableConfigurationViewProvider,
-    TelemetryTableType,
-    TelemetryTableViewActions
+    TelemetryTableType
 ) {
     return function plugin() {
         return function install(openmct) {
@@ -43,10 +41,6 @@ define([
                     return true;
                 }
             });
-
-            TelemetryTableViewActions.default.forEach(action => {
-                openmct.actions.register(action);
-            });
         };
     };
 });

src/plugins/telemetryTable/pluginSpec.js

@@ -168,8 +168,6 @@ describe("the plugin", () => {
                 return telemetryPromise;
             });
 
-            openmct.router.path = [testTelemetryObject];
-
             applicableViews = openmct.objectViews.get(testTelemetryObject);
             tableViewProvider = applicableViews.find((viewProvider) => viewProvider.key === 'table');
             tableView = tableViewProvider.view(testTelemetryObject, [testTelemetryObject]);

src/plugins/timeline/Plan.vue

@@ -61,21 +61,13 @@ export default {
         this.openmct.time.on("timeSystem", this.setScaleAndPlotActivities);
         this.openmct.time.on("bounds", this.updateViewBounds);
         this.resizeTimer = setInterval(this.resize, RESIZE_POLL_INTERVAL);
-        this.unlisten = this.openmct.objects.observe(this.domainObject, '*', this.observeForChanges);
     },
     destroyed() {
         clearInterval(this.resizeTimer);
         this.openmct.time.off("timeSystem", this.setScaleAndPlotActivities);
         this.openmct.time.off("bounds", this.updateViewBounds);
-        if (this.unlisten) {
-            this.unlisten();
-        }
     },
     methods: {
-        observeForChanges(mutatedObject) {
-            this.validateJSON(mutatedObject.selectFile.body);
-            this.setScaleAndPlotActivities();
-        },
         resize() {
             if (this.$refs.axisHolder.clientWidth !== this.width) {
                 this.setDimensions();
@@ -208,7 +200,7 @@ export default {
             return 0;
         },
         // Get the row where the next activity will land.
-        getRowForActivity(rectX, width, minimumActivityRow = 0) {
+        getRowForActivity(rectX, width, defaultActivityRow = 0) {
             let currentRow;
             let sortedActivityRows = Object.keys(this.activitiesByRow).sort(this.sortFn);
 
@@ -224,18 +216,17 @@ export default {
 
             for (let i = 0; i < sortedActivityRows.length; i++) {
                 let row = sortedActivityRows[i];
-                if (row >= minimumActivityRow && getOverlap(this.activitiesByRow[row])) {
+                if (getOverlap(this.activitiesByRow[row])) {
                     currentRow = row;
                     break;
                 }
             }
 
             if (currentRow === undefined && sortedActivityRows.length) {
-                let row = Math.max(parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10), minimumActivityRow);
-                currentRow = row + ROW_HEIGHT + ROW_PADDING;
+                currentRow = parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10) + ROW_HEIGHT + ROW_PADDING;
             }
 
-            return (currentRow || minimumActivityRow);
+            return (currentRow || defaultActivityRow);
         },
         calculatePlanLayout() {
             this.activitiesByRow = {};
@@ -245,9 +236,8 @@ export default {
             let groups = Object.keys(this.json);
             groups.forEach((key, index) => {
                 let activities = this.json[key];
-                //set the new group's first row. It should be greater than the largest row of the last group
-                let sortedActivityRows = Object.keys(this.activitiesByRow).sort(this.sortFn);
-                const groupRowStart = sortedActivityRows.length ? parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10) + 1 : 0;
+                //set the currentRow to the beginning of the next logical row
+                currentRow = currentRow + ROW_HEIGHT * index;
                 let newGroup = true;
                 activities.forEach((activity) => {
                     if (this.isActivityInBounds(activity)) {
@@ -266,9 +256,9 @@ export default {
                         const textWidth = textStart + this.getTextWidth(textLines[0]) + TEXT_LEFT_PADDING;
 
                         if (activityNameFitsRect) {
-                            currentRow = this.getRowForActivity(rectX, rectWidth, groupRowStart);
+                            currentRow = this.getRowForActivity(rectX, rectWidth);
                         } else {
-                            currentRow = this.getRowForActivity(rectX, textWidth, groupRowStart);
+                            currentRow = this.getRowForActivity(rectX, textWidth);
                         }
 
                         let textY = parseInt(currentRow, 10) + (activityNameFitsRect ? INNER_TEXT_PADDING : OUTER_TEXT_PADDING);

src/plugins/utcTimeSystem/LocalClockSpec.js

@@ -1,9 +1,9 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * http://www.apache.org/licenses/LICENSE-2.0.
@@ -14,16 +14,31 @@
  * License for the specific language governing permissions and limitations
  * under the License.
  *
- * Open MCT includes source code licensed under additional open source
+ * Open MCT Web includes source code licensed under additional open source
  * licenses. See the Open Source Licenses file (LICENSES.md) included with
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import ViewDatumAction from './ViewDatumAction.js';
+define(["./LocalClock"], function (LocalClock) {
+    describe("The LocalClock class", function () {
+        let clock;
+        let mockTimeout;
+        const timeoutHandle = {};
 
-export default function plugin() {
-    return function install(openmct) {
-        openmct.actions.register(new ViewDatumAction(openmct));
-    };
-}
+        beforeEach(function () {
+            mockTimeout = jasmine.createSpy("timeout");
+            mockTimeout.and.returnValue(timeoutHandle);
+
+            clock = new LocalClock(0);
+            clock.start();
+        });
+
+        it("calls listeners on tick with current time", function () {
+            const mockListener = jasmine.createSpy("listener");
+            clock.on('tick', mockListener);
+            clock.tick();
+            expect(mockListener).toHaveBeenCalledWith(jasmine.any(Number));
+        });
+    });
+});

src/plugins/utcTimeSystem/UTCTimeSystemSpec.js

@@ -0,0 +1,48 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(['./UTCTimeSystem'], function (UTCTimeSystem) {
+    describe("The UTCTimeSystem class", function () {
+        let timeSystem;
+        let mockTimeout;
+
+        beforeEach(function () {
+            mockTimeout = jasmine.createSpy("timeout");
+            timeSystem = new UTCTimeSystem(mockTimeout);
+        });
+
+        it("Uses the UTC time format", function () {
+            expect(timeSystem.timeFormat).toBe('utc');
+        });
+
+        it("is UTC based", function () {
+            expect(timeSystem.isUTCBased).toBe(true);
+        });
+
+        it("defines expected metadata", function () {
+            expect(timeSystem.key).toBeDefined();
+            expect(timeSystem.name).toBeDefined();
+            expect(timeSystem.cssClass).toBeDefined();
+            expect(timeSystem.durationFormat).toBeDefined();
+        });
+    });
+});

src/plugins/utcTimeSystem/pluginSpec.js

@@ -1,103 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 LocalClock from './LocalClock.js';
-import UTCTimeSystem from './UTCTimeSystem';
-import {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe("The UTC Time System", () => {
-    const UTC_SYSTEM_AND_FORMAT_KEY = 'utc';
-    let openmct;
-    let utcTimeSystem;
-    let mockTimeout;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        openmct.install(openmct.plugins.UTCTimeSystem());
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    describe("plugin", function () {
-
-        beforeEach(function () {
-            mockTimeout = jasmine.createSpy("timeout");
-            utcTimeSystem = new UTCTimeSystem(mockTimeout);
-        });
-
-        it("is installed", () => {
-            let timeSystems = openmct.time.getAllTimeSystems();
-            let utc = timeSystems.find(ts => ts.key === UTC_SYSTEM_AND_FORMAT_KEY);
-
-            expect(utc).not.toEqual(-1);
-        });
-
-        it("can be set to be the main time system", () => {
-            openmct.time.timeSystem(UTC_SYSTEM_AND_FORMAT_KEY, {
-                start: 0,
-                end: 4
-            });
-
-            expect(openmct.time.timeSystem().key).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-        });
-
-        it("uses the utc time format", () => {
-            expect(utcTimeSystem.timeFormat).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-        });
-
-        it("is UTC based", () => {
-            expect(utcTimeSystem.isUTCBased).toBe(true);
-        });
-
-        it("defines expected metadata", () => {
-            expect(utcTimeSystem.key).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-            expect(utcTimeSystem.name).toBeDefined();
-            expect(utcTimeSystem.cssClass).toBeDefined();
-            expect(utcTimeSystem.durationFormat).toBeDefined();
-        });
-    });
-
-    describe("LocalClock class", function () {
-        let clock;
-        const timeoutHandle = {};
-
-        beforeEach(function () {
-            mockTimeout = jasmine.createSpy("timeout");
-            mockTimeout.and.returnValue(timeoutHandle);
-
-            clock = new LocalClock(0);
-            clock.start();
-        });
-
-        it("calls listeners on tick with current time", function () {
-            const mockListener = jasmine.createSpy("listener");
-            clock.on('tick', mockListener);
-            clock.tick();
-            expect(mockListener).toHaveBeenCalledWith(jasmine.any(Number));
-        });
-    });
-});

src/plugins/viewDatumAction/ViewDatumAction.js

@@ -1,69 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 MetadataListView from './components/MetadataList.vue';
-import Vue from 'vue';
-
-export default class ViewDatumAction {
-    constructor(openmct) {
-        this.name = 'View Full Datum';
-        this.key = 'viewDatumAction';
-        this.description = 'View full value of datum received';
-        this.cssClass = 'icon-object';
-
-        this._openmct = openmct;
-    }
-    invoke(objectPath, view) {
-        let viewContext = view.getViewContext && view.getViewContext();
-        let attributes = viewContext.getDatum && viewContext.getDatum();
-        let component = new Vue ({
-            provide: {
-                name: this.name,
-                attributes
-            },
-            components: {
-                MetadataListView
-            },
-            template: '<MetadataListView />'
-        });
-
-        this._openmct.overlays.overlay({
-            element: component.$mount().$el,
-            size: 'large',
-            dismissable: true,
-            onDestroy: () => {
-                component.$destroy();
-            }
-        });
-    }
-    appliesTo(objectPath, view = {}) {
-        let viewContext = (view.getViewContext && view.getViewContext()) || {};
-        let datum = viewContext.getDatum;
-        let enabled = viewContext.viewDatumAction;
-
-        if (enabled && datum) {
-            return true;
-        }
-
-        return false;
-    }
-}

src/plugins/viewDatumAction/components/MetadataList.vue

@@ -1,24 +0,0 @@
-<template>
-<div class="c-attributes-view">
-    <div class="c-overlay__top-bar">
-        <div class="c-overlay__dialog-title">{{ name }}</div>
-    </div>
-    <div class="c-overlay__contents-main l-preview-window__object-view">
-        <ul class="c-attributes-view__content">
-            <li
-                v-for="attribute in Object.keys(attributes)"
-                :key="attribute"
-            >
-                <span class="c-attributes-view__grid-item__label">{{ attribute }}</span>
-                <span class="c-attributes-view__grid-item__value">{{ attributes[attribute] }}</span>
-            </li>
-        </ul>
-    </div>
-</div>
-</template>
-
-<script>
-export default {
-    inject: ['name', 'attributes']
-};
-</script>

src/plugins/viewDatumAction/components/metadata-list.scss

@@ -1,30 +0,0 @@
-.c-attributes-view {
-    display: flex;
-    flex: 1 1 auto;
-    flex-direction: column;
-
-    > * {
-        flex: 0 0 auto;
-    }
-
-    &__content {
-        $p: 3px;
-
-        display: grid;
-        grid-template-columns: max-content 1fr;
-        grid-row-gap: $p;
-
-        li { display: contents; }
-
-        [class*="__grid-item"] {
-            border-bottom: 1px solid rgba(#999, 0.2);
-            padding: 0 5px $p 0;
-        }
-
-        [class*="__label"] {
-            opacity: 0.8;
-        }
-    }
-
-
-}

src/plugins/viewDatumAction/pluginSpec.js

@@ -1,95 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, 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 {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe("the plugin", () => {
-    let openmct;
-    let viewDatumAction;
-    let mockObjectPath;
-    let mockView;
-    let mockDatum;
-
-    beforeEach((done) => {
-        openmct = createOpenMct();
-
-        openmct.on('start', done);
-        openmct.startHeadless();
-
-        viewDatumAction = openmct.actions._allActions.viewDatumAction;
-
-        mockObjectPath = [{
-            name: 'mock object',
-            type: 'telemetry-table',
-            identifier: {
-                key: 'mock-object',
-                namespace: ''
-            }
-        }];
-
-        mockDatum = {
-            time: 123456789,
-            sin: 0.4455512,
-            cos: 0.4455512
-        };
-
-        mockView = {
-            getViewContext: () => {
-                return {
-                    viewDatumAction: true,
-                    getDatum: () => {
-                        return mockDatum;
-                    }
-                };
-            }
-        };
-
-        done();
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it('installs the view datum action', () => {
-        expect(viewDatumAction).toBeDefined();
-    });
-
-    describe('when invoked', () => {
-
-        beforeEach((done) => {
-            openmct.overlays.overlay = function (options) {};
-
-            spyOn(openmct.overlays, 'overlay');
-
-            viewDatumAction.invoke(mockObjectPath, mockView);
-
-            done();
-        });
-
-        it('uses an overlay to show user datum values', () => {
-            expect(openmct.overlays.overlay).toHaveBeenCalled();
-        });
-    });
-});

src/styles/_constants-espresso.scss

@@ -218,7 +218,7 @@ $colorBtnActiveFg: $colorOkFg;
 $colorBtnSelectedBg: $colorSelectedBg;
 $colorBtnSelectedFg: $colorSelectedFg;
 $colorClickIconButton: $colorKey;
-$colorClickIconButtonBgHov: rgba($colorKey, 0.3);
+$colorClickIconButtonBgHov: rgba($colorKey, 0.6);
 $colorClickIconButtonFgHov: $colorKeyHov;
 $colorDropHint: $colorKey;
 $colorDropHintBg: pushBack($colorDropHint, 10%);
@@ -378,11 +378,6 @@ $colorItemTreeVC: $colorDisclosureCtrl;
 $colorItemTreeVCHover: $colorDisclosureCtrlHov;
 $shdwItemTreeIcon: none;
 
-// Layout frame controls
-$frameControlsColorFg: white;
-$frameControlsColorBg: $colorKey;
-$frameControlsShdw: $shdwMenu;
-
 // Images
 $colorThumbHoverBg: $colorItemTreeHoverBg;
 

src/styles/_constants-maelstrom.scss

@@ -382,11 +382,6 @@ $colorItemTreeVC: $colorDisclosureCtrl;
 $colorItemTreeVCHover: $colorDisclosureCtrlHov;
 $shdwItemTreeIcon: none;
 
-// Layout frame controls
-$frameControlsColorFg: white;
-$frameControlsColorBg: $colorKey;
-$frameControlsShdw: $shdwMenu;
-
 // Images
 $colorThumbHoverBg: $colorItemTreeHoverBg;
 

src/styles/_constants-snow.scss

@@ -80,13 +80,13 @@ $uiColor: #289fec; // Resize bars, splitter bars, etc.
 $colorInteriorBorder: rgba($colorBodyFg, 0.2);
 $colorA: $colorBodyFg;
 $colorAHov: $colorKey;
-$filterHov: hue-rotate(-10deg) brightness(0.8) contrast(2); // Tree, location items
-$colorSelectedBg: pushBack($colorKey, 40%);
+$filterHov: brightness(0.8) contrast(2); // Tree, location items
+$colorSelectedBg: rgba($colorKey, 0.2);
 $colorSelectedFg: pullForward($colorBodyFg, 10%);
 
 // Object labels
 $objectLabelTypeIconOpacity: 0.5;
-$objectLabelNameFilter: brightness(0.9);
+$objectLabelNameFilter: brightness(0.5);
 
 // Layout
 $shellMainPad: 4px 0;
@@ -378,11 +378,6 @@ $colorItemTreeVC: $colorDisclosureCtrl;
 $colorItemTreeVCHover: $colorDisclosureCtrlHov;
 $shdwItemTreeIcon: none;
 
-// Layout frame controls
-$frameControlsColorFg: $colorClickIconButton;
-$frameControlsColorBg: $colorMenuBg;
-$frameControlsShdw: $shdwMenu;
-
 // Images
 $colorThumbHoverBg: $colorItemTreeHoverBg;
 

src/styles/_controls.scss

@@ -126,7 +126,7 @@ button {
 
 .c-icon-button {
     [class*='label'] {
-        opacity: 0.8;
+        opacity: 0.6;
     }
 
     &--mixed {
@@ -468,6 +468,9 @@ select {
 
     > * {
         flex: 0 0 auto;
+        //+ * {
+        //    margin-top: $interiorMarginSm;
+        //}
     }
 }
 
@@ -497,8 +500,8 @@ select {
             min-width: 1em;
         }
 
-        &:not([class*='icon']):before {
-             content: ''; // Enable :before so that menu items without an icon still indent properly
+        &:not([class]):before {
+             content: ''; // Add this element so that menu items without an icon still indent properly
         }
     }
 }
@@ -509,7 +512,7 @@ select {
 
     &__section-hint {
         $m: $interiorMargin;
-        margin: 0 0 $m 0;
+        margin: $m 0;
         padding: $m nth($menuItemPad, 2) 0 nth($menuItemPad, 2);
 
         opacity: 0.6;
@@ -521,7 +524,7 @@ select {
         $m: $interiorMargin;
         border-top: 1px solid $colorInteriorBorder;
         margin: $m 0;
-        padding: 0 nth($menuItemPad, 2) 0 nth($menuItemPad, 2);
+        padding: $m nth($menuItemPad, 2) 0 nth($menuItemPad, 2);
     }
 }
 

src/styles/_legacy-plots.scss

@@ -59,8 +59,14 @@ mct-plot {
     }
 
     /*********************** MISSING ITEM INDICATORS */
-    .is-status__indicator {
-        font-size: 0.8em;
+    .is-missing__indicator {
+        display: none;
+    }
+    .is-missing {
+        @include isMissing();
+        .is-missing__indicator {
+            font-size: 0.8em;
+        }
     }
 }
 

src/styles/_mixins.scss

@@ -129,26 +129,31 @@
     }
 }
 
-@mixin isStatus($absPos: false, $glyph: '', $color: $colorBodyFg) {
-    // Supports CSS classing as follows:
-    // is-status--missing, is-status--suspect, etc.
+@mixin isMissing($absPos: false) {
     // Common styles to be applied to tree items, object labels, grid and list item views
+    //opacity: 0.7;
+    //pointer-events: none; // Don't think we can do this, as disables title hover on icon element
 
-    .is-status__indicator {
-        display: block ; // Set to display: none in status.scss
+    .is-missing__indicator {
+        display: none ;
         text-shadow: $colorBodyBg 0 0 2px;
+        color: $colorAlert;
         font-family: symbolsfont;
 
-        @if $absPos {
+        &:before {
+            content: $glyph-icon-alert-triangle;
+        }
+    }
+
+    @if $absPos {
+        .is-missing__indicator {
             position: absolute;
             z-index: 3;
         }
-
-        &:before {
-            color: $color;
-            content: $glyph;
-        }
     }
+
+    &.is-missing .is-missing__indicator,
+    .is-missing .is-missing__indicator { display: block !important; }
 }
 
 @mixin bgDiagonalStripes($c: yellow, $a: 0.1, $d: 40px) {
@@ -497,8 +502,8 @@
 }
 
 @mixin cClickIconButtonLayout() {
-    $pLR: 5px;
-    $pTB: 5px;
+    $pLR: 4px;
+    $pTB: 4px;
     padding: $pTB $pLR;
 
     &:before,
@@ -517,7 +522,6 @@
     @include cControl();
     @include cClickIconButtonLayout();
     background: none;
-    color: $colorClickIconButton;
     box-shadow: none;
     cursor: pointer;
     transition: $transOut;
@@ -526,8 +530,7 @@
     @include hover() {
         transition: $transIn;
         background: $colorClickIconButtonBgHov;
-        //color: $colorClickIconButtonFgHov;
-        filter: $filterHov;
+        color: $colorClickIconButtonFgHov;
     }
 
     &[class*="--major"] {

src/styles/_status.scss

@@ -198,17 +198,3 @@ tr {
 
 .u-alert { @include uIndicator($colorAlert, $colorAlertFg, $glyph-icon-alert-triangle); }
 .u-error { @include uIndicator($colorError, $colorErrorFg, $glyph-icon-alert-triangle); }
-
-.is-status {
-    &__indicator {
-        display: none; // Default state; is set to block when within an actual is-status class
-    }
-
-    &--missing {
-        @include isStatus($glyph: $glyph-icon-alert-triangle, $color: $colorAlert);
-    }
-
-    &--suspect {
-        @include isStatus($glyph: $glyph-icon-alert-rect, $color: $colorWarningLo);
-    }
-}

src/styles/_table.scss

@@ -97,7 +97,6 @@ div.c-table {
             }
         }
         .c-table-control-bar {
-            .c-icon-button,
             .c-click-icon,
             .c-button {
                 &__label {

src/styles/notebook.scss

@@ -213,16 +213,17 @@
     }
 }
 
-.is-notebook-default,
-.is-status--notebook-default {
+.is-notebook-default {
     &:after {
         color: $colorFilter;
+        content: $glyph-icon-notebook-page;
+        display: block;
         font-family: symbolsfont;
         font-size: 0.9em;
+        margin-left: $interiorMargin;
     }
 
     &.c-list__item:after {
-        content: $glyph-icon-notebook-page;
         flex: 1 0 auto;
         text-align: right;
     }

src/styles/vue-styles.scss

@@ -27,7 +27,6 @@
 @import "../plugins/timeConductor/conductor-mode-icon.scss";
 @import "../plugins/timeConductor/date-picker.scss";
 @import "../plugins/timeline/timeline-axis.scss";
-@import "../plugins/viewDatumAction/components/metadata-list.scss";
 @import "../ui/components/object-frame.scss";
 @import "../ui/components/object-label.scss";
 @import "../ui/components/progress-bar.scss";