spiderfw 0.6.38 → 0.6.39

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

@@ -0,0 +1,82 @@
+/**
+ * LegacyInput.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
+ */
+
+/**
+ * Converts legacy input to modern HTML.
+ *
+ * @class tinymce.LegacyInput
+ * @private
+ */
+define("tinymce/LegacyInput", [
+	"tinymce/EditorManager",
+	"tinymce/util/Tools"
+], function(EditorManager, Tools) {
+	var each = Tools.each, explode = Tools.explode;
+
+	EditorManager.on('AddEditor', function(e) {
+		var editor = e.editor;
+
+		editor.on('preInit', function() {
+			var filters, fontSizes, dom, settings = editor.settings;
+
+			function replaceWithSpan(node, styles) {
+				each(styles, function(value, name) {
+					if (value) {
+						dom.setStyle(node, name, value);
+					}
+				});
+
+				dom.rename(node, 'span');
+			}
+
+			function convert(e) {
+				dom = editor.dom;
+
+				if (settings.convert_fonts_to_spans) {
+					each(dom.select('font,u,strike', e.node), function(node) {
+						filters[node.nodeName.toLowerCase()](dom, node);
+					});
+				}
+			}
+
+			if (settings.inline_styles) {
+				fontSizes = explode(settings.font_size_legacy_values);
+
+				filters = {
+					font: function(dom, node) {
+						replaceWithSpan(node, {
+							backgroundColor: node.style.backgroundColor,
+							color: node.color,
+							fontFamily: node.face,
+							fontSize: fontSizes[parseInt(node.size, 10) - 1]
+						});
+					},
+
+					u: function(dom, node) {
+						// HTML5 allows U element
+						if (editor.settings.schema === "html4") {
+							replaceWithSpan(node, {
+								textDecoration: 'underline'
+							});
+						}
+					},
+
+					strike: function(dom, node) {
+						replaceWithSpan(node, {
+							textDecoration: 'line-through'
+						});
+					}
+				};
+
+				editor.on('PreProcess SetContent', convert);
+			}
+		});
+	});
+});

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

@@ -0,0 +1,54 @@
+/**
+ * Mode.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
+ */
+
+/**
+ * Mode switcher logic.
+ *
+ * @private
+ * @class tinymce.Mode
+ */
+define("tinymce/Mode", [], function() {
+	function setEditorCommandState(editor, cmd, state) {
+		try {
+			editor.getDoc().execCommand(cmd, false, state);
+		} catch (ex) {
+			// Ignore
+		}
+	}
+
+	function setMode(editor, mode) {
+		var currentMode = editor.readonly ? 'readonly' : 'design';
+
+		if (mode == currentMode) {
+			return;
+		}
+
+		if (mode == 'readonly') {
+			editor.selection.controlSelection.hideResizeRect();
+			editor.readonly = true;
+			editor.getBody().contentEditable = false;
+		} else {
+			editor.readonly = false;
+			editor.getBody().contentEditable = true;
+			setEditorCommandState(editor, "StyleWithCSS", false);
+			setEditorCommandState(editor, "enableInlineTableEditing", false);
+			setEditorCommandState(editor, "enableObjectResizing", false);
+			editor.focus();
+			editor.nodeChanged();
+		}
+
+		// Event is NOT preventable
+		editor.fire('SwitchMode', {mode: mode});
+	}
+
+	return {
+		setMode: setMode
+	};
+});

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

