spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/ui/FlowLayout.js

@@ -0,0 +1,46 @@
+/**
+ * FlowLayout.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 layout manager will place the controls by using the browsers native layout.
+ *
+ * @-x-less FlowLayout.less
+ * @class tinymce.ui.FlowLayout
+ * @extends tinymce.ui.Layout
+ */
+define("tinymce/ui/FlowLayout", [
+	"tinymce/ui/Layout"
+], function(Layout) {
+	return Layout.extend({
+		Defaults: {
+			containerClass: 'flow-layout',
+			controlClass: 'flow-layout-item',
+			endClass: 'break'
+		},
+
+		/**
+		 * Recalculates the positions of the controls in the specified container.
+		 *
+		 * @method recalc
+		 * @param {tinymce.ui.Container} container Container instance to recalc.
+		 */
+		recalc: function(container) {
+			container.items().filter(':visible').each(function(ctrl) {
+				if (ctrl.recalc) {
+					ctrl.recalc();
+				}
+			});
+		},
+
+		isNative: function() {
+			return true;
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/Form.js

@@ -0,0 +1,157 @@
+/**
+ * Form.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 creates a form container. A form container has the ability
+ * to automatically wrap items in tinymce.ui.FormItem instances.
+ *
+ * Each FormItem instance is a container for the label and the item.
+ *
+ * @example
+ * tinymce.ui.Factory.create({
+ *     type: 'form',
+ *     items: [
+ *         {type: 'textbox', label: 'My text box'}
+ *     ]
+ * }).renderTo(document.body);
+ *
+ * @class tinymce.ui.Form
+ * @extends tinymce.ui.Container
+ */
+define("tinymce/ui/Form", [
+	"tinymce/ui/Container",
+	"tinymce/ui/FormItem",
+	"tinymce/util/Tools"
+], function(Container, FormItem, Tools) {
+	"use strict";
+
+	return Container.extend({
+		Defaults: {
+			containerCls: 'form',
+			layout: 'flex',
+			direction: 'column',
+			align: 'stretch',
+			flex: 1,
+			padding: 20,
+			labelGap: 30,
+			spacing: 10,
+			callbacks: {
+				submit: function() {
+					this.submit();
+				}
+			}
+		},
+
+		/**
+		 * This method gets invoked before the control is rendered.
+		 *
+		 * @method preRender
+		 */
+		preRender: function() {
+			var self = this, items = self.items();
+
+			if (!self.settings.formItemDefaults) {
+				self.settings.formItemDefaults = {
+					layout: 'flex',
+					autoResize: "overflow",
+					defaults: {flex: 1}
+				};
+			}
+
+			// Wrap any labeled items in FormItems
+			items.each(function(ctrl) {
+				var formItem, label = ctrl.settings.label;
+
+				if (label) {
+					formItem = new FormItem(Tools.extend({
+						items: {
+							type: 'label',
+							id: ctrl._id + '-l',
+							text: label,
+							flex: 0,
+							forId: ctrl._id,
+							disabled: ctrl.disabled()
+						}
+					}, self.settings.formItemDefaults));
+
+					formItem.type = 'formitem';
+					ctrl.aria('labelledby', ctrl._id + '-l');
+
+					if (typeof ctrl.settings.flex == "undefined") {
+						ctrl.settings.flex = 1;
+					}
+
+					self.replace(ctrl, formItem);
+					formItem.add(ctrl);
+				}
+			});
+		},
+
+		/**
+		 * Fires a submit event with the serialized form.
+		 *
+		 * @method submit
+		 * @return {Object} Event arguments object.
+		 */
+		submit: function() {
+			return this.fire('submit', {data: this.toJSON()});
+		},
+
+		/**
+		 * Post render method. Called after the control has been rendered to the target.
+		 *
+		 * @method postRender
+		 * @return {tinymce.ui.ComboBox} Current combobox instance.
+		 */
+		postRender: function() {
+			var self = this;
+
+			self._super();
+			self.fromJSON(self.settings.data);
+		},
+
+		bindStates: function() {
+			var self = this;
+
+			self._super();
+
+			function recalcLabels() {
+				var maxLabelWidth = 0, labels = [], i, labelGap, items;
+
+				if (self.settings.labelGapCalc === false) {
+					return;
+				}
+
+				if (self.settings.labelGapCalc == "children") {
+					items = self.find('formitem');
+				} else {
+					items = self.items();
+				}
+
+				items.filter('formitem').each(function(item) {
+					var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
+
+					maxLabelWidth = labelWidth > maxLabelWidth ? labelWidth : maxLabelWidth;
+					labels.push(labelCtrl);
+				});
+
+				labelGap = self.settings.labelGap || 0;
+
+				i = labels.length;
+				while (i--) {
+					labels[i].settings.minWidth = maxLabelWidth + labelGap;
+				}
+			}
+
+			self.on('show', recalcLabels);
+			recalcLabels();
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/FormItem.js

@@ -0,0 +1,56 @@
+/**
+ * FormItem.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 is a container created by the form element with
+ * a label and control item.
+ *
+ * @class tinymce.ui.FormItem
+ * @extends tinymce.ui.Container
+ * @setting {String} label Label to display for the form item.
+ */
+define("tinymce/ui/FormItem", [
+	"tinymce/ui/Container"
+], function(Container) {
+	"use strict";
+
+	return Container.extend({
+		Defaults: {
+			layout: 'flex',
+			align: 'center',
+			defaults: {
+				flex: 1
+			}
+		},
+
+		/**
+		 * Renders the control as a HTML string.
+		 *
+		 * @method renderHtml
+		 * @return {String} HTML representing the control.
+		 */
+		renderHtml: function() {
+			var self = this, layout = self._layout, prefix = self.classPrefix;
+
+			self.classes.add('formitem');
+			layout.preRender(self);
+
+			return (
+				'<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' +
+					(self.settings.title ? ('<div id="' + self._id + '-title" class="' + prefix + 'title">' +
+						self.settings.title + '</div>') : '') +
+					'<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' +
+						(self.settings.html || '') + layout.renderHtml(self) +
+					'</div>' +
+				'</div>'
+			);
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/FormatControls.js

@@ -0,0 +1,535 @@
+/**
+ * FormatControls.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
+ */
+
+/**
+ * Internal class containing all TinyMCE specific control types such as
+ * format listboxes, fontlist boxes, toolbar buttons etc.
+ *
+ * @class tinymce.ui.FormatControls
+ */
+define("tinymce/ui/FormatControls", [
+	"tinymce/ui/Control",
+	"tinymce/ui/Widget",
+	"tinymce/ui/FloatPanel",
+	"tinymce/util/Tools",
+	"tinymce/EditorManager",
+	"tinymce/Env"
+], function(Control, Widget, FloatPanel, Tools, EditorManager, Env) {
+	var each = Tools.each;
+
+	EditorManager.on('AddEditor', function(e) {
+		if (e.editor.rtl) {
+			Control.rtl = true;
+		}
+
+		registerControls(e.editor);
+	});
+
+	Control.translate = function(text) {
+		return EditorManager.translate(text);
+	};
+
+	Widget.tooltips = !Env.iOS;
+
+	function registerControls(editor) {
+		var formatMenu;
+
+		function createListBoxChangeHandler(items, formatName) {
+			return function() {
+				var self = this;
+
+				editor.on('nodeChange', function(e) {
+					var formatter = editor.formatter;
+					var value = null;
+
+					each(e.parents, function(node) {
+						each(items, function(item) {
+							if (formatName) {
+								if (formatter.matchNode(node, formatName, {value: item.value})) {
+									value = item.value;
+								}
+							} else {
+								if (formatter.matchNode(node, item.value)) {
+									value = item.value;
+								}
+							}
+
+							if (value) {
+								return false;
+							}
+						});
+
+						if (value) {
+							return false;
+						}
+					});
+
+					self.value(value);
+				});
+			};
+		}
+
+		function createFormats(formats) {
+			formats = formats.replace(/;$/, '').split(';');
+
+			var i = formats.length;
+			while (i--) {
+				formats[i] = formats[i].split('=');
+			}
+
+			return formats;
+		}
+
+		function createFormatMenu() {
+			var count = 0, newFormats = [];
+
+			var defaultStyleFormats = [
+				{title: 'Headings', items: [
+					{title: 'Heading 1', format: 'h1'},
+					{title: 'Heading 2', format: 'h2'},
+					{title: 'Heading 3', format: 'h3'},
+					{title: 'Heading 4', format: 'h4'},
+					{title: 'Heading 5', format: 'h5'},
+					{title: 'Heading 6', format: 'h6'}
+				]},
+
+				{title: 'Inline', items: [
+					{title: 'Bold', icon: 'bold', format: 'bold'},
+					{title: 'Italic', icon: 'italic', format: 'italic'},
+					{title: 'Underline', icon: 'underline', format: 'underline'},
+					{title: 'Strikethrough', icon: 'strikethrough', format: 'strikethrough'},
+					{title: 'Superscript', icon: 'superscript', format: 'superscript'},
+					{title: 'Subscript', icon: 'subscript', format: 'subscript'},
+					{title: 'Code', icon: 'code', format: 'code'}
+				]},
+
+				{title: 'Blocks', items: [
+					{title: 'Paragraph', format: 'p'},
+					{title: 'Blockquote', format: 'blockquote'},
+					{title: 'Div', format: 'div'},
+					{title: 'Pre', format: 'pre'}
+				]},
+
+				{title: 'Alignment', items: [
+					{title: 'Left', icon: 'alignleft', format: 'alignleft'},
+					{title: 'Center', icon: 'aligncenter', format: 'aligncenter'},
+					{title: 'Right', icon: 'alignright', format: 'alignright'},
+					{title: 'Justify', icon: 'alignjustify', format: 'alignjustify'}
+				]}
+			];
+
+			function createMenu(formats) {
+				var menu = [];
+
+				if (!formats) {
+					return;
+				}
+
+				each(formats, function(format) {
+					var menuItem = {
+						text: format.title,
+						icon: format.icon
+					};
+
+					if (format.items) {
+						menuItem.menu = createMenu(format.items);
+					} else {
+						var formatName = format.format || "custom" + count++;
+
+						if (!format.format) {
+							format.name = formatName;
+							newFormats.push(format);
+						}
+
+						menuItem.format = formatName;
+						menuItem.cmd = format.cmd;
+					}
+
+					menu.push(menuItem);
+				});
+
+				return menu;
+			}
+
+			function createStylesMenu() {
+				var menu;
+
+				if (editor.settings.style_formats_merge) {
+					if (editor.settings.style_formats) {
+						menu = createMenu(defaultStyleFormats.concat(editor.settings.style_formats));
+					} else {
+						menu = createMenu(defaultStyleFormats);
+					}
+				} else {
+					menu = createMenu(editor.settings.style_formats || defaultStyleFormats);
+				}
+
+				return menu;
+			}
+
+			editor.on('init', function() {
+				each(newFormats, function(format) {
+					editor.formatter.register(format.name, format);
+				});
+			});
+
+			return {
+				type: 'menu',
+				items: createStylesMenu(),
+				onPostRender: function(e) {
+					editor.fire('renderFormatsMenu', {control: e.control});
+				},
+				itemDefaults: {
+					preview: true,
+
+					textStyle: function() {
+						if (this.settings.format) {
+							return editor.formatter.getCssText(this.settings.format);
+						}
+					},
+
+					onPostRender: function() {
+						var self = this;
+
+						self.parent().on('show', function() {
+							var formatName, command;
+
+							formatName = self.settings.format;
+							if (formatName) {
+								self.disabled(!editor.formatter.canApply(formatName));
+								self.active(editor.formatter.match(formatName));
+							}
+
+							command = self.settings.cmd;
+							if (command) {
+								self.active(editor.queryCommandState(command));
+							}
+						});
+					},
+
+					onclick: function() {
+						if (this.settings.format) {
+							toggleFormat(this.settings.format);
+						}
+
+						if (this.settings.cmd) {
+							editor.execCommand(this.settings.cmd);
+						}
+					}
+				}
+			};
+		}
+
+		formatMenu = createFormatMenu();
+
+		function initOnPostRender(name) {
+			return function() {
+				var self = this;
+
+				// TODO: Fix this
+				if (editor.formatter) {
+					editor.formatter.formatChanged(name, function(state) {
+						self.active(state);
+					});
+				} else {
+					editor.on('init', function() {
+						editor.formatter.formatChanged(name, function(state) {
+							self.active(state);
+						});
+					});
+				}
+			};
+		}
+
+		// Simple format controls <control/format>:<UI text>
+		each({
+			bold: 'Bold',
+			italic: 'Italic',
+			underline: 'Underline',
+			strikethrough: 'Strikethrough',
+			subscript: 'Subscript',
+			superscript: 'Superscript'
+		}, function(text, name) {
+			editor.addButton(name, {
+				tooltip: text,
+				onPostRender: initOnPostRender(name),
+				onclick: function() {
+					toggleFormat(name);
+				}
+			});
+		});
+
+		// Simple command controls <control>:[<UI text>,<Command>]
+		each({
+			outdent: ['Decrease indent', 'Outdent'],
+			indent: ['Increase indent', 'Indent'],
+			cut: ['Cut', 'Cut'],
+			copy: ['Copy', 'Copy'],
+			paste: ['Paste', 'Paste'],
+			help: ['Help', 'mceHelp'],
+			selectall: ['Select all', 'SelectAll'],
+			removeformat: ['Clear formatting', 'RemoveFormat'],
+			visualaid: ['Visual aids', 'mceToggleVisualAid'],
+			newdocument: ['New document', 'mceNewDocument']
+		}, function(item, name) {
+			editor.addButton(name, {
+				tooltip: item[0],
+				cmd: item[1]
+			});
+		});
+
+		// Simple command controls with format state
+		each({
+			blockquote: ['Blockquote', 'mceBlockQuote'],
+			numlist: ['Numbered list', 'InsertOrderedList'],
+			bullist: ['Bullet list', 'InsertUnorderedList'],
+			subscript: ['Subscript', 'Subscript'],
+			superscript: ['Superscript', 'Superscript'],
+			alignleft: ['Align left', 'JustifyLeft'],
+			aligncenter: ['Align center', 'JustifyCenter'],
+			alignright: ['Align right', 'JustifyRight'],
+			alignjustify: ['Justify', 'JustifyFull'],
+			alignnone: ['No alignment', 'JustifyNone']
+		}, function(item, name) {
+			editor.addButton(name, {
+				tooltip: item[0],
+				cmd: item[1],
+				onPostRender: initOnPostRender(name)
+			});
+		});
+
+		function toggleUndoRedoState(type) {
+			return function() {
+				var self = this;
+
+				type = type == 'redo' ? 'hasRedo' : 'hasUndo';
+
+				function checkState() {
+					return editor.undoManager ? editor.undoManager[type]() : false;
+				}
+
+				self.disabled(!checkState());
+				editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function() {
+					self.disabled(editor.readonly || !checkState());
+				});
+			};
+		}
+
+		function toggleVisualAidState() {
+			var self = this;
+
+			editor.on('VisualAid', function(e) {
+				self.active(e.hasVisual);
+			});
+
+			self.active(editor.hasVisual);
+		}
+
+		editor.addButton('undo', {
+			tooltip: 'Undo',
+			onPostRender: toggleUndoRedoState('undo'),
+			cmd: 'undo'
+		});
+
+		editor.addButton('redo', {
+			tooltip: 'Redo',
+			onPostRender: toggleUndoRedoState('redo'),
+			cmd: 'redo'
+		});
+
+		editor.addMenuItem('newdocument', {
+			text: 'New document',
+			icon: 'newdocument',
+			cmd: 'mceNewDocument'
+		});
+
+		editor.addMenuItem('undo', {
+			text: 'Undo',
+			icon: 'undo',
+			shortcut: 'Meta+Z',
+			onPostRender: toggleUndoRedoState('undo'),
+			cmd: 'undo'
+		});
+
+		editor.addMenuItem('redo', {
+			text: 'Redo',
+			icon: 'redo',
+			shortcut: 'Meta+Y',
+			onPostRender: toggleUndoRedoState('redo'),
+			cmd: 'redo'
+		});
+
+		editor.addMenuItem('visualaid', {
+			text: 'Visual aids',
+			selectable: true,
+			onPostRender: toggleVisualAidState,
+			cmd: 'mceToggleVisualAid'
+		});
+
+		editor.addButton('remove', {
+			tooltip: 'Remove',
+			icon: 'remove',
+			cmd: 'Delete'
+		});
+
+		each({
+			cut: ['Cut', 'Cut', 'Meta+X'],
+			copy: ['Copy', 'Copy', 'Meta+C'],
+			paste: ['Paste', 'Paste', 'Meta+V'],
+			selectall: ['Select all', 'SelectAll', 'Meta+A'],
+			bold: ['Bold', 'Bold', 'Meta+B'],
+			italic: ['Italic', 'Italic', 'Meta+I'],
+			underline: ['Underline', 'Underline'],
+			strikethrough: ['Strikethrough', 'Strikethrough'],
+			subscript: ['Subscript', 'Subscript'],
+			superscript: ['Superscript', 'Superscript'],
+			removeformat: ['Clear formatting', 'RemoveFormat']
+		}, function(item, name) {
+			editor.addMenuItem(name, {
+				text: item[0],
+				icon: name,
+				shortcut: item[2],
+				cmd: item[1]
+			});
+		});
+
+		editor.on('mousedown', function() {
+			FloatPanel.hideAll();
+		});
+
+		function toggleFormat(fmt) {
+			if (fmt.control) {
+				fmt = fmt.control.value();
+			}
+
+			if (fmt) {
+				editor.execCommand('mceToggleFormat', false, fmt);
+			}
+		}
+
+		editor.addButton('styleselect', {
+			type: 'menubutton',
+			text: 'Formats',
+			menu: formatMenu
+		});
+
+		editor.addButton('formatselect', function() {
+			var items = [], blocks = createFormats(editor.settings.block_formats ||
+				'Paragraph=p;' +
+				'Heading 1=h1;' +
+				'Heading 2=h2;' +
+				'Heading 3=h3;' +
+				'Heading 4=h4;' +
+				'Heading 5=h5;' +
+				'Heading 6=h6;' +
+				'Preformatted=pre'
+			);
+
+			each(blocks, function(block) {
+				items.push({
+					text: block[0],
+					value: block[1],
+					textStyle: function() {
+						return editor.formatter.getCssText(block[1]);
+					}
+				});
+			});
+
+			return {
+				type: 'listbox',
+				text: blocks[0][0],
+				values: items,
+				fixedWidth: true,
+				onselect: toggleFormat,
+				onPostRender: createListBoxChangeHandler(items)
+			};
+		});
+
+		editor.addButton('fontselect', function() {
+			var defaultFontsFormats =
+				'Andale Mono=andale mono,monospace;' +
+				'Arial=arial,helvetica,sans-serif;' +
+				'Arial Black=arial black,sans-serif;' +
+				'Book Antiqua=book antiqua,palatino,serif;' +
+				'Comic Sans MS=comic sans ms,sans-serif;' +
+				'Courier New=courier new,courier,monospace;' +
+				'Georgia=georgia,palatino,serif;' +
+				'Helvetica=helvetica,arial,sans-serif;' +
+				'Impact=impact,sans-serif;' +
+				'Symbol=symbol;' +
+				'Tahoma=tahoma,arial,helvetica,sans-serif;' +
+				'Terminal=terminal,monaco,monospace;' +
+				'Times New Roman=times new roman,times,serif;' +
+				'Trebuchet MS=trebuchet ms,geneva,sans-serif;' +
+				'Verdana=verdana,geneva,sans-serif;' +
+				'Webdings=webdings;' +
+				'Wingdings=wingdings,zapf dingbats';
+
+			var items = [], fonts = createFormats(editor.settings.font_formats || defaultFontsFormats);
+
+			each(fonts, function(font) {
+				items.push({
+					text: {raw: font[0]},
+					value: font[1],
+					textStyle: font[1].indexOf('dings') == -1 ? 'font-family:' + font[1] : ''
+				});
+			});
+
+			return {
+				type: 'listbox',
+				text: 'Font Family',
+				tooltip: 'Font Family',
+				values: items,
+				fixedWidth: true,
+				onPostRender: createListBoxChangeHandler(items, 'fontname'),
+				onselect: function(e) {
+					if (e.control.settings.value) {
+						editor.execCommand('FontName', false, e.control.settings.value);
+					}
+				}
+			};
+		});
+
+		editor.addButton('fontsizeselect', function() {
+			var items = [], defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
+			var fontsize_formats = editor.settings.fontsize_formats || defaultFontsizeFormats;
+
+			each(fontsize_formats.split(' '), function(item) {
+				var text = item, value = item;
+				// Allow text=value font sizes.
+				var values = item.split('=');
+				if (values.length > 1) {
+					text = values[0];
+					value = values[1];
+				}
+				items.push({text: text, value: value});
+			});
+
+			return {
+				type: 'listbox',
+				text: 'Font Sizes',
+				tooltip: 'Font Sizes',
+				values: items,
+				fixedWidth: true,
+				onPostRender: createListBoxChangeHandler(items, 'fontsize'),
+				onclick: function(e) {
+					if (e.control.settings.value) {
+						editor.execCommand('FontSize', false, e.control.settings.value);
+					}
+				}
+			};
+		});
+
+		editor.addMenuItem('formats', {
+			text: 'Formats',
+			menu: formatMenu
+		});
+	}
+});