gnuside-aloha-rails 0.23.3

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

@@ -0,0 +1,183 @@
+define([
+	'aloha/core',
+	'jquery',
+	'PubSub'
+], function (
+	Aloha,
+	jQuery,
+	PubSub
+) {
+	'use strict';
+
+	/**
+	 * The last uid that was was used to uniquely identify a function.
+	 * NB: Make sure to increment this counter before assigning it to a new
+	 *     function.
+	 *
+	 * @type {numder}
+	 * @private
+	 */
+	var alohaUid = 0;
+
+	/**
+	 * A spares array, where arguments lists are indexed against the alohaUid of
+	 * the guarded dispatch function with which they were registered with.
+	 *
+	 * @type {object.<number, array>}
+	 * @private
+	 */
+	var registeredArguments = {};
+
+	/**
+	 * A spares array of guarded dispatch functions indexed against their
+	 * alohaUid.  Each entry in this array will correspond with an entry in the
+	 * `registeredArguments' map which is exists on the same index.
+	 *
+	 * @type {object.<number, array>}
+	 * @private
+	 */
+	var registeredGuards = {};
+
+	/**
+	 * For a given function, will derive its unique identifing number.  Be
+	 * aware that although this is a "getter" function, it will mutate the
+	 * given function, and the closure variable `alohaUid' if the given
+	 * function has not had a unique id set to it.
+	 *
+	 * @param {function} func Function whose uid is to be retreived.
+	 * @return {number} The alohaUid property that has been assigned to the
+	 *                  given function.
+	 */
+	function getUid(func) {
+		if (!func.alohaUid) {
+			func.alohaUid = ++alohaUid;
+		}
+		return func.alohaUid;
+	}
+
+	/**
+	 * Retrieves a list of all guard functions that are registered for the
+	 * given event.
+	 *
+	 * @param {string} event The name of the event whose guard functions are to
+	 *                       be to retreive.
+	 * @return {array.<function>} A list of guarded dispatch functions that
+	 *                            were registered to handle the given event.
+	 */
+	function getRegisteredGuards(event) {
+		return registeredGuards[event] || [];
+	}
+
+	/**
+	 * Retrieves a list of argument lists that were registerd with the given
+	 * guard function.
+	 *
+	 * @paran {function} guard A function that is to filter and dispatch.
+	 * @return {array.<*>} A list of arguments list.
+	 */
+	function getArguments(guard) {
+		return registeredArguments[guard.alohaUid] || [];
+	}
+
+	/**
+	 * Registers the given arguments list against the provided guard function.
+	 *
+	 * @paran {function} guard A function that is to filter and dispatch a
+	 *                         variable number of callbacks.
+	 * @return {array.<*>} The list of all registed arguments lists that
+	 *                     correspond with the given guard.
+	 */
+	function registerArguments(guard, args) {
+		if (!registeredArguments[guard.alohaUid]) {
+			registeredArguments[guard.alohaUid] = [];
+		}
+		registeredArguments[guard.alohaUid].push(args);
+		return registeredArguments[guard.alohaUid];
+	}
+
+	/**
+	 * Registers the given guard function to the given event.
+	 *
+	 * @paran {string} event The event on which to invoke the guard.
+	 * @paran {function} guard A function that is to filter and dispatch a
+	 *                         variable number of callbacks.
+	 * @return {array.<*>} The list of all registed guard functions that
+	 *                     correspond with the given guard.
+	 */
+	function registerGuard(event, guard) {
+		if (!registeredGuards[event]) {
+			registeredGuards[event] = [];
+		}
+		registeredGuards[event].push(guard);
+		return registeredGuards[event];
+	}
+
+	/**
+	 * Process a guard functions that have been registered on the given event
+	 * when the event is triggered.
+	 *
+	 * @param {Event} event Name of the event.
+	 * @param ... any other arguments passed on to the guard function
+	 */
+	function trigger(event) {
+		var guards = getRegisteredGuards(event);
+		var i;
+		for (i = 0; i < guards.length; i++) {
+			guards[i].apply(null, [getArguments(guards[i])].concat(arguments));
+		}
+	}
+
+	/**
+	 * Provides a mechanism to register event handlers that are filtered and
+	 * dispatched through a guard function.
+	 *
+	 * All arguments following the guard parameter will be passed to the guard
+	 * function in a list containing a tuple of arguments.  It is expected that
+	 * one of the arguments will be a callback function that will be call if
+	 * the other arguments pass the condition implemented in the guarded
+	 * dispatch function.
+	 *
+	 * USAGE:
+	 *    sub(event, dispatch [, ... ])
+	 *
+	 * @param {string} event
+	 * @param {function(array.<array.<*...>>)} guard A function that will be
+	 *                                               invoked when the specified
+	 *                                               event is fired.  This
+	 *                                               function will receive a
+	 *                                               array consisting of
+	 *                                               arguments tuples, followed
+	 *                                               by the the arguments that
+	 *                                               are received from the
+	 *                                               event.
+	 * @param {*...} args A variable number of arguments which will be passed
+	 *                    as a list in a list to the dispatch function.
+	 */
+	function sub() {
+		var args = Array.prototype.slice.call(arguments);
+		var events = args.shift();
+		if (typeof events === 'string') {
+			events = [events];
+		}
+		var guard = args.shift();
+		getUid(guard);
+		registerArguments(guard, args);
+		var i;
+		var event;
+		var bindHandler = function ($event, range, nativeEvent) {
+			trigger(event, $event, range, nativeEvent);
+		};
+		var pubsubHandler = function () {
+			trigger(event);
+		};
+		for (i = 0; i < events.length; i++) {
+			event = events[i];
+			registerGuard(event, guard);
+			Aloha.bind(event, bindHandler);
+			PubSub.sub(event, pubsubHandler);
+		}
+	}
+
+	return sub;
+
+});

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

