gnuside-aloha-rails 0.23.3

data/vendor/assets/javascripts/aloha/lib/aloha/block-jump.js

@@ -0,0 +1,153 @@
+/* block-jump.js is part of the Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor. 
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php 
+ * 
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * 
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+/**
+ * Implements some logic related to moving the cursor keys across blocks.
+ * 
+ * In the following example
+ *
+ * "some text<span class="aloha-block ..." contenteditable="false" ...>...</span>[]some text"
+ *
+ * when one moves the cursor indicated by "[]" to the left, the entire
+ * non-contenteditable block is skipped. The same for moving the cursor
+ * right across the block.
+ *
+ * TODO: actually, the block shouldn't be skipped, it should be
+ *       selected/highlighted first.
+ * TODO: this file currently doesn't contain all the code to implement
+ *       block jumping. Some of it is currently implemented in markup.js.
+ */
+define([
+	'aloha/core',
+	'jquery',
+	'aloha/console'
+], function (
+	Aloha,
+	$,
+	console
+) {
+	'use strict';
+
+	var zeroWidthNode = null;
+
+	/**
+	 * Replaces the text in given text with the given text.
+	 *
+	 * @param node
+	 *        A text node attached to the DOM.
+	 * @param text
+	 *        A string that is to replace the text of the given text node.
+	 */
+	function replaceMergeTextNode(node, text) {
+		node.deleteData(0, node.length);
+		if ('' !== text) {
+			if (node.nextSibling && 3 === node.nextSibling.nodeType) {
+				node.nextSibling.insertData(0, text);
+			} else if (node.previousSibling && 3 === node.previousSibling.nodeType) {
+				node.previousSibling.insertData(node.previousSibling.length, text);
+			} else {
+				node.insertData(0, text);
+			}
+		}
+		// We don't remove the node immediately to avoid intefering with a
+		// caller's range object that may have a start or end containers
+		// equal to this node. Removing it in a timeout may still interfere
+		// with the selection, but that was not a problem during testing.
+		setTimeout(function () {
+			if (0 === node.length) {
+				$(node).remove();
+			}
+		}, 0);
+	}
+
+	/**
+	 * Removes a previously inserted zero width text node.
+	 * See insertZeroWidthTextNodeFix().
+	 */
+	function removeZeroWidthTextNodeFix() {
+		if (!zeroWidthNode) {
+			return;
+		}
+		// We want to only replace a single zero-width character to avoid
+		// interfering with the other zero-width whitespace hack that makes
+		// empty lines visible in IE7.
+		var text = zeroWidthNode.nodeValue.replace(/\u200b/, '');
+		if (text === zeroWidthNode.nodeValue) {
+			console.warn('Expected to remove the zero width text node fix, but couldn\'t find it');
+		}
+		replaceMergeTextNode(zeroWidthNode, text);
+		zeroWidthNode = null;
+	}
+
+	/**
+	 * Inserts a zero width text node before or after a block.
+	 *
+	 * There is a problem where some browsers can't select the boundary
+	 * between some contenteditable content and non-contenteditable
+	 * content. For example, if in the example at the top of the file
+	 * the selection were one step to the right "...</span>s[]ome..."
+	 * and the left cursor key were pressed, then the selection would
+	 * just disappear or be stuck between the span and the text node.
+	 *
+	 * To work around this problem a zero width text node is inserted
+	 * before or after a block.
+	 *
+	 * The inserted zero width text node will be removed automatically
+	 * when it isn't necessary any more (on selection change or on
+	 * editable.getContents()).
+	 *
+	 * TODO: In retrospect, a better alternative may be to simply wrap
+	 *       every inlin-block with an editable span.
+	 * @param block
+	 *        The DOM element for a block before or after which the zero
+	 *        width text node will be inserted.
+	 * @param isGoingLeft
+	 *        True if the zero width text node is to be inserted after
+	 *        the block element, or false if the zero width text node is
+	 *        to be inserted before the block element.
+	 * @return
+	 *        The text node that was inserted.
+	 */
+	function insertZeroWidthTextNodeFix(block, isGoingLeft) {
+		removeZeroWidthTextNodeFix();
+		zeroWidthNode = document.createTextNode("\u200b");
+		if (isGoingLeft) {
+			$(block).after(zeroWidthNode);
+		} else {
+			$(block).before(zeroWidthNode);
+		}
+		Aloha.bind('aloha-selection-changed', function (event) {
+			removeZeroWidthTextNodeFix();
+			Aloha.unbind(event);
+		});
+		return zeroWidthNode;
+	}
+
+	return {
+		removeZeroWidthTextNodeFix: removeZeroWidthTextNodeFix,
+		insertZeroWidthTextNodeFix: insertZeroWidthTextNodeFix
+	};
+});

