spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/util/Delay.js

@@ -0,0 +1,191 @@
+/**
+ * Delay.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Utility class for working with delayed actions like setTimeout.
+ *
+ * @class tinymce.util.Delay
+ */
+define("tinymce/util/Delay", [
+	"tinymce/util/Promise"
+], function(Promise) {
+	var requestAnimationFramePromise;
+
+	function requestAnimationFrame(callback, element) {
+		var i, requestAnimationFrameFunc = window.requestAnimationFrame, vendors = ['ms', 'moz', 'webkit'];
+
+		function featurefill(callback) {
+			window.setTimeout(callback, 0);
+		}
+
+		for (i = 0; i < vendors.length && !requestAnimationFrameFunc; i++) {
+			requestAnimationFrameFunc = window[vendors[i] + 'RequestAnimationFrame'];
+		}
+
+		if (!requestAnimationFrameFunc) {
+			requestAnimationFrameFunc = featurefill;
+		}
+
+		requestAnimationFrameFunc(callback, element);
+	}
+
+	function wrappedSetTimeout(callback, time) {
+		if (typeof time != 'number') {
+			time = 0;
+		}
+
+		return setTimeout(callback, time);
+	}
+
+	function wrappedSetInterval(callback, time) {
+		if (typeof time != 'number') {
+			time = 0;
+		}
+
+		return setInterval(callback, time);
+	}
+
+	function wrappedClearTimeout(id) {
+		return clearTimeout(id);
+	}
+
+	function wrappedClearInterval(id) {
+		return clearInterval(id);
+	}
+
+	return {
+		/**
+		 * Requests an animation frame and fallbacks to a timeout on older browsers.
+		 *
+		 * @method requestAnimationFrame
+		 * @param {function} callback Callback to execute when a new frame is available.
+		 * @param {DOMElement} element Optional element to scope it to.
+		 */
+		requestAnimationFrame: function(callback, element) {
+			if (requestAnimationFramePromise) {
+				requestAnimationFramePromise.then(callback);
+				return;
+			}
+
+			requestAnimationFramePromise = new Promise(function(resolve) {
+				if (!element) {
+					element = document.body;
+				}
+
+				requestAnimationFrame(resolve, element);
+			}).then(callback);
+		},
+
+		/**
+		 * Sets a timer in ms and executes the specified callback when the timer runs out.
+		 *
+		 * @method setTimeout
+		 * @param {function} callback Callback to execute when timer runs out.
+		 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
+		 * @return {Number} Timeout id number.
+		 */
+		setTimeout: wrappedSetTimeout,
+
+		/**
+		 * Sets an interval timer in ms and executes the specified callback at every interval of that time.
+		 *
+		 * @method setInterval
+		 * @param {function} callback Callback to execute when interval time runs out.
+		 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
+		 * @return {Number} Timeout id number.
+		 */
+		setInterval: wrappedSetInterval,
+
+		/**
+		 * Sets an editor timeout it's similar to setTimeout except that it checks if the editor instance is
+		 * still alive when the callback gets executed.
+		 *
+		 * @method setEditorTimeout
+		 * @param {tinymce.Editor} editor Editor instance to check the removed state on.
+		 * @param {function} callback Callback to execute when timer runs out.
+		 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
+		 * @return {Number} Timeout id number.
+		 */
+		setEditorTimeout: function(editor, callback, time) {
+			return wrappedSetTimeout(function() {
+				if (!editor.removed) {
+					callback();
+				}
+			}, time);
+		},
+
+		/**
+		 * Sets an interval timer it's similar to setInterval except that it checks if the editor instance is
+		 * still alive when the callback gets executed.
+		 *
+		 * @method setEditorInterval
+		 * @param {function} callback Callback to execute when interval time runs out.
+		 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
+		 * @return {Number} Timeout id number.
+		 */
+		setEditorInterval: function(editor, callback, time) {
+			var timer;
+
+			timer = wrappedSetInterval(function() {
+				if (!editor.removed) {
+					callback();
+				} else {
+					clearInterval(timer);
+				}
+			}, time);
+
+			return timer;
+		},
+
+		/**
+		 * Creates throttled callback function that only gets executed once within the specified time.
+		 *
+		 * @method throttle
+		 * @param {function} callback Callback to execute when timer finishes.
+		 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
+		 * @return {Function} Throttled function callback.
+		 */
+		throttle: function(callback, time) {
+			var timer, func;
+
+			func = function() {
+				var args = arguments;
+
+				clearTimeout(timer);
+
+				timer = wrappedSetTimeout(function() {
+					callback.apply(this, args);
+				}, time);
+			};
+
+			func.stop = function() {
+				clearTimeout(timer);
+			};
+
+			return func;
+		},
+
+		/**
+		 * Clears an interval timer so it won't execute.
+		 *
+		 * @method clearInterval
+		 * @param {Number} Interval timer id number.
+		 */
+		clearInterval: wrappedClearInterval,
+
+		/**
+		 * Clears an timeout timer so it won't execute.
+		 *
+		 * @method clearTimeout
+		 * @param {Number} Timeout timer id number.
+		 */
+		clearTimeout: wrappedClearTimeout
+	};
+});

