aloha-rails 0.0.1

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/de/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"Unsortierte Liste einf\u00fcgen","button.createolist.tooltip":"Sortierte Liste einf\u00fcgen"});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/eo/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"Enmeti senordan liston","button.createolist.tooltip":"Enmeti ordan liston"});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/fi/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"Lis\u00e4\u00e4 j\u00e4rjestelem\u00e4t\u00f6n lista","button.createolist.tooltip":"Lis\u00e4\u00e4 j\u00e4rjestelty lista"});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/fr/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"Ins\u00e9rer une liste non ordonn\u00e9e","button.createolist.tooltip":"Ins\u00e9rer liste ordonn\u00e9e"});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/i18n.js

@@ -0,0 +1,9 @@
+define({
+	root: {"button.createulist.tooltip":"Insert Unordered List","button.createolist.tooltip":"Insert Ordered List","button.indentlist.tooltip":"Indent List","button.outdentlist.tooltip":"Outdent List","floatingmenu.tab.list":"Lists"}
+,	"de":true,
+	"eo":true,
+	"fi":true,
+	"fr":true,
+	"it":true,
+	"ru":true
+});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/it/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"Inserisci una lista","button.createolist.tooltip":"Inserisci una lista numerata"});

data/vendor/assets/javascripts/aloha/plugins/common/list/nls/ru/i18n.js

@@ -0,0 +1 @@
+define({"button.createulist.tooltip":"\u0412\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u0421\u043f\u0438\u0441\u043e\u043a","button.createolist.tooltip":"\u0412\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u0423\u043f\u043e\u0440\u044f\u0434\u043e\u0447\u0435\u043d\u043d\u044b\u0439 \u0421\u043f\u0438\u0441\u043e\u043a"});

data/vendor/assets/javascripts/aloha/plugins/common/list/package.json

@@ -0,0 +1 @@
+{}

data/vendor/assets/javascripts/aloha/plugins/common/paste/README.md

@@ -0,0 +1,3 @@
+Paste plugin allows to handle some different contents that are pasted into the editable area.
+
+This plugin is released under the AGPL license.

data/vendor/assets/javascripts/aloha/plugins/common/paste/lib/paste-plugin.js

