From b89a7ee8b956c96a1dcee995ea840feddc5d4b27 Mon Sep 17 00:00:00 2001 From: Pierre Frisch Date: Thu, 22 Dec 2011 07:25:50 -0800 Subject: First commit of Ninja to ninja-internal Signed-off-by: Valerio Virgillito --- node_modules/montage/core/event/mutable-event.js | 234 +++++++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100755 node_modules/montage/core/event/mutable-event.js (limited to 'node_modules/montage/core/event/mutable-event.js') diff --git a/node_modules/montage/core/event/mutable-event.js b/node_modules/montage/core/event/mutable-event.js new file mode 100755 index 00000000..edf56951 --- /dev/null +++ b/node_modules/montage/core/event/mutable-event.js @@ -0,0 +1,234 @@ +/* + This file contains proprietary software owned by Motorola Mobility, Inc.
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.
+ (c) Copyright 2011 Motorola Mobility, Inc. All Rights Reserved. + */ +/** + @module montage/core/event/mutable-event + @requires montage + @requires montage/core/enum + */ +var Montage = require("montage").Montage, + Enum = require("core/enum").Enum; + +var ChangeTypes = exports.ChangeTypes = Enum.create().initWithMembers("MODIFICATION", "ADDITION", "REMOVAL"); + +var _eventConstructorsByType = {}; +var _changeEventConstructor = null; +var nullDescriptor = {value: null}; + +var wrapProperty = function(obj, key) { + + var storageKey = "_" + key; + + Montage.defineProperty(obj, storageKey, {value: undefined}); + + Montage.defineProperty(obj, key, { + get:(function(key, storageKey) { + return function() { + return this.hasOwnProperty(storageKey) ? this[storageKey] : (this._event ? this._event[key] : undefined); + }; + })(key, storageKey), + + set: (function(storageKey) { + return function(value) { + this[storageKey] = value; + }; + })(storageKey) + }); +}; +/** + @class module:montage/core/event/mutable-event.MutableEvent +*/ +var MutableEvent = exports.MutableEvent = Montage.create(Montage,/** @lends module:montage/core/event/mutable-event.MutableEvent# */ { + /** + @function + @param {Event} event The original event. + @returns newEvent + */ + fromEvent: { + value: function(event) { + var type = event.type, + constructor = _eventConstructorsByType[type], + newEvent; + if (!constructor) { + constructor = function() { + }; + constructor.prototype = MutableEvent.create()._initPrototypeWithEvent(event); + _eventConstructorsByType[type] = constructor; + } + newEvent = new constructor(); + newEvent._initWithEvent(event); + return newEvent; + } + }, + + // Same arguments as initEvent & initCustomEvent + + /** + @function + @param {Event} type TODO + @param {Event} canBubbleArg TODO + @param {Event} cancelableArg TODO + @param {Event} data TODO + @returns this.fromEvent(anEvent) + */ + fromType: { + value: function(type, canBubbleArg, cancelableArg, data) { + var anEvent = document.createEvent("CustomEvent"); + anEvent.initEvent(type, canBubbleArg, cancelableArg, data); + return this.fromEvent(anEvent); + } + }, + + /** + @function + @returns new _changeEventConstructor() + */ + changeEvent: { + value: function() { + return new _changeEventConstructor(); + } + }, + +/** + @function + @param {Event} key TODO + @param {Event} minus TODO + @returns changeEvent + */ + changeEventForKeyAndValue: { + value: function(key, minus) { + var changeEvent = new _changeEventConstructor(); + changeEvent.type = "change@" + key; + changeEvent.minus = minus; + changeEvent.propertyChange = ChangeTypes.MODIFICATION; + return changeEvent; + } + }, + + /** + @function + @param {String} plus TODO + @returns itself + */ + withPlusValue: { + value: function(plus) { + this.plus = plus; + return this; + } + }, +/** + @private +*/ + _initPrototypeWithEvent: { + value: function(event) { + var key; + + for (key in event) { + + // Don't overwrite keys we have installed + if (this[key]) { + continue; + } + + // Skip methods, the ones we care about have been wrapped already + // TODO actually wrap all known functions generically + //if (typeof this[key] === "function") { + // continue; + //} + + // TODO ok, maybe it would be quicker to not make this a function, but I really hate duplicated code + wrapProperty(this, key); + } + + wrapProperty(this, "replayed"); + + return this; + } + }, +/** + @private +*/ + _initWithEvent: { + value: function(event) { + this._event = event; + return this; + } + }, +/** + @function + */ + preventDefault: { + value: function() { + this._event.preventDefault(); + } + }, +/** + @function + */ + stopImmediatePropagation: { + value: function() { + this._event.stopImmediatePropagation(); + // TODO only if the event is cancellable? + this.propagationStopped = true; + } + }, +/** + @type {Property} + @default {Boolean} false + */ + propagationStopped: { + value: false + }, +/** + @type {Property} + @default {Boolean} true + */ + mutable: { + value: true + }, +/** + @type {Property} + @default {Element} null + */ + target: { + value: null + }, +/** + @function + */ + stopPropagation: { + value: function() { + this._event.stopPropagation(); + // TODO only if the event is cancellable? + this.propagationStopped = true; + } + }, +/** + @function + */ + stop: { + value: function() { + this.preventDefault(); + this.stopPropagation(); + } + } + +}); +/** + @private +*/ +_changeEventConstructor = function() { +}; +/** + @private +*/ +_changeEventConstructor.prototype = MutableEvent.create()._initPrototypeWithEvent(document.createEvent("CustomEvent").initCustomEvent("change", true, false, null)); +// TODO this shouldn't be necessary; initWithCustomEvent should be setting the type to "change" but that doesn't seem to be the case +// TODO should file a bug on this with some test reduction +/** + @private +*/ +_changeEventConstructor.prototype.type = "change"; +exports._Change = _changeEventConstructor; -- cgit v1.2.3