locomotive-aloha-rails 0.20.1

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

@@ -0,0 +1,330 @@
+/*!
+* This file is part of Aloha Editor Project http://aloha-editor.org
+* Copyright © 2010-2011 Gentics Software GmbH, aloha@gentics.com
+* Contributors http://aloha-editor.org/contribution.php 
+* Licensed unter the terms of http://www.aloha-editor.org/license.html
+*//*
+* Aloha Editor is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) 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 Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+define(
+['aloha/core', 'util/class', 'aloha/jquery'],
+function(Aloha, Class, jQuery ) {
+	
+	
+	var
+//		$ = jQuery,
+//		Aloha = window.Aloha,
+		console = window.console;
+//		Class = window.Class
+//		GENTICS = window.GENTICS;
+
+/**
+ * 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()});
+		
+		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
+		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.
+return Aloha.Log = Aloha.Console = alohaConsole;
+
+});

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

@@ -0,0 +1,65 @@
+/*!
+ * 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/registry'],
+function( jQuery, Registry ) {
+	
+
+	/**
+	 * Create an contentHandler from the given definition. Acts as a factory method
+	 * for contentHandler.
+	 *
+	 * @param {Object} definition
+	 */
+	return new ( Registry.extend({
+
+		createHandler: function( definition ) {
+			
+			if ( typeof definition.handleContent != 'function' ) {
+				throw 'ContentHandler has no function handleContent().';
+			}
+
+			var AbstractContentHandler = Class.extend({
+				handleContent: function( content ) {
+					// Implement in subclass!
+				}
+			}, definition);
+			
+			return new AbstractContentHandler();
+		},
+		
+		handleContent: function ( content, options ) {
+			var handler,
+				handlers = this.getEntries();
+			
+			if ( typeof options.contenthandler === 'undefined') {
+				options.contenthandler = [];
+				for ( handler in handlers ) {
+					if ( handlers.hasOwnProperty(handler) ) {
+						options.contenthandler.push(handler);
+					}
+				}
+			}
+
+			for ( handler in handlers ) {
+				if ( handlers.hasOwnProperty(handler) ) {
+					if (jQuery.inArray( handler, options.contenthandler ) < 0 ) {
+						continue;
+					}
+					
+					if ( typeof handlers[handler].handleContent === 'function') {
+						content = handlers[handler].handleContent( content, options );
+					} else {
+						console.error( 'A valid content handler needs the method handleContent.' );
+					}
+				}
+			}
+
+			return content;
+		}
+	}))();
+});

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