@@ -0,0 +1,221 @@
+/*!
+* 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
+*/
+
+/**
+ * Paste Plugin
+ * ------------
+ * The paste plugin intercepts all browser paste events that target aloha-
+ * editables, and redirects the events into a hidden div. Once pasting is done
+ * into this div, its contents will be processed by registered content handlers
+ * before being copied into the active editable, at the current range.
+ */
+
+define(
+[ 'aloha/core', 'aloha/plugin', 'aloha/jquery', 'aloha/command',
+  'aloha/console' ],
+function ( Aloha, Plugin, jQuery, Commands, console ) {
+	
+	
+	var GENTICS = window.GENTICS,
+	    $window = jQuery( window ),
+	    pasteRange = null,
+	    pasteEditable = null;
+	
+	// We need to hide the editable div. We'll use clip:rect for chrome and IE,
+	// and width/height for FF
+	var $pasteDiv = jQuery( '<div id="pasteContainer" ' +
+			'style="position:absolute; clip:rect(0px, 0px, 0px, 0px); ' +
+			'width: 1px; height: 1px;"></div>' ).contentEditable( true );
+	
+	/**
+	 * Redirects the paste event into the hidden pasteDiv
+	 */
+	function redirectPaste () {
+		// store the current range
+		pasteRange = Aloha.getSelection().getRangeAt( 0 );
+		pasteEditable = Aloha.activeEditable;
+		
+		// store the current scroll position
+		$pasteDiv.css( {
+			top: $window.scrollTop(),
+			left: $window.scrollLeft() - 200
+		} );
+		
+		// empty the pasteDiv
+		$pasteDiv.contents().remove();
+		
+		if ( pasteEditable ) {
+			// TODO test in IE!
+			pasteEditable.obj.blur();
+		}
+		
+		GENTICS.Utils.Dom.setCursorInto( $pasteDiv.get( 0 ) );
+		
+		$pasteDiv.focus();
+	};
+
+	/**
+	 * Gets the pasted content and inserts them into the current active
+	 * editable
+	 */
+	function getPastedContent () {
+		var that = this,
+		    pasteDivContents;
+		
+		// insert the content into the editable at the current range
+		if ( pasteRange && pasteEditable ) {
+			// activate and focus the editable
+			// @todo test in IE
+			//pasteEditable.activate();
+			pasteEditable.obj.click();
+			
+			pasteDivContents = $pasteDiv.html();
+			
+			// We need to remove an insidious nbsp that IE inserted into our
+			// paste div, otherwise it will result in an empty paragraph being
+			// created right before the pasted content, if the pasted content
+			// is a paragraph
+			if ( jQuery.browser.msie &&
+					/^&nbsp;/.test( pasteDivContents ) ) {
+				pasteDivContents = pasteDivContents.substring( 6 );
+			}
+			
+			pasteDivContents = jQuery.trim( pasteDivContents );
+			
+			// Detects a situation where we are about to paste into a selection
+			// that looks like this: <p> [</p>...
+			// The nbsp inside the <p> node was placed there to make the empty
+			// paragraph visible in HTML5 conformant rendering engines, like
+			// WebKit. Without the white space, such browsers would correctly
+			// render an empty <p> as invisible.
+			// Note that we do not "prop up" otherwise empty paragraph nodes
+			// using a <br />, as WebKit does, because IE does display empty
+			// paragraphs which are content-editable and so a <br /> results in
+			// 2 lines instead of 1 being shown inside the paragraph.
+			// If we detect this situation, we remove the white space so that
+			// when we paste a new paragraph into the paragraph, it is not be
+			// split, leaving an empty paragraph on top of the pasted content
+			// 
+			// We use "/^(\s|%A0)$/.test( escape(" instead of
+			// "/^(\s|&nbsp;)$/.test( escape(" because it seems that IE
+			// transforms non-breaking spaces into atomic tokens
+			var startContainer = pasteRange.startContainer;
+			if ( startContainer.nodeType == 3 &&
+					startContainer.parentNode.nodeName == 'P' &&
+						startContainer.parentNode.childNodes.length == 1 &&
+							/^(\s|%A0)$/.test( escape( startContainer.data ) ) ) {
+				startContainer.data = '';
+				pasteRange.startOffset = 0;
+				
+				// In case ... <p> []</p>
+				if ( pasteRange.endContainer == startContainer ) {
+					pasteRange.endOffset = 0;
+				}
+			}
+			
+			if ( Aloha.queryCommandSupported( 'insertHTML' ) ) {
+				Aloha.execCommand( 'insertHTML', false, pasteDivContents,
+					pasteRange );
+			} else {
+				console.error( 'Common.Paste', 'Command "insertHTML" not ' +
+					'available. Enable the plugin "common/commands".' );
+			}
+		}
+		
+		pasteRange = void 0;
+		pasteEditable = void 0;
+		
+		$pasteDiv.contents().remove();
+	};
+
+	// Public Methods
+	return Plugin.create( 'paste', {
+		
+		settings: {},
+		
+		init: function () {
+			var that = this;
+			
+			jQuery( 'body' ).append( $pasteDiv );
+			
+			// subscribe to the event editableCreated to redirect paste events
+			// into our hidden pasteDiv
+			// TODO: move to paste command
+			// http://support.mozilla.com/en-US/kb/Granting%20JavaScript%20access%20to%20the%20clipboard
+			// https://code.google.com/p/zeroclipboard/
+			Aloha.bind( 'aloha-editable-created', function ( event, editable ) {
+				// browser-dependent events
+				if ( jQuery.browser.msie ) {
+					// We will only us the ugly beforepaste hack if we shall
+					// not access the clipboard
+					if ( that.settings.noclipboardaccess ) {
+						editable.obj.bind( 'beforepaste', function ( event ) {
+							redirectPaste();
+							event.stopPropagation();
+						} );
+					} else {
+						// uses the execCommand for IE
+						editable.obj.bind( 'paste', function ( event ) {
+							redirectPaste();
+							
+							var range = document.selection.createRange();
+							range.execCommand( 'paste' );
+							
+							getPastedContent();
+							// We manually unset the metaKey property because
+							// the smartContentChange method will not process
+							// this event if the metaKey property is set
+							event.metaKey = void 0;
+							
+							Aloha.activeEditable.smartContentChange( event );
+							event.stopPropagation();
+							
+							return false;
+						} );
+					}
+				} else {
+					editable.obj.bind( 'paste', function ( event ) {
+						redirectPaste();
+						// We need to accomodate a small amount execution
+						// window to ensure that pasted content has actually
+						// been inserted
+						window.setTimeout( function () {
+							getPastedContent();
+							Aloha.activeEditable.smartContentChange( event );
+							event.stopPropagation();
+						}, 10 );
+					} );
+				}
+			} );
+
+			// bind a handler to the paste event of the pasteDiv to get the
+			// pasted content (but do this only once, not for every editable)
+			if ( jQuery.browser.msie && that.settings.noclipboardaccess ) {
+				$pasteDiv.bind( 'paste', function ( event ) {
+					window.setTimeout( function () {
+						getPastedContent();
+						Aloha.activeEditable.smartContentChange( event );
+						event.stopPropagation();
+					}, 10 );
+				} );
+			}
+		},
+
+		/**
+		 * Register the given paste handler
+		 * @deprecated
+		 * @param pasteHandler paste handler to be registered
+		 */
+		register: function ( pasteHandler ) {
+			console.deprecated( 'Plugins.Paste', 'register() for ' +
+				'pasteHandler is deprecated. Use the ContentHandler Plugin ' +
+				'instead.' );
+		}
+		
+	} );
+	
+} );

