locomotive-aloha-rails 0.20.1.5 → 0.23.2.1

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/arena.js

@@ -0,0 +1,11 @@
+define(['jquery', 'ui/component'],function($, Component){
+	var Arena = Component.extend({
+		init: function(){
+			this.element = $('<div>');
+		},
+		adopt: function(component) {
+			this.element.append(component.element);
+		}
+	});
+	return Arena;
+});

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/autocomplete.js

@@ -0,0 +1,70 @@
+define([
+	'jquery',
+	'aloha/repositorymanager',
+	'ui/component',
+	'ui/context',
+	'./vendor/jquery-ui-autocomplete-html',
+], function(
+	jQuery,
+	RepositoryManager,
+	Context,
+	Component
+) {
+	'use strict';
+
+	/**
+	 * Generates the HTML for an item
+	 * @param {string} template
+	 * @param {object} item
+	 * @return {string}
+	 */
+	function parse( template, item ) {
+		return template.replace( /{{([^}]+)}}/g, function( _, name ) {
+			return name in item ? item[ name ] : "";
+		});
+	}
+
+	/**
+	 * Autocomplete component type
+	 * @class
+	 * @extends {Component}
+	 */
+	var Autocomplete = Component.extend({
+		init: function() {
+			this._super();
+			var that = this;
+			this.element = jQuery( "<input>" )
+				.autocomplete({
+					html: true,
+					appendTo: Context.selector,
+					source: function( req, res ) {
+						RepositoryManager.query({
+							queryString: req.term,
+							objectTypeFilter: that.types
+						}, function( data ) {
+							res( jQuery.map( data.items, function( item ) {
+								return {
+									label: parse( that.template, item ),
+									value: item.name,
+									obj: item
+								};
+							}));
+						});
+					}
+				})
+				.bind( "autocompletechange", jQuery.proxy( function( event, ui ) {
+					this.setValue( event.target.value, ui.item ? ui.item.obj : null );
+				}, this ) );
+		},
+
+		// invoked when the user has changed the value and blurred the field
+		/**
+		 * Sets the value of the component
+		 * @param {string} value Raw value
+		 * @param {object} item Structured value
+		 */
+		setValue: function( value, item ) {}
+	});
+
+	return Autocomplete;
+});

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/button.js

@@ -0,0 +1,114 @@
+/**
+ * NOTES:
+ *    - Why do we maintain 2 references to the DOM element for a button
+ *    component (this.element = this.buttonElement)?
+ */
+
+define([
+	'jquery',
+	'ui/component',
+	'ui/utils',
+	'jqueryui'
+],
+function (jQuery, Component, Utils) {
+	'use strict';
+
+	/**
+	 * Implements a simple button component.  All interactive UI controls (that
+	 * is--anything that is not a label) will most probably extend the Button
+	 * component.
+	 *
+	 * An extending class should optionally define the following properties
+	 * tooltip - the internationalized tooltip text,
+	 * icon    - the icon class,
+	 * class   - an additional class to add to the button element,
+	 * click   - the click handler for the button.
+	 *
+	 * @class
+	 * @name Button
+	 * @extends {Component}
+	 */
+	var Button = Component.extend({
+
+		/**
+		 * Initializes this button instance.
+		 * The initialization is done when the component is rendered, not when
+		 * it is created.  This is necessary to allow multiple renderings of
+		 * the same component.  For example, you may want a component to be in
+		 * the toolbar and in the sidebar.
+		 *
+		 * @override
+		 */
+		init: function () {
+			this._super();
+			this.createButtonElement();
+			Utils.makeButton(this.buttonElement, this)
+				.button('widget')
+				.tooltip({
+					tooltipClass: 'aloha aloha-ui-tooltip',
+					position: {
+						my: 'left top',
+						at: 'right bottom'
+					}
+				})
+				.click(jQuery.proxy(function () {
+
+					// Ensure tooltips are always hidden after a button
+					// is clicked because sometimes the tooltip doesn't
+					// get closed automatically, for example after table
+					// cells are merged or split.
+					// IE needs the force argument to be true, Chrome doesn't.
+					// The event argument can be ignored.
+					this.buttonElement.tooltip('close', null/*event*/, true/*force*/);
+
+					this._onClick();
+				}, this));
+		},
+
+		/**
+		 * May be overridden by component subclasses to implement
+		 * component-specific behaviour.  The default implementation just calls
+		 * the public click method.
+		 *
+		 * @protected
+		 */
+		_onClick: function () {
+			this.click();
+		},
+
+		/**
+		 * Handles mouse clicks on this button's rendered elements.
+		 */
+		click: function () {},
+
+		/**
+		 * Creates the DOM element to be rendered for user interaction.
+		 *
+		 * @return {jQuery<HTMLElement>}
+		 */
+		createButtonElement: function () {
+			var button = Utils.makeButtonElement();
+			if (this['class']) {
+				button.addClass(this['class']);
+			}
+			this.element = this.buttonElement = button;
+			return button;
+		},
+
+		/**
+		 * Shows the button in a greyed-out inactive (unclickable) state.
+		 */
+		disable: function() {
+			this.element.button('option', 'disabled', false);
+		},
+
+		/**
+		 * Enables the button again after it has previously been disabled.
+		 */
+		enable: function(enable_opt) {
+			this.element.button('option', 'disabled', enable_opt === false);
+		}
+	});
+
+	return Button;
+});

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/component.js