data/vendor/assets/javascripts/aloha/lib/aloha/command.js

@@ -0,0 +1,287 @@
+/* command.js is part of Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor.
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php
+ *
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+define([
+	'aloha/core',
+	'aloha/registry',
+	'aloha/engine',
+	'util/dom',
+	'aloha/contenthandlermanager'
+], function (
+	Aloha,
+	Registry,
+	Engine,
+	Dom,
+	ContentHandlerManager
+) {
+	"use strict";
+
+	//			Action: What the command does when executed via execCommand(). Every command defined
+	//			in CommandManager specification has an action defined for it in the relevant section. For example,
+	//			the bold command's action generally makes the current selection bold, or removes bold if
+	//			the selection is already bold. An editing toolbar might provide buttons that execute the
+	//			action for a command if clicked, or a script might run an action without user interaction
+	//			to achieve some particular effect.
+	//
+	//			Indeterminate: A boolean value returned by queryCommandIndeterm(), depending on the
+	//			current state of the document. Generally, a command that has a state defined will be
+	//			indeterminate if the state is true for part but not all of the current selection, and a
+	//			command that has a value defined will be indeterminate if different parts of the
+	//			selection have different values. An editing toolbar might display a button or control
+	//			in a special way if the command is indeterminate, like showing a "bold" button as
+	//			partially depressed, or leaving a font size selector blank instead of showing the font
+	//			size of the current selection. As a rule, a command can only be indeterminate if its
+	//			state is false, supposing it has a state.
+	//
+	//			State: A boolean value returned by queryCommandState(), depending on the current state
+	//			of the document. The state of a command is true if it is already in effect, in some
+	//			sense specific to the command. Most commands that have a state defined will take opposite
+	//			actions depending on whether the state is true or false, such as making the selection
+	//			bold if the state is false and removing bold if the state is true. Others will just
+	//			have no effect if the state is true, like the justifyCenter command. Still others will
+	//			have the same effect regardless, like the styleWithCss command. An editing toolbar might
+	//			display a button or control differently depending on the state and indeterminacy of the
+	//			command.
+	//
+	//			Value: A string returned by queryCommandValue(), depending on the current state of the
+	//			document. A command usually has a value instead of a state if the property it modifies
+	//			can take more than two different values, like the foreColor command. If the command is
+	//			indeterminate, its value is generally based on the start of the selection. Otherwise,
+	//			in most cases the value holds true for the entire selection, but see the justifyCenter
+	//			command and its three companions for an exception. An editing toolbar might display the
+	//			value of a command as selected in a drop-down or filled in in a text box, if the command
+	//			isn't indeterminate.
+	//
+	//			Relevant CSS property: CommandManager is defined for certain inline formatting commands, and
+	//			is used in algorithms specific to those commands. It is an implementation detail, and
+	//			is not exposed to authors. If a command does not have a relevant CSS property
+	//			specified, it defaults to null.
+
+	var CommandManager = {
+
+		execCommand: function (commandId, showUi, value, range) {
+			var evtObj = {
+				commandId: commandId,
+				preventDefault: false
+			};
+			Aloha.trigger('aloha-command-will-execute', evtObj);
+
+			if (evtObj.preventDefault === true) {
+				return;
+			}
+			// Read current selection if not passed
+			if (!range) {
+				if (!Aloha.getSelection().getRangeCount()) {
+					return;
+				}
+				range = Aloha.getSelection().getRangeAt(0);
+			}
+
+			// For the insertHTML command we provide contenthandler API
+			if (commandId.toLowerCase() === 'inserthtml') {
+				//if (typeof Aloha.settings.contentHandler.insertHtml === 'undefined') {
+				//	use all registered content handler; used for copy & paste atm (or write log message)
+				//	Aloha.settings.contentHandler.insertHtml = Aloha.defaults.contentHandler.insertHtml;
+				//}
+				value = ContentHandlerManager.handleContent(value, {
+					contenthandler: Aloha.settings.contentHandler.insertHtml,
+					command: 'insertHtml'
+				});
+			}
+
+			Engine.execCommand(commandId, showUi, value, range);
+
+			if (Aloha.getSelection().getRangeCount()) {
+				// Read range after engine modification
+				range = Aloha.getSelection().getRangeAt(0);
+
+				// FIX: doCleanup should work with W3C range
+				var startnode = range.commonAncestorContainer;
+				if (startnode.parentNode) {
+					startnode = startnode.parentNode;
+				}
+				var rangeObject = new window.GENTICS.Utils.RangeObject();
+				rangeObject.startContainer = range.startContainer;
+				rangeObject.startOffset = range.startOffset;
+				rangeObject.endContainer = range.endContainer;
+				rangeObject.endOffset = range.endOffset;
+				Dom.doCleanup({
+					merge: true,
+					removeempty: false
+				}, rangeObject, startnode);
+				rangeObject.select();
+			}
+
+			Aloha.trigger('aloha-command-executed', commandId);
+		},
+
+		// If command is available and not disabled or the active range is not null
+		// the command is enabled
+		queryCommandEnabled: function (commandId, range) {
+
+			// Take current selection if not passed
+			if (!range) {
+				if (!Aloha.getSelection().getRangeCount()) {
+					return;
+				}
+				range = Aloha.getSelection().getRangeAt(0);
+			}
+			return Engine.queryCommandEnabled(commandId, range);
+		},
+
+		// "Return true if command is indeterminate, otherwise false."
+		queryCommandIndeterm: function (commandId, range) {
+
+			// Take current selection if not passed
+			if (!range) {
+				if (!Aloha.getSelection().getRangeCount()) {
+					return;
+				}
+				range = Aloha.getSelection().getRangeAt(0);
+			}
+			return Engine.queryCommandIndeterm(commandId, range);
+
+		},
+
+		queryCommandState: function (commandId, range) {
+
+			// Take current selection if not passed
+			if (!range) {
+				if (!Aloha.getSelection().getRangeCount()) {
+					return;
+				}
+				range = Aloha.getSelection().getRangeAt(0);
+			}
+			return Engine.queryCommandState(commandId, range);
+
+		},
+
+		// "When the queryCommandSupported(command) method on the HTMLDocument
+		// interface is invoked, the user agent must return true if command is
+		// supported, and false otherwise."
+		queryCommandSupported: function (commandId) {
+
+			return Engine.queryCommandSupported(commandId);
+		},
+
+		queryCommandValue: function (commandId, range) {
+
+			// Take current selection if not passed
+			if (!range) {
+				if (!Aloha.getSelection().getRangeCount()) {
+					return;
+				}
+				range = Aloha.getSelection().getRangeAt(0);
+			}
+
+			// "Return command's value."
+			return Engine.queryCommandValue(commandId, range);
+		},
+		querySupportedCommands: function () {
+
+			var commands = [],
+				command;
+
+			for (command in Engine.commands) {
+				if (Engine.commands.hasOwnProperty(command)) {
+					commands.push(command);
+				}
+			}
+			return commands;
+		},
+		getStateOverride: Engine.getStateOverride,
+		setStateOverride: Engine.setStateOverride,
+		resetOverrides: Engine.resetOverrides,
+		unsetStateOverride: Engine.unsetStateOverride
+	};
+
+	// create an instance
+	CommandManager = new (Registry.extend(CommandManager))();
+
+	/**
+	 * Executes a registered command.
+	 * http://aryeh.name/spec/editing/editing.html#methods-of-the-htmldocument-interface
+	 * @method
+	 * @param command name of the command
+	 * @param showUI has no effect for Aloha Editor and is only here because in spec...
+	 * @param value depends on the used command and it impementation
+	 * @range optional a range on which the command will be executed if not specified
+	 *        the current selection will be used as range
+	 */
+	Aloha.execCommand = CommandManager.execCommand;
+
+	/**
+	 * Check wheater the command in enabled.
+	 * If command is not supported, raise a NOT_SUPPORTED_ERR exception.
+	 * @param command name of the command
+	 * @return true if command is enabled, false otherwise.
+	 */
+	Aloha.queryCommandEnabled = CommandManager.queryCommandEnabled;
+
+	/**
+	 * Check if the command has an indetermed state.
+	 * If command is not supported, a NOT_SUPPORTED_ERR exception is thrown
+	 * If command has no indeterminacy, INVALID_ACCESS_ERR exception is thrown
+	 * If command is not enabled, return false.
+	 * @param command name of the command
+	 * @range optional a range on which the command will be executed if not specified
+	 *        the current selection will be used as range
+	 * @return true if command is indeterminate, otherwise false.
+	 */
+	Aloha.queryCommandIndeterm = CommandManager.queryCommandIndeterm;
+
+	/**
+	 * Returns the state of a given command
+	 * If command is not supported, a NOT_SUPPORTED_ERR exception is thrown
+	 * If command has no state, an INVALID_ACCESS_ERR exception is thrown
+	 * If command is not enabled, return false
+	 * If the state override for command is set, it returns the state
+	 * @param command name of the command
+	 * @return state override or true if command's state is true, otherwise false.
+	 */
+	Aloha.queryCommandState = CommandManager.queryCommandState;
+
+	/**
+	 * Check if a given command is supported
+	 * @return true if command is supported, and false otherwise.
+	 */
+	Aloha.queryCommandSupported = CommandManager.queryCommandSupported;
+
+	/**
+	 * Returns the Value of a given Command
+	 * If command is not supported, a NOT_SUPPORTED_ERR exception is thrown
+	 * If command is not enabled, returns an empty string
+	 * If command is "fontSize" and its value override is set, an integer
+	 * number of pixels is returned as font size for the result.
+	 * If the value override for command is set, it returns that.
+	 * @return command's value.
+	 */
+	Aloha.queryCommandValue = CommandManager.queryCommandValue;
+
+	Aloha.querySupportedCommands = CommandManager.querySupportedCommands;
+
+	return CommandManager;
+});

