Ignore right clicks on pane resizes (#4151)

.github/workflows/codeql-analysis.yml

@@ -1,33 +0,0 @@
-
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  schedule:
-    - cron: '28 21 * * 3'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: javascript
-
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

index.html

@@ -195,7 +195,6 @@
             ['table', 'telemetry.plot.overlay', 'telemetry.plot.stacked'],
             {indicator: true}
         ));
-        openmct.install(openmct.plugins.Clock({ enableClockIndicator: true }));
         openmct.start();
     </script>
 </html>

package.json

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

platform/commonUI/edit/bundle.js

@@ -33,6 +33,10 @@ define([
     "./src/actions/CancelAction",
     "./src/policies/EditPersistableObjectsPolicy",
     "./src/representers/EditRepresenter",
+    "./src/capabilities/EditorCapability",
+    "./src/capabilities/TransactionCapabilityDecorator",
+    "./src/services/TransactionManager",
+    "./src/services/TransactionService",
     "./src/creation/CreateMenuController",
     "./src/creation/LocatorController",
     "./src/creation/CreationPolicy",
@@ -58,6 +62,10 @@ define([
     CancelAction,
     EditPersistableObjectsPolicy,
     EditRepresenter,
+    EditorCapability,
+    TransactionCapabilityDecorator,
+    TransactionManager,
+    TransactionService,
     CreateMenuController,
     LocatorController,
     CreationPolicy,
@@ -255,6 +263,26 @@ define([
                     }
                 ],
                 "components": [
+                    {
+                        "type": "decorator",
+                        "provides": "capabilityService",
+                        "implementation": TransactionCapabilityDecorator,
+                        "depends": [
+                            "$q",
+                            "transactionManager"
+                        ],
+                        "priority": "fallback"
+                    },
+                    {
+                        "type": "provider",
+                        "provides": "transactionService",
+                        "implementation": TransactionService,
+                        "depends": [
+                            "$q",
+                            "$log",
+                            "cacheService"
+                        ]
+                    },
                     {
                         "key": "CreateActionProvider",
                         "provides": "actionService",
@@ -285,12 +313,33 @@ define([
                         ]
                     }
                 ],
+                "capabilities": [
+                    {
+                        "key": "editor",
+                        "name": "Editor Capability",
+                        "description": "Provides transactional editing capabilities",
+                        "implementation": EditorCapability,
+                        "depends": [
+                            "transactionService",
+                            "openmct"
+                        ]
+                    }
+                ],
                 "controls": [
                     {
                         "key": "locator",
                         "template": locatorTemplate
                     }
                 ],
+                "services": [
+                    {
+                        "key": "transactionManager",
+                        "implementation": TransactionManager,
+                        "depends": [
+                            "transactionService"
+                        ]
+                    }
+                ],
                 "runs": [
                     {
                         depends: [

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

@@ -0,0 +1,113 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(
+    [],
+    function () {
+
+        /**
+         * A capability that implements an editing 'session' for a domain
+         * object. An editing session is initiated via a call to .edit().
+         * Once initiated, any persist operations will be queued pending a
+         * subsequent call to [.save()](@link #save) or [.finish()](@link
+         * #finish).
+         * @param transactionService
+         * @param domainObject
+         * @constructor
+         */
+        function EditorCapability(
+            transactionService,
+            openmct,
+            domainObject
+        ) {
+            this.transactionService = transactionService;
+            this.openmct = openmct;
+            this.domainObject = domainObject;
+        }
+
+        /**
+         * Initiate an editing session. This will start a transaction during
+         * which any persist operations will be deferred until either save()
+         * or finish() are called.
+         */
+        EditorCapability.prototype.edit = function () {
+            console.warn('DEPRECATED: cannot edit via edit capability, use openmct.editor instead.');
+
+            if (!this.openmct.editor.isEditing()) {
+                this.openmct.editor.edit();
+                this.domainObject.getCapability('status').set('editing', true);
+            }
+        };
+
+        /**
+         * Determines whether this object, or any of its ancestors are
+         * currently being edited.
+         * @returns boolean
+         */
+        EditorCapability.prototype.inEditContext = function () {
+            return this.openmct.editor.isEditing();
+        };
+
+        /**
+         * Is this the root editing object (ie. the object that the user
+         * clicked 'edit' on)?
+         * @returns {*}
+         */
+        EditorCapability.prototype.isEditContextRoot = function () {
+            return this.openmct.editor.isEditing();
+        };
+
+        /**
+         * Save any unsaved changes from this editing session. This will
+         * end the current transaction and continue with a new one.
+         * @returns {*}
+         */
+        EditorCapability.prototype.save = function () {
+            console.warn('DEPRECATED: cannot save via edit capability, use openmct.editor instead.');
+
+            return Promise.resolve();
+        };
+
+        EditorCapability.prototype.invoke = EditorCapability.prototype.edit;
+
+        /**
+         * Finish the current editing session. This will discard any pending
+         * persist operations
+         * @returns {*}
+         */
+        EditorCapability.prototype.finish = function () {
+            console.warn('DEPRECATED: cannot finish via edit capability, use openmct.editor instead.');
+
+            return Promise.resolve();
+        };
+
+        /**
+         * @returns {boolean} true if there have been any domain model
+         * modifications since the last persist, false otherwise.
+         */
+        EditorCapability.prototype.dirty = function () {
+            return this.transactionService.size() > 0;
+        };
+
+        return EditorCapability;
+    }
+);

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

@@ -0,0 +1,75 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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(
+    ['./TransactionalPersistenceCapability'],
+    function (TransactionalPersistenceCapability) {
+
+        /**
+         * Wraps the [PersistenceCapability]{@link PersistenceCapability} with
+         * transactional capabilities.
+         * @param $q
+         * @param transactionService
+         * @param capabilityService
+         * @see TransactionalPersistenceCapability
+         * @constructor
+         */
+        function TransactionCapabilityDecorator(
+            $q,
+            transactionService,
+            capabilityService
+        ) {
+            this.capabilityService = capabilityService;
+            this.transactionService = transactionService;
+            this.$q = $q;
+        }
+
+        /**
+         * Decorate PersistenceCapability to queue persistence calls when a
+         * transaction is in progress.
+         */
+        TransactionCapabilityDecorator.prototype.getCapabilities = function () {
+            var self = this,
+                capabilities = this.capabilityService.getCapabilities
+                    .apply(this.capabilityService, arguments),
+                persistenceCapability = capabilities.persistence;
+
+            capabilities.persistence = function (domainObject) {
+                var original =
+                    (typeof persistenceCapability === 'function')
+                        ? persistenceCapability(domainObject)
+                        : persistenceCapability;
+
+                return new TransactionalPersistenceCapability(
+                    self.$q,
+                    self.transactionService,
+                    original,
+                    domainObject
+                );
+            };
+
+            return capabilities;
+        };
+
+        return TransactionCapabilityDecorator;
+    }
+);

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

@@ -0,0 +1,91 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(
+    [],
+    function () {
+
+        /**
+         * Wraps persistence capability to enable transactions. Transactions
+         * will cause persist calls not to be invoked immediately, but
+         * rather queued until [EditorCapability.save()]{@link EditorCapability#save}
+         * or [EditorCapability.cancel()]{@link EditorCapability#cancel} are
+         * called.
+         * @memberof platform/commonUI/edit/capabilities
+         * @param $q
+         * @param transactionManager
+         * @param persistenceCapability
+         * @param domainObject
+         * @constructor
+         */
+        function TransactionalPersistenceCapability(
+            $q,
+            transactionManager,
+            persistenceCapability,
+            domainObject
+        ) {
+            this.transactionManager = transactionManager;
+            this.persistenceCapability = persistenceCapability;
+            this.domainObject = domainObject;
+            this.$q = $q;
+        }
+
+        /**
+         * The wrapped persist function. If a transaction is active, persist
+         * will be queued until the transaction is committed or cancelled.
+         * @returns {*}
+         */
+        TransactionalPersistenceCapability.prototype.persist = function () {
+            var wrappedPersistence = this.persistenceCapability;
+
+            if (this.transactionManager.isActive()) {
+                this.transactionManager.addToTransaction(
+                    this.domainObject.getId(),
+                    wrappedPersistence.persist.bind(wrappedPersistence),
+                    wrappedPersistence.refresh.bind(wrappedPersistence)
+                );
+
+                //Need to return a promise from this function
+                return this.$q.when(true);
+            } else {
+                return this.persistenceCapability.persist();
+            }
+        };
+
+        TransactionalPersistenceCapability.prototype.refresh = function () {
+            this.transactionManager
+                .clearTransactionsFor(this.domainObject.getId());
+
+            return this.persistenceCapability.refresh();
+        };
+
+        TransactionalPersistenceCapability.prototype.getSpace = function () {
+            return this.persistenceCapability.getSpace();
+        };
+
+        TransactionalPersistenceCapability.prototype.persisted = function () {
+            return this.persistenceCapability.persisted();
+        };
+
+        return TransactionalPersistenceCapability;
+    }
+);

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

@@ -19,41 +19,31 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
+define(['./Transaction'], function (Transaction) {
+    /**
+     * A nested transaction is a transaction which takes place in the context
+     * of a larger parent transaction. It becomes part of the parent
+     * transaction when (and only when) committed.
+     * @param parent
+     * @constructor
+     * @extends {platform/commonUI/edit/services.Transaction}
+     * @memberof platform/commonUI/edit/services
+     */
+    function NestedTransaction(parent) {
+        this.parent = parent;
+        Transaction.call(this, parent.$log);
+    }
 
-import Clock from './components/Clock.vue';
-import Vue from 'vue';
+    NestedTransaction.prototype = Object.create(Transaction.prototype);
 
-export default function ClockViewProvider(openmct) {
-    return {
-        key: 'clock.view',
-        name: 'Clock',
-        cssClass: 'icon-clock',
-        canView(domainObject) {
-            return domainObject.type === 'clock';
-        },
+    NestedTransaction.prototype.commit = function () {
+        this.parent.add(
+            Transaction.prototype.commit.bind(this),
+            Transaction.prototype.cancel.bind(this)
+        );
 
-        view: function (domainObject) {
-            let component;
-
-            return {
-                show: function (element) {
-                    component = new Vue({
-                        el: element,
-                        components: {
-                            Clock
-                        },
-                        provide: {
-                            openmct,
-                            domainObject
-                        },
-                        template: '<clock />'
-                    });
-                },
-                destroy: function () {
-                    component.$destroy();
-                    component = undefined;
-                }
-            };
-        }
+        return Promise.resolve(true);
     };
-}
+
+    return NestedTransaction;
+});

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

@@ -0,0 +1,99 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+define([], function () {
+    /**
+     * A Transaction represents a set of changes that are intended to
+     * be kept or discarded as a unit.
+     * @param $log Angular's `$log` service, for logging messages
+     * @constructor
+     * @memberof platform/commonUI/edit/services
+     */
+    function Transaction($log) {
+        this.$log = $log;
+        this.callbacks = [];
+    }
+
+    /**
+     * Add a change to the current transaction, as expressed by functions
+     * to either keep or discard the change.
+     * @param {Function} commit called when the transaction is committed
+     * @param {Function} cancel called when the transaction is cancelled
+     * @returns {Function) a function which may be called to remove this
+     *          pair of callbacks from the transaction
+     */
+    Transaction.prototype.add = function (commit, cancel) {
+        var callback = {
+            commit: commit,
+            cancel: cancel
+        };
+        this.callbacks.push(callback);
+
+        return function () {
+            this.callbacks = this.callbacks.filter(function (c) {
+                return c !== callback;
+            });
+        }.bind(this);
+    };
+
+    /**
+     * Get the number of changes in the current transaction.
+     * @returns {number} the size of the current transaction
+     */
+    Transaction.prototype.size = function () {
+        return this.callbacks.length;
+    };
+
+    /**
+     * Keep all changes associated with this transaction.
+     * @method {platform/commonUI/edit/services.Transaction#commit}
+     * @returns {Promise} a promise which will resolve when all callbacks
+     *          have been handled.
+     */
+
+    /**
+     * Discard all changes associated with this transaction.
+     * @method {platform/commonUI/edit/services.Transaction#cancel}
+     * @returns {Promise} a promise which will resolve when all callbacks
+     *          have been handled.
+     */
+
+    ['commit', 'cancel'].forEach(function (method) {
+        Transaction.prototype[method] = function () {
+            var promises = [];
+            var callback;
+
+            while (this.callbacks.length > 0) {
+                callback = this.callbacks.shift();
+                try {
+                    promises.push(callback[method]());
+                } catch (e) {
+                    this.$log
+                        .error("Error trying to " + method + " transaction.");
+                }
+            }
+
+            return Promise.all(promises);
+        };
+    });
+
+    return Transaction;
+});

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

@@ -0,0 +1,119 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define([], function () {
+    /**
+     * Manages transactions to support the TransactionalPersistenceCapability.
+     * This assumes that all commit/cancel callbacks for a given domain
+     * object are equivalent, and only need to be added once to any active
+     * transaction. Violating this assumption may cause unexpected behavior.
+     * @constructor
+     * @memberof platform/commonUI/edit
+     */
+    function TransactionManager(transactionService) {
+        this.transactionService = transactionService;
+        this.clearTransactionFns = {};
+    }
+
+    /**
+     * Check if a transaction is currently active.
+     * @returns {boolean} true if there is a transaction active
+     */
+    TransactionManager.prototype.isActive = function () {
+        return this.transactionService.isActive();
+    };
+
+    /**
+     * Check if callbacks associated with this domain object have already
+     * been added to the active transaction.
+     * @private
+     * @param {string} id the identifier of the domain object to check
+     * @returns {boolean} true if callbacks have been added
+     */
+    TransactionManager.prototype.isScheduled = function (id) {
+        return Boolean(this.clearTransactionFns[id]);
+    };
+
+    /**
+     * Add callbacks associated with this domain object to the active
+     * transaction. Both callbacks are expected to return promises that
+     * resolve when their associated behavior is complete.
+     *
+     * If callbacks associated with this domain object have already been
+     * added to the active transaction, this call will be ignored.
+     *
+     * @param {string} id the identifier of the associated domain object
+     * @param {Function} onCommit behavior to invoke when committing transaction
+     * @param {Function} onCancel behavior to invoke when cancelling transaction
+     */
+    TransactionManager.prototype.addToTransaction = function (
+        id,
+        onCommit,
+        onCancel
+    ) {
+        var release = this.releaseClearFn.bind(this, id);
+
+        function chain(promiseFn, nextFn) {
+            return function () {
+                return promiseFn().then(nextFn);
+            };
+        }
+
+        /**
+         * Clear any existing persistence calls for object with given ID. This ensures only the most recent persistence
+         * call is executed. This should prevent stale objects being persisted and overwriting fresh ones.
+         */
+        if (this.isScheduled(id)) {
+            this.clearTransactionsFor(id);
+        }
+
+        this.clearTransactionFns[id] =
+            this.transactionService.addToTransaction(
+                chain(onCommit, release),
+                chain(onCancel, release)
+            );
+    };
+
+    /**
+     * Remove any callbacks associated with this domain object from the
+     * active transaction.
+     * @param {string} id the identifier for the domain object
+     */
+    TransactionManager.prototype.clearTransactionsFor = function (id) {
+        if (this.isScheduled(id)) {
+            this.clearTransactionFns[id]();
+            this.releaseClearFn(id);
+        }
+    };
+
+    /**
+     * Release the cached "remove from transaction" function that has been
+     * stored in association with this domain object.
+     * @param {string} id the identifier for the domain object
+     * @private
+     */
+    TransactionManager.prototype.releaseClearFn = function (id) {
+        delete this.clearTransactionFns[id];
+    };
+
+    return TransactionManager;
+});

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

@@ -0,0 +1,138 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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(
+    ['./Transaction', './NestedTransaction'],
+    function (Transaction, NestedTransaction) {
+        /**
+         * Implements an application-wide transaction state. Once a
+         * transaction is started, calls to
+         * [PersistenceCapability.persist()]{@link PersistenceCapability#persist}
+         * will be deferred until a subsequent call to
+         * [TransactionService.commit]{@link TransactionService#commit} is made.
+         *
+         * @memberof platform/commonUI/edit/services
+         * @param $q
+         * @constructor
+         */
+        function TransactionService($q, $log, cacheService) {
+            this.$q = $q;
+            this.$log = $log;
+            this.cacheService = cacheService;
+            this.transactions = [];
+        }
+
+        /**
+         * Starts a transaction. While a transaction is active all calls to
+         * [PersistenceCapability.persist](@link PersistenceCapability#persist)
+         * will be queued until [commit]{@link #commit} or [cancel]{@link
+         * #cancel} are called
+         */
+        TransactionService.prototype.startTransaction = function () {
+            var transaction = this.isActive()
+                ? new NestedTransaction(this.transactions[0])
+                : new Transaction(this.$log);
+
+            this.transactions.push(transaction);
+        };
+
+        /**
+         * @returns {boolean} If true, indicates that a transaction is in progress
+         */
+        TransactionService.prototype.isActive = function () {
+            return this.transactions.length > 0;
+        };
+
+        /**
+         * Adds provided functions to a queue to be called on
+         * [.commit()]{@link #commit} or
+         * [.cancel()]{@link #commit}
+         * @param onCommit A function to call on commit
+         * @param onCancel A function to call on cancel
+         */
+        TransactionService.prototype.addToTransaction = function (onCommit, onCancel) {
+            if (this.isActive()) {
+                return this.activeTransaction().add(onCommit, onCancel);
+            } else {
+                //Log error because this is a programming error if it occurs.
+                this.$log.error("No transaction in progress");
+            }
+        };
+
+        /**
+         * Get the transaction at the top of the stack.
+         * @private
+         */
+        TransactionService.prototype.activeTransaction = function () {
+            return this.transactions[this.transactions.length - 1];
+        };
+
+        /**
+         * All persist calls deferred since the beginning of the transaction
+         * will be committed.  If this is the last transaction, clears the
+         * cache.
+         *
+         * @returns {Promise} resolved when all persist operations have
+         * completed. Will reject if any commit operations fail
+         */
+        TransactionService.prototype.commit = function () {
+            var transaction = this.transactions.pop();
+            if (!transaction) {
+                return Promise.reject();
+            }
+
+            if (!this.isActive()) {
+                return transaction.commit()
+                    .then(function (r) {
+                        this.cacheService.flush();
+
+                        return r;
+                    }.bind(this));
+            }
+
+            return transaction.commit();
+        };
+
+        /**
+         * Cancel the current transaction, replacing any dirty objects from
+         * persistence. Not a true rollback, as it cannot be used to undo any
+         * persist calls that were successful in the event one of a batch of
+         * persists failing.
+         *
+         * @returns {*}
+         */
+        TransactionService.prototype.cancel = function () {
+            var transaction = this.transactions.pop();
+
+            return transaction ? transaction.cancel() : Promise.reject();
+        };
+
+        /**
+         * Get the size (the number of commit/cancel callbacks) of
+         * the active transaction.
+         * @returns {number} size of the active transaction
+         */
+        TransactionService.prototype.size = function () {
+            return this.isActive() ? this.activeTransaction().size() : 0;
+        };
+
+        return TransactionService;
+    });

platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js

@@ -0,0 +1,192 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/capabilities/EditorCapability"],
+    function (EditorCapability) {
+
+        xdescribe("The editor capability", function () {
+            var mockDomainObject,
+                capabilities,
+                mockParentObject,
+                mockTransactionService,
+                mockStatusCapability,
+                mockParentStatus,
+                mockContextCapability,
+                capability;
+
+            function fastPromise(val) {
+                return {
+                    then: function (callback) {
+                        return callback(val);
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockParentObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockTransactionService = jasmine.createSpyObj(
+                    "transactionService",
+                    [
+                        "startTransaction",
+                        "size",
+                        "commit",
+                        "cancel"
+                    ]
+                );
+                mockTransactionService.commit.and.returnValue(fastPromise());
+                mockTransactionService.cancel.and.returnValue(fastPromise());
+                mockTransactionService.isActive = jasmine.createSpy('isActive');
+
+                mockStatusCapability = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockParentStatus = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockContextCapability = jasmine.createSpyObj(
+                    "contextCapability",
+                    ["getParent"]
+                );
+                mockContextCapability.getParent.and.returnValue(mockParentObject);
+
+                capabilities = {
+                    context: mockContextCapability,
+                    status: mockStatusCapability
+                };
+
+                mockDomainObject.hasCapability.and.callFake(function (name) {
+                    return capabilities[name] !== undefined;
+                });
+
+                mockDomainObject.getCapability.and.callFake(function (name) {
+                    return capabilities[name];
+                });
+
+                mockParentObject.getCapability.and.returnValue(mockParentStatus);
+                mockParentObject.hasCapability.and.returnValue(false);
+
+                capability = new EditorCapability(
+                    mockTransactionService,
+                    mockDomainObject
+                );
+            });
+
+            it("starts a transaction when edit is invoked", function () {
+                capability.edit();
+                expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+            });
+
+            it("sets editing status on object", function () {
+                capability.edit();
+                expect(mockStatusCapability.set).toHaveBeenCalledWith("editing", true);
+            });
+
+            it("uses editing status to determine editing context root", function () {
+                capability.edit();
+                mockStatusCapability.get.and.returnValue(false);
+                expect(capability.isEditContextRoot()).toBe(false);
+                mockStatusCapability.get.and.returnValue(true);
+                expect(capability.isEditContextRoot()).toBe(true);
+            });
+
+            it("inEditingContext returns true if parent object is being"
+                + " edited", function () {
+                mockStatusCapability.get.and.returnValue(false);
+                mockParentStatus.get.and.returnValue(false);
+                expect(capability.inEditContext()).toBe(false);
+                mockParentStatus.get.and.returnValue(true);
+                expect(capability.inEditContext()).toBe(true);
+            });
+
+            describe("save", function () {
+                beforeEach(function () {
+                    capability.edit();
+                    capability.save();
+                });
+                it("commits the transaction", function () {
+                    expect(mockTransactionService.commit).toHaveBeenCalled();
+                });
+                it("begins a new transaction", function () {
+                    expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(true);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("cancels the transaction", function () {
+                    expect(mockTransactionService.cancel).toHaveBeenCalled();
+                });
+                it("resets the edit state", function () {
+                    expect(mockStatusCapability.set).toHaveBeenCalledWith('editing', false);
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(false);
+                    capability.edit();
+                });
+
+                it("does not cancel transaction when transaction is not active", function () {
+                    capability.finish();
+                    expect(mockTransactionService.cancel).not.toHaveBeenCalled();
+                });
+
+                it("returns a promise", function () {
+                    expect(capability.finish() instanceof Promise).toBe(true);
+                });
+
+            });
+
+            describe("dirty", function () {
+                var model = {};
+
+                beforeEach(function () {
+                    mockDomainObject.getModel.and.returnValue(model);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("returns true if the object has been modified since it"
+                    + " was last persisted", function () {
+                    mockTransactionService.size.and.returnValue(0);
+                    expect(capability.dirty()).toBe(false);
+                    mockTransactionService.size.and.returnValue(1);
+                    expect(capability.dirty()).toBe(true);
+                });
+            });
+        });
+    }
+);

platform/commonUI/edit/test/capabilities/TransactionCapabilityDecoratorSpec.js

@@ -0,0 +1,54 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/capabilities/TransactionalPersistenceCapability",
+        "../../src/capabilities/TransactionCapabilityDecorator"
+    ],
+    function (TransactionalPersistenceCapability, TransactionCapabilityDecorator) {
+
+        describe("The transaction capability decorator", function () {
+            var mockQ,
+                mockTransactionService,
+                mockCapabilityService,
+                provider;
+
+            beforeEach(function () {
+                mockQ = {};
+                mockTransactionService = {};
+                mockCapabilityService = jasmine.createSpyObj("capabilityService", ["getCapabilities"]);
+                mockCapabilityService.getCapabilities.and.returnValue({
+                    persistence: function () {}
+                });
+
+                provider = new TransactionCapabilityDecorator(mockQ, mockTransactionService, mockCapabilityService);
+
+            });
+            it("decorates the persistence capability", function () {
+                var capabilities = provider.getCapabilities();
+                expect(capabilities.persistence({}) instanceof TransactionalPersistenceCapability).toBe(true);
+            });
+
+        });
+    }
+);

platform/commonUI/edit/test/capabilities/TransactionalPersistenceCapabilitySpec.js

@@ -0,0 +1,111 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/capabilities/TransactionalPersistenceCapability"
+    ],
+    function (TransactionalPersistenceCapability) {
+
+        function fastPromise(val) {
+            return {
+                then: function (callback) {
+                    return callback(val);
+                }
+            };
+        }
+
+        describe("The transactional persistence decorator", function () {
+            var mockQ,
+                mockTransactionManager,
+                mockPersistence,
+                mockDomainObject,
+                testId,
+                capability;
+
+            beforeEach(function () {
+                testId = "test-id";
+
+                mockQ = jasmine.createSpyObj("$q", ["when"]);
+                mockQ.when.and.callFake(function (val) {
+                    return fastPromise(val);
+                });
+                mockTransactionManager = jasmine.createSpyObj(
+                    "transactionService",
+                    ["isActive", "addToTransaction", "clearTransactionsFor"]
+                );
+                mockPersistence = jasmine.createSpyObj(
+                    "persistenceCapability",
+                    ["persist", "refresh", "getSpace"]
+                );
+                mockPersistence.persist.and.returnValue(fastPromise());
+                mockPersistence.refresh.and.returnValue(fastPromise());
+
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getModel", "getId"]
+                );
+                mockDomainObject.getModel.and.returnValue({persisted: 1});
+                mockDomainObject.getId.and.returnValue(testId);
+
+                capability = new TransactionalPersistenceCapability(
+                    mockQ,
+                    mockTransactionManager,
+                    mockPersistence,
+                    mockDomainObject
+                );
+            });
+
+            it("if no transaction is active, passes through to persistence"
+                + " provider", function () {
+                mockTransactionManager.isActive.and.returnValue(false);
+                capability.persist();
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
+
+            it("if transaction is active, persist and cancel calls are"
+                + " queued", function () {
+                mockTransactionManager.isActive.and.returnValue(true);
+                capability.persist();
+                expect(mockTransactionManager.addToTransaction).toHaveBeenCalled();
+                mockTransactionManager.addToTransaction.calls.mostRecent().args[1]();
+                expect(mockPersistence.persist).toHaveBeenCalled();
+                mockTransactionManager.addToTransaction.calls.mostRecent().args[2]();
+                expect(mockPersistence.refresh).toHaveBeenCalled();
+            });
+
+            it("wraps getSpace", function () {
+                mockPersistence.getSpace.and.returnValue('foo');
+                expect(capability.getSpace()).toEqual('foo');
+            });
+
+            it("clears transactions and delegates refresh calls", function () {
+                capability.refresh();
+                expect(mockTransactionManager.clearTransactionsFor)
+                    .toHaveBeenCalledWith(testId);
+                expect(mockPersistence.refresh)
+                    .toHaveBeenCalled();
+            });
+
+        });
+    }
+);

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

@@ -0,0 +1,75 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/services/NestedTransaction"], function (NestedTransaction) {
+    var TRANSACTION_METHODS = ['add', 'commit', 'cancel', 'size'];
+
+    describe("A NestedTransaction", function () {
+        var mockTransaction,
+            nestedTransaction;
+
+        beforeEach(function () {
+            mockTransaction =
+                jasmine.createSpyObj('transaction', TRANSACTION_METHODS);
+            nestedTransaction = new NestedTransaction(mockTransaction);
+        });
+
+        it("exposes a Transaction's interface", function () {
+            TRANSACTION_METHODS.forEach(function (method) {
+                expect(nestedTransaction[method])
+                    .toEqual(jasmine.any(Function));
+            });
+        });
+
+        describe("when callbacks are added", function () {
+            var mockCommit,
+                mockCancel;
+
+            beforeEach(function () {
+                mockCommit = jasmine.createSpy('commit');
+                mockCancel = jasmine.createSpy('cancel');
+                nestedTransaction.add(mockCommit, mockCancel);
+            });
+
+            it("does not interact with its parent transaction", function () {
+                TRANSACTION_METHODS.forEach(function (method) {
+                    expect(mockTransaction[method])
+                        .not.toHaveBeenCalled();
+                });
+            });
+
+            describe("and the transaction is committed", function () {
+                beforeEach(function () {
+                    nestedTransaction.commit();
+                });
+
+                it("adds to its parent transaction", function () {
+                    expect(mockTransaction.add).toHaveBeenCalledWith(
+                        jasmine.any(Function),
+                        jasmine.any(Function)
+                    );
+                });
+            });
+        });
+    });
+});
+

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

@@ -0,0 +1,141 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/services/TransactionManager"],
+    function (TransactionManager) {
+        describe("TransactionManager", function () {
+            var mockTransactionService,
+                testId,
+                mockOnCommit,
+                mockOnCancel,
+                mockRemoves,
+                mockPromise,
+                manager;
+
+            beforeEach(function () {
+                mockRemoves = [];
+                mockTransactionService = jasmine.createSpyObj(
+                    "transactionService",
+                    ["addToTransaction", "isActive"]
+                );
+                mockOnCommit = jasmine.createSpy('commit');
+                mockOnCancel = jasmine.createSpy('cancel');
+                testId = 'test-id';
+                mockPromise = jasmine.createSpyObj('promise', ['then']);
+
+                mockOnCommit.and.returnValue(mockPromise);
+                mockOnCancel.and.returnValue(mockPromise);
+
+                mockTransactionService.addToTransaction.and.callFake(function () {
+                    var mockRemove =
+                        jasmine.createSpy('remove-' + mockRemoves.length);
+                    mockRemoves.push(mockRemove);
+
+                    return mockRemove;
+                });
+
+                manager = new TransactionManager(mockTransactionService);
+            });
+
+            it("delegates isActive calls", function () {
+                [false, true].forEach(function (state) {
+                    mockTransactionService.isActive.and.returnValue(state);
+                    expect(manager.isActive()).toBe(state);
+                });
+            });
+
+            describe("when addToTransaction is called", function () {
+                beforeEach(function () {
+                    manager.addToTransaction(
+                        testId,
+                        mockOnCommit,
+                        mockOnCancel
+                    );
+                });
+
+                it("adds callbacks to the active transaction", function () {
+                    expect(mockTransactionService.addToTransaction)
+                        .toHaveBeenCalledWith(
+                            jasmine.any(Function),
+                            jasmine.any(Function)
+                        );
+                });
+
+                it("invokes passed-in callbacks from its own callbacks", function () {
+                    expect(mockOnCommit).not.toHaveBeenCalled();
+                    mockTransactionService.addToTransaction
+                        .calls.mostRecent().args[0]();
+                    expect(mockOnCommit).toHaveBeenCalled();
+
+                    expect(mockOnCancel).not.toHaveBeenCalled();
+                    mockTransactionService.addToTransaction
+                        .calls.mostRecent().args[1]();
+                    expect(mockOnCancel).toHaveBeenCalled();
+                });
+
+                describe("Adds callbacks to transaction", function () {
+                    beforeEach(function () {
+                        spyOn(manager, 'clearTransactionsFor');
+                        manager.clearTransactionsFor.and.callThrough();
+                    });
+
+                    it("and clears pending calls if same object", function () {
+                        manager.addToTransaction(
+                            testId,
+                            jasmine.createSpy(),
+                            jasmine.createSpy()
+                        );
+                        expect(manager.clearTransactionsFor).toHaveBeenCalledWith(testId);
+                    });
+
+                    it("and does not clear pending calls if different object", function () {
+                        manager.addToTransaction(
+                            'other-id',
+                            jasmine.createSpy(),
+                            jasmine.createSpy()
+                        );
+                        expect(manager.clearTransactionsFor).not.toHaveBeenCalled();
+                    });
+
+                    afterEach(function () {
+                        expect(mockTransactionService.addToTransaction.calls.count()).toEqual(2);
+                    });
+                });
+
+                it("does not remove callbacks from the transaction", function () {
+                    expect(mockRemoves[0]).not.toHaveBeenCalled();
+                });
+
+                describe("and clearTransactionsFor is subsequently called", function () {
+                    beforeEach(function () {
+                        manager.clearTransactionsFor(testId);
+                    });
+
+                    it("removes callbacks from the transaction", function () {
+                        expect(mockRemoves[0]).toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+    }
+);

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

@@ -0,0 +1,139 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/services/TransactionService"],
+    function (TransactionService) {
+
+        describe("The Transaction Service", function () {
+            var mockQ,
+                mockLog,
+                mockCacheService,
+                transactionService;
+
+            function fastPromise(val) {
+                return {
+                    then: function (callback) {
+                        return fastPromise(callback(val));
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockQ = jasmine.createSpyObj("$q", ["all"]);
+                mockCacheService = jasmine.createSpyObj("cacheService", ["flush"]);
+                mockQ.all.and.returnValue(fastPromise());
+                mockLog = jasmine.createSpyObj("$log", ["error"]);
+                transactionService = new TransactionService(mockQ, mockLog, mockCacheService);
+            });
+
+            it("isActive returns true if a transaction is in progress", function () {
+                expect(transactionService.isActive()).toBe(false);
+                transactionService.startTransaction();
+                expect(transactionService.isActive()).toBe(true);
+            });
+
+            it("addToTransaction queues onCommit and onCancel functions", function () {
+                var onCommit = jasmine.createSpy('onCommit'),
+                    onCancel = jasmine.createSpy('onCancel');
+
+                transactionService.startTransaction();
+                transactionService.addToTransaction(onCommit, onCancel);
+                expect(transactionService.size()).toBe(1);
+            });
+
+            it("size function returns size of commit and cancel queues", function () {
+                var onCommit = jasmine.createSpy('onCommit'),
+                    onCancel = jasmine.createSpy('onCancel');
+
+                transactionService.startTransaction();
+                transactionService.addToTransaction(onCommit, onCancel);
+                transactionService.addToTransaction(onCommit, onCancel);
+                transactionService.addToTransaction(onCommit, onCancel);
+                expect(transactionService.size()).toBe(3);
+            });
+
+            describe("commit", function () {
+                var onCommits;
+
+                beforeEach(function () {
+                    onCommits = [0, 1, 2].map(function (val) {
+                        return jasmine.createSpy("onCommit" + val);
+                    });
+
+                    transactionService.startTransaction();
+                    onCommits.forEach(transactionService.addToTransaction.bind(transactionService));
+                });
+
+                it("commit calls all queued commit functions", function () {
+                    expect(transactionService.size()).toBe(3);
+
+                    return transactionService.commit().then(() => {
+                        onCommits.forEach(function (spy) {
+                            expect(spy).toHaveBeenCalled();
+                        });
+                    });
+                });
+
+                it("commit resets active state and clears queues", function () {
+                    return transactionService.commit().then(() => {
+                        expect(transactionService.isActive()).toBe(false);
+                        expect(transactionService.size()).toBe(0);
+                        expect(transactionService.size()).toBe(0);
+                    });
+                });
+
+            });
+
+            describe("cancel", function () {
+                var onCancels;
+
+                beforeEach(function () {
+                    onCancels = [0, 1, 2].map(function (val) {
+                        return jasmine.createSpy("onCancel" + val);
+                    });
+
+                    transactionService.startTransaction();
+                    onCancels.forEach(function (onCancel) {
+                        transactionService.addToTransaction(undefined, onCancel);
+                    });
+                });
+
+                it("cancel calls all queued cancel functions", function () {
+                    expect(transactionService.size()).toBe(3);
+                    transactionService.cancel();
+                    onCancels.forEach(function (spy) {
+                        expect(spy).toHaveBeenCalled();
+                    });
+                });
+
+                it("cancel resets active state and clears queues", function () {
+                    transactionService.cancel();
+                    expect(transactionService.isActive()).toBe(false);
+                    expect(transactionService.size()).toBe(0);
+                });
+
+            });
+
+        });
+    }
+);

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

@@ -0,0 +1,109 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/services/Transaction"],
+    function (Transaction) {
+
+        describe("A Transaction", function () {
+            var mockLog,
+                transaction;
+
+            beforeEach(function () {
+                mockLog = jasmine.createSpyObj(
+                    '$log',
+                    ['warn', 'info', 'error', 'debug']
+                );
+                transaction = new Transaction(mockLog);
+            });
+
+            it("initially has a size of zero", function () {
+                expect(transaction.size()).toEqual(0);
+            });
+
+            describe("when callbacks are added", function () {
+                var mockCommit,
+                    mockCancel,
+                    remove;
+
+                beforeEach(function () {
+                    mockCommit = jasmine.createSpy('commit');
+                    mockCancel = jasmine.createSpy('cancel');
+                    remove = transaction.add(mockCommit, mockCancel);
+                });
+
+                it("reports a new size", function () {
+                    expect(transaction.size()).toEqual(1);
+                });
+
+                it("returns a function to remove those callbacks", function () {
+                    expect(remove).toEqual(jasmine.any(Function));
+                    remove();
+                    expect(transaction.size()).toEqual(0);
+                });
+
+                describe("and the transaction is committed", function () {
+                    beforeEach(function () {
+                        transaction.commit();
+                    });
+
+                    it("triggers the commit callback", function () {
+                        expect(mockCommit).toHaveBeenCalled();
+                    });
+
+                    it("does not trigger the cancel callback", function () {
+                        expect(mockCancel).not.toHaveBeenCalled();
+                    });
+                });
+
+                describe("and the transaction is cancelled", function () {
+                    beforeEach(function () {
+                        transaction.cancel();
+                    });
+
+                    it("triggers the cancel callback", function () {
+                        expect(mockCancel).toHaveBeenCalled();
+                    });
+
+                    it("does not trigger the commit callback", function () {
+                        expect(mockCommit).not.toHaveBeenCalled();
+                    });
+                });
+
+                describe("and an exception is encountered during commit", function () {
+                    beforeEach(function () {
+                        mockCommit.and.callFake(function () {
+                            throw new Error("test error");
+                        });
+                        transaction.commit();
+                    });
+
+                    it("logs an error", function () {
+                        expect(mockLog.error).toHaveBeenCalled();
+                    });
+                });
+            });
+
+        });
+    }
+);
+

platform/core/bundle.js

@@ -45,6 +45,7 @@ define([
     "./src/capabilities/MutationCapability",
     "./src/capabilities/DelegationCapability",
     "./src/capabilities/InstantiationCapability",
+    "./src/runs/TransactingMutationListener",
     "./src/services/Now",
     "./src/services/Throttle",
     "./src/services/Topic",
@@ -74,6 +75,7 @@ define([
     MutationCapability,
     DelegationCapability,
     InstantiationCapability,
+    TransactingMutationListener,
     Now,
     Throttle,
     Topic,
@@ -361,6 +363,12 @@ define([
                         ]
                     }
                 ],
+                "runs": [
+                    {
+                        "implementation": TransactingMutationListener,
+                        "depends": ["topic", "transactionService", "cacheService"]
+                    }
+                ],
                 "constants": [
                     {
                         "key": "PERSISTENCE_SPACE",

platform/core/src/runs/TransactingMutationListener.js

@@ -0,0 +1,55 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define([], function () {
+
+    /**
+     * Listens for mutation on domain objects and triggers persistence when
+     * it occurs.
+     * @param {Topic} topic the `topic` service; used to listen for mutation
+     * @memberof platform/core
+     */
+    function TransactingMutationListener(
+        topic,
+        transactionService,
+        cacheService
+    ) {
+
+        function hasChanged(domainObject) {
+            var model = domainObject.getModel();
+
+            return model.persisted === undefined || model.modified > model.persisted;
+        }
+
+        var mutationTopic = topic('mutation');
+        mutationTopic.listen(function (domainObject) {
+            var persistence = domainObject.getCapability('persistence');
+            cacheService.put(domainObject.getId(), domainObject.getModel());
+
+            if (hasChanged(domainObject)) {
+                persistence.persist();
+            }
+        });
+    }
+
+    return TransactingMutationListener;
+});

platform/core/test/runs/TransactingMutationListenerSpec.js

@@ -0,0 +1,112 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/runs/TransactingMutationListener"],
+    function (TransactingMutationListener) {
+
+        describe("TransactingMutationListener", function () {
+            var mockTopic,
+                mockMutationTopic,
+                mockCacheService,
+                mockTransactionService,
+                mockDomainObject,
+                mockModel,
+                mockPersistence;
+
+            beforeEach(function () {
+                mockTopic = jasmine.createSpy('topic');
+                mockMutationTopic =
+                    jasmine.createSpyObj('mutation', ['listen']);
+                mockCacheService =
+                    jasmine.createSpyObj('cacheService', [
+                        'put'
+                    ]);
+                mockTransactionService =
+                    jasmine.createSpyObj('transactionService', [
+                        'isActive',
+                        'startTransaction',
+                        'commit'
+                    ]);
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getId', 'getCapability', 'getModel']
+                );
+                mockPersistence = jasmine.createSpyObj(
+                    'persistence',
+                    ['persist', 'refresh', 'persisted']
+                );
+
+                mockTopic.and.callFake(function (t) {
+                    expect(t).toBe('mutation');
+
+                    return mockMutationTopic;
+                });
+
+                mockDomainObject.getId.and.returnValue('mockId');
+                mockDomainObject.getCapability.and.callFake(function (c) {
+                    expect(c).toBe('persistence');
+
+                    return mockPersistence;
+                });
+                mockModel = {};
+                mockDomainObject.getModel.and.returnValue(mockModel);
+
+                mockPersistence.persisted.and.returnValue(true);
+
+                return new TransactingMutationListener(
+                    mockTopic,
+                    mockTransactionService,
+                    mockCacheService
+                );
+            });
+
+            it("listens for mutation", function () {
+                expect(mockMutationTopic.listen)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+            });
+
+            it("calls persist if the model has changed", function () {
+                mockModel.persisted = Date.now();
+
+                //Mark the model dirty by setting the mutated date later than the last persisted date.
+                mockModel.modified = mockModel.persisted + 1;
+
+                mockMutationTopic.listen.calls.mostRecent()
+                    .args[0](mockDomainObject);
+
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
+
+            it("does not call persist if the model has not changed", function () {
+                mockModel.persisted = Date.now();
+
+                mockModel.modified = mockModel.persisted;
+
+                mockMutationTopic.listen.calls.mostRecent()
+                    .args[0](mockDomainObject);
+
+                expect(mockPersistence.persist).not.toHaveBeenCalled();
+            });
+        });
+    }
+);

platform/features/clock/bundle.js

@@ -21,24 +21,32 @@
  *****************************************************************************/
 
 define([
+    "moment-timezone",
+    "./src/indicators/ClockIndicator",
     "./src/services/TickerService",
     "./src/services/TimerService",
+    "./src/controllers/ClockController",
     "./src/controllers/TimerController",
     "./src/controllers/RefreshingController",
     "./src/actions/StartTimerAction",
     "./src/actions/RestartTimerAction",
     "./src/actions/StopTimerAction",
     "./src/actions/PauseTimerAction",
+    "./res/templates/clock.html",
     "./res/templates/timer.html"
 ], function (
+    MomentTimezone,
+    ClockIndicator,
     TickerService,
     TimerService,
+    ClockController,
     TimerController,
     RefreshingController,
     StartTimerAction,
     RestartTimerAction,
     StopTimerAction,
     PauseTimerAction,
+    clockTemplate,
     timerTemplate
 ) {
     return {
@@ -65,6 +73,16 @@ define([
                         "value": "YYYY/MM/DD HH:mm:ss"
                     }
                 ],
+                "indicators": [
+                    {
+                        "implementation": ClockIndicator,
+                        "depends": [
+                            "tickerService",
+                            "CLOCK_INDICATOR_FORMAT"
+                        ],
+                        "priority": "preferred"
+                    }
+                ],
                 "services": [
                     {
                         "key": "tickerService",
@@ -81,6 +99,14 @@ define([
                     }
                 ],
                 "controllers": [
+                    {
+                        "key": "ClockController",
+                        "implementation": ClockController,
+                        "depends": [
+                            "$scope",
+                            "tickerService"
+                        ]
+                    },
                     {
                         "key": "TimerController",
                         "implementation": TimerController,
@@ -100,6 +126,12 @@ define([
                     }
                 ],
                 "views": [
+                    {
+                        "key": "clock",
+                        "type": "clock",
+                        "editable": false,
+                        "template": clockTemplate
+                    },
                     {
                         "key": "timer",
                         "type": "timer",
@@ -154,6 +186,70 @@ define([
                     }
                 ],
                 "types": [
+                    {
+                        "key": "clock",
+                        "name": "Clock",
+                        "cssClass": "icon-clock",
+                        "description": "A UTC-based clock that supports a variety of display formats. Clocks can be added to Display Layouts.",
+                        "priority": 101,
+                        "features": [
+                            "creation"
+                        ],
+                        "properties": [
+                            {
+                                "key": "clockFormat",
+                                "name": "Display Format",
+                                "control": "composite",
+                                "items": [
+                                    {
+                                        "control": "select",
+                                        "options": [
+                                            {
+                                                "value": "YYYY/MM/DD hh:mm:ss",
+                                                "name": "YYYY/MM/DD hh:mm:ss"
+                                            },
+                                            {
+                                                "value": "YYYY/DDD hh:mm:ss",
+                                                "name": "YYYY/DDD hh:mm:ss"
+                                            },
+                                            {
+                                                "value": "hh:mm:ss",
+                                                "name": "hh:mm:ss"
+                                            }
+                                        ],
+                                        "cssClass": "l-inline"
+                                    },
+                                    {
+                                        "control": "select",
+                                        "options": [
+                                            {
+                                                "value": "clock12",
+                                                "name": "12hr"
+                                            },
+                                            {
+                                                "value": "clock24",
+                                                "name": "24hr"
+                                            }
+                                        ],
+                                        "cssClass": "l-inline"
+                                    }
+                                ]
+                            },
+                            {
+                                "key": "timezone",
+                                "name": "Timezone",
+                                "control": "autocomplete",
+                                "options": MomentTimezone.tz.names()
+                            }
+                        ],
+                        "model": {
+                            "clockFormat": [
+                                "YYYY/MM/DD hh:mm:ss",
+                                "clock12"
+                            ],
+                            "timezone": "UTC"
+                        }
+                    },
                     {
                         "key": "timer",
                         "name": "Timer",

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

@@ -0,0 +1,32 @@
+<!--
+ Open MCT, Copyright (c) 2009-2016, 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.
+-->
+<div class="c-clock l-time-display u-style-receiver js-style-receiver" ng-controller="ClockController as clock">
+	<div class="c-clock__timezone">
+		{{clock.zone()}}
+	</div>
+	<div class="c-clock__value">
+		{{clock.text()}}
+	</div>
+	<div class="c-clock__ampm">
+		{{clock.ampm()}}
+	</div>
+</div>

platform/features/clock/src/controllers/ClockController.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2009-2016, 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([
+    'moment',
+    'moment-timezone'
+],
+function (
+    moment,
+    momentTimezone
+) {
+
+    /**
+         * Controller for views of a Clock domain object.
+         *
+         * @constructor
+         * @memberof platform/features/clock
+         * @param {angular.Scope} $scope the Angular scope
+         * @param {platform/features/clock.TickerService} tickerService
+         *        a service used to align behavior with clock ticks
+         */
+    function ClockController($scope, tickerService) {
+        var lastTimestamp,
+            unlisten,
+            timeFormat,
+            zoneName,
+            self = this;
+
+        function update() {
+            var m = zoneName
+                ? moment.utc(lastTimestamp).tz(zoneName) : moment.utc(lastTimestamp);
+            self.zoneAbbr = m.zoneAbbr();
+            self.textValue = timeFormat && m.format(timeFormat);
+            self.ampmValue = m.format("A"); // Just the AM or PM part
+        }
+
+        function tick(timestamp) {
+            lastTimestamp = timestamp;
+            update();
+        }
+
+        function updateModel(model) {
+            var baseFormat;
+            if (model !== undefined) {
+                baseFormat = model.clockFormat[0];
+
+                self.use24 = model.clockFormat[1] === 'clock24';
+                timeFormat = self.use24
+                    ? baseFormat.replace('hh', "HH") : baseFormat;
+                // If wrong timezone is provided, the UTC will be used
+                zoneName = momentTimezone.tz.names().includes(model.timezone)
+                    ? model.timezone : "UTC";
+                update();
+            }
+        }
+
+        // Pull in the model (clockFormat and timezone) from the domain object model
+        $scope.$watch('model', updateModel);
+
+        // Listen for clock ticks ... and stop listening on destroy
+        unlisten = tickerService.listen(tick);
+        $scope.$on('$destroy', unlisten);
+    }
+
+    /**
+         * Get the clock's time zone, as displayable text.
+         * @returns {string}
+         */
+    ClockController.prototype.zone = function () {
+        return this.zoneAbbr;
+    };
+
+    /**
+         * Get the current time, as displayable text.
+         * @returns {string}
+         */
+    ClockController.prototype.text = function () {
+        return this.textValue;
+    };
+
+    /**
+         * Get the text to display to qualify a time as AM or PM.
+         * @returns {string}
+         */
+    ClockController.prototype.ampm = function () {
+        return this.use24 ? '' : this.ampmValue;
+    };
+
+    return ClockController;
+}
+);

platform/features/clock/src/indicators/ClockIndicator.js

@@ -0,0 +1,65 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2009-2016, 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(
+    ['moment'],
+    function (moment) {
+
+        /**
+         * Indicator that displays the current UTC time in the status area.
+         * @implements {Indicator}
+         * @memberof platform/features/clock
+         * @param {platform/features/clock.TickerService} tickerService
+         *        a service used to align behavior with clock ticks
+         * @param {string} indicatorFormat format string for timestamps
+         *        shown in this indicator
+         */
+        function ClockIndicator(tickerService, indicatorFormat) {
+            var self = this;
+
+            this.text = "";
+
+            tickerService.listen(function (timestamp) {
+                self.text = moment.utc(timestamp)
+                    .format(indicatorFormat) + " UTC";
+            });
+        }
+
+        ClockIndicator.prototype.getGlyphClass = function () {
+            return "";
+        };
+
+        ClockIndicator.prototype.getCssClass = function () {
+            return "t-indicator-clock icon-clock no-minify c-indicator--not-clickable";
+        };
+
+        ClockIndicator.prototype.getText = function () {
+            return this.text;
+        };
+
+        ClockIndicator.prototype.getDescription = function () {
+            return "";
+        };
+
+        return ClockIndicator;
+    }
+);

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

@@ -0,0 +1,107 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2009-2017, 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/controllers/ClockController"],
+    function (ClockController) {
+
+        // Wed, 03 Jun 2015 17:56:14 GMT
+        var TEST_TIMESTAMP = 1433354174000;
+
+        describe("A clock view's controller", function () {
+            var mockScope,
+                mockTicker,
+                mockUnticker,
+                controller;
+
+            beforeEach(function () {
+                mockScope = jasmine.createSpyObj('$scope', ['$watch', '$on']);
+                mockTicker = jasmine.createSpyObj('ticker', ['listen']);
+                mockUnticker = jasmine.createSpy('unticker');
+
+                mockTicker.listen.and.returnValue(mockUnticker);
+
+                controller = new ClockController(mockScope, mockTicker);
+            });
+
+            it("watches for model (clockFormat and timezone) from the domain object model", function () {
+                expect(mockScope.$watch).toHaveBeenCalledWith(
+                    "model",
+                    jasmine.any(Function)
+                );
+            });
+
+            it("subscribes to clock ticks", function () {
+                expect(mockTicker.listen)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+            });
+
+            it("unsubscribes to ticks when destroyed", function () {
+                // Make sure $destroy is being listened for...
+                expect(mockScope.$on.calls.mostRecent().args[0]).toEqual('$destroy');
+                expect(mockUnticker).not.toHaveBeenCalled();
+
+                // ...and makes sure that its listener unsubscribes from ticker
+                mockScope.$on.calls.mostRecent().args[1]();
+                expect(mockUnticker).toHaveBeenCalled();
+            });
+
+            it("formats using the format string from the model", function () {
+                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
+                mockScope.$watch.calls.mostRecent().args[1]({
+                    "clockFormat": [
+                        "YYYY-DDD hh:mm:ss",
+                        "clock24"
+                    ],
+                    "timezone": "Canada/Eastern"
+                });
+
+                expect(controller.zone()).toEqual("EDT");
+                expect(controller.text()).toEqual("2015-154 13:56:14");
+                expect(controller.ampm()).toEqual("");
+            });
+
+            it("formats 12-hour time", function () {
+                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
+                mockScope.$watch.calls.mostRecent().args[1]({
+                    "clockFormat": [
+                        "YYYY-DDD hh:mm:ss",
+                        "clock12"
+                    ],
+                    "timezone": ""
+                });
+
+                expect(controller.zone()).toEqual("UTC");
+                expect(controller.text()).toEqual("2015-154 05:56:14");
+                expect(controller.ampm()).toEqual("PM");
+            });
+
+            it("does not throw exceptions when model is undefined", function () {
+                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
+                expect(function () {
+                    mockScope.$watch.calls.mostRecent().args[1](undefined);
+                }).not.toThrow();
+            });
+
+        });
+    }
+);

platform/features/clock/test/indicators/ClockIndicatorSpec.js

@@ -0,0 +1,58 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2009-2016, 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/indicators/ClockIndicator"],
+    function (ClockIndicator) {
+
+        // Wed, 03 Jun 2015 17:56:14 GMT
+        var TEST_TIMESTAMP = 1433354174000,
+            TEST_FORMAT = "YYYY-DDD HH:mm:ss";
+
+        describe("The clock indicator", function () {
+            var mockTicker,
+                mockUnticker,
+                indicator;
+
+            beforeEach(function () {
+                mockTicker = jasmine.createSpyObj('ticker', ['listen']);
+                mockUnticker = jasmine.createSpy('unticker');
+
+                mockTicker.listen.and.returnValue(mockUnticker);
+
+                indicator = new ClockIndicator(mockTicker, TEST_FORMAT);
+            });
+
+            it("displays the current time", function () {
+                mockTicker.listen.calls.mostRecent().args[0](TEST_TIMESTAMP);
+                expect(indicator.getText()).toEqual("2015-154 17:56:14 UTC");
+            });
+
+            it("implements the Indicator interface", function () {
+                expect(indicator.getCssClass()).toEqual(jasmine.any(String));
+                expect(indicator.getText()).toEqual(jasmine.any(String));
+                expect(indicator.getDescription()).toEqual(jasmine.any(String));
+            });
+
+        });
+    }
+);

platform/import-export/bundle.js

@@ -30,8 +30,8 @@ define([
 
     return function ImportExportPlugin() {
         return function (openmct) {
-            ExportAsJSONAction.prototype.appliesTo = function (context) {
-                return this.openmct.$injector.get('policyService')
+            ExportAsJSONAction.appliesTo = function (context) {
+                return openmct.$injector.get('policyService')
                     .allow("creation", context.domainObject.getCapability("type")
                     );
             };

platform/import-export/test/actions/ExportAsJSONActionSpec.js

@@ -29,7 +29,7 @@ define(
     ],
     function (ExportAsJSONAction, domainObjectFactory, MCT, AdapterCapability) {
 
-        describe("The export JSON action", function () {
+        xdescribe("The export JSON action", function () {
 
             var context,
                 action,
@@ -102,7 +102,7 @@ define(
                 expect(action).toBeDefined();
             });
 
-            xit("doesn't export non-creatable objects in tree", function () {
+            it("doesn't export non-creatable objects in tree", function () {
                 var nonCreatableType = {
                     hasFeature:
                         function (feature) {
@@ -149,7 +149,7 @@ define(
                 });
             });
 
-            xit("can export self-containing objects", function () {
+            it("can export self-containing objects", function () {
                 var parent = domainObjectFactory({
                     name: 'parent',
                     model: {
@@ -191,7 +191,7 @@ define(
                 });
             });
 
-            xit("exports links to external objects as new objects", function () {
+            it("exports links to external objects as new objects", function () {
                 var parent = domainObjectFactory({
                     name: 'parent',
                     model: {

platform/import-export/test/actions/ImportAsJSONActionSpec.js

@@ -27,7 +27,7 @@ define(
     ],
     function (ImportAsJSONAction, domainObjectFactory) {
 
-        describe("The import JSON action", function () {
+        xdescribe("The import JSON action", function () {
 
             var context = {};
             var action,
@@ -146,7 +146,7 @@ define(
                 });
             });
 
-            xit("can import self-containing objects", function () {
+            it("can import self-containing objects", function () {
                 var compDomainObject = domainObjectFactory({
                     name: 'compObject',
                     model: { name: 'compObject'},
@@ -198,7 +198,7 @@ define(
                 });
             });
 
-            xit("assigns new ids to each imported object", function () {
+            it("assigns new ids to each imported object", function () {
                 dialogService.getUserInput.and.returnValue(Promise.resolve(
                     {
                         selectFile: {

src/api/Editor.js

@@ -34,6 +34,7 @@ export default class Editor extends EventEmitter {
      * Initiate an editing session. This will start a transaction during
      * which any persist operations will be deferred until either save()
      * or finish() are called.
+     * @private
      */
     edit() {
         if (this.editing === true) {
@@ -41,8 +42,8 @@ export default class Editor extends EventEmitter {
         }
 
         this.editing = true;
+        this.getTransactionService().startTransaction();
         this.emit('isEditing', true);
-        this.openmct.objects.startTransaction();
     }
 
     /**
@@ -55,24 +56,41 @@ export default class Editor extends EventEmitter {
     /**
      * Save any unsaved changes from this editing session. This will
      * end the current transaction.
+     *
+     * @private
      */
     save() {
-        return this.openmct.objects.CommitAllTransactions()
-            .then(() => {
-                this.editing = false;
-                this.emit('isEditing', false);
-            }).catch(error => {
-                throw error;
-            });
+        return this.getTransactionService().commit().then((result) => {
+            this.editing = false;
+            this.emit('isEditing', false);
+
+            return result;
+        }).catch((error) => {
+            throw error;
+        });
     }
 
     /**
      * End the currently active transaction and discard unsaved changes.
+     *
+     * @private
      */
     cancel() {
+        let cancelPromise = this.getTransactionService().cancel();
         this.editing = false;
         this.emit('isEditing', false);
 
-        return this.openmct.objects.CancelAllTransactions();
+        return cancelPromise;
+    }
+
+    /**
+     * @private
+     */
+    getTransactionService() {
+        if (!this.transactionService) {
+            this.transactionService = this.openmct.$injector.get('transactionService');
+        }
+
+        return this.transactionService;
     }
 }

src/api/objects/ConflictError.js

@@ -1,2 +0,0 @@
-export default class ConflictError extends Error {
-}

src/api/objects/ObjectAPI.js

@@ -26,8 +26,6 @@ import RootRegistry from './RootRegistry';
 import RootObjectProvider from './RootObjectProvider';
 import EventEmitter from 'EventEmitter';
 import InterceptorRegistry from './InterceptorRegistry';
-import TransactionManager from './TransactionManager';
-import ConflictError from './ConflictError';
 
 /**
  * Utilities for loading, saving, and manipulating domain objects.
@@ -36,14 +34,12 @@ import ConflictError from './ConflictError';
  */
 
 function ObjectAPI(typeRegistry, openmct) {
-    this.openmct = openmct;
-
     this.typeRegistry = typeRegistry;
     this.eventEmitter = new EventEmitter();
     this.providers = {};
     this.rootRegistry = new RootRegistry();
     this.injectIdentifierService = function () {
-        this.identifierService = this.openmct.$injector.get("identifierService");
+        this.identifierService = openmct.$injector.get("identifierService");
     };
 
     this.rootProvider = new RootObjectProvider(this.rootRegistry);
@@ -51,10 +47,6 @@ function ObjectAPI(typeRegistry, openmct) {
     this.interceptorRegistry = new InterceptorRegistry();
 
     this.SYNCHRONIZED_OBJECT_TYPES = ['notebook', 'plan'];
-
-    this.errors = {
-        Conflict: ConflictError
-    };
 }
 
 /**
@@ -320,27 +312,6 @@ ObjectAPI.prototype.save = function (domainObject) {
     return result;
 };
 
-/**
- * After entering into edit mode, creates a new instance of TransactionManager to keep track of changes in Objects
- */
-ObjectAPI.prototype.startTransaction = function () {
-    this.transactionManager = new TransactionManager();
-};
-
-/**
- * When in edit mode, after save action commit/persists all stored transactions
- */
-ObjectAPI.prototype.CommitAllTransactions = function () {
-    return this.transactionManager.CommitAllTransactions(this.save.bind(this));
-};
-
-/**
- * When in edit mode, after cancel action discard all stored transactions
- */
-ObjectAPI.prototype.CancelAllTransactions = function () {
-    return this.transactionManager.CancelAllTransactions();
-};
-
 /**
  * Add a root-level object.
  * @param {module:openmct.ObjectAPI~Identifier|function} an array of
@@ -387,20 +358,6 @@ ObjectAPI.prototype.applyGetInterceptors = function (identifier, domainObject) {
     return domainObject;
 };
 
-/**
- * Return relative url path from a given object path
- * eg: #/browse/mine/cb56f6bf-c900-43b7-b923-2e3b64b412db/6e89e858-77ce-46e4-a1ad-749240286497/....
- * @param {Array} objectPath
- * @returns {string} relative url for object
- */
-ObjectAPI.prototype.getRelativePath = function (objectPath) {
-    return objectPath
-        .map(p => this.makeKeyString(p.identifier))
-        .reverse()
-        .join('/')
-    ;
-};
-
 /**
  * Modify a domain object.
  * @param {module:openmct.DomainObject} object the object to mutate
@@ -430,12 +387,6 @@ ObjectAPI.prototype.mutate = function (domainObject, path, value) {
         //Destroy temporary mutable object
         this.destroyMutable(mutableDomainObject);
     }
-
-    if (this.transactionManager && this.openmct.editor.isEditing()) {
-        this.transactionManager.addTransaction(domainObject);
-    } else {
-        this.save(domainObject);
-    }
 };
 
 /**

src/api/objects/ObjectAPISpec.js

@@ -26,10 +26,6 @@ describe("The Object API", () => {
 
         openmct.$injector.get.and.returnValue(mockIdentifierService);
         objectAPI = new ObjectAPI(typeRegistry, openmct);
-
-        openmct.editor = {};
-        openmct.editor.isEditing = () => false;
-
         mockDomainObject = {
             identifier: {
                 namespace: TEST_NAMESPACE,

src/api/overlays/Overlay.js

@@ -10,37 +10,28 @@ const cssClasses = {
 };
 
 class Overlay extends EventEmitter {
-    constructor({
-        buttons,
-        autoHide = true,
-        dismissable = true,
-        element,
-        onDestroy,
-        size
-    } = {}) {
+    constructor(options) {
         super();
 
+        this.dismissable = options.dismissable !== false;
         this.container = document.createElement('div');
-        this.container.classList.add('l-overlay-wrapper', cssClasses[size]);
-
-        this.autoHide = autoHide;
-        this.dismissable = dismissable !== false;
+        this.container.classList.add('l-overlay-wrapper', cssClasses[options.size]);
 
         this.component = new Vue({
-            components: {
-                OverlayComponent: OverlayComponent
-            },
             provide: {
                 dismiss: this.dismiss.bind(this),
-                element,
-                buttons,
+                element: options.element,
+                buttons: options.buttons,
                 dismissable: this.dismissable
             },
+            components: {
+                OverlayComponent: OverlayComponent
+            },
             template: '<overlay-component></overlay-component>'
         });
 
-        if (onDestroy) {
-            this.once('destroy', onDestroy);
+        if (options.onDestroy) {
+            this.once('destroy', options.onDestroy);
         }
     }
 

src/api/overlays/OverlayAPI.js

@@ -30,10 +30,7 @@ class OverlayAPI {
      */
     showOverlay(overlay) {
         if (this.activeOverlays.length) {
-            const previousOverlay = this.activeOverlays[this.activeOverlays.length - 1];
-            if (previousOverlay.autoHide) {
-                previousOverlay.container.classList.add('invisible');
-            }
+            this.activeOverlays[this.activeOverlays.length - 1].container.classList.add('invisible');
         }
 
         this.activeOverlays.push(overlay);

src/api/telemetry/TelemetryCollection.js

@@ -342,8 +342,6 @@ export class TelemetryCollection extends EventEmitter {
         this.boundedTelemetry = [];
         this.futureBuffer = [];
 
-        this.emit('clear');
-
         this._requestHistoricalTelemetry();
     }
 

src/exporters/ImageExporter.js

@@ -90,7 +90,7 @@ class ImageExporter {
                 element.id = oldId;
             },
             removeContainer: true // Set to false to debug what html2canvas renders
-        }).then(canvas => {
+        }).then(function (canvas) {
             dialog.dismiss();
 
             return new Promise(function (resolve, reject) {
@@ -105,10 +105,9 @@ class ImageExporter {
 
                 return canvas.toBlob(blob => resolve({ blob }), mimeType);
             });
-        }).catch(error => {
+        }, function (error) {
+            console.log('error capturing image', error);
             dialog.dismiss();
-
-            console.error('error capturing image', error);
             const errorDialog = overlays.dialog({
                 iconClass: 'error',
                 message: 'Image was not captured successfully!',

src/plugins/clearData/ClearDataAction.js

@@ -1,78 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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.
- *****************************************************************************/
-
-function inSelectionPath(openmct, domainObject) {
-    const domainObjectIdentifier = domainObject.identifier;
-
-    return openmct.selection.get().some(selectionPath => {
-        return selectionPath.some(objectInPath => {
-            const objectInPathIdentifier = objectInPath.context.item.identifier;
-
-            return openmct.objects.areIdsEqual(objectInPathIdentifier, domainObjectIdentifier);
-        });
-    });
-}
-
-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';
-
-        this._openmct = openmct;
-        this._appliesToObjects = appliesToObjects;
-    }
-    invoke(objectPath) {
-        let domainObject = null;
-        if (objectPath) {
-            domainObject = objectPath[0];
-        }
-
-        this._openmct.objectViews.emit('clearData', domainObject);
-    }
-    appliesTo(objectPath) {
-        if (!objectPath) {
-            return false;
-        }
-
-        const contextualDomainObject = objectPath[0];
-        // first check to see if this action applies to this sort of object at all
-        const appliesToThisObject = this._appliesToObjects.some(type => {
-            return contextualDomainObject.type === type;
-        });
-        if (!appliesToThisObject) {
-            // we've selected something not applicable
-            return false;
-        }
-
-        const objectInSelectionPath = inSelectionPath(this._openmct, contextualDomainObject);
-        if (objectInSelectionPath) {
-            return true;
-        } else {
-            // if this it doesn't match up, check to see if we're in a composition (i.e., layout)
-            const routerPath = this._openmct.router.path[0];
-
-            return routerPath.type === 'layout';
-        }
-    }
-}

src/plugins/clearData/clearDataAction.js

@@ -20,35 +20,22 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-export default class TransactionManager {
-    constructor() {
-        this.transactions = new Set();
+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';
+
+        this._openmct = openmct;
+        this._appliesToObjects = appliesToObjects;
     }
-
-    addTransaction(object) {
-        this.transactions.add(object);
+    invoke(objectPath) {
+        this._openmct.objectViews.emit('clearData', objectPath[0]);
     }
+    appliesTo(objectPath) {
+        let contextualDomainObject = objectPath[0];
 
-    CancelAllTransactions() {
-        return this.clearTransactions();
-    }
-
-    CommitAllTransactions(save) {
-        const promisesArray = [];
-        this.transactions.forEach(o => {
-            promisesArray.push(save(o));
-        });
-
-        this.clearTransactions();
-
-        return Promise.all(promisesArray);
-    }
-
-    clearTransactions() {
-        this.transactions = new Set();
-        // TODO:
-        // call `this.opemct.objects.refresh()`
-
-        return Promise.resolve();
+        return this._appliesToObjects.filter(type => contextualDomainObject.type === type).length;
     }
 }

src/plugins/clearData/plugin.js

@@ -22,7 +22,7 @@
 
 define([
     './components/globalClearIndicator.vue',
-    './ClearDataAction',
+    './clearDataAction',
     'vue'
 ], function (
     GlobaClearIndicator,

src/plugins/clearData/test/ClearDataActionSpec.js

@@ -1,140 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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 ClearDataActionPlugin from '../plugin.js';
-import ClearDataAction from '../ClearDataAction.js';
-
-describe('When the Clear Data Plugin is installed,', () => {
-    const mockObjectViews = jasmine.createSpyObj('objectViews', ['emit']);
-    const mockIndicatorProvider = jasmine.createSpyObj('indicators', ['add']);
-    const mockActionsProvider = jasmine.createSpyObj('actions', ['register']);
-    const goodMockSelectionPath = [[{
-        context: {
-            item: {
-                identifier: {
-                    key: 'apple',
-                    namespace: ''
-                }
-            }
-        }
-    }]];
-
-    const openmct = {
-        objectViews: mockObjectViews,
-        indicators: mockIndicatorProvider,
-        actions: mockActionsProvider,
-        install: function (plugin) {
-            plugin(this);
-        },
-        selection: {
-            get: function () {
-                return goodMockSelectionPath;
-            }
-        },
-        objects: {
-            areIdsEqual: function (obj1, obj2) {
-                return true;
-            }
-        }
-    };
-
-    const mockObjectPath = [
-        {
-            name: 'mockObject1',
-            type: 'apple'
-        },
-        {
-            name: 'mockObject2',
-            type: 'banana'
-        }
-    ];
-
-    it('Global Clear Indicator is installed', () => {
-        openmct.install(ClearDataActionPlugin([]));
-
-        expect(mockIndicatorProvider.add).toHaveBeenCalled();
-    });
-
-    it('Clear Data context menu action is installed', () => {
-        openmct.install(ClearDataActionPlugin([]));
-
-        expect(mockActionsProvider.register).toHaveBeenCalled();
-    });
-
-    it('clear data action emits a clearData event when invoked', () => {
-        const action = new ClearDataAction(openmct);
-
-        action.invoke(mockObjectPath);
-
-        expect(mockObjectViews.emit).toHaveBeenCalledWith('clearData', mockObjectPath[0]);
-    });
-
-    it('clears data on applicable objects', () => {
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(true);
-    });
-
-    it('does not clear data on inapplicable objects', () => {
-        let action = new ClearDataAction(openmct, ['pineapple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(false);
-    });
-
-    it('does not clear data if not in the selection path and not a layout', () => {
-        openmct.objects = {
-            areIdsEqual: function (obj1, obj2) {
-                return false;
-            }
-        };
-        openmct.router = {
-            path: [{type: 'not-a-layout'}]
-        };
-
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(false);
-    });
-
-    it('does clear data if not in the selection path and is a layout', () => {
-        openmct.objects = {
-            areIdsEqual: function (obj1, obj2) {
-                return false;
-            }
-        };
-        openmct.router = {
-            path: [{type: 'layout'}]
-        };
-
-        let action = new ClearDataAction(openmct, ['apple']);
-
-        const actionApplies = action.appliesTo(mockObjectPath);
-
-        expect(actionApplies).toBe(true);
-    });
-});

src/plugins/clearData/test/clearDataActionSpec.js

@@ -0,0 +1,64 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 ClearDataActionPlugin from '../plugin.js';
+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 openmct = {
+        objectViews: mockObjectViews,
+        indicators: mockIndicatorProvider,
+        actions: mockActionsProvider,
+        install: function (plugin) {
+            plugin(this);
+        }
+    };
+
+    const mockObjectPath = [
+        {name: 'mockObject1'},
+        {name: 'mockObject2'}
+    ];
+
+    it('Global Clear Indicator is installed', function () {
+        openmct.install(ClearDataActionPlugin([]));
+
+        expect(mockIndicatorProvider.add).toHaveBeenCalled();
+    });
+
+    it('Clear Data context menu action is installed', function () {
+        openmct.install(ClearDataActionPlugin([]));
+
+        expect(mockActionsProvider.register).toHaveBeenCalled();
+    });
+
+    it('clear data action emits a clearData event when invoked', function () {
+        let action = new ClearDataAction(openmct);
+
+        action.invoke(mockObjectPath);
+
+        expect(mockObjectViews.emit).toHaveBeenCalledWith('clearData', mockObjectPath[0]);
+    });
+});

src/plugins/clock/components/Clock.vue

@@ -1,99 +0,0 @@
-<!--
- Open MCT, Copyright (c) 2014-2021, United States Government
- as represented by the Administrator of the National Aeronautics and Space
- Administration. All rights reserved.
-
- Open MCT is licensed under the Apache License, Version 2.0 (the
- "License"); you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0.
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- License for the specific language governing permissions and limitations
- under the License.
-
- Open MCT includes source code licensed under additional open source
- licenses. See the Open Source Licenses file (LICENSES.md) included with
- this source code distribution or the Licensing information page available
- at runtime from the About dialog for additional information.
--->
-
-<template>
-<div class="l-angular-ov-wrapper">
-    <div class="u-contents">
-        <div class="c-clock l-time-display u-style-receiver js-style-receiver">
-            <div class="c-clock__timezone">
-                {{ timeZoneAbbr }}
-            </div>
-            <div class="c-clock__value">
-                {{ timeTextValue }}
-            </div>
-            <div class="c-clock__ampm">
-                {{ timeAmPm }}
-            </div>
-        </div>
-    </div>
-</div>
-</template>
-
-<script>
-import moment from 'moment';
-import momentTimezone from 'moment-timezone';
-
-export default {
-    inject: ['openmct', 'domainObject'],
-    data() {
-        return {
-            lastTimestamp: null
-        };
-    },
-    computed: {
-        configuration() {
-            return this.domainObject.configuration;
-        },
-        baseFormat() {
-            return this.configuration.baseFormat;
-        },
-        use24() {
-            return this.configuration.use24 === 'clock24';
-        },
-        timezone() {
-            return this.configuration.timezone;
-        },
-        timeFormat() {
-            return this.use24 ? this.baseFormat.replace('hh', "HH") : this.baseFormat;
-        },
-        zoneName() {
-            return momentTimezone.tz.names().includes(this.timezone) ? this.timezone : "UTC";
-        },
-        momentTime() {
-            return this.zoneName ? moment.utc(this.lastTimestamp).tz(this.zoneName) : moment.utc(this.lastTimestamp);
-        },
-        timeZoneAbbr() {
-            return this.momentTime.zoneAbbr();
-        },
-        timeTextValue() {
-            return this.timeFormat && this.momentTime.format(this.timeFormat);
-        },
-        timeAmPm() {
-            return this.use24 ? '' : this.momentTime.format("A");
-        }
-    },
-    mounted() {
-        const TickerService = this.openmct.$injector.get('tickerService');
-        this.unlisten = TickerService.listen(this.tick);
-    },
-    beforeDestroy() {
-        if (this.unlisten) {
-            this.unlisten();
-        }
-    },
-    methods: {
-        tick(timestamp) {
-            this.lastTimestamp = timestamp;
-        }
-    }
-};
-</script>

src/plugins/clock/components/ClockIndicator.vue

@@ -1,64 +0,0 @@
-<!--
- Open MCT, Copyright (c) 2014-2021, United States Government
- as represented by the Administrator of the National Aeronautics and Space
- Administration. All rights reserved.
-
- Open MCT is licensed under the Apache License, Version 2.0 (the
- "License"); you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0.
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- License for the specific language governing permissions and limitations
- under the License.
-
- Open MCT includes source code licensed under additional open source
- licenses. See the Open Source Licenses file (LICENSES.md) included with
- this source code distribution or the Licensing information page available
- at runtime from the About dialog for additional information.
--->
-
-<template>
-<div class="c-indicator t-indicator-clock icon-clock no-minify c-indicator--not-clickable">
-    <span class="label c-indicator__label">
-        {{ timeTextValue }}
-    </span>
-</div>
-</template>
-
-<script>
-import moment from 'moment';
-
-export default {
-    inject: ['openmct'],
-    props: {
-        indicatorFormat: {
-            type: String,
-            required: true
-        }
-    },
-    data() {
-        return {
-            timeTextValue: null
-        };
-    },
-    mounted() {
-        this.openmct.on('start', () => {
-            const TickerService = this.openmct.$injector.get('tickerService');
-            this.unlisten = TickerService.listen(this.tick);
-        });
-    },
-    beforeDestroy() {
-        if (this.unlisten) {
-            this.unlisten();
-        }
-    },
-    methods: {
-        tick(timestamp) {
-            this.timeTextValue = `${moment.utc(timestamp).format(this.indicatorFormat)} UTC`;
-        }
-    }
-};
-</script>

src/plugins/clock/plugin.js

@@ -1,154 +0,0 @@
-
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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 ClockViewProvider from './ClockViewProvider';
-import ClockIndicator from './components/ClockIndicator.vue';
-
-import momentTimezone from 'moment-timezone';
-import Vue from 'vue';
-
-export default function ClockPlugin(options) {
-    return function install(openmct) {
-        const CLOCK_INDICATOR_FORMAT = 'YYYY/MM/DD HH:mm:ss';
-        openmct.types.addType('clock', {
-            name: 'Clock',
-            description: 'A UTC-based clock that supports a variety of display formats. Clocks can be added to Display Layouts.',
-            creatable: true,
-            cssClass: 'icon-clock',
-            initialize: function (domainObject) {
-                domainObject.configuration = {
-                    baseFormat: 'YYYY/MM/DD hh:mm:ss',
-                    use24: 'clock12',
-                    timezone: 'UTC'
-                };
-            },
-            "form": [
-                {
-                    "key": "displayFormat",
-                    "name": "Display Format",
-                    control: 'select',
-                    options: [
-                        {
-                            value: 'YYYY/MM/DD hh:mm:ss',
-                            name: 'YYYY/MM/DD hh:mm:ss'
-                        },
-                        {
-                            value: 'YYYY/DDD hh:mm:ss',
-                            name: 'YYYY/DDD hh:mm:ss'
-                        },
-                        {
-                            value: 'hh:mm:ss',
-                            name: 'hh:mm:ss'
-                        }
-                    ],
-                    cssClass: 'l-inline',
-                    property: [
-                        'configuration',
-                        'baseFormat'
-                    ]
-                },
-                {
-                    control: 'select',
-                    options: [
-                        {
-                            value: 'clock12',
-                            name: '12hr'
-                        },
-                        {
-                            value: 'clock24',
-                            name: '24hr'
-                        }
-                    ],
-                    cssClass: 'l-inline',
-                    property: [
-                        'configuration',
-                        'use24'
-                    ]
-                },
-                {
-                    "key": "timezone",
-                    "name": "Timezone",
-                    "control": "autocomplete",
-                    "options": momentTimezone.tz.names(),
-                    property: [
-                        'configuration',
-                        'timezone'
-                    ]
-                }
-            ]
-        });
-        openmct.objectViews.addProvider(new ClockViewProvider(openmct));
-
-        if (options && options.enableClockIndicator === true) {
-            const clockIndicator = new Vue ({
-                components: {
-                    ClockIndicator
-                },
-                provide: {
-                    openmct
-                },
-                data() {
-                    return {
-                        indicatorFormat: CLOCK_INDICATOR_FORMAT
-                    };
-                },
-                template: '<ClockIndicator :indicator-format="indicatorFormat" />'
-            });
-            const indicator = {
-                element: clockIndicator.$mount().$el,
-                key: 'clock-indicator'
-            };
-
-            openmct.indicators.add(indicator);
-        }
-
-        openmct.objects.addGetInterceptor({
-            appliesTo: (identifier, domainObject) => {
-                return domainObject && domainObject.type === 'clock';
-            },
-            invoke: (identifier, domainObject) => {
-                if (domainObject.configuration) {
-                    return domainObject;
-                }
-
-                if (domainObject.clockFormat
-                    && domainObject.timezone) {
-                    const baseFormat = domainObject.clockFormat[0];
-                    const use24 = domainObject.clockFormat[1];
-                    const timezone = domainObject.timezone;
-
-                    domainObject.configuration = {
-                        baseFormat,
-                        use24,
-                        timezone
-                    };
-
-                    openmct.objects.mutate(domainObject, 'configuration', domainObject.configuration);
-                }
-
-                return domainObject;
-            }
-        });
-
-    };
-}

src/plugins/clock/pluginSpec.js

@@ -1,231 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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';
-import clockPlugin from './plugin';
-
-import Vue from 'vue';
-
-describe("Clock plugin:", () => {
-    let openmct;
-    let clockDefinition;
-    let element;
-    let child;
-    let appHolder;
-
-    let clockDomainObject;
-
-    function setupClock(enableClockIndicator) {
-        return new Promise((resolve, reject) => {
-            clockDomainObject = {
-                identifier: {
-                    key: 'clock',
-                    namespace: 'test-namespace'
-                },
-                type: 'clock'
-            };
-
-            appHolder = document.createElement('div');
-            appHolder.style.width = '640px';
-            appHolder.style.height = '480px';
-            document.body.appendChild(appHolder);
-
-            openmct = createOpenMct();
-
-            element = document.createElement('div');
-            child = document.createElement('div');
-            element.appendChild(child);
-
-            openmct.install(clockPlugin({ enableClockIndicator }));
-
-            clockDefinition = openmct.types.get('clock').definition;
-            clockDefinition.initialize(clockDomainObject);
-
-            openmct.on('start', resolve);
-            openmct.start(appHolder);
-        });
-    }
-
-    describe("Clock view:", () => {
-        let clockViewProvider;
-        let clockView;
-        let clockViewObject;
-        let mutableClockObject;
-
-        beforeEach(async () => {
-            await setupClock(true);
-
-            clockViewObject = {
-                ...clockDomainObject,
-                id: "test-object",
-                name: 'Clock',
-                configuration: {
-                    baseFormat: 'YYYY/MM/DD hh:mm:ss',
-                    use24: 'clock12',
-                    timezone: 'UTC'
-                }
-            };
-
-            spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve(clockViewObject));
-            spyOn(openmct.objects, 'save').and.returnValue(Promise.resolve(true));
-
-            const applicableViews = openmct.objectViews.get(clockViewObject, [clockViewObject]);
-            clockViewProvider = applicableViews.find(viewProvider => viewProvider.key === 'clock.view');
-
-            mutableClockObject = await openmct.objects.getMutable(clockViewObject.identifier);
-
-            clockView = clockViewProvider.view(mutableClockObject);
-            clockView.show(child);
-
-            await Vue.nextTick();
-        });
-
-        afterEach(() => {
-            clockView.destroy();
-            openmct.objects.destroyMutable(mutableClockObject);
-            if (appHolder) {
-                appHolder.remove();
-            }
-
-            return resetApplicationState(openmct);
-        });
-
-        it("has name as Clock", () => {
-            expect(clockDefinition.name).toEqual('Clock');
-        });
-
-        it("is creatable", () => {
-            expect(clockDefinition.creatable).toEqual(true);
-        });
-
-        it("provides clock view", () => {
-            expect(clockViewProvider).toBeDefined();
-        });
-
-        it("renders clock element", () => {
-            const clockElement = element.querySelectorAll('.c-clock');
-            expect(clockElement.length).toBe(1);
-        });
-
-        it("renders major elements", () => {
-            const clockElement = element.querySelector('.c-clock');
-            const timezone = clockElement.querySelector('.c-clock__timezone');
-            const time = clockElement.querySelector('.c-clock__value');
-            const amPm = clockElement.querySelector('.c-clock__ampm');
-            const hasMajorElements = Boolean(timezone && time && amPm);
-
-            expect(hasMajorElements).toBe(true);
-        });
-
-        it("renders time in UTC", () => {
-            const clockElement = element.querySelector('.c-clock');
-            const timezone = clockElement.querySelector('.c-clock__timezone').textContent.trim();
-
-            expect(timezone).toBe('UTC');
-        });
-
-        it("updates the 24 hour option in the configuration", (done) => {
-            expect(clockDomainObject.configuration.use24).toBe('clock12');
-            const new24Option = 'clock24';
-
-            openmct.objects.observe(clockViewObject, 'configuration', (changedDomainObject) => {
-                expect(changedDomainObject.use24).toBe(new24Option);
-                done();
-            });
-
-            openmct.objects.mutate(clockViewObject, 'configuration.use24', new24Option);
-        });
-
-        it("updates the timezone option in the configuration", (done) => {
-            expect(clockDomainObject.configuration.timezone).toBe('UTC');
-            const newZone = 'CST6CDT';
-
-            openmct.objects.observe(clockViewObject, 'configuration', (changedDomainObject) => {
-                expect(changedDomainObject.timezone).toBe(newZone);
-                done();
-            });
-
-            openmct.objects.mutate(clockViewObject, 'configuration.timezone', newZone);
-        });
-
-        it("updates the time format option in the configuration", (done) => {
-            expect(clockDomainObject.configuration.baseFormat).toBe('YYYY/MM/DD hh:mm:ss');
-            const newFormat = 'hh:mm:ss';
-
-            openmct.objects.observe(clockViewObject, 'configuration', (changedDomainObject) => {
-                expect(changedDomainObject.baseFormat).toBe(newFormat);
-                done();
-            });
-
-            openmct.objects.mutate(clockViewObject, 'configuration.baseFormat', newFormat);
-        });
-    });
-
-    describe("Clock Indicator view:", () => {
-        let clockIndicator;
-
-        afterEach(() => {
-            if (clockIndicator) {
-                clockIndicator.remove();
-            }
-
-            clockIndicator = undefined;
-            if (appHolder) {
-                appHolder.remove();
-            }
-
-            return resetApplicationState(openmct);
-        });
-
-        it("doesn't exist", async () => {
-            await setupClock(false);
-
-            clockIndicator = openmct.indicators.indicatorObjects
-                .find(indicator => indicator.key === 'clock-indicator');
-
-            const clockIndicatorMissing = clockIndicator === null || clockIndicator === undefined;
-            expect(clockIndicatorMissing).toBe(true);
-        });
-
-        it("exists", async () => {
-            await setupClock(true);
-
-            clockIndicator = openmct.indicators.indicatorObjects
-                .find(indicator => indicator.key === 'clock-indicator').element;
-
-            const hasClockIndicator = clockIndicator !== null && clockIndicator !== undefined;
-            expect(hasClockIndicator).toBe(true);
-        });
-
-        it("contains text", async () => {
-            await setupClock(true);
-
-            clockIndicator = openmct.indicators.indicatorObjects
-                .find(indicator => indicator.key === 'clock-indicator').element;
-
-            const clockIndicatorText = clockIndicator.textContent.trim();
-            const textIncludesUTC = clockIndicatorText.includes('UTC');
-
-            expect(textIncludesUTC).toBe(true);
-        });
-    });
-});

src/plugins/condition/components/inspector/ConditionalStylesView.vue

@@ -273,7 +273,10 @@ export default {
             this.openmct.objects.getOriginalPath(this.conditionSetDomainObject.identifier).then(
                 (objectPath) => {
                     this.objectPath = objectPath;
-                    this.navigateToPath = '#/browse/' + this.openmct.objects.getRelativePath(this.objectPath);
+                    this.navigateToPath = '#/browse/' + this.objectPath
+                        .map(o => o && this.openmct.objects.makeKeyString(o.identifier))
+                        .reverse()
+                        .join('/');
                 }
             );
         },

src/plugins/condition/components/inspector/StylesView.vue

@@ -141,7 +141,6 @@ const NON_STYLEABLE_CONTAINER_TYPES = [
 const NON_STYLEABLE_LAYOUT_ITEM_TYPES = [
     'line-view',
     'box-view',
-    'ellipse-view',
     'image-view'
 ];
 
@@ -297,7 +296,10 @@ export default {
             this.openmct.objects.getOriginalPath(this.conditionSetDomainObject.identifier).then(
                 (objectPath) => {
                     this.objectPath = objectPath;
-                    this.navigateToPath = '#/browse/' + this.openmct.objects.getRelativePath(this.objectPath);
+                    this.navigateToPath = '#/browse/' + this.objectPath
+                        .map(o => o && this.openmct.objects.makeKeyString(o.identifier))
+                        .reverse()
+                        .join('/');
                 }
             );
         },

src/plugins/condition/pluginSpec.js

@@ -230,7 +230,7 @@ describe('the plugin', function () {
         };
         const staticStyle = {
             "style": {
-                "backgroundColor": "#666666",
+                "backgroundColor": "#717171",
                 "border": "1px solid #00ffff"
             }
         };
@@ -238,7 +238,7 @@ describe('the plugin', function () {
             "conditionId": "39584410-cbf9-499e-96dc-76f27e69885d",
             "style": {
                 "isStyleInvisible": "",
-                "backgroundColor": "#666666",
+                "backgroundColor": "#717171",
                 "border": "1px solid #ffff00"
             }
         };
@@ -250,7 +250,7 @@ describe('the plugin', function () {
                 "configuration": {
                     "items": [
                         {
-                            "fill": "#666666",
+                            "fill": "#717171",
                             "stroke": "",
                             "x": 1,
                             "y": 1,
@@ -259,22 +259,12 @@ describe('the plugin', function () {
                             "type": "box-view",
                             "id": "89b88746-d325-487b-aec4-11b79afff9e8"
                         },
-                        {
-                            "fill": "#666666",
-                            "stroke": "",
-                            "x": 1,
-                            "y": 1,
-                            "width": 10,
-                            "height": 5,
-                            "type": "ellipse-view",
-                            "id": "19b88746-d325-487b-aec4-11b79afff9z8"
-                        },
                         {
                             "x": 18,
                             "y": 9,
                             "x2": 23,
                             "y2": 4,
-                            "stroke": "#666666",
+                            "stroke": "#717171",
                             "type": "line-view",
                             "id": "57d49a28-7863-43bd-9593-6570758916f0"
                         },
@@ -309,12 +299,12 @@ describe('the plugin', function () {
                 "y": 9,
                 "x2": 23,
                 "y2": 4,
-                "stroke": "#666666",
+                "stroke": "#717171",
                 "type": "line-view",
                 "id": "57d49a28-7863-43bd-9593-6570758916f0"
             };
             boxLayoutItem = {
-                "fill": "#666666",
+                "fill": "#717171",
                 "stroke": "",
                 "x": 1,
                 "y": 1,

src/plugins/condition/utils/styleUtils.js

@@ -29,10 +29,9 @@ const styleProps = {
         noneValue: NONE_VALUE,
         applicableForType: type => {
             return !type ? true : (type === 'text-view'
-                                            || type === 'telemetry-view'
-                                            || type === 'box-view'
-                                            || type === 'ellipse-view'
-                                            || type === 'subobject-view');
+                                      || type === 'telemetry-view'
+                                      || type === 'box-view'
+                                      || type === 'subobject-view');
         }
     },
     border: {
@@ -42,7 +41,6 @@ const styleProps = {
             return !type ? true : (type === 'text-view'
                                             || type === 'telemetry-view'
                                             || type === 'box-view'
-                                            || type === 'ellipse-view'
                                             || type === 'image-view'
                                             || type === 'line-view'
                                             || type === 'subobject-view');

src/plugins/displayLayout/DisplayLayoutToolbar.js

@@ -149,7 +149,6 @@ define(['lodash'], function (_) {
                         return type === 'text-view'
                             || type === 'telemetry-view'
                             || type === 'box-view'
-                            || type === 'ellipse-view'
                             || type === 'image-view'
                             || type === 'line-view'
                             || type === 'subobject-view';
@@ -181,10 +180,6 @@ define(['lodash'], function (_) {
                                     "name": "Box",
                                     "class": "icon-box-round-corners"
                                 },
-                                {
-                                    "name": "Ellipse",
-                                    "class": "icon-circle"
-                                },
                                 {
                                     "name": "Line",
                                     "class": "icon-line-horz"
@@ -750,7 +745,7 @@ define(['lodash'], function (_) {
                         if (toolbar.remove.length === 0) {
                             toolbar.remove = [getRemoveButton(selectedParent, selectionPath, selectedObjects)];
                         }
-                    } else if (layoutItem.type === 'box-view' || layoutItem.type === 'ellipse-view') {
+                    } else if (layoutItem.type === 'box-view') {
                         if (toolbar.position.length === 0) {
                             toolbar.position = [
                                 getStackOrder(selectedParent, selectionPath),

src/plugins/displayLayout/components/BoxView.vue

@@ -43,7 +43,7 @@ import conditionalStylesMixin from '../mixins/objectStyles-mixin';
 export default {
     makeDefinition() {
         return {
-            fill: '#666666',
+            fill: '#717171',
             stroke: '',
             x: 1,
             y: 1,

src/plugins/displayLayout/components/DisplayLayout.vue

@@ -76,7 +76,6 @@ import uuid from 'uuid';
 import SubobjectView from './SubobjectView.vue';
 import TelemetryView from './TelemetryView.vue';
 import BoxView from './BoxView.vue';
-import EllipseView from './EllipseView.vue';
 import TextView from './TextView.vue';
 import LineView from './LineView.vue';
 import ImageView from './ImageView.vue';
@@ -113,7 +112,6 @@ const ITEM_TYPE_VIEW_MAP = {
     'subobject-view': SubobjectView,
     'telemetry-view': TelemetryView,
     'box-view': BoxView,
-    'ellipse-view': EllipseView,
     'line-view': LineView,
     'text-view': TextView,
     'image-view': ImageView

src/plugins/displayLayout/components/EllipseView.vue

@@ -1,122 +0,0 @@
-/*****************************************************************************
-* Open MCT, Copyright (c) 2014-2021, United States Government
-* as represented by the Administrator of the National Aeronautics and Space
-* Administration. All rights reserved.
-*
-* Open MCT is licensed under the Apache License, Version 2.0 (the
-* "License"); you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-* http://www.apache.org/licenses/LICENSE-2.0.
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-* License for the specific language governing permissions and limitations
-* under the License.
-*
-* Open MCT includes source code licensed under additional open source
-* licenses. See the Open Source Licenses file (LICENSES.md) included with
-* this source code distribution or the Licensing information page available
-* at runtime from the About dialog for additional information.
-*****************************************************************************/
-
-<template>
-<layout-frame
-    :item="item"
-    :grid-size="gridSize"
-    :is-editing="isEditing"
-    @move="(gridDelta) => $emit('move', gridDelta)"
-    @endMove="() => $emit('endMove')"
->
-    <div
-        class="c-ellipse-view u-style-receiver js-style-receiver"
-        :class="[styleClass]"
-        :style="style"
-    ></div>
-</layout-frame>
-</template>
-
-<script>
-import LayoutFrame from './LayoutFrame.vue';
-import conditionalStylesMixin from '../mixins/objectStyles-mixin';
-
-export default {
-    makeDefinition() {
-        return {
-            fill: '#666666',
-            stroke: '',
-            x: 1,
-            y: 1,
-            width: 10,
-            height: 10
-        };
-    },
-    components: {
-        LayoutFrame
-    },
-    mixins: [conditionalStylesMixin],
-    inject: ['openmct'],
-    props: {
-        item: {
-            type: Object,
-            required: true
-        },
-        gridSize: {
-            type: Array,
-            required: true,
-            validator: (arr) => arr && arr.length === 2
-                    && arr.every(el => typeof el === 'number')
-        },
-        index: {
-            type: Number,
-            required: true
-        },
-        initSelect: Boolean,
-        isEditing: {
-            type: Boolean,
-            required: true
-        }
-    },
-    computed: {
-        style() {
-            if (this.itemStyle) {
-                return this.itemStyle;
-            } else {
-                return {
-                    backgroundColor: this.item.fill,
-                    border: this.item.stroke ? '1px solid ' + this.item.stroke : ''
-                };
-            }
-        }
-    },
-    watch: {
-        index(newIndex) {
-            if (!this.context) {
-                return;
-            }
-
-            this.context.index = newIndex;
-        },
-        item(newItem) {
-            if (!this.context) {
-                return;
-            }
-
-            this.context.layoutItem = newItem;
-        }
-    },
-    mounted() {
-        this.context = {
-            layoutItem: this.item,
-            index: this.index
-        };
-        this.removeSelectable = this.openmct.selection.selectable(
-            this.$el, this.context, this.initSelect);
-    },
-    destroyed() {
-        if (this.removeSelectable) {
-            this.removeSelectable();
-        }
-    }
-};
-</script>

src/plugins/displayLayout/components/LineView.vue

@@ -96,7 +96,7 @@ export default {
             y: 10,
             x2: 10,
             y2: 5,
-            stroke: '#666666'
+            stroke: '#717171'
         };
     },
     mixins: [conditionalStylesMixin],

src/plugins/displayLayout/components/box-and-line-views.scss

@@ -1,5 +1,4 @@
-.c-box-view,
-.c-ellipse-view {
+.c-box-view {
     border-width: $drawingObjBorderW !important;
     display: flex;
     align-items: stretch;
@@ -9,10 +8,6 @@
     }
 }
 
-.c-ellipse-view {
-    border-radius: 50%;
-}
-
 .c-line-view {
     &.c-frame {
         box-shadow: none !important;

src/plugins/displayLayout/pluginSpec.js

@@ -186,7 +186,7 @@ describe('the plugin', function () {
                 'configuration': {
                     'items': [
                         {
-                            'fill': '#666666',
+                            'fill': '#717171',
                             'stroke': '',
                             'x': 1,
                             'y': 1,
@@ -195,22 +195,12 @@ describe('the plugin', function () {
                             'type': 'box-view',
                             'id': '89b88746-d325-487b-aec4-11b79afff9e8'
                         },
-                        {
-                            'fill': '#666666',
-                            'stroke': '',
-                            'x': 1,
-                            'y': 1,
-                            'width': 10,
-                            'height': 10,
-                            'type': 'ellipse-view',
-                            'id': '19b88746-d325-487b-aec4-11b79afff9z8'
-                        },
                         {
                             'x': 18,
                             'y': 9,
                             'x2': 23,
                             'y2': 4,
-                            'stroke': '#666666',
+                            'stroke': '#717171',
                             'type': 'line-view',
                             'id': '57d49a28-7863-43bd-9593-6570758916f0'
                         },
@@ -351,7 +341,7 @@ describe('the plugin', function () {
         it('provides controls including separators', () => {
             const displayLayoutToolbar = openmct.toolbars.get(selection);
 
-            expect(displayLayoutToolbar.length).toBe(7);
+            expect(displayLayoutToolbar.length).toBe(9);
         });
     });
 });

src/plugins/notebook/components/Notebook.vue

@@ -140,7 +140,6 @@ import SearchResults from './SearchResults.vue';
 import Sidebar from './Sidebar.vue';
 import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaultNotebookSectionId, setDefaultNotebookPageId } from '../utils/notebook-storage';
 import { addNotebookEntry, createNewEmbed, getEntryPosById, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
-import { saveNotebookImageDomainObject, updateNamespaceOfDomainObject } from '../utils/notebook-image';
 import { NOTEBOOK_VIEW_TYPE } from '../notebook-constants';
 import objectUtils from 'objectUtils';
 
@@ -386,13 +385,9 @@ export default {
             const snapshotId = event.dataTransfer.getData('openmct/snapshot/id');
             if (snapshotId.length) {
                 const snapshot = this.snapshotContainer.getSnapshot(snapshotId);
-                this.newEntry(snapshot.embedObject);
+                this.newEntry(snapshot);
                 this.snapshotContainer.removeSnapshot(snapshotId);
 
-                const namespace = this.domainObject.identifier.namespace;
-                const notebookImageDomainObject = updateNamespaceOfDomainObject(snapshot.notebookImageDomainObject, namespace);
-                saveNotebookImageDomainObject(this.openmct, notebookImageDomainObject);
-
                 return;
             }
 
@@ -456,9 +451,12 @@ export default {
                 : undefined;
         },
         getDefaultNotebookObject() {
-            const defaultNotebook = getDefaultNotebook();
+            const oldNotebookStorage = getDefaultNotebook();
+            if (!oldNotebookStorage) {
+                return null;
+            }
 
-            return defaultNotebook && this.openmct.objects.get(defaultNotebook.identifier);
+            return this.openmct.objects.get(oldNotebookStorage.identifier);
         },
         getLinktoNotebook() {
             const objectPath = this.openmct.router.path;
@@ -592,25 +590,13 @@ export default {
 
             return section.id;
         },
-        async newEntry(embed = null) {
-            let transaction = this.openmct.objects.startTransaction();
-
+        newEntry(embed = null) {
             this.resetSearch();
             const notebookStorage = this.createNotebookStorageObject();
             this.updateDefaultNotebook(notebookStorage);
             const id = addNotebookEntry(this.openmct, this.domainObject, notebookStorage, embed);
             this.focusEntryId = id;
-
-            try {
-                await transaction.CommitAllTransactions();
-            } catch (error) {
-                if (error instanceof this.openmct.objects.errors.Conflict) {
-                    transaction.CancelAllTransactions().then(this.newEntry);
-                }
-            }
-
         },
-
         orientationChange() {
             this.formatSidebar();
         },

src/plugins/notebook/components/NotebookEmbed.vue

@@ -40,7 +40,7 @@ export default {
     components: {
         PopupMenu
     },
-    inject: ['openmct', 'snapshotContainer'],
+    inject: ['openmct'],
     props: {
         embed: {
             type: Object,
@@ -48,12 +48,6 @@ export default {
                 return {};
             }
         },
-        isSnapshotContainer: {
-            type: Boolean,
-            default() {
-                return false;
-            }
-        },
         removeActionString: {
             type: String,
             default() {
@@ -141,14 +135,6 @@ export default {
                 return;
             }
 
-            if (this.isSnapshotContainer) {
-                const snapshot = this.snapshotContainer.getSnapshot(this.embed.id);
-                const fullSizeImageURL = snapshot.notebookImageDomainObject.configuration.fullSizeImageURL;
-                painterroInstance.show(fullSizeImageURL);
-
-                return;
-            }
-
             this.openmct.objects.get(fullSizeImageObjectIdentifier)
                 .then(object => {
                     painterroInstance.show(object.configuration.fullSizeImageURL);
@@ -204,14 +190,6 @@ export default {
                 return;
             }
 
-            if (this.isSnapshotContainer) {
-                const snapshot = this.snapshotContainer.getSnapshot(this.embed.id);
-                const fullSizeImageURL = snapshot.notebookImageDomainObject.configuration.fullSizeImageURL;
-                this.openSnapshotOverlay(fullSizeImageURL);
-
-                return;
-            }
-
             this.openmct.objects.get(fullSizeImageObjectIdentifier)
                 .then(object => {
                     this.openSnapshotOverlay(object.configuration.fullSizeImageURL);
@@ -281,20 +259,8 @@ export default {
         updateSnapshot(snapshotObject) {
             this.embed.snapshot.thumbnailImage = snapshotObject.thumbnailImage;
 
-            this.updateNotebookImageDomainObjectSnapshot(snapshotObject);
+            updateNotebookImageDomainObject(this.openmct, this.embed.snapshot.fullSizeImageObjectIdentifier, snapshotObject.fullSizeImage);
             this.updateEmbed(this.embed);
-        },
-        updateNotebookImageDomainObjectSnapshot(snapshotObject) {
-            if (this.isSnapshotContainer) {
-                const snapshot = this.snapshotContainer.getSnapshot(this.embed.id);
-
-                snapshot.embedObject.snapshot.thumbnailImage = snapshotObject.thumbnailImage;
-                snapshot.notebookImageDomainObject.configuration.fullSizeImageURL = snapshotObject.fullSizeImage.src;
-
-                this.snapshotContainer.updateSnapshot(snapshot);
-            } else {
-                updateNotebookImageDomainObject(this.openmct, this.embed.snapshot.fullSizeImageObjectIdentifier, snapshotObject.fullSizeImage);
-            }
         }
     }
 };

src/plugins/notebook/components/NotebookEntry.vue

@@ -102,11 +102,9 @@
 
 <script>
 import NotebookEmbed from './NotebookEmbed.vue';
-import TextHighlight from '../../../utils/textHighlight/TextHighlight.vue';
 import { createNewEmbed } from '../utils/notebook-entries';
-import { saveNotebookImageDomainObject, updateNamespaceOfDomainObject } from '../utils/notebook-image';
-
 import Moment from 'moment';
+import TextHighlight from '../../../utils/textHighlight/TextHighlight.vue';
 
 export default {
     components: {
@@ -212,12 +210,8 @@ export default {
             const snapshotId = $event.dataTransfer.getData('openmct/snapshot/id');
             if (snapshotId.length) {
                 const snapshot = this.snapshotContainer.getSnapshot(snapshotId);
-                this.entry.embeds.push(snapshot.embedObject);
                 this.snapshotContainer.removeSnapshot(snapshotId);
-
-                const namespace = this.domainObject.identifier.namespace;
-                const notebookImageDomainObject = updateNamespaceOfDomainObject(snapshot.notebookImageDomainObject, namespace);
-                saveNotebookImageDomainObject(this.openmct, notebookImageDomainObject);
+                this.entry.embeds.push(snapshot);
             } else {
                 const data = $event.dataTransfer.getData('openmct/domain-object-path');
                 const objectPath = JSON.parse(data);

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -17,26 +17,19 @@
 
 <script>
 import Snapshot from '../snapshot';
-import { getDefaultNotebook, validateNotebookStorageObject } from '../utils/notebook-storage';
+import { getDefaultNotebook, getNotebookSectionAndPage, validateNotebookStorageObject } from '../utils/notebook-storage';
 import { NOTEBOOK_DEFAULT, NOTEBOOK_SNAPSHOT } from '../notebook-constants';
-import { getMenuItems } from '../utils/notebook-snapshot-menu';
 
 export default {
     inject: ['openmct'],
     props: {
-        currentView: {
-            type: Object,
-            default() {
-                return {};
-            }
-        },
         domainObject: {
             type: Object,
             default() {
                 return {};
             }
         },
-        isPreview: {
+        ignoreLink: {
             type: Boolean,
             default() {
                 return false;
@@ -57,40 +50,51 @@ export default {
     },
     mounted() {
         validateNotebookStorageObject();
+        this.getDefaultNotebookObject();
 
         this.notebookSnapshot = new Snapshot(this.openmct);
         this.setDefaultNotebookStatus();
     },
     methods: {
-        getPreviewObjectLink() {
-            const relativePath = this.openmct.objects.getRelativePath(this.objectPath);
-            const urlParams = this.openmct.router.getParams();
-            urlParams.view = this.currentView.key;
+        getDefaultNotebookObject() {
+            const defaultNotebook = getDefaultNotebook();
 
-            const urlParamsString = Object.entries(urlParams)
-                .map(([key, value]) => `${key}=${value}`)
-                .join('&');
-
-            return `#/browse/${relativePath}?${urlParamsString}`;
+            return defaultNotebook && this.openmct.objects.get(defaultNotebook.identifier);
         },
         async showMenu(event) {
-            const menuItemOptions = {
-                default: {
-                    cssClass: 'icon-notebook',
-                    name: `Save to Notebook`,
-                    onItemClicked: () => this.snapshot(NOTEBOOK_DEFAULT, event.target)
-                },
-                snapshot: {
-                    cssClass: 'icon-camera',
-                    name: 'Save to Notebook Snapshots',
-                    onItemClicked: () => this.snapshot(NOTEBOOK_SNAPSHOT, event.target)
-                }
-            };
-
-            const notebookTypes = await getMenuItems(this.openmct, menuItemOptions);
+            const notebookTypes = [];
             const elementBoundingClientRect = this.$el.getBoundingClientRect();
             const x = elementBoundingClientRect.x;
             const y = elementBoundingClientRect.y + elementBoundingClientRect.height;
+
+            const defaultNotebookObject = await this.getDefaultNotebookObject();
+            if (defaultNotebookObject) {
+                const defaultNotebook = getDefaultNotebook();
+                const { section, page } = getNotebookSectionAndPage(defaultNotebookObject, defaultNotebook.defaultSectionId, defaultNotebook.defaultPageId);
+                if (section && page) {
+                    const name = defaultNotebookObject.name;
+                    const sectionName = section.name;
+                    const pageName = page.name;
+                    const defaultPath = `${name} - ${sectionName} - ${pageName}`;
+
+                    notebookTypes.push({
+                        cssClass: 'icon-notebook',
+                        name: `Save to Notebook ${defaultPath}`,
+                        onItemClicked: () => {
+                            return this.snapshot(NOTEBOOK_DEFAULT, event.target);
+                        }
+                    });
+                }
+            }
+
+            notebookTypes.push({
+                cssClass: 'icon-camera',
+                name: 'Save to Notebook Snapshots',
+                onItemClicked: () => {
+                    return this.snapshot(NOTEBOOK_SNAPSHOT, event.target);
+                }
+            });
+
             this.openmct.menus.showMenu(x, y, notebookTypes);
         },
         snapshot(notebookType, target) {
@@ -98,12 +102,15 @@ export default {
                 const wrapper = target && target.closest('.js-notebook-snapshot-item-wrapper')
                     || document;
                 const element = wrapper.querySelector('.js-notebook-snapshot-item');
+
+                const bounds = this.openmct.time.bounds();
+                const link = !this.ignoreLink
+                    ? window.location.hash
+                    : null;
+
                 const objectPath = this.objectPath || this.openmct.router.path;
-                const link = this.isPreview
-                    ? this.getPreviewObjectLink()
-                    : window.location.hash;
                 const snapshotMeta = {
-                    bounds: this.openmct.time.bounds(),
+                    bounds,
                     link,
                     objectPath,
                     openmct: this.openmct

src/plugins/notebook/components/NotebookSnapshotContainer.vue

@@ -27,15 +27,15 @@
     </div><!-- closes l-browse-bar -->
     <div class="c-snapshots">
         <span v-for="snapshot in snapshots"
-              :key="snapshot.embedObject.id"
+              :key="snapshot.id"
               draggable="true"
               @dragstart="startEmbedDrag(snapshot, $event)"
         >
             <NotebookEmbed ref="notebookEmbed"
-                           :key="snapshot.embedObject.id"
-                           :embed="snapshot.embedObject"
-                           :is-snapshot-container="true"
+                           :key="snapshot.id"
+                           :embed="snapshot"
                            :remove-action-string="'Delete Snapshot'"
+                           @updateEmbed="updateSnapshot"
                            @removeEmbed="removeSnapshot"
             />
         </span>
@@ -119,8 +119,11 @@ export default {
             this.snapshots = this.snapshotContainer.getSnapshots();
         },
         startEmbedDrag(snapshot, event) {
-            event.dataTransfer.setData('text/plain', snapshot.embedObject.id);
-            event.dataTransfer.setData('openmct/snapshot/id', snapshot.embedObject.id);
+            event.dataTransfer.setData('text/plain', snapshot.id);
+            event.dataTransfer.setData('openmct/snapshot/id', snapshot.id);
+        },
+        updateSnapshot(snapshot) {
+            this.snapshotContainer.updateSnapshot(snapshot);
         }
     }
 };

src/plugins/notebook/pluginSpec.js

@@ -148,14 +148,10 @@ describe("Notebook plugin:", () => {
                 'observe'
             ]);
 
-            openmct.editor = {};
-            openmct.editor.isEditing = () => false;
-
             const applicableViews = openmct.objectViews.get(notebookViewObject, [notebookViewObject]);
             notebookViewProvider = applicableViews.find(viewProvider => viewProvider.key === 'notebook-vue');
 
             testObjectProvider.get.and.returnValue(Promise.resolve(notebookViewObject));
-            testObjectProvider.create.and.returnValue(Promise.resolve(notebookViewObject));
             openmct.objects.addProvider('test-namespace', testObjectProvider);
             testObjectProvider.observe.and.returnValue(() => {});
 

src/plugins/notebook/snapshot-container.js

@@ -18,18 +18,13 @@ export default class SnapshotContainer extends EventEmitter {
         return SnapshotContainer.instance;
     }
 
-    addSnapshot(notebookImageDomainObject, embedObject) {
+    addSnapshot(embedObject) {
         const snapshots = this.getSnapshots();
         if (snapshots.length >= NOTEBOOK_SNAPSHOT_MAX_COUNT) {
             snapshots.pop();
         }
 
-        const snapshotObject = {
-            notebookImageDomainObject,
-            embedObject
-        };
-
-        snapshots.unshift(snapshotObject);
+        snapshots.unshift(embedObject);
 
         return this.saveSnapshots(snapshots);
     }
@@ -37,7 +32,7 @@ export default class SnapshotContainer extends EventEmitter {
     getSnapshot(id) {
         const snapshots = this.getSnapshots();
 
-        return snapshots.find(s => s.embedObject.id === id);
+        return snapshots.find(s => s.id === id);
     }
 
     getSnapshots() {
@@ -52,7 +47,7 @@ export default class SnapshotContainer extends EventEmitter {
         }
 
         const snapshots = this.getSnapshots();
-        const filteredsnapshots = snapshots.filter(snapshot => snapshot.embedObject.id !== id);
+        const filteredsnapshots = snapshots.filter(snapshot => snapshot.id !== id);
 
         return this.saveSnapshots(filteredsnapshots);
     }
@@ -78,7 +73,7 @@ export default class SnapshotContainer extends EventEmitter {
     updateSnapshot(snapshot) {
         const snapshots = this.getSnapshots();
         const updatedSnapshots = snapshots.map(s => {
-            return s.embedObject.id === snapshot.embedObject.id
+            return s.id === snapshot.id
                 ? snapshot
                 : s;
         });

src/plugins/notebook/snapshot.js

@@ -1,7 +1,7 @@
 import { addNotebookEntry, createNewEmbed } from './utils/notebook-entries';
 import { getDefaultNotebook, getNotebookSectionAndPage, getDefaultNotebookLink, setDefaultNotebook } from './utils/notebook-storage';
 import { NOTEBOOK_DEFAULT } from '@/plugins/notebook/notebook-constants';
-import { createNotebookImageDomainObject, saveNotebookImageDomainObject, updateNamespaceOfDomainObject, DEFAULT_SIZE } from './utils/notebook-image';
+import { createNotebookImageDomainObject, DEFAULT_SIZE } from './utils/notebook-image';
 
 import SnapshotContainer from './snapshot-container';
 import ImageExporter from '../../exporters/ImageExporter';
@@ -35,28 +35,29 @@ export default class Snapshot {
      * @private
      */
     _saveSnapShot(notebookType, fullSizeImageURL, thumbnailImageURL, snapshotMeta) {
-        const object = createNotebookImageDomainObject(fullSizeImageURL);
-        const thumbnailImage = { src: thumbnailImageURL || '' };
-        const snapshot = {
-            fullSizeImageObjectIdentifier: object.identifier,
-            thumbnailImage
-        };
-        const embed = createNewEmbed(snapshotMeta, snapshot);
-        if (notebookType === NOTEBOOK_DEFAULT) {
-            const notebookStorage = getDefaultNotebook();
+        createNotebookImageDomainObject(this.openmct, fullSizeImageURL)
+            .then(object => {
+                const thumbnailImage = { src: thumbnailImageURL || '' };
+                const snapshot = {
+                    fullSizeImageObjectIdentifier: object.identifier,
+                    thumbnailImage
+                };
+                const embed = createNewEmbed(snapshotMeta, snapshot);
+                if (notebookType === NOTEBOOK_DEFAULT) {
+                    this._saveToDefaultNoteBook(embed);
 
-            this._saveToDefaultNoteBook(notebookStorage, embed);
-            const notebookImageDomainObject = updateNamespaceOfDomainObject(object, notebookStorage.identifier.namespace);
-            saveNotebookImageDomainObject(this.openmct, notebookImageDomainObject);
-        } else {
-            this._saveToNotebookSnapshots(object, embed);
-        }
+                    return;
+                }
+
+                this._saveToNotebookSnapshots(embed);
+            });
     }
 
     /**
      * @private
      */
-    _saveToDefaultNoteBook(notebookStorage, embed) {
+    _saveToDefaultNoteBook(embed) {
+        const notebookStorage = getDefaultNotebook();
         this.openmct.objects.get(notebookStorage.identifier)
             .then(async (domainObject) => {
                 addNotebookEntry(this.openmct, domainObject, notebookStorage, embed);
@@ -84,22 +85,19 @@ export default class Snapshot {
     /**
      * @private
      */
-    _saveToNotebookSnapshots(notebookImageDomainObject, embed) {
-        this.snapshotContainer.addSnapshot(notebookImageDomainObject, embed);
+    _saveToNotebookSnapshots(embed) {
+        this.snapshotContainer.addSnapshot(embed);
     }
 
     _showNotification(msg, url) {
         const options = {
-            autoDismissTimeout: 30000
-        };
-
-        if (!this.openmct.editor.isEditing()) {
-            options.link = {
+            autoDismissTimeout: 30000,
+            link: {
                 cssClass: '',
                 text: 'click to view',
                 onClick: this._navigateToNotebook(url)
-            };
-        }
+            }
+        };
 
         this.openmct.notifications.info(msg, options);
     }
@@ -110,8 +108,7 @@ export default class Snapshot {
         }
 
         return () => {
-            const path = window.location.href.split('#');
-            window.location.href = path[0] + url;
+            window.location.href = window.location.origin + url;
         };
     }
 }

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

@@ -44,7 +44,6 @@ const notebookDomainObject = {
         namespace: ''
     },
     type: 'notebook',
-    name: 'Test Notebook',
     configuration: {
         defaultSort: 'oldest',
         entries: notebookEntries,
@@ -119,12 +118,6 @@ describe('Notebook Entries:', () => {
             'create',
             'update'
         ]));
-        openmct.editor = {
-            isEditing: () => false
-        };
-        openmct.objects.isPersistable = () => true;
-        openmct.objects.save = () => Promise.resolve(true);
-
         window.localStorage.setItem('notebook-storage', null);
     });
 

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

@@ -5,14 +5,14 @@ export const DEFAULT_SIZE = {
     height: 30
 };
 
-export function createNotebookImageDomainObject(fullSizeImageURL) {
+export function createNotebookImageDomainObject(openmct, fullSizeImageURL) {
     const identifier = {
         key: uuid(),
         namespace: ''
     };
     const viewType = 'notebookSnapshotImage';
 
-    return {
+    const object = {
         name: 'Notebook Snapshot Image',
         type: viewType,
         identifier,
@@ -20,6 +20,21 @@ export function createNotebookImageDomainObject(fullSizeImageURL) {
             fullSizeImageURL
         }
     };
+
+    return new Promise((resolve, reject) => {
+        openmct.objects.save(object)
+            .then(result => {
+                if (result) {
+                    resolve(object);
+                }
+
+                reject();
+            })
+            .catch(e => {
+                console.error(e);
+                reject();
+            });
+    });
 }
 
 export function getThumbnailURLFromCanvas(canvas, size = DEFAULT_SIZE) {
@@ -52,23 +67,6 @@ export function getThumbnailURLFromimageUrl(imageUrl, size = DEFAULT_SIZE) {
     });
 }
 
-export function saveNotebookImageDomainObject(openmct, object) {
-    return new Promise((resolve, reject) => {
-        openmct.objects.save(object)
-            .then(result => {
-                if (result) {
-                    resolve(object);
-                } else {
-                    reject();
-                }
-            })
-            .catch(e => {
-                console.error(e);
-                reject();
-            });
-    });
-}
-
 export function updateNotebookImageDomainObject(openmct, identifier, fullSizeImage) {
     openmct.objects.get(identifier)
         .then(domainObject => {
@@ -78,9 +76,3 @@ export function updateNotebookImageDomainObject(openmct, identifier, fullSizeIma
             openmct.objects.mutate(domainObject, 'configuration', configuration);
         });
 }
-
-export function updateNamespaceOfDomainObject(object, namespace) {
-    object.identifier.namespace = namespace;
-
-    return object;
-}

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

@@ -1,18 +1,16 @@
-import { createNotebookImageDomainObject, getThumbnailURLFromimageUrl, saveNotebookImageDomainObject, updateNamespaceOfDomainObject } from './notebook-image';
+import { createNotebookImageDomainObject, getThumbnailURLFromimageUrl } from './notebook-image';
 import { mutateObject } from './notebook-entries';
 
-const IMAGE_MIGRATION_VER = "v1";
-
 export function notebookImageMigration(openmct, domainObject) {
     const configuration = domainObject.configuration;
     const notebookEntries = configuration.entries;
 
     const imageMigrationVer = configuration.imageMigrationVer;
-    if (imageMigrationVer && imageMigrationVer === IMAGE_MIGRATION_VER) {
+    if (imageMigrationVer && imageMigrationVer === 'v1') {
         return;
     }
 
-    configuration.imageMigrationVer = IMAGE_MIGRATION_VER;
+    configuration.imageMigrationVer = 'v1';
 
     // to avoid muliple notebookImageMigration calls updating images.
     mutateObject(openmct, domainObject, 'configuration', configuration);
@@ -29,16 +27,14 @@ export function notebookImageMigration(openmct, domainObject) {
                     const fullSizeImageURL = snapshot.src;
                     if (fullSizeImageURL) {
                         const thumbnailImageURL = await getThumbnailURLFromimageUrl(fullSizeImageURL);
-                        const object = createNotebookImageDomainObject(fullSizeImageURL);
-                        const notebookImageDomainObject = updateNamespaceOfDomainObject(object, domainObject.identifier.namespace);
+                        const notebookImageDomainObject = await createNotebookImageDomainObject(openmct, fullSizeImageURL);
+
                         embed.snapshot = {
                             fullSizeImageObjectIdentifier: notebookImageDomainObject.identifier,
                             thumbnailImage: { src: thumbnailImageURL || '' }
                         };
 
                         mutateObject(openmct, domainObject, 'configuration.entries', notebookEntries);
-
-                        saveNotebookImageDomainObject(openmct, notebookImageDomainObject);
                     }
                 });
             });

src/plugins/notebook/utils/notebook-snapshot-menu.js

@@ -1,31 +0,0 @@
-import { getDefaultNotebook, getNotebookSectionAndPage } from './notebook-storage';
-
-export async function getMenuItems(openmct, menuItemOptions) {
-    const notebookTypes = [];
-
-    const defaultNotebook = getDefaultNotebook();
-    const defaultNotebookObject = defaultNotebook && await openmct.objects.get(defaultNotebook.identifier);
-    if (defaultNotebookObject) {
-        const { section, page } = getNotebookSectionAndPage(defaultNotebookObject, defaultNotebook.defaultSectionId, defaultNotebook.defaultPageId);
-        if (section && page) {
-            const name = defaultNotebookObject.name;
-            const sectionName = section.name;
-            const pageName = page.name;
-            const defaultPath = `${name} - ${sectionName} - ${pageName}`;
-
-            notebookTypes.push({
-                cssClass: menuItemOptions.default.cssClass,
-                name: `${menuItemOptions.default.name} ${defaultPath}`,
-                onItemClicked: menuItemOptions.default.onItemClicked
-            });
-        }
-    }
-
-    notebookTypes.push({
-        cssClass: menuItemOptions.snapshot.cssClass,
-        name: menuItemOptions.snapshot.name,
-        onItemClicked: menuItemOptions.snapshot.onItemClicked
-    });
-
-    return notebookTypes;
-}

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

@@ -71,7 +71,11 @@ export async function getDefaultNotebookLink(openmct, domainObject = null) {
     }
 
     const path = await openmct.objects.getOriginalPath(domainObject.identifier)
-        .then(openmct.objects.getRelativePath);
+        .then(objectPath => objectPath
+            .map(o => o && openmct.objects.makeKeyString(o.identifier))
+            .reverse()
+            .join('/')
+        );
     const { defaultPageId, defaultSectionId } = getDefaultNotebook();
 
     return `#/browse/${path}?sectionId=${defaultSectionId}&pageId=${defaultPageId}`;

src/plugins/persistence/couch/CouchObjectProvider.js

@@ -586,10 +586,6 @@ export default class CouchObjectProvider {
     }
 
     update(model) {
-        // if (model.type === 'notebook') {
-        //     throw new this.openmct.objects.errors.Conflict("Conflict while saving notebook");
-        // }
-
         let intermediateResponse = this.getIntermediateResponse();
         const key = model.identifier.key;
         this.enqueueObject(key, model, intermediateResponse);

src/plugins/plot/MctPlot.vue

@@ -393,31 +393,12 @@ export default {
             });
         },
 
-        clearSeries() {
+        clearData() {
             this.config.series.forEach(function (series) {
                 series.reset();
             });
         },
 
-        compositionPathContainsId(domainObjectToClear) {
-            return domainObjectToClear.composition.some((compositionIdentifier) => {
-                return this.openmct.objects.areIdsEqual(compositionIdentifier, this.domainObject.identifier);
-            });
-        },
-
-        clearData(domainObjectToClear) {
-            // If we don't have an object to clear (global), or the IDs are equal, just clear the data.
-            // If we have an object to clear, but the IDs don't match, we need to check the composition
-            // of the object we've been asked to clear to see if it contains the id we're looking for.
-            // This happens with stacked plots for example.
-            // If we find the ID, clear the plot.
-            if (!domainObjectToClear
-            || this.openmct.objects.areIdsEqual(domainObjectToClear.identifier, this.domainObject.identifier)
-            || this.compositionPathContainsId(domainObjectToClear)) {
-                this.clearSeries();
-            }
-        },
-
         setDisplayRange(series, xKey) {
             if (this.config.series.length !== 1) {
                 return;

src/plugins/plugins.js

@@ -69,7 +69,6 @@ define([
     './CouchDBSearchFolder/plugin',
     './timeline/plugin',
     './hyperlink/plugin',
-    './clock/plugin',
     './DeviceClassifier/plugin'
 ], function (
     _,
@@ -120,7 +119,6 @@ define([
     CouchDBSearchFolder,
     Timeline,
     Hyperlink,
-    Clock,
     DeviceClassifier
 ) {
     const bundleMap = {
@@ -225,7 +223,6 @@ define([
     plugins.CouchDBSearchFolder = CouchDBSearchFolder.default;
     plugins.Timeline = Timeline.default;
     plugins.Hyperlink = Hyperlink.default;
-    plugins.Clock = Clock.default;
     plugins.DeviceClassifier = DeviceClassifier.default;
 
     return plugins;

src/plugins/telemetryTable/TelemetryTable.js

@@ -153,7 +153,6 @@ define([
 
             this.telemetryCollections[keyString].on('remove', telemetryRemover);
             this.telemetryCollections[keyString].on('add', telemetryProcessor);
-            this.telemetryCollections[keyString].on('clear', this.tableRows.clear);
             this.telemetryCollections[keyString].load();
 
             this.decrementOutstandingRequests();

src/plugins/viewLargeAction/viewLargeAction.js

@@ -20,7 +20,7 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import Preview from '@/ui/preview/Preview.vue';
+import PreviewHeader from '@/ui/preview/preview-header.vue';
 
 import Vue from 'vue';
 
@@ -46,7 +46,7 @@ export default class ViewLargeAction {
             throw new Error(message);
         }
 
-        this._expand(objectPath, childElement);
+        this._expand(objectPath, childElement, view);
     }
 
     appliesTo(objectPath, view = {}) {
@@ -58,29 +58,49 @@ export default class ViewLargeAction {
         return viewLargeAction;
     }
 
-    _expand(objectPath, childElement) {
+    _expand(objectPath, childElement, view) {
         const parentElement = childElement.parentElement;
 
         this.overlay = this.openmct.overlays.overlay({
-            element: this._getPreview(objectPath),
+            element: this._getOverlayElement(objectPath, childElement, view),
             size: 'large',
-            autoHide: false,
             onDestroy() {
                 parentElement.append(childElement);
             }
         });
     }
 
-    _getPreview(objectPath) {
+    _getOverlayElement(objectPath, childElement, view) {
+        const fragment = new DocumentFragment();
+        const header = this._getPreviewHeader(objectPath, view);
+        fragment.append(header);
+
+        const wrapper = document.createElement('div');
+        wrapper.classList.add('l-preview-window__object-view');
+        wrapper.append(childElement);
+        fragment.append(wrapper);
+
+        return fragment;
+    }
+
+    _getPreviewHeader(objectPath, view) {
+        const domainObject = objectPath[0];
+        const actionCollection = this.openmct.actions.getActionsCollection(objectPath, view);
         const preview = new Vue({
             components: {
-                Preview
+                PreviewHeader
             },
             provide: {
                 openmct: this.openmct,
-                objectPath
+                objectPath: this.objectPath
             },
-            template: '<Preview></Preview>'
+            data() {
+                return {
+                    domainObject,
+                    actionCollection
+                };
+            },
+            template: '<PreviewHeader :actionCollection="actionCollection" :domainObject="domainObject" :hideViewSwitcher="true" :showNotebookMenuSwitcher="true"></PreviewHeader>'
         });
 
         return preview.$mount().$el;

src/styles/_constants.scss

@@ -154,7 +154,6 @@ $glyph-icon-flag: '\e92a';
 $glyph-icon-eye-disabled: '\e92b';
 $glyph-icon-notebook-page: '\e92c';
 $glyph-icon-unlocked: '\e92d';
-$glyph-icon-circle: '\e92e';
 $glyph-icon-arrows-right-left: '\ea00';
 $glyph-icon-arrows-up-down: '\ea01';
 $glyph-icon-bullet: '\ea02';
@@ -258,7 +257,6 @@ $glyph-icon-conditional: '\eb27';
 $glyph-icon-condition-widget: '\eb28';
 $glyph-icon-alphanumeric: '\eb29';
 $glyph-icon-image-telemetry: '\eb2a';
-$glyph-icon-telemetry-aggregate: '\eb2b';
 
 /************************** GLYPHS AS DATA URI */
 // Only objects have been converted, for use in Create menu and folder views

src/styles/_glyphs.scss

@@ -85,7 +85,6 @@
 .icon-eye-disabled {  @include glyphBefore($glyph-icon-eye-disabled); }
 .icon-notebook-page {  @include glyphBefore($glyph-icon-notebook-page); }
 .icon-unlocked {  @include glyphBefore($glyph-icon-unlocked); }
-.icon-circle {  @include glyphBefore($glyph-icon-circle); }
 .icon-arrows-right-left {  @include glyphBefore($glyph-icon-arrows-right-left); }
 .icon-arrows-up-down {  @include glyphBefore($glyph-icon-arrows-up-down); }
 .icon-bullet {  @include glyphBefore($glyph-icon-bullet); }
@@ -189,7 +188,6 @@
 .icon-condition-widget {  @include glyphBefore($glyph-icon-condition-widget); }
 .icon-alphanumeric {  @include glyphBefore($glyph-icon-alphanumeric); }
 .icon-image-telemetry {  @include glyphBefore($glyph-icon-image-telemetry); }
-.icon-telemetry-aggregate {  @include glyphBefore($glyph-icon-telemetry-aggregate); }
 
 /************************** 12 PX CLASSES */
 // TODO: sync with 16px redo as of 10/25/18

src/styles/fonts/Open MCT Symbols 16px.json

@@ -2,7 +2,7 @@
   "metadata": {
     "name": "Open MCT Symbols 16px",
     "lastOpened": 0,
-    "created": 1629996145999
+    "created": 1621648023886
   },
   "iconSets": [
     {
@@ -375,21 +375,13 @@
           "code": 59693,
           "tempChar": ""
         },
-        {
-          "order": 197,
-          "id": 169,
-          "name": "icon-circle",
-          "prevSize": 24,
-          "code": 59694,
-          "tempChar": ""
-        },
         {
           "order": 27,
           "id": 105,
           "name": "icon-arrows-right-left",
           "prevSize": 24,
           "code": 59904,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 26,
@@ -397,7 +389,7 @@
           "name": "icon-arrows-up-down",
           "prevSize": 24,
           "code": 59905,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 68,
@@ -405,7 +397,7 @@
           "name": "icon-bullet",
           "prevSize": 24,
           "code": 59906,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 150,
@@ -413,7 +405,7 @@
           "prevSize": 24,
           "code": 59907,
           "name": "icon-calendar",
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 45,
@@ -421,7 +413,7 @@
           "name": "icon-chain-links",
           "prevSize": 24,
           "code": 59908,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 73,
@@ -429,7 +421,7 @@
           "name": "icon-download",
           "prevSize": 24,
           "code": 59909,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 39,
@@ -437,7 +429,7 @@
           "name": "icon-duplicate",
           "prevSize": 24,
           "code": 59910,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 50,
@@ -445,7 +437,7 @@
           "name": "icon-folder-new",
           "prevSize": 24,
           "code": 59911,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 138,
@@ -453,7 +445,7 @@
           "name": "icon-fullscreen-collapse",
           "prevSize": 24,
           "code": 59912,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 139,
@@ -461,7 +453,7 @@
           "name": "icon-fullscreen-expand",
           "prevSize": 24,
           "code": 59913,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 122,
@@ -469,7 +461,7 @@
           "name": "icon-layers",
           "prevSize": 24,
           "code": 59914,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 151,
@@ -477,7 +469,7 @@
           "name": "icon-line-horz",
           "prevSize": 24,
           "code": 59915,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 100,
@@ -485,7 +477,7 @@
           "name": "icon-magnify",
           "prevSize": 24,
           "code": 59916,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 99,
@@ -493,7 +485,7 @@
           "name": "icon-magnify-in",
           "prevSize": 24,
           "code": 59917,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 101,
@@ -501,7 +493,7 @@
           "name": "icon-magnify-out-v2",
           "prevSize": 24,
           "code": 59918,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 103,
@@ -509,7 +501,7 @@
           "name": "icon-menu",
           "prevSize": 24,
           "code": 59919,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 124,
@@ -517,7 +509,7 @@
           "name": "icon-move",
           "prevSize": 24,
           "code": 59920,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 7,
@@ -525,7 +517,7 @@
           "name": "icon-new-window",
           "prevSize": 24,
           "code": 59921,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 63,
@@ -533,7 +525,7 @@
           "name": "icon-paint-bucket-v2",
           "prevSize": 24,
           "code": 59922,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 15,
@@ -541,7 +533,7 @@
           "name": "icon-pencil",
           "prevSize": 24,
           "code": 59923,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 54,
@@ -549,7 +541,7 @@
           "name": "icon-pencil-edit-in-place",
           "prevSize": 24,
           "code": 59924,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 40,
@@ -557,7 +549,7 @@
           "name": "icon-play",
           "prevSize": 24,
           "code": 59925,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 125,
@@ -565,7 +557,7 @@
           "name": "icon-pause",
           "prevSize": 24,
           "code": 59926,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 119,
@@ -573,7 +565,7 @@
           "name": "icon-plot-resource",
           "prevSize": 24,
           "code": 59927,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 48,
@@ -581,7 +573,7 @@
           "name": "icon-pointer-left",
           "prevSize": 24,
           "code": 59928,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 47,
@@ -589,7 +581,7 @@
           "name": "icon-pointer-right",
           "prevSize": 24,
           "code": 59929,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 85,
@@ -597,7 +589,7 @@
           "name": "icon-refresh",
           "prevSize": 24,
           "code": 59930,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 55,
@@ -605,7 +597,7 @@
           "name": "icon-save",
           "prevSize": 24,
           "code": 59931,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 56,
@@ -613,7 +605,7 @@
           "name": "icon-save-as",
           "prevSize": 24,
           "code": 59932,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 58,
@@ -621,7 +613,7 @@
           "name": "icon-sine",
           "prevSize": 24,
           "code": 59933,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 113,
@@ -629,7 +621,7 @@
           "name": "icon-font",
           "prevSize": 24,
           "code": 59934,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 41,
@@ -637,7 +629,7 @@
           "name": "icon-thumbs-strip",
           "prevSize": 24,
           "code": 59935,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 146,
@@ -645,7 +637,7 @@
           "name": "icon-two-parts-both",
           "prevSize": 24,
           "code": 59936,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 145,
@@ -653,7 +645,7 @@
           "name": "icon-two-parts-one-only",
           "prevSize": 24,
           "code": 59937,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 82,
@@ -661,7 +653,7 @@
           "name": "icon-resync",
           "prevSize": 24,
           "code": 59938,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 86,
@@ -669,7 +661,7 @@
           "name": "icon-reset",
           "prevSize": 24,
           "code": 59939,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 61,
@@ -677,7 +669,7 @@
           "name": "icon-x-in-circle",
           "prevSize": 24,
           "code": 59940,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 84,
@@ -685,7 +677,7 @@
           "name": "icon-brightness",
           "prevSize": 24,
           "code": 59941,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 83,
@@ -693,7 +685,7 @@
           "name": "icon-contrast",
           "prevSize": 24,
           "code": 59942,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 87,
@@ -701,7 +693,7 @@
           "name": "icon-expand",
           "prevSize": 24,
           "code": 59943,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 89,
@@ -709,7 +701,7 @@
           "name": "icon-list-view",
           "prevSize": 24,
           "code": 59944,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 133,
@@ -717,7 +709,7 @@
           "name": "icon-grid-snap-to",
           "prevSize": 24,
           "code": 59945,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 132,
@@ -725,7 +717,7 @@
           "name": "icon-grid-snap-no",
           "prevSize": 24,
           "code": 59946,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 94,
@@ -733,7 +725,7 @@
           "name": "icon-frame-show",
           "prevSize": 24,
           "code": 59947,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 95,
@@ -741,7 +733,7 @@
           "name": "icon-frame-hide",
           "prevSize": 24,
           "code": 59948,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 97,
@@ -749,7 +741,7 @@
           "name": "icon-import",
           "prevSize": 24,
           "code": 59949,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 96,
@@ -757,7 +749,7 @@
           "name": "icon-export",
           "prevSize": 24,
           "code": 59950,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 194,
@@ -765,7 +757,7 @@
           "name": "icon-font-size",
           "prevSize": 24,
           "code": 59951,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 163,
@@ -773,7 +765,7 @@
           "name": "icon-clear-data",
           "prevSize": 24,
           "code": 59952,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 173,
@@ -781,7 +773,7 @@
           "name": "icon-history",
           "prevSize": 24,
           "code": 59953,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 181,
@@ -789,7 +781,7 @@
           "name": "icon-arrow-up-to-parent",
           "prevSize": 24,
           "code": 59954,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 184,
@@ -797,7 +789,7 @@
           "name": "icon-crosshair-in-circle",
           "prevSize": 24,
           "code": 59955,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 185,
@@ -805,7 +797,7 @@
           "name": "icon-target",
           "prevSize": 24,
           "code": 59956,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 187,
@@ -813,7 +805,7 @@
           "name": "icon-items-collapse",
           "prevSize": 24,
           "code": 59957,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 188,
@@ -821,7 +813,7 @@
           "name": "icon-items-expand",
           "prevSize": 24,
           "code": 59958,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 190,
@@ -829,7 +821,7 @@
           "name": "icon-3-dots",
           "prevSize": 24,
           "code": 59959,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 193,
@@ -837,7 +829,7 @@
           "name": "icon-grid-on",
           "prevSize": 24,
           "code": 59960,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 192,
@@ -845,7 +837,7 @@
           "name": "icon-grid-off",
           "prevSize": 24,
           "code": 59961,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 191,
@@ -853,7 +845,7 @@
           "name": "icon-camera",
           "prevSize": 24,
           "code": 59962,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 196,
@@ -861,7 +853,7 @@
           "name": "icon-folders-collapse",
           "prevSize": 24,
           "code": 59963,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 144,
@@ -869,7 +861,7 @@
           "name": "icon-activity",
           "prevSize": 24,
           "code": 60160,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 104,
@@ -877,7 +869,7 @@
           "name": "icon-activity-mode",
           "prevSize": 24,
           "code": 60161,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 137,
@@ -885,7 +877,7 @@
           "name": "icon-autoflow-tabular",
           "prevSize": 24,
           "code": 60162,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 115,
@@ -893,7 +885,7 @@
           "name": "icon-clock",
           "prevSize": 24,
           "code": 60163,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 2,
@@ -901,7 +893,7 @@
           "name": "icon-database",
           "prevSize": 24,
           "code": 60164,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 3,
@@ -909,7 +901,7 @@
           "name": "icon-database-query",
           "prevSize": 24,
           "code": 60165,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 67,
@@ -917,7 +909,7 @@
           "name": "icon-dataset",
           "prevSize": 24,
           "code": 60166,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 59,
@@ -925,7 +917,7 @@
           "name": "icon-datatable",
           "prevSize": 24,
           "code": 60167,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 136,
@@ -933,7 +925,7 @@
           "name": "icon-dictionary",
           "prevSize": 24,
           "code": 60168,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 51,
@@ -941,7 +933,7 @@
           "name": "icon-folder",
           "prevSize": 24,
           "code": 60169,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 147,
@@ -949,7 +941,7 @@
           "name": "icon-image",
           "prevSize": 24,
           "code": 60170,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 4,
@@ -957,7 +949,7 @@
           "name": "icon-layout",
           "prevSize": 24,
           "code": 60171,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 24,
@@ -965,7 +957,7 @@
           "name": "icon-object",
           "prevSize": 24,
           "code": 60172,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 52,
@@ -973,7 +965,7 @@
           "name": "icon-object-unknown",
           "prevSize": 24,
           "code": 60173,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 105,
@@ -981,7 +973,7 @@
           "name": "icon-packet",
           "prevSize": 24,
           "code": 60174,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 126,
@@ -989,7 +981,7 @@
           "name": "icon-page",
           "prevSize": 24,
           "code": 60175,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 130,
@@ -997,7 +989,7 @@
           "name": "icon-plot-overlay",
           "prevSize": 24,
           "code": 60176,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 80,
@@ -1005,7 +997,7 @@
           "name": "icon-plot-stacked",
           "prevSize": 24,
           "code": 60177,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 134,
@@ -1013,7 +1005,7 @@
           "name": "icon-session",
           "prevSize": 24,
           "code": 60178,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 109,
@@ -1021,7 +1013,7 @@
           "name": "icon-tabular",
           "prevSize": 24,
           "code": 60179,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 107,
@@ -1029,7 +1021,7 @@
           "name": "icon-tabular-lad",
           "prevSize": 24,
           "code": 60180,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 106,
@@ -1037,7 +1029,7 @@
           "name": "icon-tabular-lad-set",
           "prevSize": 24,
           "code": 60181,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 70,
@@ -1045,7 +1037,7 @@
           "name": "icon-tabular-realtime",
           "prevSize": 24,
           "code": 60182,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 60,
@@ -1053,7 +1045,7 @@
           "name": "icon-tabular-scrolling",
           "prevSize": 24,
           "code": 60183,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 131,
@@ -1061,7 +1053,7 @@
           "name": "icon-telemetry",
           "prevSize": 24,
           "code": 60184,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 108,
@@ -1069,7 +1061,7 @@
           "name": "icon-timeline",
           "prevSize": 24,
           "code": 60185,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 81,
@@ -1077,7 +1069,7 @@
           "name": "icon-timer",
           "prevSize": 24,
           "code": 60186,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 69,
@@ -1085,7 +1077,7 @@
           "name": "icon-topic",
           "prevSize": 24,
           "code": 60187,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 79,
@@ -1093,7 +1085,7 @@
           "name": "icon-box-with-dashed-lines-v2",
           "prevSize": 24,
           "code": 60188,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 90,
@@ -1101,7 +1093,7 @@
           "name": "icon-summary-widget",
           "prevSize": 24,
           "code": 60189,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 92,
@@ -1109,7 +1101,7 @@
           "name": "icon-notebook",
           "prevSize": 24,
           "code": 60190,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 168,
@@ -1117,7 +1109,7 @@
           "name": "icon-tabs-view",
           "prevSize": 24,
           "code": 60191,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 117,
@@ -1125,7 +1117,7 @@
           "name": "icon-flexible-layout",
           "prevSize": 24,
           "code": 60192,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 166,
@@ -1133,7 +1125,7 @@
           "name": "icon-generator-sine",
           "prevSize": 24,
           "code": 60193,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 167,
@@ -1141,7 +1133,7 @@
           "name": "icon-generator-event",
           "prevSize": 24,
           "code": 60194,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 165,
@@ -1149,7 +1141,7 @@
           "name": "icon-gauge-v2",
           "prevSize": 24,
           "code": 60195,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 170,
@@ -1157,7 +1149,7 @@
           "name": "icon-spectra",
           "prevSize": 24,
           "code": 60196,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 171,
@@ -1165,7 +1157,7 @@
           "name": "icon-telemetry-spectra",
           "prevSize": 24,
           "code": 60197,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 172,
@@ -1173,7 +1165,7 @@
           "name": "icon-pushbutton",
           "prevSize": 24,
           "code": 60198,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 174,
@@ -1181,7 +1173,7 @@
           "name": "icon-conditional",
           "prevSize": 24,
           "code": 60199,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 178,
@@ -1189,7 +1181,7 @@
           "name": "icon-condition-widget",
           "prevSize": 24,
           "code": 60200,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 180,
@@ -1197,7 +1189,7 @@
           "name": "icon-alphanumeric",
           "prevSize": 24,
           "code": 60201,
-          "tempChar": ""
+          "tempChar": ""
         },
         {
           "order": 183,
@@ -1205,15 +1197,7 @@
           "name": "icon-image-telemetry",
           "prevSize": 24,
           "code": 60202,
-          "tempChar": ""
-        },
-        {
-          "order": 198,
-          "id": 170,
-          "name": "icon-telemetry-aggregate",
-          "prevSize": 24,
-          "code": 60203,
-          "tempChar": ""
+          "tempChar": ""
         }
       ],
       "id": 0,
@@ -2016,26 +2000,6 @@
             ]
           }
         },
-        {
-          "id": 169,
-          "paths": [
-            "M1024 512c0 282.77-229.23 512-512 512s-512-229.23-512-512c0-282.77 229.23-512 512-512s512 229.23 512 512z"
-          ],
-          "attrs": [
-            {}
-          ],
-          "isMulticolor": false,
-          "isMulticolor2": false,
-          "grid": 16,
-          "tags": [
-            "icon-circle"
-          ],
-          "colorPermutations": {
-            "12552552551": [
-              {}
-            ]
-          }
-        },
         {
           "id": 105,
           "paths": [
@@ -3820,32 +3784,6 @@
               {}
             ]
           }
-        },
-        {
-          "id": 170,
-          "paths": [
-            "M78 395.44c14-41.44 37.48-100.8 69.2-148.36 38.62-57.78 82.38-87.080 130.14-87.080s91.5 29.3 130 87.080c31.72 47.56 55.14 106.92 69.2 148.36 30.88 90.96 63.12 134.98 78 146.54 14.94-11.56 47.2-55.58 78-146.54 14-41.44 37.48-100.8 69.22-148.36q27.8-41.7 59.12-63.5c-75.7-111.377-201.81-183.58-344.783-183.58-0.034 0-0.068 0-0.103 0l0.006-0c-229.76 0-416 186.24-416 416-0 0.071-0 0.156-0 0.24 0 39.119 5.396 76.977 15.484 112.871l-0.704-2.931c16.78-21.74 40.4-63.34 63.22-130.74z",
-            "M754 436.56c-14 41.44-37.48 100.8-69.2 148.36-38.56 57.78-82.32 87.080-130 87.080s-91.5-29.3-130-87.080c-31.72-47.56-55.14-106.92-69.2-148.36-30.88-90.96-63.14-134.98-78-146.54-14.94 11.56-47.2 55.58-78 146.54-14.38 41.44-37.8 100.8-69.6 148.36q-27.8 41.7-59.12 63.5c75.7 111.378 201.81 183.58 344.783 183.58 0.119 0 0.237-0 0.356-0l-0.019 0c229.76 0 416-186.24 416-416 0-0.071 0-0.156 0-0.24 0-39.119-5.396-76.977-15.484-112.871l0.704 2.931c-16.78 21.74-40.4 63.34-63.22 130.74z",
-            "M921.56 334.62c4.098 24.449 6.44 52.617 6.44 81.332 0 0.017-0 0.034-0 0.051l0-0.003c0 0.095 0 0.208 0 0.32 0 282.593-229.087 511.68-511.68 511.68-0.113 0-0.225-0-0.338-0l0.018 0c-0.014 0-0.031 0-0.048 0-28.716 0-56.884-2.342-84.325-6.845l2.993 0.405c72.483 63.623 168.109 102.44 272.802 102.44 0.203 0 0.406-0 0.61-0l-0.031 0c229.76 0 416-186.24 416-416 0-0.172 0-0.375 0-0.578 0-104.692-38.817-200.319-102.844-273.271l0.404 0.47z"
-          ],
-          "attrs": [
-            {},
-            {},
-            {}
-          ],
-          "isMulticolor": false,
-          "isMulticolor2": false,
-          "grid": 16,
-          "tags": [
-            "icon-telemetry-aggregate"
-          ],
-          "colorPermutations": {
-            "12552552551": [
-              {},
-              {},
-              {}
-            ]
-          }
         }
       ],
       "invisible": false,

src/styles/fonts/Open-MCT-Symbols-16px.svg

@@ -53,7 +53,6 @@
 <glyph unicode="&#xe92b;" glyph-name="icon-eye-disabled" d="M209.46 223.32q-7.46 9.86-14.26 20.28c-14.737 21.984-27.741 47.184-37.759 73.847l-0.841 2.553c11.078 29.259 24.068 54.443 39.51 77.869l-0.91-1.469c23.221 34.963 50.705 64.8 82.207 89.793l0.793 0.607c57.663 45.719 130.179 75.053 209.311 79.947l1.069 0.053 114.48 140.88c-27.366 5.017-58.869 7.898-91.041 7.92h-0.019c-245.8 0-452.2-168-510.8-395.6 21.856-82.93 60.906-154.847 113.325-214.773l-0.525 0.613zM814.76 416.92q7.52-10 14.44-20.52c14.737-21.984 27.741-47.184 37.759-73.847l0.841-2.553c-10.859-29.216-23.863-54.416-39.447-77.748l0.847 1.348c-23.221-34.963-50.705-64.8-82.207-89.793l-0.793-0.607c-57.762-45.834-130.437-75.216-209.743-80.049l-1.057-0.051-114.46-140.86c27.346-4.988 58.817-7.84 90.955-7.84 0.037 0 0.074 0 0.111 0h-0.005c245.8 0 452.2 168 510.8 395.6-21.856 82.93-60.906 154.847-113.325 214.773l0.525-0.613zM832 832l-832-1024h192l832 1024h-192z" />
 <glyph unicode="&#xe92c;" glyph-name="icon-notebook-page" d="M830 770h-830l-4-702c0-106.6 87.4-194 194-194h640c106.6 0 194 87.4 194 194v508c0 106.8-87.4 194-194 194zM832 386l-384-384-192 192v256l192-192 384 384v-256z" />
 <glyph unicode="&#xe92d;" glyph-name="icon-unlocked" d="M768 832c-141.339-0.114-255.886-114.661-256-255.989v-128.011h-448c-35.301-0.113-63.887-28.699-64-63.989v-512.011c0.113-35.301 28.699-63.887 63.989-64h638.011c35.301 0.113 63.887 28.699 64 63.989v512.011c-0.113 35.301-28.699 63.887-63.989 64h-62.011v128c0 70.692 57.308 128 128 128s128-57.308 128-128v0-128h128v128c-0.114 141.339-114.661 255.886-255.989 256h-0.011z" />
-<glyph unicode="&#xe92e;" glyph-name="icon-circle" d="M1024 320c0-282.77-229.23-512-512-512s-512 229.23-512 512c0 282.77 229.23 512 512 512s512-229.23 512-512z" />
 <glyph unicode="&#xea00;" glyph-name="icon-arrows-right-left" d="M1024 320l-448-512v1024zM448 832l-448-512 448-512z" />
 <glyph unicode="&#xea01;" glyph-name="icon-arrows-up-down" d="M512 832l512-448h-1024zM0 256l512-448 512 448z" />
 <glyph unicode="&#xea02;" glyph-name="icon-bullet" d="M832 80c0-44-36-80-80-80h-480c-44 0-80 36-80 80v480c0 44 36 80 80 80h480c44 0 80-36 80-80v-480z" />
@@ -157,5 +156,4 @@
 <glyph unicode="&#xeb28;" glyph-name="icon-condition-widget" d="M832 832h-640c-105.6 0-192-86.4-192-192v-640c0-105.6 86.4-192 192-192h640c105.6 0 192 86.4 192 192v640c0 105.6-86.4 192-192 192zM512 64l-384 256 384 256 384-256z" />
 <glyph unicode="&#xeb29;" glyph-name="icon-alphanumeric" d="M535.6 301.4c-8.4-1.6-17.2-3-26.2-4s-18.2-2.4-27.2-4c-10.196-1.861-18.808-4.010-27.21-6.633l1.61 0.433c-8.609-2.674-16.105-6.348-22.89-10.987l0.29 0.187c-6.693-4.517-12.283-10.107-16.663-16.585l-0.137-0.215c-4.6-6.8-7.4-15.6-8.8-26s-0.4-18.4 2.4-25.2c2.746-6.688 7.224-12.195 12.881-16.122l0.119-0.078c5.967-4.053 13.057-6.94 20.704-8.161l0.296-0.039c7.592-1.527 16.319-2.4 25.25-2.4 0.123 0 0.246 0 0.369 0h-0.019c22.2 0 39.6 3.6 52.6 11s23.2 16.2 30.2 26.4c6.273 8.873 11.271 19.191 14.426 30.285l0.174 0.715c1.853 6.809 3.601 15.41 4.855 24.169l0.145 1.231 5.2 41.6c-5.4-4.217-11.723-7.564-18.583-9.689l-0.417-0.111c-6.489-2.241-14.362-4.255-22.444-5.662l-0.956-0.138zM1024 448v192h-152l24 192h-192l-24-192h-256l24 192h-192l-24-192h-232v-192h208l-32-256h-176v-192h152l-24-192h192l24 192h256l-24-192h192l24 192h232v192h-208l32 256zM702.8 420.2l-26.4-211.8c-2.231-15.809-3.537-34.122-3.6-52.727v-0.073c0-16.8 2.2-29.4 6.4-37.8h-113.4c-1.342 5.556-2.338 12.122-2.781 18.84l-0.019 0.36c-0.261 3.524-0.409 7.634-0.409 11.778 0 2.962 0.076 5.907 0.226 8.832l-0.017-0.41c-18.663-17.401-41.395-30.694-66.597-38.289l-1.203-0.311c-22.627-6.956-48.639-10.974-75.586-11h-0.014c-0.764-0.011-1.666-0.018-2.569-0.018-18.098 0-35.598 2.563-52.156 7.345l1.325-0.328c-15.991 4.512-29.851 12.090-41.545 22.122l0.145-0.122c-11.233 9.982-19.792 22.733-24.624 37.192l-0.176 0.608c-5.2 15.2-6.4 33.4-3.8 54.4s9.4 42.2 19.4 57.2c9.524 14.399 21.535 26.346 35.532 35.512l0.468 0.288c13.387 8.662 28.922 15.533 45.512 19.765l1.088 0.235c13.436 3.792 30.801 7.554 48.47 10.41l2.93 0.39c17 2.6 33.8 4.6 50.4 6.2 16.628 1.527 31.69 4.070 46.349 7.643l-2.149-0.443c13 3 23.6 7.6 31.6 13.6s12.6 15 13.6 26.4 0.8 21.8-2.4 28.8c-2.849 6.902-7.542 12.56-13.468 16.517l-0.132 0.083c-6.217 4.011-13.604 6.78-21.543 7.774l-0.257 0.026c-7.897 1.277-17 2.007-26.274 2.007-0.537 0-1.073-0.002-1.609-0.007l0.082 0.001c-22 0-40-4.6-53.8-14.2s-23-25.2-28-47.2h-111.8c4.8 26.2 14.2 48 27.8 65.4 13.475 16.978 29.89 30.968 48.574 41.377l0.826 0.423c18.192 10.038 39.297 17.806 61.619 22.175l1.381 0.225c20.488 4.162 44.053 6.563 68.171 6.6h0.029c21.8-0.005 43.239-1.532 64.222-4.479l-2.422 0.279c20.641-2.809 39.324-8.783 56.401-17.461l-1.001 0.461c15.909-8.108 28.858-20.031 37.967-34.601l0.233-0.399c9-15 12.2-34.8 9-59.6z" />
 <glyph unicode="&#xeb2a;" glyph-name="icon-image-telemetry" d="M512 832c-282.8 0-512-229.2-512-512s229.2-512 512-512 512 229.2 512 512-229.2 512-512 512zM783.6 48.4c-69.581-69.675-165.757-112.776-272-112.776-212.298 0-384.4 172.102-384.4 384.4s172.102 384.4 384.4 384.4c212.298 0 384.4-172.102 384.4-384.4 0-0.008 0-0.017 0-0.025v0.001c0.001-0.264 0.001-0.575 0.001-0.887 0-105.769-42.964-201.503-112.391-270.703l-0.010-0.010zM704 448l-128-128-192 192-192-192c0-176.731 143.269-320 320-320s320 143.269 320 320v0z" />
-<glyph unicode="&#xeb2b;" glyph-name="icon-telemetry-aggregate" d="M78 436.56c14 41.44 37.48 100.8 69.2 148.36 38.62 57.78 82.38 87.080 130.14 87.080s91.5-29.3 130-87.080c31.72-47.56 55.14-106.92 69.2-148.36 30.88-90.96 63.12-134.98 78-146.54 14.94 11.56 47.2 55.58 78 146.54 14 41.44 37.48 100.8 69.22 148.36q27.8 41.7 59.12 63.5c-75.7 111.377-201.81 183.58-344.783 183.58-0.034 0-0.068 0-0.103 0h0.006c-229.76 0-416-186.24-416-416 0-0.071 0-0.156 0-0.24 0-39.119 5.396-76.977 15.484-112.871l-0.704 2.931c16.78 21.74 40.4 63.34 63.22 130.74zM754 395.44c-14-41.44-37.48-100.8-69.2-148.36-38.56-57.78-82.32-87.080-130-87.080s-91.5 29.3-130 87.080c-31.72 47.56-55.14 106.92-69.2 148.36-30.88 90.96-63.14 134.98-78 146.54-14.94-11.56-47.2-55.58-78-146.54-14.38-41.44-37.8-100.8-69.6-148.36q-27.8-41.7-59.12-63.5c75.7-111.378 201.81-183.58 344.783-183.58 0.119 0 0.237 0 0.356 0h-0.019c229.76 0 416 186.24 416 416 0 0.071 0 0.156 0 0.24 0 39.119-5.396 76.977-15.484 112.871l0.704-2.931c-16.78-21.74-40.4-63.34-63.22-130.74zM921.56 497.38c4.098-24.449 6.44-52.617 6.44-81.332 0-0.017 0-0.034 0-0.051v0.003c0-0.095 0-0.208 0-0.32 0-282.593-229.087-511.68-511.68-511.68-0.113 0-0.225 0-0.338 0h0.018c-0.014 0-0.031 0-0.048 0-28.716 0-56.884 2.342-84.325 6.845l2.993-0.405c72.483-63.623 168.109-102.44 272.802-102.44 0.203 0 0.406 0 0.61 0h-0.031c229.76 0 416 186.24 416 416 0 0.172 0 0.375 0 0.578 0 104.692-38.817 200.319-102.844 273.271l0.404-0.47z" />
 </font></defs></svg>

src/tools/url.js

@@ -39,7 +39,13 @@ export function paramsToArray(openmct) {
 }
 
 export function identifierToString(openmct, objectPath) {
-    return '#/browse/' + openmct.objects.getRelativePath(objectPath);
+    let identifier = '#/browse/' + objectPath.map(function (o) {
+        return o && openmct.objects.makeKeyString(o.identifier);
+    })
+        .reverse()
+        .join('/');
+
+    return identifier;
 }
 
 export default function objectPathToUrl(openmct, objectPath) {

src/ui/layout/Layout.vue

@@ -53,7 +53,7 @@
             class="l-shell__pane-tree"
             handle="after"
             label="Browse"
-            hide-param="hideTree"
+            collapsable
             @start-resizing="onStartResizing"
             @end-resizing="onEndResizing"
         >
@@ -104,7 +104,7 @@
             class="l-shell__pane-inspector l-pane--holds-multipane"
             handle="before"
             label="Inspect"
-            hide-param="hideInspector"
+            collapsable
             @start-resizing="onStartResizing"
             @end-resizing="onEndResizing"
         >

src/ui/layout/LayoutSpec.js

@@ -1,171 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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';
-import Vue from 'vue';
-import Layout from './Layout.vue';
-
-describe('Open MCT Layout:', () => {
-    let openmct;
-    let element;
-    let components;
-
-    beforeEach((done) => {
-        openmct = createOpenMct();
-        openmct.on('start', done);
-
-        // to silence error from BrowseBar.vue
-        spyOn(openmct.objectViews, 'get')
-            .and.callFake(() => []);
-
-        openmct.startHeadless();
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    describe('the pane:', () => {
-        it('is displayed on layout load', async () => {
-            await createLayout();
-            await Vue.nextTick();
-
-            Object.entries(components).forEach(([name, component]) => {
-                expect(
-                    component.pane
-                ).toBeTruthy();
-
-                expect(
-                    isCollapsed(component.pane)
-                ).toBeFalse();
-            });
-        });
-
-        it('is collapsed on layout load if specified by a hide param', async () => {
-            setHideParams();
-
-            await createLayout();
-            await Vue.nextTick();
-
-            Object.entries(components).forEach(([name, component]) => {
-                expect(
-                    isCollapsed(component.pane)
-                ).toBeTrue();
-            });
-        });
-
-        it('on toggle collapses if expanded', async () => {
-            await createLayout();
-            toggleCollapseButtons();
-            await Vue.nextTick();
-
-            Object.entries(components).forEach(([name, component]) => {
-                expect(
-                    openmct.router.getSearchParam(component.param)
-                ).toEqual('true');
-
-                expect(
-                    isCollapsed(component.pane)
-                ).toBeTrue();
-            });
-        });
-
-        it('on toggle expands if collapsed', async () => {
-            setHideParams();
-
-            await createLayout();
-            toggleExpandButtons();
-            await Vue.nextTick();
-
-            Object.entries(components).forEach(([name, component]) => {
-                expect(
-                    openmct.router.getSearchParam(component.param)
-                ).not.toEqual('true');
-
-                expect(
-                    isCollapsed(component.pane)
-                ).toBeFalse();
-            });
-        });
-    });
-
-    async function createLayout() {
-        const el = document.createElement('div');
-        const child = document.createElement('div');
-        el.appendChild(child);
-
-        element = await new Vue({
-            el,
-            components: {
-                Layout
-            },
-            provide: {
-                openmct
-            },
-            template: `<Layout ref="layout"/>`
-        }).$mount().$el;
-
-        setComponents();
-    }
-
-    function setComponents() {
-        components = {
-            tree: {
-                param: 'hideTree',
-                pane: element.querySelector('.l-shell__pane-tree'),
-                collapseButton: element.querySelector('.l-shell__pane-tree .l-pane__collapse-button'),
-                expandButton: element.querySelector('.l-shell__pane-tree .l-pane__expand-button')
-            },
-            inspector: {
-                param: 'hideInspector',
-                pane: element.querySelector('.l-shell__pane-inspector'),
-                collapseButton: element.querySelector('.l-shell__pane-inspector .l-pane__collapse-button'),
-                expandButton: element.querySelector('.l-shell__pane-inspector .l-pane__expand-button')
-            }
-        };
-    }
-
-    function isCollapsed(el) {
-        return el.classList.contains('l-pane--collapsed');
-    }
-
-    function setHideParams() {
-        Object.entries(components).forEach(([name, component]) => {
-            openmct.router.setSearchParam(component.param, true);
-        });
-    }
-
-    function toggleCollapseButtons() {
-        Object.entries(components).forEach(([name, component]) => {
-            component.collapseButton.click();
-        });
-    }
-
-    function toggleExpandButtons() {
-        Object.entries(components).forEach(([name, component]) => {
-            component.expandButton.click();
-        });
-    }
-});

src/ui/layout/pane.vue

@@ -41,6 +41,10 @@
 
 <script>
 const COLLAPSE_THRESHOLD_PX = 40;
+const HIDE_TREE_PARAM = 'hideTree';
+const HIDE_INSPECTOR_PARAM = 'hideInspector';
+const PANE_INSPECTOR = 'Inspect';
+const PANE_TREE = 'Browse';
 
 export default {
     inject: ['openmct'],
@@ -52,11 +56,11 @@ export default {
                 return ['', 'before', 'after'].indexOf(value) !== -1;
             }
         },
-        label: {
-            type: String,
-            default: ''
+        collapsable: {
+            type: Boolean,
+            default: false
         },
-        hideParam: {
+        label: {
             type: String,
             default: ''
         }
@@ -67,11 +71,6 @@ export default {
             resizing: false
         };
     },
-    computed: {
-        collapsable() {
-            return this.hideParam && this.hideParam.length;
-        }
-    },
     beforeMount() {
         this.type = this.$parent.type;
         this.styleProp = (this.type === 'horizontal') ? 'width' : 'height';
@@ -79,25 +78,39 @@ export default {
     async mounted() {
         await this.$nextTick();
         // Hide tree and/or inspector pane if specified in URL
-        if (this.collapsable) {
-            this.handleHideUrl();
-        }
+        this.handleHideUrl();
+        this.openmct.router.on('change:params', this.handleHideUrl);
+    },
+    beforeDestroy() {
+        this.openmct.router.off('change:params', this.handleHideUrl);
     },
     methods: {
         toggleCollapse: function (e) {
+            let target = this.label === PANE_TREE ? HIDE_TREE_PARAM : HIDE_INSPECTOR_PARAM;
+            this.collapsed = !this.collapsed;
             if (this.collapsed) {
-                this.handleExpand();
-                this.removeHideParam(this.hideParam);
-            } else {
                 this.handleCollapse();
-                this.addHideParam(this.hideParam);
+                this.addHideParam(target);
+            } else {
+                this.handleExpand();
+                this.removeHideParam(target);
             }
         },
         handleHideUrl: function () {
-            const hideParam = this.openmct.router.getSearchParam(this.hideParam);
+            if (!this.collapsable) {
+                return;
+            }
 
-            if (hideParam === 'true') {
+            let hideTreeParam = this.openmct.router.getSearchParam(HIDE_TREE_PARAM);
+            let hideInspectorParam = this.openmct.router.getSearchParam(HIDE_INSPECTOR_PARAM);
+            let hideTree = hideTreeParam === 'true' && this.label === PANE_TREE;
+            let hideInspector = hideInspectorParam === 'true' && this.label === PANE_INSPECTOR;
+            if (hideTree || hideInspector) {
+                this.collapsed = true;
                 this.handleCollapse();
+            } else {
+                this.collapsed = false;
+                this.handleExpand();
             }
         },
         addHideParam: function (target) {
@@ -109,13 +122,11 @@ export default {
         handleCollapse: function () {
             this.currentSize = (this.dragCollapse === true) ? this.initial : this.$el.style[this.styleProp];
             this.$el.style[this.styleProp] = '';
-            this.collapsed = true;
         },
         handleExpand: function () {
             this.$el.style[this.styleProp] = this.currentSize;
             delete this.currentSize;
             delete this.dragCollapse;
-            this.collapsed = false;
         },
         trackSize: function () {
             if (!this.dragCollapse === true) {

src/ui/layout/paneSpec.js

@@ -0,0 +1,90 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 pane", () => {
+    let openmct;
+    let appHolder;
+    let element;
+    let child;
+    let resolveFunction;
+
+    beforeEach((done) => {
+        openmct = createOpenMct();
+
+        appHolder = document.createElement('div');
+        appHolder.style.width = '640px';
+        appHolder.style.height = '480px';
+
+        openmct = createOpenMct();
+        openmct.install(openmct.plugins.MyItems());
+        openmct.install(openmct.plugins.LocalTimeSystem());
+        openmct.install(openmct.plugins.UTCTimeSystem());
+
+        element = document.createElement('div');
+        child = document.createElement('div');
+        element.appendChild(child);
+
+        openmct.on('start', done);
+        openmct.start(appHolder);
+
+        document.body.append(appHolder);
+
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+    it('toggling tree will toggle tree hide params', (done) => {
+        document.querySelector('.l-shell__pane-tree .l-pane__collapse-button').click();
+        expect(openmct.router.getSearchParam('hideTree')).toBe('true');
+        done();
+    });
+
+    it('tree pane collapses when adding hide tree param in URL', () => {
+        openmct.router.setSearchParam('hideTree', 'true');
+        expect(document.querySelector('.l-shell__pane-tree.l-pane--collapsed')).toBeDefined();
+    });
+
+    it('inspector pane collapses when adding hide inspector param in URL', () => {
+        openmct.router.setSearchParam('hideInspector', 'true');
+        expect(document.querySelector('.l-shell__pane-inspector.l-pane--collapsed')).toBeDefined();
+    });
+
+    it('toggle inspector pane will toggle inspector hide param', (done) => {
+        // There's a short delay on addubg the param.
+        resolveFunction = () => {
+            setTimeout(() => {
+                expect(openmct.router.getSearchParam('hideInspector')).toBe('true');
+                done();
+            }, 500);
+        };
+
+        openmct.router.on('change:params', resolveFunction);
+        document.querySelector('.l-shell__pane-inspector .l-pane__collapse-button').click();
+    });
+
+});

src/ui/preview/Preview.vue

@@ -59,13 +59,12 @@ export default {
     },
     mounted() {
         this.views = this.openmct.objectViews.get(this.domainObject, this.objectPath).map((view) => {
-            view.onItemClicked = () => {
+            view.callBack = () => {
                 return this.setView(view);
             };
 
             return view;
         });
-
         this.setView(this.views[0]);
     },
     beforeDestroy() {

src/ui/preview/PreviewAction.js

@@ -60,7 +60,6 @@ export default class PreviewAction {
         let overlay = this._openmct.overlays.overlay({
             element: preview.$el,
             size: 'large',
-            autoHide: false,
             buttons: [
                 {
                     label: 'Done',

src/ui/preview/preview-header.vue

@@ -18,12 +18,6 @@
             :views="views"
             :current-view="currentView"
         />
-        <NotebookMenuSwitcher :domain-object="domainObject"
-                              :object-path="objectPath"
-                              :is-preview="true"
-                              :current-view="currentView"
-                              class="c-notebook-snapshot-menubutton"
-        />
         <div class="l-browse-bar__actions">
             <button
                 v-for="(item, index) in statusBarItems"
@@ -44,9 +38,7 @@
 </template>
 
 <script>
-import NotebookMenuSwitcher from '@/plugins/notebook/components/NotebookMenuSwitcher.vue';
 import ViewSwitcher from '../../ui/layout/ViewSwitcher.vue';
-
 const HIDDEN_ACTIONS = [
     'remove',
     'move',
@@ -56,12 +48,10 @@ const HIDDEN_ACTIONS = [
 
 export default {
     components: {
-        NotebookMenuSwitcher,
         ViewSwitcher
     },
     inject: [
-        'openmct',
-        'objectPath'
+        'openmct'
     ],
     props: {
         currentView: {
@@ -153,7 +143,6 @@ export default {
         showMenuItems(event) {
             let sortedActions = this.openmct.actions._groupAndSortActions(this.menuActionItems);
             const menuItems = this.openmct.menus.actionsToMenuItems(sortedActions, this.actionCollection.objectPath, this.actionCollection.view);
-
             const visibleMenuItems = this.filterHiddenItems(menuItems);
             this.openmct.menus.showMenu(event.x, event.y, visibleMenuItems);
         }