@@ -0,0 +1,121 @@
+define([
+	'aloha/core',
+	'jquery',
+	'util/class'
+], function (
+	Aloha,
+	$,
+	Class
+) {
+	'use strict';
+
+	var idCounter = 0;
+
+	/**
+	 * Component class and manager.
+	 *
+	 * This implementation constitues the base of all UI components (buttons,
+	 * and labels).  The `Component' constructor object, with its static
+	 * properties and functions, manages all components instances.
+	 *
+	 * @class
+	 * @base
+	 */
+	var Component = Class.extend({
+
+		id: 0,
+
+		/**
+		 * Flag to indicate that this is an instance of a component and  not the class object.
+		 */
+		isInstance: true,
+
+		/**
+		 * The Container instance or null if this component was not
+		 * adopted by a counter by calling Component.adopt().
+		 */
+		container: null,
+
+		/**
+		 * Will be set in Component.define()
+		 */
+		type: null,
+
+		/**
+		 * @type {boolean} Whether or not this component is visible.
+		 */
+		visible: true,
+
+		/**
+		 * The type property is set in Component.define(), so components should only ever be instantiated through define.
+		 * @constructor
+		 */
+		_constructor: function () {
+			this.id = idCounter++;
+			this.init();
+		},
+
+		adoptParent: function (container) {
+			this.container = container;
+		},
+
+		/**
+		 * Initializes this component.  To be implemented in subclasses.
+		 */
+		init: function () {},
+
+		isVisible: function () {
+			return this.visible;
+		},
+
+		/**
+		 * Shows this component.
+		 */
+		show: function (show_opt) {
+			if (false === show_opt) {
+				this.hide();
+				return;
+			}
+			// Only call container.childVisible if we switch from hidden to visible
+			if (!this.visible) {
+				this.visible = true;
+				this.element.show();
+				if (this.container) {
+					this.container.childVisible(this, true);
+				}
+			}
+		},
+
+		/**
+		 * Hides this component.
+		 */
+		hide: function () {
+			// Only call container.childVisible if we switch from visible to hidden
+			if (this.visible) {
+				this.visible = false;
+				this.element.hide();
+				if (this.container) {
+					this.container.childVisible(this, false);
+				}
+			}
+		},
+
+		focus: function () {
+			this.element.focus();
+			if (this.container) {
+				this.container.childFocus(this);
+			}
+		},
+
+		foreground: function () {
+			if (this.container) {
+				this.container.childForeground(this);
+			}
+		},
+
+		enable: function (enable_opt) {},
+		disable: function () {}
+	});
+
+	return Component;
+});

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/container.js