@@ -0,0 +1,560 @@
+/*!
+* This file is part of Aloha Editor Project http://aloha-editor.org
+* Copyright © 2010-2011 Gentics Software GmbH, aloha@gentics.com
+* Contributors http://aloha-editor.org/contribution.php 
+* Licensed unter the terms of http://www.aloha-editor.org/license.html
+*//*
+* Aloha Editor is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) 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 Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+define(
+
+[
+	'aloha/jquery',
+	'aloha/pluginmanager'
+],
+
+function ( jQuery, PluginManager ) {
+	
+
+
+	//----------------------------------------
+	// Private variables
+	//----------------------------------------
+	
+	/**
+	 * Hash table that will be populated through the loadPlugins method.
+	 * Maps the names of plugins with their urls for easy assess in the getPluginsUrl method
+	 */
+	var pluginPaths = {};
+
+	/**
+	 * Base Aloha Object
+	 * @namespace Aloha
+	 * @class Aloha The Aloha base object, which contains all the core functionality
+	 * @singleton
+	 */
+	jQuery.extend(true, Aloha, {
+
+		/**
+		 * The Aloha Editor Version we are using
+		 * It should be set by us and updated for the particular branch
+		 * @property
+		 */
+		version: '0.10.0',
+
+		/**
+		 * Array of editables that are managed by Aloha
+		 * @property
+		 * @type Array
+		 */
+		editables: [],
+
+		/**
+		 * The currently active editable is referenced here
+		 * @property
+		 * @type Aloha.Editable
+		 */
+		activeEditable: null,
+
+		/**
+		 * settings object, which will contain all Aloha settings
+		 * @cfg {Object} object Aloha's settings
+		 */
+		settings: {},
+		
+		/**
+		 * defaults object, which will contain all Aloha defaults
+		 * @cfg {Object} object Aloha's settings
+		 */
+		defaults: {},
+		
+		/**
+		 * Namespace for ui components
+		 */
+		ui: {},
+		
+		/**
+		 * This represents the name of the users OS. Could be:
+		 * 'Mac', 'Linux', 'Win', 'Unix', 'Unknown'
+		 * @property
+		 * @type string
+		 */
+		OSName: 'Unknown',
+
+		/**
+		 * Which stage is the aloha init process at?
+		 * @property
+		 * @type string
+		 */
+		stage: 'loadingAloha',
+
+		/**
+		 * A list of loaded plugin names. Available after the
+		 * "loadPlugins" stage.
+		 *
+		 * @property
+		 * @type array
+		 * @internal
+		 */
+		loadedPlugins: [],
+
+		requirePaths: [],
+		/**
+		 * Initialize the initialization process
+		 */
+		init: function () {
+				
+			// merge defaults and settings and provide all in settings
+			Aloha.settings = jQuery.extendObjects( true, {}, Aloha.defaults, Aloha.settings );
+
+			// initialize rangy. This is probably necessary here,
+			// because due to the current loading mechanism, rangy
+			// doesn't initialize itself in all browsers
+			if (window.rangy) {
+				window.rangy.init();
+			}
+			
+			// Load & Initialise
+			Aloha.stage = 'loadPlugins';
+			Aloha.loadPlugins(function(){
+				Aloha.stage = 'initAloha';
+				Aloha.initAloha(function(){
+					Aloha.stage = 'initPlugins';
+					Aloha.initPlugins(function(){
+						Aloha.stage = 'initGui';
+						Aloha.initGui(function(){
+							Aloha.stage = 'alohaReady';
+							Aloha.trigger('aloha-ready');
+						});
+					});
+				});
+			});
+		},
+
+		/**
+		 * Load Plugins
+		 */
+		loadPlugins: function (next) {
+			// contains an array like [common/format, common/block]
+			var configuredPluginsWithBundle = this.getPluginsToBeLoaded();
+
+			if (configuredPluginsWithBundle.length) {
+				var paths = {},
+				    pluginNames = [],
+				    requiredInitializers = [],
+				    pathsToPlugins = {};
+
+				// Background: We do not use CommonJS packages for our Plugins
+				// as this breaks the loading order when these modules have
+				// other dependencies.
+				// We "emulate" the commonjs modules with the path mapping.
+				/* require(
+				 *  { paths: {
+				 *      'format': 'plugins/common/format/lib',
+				 *      'format/nls': 'plugins/common/format/nls',
+				 *      ... for every plugin ...
+				 *    }
+				 *  },
+				 *  ['format/format-plugin', ... for every plugin ...],
+				 *  next <-- when everything is loaded, we continue
+				 */
+				jQuery.each(configuredPluginsWithBundle, function (i, configuredPluginWithBundle) {
+					var tmp, bundleName, pluginName, bundlePath = '';
+
+					tmp = configuredPluginWithBundle.split('/');
+					bundleName = tmp[0];
+					pluginName = tmp[1];
+
+					// TODO assertion if pluginName or bundleName NULL _-> ERROR!!
+
+					if (Aloha.settings.basePath) {
+						bundlePath = Aloha.settings.basePath;
+					}
+
+					if (Aloha.settings.bundles && Aloha.settings.bundles[bundleName]) {
+						bundlePath += Aloha.settings.bundles[bundleName];
+					} else {
+						bundlePath += '../plugins/' + bundleName;
+					}
+
+					pluginNames.push(pluginName);
+					paths[pluginName] = bundlePath + '/' + pluginName + '/lib';
+
+					pathsToPlugins[pluginName] = bundlePath + '/' + pluginName;
+
+					// As the "nls" path lies NOT inside /lib/, but is a sibling to /lib/, we need
+					// to register it explicitely. The same goes for the "css" folder.
+					jQuery.each(['nls', 'css', 'vendor', 'res'], function() {
+						paths[pluginName + '/' + this] = bundlePath + '/' + pluginName + '/' + this;
+					});
+
+					requiredInitializers.push(pluginName + '/' + pluginName + '-plugin');
+				});
+
+				this.loadedPlugins = pluginNames;
+				this.requirePaths = paths;
+				
+				// Main Require.js loading call, which fetches all the plugins.
+				require(
+					{
+						context: 'aloha',
+						paths: paths,
+						locale: this.settings.locale || this.defaults.locale || 'en'
+					},
+					requiredInitializers,
+					next
+				);
+
+				pluginPaths = pathsToPlugins;
+			} else {
+				next();
+			}
+		},
+
+		/**
+		 * Fetches plugins the user wants to have loaded. Returns all plugins the user
+		 * has specified with the data-plugins property as array, with the bundle
+		 * name in front.
+		 *
+		 * @return array
+		 * @internal
+		 */
+		getPluginsToBeLoaded: function() {
+			// look for data-aloha-plugins attributes and load values
+			var
+				plugins = jQuery('[data-aloha-plugins]').data('aloha-plugins');
+
+			// Determine Plugins
+			if ( typeof plugins === 'string' && plugins !== "") {
+				return plugins.replace(/\s+/g, '').split(',');
+			}
+			// Return
+			return [];
+			
+		},
+
+		/**
+		 * Returns list of loaded plugins (without Bundle name)
+		 *
+		 * @return array
+		 */
+		getLoadedPlugins: function() {
+			return this.loadedPlugins;
+		},
+
+		/**
+		 * Returns true if a certain plugin is loaded, false otherwise.
+		 */
+		isPluginLoaded: function(pluginName) {
+			var found = false;
+			jQuery.each(this.loadedPlugins, function() {
+				if (pluginName.toString() === this.toString()) {
+					found = true;
+				}
+			});
+			return found;
+		},
+
+		/**
+		 * Initialise Aloha
+		 */
+		initAloha: function(next){
+			// check browser version on init
+			// this has to be revamped, as
+			if (jQuery.browser.webkit && parseFloat(jQuery.browser.version) < 532.5 || // Chrome/Safari 4
+				jQuery.browser.mozilla && parseFloat(jQuery.browser.version) < 1.9 || // FF 3.5
+				jQuery.browser.msie && jQuery.browser.version < 7 || // IE 7
+				jQuery.browser.opera && jQuery.browser.version < 11 ) { // right now, Opera needs some work
+				if (window.console && window.console.log) {
+					window.console.log( 'Your browser is not supported.' );
+				}
+			}
+
+			// register the body click event to blur editables
+			jQuery('html').mousedown(function(e) {
+				// if an Ext JS modal is visible, we don't want to loose the focus on
+				// the editable as we assume that the user must have clicked somewhere
+				// in the modal... where else could he click?
+				// loosing the editable focus in this case hinders correct table
+				// column/row deletion, as the table module will clean it's selection
+				// as soon as the editable is deactivated. Fusubscriberthermore you'd have to
+				// refocus the editable again, which is just strange UX
+				if (Aloha.activeEditable && !Aloha.isMessageVisible() && !Aloha.eventHandled) {
+					Aloha.activeEditable.blur();
+					Aloha.activeEditable = null;
+				}
+			}).mouseup(function(e) {
+				Aloha.eventHandled = false;
+			});
+			
+			// Initialise the base path to the aloha files
+			Aloha.settings.base = Aloha.getAlohaUrl();
+
+			// initialize the Log
+			Aloha.Log.init();
+
+			// initialize the error handler for general javascript errors
+			if ( Aloha.settings.errorhandling ) {
+				window.onerror = function (msg, url, linenumber) {
+					Aloha.Log.error(Aloha, 'Error message: ' + msg + '\nURL: ' + url + '\nLine Number: ' + linenumber);
+					// TODO eventually add a message to the message line?
+					return true;
+				};
+			}
+
+			// OS detection
+			if (navigator.appVersion.indexOf('Win') != -1) {
+				Aloha.OSName = 'Win';
+			}
+			if (navigator.appVersion.indexOf('Mac') != -1) {
+				Aloha.OSName = 'Mac';
+			}
+			if (navigator.appVersion.indexOf('X11') != -1) {
+				Aloha.OSName = 'Unix';
+			}
+			if (navigator.appVersion.indexOf('Linux') != -1) {
+				Aloha.OSName = 'Linux';
+			}
+
+			try {
+				// this will disable browsers image resizing facilities
+				// disable resize handles
+				var supported;
+				try {
+					supported = document.queryCommandSupported( 'enableObjectResizing' );
+				} catch ( e ) {
+					supported = false;
+					Aloha.Log.log( 'enableObjectResizing is not supported.' );
+				}
+				
+				if ( supported ) {
+					document.execCommand( 'enableObjectResizing', false, false);
+					Aloha.Log.log( 'enableObjectResizing disabled.' );
+				}
+			} catch (e) {
+				Aloha.Log.error( e, 'Could not disable enableObjectResizing' );
+				// this is just for others, who will not support disabling enableObjectResizing
+			}
+			// Forward
+			next();
+		},
+
+		/**
+		 * Loads plugins Aloha
+		 * @return void
+		 */
+		initPlugins: function (next) {
+			PluginManager.init(function(){
+				next();
+			}, this.getLoadedPlugins() );
+		},
+
+		/**
+		 * Loads GUI components
+		 * @return void
+		 */
+		initGui: function (next) {
+			
+			Aloha.RepositoryManager.init();
+
+			// activate registered editables
+			for (var i = 0, editablesLength = Aloha.editables.length; i < editablesLength; i++) {
+				if ( !Aloha.editables[i].ready ) {
+					Aloha.editables[i].init();
+				}
+			}
+
+			// Forward
+			next();
+		},
+
+		/**
+		 * Activates editable and deactivates all other Editables
+		 * @param {Editable} editable the Editable to be activated
+		 * @return void
+		 */
+		activateEditable: function (editable) {
+
+			// blur all editables, which are currently active
+			for (var i = 0, editablesLength = Aloha.editables.length; i < editablesLength; i++) {
+				if (Aloha.editables[i] != editable && Aloha.editables[i].isActive) {
+					Aloha.editables[i].blur();
+				}
+			}
+
+			Aloha.activeEditable = editable;
+		},
+
+		/**
+		 * Returns the current Editable
+		 * @return {Editable} returns the active Editable
+		 */
+		getActiveEditable: function() {
+			return Aloha.activeEditable;
+		},
+
+		/**
+		 * deactivated the current Editable
+		 * @return void
+		 */
+		deactivateEditable: function () {
+
+			if ( typeof Aloha.activeEditable === 'undefined' || Aloha.activeEditable === null ) {
+				return;
+			}
+
+			// blur the editable
+			Aloha.activeEditable.blur();
+			Aloha.activeEditable = null;
+		},
+
+		/**
+		 * Gets an editable by an ID or null if no Editable with that ID registered.
+		 * @param {string} id the element id to look for.
+		 * @return {Aloha.Editable} editable
+		 */
+		getEditableById: function (id) {
+
+			// if the element is a textarea than route to the editable div
+			if (jQuery('#'+id).get(0).nodeName.toLowerCase() === 'textarea' ) {
+				id = id + '-aloha';
+			}
+
+			// serach all editables for id
+			for (var i = 0, editablesLength = Aloha.editables.length; i < editablesLength; i++) {
+				if (Aloha.editables[i].getId() == id) {
+					return Aloha.editables[i];
+				}
+			}
+
+			return null;
+		},
+
+		/**
+		 * Checks wheater an object is a registered Aloha Editable.
+		 * @param {jQuery} obj the jQuery object to be checked.
+		 * @return {boolean}
+		 */
+		isEditable: function (obj) {
+			for (var i=0, editablesLength = Aloha.editables.length; i < editablesLength; i++) {
+				if ( Aloha.editables[i].originalObj.get(0) === obj ) {
+					return true;
+				}
+			}
+			return false;
+		},
+
+		/**
+		 * Logs a message to the console
+		 * @param level Level of the log ("error", "warn" or "info", "debug")
+		 * @param component Component that calls the log
+		 * @param message log message
+		 * @return void
+		 * @hide
+		 */
+		log: function(level, component, message) {
+			if (typeof Aloha.Log !== "undefined")
+				Aloha.Log.log(level, component, message);
+		},
+		
+		/**
+		 * Register the given editable
+		 * @param editable editable to register
+		 * @return void
+		 * @hide
+		 */
+		registerEditable: function (editable) {
+			Aloha.editables.push(editable);
+		},
+
+		/**
+		 * Unregister the given editable. It will be deactivated and removed from editables.
+		 * @param editable editable to unregister
+		 * @return void
+		 * @hide
+		 */
+		unregisterEditable: function (editable) {
+
+			// Find the index
+			var id = Aloha.editables.indexOf( editable );
+			// Remove it if really found!
+			if (id != -1) {
+				Aloha.editables.splice(id, 1);
+			}
+		},
+
+		/**
+		 * String representation
+		 * @hide
+		 */
+		toString: function () {
+			return 'Aloha';
+		},
+
+		/**
+		 * Check whether at least one editable was modified
+		 * @method
+		 * @return {boolean} true when at least one editable was modified, false if not
+		 */
+		isModified: function () {
+			// check if something needs top be saved
+			for (var i = 0; i < Aloha.editables.length; i++) {
+				if (Aloha.editables[i].isModified && Aloha.editables[i].isModified()) {
+					return true;
+				}
+			}
+
+			return false;
+		},
+
+		/**
+		 * Determines the Aloha Url
+		 * @method
+		 * @return {String} alohaUrl
+		 */
+		getAlohaUrl: function( suffix ) {
+			// aloha base path is defined by a script tag with 2 data attributes
+			var requireJs = jQuery('[data-aloha-plugins]'),
+				baseUrl = ( requireJs.length ) ? requireJs[0].src.replace( /\/?aloha.js$/ , '' ) : '';
+				
+			return baseUrl;
+		},
+
+		/**
+		 * Gets the Plugin Url
+		 * @method
+		 * @param {String} name
+		 * @return {String} url
+		 */
+		getPluginUrl: function (name) {
+			var url;
+
+			if (name) {
+				url = pluginPaths[name];
+				if(url) {
+					//Check if url is absolute and attach base url if it is not
+					if(!url.match("^(\/|http[s]?:).*")) {
+						url = Aloha.getAlohaUrl() + '/' + url;
+					}
+				}
+			}
+
+			return url;
+		}
+
+	});
+
+	return Aloha;
+});