spiderfw 0.6.38 → 0.6.39

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

@@ -0,0 +1,62 @@
+/**
+ * ButtonGroup.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 control enables you to put multiple buttons into a group. This is
+ * useful when you want to combine similar toolbar buttons into a group.
+ *
+ * @example
+ * // Create and render a buttongroup with two buttons to the body element
+ * tinymce.ui.Factory.create({
+ *     type: 'buttongroup',
+ *     items: [
+ *         {text: 'Button A'},
+ *         {text: 'Button B'}
+ *     ]
+ * }).renderTo(document.body);
+ *
+ * @-x-less ButtonGroup.less
+ * @class tinymce.ui.ButtonGroup
+ * @extends tinymce.ui.Container
+ */
+define("tinymce/ui/ButtonGroup", [
+	"tinymce/ui/Container"
+], function(Container) {
+	"use strict";
+
+	return Container.extend({
+		Defaults: {
+			defaultType: 'button',
+			role: 'group'
+		},
+
+		/**
+		 * Renders the control as a HTML string.
+		 *
+		 * @method renderHtml
+		 * @return {String} HTML representing the control.
+		 */
+		renderHtml: function() {
+			var self = this, layout = self._layout;
+
+			self.classes.add('btn-group');
+			self.preRender();
+			layout.preRender(self);
+
+			return (
+				'<div id="' + self._id + '" class="' + self.classes + '">' +
+					'<div id="' + self._id + '-body">' +
+						(self.settings.html || '') + layout.renderHtml(self) +
+					'</div>' +
+				'</div>'
+			);
+		}
+	});
+});

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

@@ -0,0 +1,162 @@
+/**
+ * Checkbox.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 control creates a custom checkbox.
+ *
+ * @example
+ * // Create and render a checkbox to the body element
+ * tinymce.ui.Factory.create({
+ *     type: 'checkbox',
+ *     checked: true,
+ *     text: 'My checkbox'
+ * }).renderTo(document.body);
+ *
+ * @-x-less Checkbox.less
+ * @class tinymce.ui.Checkbox
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/Checkbox", [
+	"tinymce/ui/Widget"
+], function(Widget) {
+	"use strict";
+
+	return Widget.extend({
+		Defaults: {
+			classes: "checkbox",
+			role: "checkbox",
+			checked: false
+		},
+
+		/**
+		 * Constructs a new Checkbox instance with the specified settings.
+		 *
+		 * @constructor
+		 * @param {Object} settings Name/value object with settings.
+		 * @setting {Boolean} checked True if the checkbox should be checked by default.
+		 */
+		init: function(settings) {
+			var self = this;
+
+			self._super(settings);
+
+			self.on('click mousedown', function(e) {
+				e.preventDefault();
+			});
+
+			self.on('click', function(e) {
+				e.preventDefault();
+
+				if (!self.disabled()) {
+					self.checked(!self.checked());
+				}
+			});
+
+			self.checked(self.settings.checked);
+		},
+
+		/**
+		 * Getter/setter function for the checked state.
+		 *
+		 * @method checked
+		 * @param {Boolean} [state] State to be set.
+		 * @return {Boolean|tinymce.ui.Checkbox} True/false or checkbox if it's a set operation.
+		 */
+		checked: function(state) {
+			if (!arguments.length) {
+				return this.state.get('checked');
+			}
+
+			this.state.set('checked', state);
+
+			return this;
+		},
+
+		/**
+		 * Getter/setter function for the value state.
+		 *
+		 * @method value
+		 * @param {Boolean} [state] State to be set.
+		 * @return {Boolean|tinymce.ui.Checkbox} True/false or checkbox if it's a set operation.
+		 */
+		value: function(state) {
+			if (!arguments.length) {
+				return this.checked();
+			}
+
+			return this.checked(state);
+		},
+
+		/**
+		 * Renders the control as a HTML string.
+		 *
+		 * @method renderHtml
+		 * @return {String} HTML representing the control.
+		 */
+		renderHtml: function() {
+			var self = this, id = self._id, prefix = self.classPrefix;
+
+			return (
+				'<div id="' + id + '" class="' + self.classes + '" unselectable="on" aria-labelledby="' + id + '-al" tabindex="-1">' +
+					'<i class="' + prefix + 'ico ' + prefix + 'i-checkbox"></i>' +
+					'<span id="' + id + '-al" class="' + prefix + 'label">' + self.encode(self.state.get('text')) + '</span>' +
+				'</div>'
+			);
+		},
+
+		bindStates: function() {
+			var self = this;
+
+			function checked(state) {
+				self.classes.toggle("checked", state);
+				self.aria('checked', state);
+			}
+
+			self.state.on('change:text', function(e) {
+				self.getEl('al').firstChild.data = self.translate(e.value);
+			});
+
+			self.state.on('change:checked change:value', function(e) {
+				self.fire('change');
+				checked(e.value);
+			});
+
+			self.state.on('change:icon', function(e) {
+				var icon = e.value, prefix = self.classPrefix;
+
+				if (typeof icon == 'undefined') {
+					return self.settings.icon;
+				}
+
+				self.settings.icon = icon;
+				icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+
+				var btnElm = self.getEl().firstChild, iconElm = btnElm.getElementsByTagName('i')[0];
+
+				if (icon) {
+					if (!iconElm || iconElm != btnElm.firstChild) {
+						iconElm = document.createElement('i');
+						btnElm.insertBefore(iconElm, btnElm.firstChild);
+					}
+
+					iconElm.className = icon;
+				} else if (iconElm) {
+					btnElm.removeChild(iconElm);
+				}
+			});
+
+			if (self.state.get('checked')) {
+				checked(true);
+			}
+
+			return self._super();
+		}
+	});
+});

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

