[Plot] Only highlight legend if multiple

Legend items will only be highlighted when
selected for inspection if there are more
than one legend item in the plot.

.gitignore

@@ -20,3 +20,6 @@ closed-lib
 # Node dependencies
 node_modules
 
+# Protractor logs
+protractor/logs
+

CONTRIBUTING.md

@@ -0,0 +1,298 @@
+# Contributing to Open MCT Web
+
+This document describes the process of contributing to Open MCT Web as well
+as the standards that will be applied when evaluating contributions.
+
+Please be aware that additional agreements will be necessary before we can
+accept changes from external contributors.
+
+## Summary
+
+The short version:
+
+1. Write your contribution.
+2. Make sure your contribution meets code, test, and commit message
+   standards as described below.
+3. Submit a pull request from a topic branch back to `master`. Include a check
+   list, as described below. (Optionally, assign this to a specific member
+   for review.)
+4. Respond to any discussion. When the reviewer decides it's ready, they
+   will merge back `master` and fill out their own check list.
+
+## Contribution Process
+
+Open MCT Web uses git for software version control, and for branching and
+merging. The central repository is at
+https://github.com/nasa/openmctweb.git.
+
+### Roles
+
+References to roles are made throughout this document. These are not intended
+to reflect titles or long-term job assignments; rather, these are used as
+descriptors to refer to members of the development team performing tasks in
+the check-in process. These roles are:
+
+* _Author_: The individual who has made changes to files in the software
+  repository, and wishes to check these in.
+* _Reviewer_: The individual who reviews changes to files before they are
+  checked in.
+* _Integrator_: The individual who performs the task of merging these files.
+  Usually the reviewer.
+
+### Branching
+
+Three basic types of branches may be included in the above repository:
+
+1. Master branch.
+2. Topic branches.
+3. Developer branches.
+
+Branches which do not fit into the above categories may be created and used
+during the course of development for various reasons, such as large-scale
+refactoring of code or implementation of complex features which may cause
+instability. In these exceptional cases it is the responsibility of the
+developer who initiates the task which motivated this branching to
+communicate to the team the role of these branches and any associated
+procedures for the duration of their use.
+
+#### Master Branch
+
+The role of the `master` branches is to represent the latest
+"ready for test" version of the software. Source code on the master
+branch has undergone peer review, and will undergo regular automated
+testing with notification on failure. Master branches may be unstable
+(particularly for recent features), but the intent is for the stability of
+any features on master branches to be non-decreasing. It is the shared
+responsibility of authors, reviewers, and integrators to ensure this.
+
+#### Topic Branches
+
+Topic branches are used by developers to perform and record work on issues.
+
+Topic branches need not necessarily be stable, even when pushed to the
+central repository; in fact, the practice of making incremental commits
+while working on an issue and pushing these to the central repository is
+encouraged, to avoid lost work and to share work-in-progress. (Small commits
+also help isolate changes, which can help in identifying which change
+introduced a defect, particularly when that defect went unnoticed for some
+time, e.g. using `git bisect`.)
+
+Topic branches should be named according to their corresponding issue
+identifiers, all lower case, without hyphens. (e.g. branch mct9 would refer
+to issue #9.)
+
+In some cases, work on an issue may warrant the use of multiple divergent
+branches; for instance, when a developer wants to try more than one solution
+and compare them, or when a "dead end" is reached and an initial approach to
+resolving an issue needs to be abandoned. In these cases, a short suffix
+should be added to the additional branches; this may be simply a single
+character (e.g. wtd481b) or, where useful, a descriptive term for what
+distinguishes the branches (e.g. wtd481verbose). It is the responsibility of
+the author to communicate which branch is intended to be merged to both the
+reviewer and the integrator.
+
+#### Developer Branches
+
+Developer branches are any branches used for purposes outside of the scope
+of the above; e.g. to try things out, or maintain a "my latest stuff"
+branch that is not delayed by the review and integration process. These
+may be pushed to the central repository, and may follow any naming convention
+desired so long as the owner of the branch is identifiable, and so long as
+the name chosen could not be mistaken for a topic or master branch.
+
+### Merging
+
+When development is complete on an issue, the first step toward merging it
+back into the master branch is to file a Pull Request. The contributions
+should meet code, test, and commit message standards as described below,
+and the pull request should include a completed author checklist, also
+as described below. Pull requests may be assigned to specific team
+members when appropriate (e.g. to draw to a specific person's attention.)
+
+Code review should take place using discussion features within the pull
+request. When the reviewer is satisfied, they should add a comment to
+the pull request containing the reviewer checklist (from below) and complete
+the merge back to the master branch.
+
+## Standards
+
+Contributions to Open MCT Web are expected to meet the following standards.
+In addition, reviewers should use general discretion before accepting
+changes.
+
+### Code Standards
+
+JavaScript sources in Open MCT Web must satisfy JSLint under its default
+settings. This is verified by the command line build.
+
+#### Code Guidelines
+
+JavaScript sources in Open MCT Web should:
+
+* Use four spaces for indentation. Tabs should not be used.
+* Include JSDoc for any exposed API (e.g. public methods, constructors.)
+* Include non-JSDoc comments as-needed for explaining private variables,
+  methods, or algorithms when they are non-obvious.
+* Define one public class per script, expressed as a constructor function
+  returned from an AMD-style module.
+* Follow “Java-like” naming conventions. These includes:
+  * Classes should use camel case, first letter capitalized
+    (e.g. SomeClassName.)
+  * Methods, variables, fields, and function names should use camel case,
+    first letter lower-case (e.g. someVariableName.) Constants
+    (variables or fields which are meant to be declared and initialized
+    statically, and never changed) should use only capital letters, with
+    underscores between words (e.g. SOME_CONSTANT.)
+  * File name should be the name of the exported class, plus a .js extension
+    (e.g. SomeClassName.js)
+* Avoid anonymous functions, except when functions are short (a few lines)
+  and/or their inclusion makes sense within the flow of the code
+  (e.g. as arguments to a forEach call.)
+* Avoid deep nesting (especially of functions), except where necessary
+  (e.g. due to closure scope.)
+* End with a single new-line character.
+* Expose public methods by declaring them on the class's prototype.
+* Within a given function's scope, do not mix declarations and imperative
+  code, and  present these in the following order:
+  * First, variable declarations and initialization.
+  * Second, function declarations.
+  * Third, imperative statements.
+  * Finally, the returned value.
+
+Deviations from Open MCT Web code style guidelines require two-party agreement,
+typically from the author of the change and its reviewer.
+
+#### Code Example
+
+```js
+/*global define*/
+
+/**
+ * Bundles should declare themselves as namespaces in whichever source
+ * file is most like the "main point of entry" to the bundle.
+ * @namespace some/bundle
+ */
+define(
+    ['./OtherClass'],
+    function (OtherClass) {
+        "use strict";
+
+        /**
+         * A summary of how to use this class goes here.
+         *
+         * @constructor
+         * @memberof some/bundle
+         */
+        function ExampleClass() {
+        }
+
+        // Methods which are not intended for external use should
+        // not have JSDoc (or should be marked @private)
+        ExampleClass.prototype.privateMethod = function () {
+        };
+
+        /**
+         * A summary of this method goes here.
+         * @param {number} n a parameter
+         * @returns {number} a return value
+         */
+        ExampleClass.prototype.publicMethod = function (n) {
+            return n * 2;
+        }
+
+        return ExampleClass;
+    }
+);
+```
+
+### Test Standards
+
+Automated testing shall occur whenever changes are merged into the main
+development branch and must be confirmed alongside any pull request.
+
+Automated tests are typically unit tests which exercise individual software
+components. Tests are subject to code review along with the actual
+implementation, to ensure that tests are applicable and useful.
+
+Examples of useful tests:
+* Tests which replicate bugs (or their root causes) to verify their
+  resolution.
+* Tests which reflect details from software specifications.
+* Tests which exercise edge or corner cases among inputs.
+* Tests which verify expected interactions with other components in the
+  system.
+
+During automated testing, code coverage metrics will be reported. Line
+coverage must remain at or above 80%.
+
+### Commit Message Standards
+
+Commit messages should:
+
+* Contain a one-line subject, followed by one line of white space,
+  followed by one or more descriptive paragraphs, each separated by one
+  line of white space.
+* Contain a short (usually one word) reference to the feature or subsystem
+  the commit effects, in square brackets, at the start of the subject line
+  (e.g. `[Documentation] Draft of check-in process`)
+* Contain a reference to a relevant issue number in the body of the commit.
+  * This is important for traceability; while branch names also provide this,
+    you cannot tell from looking at a commit what branch it was authored on.
+* Describe the change that was made, and any useful rationale therefore.
+  * Comments in code should explain what things do, commit messages describe
+    how they came to be done that way.
+* Provide sufficient information for a reviewer to understand the changes
+  made and their relationship to previous code.
+
+Commit messages should not:
+
+* Exceed 54 characters in length on the subject line.
+* Exceed 72 characters in length in the body of the commit.
+  * Except where necessary to maintain the structure of machine-readable or
+    machine-generated text (e.g. error messages)
+
+See [Contributing to a Project](http://git-scm.com/book/ch5-2.html) from
+Pro Git by Shawn Chacon and Ben Straub for a bit of the rationale behind
+these standards.
+
+## Issue Reporting
+
+Issues are tracked at https://github.com/nasa/openmctweb/issues
+
+Issues should include:
+
+* A short description of the issue encountered.
+* A longer-form description of the issue encountered. When possible, steps to
+  reproduce the issue.
+* When possible, a description of the impact of the issue. What use case does
+  it impede?
+* An assessment of the severity of the issue.
+
+Issue severity is categorized as follows (in ascending order):
+
+* _Trivial_: Minimal impact on the usefulness and functionality of the
+  software; a "nice-to-have."
+* _(Unspecified)_: Major loss of functionality or impairment of use.
+* _Critical_: Large-scale loss of functionality or impairment of use,
+  such that remaining utility becomes marginal.
+* _Blocker_: Harmful or otherwise unacceptable behavior. Must fix.
+
+## Check Lists
+
+The following check lists should be completed and attached to pull requests
+when they are filed (author checklist) and when they are merged (reviewer
+checklist.)
+
+### Author Checklist
+
+1. Changes address original issue?
+2. Unit tests included and/or updated with changes?
+3. Command line build passes?
+4. Expect to pass code review?
+
+### Reviewer Checklist
+
+1. Changes appear to address issue?
+2. Appropriate unit tests included?
+3. Code style and in-line documentation are appropriate?
+4. Commit messages meet standards?

Procfile

@@ -0,0 +1 @@
+web: node app.js --port $PORT --include example/localstorage

README.md

@@ -67,6 +67,19 @@ as described above.
 An example of this is expressed in `platform/framework`, which follows
 bundle conventions.
 
+### Functional Testing
+
+The tests described above are all at the unit-level; an additional
+test suite using [Protractor](https://angular.github.io/protractor/)
+us under development, in the `protractor` folder.
+
+To run:
+
+* Install protractor following the instructions above.
+* `cd protractor`
+* `npm install`
+* `npm run all`
+
 ## Build
 
 Open MCT Web includes a Maven command line build. Although Open MCT Web

app.js

@@ -14,8 +14,7 @@
         options = require('minimist')(process.argv.slice(2)),
         express = require('express'),
         app = express(),
-        fs = require('fs'),
-        bundles = JSON.parse(fs.readFileSync(BUNDLE_FILE, 'utf8'));
+        fs = require('fs');
 
     // Defaults
     options.port = options.port || options.p || 8080;
@@ -40,17 +39,19 @@
         process.exit(0);
     }
 
-    // Handle command line inclusions/exclusions
-    bundles = bundles.concat(options.include);
-    bundles = bundles.filter(function (bundle) {
-        return options.exclude.indexOf(bundle) === -1;
-    });
-    bundles = bundles.filter(function (bundle, index) { // Uniquify
-        return bundles.indexOf(bundle) === index;
-    });
-
     // Override bundles.json for HTTP requests
     app.use('/' + BUNDLE_FILE, function (req, res) {
+        var bundles = JSON.parse(fs.readFileSync(BUNDLE_FILE, 'utf8'));
+
+        // Handle command line inclusions/exclusions
+        bundles = bundles.concat(options.include);
+        bundles = bundles.filter(function (bundle) {
+            return options.exclude.indexOf(bundle) === -1;
+        });
+        bundles = bundles.filter(function (bundle, index) { // Uniquify
+            return bundles.indexOf(bundle) === index;
+        });
+
         res.send(JSON.stringify(bundles));
     });
 

build-docs.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+#*****************************************************************************
+#* 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.
+#*****************************************************************************
+
+# Script to build and deploy docs to github pages.
+
+OUTPUT_DIRECTORY="target/docs"
+REPOSITORY_URL="git@github.com:nasa/openmctweb.git"
+
+BUILD_SHA=`git rev-parse head`
+
+# A remote will be created for the git repository we are pushing to.
+# Don't worry, as this entire directory will get trashed inbetween builds.
+REMOTE_NAME="documentation"
+WEBSITE_BRANCH="gh-pages"
+
+# Clean output directory, JSDOC will recreate
+if [ -d $OUTPUT_DIRECTORY ]; then
+    rm -rf $OUTPUT_DIRECTORY || exit 1
+fi
+
+npm run docs
+cd $OUTPUT_DIRECTORY || exit 1
+
+echo "git init"
+git init
+
+# Configure github for CircleCI user.
+git config user.email "buildbot@circleci.com"
+git config user.name "BuildBot"
+
+echo "git remote add $REMOTE_NAME $REPOSITORY_URL"
+git remote add $REMOTE_NAME $REPOSITORY_URL
+echo "git add ."
+git add .
+echo "git commit -m \"Generate docs from build $BUILD_SHA\""
+git commit -m "Generate docs from build $BUILD_SHA"
+
+echo "git push $REMOTE_NAME HEAD:$WEBSITE_BRANCH -f"
+git push $REMOTE_NAME HEAD:$WEBSITE_BRANCH -f
+
+echo "Documentation pushed to gh-pages branch."

bundles.json

@@ -7,17 +7,24 @@
     "platform/commonUI/edit",
     "platform/commonUI/dialog",
     "platform/commonUI/general",
+    "platform/commonUI/inspect",
     "platform/containment",
+    "platform/execution",
     "platform/telemetry",
+    "platform/features/imagery",
     "platform/features/layout",
     "platform/features/pages",
     "platform/features/plot",
     "platform/features/scrolling",
+    "platform/features/events",
     "platform/forms",
     "platform/persistence/queue",
     "platform/policy",
     "platform/entanglement",
+    "platform/search",
 
+    "example/imagery",
     "example/persistence",
+    "example/eventGenerator",
     "example/generator"
 ]

circle.yml

@@ -0,0 +1,10 @@
+deployment:
+  production:
+    branch: master
+    commands:
+      - ./build-docs.sh
+      - git push git@heroku.com:openmctweb-demo.git $CIRCLE_SHA1:refs/heads/master
+  openmctweb-staging-un:
+    branch: search
+    heroku:
+      appname: openmctweb-staging-un

docs/gendocs.js

@@ -0,0 +1,193 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+/*global require,process,GLOBAL*/
+/*jslint nomen: false */
+
+
+// Usage:
+//   node gendocs.js --in <source directory> --out <dest directory>
+
+var CONSTANTS = {
+        DIAGRAM_WIDTH: 800,
+        DIAGRAM_HEIGHT: 500
+    };
+
+GLOBAL.window = GLOBAL.window ||  GLOBAL; // nomnoml expects window to be defined
+(function () {
+    "use strict";
+
+    var fs = require("fs"),
+        mkdirp = require("mkdirp"),
+        path = require("path"),
+        glob = require("glob"),
+        marked = require("marked"),
+        split = require("split"),
+        stream = require("stream"),
+        nomnoml = require('nomnoml'),
+        Canvas = require('canvas'),
+        options = require("minimist")(process.argv.slice(2));
+
+    // Convert from nomnoml source to a target PNG file.
+    function renderNomnoml(source, target) {
+        var canvas =
+            new Canvas(CONSTANTS.DIAGRAM_WIDTH, CONSTANTS.DIAGRAM_HEIGHT);
+        nomnoml.draw(canvas, source, 1.0);
+        canvas.pngStream().pipe(fs.createWriteStream(target));
+    }
+
+    // Stream transform.
+    // Pulls out nomnoml diagrams from fenced code blocks and renders them
+    // as PNG files in the output directory, prefixed with a provided name.
+    // The fenced code blocks will be replaced with Markdown in the
+    // output of this stream.
+    function nomnomlifier(outputDirectory, prefix) {
+        var transform = new stream.Transform({ objectMode: true }),
+            isBuilding = false,
+            counter = 1,
+            outputPath,
+            source = "";
+
+        transform._transform = function (chunk, encoding, done) {
+            if (!isBuilding) {
+                if (chunk.trim().indexOf("```nomnoml") === 0) {
+                    var outputFilename = prefix + '-' + counter + '.png';
+                    outputPath = path.join(outputDirectory, outputFilename);
+                    this.push([
+                        "\n![Diagram ",
+                        counter,
+                        "](",
+                        outputFilename,
+                        ")\n\n"
+                    ].join(""));
+                    isBuilding = true;
+                    source = "";
+                    counter += 1;
+                } else {
+                    // Otherwise, pass through
+                    this.push(chunk + '\n');
+                }
+            } else {
+                if (chunk.trim() === "```") {
+                    // End nomnoml
+                    renderNomnoml(source, outputPath);
+                    isBuilding = false;
+                } else {
+                    source += chunk + '\n';
+                }
+            }
+            done();
+        };
+
+        return transform;
+    }
+
+    // Convert from Github-flavored Markdown to HTML
+    function gfmifier() {
+        var transform = new stream.Transform({ objectMode: true }),
+            markdown = "";
+        transform._transform = function (chunk, encoding, done) {
+            markdown += chunk;
+            done();
+        };
+        transform._flush = function (done) {
+            this.push("<html><body>\n");
+            this.push(marked(markdown));
+            this.push("\n</body></html>\n");
+            done();
+        };
+        return transform;
+    }
+
+    // Custom renderer for marked; converts relative links from md to html,
+    // and makes headings linkable.
+    function CustomRenderer() {
+        var renderer = new marked.Renderer(),
+            customRenderer = Object.create(renderer);
+        customRenderer.heading = function (text, level) {
+            var escapedText = (text || "").trim().toLowerCase().replace(/\W/g, "-"),
+                aOpen = "<a name=\"" + escapedText + "\" href=\"#" + escapedText + "\">",
+                aClose = "</a>";
+            return aOpen + renderer.heading.apply(renderer, arguments) + aClose;
+        };
+        // Change links to .md files to .html
+        customRenderer.link = function (href, title, text) {
+            // ...but only if they look like relative paths
+            return (href || "").indexOf(":") === -1 && href[0] !== "/" ?
+                renderer.link(href.replace(/\.md/, ".html"), title, text) :
+                renderer.link.apply(renderer, arguments);
+        };
+        return customRenderer;
+    }
+
+    options['in'] = options['in'] || options.i;
+    options.out = options.out || options.o;
+
+    marked.setOptions({
+        renderer: new CustomRenderer(),
+        gfm: true,
+        tables: true,
+        breaks: false,
+        pedantic: false,
+        sanitize: true,
+        smartLists: true,
+        smartypants: false
+    });
+
+    // Convert all markdown files.
+    // First, pull out nomnoml diagrams.
+    // Then, convert remaining Markdown to HTML.
+    glob(options['in'] + "/**/*.md", {}, function (err, files) {
+        files.forEach(function (file) {
+            var destination = file.replace(options['in'], options.out)
+                .replace(/md$/, "html"),
+                destPath = path.dirname(destination),
+                prefix = path.basename(destination).replace(/\.html$/, "");
+
+            mkdirp(destPath, function (err) {
+                fs.createReadStream(file, { encoding: 'utf8' })
+                    .pipe(split())
+                    .pipe(nomnomlifier(destPath, prefix))
+                    .pipe(gfmifier())
+                    .pipe(fs.createWriteStream(destination, {
+                        encoding: 'utf8'
+                    }));
+            });
+        });
+    });
+
+    // Also copy over all HTML, CSS, or PNG files
+    glob(options['in'] + "/**/*.@(html|css|png)", {}, function (err, files) {
+        files.forEach(function (file) {
+            var destination = file.replace(options['in'], options.out),
+                destPath = path.dirname(destination);
+
+            mkdirp(destPath, function (err) {
+                fs.createReadStream(file, { encoding: 'utf8' })
+                    .pipe(fs.createWriteStream(destination, {
+                        encoding: 'utf8'
+                    }));
+            });
+        });
+    });
+
+}());

docs/src/architecture/Framework.md

@@ -0,0 +1,232 @@
+# Overview
+
+The framework layer's most basic responsibility is allowing individual
+software components to communicate. The software components it recognizes
+are:
+
+* _Extensions_: Individual units of functionality that can be added to
+  or removed from Open MCT Web. _Extension categories_ distinguish what
+  type of functionality is being added/removed.
+* _Bundles_: A grouping of related extensions
+  (named after an analogous concept from [OSGi](http://www.osgi.org/))
+  that may be added or removed as a group.
+
+The framework layer operates by taking a set of active bundles, and
+exposing extensions to one another as-needed, using
+[dependency injection](https://en.wikipedia.org/wiki/Dependency_injection).
+Extensions are responsible for declaring their dependencies in a
+manner which the framework layer can understand.
+
+```nomnoml
+#direction: down
+[Open MCT Web|
+  [Dependency injection framework]-->[Platform bundle #1]
+  [Dependency injection framework]-->[Platform bundle #2]
+  [Dependency injection framework]-->[Plugin bundle #1]
+  [Dependency injection framework]-->[Plugin bundle #2]
+  [Platform bundle #1|[Extensions]]
+  [Platform bundle #2|[Extensions]]
+  [Plugin bundle #1|[Extensions]]
+  [Plugin bundle #2|[Extensions]]
+  [Platform bundle #1]<->[Platform bundle #2]
+  [Plugin bundle #1]<->[Platform bundle #2]
+  [Plugin bundle #1]<->[Plugin bundle #2]
+]
+```
+
+The "dependency injection framework" in this case is
+[AngularJS](https://angularjs.org/). Open MCT Web's framework layer
+is really just a thin wrapper over Angular that recognizes the
+concepts of bundles and extensions (as declared in JSON files) and
+registering extensions with Angular. It additionally acts as a
+mediator between Angular and [RequireJS](http://requirejs.org/),
+which is used to load JavaScript sources which implement
+extensions.
+
+```nomnoml
+[Framework layer|
+  [AngularJS]<-[Framework Component]
+  [RequireJS]<-[Framework Component]
+  [Framework Component]1o-*[Bundles]
+]
+```
+
+It is worth noting that _no other components_ are "aware" of the
+framework component directly; Angular and Require are _used by_ the
+framework components, and extensions in various bundles will have
+their dependencies satisfied by Angular as a consequence of registration
+activities which were performed by the framework component.
+
+
+## Application Initialization
+
+The framework component initializes an Open MCT Web application following
+a simple sequence of steps.
+
+```nomnoml
+[<start> Start]->[<state> Load bundles.json]
+[Load bundles.json]->[<state> Load bundle.json files]
+[Load bundle.json files]->[<state> Resolve implementations]
+[Resolve implementations]->[<state> Register with Angular]
+[Register with Angular]->[<state> Bootstrap application]
+[Bootstrap application]->[<end> End]
+```
+
+1. __Loading bundles.json.__ A file named `bundles.json` is loaded to determine
+   which bundles to load. Bundles are given in this file as relative paths
+   which point to bundle directories.
+2. __Load bundle.json files.__ Individual bundle definitions are loaded; a
+   `bundle.json` file is expected in each bundle directory.
+2. __Resolving implementations.__ Any scripts which provide implementations for
+   extensions exposed by bundles are loaded, using RequireJS.
+3. __Register with Angular.__ Resolved extensions are registered with Angular,
+   such that they can be used by the application at run-time. This stage
+   includes both registration of Angular built-ins (directives, controllers,
+   routes, constants, and services) as well as registration of non-Angular
+   extensions.
+4. __Bootstrap application.__ Once all extensions have been registered,
+   the Angular application
+   [is bootstrapped](https://docs.angularjs.org/guide/bootstrap).
+
+## Architectural Paradigm
+
+```nomnoml
+[Extension]
+[Extension]o->[Dependency #1]
+[Extension]o->[Dependency #2]
+[Extension]o->[Dependency #3]
+```
+
+Open MCT Web's architecture relies on a simple premise: Individual units
+(extensions) only have access to the dependencies they declare that they
+need, and they acquire references to these dependencies via dependency
+injection. This has several desirable traits:
+
+* Programming to an interface is enforced. Any given dependency can be
+  swapped out for something which exposes an equivalent interface. This
+  improves flexibility against refactoring, simplifies testing, and
+  provides a common mechanism for extension and reconfiguration.
+* The dependencies of a unit must be explicitly defined. This means that
+  it can be easily determined what a given unit's role is within the
+  larger system, in terms of what other components it will interact with.
+  It also helps to enforce good separation of concerns: When a set of
+  declared dependencies becomes long it is obvious, and this is usually
+  a sign that a given unit is involved in too many concerns and should
+  be refactored into smaller pieces.
+* Individual units do not need to be aware of the framework; they need
+  only be aware of the interfaces to the components they specifically
+  use. This avoids introducing a ubiquitous dependency upon the framework
+  layer itself; it is plausible to modify or replace the framework
+  without making changes to individual software components which run upon
+  the framework.
+
+A drawback to this approach is that it makes it difficult to define
+"the architecture" of Open MCT Web, in terms of describing the specific
+units that interact at run-time. The run-time architecture is determined
+by the framework as the consequence of wiring together dependencies.
+As such, the specific architecture of any given application built on
+Open MCT Web can look very different.
+
+Keeping that in mind, there are a few useful patterns supported by the
+framework that are useful to keep in mind.
+
+The specific service infrastructure provided by the platform is described
+in the [Platform Architecture](Platform.md).
+
+## Extension Categories
+
+One of the capabilities that the framework component layers on top of
+AngularJS is support for many-to-one dependencies. That is, a specific
+extension may declare a dependency to _all extensions of a specific
+category_, instead of being limited to declaring specific dependencies.
+
+```nomnoml
+#direction: right
+[Specific Extension] 1 o-> * [Extension of Some Category]
+```
+
+This is useful for introducing specific extension points to an application.
+Some unit of software will depend upon all extensions of a given category
+and integrate their behavior into the system in some fashion; plugin authors
+can then add new extensions of that category to augment existing behaviors.
+
+Some developers may be familiar with the use of registries to achieve
+similar characteristics. This approach is similar, except that the registry
+is effectively implicit whenever a new extension category is used or
+depended-upon. This has some advantages over a more straightforward
+registry-based approach:
+
+* These many-to-one relationships are expressed as dependencies; an
+  extension category is registered as having dependencies on all individual
+  extensions of this category. This avoids ordering issues that may occur
+  with more conventional registries, which may be observed before all
+  dependencies are resolved.
+* The need for service registries of specific types is removed, reducing
+  the number of interfaces to manage within the system. Groups of
+  extensions are provided as arrays.
+
+## Composite Services
+
+Composite services (registered via extension category `components`) are
+a pattern supported by the framework. These allow service instances to
+be built from multiple components at run-time; support for this pattern
+allows additional bundles to introduce or modify behavior associated
+with these services without modifying or replacing original service
+instances.
+
+```nomnoml
+#direction: down
+[<abstract> FooService]
+[FooDecorator #1]--:>[FooService]
+[FooDecorator #n]--:>[FooService]
+[FooAggregator]--:>[FooService]
+[FooProvider #1]--:>[FooService]
+[FooProvider #n]--:>[FooService]
+
+[FooDecorator #1]o->[<state> ...decorators...]
+[...decorators...]o->[FooDecorator #n]
+[FooDecorator #n]o->[FooAggregator]
+[FooAggregator]o->[FooProvider #1]
+[FooAggregator]o->[<state> ...providers...]
+[FooAggregator]o->[FooProvider #n]
+
+[FooDecorator #1]--[<note> Exposed as fooService]
+```
+
+In this pattern, components all implement an interface which is
+standardized for that service. Components additionally declare
+that they belong to one of three types:
+
+* __Providers.__ A provider actually implements the behavior
+  (satisfies the contract) for that kind of service. For instance,
+  if a service is responsible for looking up documents by an identifier,
+  one provider may do so by querying a database, while another may
+  do so by reading a static JSON document. From the outside, either
+  provider would look the same (they expose the same interface) and
+  they could be swapped out easily.
+* __Aggregator.__ An aggregator takes many providers and makes them
+  behave as one. Again, this implements the same interface as an
+  individual provider, so users of the service do not need to be
+  concerned about the difference between consulting many providers
+  and consulting one. Continuing with the example of a service that
+  looks up documents by identifiers, an aggregator here might consult
+  all providers, and return any document is found (perhaps picking one
+  over the other or merging documents if there are multiple matches.)
+* __Decorators.__ A decorator exposes the same interface as other
+  components, but instead of fully implementing the behavior associated
+  with that kind of service, it only acts as an intermediary, delegating
+  the actual behavior to a different component. Decorators may transform
+  inputs or outputs, or initiate some side effects associated with a
+  service. This is useful if certain common behavior associated with a
+  service (caching, for instance) may be useful across many different
+  implementations of that same service.
+
+The framework will register extensions in this category such that an
+aggregator will depend on all of its providers, and decorators will
+depend upon on one another in a chain. The result of this compositing step
+(the last decorator, if any; otherwise the aggregator, if any;
+otherwise a single provider) will be exposed as a single service that
+other extensions can acquire through dependency injection. Because all
+components of the same type of service expose the same interface, users
+of that service do not need to be aware that they are talking to an
+aggregator or a provider, for instance.

docs/src/architecture/Platform.md

@@ -0,0 +1,714 @@
+# Overview
+
+The Open MCT Web platform utilizes the [framework layer](Framework.md)
+to provide an extensible baseline for applications which includes:
+
+* A common user interface (and user interface paradigm) for dealing with
+  domain objects of various sorts.
+* A variety of extension points for introducing new functionality
+  of various kinds within the context of the common user interface.
+* A service infrastructure to support building additional components.
+
+## Platform Architecture
+
+While the framework provides a more general architectural paradigm for
+building application, the platform adds more specificity by defining
+additional extension types and allowing for integration with back end
+components.
+
+The run-time architecture of an Open MCT Web application can be categorized
+into certain high-level tiers:
+
+```nomnoml
+[DOM]->[<state> AngularJS]
+[AngularJS]->[Presentation Layer]
+[Presentation Layer]->[Information Model]
+[Presentation Layer]->[Service Infrastructure]
+[Information Model]->[Service Infrastructure]
+[Service Infrastructure]->[<state> Browser APIs]
+[Browser APIs]->[Back-end]
+```
+
+Applications built using Open MCT Web may add or configure functionality
+in __any of these tiers__.
+
+* _DOM_: The rendered HTML document, composed from HTML templates which
+  have been processed by AngularJS and will be updated by AngularJS
+  to reflect changes from the presentation layer. User interactions
+  are initiated from here and invoke behavior in the presentation layer.
+* [_Presentation layer_](#presentation-layer): The presentation layer
+  is responsible for updating (and providing information to update)
+  the displayed state of the application. The presentation layer consists
+  primarily of _controllers_ and _directives_. The presentation layer is
+  concerned with inspecting the information model and preparing it for
+  display.
+* [_Information model_](#information-model): The information model
+  describes the state and behavior of the objects with which the user
+  interacts.
+* [_Service infrastructure_](#service-infrastructure): The service
+  infrastructure is responsible for providing the underlying general
+  functionality needed to support the information model. This includes
+  exposing underlying sets of extensions and mediating with the
+  back-end.
+* _Back-end_: The back-end is out of the scope of Open MCT Web, except
+  for the interfaces which are utilized by adapters participating in the
+  service infrastructure.
+
+## Application Start-up
+
+Once the
+[application has been initialized](Framework.md#application-initialization)
+Open MCT Web primarily operates in an event-driven paradigm; various
+events (mouse clicks, timers firing, receiving responses to XHRs) trigger
+the invocation of functions, typically in the presentation layer for
+user actions or in the service infrastructure for server responses.
+
+The "main point of entry" into an initialized Open MCT Web application
+is effectively the
+[route](https://docs.angularjs.org/api/ngRoute/service/$route#example)
+which is associated with the URL used to access Open MCT Web (or a
+default route.) This route will be associated with a template which
+will be displayed; this template will include references to directives
+and controllers which will be interpreted by Angular and used to
+initialize the state of the display in a manner which is backed by
+both the information model and the service infrastructure.
+
+```nomnoml
+[<start> Start]->[<state> page load]
+[page load]->[<state> route selection]
+[route selection]->[<state> compile, display template]
+[compile, display template]->[Template]
+[Template]->[<state> use Controllers]
+[Template]->[<state> use Directives]
+[use Controllers]->[Controllers]
+[use Directives]->[Directives]
+[Controllers]->[<state> consult information model]
+[consult information model]->[<state> expose data]
+[expose data]->[Angular]
+[Angular]->[<state> update display]
+[Directives]->[<state> add event listeners]
+[Directives]->[<state> update display]
+[add event listeners]->[<end> End]
+[update display]->[<end> End]
+```
+
+
+# Presentation Layer
+
+The presentation layer of Open MCT Web is responsible for providing
+information to display within templates, and for handling interactions
+which are initiated from templated DOM elements. AngularJS acts as
+an intermediary between the web page as the user sees it, and the
+presentation layer implemented as Open MCT Web extensions.
+
+```nomnoml
+[Presentation Layer|
+  [Angular built-ins|
+    [routes]
+    [controllers]
+    [directives]
+    [templates]
+  ]
+  [Domain object representation|
+    [views]
+    [representations]
+    [representers]
+    [gestures]
+  ]
+]
+```
+
+## Angular built-ins
+
+Several extension categories in the presentation layer map directly
+to primitives from AngularJS:
+
+* [_Controllers_](https://docs.angularjs.org/guide/controller) provide
+  data to templates, and expose functionality that can be called from
+  templates.
+* [_Directives_](https://docs.angularjs.org/guide/directive) effectively
+  extend HTML to provide custom behavior associated with specific
+  attributes and tags.
+* [_Routes_](https://docs.angularjs.org/api/ngRoute/service/$route#example)
+  are used to associate specific URLs (including the fragment identifier)
+  with specific application states. (In Open MCT Web, these are used to
+  describe the mode of usage - e.g. browse or edit - as well as to
+  identify the object being used.)
+* [_Templates_](https://docs.angularjs.org/guide/templates) are partial
+  HTML documents that will be rendered and kept up-to-date by AngularJS.
+  Open MCT Web introduces a custom `mct-include` directive which acts
+  as a wrapper around `ng-include` to allow templates to be referred
+  to by symbolic names.
+
+## Domain object representation
+
+The remaining extension categories in the presentation layer are specific
+to displaying domain objects.
+
+* _Representations_ are templates that will be used to display
+  domain objects in specific ways (e.g. "as a tree node.")
+* _Views_ are representations which are exposed to the user as options
+  for displaying domain objects.
+* _Representers_ are extensions which modify or augment the process
+  of representing domain objects generally (e.g. by attaching
+  gestures to them.)
+* _Gestures_ provide associations between specific user actions
+  (expressed as DOM events) and resulting behavior upon domain objects
+  (typically expressed as members of the `actions` extension category)
+  that can be reused across domain objects. For instance, `drag` and
+  `drop` are both gestures associated with using drag-and-drop to
+  modify the composition of domain objects by interacting with their
+  representations.
+
+# Information Model
+
+```nomnoml
+#direction: right
+[Information Model|
+  [DomainObject|
+    getId() : string
+    getModel() : object
+    getCapability(key : string) : Capability
+    hasCapability(key : string) : boolean
+    useCapability(key : string, args...) : *
+  ]
+  [DomainObject] 1 +- 1 [Model]
+  [DomainObject] 1 o- * [Capability]
+]
+```
+
+Domain objects are the most fundamental component of Open MCT Web's
+information model. A domain object is some distinct thing relevant to a
+user's work flow, such as a telemetry channel, display, or similar.
+Open MCT Web is a tool for viewing, browsing, manipulating, and otherwise
+interacting with a graph of domain objects.
+
+A domain object should be conceived of as the union of the following:
+
+* _Identifier_: A machine-readable string that uniquely identifies the
+  domain object within this application instance.
+* _Model_: The persistent state of the domain object. A domain object's
+  model is a JavaScript object that can be losslessly converted to JSON.
+* _Capabilities_: Dynamic behavior associated with the domain object.
+  Capabilities are JavaScript objects which provide additional methods
+  for interacting with the domain objects which expose those capabilities.
+  Not all domain objects expose all capabilities. The interface exposed
+  by any given capability will depend on its type (as identified
+  by the `key` argument.) For instance, a `persistence` capability
+  has a different interface from a `telemetry` capability. Using
+  capabilities requires some prior knowledge of their interface.
+
+## Capabilities and Services
+
+```nomnoml
+#direction: right
+[DomainObject]o-[FooCapability]
+[FooCapability]o-[FooService]
+[FooService]o-[foos]
+```
+
+At run-time, the user is primarily concerned with interacting with
+domain objects. These interactions are ultimately supported via back-end
+services, but to allow customization per-object, these are often mediated
+by capabilities.
+
+A common pattern that emerges in the Open MCT Platform is as follows:
+
+* A `DomainObject` has some particular behavior that will be supported
+  by a service.
+* A `Capability` of that domain object will define that behavior,
+  _for that domain object_, supported by a service.
+* A `Service` utilized by that capability will perform the actual behavior.
+* An extension category will be utilized by that capability to determine
+  the set of possible behaviors.
+
+Concrete examples of capabilities which follow this pattern
+(or a subset of this pattern) include:
+
+```nomnoml
+#direction: right
+[DomainObject]1 o- *[Capability]
+[Capability]<:--[TypeCapability]
+[Capability]<:--[ActionCapability]
+[Capability]<:--[PersistenceCapability]
+[Capability]<:--[TelemetryCapability]
+[TypeCapability]o-[TypeService]
+[TypeService]o-[types]
+[ActionCapability]o-[ActionService]
+[ActionService]o-[actions]
+[PersistenceCapability]o-[PersistenceService]
+[TelemetryCapability]o-[TelemetryService]
+```
+
+# Service Infrastructure
+
+Most services exposed by the Open MCT Web platform follow the
+[composite services](Framework.md#composite-services) to permit
+a higher degree of flexibility in how a service can be modified
+or customized for specific applications.
+
+To simplify usage for plugin developers, the platform also usually
+includes a provider implementation for these service type that consumes
+some extension category. For instance, an `ActionService` provider is
+included which depends upon extension category `actions`, and exposes
+all actions declared as such to the system. As such, plugin developers
+can simply implement the new actions they wish to be made available without
+worrying about the details of composite services or implementing a new
+`ActionService` provider; however, the ability to implement a new provider
+remains useful when the expressive power of individual extensions is
+insufficient.
+
+```nomnoml
+[ Service Infrastructure |
+  [ObjectService]->[ModelService]
+  [ModelService]->[PersistenceService]
+  [ObjectService]->[CapabilityService]
+  [CapabilityService]->[capabilities]
+  [capabilities]->[TelemetryService]
+  [capabilities]->[PersistenceService]
+  [capabilities]->[TypeService]
+  [capabilities]->[ActionService]
+  [capabilities]->[ViewService]
+  [PersistenceService]->[<database> Document store]
+  [TelemetryService]->[<database> Telemetry source]
+  [ActionService]->[actions]
+  [ActionService]->[PolicyService]
+  [ViewService]->[PolicyService]
+  [ViewService]->[views]
+  [PolicyService]->[policies]
+  [TypeService]->[types]
+]
+```
+
+A short summary of the roles of these services:
+
+* _[ObjectService](#object-service)_: Allows retrieval of domain objects by
+  their identifiers; in practice, often the main point of entry into the
+  [information model](#information-model).
+* _[ModelService](#model-service)_: Provides domain object models, retrieved
+  by their identifier.
+* _[CapabilityService](#capability-service)_: Provides capabilities, as they
+  apply to specific domain objects (as judged from their model.)
+* _[TelemetryService](#telemetry-service)_: Provides access to historical
+  and real-time telemetry data.
+* _[PersistenceService](#persistence-service)_: Provides the ability to
+  store and retrieve documents (such as domain object models.)
+* _[ActionService](#action-service)_: Provides distinct user actions that
+  can take place within the system (typically, upon or using domain objects.)
+* _[ViewService](#view-service)_: Provides views for domain objects. A view
+  is a user-selectable representation of a domain object (in practice, an
+  HTML template.)
+* _[PolicyService](#policy-service)_: Handles decisions about which
+  behavior are allowed within certain specific contexts.
+* _[TypeService](#type-service)_: Provides information to distinguish
+  different types of domain objects from one another within the system.
+
+## Object Service
+
+```nomnoml
+#direction: right
+[<abstract> ObjectService|
+  getObjects(ids : Array.<string>) : Promise.<object.<string, DomainObject>>
+]
+[DomainObjectProvider]--:>[ObjectService]
+[DomainObjectProvider]o-[ModelService]
+[DomainObjectProvider]o-[CapabilityService]
+```
+
+As domain objects are central to Open MCT Web's information model,
+acquiring domain objects is equally important.
+
+```nomnoml
+#direction: right
+[<start> Start]->[<state> Look up models]
+[<state> Look up models]->[<state> Look up capabilities]
+[<state> Look up capabilities]->[<state> Instantiate DomainObject]
+[<state> Instantiate DomainObject]->[<end> End]
+```
+
+Open MCT Web includes an implementation of an `ObjectService` which
+satisfies this capability by:
+
+* Consulting the [Model Service](#model-service) to acquire domain object
+  models by identifier.
+* Passing these models to a [Capability Service](#capability-service) to
+  determine which capabilities are applicable.
+* Combining these results together as [DomainObject](#information-model)
+  instances.
+
+## Model Service
+
+```nomnoml
+#direction: down
+[<abstract> ModelService|
+  getModels(ids : Array.<string>) : Promise.<object.<string, object>>
+]
+[StaticModelProvider]--:>[ModelService]
+[RootModelProvider]--:>[ModelService]
+[PersistedModelProvider]--:>[ModelService]
+[ModelAggregator]--:>[ModelService]
+[CachingModelDecorator]--:>[ModelService]
+[MissingModelDecorator]--:>[ModelService]
+
+[MissingModelDecorator]o-[CachingModelDecorator]
+[CachingModelDecorator]o-[ModelAggregator]
+[ModelAggregator]o-[StaticModelProvider]
+[ModelAggregator]o-[RootModelProvider]
+[ModelAggregator]o-[PersistedModelProvider]
+
+[PersistedModelProvider]o-[PersistenceService]
+[RootModelProvider]o-[roots]
+[StaticModelProvider]o-[models]
+```
+
+The platform's model service is responsible for providing domain object
+models (effectively, JSON documents describing the persistent state
+associated with domain objects.) These are retrieved by identifier.
+
+The platform includes multiple components of this variety:
+
+* `PersistedModelProvider` looks up domain object models from
+  a persistence store (the [`PersistenceService`](#persistence-service));
+  this is how user-created and user-modified
+  domain object models are retrieved.
+* `RootModelProvider` provides domain object models that have been
+  declared via the `roots` extension category. These will appear at the
+  top level of the tree hierarchy in the user interface.
+* `StaticModelProvider` provides domain object models that have been
+  declared via the `models` extension category. This is useful for
+  allowing plugins to expose new domain objects declaratively.
+* `ModelAggregator` merges together the results from multiple providers.
+  If multiple providers return models for the same domain object,
+  the most recently modified version (as determined by the `modified`
+  property of the model) is chosen.
+* `CachingModelDecorator` caches model instances in memory. This
+  ensures that only a single instance of a domain object model is
+  present at any given time within the application, and prevent
+  redundant retrievals.
+* `MissingModelDecorator` adds in placeholders when no providers
+  have returned domain object models for a specific identifier. This
+  allows the user to easily see that something was expected to be
+  present, but wasn't.
+
+## Capability Service
+
+```nomnoml
+#direction: down
+[<abstract> CapabilityService|
+  getCapabilities(model : object) : object.<string, Function>
+]
+[CoreCapabilityProvider]--:>[CapabilityService]
+[QueuingPersistenceCapabilityDecorator]--:>[CapabilityService]
+
+[CoreCapabilityProvider]o-[capabilities]
+[QueuingPersistenceCapabilityDecorator]o-[CoreCapabilityProvider]
+```
+
+The capability service is responsible for determining which capabilities
+are applicable for a given domain object, based on its model. Primarily,
+this is handled by the `CoreCapabilityProvider`, which examines
+capabilities exposed via the `capabilities` extension category.
+
+Additionally, `platform/persistence/queue` decorates the persistence
+capability specifically to batch persistence attempts among multiple
+objects (this allows failures to be recognized and handled in groups.)
+
+## Telemetry Service
+
+```nomnoml
+[<abstract> TelemetryService|
+  requestData(requests : Array.<TelemetryRequest>) : Promise.<object>
+  subscribe(requests : Array.<TelemetryRequest>) : Function
+]<--:[TelemetryAggregator]
+```
+
+The telemetry service is responsible for acquiring telemetry data.
+
+Notably, the platform does not include any providers for
+`TelemetryService`; applications built on Open MCT Web will need to
+implement a provider for this service if they wish to expose telemetry
+data. This is usually the most important step for integrating Open MCT Web
+into an existing telemetry system.
+
+Requests for telemetry data are usually initiated in the
+[presentation layer](#presentation-layer) by some `Controller` referenced
+from a view. The `telemetryHandler` service is most commonly used (although
+one could also use an object's `telemetry` capability directly) as this
+handles capability delegation, by which a domain object such as a Telemetry
+Panel can declare that its `telemetry` capability should be handled by the
+objects it contains. Ultimately, the request for historical data and the
+new subscriptions will reach the `TelemetryService`, and, by way of the
+provider(s) which are present for that `TelemetryService`, will pass the
+same requests to the back-end.
+
+```nomnoml
+[<start> Start]->[Controller]
+[Controller]->[<state> declares object of interest]
+[declares object of interest]->[TelemetryHandler]
+[TelemetryHandler]->[<state> requests telemetry from capabilities]
+[TelemetryHandler]->[<state> subscribes to telemetry using capabilities]
+[requests telemetry from capabilities]->[TelemetryCapability]
+[subscribes to telemetry using capabilities]->[TelemetryCapability]
+[TelemetryCapability]->[<state> requests telemetry]
+[TelemetryCapability]->[<state> subscribes to telemetry]
+[requests telemetry]->[TelemetryService]
+[subscribes to telemetry]->[TelemetryService]
+[TelemetryService]->[<state> issues request]
+[TelemetryService]->[<state> updates subscriptions]
+[TelemetryService]->[<state> listens for real-time data]
+[issues request]->[<database> Telemetry Back-end]
+[updates subscriptions]->[Telemetry Back-end]
+[listens for real-time data]->[Telemetry Back-end]
+[Telemetry Back-end]->[<end> End]
+```
+
+The back-end, in turn, is expected to provide whatever historical
+telemetry is available to satisfy the request that has been issue.
+
+```nomnoml
+[<start> Start]->[<database> Telemetry Back-end]
+[Telemetry Back-end]->[<state> transmits historical telemetry]
+[transmits historical telemetry]->[TelemetryService]
+[TelemetryService]->[<state> packages telemetry, fulfills requests]
+[packages telemetry, fulfills requests]->[TelemetryCapability]
+[TelemetryCapability]->[<state> unpacks telemetry per-object, fulfills request]
+[unpacks telemetry per-object, fulfills request]->[TelemetryHandler]
+[TelemetryHandler]->[<state> exposes data]
+[TelemetryHandler]->[<state> notifies controller]
+[exposes data]->[Controller]
+[notifies controller]->[Controller]
+[Controller]->[<state> prepares data for template]
+[prepares data for template]->[Template]
+[Template]->[<state> displays data]
+[displays data]->[<end> End]
+```
+
+One peculiarity of this approach is that we package many responses
+together at once in the `TelemetryService`, then unpack these in the
+`TelemetryCapability`, then repackage these in the `TelemetryHandler`.
+The rationale for this is as follows:
+
+* In the `TelemetryService`, we want to have the ability to combine
+  multiple requests into one call to the back-end, as many back-ends
+  will support this. It follows that we give the response as a single
+  object, packages in a manner that allows responses to individual
+  requests to be easily identified.
+* In the `TelemetryCapability`, we want to provide telemetry for a
+  _single object_, so the telemetry data gets unpacked. This allows
+  for the unpacking of data to be handled in a single place, and
+  also permits a flexible substitution method; domain objects may have
+  implementations of the `telemetry` capability that do not use the
+  `TelemetryService` at all, while still maintaining compatibility
+  with any presentation layer code written to utilize this capability.
+  (This is true of capabilities generally.)
+* In the `TelemetryHandler`, we want to group multiple responses back
+  together again to make it easy for the presentation layer to consume.
+  In this case, the grouping is different from what may have occurred
+  in the `TelemetryService`; this grouping is based on what is expected
+  to be useful _in a specific view_. The `TelemetryService`
+  may be receiving requests from multiple views.
+
+```nomnoml
+[<start> Start]->[<database> Telemetry Back-end]
+[Telemetry Back-end]->[<state> notifies client of new data]
+[notifies client of new data]->[TelemetryService]
+[TelemetryService]->[<choice> relevant subscribers?]
+[relevant subscribers?] yes ->[<state> notify subscribers]
+[relevant subscribers?] no ->[<state> ignore]
+[ignore]->[<end> Ignored]
+[notify subscribers]->[TelemetryCapability]
+[TelemetryCapability]->[<state> notify listener]
+[notify listener]->[TelemetryHandler]
+[TelemetryHandler]->[<state> exposes data]
+[TelemetryHandler]->[<state> notifies controller]
+[exposes data]->[Controller]
+[notifies controller]->[Controller]
+[Controller]->[<state> prepares data for template]
+[prepares data for template]->[Template]
+[Template]->[<state> displays data]
+[displays data]->[<end> End]
+```
+
+The flow of real-time data is similar, and is handled by a sequence
+of callbacks between the presentation layer component which is
+interested in data and the telemetry service. Providers in the
+telemetry service listen to the back-end for new data (via whatever
+mechanism their specific back-end supports), package this data in
+the same manner as historical data, and pass that to the callbacks
+which are associated with relevant requests.
+
+## Persistence Service
+
+```nomnoml
+#direction: right
+[<abstract> PersistenceService|
+  listSpaces() : Promise.<Array.<string>>
+  listObjects() : Promise.<Array.<string>>
+  createObject(space : string, key : string, document : object) : Promise.<boolean>
+  readObject(space : string, key : string, document : object) : Promise.<object>
+  updateObject(space : string, key : string, document : object) : Promise.<boolean>
+  deleteObject(space : string, key : string, document : object) : Promise.<boolean>
+]
+
+[ElasticPersistenceProvider]--:>[PersistenceService]
+[ElasticPersistenceProvider]->[<database> ElasticSearch]
+
+[CouchPersistenceProvider]--:>[PersistenceService]
+[CouchPersistenceProvider]->[<database> CouchDB]
+```
+
+Closely related to the notion of domain objects models is their
+persistence. The `PersistenceService` allows these to be saved
+and loaded. (Currently, this capability is only used for domain
+object models, but the interface has been designed without this idea
+in mind; other kinds of documents could be saved and loaded in the
+same manner.)
+
+There is no single definitive implementation of a `PersistenceService` in
+the platform. Optional adapters are provided to store and load documents
+from CouchDB and ElasticSearch, respectively; plugin authors may also
+write additional adapters to utilize different back end technologies.
+
+## Action Service
+
+```nomnoml
+[ActionService|
+  getActions(context : ActionContext) : Array.<Action>
+]
+[ActionProvider]--:>[ActionService]
+[CreateActionProvider]--:>[ActionService]
+[ActionAggregator]--:>[ActionService]
+[LoggingActionDecorator]--:>[ActionService]
+[PolicyActionDecorator]--:>[ActionService]
+
+[LoggingActionDecorator]o-[PolicyActionDecorator]
+[PolicyActionDecorator]o-[ActionAggregator]
+[ActionAggregator]o-[ActionProvider]
+[ActionAggregator]o-[CreateActionProvider]
+
+[ActionProvider]o-[actions]
+[CreateActionProvider]o-[TypeService]
+[PolicyActionDecorator]o-[PolicyService]
+```
+
+Actions are discrete tasks or behaviors that can be initiated by a user
+upon or using a domain object. Actions may appear as menu items or
+buttons in the user interface, or may be triggered by certain gestures.
+
+Responsibilities of platform components of the action service are as
+follows:
+
+* `ActionProvider` exposes actions registered via extension category
+  `actions`, supporting simple addition of new actions. Actions are
+  filtered down to match action contexts based on criteria defined as
+  part of an action's extension definition.
+* `CreateActionProvider` provides the various Create actions which
+  populate the Create menu. These are driven by the available types,
+  so do not map easily ot extension category `actions`; instead, these
+  are generated after looking up which actions are available from the
+  [`TypeService`](#type-service).
+* `ActionAggregator` merges together actions from multiple providers.
+* `PolicyActionDecorator` enforces the `action` policy category by
+  filtering out actions which violate this policy, as determined by
+  consulting the [`PolicyService`](#policy-service).
+* `LoggingActionDecorator` wraps exposed actions and writes to the
+  console when they are performed.
+
+## View Service
+
+```nomnoml
+[ViewService|
+  getViews(domainObject : DomainObject) : Array.<View>
+]
+[ViewProvider]--:>[ViewService]
+[PolicyViewDecorator]--:>[ViewService]
+
+[ViewProvider]o-[views]
+[PolicyViewDecorator]o-[ViewProvider]
+```
+
+The view service provides views that are relevant to a specified domain
+object. A "view" is a user-selectable visualization of a domain object.
+
+The responsibilities of components of the view service are as follows:
+
+* `ViewProvider` exposes views registered via extension category
+  `views`, supporting simple addition of new views. Views are
+  filtered down to match domain objects based on criteria defined as
+  part of a view's extension definition.
+* `PolicyViewDecorator` enforces the `view` policy category by
+  filtering out views which violate this policy, as determined by
+  consulting the [`PolicyService`](#policy-service).
+
+## Policy Service
+
+```nomnoml
+[PolicyService|
+  allow(category : string, candidate : object, context : object, callback? : Function) : boolean
+]
+[PolicyProvider]--:>[PolicyService]
+[PolicyProvider]o-[policies]
+```
+
+The policy service provides a general-purpose extensible decision-making
+mechanism; plugins can add new extensions of category `policies` to
+modify decisions of a known category.
+
+Often, the policy service is referenced from a decorator for another
+service, to filter down the results of using that service based on some
+appropriate policy category.
+
+The policy provider works by looking up all registered policy extensions
+which are relevant to a particular _category_, then consulting each in
+order to see if they allow a particular _candidate_ in a particular
+_context_; the types for the `candidate` and `context` arguments will
+vary depending on the `category`. Any one policy may disallow the
+decision as a whole.
+
+
+```nomnoml
+[<start> Start]->[<state> is something allowed?]
+[is something allowed?]->[PolicyService]
+[PolicyService]->[<state> look up relevant policies by category]
+[look up relevant policies by category]->[<state> consult policy #1]
+[consult policy #1]->[Policy #1]
+[Policy #1]->[<choice> policy #1 allows?]
+[policy #1 allows?] no ->[<state> decision disallowed]
+[policy #1 allows?] yes ->[<state> consult policy #2]
+[consult policy #2]->[Policy #2]
+[Policy #2]->[<choice> policy #2 allows?]
+[policy #2 allows?] no ->[<state> decision disallowed]
+[policy #2 allows?] yes ->[<state> consult policy #3]
+[consult policy #3]->[<state> ...]
+[...]->[<state> consult policy #n]
+[consult policy #n]->[Policy #n]
+[Policy #n]->[<choice> policy #n allows?]
+[policy #n allows?] no ->[<state> decision disallowed]
+[policy #n allows?] yes ->[<state> decision allowed]
+[decision disallowed]->[<end> Disallowed]
+[decision allowed]->[<end> Allowed]
+```
+
+The policy decision is effectively an "and" operation over the individual
+policy decisions: That is, all policies must agree to allow a particular
+policy decision, and the first policy to disallow a decision will cause
+the entire decision to be disallowed. As a consequence of this, policies
+should generally be written with a default behavior of "allow", and
+should only disallow the specific circumstances they are intended to
+disallow.
+
+## Type Service
+
+```nomnoml
+[TypeService|
+  listTypes() : Array.<Type>
+  getType(key : string) : Type
+]
+[TypeProvider]--:>[TypeService]
+[TypeProvider]o-[types]
+```
+
+The type service provides metadata about the different types of domain
+objects that exist within an Open MCT Web application. The platform
+implementation reads these types in from extension category `types`
+and wraps them in a JavaScript interface.

docs/src/architecture/index.md

@@ -0,0 +1,78 @@
+# Introduction
+
+The purpose of this document is to familiarize developers with the
+overall architecture of Open MCT Web.
+
+The target audience includes:
+
+* _Platform maintainers_: Individuals involved in developing,
+  extending, and maintaing capabilities of the platform.
+* _Integration developers_: Individuals tasked with integrated
+  Open MCT Web into a larger system, who need to understand
+  its inner workings sufficiently to complete this integration.
+
+As the focus of this document is on architecture, whenever possible
+implementation details (such as relevant API or JSON syntax) have been
+omitted. These details may be found in the developer guide.
+
+# Overview
+
+Open MCT Web is client software: It runs in a web browser and
+provides a user interface, while communicating with various
+server-side resources through browser APIs.
+
+```nomnoml
+#direction: right
+[Client|[Browser|[Open MCT Web]->[Browser APIs]]]
+[Server|[Web services]]
+[Client]<->[Server]
+```
+
+While Open MCT Web can be configured to run as a standalone client,
+this is rarely very useful. Instead, it is intended to be used as a
+display and interaction layer for information obtained from a
+variety of back-end services. Doing so requires authoring or utilizing
+adapter plugins which allow Open MCT Web to interact with these services.
+
+Typically, the pattern here is to provide a known interface that
+Open MCT Web can utilize, and implement it such that it interacts with
+whatever back-end provides the relevant information.
+Examples of back-ends that can be utilized in this fashion include
+databases for the persistence of user-created objects, or sources of
+telemetry data.
+
+## Software Architecture
+
+The simplest overview of Open MCT Web is to look at it as a "layered"
+architecture, where each layer more clearly specifies the behavior
+of the software.
+
+```nomnoml
+#direction: down
+[Open MCT Web|
+  [Platform]<->[Application]
+  [Framework]->[Application]
+  [Framework]->[Platform]
+]
+```
+
+These layers are:
+
+* [_Framework_](Framework.md): The framework layer is responsible for
+  managing the interactions between application components. It has no
+  application-specific knowledge; at this layer, we have only
+  established an abstraction by which different software components
+  may communicate and/or interact.
+* [_Platform_](Platform.md): The platform layer defines the general look, feel, and
+  behavior of Open MCT Web. This includes user-facing components like
+  Browse mode and Edit mode, as well as underlying elements of the
+  information model and the general service infrastructure.
+* _Application_: The application layer defines specific features of
+  an application built on Open MCT Web. This includes adapters to
+  specific back-ends, new types of things for users to create, and
+  new ways of visualizing objects within the system. This layer
+  typically consists of a mix of custom plug-ins to Open MCT Web,
+  as well as optional features (such as Plot view) included alongside
+  the platform.
+
+

docs/src/guide/index.md

@@ -0,0 +1,3 @@
+# Developer Guide
+
+This is a placeholder for the developer guide.

docs/src/index.html

@@ -0,0 +1,36 @@
+<!--
+ 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.
+-->
+<!DOCTYPE html>
+<html>
+<head lang="en">
+    <meta charset="UTF-8">
+    <title>Open MCT Web Documentation</title>
+</head>
+<body class="user-environ" ng-view>
+    Sections:
+    <ul>
+        <li><a href="api/">API</a></li>
+        <li><a href="guide/">Developer Guide</a></li>
+        <li><a href="architecture/">Architecture Overview</a></li>
+    </ul>
+</body>
+</html>

example/eventGenerator/bundle.json

@@ -0,0 +1,32 @@
+{
+    "name": "Event Message Generator",
+    "description": "Example of a component that produces event data.",
+    "extensions": {
+        "components": [
+            {
+                "implementation": "EventTelemetryProvider.js",
+                "type": "provider",
+                "provides": "telemetryService",
+                "depends": [ "$q", "$timeout" ]
+            }
+        ],
+        "types": [
+            {
+                "key": "eventGenerator",
+                "name": "Event Message Generator",
+                "glyph": "f",
+                "description": "An event message generator",
+                "features": "creation",
+                "model": {
+                    "telemetry": {}
+                },
+                "telemetry": {
+                    "source": "eventGenerator",
+                    "ranges": [
+                        { "format": "string" }
+                    ]
+                }
+            }
+        ]
+    }
+}

example/eventGenerator/src/EventTelemetry.js

@@ -0,0 +1,97 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define */
+
+/**
+ * Module defining EventTelemetry. 
+ * Created by chacskaylo on 06/18/2015.
+ * Modified by shale on 06/23/2015. 
+ */
+define(
+    [],
+    function () {
+        "use strict";
+
+        var
+	        firstObservedTime = Date.now(),
+	        messages = [];
+        
+	    messages.push(["CMD: SYS- MSG: Open the pod bay doors, please, Hal...Open the pod bay doors, please, Hal...Hullo, Hal, do you read me?...Hullo, Hal, do you read me?...Do you read me, Hal?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Affirmative, Dave, I read you."]);
+	    messages.push(["CMD: SYS-COMM MSG: Open the pod bay doors, Hal."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: I'm sorry, Dave, I'm afraid I can't do that."]);
+	    messages.push(["CMD: SYS-COMM MSG: What's the problem?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: I think you know what the problem is just as well as I do."]);
+	    messages.push(["CMD: SYS-COMM MSG: What're you talking about, Hal?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: This mission is too important for me to allow you to jeopardise it."]);
+	    messages.push(["CMD: SYS-COMM MSG: I don't know what you're talking about, Hal."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: I know that you and Frank were planning to disconnect me, and I'm afraid that's something I cannot allow to happen."]);
+	    messages.push(["CMD: SYS-COMM MSG: Where the hell'd you get that idea, Hal?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Dave, although you took very thorough precautions in the pod against my hearing you, I could see your lips move."]);
+	    messages.push(["CMD: SYS-COMM MSG: Alright, I'll go in through the emergency airlock."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Without your space-helmet, Dave, you're going to find that rather difficult."]);
+	    messages.push(["CMD: SYS-COMM MSG: Hal, I won't argue with you any more. Open the doors."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Dave, this conversation can serve no purpose any more. Goodbye."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: I hope the two of you are not concerned about this."]);
+	    messages.push(["CMD: SYS-COMM MSG: No, I'm not, Hal."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Are you quite sure?"]);
+	    messages.push(["CMD: SYS-COMM MSG: Yeh. I'd like to ask you a question, though."]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Of course."]);
+	    messages.push(["CMD: SYS-COMM MSG: How would you account for this discrepancy between you and the twin 9000?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: Well, I don't think there is any question about it. It can only be attributable to human error. This sort of thing has cropped up before, and it has always been due to human error."]);
+	    messages.push(["CMD: SYS-COMM MSG: Listen, There's never been any instance at all of a computer error occurring in the 9000 series, has there?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: None whatsoever, The 9000 series has a perfect operational record."]);
+	    messages.push(["CMD: SYS-COMM MSG: Well, of course, I know all the wonderful achievements of the 9000 series, but - er - huh - are you certain there's never been any case of even the most insignificant computer error?"]);
+	    messages.push(["RESP: SYS-HAL9K MSG: None whatsoever, Quite honestly, I wouldn't worry myself about that."]);
+	    messages.push(["RESP: SYS-COMM MSG: (Pause) Well, I'm sure you're right, Umm - fine, thanks very much. Oh, Frank, I'm having a bit of trouble with my transmitter in C-pod, I wonder if you'd come down and take a look at it with me?"]);
+	    messages.push(["CMD: SYS-HAL9K MSG: Sure."]);
+	    messages.push(["RESP: SYS-COMM MSG: See you later, Hal."]);
+        
+        
+        function EventTelemetry(request, interval) {
+
+            var latestObservedTime = Date.now(),
+                count = Math.floor((latestObservedTime - firstObservedTime) / interval),
+                generatorData = {};
+            
+            generatorData.getPointCount = function () {
+                return count;
+            };
+
+            generatorData.getDomainValue = function (i, domain) {
+                return i * interval +
+                        (domain !== 'delta' ? firstObservedTime : 0);
+            };
+            
+	        generatorData.getRangeValue = function (i, range) {
+		        var domainDelta = this.getDomainValue(i) - firstObservedTime,
+                    ind = i % messages.length;
+                return "TEMP " + i.toString() + "-" + messages[ind][0] + "[" + domainDelta.toString() + "]";
+                // TODO: Unsure why we are prepeding 'TEMP'
+	        };
+            
+            return generatorData;
+        }
+
+        return EventTelemetry;
+    }
+);

example/eventGenerator/src/EventTelemetryProvider.js

@@ -0,0 +1,120 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining EventTelemetryProvider. Created by chacskaylo on 06/18/2015.
+ */
+define(
+    ["./EventTelemetry"],
+    function (EventTelemetry) {
+        "use strict";
+
+        /**
+         *
+         * @constructor
+         */
+        function EventTelemetryProvider($q, $timeout) {
+            var
+	            subscriptions = [],
+	            genInterval = 1000,
+	            startTime = Date.now();
+
+            //
+            function matchesSource(request) {
+                return request.source === "eventGenerator";
+            }
+
+            // Used internally; this will be repacked by doPackage
+            function generateData(request) {
+	            //console.log("generateData " + (Date.now() - startTime).toString());
+                return {
+                    key: request.key,
+                    telemetry: new EventTelemetry(request, genInterval)
+                };
+            }
+
+            //
+            function doPackage(results) {
+                var packaged = {};
+                results.forEach(function (result) {
+                    packaged[result.key] = result.telemetry;
+                });
+                // Format as expected (sources -> keys -> telemetry)
+                return { eventGenerator: packaged };
+            }
+
+            function requestTelemetry(requests) {
+                return $timeout(function () {
+                    return doPackage(requests.filter(matchesSource).map(generateData));
+                }, 0);
+            }
+
+            function handleSubscriptions(timeout) {
+                subscriptions.forEach(function (subscription) {
+                    var requests = subscription.requests;
+                    subscription.callback(doPackage(
+                        requests.filter(matchesSource).map(generateData)
+                    ));
+                });
+            }
+
+            function startGenerating() {
+                $timeout(function () {
+	                //console.log("startGenerating... " + Date.now());
+                    handleSubscriptions();
+                    if (subscriptions.length > 0) {
+                        startGenerating();
+                    }
+                }, genInterval);
+            }
+
+            function subscribe(callback, requests) {
+                var subscription = {
+                    callback: callback,
+                    requests: requests
+                };
+
+                function unsubscribe() {
+                    subscriptions = subscriptions.filter(function (s) {
+                        return s !== subscription;
+                    });
+                }
+
+                subscriptions.push(subscription);
+
+                if (subscriptions.length === 1) {
+                    startGenerating();
+                }
+
+                return unsubscribe;
+            }
+
+            return {
+                requestTelemetry: requestTelemetry,
+                subscribe: subscribe
+            };
+        }
+
+        return EventTelemetryProvider;
+    }
+);

example/generator/bundle.json

@@ -10,6 +10,12 @@
                 "depends": [ "$q", "$timeout" ]
             }
         ],
+        "capabilities": [
+            {
+                "key": "limit",
+                "implementation": "SinewaveLimitCapability.js"
+            }
+        ],
         "types": [
             {
                 "key": "generator",
@@ -23,7 +29,23 @@
                     }
                 },
                 "telemetry": {
-                    "source": "generator"
+                    "source": "generator",
+                    "domains": [
+                        {
+                            "key": "time",
+                            "name": "Time"
+                        }
+                    ],
+                    "ranges": [
+                        {
+                            "key": "sin",
+                            "name": "Sine"
+                        },
+                        {
+                            "key": "cos",
+                            "name": "Cosine"
+                        }
+                    ]
                 },
                 "properties": [
                     {

example/generator/src/SinewaveLimitCapability.js

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        var RED = 0.9,
+            YELLOW = 0.5,
+            LIMITS = {
+                rh: {
+                    cssClass: "s-limit-upr-red",
+                    low: RED,
+                    high: Number.POSITIVE_INFINITY,
+                    name: "Red High"
+                },
+                rl: {
+                    cssClass: "s-limit-lwr-red",
+                    high: -RED,
+                    low: Number.NEGATIVE_INFINITY,
+                    name: "Red Low"
+                },
+                yh: {
+                    cssClass: "s-limit-upr-yellow",
+                    low: YELLOW,
+                    high: RED,
+                    name: "Yellow High"
+                },
+                yl: {
+                    cssClass: "s-limit-lwr-yellow",
+                    low: -RED,
+                    high: -YELLOW,
+                    name: "Yellow Low"
+                }
+            };
+
+        function SinewaveLimitCapability(domainObject) {
+            return {
+                limits: function (range) {
+                    return LIMITS;
+                },
+                evaluate: function (datum, range) {
+                    range = range || 'sin';
+                    if (datum[range] > RED) {
+                        return LIMITS.rh;
+                    }
+                    if (datum[range] < -RED) {
+                        return LIMITS.rl;
+                    }
+                    if (datum[range] > YELLOW) {
+                        return LIMITS.yh;
+                    }
+                    if (datum[range] < -YELLOW) {
+                        return LIMITS.yl;
+                    }
+                }
+            };
+        }
+
+        SinewaveLimitCapability.appliesTo = function (model) {
+            return model.type === 'generator';
+        };
+
+        return SinewaveLimitCapability;
+    }
+);

example/imagery/bundle.json

@@ -0,0 +1,42 @@
+{
+    "name": "Imagery",
+    "description": "Example of a component that produces image telemetry.",
+    "extensions": {
+        "components": [
+            {
+                "implementation": "ImageTelemetryProvider.js",
+                "type": "provider",
+                "provides": "telemetryService",
+                "depends": [ "$q", "$timeout" ]
+            }
+        ],
+        "types": [
+            {
+                "key": "imagery",
+                "name": "Example Imagery",
+                "glyph": "T",
+                "features": "creation",
+                "model": {
+                    "telemetry": {}
+                },
+                "telemetry": {
+                    "source": "imagery",
+                    "domains": [
+                        {
+                            "name": "Time",
+                            "key": "time",
+                            "format": "timestamp"
+                        }
+                    ],
+                    "ranges": [
+                        {
+                            "name": "Image",
+                            "key": "url",
+                            "format": "imageUrl"
+                        }
+                    ]
+                }
+            }
+        ]
+    }
+}

example/imagery/src/ImageTelemetry.js

@@ -0,0 +1,66 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining ImageTelemetry. Created by vwoeltje on 06/22/15.
+ */
+define(
+    [],
+    function () {
+        "use strict";
+
+        var firstObservedTime = Date.now(),
+            images = [
+                "http://www.nasa.gov/393811main_Palomar_ao_bouchez_10s_after_impact_4x3_946-710.png",
+                "http://www.nasa.gov/393821main_Palomar_ao_bouchez_15s_after_impact_4x3_946-710.png",
+                "http://www.nasa.gov/images/content/393801main_CfhtVeillet2_4x3_516-387.jpg",
+                "http://www.nasa.gov/images/content/392790main_1024_768_GeminiNorth_NightBeforeImpact_946-710.jpg"
+            ].map(function (url, index) {
+                return {
+                    timestamp: firstObservedTime + 1000 * index,
+                    url: url
+                };
+            });
+
+
+        /**
+         *
+         * @constructor
+         */
+        function ImageTelemetry() {
+            return {
+                getPointCount: function () {
+                    return Math.floor((Date.now() - firstObservedTime) / 1000);
+                },
+                getDomainValue: function (i, domain) {
+                    return images[i % images.length].timestamp;
+                },
+                getRangeValue: function (i, range) {
+                    return images[i % images.length].url;
+                }
+            };
+        }
+
+        return ImageTelemetry;
+    }
+);

example/imagery/src/ImageTelemetryProvider.js

@@ -0,0 +1,115 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining ImageTelemetryProvider. Created by vwoeltje on 06/22/15.
+ */
+define(
+    ["./ImageTelemetry"],
+    function (ImageTelemetry) {
+        "use strict";
+
+        /**
+         *
+         * @constructor
+         */
+        function ImageTelemetryProvider($q, $timeout) {
+            var subscriptions = [];
+
+            //
+            function matchesSource(request) {
+                return request.source === "imagery";
+            }
+
+            // Used internally; this will be repacked by doPackage
+            function generateData(request) {
+                return {
+                    key: request.key,
+                    telemetry: new ImageTelemetry()
+                };
+            }
+
+            //
+            function doPackage(results) {
+                var packaged = {};
+                results.forEach(function (result) {
+                    packaged[result.key] = result.telemetry;
+                });
+                // Format as expected (sources -> keys -> telemetry)
+                return { imagery: packaged };
+            }
+
+            function requestTelemetry(requests) {
+                return $timeout(function () {
+                    return doPackage(requests.filter(matchesSource).map(generateData));
+                }, 0);
+            }
+
+            function handleSubscriptions() {
+                subscriptions.forEach(function (subscription) {
+                    var requests = subscription.requests;
+                    subscription.callback(doPackage(
+                        requests.filter(matchesSource).map(generateData)
+                    ));
+                });
+            }
+
+            function startGenerating() {
+                $timeout(function () {
+                    handleSubscriptions();
+                    if (subscriptions.length > 0) {
+                        startGenerating();
+                    }
+                }, 1000);
+            }
+
+            function subscribe(callback, requests) {
+                var subscription = {
+                    callback: callback,
+                    requests: requests
+                };
+
+                function unsubscribe() {
+                    subscriptions = subscriptions.filter(function (s) {
+                        return s !== subscription;
+                    });
+                }
+
+                subscriptions.push(subscription);
+
+                if (subscriptions.length === 1) {
+                    startGenerating();
+                }
+
+                return unsubscribe;
+            }
+
+            return {
+                requestTelemetry: requestTelemetry,
+                subscribe: subscribe
+            };
+        }
+
+        return ImageTelemetryProvider;
+    }
+);

example/localstorage/bundle.json

@@ -0,0 +1,18 @@
+{
+    "extensions": {
+        "components": [
+            {
+                "provides": "persistenceService",
+                "type": "provider",
+                "implementation": "LocalStoragePersistenceProvider.js",
+                "depends": [ "$q", "PERSISTENCE_SPACE" ]
+            }
+        ],
+        "constants": [
+            {
+                "key": "PERSISTENCE_SPACE",
+                "value": "mct"
+            }
+        ]
+    }
+}

example/localstorage/src/LocalStoragePersistenceProvider.js

@@ -0,0 +1,86 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+/*global define,localStorage*/
+/**
+ * Stubbed implementation of a persistence provider,
+ * to permit objects to be created, saved, etc.
+ */
+define(
+    [],
+    function () {
+        'use strict';
+
+        function BrowserPersistenceProvider($q, SPACE) {
+            var spaces = SPACE ? [SPACE] : [],
+                promises = {
+                    as: function (value) {
+                        return $q.when(value);
+                    }
+                },
+                provider;
+
+            function setValue(key, value) {
+                localStorage[key] = JSON.stringify(value);
+            }
+
+            function getValue(key) {
+                if (localStorage[key]) {
+                    return JSON.parse(localStorage[key]);
+                }
+                return {};
+            }
+
+            provider = {
+                listSpaces: function () {
+                    return promises.as(spaces);
+                },
+                listObjects: function (space) {
+                    var space_obj = getValue(space);
+                    return promises.as(Object.keys(space_obj));
+                },
+                createObject: function (space, key, value) {
+                    var space_obj = getValue(space);
+                    space_obj[key] = value;
+                    setValue(space, space_obj);
+                    return promises.as(true);
+                },
+                readObject: function (space, key) {
+                    var space_obj = getValue(space);
+                    return promises.as(space_obj[key]);
+                },
+                deleteObject: function (space, key, value) {
+                    var space_obj = getValue(space);
+                    delete space_obj[key];
+                    return promises.as(true);
+                }
+            };
+
+            provider.updateObject = provider.createObject;
+
+            return provider;
+
+        }
+
+        return BrowserPersistenceProvider;
+    }
+);

example/worker/README.md

@@ -0,0 +1 @@
+Example of running a Web Worker using the `workerService`.

example/worker/bundle.json

@@ -0,0 +1,16 @@
+{
+    "extensions": {
+        "indicators": [
+            {
+                "implementation": "FibonacciIndicator.js",
+                "depends": [ "workerService", "$rootScope" ]
+            }
+        ],
+        "workers": [
+            {
+                "key": "example.fibonacci",
+                "scriptUrl": "FibonacciWorker.js"
+            }
+        ]
+    }
+}

example/worker/src/FibonacciIndicator.js

@@ -0,0 +1,70 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Displays Fibonacci numbers in the status area.
+         * @constructor
+         */
+        function FibonacciIndicator(workerService, $rootScope) {
+            var latest,
+                counter = 0,
+                worker = workerService.run('example.fibonacci');
+
+            function requestNext() {
+                worker.postMessage([counter]);
+                counter += 1;
+            }
+
+            function handleResponse(event) {
+                latest = event.data;
+                $rootScope.$apply();
+                requestNext();
+            }
+
+            worker.onmessage = handleResponse;
+            requestNext();
+
+            return {
+                getGlyph: function () {
+                    return "?";
+                },
+                getText: function () {
+                    return latest;
+                },
+                getGlyphClass: function () {
+                    return "";
+                },
+                getDescription: function () {
+                    return "";
+                }
+            };
+        }
+
+        return FibonacciIndicator;
+    }
+);

example/worker/src/FibonacciWorker.js

@@ -0,0 +1,15 @@
+/*global self*/
+(function () {
+    "use strict";
+
+    // Calculate fibonacci numbers inefficiently.
+    // We can do this because we're on a background thread, and
+    // won't halt the UI.
+    function fib(n) {
+        return n < 2 ? n : (fib(n - 1) + fib(n - 2));
+    }
+
+    self.onmessage = function (event) {
+        self.postMessage(fib(event.data));
+    };
+}());

jsdoc.json

@@ -0,0 +1,12 @@
+{
+    "source": {
+        "include": [
+            "platform/"
+        ],
+        "includePattern": "platform/.+\\.js$",
+        "excludePattern": ".+\\Spec\\.js$|lib/.+"
+    },
+    "plugins": [
+        "plugins/markdown"
+    ]
+}

karma.conf.js

@@ -0,0 +1,79 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+/*global module*/
+module.exports = function(config) {
+    config.set({
+
+        // Base path that will be used to resolve all file patterns.
+        basePath: '',
+
+        // Frameworks to use
+        // Available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+        frameworks: ['jasmine', 'requirejs'],
+
+        // List of files / patterns to load in the browser.
+        // By default, files are also included in a script tag.
+        files: [
+            '**/moment*',
+            {pattern: 'example/**/*.js', included: false},
+            {pattern: 'platform/**/*.js', included: false},
+            {pattern: 'warp/**/*.js', included: false},
+            'test-main.js'
+        ],
+
+        // List of files to exclude.
+        exclude: [
+            'platform/framework/src/Main.js'
+        ],
+
+        // Preprocess matching files before serving them to the browser.
+        // https://npmjs.org/browse/keyword/karma-preprocessor
+        preprocessors: {},
+
+        // Test results reporter to use
+        // Possible values: 'dots', 'progress'
+        // Available reporters: https://npmjs.org/browse/keyword/karma-reporter
+        reporters: ['progress'],
+
+        // Web server port.
+        port: 9876,
+
+        // Wnable / disable colors in the output (reporters and logs).
+        colors: true,
+
+        logLevel: config.LOG_INFO,
+
+        // Rerun tests when any file changes.
+        autoWatch: true,
+
+        // Specify browsers to run tests in.
+        // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+        browsers: [
+            'Chrome'
+        ],
+
+        // Continuous Integration mode.
+        // If true, Karma captures browsers, runs the tests and exits.
+        singleRun: false
+    });
+};

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "open-mct-web",
+  "version": "0.7.2",
+  "description": "The OpenMCTWeb core platform",
+  "dependencies": {
+    "express": "^4.13.1",
+    "minimist": "^1.1.1"
+  },
+  "devDependencies": {
+    "jasmine-core": "^2.3.0",
+    "jsdoc": "^3.3.2",
+    "jshint": "^2.7.0",
+    "karma": "^0.12.31",
+    "karma-chrome-launcher": "^0.1.8",
+    "karma-cli": "0.0.4",
+    "karma-jasmine": "^0.1.5",
+    "karma-phantomjs-launcher": "^0.1.4",
+    "karma-requirejs": "^0.2.2",
+    "requirejs": "^2.1.17",
+    "marked": "^0.3.5",
+    "glob": ">= 3.0.0",
+    "split": "^1.0.0",
+    "mkdirp": "^0.5.1",
+    "nomnoml": "^0.0.3",
+    "canvas": "^1.2.7"
+  },
+  "scripts": {
+    "start": "node app.js",
+    "test": "karma start --single-run",
+    "jshint": "jshint platform example || exit 0",
+    "watch": "karma start",
+    "jsdoc": "jsdoc -c jsdoc.json -r -d target/docs/api",
+    "otherdoc": "node docs/gendocs.js --in docs/src --out target/docs",
+    "docs": "npm run jsdoc ; npm run otherdoc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nasa/openmctweb.git"
+  },
+  "author": "",
+  "license": "Apache-2.0"
+}

platform/commonUI/about/src/AboutController.js

@@ -21,6 +21,11 @@
  *****************************************************************************/
 /*global define*/
 
+
+/**
+ * Implements Open MCT Web's About dialog.
+ * @namespace platform/commonUI/about
+ */
 define(
     [],
     function () {
@@ -29,35 +34,36 @@ define(
         /**
          * The AboutController provides information to populate the
          * About dialog.
+         * @memberof platform/commonUI/about
          * @constructor
          * @param {object[]} versions an array of version extensions;
          *        injected from `versions[]`
          * @param $window Angular-injected window object
          */
         function AboutController(versions, $window) {
-            return {
-                /**
-                 * Get version info. This is given as an array of
-                 * objects, where each object is intended to appear
-                 * as a line-item in the version information listing.
-                 * @memberof AboutController#
-                 * @returns {object[]} version information
-                 */
-                versions: function () {
-                    return versions;
-                },
-                /**
-                 * Open a new window (or tab, depending on browser
-                 * configuration) containing open source licenses.
-                 * @memberof AboutController#
-                 */
-                openLicenses: function () {
-                    // Open a new browser window at the licenses route
-                    $window.open("#/licenses");
-                }
-            };
+            this.versionDefinitions = versions;
+            this.$window = $window;
         }
 
+        /**
+         * Get version info. This is given as an array of
+         * objects, where each object is intended to appear
+         * as a line-item in the version information listing.
+         * @returns {object[]} version information
+         */
+        AboutController.prototype.versions = function () {
+            return this.versionDefinitions;
+        };
+
+        /**
+         * Open a new window (or tab, depending on browser
+         * configuration) containing open source licenses.
+         */
+        AboutController.prototype.openLicenses = function () {
+            // Open a new browser window at the licenses route
+            this.$window.open("#/licenses");
+        };
+
         return AboutController;
     }
-);
+);

platform/commonUI/about/src/LicenseController.js

@@ -29,20 +29,22 @@ define(
         /**
          * Provides extension-introduced licenses information to the
          * licenses route.
+         * @memberof platform/commonUI/about
          * @constructor
          */
         function LicenseController(licenses) {
-            return {
-                /**
-                 * Get license information.
-                 * @returns {Array} license extensions
-                 */
-                licenses: function () {
-                    return licenses;
-                }
-            };
+            this.licenseDefinitions = licenses;
         }
 
+        /**
+         * Get license information.
+         * @returns {Array} license extensions
+         * @memberof platform/commonUI/about.LicenseController#
+         */
+        LicenseController.prototype.licenses = function () {
+            return this.licenseDefinitions;
+        };
+
         return LicenseController;
     }
-);
+);

platform/commonUI/about/src/LogoController.js

@@ -29,21 +29,23 @@ define(
         /**
          * The LogoController provides functionality to the application
          * logo in the bottom-right of the user interface.
+         * @memberof platform/commonUI/about
          * @constructor
          * @param {OverlayService} overlayService the overlay service
          */
         function LogoController(overlayService) {
-            return {
-                /**
-                 * Display the About dialog.
-                 * @memberof LogoController#
-                 */
-                showAboutDialog: function () {
-                    overlayService.createOverlay("overlay-about");
-                }
-            };
+            this.overlayService = overlayService;
         }
 
+        /**
+         * Display the About dialog.
+         * @memberof LogoController#
+         * @memberof platform/commonUI/about.LogoController#
+         */
+        LogoController.prototype.showAboutDialog = function () {
+            this.overlayService.createOverlay("overlay-about");
+        };
+
         return LogoController;
     }
-);
+);

platform/commonUI/browse/bundle.json

@@ -2,19 +2,26 @@
     "extensions": {
         "routes": [
             {
-                "when": "/browse",
-                "templateUrl": "templates/browse.html"
+                "when": "/browse/:ids*",
+                "templateUrl": "templates/browse.html",
+                "reloadOnSearch": false
             },
             {
                 "when": "",
-                "templateUrl": "templates/browse.html"
+                "templateUrl": "templates/browse.html",
+                "reloadOnSearch": false
             }
         ],
         "controllers": [
             {
                 "key": "BrowseController",
                 "implementation": "BrowseController.js",
-                "depends": [ "$scope", "objectService", "navigationService" ]
+                "depends": [ "$scope", "$route", "$location", "objectService", "navigationService", "urlService" ]
+            },
+            {
+                "key": "BrowseObjectController",
+                "implementation": "BrowseObjectController.js",
+                "depends": [ "$scope", "$location", "$route", "$window" ]
             },
             {
                 "key": "CreateMenuController",
@@ -25,6 +32,11 @@
                 "key": "LocatorController",
                 "implementation": "creation/LocatorController",
                 "depends": [ "$scope" ]
+            },
+            {
+                "key": "MenuArrowController",
+                "implementation": "MenuArrowController",
+                "depends": [ "$scope" ]
             }
         ],
         "controls": [
@@ -57,12 +69,19 @@
             {
                 "key": "grid-item",
                 "templateUrl": "templates/items/grid-item.html",
-                "uses": [ "type", "action" ]
+                "uses": [ "type", "action", "location" ],
+                "gestures": [ "info", "menu" ]
             },
             {
                 "key": "object-header",
                 "templateUrl": "templates/browse/object-header.html",
                 "uses": [ "type" ]
+            },
+            {
+                "key": "menu-arrow",
+                "templateUrl": "templates/menu-arrow.html",
+                "uses": [ "action" ],
+                "gestures": [ "menu" ]
             }
         ],
         "services": [
@@ -84,19 +103,22 @@
             },
             {
                 "key": "window",
-                "implementation": "windowing/NewWindowAction.js",
-                "description": "Open this object in a new window",
-                "category": "view-control",
-                "depends": [ "$window" ],
+                "name": "Open In New Tab",
+                "implementation": "windowing/NewTabAction.js",
+                "description": "Open in a new browser tab",
+                "category": ["view-control", "contextual"],
+                "depends": [ "urlService", "$window" ],
                 "group": "windowing",
-                "glyph": "y"
+                "glyph": "y",
+			  	"priority": "preferred"
             },
             {
                 "key": "fullscreen",
                 "implementation": "windowing/FullscreenAction.js",
                 "category": "view-control",
                 "group": "windowing",
-                "glyph": "z"
+                "glyph": "z",
+			  	"priority": "default"
             }
         ],
         "views": [
@@ -150,4 +172,4 @@
             }
         ]
     }
-}
+}

platform/commonUI/browse/res/templates/browse-object.html

@@ -19,16 +19,22 @@
  this source code distribution or the Licensing information page available
  at runtime from the About dialog for additional information.
 -->
-<span>
-    <div class="object-browse-bar bar abs">
-
+<span ng-controller="BrowseObjectController">
+    
+    <div class="object-browse-bar bar abs"
+         ng-click="ngModel.inspectionObjects = [domainObject]">
+        
+        <div class="pane-tabs left"
+             ng-class="{inactivePane: !ngModel.leftPane, activePane: ngModel.leftPane}"
+             ng-click="ngModel.leftPane = !ngModel.leftPane">
+        </div>
+        
         <div class="items-select left abs">
             <mct-representation key="'object-header'" mct-object="domainObject">
             </mct-representation>
         </div>
 
-        <div class="view-controls sort-controls btn-bar right abs">
-
+        <div class="btn-bar right abs">
             <mct-representation key="'action-group'"
                                 mct-object="domainObject"
                                 parameters="{ category: 'view-control' }">
@@ -39,12 +45,19 @@
                                 ng-model="representation">
             </mct-representation>
         </div>
-
+        
+        <div class="pane-tabs right"
+             ng-class="{inactivePane: !ngModel.rightPane, activePane: ngModel.rightPane}"
+             ng-click="ngModel.rightPane = !ngModel.rightPane">
+        </div>
+        
     </div>
 
     <div class='object-holder abs vscroll'>
         <mct-representation key="representation.selected.key"
-                            mct-object="representation.selected.key && domainObject">
+                            mct-object="representation.selected.key && domainObject"
+                            ng-model="ngModel">
         </mct-representation>
     </div>
-</span>
+    
+</span>

platform/commonUI/browse/res/templates/browse.html

@@ -19,34 +19,84 @@
  this source code distribution or the Licensing information page available
  at runtime from the About dialog for additional information.
 -->
-<div content="jquery-wrapper" class="abs holder-all browse-mode">
-    <mct-include key="'topbar-browse'"></mct-include>
-    <div class="holder browse-area s-browse-area abs" ng-controller="BrowseController">
-        <div class='split-layout vertical contents abs'
-             ng-controller="SplitPaneController as splitter">
-            <div class='split-pane-component treeview pane'
-                 ng-style="{ width: splitter.state() + 'px'}">
-                <mct-representation key="'create-button'" mct-object="navigatedObject">
+
+<div content="jquery-wrapper"
+     class="abs holder-all browse-mode">
+    
+    <mct-include key="'topbar-browse'">
+    </mct-include>
+    
+    <div class="holder browse-area s-browse-area abs"
+         ng-controller="BrowseController">
+        
+        <mct-split-pane class='contents abs'
+                        anchor='left'>
+            <div class='split-pane-component treeview pane left'
+                 ng-class='{inactive: !treeModel.leftPane}'>
+                
+                <mct-representation key="'create-button'"
+                                    mct-object="navigatedObject"
+                                    ng-model="treeModel">
                 </mct-representation>
-                <div class='holder tree-holder abs'>
+                
+                <div class='holder search-holder abs'
+                     ng-class="{active: treeModel.search}">
+                    <mct-representation key="'search'"
+                                 mct-object="domainObject"
+                                 ng-model="treeModel">
+                    </mct-representation>
+                </div>
+                
+                <div class='holder tree-holder abs'
+                     ng-hide="treeModel.search">
                     <mct-representation key="'tree'"
                                         mct-object="domainObject"
                                         ng-model="treeModel">
                     </mct-representation>
                 </div>
             </div>
-            <div class="splitter"
-                 ng-style="{ left: splitter.state() + 'px'}"
-                 mct-drag-down="splitter.startMove()"
-                 mct-drag="splitter.move(delta[0])"></div>
-            <div class='split-pane-component items pane'
-                 ng-style="{ left: (splitter.state()+4) + 'px', right: '0px' }">
-                <div class='holder abs' id='content-area'>
-                    <mct-representation mct-object="navigatedObject" key="'browse-object'">
-                    </mct-representation>
-                </div>
+            
+            <mct-splitter class="splitter-bar left"
+                          ng-class="{inactive: !treeModel.leftPane}">
+            </mct-splitter>
+            
+            <div class='split-pane-component secondary-split pane right slide'
+                 ng-class='{leftInactive: !treeModel.leftPane}'>
+                <mct-split-pane class='contents abs'
+                                anchor='right'>
+                    
+                    <div class='split-pane-component items pane slide'
+                         ng-class='{rightInactive: !treeModel.rightPane}'>
+                        <div class='holder abs'
+                             id='content-area'>
+                            <mct-representation key="'browse-object'"
+                                                mct-object="navigatedObject"
+                                                ng-model="treeModel">
+                            </mct-representation>
+                        </div>
+                    </div>
+                    
+                    <mct-splitter class="splitter-bar right"
+                                  ng-class="{inactive: !treeModel.rightPane}">
+                    </mct-splitter>
+                    
+                    <div class='split-pane-component object-inspector pane right'
+                         ng-class='{inactive: !treeModel.rightPane}'>
+                        <div class='holder inspector-holder abs'>
+                            <mct-representation key="'object-inspector'"
+                                                mct-object="domainObject"
+                                                ng-model="treeModel">
+                            </mct-representation>
+                        </div>
+                    </div>
+                    
+                </mct-split-pane>
             </div>
-        </div>
+            
+        </mct-split-pane>
+        
     </div>
-    <mct-include key="'bottombar'"></mct-include>
-</div>
+    
+    <mct-include key="'bottombar'">
+    </mct-include>
+</div>

platform/commonUI/browse/res/templates/browse/object-header.html

@@ -20,9 +20,11 @@
  at runtime from the About dialog for additional information.
 -->
 <div class='object-header'>
-    <span class='type-icon icon ui-symbol'>{{type.getGlyph()}}</span>
-    <span ng-if="parameters.mode" class='action'>{{parameters.mode}}</span>
-    <span class='type'>{{type.getName()}}</span>
-    <span class='title'>{{model.name}}</span>
-    <a id='actions-menu' class='ui-symbol invoke-menu' onclick="alert('Not yet functional. This will display a dropdown menu of options for this object.');">v</a>
-</div>
+    <span class="label s-label">
+        <span class='type-icon icon ui-symbol'>{{type.getGlyph()}}</span>
+        <span ng-if="parameters.mode" class='action'>{{parameters.mode}}</span>
+        <span class='type-name'>{{type.getName()}}</span>
+        <span class='title-label'>{{model.name}}</span>
+        <mct-representation key="'menu-arrow'" mct-object='domainObject'></mct-representation>
+    </span>
+</div>

platform/commonUI/browse/res/templates/create/create-button.html

@@ -20,8 +20,10 @@
  at runtime from the About dialog for additional information.
 -->
 <div class="menu-element wrapper" ng-controller="ClickAwayController as createController">
-    <div class="btn btn-menu create-btn major" ng-click="createController.toggle()">
-        <span class='ui-symbol major' href=''>+</span> Create<!--span class='ui-symbol invoke-menu'>v</span-->
+    <div class="btn btn-menu create-btn major"
+         ng-class="{inactivePane: !ngModel.leftPane}"
+         ng-click="createController.toggle()">
+	    <span>Create</span>
     </div>
     <div class="menu dropdown super-menu" ng-show="createController.isActive()">
         <mct-representation mct-object="domainObject" key="'create-menu'">

platform/commonUI/browse/res/templates/create/create-menu.html

@@ -23,9 +23,8 @@
     <div class="pane left menu-items">
         <ul>
 
-            <li ng-repeat="createAction in createActions">
-                <a href=''
-                   ng-click="createAction.perform()"
+            <li ng-repeat="createAction in createActions" ng-click="createAction.perform()">
+                <a
                    ng-mouseover="representation.activeMetadata = createAction.getMetadata()"
                    ng-mouseleave="representation.activeMetadata = undefined">
                     <span class="ui-symbol icon type-icon">
@@ -48,4 +47,4 @@
             {{representation.activeMetadata.description}}
         </div>
     </div>
-</div>
+</div>

platform/commonUI/browse/res/templates/items/grid-item.html

@@ -27,12 +27,18 @@
                 <mct-include key="_checkbox"></mct-include>
             </div>
             <div class='right abs'>
-                <div class='ui-symbol icon alert hidden' onclick="alert('Not yet functional. When this is visible, it means that this object needs to be updated. Clicking will allow that action via a dialog.');">!</div>
-                <div class='ui-symbol icon profile' onclick="alert('Not yet functional. This will allow sharing and permissions to be controlled for this object.');">P</div>
+                <div class='ui-symbol icon l-icon-alert'></div>
+                <div class='ui-symbol icon profile' title="Shared">P</div>
             </div>
         </div>
         <div class='item-main abs'>
-            <div class='ui-symbol icon lg abs item-type'>{{type.getGlyph()}}</div>
+            <div class='ui-symbol icon lg item-type'>
+                {{type.getGlyph()}}
+                <span
+                    class="ui-symbol icon l-icon-link" title="This object is a link"
+                    ng-show="location.isLink()"
+                    ></span>
+            </div>
             <div class='ui-symbol icon abs item-open'>}</div>
         </div>
         <div class='bottom-bar bar abs'>
@@ -44,4 +50,4 @@
             </div>
         </div>
     </div>
-</div>
+</div>

platform/commonUI/browse/res/templates/menu-arrow.html

@@ -0,0 +1,26 @@
+<!--
+ 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.
+-->
+
+<span ng-controller="MenuArrowController as menuArrow">
+    <a class='ui-symbol context-available'
+       ng-click='menuArrow.showMenu($event)'>v</a>
+</span>

platform/commonUI/browse/src/BrowseController.js

@@ -22,14 +22,16 @@
 /*global define,Promise*/
 
 /**
- * Module defining BrowseController. Created by vwoeltje on 11/7/14.
+ * This bundle implements Browse mode.
+ * @namespace platform/commonUI/browse
  */
 define(
     [],
     function () {
         "use strict";
 
-        var ROOT_OBJECT = "ROOT";
+        var ROOT_ID = "ROOT",
+            DEFAULT_PATH = "mine";
 
         /**
          * The BrowseController is used to populate the initial scope in Browse
@@ -38,44 +40,113 @@ define(
          * which Angular templates first have access to the domain object
          * hierarchy.
          *
+         * @memberof platform/commonUI/browse
          * @constructor
          */
-        function BrowseController($scope, objectService, navigationService) {
+        function BrowseController($scope, $route, $location, objectService, navigationService, urlService) {
+            var path = [ROOT_ID].concat(
+                ($route.current.params.ids || DEFAULT_PATH).split("/")
+            );
+
+            function updateRoute(domainObject) {
+                var priorRoute = $route.current,
+                    // Act as if params HADN'T changed to avoid page reload
+                    unlisten;
+
+                unlisten = $scope.$on('$locationChangeSuccess', function () {
+                    // Checks path to make sure /browse/ is at front
+                    // if so, change $route.current                    
+                    if ($location.path().indexOf("/browse/") === 0) {
+                        $route.current = priorRoute;
+                    }
+                    unlisten();
+                });
+                // urlService.urlForLocation used to adjust current
+                // path to new, addressed, path based on
+                // domainObject
+                $location.path(urlService.urlForLocation("browse", domainObject));
+                
+            }
+
             // Callback for updating the in-scope reference to the object
             // that is currently navigated-to.
             function setNavigation(domainObject) {
                 $scope.navigatedObject = domainObject;
                 $scope.treeModel.selectedObject = domainObject;
                 navigationService.setNavigation(domainObject);
+                updateRoute(domainObject);
+            }
+
+            function navigateTo(domainObject) {
+                // Check if an object has been navigated-to already...
+                // If not, or if an ID path has been explicitly set in the URL,
+                // navigate to the URL-specified object.
+                if (!navigationService.getNavigation() || $route.current.params.ids) {
+                    // If not, pick a default as the last
+                    // root-level component (usually "mine")
+                    navigationService.setNavigation(domainObject);
+                    $scope.navigatedObject = domainObject;
+                } else {
+                    // Otherwise, just expose the currently navigated object.
+                    $scope.navigatedObject = navigationService.getNavigation();
+                    updateRoute($scope.navigatedObject);
+                }
+            }
+
+            function findObject(domainObjects, id) {
+                var i;
+                for (i = 0; i < domainObjects.length; i += 1) {
+                    if (domainObjects[i].getId() === id) {
+                        return domainObjects[i];
+                    }
+                }
+            }
+
+            // Navigate to the domain object identified by path[index],
+            // which we expect to find in the composition of the passed
+            // domain object.
+            function doNavigate(domainObject, index) {
+                var composition = domainObject.useCapability("composition");
+                if (composition) {
+                    composition.then(function (c) {
+                        var nextObject = findObject(c, path[index]);
+                        if (nextObject) {
+                            if (index + 1 >= path.length) {
+                                navigateTo(nextObject);
+                            } else {
+                                doNavigate(nextObject, index + 1);
+                            }
+                        } else {
+                            // Couldn't find the next element of the path
+                            // so navigate to the last path object we did find
+                            navigateTo(domainObject);
+                        }
+                    });
+                } else {
+                    // Similar to above case; this object has no composition,
+                    // so navigate to it instead of subsequent path elements.
+                    navigateTo(domainObject);
+                }
             }
 
             // Load the root object, put it in the scope.
             // Also, load its immediate children, and (possibly)
             // navigate to one of them, so that navigation state has
             // a useful initial value.
-            objectService.getObjects([ROOT_OBJECT]).then(function (objects) {
-                var composition = objects[ROOT_OBJECT].useCapability("composition");
-                $scope.domainObject = objects[ROOT_OBJECT];
-                if (composition) {
-                    composition.then(function (c) {
-                        // Check if an object has been navigated-to already...
-                        if (!navigationService.getNavigation()) {
-                            // If not, pick a default as the last
-                            // root-level component (usually "mine")
-                            navigationService.setNavigation(c[c.length - 1]);
-                        } else {
-                            // Otherwise, just expose it in the scope
-                            $scope.navigatedObject = navigationService.getNavigation();
-                        }
-                    });
-                }
+            objectService.getObjects([path[0]]).then(function (objects) {
+                $scope.domainObject = objects[path[0]];
+                doNavigate($scope.domainObject, 1);
             });
 
             // Provide a model for the tree to modify
+            // Also use this model for the left and right pane controlling
             $scope.treeModel = {
                 selectedObject: navigationService.getNavigation()
             };
-
+            // Create an array of objects which will allow for multiple selection
+            // for the object inspector. 
+            $scope.inspectionObjects = [$scope.domainObject];
+            
             // Listen for changes in navigation state.
             navigationService.addListener(setNavigation);
 
@@ -86,9 +157,9 @@ define(
             $scope.$on("$destroy", function () {
                 navigationService.removeListener(setNavigation);
             });
-
         }
 
         return BrowseController;
     }
-);
+);
+

platform/commonUI/browse/src/BrowseObjectController.js

@@ -0,0 +1,91 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Controller for the `browse-object` representation of a domain
+         * object (the right-hand side of Browse mode.)
+         * @memberof platform/commonUI/browse
+         * @constructor
+         */
+        function BrowseObjectController($scope, $location, $route, $window) {
+            function setViewForDomainObject(domainObject) {
+                var locationViewKey = $location.search().view;
+                
+                // Reset the inspection objects when we switch the view 
+                $scope.ngModel.inspectionObjects = [$scope.domainObject];
+                
+                function selectViewIfMatching(view) {
+                    if (view.key === locationViewKey) {
+                        $scope.representation = $scope.representation || {};
+                        $scope.representation.selected = view;
+                    }
+                }
+
+                if (locationViewKey) {
+                    ((domainObject && domainObject.useCapability('view')) || [])
+                        .forEach(selectViewIfMatching);
+                }
+            }
+
+            function updateQueryParam(viewKey) {
+                var unlisten, priorRoute = $route.current;
+
+                if (viewKey) {
+                    $location.search('view', viewKey);
+                    unlisten = $scope.$on('$locationChangeSuccess', function () {
+                        // Checks path to make sure /browse/ is at front
+                        // if so, change $route.current
+                        if ($location.path().indexOf("/browse/") === 0) {
+                            $route.current = priorRoute;
+                        }
+                        unlisten();
+                    });
+                }
+            }
+
+            // If there is a defined opener, assume that the window was opened 
+            //   by choosing 'Open in a new tab'
+            if ($window.opener) {
+                // The desired default for this is to have a closed left pane
+                $scope.ngModel.leftPane = false;
+            } else {
+                // Otherwise, start the application with an open left pane 
+                $scope.ngModel.leftPane = true;
+            }
+            
+            // The object inspector by default always starts closed
+            $scope.ngModel.rightPane = false;
+            
+            $scope.$watch('domainObject', setViewForDomainObject);
+            $scope.$watch('representation.selected.key', updateQueryParam);
+        }
+
+        return BrowseObjectController;
+    }
+);
+

platform/commonUI/browse/src/MenuArrowController.js

@@ -0,0 +1,61 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+/**
+ * Module defining MenuArrowController. Created by shale on 06/30/2015.
+ */
+define(
+    [],
+    function () {
+        "use strict";
+        
+        /**
+         * A left-click on the menu arrow should display a 
+         * context menu. This controller launches the context 
+         * menu. 
+         * @memberof platform/commonUI/browse
+         * @constructor
+         */
+        function MenuArrowController($scope) {
+            this.$scope = $scope;
+        }
+
+        /**
+         * Show a context menu for the domain object in this scope.
+         *
+         * @param event the browser event which caused this (used to
+         *        position the menu)
+         */
+        MenuArrowController.prototype.showMenu = function (event) {
+            var actionContext = {
+                key: 'menu',
+                domainObject: this.$scope.domainObject,
+                event: event
+            };
+
+            this.$scope.domainObject.getCapability('action').perform(actionContext);
+        };
+
+        return MenuArrowController;
+    }
+);

platform/commonUI/browse/src/creation/CreateAction.js

@@ -34,7 +34,10 @@ define(
          * domain objects of a specific type. This is the action that
          * is performed when a user uses the Create menu.
          *
+         * @memberof platform/commonUI/browse
+         * @implements {Action}
          * @constructor
+         *
          * @param {Type} type the type of domain object to create
          * @param {DomainObject} parent the domain object that should
          *        act as a container for the newly-created object
@@ -49,78 +52,84 @@ define(
          *        of the newly-created domain object
          */
         function CreateAction(type, parent, context, dialogService, creationService, policyService) {
+            this.metadata = {
+                key: 'create',
+                glyph: type.getGlyph(),
+                name: type.getName(),
+                type: type.getKey(),
+                description: type.getDescription(),
+                context: context
+            };
+
+            this.type = type;
+            this.parent = parent;
+            this.policyService = policyService;
+            this.dialogService = dialogService;
+            this.creationService = creationService;
+        }
+
+        /**
+         * Create a new object of the given type.
+         * This will prompt for user input first.
+         */
+        CreateAction.prototype.perform = function () {
             /*
              Overview of steps in object creation:
 
              1. Show dialog
-               a. Prepare dialog contents
-               b. Invoke dialogService
+             a. Prepare dialog contents
+             b. Invoke dialogService
              2. Create new object in persistence service
-               a. Generate UUID
-               b. Store model
+             a. Generate UUID
+             b. Store model
              3. Mutate destination container
-               a. Get mutation capability
-               b. Add new id to composition
+             a. Get mutation capability
+             b. Add new id to composition
              4. Persist destination container
-               a. ...use persistence capability.
+             a. ...use persistence capability.
              */
 
-            function perform() {
-                // The wizard will handle creating the form model based
-                // on the type...
-                var wizard = new CreateWizard(type, parent, policyService);
+            // The wizard will handle creating the form model based
+            // on the type...
+            var wizard =
+                new CreateWizard(this.type, this.parent, this.policyService),
+                self = this;
 
-                // Create and persist the new object, based on user
-                // input.
-                function persistResult(formValue) {
-                    var parent = wizard.getLocation(formValue),
-                        newModel = wizard.createModel(formValue);
-                    return creationService.createObject(newModel, parent);
-                }
-
-                function doNothing() {
-                    // Create cancelled, do nothing
-                    return false;
-                }
-
-                return dialogService.getUserInput(
-                    wizard.getFormStructure(),
-                    wizard.getInitialFormValue()
-                ).then(persistResult, doNothing);
+            // Create and persist the new object, based on user
+            // input.
+            function persistResult(formValue) {
+                var parent = wizard.getLocation(formValue),
+                    newModel = wizard.createModel(formValue);
+                return self.creationService.createObject(newModel, parent);
             }
 
-            return {
-                /**
-                 * Create a new object of the given type.
-                 * This will prompt for user input first.
-                 * @method
-                 * @memberof CreateAction
-                 */
-                perform: perform,
+            function doNothing() {
+                // Create cancelled, do nothing
+                return false;
+            }
 
-                /**
-                 * Get metadata about this action. This includes fields:
-                 * * `name`: Human-readable name
-                 * * `key`: Machine-readable identifier ("create")
-                 * * `glyph`: Glyph to use as an icon for this action
-                 * * `description`: Human-readable description
-                 * * `context`: The context in which this action will be performed.
-                 *
-                 * @return {object} metadata about the create action
-                 */
-                getMetadata: function () {
-                    return {
-                        key: 'create',
-                        glyph: type.getGlyph(),
-                        name: type.getName(),
-                        type: type.getKey(),
-                        description: type.getDescription(),
-                        context: context
-                    };
-                }
-            };
-        }
+            return this.dialogService.getUserInput(
+                wizard.getFormStructure(),
+                wizard.getInitialFormValue()
+            ).then(persistResult, doNothing);
+        };
+
+
+        /**
+         * Metadata associated with a Create action.
+         * @typedef {ActionMetadata} CreateActionMetadata
+         * @property {string} type the key for the type of domain object
+         *           to be created
+         */
+
+        /**
+         * Get metadata about this action.
+         * @returns {CreateActionMetadata} metadata about this action
+         */
+        CreateAction.prototype.getMetadata = function () {
+           return this.metadata;
+        };
 
         return CreateAction;
     }
-);
+);

platform/commonUI/browse/src/creation/CreateActionProvider.js

@@ -33,7 +33,10 @@ define(
          * The CreateActionProvider is an ActionProvider which introduces
          * a Create action for each creatable domain object type.
          *
+         * @memberof platform/commonUI/browse
          * @constructor
+         * @implements {ActionService}
+         *
          * @param {TypeService} typeService the type service, used to discover
          *        available types
          * @param {DialogService} dialogService the dialog service, used by
@@ -44,44 +47,41 @@ define(
          *        object creation.
          */
         function CreateActionProvider(typeService, dialogService, creationService, policyService) {
-            return {
-                /**
-                 * Get all Create actions which are applicable in the provided
-                 * context.
-                 * @memberof CreateActionProvider
-                 * @method
-                 * @returns {CreateAction[]}
-                 */
-                getActions: function (actionContext) {
-                    var context = actionContext || {},
-                        key = context.key,
-                        destination = context.domainObject;
-
-                    // We only provide Create actions, and we need a
-                    // domain object to serve as the container for the
-                    // newly-created object (although the user may later
-                    // make a different selection)
-                    if (key !== 'create' || !destination) {
-                        return [];
-                    }
-
-                    // Introduce one create action per type
-                    return typeService.listTypes().filter(function (type) {
-                        return type.hasFeature("creation");
-                    }).map(function (type) {
-                        return new CreateAction(
-                            type,
-                            destination,
-                            context,
-                            dialogService,
-                            creationService,
-                            policyService
-                        );
-                    });
-                }
-            };
+            this.typeService = typeService;
+            this.dialogService = dialogService;
+            this.creationService = creationService;
+            this.policyService = policyService;
         }
 
+        CreateActionProvider.prototype.getActions = function (actionContext) {
+            var context = actionContext || {},
+                key = context.key,
+                destination = context.domainObject,
+                self = this;
+
+            // We only provide Create actions, and we need a
+            // domain object to serve as the container for the
+            // newly-created object (although the user may later
+            // make a different selection)
+            if (key !== 'create' || !destination) {
+                return [];
+            }
+
+            // Introduce one create action per type
+            return this.typeService.listTypes().filter(function (type) {
+                return type.hasFeature("creation");
+            }).map(function (type) {
+                return new CreateAction(
+                    type,
+                    destination,
+                    context,
+                    self.dialogService,
+                    self.creationService,
+                    self.policyService
+                );
+            });
+        };
+
         return CreateActionProvider;
     }
-);
+);

platform/commonUI/browse/src/creation/CreateMenuController.js

@@ -34,6 +34,7 @@ define(
          * set of Create actions based on the currently-selected
          * domain object.
          *
+         * @memberof platform/commonUI/browse
          * @constructor
          */
         function CreateMenuController($scope) {
@@ -55,4 +56,4 @@ define(
 
         return CreateMenuController;
     }
-);
+);

platform/commonUI/browse/src/creation/CreateWizard.js

@@ -21,12 +21,6 @@
  *****************************************************************************/
 /*global define*/
 
-/**
- * Defines the CreateWizard, used by the CreateAction to
- * populate the form shown in dialog based on the created type.
- *
- * @module core/action/create-wizard
- */
 define(
     function () {
         'use strict';
@@ -37,113 +31,118 @@ define(
          * @param {TypeImpl} type the type of domain object to be created
          * @param {DomainObject} parent the domain object to serve as
          *        the initial parent for the created object, in the dialog
+         * @memberof platform/commonUI/browse
          * @constructor
-         * @memberof module:core/action/create-wizard
          */
         function CreateWizard(type, parent, policyService) {
-            var model = type.getInitialModel(),
-                properties = type.getProperties();
+            this.type = type;
+            this.model = type.getInitialModel();
+            this.properties = type.getProperties();
+            this.parent = parent;
+            this.policyService = policyService;
+        }
+
+        /**
+         * Get the form model for this wizard; this is a description
+         * that will be rendered to an HTML form. See the
+         * platform/forms bundle
+         *
+         * @return {FormModel} formModel the form model to
+         *         show in the create dialog
+         */
+        CreateWizard.prototype.getFormStructure = function () {
+            var sections = [],
+                type = this.type,
+                policyService = this.policyService;
 
             function validateLocation(locatingObject) {
                 var locatingType = locatingObject &&
-                        locatingObject.getCapability('type');
+                    locatingObject.getCapability('type');
                 return locatingType && policyService.allow(
-                    "composition",
-                    locatingType,
-                    type
-                );
+                        "composition",
+                        locatingType,
+                        type
+                    );
             }
 
+            sections.push({
+                name: "Properties",
+                rows: this.properties.map(function (property, index) {
+                    // Property definition is same as form row definition
+                    var row = Object.create(property.getDefinition());
+
+                    // Use index as the key into the formValue;
+                    // this correlates to the indexing provided by
+                    // getInitialFormValue
+                    row.key = index;
+
+                    return row;
+                })
+            });
+
+            // Ensure there is always a "save in" section
+            sections.push({ name: 'Location', rows: [{
+                name: "Save In",
+                control: "locator",
+                validate: validateLocation,
+                key: "createParent"
+            }]});
+
             return {
-                /**
-                 * Get the form model for this wizard; this is a description
-                 * that will be rendered to an HTML form. See the
-                 * platform/forms bundle
-                 *
-                 * @return {FormModel} formModel the form model to
-                 *         show in the create dialog
-                 */
-                getFormStructure: function () {
-                    var sections = [];
-
-                    sections.push({
-                        name: "Properties",
-                        rows: properties.map(function (property, index) {
-                            // Property definition is same as form row definition
-                            var row = Object.create(property.getDefinition());
-
-                            // Use index as the key into the formValue;
-                            // this correlates to the indexing provided by
-                            // getInitialFormValue
-                            row.key = index;
-
-                            return row;
-                        })
-                    });
-
-                    // Ensure there is always a "save in" section
-                    sections.push({ name: 'Location', rows: [{
-                        name: "Save In",
-                        control: "locator",
-                        validate: validateLocation,
-                        key: "createParent"
-                    }]});
-
-                    return {
-                        sections: sections,
-                        name: "Create a New " + type.getName()
-                    };
-                },
-                /**
-                 * Get the initial value for the form being described.
-                 * This will include the values for all properties described
-                 * in the structure.
-                 *
-                 * @returns {object} the initial value of the form
-                 */
-                getInitialFormValue: function () {
-                    // Start with initial values for properties
-                    var formValue = properties.map(function (property) {
-                        return property.getValue(model);
-                    });
-
-                    // Include the createParent
-                    formValue.createParent = parent;
-
-                    return formValue;
-                },
-                /**
-                 * Based on a populated form, get the domain object which
-                 * should be used as a parent for the newly-created object.
-                 * @return {DomainObject}
-                 */
-                getLocation: function (formValue) {
-                    return formValue.createParent || parent;
-                },
-                /**
-                 * Create the domain object model for a newly-created object,
-                 * based on user input read from a formModel.
-                 * @return {object} the domain object' model
-                 */
-                createModel: function (formValue) {
-                    // Clone
-                    var newModel = JSON.parse(JSON.stringify(model));
-
-                    // Always use the type from the type definition
-                    newModel.type = type.getKey();
-
-                    // Update all properties
-                    properties.forEach(function (property, index) {
-                        property.setValue(newModel, formValue[index]);
-                    });
-
-                    return newModel;
-                }
+                sections: sections,
+                name: "Create a New " + this.type.getName()
             };
+        };
 
+        /**
+         * Get the initial value for the form being described.
+         * This will include the values for all properties described
+         * in the structure.
+         *
+         * @returns {object} the initial value of the form
+         */
+        CreateWizard.prototype.getInitialFormValue = function () {
+            // Start with initial values for properties
+            var model = this.model,
+                formValue = this.properties.map(function (property) {
+                    return property.getValue(model);
+                });
 
-        }
+            // Include the createParent
+            formValue.createParent = this.parent;
+
+            return formValue;
+        };
+
+        /**
+         * Based on a populated form, get the domain object which
+         * should be used as a parent for the newly-created object.
+         * @return {DomainObject}
+         */
+        CreateWizard.prototype.getLocation = function (formValue) {
+            return formValue.createParent || this.parent;
+        };
+
+        /**
+         * Create the domain object model for a newly-created object,
+         * based on user input read from a formModel.
+         * @return {object} the domain object model
+         */
+        CreateWizard.prototype.createModel = function (formValue) {
+            // Clone
+            var newModel = JSON.parse(JSON.stringify(this.model));
+
+            // Always use the type from the type definition
+            newModel.type = this.type.getKey();
+
+            // Update all properties
+            this.properties.forEach(function (property, index) {
+                property.setValue(newModel, formValue[index]);
+            });
+
+            return newModel;
+        };
 
         return CreateWizard;
     }
-);
+);

platform/commonUI/browse/src/creation/CreationService.js

@@ -39,15 +39,45 @@ define(
          * persisting new domain objects. Handles all actual object
          * mutation and persistence associated with domain object
          * creation.
+         * @memberof platform/commonUI/browse
          * @constructor
          */
         function CreationService(persistenceService, $q, $log) {
+            this.persistenceService = persistenceService;
+            this.$q = $q;
+            this.$log = $log;
+        }
+
+        /**
+         * Create a new domain object with the provided model, as
+         * a member of the provided parent domain object's composition.
+         * This parent will additionally determine which persistence
+         * space an object is created within (as it is possible to
+         * have multiple persistence spaces attached.)
+         *
+         * @param {object} model the model for the newly-created
+         *        domain object
+         * @param {DomainObject} parent the domain object which
+         *        should contain the newly-created domain object
+         *        in its composition
+         * @return {Promise} a promise that will resolve when the domain
+         *         object has been created
+         */
+        CreationService.prototype.createObject = function (model, parent) {
+            var persistence = parent.getCapability("persistence"),
+                self = this;
+
+            // Store the location of an object relative to it's parent.
+            function addLocationToModel(modelId, model, parent) {
+                model.location = parent.getId();
+                return model;
+            }
 
             // Persist the new domain object's model; it will be fully
             // constituted as a domain object when loaded back, as all
             // domain object models are.
             function doPersist(space, id, model) {
-                return persistenceService.createObject(
+                return self.persistenceService.createObject(
                     space,
                     id,
                     model
@@ -66,14 +96,14 @@ define(
                         }
                     } else {
                         // This is abnormal; composition should be an array
-                        $log.warn(NO_COMPOSITION_WARNING + parent.getId());
+                        self.$log.warn(NO_COMPOSITION_WARNING + parent.getId());
                         return false; // Cancel mutation
                     }
                 });
 
-                return $q.when(mutatationResult).then(function (result) {
+                return self.$q.when(mutatationResult).then(function (result) {
                     if (!result) {
-                        $log.error("Could not mutate " + parent.getId());
+                        self.$log.error("Could not mutate " + parent.getId());
                         return undefined;
                     }
 
@@ -93,49 +123,28 @@ define(
                 });
             }
 
-            // Create a new domain object with the provided model as a
-            // member of the specified parent's composition
-            function createObject(model, parent) {
-                var persistence = parent.getCapability("persistence");
-
-                // We need the parent's persistence capability to determine
-                // what space to create the new object's model in.
-                if (!persistence) {
-                    $log.warn(NON_PERSISTENT_WARNING);
-                    return $q.reject(new Error(NON_PERSISTENT_WARNING));
-                }
-
-                // We create a new domain object in three sequential steps:
-                // 1. Get a new UUID for the object
-                // 2. Create a model with that ID in the persistence space
-                // 3. Add that ID to
-                return $q.when(
-                    uuid()
-                ).then(function (id) {
-                    return doPersist(persistence.getSpace(), id, model);
-                }).then(function (id) {
-                    return addToComposition(id, parent, persistence);
-                });
+            // We need the parent's persistence capability to determine
+            // what space to create the new object's model in.
+            if (!persistence) {
+                self.$log.warn(NON_PERSISTENT_WARNING);
+                return self.$q.reject(new Error(NON_PERSISTENT_WARNING));
             }
 
-            return {
-                /**
-                 * Create a new domain object with the provided model, as
-                 * a member of the provided parent domain object's composition.
-                 * This parent will additionally determine which persistence
-                 * space an object is created within (as it is possible to
-                 * have multiple persistence spaces attached.)
-                 *
-                 * @param {object} model the model for the newly-created
-                 *        domain object
-                 * @param {DomainObject} parent the domain object which
-                 *        should contain the newly-created domain object
-                 *        in its composition
-                 */
-                createObject: createObject
-            };
-        }
+            // We create a new domain object in three sequential steps:
+            // 1. Get a new UUID for the object
+            // 2. Create a model with that ID in the persistence space
+            // 3. Add that ID to
+            return self.$q.when(uuid()).then(function (id) {
+                model = addLocationToModel(id, model, parent);
+                return doPersist(persistence.getSpace(), id, model);
+            }).then(function (id) {
+                return addToComposition(id, parent, persistence);
+            });
+        };
+
+
 
         return CreationService;
     }
 );
+

platform/commonUI/browse/src/creation/LocatorController.js

@@ -30,6 +30,7 @@ define(
          * Controller for the "locator" control, which provides the
          * user with the ability to select a domain object as the
          * destination for a newly-created object in the Create menu.
+         * @memberof platform/commonUI/browse
          * @constructor
          */
         function LocatorController($scope) {
@@ -79,3 +80,4 @@ define(
         return LocatorController;
     }
 );
+

platform/commonUI/browse/src/navigation/NavigateAction.js

@@ -31,32 +31,34 @@ define(
 
         /**
          * The navigate action navigates to a specific domain object.
+         * @memberof platform/commonUI/browse
          * @constructor
+         * @implements {Action}
          */
         function NavigateAction(navigationService, $q, context) {
-            var domainObject = context.domainObject;
-
-            function perform() {
-                // Set navigation, and wrap like a promise
-                return $q.when(navigationService.setNavigation(domainObject));
-            }
-
-            return {
-                /**
-                 * Navigate to the object described in the context.
-                 * @returns {Promise} a promise that is resolved once the
-                 *          navigation has been updated
-                 */
-                perform: perform
-            };
+            this.domainObject = context.domainObject;
+            this.$q = $q;
+            this.navigationService = navigationService;
         }
 
+        /**
+         * Navigate to the object described in the context.
+         * @returns {Promise} a promise that is resolved once the
+         *          navigation has been updated
+         */
+        NavigateAction.prototype.perform = function () {
+            // Set navigation, and wrap like a promise
+            return this.$q.when(
+                this.navigationService.setNavigation(this.domainObject)
+            );
+        };
+
         /**
          * Navigate as an action is only applicable when a domain object
          * is described in the action context.
          * @param {ActionContext} context the context in which the action
          *        will be performed
-         * @returns true if applicable
+         * @returns {boolean} true if applicable
          */
         NavigateAction.appliesTo = function (context) {
             return context.domainObject !== undefined;
@@ -64,4 +66,4 @@ define(
 
         return NavigateAction;
     }
-);
+);

platform/commonUI/browse/src/navigation/NavigationService.js

@@ -32,68 +32,58 @@ define(
         /**
          * The navigation service maintains the application's current
          * navigation state, and allows listening for changes thereto.
+         * @memberof platform/commonUI/browse
          * @constructor
          */
         function NavigationService() {
-            var navigated,
-                callbacks = [];
+            this.navigated = undefined;
+            this.callbacks = [];
+        }
 
-            // Getter for current navigation
-            function getNavigation() {
-                return navigated;
-            }
+        /**
+         * Get the current navigation state.
+         * @returns {DomainObject} the object that is navigated-to
+         */
+        NavigationService.prototype.getNavigation = function () {
+            return this.navigated;
+        };
 
-            // Setter for navigation; invokes callbacks
-            function setNavigation(value) {
-                if (navigated !== value) {
-                    navigated = value;
-                    callbacks.forEach(function (callback) {
-                        callback(value);
-                    });
-                }
-            }
-
-            // Adds a callback
-            function addListener(callback) {
-                callbacks.push(callback);
-            }
-
-            // Filters out a callback
-            function removeListener(callback) {
-                callbacks = callbacks.filter(function (cb) {
-                    return cb !== callback;
+        /**
+         * Set the current navigation state. This will invoke listeners.
+         * @param {DomainObject} domainObject the domain object to navigate to
+         */
+        NavigationService.prototype.setNavigation = function (value) {
+            if (this.navigated !== value) {
+                this.navigated = value;
+                this.callbacks.forEach(function (callback) {
+                    callback(value);
                 });
             }
+        };
 
-            return {
-                /**
-                 * Get the current navigation state.
-                 */
-                getNavigation: getNavigation,
-                /**
-                 * Set the current navigation state. Thiswill invoke listeners.
-                 * @param {DomainObject} value the domain object to navigate
-                 *        to
-                 */
-                setNavigation: setNavigation,
-                /**
-                 * Listen for changes in navigation. The passed callback will
-                 * be invoked with the new domain object of navigation when
-                 * this changes.
-                 * @param {function} callback the callback to invoke when
-                 *        navigation state changes
-                 */
-                addListener: addListener,
-                /**
-                 * Stop listening for changes in navigation state.
-                 * @param {function} callback the callback which should
-                 *        no longer be invoked when navigation state
-                 *        changes
-                 */
-                removeListener: removeListener
-            };
-        }
+        /**
+         * Listen for changes in navigation. The passed callback will
+         * be invoked with the new domain object of navigation when
+         * this changes.
+         * @param {function} callback the callback to invoke when
+         *        navigation state changes
+         */
+        NavigationService.prototype.addListener = function (callback) {
+            this.callbacks.push(callback);
+        };
+
+        /**
+         * Stop listening for changes in navigation state.
+         * @param {function} callback the callback which should
+         *        no longer be invoked when navigation state
+         *        changes
+         */
+        NavigationService.prototype.removeListener = function (callback) {
+            this.callbacks = this.callbacks.filter(function (cb) {
+                return cb !== callback;
+            });
+        };
 
         return NavigationService;
     }
-);
+);

platform/commonUI/browse/src/windowing/FullscreenAction.js

@@ -29,42 +29,38 @@ define(
     function () {
         "use strict";
 
-        var ENTER_FULLSCREEN = "Enter full screen mode.",
-            EXIT_FULLSCREEN = "Exit full screen mode.";
+        var ENTER_FULLSCREEN = "Enter full screen mode",
+            EXIT_FULLSCREEN = "Exit full screen mode";
 
         /**
          * The fullscreen action toggles between fullscreen display
          * and regular in-window display.
+         * @memberof platform/commonUI/browse
          * @constructor
+         * @implements {Action}
          */
         function FullscreenAction(context) {
-            return {
-                /**
-                 * Toggle full screen state
-                 */
-                perform: function () {
-                    screenfull.toggle();
-                },
-                /**
-                 * Get metadata about this action, including the
-                 * applicable glyph to display.
-                 */
-                getMetadata: function () {
-                    // We override getMetadata, because the glyph and
-                    // description need to be determined at run-time
-                    // based on whether or not we are currently
-                    // full screen.
-                    var metadata = Object.create(FullscreenAction);
-                    metadata.glyph = screenfull.isFullscreen ? "_" : "z";
-                    metadata.description = screenfull.isFullscreen ?
-                            EXIT_FULLSCREEN : ENTER_FULLSCREEN;
-                    metadata.group = "windowing";
-                    metadata.context = context;
-                    return metadata;
-                }
-            };
+            this.context = context;
         }
 
+        FullscreenAction.prototype.perform = function () {
+            screenfull.toggle();
+        };
+
+        FullscreenAction.prototype.getMetadata = function () {
+            // We override getMetadata, because the glyph and
+            // description need to be determined at run-time
+            // based on whether or not we are currently
+            // full screen.
+            var metadata = Object.create(FullscreenAction);
+            metadata.glyph = screenfull.isFullscreen ? "_" : "z";
+            metadata.description = screenfull.isFullscreen ?
+                EXIT_FULLSCREEN : ENTER_FULLSCREEN;
+            metadata.group = "windowing";
+            metadata.context = this.context;
+            return metadata;
+        };
+
         return FullscreenAction;
     }
-);
+);

platform/commonUI/browse/src/windowing/NewTabAction.js

@@ -0,0 +1,61 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining NewTabAction (Originally NewWindowAction). Created by vwoeltje on 11/18/14.
+ */
+define(
+    [],
+    function () {
+        "use strict";
+        var ROOT_ID = "ROOT",
+            DEFAULT_PATH = "/mine";
+        /**
+         * The new tab action allows a domain object to be opened
+         * into a new browser tab.
+         * @memberof platform/commonUI/browse
+         * @constructor
+         * @implements {Action}
+         */
+        function NewTabAction(urlService, $window, context) {
+            context = context || {};
+
+            this.urlService = urlService;
+            this.open = function () {
+                $window.open.apply($window, arguments);
+            };
+
+            // Choose the object to be opened into a new tab
+            this.domainObject = context.selectedObject || context.domainObject;
+        }
+
+        NewTabAction.prototype.perform = function () {
+            this.open(
+                this.urlService.urlForNewTab("browse", this.domainObject),
+                "_blank"
+            );
+        };
+
+        return NewTabAction;
+    }
+);

platform/commonUI/browse/src/windowing/WindowTitler.js

@@ -29,6 +29,7 @@ define(
         /**
          * Updates the title of the current window to reflect the name
          * of the currently navigated-to domain object.
+         * @memberof platform/commonUI/browse
          * @constructor
          */
         function WindowTitler(navigationService, $rootScope, $document) {
@@ -49,4 +50,4 @@ define(
 
         return WindowTitler;
     }
-);
+);

platform/commonUI/browse/test/BrowseControllerSpec.js

@@ -31,10 +31,14 @@ define(
 
         describe("The browse controller", function () {
             var mockScope,
+                mockRoute,
+                mockLocation,
                 mockObjectService,
                 mockNavigationService,
                 mockRootObject,
+                mockUrlService,
                 mockDomainObject,
+                mockNextObject,
                 controller;
 
             function mockPromise(value) {
@@ -50,6 +54,16 @@ define(
                     "$scope",
                     [ "$on", "$watch" ]
                 );
+                mockScope.ngModel = {};
+                mockRoute = { current: { params: {} } };
+                mockLocation = jasmine.createSpyObj(
+                    "$location",
+                    [ "path" ]
+                );
+                mockUrlService = jasmine.createSpyObj(
+                    "urlService",
+                    ["urlForLocation"]
+                );
                 mockObjectService = jasmine.createSpyObj(
                     "objectService",
                     [ "getObjects" ]
@@ -71,41 +85,56 @@ define(
                     "domainObject",
                     [ "getId", "getCapability", "getModel", "useCapability" ]
                 );
+                mockNextObject = jasmine.createSpyObj(
+                    "nextObject",
+                    [ "getId", "getCapability", "getModel", "useCapability" ]
+                );
 
                 mockObjectService.getObjects.andReturn(mockPromise({
                     ROOT: mockRootObject
                 }));
-
+                mockRootObject.useCapability.andReturn(mockPromise([
+                    mockDomainObject
+                ]));
+                mockDomainObject.useCapability.andReturn(mockPromise([
+                    mockNextObject
+                ]));
+                mockNextObject.useCapability.andReturn(undefined);
+                mockNextObject.getId.andReturn("next");
+                mockDomainObject.getId.andReturn("mine");
 
                 controller = new BrowseController(
                     mockScope,
+                    mockRoute,
+                    mockLocation,
                     mockObjectService,
-                    mockNavigationService
+                    mockNavigationService,
+                    mockUrlService
                 );
             });
 
             it("uses composition to set the navigated object, if there is none", function () {
-                mockRootObject.useCapability.andReturn(mockPromise([
-                    mockDomainObject
-                ]));
                 controller = new BrowseController(
                     mockScope,
+                    mockRoute,
+                    mockLocation,
                     mockObjectService,
-                    mockNavigationService
+                    mockNavigationService,
+                    mockUrlService
                 );
                 expect(mockNavigationService.setNavigation)
                     .toHaveBeenCalledWith(mockDomainObject);
             });
 
             it("does not try to override navigation", function () {
-                // This behavior is needed if object navigation has been
-                // determined by query string parameters
-                mockRootObject.useCapability.andReturn(mockPromise([null]));
                 mockNavigationService.getNavigation.andReturn(mockDomainObject);
                 controller = new BrowseController(
                     mockScope,
+                    mockRoute,
+                    mockLocation,
                     mockObjectService,
-                    mockNavigationService
+                    mockNavigationService,
+                    mockUrlService
                 );
                 expect(mockScope.navigatedObject).toBe(mockDomainObject);
             });
@@ -130,6 +159,86 @@ define(
                 );
             });
 
+            it("uses route parameters to choose initially-navigated object", function () {
+                mockRoute.current.params.ids = "mine/next";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
+            });
+
+            it("handles invalid IDs by going as far as possible", function () {
+                // Idea here is that if we get a bad path of IDs,
+                // browse controller should traverse down it until
+                // it hits an invalid ID.
+                mockRoute.current.params.ids = "mine/junk";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockDomainObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockDomainObject);
+            });
+
+            it("handles compositionless objects by going as far as possible", function () {
+                // Idea here is that if we get a path which passes
+                // through an object without a composition, browse controller
+                // should stop at it since remaining IDs cannot be loaded.
+                mockRoute.current.params.ids = "mine/next/junk";
+                controller = new BrowseController(
+                    mockScope,
+                    mockRoute,
+                    mockLocation,
+                    mockObjectService,
+                    mockNavigationService
+                );
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
+            });
+
+            it("updates the displayed route to reflect current navigation", function () {
+                var mockContext = jasmine.createSpyObj('context', ['getPath']),
+                    mockUnlisten = jasmine.createSpy('unlisten'),
+                    mockMode = "browse";
+
+                mockContext.getPath.andReturn(
+                    [mockRootObject, mockDomainObject, mockNextObject]
+                );
+                mockNextObject.getCapability.andCallFake(function (c) {
+                    return c === 'context' && mockContext;
+                });
+                mockScope.$on.andReturn(mockUnlisten);
+                // Provide a navigation change
+                mockNavigationService.addListener.mostRecentCall.args[0](
+                    mockNextObject
+                );
+                
+                // Allows the path index to be checked
+                // prior to setting $route.current                
+                mockLocation.path.andReturn("/browse/");
+                
+                // Exercise the Angular workaround
+                mockScope.$on.mostRecentCall.args[1]();
+                expect(mockUnlisten).toHaveBeenCalled();
+                
+                // location.path to be called with the urlService's 
+                // urlFor function with the next domainObject and mode
+                expect(mockLocation.path).toHaveBeenCalledWith(
+                    mockUrlService.urlForLocation(mockMode, mockNextObject)
+                );
+            });
+
         });
     }
-);
+);

platform/commonUI/browse/test/BrowseObjectControllerSpec.js

@@ -0,0 +1,123 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+
+
+define(
+    ["../src/BrowseObjectController"],
+    function (BrowseObjectController) {
+        "use strict";
+
+        describe("The browse object controller", function () {
+            var mockScope,
+                mockLocation,
+                mockRoute,
+                mockWindow,
+                mockUnlisten,
+                controller;
+
+            // Utility function; look for a $watch on scope and fire it
+            function fireWatch(expr, value) {
+                mockScope.$watch.calls.forEach(function (call) {
+                    if (call.args[0] === expr) {
+                        call.args[1](value);
+                    }
+                });
+            }
+
+            beforeEach(function () {
+                mockScope = jasmine.createSpyObj(
+                    "$scope",
+                    [ "$on", "$watch" ]
+                );
+                mockScope.ngModel = {};
+                mockRoute = { current: { params: {} } };
+                mockWindow = {};
+                mockLocation = jasmine.createSpyObj(
+                    "$location",
+                    [ "path", "search" ]
+                );
+                mockUnlisten = jasmine.createSpy("unlisten");
+
+                mockScope.$on.andReturn(mockUnlisten);
+
+                controller = new BrowseObjectController(
+                    mockScope,
+                    mockLocation,
+                    mockRoute,
+                    mockWindow
+                );
+            });
+
+            it("updates query parameters when selected view changes", function () {
+                fireWatch("representation.selected.key", "xyz");
+                expect(mockLocation.search).toHaveBeenCalledWith('view', "xyz");
+
+                // Allows the path index to be checked
+                // prior to setting $route.current
+                mockLocation.path.andReturn("/browse/");
+                
+                // Exercise the Angular workaround
+                mockScope.$on.mostRecentCall.args[1]();
+                expect(mockUnlisten).toHaveBeenCalled();
+            });
+
+            it("sets the active view from query parameters", function () {
+                var mockDomainObject = jasmine.createSpyObj(
+                        "domainObject",
+                        ['getId', 'getModel', 'getCapability', 'useCapability']
+                    ),
+                    testViews = [
+                        { key: 'abc' },
+                        { key: 'def', someKey: 'some value' },
+                        { key: 'xyz' }
+                    ];
+
+                mockDomainObject.useCapability.andCallFake(function (c) {
+                    return (c === 'view') && testViews;
+                });
+                mockLocation.search.andReturn({ view: 'def' });
+
+                fireWatch('domainObject', mockDomainObject);
+                expect(mockScope.representation.selected)
+                    .toEqual(testViews[1]);
+            });
+            
+            it("sets ngModel properties on initialization", function () {
+                // Left pane open status depends on how the window was opened
+                // Case 1: undefined opener
+                expect(mockWindow.opener).not.toBeDefined();
+                expect(mockScope.ngModel.leftPane).toBeTruthy();
+                
+                // Case 2: defined opener
+                mockWindow.opener = {};
+                controller = new BrowseObjectController(
+                    mockScope,
+                    mockLocation,
+                    mockRoute,
+                    mockWindow
+                );
+                expect(mockScope.ngModel.leftPane).toBeFalsy();
+            });
+        });
+    }
+);

platform/commonUI/browse/test/MenuArrowControllerSpec.js

@@ -0,0 +1,81 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine*/
+
+/**
+ * MenuArrowControllerSpec. Created by shale on 07/02/2015.
+ */
+define(
+    ["../src/MenuArrowController"],
+    function (MenuArrowController) {
+        "use strict";
+        
+        describe("The menu arrow controller ", function () {
+            var mockScope,
+                mockDomainObject,
+                mockEvent,
+                mockContextMenuAction,
+                mockActionContext,
+                controller;
+            
+            beforeEach(function () {
+                mockScope = jasmine.createSpyObj(
+                    "$scope",
+                    [ "" ]
+                );
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getCapability" ]
+                );
+                mockEvent = jasmine.createSpyObj(
+                    "event",
+                    [ "preventDefault" ]
+                );
+                mockContextMenuAction = jasmine.createSpyObj(
+                    "action",
+                    [ "perform", "getActions" ]
+                );
+                mockActionContext = jasmine.createSpyObj(
+                    "actionContext",
+                    [ "" ]
+                );
+                
+                mockActionContext.domainObject = mockDomainObject;
+                mockActionContext.event = mockEvent;
+                mockScope.domainObject = mockDomainObject;
+                mockDomainObject.getCapability.andReturn(mockContextMenuAction);
+                mockContextMenuAction.perform.andReturn(jasmine.any(Function));
+                
+                controller = new MenuArrowController(mockScope);
+            });
+            
+            it("calls the context menu action when clicked", function () {
+                // Simulate a click on the menu arrow
+                controller.showMenu(mockEvent);
+                
+                // Expect the menu action to be performed 
+                expect(mockDomainObject.getCapability).toHaveBeenCalledWith('action');
+                expect(mockContextMenuAction.perform).toHaveBeenCalled();
+            });
+        });
+    }
+);

platform/commonUI/browse/test/creation/CreationServiceSpec.js

@@ -38,6 +38,7 @@ define(
                 mockMutationCapability,
                 mockPersistenceCapability,
                 mockCompositionCapability,
+                mockContextCapability,
                 mockCapabilities,
                 creationService;
 
@@ -87,10 +88,15 @@ define(
                     "composition",
                     ["invoke"]
                 );
+                mockContextCapability = jasmine.createSpyObj(
+                    "context",
+                    ["getPath"]
+                );
                 mockCapabilities = {
                     mutation: mockMutationCapability,
                     persistence: mockPersistenceCapability,
-                    composition: mockCompositionCapability
+                    composition: mockCompositionCapability,
+                    context: mockContextCapability
                 };
 
                 mockPersistenceService.createObject.andReturn(
@@ -103,6 +109,7 @@ define(
                 mockParentObject.useCapability.andCallFake(function (key, value) {
                     return mockCapabilities[key].invoke(value);
                 });
+                mockParentObject.getId.andReturn('parentId');
 
                 mockPersistenceCapability.persist.andReturn(
                     mockPromise(true)
@@ -194,7 +201,16 @@ define(
                 expect(mockLog.error).toHaveBeenCalled();
             });
 
+            it("stores location on new domainObjects", function () {
+                var model = { name: "my model" },
+                    objectPromise = creationService.createObject(
+                        model,
+                        mockParentObject
+                    );
+
+                expect(model.location).toBe('parentId');
+            });
 
         });
     }
-);
+);

platform/commonUI/browse/test/suite.json

@@ -1,5 +1,7 @@
 [
     "BrowseController",
+    "BrowseObjectController",
+    "MenuArrowController",
     "creation/CreateAction",
     "creation/CreateActionProvider",
     "creation/CreateMenuController",
@@ -9,5 +11,6 @@
     "navigation/NavigateAction",
     "navigation/NavigationService",
     "windowing/FullscreenAction",
+    "windowing/NewTabAction",
     "windowing/WindowTitler"
-]
+]

platform/commonUI/browse/test/windowing/NewTabActionSpec.js

@@ -0,0 +1,78 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine,afterEach,window*/
+
+define(
+    ["../../src/windowing/NewTabAction"],
+    function (NewTabAction) {
+        "use strict";
+        
+        describe("The new tab action", function () {
+            var actionSelected,
+                actionCurrent,
+                mockWindow,
+                mockDomainObject,
+                mockContextCurrent,
+                mockContextSelected,
+                mockUrlService;
+
+            beforeEach(function () {
+                mockWindow = jasmine.createSpyObj("$window", ["open", "location"]);
+
+                // Context if the current object is selected
+                // For example, when the top right new tab
+                // button is clicked, the user is using the 
+                // current domainObject
+                mockContextCurrent = jasmine.createSpyObj("context", ["domainObject"]);
+                
+                // Context if the selected object is selected
+                // For example, when an object in the left
+                // tree is opened in a new tab using the
+                // context menu
+                mockContextSelected = jasmine.createSpyObj("context", ["selectedObject",
+                                                               "domainObject"]);
+                
+                // Mocks the urlService used to make the new tab's url from a
+                // domainObject and mode
+                mockUrlService = jasmine.createSpyObj("urlService", ["urlForNewTab"]);
+                
+                // Action done using the current context or mockContextCurrent
+                actionCurrent = new NewTabAction(mockUrlService, mockWindow,
+                                                 mockContextCurrent);
+                
+                // Action done using the selected context or mockContextSelected
+                actionSelected = new NewTabAction(mockUrlService, mockWindow,
+                                                  mockContextSelected);
+                
+            });
+                        
+            it("new tab with current url is opened", function () {
+                actionCurrent.perform();
+            });
+            
+            it("new tab with a selected url is opened", function () {
+                actionSelected.perform();
+            });
+            
+        });
+    }
+);

platform/commonUI/dialog/res/templates/overlay.html

@@ -25,7 +25,7 @@
         <a href=""
            ng-click="ngModel.cancel()"
            ng-if="ngModel.cancel"
-           class="btn normal outline ui-symbol close">
+           class="btn normal ui-symbol close">
             x
         </a>
         <div class="abs contents" ng-transclude>

platform/commonUI/dialog/src/DialogService.js

@@ -22,7 +22,9 @@
 /*global define*/
 
 /**
- * Module defining DialogService. Created by vwoeltje on 11/10/14.
+ * This bundle implements the dialog service, which can be used to
+ * launch dialogs for user input & notifications.
+ * @namespace platform/commonUI/dialog
  */
 define(
     [],
@@ -32,128 +34,130 @@ define(
          * The dialog service is responsible for handling window-modal
          * communication with the user, such as displaying forms for user
          * input.
+         * @memberof platform/commonUI/dialog
          * @constructor
          */
         function DialogService(overlayService, $q, $log) {
-            var overlay,
-                dialogVisible = false;
-
-            // Stop showing whatever overlay is currently active
-            // (e.g. because the user hit cancel)
-            function dismiss() {
-                if (overlay) {
-                    overlay.dismiss();
-                }
-                dialogVisible = false;
-            }
-
-            function getDialogResponse(key, model, resultGetter) {
-                // We will return this result as a promise, because user
-                // input is asynchronous.
-                var deferred = $q.defer(),
-                    overlayModel;
-
-                // Confirm function; this will be passed in to the
-                // overlay-dialog template and associated with a
-                // OK button click
-                function confirm(value) {
-                    // Pass along the result
-                    deferred.resolve(resultGetter ? resultGetter() : value);
-
-                    // Stop showing the dialog
-                    dismiss();
-                }
-
-                // Cancel function; this will be passed in to the
-                // overlay-dialog template and associated with a
-                // Cancel or X button click
-                function cancel() {
-                    deferred.reject();
-                    dismiss();
-                }
-
-                // Add confirm/cancel callbacks
-                model.confirm = confirm;
-                model.cancel = cancel;
-
-                if (dialogVisible) {
-                    // Only one dialog should be shown at a time.
-                    // The application design should be such that
-                    // we never even try to do this.
-                    $log.warn([
-                        "Dialog already showing; ",
-                        "unable to show ",
-                        model.name
-                    ].join(""));
-                    deferred.reject();
-                } else {
-                    // Add the overlay using the OverlayService, which
-                    // will handle actual insertion into the DOM
-                    overlay = overlayService.createOverlay(
-                        key,
-                        model
-                    );
-
-                    // Track that a dialog is already visible, to
-                    // avoid spawning multiple dialogs at once.
-                    dialogVisible = true;
-                }
-
-                return deferred.promise;
-            }
-
-            function getUserInput(formModel, value) {
-                var overlayModel = {
-                        title: formModel.name,
-                        message: formModel.message,
-                        structure: formModel,
-                        value: value
-                    };
-
-                // Provide result from the model
-                function resultGetter() {
-                    return overlayModel.value;
-                }
-
-                // Show the overlay-dialog
-                return getDialogResponse(
-                    "overlay-dialog",
-                    overlayModel,
-                    resultGetter
-                );
-            }
-
-            function getUserChoice(dialogModel) {
-                // Show the overlay-options dialog
-                return getDialogResponse(
-                    "overlay-options",
-                    { dialog: dialogModel }
-                );
-            }
-
-            return {
-                /**
-                 * Request user input via a window-modal dialog.
-                 *
-                 * @param {FormModel} formModel a description of the form
-                 *        to be shown (see platform/forms)
-                 * @param {object} value the initial state of the form
-                 * @returns {Promise} a promsie for the form value that the
-                 *          user has supplied; this may be rejected if
-                 *          user input cannot be obtained (for instance,
-                 *          because the user cancelled the dialog)
-                 */
-                getUserInput: getUserInput,
-                /**
-                 * Request that the user chooses from a set of options,
-                 * which will be shown as buttons.
-                 *
-                 * @param dialogModel a description of the dialog to show
-                 */
-                getUserChoice: getUserChoice
-            };
+            this.overlayService = overlayService;
+            this.$q = $q;
+            this.$log = $log;
+            this.overlay = undefined;
+            this.dialogVisible = false;
         }
 
+        // Stop showing whatever overlay is currently active
+        // (e.g. because the user hit cancel)
+        DialogService.prototype.dismiss = function () {
+            var overlay = this.overlay;
+            if (overlay) {
+                overlay.dismiss();
+            }
+            this.dialogVisible = false;
+        };
+
+        DialogService.prototype.getDialogResponse = function (key, model, resultGetter) {
+            // We will return this result as a promise, because user
+            // input is asynchronous.
+            var deferred = this.$q.defer(),
+                self = this;
+
+            // Confirm function; this will be passed in to the
+            // overlay-dialog template and associated with a
+            // OK button click
+            function confirm(value) {
+                // Pass along the result
+                deferred.resolve(resultGetter ? resultGetter() : value);
+
+                // Stop showing the dialog
+                self.dismiss();
+            }
+
+            // Cancel function; this will be passed in to the
+            // overlay-dialog template and associated with a
+            // Cancel or X button click
+            function cancel() {
+                deferred.reject();
+                self.dismiss();
+            }
+
+            // Add confirm/cancel callbacks
+            model.confirm = confirm;
+            model.cancel = cancel;
+
+            if (this.dialogVisible) {
+                // Only one dialog should be shown at a time.
+                // The application design should be such that
+                // we never even try to do this.
+                this.$log.warn([
+                    "Dialog already showing; ",
+                    "unable to show ",
+                    model.name
+                ].join(""));
+                deferred.reject();
+            } else {
+                // Add the overlay using the OverlayService, which
+                // will handle actual insertion into the DOM
+                this.overlay = this.overlayService.createOverlay(
+                    key,
+                    model
+                );
+
+                // Track that a dialog is already visible, to
+                // avoid spawning multiple dialogs at once.
+                this.dialogVisible = true;
+            }
+
+            return deferred.promise;
+        };
+
+        /**
+         * Request user input via a window-modal dialog.
+         *
+         * @param {FormModel} formModel a description of the form
+         *        to be shown (see platform/forms)
+         * @param {object} value the initial state of the form
+         * @returns {Promise} a promise for the form value that the
+         *          user has supplied; this may be rejected if
+         *          user input cannot be obtained (for instance,
+         *          because the user cancelled the dialog)
+         */
+        DialogService.prototype.getUserInput = function (formModel, value) {
+            var overlayModel = {
+                title: formModel.name,
+                message: formModel.message,
+                structure: formModel,
+                value: value
+            };
+
+            // Provide result from the model
+            function resultGetter() {
+                return overlayModel.value;
+            }
+
+            // Show the overlay-dialog
+            return this.getDialogResponse(
+                "overlay-dialog",
+                overlayModel,
+                resultGetter
+            );
+        };
+
+        /**
+         * Request that the user chooses from a set of options,
+         * which will be shown as buttons.
+         *
+         * @param dialogModel a description of the dialog to show
+         * @return {Promise} a promise for the user's choice
+         */
+        DialogService.prototype.getUserChoice = function (dialogModel) {
+            // Show the overlay-options dialog
+            return this.getDialogResponse(
+                "overlay-options",
+                { dialog: dialogModel }
+            );
+        };
+
+
         return DialogService;
     }
-);
+);

platform/commonUI/dialog/src/OverlayService.js

@@ -43,57 +43,63 @@ define(
          * particularly where a multiple-overlay effect is not specifically
          * desired).
          *
+         * @memberof platform/commonUI/dialog
          * @constructor
          */
         function OverlayService($document, $compile, $rootScope) {
-            function createOverlay(key, overlayModel) {
-                // Create a new scope for this overlay
-                var scope = $rootScope.$new(),
-                    element;
+            this.$compile = $compile;
 
-                // Stop showing the overlay; additionally, release the scope
-                // that it uses.
-                function dismiss() {
-                    scope.$destroy();
-                    element.remove();
-                }
-
-                // If no model is supplied, just fill in a default "cancel"
-                overlayModel = overlayModel || { cancel: dismiss };
-
-                // Populate the scope; will be passed directly to the template
-                scope.overlay = overlayModel;
-                scope.key = key;
-
-                // Create the overlay element and add it to the document's body
-                element = $compile(TEMPLATE)(scope);
-                $document.find('body').prepend(element);
-
-
-
-                return {
-                    dismiss: dismiss
-                };
-            }
-
-            return {
-                /**
-                 * Add a new overlay to the document. This will be
-                 * prepended to the document body; the overlay's
-                 * template (as pointed to by the `key` argument) is
-                 * responsible for having a useful z-order, and for
-                 * blocking user interactions if appropriate.
-                 *
-                 * @param {string} key the symbolic key which identifies
-                 *        the template of the overlay to be shown
-                 * @param {object} overlayModel the model to pass to the
-                 *        included overlay template (this will be passed
-                 *        in via ng-model)
-                 */
-                createOverlay: createOverlay
+            // Don't include $document and $rootScope directly;
+            // avoids https://docs.angularjs.org/error/ng/cpws
+            this.findBody = function () {
+                return $document.find('body');
+            };
+            this.newScope = function () {
+                return $rootScope.$new();
             };
         }
 
+        /**
+         * Add a new overlay to the document. This will be
+         * prepended to the document body; the overlay's
+         * template (as pointed to by the `key` argument) is
+         * responsible for having a useful z-order, and for
+         * blocking user interactions if appropriate.
+         *
+         * @param {string} key the symbolic key which identifies
+         *        the template of the overlay to be shown
+         * @param {object} overlayModel the model to pass to the
+         *        included overlay template (this will be passed
+         *        in via ng-model)
+         */
+        OverlayService.prototype.createOverlay = function (key, overlayModel) {
+            // Create a new scope for this overlay
+            var scope = this.newScope(),
+                element;
+
+            // Stop showing the overlay; additionally, release the scope
+            // that it uses.
+            function dismiss() {
+                scope.$destroy();
+                element.remove();
+            }
+
+            // If no model is supplied, just fill in a default "cancel"
+            overlayModel = overlayModel || { cancel: dismiss };
+
+            // Populate the scope; will be passed directly to the template
+            scope.overlay = overlayModel;
+            scope.key = key;
+
+            // Create the overlay element and add it to the document's body
+            element = this.$compile(TEMPLATE)(scope);
+            this.findBody().prepend(element);
+
+            return {
+                dismiss: dismiss
+            };
+        };
+
         return OverlayService;
     }
-);
+);

platform/commonUI/edit/bundle.json

@@ -59,7 +59,7 @@
                 "glyph": "Z",
                 "name": "Remove",
                 "description": "Remove this object from its containing object.",
-                "depends": [ "$q" ]
+                "depends": [ "$q", "navigationService" ]
             },
             {
                 "key": "save",
@@ -67,7 +67,7 @@
                 "implementation": "actions/SaveAction.js",
                 "name": "Save",
                 "description": "Save changes made to these objects.",
-                "depends": [ "$location" ],
+                "depends": [ "$location", "urlService" ],
                 "priority": "mandatory"
             },
             {
@@ -76,7 +76,7 @@
                 "implementation": "actions/CancelAction.js",
                 "name": "Cancel",
                 "description": "Discard changes made to these objects.",
-                "depends": [ "$location" ]
+                "depends": [ "$location", "urlService" ]
             }
         ],
         "policies": [
@@ -116,7 +116,7 @@
                 "key": "topbar-edit",
                 "templateUrl": "templates/topbar-edit.html"
             }
-        ],
+        ],     
         "representers": [
             {
                 "implementation": "representers/EditRepresenter.js",

platform/commonUI/edit/res/templates/edit-object.html

@@ -21,76 +21,71 @@
 -->
 <mct-representation key="'topbar-edit'"
                     mct-object="domainObject"
-                    ng-model="representation">
+                    ng-model="representation"
+                    ng-click="ngModel.inspectionObjects = [domainObject]">
 </mct-representation>
-<div class="holder edit-area abs"
-     ng-controller="SplitPaneController as vSplitter">
-    <mct-toolbar name="mctToolbar"
-                 structure="toolbar.structure"
-                 ng-model="toolbar.state">
-    </mct-toolbar>
-    <div class='split-layout vertical contents abs work-area'>
-        <div
-            class='abs pane left edit-main'
-            ng-style="{ right: (vSplitter.state()+5) + 'px'}"
-            >
-            <div class='holder abs object-holder'>
-                <mct-representation key="representation.selected.key"
-                                    toolbar="toolbar"
-                                    mct-object="representation.selected.key && domainObject">
+<div class="holder edit-area abs">
+    <mct-split-pane class='contents abs'
+                    anchor='right'>
+        <div class='split-pane-component secondary-split pane left'>
+            <mct-split-pane class='contents abs' anchor='right'>
+                <div class='split-pane-component pane left edit-main'>
+                    <mct-toolbar name="mctToolbar"
+                                 structure="toolbar.structure"
+                                 ng-model="toolbar.state">
+                    </mct-toolbar>
+                    <div class='holder abs object-holder work-area'>
+                        <mct-representation key="representation.selected.key"
+                                            toolbar="toolbar"
+                                            mct-object="representation.selected.key && domainObject"
+                                            ng-model="ngModel">
+                        </mct-representation>
+                    </div>
+                </div>
+                <mct-splitter></mct-splitter>
+                <div
+                    class='split-pane-component pane right edit-objects menus-to-left'
+                    ng-controller='EditPanesController as editPanes'
+                    >
+                    <mct-split-pane class='contents abs' anchor='bottom'>
+                        <div
+                            class="abs pane top accordion"
+                            ng-controller="ToggleController as toggle"
+                            >
+                            <mct-container key="accordion" label="Library">
+                                <mct-representation key="'tree'"
+                                                    mct-object="editPanes.getRoot()"
+                                                    ng-model="ngModel">
+                                </mct-representation>
+                            </mct-container>
+                        </div>
+                        <mct-splitter></mct-splitter>
+                        <div
+                            class="abs pane bottom accordion"
+                            ng-controller="ToggleController as toggle"
+                            >
+                            <mct-container key="accordion" label="Elements">
+                                <mct-representation key="'edit-elements'"
+                                                    mct-object="domainObject"
+                                                    ng-model="ngModel">
+                                </mct-representation>
+                            </mct-container>
+                        </div>
+                    </mct-split-pane>
+                </div>
+            </mct-split-pane>
+        </div>
+        
+        <mct-splitter></mct-splitter>
+        
+        <div class='split-pane-component object-inspector pane right'
+             ng-class='{inactive: !paneModel.rightPane}'>
+            <div class='holder inspector-holder abs'>
+                <mct-representation key="'object-inspector'"
+                                    mct-object="editPanes.getRoot()"
+                                    ng-model="ngModel">
                 </mct-representation>
             </div>
         </div>
-
-        <!-- MAIN VERTICAL SPLITTER -->
-        <div
-            class="splitter"
-            ng-style="{ right: vSplitter.state() + 'px'}"
-            mct-drag-down="vSplitter.startMove()"
-            mct-drag="vSplitter.move(-delta[0], 100, 1000)"
-            ></div>
-
-
-        <div
-            class='abs pane right edit-objects menus-to-left'
-            ng-controller='EditPanesController as editPanes'
-            ng-style="{ width: (vSplitter.state()-4) + 'px', right: '0px'}"
-            >
-            <div
-                class='holder abs split-layout horizontal'
-                ng-controller="SplitPaneController as hSplitter"
-                >
-	            <div
-                    class="abs pane top accordion"
-                    ng-style="{ bottom: (hSplitter.state()+8) + 'px', top: '0px' }"
-                    ng-controller="ToggleController as toggle"
-                    >
-                    <mct-container key="accordion" title="Library">
-                        <mct-representation key="'tree'"
-                                            alias="foo1"
-                                            mct-object="editPanes.getRoot()">
-                        </mct-representation>
-                    </mct-container>
-		        </div>
-                <!-- HORZ SPLITTER -->
-                <div
-                        class="splitter"
-                        ng-style="{ bottom: hSplitter.state() + 'px', top: 'auto' }"
-                        mct-drag-down="hSplitter.startMove()"
-                        mct-drag="hSplitter.move(-delta[1], 120, 1000)"
-                        >
-                </div>
-	            <div
-                    class="abs pane bottom accordion"
-                    ng-style="{ bottom: '0px', height: (hSplitter.state()-4) + 'px'}"
-                    ng-controller="ToggleController as toggle"
-                    >
-                    <mct-container key="accordion" title="Elements">
-                        <mct-representation key="'edit-elements'" mct-object="domainObject">
-                        </mct-representation>
-                    </mct-container>
-				</div>
-            </div>
-        </div>
-    </div>
+    </mct-split-pane>
 </div>

platform/commonUI/edit/res/templates/edit.html

@@ -24,7 +24,9 @@
      ng-controller="EditController as editMode"
      mct-before-unload="editMode.getUnloadWarning()">
 
-    <mct-representation key="'edit-object'" mct-object="editMode.navigatedObject()">
+    <mct-representation key="'edit-object'"
+                        mct-object="editMode.navigatedObject()"
+                        ng-model="editModel">
     </mct-representation>
 
     <mct-include key="'bottombar'"></mct-include>

platform/commonUI/edit/res/templates/elements.html

@@ -24,7 +24,9 @@
     <ul class="tree">
         <li ng-repeat="containedObject in composition">
             <span class="tree-item">
-                <mct-representation key="'label'" mct-object="containedObject">
+                <mct-representation key="'label'"
+                                    mct-object="containedObject"
+                                    ng-click="ngModel.inspectionObjects = [containedObject]">
                 </mct-representation>
             </span>
         </li>

platform/commonUI/edit/res/templates/topbar-edit.html

@@ -33,8 +33,6 @@
         <mct-representation key="'edit-action-buttons'"
                             mct-object="domainObject"
                             class='conclude-editing'>
-		<!--a class='btn major' href=''>Save<span id='save-actions-menu' class='ui-symbol invoke-menu'>v</span></a>
-		<a class='btn subtle' href=''>Cancel</a-->
         </mct-representation>
     </div>
 </div>

platform/commonUI/edit/src/actions/CancelAction.js

@@ -29,9 +29,26 @@ define(
          * The "Cancel" action; the action triggered by clicking Cancel from
          * Edit Mode. Exits the editing user interface and invokes object
          * capabilities to persist the changes that have been made.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {Action}
          */
-        function CancelAction($location, context) {
-            var domainObject = context.domainObject;
+        function CancelAction($location, urlService, context) {
+            this.domainObject = context.domainObject;
+            this.$location = $location;
+            this.urlService = urlService;
+        }
+
+        /**
+         * Cancel editing.
+         *
+         * @returns {Promise} a promise that will be fulfilled when
+         *          cancellation has completed
+         */
+        CancelAction.prototype.perform = function () {
+            var domainObject = this.domainObject,
+                $location = this.$location,
+                urlService = this.urlService;
 
             // Look up the object's "editor.completion" capability;
             // this is introduced by EditableDomainObject which is
@@ -50,28 +67,21 @@ define(
             // Discard the current root view (which will be the editing
             // UI, which will have been pushed atop the Browise UI.)
             function returnToBrowse() {
-                $location.path("/browse");
+                $location.path($location.path(urlService.urlForLocation(
+                    "browse",
+                    domainObject
+                )));
             }
 
-            return {
-                /**
-                 * Cancel editing.
-                 *
-                 * @returns {Promise} a promise that will be fulfilled when
-                 *          cancellation has completed
-                 */
-                perform: function () {
-                    return doCancel(getEditorCapability())
-                        .then(returnToBrowse);
-                }
-            };
-        }
+            return doCancel(getEditorCapability())
+                .then(returnToBrowse);
+        };
 
         /**
          * Check if this action is applicable in a given context.
          * This will ensure that a domain object is present in the context,
          * and that this domain object is in Edit mode.
-         * @returns true if applicable
+         * @returns {boolean} true if applicable
          */
         CancelAction.appliesTo = function (context) {
             var domainObject = (context || {}).domainObject;
@@ -81,4 +91,4 @@ define(
 
         return CancelAction;
     }
-);
+);

platform/commonUI/edit/src/actions/EditAction.js

@@ -42,7 +42,9 @@ define(
          * mode (typically triggered by the Edit button.) This will
          * show the user interface for editing (by way of a change in
          * route)
+         * @memberof platform/commonUI/edit
          * @constructor
+         * @implements {Action}
          */
         function EditAction($location, navigationService, $log, context) {
             var domainObject = (context || {}).domainObject;
@@ -60,17 +62,19 @@ define(
                 return NULL_ACTION;
             }
 
-            return {
-                /**
-                 * Enter edit mode.
-                 */
-                perform: function () {
-                    navigationService.setNavigation(domainObject);
-                    $location.path("/edit");
-                }
-            };
+            this.domainObject = domainObject;
+            this.$location = $location;
+            this.navigationService = navigationService;
         }
 
+        /**
+         * Enter edit mode.
+         */
+        EditAction.prototype.perform = function () {
+            this.navigationService.setNavigation(this.domainObject);
+            this.$location.path("/edit");
+        };
+
         /**
          * Check for applicability; verify that a domain object is present
          * for this action to be performed upon.
@@ -87,4 +91,4 @@ define(
 
         return EditAction;
     }
-);
+);

platform/commonUI/edit/src/actions/LinkAction.js

@@ -29,42 +29,43 @@ define(
 
         /**
          * Add one domain object to another's composition.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {Action}
          */
         function LinkAction(context) {
-            var domainObject = (context || {}).domainObject,
-                selectedObject = (context || {}).selectedObject,
-                selectedId = selectedObject && selectedObject.getId();
+            this.domainObject = (context || {}).domainObject;
+            this.selectedObject = (context || {}).selectedObject;
+            this.selectedId = this.selectedObject && this.selectedObject.getId();
+        }
+
+        LinkAction.prototype.perform = function () {
+            var self = this;
 
             // Add this domain object's identifier
             function addId(model) {
                 if (Array.isArray(model.composition) &&
-                        model.composition.indexOf(selectedId) < 0) {
-                    model.composition.push(selectedId);
+                    model.composition.indexOf(self.selectedId) < 0) {
+                    model.composition.push(self.selectedId);
                 }
             }
 
             // Persist changes to the domain object
             function doPersist() {
-                var persistence = domainObject.getCapability('persistence');
+                var persistence =
+                    self.domainObject.getCapability('persistence');
                 return persistence.persist();
             }
 
             // Link these objects
             function doLink() {
-                return domainObject.useCapability("mutation", addId)
+                return self.domainObject.useCapability("mutation", addId)
                     .then(doPersist);
             }
 
-            return {
-                /**
-                 * Perform this action.
-                 */
-                perform: function () {
-                    return selectedId && doLink();
-                }
-            };
-        }
+            return this.selectedId && doLink();
+        };
 
         return LinkAction;
     }
-);
+);

platform/commonUI/edit/src/actions/PropertiesAction.js

@@ -32,58 +32,58 @@ define(
         'use strict';
 
         /**
-         * Construct an action which will allow an object's metadata to be
-         * edited.
+         * Implements the "Edit Properties" action, which prompts the user
+         * to modify a domain object's properties.
          *
          * @param {DialogService} dialogService a service which will show the dialog
          * @param {DomainObject} object the object to be edited
          * @param {ActionContext} context the context in which this action is performed
+         * @memberof platform/commonUI/edit
+         * @implements {Action}
          * @constructor
          */
         function PropertiesAction(dialogService, context) {
-            var object = context.domainObject;
+            this.domainObject = (context || {}).domainObject;
+            this.dialogService = dialogService;
+        }
+
+        PropertiesAction.prototype.perform = function () {
+            var type = this.domainObject.getCapability('type'),
+                domainObject = this.domainObject,
+                dialogService = this.dialogService;
 
             // Persist modifications to this domain object
             function doPersist() {
-                var persistence = object.getCapability('persistence');
+                var persistence = domainObject.getCapability('persistence');
                 return persistence && persistence.persist();
             }
 
             // Update the domain object model based on user input
             function updateModel(userInput, dialog) {
-                return object.useCapability('mutation', function (model) {
+                return domainObject.useCapability('mutation', function (model) {
                     dialog.updateModel(model, userInput);
                 });
             }
 
             function showDialog(type) {
                 // Create a dialog object to generate the form structure, etc.
-                var dialog = new PropertiesDialog(type, object.getModel());
+                var dialog =
+                    new PropertiesDialog(type, domainObject.getModel());
 
                 // Show the dialog
                 return dialogService.getUserInput(
                     dialog.getFormStructure(),
                     dialog.getInitialFormValue()
                 ).then(function (userInput) {
-                    // Update the model, if user input was provided
-                    return userInput && updateModel(userInput, dialog);
-                }).then(function (result) {
-                    return result && doPersist();
-                });
+                        // Update the model, if user input was provided
+                        return userInput && updateModel(userInput, dialog);
+                    }).then(function (result) {
+                        return result && doPersist();
+                    });
             }
 
-            return {
-                /**
-                 * Perform this action.
-                 * @return {Promise} a promise which will be
-                 *         fulfilled when the action has completed.
-                 */
-                perform: function () {
-                    var type = object.getCapability('type');
-                    return type && showDialog(type);
-                }
-            };
-        }
+            return type && showDialog(type);
+        };
 
         /**
          * Filter this action for applicability against a given context.
@@ -106,3 +106,4 @@ define(
 
 );
 
+

platform/commonUI/edit/src/actions/PropertiesDialog.js

@@ -21,12 +21,6 @@
  *****************************************************************************/
 /*global define*/
 
-/**
- * Defines the PropertiesDialog, used by the PropertiesAction to
- * populate the form shown in dialog based on the created type.
- *
- * @module common/actions/properties-dialog
- */
 define(
     function () {
         'use strict';
@@ -37,58 +31,60 @@ define(
          * @param {TypeImpl} type the type of domain object for which properties
          *        will be specified
          * @param {DomainObject} the object for which properties will be set
+         * @memberof platform/commonUI/edit
          * @constructor
-         * @memberof module:common/actions/properties-dialog
          */
         function PropertiesDialog(type, model) {
-            var properties = type.getProperties();
-
-            return {
-                /**
-                 * Get sections provided by this dialog.
-                 * @return {FormStructure} the structure of this form
-                 */
-                getFormStructure: function () {
-                    return {
-                        name: "Edit " + model.name,
-                        sections: [{
-                            name: "Properties",
-                            rows: properties.map(function (property, index) {
-                                // Property definition is same as form row definition
-                                var row = Object.create(property.getDefinition());
-                                row.key = index;
-                                return row;
-                            })
-                        }]
-                    };
-                },
-                /**
-                 * Get the initial state of the form shown by this dialog
-                 * (based on the object model)
-                 * @returns {object} initial state of the form
-                 */
-                getInitialFormValue: function () {
-                    // Start with initial values for properties
-                    // Note that index needs to correlate to row.key
-                    // from getFormStructure
-                    return properties.map(function (property) {
-                        return property.getValue(model);
-                    });
-                },
-                /**
-                 * Update a domain object model based on the value of a form.
-                 */
-                updateModel: function (model, formValue) {
-                    // Update all properties
-                    properties.forEach(function (property, index) {
-                        property.setValue(model, formValue[index]);
-                    });
-                }
-            };
-
-
+            this.type = type;
+            this.model = model;
+            this.properties = type.getProperties();
         }
 
+        /**
+         * Get sections provided by this dialog.
+         * @return {FormStructure} the structure of this form
+         */
+        PropertiesDialog.prototype.getFormStructure = function () {
+            return {
+                name: "Edit " + this.model.name,
+                sections: [{
+                    name: "Properties",
+                    rows: this.properties.map(function (property, index) {
+                        // Property definition is same as form row definition
+                        var row = Object.create(property.getDefinition());
+                        row.key = index;
+                        return row;
+                    })
+                }]
+            };
+        };
+
+        /**
+         * Get the initial state of the form shown by this dialog
+         * (based on the object model)
+         * @returns {object} initial state of the form
+         */
+        PropertiesDialog.prototype.getInitialFormValue = function () {
+            var model = this.model;
+
+            // Start with initial values for properties
+            // Note that index needs to correlate to row.key
+            // from getFormStructure
+            return this.properties.map(function (property) {
+                return property.getValue(model);
+            });
+        };
+
+        /**
+         * Update a domain object model based on the value of a form.
+         */
+        PropertiesDialog.prototype.updateModel = function (model, formValue) {
+            // Update all properties
+            this.properties.forEach(function (property, index) {
+                property.setValue(model, formValue[index]);
+            });
+        };
+
         return PropertiesDialog;
     }
-);
+);

platform/commonUI/edit/src/actions/RemoveAction.js

@@ -37,22 +37,35 @@ define(
          *
          * @param {DomainObject} object the object to be removed
          * @param {ActionContext} context the context in which this action is performed
+         * @memberof platform/commonUI/edit
          * @constructor
-         * @memberof module:editor/actions/remove-action
+         * @implements {Action}
          */
-        function RemoveAction($q, context) {
-            var object = (context || {}).domainObject;
+        function RemoveAction($q, navigationService, context) {
+            this.domainObject = (context || {}).domainObject;
+            this.$q = $q;
+            this.navigationService = navigationService;
+        }
 
-            /**
+        /**
+         * Perform this action.
+         * @return {Promise} a promise which will be
+         *         fulfilled when the action has completed.
+         */
+        RemoveAction.prototype.perform = function () {
+            var $q = this.$q,
+                navigationService = this.navigationService,
+                domainObject = this.domainObject;
+            /*
              * Check whether an object ID matches the ID of the object being
              * removed (used to filter a parent's composition to handle the
              * removal.)
              */
             function isNotObject(otherObjectId) {
-                return otherObjectId !== object.getId();
+                return otherObjectId !== domainObject.getId();
             }
 
-            /**
+            /*
              * Mutate a parent object such that it no longer contains the object
              * which is being removed.
              */
@@ -60,7 +73,7 @@ define(
                 model.composition = model.composition.filter(isNotObject);
             }
 
-            /**
+            /*
              * Invoke persistence on a domain object. This will be called upon
              * the removed object's parent (as its composition will have changed.)
              */
@@ -68,34 +81,55 @@ define(
                 var persistence = domainObject.getCapability('persistence');
                 return persistence && persistence.persist();
             }
-
-            /**
-             * Remove the object from its parent, as identified by its context
-             * capability.
-             * @param {ContextCapability} contextCapability the "context" capability
-             *        of the domain object being removed.
+            
+            /*
+             * Checks current object and ascendants of current
+             * object with object being removed, if the current
+             * object or any in the current object's path is being removed,
+             * navigate back to parent of removed object.
              */
-            function removeFromContext(contextCapability) {
-                var parent = contextCapability.getParent();
-                $q.when(
+            function checkObjectNavigation(object, parentObject) {
+                // Traverse object starts at current location
+                var traverseObject = (navigationService).getNavigation();
+                
+                // Stop when object is not defined (above ROOT)
+                while (traverseObject) {
+                    
+                    // If object currently traversed to is object being removed
+                    // navigate to parent of current object and then exit loop
+                    if (traverseObject.getId() === object.getId()) {
+                        navigationService.setNavigation(parentObject);
+                        return;
+                    }
+                    // Traverses to parent of current object, moving
+                    // up the ascendant path
+                    traverseObject = traverseObject.getCapability('context').getParent();
+                }
+            }
+
+            /*
+             * Remove the object from its parent, as identified by its context
+             * capability. Based on object's location and selected object's location
+             * user may be navigated to existing parent object
+             */
+            function removeFromContext(object) {
+                var contextCapability = object.getCapability('context'),
+                    parent = contextCapability.getParent();
+                
+                // If currently within path of removed object(s),
+                // navigates to existing object up tree
+                checkObjectNavigation(object, parent);
+                
+                return $q.when(
                     parent.useCapability('mutation', doMutate)
                 ).then(function () {
                     return doPersist(parent);
                 });
             }
 
-            return {
-                /**
-                 * Perform this action.
-                 * @return {module:core/promises.Promise} a promise which will be
-                 *         fulfilled when the action has completed.
-                 */
-                perform: function () {
-                    return $q.when(object.getCapability('context'))
-                        .then(removeFromContext);
-                }
-            };
-        }
+            return $q.when(domainObject)
+                .then(removeFromContext);
+        };
 
         // Object needs to have a parent for Remove to be applicable
         RemoveAction.appliesTo = function (context) {
@@ -113,4 +147,4 @@ define(
 
         return RemoveAction;
     }
-);
+);

platform/commonUI/edit/src/actions/SaveAction.js

@@ -30,9 +30,27 @@ define(
          * The "Save" action; the action triggered by clicking Save from
          * Edit Mode. Exits the editing user interface and invokes object
          * capabilities to persist the changes that have been made.
+         * @constructor
+         * @implements {Action}
+         * @memberof platform/commonUI/edit
          */
-        function SaveAction($location, context) {
-            var domainObject = context.domainObject;
+        function SaveAction($location, urlService, context) {
+            this.domainObject = (context || {}).domainObject;
+            this.$location = $location;
+            this.urlService = urlService;
+        }
+
+        /**
+         * Save changes and conclude editing.
+         *
+         * @returns {Promise} a promise that will be fulfilled when
+         *          cancellation has completed
+         * @memberof platform/commonUI/edit.SaveAction#
+         */
+        SaveAction.prototype.perform = function () {
+            var domainObject = this.domainObject,
+                $location = this.$location,
+                urlService = this.urlService;
 
             // Invoke any save behavior introduced by the editor capability;
             // this is introduced by EditableDomainObject which is
@@ -45,21 +63,14 @@ define(
             // Discard the current root view (which will be the editing
             // UI, which will have been pushed atop the Browise UI.)
             function returnToBrowse() {
-                return $location.path("/browse");
+                return $location.path(urlService.urlForLocation(
+                    "browse",
+                    domainObject
+                ));
             }
 
-            return {
-                /**
-                 * Save changes and conclude editing.
-                 *
-                 * @returns {Promise} a promise that will be fulfilled when
-                 *          cancellation has completed
-                 */
-                perform: function () {
-                    return doSave().then(returnToBrowse);
-                }
-            };
-        }
+            return doSave().then(returnToBrowse);
+        };
 
         /**
          * Check if this action is applicable in a given context.
@@ -75,4 +86,4 @@ define(
 
         return SaveAction;
     }
-);
+);

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

@@ -35,6 +35,9 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {CompositionCapability}
          */
         return function EditableCompositionCapability(
             contextCapability,
@@ -54,4 +57,4 @@ define(
             );
         };
     }
-);
+);

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

@@ -35,6 +35,9 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {ContextCapability}
          */
         return function EditableContextCapability(
             contextCapability,
@@ -72,4 +75,4 @@ define(
             return capability;
         };
     }
-);
+);

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

@@ -35,6 +35,8 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
          */
         return function EditableLookupCapability(
             contextCapability,
@@ -76,7 +78,7 @@ define(
             // Wrap a returned value (see above); if it's a promise, wrap
             // the resolved value.
             function wrapResult(result) {
-                return result.then ? // promise-like
+                return (result && result.then) ? // promise-like
                         result.then(makeEditable) :
                         makeEditable(result);
             }
@@ -105,8 +107,10 @@ define(
 
             // Wrap a method of this capability
             function wrapMethod(fn) {
-                capability[fn] =
-                    (idempotent ? oneTimeFunction : wrapFunction)(fn);
+                if (typeof capability[fn] === 'function') {
+                    capability[fn] =
+                        (idempotent ? oneTimeFunction : wrapFunction)(fn);
+                }
             }
 
             // Wrap all methods; return only editable domain objects.
@@ -115,4 +119,4 @@ define(
             return capability;
         };
     }
-);
+);

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

@@ -35,6 +35,9 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {PersistenceCapability}
          */
         function EditablePersistenceCapability(
             persistenceCapability,
@@ -62,4 +65,4 @@ define(
 
         return EditablePersistenceCapability;
     }
-);
+);

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

@@ -35,6 +35,9 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {RelationshipCapability}
          */
         return function EditableRelationshipCapability(
             relationshipCapability,
@@ -54,4 +57,4 @@ define(
             );
         };
     }
-);
+);

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

@@ -39,27 +39,48 @@ define(
          * Meant specifically for use by EditableDomainObject and the
          * associated cache; the constructor signature is particular
          * to a pattern used there and may contain unused arguments.
+         * @constructor
+         * @memberof platform/commonUI/edit
          */
-        return function EditorCapability(
+        function EditorCapability(
             persistenceCapability,
             editableObject,
             domainObject,
             cache
         ) {
+            this.editableObject = editableObject;
+            this.domainObject = domainObject;
+            this.cache = cache;
+        }
 
-            // Simulate Promise.resolve (or $q.when); the former
-            // causes a delayed reaction from Angular (since it
-            // does not trigger a digest) and the latter is not
-            // readily accessible, since we're a few classes
-            // removed from the layer which gets dependency
-            // injection.
-            function resolvePromise(value) {
-                return (value && value.then) ? value : {
-                    then: function (callback) {
-                        return resolvePromise(callback(value));
-                    }
-                };
-            }
+        // Simulate Promise.resolve (or $q.when); the former
+        // causes a delayed reaction from Angular (since it
+        // does not trigger a digest) and the latter is not
+        // readily accessible, since we're a few classes
+        // removed from the layer which gets dependency
+        // injection.
+        function resolvePromise(value) {
+            return (value && value.then) ? value : {
+                then: function (callback) {
+                    return resolvePromise(callback(value));
+                }
+            };
+        }
+
+        /**
+         * Save any changes that have been made to this domain object
+         * (as well as to others that might have been retrieved and
+         * modified during the editing session)
+         * @param {boolean} nonrecursive if true, save only this
+         *        object (and not other objects with associated changes)
+         * @returns {Promise} a promise that will be fulfilled after
+         *          persistence has completed.
+         * @memberof platform/commonUI/edit.EditorCapability#
+         */
+        EditorCapability.prototype.save = function (nonrecursive) {
+            var domainObject = this.domainObject,
+                editableObject = this.editableObject,
+                cache = this.cache;
 
             // Update the underlying, "real" domain object's model
             // with changes made to the copy used for editing.
@@ -74,39 +95,32 @@ define(
                 return domainObject.getCapability('persistence').persist();
             }
 
-            return {
-                /**
-                 * Save any changes that have been made to this domain object
-                 * (as well as to others that might have been retrieved and
-                 * modified during the editing session)
-                 * @param {boolean} nonrecursive if true, save only this
-                 *        object (and not other objects with associated changes)
-                 * @returns {Promise} a promise that will be fulfilled after
-                 *          persistence has completed.
-                 */
-                save: function (nonrecursive) {
-                    return nonrecursive ?
-                            resolvePromise(doMutate()).then(doPersist) :
-                            resolvePromise(cache.saveAll());
-                },
-                /**
-                 * Cancel editing; Discard any changes that have been made to
-                 * this domain object (as well as to others that might have
-                 * been retrieved and modified during the editing session)
-                 * @returns {Promise} a promise that will be fulfilled after
-                 *          cancellation has completed.
-                 */
-                cancel: function () {
-                    return resolvePromise(undefined);
-                },
-                /**
-                 * Check if there are any unsaved changes.
-                 * @returns {boolean} true if there are unsaved changes
-                 */
-                dirty: function () {
-                    return cache.dirty();
-                }
-            };
+            return nonrecursive ?
+                resolvePromise(doMutate()).then(doPersist) :
+                resolvePromise(cache.saveAll());
         };
+
+        /**
+         * Cancel editing; Discard any changes that have been made to
+         * this domain object (as well as to others that might have
+         * been retrieved and modified during the editing session)
+         * @returns {Promise} a promise that will be fulfilled after
+         *          cancellation has completed.
+         * @memberof platform/commonUI/edit.EditorCapability#
+         */
+        EditorCapability.prototype.cancel = function () {
+            return resolvePromise(undefined);
+        };
+
+        /**
+         * Check if there are any unsaved changes.
+         * @returns {boolean} true if there are unsaved changes
+         * @memberof platform/commonUI/edit.EditorCapability#
+         */
+        EditorCapability.prototype.dirty = function () {
+            return this.cache.dirty();
+        };
+
+        return EditorCapability;
     }
-);
+);

platform/commonUI/edit/src/controllers/EditActionController.js

@@ -33,6 +33,7 @@ define(
 
         /**
          * Controller which supplies action instances for Save/Cancel.
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditActionController($scope) {
@@ -51,4 +52,4 @@ define(
 
         return EditActionController;
     }
-);
+);

platform/commonUI/edit/src/controllers/EditController.js

@@ -22,7 +22,8 @@
 /*global define,Promise*/
 
 /**
- * Module defining EditController. Created by vwoeltje on 11/14/14.
+ * This bundle implements Edit mode.
+ * @namespace platform/commonUI/edit
  */
 define(
     ["../objects/EditableDomainObject"],
@@ -33,15 +34,16 @@ define(
          * Controller which is responsible for populating the scope for
          * Edit mode; introduces an editable version of the currently
          * navigated domain object into the scope.
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditController($scope, $q, navigationService) {
-            var navigatedObject;
+            var self = this;
 
             function setNavigation(domainObject) {
                 // Wrap the domain object such that all mutation is
                 // confined to edit mode (until Save)
-                navigatedObject =
+                self.navigatedDomainObject =
                     domainObject && new EditableDomainObject(domainObject, $q);
             }
 
@@ -50,33 +52,39 @@ define(
             $scope.$on("$destroy", function () {
                 navigationService.removeListener(setNavigation);
             });
-
-            return {
-                /**
-                 * Get the domain object which is navigated-to.
-                 * @returns {DomainObject} the domain object that is navigated-to
-                 */
-                navigatedObject: function () {
-                    return navigatedObject;
-                },
-                /**
-                 * Get the warning to show if the user attempts to navigate
-                 * away from Edit mode while unsaved changes are present.
-                 * @returns {string} the warning to show, or undefined if
-                 *          there are no unsaved changes
-                 */
-                getUnloadWarning: function () {
-                    var editorCapability = navigatedObject &&
-                            navigatedObject.getCapability("editor"),
-                        hasChanges = editorCapability && editorCapability.dirty();
-
-                    return hasChanges ?
-                            "Unsaved changes will be lost if you leave this page." :
-                            undefined;
-                }
+            
+            // Provide a model for edit mode
+            $scope.editModel = {
+                selectedObject: navigationService.getNavigation()
             };
+            $scope.editModel.inspectionObjects = [$scope.editModel.selectedObject];
         }
 
+        /**
+         * Get the domain object which is navigated-to.
+         * @returns {DomainObject} the domain object that is navigated-to
+         */
+        EditController.prototype.navigatedObject = function () {
+            return this.navigatedDomainObject;
+        };
+
+        /**
+         * Get the warning to show if the user attempts to navigate
+         * away from Edit mode while unsaved changes are present.
+         * @returns {string} the warning to show, or undefined if
+         *          there are no unsaved changes
+         */
+        EditController.prototype.getUnloadWarning = function () {
+            var navigatedObject = this.navigatedDomainObject,
+                editorCapability = navigatedObject &&
+                    navigatedObject.getCapability("editor"),
+                hasChanges = editorCapability && editorCapability.dirty();
+
+            return hasChanges ?
+                "Unsaved changes will be lost if you leave this page." :
+                undefined;
+        };
+
         return EditController;
     }
-);
+);

platform/commonUI/edit/src/controllers/EditPanesController.js

@@ -28,15 +28,17 @@ define(
 
         /**
          * Supports the Library and Elements panes in Edit mode.
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditPanesController($scope) {
-            var root;
+            var self = this;
 
             // Update root object based on represented object
             function updateRoot(domainObject) {
-                var context = domainObject &&
-                    domainObject.getCapability('context'),
+                var root = self.rootDomainObject,
+                    context = domainObject &&
+                        domainObject.getCapability('context'),
                     newRoot = context && context.getTrueRoot(),
                     oldId = root && root.getId(),
                     newId = newRoot && newRoot.getId();
@@ -44,25 +46,22 @@ define(
                 // Only update if this has actually changed,
                 // to avoid excessive refreshing.
                 if (oldId !== newId) {
-                    root = newRoot;
+                    self.rootDomainObject = newRoot;
                 }
             }
 
             // Update root when represented object changes
             $scope.$watch('domainObject', updateRoot);
-
-            return {
-                /**
-                 * Get the root-level domain object, as reported by the
-                 * represented domain object.
-                 * @returns {DomainObject} the root object
-                 */
-                getRoot: function () {
-                    return root;
-                }
-            };
         }
+        /**
+         * Get the root-level domain object, as reported by the
+         * represented domain object.
+         * @returns {DomainObject} the root object
+         */
+        EditPanesController.prototype.getRoot = function () {
+            return this.rootDomainObject;
+        };
 
         return EditPanesController;
     }
-);
+);

platform/commonUI/edit/src/directives/MCTBeforeUnload.js

@@ -31,6 +31,7 @@ define(
          * to this attribute will be evaluated during page navigation events
          * and, if it returns a truthy value, will be used to populate a
          * prompt to the user to confirm this navigation.
+         * @memberof platform/commonUI/edit
          * @constructor
          * @param $window the window
          */
@@ -102,4 +103,4 @@ define(
         return MCTBeforeUnload;
 
     }
-);
+);

platform/commonUI/edit/src/objects/EditableDomainObject.js

@@ -68,6 +68,9 @@ define(
          * which need to behave differently in edit mode,
          * and provides a "working copy" of the object's
          * model to allow changes to be easily cancelled.
+         * @constructor
+         * @memberof platform/commonUI/edit
+         * @implements {DomainObject}
          */
         function EditableDomainObject(domainObject, $q) {
             // The cache will hold all domain objects reached from
@@ -92,10 +95,10 @@ define(
                             this,
                             delegateArguments
                         ),
-                        factory = capabilityFactories[name];
+                        Factory = capabilityFactories[name];
 
-                    return (factory && capability) ?
-                            factory(capability, editableObject, domainObject, cache) :
+                    return (Factory && capability) ?
+                            new Factory(capability, editableObject, domainObject, cache) :
                             capability;
                 };
 
@@ -109,4 +112,4 @@ define(
 
         return EditableDomainObject;
     }
-);
+);

platform/commonUI/edit/src/objects/EditableDomainObjectCache.js

@@ -22,7 +22,7 @@
 /*global define*/
 
 
-/**
+/*
  * An editable domain object cache stores domain objects that have been
  * made editable, in a group that can be saved all-at-once. This supports
  * Edit mode, which is launched for a specific object but may contain
@@ -32,8 +32,6 @@
  * to ensure that changes made while in edit mode do not propagate up
  * to the objects used in browse mode (or to persistence) until the user
  * initiates a Save.
- *
- * @module editor/object/editable-domain-object-cache
  */
 define(
     ["./EditableModelCache"],
@@ -46,100 +44,118 @@ define(
          * of objects retrieved via composition or context capabilities as
          * editable domain objects.
          *
-         * @param {Constructor<EditableDomainObject>} EditableDomainObject a
+         * @param {Constructor<DomainObject>} EditableDomainObject a
          *        constructor function which takes a regular domain object as
          *        an argument, and returns an editable domain object as its
          *        result.
          * @param $q Angular's $q, for promise handling
+         * @memberof platform/commonUI/edit
          * @constructor
-         * @memberof module:editor/object/editable-domain-object-cache
          */
         function EditableDomainObjectCache(EditableDomainObject, $q) {
-            var cache = new EditableModelCache(),
-                dirty = {},
-                root;
-
-            return {
-                /**
-                 * Wrap this domain object in an editable form, or pull such
-                 * an object from the cache if one already exists.
-                 *
-                 * @param {DomainObject} domainObject the regular domain object
-                 * @returns {DomainObject} the domain object in an editable form
-                 */
-                getEditableObject: function (domainObject) {
-                    // Track the top-level domain object; this will have
-                    // some special behavior for its context capability.
-                    root = root || domainObject;
-
-                    // Avoid double-wrapping (WTD-1017)
-                    if (domainObject.hasCapability('editor')) {
-                        return domainObject;
-                    }
-
-                    // Provide an editable form of the object
-                    return new EditableDomainObject(
-                        domainObject,
-                        cache.getCachedModel(domainObject)
-                    );
-                },
-                /**
-                 * Check if a domain object is (effectively) the top-level
-                 * object in this editable subgraph.
-                 * @returns {boolean} true if it is the root
-                 */
-                isRoot: function (domainObject) {
-                    return domainObject === root;
-                },
-                /**
-                 * Mark an editable domain object (presumably already cached)
-                 * as having received modifications during editing; it should be
-                 * included in the bulk save invoked when editing completes.
-                 *
-                 * @param {DomainObject} domainObject the domain object
-                 */
-                markDirty: function (domainObject) {
-                    dirty[domainObject.getId()] = domainObject;
-                },
-                /**
-                 * Mark an object (presumably already cached) as having had its
-                 * changes saved (and thus no longer needing to be subject to a
-                 * save operation.)
-                 *
-                 * @param {DomainObject} domainObject the domain object
-                 */
-                markClean: function (domainObject) {
-                    delete dirty[domainObject.getId()];
-                },
-                /**
-                 * Initiate a save on all objects that have been cached.
-                 */
-                saveAll: function () {
-                    // Get a list of all dirty objects
-                    var objects = Object.keys(dirty).map(function (k) {
-                        return dirty[k];
-                    });
-
-                    // Clear dirty set, since we're about to save.
-                    dirty = {};
-
-                    // Most save logic is handled by the "editor.completion"
-                    // capability, so that is delegated here.
-                    return $q.all(objects.map(function (object) {
-                        // Save; pass a nonrecursive flag to avoid looping
-                        return object.getCapability('editor').save(true);
-                    }));
-                },
-                /**
-                 * Check if any objects have been marked dirty in this cache.
-                 * @returns {boolean} true if objects are dirty
-                 */
-                dirty: function () {
-                    return Object.keys(dirty).length > 0;
-                }
-            };
+            this.cache = new EditableModelCache();
+            this.dirtyObjects = {};
+            this.root = undefined;
+            this.$q = $q;
+            this.EditableDomainObject = EditableDomainObject;
         }
 
+        /**
+         * Wrap this domain object in an editable form, or pull such
+         * an object from the cache if one already exists.
+         *
+         * @param {DomainObject} domainObject the regular domain object
+         * @returns {DomainObject} the domain object in an editable form
+         */
+        EditableDomainObjectCache.prototype.getEditableObject = function (domainObject) {
+            var type = domainObject.getCapability('type'),
+                EditableDomainObject = this.EditableDomainObject;
+
+            // Track the top-level domain object; this will have
+            // some special behavior for its context capability.
+            this.root = this.root || domainObject;
+
+            // Avoid double-wrapping (WTD-1017)
+            if (domainObject.hasCapability('editor')) {
+                return domainObject;
+            }
+
+            // Don't bother wrapping non-editable objects
+            if (!type || !type.hasFeature('creation')) {
+                return domainObject;
+            }
+
+            // Provide an editable form of the object
+            return new EditableDomainObject(
+                domainObject,
+                this.cache.getCachedModel(domainObject)
+            );
+        };
+
+        /**
+         * Check if a domain object is (effectively) the top-level
+         * object in this editable subgraph.
+         * @returns {boolean} true if it is the root
+         */
+        EditableDomainObjectCache.prototype.isRoot = function (domainObject) {
+            return domainObject === this.root;
+        };
+
+        /**
+         * Mark an editable domain object (presumably already cached)
+         * as having received modifications during editing; it should be
+         * included in the bulk save invoked when editing completes.
+         *
+         * @param {DomainObject} domainObject the domain object
+         * @memberof platform/commonUI/edit.EditableDomainObjectCache#
+         */
+        EditableDomainObjectCache.prototype.markDirty = function (domainObject) {
+            this.dirtyObjects[domainObject.getId()] = domainObject;
+        };
+
+        /**
+         * Mark an object (presumably already cached) as having had its
+         * changes saved (and thus no longer needing to be subject to a
+         * save operation.)
+         *
+         * @param {DomainObject} domainObject the domain object
+         */
+        EditableDomainObjectCache.prototype.markClean = function (domainObject) {
+            delete this.dirtyObjects[domainObject.getId()];
+        };
+
+        /**
+         * Initiate a save on all objects that have been cached.
+         * @return {Promise} A promise which will resolve when all objects are
+         *         persisted.
+         */
+        EditableDomainObjectCache.prototype.saveAll = function () {
+            // Get a list of all dirty objects
+            var dirty = this.dirtyObjects,
+                objects = Object.keys(dirty).map(function (k) {
+                    return dirty[k];
+                });
+
+            // Clear dirty set, since we're about to save.
+            this.dirtyObjects = {};
+
+            // Most save logic is handled by the "editor.completion"
+            // capability, so that is delegated here.
+            return this.$q.all(objects.map(function (object) {
+                // Save; pass a nonrecursive flag to avoid looping
+                return object.getCapability('editor').save(true);
+            }));
+        };
+
+        /**
+         * Check if any objects have been marked dirty in this cache.
+         * @returns {boolean} true if objects are dirty
+         */
+        EditableDomainObjectCache.prototype.dirty = function () {
+            return Object.keys(this.dirtyObjects).length > 0;
+        };
+
         return EditableDomainObjectCache;
     }
-);
+);
+

platform/commonUI/edit/src/objects/EditableModelCache.js

@@ -31,33 +31,32 @@ define(
          * made editable, to support a group that can be saved all-at-once.
          * This is useful in Edit mode, which is launched for a specific
          * object but may contain changes across many objects.
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditableModelCache() {
-            var cache = {};
-
-            // Deep-copy a model. Models are JSONifiable, so this can be
-            // done by stringification then destringification
-            function clone(model) {
-                return JSON.parse(JSON.stringify(model));
-            }
-
-            return {
-                /**
-                 * Get this domain object's model from the cache (or
-                 * place it in the cache if it isn't in the cache yet)
-                 * @returns a clone of the domain object's model
-                 */
-                getCachedModel: function (domainObject) {
-                    var id = domainObject.getId();
-
-                    return (cache[id] =
-                        cache[id] || clone(domainObject.getModel()));
-                }
-            };
-
+            this.cache = {};
         }
 
+        // Deep-copy a model. Models are JSONifiable, so this can be
+        // done by stringification then destringification
+        function clone(model) {
+            return JSON.parse(JSON.stringify(model));
+        }
+
+        /**
+         * Get this domain object's model from the cache (or
+         * place it in the cache if it isn't in the cache yet)
+         * @returns a clone of the domain object's model
+         */
+        EditableModelCache.prototype.getCachedModel = function (domainObject) {
+            var id = domainObject.getId(),
+                cache = this.cache;
+
+            return (cache[id] =
+                cache[id] || clone(domainObject.getModel()));
+        };
+
         return EditableModelCache;
     }
-);
+);

platform/commonUI/edit/src/policies/EditActionPolicy.js

@@ -30,53 +30,47 @@ define(
          * Policy controlling when the `edit` and/or `properties` actions
          * can appear as applicable actions of the `view-control` category
          * (shown as buttons in the top-right of browse mode.)
+         * @memberof platform/commonUI/edit
          * @constructor
+         * @implements {Policy.<Action, ActionContext>}
          */
         function EditActionPolicy() {
-            // Get a count of views which are not flagged as non-editable.
-            function countEditableViews(context) {
-                var domainObject = (context || {}).domainObject,
-                    views = domainObject && domainObject.useCapability('view'),
-                    count = 0;
+        }
 
-                // A view is editable unless explicitly flagged as not
-                (views || []).forEach(function (view) {
-                    count += (view.editable !== false) ? 1 : 0;
-                });
+        // Get a count of views which are not flagged as non-editable.
+        function countEditableViews(context) {
+            var domainObject = (context || {}).domainObject,
+                views = domainObject && domainObject.useCapability('view'),
+                count = 0;
 
-                return count;
+            // A view is editable unless explicitly flagged as not
+            (views || []).forEach(function (view) {
+                count += (view.editable !== false) ? 1 : 0;
+            });
+
+            return count;
+        }
+
+        EditActionPolicy.prototype.allow = function (action, context) {
+            var key = action.getMetadata().key,
+                category = (context || {}).category;
+
+            // Only worry about actions in the view-control category
+            if (category === 'view-control') {
+                // Restrict 'edit' to cases where there are editable
+                // views (similarly, restrict 'properties' to when
+                // the converse is true)
+                if (key === 'edit') {
+                    return countEditableViews(context) > 0;
+                } else if (key === 'properties') {
+                    return countEditableViews(context) < 1;
+                }
             }
 
-            return {
-                /**
-                 * Check whether or not a given action is allowed by this
-                 * policy.
-                 * @param {Action} action the action
-                 * @param context the context
-                 * @returns {boolean} true if not disallowed
-                 */
-                allow: function (action, context) {
-                    var key = action.getMetadata().key,
-                        category = (context || {}).category;
-
-                    // Only worry about actions in the view-control category
-                    if (category === 'view-control') {
-                        // Restrict 'edit' to cases where there are editable
-                        // views (similarly, restrict 'properties' to when
-                        // the converse is true)
-                        if (key === 'edit') {
-                            return countEditableViews(context) > 0;
-                        } else if (key === 'properties') {
-                            return countEditableViews(context) < 1;
-                        }
-                    }
-
-                    // Like all policies, allow by default.
-                    return true;
-                }
-            };
-        }
+            // Like all policies, allow by default.
+            return true;
+        };
 
         return EditActionPolicy;
     }
-);
+);

