locomotive-aloha-rails 0.20.1

data/vendor/assets/javascripts/aloha/plugins/common/block/lib/blockcontenthandler.js

@@ -0,0 +1,58 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+define(
+['aloha/jquery', 'aloha/contenthandlermanager', 'block/blockmanager'],
+function(jQuery, ContentHandlerManager, BlockManager) {
+
+	/**
+	 * @name block.BlockContentHandler
+	 * @class Special block content handler
+	 *
+	 * The blog content handler handles pasting of blocks in editables. Pasted
+	 * block markup will be replaced by a freshly rendered block instance.
+	 */
+	var BlockContentHandler = ContentHandlerManager.createHandler(
+	/** @lends block.BlockContentHandler */
+	{
+		/**
+		 * Handle the pasting. Remove all unwanted stuff.
+		 * @param {jQuery} content
+		 */
+		handleContent: function( content ) {
+			if ( typeof content === 'string' ){
+				content = jQuery( '<div>' + content + '</div>' );
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content);
+			}
+
+			content.find('.aloha-block').each(function() {
+				var oldBlock = jQuery(this);
+
+				// TODO: use block.serialize();
+
+				var dataAttributes = {};
+				jQuery.each(oldBlock.data(), function(k, v) {
+					dataAttributes['data-' + k] = v;
+				})
+
+				var newBlock = jQuery('<' + this.tagName + '/>')
+					.attr(jQuery.extend({
+							about: oldBlock.attr('about'),
+							'class': oldBlock.attr('class')
+						}, dataAttributes))
+					.removeClass('aloha-block-active');
+
+				oldBlock.replaceWith(newBlock);
+				BlockManager._blockify(newBlock);
+			});
+			
+			return content.html();
+		}
+	});
+	return BlockContentHandler;
+});

data/vendor/assets/javascripts/aloha/plugins/common/block/lib/blockmanager.js

