locomotive-aloha-rails 0.20.1.5 → 0.23.2.1

data/vendor/assets/javascripts/aloha/plugins/common/ui/lib/port-helper-multi-split.js

@@ -0,0 +1,71 @@
+/*global define: true */
+/**
+ * This is a helper module for porting plugins from the old
+ * ui-attributefield.js in the aloha core to the new ui-plugin.
+ * This interface is obsolete and must not be used for new implementations.
+ */
+define([
+	'aloha/core',
+	'jquery',
+	'ui/ui',
+	'ui/multiSplit'
+], function (
+	Aloha,
+	jQuery,
+	Ui,
+	MultiSplit
+) {
+	'use strict';
+
+	function MultiSplitButton(props) {
+		var multiSplit;
+
+		multiSplit = Ui.adopt(props.name, MultiSplit, {
+			scope: props.scope,
+			getButtons: function () {
+				var buttons = [];
+				jQuery.each(props.items, function (i, item) {
+					buttons.push({
+						tooltip: item.tooltip,
+						text: item.text,
+						name: item.name,
+						icon: item.iconClass,
+						click: item.click,
+						init: function () {
+							if (item.cls) {
+								this.element.addClass(item.cls);
+							}
+							if (item.init) {
+								item.init.call(this);
+							}
+						},
+						wide: item.wide
+					});
+				});
+				return buttons;
+			}
+		});
+
+		return {
+			// Expose this function so the cite-plugin can push its own
+			// button to the format plugin's multi-split-button (which
+			// is a disastrous hack I know).
+			// TODO make it possible to combine the items of multiple
+			// plugins into a single multi split button.
+			pushItem: function (item) {
+				multiSplit.addButton(item);
+			},
+			showItem: function (name) {
+				multiSplit.show(name);
+			},
+			hideItem: function (name) {
+				multiSplit.hide(name);
+			},
+			setActiveItem: function (name) {
+				multiSplit.setActiveButton(name);
+			}
+		};
+	}
+
+	return MultiSplitButton;
+});

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