@@ -0,0 +1,106 @@
+define([
+	'aloha/core',
+	'jquery',
+	'util/class',
+	'ui/container'
+], function(
+	Aloha,
+	$,
+	Class,
+	Container
+) {
+	'use strict';
+
+	/**
+	 * The Surface class and manager.
+	 *
+	 * @class
+	 * @base
+	 */
+	var Surface = Class.extend({
+		_constructor: function(context) {
+			context.surfaces.push(this);
+		},
+
+		/**
+		 * Check for whether or not this surface is active--that is, whether is
+		 * is visible and the user can interact with it.
+		 *
+		 * @eturn {boolean} True if this surface is visible.
+		 */
+		isActive: function() {
+			return true;
+		}
+	});
+
+	// Static fields for the Surface class.
+
+	$.extend(Surface, {
+
+		/**
+		 * The range of the current selection.
+		 * 
+		 * Interacting with a surface removes focus from the editable, so the
+		 * surface is responsible for keeping track of the range that should be
+		 * modified by the components.
+		 * 
+		 * @static
+		 * @type {Aloha.Selection}
+		 */
+		range: null,
+
+		/**
+		 * Shows all surfaces for a given context.
+		 *
+		 * @param {!Object} context.
+		 */
+		show: function(context) {
+			$.each(context.surfaces, function(i, surface) {
+				surface.show();
+			});
+		},
+
+		/**
+		 * Hides all surfaces for a given context.
+		 *
+		 * @param {!Object} context
+		 */
+		hide: function(context) {
+			$.each(context.surfaces, function (i, surface) {
+				surface.hide();
+			});
+		},
+
+		/**
+		 * Track editable and range when interacting with a surface.
+		 *
+		 * @param {jQuery<HTMLElement>} element A component or surface for
+		 *                                      which we wish to keep track of
+		 *                                      the current selection range
+		 *                                      when the user interacts with
+		 *                                      it.
+		 */
+		trackRange: function(element) {
+			element.bind('mousedown', function(e) {
+				e.originalEvent.stopSelectionUpdate = true;
+				Aloha.eventHandled = true;
+				Surface.suppressHide = true;
+
+				if (Aloha.activeEditable) {
+					var selection = Aloha.getSelection();
+					Surface.range = (0 < selection.getRangeCount())
+					              ? selection.getRangeAt(0)
+								  : null;
+				}
+			});
+			
+			element.bind('mouseup', function(e) {
+				e.originalEvent.stopSelectionUpdate = true;
+				Aloha.eventHandled = false;
+				Surface.suppressHide = false;
+			});
+		}
+	});
+
+	return Surface;
+});

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

