1 files changed, 1420 insertions, 0 deletions

diff --git a/node_modules/montage-user/core/event/binding.js b/node_modules/montage-user/core/event/binding.js
new file mode 100755
index 00000000..7a15e5b9
--- /dev/null
+++ b/node_modules/montage-user/core/event/binding.js
@@ -0,0 +1,1420 @@
+/* <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/core/event/binding
+    @requires montage/core/core
+    @requires montage/core/event/mutable-event
+    @requires montage/core/serializer
+    @requires montage/core/deserializer
+    @requires montage/core/event/event-manager
+*/
+
+var Montage = require("montage").Montage,
+    ChangeEventConstructor = require("core/event/mutable-event")._Change,
+    ChangeTypes = require("core/event/mutable-event").ChangeTypes,
+    Serializer = require("core/serializer").Serializer,
+    Deserializer = require("core/deserializer").Deserializer,
+    defaultEventManager = require("core/event/event-manager").defaultEventManager,
+    AT_TARGET = 2;
+
+/**
+    @member external:Array#dispatchChangeEvent
+*/
+Object.defineProperty(Array.prototype, "dispatchChangeEvent", {value: false, enumerable: false, writable: true});
+
+/**
+    @member external:Array#dispatchChangeAtIndexEvent
+*/
+Object.defineProperty(Array.prototype, "dispatchChangeAtIndexEvent", {value: false, enumerable: false, writable: true});
+
+/**
+    @member external:Array#dispatchChangeAtLengthEvent
+*/
+Object.defineProperty(Array.prototype, "dispatchChangeAtLengthEvent", {value: false, enumerable: false, writable: true});
+
+/**
+    @class module:montage/core/event/binding.ChangeEventDispatchingArray
+*/
+var ChangeEventDispatchingArray = exports.ChangeEventDispatchingArray = [];
+
+/**
+    @function external:Array#addContentEventListener
+    @param {string} type Event type
+    @param {object|function} listener Event listener.
+    @param {boolean} useCapture Specifies whether to listen for the event during the capture phase.
+*/
+Object.defineProperty(Array.prototype, "addContentEventListener", {
+    value: function(type, listener, useCapture) {
+    },
+    enumerable: false,
+    configurable: true
+});
+
+
+Object.defineProperty(ChangeEventDispatchingArray, "_splice", {
+    value: Array.prototype.splice,
+    enumerable: false,
+    configurable: true
+});
+
+/**
+    @function module:montage/core/event/binding.ChangeEventDispatchingArray#splice
+    @param {string} type Event type
+    @param {object|function} listener Event listener.
+    @param {boolean} useCapture Specifies whether to listen for the event during the capture phase.
+*/
+Object.defineProperty(ChangeEventDispatchingArray, "splice", {
+    value: function(index, howMany/*[, element1[, ...[, elementN]]]*/) {
+
+        var originalCount = this.length,
+            addedCount = arguments.length - 2, /* elements to add less the index and howMany parameters*/
+            removedCount,
+            netChange,
+            i, changeType, changeEvent, affectedIndexCount, startIndex, changeIndex,
+            removedMembers,
+            addedMembers = [];
+
+        if (addedCount > 0) {
+            addedMembers = this.slice.call(arguments, 2);
+        }
+
+        // Index may be positive (from the front) or negative (from the back) figure out the positive one
+        // now in anticipation of needing it when dispatching events
+        startIndex = index >= 0 ? index : this.length + index;
+        removedMembers = this._splice.apply(this, arguments);
+        removedCount = removedMembers.length;
+
+        netChange = addedCount - removedCount;
+
+        // Find the most accurate propertyChange type for this splice,
+        // For the most part it's considered a modification unless the length of the array was modified
+        // if only to not bother notifying listeners for changes of the length of this array
+        changeType = ChangeTypes.MODIFICATION;
+
+        if (netChange > 0) {
+            changeType = ChangeTypes.ADDITION;
+        } else if (netChange < 0) {
+            changeType = ChangeTypes.REMOVAL;
+        }
+
+        if (this.dispatchChangeEvent) {
+            changeEvent = new ChangeEventConstructor();
+            changeEvent.minus = removedMembers;
+            changeEvent.plus = addedMembers;
+            changeEvent.changeIndex = index;
+            changeEvent.propertyChange = changeType;
+            this.dispatchEvent(changeEvent);
+        }
+
+        if (this.dispatchChangeAtIndexEvent) {
+
+            if (typeof howMany === "undefined") {
+                // no howMany argument given: remove all elements after index?
+                // TODO this may only be in some implementations
+                affectedIndexCount = originalCount + addedCount;
+            } else if (0 === netChange) {
+                // No net change; affects only how many expected
+                affectedIndexCount = addedCount;
+            } else if (netChange > 0) {
+                // Net gain; affects from start to end of original array + net gain
+                affectedIndexCount = (originalCount - startIndex) + (netChange);
+            } else {
+                // Net loss; affects from start to end of original array
+                affectedIndexCount = originalCount - startIndex;
+            }
+
+            for (i = 0; i < affectedIndexCount; i++) {
+                changeIndex = startIndex + i;
+
+                changeEvent = new ChangeEventConstructor();
+                changeEvent.type = "change@" + changeIndex;
+
+                // old value at changeIndex was either:
+                // - removed outright, or replaced
+                // - moved somewhere in the array due to a gain or loss
+                changeEvent.minus = (i < removedCount) ? removedMembers[i] : this[changeIndex + netChange];
+
+                changeEvent.plus = this[changeIndex];
+                changeEvent.changeIndex = changeIndex;
+                changeEvent.propertyChange = changeType;
+                this.dispatchEvent(changeEvent);
+            }
+        }
+
+        return removedMembers;
+    },
+    enumerable: false,
+    configurable: true
+});
+//Removes the first element from an array and returns that element. This method changes the length of the array.
+Object.defineProperty(ChangeEventDispatchingArray, "_shift", {
+    value: Array.prototype.shift,
+    enumerable: false,
+    configurable: true
+});
+
+/**
+    @function module:montage/core/event/binding.ChangeEventDispatchingArray#shift
+*/
+Object.defineProperty(ChangeEventDispatchingArray, "shift", {
+    value: function() {
+
+        if (0 === this.length) {
+            return;
+        }
+
+        var result, i, countI, changeEvent;
+
+        result = this._shift.call(this);
+
+        if (this.dispatchChangeEvent) {
+            changeEvent = new ChangeEventConstructor();
+            changeEvent.minus = result;
+            changeEvent.plus = this[0];
+            changeEvent.changeIndex = 0;
+            changeEvent.propertyChange = ChangeTypes.REMOVAL;
+            this.dispatchEvent(changeEvent);
+        }
+
+        if (this.dispatchChangeAtIndexEvent) {
+            // A single item was just removed form the front; notify all index listeners
+            // (including listeners for the index that is now undefined at the end)
+            for (i = 0,countI = this.length + 1; i < countI; i++) {
+                changeEvent = new ChangeEventConstructor();
+                changeEvent.type = "change@" + i;
+                changeEvent.minus = i === 0 ? result : this[i - 1];
+                changeEvent.plus = this[i];
+                changeEvent.changeIndex = i;
+                changeEvent.propertyChange = ChangeTypes.REMOVAL;
+                this.dispatchEvent(changeEvent);
+            }
+        }
+        return result;
+    },
+    enumerable: false,
+    configurable: true
+});
+
+//Adds one or more elements to the beginning of an array and returns the new length of the array.
+Object.defineProperty(ChangeEventDispatchingArray, "_unshift", {
+    value: Array.prototype.unshift,
+    enumerable: false,
+    configurable: true
+});
+
+/**
+    @function module:montage/core/event/binding.ChangeEventDispatchingArray#unshift
+*/
+Object.defineProperty(ChangeEventDispatchingArray, "unshift", {
+    value: function() {
+
+        var addedCount = arguments.length, i, countI, changeEvent;
+
+        countI = this._unshift.apply(this, arguments);
+
+        if (this.dispatchChangeEvent) {
+            changeEvent = new ChangeEventConstructor();
+            changeEvent.minus = undefined;
+            changeEvent.plus = Array.prototype.slice.call(argume