@@ -0,0 +1,242 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+define(['aloha', 'aloha/jquery', 'aloha/floatingmenu', 'aloha/observable', 'aloha/registry'],
+function(Aloha, jQuery, FloatingMenu, Observable, Registry) {
+	
+
+	var
+		GENTICS = window.GENTICS;
+
+	/**
+	 * @name block.blockmanager
+	 * @class Block manager singleton
+	 */
+	var BlockManager = new (Class.extend(Observable,
+	/** @lends block.blockmanager */
+	{
+
+		/**
+		 * @name block.blockmanager#block-selection-change
+		 * @event
+		 * @param {Array} selectedBlocks Array of AbstractBlock objects, containing selected blocks. The first element in the array is the innermost block, and the other elements are the parent blocks.
+		 */
+
+		/**
+		 * @name block.blockmanager#block-delete
+		 * @event fired directly before a block is deleted
+		 * @param {AbstractBlock} the block to be deleted
+		 */
+
+		defaults: {
+			'block-type': 'DefaultBlock'
+		},
+
+		/**
+		 * Registry of block types
+		 * @type Registry
+		 */
+		blockTypes: null,
+
+		/**
+		 * Registry of blocks
+		 * @type Registry
+		 */
+		blocks: null,
+
+		activeBlocks: null,
+
+		/**
+		 * @constructor
+		 */
+		_constructor: function() {
+			FloatingMenu.createScope('Aloha.Block');
+			this.blockTypes = new Registry();
+			this.blocks = new Registry();
+			this.activeBlocks = {};
+		},
+
+		/**
+		 * Register initial event handlers
+		 *
+		 * @private
+		 */
+		registerEventHandlers: function() {
+			var that = this;
+
+			// Register event handlers for deactivating an Aloha Block
+			jQuery(document).bind('click', function(event) {
+				if (that.activeBlocks == {}) return;
+				if (jQuery(event.target).parents('.aloha-sidebar-bar, .aloha-block-do-not-deactivate, .aloha-floatingmenu').length > 0
+					|| jQuery(event.target).is('.aloha-sidebar-bar, .aloha-block-do-not-deactivate, .aloha-floatingmenu')) {
+					// If we are inside the sidebar, the floating menu or other elements which should not trigger the block deactivation, we do an early return.
+					return;
+				}
+				BlockManager._deactivateActiveBlocks();
+			});
+
+			Aloha.bind('aloha-selection-changed', function(evt, selection, originalEvent) {
+				// the following line is needed to de-select blocks when navigating over them using the mouse cursors.
+				// We only want to execute it though, if we are not inside a block, as it would otherwise
+				// directly deselect the block we just selected. This is just a hotfix and not the final solution yet.
+				if (selection && jQuery(selection.getCommonAncestorContainer()).parents('.aloha-block').length > 0) {
+					return;
+				}
+				that._deactivateActiveBlocks();
+			});
+		},
+
+		/**
+		 * Blockify a given element with the instance defaults
+		 * Directly called when one does jQuery.alohaBlock(instanceDefaults)
+		 *
+		 * @private
+		 */
+		_blockify: function(element, instanceDefaults) {
+			var attributes, block;
+			element = jQuery(element);
+
+			// TODO: check if object is already Block-ified
+
+			attributes = this.getConfig(element, instanceDefaults);
+
+			element.contentEditable(false);
+
+			if (!this.blockTypes.has(attributes['block-type'])) {
+				Aloha.Log.error('block/blockmanager', 'Block Type ' + attributes['block-type'] + ' not found!');
+				return;
+			}
+
+			block = new (this.blockTypes.get(attributes['block-type']))(element);
+			block.element.addClass('aloha-block-' + attributes['block-type']);
+
+			// Save attributes on block, but ignore jquery attribute.
+			jQuery.each(attributes, function(k, v) {
+				if (k.indexOf('jQuery') === 0) return;
+				block.attr(k, v, true);
+			});
+
+			// Remove the attributes from the child element, as they have been moved to the parent element.
+			jQuery.each(element.data(), function(k, v) {
+				element.removeAttr('data-' + k);
+			});
+			element.removeAttr('about');
+
+			// Register block
+			this.blocks.register(block.getId(), block);
+
+			block._renderAndSetContent();
+		},
+
+		/**
+		 * Deactivate all active blocks
+		 *
+		 * @private
+		 */
+		_deactivateActiveBlocks: function() {
+			jQuery.each(jQuery.extend({}, this.activeBlocks), function(id) {
+				var block = BlockManager.getBlock(id);
+				if (block) {
+					block.deactivate();
+				}
+			});
+		},
+
+		/**
+		 * Merges the config from different places, and return the merged config.
+		 *
+		 * @private
+		 */
+		getConfig: function(blockElement, instanceDefaults) {
+			// TODO: merge from plugin settings
+			// TODO: What about double matches / overrides / multiple selectors applying?
+			var settingsDefaults = {};
+
+			return jQuery.extend(
+				{},
+				this.defaults,
+				settingsDefaults,
+				instanceDefaults,
+				blockElement.data(),
+				{	// Override the "about" property
+					about: blockElement.attr('about')
+				}
+			);
+		},
+
+		/**
+		 * Get a Block instance by id or DOM node
+		 *
+		 * @param {String|DOMNode} idOrDomNode
+		 * @return {block.block.AbstractBlock} Block instance
+		 */
+		getBlock: function(idOrDomNode) {
+			var id;
+			if (typeof idOrDomNode === 'object') {
+				id = jQuery(idOrDomNode).attr('id');
+			} else {
+				id = idOrDomNode;
+			}
+
+			return this.blocks.get(id);
+		},
+
+		/**
+		 * Unregister (e.g. remove) the given block
+		 *
+		 * @param {Object|String} blockOrBlockId Block or block id
+		 */
+		_unregisterBlock: function(blockOrBlockId) {
+			var id;
+			if (typeof blockOrBlockId === 'object') {
+				id = blockOrBlockId.getId();
+			} else {
+				id = blockOrBlockId;
+			}
+			this.blocks.unregister(blockOrBlockId);
+		},
+
+		/**
+		 * Register the given block type
+		 *
+		 * @param {String} Identifier
+		 * @param {Class} A class that extends block.block.AbstractBlock
+		 */
+		registerBlockType: function(identifier, blockType) {
+			FloatingMenu.createScope('Aloha.Block.' + identifier, 'Aloha.Block');
+			this.blockTypes.register(identifier, blockType);
+		},
+
+		/**
+		 * Get all active blocks indexed by block id
+		 *
+		 * @return {Object}
+		 */
+		getActiveBlocks: function() {
+			var activeBlocks = {};
+			jQuery.each(this.blocks.getEntries(), function(blockId, block) {
+				if (block.isActive()) {
+					activeBlocks[blockId] = block;
+				}
+			});
+			return activeBlocks;
+		},
+
+		_setActive: function(block) {
+			this.activeBlocks[block.id] = true;
+		},
+
+		_setInactive: function(block) {
+			delete this.activeBlocks[block.id];
+		}
+	}))();
+
+	Aloha.Block = Aloha.Block || {};
+	Aloha.Block.BlockManager = BlockManager;
+
+	return BlockManager;
+});

data/vendor/assets/javascripts/aloha/plugins/common/block/lib/editor.js