@@ -0,0 +1,154 @@
+/**
+ * NodeChange.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 nodechange event dispatching both manual and through selection change events.
+ *
+ * @class tinymce.NodeChange
+ * @private
+ */
+define("tinymce/NodeChange", [
+	"tinymce/dom/RangeUtils",
+	"tinymce/Env",
+	"tinymce/util/Delay"
+], function(RangeUtils, Env, Delay) {
+	return function(editor) {
+		var lastRng, lastPath = [];
+
+		/**
+		 * Returns true/false if the current element path has been changed or not.
+		 *
+		 * @private
+		 * @return {Boolean} True if the element path is the same false if it's not.
+		 */
+		function isSameElementPath(startElm) {
+			var i, currentPath;
+
+			currentPath = editor.$(startElm).parentsUntil(editor.getBody()).add(startElm);
+			if (currentPath.length === lastPath.length) {
+				for (i = currentPath.length; i >= 0; i--) {
+					if (currentPath[i] !== lastPath[i]) {
+						break;
+					}
+				}
+
+				if (i === -1) {
+					lastPath = currentPath;
+					return true;
+				}
+			}
+
+			lastPath = currentPath;
+
+			return false;
+		}
+
+		// Gecko doesn't support the "selectionchange" event
+		if (!('onselectionchange' in editor.getDoc())) {
+			editor.on('NodeChange Click MouseUp KeyUp Focus', function(e) {
+				var nativeRng, fakeRng;
+
+				// Since DOM Ranges mutate on modification
+				// of the DOM we need to clone it's contents
+				nativeRng = editor.selection.getRng();
+				fakeRng = {
+					startContainer: nativeRng.startContainer,
+					startOffset: nativeRng.startOffset,
+					endContainer: nativeRng.endContainer,
+					endOffset: nativeRng.endOffset
+				};
+
+				// Always treat nodechange as a selectionchange since applying
+				// formatting to the current range wouldn't update the range but it's parent
+				if (e.type == 'nodechange' || !RangeUtils.compareRanges(fakeRng, lastRng)) {
+					editor.fire('SelectionChange');
+				}
+
+				lastRng = fakeRng;
+			});
+		}
+
+		// IE has a bug where it fires a selectionchange on right click that has a range at the start of the body
+		// When the contextmenu event fires the selection is located at the right location
+		editor.on('contextmenu', function() {
+			editor.fire('SelectionChange');
+		});
+
+		// Selection change is delayed ~200ms on IE when you click inside the current range
+		editor.on('SelectionChange', function() {
+			var startElm = editor.selection.getStart(true);
+
+			// IE 8 will fire a selectionchange event with an incorrect selection
+			// when focusing out of table cells. Click inside cell -> toolbar = Invalid SelectionChange event
+			if (!Env.range && editor.selection.isCollapsed()) {
+				return;
+			}
+
+			if (!isSameElementPath(startElm) && editor.dom.isChildOf(startElm, editor.getBody())) {
+				editor.nodeChanged({selectionChange: true});
+			}
+		});
+
+		// Fire an extra nodeChange on mouseup for compatibility reasons
+		editor.on('MouseUp', function(e) {
+			if (!e.isDefaultPrevented()) {
+				// Delay nodeChanged call for WebKit edge case issue where the range
+				// isn't updated until after you click outside a selected image
+				if (editor.selection.getNode().nodeName == 'IMG') {
+					Delay.setEditorTimeout(editor, function() {
+						editor.nodeChanged();
+					});
+				} else {
+					editor.nodeChanged();
+				}
+			}
+		});
+
+		/**
+		 * Dispatches out a onNodeChange event to all observers. This method should be called when you
+		 * need to update the UI states or element path etc.
+		 *
+		 * @method nodeChanged
+		 * @param {Object} args Optional args to pass to NodeChange event handlers.
+		 */
+		this.nodeChanged = function(args) {
+			var selection = editor.selection, node, parents, root;
+
+			// Fix for bug #1896577 it seems that this can not be fired while the editor is loading
+			if (editor.initialized && selection && !editor.settings.disable_nodechange && !editor.readonly) {
+				// Get start node
+				root = editor.getBody();
+				node = selection.getStart() || root;
+				node = node.ownerDocument != editor.getDoc() ? editor.getBody() : node;
+
+				// Edge case for <p>|<img></p>
+				if (node.nodeName == 'IMG' && selection.isCollapsed()) {
+					node = node.parentNode;
+				}
+
+				// Get parents and add them to object
+				parents = [];
+				editor.dom.getParent(node, function(node) {
+					if (node === root) {
+						return true;
+					}
+
+					parents.push(node);
+				});
+
+				args = args || {};
+				args.element = node;
+				args.parents = parents;
+
+				editor.fire('NodeChange', args);
+			}
+		};
+	};
+});

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