data/apps/core/components/public/js/tinymce/classes/util/EventDispatcher.js

@@ -0,0 +1,294 @@
+/**
+ * EventDispatcher.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class lets you add/remove and fire events by name on the specified scope. This makes
+ * it easy to add event listener logic to any class.
+ *
+ * @class tinymce.util.EventDispatcher
+ * @example
+ *  var eventDispatcher = new EventDispatcher();
+ *
+ *  eventDispatcher.on('click', function() {console.log('data');});
+ *  eventDispatcher.fire('click', {data: 123});
+ */
+define("tinymce/util/EventDispatcher", [
+	"tinymce/util/Tools"
+], function(Tools) {
+	var nativeEvents = Tools.makeMap(
+		"focus blur focusin focusout click dblclick mousedown mouseup mousemove mouseover beforepaste paste cut copy selectionchange " +
+		"mouseout mouseenter mouseleave wheel keydown keypress keyup input contextmenu dragstart dragend dragover " +
+		"draggesture dragdrop drop drag submit " +
+		"compositionstart compositionend compositionupdate touchstart touchend",
+		' '
+	);
+
+	function Dispatcher(settings) {
+		var self = this, scope, bindings = {}, toggleEvent;
+
+		function returnFalse() {
+			return false;
+		}
+
+		function returnTrue() {
+			return true;
+		}
+
+		settings = settings || {};
+		scope = settings.scope || self;
+		toggleEvent = settings.toggleEvent || returnFalse;
+
+		/**
+		 * Fires the specified event by name.
+		 *
+		 * @method fire
+		 * @param {String} name Name of the event to fire.
+		 * @param {Object?} args Event arguments.
+		 * @return {Object} Event args instance passed in.
+		 * @example
+		 * instance.fire('event', {...});
+		 */
+		function fire(name, args) {
+			var handlers, i, l, callback;
+
+			name = name.toLowerCase();
+			args = args || {};
+			args.type = name;
+
+			// Setup target is there isn't one
+			if (!args.target) {
+				args.target = scope;
+			}
+
+			// Add event delegation methods if they are missing
+			if (!args.preventDefault) {
+				// Add preventDefault method
+				args.preventDefault = function() {
+					args.isDefaultPrevented = returnTrue;
+				};
+
+				// Add stopPropagation
+				args.stopPropagation = function() {
+					args.isPropagationStopped = returnTrue;
+				};
+
+				// Add stopImmediatePropagation
+				args.stopImmediatePropagation = function() {
+					args.isImmediatePropagationStopped = returnTrue;
+				};
+
+				// Add event delegation states
+				args.isDefaultPrevented = returnFalse;
+				args.isPropagationStopped = returnFalse;
+				args.isImmediatePropagationStopped = returnFalse;
+			}
+
+			if (settings.beforeFire) {
+				settings.beforeFire(args);
+			}
+
+			handlers = bindings[name];
+			if (handlers) {
+				for (i = 0, l = handlers.length; i < l; i++) {
+					callback = handlers[i];
+
+					// Unbind handlers marked with "once"
+					if (callback.once) {
+						off(name, callback.func);
+					}
+
+					// Stop immediate propagation if needed
+					if (args.isImmediatePropagationStopped()) {
+						args.stopPropagation();
+						return args;
+					}
+
+					// If callback returns false then prevent default and stop all propagation
+					if (callback.func.call(scope, args) === false) {
+						args.preventDefault();
+						return args;
+					}
+				}
+			}
+
+			return args;
+		}
+
+		/**
+		 * Binds an event listener to a specific event by name.
+		 *
+		 * @method on
+		 * @param {String} name Event name or space separated list of events to bind.
+		 * @param {callback} callback Callback to be executed when the event occurs.
+		 * @param {Boolean} first Optional flag if the event should be prepended. Use this with care.
+		 * @return {Object} Current class instance.
+		 * @example
+		 * instance.on('event', function(e) {
+		 *     // Callback logic
+		 * });
+		 */
+		function on(name, callback, prepend, extra) {
+			var handlers, names, i;
+
+			if (callback === false) {
+				callback = returnFalse;
+			}
+
+			if (callback) {
+				callback = {
+					func: callback
+				};
+
+				if (extra) {
+					Tools.extend(callback, extra);
+				}
+
+				names = name.toLowerCase().split(' ');
+				i = names.length;
+				while (i--) {
+					name = names[i];
+					handlers = bindings[name];
+					if (!handlers) {
+						handlers = bindings[name] = [];
+						toggleEvent(name, true);
+					}
+
+					if (prepend) {
+						handlers.unshift(callback);
+					} else {
+						handlers.push(callback);
+					}
+				}
+			}
+
+			return self;
+		}
+
+		/**
+		 * Unbinds an event listener to a specific event by name.
+		 *
+		 * @method off
+		 * @param {String?} name Name of the event to unbind.
+		 * @param {callback?} callback Callback to unbind.
+		 * @return {Object} Current class instance.
+		 * @example
+		 * // Unbind specific callback
+		 * instance.off('event', handler);
+		 *
+		 * // Unbind all listeners by name
+		 * instance.off('event');
+		 *
+		 * // Unbind all events
+		 * instance.off();
+		 */
+		function off(name, callback) {
+			var i, handlers, bindingName, names, hi;
+
+			if (name) {
+				names = name.toLowerCase().split(' ');
+				i = names.length;
+				while (i--) {
+					name = names[i];
+					handlers = bindings[name];
+
+					// Unbind all handlers
+					if (!name) {
+						for (bindingName in bindings) {
+							toggleEvent(bindingName, false);
+							delete bindings[bindingName];
+						}
+
+						return self;
+					}
+
+					if (handlers) {
+						// Unbind all by name
+						if (!callback) {
+							handlers.length = 0;
+						} else {
+							// Unbind specific ones
+							hi = handlers.length;
+							while (hi--) {
+								if (handlers[hi].func === callback) {
+									handlers = handlers.slice(0, hi).concat(handlers.slice(hi + 1));
+									bindings[name] = handlers;
+								}
+							}
+						}
+
+						if (!handlers.length) {
+							toggleEvent(name, false);
+							delete bindings[name];
+						}
+					}
+				}
+			} else {
+				for (name in bindings) {
+					toggleEvent(name, false);
+				}
+
+				bindings = {};
+			}
+
+			return self;
+		}
+
+		/**
+		 * Binds an event listener to a specific event by name
+		 * and automatically unbind the event once the callback fires.
+		 *
+		 * @method once
+		 * @param {String} name Event name or space separated list of events to bind.
+		 * @param {callback} callback Callback to be executed when the event occurs.
+		 * @param {Boolean} first Optional flag if the event should be prepended. Use this with care.
+		 * @return {Object} Current class instance.
+		 * @example
+		 * instance.once('event', function(e) {
+		 *     // Callback logic
+		 * });
+		 */
+		function once(name, callback, prepend) {
+			return on(name, callback, prepend, {once: true});
+		}
+
+		/**
+		 * Returns true/false if the dispatcher has a event of the specified name.
+		 *
+		 * @method has
+		 * @param {String} name Name of the event to check for.
+		 * @return {Boolean} true/false if the event exists or not.
+		 */
+		function has(name) {
+			name = name.toLowerCase();
+			return !(!bindings[name] || bindings[name].length === 0);
+		}
+
+		// Expose
+		self.fire = fire;
+		self.on = on;
+		self.off = off;
+		self.once = once;
+		self.has = has;
+	}
+
+	/**
+	 * Returns true/false if the specified event name is a native browser event or not.
+	 *
+	 * @method isNative
+	 * @param {String} name Name to check if it's native.
+	 * @return {Boolean} true/false if the event is native or not.
+	 * @static
+	 */
+	Dispatcher.isNative = function(name) {
+		return !!nativeEvents[name.toLowerCase()];
+	};
+
+	return Dispatcher;
+});