First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>

1 files changed, 792 insertions, 0 deletions

diff --git a/node_modules/montage/ui/template.js b/node_modules/montage/ui/template.js
new file mode 100755
index 00000000..219fbc5f
--- /dev/null
+++ b/node_modules/montage/ui/template.js
@@ -0,0 +1,792 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+/**
+    @module montage/ui/template
+    @requires montage/core
+    @requires montage/core/serializer
+    @requires montage/core/deserializer
+    @requires montage/core/logger
+*/
+
+exports = typeof exports !== "undefined" ? exports : {};
+
+var Montage = require("montage").Montage;
+var Serializer = require("core/serializer").Serializer;
+var Deserializer = require("core/deserializer").Deserializer;
+var logger = require("core/logger").logger("template");
+var defaultEventManager = require("core/event/event-manager").defaultEventManager;
+var defaultApplication = require("ui/application").application;
+
+/**
+    @class module:montage/ui/template.Template
+    @extends module:montage/core/core.Montage
+*/
+var Template = exports.Template = Montage.create(Montage, /** @lends module:montage/ui/template.Template# */ {
+
+/**
+    The value of the type assigned to a Montage script block.
+    @type {string}
+    @private
+*/
+    _OLD_SCRIPT_TYPE: {value: "text/m-objects"},
+    _SCRIPT_TYPE: {value: "text/montage-serialization"},
+
+/**
+    @private
+*/
+    _document: {value: null},
+/**
+    @private
+*/
+    _externalObjects: {value: null},
+    _ownerSerialization: {value: null},
+    _rootUrl: {value: null},
+/**
+    @private
+*/
+    _isLoaded: {value: false},
+    
+    /**
+    Creates a new Template instance from an HTML document element.
+    @function
+    @return {module:montage/template.Template}
+    */
+    initWithDocument: {value: function(doc) {
+        this._document = doc;
+
+        return this;
+    }},
+    
+    __templatesById: {value: {}},
+    __templateCallbacksByModuleId: {value: {}},
+
+    /**
+    Finds (or creates) the apropriate Template object to be used on a specific module id that represents an HTML page.
+    Any Template object can be used but this function guarantees that only one template object is used per module id reducing the number of objects needed.
+    @function
+    @param {Function} requireFunction The require function to load the template file.
+    @param {String} moduleId The module id.
+    @param {Function} callback The function to call when the template is ready, receives a Template object as a parameter.
+    */
+    templateWithModuleId: {value: function(requireFunction, moduleId, callback) {
+        var template = this.__templatesById[moduleId];
+        var templateCallback = function(template) {
+            template.__templateCallbacksByModuleId[moduleId].forEach(function(value) {
+                value.call(this,template);
+            });
+            delete template.__templateCallbacksByModuleId[moduleId];
+        };
+
+        if(!template) {
+            this.__templateCallbacksByModuleId[moduleId] = [callback];
+            this.__templatesById[moduleId] = (template = this.create().initWithModuleId(requireFunction, moduleId, templateCallback));
+        } else if(!template._isLoaded) {
+            this.__templateCallbacksByModuleId[moduleId].push(callback);
+        }
+        else {
+            callback(template);
+        }
+        return template;
+    }},
+
+    /**
+    Creates a (or uses a previously created one) Template object out of a fully instantiated component.
+    This means creating a markup from the Component object's element and a serialization with the Component object as the owner of the Template.
+    This function guarantees that only one Template object is used per type of component reducing the number of objects needed.
+    @function
+    @param {Function} requireFunction The require function to use to load the modules used in the serialization.
+    @param {String} moduleId The module id.
+    @param {Function} callback The function to call when the template is ready, receives a Template object as a parameter.
+    */
+    templateWithComponent: {value: function(component) {
+        var componentId = component._templateId,
+            template = this.__templatesById[componentId],
+            externalObjects;
+
+        if (!template) {
+            template = this.create().initWithComponent(component);
+            externalObjects = template._externalObjects;
+            // don't store this template if it has external objects, the next component to use might have diferent objects for the same ids
+            if (!externalObjects || Object.keys(externalObjects).length === 0) {
+                this.__templatesById[componentId] = template;
+            }
+        }
+
+        return template;
+    }},
+
+    /**
+     Private reference to template's deserializer.
+     @private
+    */
+    _deserializer: {value:null},
+    
+    /**
+    The deserializer object used by the template.
+    @type {module:montage/core/deserializer.Deserializer}
+    */
+    deserializer: {
+        get: function() {
+            return this._deserializer || (this._deserializer = Deserializer.create().initWithString(this._rootObjectSerialization));
+        }
+    },
+
+    /**
+    Initializes the Template object with a specific module id that represents an HTML page.
+    @function
+    @param {Function} requireFunction The require function to load the template file.
+    @param {String} moduleId The module id.
+    @param {Function} callback The function to call when the template is initialized, receives a Template object as a parameter.
+    @returns itself
+    */
+    initWithModuleId: {value: function(requireFunction, moduleId, callback) {
+        var self = this;
+
+        this.createHtmlDocumentFromModuleId(requireFunction, moduleId, function(doc) {
+            if (!doc) {
+                throw "Template '" + url + "' not found.";
+            }
+            self._isLoaded = true;
+            self.initWithDocument(doc);
+            if (callback) {
+                callback(self);
+            }
+        });
+        return this;
+    }},
+
+    /**
+     @private
+     */
+    _serializer: {
+        value: null
+    },
+
+    /**
+    The serializer object used by the template.
+    @type {module:montage/core/serializer.Serializer}
+    */
+    serializer: {
+        get: function() {
+            return this._serializer || (this._serializer = Serializer.create().initWithRequire(window.require));
+        }
+    },
+
+    /**
+     Initializes a Template object out of a fully instantiated component.
+     This means creating a markup from the Component object's element and a serialization with the Component object as the owner of the Template.
+     @function
+     @param {Object} component The component with which to initialize the template.
+     @returns itself
+     */
+    initWithComponent: {value: function(component) {
+        var htmlDocument = document.implementation.createHTMLDocument(""),
+            serializer = this.serializer,
+            serialization,
+            elements, element,
+            elementsCount, e1, e2;
+
+        this._document = htmlDocument;
+
+        this._ownerSerialization = serializer.serialize({owner: component});
+        this._externalObjects = serializer.getExternalObjects();
+        elements = serializer.getExternalElements();
+
+        var elementsCount = elements.length;
+        if (elementsCount > 1) {
+            // reduce elements to its top fringe O(n^2) ... could probably reduce this (in avg) by removing all children of the component's element first
+            for (var i = 0; i < elementsCount; i++) {
+                e1 = elements[i];
+                for (var j = 0; j < elementsCount; j++) {
+                    if (i !== j) {
+                        var e2 = elements[j];
+                        // is e2 contained in e1?
+                        while ((e2 = e2.parentNode) && e2 !== e1) {
+                        };
+                        if (e2) {
+                            elements.splice(j, 1);
+                            elementsCount--;
+                            j--;
+                            if (i > j) {
+                                i--;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        for (var i = 0; element = elements[i]; i++) {
+            htmlDocument.body.appendChild(htmlDocument.importNode(element, true))
+        }
+        // make sure we use the same require used to create this component to instantiate this reel
+        this._deserializer = this._createDeserializer(this._ownerSerialization);