Temp changes to make JSC demo work.

Merge pull request #1493 from nasa/updated-docs
[Docs] Replace existing API documentation with V1 public API docs
2017-04-03 18:36:09 -05:00 · 2017-03-29 15:05:19 -07:00 · 2017-03-28 12:03:00 -07:00 · 2017-03-27 15:21:47 -07:00 · 2017-03-27 14:53:41 -07:00 · 2017-03-27 13:58:26 -07:00
46 changed files with 1175 additions and 734 deletions
--- a/API.md
+++ b/API.md
@@ -1,76 +1,150 @@
-# Open MCT API
+# Building Applications With Open MCT

-The Open MCT framework public api can be utilized by building the application
-(`gulp install`) and then copying the file from `dist/main.js` to your
-directory of choice.
+## Scope and purpose of this document

-Open MCT supports AMD, CommonJS, and loading via a script tag; it's easy to use
-in your project. The [`openmct`]{@link module:openmct} module is exported
-via AMD and CommonJS, and is also exposed as `openmct` in the global scope
-if loaded via a script tag.
+This document is intended to serve as a reference for developing an application 
+based on Open MCT. It will provide details of the API functions necessary to extend the 
+Open MCT platform meet common use cases such as integrating with a telemetry source. 

-## Overview
+The best place to start is with the [Open MCT Tutorials](https://github.com/nasa/openmct-tutorial). 
+These will walk you through the process of getting up and running with Open MCT, 
+as well as addressing some common developer use cases.

-Open MCT's goal is to allow you to browse, create, edit, and visualize all of
-the domain knowledge you need on a daily basis.
+## Building From Source 

-To do this, the main building block provided by Open MCT is the _domain object_.
-The temperature sensor on the starboard solar panel,
-an overlay plot comparing the results of all temperature sensor,
-the command dictionary for a spacecraft,
-the individual commands in that dictionary, your "my documents" folder:
+The latest version of Open MCT is available from [our GitHub repository](https://github.com/nasa/openmct). 
+If you have `git`, and `node` installed, you can build Open MCT with the commands 
+```
+git clone https://github.com/nasa/openmct.git
+cd openmct
+npm install
+```
+
+These commands will fetch the Open MCT source from our GitHub repository, and build 
+a minified version that can be included in your application. The output of the 
+build process is placed in a `dist` folder under the openmct source directory, 
+which can be copied out to another location as needed. The contents of this 
+folder will include a minified javascript file named `openmct.js` as well as 
+assets such as html, css, and images necessary for the UI. 
+
+## Starting an Open MCT application
+
+To start a minimally functional Open MCT application, it is necessary to include 
+the Open MCT distributable, enable some basic plugins, and bootstrap the application. 
+The tutorials walk through the process of getting Open MCT up and running from scratch,
+but provided below is a minimal HTML template that includes Open MCT, installs 
+some basic plugins, and bootstraps the application. It assumes that Open MCT is 
+installed under an `openmct` subdirectory, as described in [Building From Source](#building-from-source). 
+
+This approach includes openmct using a simple script tag, resulting in a global 
+variable named `openmct`. This `openmct` object is used subsequently to make API 
+calls. 
+
+Open MCT is packaged as a UMD (Universal Module Definition) module, so common 
+script loaders are also supported.
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Open MCT</title>
+    <script src="openmct.js"></script>
+</head>
+<body>
+    <script>
+        openmct.setAssetPath('openmct/dist');
+        openmct.install(openmct.plugins.LocalStorage());
+        openmct.install(openmct.plugins.MyItems());
+        openmct.install(openmct.plugins.UTCTimeSystem());
+        openmct.install(openmct.plugins.Espresso());
+        openmct.start();
+    </script>
+</body>
+</html>
+```
+
+The Open MCT library included above requires certain assets such as html templates, 
+images, and css. If you installed Open MCT from GitHub as described in the section 
+on [Building from Source](#building-from-source) then these assets will have been 
+downloaded along with the Open MCT javascript library. You can specify the 
+location of these assets by calling `openmct.setAssetPath()`. Typically this will 
+be the same location as the `openmct.js` library is included from.
+
+There are some plugins bundled with the application that provide UI, persistence, 
+and other default configuration which are necessary to be able to do anything with 
+the application initially. Any of these plugins can, in principle, be replaced with a custom 
+plugin. The included plugins are documented in the [Included Plugins](#included-plugins) 
+section.  
+
+## Plugins
+
+### Defining and Installing a New Plugin
+
+```javascript
+openmct.install(function install(openmctAPI) {
+    // Do things here
+    // ...
+});
+```
+
+New plugins are installed in Open MCT by calling `openmct.install`, and providing 
+a plugin installation function. This function will be invoked on application 
+startup with one parameter - the openmct API object. A common approach used in 
+the Open MCT codebase is to define a plugin as a function that returns this 
+installation function. This allows configuration to be specified when the plugin is included.
+
+eg.
+```javascript
+openmct.install(openmct.plugins.Elasticsearch("http://localhost:8002/openmct"));
+```
+This approach can be seen in all of the [plugins provided with Open MCT](https://github.com/nasa/openmct/blob/master/src/plugins/plugins.js).
+
+## Domain Objects and Identifiers
+
+_Domain Objects_ are the basic entities that represent domain knowledge in Open MCT.
+The temperature sensor on a solar panel, an overlay plot comparing 
+the results of all temperature sensors, the command dictionary for a spacecraft,
+the individual commands in that dictionary, the "My Items" folder:
 All of these things are domain objects.

-Domain objects have Types, so a specific instrument temperature sensor is a
-"Telemetry Point," and turning on a drill for a certain duration of time is
-an "Activity".  Types allow you to form an ontology of knowledge and provide
-an abstraction for grouping, visualizing, and interpreting data.
+A _Domain Object_ is simply a javascript object with some standard attributes.  
+An example of a _Domain Object_ is the "My Items" object which is a folder in 
+which a user can persist any objects that they create. The My Items object 
+looks like this: 

-And then we have Views. Views allow you to visualize domain objects. Views can
-apply to specific domain objects; they may also apply to certain types of
-domain objects, or they may apply to everything.  Views are simply a method
-of visualizing domain objects.
-
-Regions allow you to specify what views are displayed for specific types of
-domain objects in response to different user actions. For instance, you may
-want to display a different view while editing, or you may want to update the
-toolbar display when objects are selected.  Regions allow you to map views to
-specific user actions.
-
-Domain objects can be mutated and persisted, developers can create custom
-actions and apply them to domain objects, and many more things can be done.
-For more information, read on!
-
-## Running Open MCT
-
-Once the [`openmct`](@link module:openmct) module has been loaded, you can
-simply invoke [`start`]{@link module:openmct.MCT#start} to run Open MCT:
-
-
-```
-openmct.start();
+```javascript
+{
+    identifier: {
+        namespace: ""
+        key: "mine"
+    }
+    name:"My Items",
+    type:"folder",
+    location:"ROOT",
+    composition: []
+}
 ```

-Generally, however, you will want to configure Open MCT by adding plugins
-before starting it. It is important to install plugins and configure Open MCT
-_before_ calling [`start`]{@link module:openmct.MCT#start}; Open MCT is not
-designed to be reconfigured once started.
+### Object Attributes

-## Configuring Open MCT
+The main attributes to note are the `identifier`, and `type` attributes.
+* `identifier`: A composite key that provides a universally unique identifier for 
+this object. The `namespace` and `key` are used to identify the object. The `key` 
+must be unique within the namespace. 
+* `type`: All objects in Open MCT have a type. Types allow you to form an 
+ontology of knowledge and provide an abstraction for grouping, visualizing, and 
+interpreting data. Details on how to define a new object type are provided below. 

-The [`openmct`]{@link module:openmct} module (more specifically, the
-[`MCT`]{@link module:openmct.MCT} class, of which `openmct` is an instance)
-exposes a variety of methods to allow the application to be configured,
-extended, and customized before running.
+Open MCT uses a number of builtin types. Typically you are going to want to 
+define your own if extending Open MCT.

-Short examples follow; see the linked documentation for further details.
+### Domain Object Types

-### Adding Domain Object Types
+Custom types may be registered via the `addType` function on the opencmt Type 
+registry.

-Custom types may be registered via
-[`openmct.types`]{@link module:openmct.MCT#types}:
-
-```
+eg.
+```javascript
 openmct.types.addType('my-type', {
    label: "My Type",
    description: "This is a type that I added!",
@@ -78,66 +152,98 @@ openmct.types.addType('my-type', {
 });
 ```

-### Adding Views
+The `addType` function accepts two arguments:
+* A `string` key identifying the type. This key is used when specifying a type 
+for an object.
+* An object type specification. An object type definition supports the following 
+attributes      
+    * `label`: a `string` naming this object type
+    * `description`: a `string` specifying a longer-form description of this type
+    * `initialize`: a `function` which initializes the model for new domain objects 
+    of this type. This can be used for setting default values on an object when 
+    it is instantiated.
+    * `creatable`: A `boolean` indicating whether users should be allowed to create 
+    this type (default: `false`). This will determine whether the type appears 
+    in the `Create` menu.
+    * `cssClass`: A `string` specifying a CSS class to apply to each representation 
+    of this object. This is used for specifying an icon to appear next to each 
+    object of this type.

-Custom views may be registered based on the region in the application
-where they should appear:
+The [Open MCT Tutorials](https://github.com/openmct/openmct-tutorial) provide a 
+step-by-step examples of writing code for Open MCT that includes a [section on 
+defining a new object type](https://github.com/nasa/openmct-tutorial#step-3---providing-objects).

-* [`openmct.mainViews`]{@link module:openmct.MCT#mainViews} is a registry
-  of views of domain objects which should appear in the main viewing area.
-* [`openmct.inspectors`]{@link module:openmct.MCT#inspectors} is a registry
-  of views of domain objects and/or active selections, which should appear in
-  the Inspector.
-* [`openmct.toolbars`]{@link module:openmct.MCT#toolbars} is a registry
-  of views of domain objects and/or active selections, which should appear in
-  the toolbar area while editing.
-* [`openmct.indicators`]{@link module:openmct.MCT#inspectors} is a registry
-  of views which should appear in the status area of the application.
+## Root Objects

-Example:
+In many cases, you'd like a certain object (or a certain hierarchy of objects) 
+to be accessible from the top level of the application (the tree on the left-hand 
+side of Open MCT.) For example, it is typical to expose a telemetry dictionary 
+as a hierarchy of telemetry-providing domain objects in this fashion.

-```
-openmct.mainViews.addProvider({
-    canView: function (domainObject) {
-        return domainObject.type === 'my-type';
-    },
-    view: function (domainObject) {
-        return new MyView(domainObject);
-    }
-});
+To do so, use the `addRoot` method of the object API.
+
+eg.
+```javascript
+openmct.objects.addRoot({
+        namespace: "my-namespace",
+        key: "my-key"
+    });
 ```

-### Adding a Root-level Object
-
-In many cases, you'd like a certain object (or a certain hierarchy of
-objects) to be accessible from the top level of the application (the
-tree on the left-hand side of Open MCT.) It is typical to expose a telemetry
-dictionary as a hierarchy of telemetry-providing domain objects in this
-fashion.
-
-To do so, use the [`addRoot`]{@link module:openmct.ObjectAPI#addRoot} method
-of the [object API]{@link module:openmct.ObjectAPI}:
-
-```
-openmct.objects.addRoot({ key: "my-key", namespace: "my-namespace" });
-```
+The `addRoot` function takes a single [object identifier](#domain-objects-and-identifiers) 
+as an argument. 

 Root objects are loaded just like any other objects, i.e. via an object
 provider.

-### Adding Composition Providers
+## Object Providers

-The "composition" of a domain object is the list of objects it contains,
-as shown (for example) in the tree for browsing. Open MCT provides a
+An Object Provider is used to build _Domain Objects_, typically retrieved from 
+some source such as a persistence store or telemetry dictionary. In order to 
+integrate telemetry from a new source an object provider will need to be created 
+that can build objects representing telemetry points exposed by the telemetry 
+source. The API call to define a new object provider is fairly straightforward. 
+Here's a very simple example:
+
+```javascript
+openmct.objects.addProvider('example.namespace', {
+    get: function (identifier) {
+        return Promise.resolve({
+            identifier: identifier,
+            name: 'Example Object',
+            type: 'example-object-type'
+        });
+    }
+});
+```
+The `addProvider` function takes two arguments:
+
+* `namespace`: A `string` representing the namespace that this object provider 
+will provide objects for.
+* `provider`: An `object` with a single function, `get`. This function accepts an 
+[Identifier](#domain-objects-and-identifiers) for the object to be provided. 
+It is expected that the `get` function will return a 
+[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) 
+that resolves with the object being requested.
+
+In future, object providers will support other methods to enable other operations 
+with persistence stores, such as creating, updating, and deleting objects.
+
+## Composition Providers
+
+The _composition_ of a domain object is the list of objects it contains, as shown 
+(for example) in the tree for browsing. Open MCT provides a
 [default solution](#default-composition-provider) for composition, but there
 may be cases where you want to provide the composition of a certain object
 (or type of object) dynamically.

-For instance, you may want to populate a hierarchy under a custom root-level
-object based on the contents of a telemetry dictionary.
-To do this, you can add a new CompositionProvider:
+### Adding Composition Providers

-```
+You may want to populate a hierarchy under a custom root-level object based on 
+the contents of a telemetry dictionary. To do this, you can add a new 
+Composition Provider:
+
+```javascript
 openmct.composition.addProvider({
    appliesTo: function (domainObject) {
        return domainObject.type === 'my-type';
@@ -147,20 +253,27 @@ openmct.composition.addProvider({
    }
 });
 ```
+The `addProvider` function accepts a Composition Provider object as its sole 
+argument. A Composition Provider is a javascript object exposing two functions:
+* `appliesTo`: A `function` that accepts a `domainObject` argument, and returns 
+a `boolean` value indicating whether this composition provider applies to the 
+given object.
+* `load`: A `function` that accepts a `domainObject` as an argument, and returns
+a `Promise` that resolves with an array of [Identifier](#domain-objects-and-identifiers).
+These identifiers will be used to fetch Domain Objects from an [Object Provider](#object-provider)

-#### Default Composition Provider
+### Default Composition Provider

-The default composition provider applies to any domain object with
-a `composition` property. The value of `composition` should be an
-array of identifiers, e.g.:
+The default composition provider applies to any domain object with a `composition` 
+property. The value of `composition` should be an array of identifiers, e.g.:

-```js
+```javascript
 var domainObject = {
    name: "My Object",
    type: 'folder',
    composition: [
        {
-            key: '412229c3-922c-444b-8624-736d85516247',
+            id: '412229c3-922c-444b-8624-736d85516247',
            namespace: 'foo'
        },
        {
@@ -171,169 +284,146 @@ var domainObject = {
 };
 ```

-### Adding Telemetry Providers
+## Telemetry Providers

-When connecting to a new telemetry source, you will want to register a new
-[telemetry provider]{@link module:openmct.TelemetryAPI~TelemetryProvider}
-with the [telemetry API]{@link module:openmct.TelemetryAPI#addProvider}:
+When connecting to a new telemetry source, you will need to register a new
+_Telemetry Provider_. A _Telemetry Provider_ retrieves telemetry data from some telemetry 
+source, and exposes them in a way that can be used by Open MCT. A telemetry 
+provider typically can support a one off __request__ for a batch of telemetry data, 
+or it can provide the ability to __subscribe__ to receive new telemetry data when 
+it becomes available, or both.

-```
+```javascript
 openmct.telemetry.addProvider({
-    canProvideTelemetry: function (domainObject) {
-        return domainObject.type === 'my-type';
+    supportsRequest: function (domainObject) {
+        //...
    },
-    properties: function (domainObject) {
-        return [
-            { key: 'value', name: "Temperature", units: "degC" },
-            { key: 'time', name: "UTC" }
-        ];
+    supportsSubscribe: function (domainObject) {
+        //...
    },
-    request: function (domainObject, options) {
-        var telemetryId = domainObject.myTelemetryId;
-        return myAdapter.request(telemetryId, options.start, options.end);
+    request: function (domainObject, options) {    
+        //...
    },
-    subscribe: function (domainObject, callback) {
-        var telemetryId = domainObject.myTelemetryId;
-        myAdapter.subscribe(telemetryId, callback);
-        return myAdapter.unsubscribe.bind(myAdapter, telemetryId, callback);
+    subscribe: function (domainObject, callback, options) {
+        //...
    }
-});
+})
 ```

+A telemetry provider is an object with the following functions defined:
+
+* `supportsRequest`: An __optional__ `function` that accepts a 
+[Domain Object](#domain-objects-and-identifiers) and returns a `boolean` value
+indicating whether or not this provider supports telemetry requests for the 
+given object. If this returns `true` then a `request` function must be defined. 
+* `supportsSubscribe`: An __optional__ `function` that accepts a 
+[Domain Object](#domain-objects-and-identifiers) and returns a `boolean` value 
+indicating whether or not this provider supports telemetry subscriptions. If this 
+returns `true` then a `subscribe` function must also be defined. As with `request`, 
+the return value will typically be conditional, and based on attributes of 
+`domainObject` such as its identifier.
+* `request`: A `function` that returns a `Promise` that will resolve with an `Array` 
+of telemetry in a single query. This function accepts as arguments a 
+[Domain Object](#domain-objects-and-identifiers) and an object containing some 
+[request options](#telemetry-requests). 
+* `subscribe`:  A `function` that accepts a [Domain Object](#domain-objects-and-identifiers),
+a callback `function`, and a [telemetry request](#telemetry-requests). The 
+callback is invoked whenever telemetry is available, and 
+
+
 The implementations for `request` and `subscribe` can vary depending on the
 nature of the endpoint which will provide telemetry. In the example above,
-it is assumed that `myAdapter` contains the specific implementations
-(HTTP requests, WebSocket connections, etc.) associated with some telemetry
+it is assumed that `myAdapter` contains the implementation details
+(such as HTTP requests, WebSocket connections, etc.) associated with some telemetry
 source.

-## Using Open MCT
+For a step-by-step guide to building a telemetry adapter, please see the 
+[Open MCT Tutorials](https://github.com/larkin/openmct-tutorial).

-When implementing new features, it is useful and sometimes necessary to
-utilize functionality exposed by Open MCT.
-
-### Retrieving Composition
-
-To limit which objects are loaded at any given time, the composition of
-a domain object must be requested asynchronously:
-
-```
-openmct.composition(myObject).load().then(function (childObjects) {
-    childObjects.forEach(doSomething);
-});
+### Telemetry Requests
+Telemetry requests support time bounded queries. A call to a _Telemetry Provider_'s 
+`request` function will include an `options` argument. These are simply javascript
+objects with attributes for the request parameters. An example of a telemetry 
+request object with a start and end time is included below:
+```javascript
+{
+    start: 1487981997240,
+    end: 1487982897240
+}
 ```

-### Support Common Gestures
+### Telemetry Data

-Custom views may also want to support common gestures using the
-[gesture API]{@link module:openmct.GestureAPI}. For instance, to make
-a view (or part of a view) selectable:
+Telemetry data is provided to Open MCT by _[Telemetry Providers](#telemetry-providers)_
+in the form of javascript objects. A collection of telemetry values (for example, 
+retrieved in response to a `request`) is represented by an `Array` of javascript 
+objects. These telemetry javascript objects are simply key value pairs.

-```
-openmct.gestures.selectable(myHtmlElement, myDomainObject);
+Typically a telemetry datum will have some timestamp associated with it. This 
+time stamp should have a key that corresponds to some time system supported by 
+Open MCT. If the `UTCTimeSystem` plugin is installed, then the key `utc` can be used.
+   
+An example of a telemetry provider request function that returns a collection of
+mock telemtry data is below:
+
+```javascript
+openmct.telemetry.addProvider({
+    supportsRequest: function (domainObject) {
+        return true
+    },
+    request: function (domainObject, options) {    
+        return Promise.resolve([
+            {
+                'utc': Date.now() - 2000,
+                'value': 1,
+            },
+            {
+                'utc': Date.now() - 1000,
+                'value': 2,
+            },
+            {
+                'utc': Date.now(),
+                'value': 3,
+            }
+        ]);
+    }
+})
 ```

-### Working with Domain Objects
-
-The [object API]{@link module:openmct.ObjectAPI} provides useful methods
-for working with domain objects.
-
-To make changes to a domain object, use the
-[`mutate`]{@link module:openmct.ObjectAPI#mutate} method:
-
-```
-openmct.objects.mutate(myDomainObject, "name", "New name!");
-```
-
-Making modifications in this fashion allows other usages of the domain
-object to remain up to date using the
-[`observe`]{@link module:openmct.ObjectAPI#observe} method:
-
-```
-openmct.objects.observe(myDomainObject, "name", function (newName) {
-    myLabel.textContent = newName;
-});
-```
-
-### Using Telemetry
-
-Very often in Open MCT, you wish to work with telemetry data (for instance,
-to display it in a custom visualization.)
-
-
-### Synchronizing with the Time Conductor
-
-Views which wish to remain synchronized with the state of Open MCT's
-time conductor should utilize
-[`openmct.conductor`]{@link module:openmct.TimeConductor}:
-
-```
-openmct.conductor.on('bounds', function (newBounds) {
-    requestTelemetry(newBounds.start, newBounds.end).then(displayTelemetry);
-});
-```
-
-## Plugins
-
-While you can register new features with Open MCT directly, it is generally
-more useful to package these as a plugin. A plugin is a function that takes
-[`openmct`]{@link module:openmct} as an argument, and performs configuration
-upon `openmct` when invoked.
-
-### Installing Plugins
-
-To install plugins, use the [`install`]{@link module:openmct.MCT#install}
-method:
-
-```
-openmct.install(myPlugin);
-```
-
-The plugin will be invoked to configure Open MCT before it is started.
-
-### Included Plugins
+## Included Plugins

 Open MCT is packaged along with a few general-purpose plugins:

 * `openmct.plugins.CouchDB` is an adapter for using CouchDB for persistence
  of user-created objects. This is a constructor that takes the URL for the
  CouchDB database as a parameter, e.g.
-  `openmct.install(new openmct.plugins.CouchDB('http://localhost:5984/openmct'))`
+```javascript
+openmct.install(openmct.plugins.CouchDB('http://localhost:5984/openmct'))
+```
 * `openmct.plugins.Elasticsearch` is an adapter for using Elasticsearch for
  persistence of user-created objects. This is a
  constructor that takes the URL for the Elasticsearch instance as a
-  parameter, e.g.
-  `openmct.install(new openmct.plugins.CouchDB('http://localhost:9200'))`.
-  Domain objects will be indexed at `/mct/domain_object`.
-* `openmct.plugins.espresso` and `openmct.plugins.snow` are two different
+  parameter. eg.
+```javascript
+openmct.install(openmct.plugins.CouchDB('http://localhost:9200'))
+```
+* `openmct.plugins.Espresso` and `openmct.plugins.Snow` are two different
  themes (dark and light) available for Open MCT. Note that at least one
  of these themes must be installed for Open MCT to appear correctly.
-* `openmct.plugins.localStorage` provides persistence of user-created
+* `openmct.plugins.LocalStorage` provides persistence of user-created
  objects in browser-local storage. This is particularly useful in
  development environments.
-* `openmct.plugins.myItems` adds a top-level folder named "My Items"
+* `openmct.plugins.MyItems` adds a top-level folder named "My Items"
  when the application is first started, providing a place for a
  user to store created items.
-* `openmct.plugins.utcTimeSystem` provides support for using the time
-  conductor with UTC time.
+* `openmct.plugins.UTCTimeSystem` provides a default time system for Open MCT.

 Generally, you will want to either install these plugins, or install
 different plugins that provide persistence and an initial folder
-hierarchy. Installation is as described [above](#installing-plugins):
+hierarchy.

+eg.
+```javascript
+openmct.install(openmct.plugins.LocalStorage());
+openmct.install(openmct.plugins.MyItems());
 ```
-openmct.install(openmct.plugins.localStorage);
-openmct.install(openmct.plugins.myItems);
-```
-
-### Writing Plugins
-
-Plugins configure Open MCT, and should utilize the
-[`openmct`]{@link module:openmct} module to do so, as summarized above in
-"Configuring Open MCT" and "Using Open MCT" above.
-
-### Distributing Plugins
-
-Hosting or downloading plugins is outside of the scope of this documentation.
-We recommend distributing plugins as UMD modules which export a single
-function.
-
--- a/example/generator/src/GeneratorProvider.js
+++ b/example/generator/src/GeneratorProvider.js
@@ -41,6 +41,10 @@ define([
        return domainObject.type === 'generator';
    };

+    GeneratorProvider.prototype.supportsRequest =
+        GeneratorProvider.prototype.supportsSubscribe =
+            GeneratorProvider.prototype.canProvideTelemetry;
+
    GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request) {
        var props = [
            'amplitude',
--- a/example/generator/src/SinewaveConstants.js
+++ b/example/generator/src/SinewaveConstants.js
@@ -19,7 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global define,Promise*/
+/*global define*/

 define({
    START_TIME: Date.now() - 24 * 60 * 60 * 1000 // Now minus a day.
--- a/example/generator/src/SinewaveDeltaFormat.js
+++ b/example/generator/src/SinewaveDeltaFormat.js
@@ -19,12 +19,11 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global define,Promise*/
+/*global define*/

 define(
    ['./SinewaveConstants', 'moment'],
    function (SinewaveConstants, moment) {
-        "use strict";

        var START_TIME = SinewaveConstants.START_TIME,
            FORMAT_REGEX = /^-?\d+:\d+:\d+$/,
--- a/example/generator/src/SinewaveLimitCapability.js
+++ b/example/generator/src/SinewaveLimitCapability.js
--- a/example/generator/src/SinewaveTelemetryProvider.js
+++ b/example/generator/src/SinewaveTelemetryProvider.js
--- a/example/generator/src/SinewaveTelemetrySeries.js
+++ b/example/generator/src/SinewaveTelemetrySeries.js
--- a/example/generator/src/WorkerInterface.js
+++ b/example/generator/src/WorkerInterface.js
--- a/example/generator/bundle.js
+++ b/example/generator/bundle.js
@@ -1,184 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-/*global define*/
-
-define([
-    "./src/SinewaveTelemetryProvider",
-    "./src/SinewaveLimitCapability",
-    "./src/SinewaveDeltaFormat",
-    'legacyRegistry'
-], function (
-    SinewaveTelemetryProvider,
-    SinewaveLimitCapability,
-    SinewaveDeltaFormat,
-    legacyRegistry
-) {
-    "use strict";
-
-    legacyRegistry.register("example/generator", {
-        "name": "Sine Wave Generator",
-        "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
-        "extensions": {
-            "components": [
-                {
-                    "implementation": SinewaveTelemetryProvider,
-                    "type": "provider",
-                    "provides": "telemetryService",
-                    "depends": [
-                        "$q",
-                        "$timeout"
-                    ]
-                }
-            ],
-            "capabilities": [
-                {
-                    "key": "limit",
-                    "implementation": SinewaveLimitCapability
-                }
-            ],
-            "formats": [
-                {
-                    "key": "example.delta",
-                    "implementation": SinewaveDeltaFormat
-                }
-            ],
-            "constants": [
-                {
-                    "key": "TIME_CONDUCTOR_DOMAINS",
-                    "value": [
-                        {
-                            "key": "time",
-                            "name": "Time"
-                        },
-                        {
-                            "key": "yesterday",
-                            "name": "Yesterday"
-                        },
-                        {
-                            "key": "delta",
-                            "name": "Delta"
-                        }
-                    ],
-                    "priority": -1
-                }
-            ],
-            "types": [
-                {
-                    "key": "generator",
-                    "name": "Sine Wave Generator",
-                    "cssClass": "icon-telemetry",
-                    "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
-                    "priority": 10,
-                    "features": "creation",
-                    "model": {
-                        "telemetry": {
-                            "period": 10,
-                            "amplitude": 1,
-                            "offset": 0,
-                            "dataRateInHz": 1
-                        }
-                    },
-                    "telemetry": {
-                        "source": "generator",
-                        "domains": [
-                            {
-                                "key": "utc",
-                                "name": "Time",
-                                "format": "utc"
-                            },
-                            {
-                                "key": "yesterday",
-                                "name": "Yesterday",
-                                "format": "utc"
-                            },
-                            {
-                                "key": "delta",
-                                "name": "Delta",
-                                "format": "example.delta"
-                            }
-                        ],
-                        "ranges": [
-                            {
-                                "key": "sin",
-                                "name": "Sine"
-                            },
-                            {
-                                "key": "cos",
-                                "name": "Cosine"
-                            }
-                        ]
-                    },
-                    "properties": [
-                        {
-                            "name": "Period",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "period",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "period"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Amplitude",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "amplitude",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "amplitude"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Offset",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "offset",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "offset"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Data Rate (hz)",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "dataRateInHz",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "dataRateInHz"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        }
-                    ]
-                }
-            ]
-        }
-    });
-});
--- a/example/generator/src/generatorWorker.js
+++ b/example/generator/src/generatorWorker.js
--- a/example/generator/plugin.js
+++ b/example/generator/plugin.js
@@ -0,0 +1,171 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    "./GeneratorProvider",
+    "./SinewaveLimitCapability",
+    "./SinewaveDeltaFormat"
+], function (
+    GeneratorProvider,
+    SinewaveLimitCapability,
+    SinewaveDeltaFormat
+) {
+
+    var legacyExtensions = {
+        "capabilities": [
+            {
+                "key": "limit",
+                "implementation": SinewaveLimitCapability
+            }
+        ],
+        "formats": [
+            {
+                "key": "example.delta",
+                "implementation": SinewaveDeltaFormat
+            }
+        ],
+        "constants": [
+            {
+                "key": "TIME_CONDUCTOR_DOMAINS",
+                "value": [
+                    {
+                        "key": "time",
+                        "name": "Time"
+                    },
+                    {
+                        "key": "yesterday",
+                        "name": "Yesterday"
+                    },
+                    {
+                        "key": "delta",
+                        "name": "Delta"
+                    }
+                ],
+                "priority": -1
+            }
+        ]
+    }
+
+    return function(openmct){
+        //Register legacy extensions for things not yet supported by the new API
+        Object.keys(legacyExtensions).forEach(function (type){
+            var extensionsOfType = legacyExtensions[type];
+            extensionsOfType.forEach(function (extension) {
+                openmct.legacyExtension(type, extension)
+            })
+        });
+        openmct.types.addType("generator", {
+            label: "Sine Wave Generator",
+            description: "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
+            cssClass: "icon-telemetry",
+            creatable: true,
+            form: [
+                {
+                    name: "Period",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "period",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "period"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Amplitude",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "amplitude",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "amplitude"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Offset",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "offset",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "offset"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Data Rate (hz)",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "dataRateInHz",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "dataRateInHz"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                }
+            ],
+            initialize: function (object) {
+                object.telemetry = {
+                    period: 10,
+                    amplitude: 1,
+                    offset: 0,
+                    dataRateInHz: 1,
+                    domains: [
+                        {
+                            key: "utc",
+                            name: "Time",
+                            format: "utc"
+                        },
+                        {
+                            key: "yesterday",
+                            name: "Yesterday",
+                            format: "utc"
+                        },
+                        {
+                            key: "delta",
+                            name: "Delta",
+                            format: "example.delta"
+                        }
+                    ],
+                    ranges: [
+                        {
+                            key: "sin",
+                            name: "Sine"
+                        },
+                        {
+                            key: "cos",
+                            name: "Cosine"
+                        }
+                    ]
+                };
+            }
+        });
+        openmct.telemetry.addProvider(new GeneratorProvider());
+    };
+
+});
--- a/example/imagery/src/ImageTelemetry.js
+++ b/example/imagery/src/ImageTelemetry.js
@@ -31,10 +31,25 @@ define(

        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"
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18731.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18732.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18733.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18734.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18735.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18736.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18737.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18738.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18739.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18740.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18741.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18742.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18743.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18744.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18745.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18746.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18747.jpg",
+                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18748.jpg"
+
            ].map(function (url, index) {
                return {
                    timestamp: firstObservedTime + 1000 * index,
--- a/index.html
+++ b/index.html
@@ -31,14 +31,15 @@
        require(['openmct'], function (openmct) {
            [
                'example/imagery',
-                'example/eventGenerator',
-                'example/generator'
+                'example/eventGenerator'
            ].forEach(
                openmct.legacyRegistry.enable.bind(openmct.legacyRegistry)
            );
-            openmct.install(openmct.plugins.myItems);
-            openmct.install(openmct.plugins.localStorage);
-            openmct.install(openmct.plugins.espresso);
+            openmct.install(openmct.plugins.MyItems());
+            openmct.install(openmct.plugins.LocalStorage());
+            openmct.install(openmct.plugins.Espresso());
+            openmct.install(openmct.plugins.Generator());
+            openmct.install(openmct.plugins.UTCTimeSystem());
            openmct.start();
        });
    </script>
--- a/openmct.js
+++ b/openmct.js
@@ -84,5 +84,11 @@ define([
        return new Main().run(defaultRegistry);
    });

+    // For now, install conductor by default
+    openmct.install(openmct.plugins.Conductor({
+        showConductor: false
+    }));
+
+
    return openmct;
 });
--- a/platform/commonUI/general/res/sass/_inspector.scss
+++ b/platform/commonUI/general/res/sass/_inspector.scss
@@ -76,17 +76,18 @@
                &:not(.first) {
                    border-top: 1px solid $colorFormLines;
                }
-                .form-row {
-                    @include align-items(center);
-                    border: none;
-                    padding: $interiorMarginSm 0;
-                    .label {
-                        min-width: 80px;
-                    }
-                    input[type='text'],
-                    input[type='search'] {
-                        width: 100%;
-                    }
+            }
+            .form-row {
+                @include align-items(center);
+                border: none !important;
+                margin-bottom: 0 !important;
+                padding: $interiorMarginSm 0;
+                .label {
+                    min-width: 80px;
+                }
+                input[type='text'],
+                input[type='search'] {
+                    width: 100%;
                }
            }
        }
--- a/platform/commonUI/general/res/sass/startup-base.scss
+++ b/platform/commonUI/general/res/sass/startup-base.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";
@import "logo-and-bg";

--- a/platform/commonUI/themes/espresso/res/sass/theme-espresso.scss
+++ b/platform/commonUI/themes/espresso/res/sass/theme-espresso.scss
@@ -19,7 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";

@import "../../../../general/res/sass/_mixins";
--- a/platform/commonUI/themes/snow/res/sass/theme-snow.scss
+++ b/platform/commonUI/themes/snow/res/sass/theme-snow.scss
@@ -19,7 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";

@import "../../../../general/res/sass/_mixins";
--- a/platform/features/conductor/compatibility/bundle.js
+++ b/platform/features/conductor/compatibility/bundle.js
@@ -21,11 +21,9 @@
 *****************************************************************************/

 define([
-    "./src/ConductorTelemetryDecorator",
    "./src/ConductorRepresenter",
    'legacyRegistry'
 ], function (
-    ConductorTelemetryDecorator,
    ConductorRepresenter,
    legacyRegistry
 ) {
@@ -39,16 +37,6 @@ define([
                        "openmct"
                    ]
                }
-            ],
-            "components": [
-                {
-                    "type": "decorator",
-                    "provides": "telemetryService",
-                    "implementation": ConductorTelemetryDecorator,
-                    "depends": [
-                        "openmct"
-                    ]
-                }
            ]
        }
    });
--- a/platform/features/conductor/compatibility/src/ConductorTelemetryDecorator.js
+++ b/platform/features/conductor/compatibility/src/ConductorTelemetryDecorator.js
@@ -1,87 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    function () {
-
-        /**
-         * Decorates the `telemetryService` such that requests are
-         * mediated by the time conductor. This is a modified version of the
-         * decorator used in the old TimeConductor that integrates with the
-         * new TimeConductor API.
-         *
-         * @constructor
-         * @memberof platform/features/conductor
-         * @implements {TelemetryService}
-         * @param {platform/features/conductor.TimeConductor} conductor
-         *        the service which exposes the global time conductor
-         * @param {TelemetryService} telemetryService the decorated service
-         */
-        function ConductorTelemetryDecorator(openmct, telemetryService) {
-            this.conductor = openmct.conductor;
-            this.telemetryService = telemetryService;
-
-            this.amendRequests = ConductorTelemetryDecorator.prototype.amendRequests.bind(this);
-        }
-
-        function amendRequest(request, bounds, timeSystem) {
-            request = request || {};
-            request.start = bounds.start;
-            request.end = bounds.end;
-            request.domain = timeSystem.metadata.key;
-
-            return request;
-        }
-
-        ConductorTelemetryDecorator.prototype.amendRequests = function (requests) {
-            var bounds = this.conductor.bounds(),
-                timeSystem = this.conductor.timeSystem();
-
-            return (requests || []).map(function (request) {
-                return amendRequest(request, bounds, timeSystem);
-            });
-        };
-
-        ConductorTelemetryDecorator.prototype.requestTelemetry = function (requests) {
-            return this.telemetryService
-                .requestTelemetry(this.amendRequests(requests));
-        };
-
-        ConductorTelemetryDecorator.prototype.subscribe = function (callback, requests) {
-            var unsubscribeFunc = this.telemetryService.subscribe(callback, this.amendRequests(requests)),
-                conductor = this.conductor,
-                self = this;
-
-            function amendRequests() {
-                return self.amendRequests(requests);
-            }
-
-            conductor.on('bounds', amendRequests);
-            return function () {
-                unsubscribeFunc();
-                conductor.off('bounds', amendRequests);
-            };
-        };
-
-        return ConductorTelemetryDecorator;
-    }
-);
--- a/platform/features/conductor/core/bundle.js
+++ b/platform/features/conductor/core/bundle.js
@@ -70,8 +70,9 @@ define([
                        "$location",
                        "openmct",
                        "timeConductorViewService",
-                        "timeSystems[]",
-                        "formatService"
+                        "formatService",
+                        "DEFAULT_TIMECONDUCTOR_MODE",
+                        "SHOW_TIMECONDUCTOR"
                    ]
                },
                {
@@ -150,6 +151,13 @@ define([
                    "link": "https://github.com/d3/d3/blob/master/LICENSE"
                }
            ],
+            "constants": [
+                {
+                    "key": "DEFAULT_TIMECONDUCTOR_MODE",
+                    "value": "realtime",
+                    "priority": "fallback"
+                }
+            ],
            "formats": [
                {
                    "key": "number",
--- a/platform/features/conductor/core/res/sass/time-conductor-espresso.scss
+++ b/platform/features/conductor/core/res/sass/time-conductor-espresso.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";
@import "../../../../../commonUI/general/res/sass/constants";
@import "../../../../../commonUI/general/res/sass/mixins";
--- a/platform/features/conductor/core/res/sass/time-conductor-snow.scss
+++ b/platform/features/conductor/core/res/sass/time-conductor-snow.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";
@import "../../../../../commonUI/general/res/sass/constants";
@import "../../../../../commonUI/general/res/sass/mixins";
--- a/platform/features/conductor/core/res/templates/time-conductor.html
+++ b/platform/features/conductor/core/res/templates/time-conductor.html
@@ -1,8 +1,7 @@
 <!-- Parent holder for time conductor. follow-mode | fixed-mode -->
 <div ng-controller="TimeConductorController as tcController"
    class="holder grows flex-elem l-flex-row l-time-conductor {{modeModel.selectedKey}}-mode {{timeSystemModel.selected.metadata.key}}-time-system"
-        ng-class="{'status-panning': tcController.panning}">
-
+        ng-class="{'status-panning': tcController.panning}" ng-show="showTimeConductor">
    <div class="flex-elem holder time-conductor-icon">
        <div class="hand-little"></div>
        <div class="hand-big"></div>
--- a/platform/features/conductor/core/src/ui/TimeConductorController.js
+++ b/platform/features/conductor/core/src/ui/TimeConductorController.js
@@ -40,7 +40,16 @@ define(
         * @memberof platform.features.conductor
         * @constructor
         */
-        function TimeConductorController($scope, $window, $location, openmct, conductorViewService, timeSystems, formatService) {
+        function TimeConductorController(
+            $scope,
+            $window,
+            $location,
+            openmct,
+            conductorViewService,
+            formatService,
+            DEFAULT_MODE,
+            SHOW_TIMECONDUCTOR
+        ) {

            var self = this;

@@ -60,10 +69,14 @@ define(
            this.validation = new TimeConductorValidation(this.conductor);
            this.formatService = formatService;

+            //Check if the default mode defined is actually available
+            if (this.modes[DEFAULT_MODE] === undefined) {
+                DEFAULT_MODE = 'fixed';
+            }
+            this.DEFAULT_MODE = DEFAULT_MODE;
+
            // Construct the provided time system definitions
-            this.timeSystems = timeSystems.map(function (timeSystemConstructor) {
-                return timeSystemConstructor();
-            });
+            this.timeSystems = conductorViewService.systems;

            this.initializeScope();
            var searchParams = JSON.parse(JSON.stringify(this.$location.search()));
@@ -94,6 +107,8 @@ define(
            //Respond to any subsequent conductor changes
            this.conductor.on('bounds', this.changeBounds);
            this.conductor.on('timeSystem', this.changeTimeSystem);
+
+            this.$scope.showTimeConductor = SHOW_TIMECONDUCTOR;
        }

        /**
@@ -139,7 +154,7 @@ define(
            //Set mode from url if changed
            if (searchParams[SEARCH.MODE] === undefined ||
                searchParams[SEARCH.MODE] !== this.$scope.modeModel.selectedKey) {
-                this.setMode(searchParams[SEARCH.MODE] || "fixed");
+                this.setMode(searchParams[SEARCH.MODE] || this.DEFAULT_MODE);
            }

            if (searchParams[SEARCH.TIME_SYSTEM] &&
--- a/platform/features/conductor/core/src/ui/TimeConductorControllerSpec.js
+++ b/platform/features/conductor/core/src/ui/TimeConductorControllerSpec.js
@@ -130,8 +130,10 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                    mockLocation,
                    {conductor: mockTimeConductor},
                    mockConductorViewService,
-                    mockTimeSystems,
-                    mockFormatService
+                    mockFormatService,
+                    'fixed',
+                    true
+
                );

                tsListener = getListener(mockTimeConductor.on, "timeSystem");
@@ -244,7 +246,6 @@ define(['./TimeConductorController'], function (TimeConductorController) {
            var ts1Metadata;
            var ts2Metadata;
            var ts3Metadata;
-            var mockTimeSystemConstructors;

            beforeEach(function () {
                mode = "realtime";
@@ -276,11 +277,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                ];

                //Wrap in mock constructors
-                mockTimeSystemConstructors = mockTimeSystems.map(function (mockTimeSystem) {
-                    return function () {
-                        return mockTimeSystem;
-                    };
-                });
+                mockConductorViewService.systems = mockTimeSystems;

                controller = new TimeConductorController(
                    mockScope,
@@ -288,8 +285,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                    mockLocation,
                    {conductor: mockTimeConductor},
                    mockConductorViewService,
-                    mockTimeSystemConstructors,
-                    mockFormatService
+                    mockFormatService,
+                    "fixed",
+                    true
                );
            });

@@ -434,12 +432,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                    }
                };

-                mockTimeSystems.push(function () {
-                    return timeSystem;
-                });
-                mockTimeSystems.push(function () {
-                    return otherTimeSystem;
-                });
+                mockConductorViewService.systems = [timeSystem, otherTimeSystem];

                urlBounds = {
                    start: 100,
@@ -467,8 +460,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                    mockLocation,
                    {conductor: mockTimeConductor},
                    mockConductorViewService,
-                    mockTimeSystems,
-                    mockFormatService
+                    mockFormatService,
+                    "fixed",
+                    true
                );

                spyOn(controller, "setMode");
--- a/platform/features/conductor/utcTimeSystem/bundle.js
+++ b/platform/features/conductor/utcTimeSystem/bundle.js
@@ -34,23 +34,7 @@ define([
                    "implementation": UTCTimeSystem,
                    "depends": ["$timeout"]
                }
-            ],
-            "runs": [
-                {
-                    "implementation": function (openmct, $timeout) {
-                        // Temporary shim to initialize the time conductor to
-                        // something
-                        if (!openmct.conductor.timeSystem()) {
-                            var utcTimeSystem = new UTCTimeSystem($timeout);
-
-                            openmct.conductor.timeSystem(utcTimeSystem, utcTimeSystem.defaults().bounds);
-                        }
-                    },
-                    "depends": ["openmct", "$timeout"],
-                    "priority": "fallback"
-                }
            ]
        }
    });
-
 });
--- a/platform/features/conductor/utcTimeSystem/src/UTCTimeSystem.js
+++ b/platform/features/conductor/utcTimeSystem/src/UTCTimeSystem.js
@@ -48,6 +48,7 @@ define([

        this.fmts = ['utc'];
        this.sources = [new LocalClock($timeout, DEFAULT_PERIOD)];
+        this.defaultValues = undefined;
    }

    UTCTimeSystem.prototype = Object.create(TimeSystem.prototype);
@@ -64,18 +65,25 @@ define([
        return this.sources;
    };

-    UTCTimeSystem.prototype.defaults = function () {
-        var now = Math.ceil(Date.now() / 1000) * 1000;
-        var ONE_MINUTE = 60 * 1 * 1000;
-        var FIFTY_YEARS = 50 * 365 * 24 * 60 * 60 * 1000;
+    UTCTimeSystem.prototype.defaults = function (defaults) {
+        if (arguments.length > 0) {
+            this.defaultValues = defaults;
+        }

-        return {
-            key: 'utc-default',
-            name: 'UTC time system defaults',
-            deltas: {start: FIFTEEN_MINUTES, end: 0},
-            bounds: {start: now - FIFTEEN_MINUTES, end: now},
-            zoom: {min: FIFTY_YEARS, max: ONE_MINUTE}
-        };
+        if (this.defaultValues === undefined) {
+            var now = Math.ceil(Date.now() / 1000) * 1000;
+            var ONE_MINUTE = 60 * 1 * 1000;
+            var FIFTY_YEARS = 50 * 365 * 24 * 60 * 60 * 1000;
+
+            this.defaultValues = {
+                key: 'utc-default',
+                name: 'UTC time system defaults',
+                deltas: {start: FIFTEEN_MINUTES, end: 0},
+                bounds: {start: now - FIFTEEN_MINUTES, end: now},
+                zoom: {min: FIFTY_YEARS, max: ONE_MINUTE}
+            };
+        }
+        return this.defaultValues;
    };

    return UTCTimeSystem;
--- a/platform/features/pages/bundle.js
+++ b/platform/features/pages/bundle.js
@@ -47,7 +47,6 @@ define([
                            "key": "url",
                            "name": "URL",
                            "control": "textfield",
-                            "pattern": "^(ftp|https?)\\:\\/\\/\\w+(\\.\\w+)*(\\:\\d+)?(\\/\\S*)*$",
                            "required": true,
                            "cssClass": "l-input-lg"
                        }
--- a/platform/features/table/src/TelemetryCollection.js
+++ b/platform/features/table/src/TelemetryCollection.js
@@ -112,22 +112,6 @@ define(
            this.lastBounds = bounds;
        };

-        /**
-         * Determines is a given telemetry datum is within the bounds currently
-         * defined for this telemetry collection.
-         * @private
-         * @param datum
-         * @returns {boolean}
-         */
-        TelemetryCollection.prototype.inBounds = function (datum) {
-            var noBoundsDefined = !this.lastBounds || (this.lastBounds.start === undefined && this.lastBounds.end === undefined);
-            var withinBounds =
-                _.get(datum, this.sortField) >= this.lastBounds.start &&
-                _.get(datum, this.sortField) <= this.lastBounds.end;
-
-            return noBoundsDefined || withinBounds;
-        };
-
        /**
         * Adds an individual item to the collection. Used internally only
         * @private
@@ -173,9 +157,10 @@ define(
                // based on time stamp because the array is guaranteed ordered due
                // to sorted insertion.
                var startIx = _.sortedIndex(array, item, this.sortField);
+                var endIx;

                if (startIx !== array.length) {
-                    var endIx = _.sortedLastIndex(array, item, this.sortField);
+                    endIx = _.sortedLastIndex(array, item, this.sortField);

                    // Create an array of potential dupes, based on having the
                    // same time stamp
@@ -185,7 +170,7 @@ define(
                }

                if (!isDuplicate) {
-                    array.splice(startIx, 0, item);
+                    array.splice(endIx || startIx, 0, item);

                    //Return true if it was added and in bounds
                    return array === this.telemetry;
--- a/platform/features/table/src/controllers/MCTTableController.js
+++ b/platform/features/table/src/controllers/MCTTableController.js
@@ -425,6 +425,38 @@ define(
            }
        };

+        /**
+         * Finds the correct insertion point for a new row, which takes into
+         * account duplicates to make sure new rows are inserted in a way that
+         * maintains arrival order.
+         *
+         * @private
+         * @param {Array} searchArray
+         * @param {Object} searchElement Object to find the insertion point for
+         */
+        MCTTableController.prototype.findInsertionPoint = function (searchArray, searchElement) {
+            //First, use a binary search to find the correct insertion point
+            var index = this.binarySearch(searchArray, searchElement, 0, searchArray.length - 1);
+            var testIndex = index;
+
+            //It's possible that the insertion point is a duplicate of the element to be inserted
+            var isDupe = function () {
+                return this.sortComparator(searchElement,
+                        searchArray[testIndex][this.$scope.sortColumn].text) === 0;
+            }.bind(this);
+
+            // In the event of a duplicate, scan left or right (depending on
+            // sort order) to find an insertion point that maintains order received
+            while (testIndex >= 0 && testIndex < searchArray.length && isDupe()) {
+                if (this.$scope.sortDirection === 'asc') {
+                    index = ++testIndex;
+                } else {
+                    index = testIndex--;
+                }
+            }
+            return index;
+        };
+
        /**
         * @private
         */
@@ -439,9 +471,9 @@ define(
                case -1:
                    return this.binarySearch(searchArray, searchElement, min,
                        sampleAt - 1);
-                case 0 :
+                case 0:
                    return sampleAt;
-                case 1 :
+                case 1:
                    return this.binarySearch(searchArray, searchElement,
                        sampleAt + 1, max);
            }
@@ -458,7 +490,7 @@ define(
                index = array.length;
            } else {
                //Sort is enabled, perform binary search to find insertion point
-                index = this.binarySearch(array, element[this.$scope.sortColumn].text, 0, array.length - 1);
+                index = this.findInsertionPoint(array, element[this.$scope.sortColumn].text);
            }
            if (index === -1) {
                array.unshift(element);
--- a/platform/features/table/src/controllers/TelemetryTableController.js
+++ b/platform/features/table/src/controllers/TelemetryTableController.js
@@ -72,7 +72,7 @@ define(
             * Create a new format object from legacy object, and replace it
             * when it changes
             */
-            this.newObject = objectUtils.toNewFormat($scope.domainObject.getModel(),
+            this.domainObject = objectUtils.toNewFormat($scope.domainObject.getModel(),
                $scope.domainObject.getId());

            _.bindAll(this, [
@@ -144,9 +144,9 @@ define(
                this.unobserveObject();
            }

-            this.unobserveObject = this.openmct.objects.observe(this.newObject, "*",
+            this.unobserveObject = this.openmct.objects.observe(this.domainObject, "*",
                    function (domainObject) {
-                        this.newObject = domainObject;
+                        this.domainObject = domainObject;
                        this.getData();
                    }.bind(this)
                );
@@ -364,11 +364,8 @@ define(
            var telemetryApi = this.openmct.telemetry;
            var telemetryCollection = this.telemetry;
            //Set table max length to avoid unbounded growth.
-            //var maxRows = 100000;
-            var maxRows = Number.MAX_VALUE;
            var limitEvaluator;
            var added = false;
-            var scope = this.$scope;
            var table = this.table;

            this.subscriptions.forEach(function (subscription) {
@@ -379,16 +376,6 @@ define(
            function newData(domainObject, datum) {
                limitEvaluator = telemetryApi.limitEvaluator(domainObject);
                added = telemetryCollection.add([table.getRowValues(limitEvaluator, datum)]);
-
-                //Inform table that a new row has been added
-                if (scope.rows.length > maxRows) {
-                    scope.$broadcast('remove:rows', scope.rows[0]);
-                    scope.rows.shift();
-                }
-                if (!scope.loading && added) {
-                    scope.$broadcast('add:row',
-                        scope.rows.length - 1);
-                }
            }

            objects.forEach(function (object) {
@@ -399,6 +386,42 @@ define(
            return objects;
        };

+        /**
+         * Return an array of telemetry objects in this view that should be
+         * subscribed to.
+         * @private
+         * @returns {Promise<Array>} a promise that resolves with an array of
+         * telemetry objects in this view.
+         */
+        TelemetryTableController.prototype.getTelemetryObjects = function () {
+            var telemetryApi = this.openmct.telemetry;
+            var compositionApi = this.openmct.composition;
+
+            function filterForTelemetry(objects) {
+                return objects.filter(telemetryApi.canProvideTelemetry.bind(telemetryApi));
+            }
+
+            /*
+             * If parent object is a telemetry object, subscribe to it. Do not
+             * test composees.
+             */
+            if (telemetryApi.canProvideTelemetry(this.domainObject)) {
+                return Promise.resolve([this.domainObject]);
+            } else {
+                /*
+                 * If parent object is not a telemetry object, subscribe to all
+                 * composees that are telemetry producing objects.
+                 */
+                var composition = compositionApi.get(this.domainObject);
+
+                if (composition) {
+                    return composition
+                        .load()
+                        .then(filterForTelemetry);
+                }
+            }
+        };
+
        /**
         * Request historical data, and subscribe to for real-time data.
         * @private
@@ -406,10 +429,7 @@ define(
         * established, and historical telemetry is received and processed.
         */
        TelemetryTableController.prototype.getData = function () {
-            var telemetryApi = this.openmct.telemetry;
-            var compositionApi = this.openmct.composition;
            var scope = this.$scope;
-            var newObject = this.newObject;

            this.telemetry.clear();
            this.telemetry.bounds(this.openmct.conductor.bounds());
@@ -421,28 +441,9 @@ define(
                console.error(e.stack);
            }

-            function filterForTelemetry(objects) {
-                return objects.filter(telemetryApi.canProvideTelemetry.bind(telemetryApi));
-            }
-
-            function getDomainObjects() {
-                var objects = [newObject];
-                var composition = compositionApi.get(newObject);
-
-                if (composition) {
-                    return composition
-                        .load()
-                        .then(function (children) {
-                            return objects.concat(children);
-                        });
-                } else {
-                    return Promise.resolve(objects);
-                }
-            }
            scope.rows = [];

-            return getDomainObjects()
-                .then(filterForTelemetry)
+            return this.getTelemetryObjects()
                .then(this.loadColumns)
                .then(this.subscribeToNewData)
                .then(this.getHistoricalData)
--- a/platform/features/table/test/TelemetryCollectionSpec.js
+++ b/platform/features/table/test/TelemetryCollectionSpec.js
@@ -138,6 +138,27 @@ define(
                        };
                        collection.add([addedObjectB, addedObjectA]);

+                        expect(collection.telemetry[11]).toBe(addedObjectB);
+                    }
+                );
+                it("maintains insertion order in the case of duplicate time stamps",
+                    function () {
+                        var addedObjectA = {
+                            timestamp: 10000,
+                            value: {
+                                integer: 10,
+                                text: integerTextMap[10]
+                            }
+                        };
+                        var addedObjectB = {
+                            timestamp: 10000,
+                            value: {
+                                integer: 11,
+                                text: integerTextMap[11]
+                            }
+                        };
+                        collection.add([addedObjectA, addedObjectB]);
+
                        expect(collection.telemetry[11]).toBe(addedObjectB);
                    }
                );
--- a/platform/features/table/test/controllers/MCTTableControllerSpec.js
+++ b/platform/features/table/test/controllers/MCTTableControllerSpec.js
@@ -459,14 +459,14 @@ define(

                        beforeEach(function () {
                            row4 = {
-                                'col1': {'text': 'row5 col1'},
+                                'col1': {'text': 'row4 col1'},
                                'col2': {'text': 'xyz'},
-                                'col3': {'text': 'row5 col3'}
+                                'col3': {'text': 'row4 col3'}
                            };
                            row5 = {
-                                'col1': {'text': 'row6 col1'},
+                                'col1': {'text': 'row5 col1'},
                                'col2': {'text': 'aaa'},
-                                'col3': {'text': 'row6 col3'}
+                                'col3': {'text': 'row5 col3'}
                            };
                            row6 = {
                                'col1': {'text': 'row6 col1'},
@@ -490,6 +490,71 @@ define(
                            expect(mockScope.displayRows[3].col2.text).toEqual('ggg');
                        });

+                        it('Inserts duplicate values for sort column in order received when sorted descending', function () {
+                            mockScope.sortColumn = 'col2';
+                            mockScope.sortDirection = 'desc';
+
+                            mockScope.displayRows = controller.sortRows(testRows.slice(0));
+
+                            var row6b = {
+                                'col1': {'text': 'row6b col1'},
+                                'col2': {'text': 'ggg'},
+                                'col3': {'text': 'row6b col3'}
+                            };
+                            var row6c = {
+                                'col1': {'text': 'row6c col1'},
+                                'col2': {'text': 'ggg'},
+                                'col3': {'text': 'row6c col3'}
+                            };
+
+                            controller.addRows(undefined, [row4, row5]);
+                            controller.addRows(undefined, [row6, row6b, row6c]);
+                            expect(mockScope.displayRows[0].col2.text).toEqual('xyz');
+                            expect(mockScope.displayRows[7].col2.text).toEqual('aaa');
+
+                            // Added duplicate rows
+                            expect(mockScope.displayRows[2].col2.text).toEqual('ggg');
+                            expect(mockScope.displayRows[3].col2.text).toEqual('ggg');
+                            expect(mockScope.displayRows[4].col2.text).toEqual('ggg');
+
+                            // Check that original order is maintained with dupes
+                            expect(mockScope.displayRows[2].col3.text).toEqual('row6c col3');
+                            expect(mockScope.displayRows[3].col3.text).toEqual('row6b col3');
+                            expect(mockScope.displayRows[4].col3.text).toEqual('row6 col3');
+                        });
+
+                        it('Inserts duplicate values for sort column in order received when sorted ascending', function () {
+                            mockScope.sortColumn = 'col2';
+                            mockScope.sortDirection = 'asc';
+
+                            mockScope.displayRows = controller.sortRows(testRows.slice(0));
+
+                            var row6b = {
+                                'col1': {'text': 'row6b col1'},
+                                'col2': {'text': 'ggg'},
+                                'col3': {'text': 'row6b col3'}
+                            };
+                            var row6c = {
+                                'col1': {'text': 'row6c col1'},
+                                'col2': {'text': 'ggg'},
+                                'col3': {'text': 'row6c col3'}
+                            };
+
+                            controller.addRows(undefined, [row4, row5, row6]);
+                            controller.addRows(undefined, [row6b, row6c]);
+                            expect(mockScope.displayRows[0].col2.text).toEqual('aaa');
+                            expect(mockScope.displayRows[7].col2.text).toEqual('xyz');
+
+                            // Added duplicate rows
+                            expect(mockScope.displayRows[3].col2.text).toEqual('ggg');
+                            expect(mockScope.displayRows[4].col2.text).toEqual('ggg');
+                            expect(mockScope.displayRows[5].col2.text).toEqual('ggg');
+                            // Check that original order is maintained with dupes
+                            expect(mockScope.displayRows[3].col3.text).toEqual('row6 col3');
+                            expect(mockScope.displayRows[4].col3.text).toEqual('row6b col3');
+                            expect(mockScope.displayRows[5].col3.text).toEqual('row6c col3');
+                        });
+
                        it('Adds new rows at the correct sort position when' +
                            ' sorted and filtered', function () {
                            mockScope.sortColumn = 'col2';
--- a/platform/features/table/test/controllers/TelemetryTableControllerSpec.js
+++ b/platform/features/table/test/controllers/TelemetryTableControllerSpec.js
@@ -161,7 +161,7 @@ define(
                });
            });

-            describe ('Subscribes to new data', function () {
+            describe ('when getting telemetry', function () {
                var mockComposition,
                    mockTelemetryObject,
                    mockChildren,
@@ -173,9 +173,7 @@ define(
                        "load"
                    ]);

-                    mockTelemetryObject = jasmine.createSpyObj("mockTelemetryObject", [
-                        "something"
-                    ]);
+                    mockTelemetryObject = {};
                    mockTelemetryObject.identifier = {
                        key: "mockTelemetryObject"
                    };
@@ -192,22 +190,12 @@ define(
                    });

                    done = false;
-                    controller.getData().then(function () {
-                        done = true;
-                    });
-                });
-
-                it('fetches historical data', function () {
-                    waitsFor(function () {
-                        return done;
-                    }, "getData to return", 100);
-
-                    runs(function () {
-                        expect(mockTelemetryAPI.request).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Object));
-                    });
                });

                it('fetches historical data for the time period specified by the conductor bounds', function () {
+                    controller.getData().then(function () {
+                        done = true;
+                    });
                    waitsFor(function () {
                        return done;
                    }, "getData to return", 100);
@@ -217,17 +205,11 @@ define(
                    });
                });

-                it('subscribes to new data', function () {
-                    waitsFor(function () {
-                        return done;
-                    }, "getData to return", 100);
-
-                    runs(function () {
-                        expect(mockTelemetryAPI.subscribe).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Function), {});
+                it('unsubscribes on view destruction', function () {
+                    controller.getData().then(function () {
+                        done = true;
                    });

-                });
-                it('and unsubscribes on view destruction', function () {
                    waitsFor(function () {
                        return done;
                    }, "getData to return", 100);
@@ -239,6 +221,87 @@ define(
                        expect(unsubscribe).toHaveBeenCalled();
                    });
                });
+                it('fetches historical data for the time period specified by the conductor bounds', function () {
+                    controller.getData().then(function () {
+                        done = true;
+                    });
+                    waitsFor(function () {
+                        return done;
+                    }, "getData to return", 100);
+
+                    runs(function () {
+                        expect(mockTelemetryAPI.request).toHaveBeenCalledWith(mockTelemetryObject, mockBounds);
+                    });
+                });
+
+                it('fetches data for, and subscribes to parent object if it is a telemetry object', function () {
+                    controller.getData().then(function () {
+                        done = true;
+                    });
+                    waitsFor(function () {
+                        return done;
+                    }, "getData to return", 100);
+
+                    runs(function () {
+                        expect(mockTelemetryAPI.subscribe).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Function), {});
+                        expect(mockTelemetryAPI.request).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Object));
+                    });
+                });
+                it('fetches data for, and subscribes to parent object if it is a telemetry object', function () {
+                    controller.getData().then(function () {
+                        done = true;
+                    });
+                    waitsFor(function () {
+                        return done;
+                    }, "getData to return", 100);
+
+                    runs(function () {
+                        expect(mockTelemetryAPI.subscribe).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Function), {});
+                        expect(mockTelemetryAPI.request).toHaveBeenCalledWith(mockTelemetryObject, jasmine.any(Object));
+                    });
+                });
+
+                it('fetches data for, and subscribes to any composees that are telemetry objects if parent is not', function () {
+                    mockChildren = [
+                        {name: "child 1"}
+                    ];
+                    var mockTelemetryChildren = [
+                        {name: "child 2"},
+                        {name: "child 3"},
+                        {name: "child 4"}
+                    ];
+                    mockChildren = mockChildren.concat(mockTelemetryChildren);
+                    mockComposition.load.andReturn(Promise.resolve(mockChildren));
+
+                    mockTelemetryAPI.canProvideTelemetry.andCallFake(function (object) {
+                        if (object === mockTelemetryObject) {
+                            return false;
+                        } else {
+                            return mockTelemetryChildren.indexOf(object) !== -1;
+                        }
+                    });
+
+                    controller.getData().then(function () {
+                        done = true;
+                    });
+
+                    waitsFor(function () {
+                        return done;
+                    }, "getData to return", 100);
+
+                    runs(function () {
+                        mockTelemetryChildren.forEach(function (child) {
+                            expect(mockTelemetryAPI.subscribe).toHaveBeenCalledWith(child, jasmine.any(Function), {});
+                        });
+
+                        mockTelemetryChildren.forEach(function (child) {
+                            expect(mockTelemetryAPI.request).toHaveBeenCalledWith(child, jasmine.any(Object));
+                        });
+
+                        expect(mockTelemetryAPI.subscribe).not.toHaveBeenCalledWith(mockChildren[0], jasmine.any(Function), {});
+                        expect(mockTelemetryAPI.subscribe).not.toHaveBeenCalledWith(mockTelemetryObject[0], jasmine.any(Function), {});
+                    });
+                });
            });

            it('When in real-time mode, enables auto-scroll', function () {
--- a/platform/features/timeline/res/sass/timeline-espresso.scss
+++ b/platform/features/timeline/res/sass/timeline-espresso.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";

@import "../../../../commonUI/general/res/sass/constants";
--- a/platform/features/timeline/res/sass/timeline-snow.scss
+++ b/platform/features/timeline/res/sass/timeline-snow.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";

@import "../../../../commonUI/general/res/sass/constants";
--- a/platform/features/timeline/res/sass/timeline.scss
+++ b/platform/features/timeline/res/sass/timeline.scss
@@ -19,6 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
+$output-bourbon-deprecation-warnings: false;
@import "bourbon";

@import "../../../../commonUI/general/res/sass/constants";
--- a/platform/search/res/templates/search-item.html
+++ b/platform/search/res/templates/search-item.html
@@ -18,14 +18,14 @@
 licenses. See the Open Source Licenses file (LICENSES.md) included with
 this source code distribution or the Licensing information page available
 at runtime from the About dialog for additional information.
--> 
+-->

 <div class="search-result-item l-flex-row flex-elem grows"
     ng-class="{selected: ngModel.selectedObject.getId() === domainObject.getId()}">
    <mct-representation key="'label'"
                        mct-object="domainObject"
                        ng-model="ngModel"
-                        ng-click="ngModel.selectedObject = domainObject"
+                        ng-click="ngModel.allowSelection(domainObject) && ngModel.onSelection(domainObject)"
                        class="l-flex-row flex-elem grows">
    </mct-representation>
-</div>
+</div>
--- a/platform/telemetry/bundle.js
+++ b/platform/telemetry/bundle.js
@@ -79,6 +79,7 @@ define([
                    "key": "telemetry",
                    "implementation": TelemetryCapability,
                    "depends": [
+                        "openmct",
                        "$injector",
                        "$q",
                        "$log"
--- a/platform/telemetry/src/TelemetryCapability.js
+++ b/platform/telemetry/src/TelemetryCapability.js
@@ -24,8 +24,12 @@
 * Module defining TelemetryCapability. Created by vwoeltje on 11/12/14.
 */
 define(
-    [],
-    function () {
+    [
+        '../../../src/api/objects/object-utils'
+    ],
+    function (
+        objectUtils
+    ) {

        var ZERO = function () {
            return 0;
@@ -103,7 +107,7 @@ define(
         * @implements {Capability}
         * @constructor
         */
-        function TelemetryCapability($injector, $q, $log, domainObject) {
+        function TelemetryCapability(openmct, $injector, $q, $log, domainObject) {
            // We could depend on telemetryService directly, but
            // there isn't a platform implementation of this.
            this.initializeTelemetryService = function () {
@@ -118,7 +122,7 @@ define(
                }
            };

-
+            this.openmct = openmct;
            this.$q = $q;
            this.$log = $log;
            this.domainObject = domainObject;
@@ -135,7 +139,9 @@ define(
                type = domainObject.getCapability("type"),
                typeRequest = (type && type.getDefinition().telemetry) || {},
                modelTelemetry = domainObject.getModel().telemetry,
-                fullRequest = Object.create(typeRequest);
+                fullRequest = Object.create(typeRequest),
+                bounds,
+                timeSystem;

            // Add properties from the telemetry field of this
            // specific domain object.
@@ -156,10 +162,37 @@ define(
                fullRequest.key = domainObject.getId();
            }

+            if (request.start === undefined && request.end === undefined) {
+                bounds = this.openmct.conductor.bounds();
+                fullRequest.start = bounds.start;
+                fullRequest.end = bounds.end;
+            }
+
+            if (request.domain === undefined) {
+                timeSystem = this.openmct.conductor.timeSystem();
+                if (timeSystem !== undefined) {
+                    fullRequest.domain = timeSystem.metadata.key;
+                }
+            }
+
            return fullRequest;
        };


+        function asSeries(telemetry, defaultDomain, defaultRange) {
+            return {
+                getRangeValue: function (index, range) {
+                    return telemetry[index][range || defaultRange];
+                },
+                getDomainValue: function (index, domain) {
+                    return telemetry[index][domain || defaultDomain];
+                },
+                getPointCount: function () {
+                    return telemetry.length;
+                }
+            };
+        }
+
        /**
         * Request telemetry data for this specific domain object.
         * @param {TelemetryRequest} [request] parameters for this
@@ -169,11 +202,21 @@ define(
         */
        TelemetryCapability.prototype.requestData = function requestTelemetry(request) {
            // Bring in any defaults from the object model
-            var fullRequest = this.buildRequest(request || {}),
-                source = fullRequest.source,
-                key = fullRequest.key,
-                telemetryService = this.telemetryService ||
-                    this.initializeTelemetryService(); // Lazy initialization
+            var fullRequest = this.buildRequest(request || {});
+            var source = fullRequest.source;
+            var key = fullRequest.key;
+            var telemetryService = this.telemetryService ||
+                this.initializeTelemetryService(); // Lazy initialization
+
+            var domainObject = objectUtils.toNewFormat(this.domainObject.getModel(), this.domainObject.getId());
+            var telemetryAPI = this.openmct.telemetry;
+
+            var metadata = telemetryAPI.getMetadata(domainObject);
+            var defaultDomain = (metadata.valuesForHints(['domain'])[0] || {}).key;
+            var defaultRange = (metadata.valuesForHints(['range'])[0] || {}).key;
+
+            var isLegacyProvider = telemetryAPI.findRequestProvider(domainObject) ===
+                telemetryAPI.legacyProvider;

            // Pull out the relevant field from the larger,
            // structured response.
@@ -187,11 +230,17 @@ define(
                return telemetryService.requestTelemetry([fullRequest]);
            }

-            // If a telemetryService is not available,
-            // getTelemetryService() should reject, and this should
-            // bubble through subsequent then calls.
-            return telemetryService &&
-                requestTelemetryFromService().then(getRelevantResponse);
+            if (isLegacyProvider) {
+                // If a telemetryService is not available,
+                // getTelemetryService() should reject, and this should
+                // bubble through subsequent then calls.
+                return telemetryService &&
+                    requestTelemetryFromService().then(getRelevantResponse);
+            } else {
+                return telemetryAPI.request(domainObject, fullRequest).then(function (telemetry) {
+                    return asSeries(telemetry, defaultDomain, defaultRange);
+                });
+            }
        };

        /**
@@ -217,12 +266,26 @@ define(
         *        subscription request
         */
        TelemetryCapability.prototype.subscribe = function subscribe(callback, request) {
-            var fullRequest = this.buildRequest(request || {}),
-                telemetryService = this.telemetryService ||
-                    this.initializeTelemetryService(); // Lazy initialization
+            var fullRequest = this.buildRequest(request || {});
+            var telemetryService = this.telemetryService ||
+                this.initializeTelemetryService(); // Lazy initialization
+
+            var domainObject = objectUtils.toNewFormat(this.domainObject.getModel(), this.domainObject.getId());
+            var telemetryAPI = this.openmct.telemetry;
+
+            var metadata = telemetryAPI.getMetadata(domainObject);
+            var defaultDomain = (metadata.valuesForHints(['domain'])[0] || {}).key;
+            var defaultRange = (metadata.valuesForHints(['range'])[0] || {}).key;
+
+            var isLegacyProvider = telemetryAPI.findSubscriptionProvider(domainObject) ===
+                telemetryAPI.legacyProvider;
+
+            function update(telemetry) {
+                callback(asSeries([telemetry], defaultDomain, defaultRange));
+            }

            // Unpack the relevant telemetry series
-            function update(telemetries) {
+            function updateLegacy(telemetries) {
                var source = fullRequest.source,
                    key = fullRequest.key,
                    result = ((telemetries || {})[source] || {})[key];
@@ -231,8 +294,13 @@ define(
                }
            }

-            return telemetryService &&
-                telemetryService.subscribe(update, [fullRequest]);
+            // Avoid a loop here...
+            if (isLegacyProvider) {
+                return telemetryService &&
+                    telemetryService.subscribe(updateLegacy, [fullRequest]);
+            } else {
+                return telemetryAPI.subscribe(domainObject, update, fullRequest);
+            }
        };

        /**
--- a/platform/telemetry/test/TelemetryCapabilitySpec.js
+++ b/platform/telemetry/test/TelemetryCapabilitySpec.js
@@ -32,8 +32,9 @@ define(
                mockTelemetryService,
                mockReject,
                mockUnsubscribe,
-                telemetry;
-
+                telemetry,
+                mockTelemetryAPI,
+                mockAPI;

            function mockPromise(value) {
                return {
@@ -43,6 +44,9 @@ define(
                };
            }

+            function noop() {
+            }
+
            beforeEach(function () {
                mockInjector = jasmine.createSpyObj("$injector", ["get"]);
                mockQ = jasmine.createSpyObj("$q", ["when", "reject"]);
@@ -79,7 +83,40 @@ define(
                // Bubble up...
                mockReject.then.andReturn(mockReject);

+                mockTelemetryAPI = jasmine.createSpyObj("telemetryAPI", [
+                    "getMetadata",
+                    "subscribe",
+                    "request",
+                    "findRequestProvider",
+                    "findSubscriptionProvider"
+                ]);
+                mockTelemetryAPI.getMetadata.andReturn({
+                    valuesForHints: function () {
+                        return [];
+                    }
+                });
+
+                mockAPI = {
+                    telemetry: mockTelemetryAPI,
+                    conductor: {
+                        bounds: function () {
+                            return {
+                                start: 0,
+                                end: 1
+                            };
+                        },
+                        timeSystem: function () {
+                            return {
+                                metadata: {
+                                    key: 'mockTimeSystem'
+                                }
+                            };
+                        }
+                    }
+                };
+
                telemetry = new TelemetryCapability(
+                    mockAPI,
                    mockInjector,
                    mockQ,
                    mockLog,
@@ -111,9 +148,9 @@ define(
                        id: "testId", // from domain object
                        source: "testSource", // from model
                        key: "testKey", // from model
-                        start: 42 // from argument
+                        start: 42, // from argument
+                        domain: 'mockTimeSystem'
                    }]);
-
            });

            it("provides an empty series when telemetry is missing", function () {
@@ -129,7 +166,10 @@ define(
                expect(telemetry.getMetadata()).toEqual({
                    id: "testId", // from domain object
                    source: "testSource",
-                    key: "testKey"
+                    key: "testKey",
+                    start: 0,
+                    end: 1,
+                    domain: 'mockTimeSystem'
                });
            });

@@ -143,7 +183,10 @@ define(
                expect(telemetry.getMetadata()).toEqual({
                    id: "testId", // from domain object
                    source: "testSource", // from model
-                    key: "testId" // from domain object
+                    key: "testId", // from domain object
+                    start: 0,
+                    end: 1,
+                    domain: 'mockTimeSystem'
                });
            });

@@ -161,6 +204,57 @@ define(
                expect(mockLog.warn).toHaveBeenCalled();
            });

+            it("if a new style telemetry source is available, use it", function () {
+                var mockProvider = {};
+                mockTelemetryAPI.findSubscriptionProvider.andReturn(mockProvider);
+                telemetry.subscribe(noop, {});
+                expect(mockTelemetryService.subscribe).not.toHaveBeenCalled();
+                expect(mockTelemetryAPI.subscribe).toHaveBeenCalled();
+            });
+
+            it("if a new style telemetry source is not available, revert to old API", function () {
+                mockTelemetryAPI.findSubscriptionProvider.andReturn(undefined);
+                telemetry.subscribe(noop, {});
+                expect(mockTelemetryAPI.subscribe).not.toHaveBeenCalled();
+                expect(mockTelemetryService.subscribe).toHaveBeenCalled();
+            });
+
+            it("Wraps telemetry returned from the new API as a telemetry series", function () {
+                var returnedTelemetry;
+                var mockTelemetry = [{
+                    prop1: "val1",
+                    prop2: "val2",
+                    prop3: "val3"
+                },
+                {
+                    prop1: "val4",
+                    prop2: "val5",
+                    prop3: "val6"
+                }];
+                var mockProvider = {};
+                var dunzo = false;
+
+                mockTelemetryAPI.findRequestProvider.andReturn(mockProvider);
+                mockTelemetryAPI.request.andReturn(Promise.resolve(mockTelemetry));
+
+                telemetry.requestData({}).then(function (data) {
+                    returnedTelemetry = data;
+                    dunzo = true;
+                });
+
+                waitsFor(function () {
+                    return dunzo;
+                });
+
+                runs(function () {
+                    expect(returnedTelemetry.getPointCount).toBeDefined();
+                    expect(returnedTelemetry.getDomainValue).toBeDefined();
+                    expect(returnedTelemetry.getRangeValue).toBeDefined();
+                    expect(returnedTelemetry.getPointCount()).toBe(2);
+                });
+
+            });
+
            it("allows subscriptions to updates", function () {
                var mockCallback = jasmine.createSpy("callback"),
                    subscription = telemetry.subscribe(mockCallback);
@@ -171,7 +265,10 @@ define(
                    [{
                        id: "testId", // from domain object
                        source: "testSource",
-                        key: "testKey"
+                        key: "testKey",
+                        start: 0,
+                        end: 1,
+                        domain: 'mockTimeSystem'
                    }]
                );

@@ -188,8 +285,28 @@ define(
                expect(mockUnsubscribe).not.toHaveBeenCalled();
                subscription(); // should be an unsubscribe function
                expect(mockUnsubscribe).toHaveBeenCalled();
+            });

+            it("applies time conductor bounds if request bounds not defined", function () {
+                var fullRequest = telemetry.buildRequest({});
+                var mockBounds = mockAPI.conductor.bounds();

+                expect(fullRequest.start).toBe(mockBounds.start);
+                expect(fullRequest.end).toBe(mockBounds.end);
+
+                fullRequest = telemetry.buildRequest({start: 10, end: 20});
+
+                expect(fullRequest.start).toBe(10);
+                expect(fullRequest.end).toBe(20);
+            });
+
+            it("applies domain from time system if none defined", function () {
+                var fullRequest = telemetry.buildRequest({});
+                var mockTimeSystem = mockAPI.conductor.timeSystem();
+                expect(fullRequest.domain).toBe(mockTimeSystem.metadata.key);
+
+                fullRequest = telemetry.buildRequest({domain: 'someOtherDomain'});
+                expect(fullRequest.domain).toBe('someOtherDomain');
            });
        });
    }
--- a/src/api/telemetry/TelemetryMetadataManager.js
+++ b/src/api/telemetry/TelemetryMetadataManager.js
@@ -105,7 +105,6 @@ define([
        this.valueMetadatas = this.valueMetadatas.map(applyReasonableDefaults);
    }

-
    /**
     * Get value metadata for a single key.
     */
--- a/src/api/types/TypeRegistry.js
+++ b/src/api/types/TypeRegistry.js
@@ -44,7 +44,7 @@ define(['./Type'], function (Type) {
    }

    /**
-     * Register a new type of view.
+     * Register a new object type.
     *
     * @param {string} typeKey a string identifier for this type
     * @param {module:openmct.Type} type the type to add
--- a/src/defaultRegistry.js
+++ b/src/defaultRegistry.js
@@ -33,7 +33,6 @@ define([
    '../example/export/bundle',
    '../example/extensions/bundle',
    '../example/forms/bundle',
-    '../example/generator/bundle',
    '../example/identity/bundle',
    '../example/imagery/bundle',
    '../example/mobile/bundle',
--- a/src/plugins/plugins.js
+++ b/src/plugins/plugins.js
@@ -21,24 +21,93 @@
 *****************************************************************************/

 define([
-    'lodash'
-], function (_) {
+    'lodash',
+    '../../platform/features/conductor/utcTimeSystem/src/UTCTimeSystem',
+    '../../example/generator/plugin'
+], function (
+    _,
+    UTCTimeSystem,
+    GeneratorPlugin
+) {
    var bundleMap = {
-        couchDB: 'platform/persistence/couch',
-        elasticsearch: 'platform/persistence/elastic',
-        espresso: 'platform/commonUI/themes/espresso',
-        localStorage: 'platform/persistence/local',
-        myItems: 'platform/features/my-items',
-        snow: 'platform/commonUI/themes/snow',
-        utcTimeSystem: 'platform/features/conductor/utcTimeSystem'
+        CouchDB: 'platform/persistence/couch',
+        Elasticsearch: 'platform/persistence/elastic',
+        Espresso: 'platform/commonUI/themes/espresso',
+        LocalStorage: 'platform/persistence/local',
+        MyItems: 'platform/features/my-items',
+        Snow: 'platform/commonUI/themes/snow'
    };

    var plugins = _.mapValues(bundleMap, function (bundleName, pluginName) {
-        return function (openmct) {
-            openmct.legacyRegistry.enable(bundleName);
+        return function pluginConstructor() {
+            return function (openmct) {
+                openmct.legacyRegistry.enable(bundleName);
+            };
        };
    });

+    plugins.UTCTimeSystem = function () {
+        return function (openmct) {
+            openmct.legacyExtension("timeSystems", {
+                "implementation": UTCTimeSystem,
+                "depends": ["$timeout"]
+            });
+        };
+    };
+
+    var conductorInstalled = false;
+
+    plugins.Conductor = function (options) {
+        if (!options) {
+            options = {};
+        }
+
+        function applyDefaults(openmct, timeConductorViewService) {
+            var defaults = {};
+            var timeSystem = timeConductorViewService.systems.find(function (ts) {
+                return ts.metadata.key === options.defaultTimeSystem;
+            });
+            if (timeSystem !== undefined) {
+                defaults = timeSystem.defaults();
+
+                if (options.defaultTimespan !== undefined) {
+                    defaults.deltas.start = options.defaultTimespan;
+                    defaults.bounds.start = defaults.bounds.end - options.defaultTimespan;
+                    timeSystem.defaults(defaults);
+                }
+
+                openmct.conductor.timeSystem(timeSystem, defaults.bounds);
+            }
+        }
+
+        return function (openmct) {
+            openmct.legacyExtension('constants', {
+                key: 'DEFAULT_TIMECONDUCTOR_MODE',
+                value: options.showConductor ? 'fixed' : 'realtime',
+                priority: conductorInstalled ? 'mandatory' : 'fallback'
+            });
+            if (options.showConductor !== undefined) {
+                openmct.legacyExtension('constants', {
+                    key: 'SHOW_TIMECONDUCTOR',
+                    value: options.showConductor,
+                    priority: conductorInstalled ? 'mandatory' : 'fallback'
+                });
+            }
+            if (options.defaultTimeSystem !== undefined || options.defaultTimespan !== undefined) {
+                openmct.legacyExtension('runs', {
+                    implementation: applyDefaults,
+                    depends: ["openmct", "timeConductorViewService"]
+                });
+            }
+
+            if (!conductorInstalled) {
+                openmct.legacyRegistry.enable('platform/features/conductor/core');
+                openmct.legacyRegistry.enable('platform/features/conductor/compatibility');
+            }
+            conductorInstalled = true;
+        };
+    };
+
    plugins.CouchDB = function (url) {
        return function (openmct) {
            if (url) {
@@ -57,7 +126,7 @@ define([
                openmct.legacyRegistry.enable(bundleName);
            }

-            openmct.legacyRegistry.enable(bundleMap.couchDB);
+            openmct.legacyRegistry.enable(bundleMap.CouchDB);
        };
    };

@@ -79,9 +148,13 @@ define([
                openmct.legacyRegistry.enable(bundleName);
            }

-            openmct.legacyRegistry.enable(bundleMap.elasticsearch);
+            openmct.legacyRegistry.enable(bundleMap.Elasticsearch);
        };
    };

+    plugins.Generator = function () {
+        return GeneratorPlugin;
+    };
+
    return plugins;
 });
Author	SHA1	Message	Date
Charles Hacskaylo	6c1dc78dd6	Temp changes to make JSC demo work.	2017-04-03 18:36:09 -05:00
Victor Woeltjen	4d6a0d4931	Merge pull request #1493 from nasa/updated-docs [Docs] Replace existing API documentation with V1 public API docs	2017-03-29 15:05:19 -07:00
Henry	af622599a5	[Docs] Updated API docs to reflect V1 public API Cleaned up docs. Addresses #1473	2017-03-28 12:03:00 -07:00
Pete Richards	12d1302138	Merge pull request #1459 from nasa/open1458 [Plot] Add current conductor bounds to telemetry requests via the old API.	2017-03-27 15:21:47 -07:00
Henry	09419398e9	[Telemetry] Added unit tests for addition of bounds and domains to telemetry requests	2017-03-27 14:53:41 -07:00
Victor Woeltjen	b69e03368a	Merge pull request #1489 from nasa/open1484 [Example] Update images to be more rovery. Fixes #1484	2017-03-27 13:58:26 -07:00
Henry	4196da9f52	[Example] Update images to be more rovery. Fixes #1484	2017-03-26 17:52:14 -07:00
Victor Woeltjen	f09a76e23b	Merge pull request #1478 from nasa/open1266 [Frontend] .form-row cleanups for Inspector	2017-03-21 11:57:39 -07:00
Charles Hacskaylo	16b6a70e22	[Frontend] Cleanups for Inspector Fixes #1266	2017-03-21 10:18:29 -07:00
Andrew Henry	1a7260cc14	Revert "Disable plot by default" This reverts commit `8a75381a3d`.	2017-03-15 12:45:44 +00:00
Andrew Henry	8a75381a3d	Disable plot by default	2017-03-15 12:41:25 +00:00
Pete Richards	c394fe9287	Merge remote-tracking branch 'origin/open1465'	2017-03-03 11:26:25 -08:00
Henry	06f4a955b5	[Tables] Maintain correct insertion order with duplicates. Fixes #1465	2017-03-02 14:29:08 -08:00
Henry	a2bf92db97	[Tables] Subscribe to parent if a telemetry object, or children, but not both. Fixes #1464	2017-03-01 18:55:17 -08:00
Henry	da40f4c96e	[Plot] Add current conductor bounds to telemetry requests via the old API. Replaces telemetry decorator. Fixes #1458	2017-02-27 19:26:51 -08:00
Charles Hacskaylo	6fa5a31217	Merge pull request #1433 from nasa/open1432 [Build] Installed sound suppression system for Bourbon deprecation messages.	2017-02-27 11:12:27 -08:00
Pete Richards	5bc7a701dc	Merge pull request #1455 from nasa/api-conductor-config [Conductor] Allow configuration of conductor defaults	2017-02-24 14:58:50 -08:00
Pete Richards	5cd0516048	Enable TC by default and hide Set up TC so that it is always enabled and defaults to realtime mode. This allows us to have warp-like functionality without showing the TC interface, and simplifies a lot of tutorials. We can still reconfigure the TC by re-installing the plugin with different settings	2017-02-24 14:56:18 -08:00
Pete Richards	48a603ece8	Merge branch 'api-legacy-telemetry-provider-v2'	2017-02-24 14:47:10 -08:00
Pete Richards	abfa56464a	Merge branch 'plugins-functions'	2017-02-24 14:34:54 -08:00
Henry	c1d6e21c3c	Added tests. Fixes #1364	2017-02-23 13:50:14 -08:00
Henry	3bd556a406	Fixed failing tests	2017-02-23 10:21:33 -08:00
Henry	347fb6d882	Fixed style errors	2017-02-23 10:19:10 -08:00
Henry	b3cf7a5d93	Added support for new style telemetry providers from old screens. Converted SWG to new style data adapter	2017-02-23 09:58:46 -08:00
Andrew Henry	c7cffdeb3b	Merge pull request #1453 from nasa/restore-search-navigation [Search] Allow navigation from results	2017-02-22 13:21:03 -08:00
Pete Richards	d45ae7908d	[Search] Allow navigation from results Fix search item so that navigation occurs after clicking on a search result, while still properly preventing navigation when required. Related to #1366	2017-02-22 13:08:54 -08:00
Henry	b10fb4533e	All builtin plugins now standardized as functions	2017-02-22 12:51:49 -08:00
Henry	77d0134e2e	[Build] Added Bourbon deprecation warning suppression system.	2017-02-10 10:03:05 -08:00