@@ -0,0 +1,187 @@
+define([
+	'jquery',
+	'PubSub',
+	'util/maps'
+], function (
+	$,
+	PubSub,
+	Maps
+) {
+	'use strict';
+
+	var scopes = {
+		    'Aloha.empty': [],
+		    'Aloha.global': ['Aloha.empty'],
+		    'Aloha.continuoustext': ['Aloha.global']
+	    },
+	    activeScopes = [],
+	    addedScopes = {},
+	    scopeSetDuringSelectionChanged = false;
+
+	function pushScopeAncestors(ancestorScopes, scope) {
+		if (!scopes.hasOwnProperty(scope)) {
+			return;
+		}
+		var parentScopes = scopes[scope];
+		for (var i = 0; i < parentScopes.length; i++) {
+			var parentScope = parentScopes[i];
+			ancestorScopes.push(parentScope);
+			pushScopeAncestors(ancestorScopes, parentScope);
+		}
+	}
+
+	Aloha.bind('aloha-selection-changed-before', function () {
+		scopeSetDuringSelectionChanged = false;
+	});
+
+	Aloha.bind('aloha-selection-changed-after', function (event, range, originalEvent) {
+		// I don't know why we check for originalEvent != 'undefined', here is
+		// the original comment:
+		// "Only set the specific scope if an event was provided, which means
+		// that somehow an editable was selected"
+		if (typeof originalEvent !== 'undefined' && ! scopeSetDuringSelectionChanged) {
+			Scopes.setScope('Aloha.continuoustext');
+		}
+	});
+
+	/**
+	 * @deprecated
+	 *     Scopes don't provide any additional functionality since
+	 *     the visibility of containers and components can be
+	 *     controlled individually.
+	 */
+	var Scopes = {
+
+		/**
+		 * Increments the scope counter for the given scope and requestor.
+		 *
+		 * A counter is maintained per scope and requestor. The counter
+		 * can be incremented/decremented with enterScope/leaveScope.
+		 *
+		 * The first increment of the counter (the increment to 1) will
+		 * make the scope active (isActiveScope() returns true) and
+		 * publish the aloha.ui.scope.change event. Further increments
+		 * will do nothing except increment the counter, which will
+		 * require more leaveScope calls to be made to leave the scope.
+		 *
+		 * The last decrement of the counter (the decrement to 0) will
+		 * make the scope inactive (isActiveScope() returns false) and
+		 * publish the aloha.ui.scope.change event. Further decrements
+		 * will do nothing.
+		 *
+		 * @param scope
+		 *        The scope to enter.
+		 * @param requestor
+		 *        The subsystem or plugin that requests to leave the
+		 *        scope. Can be used to isolate the scope counter to a
+		 *        particular subsystem, usually a plugin. If not given,
+		 *        a global counter will be used instead.
+		 * @deprecated
+		 *     Scopes don't provide any additional functionality since
+		 *     the visibility of containers and components can be
+		 *     controlled individually.
+		 */
+		enterScope: function(scope, requestor) {
+			requestor = requestor || '_globalCounter';
+			var counters = addedScopes[scope];
+			if (!counters) {
+				counters = addedScopes[scope] =  {};
+			}
+			var counter = counters[requestor] || 0;
+			counters[requestor] = counter + 1;
+			if (!counter) {
+				PubSub.pub('aloha.ui.scope.change');
+			}
+		},
+
+		/**
+		 * Decrements the scope counter for the given scope and requestor.
+		 *
+		 * @param force
+		 *        True when the scope should be left even if the counter
+		 *        is non-zero after decrementing it.
+		 * @see enterScope()
+		 * @deprecated
+		 *     Scopes don't provide any additional functionality since
+		 *     the visibility of containers and components can be
+		 *     controlled individually.
+		 */
+		leaveScope: function(scope, requestor, force) {
+			requestor = requestor || '_globalCounter';
+			var counters = addedScopes[scope];
+			if (!counters) {
+				return;
+			}
+			var counter = counters[requestor];
+			if (!counter) {
+				return;
+			}
+			counter -= 1;
+			if (counter && !force) {
+				counters[requestor] = counter;
+			} else {
+				delete counters[requestor];
+				if (Maps.isEmpty(counters)) {
+					delete addedScopes[scope];
+				}
+				PubSub.pub('aloha.ui.scope.change');
+			}
+		},
+
+		/**
+		 * @deprecated
+		 *     Scopes don't provide any additional functionality since
+		 *     the visibility of containers and components can be
+		 *     controlled individually.
+		 */
+		isActiveScope: function(scope){
+			if (addedScopes[scope]) {
+				return true;
+			}
+			var isActive = (-1 !== $.inArray(scope, activeScopes));
+			if (isActive) {
+				return true;
+			}
+			return false;
+		},
+
+		/**
+		 * @deprecated
+		 *     See setScope()
+		 */
+		getPrimaryScope: function() {
+			return activeScopes[0];
+		},
+
+		/**
+		 * @deprecated
+		 *     Problem with setScope is that scopes defined by multiple plugins are exclusive to one another.
+		 *     Example: table plugin and link plugin - you want to be able to set both table and link scopes.
+		 *     Use enterScope and leaveScope instead.
+		 */
+		setScope: function(scope) {
+			scopeSetDuringSelectionChanged = true;
+			if (activeScopes[0] != scope) {
+				activeScopes = [scope];
+				pushScopeAncestors(activeScopes, scope);
+				PubSub.pub('aloha.ui.scope.change');
+			}
+		},
+
+		/**
+		 * @deprecated
+		 *     This method was used to define an ancestry for scopes.
+		 *     It is unknonwn what problem scope ancestry solved, and
+		 *     the method is therefore deprecated.
+		 */
+		createScope: function(scope, parentScopes){
+			if ( ! parentScopes ) {
+				parentScopes = ['Aloha.empty'];
+			} else if (typeof parentScopes === 'string') {
+				parentScopes = [parentScopes];
+			}
+			scopes[scope] = parentScopes;
+		}
+	};
+	return Scopes;
+});

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