data/vendor/assets/javascripts/aloha/plugins/common/paste/package.json

@@ -0,0 +1,8 @@
+{
+  "js": [
+  "src/paste.js",
+  "src/wordpastehandler.js",
+  "src/oembedpastehandler.js",
+  "src/genericpastehandler.js" 	
+  ]	 	
+}

data/vendor/assets/javascripts/aloha/plugins/common/table/css/table.css

@@ -0,0 +1,160 @@
+/* reset */
+.aloha-table tr.aloha-table-selectcolumn {
+	line-height: 0.01em;
+	height: 12px !important;
+}
+.aloha-table td.aloha-table-selectrow {
+	width: 25px !important;
+}
+.aloha-editable div.aloha-table-wrapper, .aloha-table-wrapper div.aloha-table-cell-editable, 
+.aloha-table-wrapper .aloha-table-leftuppercorner div, .aloha-table-wrapper tr.aloha-table-selectcolumn td,
+.aloha-table-wrapper td.aloha-table-selectrow , .aloha-table-wrapper div.aloha-editable-caption { 
+	margin:0; 
+	padding:0;
+	border:none; 
+	background:none;
+	outline: 0px solid transparent;
+}
+
+/* editable wrappers in cells */
+div.aloha-table-cell-editable {
+	height: 100%;
+	min-height: 100%;
+	width: 100%;
+	z-index: 99999;
+}
+
+/* only show controls when in active state */
+tr.aloha-table-selectcolumn td,
+td.aloha-table-selectrow {
+	visibility: hidden;
+}
+.aloha-editable-active tr.aloha-table-selectcolumn td,
+.aloha-editable-active td.aloha-table-selectrow {
+	visibility: visible;
+}
+
+/* selection and hover */
+.aloha-cell-selected {
+	background-color: #80B5F2 !important;
+	color: #FFF;
+}
+.aloha-table td.aloha-table-selectrow,
+.aloha-table tr.aloha-table-selectcolumn td {
+	background-color: #D0D0D0;
+}
+.aloha-table td.aloha-table-selectrow:hover,
+.aloha-table tr.aloha-table-selectcolumn td:hover {
+	background-color: #FFE767;
+}
+
+
+/* TODO make custom cursors visible in IE */
+.aloha-table tr.aloha-table-selectcolumn td.aloha-table-leftuppercorner,
+.aloha-table tr.aloha-table-selectcolumn td.aloha-table-leftuppercorner:hover {
+	cursor: default;
+	background-color: transparent;
+}
+.aloha-table td .aloha-table-cell-editable {
+	cursor: text !important;
+}
+.aloha-table tr.aloha-table-selectcolumn td {
+	cursor: url(../img/down.cur),default;
+}
+/* :tODO: make custom cursors visible in IE */
+.aloha-table td.aloha-table-selectrow {
+	cursor: url(../img/left.cur),default;
+}
+
+/* wai indicator */
+.aloha-table-wrapper div.aloha-wai-red {
+	background-image: url(../img/wai-red.png);
+}
+
+.aloha-table-wrapper div.aloha-wai-green {
+	background-image: url(../img/wai-green.png);
+}
+
+.aloha-table td.aloha-table-leftuppercorner div {
+	cursor: pointer !important;
+}
+
+/* create dialog */
+.aloha-table-createdialog {
+	z-index: 99999;
+	position: absolute;
+	background-color: #F0F0F0;
+	border: 1px solid #cccccc;
+	-moz-border-radius: 2px;
+	-webkit-border-radius: 2px;
+	border-radius: 2px;
+}
+.aloha-table-createdialog table {
+	padding: 0px;
+	margin: 0px;
+}
+.aloha-table-createdialog table td {
+	margin: 0px;
+	padding: 0px;
+	border: 1px solid #AFAFAF;
+	font-size: 8px;
+	width: 15px;
+	height: 15px;
+}
+.aloha-table-createdialog table td.hover {
+	background-color: #1c94c4;
+}
+.aloha-table-createdialog #table-size-info {
+	text-align: center;
+	font-size: 0.8em;
+}
+
+.aloha-table-textarea {
+	width:90%;
+	height:100px;
+	margin-left:5px;
+	margin-right:5px;
+}
+
+.aloha-table-label {
+	margin-left:5px;
+}
+
+
+/* ui buttons */
+button.aloha-button-table {
+	background-position: -96px 0 !important;
+}
+button.aloha-button-addColumnLeft {
+	background-position: -112px 0 !important;
+}
+button.aloha-button-addColumnRight {
+	background-position: -128px 0 !important;
+}
+button.aloha-button-addRowBefore {
+	background-position: -144px 0 !important;
+}
+button.aloha-button-addRowAfter {
+	background-position: -160px 0 !important;
+}
+button.aloha-button-deleteRows {
+	background-position: -176px 0 !important;
+}
+button.aloha-button-deleteColumns {
+	background-position: -192px 0 !important;
+}
+button.aloha-button-row-header {
+	background-position: -352px 0px !important;
+}
+button.aloha-button-col-header {
+	background-position: -368px 0px !important;
+}
+button.aloha-button-table-caption {
+	background-position: -320px 0px !important;
+}
+.aloha-button.aloha-button-merge-cells {
+	background-position: -384px 0px !important;
+}
+.aloha-button.aloha-button-split-cells {
+	background-position: -400px 0px !important;
+}