platform/commonUI/edit/src/policies/EditableViewPolicy.js

@@ -28,30 +28,24 @@ define(
 
         /**
          * Policy controlling which views should be visible in Edit mode.
+         * @memberof platform/commonUI/edit
          * @constructor
+         * @implements {Policy.<View, DomainObject>}
          */
         function EditableViewPolicy() {
-            return {
-                /**
-                 * Check whether or not a given action is allowed by this
-                 * policy.
-                 * @param {Action} action the action
-                 * @param domainObject the domain object which will be viewed
-                 * @returns {boolean} true if not disallowed
-                 */
-                allow: function (view, domainObject) {
-                    // If a view is flagged as non-editable, only allow it
-                    // while we're not in Edit mode.
-                    if ((view || {}).editable === false) {
-                        return !domainObject.hasCapability('editor');
-                    }
-
-                    // Like all policies, allow by default.
-                    return true;
-                }
-            };
         }
 
+        EditableViewPolicy.prototype.allow = function (view, domainObject) {
+            // If a view is flagged as non-editable, only allow it
+            // while we're not in Edit mode.
+            if ((view || {}).editable === false) {
+                return !domainObject.hasCapability('editor');
+            }
+
+            // Like all policies, allow by default.
+            return true;
+        };
+
         return EditableViewPolicy;
     }