data/vendor/assets/javascripts/aloha/lib/aloha/console.js

@@ -0,0 +1,347 @@
+/* console.js is part of Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor. 
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php 
+ * 
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * 
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+define([
+	'aloha/core',
+	'util/class',
+	'jquery'
+], function (
+	Aloha,
+	Class,
+	jQuery
+) {
+	"use strict";
+
+	/**
+	 * This is the aloha Log
+	 * @namespace Aloha
+	 * @class Log
+	 * @singleton
+	 */
+	var AlohaConsole = Class.extend({
+		/**
+		 * Initialize the logging
+		 * @hide
+		 */
+		init: function () {
+
+			// initialize the logging settings (if not present)
+			if (typeof Aloha.settings.logLevels === 'undefined' || !Aloha.settings.logLevels) {
+				Aloha.settings.logLevels = {
+					'error': true,
+					'warn': true
+				};
+			}
+
+			// initialize the logHistory settings (if not present)
+			if (typeof Aloha.settings.logHistory === 'undefined' || !Aloha.settings.logHistory) {
+				Aloha.settings.logHistory = {};
+			}
+			// set the default values for the loghistory
+			if (!Aloha.settings.logHistory.maxEntries) {
+				Aloha.settings.logHistory.maxEntries = 100;
+			}
+			if (!Aloha.settings.logHistory.highWaterMark) {
+				Aloha.settings.logHistory.highWaterMark = 90;
+			}
+			if (!Aloha.settings.logHistory.levels) {
+				Aloha.settings.logHistory.levels = {
+					'error': true,
+					'warn': true
+				};
+			}
+			this.flushLogHistory();
+
+			Aloha.trigger('aloha-logger-ready');
+		},
+
+		/**
+		 * Log History as array of Message Objects. Every object has the properties
+		 * 'level', 'component' and 'message'
+		 * @property
+		 * @type Array
+		 * @hide
+		 */
+		logHistory: [],
+
+		/**
+		 * Flag, which is set as soon as the highWaterMark for the log history is reached.
+		 * This flag is reset on every call of flushLogHistory()
+		 * @hide
+		 */
+		highWaterMarkReached: false,
+
+		/**
+		 * Logs a message to the console
+		 * @method
+		 * @param {String} level Level of the log ('error', 'warn' or 'info', 'debug')
+		 * @param {String} component Component that calls the log
+		 * @param {String} message log message
+		 */
+		log: function (level, component, message) {
+
+
+			// log ('Logging message');
+			if (typeof component === 'undefined') {
+				message = level;
+			}
+			if (typeof component !== 'string' && component && component.toString) {
+				component = component.toString();
+			}
+
+			// log ('warn', 'Warning message');
+			if (typeof message === 'undefined') {
+				message = component;
+				component = undefined;
+			}
+
+			if (typeof level === 'undefined' || !level) {
+				level = 'log';
+			}
+
+			level = level.toLowerCase();
+
+			if (typeof Aloha.settings.logLevels === "undefined") {
+				return;
+			}
+
+			// now check whether the log level is activated
+			if (!Aloha.settings.logLevels[level]) {
+				return;
+			}
+
+			component = component || "Unkown Aloha Component";
+
+			this.addToLogHistory({
+				'level': level,
+				'component': component,
+				'message': message,
+				'date': new Date()
+			});
+
+			var console = window.console;
+
+			switch (level) {
+			case 'error':
+				if (window.console && console.error) {
+					// FIXME:
+					// Using console.error rather than throwing an error is very
+					// problematic because we get not stack.
+					// We ought to consider doing the following:
+					// throw component + ': ' + message;
+					if (!component && !message) {
+						console.error("Error occured without message and component");
+					} else {
+						console.error(component + ': ' + message);
+					}
+				}
+				break;
+			case 'warn':
+				if (window.console && console.warn) {
+					console.warn(component + ': ' + message);
+				}
+				break;
+			case 'info':
+				if (window.console && console.info) {
+					console.info(component + ': ' + message);
+				}
+				break;
+			case 'debug':
+				if (window.console && console.log) {
+					console.log(component + ' [' + level + ']: ' + message);
+				}
+				break;
+			default:
+				if (window.console && console.log) {
+					console.log(component + ' [' + level + ']: ' + message);
+				}
+				break;
+			}
+		},
+
+		/**
+		 * Log a message of log level 'error'
+		 * @method
+		 * @param {String} component Component that calls the log
+		 * @param {String} message log message
+		 */
+		error: function (component, message) {
+			this.log('error', component, message);
+		},
+
+		/**
+		 * Log a message of log level 'warn'
+		 * @method
+		 * @param {String} component Component that calls the log
+		 * @param {String} message log message
+		 */
+		warn: function (component, message) {
+			this.log('warn', component, message);
+		},
+
+		/**
+		 * Log a message of log level 'info'
+		 * @method
+		 * @param {String} component Component that calls the log
+		 * @param {String} message log message
+		 */
+		info: function (component, message) {
+			this.log('info', component, message);
+		},
+
+		/**
+		 * Log a message of log level 'debug'
+		 * @param {String} component Component that calls the log
+		 * @param {String} message log message
+		 */
+		debug: function (component, message) {
+			this.log('debug', component, message);
+		},
+
+		/**
+		 * Methods to mark function as deprecated for developers.
+		 * @param {String} component String that calls the log
+		 * @param {String} message log message
+		 */
+		deprecated: function (component, message) {
+			this.log('warn', component, message);
+			// help the developer to locate the call.
+			if (Aloha.settings.logLevels.deprecated) {
+				throw new Error(message);
+			}
+		},
+
+		/**
+		 * Check whether the given log level is currently enabled
+		 * @param {String} level
+		 * @return true when log level is enabled, false if not
+		 */
+		isLogLevelEnabled: function (level) {
+			return Aloha.settings && Aloha.settings.logLevels && Aloha.settings.logLevels[level];
+		},
+
+		/**
+		 * Check whether error logging is enabled
+		 * @return true if error logging is enabled, false if not
+		 */
+		isErrorEnabled: function () {
+			return this.isLogLevelEnabled('error');
+		},
+
+		/**
+		 * Check whether warn logging is enabled
+		 * @return true if warn logging is enabled, false if not
+		 */
+		isWarnEnabled: function () {
+			return this.isLogLevelEnabled('warn');
+		},
+
+		/**
+		 * Check whether info logging is enabled
+		 * @return true if info logging is enabled, false if not
+		 */
+		isInfoEnabled: function () {
+			return this.isLogLevelEnabled('info');
+		},
+
+		/**
+		 * Check whether debug logging is enabled
+		 * @return true if debug logging is enabled, false if not
+		 */
+		isDebugEnabled: function () {
+			return this.isLogLevelEnabled('debug');
+		},
+
+		/**
+		 * Add the given entry to the log history. Check whether the highWaterMark has been reached, and fire an event if yes.
+		 * @param {Object} entry entry to be added to the log history
+		 * @hide
+		 */
+		addToLogHistory: function (entry) {
+
+			if (!Aloha.settings.logHistory) {
+				this.init();
+			}
+
+			// when maxEntries is set to something illegal, we do nothing (log history is disabled)
+			// check whether the level is one we like to have logged
+			if (Aloha.settings.logHistory.maxEntries <= 0 || !Aloha.settings.logHistory.levels[entry.level]) {
+
+				return;
+			}
+
+			// first add the entry as last element to the history array
+			this.logHistory.push(entry);
+
+			// check whether the highWaterMark was reached, if so, fire an event
+			if (!this.highWaterMarkReached) {
+
+				if (this.logHistory.length >= Aloha.settings.logHistory.maxEntries * Aloha.settings.logHistory.highWaterMark / 100) {
+
+					// fire the event
+					Aloha.trigger('aloha-log-full');
+					// set the flag (so we will not fire the event again until the logHistory is flushed)
+					this.highWaterMarkReached = true;
+				}
+			}
+
+			// check whether the log is full and eventually remove the oldest entries
+			// @todo remove old entries when aloha-log-full event is triggered
+			while (this.logHistory.length > Aloha.settings.logHistory.maxEntries) {
+				this.logHistory.shift();
+			}
+		},
+
+		/**
+		 * Get the log history
+		 * @return log history as array of objects
+		 * @hide
+		 */
+		getLogHistory: function () {
+			return this.logHistory;
+		},
+
+		/**
+		 * Flush the log history. Remove all log entries and reset the flag for the highWaterMark
+		 * @return void
+		 * @hide
+		 */
+		flushLogHistory: function () {
+			this.logHistory = [];
+			this.highWaterMarkReached = false;
+		}
+	});
+
+	/**
+	 * Create the Log object
+	 * @hide
+	 */
+	AlohaConsole = new AlohaConsole();
+
+	// add to log namespace for compatiblility.
+	Aloha.Log = Aloha.Console = AlohaConsole;
+	return AlohaConsole;
+});