@@ -0,0 +1,149 @@
+/**
+ * ClassList.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
+ */
+
+/**
+ * Handles adding and removal of classes.
+ *
+ * @private
+ * @class tinymce.ui.ClassList
+ */
+define("tinymce/ui/ClassList", [
+	"tinymce/util/Tools"
+], function(Tools) {
+	"use strict";
+
+	function noop() {
+	}
+
+	/**
+	 * Constructs a new class list the specified onchange
+	 * callback will be executed when the class list gets modifed.
+	 *
+	 * @constructor ClassList
+	 * @param {function} onchange Onchange callback to be executed.
+	 */
+	function ClassList(onchange) {
+		this.cls = [];
+		this.cls._map = {};
+		this.onchange = onchange || noop;
+		this.prefix = '';
+	}
+
+	Tools.extend(ClassList.prototype, {
+		/**
+		 * Adds a new class to the class list.
+		 *
+		 * @method add
+		 * @param {String} cls Class to be added.
+		 * @return {tinymce.ui.ClassList} Current class list instance.
+		 */
+		add: function(cls) {
+			if (cls && !this.contains(cls)) {
+				this.cls._map[cls] = true;
+				this.cls.push(cls);
+				this._change();
+			}
+
+			return this;
+		},
+
+		/**
+		 * Removes the specified class from the class list.
+		 *
+		 * @method remove
+		 * @param {String} cls Class to be removed.
+		 * @return {tinymce.ui.ClassList} Current class list instance.
+		 */
+		remove: function(cls) {
+			if (this.contains(cls)) {
+				for (var i = 0; i < this.cls.length; i++) {
+					if (this.cls[i] === cls) {
+						break;
+					}
+				}
+
+				this.cls.splice(i, 1);
+				delete this.cls._map[cls];
+				this._change();
+			}
+
+			return this;
+		},
+
+		/**
+		 * Toggles a class in the class list.
+		 *
+		 * @method toggle
+		 * @param {String} cls Class to be added/removed.
+		 * @param {Boolean} state Optional state if it should be added/removed.
+		 * @return {tinymce.ui.ClassList} Current class list instance.
+		 */
+		toggle: function(cls, state) {
+			var curState = this.contains(cls);
+
+			if (curState !== state) {
+				if (curState) {
+					this.remove(cls);
+				} else {
+					this.add(cls);
+				}
+
+				this._change();
+			}
+
+			return this;
+		},
+
+		/**
+		 * Returns true if the class list has the specified class.
+		 *
+		 * @method contains
+		 * @param {String} cls Class to look for.
+		 * @return {Boolean} true/false if the class exists or not.
+		 */
+		contains: function(cls) {
+			return !!this.cls._map[cls];
+		},
+
+		/**
+		 * Returns a space separated list of classes.
+		 *
+		 * @method toString
+		 * @return {String} Space separated list of classes.
+		 */
+
+		_change: function() {
+			delete this.clsValue;
+			this.onchange.call(this);
+		}
+	});
+
+	// IE 8 compatibility
+	ClassList.prototype.toString = function() {
+		var value;
+
+		if (this.clsValue) {
+			return this.clsValue;
+		}
+
+		value = '';
+		for (var i = 0; i < this.cls.length; i++) {
+			if (i > 0) {
+				value += ' ';
+			}
+
+			value += this.prefix + this.cls[i];
+		}
+
+		return value;
+	};
+
+	return ClassList;
+});

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