@@ -0,0 +1,202 @@
+define(['jquery', 'util/arrays', 'util/maps', 'util/trees'], function($, Arrays, Maps, Trees){
+	var defaultToolbarSettings = {
+		tabs: [
+			// Format Tab
+			{
+				label: 'tab.format.label',
+				showOn: { scope: 'Aloha.continuoustext' },
+				components: [
+					[
+						'bold', 'strong', 'italic', 'emphasis', 'underline', '\n',
+						'subscript', 'superscript', 'strikethrough', 'quote'
+					], [
+						'formatLink', 'formatAbbr', 'formatNumeratedHeaders', 'toggleDragDrop', '\n',
+						'toggleMetaView', 'wailang', 'toggleFormatlessPaste'
+					], [
+						'alignLeft', 'alignCenter', 'alignRight', 'alignJustify', '\n',
+						'orderedList', 'unorderedList', 'indentList', 'outdentList', 'colorPicker'
+					], [
+						'formatBlock'
+					]
+				]
+			},
+			// Insert Tab
+			{
+				label: "tab.insert.label",
+				showOn: { scope: 'Aloha.continuoustext' },
+				components: [
+					[ "createTable", "characterPicker", "insertLink",
+					  "insertImage", "insertAbbr", "insertToc",
+					  "insertHorizontalRule", "insertTag"]
+				]
+			},
+			// Link Tab
+			{
+				label: 'tab.link.label',
+				showOn: { scope: 'link' },
+				components: [ 'editLink', 'removeLink', 'linkBrowser' ]
+			},
+            // Image Tab
+            {
+                label: "tab.img.label",
+                showOn: {scope: 'image'},
+                components: [
+					[ "imageSource", "\n",
+					  "imageTitle" ],
+					[ "imageResizeWidth", "\n",
+					  "imageResizeHeight" ],
+					[ "imageAlignLeft", "imageAlignRight", "imageAlignNone", "imageIncPadding", "\n",
+					  "imageCropButton", "imageCnrReset", "imageCnrRatio", "imageDecPadding" ],
+					[ "imageBrowser" ]
+                ]
+            },
+            // Abbr Tab
+            {   label: "tab.abbr.label",
+                showOn: { scope: 'abbr' },
+                components: [
+                    [ "abbrText", "removeAbbr" ]
+                ]
+            },
+            // Wailang Tab
+            {   label: "tab.wai-lang.label",
+				showOn: { scope: 'wai-lang' },
+                components: [ [ "wailangfield", "removewailang" ] ]
+            },
+			// Table Tabs
+			{
+				label: "tab.table.label",
+				showOn: { scope: 'table.cell' },
+				components: [
+					[ "mergecells", "splitcells", "tableCaption",
+					  "tableSummary", "naturalFit" ],
+					[ "formatTable" ]
+				]
+			},
+			{
+				label: "tab.col.label",
+				showOn: { scope: 'table.column' },
+				components: [
+					[ "addcolumnleft", "addcolumnright", "deletecolumns",
+					  "columnheader", "mergecellsColumn", "splitcellsColumn",
+					  "formatColumn" ]
+				]
+			},
+			{
+				label: "tab.row.label",
+				showOn: { scope: 'table.row' },
+				components: [
+					[ "addrowbefore", "addrowafter", "deleterows", "rowheader",
+					  "mergecellsRow", "splitcellsRow", "formatRow" ]
+				]
+			},
+			{
+				label: "tab.cell.label",
+				showOn: { scope: 'table.cell' },
+				components: [
+					[ "alignTop", "alignMiddle", "alignBottom", "formatCell" ]
+				]
+			}
+
+		]
+	};
+
+	/**
+	 * Combines two toolbar configurations.
+	 *
+	 * The rules for combining configurations are as follows
+	 *
+	 * * remove all components and tabs from the default toolbar configuration
+	 *   that are listed in the given exclude array,
+	 * * add all remaining tabs from the default configuration to the user
+	 *   configuration,
+	 * * and merge tabs with the same name such that a tab property that is
+	 *   omitted in the user configuration will be taken from the default
+	 *   configuration,
+	 * * and, if both the default tab and the user's tab configuration contain
+	 *   a components property, and unless the exclusive property on a tab is
+	 *   true, append all remaining components from the default tab to the
+	 *   user's tab configuration.
+	 *
+	 * @param userTabs
+	 *        a list of tab configurations
+	 * @param defaultTabs
+	 *        a list of tab configurations
+	 * @param exclude
+	 *        a list of component names and tab labels to ignore
+	 *        in the given defaultTabs configuration.
+	 * @return
+	 *
+	 */
+	function combineToolbarSettings(userTabs, defaultTabs, exclude) {
+		var defaultTabsByLabel = Maps.fillTuples({}, Arrays.map(defaultTabs, function(tab) {
+			return [tab.label, tab];
+		}));
+		var exclusionLookup = makeExclusionMap(userTabs, exclude);
+		function pruneDefaultComponents(form) {
+			return 'array' === $.type(form) ? !form.length : exclusionLookup[form];
+		};
+		userTabs = mergeDefaultComponents(userTabs, defaultTabsByLabel, pruneDefaultComponents);
+		defaultTabs = remainingDefaultTabs(defaultTabs, exclusionLookup, pruneDefaultComponents);
+		return userTabs.concat(defaultTabs);
+	}
+
+	function remainingDefaultTabs(defaultTabs, exclusionLookup, pruneDefaultComponents) {
+		var i,
+		    tab,
+		    tabs = [],
+		    defaultTab,
+		    components;
+		for (i = 0; i < defaultTabs.length; i++) {
+			defaultTab = defaultTabs[i];
+			if (!exclusionLookup[defaultTab.label]) {
+				components = Trees.postprune(defaultTab.components, pruneDefaultComponents);
+				if (components) {
+					tab = $.extend({}, defaultTab);
+					tab.components = components;
+					tabs.push(tab);
+				}
+			}
+		}
+		return tabs;
+	}
+
+	function mergeDefaultComponents(userTabs, defaultTabsByLabel, pruneDefaultComponents) {
+		var i,
+            tab,
+		    tabs = [],
+		    userTab,
+		    components,
+		    defaultTab,
+		    defaultComponents;
+		for (i = 0; i < userTabs.length; i++) {
+			userTab = userTabs[i];
+			components = userTab.components || [];
+			defaultTab = defaultTabsByLabel[userTab.label];
+			if (!userTab.exclusive && defaultTab) {
+				defaultComponents = Trees.postprune(defaultTab.components, pruneDefaultComponents);
+				if (defaultComponents) {
+					components = components.concat(defaultComponents);
+				}
+			}
+			tab = $.extend({}, defaultTab || {}, userTab);
+			tab.components = components;
+			tabs.push(tab);
+		}
+		return tabs;
+	}
+
+	function makeExclusionMap(userTabs, exclude) {
+		var i,
+		    map = Maps.fillKeys({}, exclude, true);
+		for (i = 0; i < userTabs.length; i++) {
+			map[userTabs[i].label] = true;
+			Maps.fillKeys(map, Trees.flatten(userTabs[i].components), true);
+		}
+		return map;
+	}
+
+	return {
+		defaultToolbarSettings: defaultToolbarSettings,
+		combineToolbarSettings: combineToolbarSettings
+	};
+});