spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/WindowManager.js

@@ -0,0 +1,278 @@
+/**
+ * WindowManager.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 handles the creation of native windows and dialogs. This class can be extended to provide for example inline dialogs.
+ *
+ * @class tinymce.WindowManager
+ * @example
+ * // Opens a new dialog with the file.htm file and the size 320x240
+ * // It also adds a custom parameter this can be retrieved by using tinyMCEPopup.getWindowArg inside the dialog.
+ * tinymce.activeEditor.windowManager.open({
+ *    url: 'file.htm',
+ *    width: 320,
+ *    height: 240
+ * }, {
+ *    custom_param: 1
+ * });
+ *
+ * // Displays an alert box using the active editors window manager instance
+ * tinymce.activeEditor.windowManager.alert('Hello world!');
+ *
+ * // Displays an confirm box and an alert message will be displayed depending on what you choose in the confirm
+ * tinymce.activeEditor.windowManager.confirm("Do you want to do something", function(s) {
+ *    if (s)
+ *       tinymce.activeEditor.windowManager.alert("Ok");
+ *    else
+ *       tinymce.activeEditor.windowManager.alert("Cancel");
+ * });
+ */
+define("tinymce/WindowManager", [
+	"tinymce/ui/Window",
+	"tinymce/ui/MessageBox"
+], function(Window, MessageBox) {
+	return function(editor) {
+		var self = this, windows = [];
+
+		function getTopMostWindow() {
+			if (windows.length) {
+				return windows[windows.length - 1];
+			}
+		}
+
+		function fireOpenEvent(win) {
+			editor.fire('OpenWindow', {
+				win: win
+			});
+		}
+
+		function fireCloseEvent(win) {
+			editor.fire('CloseWindow', {
+				win: win
+			});
+		}
+
+		self.windows = windows;
+
+		editor.on('remove', function() {
+			var i = windows.length;
+
+			while (i--) {
+				windows[i].close();
+			}
+		});
+
+		/**
+		 * Opens a new window.
+		 *
+		 * @method open
+		 * @param {Object} args Optional name/value settings collection contains things like width/height/url etc.
+		 * @param {Object} params Options like title, file, width, height etc.
+		 * @option {String} title Window title.
+		 * @option {String} file URL of the file to open in the window.
+		 * @option {Number} width Width in pixels.
+		 * @option {Number} height Height in pixels.
+		 * @option {Boolean} autoScroll Specifies whether the popup window can have scrollbars if required (i.e. content
+		 * larger than the popup size specified).
+		 */
+		self.open = function(args, params) {
+			var win;
+
+			editor.editorManager.setActive(editor);
+
+			args.title = args.title || ' ';
+
+			// Handle URL
+			args.url = args.url || args.file; // Legacy
+			if (args.url) {
+				args.width = parseInt(args.width || 320, 10);
+				args.height = parseInt(args.height || 240, 10);
+			}
+
+			// Handle body
+			if (args.body) {
+				args.items = {
+					defaults: args.defaults,
+					type: args.bodyType || 'form',
+					items: args.body,
+					data: args.data,
+					callbacks: args.commands
+				};
+			}
+
+			if (!args.url && !args.buttons) {
+				args.buttons = [
+					{text: 'Ok', subtype: 'primary', onclick: function() {
+						win.find('form')[0].submit();
+					}},
+
+					{text: 'Cancel', onclick: function() {
+						win.close();
+					}}
+				];
+			}
+
+			win = new Window(args);
+			windows.push(win);
+
+			win.on('close', function() {
+				var i = windows.length;
+
+				while (i--) {
+					if (windows[i] === win) {
+						windows.splice(i, 1);
+					}
+				}
+
+				if (!windows.length) {
+					editor.focus();
+				}
+
+				fireCloseEvent(win);
+			});
+
+			// Handle data
+			if (args.data) {
+				win.on('postRender', function() {
+					this.find('*').each(function(ctrl) {
+						var name = ctrl.name();
+
+						if (name in args.data) {
+							ctrl.value(args.data[name]);
+						}
+					});
+				});
+			}
+
+			// store args and parameters
+			win.features = args || {};
+			win.params = params || {};
+
+			// Takes a snapshot in the FocusManager of the selection before focus is lost to dialog
+			if (windows.length === 1) {
+				editor.nodeChanged();
+			}
+
+			win = win.renderTo().reflow();
+
+			fireOpenEvent(win);
+
+			return win;
+		};
+
+		/**
+		 * Creates a alert dialog. Please don't use the blocking behavior of this
+		 * native version use the callback method instead then it can be extended.
+		 *
+		 * @method alert
+		 * @param {String} message Text to display in the new alert dialog.
+		 * @param {function} callback Callback function to be executed after the user has selected ok.
+		 * @param {Object} scope Optional scope to execute the callback in.
+		 * @example
+		 * // Displays an alert box using the active editors window manager instance
+		 * tinymce.activeEditor.windowManager.alert('Hello world!');
+		 */
+		self.alert = function(message, callback, scope) {
+			var win;
+
+			win = MessageBox.alert(message, function() {
+				if (callback) {
+					callback.call(scope || this);
+				} else {
+					editor.focus();
+				}
+			});
+
+			win.on('close', function() {
+				fireCloseEvent(win);
+			});
+
+			fireOpenEvent(win);
+		};
+
+		/**
+		 * Creates a confirm dialog. Please don't use the blocking behavior of this
+		 * native version use the callback method instead then it can be extended.
+		 *
+		 * @method confirm
+		 * @param {String} message Text to display in the new confirm dialog.
+		 * @param {function} callback Callback function to be executed after the user has selected ok or cancel.
+		 * @param {Object} scope Optional scope to execute the callback in.
+		 * @example
+		 * // Displays an confirm box and an alert message will be displayed depending on what you choose in the confirm
+		 * tinymce.activeEditor.windowManager.confirm("Do you want to do something", function(s) {
+		 *    if (s)
+		 *       tinymce.activeEditor.windowManager.alert("Ok");
+		 *    else
+		 *       tinymce.activeEditor.windowManager.alert("Cancel");
+		 * });
+		 */
+		self.confirm = function(message, callback, scope) {
+			var win;
+
+			win = MessageBox.confirm(message, function(state) {
+				callback.call(scope || this, state);
+			});
+
+			win.on('close', function() {
+				fireCloseEvent(win);
+			});
+
+			fireOpenEvent(win);
+		};
+
+		/**
+		 * Closes the top most window.
+		 *
+		 * @method close
+		 */
+		self.close = function() {
+			if (getTopMostWindow()) {
+				getTopMostWindow().close();
+			}
+		};
+
+		/**
+		 * Returns the params of the last window open call. This can be used in iframe based
+		 * dialog to get params passed from the tinymce plugin.
+		 *
+		 * @example
+		 * var dialogArguments = top.tinymce.activeEditor.windowManager.getParams();
+		 *
+		 * @method getParams
+		 * @return {Object} Name/value object with parameters passed from windowManager.open call.
+		 */
+		self.getParams = function() {
+			return getTopMostWindow() ? getTopMostWindow().params : null;
+		};
+
+		/**
+		 * Sets the params of the last opened window.
+		 *
+		 * @method setParams
+		 * @param {Object} params Params object to set for the last opened window.
+		 */
+		self.setParams = function(params) {
+			if (getTopMostWindow()) {
+				getTopMostWindow().params = params;
+			}
+		};
+
+		/**
+		 * Returns the currently opened window objects.
+		 *
+		 * @method getWindows
+		 * @return {Array} Array of the currently opened windows.
+		 */
+		self.getWindows = function() {
+			return windows;
+		};
+	};
+});