data/vendor/assets/javascripts/aloha/plugins/common/table/lib/table-cell.js

@@ -0,0 +1,463 @@
+define(
+['aloha/jquery', 'table/table-plugin-utils'],
+function (jQuery, Utils) {
+	/**
+	 * Constructs a TableCell.
+	 *
+	 * @param {DomNode} cell
+	 *        A td/th which will be represente by this TableCell.
+	 * @param {Table} tableObj
+	 *        The Table which contains the cell. The cell will be
+	 *        activated/dactivated with the table.
+	 */
+	var TableCell = function(originalTd, tableObj) {
+        if (null == originalTd) {
+            originalTd = '<td>&nbsp;</td>';
+        }
+
+        //original Td must be a DOM node so that the this.obj.context property is available
+        //this transformation will properly handle jQuery objects as well as DOM nodes
+        originalTd = jQuery( originalTd ).get( 0 );
+
+        this.obj = jQuery(originalTd);
+        this.tableObj = tableObj;
+
+        tableObj.cells.push(this);
+	};
+
+	/**
+	 * Reference to the jQuery-representation of the wrapping table
+	 *
+	 * @see TableCell.table
+	 */
+	TableCell.prototype.tableObj = undefined;
+
+	/**
+	 * Reference to the jQuery td-Object of the cell
+	 */
+	TableCell.prototype.obj = undefined;
+
+	/**
+	 * The jQuery wrapper of the cell
+	 */
+	TableCell.prototype.wrapper = undefined;
+
+	/**
+	 * Flag if the cell has focus
+	 */
+	TableCell.prototype.hasFocus = false;
+
+	TableCell.prototype.activate = function () {
+		// wrap the created div into the contents of the cell
+		this.obj.wrapInner( '<div/>' );
+
+		// create the editable wrapper for the cells
+		var wrapper = this.obj.children( 'div' ).eq( 0 );
+
+		wrapper.contentEditable( true );
+		wrapper.addClass( 'aloha-table-cell-editable' );
+
+		var that = this;
+		
+		// attach events to the editable div-object
+		wrapper.bind( 'focus', function ( jqEvent ) {
+			// ugly workaround for ext-js-adapter problem in ext-jquery-adapter-debug.js:1020
+			if ( jqEvent.currentTarget ) {
+				jqEvent.currentTarget.indexOf = function () {
+					return -1;
+				};
+			}
+			that._editableFocus( jqEvent );
+		} );
+		
+		wrapper.bind( 'mousedown', function ( jqEvent ) {
+			// ugly workaround for ext-js-adapter problem in ext-jquery-adapter-debug.js:1020
+			if ( jqEvent.currentTarget ) {
+				jqEvent.currentTarget.indexOf = function () {
+					return -1;
+				};
+			}
+			
+			that._editableMouseDown( jqEvent );
+
+			that._startCellSelection();
+		} );
+		wrapper.bind( 'blur',      function ( jqEvent ) { that._editableBlur( jqEvent );    });
+		wrapper.bind( 'keyup',     function ( jqEvent ) { that._editableKeyUp( jqEvent );   });
+		wrapper.bind( 'keydown',   function ( jqEvent ) { that._editableKeyDown( jqEvent ); });
+		wrapper.bind( 'mouseover', function ( jqEvent ) { that._selectCellRange();          });
+
+		// we will treat the wrapper just like an editable
+		wrapper.contentEditableSelectionChange( function ( event ) {
+			Aloha.Selection.onChange( wrapper, event );
+			return wrapper;
+		} );
+
+		this.obj.bind( 'mousedown', function ( jqEvent ) {
+			setTimeout( function () {
+				that.wrapper.trigger( 'focus' );
+			}, 1 );
+			that.tableObj.selection.unselectCells();
+	        that._startCellSelection();       
+			jqEvent.stopPropagation();
+		} );
+
+		if ( this.obj.get( 0 ) ) {
+			this.obj.get( 0 ).onselectstart = function ( jqEvent ) { return false; };
+		}
+
+		// set contenteditable wrapper div
+		this.wrapper = this.obj.children();
+		if ( this.wrapper.get( 0 ) ) {
+			this.wrapper.get( 0 ).onselectstart = function () {
+				window.event.cancelBubble = true;
+			};
+			// Disabled the dragging of content, since it makes cell selection difficult
+			this.wrapper.get( 0 ).ondragstart = function () { return false };
+		}
+
+		return this;
+	};
+
+	/**
+	 * The deactivate method removes the contenteditable helper div within the
+	 * table-data field and wraps the innerHtml to the outerHTML
+	 *
+	 * @return void
+	 */
+	TableCell.prototype.deactivate = function() {
+		var wrapper = this.obj.children('.aloha-table-cell-editable');
+
+		if (wrapper.length) {
+			// get the inner html of the contenteditable div
+			var innerHtml = wrapper.html();
+
+			// remove the contenteditable div and its attached events
+			wrapper.remove();
+
+			// remove the click event of the
+			this.obj.unbind('click');
+
+			if (jQuery.trim(this.obj.attr('class')) == '') {
+				this.obj.removeAttr('class');
+			}
+
+			// set the inner html of the contenteditable div as html for the table-data
+			// field
+			this.obj.html(innerHtml);
+		}
+	}
+
+	/**
+	 * Native toString-method
+	 *
+	 * @return string name of the namespace
+	 */
+	TableCell.prototype.toString = function() {
+		return 'TableCell';
+	};
+
+	/**
+	 * Focus method for the contentediable div within a table data-field. The method
+	 * requires the event-property Cell as a Cell object. If the
+	 * Cell wasn't activated yet it does all relevant actions to activate the cell.
+	 *
+	 * @param e
+	 *            the jquery event object
+	 * @return void
+	 */
+	TableCell.prototype._editableFocus = function(e) {
+		// only do activation stuff if the cell don't has the focus
+		if (!this.hasFocus) {
+			// set an internal flag to focus the table
+			this.tableObj.focus();
+
+			// add an active-class
+			this.obj.addClass('aloha-table-cell_active');
+
+			// set the focus flag
+			this.hasFocus = true;
+
+			// select the whole content in the table-data field
+			this._selectAll(this.wrapper.get(0));
+
+			// unset the selection type
+			this.tableObj.selection.selectionType = 'cell';
+
+		}
+	};
+
+	/**
+	 * Blur event for the contenteditable div within a table-data field. The method
+	 * requires the event-property TableCell as a TableCell object. It
+	 * sets the hasFocus flag of the cell to false and removes the "active"
+	 * css-class.
+	 *
+	 * @param jqEvent
+	 *            the jquery event object
+	 * @return void
+	 */
+	TableCell.prototype._editableBlur = function(jqEvent){
+
+		// reset the focus of the cell
+		this.hasFocus = false;
+
+		// remove "active class"
+		this.obj.removeClass('aloha-table-cell-active');
+	};
+
+	/**
+	 * Gives the X (column no) for a cell, after adding colspans 
+	 */
+	TableCell.prototype._virtualX = function(){
+		var $rows = this.tableObj.obj.children().children('tr');
+		var rowIdx = this.obj.parent().index();
+		var colIdx = this.obj.index();
+		return Utils.cellIndexToGridColumn($rows, rowIdx, colIdx);
+	};
+
+	/**
+	 * Gives the Y (row no) for a cell, after adding colspans 
+	 */
+	TableCell.prototype._virtualY = function(){
+		return this.obj.parent('tr').index();
+	};
+
+	/**
+	 * Starts the cell selection mode
+	 */
+	TableCell.prototype._startCellSelection = function(){
+		if(!this.tableObj.selection.cellSelectionMode){
+
+			//unselect currently selected cells
+			this.tableObj.selection.unselectCells();
+
+			// activate cell selection mode
+			this.tableObj.selection.cellSelectionMode = true; 
+
+			//bind a global mouseup event handler to stop cell selection
+			var that = this;
+			jQuery('body').bind('mouseup.cellselection', function(){
+				that._endCellSelection();
+			});
+
+			this.tableObj.selection.baseCellPosition = [this._virtualY(), this._virtualX()];
+		}
+	};
+
+	/**
+	 * Ends the cell selection mode
+	 */
+	TableCell.prototype._endCellSelection = function(){
+		if(this.tableObj.selection.cellSelectionMode){
+			this.tableObj.selection.cellSelectionMode = false; 
+			this.tableObj.selection.baseCellPosition = null;
+			this.tableObj.selection.lastSelectionRange = null; 
+
+			this.tableObj.selection.selectionType = 'cell';
+
+			//unbind the global cell selection event
+			jQuery('body').unbind('mouseup.cellselection');
+		}
+	};
+
+	TableCell.prototype._getSelectedRect = function () {
+		var right = this._virtualX();
+		var bottom = this._virtualY();
+		var topLeft = this.tableObj.selection.baseCellPosition;
+		var left = topLeft[1];
+		if (left > right) {
+			left = right;
+			right = topLeft[1];
+		}
+		var top = topLeft[0];
+		if (top > bottom) {
+			top = bottom;
+			bottom = topLeft[0];
+		}
+		return {"top": top, "right": right, "bottom": bottom, "left": left};
+	};
+
+	/**
+	 * Toggles selection of cell.
+	 * This works only when cell selection mode is active. 
+	 */
+	TableCell.prototype._selectCellRange = function(){
+		if(!this.tableObj.selection.cellSelectionMode) {
+			return;
+		}
+
+		var rect = this._getSelectedRect();
+
+		var table = this.tableObj;
+		var $rows = table.obj.children().children('tr');
+		var grid = Utils.makeGrid($rows);
+		
+		table.selection.selectedCells = [];
+		var selectClass = table.get('classCellSelected');
+		Utils.walkGrid(grid, function (cellInfo, j, i) {
+			if ( Utils.containsDomCell(cellInfo) ) {
+				if (i >= rect.top && i <= rect.bottom && j >= rect.left && j <= rect.right) {
+					jQuery( cellInfo.cell ).addClass(selectClass);
+					table.selection.selectedCells.push(cellInfo.cell);
+				} else {
+					jQuery( cellInfo.cell ).removeClass(selectClass);
+				}
+			}
+		});
+
+		table.selection.notifyCellsSelected();
+	};
+
+	/**
+	 * Selects all inner-contens of an contentEditable-object
+	 *
+	 * @param editableNode dom-representation of the editable node (div-element)
+	 * @return void
+	 */
+	TableCell.prototype._selectAll = function(editableNode) {
+		var e = (editableNode.jquery) ? editableNode.get(0) : editableNode;
+
+		// Not IE
+		if (!jQuery.browser.msie) {
+			var s = window.getSelection();
+			// WebKit
+			if ( s.setBaseAndExtent /*&& e> 0 */ ) {
+				s.setBaseAndExtent( e, 0, e, Math.max( 0, e.innerText.length - 1 ) );
+			}
+			// Firefox and Opera
+			else {
+				// workaround for bug # 42885
+				if (window.opera
+					&& e.innerHTML.substring(e.innerHTML.length - 4) == '<BR>') {
+					e.innerHTML = e.innerHTML + '&#160;';
+				}
+
+				var r = document.createRange();
+				r.selectNodeContents(e);
+				s.removeAllRanges();
+				s.addRange(r);
+			}
+		}
+		// Some older browsers
+		else if (document.getSelection) {
+			var s = document.getSelection();
+			var r = document.createRange();
+			r.selectNodeContents(e);
+			s.removeAllRanges();
+			s.addRange(r);
+		}
+		// IE
+		else if (document.selection) {
+			var r = document.body.createTextRange();
+			r.moveToElementText(e);
+			r.select();
+		}
+	};
+
+	/**
+	 * The mouse-down event for the editable-div in the thd-field. Unselect all
+	 * cells when clicking on the editable-div.
+	 *
+	 * @param jqEvent
+	 *            the jquery-event object
+	 * @return void
+	 */
+	TableCell.prototype._editableMouseDown = function(jqEvent) {
+		// deselect all highlighted cells registered in the this.tableObj.selection object
+		this.tableObj.selection.unselectCells();
+
+		if (this.tableObj.hasFocus) {
+			jqEvent.stopPropagation();
+		}
+	};
+
+	/**
+	 * The key-up event for the editable-div in the td-field. Just check if the div
+	 * is empty and insert an &nbsp;
+	 *
+	 * @param jqEvent
+	 *            the jquery-event object
+	 * @return void
+	 */
+	TableCell.prototype._editableKeyUp = function( jqEvent ) {
+		//TODO do we need to check for empty cells and insert a space?
+		//this._checkForEmptyEvent(jqEvent);
+	};
+
+	/**
+	 * The key-down event for the ediable-div in the td-field. Check if the the div
+	 * is empty and insert an &nbsp. Furthermore if cells are selected, unselect
+	 * them.
+	 *
+	 * @param jqEvent
+	 *            the jquery-event object
+	 * @return void
+	 */
+	TableCell.prototype._editableKeyDown = function(jqEvent) {
+		var KEYCODE_TAB = 9;
+
+		this._checkForEmptyEvent(jqEvent);
+		
+		if ( this.obj[0] === this.tableObj.obj.find('tr:last td:last')[0] ) {
+			// only add a row on a single key-press of tab (so check
+			// that alt-, shift- or ctrl-key are NOT pressed)
+			if (KEYCODE_TAB == jqEvent.keyCode && !jqEvent.altKey && !jqEvent.shiftKey && !jqEvent.ctrlKey) {
+				// add a row after the current row
+				this.tableObj.addRow(this.obj.parent().index() + 1);
+
+				// firefox needs this for the first cell of the new row
+				// to be selected (.focus() doesn't work reliably in
+				// IE7)
+				this.tableObj.cells[this.tableObj.cells.length - 1]._selectAll(this.wrapper.get(0));
+
+				jqEvent.stopPropagation();
+				return;
+			}
+		}
+	};
+
+	/**
+	 * The custom keyup event for a table-cell Checks if the cell is empty and
+	 * inserts a space (\u00a0)
+	 *
+	 * @param e
+	 *            the event object which is given by jquery
+	 * @return void
+	 */
+	TableCell.prototype._checkForEmptyEvent = function(jqEvent) {
+		var $wrapper = jQuery(this.wrapper),
+		    text = $wrapper.text();
+
+		if ( $wrapper.children().length > 0) {
+			return;
+		}
+
+		// if empty insert a blank space and blur and focus the wrapper
+		if ( text === '' ){
+			this.wrapper.text('\u00a0');
+			this.wrapper.get(0).blur();
+			this.wrapper.get(0).focus();
+		}
+	};
+
+	/**
+	 * Given a cell, will return the container element of the contents
+	 * of the cell. The container element may be the given cell itself,
+	 * or a wrapper element, in the case of activated cells.
+	 *
+	 * @param {DomNode} cell 
+	 *        the TH/TD of a TableCell that may or may not be actived.
+	 * @return {DomNode}
+	 *        the element that contains the contents of the given cell.
+	 */
+	TableCell.getContainer = function ( cell ) {
+		if ( jQuery( cell.firstChild ).hasClass( "aloha-table-cell-editable" ) ) {
+			return cell.firstChild;
+		} else {
+			return cell;
+		}
+	};
+
+	return TableCell;
+});