@@ -0,0 +1,438 @@
+/**
+ * Collection.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
+ */
+
+/**
+ * Control collection, this class contains control instances and it enables you to
+ * perform actions on all the contained items. This is very similar to how jQuery works.
+ *
+ * @example
+ * someCollection.show().disabled(true);
+ *
+ * @class tinymce.ui.Collection
+ */
+define("tinymce/ui/Collection", [
+	"tinymce/util/Tools",
+	"tinymce/ui/Selector",
+	"tinymce/util/Class"
+], function(Tools, Selector, Class) {
+	"use strict";
+
+	var Collection, proto, push = Array.prototype.push, slice = Array.prototype.slice;
+
+	proto = {
+		/**
+		 * Current number of contained control instances.
+		 *
+		 * @field length
+		 * @type Number
+		 */
+		length: 0,
+
+		/**
+		 * Constructor for the collection.
+		 *
+		 * @constructor
+		 * @method init
+		 * @param {Array} items Optional array with items to add.
+		 */
+		init: function(items) {
+			if (items) {
+				this.add(items);
+			}
+		},
+
+		/**
+		 * Adds new items to the control collection.
+		 *
+		 * @method add
+		 * @param {Array} items Array if items to add to collection.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		add: function(items) {
+			var self = this;
+
+			// Force single item into array
+			if (!Tools.isArray(items)) {
+				if (items instanceof Collection) {
+					self.add(items.toArray());
+				} else {
+					push.call(self, items);
+				}
+			} else {
+				push.apply(self, items);
+			}
+
+			return self;
+		},
+
+		/**
+		 * Sets the contents of the collection. This will remove any existing items
+		 * and replace them with the ones specified in the input array.
+		 *
+		 * @method set
+		 * @param {Array} items Array with items to set into the Collection.
+		 * @return {tinymce.ui.Collection} Collection instance.
+		 */
+		set: function(items) {
+			var self = this, len = self.length, i;
+
+			self.length = 0;
+			self.add(items);
+
+			// Remove old entries
+			for (i = self.length; i < len; i++) {
+				delete self[i];
+			}
+
+			return self;
+		},
+
+		/**
+		 * Filters the collection item based on the specified selector expression or selector function.
+		 *
+		 * @method filter
+		 * @param {String} selector Selector expression to filter items by.
+		 * @return {tinymce.ui.Collection} Collection containing the filtered items.
+		 */
+		filter: function(selector) {
+			var self = this, i, l, matches = [], item, match;
+
+			// Compile string into selector expression
+			if (typeof selector === "string") {
+				selector = new Selector(selector);
+
+				match = function(item) {
+					return selector.match(item);
+				};
+			} else {
+				// Use selector as matching function
+				match = selector;
+			}
+
+			for (i = 0, l = self.length; i < l; i++) {
+				item = self[i];
+
+				if (match(item)) {
+					matches.push(item);
+				}
+			}
+
+			return new Collection(matches);
+		},
+
+		/**
+		 * Slices the items within the collection.
+		 *
+		 * @method slice
+		 * @param {Number} index Index to slice at.
+		 * @param {Number} len Optional length to slice.
+		 * @return {tinymce.ui.Collection} Current collection.
+		 */
+		slice: function() {
+			return new Collection(slice.apply(this, arguments));
+		},
+
+		/**
+		 * Makes the current collection equal to the specified index.
+		 *
+		 * @method eq
+		 * @param {Number} index Index of the item to set the collection to.
+		 * @return {tinymce.ui.Collection} Current collection.
+		 */
+		eq: function(index) {
+			return index === -1 ? this.slice(index) : this.slice(index, +index + 1);
+		},
+
+		/**
+		 * Executes the specified callback on each item in collection.
+		 *
+		 * @method each
+		 * @param {function} callback Callback to execute for each item in collection.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		each: function(callback) {
+			Tools.each(this, callback);
+
+			return this;
+		},
+
+		/**
+		 * Returns an JavaScript array object of the contents inside the collection.
+		 *
+		 * @method toArray
+		 * @return {Array} Array with all items from collection.
+		 */
+		toArray: function() {
+			return Tools.toArray(this);
+		},
+
+		/**
+		 * Finds the index of the specified control or return -1 if it isn't in the collection.
+		 *
+		 * @method indexOf
+		 * @param {Control} ctrl Control instance to look for.
+		 * @return {Number} Index of the specified control or -1.
+		 */
+		indexOf: function(ctrl) {
+			var self = this, i = self.length;
+
+			while (i--) {
+				if (self[i] === ctrl) {
+					break;
+				}
+			}
+
+			return i;
+		},
+
+		/**
+		 * Returns a new collection of the contents in reverse order.
+		 *
+		 * @method reverse
+		 * @return {tinymce.ui.Collection} Collection instance with reversed items.
+		 */
+		reverse: function() {
+			return new Collection(Tools.toArray(this).reverse());
+		},
+
+		/**
+		 * Returns true/false if the class exists or not.
+		 *
+		 * @method hasClass
+		 * @param {String} cls Class to check for.
+		 * @return {Boolean} true/false state if the class exists or not.
+		 */
+		hasClass: function(cls) {
+			return this[0] ? this[0].classes.contains(cls) : false;
+		},
+
+		/**
+		 * Sets/gets the specific property on the items in the collection. The same as executing control.<property>(<value>);
+		 *
+		 * @method prop
+		 * @param {String} name Property name to get/set.
+		 * @param {Object} value Optional object value to set.
+		 * @return {tinymce.ui.Collection} Current collection instance or value of the first item on a get operation.
+		 */
+		prop: function(name, value) {
+			var self = this, undef, item;
+
+			if (value !== undef) {
+				self.each(function(item) {
+					if (item[name]) {
+						item[name](value);
+					}
+				});
+
+				return self;
+			}
+
+			item = self[0];
+
+			if (item && item[name]) {
+				return item[name]();
+			}
+		},
+
+		/**
+		 * Executes the specific function name with optional arguments an all items in collection if it exists.
+		 *
+		 * @example collection.exec("myMethod", arg1, arg2, arg3);
+		 * @method exec
+		 * @param {String} name Name of the function to execute.
+		 * @param {Object} ... Multiple arguments to pass to each function.
+		 * @return {tinymce.ui.Collection} Current collection.
+		 */
+		exec: function(name) {
+			var self = this, args = Tools.toArray(arguments).slice(1);
+
+			self.each(function(item) {
+				if (item[name]) {
+					item[name].apply(item, args);
+				}
+			});
+
+			return self;
+		},
+
+		/**
+		 * Remove all items from collection and DOM.
+		 *
+		 * @method remove
+		 * @return {tinymce.ui.Collection} Current collection.
+		 */
+		remove: function() {
+			var i = this.length;
+
+			while (i--) {
+				this[i].remove();
+			}
+
+			return this;
+		},
+
+		/**
+		 * Adds a class to all items in the collection.
+		 *
+		 * @method addClass
+		 * @param {String} cls Class to add to each item.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		addClass: function(cls) {
+			return this.each(function(item) {
+				item.classes.add(cls);
+			});
+		},
+
+		/**
+		 * Removes the specified class from all items in collection.
+		 *
+		 * @method removeClass
+		 * @param {String} cls Class to remove from each item.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		removeClass: function(cls) {
+			return this.each(function(item) {
+				item.classes.remove(cls);
+			});
+		}
+
+		/**
+		 * Fires the specified event by name and arguments on the control. This will execute all
+		 * bound event handlers.
+		 *
+		 * @method fire
+		 * @param {String} name Name of the event to fire.
+		 * @param {Object} args Optional arguments to pass to the event.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		// fire: function(event, args) {}, -- Generated by code below
+
+		/**
+		 * Binds a callback to the specified event. This event can both be
+		 * native browser events like "click" or custom ones like PostRender.
+		 *
+		 * The callback function will have two parameters the first one being the control that received the event
+		 * the second one will be the event object either the browsers native event object or a custom JS object.
+		 *
+		 * @method on
+		 * @param {String} name Name of the event to bind. For example "click".
+		 * @param {String/function} callback Callback function to execute ones the event occurs.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		// on: function(name, callback) {}, -- Generated by code below
+
+		/**
+		 * Unbinds the specified event and optionally a specific callback. If you omit the name
+		 * parameter all event handlers will be removed. If you omit the callback all event handles
+		 * by the specified name will be removed.
+		 *
+		 * @method off
+		 * @param {String} name Optional name for the event to unbind.
+		 * @param {function} callback Optional callback function to unbind.
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		// off: function(name, callback) {}, -- Generated by code below
+
+		/**
+		 * Shows the items in the current collection.
+		 *
+		 * @method show
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		// show: function() {}, -- Generated by code below
+
+		/**
+		 * Hides the items in the current collection.
+		 *
+		 * @method hide
+		 * @return {tinymce.ui.Collection} Current collection instance.
+		 */
+		// hide: function() {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the text contents of the items in the current collection.
+		 *
+		 * @method text
+		 * @return {tinymce.ui.Collection} Current collection instance or text value of the first item on a get operation.
+		 */
+		// text: function(value) {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the name contents of the items in the current collection.
+		 *
+		 * @method name
+		 * @return {tinymce.ui.Collection} Current collection instance or name value of the first item on a get operation.
+		 */
+		// name: function(value) {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the disabled state on the items in the current collection.
+		 *
+		 * @method disabled
+		 * @return {tinymce.ui.Collection} Current collection instance or disabled state of the first item on a get operation.
+		 */
+		// disabled: function(state) {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the active state on the items in the current collection.
+		 *
+		 * @method active
+		 * @return {tinymce.ui.Collection} Current collection instance or active state of the first item on a get operation.
+		 */
+		// active: function(state) {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the selected state on the items in the current collection.
+		 *
+		 * @method selected
+		 * @return {tinymce.ui.Collection} Current collection instance or selected state of the first item on a get operation.
+		 */
+		// selected: function(state) {}, -- Generated by code below
+
+		/**
+		 * Sets/gets the selected state on the items in the current collection.
+		 *
+		 * @method visible
+		 * @return {tinymce.ui.Collection} Current collection instance or visible state of the first item on a get operation.
+		 */
+		// visible: function(state) {}, -- Generated by code below
+	};
+
+	// Extend tinymce.ui.Collection prototype with some generated control specific methods
+	Tools.each('fire on off show hide append prepend before after reflow'.split(' '), function(name) {
+		proto[name] = function() {
+			var args = Tools.toArray(arguments);
+
+			this.each(function(ctrl) {
+				if (name in ctrl) {
+					ctrl[name].apply(ctrl, args);
+				}
+			});
+
+			return this;
+		};
+	});
+
+	// Extend tinymce.ui.Collection prototype with some property methods
+	Tools.each('text name disabled active selected checked visible parent value data'.split(' '), function(name) {
+		proto[name] = function(value) {
+			return this.prop(name, value);
+		};
+	});
+
+	// Create class based on the new prototype
+	Collection = Class.extend(proto);
+
+	// Stick Collection into Selector to prevent circual references
+	Selector.Collection = Collection;
+
+	return Collection;
+});