data/apps/core/components/public/js/tinymce/classes/caret/CaretBookmark.js

@@ -0,0 +1,263 @@
+/**
+ * CaretBookmark.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 module creates or resolves xpath like string representation of a CaretPositions.
+ *
+ * The format is a / separated list of chunks with:
+ * <element|text()>[index|after|before]
+ *
+ * For example:
+ *  p[0]/b[0]/text()[0],1 = <p><b>a|c</b></p>
+ *  p[0]/img[0],before = <p>|<img></p>
+ *  p[0]/img[0],after = <p><img>|</p>
+ *
+ * @private
+ * @static
+ * @class tinymce.caret.CaretBookmark
+ * @example
+ * var bookmark = CaretBookmark.create(rootElm, CaretPosition.before(rootElm.firstChild));
+ * var caretPosition = CaretBookmark.resolve(bookmark);
+ */
+define('tinymce/caret/CaretBookmark', [
+	'tinymce/dom/NodeType',
+	'tinymce/dom/DOMUtils',
+	'tinymce/util/Fun',
+	'tinymce/util/Arr',
+	'tinymce/caret/CaretPosition'
+], function(NodeType, DomUtils, Fun, Arr, CaretPosition) {
+	var isText = NodeType.isText,
+		isBogus = NodeType.isBogus,
+		nodeIndex = DomUtils.nodeIndex;
+
+	function normalizedParent(node) {
+		var parentNode = node.parentNode;
+
+		if (isBogus(parentNode)) {
+			return normalizedParent(parentNode);
+		}
+
+		return parentNode;
+	}
+
+	function getChildNodes(node) {
+		if (!node) {
+			return [];
+		}
+
+		return Arr.reduce(node.childNodes, function(result, node) {
+			if (isBogus(node) && node.nodeName != 'BR') {
+				result = result.concat(getChildNodes(node));
+			} else {
+				result.push(node);
+			}
+
+			return result;
+		}, []);
+	}
+
+	function normalizedTextOffset(textNode, offset) {
+		while ((textNode = textNode.previousSibling)) {
+			if (!isText(textNode)) {
+				break;
+			}
+
+			offset += textNode.data.length;
+		}
+
+		return offset;
+	}
+
+	function equal(targetValue) {
+		return function(value) {
+			return targetValue === value;
+		};
+	}
+
+	function normalizedNodeIndex(node) {
+		var nodes, index, numTextFragments;
+
+		nodes = getChildNodes(normalizedParent(node));
+		index = Arr.findIndex(nodes, equal(node), node);
+		nodes = nodes.slice(0, index + 1);
+		numTextFragments = Arr.reduce(nodes, function(result, node, i) {
+			if (isText(node) && isText(nodes[i - 1])) {
+				result++;
+			}
+
+			return result;
+		}, 0);
+
+		nodes = Arr.filter(nodes, NodeType.matchNodeNames(node.nodeName));
+		index = Arr.findIndex(nodes, equal(node), node);
+
+		return index - numTextFragments;
+	}
+
+	function createPathItem(node) {
+		var name;
+
+		if (isText(node)) {
+			name = 'text()';
+		} else {
+			name = node.nodeName.toLowerCase();
+		}
+
+		return name + '[' + normalizedNodeIndex(node) + ']';
+	}
+
+	function parentsUntil(rootNode, node, predicate) {
+		var parents = [];
+
+		for (node = node.parentNode; node != rootNode; node = node.parentNode) {
+			if (predicate && predicate(node)) {
+				break;
+			}
+
+			parents.push(node);
+		}
+
+		return parents;
+	}
+
+	function create(rootNode, caretPosition) {
+		var container, offset, path = [],
+			outputOffset, childNodes, parents;
+
+		container = caretPosition.container();
+		offset = caretPosition.offset();
+
+		if (isText(container)) {
+			outputOffset = normalizedTextOffset(container, offset);
+		} else {
+			childNodes = container.childNodes;
+			if (offset >= childNodes.length) {
+				outputOffset = 'after';
+				offset = childNodes.length - 1;
+			} else {
+				outputOffset = 'before';
+			}
+
+			container = childNodes[offset];
+		}
+
+		path.push(createPathItem(container));
+		parents = parentsUntil(rootNode, container);
+		parents = Arr.filter(parents, Fun.negate(NodeType.isBogus));
+		path = path.concat(Arr.map(parents, function(node) {
+			return createPathItem(node);
+		}));
+
+		return path.reverse().join('/') + ',' + outputOffset;
+	}
+
+	function resolvePathItem(node, name, index) {
+		var nodes = getChildNodes(node);
+
+		nodes = Arr.filter(nodes, function(node, index) {
+			return !isText(node) || !isText(nodes[index - 1]);
+		});
+
+		nodes = Arr.filter(nodes, NodeType.matchNodeNames(name));
+		return nodes[index];
+	}
+
+	function findTextPosition(container, offset) {
+		var node = container, targetOffset = 0, dataLen;
+
+		while (isText(node)) {
+			dataLen = node.data.length;
+
+			if (offset >= targetOffset && offset <= targetOffset + dataLen) {
+				container = node;
+				offset = offset - targetOffset;
+				break;
+			}
+
+			if (!isText(node.nextSibling)) {
+				container = node;
+				offset = dataLen;
+				break;
+			}
+
+			targetOffset += dataLen;
+			node = node.nextSibling;
+		}
+
+		if (offset > container.data.length) {
+			offset = container.data.length;
+		}
+
+		return new CaretPosition(container, offset);
+	}
+
+	function resolve(rootNode, path) {
+		var parts, container, offset;
+
+		if (!path) {
+			return null;
+		}
+
+		parts = path.split(',');
+		path = parts[0].split('/');
+		offset = parts.length > 1 ? parts[1] : 'before';
+
+		container = Arr.reduce(path, function(result, value) {
+			value = /([\w\-\(\)]+)\[([0-9]+)\]/.exec(value);
+			if (!value) {
+				return null;
+			}
+
+			if (value[1] === 'text()') {
+				value[1] = '#text';
+			}
+
+			return resolvePathItem(result, value[1], parseInt(value[2], 10));
+		}, rootNode);
+
+		if (!container) {
+			return null;
+		}
+
+		if (!isText(container)) {
+			if (offset === 'after') {
+				offset = nodeIndex(container) + 1;
+			} else {
+				offset = nodeIndex(container);
+			}
+
+			return new CaretPosition(container.parentNode, offset);
+		}
+
+		return findTextPosition(container, parseInt(offset, 10));
+	}
+
+	return {
+		/**
+		 * Create a xpath bookmark location for the specified caret position.
+		 *
+		 * @method create
+		 * @param {Node} rootNode Root node to create bookmark within.
+		 * @param {tinymce.caret.CaretPosition} caretPosition Caret position within the root node.
+		 * @return {String} String xpath like location of caret position.
+		 */
+		create: create,
+
+		/**
+		 * Resolves a xpath like bookmark location to the a caret position.
+		 *
+		 * @method resolve
+		 * @param {Node} rootNode Root node to resolve xpath bookmark within.
+		 * @param {String} bookmark Bookmark string to resolve.
+		 * @return {tinymce.caret.CaretPosition} Caret position resolved from xpath like bookmark.
+		 */
+		resolve: resolve
+	};
+});