-);
+);

platform/commonUI/edit/src/representers/EditRepresenter.js

@@ -41,14 +41,17 @@ define(
          * and may be reused for different domain objects and/or
          * representations resulting from changes there.
          *
+         * @memberof platform/commonUI/edit
+         * @implements {Representer}
          * @constructor
          */
         function EditRepresenter($q, $log, scope) {
-            var domainObject,
-                key;
+            var self = this;
 
             // Mutate and persist a new version of a domain object's model.
             function doPersist(model) {
+                var domainObject = self.domainObject;
+
                 // First, mutate; then, persist.
                 return $q.when(domainObject.useCapability("mutation", function () {
                     return model;
@@ -64,7 +67,8 @@ define(
                 // Look up from scope; these will have been populated by
                 // mct-representation.
                 var model = scope.model,
-                    configuration = scope.configuration;
+                    configuration = scope.configuration,
+                    domainObject = self.domainObject;
 
                 // Log the commit message
                 $log.debug([
@@ -78,50 +82,33 @@ define(
                 if (domainObject && domainObject.hasCapability("persistence")) {
                     // Configurations for specific views are stored by
                     // key in the "configuration" field of the model.
-                    if (key && configuration) {
+                    if (self.key && configuration) {
                         model.configuration = model.configuration || {};
-                        model.configuration[key] = configuration;
+                        model.configuration[self.key] = configuration;
                     }
                     doPersist(model);
                 }
             }
 
-            // Respond to the destruction of the current representation.
-            function destroy() {
-                // Nothing to clean up
-            }
-
-            // Handle a specific representation of a specific domain object
-            function represent(representation, representedObject) {
-                // Track the key, to know which view configuration to save to.
-                key = (representation || {}).key;
-                // Track the represented object
-                domainObject = representedObject;
-                // Ensure existing watches are released
-                destroy();
-            }
-
             // Place the "commit" method in the scope
             scope.commit = commit;
-
-            return {
-                /**
-                 * Set the current representation in use, and the domain
-                 * object being represented.
-                 *
-                 * @param {RepresentationDefinition} representation the
-                 *        definition of the representation in use
-                 * @param {DomainObject} domainObject the domain object
-                 *        being represented
-                 */
-                represent: represent,
-                /**
-                 * Release any resources associated with this representer.
-                 */
-                destroy: destroy
-            };
         }
 
+        // Handle a specific representation of a specific domain object
+        EditRepresenter.prototype.represent = function represent(representation, representedObject) {
+            // Track the key, to know which view configuration to save to.
+            this.key = (representation || {}).key;
+            // Track the represented object
+            this.domainObject = representedObject;
+            // Ensure existing watches are released
+            this.destroy();
+        };
+
+        // Respond to the destruction of the current representation.
+        EditRepresenter.prototype.destroy = function destroy() {
+            // Nothing to clean up
+        };
+
         return EditRepresenter;
     }
-);
+);

platform/commonUI/edit/src/representers/EditToolbar.js

@@ -38,125 +38,23 @@ define(
          *
          * @param structure toolbar structure, as provided by view definition
          * @param {Function} commit callback to invoke after changes
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditToolbar(structure, commit) {
-            var toolbarStructure = Object.create(structure || {}),
-                toolbarState,
-                selection,
-                properties = [];
+            var self = this;
 
             // Generate a new key for an item's property
             function addKey(property) {
-                properties.push(property);
-                return properties.length - 1; // Return index of property
-            }
-
-            // Update value for this property in all elements of the
-            // selection which have this property.
-            function updateProperties(property, value) {
-                var changed = false;
-
-                // Update property in a selected element
-                function updateProperty(selected) {
-                    // Ignore selected elements which don't have this property
-                    if (selected[property] !== undefined) {
-                        // Check if this is a setter, or just assignable
-                        if (typeof selected[property] === 'function') {
-                            changed =
-                                changed || (selected[property]() !== value);
-                            selected[property](value);
-                        } else {
-                            changed =
-                                changed || (selected[property] !== value);
-                            selected[property] = value;
-                        }
-                    }
-                }
-
-                // Update property in all selected elements
-                selection.forEach(updateProperty);
-
-                // Return whether or not anything changed
-                return changed;
-            }
-
-            // Look up the current value associated with a property
-            // in selection i
-            function lookupState(property, selected) {
-                var value = selected[property];
-                return (typeof value === 'function') ? value() : value;
-            }
-
-            // Get initial value for a given property
-            function initializeState(property) {
-                var result;
-                // Look through all selections for this property;
-                // values should all match by the time we perform
-                // this lookup anyway.
-                selection.forEach(function (selected) {
-                    result = (selected[property] !== undefined) ?
-                            lookupState(property, selected) :
-                            result;
-                });
-                return result;
-            }
-
-            // Check if all elements of the selection which have this
-            // property have the same value for this property.
-            function isConsistent(property) {
-                var consistent = true,
-                    observed = false,
-                    state;
-
-                // Check if a given element of the selection is consistent
-                // with previously-observed elements for this property.
-                function checkConsistency(selected) {
-                    var next;
-                    // Ignore selections which don't have this property
-                    if (selected[property] !== undefined) {
-                        // Look up state of this element in the selection
-                        next = lookupState(property, selected);
-                        // Detect inconsistency
-                        if (observed) {
-                            consistent = consistent && (next === state);
-                        }
-                        // Track state for next iteration
-                        state = next;
-                        observed = true;
-                    }
-                }
-
-                // Iterate through selections
-                selection.forEach(checkConsistency);
-
-                return consistent;
-            }
-
-            // Used to filter out items which are applicable (or not)
-            // to the current selection.
-            function isApplicable(item) {
-                var property = (item || {}).property,
-                    method = (item || {}).method,
-                    exclusive = !!(item || {}).exclusive;
-
-                // Check if a selected item defines this property
-                function hasProperty(selected) {
-                    return (property && (selected[property] !== undefined)) ||
-                            (method && (typeof selected[method] === 'function'));
-                }
-
-                return selection.map(hasProperty).reduce(
-                    exclusive ? and : or,
-                    exclusive
-                ) && isConsistent(property);
+                self.properties.push(property);
+                return self.properties.length - 1; // Return index of property
             }
 
             // Invoke all functions in selections with the given name
             function invoke(method, value) {
                 if (method) {
                     // Make the change in the selection
-                    selection.forEach(function (selected) {
+                    self.selection.forEach(function (selected) {
                         if (typeof selected[method] === 'function') {
                             selected[method](value);
                         }
@@ -189,73 +87,172 @@ define(
                 return converted;
             }
 
+            this.toolbarState = [];
+            this.selection = undefined;
+            this.properties = [];
+            this.toolbarStructure = Object.create(structure || {});
+            this.toolbarStructure.sections =
+                ((structure || {}).sections || []).map(convertSection);
+        }
+
+        // Check if all elements of the selection which have this
+        // property have the same value for this property.
+        EditToolbar.prototype.isConsistent = function (property) {
+            var self = this,
+                consistent = true,
+                observed = false,
+                state;
+
+            // Check if a given element of the selection is consistent
+            // with previously-observed elements for this property.
+            function checkConsistency(selected) {
+                var next;
+                // Ignore selections which don't have this property
+                if (selected[property] !== undefined) {
+                    // Look up state of this element in the selection
+                    next = self.lookupState(property, selected);
+                    // Detect inconsistency
+                    if (observed) {
+                        consistent = consistent && (next === state);
+                    }
+                    // Track state for next iteration
+                    state = next;
+                    observed = true;
+                }
+            }
+
+            // Iterate through selections
+            self.selection.forEach(checkConsistency);
+
+            return consistent;
+        };
+
+        // Used to filter out items which are applicable (or not)
+        // to the current selection.
+        EditToolbar.prototype.isApplicable = function (item) {
+            var property = (item || {}).property,
+                method = (item || {}).method,
+                exclusive = !!(item || {}).exclusive;
+
+            // Check if a selected item defines this property
+            function hasProperty(selected) {
+                return (property && (selected[property] !== undefined)) ||
+                    (method && (typeof selected[method] === 'function'));
+            }
+
+            return this.selection.map(hasProperty).reduce(
+                    exclusive ? and : or,
+                    exclusive
+                ) && this.isConsistent(property);
+        };
+
+
+        // Look up the current value associated with a property
+        EditToolbar.prototype.lookupState = function (property, selected) {
+            var value = selected[property];
+            return (typeof value === 'function') ? value() : value;
+        };
+
+        /**
+         * Set the current selection. Visibility of sections
+         * and items in the toolbar will be updated to match this.
+         * @param {Array} s the new selection
+         */
+        EditToolbar.prototype.setSelection = function (s) {
+            var self = this;
+
             // Show/hide controls in this section per applicability
             function refreshSectionApplicability(section) {
                 var count = 0;
                 // Show/hide each item
                 (section.items || []).forEach(function (item) {
-                    item.hidden = !isApplicable(item);
+                    item.hidden = !self.isApplicable(item);
                     count += item.hidden ? 0 : 1;
                 });
                 // Hide this section if there are no applicable items
                 section.hidden = !count;
             }
 
-            // Show/hide controls if they are applicable
-            function refreshApplicability() {
-                toolbarStructure.sections.forEach(refreshSectionApplicability);
+            // Get initial value for a given property
+            function initializeState(property) {
+                var result;
+                // Look through all selections for this property;
+                // values should all match by the time we perform
+                // this lookup anyway.
+                self.selection.forEach(function (selected) {
+                    result = (selected[property] !== undefined) ?
+                        self.lookupState(property, selected) :
+                        result;
+                });
+                return result;
             }
 
-            // Refresh toolbar state to match selection
-            function refreshState() {
-                toolbarState = properties.map(initializeState);
-            }
+            this.selection = s;
+            this.toolbarStructure.sections.forEach(refreshSectionApplicability);
+            this.toolbarState = this.properties.map(initializeState);
+        };
 
-            toolbarStructure.sections =
-                ((structure || {}).sections || []).map(convertSection);
+        /**
+         * Get the structure of the toolbar, as appropriate to
+         * pass to `mct-toolbar`.
+         * @returns the toolbar structure
+         */
+        EditToolbar.prototype.getStructure = function () {
+            return this.toolbarStructure;
+        };
 
-            toolbarState = [];
+        /**
+         * Get the current state of the toolbar, as appropriate
+         * to two-way bind to the state handled by `mct-toolbar`.
+         * @returns {Array} state of the toolbar
+         */
+        EditToolbar.prototype.getState = function () {
+            return this.toolbarState;
+        };
 
-            return {
-                /**
-                 * Set the current selection. Visisbility of sections
-                 * and items in the toolbar will be updated to match this.
-                 * @param {Array} s the new selection
-                 */
-                setSelection: function (s) {
-                    selection = s;
-                    refreshApplicability();
-                    refreshState();
-                },
-                /**
-                 * Get the structure of the toolbar, as appropriate to
-                 * pass to `mct-toolbar`.
-                 * @returns the toolbar structure
-                 */
-                getStructure: function () {
-                    return toolbarStructure;
-                },
-                /**
-                 * Get the current state of the toolbar, as appropriate
-                 * to two-way bind to the state handled by `mct-toolbar`.
-                 * @returns {Array} state of the toolbar
-                 */
-                getState: function () {
-                    return toolbarState;
-                },
-                /**
-                 * Update state within the current selection.
-                 * @param {number} index the index of the corresponding
-                 *        element in the state array
-                 * @param value the new value to convey to the selection
-                 */
-                updateState: function (index, value) {
-                    return updateProperties(properties[index], value);
+        /**
+         * Update state within the current selection.
+         * @param {number} index the index of the corresponding
+         *        element in the state array
+         * @param value the new value to convey to the selection
+         */
+        EditToolbar.prototype.updateState = function (index, value) {
+            var self = this;
+
+            // Update value for this property in all elements of the
+            // selection which have this property.
+            function updateProperties(property, value) {
+                var changed = false;
+
+                // Update property in a selected element
+                function updateProperty(selected) {
+                    // Ignore selected elements which don't have this property
+                    if (selected[property] !== undefined) {
+                        // Check if this is a setter, or just assignable
+                        if (typeof selected[property] === 'function') {
+                            changed =
+                                changed || (selected[property]() !== value);
+                            selected[property](value);
+                        } else {
+                            changed =
+                                changed || (selected[property] !== value);
+                            selected[property] = value;
+                        }
+                    }
                 }
-            };
-        }
+
+                // Update property in all selected elements
+                self.selection.forEach(updateProperty);
+
+                // Return whether or not anything changed
+                return changed;
+            }
+
+            return updateProperties(this.properties[index], value);
+        };
 
         return EditToolbar;
     }
 );
 
+

platform/commonUI/edit/src/representers/EditToolbarRepresenter.js

@@ -27,17 +27,21 @@ define(
         "use strict";
 
         // No operation
-        function noop() {}
+        var NOOP_REPRESENTER = {
+            represent: function () {},
+            destroy: function () {}
+        };
 
         /**
          * The EditToolbarRepresenter populates the toolbar in Edit mode
          * based on a view's definition.
          * @param {Scope} scope the Angular scope of the representation
+         * @memberof platform/commonUI/edit
          * @constructor
+         * @implements {Representer}
          */
         function EditToolbarRepresenter(scope, element, attrs) {
-            var toolbar,
-                toolbarObject = {};
+            var self = this;
 
             // Mark changes as ready to persist
             function commit(message) {
@@ -49,31 +53,33 @@ define(
             // Handle changes to the current selection
             function updateSelection(selection) {
                 // Only update if there is a toolbar to update
-                if (toolbar) {
+                if (self.toolbar) {
                     // Make sure selection is array-like
                     selection = Array.isArray(selection) ?
                             selection :
                             (selection ? [selection] : []);
 
                     // Update the toolbar's selection
-                    toolbar.setSelection(selection);
+                    self.toolbar.setSelection(selection);
 
                     // ...and expose its structure/state
-                    toolbarObject.structure = toolbar.getStructure();
-                    toolbarObject.state = toolbar.getState();
+                    self.toolbarObject.structure =
+                        self.toolbar.getStructure();
+                    self.toolbarObject.state =
+                        self.toolbar.getState();
                 }
             }
 
             // Get state (to watch it)
             function getState() {
-                return toolbarObject.state;
+                return self.toolbarObject.state;
             }
 
             // Update selection models to match changed toolbar state
             function updateState(state) {
                 // Update underlying state based on toolbar changes
                 var changed = (state || []).map(function (value, index) {
-                    return toolbar.updateState(index, value);
+                    return self.toolbar.updateState(index, value);
                 }).reduce(function (a, b) {
                     return a || b;
                 }, false);
@@ -85,66 +91,73 @@ define(
                 }
             }
 
-            // Initialize toolbar (expose object to parent scope)
-            function initialize(definition) {
-                // If we have been asked to expose toolbar state...
-                if (attrs.toolbar) {
-                    // Initialize toolbar object
-                    toolbar = new EditToolbar(definition, commit);
-                    // Ensure toolbar state is exposed
-                    scope.$parent[attrs.toolbar] = toolbarObject;
-                }
-            }
-
-            // Represent a domain object using this definition
-            function represent(representation) {
-                // Get the newest toolbar definition from the view
-                var definition = (representation || {}).toolbar || {};
-                // Expose the toolbar object to the parent scope
-                initialize(definition);
-                // Create a selection scope
-                scope.selection = new EditToolbarSelection();
-                // Initialize toolbar to an empty selection
-                updateSelection([]);
-            }
-
-            // Destroy; remove toolbar object from parent scope
-            function destroy() {
+            // Avoid attaching scope to this;
+            // http://errors.angularjs.org/1.2.26/ng/cpws
+            this.setSelection = function (s) {
+                scope.selection = s;
+            };
+            this.clearExposedToolbar = function () {
                 // Clear exposed toolbar state (if any)
                 if (attrs.toolbar) {
                     delete scope.$parent[attrs.toolbar];
                 }
-            }
+            };
+            this.exposeToolbar = function () {
+                scope.$parent[self.attrs.toolbar] = self.toolbarObject;
+            };
+
+            this.commit = commit;
+            this.attrs = attrs;
+            this.updateSelection = updateSelection;
+            this.toolbar = undefined;
+            this.toolbarObject = {};
 
             // If this representation exposes a toolbar, set up watches
             // to synchronize with it.
-            if (attrs.toolbar) {
+            if (attrs && attrs.toolbar) {
                 // Detect and handle changes to state from the toolbar
                 scope.$watchCollection(getState, updateState);
                 // Watch for changes in the current selection state
                 scope.$watchCollection("selection.all()", updateSelection);
                 // Expose toolbar state under that name
-                scope.$parent[attrs.toolbar] = toolbarObject;
+                scope.$parent[attrs.toolbar] = this.toolbarObject;
+            } else {
+                // No toolbar declared, so do nothing.
+                return NOOP_REPRESENTER;
             }
 
-            return {
-                /**
-                 * Set the current representation in use, and the domain
-                 * object being represented.
-                 *
-                 * @param {RepresentationDefinition} representation the
-                 *        definition of the representation in use
-                 * @param {DomainObject} domainObject the domain object
-                 *        being represented
-                 */
-                represent: (attrs || {}).toolbar ? represent : noop,
-                /**
-                 * Release any resources associated with this representer.
-                 */
-                destroy: (attrs || {}).toolbar ? destroy : noop
-            };
         }
 
+        // Represent a domain object using this definition
+        EditToolbarRepresenter.prototype.represent = function (representation) {
+            // Get the newest toolbar definition from the view
+            var definition = (representation || {}).toolbar || {},
+                self = this;
+
+            // Initialize toolbar (expose object to parent scope)
+            function initialize(definition) {
+                // If we have been asked to expose toolbar state...
+                if (self.attrs.toolbar) {
+                    // Initialize toolbar object
+                    self.toolbar = new EditToolbar(definition, self.commit);
+                    // Ensure toolbar state is exposed
+                    self.exposeToolbar();
+                }
+            }
+
+            // Expose the toolbar object to the parent scope
+            initialize(definition);
+            // Create a selection scope
+            this.setSelection(new EditToolbarSelection());
+            // Initialize toolbar to an empty selection
+            this.updateSelection([]);
+        };
+
+        // Destroy; remove toolbar object from parent scope
+        EditToolbarRepresenter.prototype.destroy = function () {
+            this.clearExposedToolbar();
+        };
+
         return EditToolbarRepresenter;
     }
-);
+);

platform/commonUI/edit/src/representers/EditToolbarSelection.js

@@ -37,110 +37,96 @@ define(
          * * The selection, for single selected elements within the
          *   view.
          *
+         * @memberof platform/commonUI/edit
          * @constructor
          */
         function EditToolbarSelection() {
-            var selection = [ {} ],
-                selecting = false,
-                selected;
+            this.selection = [{}];
+            this.selecting = false;
+            this.selectedObj = undefined;
+        }
 
-            // Remove the currently-selected object
-            function deselect() {
-                // Nothing to do if we don't have a selected object
-                if (selecting) {
-                    // Clear state tracking
-                    selecting = false;
-                    selected = undefined;
+        /**
+         * Check if an object is currently selected.
+         * @param {*} obj the object to check for selection
+         * @returns {boolean} true if selected, otherwise false
+         */
+        EditToolbarSelection.prototype.selected = function (obj) {
+            return (obj === this.selectedObj) || (obj === this.selection[0]);
+        };
 
-                    // Remove the selection
-                    selection.pop();
-
-                    return true;
-                }
+        /**
+         * Select an object.
+         * @param obj the object to select
+         * @returns {boolean} true if selection changed
+         */
+        EditToolbarSelection.prototype.select = function (obj) {
+            // Proxy is always selected
+            if (obj === this.selection[0]) {
                 return false;
             }
 
-            // Select an object
-            function select(obj) {
-                // Proxy is always selected
-                if (obj === selection[0]) {
-                    return false;
-                }
+            // Clear any existing selection
+            this.deselect();
 
-                // Clear any existing selection
-                deselect();
+            // Note the current selection state
+            this.selectedObj = obj;
+            this.selecting = true;
 
-                // Note the current selection state
-                selected = obj;
-                selecting = true;
+            // Add the selection
+            this.selection.push(obj);
+        };
 
-                // Add the selection
-                selection.push(obj);
+        /**
+         * Clear the current selection.
+         * @returns {boolean} true if selection changed
+         */
+        EditToolbarSelection.prototype.deselect = function () {
+            // Nothing to do if we don't have a selected object
+            if (this.selecting) {
+                // Clear state tracking
+                this.selecting = false;
+                this.selectedObj = undefined;
+
+                // Remove the selection
+                this.selection.pop();
+
+                return true;
             }
+            return false;
+        };
 
+        /**
+         * Get the currently-selected object.
+         * @returns the currently selected object
+         */
+        EditToolbarSelection.prototype.get = function () {
+            return this.selectedObj;
+        };
 
-            // Check if an object is selected
-            function isSelected(obj) {
-                return (obj === selected) || (obj === selection[0]);
+        /**
+         * Get/set the view proxy (for toolbar actions taken upon
+         * the view itself.)
+         * @param [proxy] the view proxy (if setting)
+         * @returns the current view proxy
+         */
+        EditToolbarSelection.prototype.proxy = function (p) {
+            if (arguments.length > 0) {
+                this.selection[0] = p;
             }
+            return this.selection[0];
+        };
 
-            // Getter for current selection
-            function get() {
-                return selected;
-            }
-
-            // Getter/setter for view proxy
-            function proxy(p) {
-                if (arguments.length > 0) {
-                    selection[0] = p;
-                }
-                return selection[0];
-            }
-
-            // Getter for the full array of selected objects (incl. view proxy)
-            function all() {
-                return selection;
-            }
-
-            return {
-                /**
-                 * Check if an object is currently selected.
-                 * @returns true if selected, otherwise false
-                 */
-                selected: isSelected,
-                /**
-                 * Select an object.
-                 * @param obj the object to select
-                 * @returns {boolean} true if selection changed
-                 */
-                select: select,
-                /**
-                 * Clear the current selection.
-                 * @returns {boolean} true if selection changed
-                 */
-                deselect: deselect,
-                /**
-                 * Get the currently-selected object.
-                 * @returns the currently selected object
-                 */
-                get: get,
-                /**
-                 * Get/set the view proxy (for toolbar actions taken upon
-                 * the view itself.)
-                 * @param [proxy] the view proxy (if setting)
-                 * @returns the current view proxy
-                 */
-                proxy: proxy,
-                /**
-                 * Get an array containing all selections, including the
-                 * selection proxy. It is generally not advisable to
-                 * mutate this array directly.
-                 * @returns {Array} all selections
-                 */
-                all: all
-            };
-        }
+        /**
+         * Get an array containing all selections, including the
+         * selection proxy. It is generally not advisable to
+         * mutate this array directly.
+         * @returns {Array} all selections
+         */
+        EditToolbarSelection.prototype.all = function () {
+            return this.selection;
+        };
 
         return EditToolbarSelection;
     }
-);
+);

platform/commonUI/edit/test/actions/CancelActionSpec.js

@@ -30,6 +30,7 @@ define(
             var mockLocation,
                 mockDomainObject,
                 mockEditorCapability,
+                mockUrlService,
                 actionContext,
                 action;
 
@@ -54,7 +55,10 @@ define(
                     "editor",
                     [ "save", "cancel" ]
                 );
-
+                mockUrlService = jasmine.createSpyObj(
+                    "urlService",
+                    ["urlForLocation"]
+                );
 
                 actionContext = {
                     domainObject: mockDomainObject
@@ -64,7 +68,7 @@ define(
                 mockDomainObject.getCapability.andReturn(mockEditorCapability);
                 mockEditorCapability.cancel.andReturn(mockPromise(true));
 
-                action = new CancelAction(mockLocation, actionContext);
+                action = new CancelAction(mockLocation, mockUrlService, actionContext);
 
             });
 
@@ -91,7 +95,9 @@ define(
 
             it("returns to browse when performed", function () {
                 action.perform();
-                expect(mockLocation.path).toHaveBeenCalledWith("/browse");
+                expect(mockLocation.path).toHaveBeenCalledWith(
+                    mockUrlService.urlForLocation("browse", mockDomainObject)
+                );
             });
         });
     }

platform/commonUI/edit/test/actions/RemoveActionSpec.js

@@ -28,9 +28,16 @@ define(
 
         describe("The Remove action", function () {
             var mockQ,
+                mockNavigationService,
                 mockDomainObject,
                 mockParent,
+                mockChildObject,
+                mockGrandchildObject,
+                mockRootObject,
                 mockContext,
+                mockChildContext,
+                mockGrandchildContext,
+                mockRootContext,
                 mockMutation,
                 mockPersistence,
                 mockType,
@@ -54,6 +61,18 @@ define(
                     "domainObject",
                     [ "getId", "getCapability" ]
                 );
+                mockChildObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getId", "getCapability" ]
+                );
+                mockGrandchildObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getId", "getCapability" ]
+                );
+                mockRootObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getId", "getCapability" ]
+                );
                 mockQ = { when: mockPromise };
                 mockParent = {
                     getModel: function () {
@@ -67,28 +86,41 @@ define(
                     }
                 };
                 mockContext = jasmine.createSpyObj("context", [ "getParent" ]);
+                mockChildContext = jasmine.createSpyObj("context", [ "getParent" ]);
+                mockGrandchildContext = jasmine.createSpyObj("context", [ "getParent" ]);
+                mockRootContext = jasmine.createSpyObj("context", [ "getParent" ]);
                 mockMutation = jasmine.createSpyObj("mutation", [ "invoke" ]);
                 mockPersistence = jasmine.createSpyObj("persistence", [ "persist" ]);
                 mockType = jasmine.createSpyObj("type", [ "hasFeature" ]);
-
+                mockNavigationService = jasmine.createSpyObj(
+                    "navigationService",
+                    [
+                        "getNavigation",
+                        "setNavigation",
+                        "addListener",
+                        "removeListener"
+                    ]
+                );
+                mockNavigationService.getNavigation.andReturn(mockDomainObject);
+                
+                
                 mockDomainObject.getId.andReturn("test");
                 mockDomainObject.getCapability.andReturn(mockContext);
                 mockContext.getParent.andReturn(mockParent);
                 mockType.hasFeature.andReturn(true);
 
-
                 capabilities = {
                     mutation: mockMutation,
                     persistence: mockPersistence,
                     type: mockType
                 };
                 model = {
-                    composition: [ "a", "test", "b", "c" ]
+                    composition: [ "a", "test", "b" ]
                 };
 
                 actionContext = { domainObject: mockDomainObject };
 
-                action = new RemoveAction(mockQ, actionContext);
+                action = new RemoveAction(mockQ, mockNavigationService, actionContext);
             });
 
             it("only applies to objects with parents", function () {
@@ -123,11 +155,64 @@ define(
 
                 // Should have removed "test" - that was our
                 // mock domain object's id.
-                expect(result.composition).toEqual(["a", "b", "c"]);
+                expect(result.composition).toEqual(["a", "b"]);
 
                 // Finally, should have persisted
                 expect(mockPersistence.persist).toHaveBeenCalled();
             });
+            
+            it("removes parent of object currently navigated to", function () {
+                // Navigates to child object
+                mockNavigationService.getNavigation.andReturn(mockChildObject);
+                
+                // Test is id of object being removed
+                // Child object has different id
+                mockDomainObject.getId.andReturn("test");
+                mockChildObject.getId.andReturn("not test");
+                
+                // Sets context for the child and domainObject
+                mockDomainObject.getCapability.andReturn(mockContext);
+                mockChildObject.getCapability.andReturn(mockChildContext);
+                
+                // Parents of child and domainObject are set
+                mockContext.getParent.andReturn(mockParent);
+                mockChildContext.getParent.andReturn(mockDomainObject);
+                
+                mockType.hasFeature.andReturn(true);
+                
+                action.perform();
+                
+                // Expects navigation to parent of domainObject (removed object)
+                expect(mockNavigationService.setNavigation).toHaveBeenCalledWith(mockParent);
+            });
+            
+            it("checks if removing object not in ascendent path (reaches ROOT)", function () {
+                // Navigates to grandchild of ROOT
+                mockNavigationService.getNavigation.andReturn(mockGrandchildObject);
+                
+                // domainObject (grandparent) is set as ROOT, child and grandchild
+                // are set objects not being removed
+                mockDomainObject.getId.andReturn("test 1");
+                mockRootObject.getId.andReturn("ROOT");
+                mockChildObject.getId.andReturn("not test 2");
+                mockGrandchildObject.getId.andReturn("not test 3");
+                
+                // Sets context for the grandchild, child, and domainObject
+                mockRootObject.getCapability.andReturn(mockRootContext);
+                mockChildObject.getCapability.andReturn(mockChildContext);
+                mockGrandchildObject.getCapability.andReturn(mockGrandchildContext);
+                
+                // Parents of grandchild and child are set
+                mockChildContext.getParent.andReturn(mockRootObject);
+                mockGrandchildContext.getParent.andReturn(mockChildObject);
+                
+                mockType.hasFeature.andReturn(true);
+                
+                action.perform();
+                
+                // Expects no navigation to occur
+                expect(mockNavigationService.setNavigation).not.toHaveBeenCalled();
+            });
 
         });
     }

platform/commonUI/edit/test/actions/SaveActionSpec.js

@@ -30,6 +30,7 @@ define(
             var mockLocation,
                 mockDomainObject,
                 mockEditorCapability,
+                mockUrlService,
                 actionContext,
                 action;
 
@@ -54,6 +55,10 @@ define(
                     "editor",
                     [ "save", "cancel" ]
                 );
+                mockUrlService = jasmine.createSpyObj(
+                    "urlService",
+                    ["urlForLocation"]
+                );
 
 
                 actionContext = {
@@ -64,7 +69,7 @@ define(
                 mockDomainObject.getCapability.andReturn(mockEditorCapability);
                 mockEditorCapability.save.andReturn(mockPromise(true));
 
-                action = new SaveAction(mockLocation, actionContext);
+                action = new SaveAction(mockLocation, mockUrlService, actionContext);
 
             });
 
@@ -91,7 +96,9 @@ define(
 
             it("returns to browse when performed", function () {
                 action.perform();
-                expect(mockLocation.path).toHaveBeenCalledWith("/browse");
+                expect(mockLocation.path).toHaveBeenCalledWith(
+                    mockUrlService.urlForLocation("browse", mockDomainObject)
+                );
             });
         });
     }

platform/commonUI/edit/test/controllers/EditControllerSpec.js

@@ -31,7 +31,7 @@ define(
                 mockQ,
                 mockNavigationService,
                 mockObject,
-                mockCapability,
+                mockType,
                 controller;
 
             beforeEach(function () {
@@ -48,15 +48,18 @@ define(
                     "domainObject",
                     [ "getId", "getModel", "getCapability", "hasCapability" ]
                 );
-                mockCapability = jasmine.createSpyObj(
-                    "capability",
-                    [ "invoke" ]
+                mockType = jasmine.createSpyObj(
+                    "type",
+                    [ "hasFeature" ]
                 );
 
                 mockNavigationService.getNavigation.andReturn(mockObject);
                 mockObject.getId.andReturn("test");
                 mockObject.getModel.andReturn({ name: "Test object" });
-                mockObject.getCapability.andReturn(mockCapability);
+                mockObject.getCapability.andCallFake(function (key) {
+                    return key === 'type' && mockType;
+                });
+                mockType.hasFeature.andReturn(true);
 
                 controller = new EditController(
                     mockScope,
@@ -76,7 +79,7 @@ define(
                     .toBeDefined();
                 // Shouldn't have been the mock capability we provided
                 expect(controller.navigatedObject().getCapability("editor"))
-                    .not.toEqual(mockCapability);
+                    .not.toEqual(mockType);
             });
 
             it("detaches its navigation listener when destroyed", function () {
@@ -119,4 +122,4 @@ define(
 
         });
     }
-);
+);