@@ -0,0 +1,156 @@
+/**
+ * NotificationManager.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 TinyMCE's notifications.
+ *
+ * @class tinymce.notificationManager
+ * @example
+ * // Opens a new notification of type "error" with text "An error occurred."
+ * tinymce.activeEditor.notificationManager.open({
+ *    text: 'An error occurred.',
+ *    type: 'error'
+ * });
+ */
+define("tinymce/NotificationManager", [
+	"tinymce/ui/Notification",
+	"tinymce/util/Delay"
+], function(Notification, Delay) {
+	return function(editor) {
+		var self = this, notifications = [];
+
+		function getLastNotification() {
+			if (notifications.length) {
+				return notifications[notifications.length - 1];
+			}
+		}
+
+		self.notifications = notifications;
+
+		function resizeWindowEvent() {
+			Delay.requestAnimationFrame(function() {
+				prePositionNotifications();
+				positionNotifications();
+			});
+		}
+
+		// Since the viewport will change based on the present notifications, we need to move them all to the
+		// top left of the viewport to give an accurate size measurement so we can position them later.
+		function prePositionNotifications() {
+			for (var i = 0; i < notifications.length; i++) {
+				notifications[i].moveTo(0, 0);
+			}
+		}
+
+		function positionNotifications() {
+			if (notifications.length > 0) {
+				var firstItem = notifications.slice(0, 1)[0];
+				var container = editor.inline ? editor.getElement() : editor.getContentAreaContainer();
+				firstItem.moveRel(container, 'tc-tc');
+				if (notifications.length > 1) {
+					for (var i = 1; i < notifications.length; i++) {
+						notifications[i].moveRel(notifications[i - 1].getEl(), 'bc-tc');
+					}
+				}
+			}
+		}
+
+		editor.on('remove', function() {
+			var i = notifications.length;
+
+			while (i--) {
+				notifications[i].close();
+			}
+		});
+
+		editor.on('ResizeEditor', positionNotifications);
+		editor.on('ResizeWindow', resizeWindowEvent);
+
+		/**
+		 * Opens a new notification.
+		 *
+		 * @method open
+		 * @param {Object} args Optional name/value settings collection contains things like timeout/color/message etc.
+		 */
+		self.open = function(args) {
+			var notif;
+
+			editor.editorManager.setActive(editor);
+
+			notif = new Notification(args);
+			notifications.push(notif);
+
+			//If we have a timeout value
+			if (args.timeout > 0) {
+				notif.timer = setTimeout(function() {
+					notif.close();
+				}, args.timeout);
+			}
+
+			notif.on('close', function() {
+				var i = notifications.length;
+
+				if (notif.timer) {
+					editor.getWin().clearTimeout(notif.timer);
+				}
+
+				while (i--) {
+					if (notifications[i] === notif) {
+						notifications.splice(i, 1);
+					}
+				}
+
+				positionNotifications();
+			});
+
+			notif.renderTo();
+
+			positionNotifications();
+
+			return notif;
+		};
+
+		/**
+		 * Closes the top most notification.
+		 *
+		 * @method close
+		 */
+		self.close = function() {
+			if (getLastNotification()) {
+				getLastNotification().close();
+			}
+		};
+
+		/**
+		 * Returns the currently opened notification objects.
+		 *
+		 * @method getNotifications
+		 * @return {Array} Array of the currently opened notifications.
+		 */
+		self.getNotifications = function() {
+			return notifications;
+		};
+
+		editor.on('SkinLoaded', function() {
+			var serviceMessage = editor.settings.service_message;
+
+			if (serviceMessage) {
+				editor.notificationManager.open({
+					text: serviceMessage,
+					type: 'warning',
+					timeout: 0,
+					icon: ''
+				});
+			}
+		});
+
+		//self.positionNotifications = positionNotifications;
+	};
+});

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

@@ -0,0 +1,34 @@
+/**
+ * Register.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 registers tinymce in common module loaders.
+ *
+ * @private
+ * @class tinymce.Register
+ */
+define("tinymce/Register", [
+], function() {
+	/*eslint consistent-this: 0 */
+	var context = this || window;
+
+	var tinymce = function() {
+		return context.tinymce;
+	};
+
+	if (typeof context.define === "function") {
+		// Bolt
+		if (!context.define.amd) {
+			context.define("ephox/tinymce", [], tinymce);
+		}
+	}
+
+	return {};
+});