@@ -0,0 +1,316 @@
+define([
+	'aloha/core',
+	'jquery',
+	'ui/container',
+	'ui/component',
+	'PubSub',
+	'jqueryui'
+], function (
+	Aloha,
+	$,
+	Container,
+	Component,
+	PubSub
+) {
+	'use strict';
+
+	var idCounter = 0;
+	var slottedComponents = {};
+
+	function hasVisibleComponents(tab){
+		var i, slot, component, hasVisible = false;
+
+		// the problem is, a container component had a button to expand the options
+		if( $(
+				'button:not(.aloha-multisplit-toggle)',
+				tab.panel
+			).length !== 0
+		){
+			hasVisible = true;
+		}
+
+		/*
+		// @todo this algorithm must be enhanced, asking each component if is visible
+		// this is the longest aproach, I iterate the components registered in
+		// this tab
+		for(i = 0; i < tab._slotsList.length; i++){
+			if(undefined !== slottedComponents[slotName]){
+				if($(
+						'button:not(.aloha-multisplit-toggle)',
+						slottedComponents[slotName].element
+					).length !== 0
+				){
+					hasVisible = true;
+					break;
+				}
+			}
+		}
+		*/
+		return hasVisible;
+	}
+
+	/**
+	 * Defines a Container object that represents a collection of related
+	 * component groups to be rendered together on the toolbar.  Tabs are
+	 * organized by feature and functionality so that related controls can be
+	 * brought in and out of view depending on whether they are
+	 * appropriate for a given user context.
+	 *
+	 * Tabs can be defined declaritively in the Aloha configuration in the
+	 * following manner:
+	 *
+	 *    Aloha.settings.toolbar: [
+	 *      {
+	 *         label: 'Lists',
+	 *         showOn: 'ul,ol,*.parent(.aloha-editable ul,.aloha-editable ol)',
+	 *         components: [ [ 'orderedList', 'unorderedList' ] ]
+	 *      }
+	 *    ]
+	 *
+	 * Alternatively, tabs can also be created imperatively in this way:
+	 * new Tab( options, components ).
+	 *
+	 * @class
+	 * @extends {Container}
+	 */
+	var Tab = Container.extend({
+
+		_elemBySlot: null,
+		_groupBySlot: null,
+		_groupByComponent: null,
+
+		/**
+		 * All that this constructor does is save the components array into a
+		 * local variable, to be used during instantialization.
+		 *
+		 * @param {object} settings
+		 * @param {Array.<Array<string>>} components
+		 * @constructor
+		 */
+		_constructor: function (context, settings, components) {
+			var thisTab = this,
+			    i, j,
+			    elem,
+			    groupedComponents,
+			    group,
+			    groupProps,
+			    componentName;
+
+			this._elemBySlot = {};
+			this._groupBySlot = {};
+			this._groupByComponent = {};
+			this._slotsList = [];
+			this._super(context, settings);
+
+			this.container = settings.container;
+			this.list = this.container.data('list');
+			this.panels = this.container.data('panels');
+			this.id = 'tab-ui-container-' + (++idCounter);
+			this.panel = $('<div>', {id : this.id, 'unselectable': 'on'});
+			this.handle = $('<li><a href="' + location.href.replace(/#.*$/, '') + '#' + this.id + '">' +
+				settings.label + '</a></li>');
+
+			for (i = 0; i < components.length; i++) {
+				if (typeof components[i] === 'string') {
+					if (1 === components[i].length && components[i].charCodeAt(0) === 10) {
+						this.panel.append('<div>', {'unselectable': 'on'});
+					} else {
+						elem = $('<span>', {'unselectable': 'on'});
+						this._elemBySlot[components[i]] = elem;
+						this.panel.append(elem);
+					}
+				} else {
+					// Hide the group until the first button is adopted into it.
+					group = $('<div>', {
+						'class': 'aloha-ui-component-group aloha-ui-hidden',
+						'unselectable': 'on'
+					}).appendTo(this.panel);
+					groupProps = {element: group, visibleCounter: 0};
+					groupedComponents = components[i];
+					for (j = 0; j < groupedComponents.length; j++) {
+						this._groupBySlot[groupedComponents[j]] = groupProps;
+						if (groupedComponents[j] &&
+							1 === groupedComponents[j].length &&
+						    groupedComponents[j].charCodeAt(0) === 10) {
+							group.append($('<div>', {'unselectable': 'on'}));
+						} else {
+							componentName = groupedComponents[j];
+							elem = $('<span>', {'unselectable': 'on'});
+							this._elemBySlot[groupedComponents[j]] = elem;
+							group.append(elem);
+						}
+					}
+				}
+			}
+
+			this.panel.append($('<div>', {'class': 'aloha-ui-clear', 'unselectable': 'on'}));
+			this.handle.appendTo(this.list);
+			this.panel.appendTo(this.panels);
+			this.container.tabs('refresh');
+
+			var alohaTabs = settings.container.data('aloha-tabs');
+			this.index = alohaTabs.length;
+			alohaTabs.push(this);
+		},
+
+		adoptInto: function(slot, component) {
+			var elem = this._elemBySlot[slot],
+			    group;
+			if (!elem) {
+				return false;
+			}
+			slottedComponents[slot] = component;
+			component.adoptParent(this);
+			elem.append(component.element);
+			group = this._groupBySlot[slot];
+			this._slotsList.push(slot);
+			if (group) {
+				this._groupByComponent[component.id] = group;
+				if (component.isVisible()) {
+					if (!group.visibleCounter) {
+						group.element.removeClass('aloha-ui-hidden');
+					}
+					group.visibleCounter += 1;
+				}
+			}
+			return true;
+		},
+
+		foreground: function() {
+			this.container.tabs('select', this.index);
+		},
+
+		childForeground: function(childComponent) {
+			this.foreground();
+		},
+
+		hasVisibleComponents: function () {
+			var siblings = this._elemBySlot;
+			var slot;
+			for (slot in siblings) {
+				if (siblings.hasOwnProperty(slot) && slottedComponents[slot]) {
+					if (slottedComponents[slot].visible) {
+						return true;
+					}
+				}
+			}
+			return false;
+		},
+
+		childVisible: function(childComponent, visible) {
+			if (visible) {
+				childComponent.container.show();
+			} else if (!childComponent.container.hasVisibleComponents()) {
+				childComponent.container.hide();
+			}
+			var group = this._groupByComponent[childComponent.id];
+			if (!group) {
+				return;
+			}
+			if (visible) {
+				if (0 === group.visibleCounter) {
+					group.element.removeClass('aloha-ui-hidden');
+				}
+				group.visibleCounter += 1;
+			} else {
+				group.visibleCounter -= 1;
+				if (0 === group.visibleCounter) {
+					group.element.addClass('aloha-ui-hidden');
+				}
+			}
+		},
+
+		/**
+		 * @override
+		 */
+		show: function() {
+			if (!this.list.children().length || !hasVisibleComponents(this)) {
+				return;
+			}
+
+			this.handle.show();
+			this.visible = true;
+
+			// Hiding all tabs may hide the toolbar, so showing the
+			// first tab again must also show the toolbar.
+			this.container.show();
+
+			// If no tabs are selected, then select the tab which was just shown.
+			if (   !this.container.find('.ui-tabs-active').length
+			    ||  this.container.tabs('option', 'selected') === this.index) {
+				this.foreground();
+			}
+		},
+
+		/**
+		 * @override
+		 */
+		hide: function() {
+			var tabs = this.list.children();
+			if ( 0 === tabs.length ) {
+				return;
+			}
+			this.handle.hide();
+			this.visible = false;
+
+			// If the tab we just hid was the selected tab, then we need to
+			// select another tab in its stead.  We will select the first
+			// visible tab we find, or else we deselect all tabs.
+			if ( this.index === this.container.tabs( 'option', 'selected' ) ) {
+				tabs = this.container.data( 'aloha-tabs' );
+
+				var i;
+				for ( i = 0; i < tabs.length; ++i ) {
+					if ( tabs[ i ].visible ) {
+						this.container.tabs( 'select', i );
+						return;
+					}
+				}
+
+				// This does not work...
+				// this.container.tabs( 'select', -1 );
+
+				// Why do we remove this class?
+				this.handle.removeClass( 'ui-tabs-active' );
+
+				// It doesn't make any sense to leave the toolbar
+				// visible after all tabs have been hidden.
+				this.container.hide();
+			}
+		}
+
+	});
+
+	$.extend(Tab, {
+
+		/**
+		 * Creates holding elements for jQuery UI Tabs for a surface.
+		 *
+		 * @static
+		 * @return {jQuery.<HTMLElement>} The holder container on which we
+		 *                                invoke jQuery UI Tabs once it is
+		 *                                populated with tab containers.
+		 */
+		createContainer: function () {
+			var $container = $('<div>', {'unselectable': 'on'});
+			var $list = $('<ul>', {'unselectable': 'on'}).appendTo($container);
+			var $panels = $('<div>', {'unselectable': 'on'}).appendTo($container);
+
+			$container
+				.data('list', $list)
+				.data('panels', $panels)
+				.data('aloha-tabs', [])
+				.tabs({
+					select: function (event, ui) {
+						var tabs = $container.data('aloha-tabs');
+						$container.data('aloha-active-container', tabs[ui.index]);
+						PubSub.pub('aloha.ui.container.selected', {data: tabs[ui.index]});
+					}
+				});
+
+			return $container;
+		}
+	});
+
+	return Tab;
+});