@@ -0,0 +1,209 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+/**
+ * @name block.editor
+ * @namespace Block attribute editors
+ */
+define(['aloha/jquery', 'aloha/observable'],
+function(jQuery, Observable) {
+	
+
+	/**
+	 * @name block.editor.AbstractEditor
+	 * @class An abstract editor
+	 */
+	var AbstractEditor = Class.extend(Observable,
+	/** @lends block.editor.AbstractEditor */
+	{
+		schema: null,
+
+		/**
+		 * @constructor
+		 */
+		_constructor: function(schema) {
+			this.schema = schema;
+		},
+
+		/**
+		 * Template method to render the editor elements
+		 * @return {jQuery}
+		 */
+		render: function() {
+			// Implement in subclass!
+		},
+
+		/**
+		 * Template method to get the editor values
+		 */
+		getValue: function() {
+			// Implement in subclass!
+		},
+
+		/**
+		 * We do not throw any change event here, as we need to break the loop "Block" -> "Editor" -> "Block"
+		 *
+		 * @param {String} value
+		 */
+		setValue: function(value) {
+			// Implement in subclass!
+		},
+
+		/**
+		 * Destroy the editor elements and unbind events
+		 */
+		destroy: function() {
+			// Implement in subclass!
+		},
+
+		/**
+		 * On deactivating, we still need to trigger a change event if the value has been modified.
+		 *
+		 * @private
+		 */
+		_deactivate: function() {
+			this.trigger('change', this.getValue());
+			this.destroy();
+		}
+	});
+
+	/**
+	 * @name block.editor.AbstractFormElementEditor
+	 * @class An abstract form editor with label
+	 * @extends block.editor.AbstractEditor
+	 */
+	var AbstractFormElementEditor = AbstractEditor.extend(
+	/** @lends block.editor.AbstractFormElementEditor */
+	{
+
+		/**
+		 * Input element HTML definition
+		 * @type String
+		 *
+		 * @private
+		 */
+		formInputElementDefinition: null,
+
+		/**
+		 * @type jQuery
+		 */
+		_$formInputElement: null,
+
+		/**
+		 * Render the label and form element
+		 * @return {jQuery}
+		 */
+		render: function() {
+			var $wrapper = jQuery('<div class="aloha-block-editor" />');
+			var guid = GENTICS.Utils.guid();
+			$wrapper.append(this.renderLabel().attr('id', guid));
+			$wrapper.append(this.renderFormElement().attr('id', guid));
+			return $wrapper;
+		},
+
+		/**
+		 * Render the label for the editor
+		 * @return {jQuery}
+		 */
+		renderLabel: function() {
+			var element = jQuery('<label />');
+			element.html(this.schema.label);
+			return element;
+		},
+
+		/**
+		 * Render the form input element
+		 * @return {jQuery}
+		 */
+		renderFormElement: function() {
+			var that = this;
+			this._$formInputElement = jQuery(this.formInputElementDefinition);
+
+			this._$formInputElement.change(function() {
+				that.trigger('change', that.getValue());
+			});
+
+			return this._$formInputElement;
+		},
+
+		/**
+		 * @return {String}
+		 */
+		getValue: function() {
+			return this._$formInputElement.val();
+		},
+
+		/**
+		 * We do not throw any change event here, as we need to break the loop "Block" -> "Editor" -> "Block"
+		 */
+		setValue: function(value) {
+			this._$formInputElement.val(value);
+		},
+
+		/**
+		 * Cleanup and remove the input element
+		 */
+		destroy: function() {
+			this._$formInputElement.remove();
+		}
+
+	});
+
+	/**
+	 * @name block.editor.StringEditor
+	 * @class An editor for string input
+	 * @extends block.editor.AbstractFormElementEditor
+	 */
+	var StringEditor = AbstractFormElementEditor.extend(
+	/** @lends block.editor.StringEditor */
+	{
+		formInputElementDefinition: '<input type="text" />'
+	});
+
+	/**
+	 * @name block.editor.NumberEditor
+	 * @class An editor for numbers
+	 * @extends block.editor.AbstractFormElementEditor
+	 */
+	var NumberEditor = AbstractFormElementEditor.extend(
+	/** @lends block.editor.NumberEditor */
+	{
+		// TODO Range should be an option
+		formInputElementDefinition: '<input type="range" />'
+	});
+
+	/**
+	 * @name block.editor.UrlEditor
+	 * @class An editor for URLs
+	 * @extends block.editor.AbstractFormElementEditor
+	 */
+	var UrlEditor = AbstractFormElementEditor.extend(
+	/** @lends block.editor.UrlEditor */
+	{
+		formInputElementDefinition: '<input type="url" />'
+	});
+
+	/**
+	 * @name block.editor.EmailEditor
+	 * @class An editor for email addresses
+	 * @extends block.editor.AbstractFormElementEditor
+	 */
+	var EmailEditor = AbstractFormElementEditor.extend(
+	/** @lends block.editor.EmailEditor */
+	{
+		formInputElementDefinition: '<input type="email" />'
+	});
+
+	return {
+		AbstractEditor: AbstractEditor,
+		AbstractFormElementEditor: AbstractFormElementEditor,
+		StringEditor: StringEditor,
+		NumberEditor: NumberEditor,
+		UrlEditor: UrlEditor,
+		EmailEditor: EmailEditor
+	}
+});