@@ -0,0 +1,210 @@
+/**
+ * Defines a `Container` Class.
+ *
+ * Containers are activated based on the `showOn` setting for the container.
+ * The values are normalized to functions which accept an element and return a
+ * boolean; true means the container should be shown.
+ *
+ * For efficiency, we group all containers that have the same normalized
+ * `showOn()' function together, so we can evaluate it once, regardless of how
+ * many containers are using the same logic. In order for this to work, the
+ * exact same function must be returned from `Container.normalizeShowOn()' when
+ * the logic is the same.
+ *
+ * The list of containers is then stored on the context instance as
+ * `context.containers', which is a hash of `showOn()' ids to an array of
+ * containers. The `showOn()' ids are unique identifiers that are stored as
+ * properties of the `showOn()' function (see `getShowOnId()'). This gives us
+ * constant lookup times when grouping containers.
+ */
+
+define([
+	'jquery',
+	'util/class',
+	'ui/scopes'
+], function(
+	$,
+	Class,
+	Scopes
+) {
+	'use strict';
+
+	var uid = 0;
+
+	/**
+	 * Gets the id of a normalized showOn option.  If the given function has
+	 * not had its showOnId set it will receive one, the first time this
+	 * function it is passed to this function.
+	 *
+	 * @param {function} showOn The function whose id we wish to get.
+	 * @return {number} The id of the given function.
+	 */
+	function getShowOnId(showOn) {
+		// Store a unique id on the showOn function.
+		// See full explanation at top of file.
+		if (!showOn.showOnId) {
+			showOn.showOnId = ++uid;
+		}
+		return showOn.showOnId;
+	}
+
+	/**
+	 * Show or hide a set of containers.
+	 *
+	 * @param {Array.<Container>} containers The set of containers to operate
+	 *                                       on.
+	 * @param {boolean} show Whether to show or hide the given containers.
+	 */
+	function toggleContainers(containers, show) {
+		var action = show ? 'show' : 'hide',
+		    i;
+		for (i = 0; i < containers.length; i++) {
+			containers[i][action]();
+		}
+	}
+
+	var scopeFns = {};
+
+	var returnTrue = function() {
+		return true;
+	};
+
+	/**
+	 * Normalizes a showOn option into a function.
+	 *
+	 * @param {(string|boolean|function)} showOn
+	 * @return function
+	 */
+	function normalizeShowOn(container, showOn) {
+		switch ($.type(showOn)) {
+		case 'function':
+			return showOn;
+		case 'object':
+			if (showOn.scope) {
+				if (scopeFns[showOn.scope]) {
+					return scopeFns[showOn.scope];
+				}
+				return scopeFns[showOn.scope] = function() {
+					return Scopes.isActiveScope(showOn.scope);
+				};
+			} else {
+				throw "Invalid showOn configuration";
+			}
+		default:
+			return returnTrue;
+		}
+	}
+
+	/**
+	 * Container class.
+	 *
+	 * @class
+	 * @base
+	 */
+	var Container = Class.extend({
+
+		/**
+		 * The containing (wrapper) element for this container.
+		 *
+		 * @type {jQuery<HTMLElement>}
+		 */
+		element: null,
+
+		/**
+		 * Initialize a new container with the specified properties.
+		 *
+		 * @param {object=} settings Optional properties, and override methods.
+		 * @constructor
+		 */
+		_constructor: function(context, settings) {
+			var showOn = normalizeShowOn(this, settings.showOn),
+			    key = getShowOnId(showOn),
+			    group = context.containers[key];
+			this.context = context;
+			if (!group) {
+				group = context.containers[key] = {
+					shouldShow: showOn,
+					containers: []
+				};
+			}
+			group.containers.push(this);
+		},
+
+		/**
+		 * Must be implemented by extending classes.
+		 *
+		 * @ingroup api
+		 * @{
+		 */
+
+		/**
+		 * A container is also a component; this is part of the component API.
+		 */
+		show: function() {},
+		/**
+		 * A container is also a component; this is part of the component API.
+		 */
+		hide: function() {},
+		/**
+		 * A container is also a component; this is part of the component API.
+		 */
+		focus: function() {},
+		/**
+		 * A container is also a component; this is part of the component API.
+		 */
+		foreground: function() {},
+
+		/**
+		 * The container was previously hidden, and now has become visible. This
+		 * allows a container to let its children react to this.
+		 */
+		childVisible: function(childComponent, visible) {},
+		/**
+		 * The container was given focus; this method must give focus to all
+		 * children of the container.
+		 * Optional. (E.g. tab.js doesn't implement this.)
+		 */
+		childFocus: function(childComponent) {},
+		/**
+		 * The container was foregrounded; this method must foreground all children
+		 * of the container.
+		 */
+		childForeground: function(childComponent) {}
+
+		/**
+		 * @} End of "ingroup api".
+		 */
+
+	});
+
+	// static fields
+
+	$.extend( Container, {
+		/**
+		 * Given an array of elements, show appropriate containers.
+		 *
+		 * @param {object} context
+		 * @param {string} eventType Type of the event triggered (optional)
+		 * @static
+		 */
+		showContainersForContext: function(context, eventType) {
+			var group,
+			    groupKey,
+			    containerGroups;
+			if (!context.containers) {
+				// No containers were constructed for the given context, so
+				// there is nothing for us to do.
+				return;
+			}
+			containerGroups = context.containers;
+			for (groupKey in containerGroups) {
+				if (containerGroups.hasOwnProperty(groupKey)) {
+					group = containerGroups[groupKey];
+					toggleContainers(group.containers, group.shouldShow(eventType));
+				}
+			}
+		}
+	});
+
+	return Container;
+});