RubyGems - typo - Versions diffs - 5.0.2 → 5.0.3.98 - Mend

typo 5.0.2 → 5.0.3.98

Files changed (1342) hide show

data/public/javascripts/fckeditor/editor/_source/classes/fckeditingarea.js ADDED Viewed

@@ -0,0 +1,344 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKEditingArea Class: renders an editable area.
+ */
+/**
+ * @constructor
+ * @param {String} targetElement The element that will hold the editing area. Any child element present in the target will be deleted.
+ */
+var FCKEditingArea = function( targetElement )
+{
+	this.TargetElement = targetElement ;
+	this.Mode = FCK_EDITMODE_WYSIWYG ;
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKEditingArea_Cleanup ) ;
+}
+/**
+ * @param {String} html The complete HTML for the page, including DOCTYPE and the <html> tag.
+ */
+FCKEditingArea.prototype.Start = function( html, secondCall )
+{
+	var eTargetElement	= this.TargetElement ;
+	var oTargetDocument	= FCKTools.GetElementDocument( eTargetElement ) ;
+	// Remove all child nodes from the target.
+	var oChild ;
+	while( ( oChild = eTargetElement.firstChild ) )		// Only one "=".
+	{
+		// Set innerHTML = '' to avoid memory leak.
+		if ( oChild.contentWindow )
+			oChild.contentWindow.document.body.innerHTML = '' ;
+		eTargetElement.removeChild( oChild ) ;
+	}
+	if ( this.Mode == FCK_EDITMODE_WYSIWYG )
+	{
+		// Create the editing area IFRAME.
+		var oIFrame = this.IFrame = oTargetDocument.createElement( 'iframe' ) ;
+		// Firefox will render the tables inside the body in Quirks mode if the
+		// source of the iframe is set to javascript. see #515
+		if ( !FCKBrowserInfo.IsGecko )
+			oIFrame.src = 'javascript:void(0)' ;
+		oIFrame.frameBorder = 0 ;
+		oIFrame.width = oIFrame.height = '100%' ;
+		// Append the new IFRAME to the target.
+		eTargetElement.appendChild( oIFrame ) ;
+		// IE has a bug with the <base> tag... it must have a </base> closer,
+		// otherwise the all successive tags will be set as children nodes of the <base>.
+		if ( FCKBrowserInfo.IsIE )
+			html = html.replace( /(<base[^>]*?)\s*\/?>(?!\s*<\/base>)/gi, '$1></base>' ) ;
+		else if ( !secondCall )
+		{
+			// Gecko moves some tags out of the body to the head, so we must use
+			// innerHTML to set the body contents (SF BUG 1526154).
+			// Extract the BODY contents from the html.
+			var oMatchBefore = html.match( FCKRegexLib.BeforeBody ) ;
+			var oMatchAfter = html.match( FCKRegexLib.AfterBody ) ;
+			if ( oMatchBefore && oMatchAfter )
+			{
+				var sBody = html.substr( oMatchBefore[1].length,
+					       html.length - oMatchBefore[1].length - oMatchAfter[1].length ) ;	// This is the BODY tag contents.
+				html =
+					oMatchBefore[1] +			// This is the HTML until the <body...> tag, inclusive.
+					'&nbsp;' +
+					oMatchAfter[1] ;			// This is the HTML from the </body> tag, inclusive.
+				// If nothing in the body, place a BOGUS tag so the cursor will appear.
+				if ( FCKBrowserInfo.IsGecko && ( sBody.length == 0 || FCKRegexLib.EmptyParagraph.test( sBody ) ) )
+					sBody = '<br type="_moz">' ;
+				this._BodyHTML = sBody ;
+			}
+			else
+				this._BodyHTML = html ;			// Invalid HTML input.
+		}
+		// Get the window and document objects used to interact with the newly created IFRAME.
+		this.Window = oIFrame.contentWindow ;
+		// IE: Avoid JavaScript errors thrown by the editing are source (like tags events).
+		// TODO: This error handler is not being fired.
+		// this.Window.onerror = function() { alert( 'Error!' ) ; return true ; }
+		var oDoc = this.Document = this.Window.document ;
+		oDoc.open() ;
+		oDoc.write( html ) ;
+		oDoc.close() ;
+		// Firefox 1.0.x is buggy... ohh yes... so let's do it two times and it
+		// will magically work.
+		if ( FCKBrowserInfo.IsGecko10 && !secondCall )
+		{
+			this.Start( html, true ) ;
+			return ;
+		}
+		this.Window._FCKEditingArea = this ;
+		// FF 1.0.x is buggy... we must wait a lot to enable editing because
+		// sometimes the content simply disappears, for example when pasting
+		// "bla1!<img src='some_url'>!bla2" in the source and then switching
+		// back to design.
+		if ( FCKBrowserInfo.IsGecko10 )
+			this.Window.setTimeout( FCKEditingArea_CompleteStart, 500 ) ;
+		else
+			FCKEditingArea_CompleteStart.call( this.Window ) ;
+	}
+	else
+	{
+		var eTextarea = this.Textarea = oTargetDocument.createElement( 'textarea' ) ;
+		eTextarea.className = 'SourceField' ;
+		eTextarea.dir = 'ltr' ;
+		FCKDomTools.SetElementStyles( eTextarea,
+			{
+				width	: '100%',
+				height	: '100%',
+				border	: 'none',
+				resize	: 'none',
+				outline	: 'none'
+			} ) ;
+		eTargetElement.appendChild( eTextarea ) ;
+		eTextarea.value = html  ;
+		// Fire the "OnLoad" event.
+		FCKTools.RunFunction( this.OnLoad ) ;
+	}
+}
+// "this" here is FCKEditingArea.Window
+function FCKEditingArea_CompleteStart()
+{
+	// On Firefox, the DOM takes a little to become available. So we must wait for it in a loop.
+	if ( !this.document.body )
+	{
+		this.setTimeout( FCKEditingArea_CompleteStart, 50 ) ;
+		return ;
+	}
+	var oEditorArea = this._FCKEditingArea ;
+	oEditorArea.MakeEditable() ;
+	// Fire the "OnLoad" event.
+	FCKTools.RunFunction( oEditorArea.OnLoad ) ;
+}
+FCKEditingArea.prototype.MakeEditable = function()
+{
+	var oDoc = this.Document ;
+	if ( FCKBrowserInfo.IsIE )
+	{
+		// Kludge for #141 and #523
+		oDoc.body.disabled = true ;
+		oDoc.body.contentEditable = true ;
+		oDoc.body.removeAttribute( "disabled" ) ;
+		/* The following commands don't throw errors, but have no effect.
+		oDoc.execCommand( 'AutoDetect', false, false ) ;
+		oDoc.execCommand( 'KeepSelection', false, true ) ;
+		*/
+	}
+	else
+	{
+		try
+		{
+			// Disable Firefox 2 Spell Checker.
+			oDoc.body.spellcheck = ( this.FFSpellChecker !== false ) ;
+			if ( this._BodyHTML )
+			{
+				oDoc.body.innerHTML = this._BodyHTML ;
+				this._BodyHTML = null ;
+			}
+			oDoc.designMode = 'on' ;
+			// Tell Gecko to use or not the <SPAN> tag for the bold, italic and underline.
+			try
+			{
+				oDoc.execCommand( 'styleWithCSS', false, FCKConfig.GeckoUseSPAN ) ;
+			}
+			catch (e)
+			{
+				// As evidenced here, useCSS is deprecated in favor of styleWithCSS:
+				// http://www.mozilla.org/editor/midas-spec.html
+				oDoc.execCommand( 'useCSS', false, !FCKConfig.GeckoUseSPAN ) ;
+			}
+			// Analyzing Firefox 1.5 source code, it seams that there is support for a
+			// "insertBrOnReturn" command. Applying it gives no error, but it doesn't
+			// gives the same behavior that you have with IE. It works only if you are
+			// already inside a paragraph and it doesn't render correctly in the first enter.
+			// oDoc.execCommand( 'insertBrOnReturn', false, false ) ;
+			// Tell Gecko (Firefox 1.5+) to enable or not live resizing of objects (by Alfonso Martinez)
+			oDoc.execCommand( 'enableObjectResizing', false, !FCKConfig.DisableObjectResizing ) ;
+			// Disable the standard table editing features of Firefox.
+			oDoc.execCommand( 'enableInlineTableEditing', false, !FCKConfig.DisableFFTableHandles ) ;
+		}
+		catch (e)
+		{
+			// In Firefox if the iframe is initially hidden it can't be set to designMode and it raises an exception
+			// So we set up a DOM Mutation event Listener on the HTML, as it will raise several events when the document is  visible again
+			FCKTools.AddEventListener( this.Window.frameElement, 'DOMAttrModified', FCKEditingArea_Document_AttributeNodeModified ) ;
+		}
+	}
+}
+// This function processes the notifications of the DOM Mutation event on the document
+// We use it to know that the document will be ready to be editable again (or we hope so)
+function FCKEditingArea_Document_AttributeNodeModified( evt )
+{
+	var editingArea = evt.currentTarget.contentWindow._FCKEditingArea ;
+	// We want to run our function after the events no longer fire, so we can know that it's a stable situation
+	if ( editingArea._timer )
+		window.clearTimeout( editingArea._timer ) ;
+	editingArea._timer = FCKTools.SetTimeout( FCKEditingArea_MakeEditableByMutation, 1000, editingArea ) ;
+}
+// This function ideally should be called after the document is visible, it does clean up of the
+// mutation tracking and tries again to make the area editable.
+function FCKEditingArea_MakeEditableByMutation()
+{
+	// Clean up
+	delete this._timer ;
+	// Now we don't want to keep on getting this event
+	FCKTools.RemoveEventListener( this.Window.frameElement, 'DOMAttrModified', FCKEditingArea_Document_AttributeNodeModified ) ;
+	// Let's try now to set the editing area editable
+	// If it fails it will set up the Mutation Listener again automatically
+	this.MakeEditable() ;
+}
+FCKEditingArea.prototype.Focus = function()
+{
+	try
+	{
+		if ( this.Mode == FCK_EDITMODE_WYSIWYG )
+		{
+			// The following check is important to avoid IE entering in a focus loop. Ref:
+			// http://sourceforge.net/tracker/index.php?func=detail&aid=1567060&group_id=75348&atid=543653
+			if ( FCKBrowserInfo.IsIE && this.Document.hasFocus() )
+				this._EnsureFocusIE() ;
+			if ( FCKBrowserInfo.IsSafari )
+				this.IFrame.focus() ;
+			else
+			{
+				this.Window.focus() ;
+				// In IE it can happen that the document is in theory focused but the active element is outside it
+				if ( FCKBrowserInfo.IsIE )
+					this._EnsureFocusIE() ;
+			}
+		}
+		else
+		{
+			var oDoc = FCKTools.GetElementDocument( this.Textarea ) ;
+			if ( (!oDoc.hasFocus || oDoc.hasFocus() ) && oDoc.activeElement == this.Textarea )
+				return ;
+			this.Textarea.focus() ;
+		}
+	}
+	catch(e) {}
+}
+FCKEditingArea.prototype._EnsureFocusIE = function()
+{
+	// In IE it can happen that the document is in theory focused but the active element is outside it
+	this.Document.body.setActive() ;
+	// Kludge for #141... yet more code to workaround IE bugs
+	var range = this.Document.selection.createRange() ;
+	// Only apply the fix when in a block and the block is empty.
+	var parentNode = range.parentElement() ;
+	if ( ! ( parentNode.childNodes.length == 0 && (
+					FCKListsLib.BlockElements[parentNode.nodeName.toLowerCase()] ||
+					FCKListsLib.NonEmptyBlockElements[parentNode.nodeName.toLowerCase()] ) ) )
+		return ;
+	var oldLength = range.text.length ;
+	range.moveEnd( "character", 1 ) ;
+	range.select() ;
+	if ( range.text.length > oldLength )
+	{
+		range.moveEnd( "character", -1 ) ;
+		range.select() ;
+	}
+}
+function FCKEditingArea_Cleanup()
+{
+	if ( this.Document )
+		this.Document.body.innerHTML = "" ;
+	this.TargetElement = null ;
+	this.IFrame = null ;
+	this.Document = null ;
+	this.Textarea = null ;
+	if ( this.Window )
+	{
+		this.Window._FCKEditingArea = null ;
+		this.Window = null ;
+	}
+}

data/public/javascripts/fckeditor/editor/_source/classes/fckelementpath.js ADDED Viewed

@@ -0,0 +1,70 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Manages the DOM ascensors element list of a specific DOM node
+ * (limited to body, inclusive).
+ */
+var FCKElementPath = function( lastNode )
+{
+	var eBlock = null ;
+	var eBlockLimit = null ;
+	var aElements = new Array() ;
+	var e = lastNode ;
+	while ( e )
+	{
+		if ( e.nodeType == 1 )
+		{
+			if ( !this.LastElement )
+				this.LastElement = e ;
+			var sElementName = e.nodeName.toLowerCase() ;
+			if ( !eBlockLimit )
+			{
+				if ( !eBlock && FCKListsLib.PathBlockElements[ sElementName ] != null )
+					eBlock = e ;
+				if ( FCKListsLib.PathBlockLimitElements[ sElementName ] != null )
+				{
+					// DIV is considered the Block, if no block is available (#525).
+					if ( !eBlock && sElementName == 'div' )
+						eBlock = e ;
+					else
+						eBlockLimit = e ;
+				}
+			}
+			aElements.push( e ) ;
+			if ( sElementName == 'body' )
+				break ;
+		}
+		e = e.parentNode ;
+	}
+	this.Block = eBlock ;
+	this.BlockLimit = eBlockLimit ;
+	this.Elements = aElements ;
+}

data/public/javascripts/fckeditor/editor/_source/classes/fckenterkey.js ADDED Viewed

@@ -0,0 +1,629 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Controls the [Enter] keystroke behavior in a document.
+ */
+/*
+ *	Constructor.
+ *		@targetDocument : the target document.
+ *		@enterMode : the behavior for the <Enter> keystroke.
+ *			May be "p", "div", "br". Default is "p".
+ *		@shiftEnterMode : the behavior for the <Shift>+<Enter> keystroke.
+ *			May be "p", "div", "br". Defaults to "br".
+ */
+var FCKEnterKey = function( targetWindow, enterMode, shiftEnterMode, tabSpaces )
+{
+	this.Window			= targetWindow ;
+	this.EnterMode		= enterMode || 'p' ;
+	this.ShiftEnterMode	= shiftEnterMode || 'br' ;
+	// Setup the Keystroke Handler.
+	var oKeystrokeHandler = new FCKKeystrokeHandler( false ) ;
+	oKeystrokeHandler._EnterKey = this ;
+	oKeystrokeHandler.OnKeystroke = FCKEnterKey_OnKeystroke ;
+	oKeystrokeHandler.SetKeystrokes( [
+		[ 13		, 'Enter' ],
+		[ SHIFT + 13, 'ShiftEnter' ],
+		[ 9 		, 'Tab' ],
+		[ 8			, 'Backspace' ],
+		[ CTRL + 8		, 'CtrlBackspace' ],
+		[ 46		, 'Delete' ]
+	] ) ;
+	if ( tabSpaces > 0 )
+	{
+		this.TabText = '' ;
+		while ( tabSpaces-- > 0 )
+			this.TabText += '\xa0' ;
+	}
+	oKeystrokeHandler.AttachToElement( targetWindow.document ) ;
+}
+function FCKEnterKey_OnKeystroke(  keyCombination, keystrokeValue )
+{
+	var oEnterKey = this._EnterKey ;
+	try
+	{
+		switch ( keystrokeValue )
+		{
+			case 'Enter' :
+				return oEnterKey.DoEnter() ;
+				break ;
+			case 'ShiftEnter' :
+				return oEnterKey.DoShiftEnter() ;
+				break ;
+			case 'Backspace' :
+				return oEnterKey.DoBackspace() ;
+				break ;
+			case 'Delete' :
+				return oEnterKey.DoDelete() ;
+				break ;
+			case 'Tab' :
+				return oEnterKey.DoTab() ;
+				break ;
+			case 'CtrlBackspace' :
+				return oEnterKey.DoCtrlBackspace() ;
+				break ;
+		}
+	}
+	catch (e)
+	{
+		// If for any reason we are not able to handle it, go
+		// ahead with the browser default behavior.
+	}
+	return false ;
+}
+/*
+ * Executes the <Enter> key behavior.
+ */
+FCKEnterKey.prototype.DoEnter = function( mode, hasShift )
+{
+	// Save an undo snapshot before doing anything
+	FCKUndo.SaveUndoStep() ;
+	this._HasShift = ( hasShift === true ) ;
+	var parentElement = FCKSelection.GetParentElement() ;
+	var parentPath = new FCKElementPath( parentElement ) ;
+	var sMode = mode || this.EnterMode ;
+	if ( sMode == 'br' || parentPath.Block && parentPath.Block.tagName.toLowerCase() == 'pre' )
+		return this._ExecuteEnterBr() ;
+	else
+		return this._ExecuteEnterBlock( sMode ) ;
+}
+/*
+ * Executes the <Shift>+<Enter> key behavior.
+ */
+FCKEnterKey.prototype.DoShiftEnter = function()
+{
+	return this.DoEnter( this.ShiftEnterMode, true ) ;
+}
+/*
+ * Executes the <Backspace> key behavior.
+ */
+FCKEnterKey.prototype.DoBackspace = function()
+{
+	var bCustom = false ;
+	// Get the current selection.
+	var oRange = new FCKDomRange( this.Window ) ;
+	oRange.MoveToSelection() ;
+	// Kludge for #247
+	if ( FCKBrowserInfo.IsIE && this._CheckIsAllContentsIncluded( oRange, this.Window.document.body ) )
+	{
+		this._FixIESelectAllBug( oRange ) ;
+		return true ;
+	}
+	var isCollapsed = oRange.CheckIsCollapsed() ;
+	if ( !isCollapsed )
+	{
+		// Bug #327, Backspace with an img selection would activate the default action in IE.
+		// Let's override that with our logic here.
+		if ( FCKBrowserInfo.IsIE && this.Window.document.selection.type.toLowerCase() == "control" )
+		{
+			var controls = this.Window.document.selection.createRange() ;
+			for ( var i = controls.length - 1 ; i >= 0 ; i-- )
+			{
+				var el = controls.item( i ) ;
+				el.parentNode.removeChild( el ) ;
+			}
+			return true ;
+		}
+		return false ;
+	}
+	var oStartBlock = oRange.StartBlock ;
+	var oEndBlock = oRange.EndBlock ;
+	// The selection boundaries must be in the same "block limit" element
+	if ( oRange.StartBlockLimit == oRange.EndBlockLimit && oStartBlock && oEndBlock )
+	{
+		if ( !isCollapsed )
+		{
+			var bEndOfBlock = oRange.CheckEndOfBlock() ;
+			oRange.DeleteContents() ;
+			if ( oStartBlock != oEndBlock )
+			{
+				oRange.SetStart(oEndBlock,1) ;
+				oRange.SetEnd(oEndBlock,1) ;
+//				if ( bEndOfBlock )
+//					oEndBlock.parentNode.removeChild( oEndBlock ) ;
+			}
+			oRange.Select() ;
+			bCustom = ( oStartBlock == oEndBlock ) ;
+		}
+		if ( oRange.CheckStartOfBlock() )
+		{
+			var oCurrentBlock = oRange.StartBlock ;
+			var ePrevious = FCKDomTools.GetPreviousSourceElement( oCurrentBlock, true, [ 'BODY', oRange.StartBlockLimit.nodeName ], ['UL','OL'] ) ;
+			bCustom = this._ExecuteBackspace( oRange, ePrevious, oCurrentBlock ) ;
+		}
+		else if ( FCKBrowserInfo.IsGeckoLike )
+		{
+			// Firefox and Opera (#1095) loose the selection when executing
+			// CheckStartOfBlock, so we must reselect.
+			oRange.Select() ;
+		}
+	}
+	oRange.Release() ;
+	return bCustom ;
+}
+FCKEnterKey.prototype.DoCtrlBackspace = function()
+{
+	FCKUndo.SaveUndoStep() ;
+	var oRange = new FCKDomRange( this.Window ) ;
+	oRange.MoveToSelection() ;
+	if ( FCKBrowserInfo.IsIE && this._CheckIsAllContentsIncluded( oRange, this.Window.document.body ) )
+	{
+		this._FixIESelectAllBug( oRange ) ;
+		return true ;
+	}
+	return false ;
+}
+FCKEnterKey.prototype._ExecuteBackspace = function( range, previous, currentBlock )
+{
+	var bCustom = false ;
+	// We could be in a nested LI.
+	if ( !previous && currentBlock && currentBlock.nodeName.IEquals( 'LI' ) && currentBlock.parentNode.parentNode.nodeName.IEquals( 'LI' ) )
+	{
+		this._OutdentWithSelection( currentBlock, range ) ;
+		return true ;
+	}
+	if ( previous && previous.nodeName.IEquals( 'LI' ) )
+	{
+		var oNestedList = FCKDomTools.GetLastChild( previous, ['UL','OL'] ) ;
+		while ( oNestedList )
+		{
+			previous = FCKDomTools.GetLastChild( oNestedList, 'LI' ) ;
+			oNestedList = FCKDomTools.GetLastChild( previous, ['UL','OL'] ) ;
+		}
+	}
+	if ( previous && currentBlock )
+	{
+		// If we are in a LI, and the previous block is not an LI, we must outdent it.
+		if ( currentBlock.nodeName.IEquals( 'LI' ) && !previous.nodeName.IEquals( 'LI' ) )
+		{
+			this._OutdentWithSelection( currentBlock, range ) ;
+			return true ;
+		}
+		// Take a reference to the parent for post processing cleanup.
+		var oCurrentParent = currentBlock.parentNode ;
+		var sPreviousName = previous.nodeName.toLowerCase() ;
+		if ( FCKListsLib.EmptyElements[ sPreviousName ] != null || sPreviousName == 'table' )
+		{
+			FCKDomTools.RemoveNode( previous ) ;
+			bCustom = true ;
+		}
+		else
+		{
+			// Remove the current block.
+			FCKDomTools.RemoveNode( currentBlock ) ;
+			// Remove any empty tag left by the block removal.
+			while ( oCurrentParent.innerHTML.Trim().length == 0 )
+			{
+				var oParent = oCurrentParent.parentNode ;
+				oParent.removeChild( oCurrentParent ) ;
+				oCurrentParent = oParent ;
+			}
+			// Cleanup the previous and the current elements.
+			FCKDomTools.LTrimNode( currentBlock ) ;
+			FCKDomTools.RTrimNode( previous ) ;
+			// Append a space to the previous.
+			// Maybe it is not always desirable...
+			// previous.appendChild( this.Window.document.createTextNode( ' ' ) ) ;
+			// Set the range to the end of the previous element and bookmark it.
+			range.SetStart( previous, 2, true ) ;
+			range.Collapse( true ) ;
+			var oBookmark = range.CreateBookmark() ;
+			// Move the contents of the block to the previous element and delete it.
+			// But for some block types (e.g. table), moving the children to the previous block makes no sense.
+			// So a check is needed. (See #1081)
+			if ( ! currentBlock.tagName.IEquals( [ 'TABLE' ] ) )
+				FCKDomTools.MoveChildren( currentBlock, previous ) ;
+			// Place the selection at the bookmark.
+			range.MoveToBookmark( oBookmark ) ;
+			range.Select() ;
+			bCustom = true ;
+		}
+	}
+	return bCustom ;
+}
+/*
+ * Executes the <Delete> key behavior.
+ */
+FCKEnterKey.prototype.DoDelete = function()
+{
+	// Save an undo snapshot before doing anything
+	// This is to conform with the behavior seen in MS Word
+	FCKUndo.SaveUndoStep() ;
+	// The <Delete> has the same effect as the <Backspace>, so we have the same
+	// results if we just move to the next block and apply the same <Backspace> logic.
+	var bCustom = false ;
+	// Get the current selection.
+	var oRange = new FCKDomRange( this.Window ) ;
+	oRange.MoveToSelection() ;
+	// Kludge for #247
+	if ( FCKBrowserInfo.IsIE && this._CheckIsAllContentsIncluded( oRange, this.Window.document.body ) )
+	{
+		this._FixIESelectAllBug( oRange ) ;
+		return true ;
+	}
+	// There is just one special case for collapsed selections at the end of a block.
+	if ( oRange.CheckIsCollapsed() && oRange.CheckEndOfBlock( FCKBrowserInfo.IsGeckoLike ) )
+	{
+		var oCurrentBlock = oRange.StartBlock ;
+		var eCurrentCell = FCKTools.GetElementAscensor( oCurrentBlock, 'td' );
+		var eNext = FCKDomTools.GetNextSourceElement( oCurrentBlock, true, [ oRange.StartBlockLimit.nodeName ],
+				['UL','OL','TR'] ) ;
+		// Bug #1323 : if we're in a table cell, and the next node belongs to a different cell, then don't
+		// delete anything.
+		if ( eCurrentCell )
+		{
+			var eNextCell = FCKTools.GetElementAscensor( eNext, 'td' );
+			if ( eNextCell != eCurrentCell )
+				return true ;
+		}
+		bCustom = this._ExecuteBackspace( oRange, oCurrentBlock, eNext ) ;
+	}
+	oRange.Release() ;
+	return bCustom ;
+}
+/*
+ * Executes the <Tab> key behavior.
+ */
+FCKEnterKey.prototype.DoTab = function()
+{
+	var oRange = new FCKDomRange( this.Window );
+	oRange.MoveToSelection() ;
+	// If the user pressed <tab> inside a table, we should give him the default behavior ( moving between cells )
+	// instead of giving him more non-breaking spaces. (Bug #973)
+	var node = oRange._Range.startContainer ;
+	while ( node )
+	{
+		if ( node.nodeType == 1 )
+		{
+			var tagName = node.tagName.toLowerCase() ;
+			if ( tagName == "tr" || tagName == "td" || tagName == "th" || tagName == "tbody" || tagName == "table" )
+				return false ;
+			else
+				break ;
+		}
+		node = node.parentNode ;
+	}
+	if ( this.TabText )
+	{
+		oRange.DeleteContents() ;
+		oRange.InsertNode( this.Window.document.createTextNode( this.TabText ) ) ;
+		oRange.Collapse( false ) ;
+		oRange.Select() ;
+	}
+	return true ;
+}
+FCKEnterKey.prototype._ExecuteEnterBlock = function( blockTag, range )
+{
+	// Get the current selection.
+	var oRange = range || new FCKDomRange( this.Window ) ;
+	var oSplitInfo = oRange.SplitBlock() ;
+	if ( oSplitInfo )
+	{
+		// Get the current blocks.
+		var ePreviousBlock	= oSplitInfo.PreviousBlock ;
+		var eNextBlock		= oSplitInfo.NextBlock ;
+		var bIsStartOfBlock	= oSplitInfo.WasStartOfBlock ;
+		var bIsEndOfBlock	= oSplitInfo.WasEndOfBlock ;
+		// If we have both the previous and next blocks, it means that the
+		// boundaries were on separated blocks, or none of them where on the
+		// block limits (start/end).
+		if ( !oSplitInfo.WasStartOfBlock && !oSplitInfo.WasEndOfBlock )
+		{
+			// Move the selection to the end block.
+			if ( eNextBlock )
+				oRange.MoveToElementEditStart( eNextBlock ) ;
+		}
+		else
+		{
+			if ( bIsStartOfBlock && bIsEndOfBlock && ePreviousBlock.tagName.toUpperCase() == 'LI' )
+			{
+				oRange.MoveToElementStart( ePreviousBlock ) ;
+				this._OutdentWithSelection( ePreviousBlock, oRange ) ;
+				oRange.Release() ;
+				return true ;
+			}
+			var eNewBlock ;
+			if ( ePreviousBlock )
+			{
+				var sPreviousBlockTag = ePreviousBlock.tagName.toUpperCase() ;
+				// If is a header tag, or we are in a Shift+Enter (#77),
+				// create a new block element.
+				if ( this._HasShift || (/^H[1-6]$/).test( sPreviousBlockTag ) )
+					eNewBlock = this.Window.document.createElement( blockTag ) ;
+				else
+				{
+					// Otherwise, duplicate the previous block.
+					eNewBlock = FCKDomTools.CloneElement( ePreviousBlock ) ;
+					this._RecreateEndingTree( ePreviousBlock, eNewBlock ) ;
+				}
+			}
+			else if ( eNextBlock )
+			{
+				eNewBlock = FCKDomTools.CloneElement( eNextBlock ) ;
+			}
+			else
+				eNewBlock = this.Window.document.createElement( blockTag ) ;
+			if ( FCKBrowserInfo.IsGeckoLike )
+				FCKTools.AppendBogusBr( eNewBlock ) ;
+			oRange.InsertNode( eNewBlock ) ;
+			// This is tricky, but to make the new block visible correctly
+			// we must select it.
+			if ( FCKBrowserInfo.IsIE )
+			{
+				// Move the selection to the new block.
+				oRange.MoveToNodeContents( eNewBlock ) ;
+				oRange.Select() ;
+			}
+			oRange.MoveToElementEditStart( bIsStartOfBlock && !bIsEndOfBlock ? eNextBlock : eNewBlock ) ;
+			if ( FCKBrowserInfo.IsGeckoLike )
+				eNewBlock.scrollIntoView( false ) ;
+		}
+		oRange.Select() ;
+	}
+	// Release the resources used by the range.
+	oRange.Release() ;
+	return true ;
+}
+FCKEnterKey.prototype._ExecuteEnterBr = function( blockTag )
+{
+	// Get the current selection.
+	var oRange = new FCKDomRange( this.Window ) ;
+	oRange.MoveToSelection() ;
+	// The selection boundaries must be in the same "block limit" element.
+	if ( oRange.StartBlockLimit == oRange.EndBlockLimit )
+	{
+		oRange.DeleteContents() ;
+		// Get the new selection (it is collapsed at this point).
+		oRange.MoveToSelection() ;
+		var bIsStartOfBlock	= oRange.CheckStartOfBlock() ;
+		var bIsEndOfBlock	= oRange.CheckEndOfBlock() ;
+		var sStartBlockTag = oRange.StartBlock ? oRange.StartBlock.tagName.toUpperCase() : '' ;
+		var bHasShift = this._HasShift ;
+		if ( !bHasShift && sStartBlockTag == 'LI' )
+			return this._ExecuteEnterBlock( null, oRange ) ;
+		// If we are at the end of a header block.
+		if ( !bHasShift && bIsEndOfBlock && (/^H[1-6]$/).test( sStartBlockTag ) )
+		{
+			// Insert a BR after the current paragraph.
+			FCKDomTools.InsertAfterNode( oRange.StartBlock, this.Window.document.createElement( 'br' ) ) ;
+			// The space is required by Gecko only to make the cursor blink.
+			if ( FCKBrowserInfo.IsGecko )
+				FCKDomTools.InsertAfterNode( oRange.StartBlock, this.Window.document.createTextNode( '' ) ) ;
+			// IE and Gecko have different behaviors regarding the position.
+			oRange.SetStart( oRange.StartBlock.nextSibling, FCKBrowserInfo.IsIE ? 3 : 1 ) ;
+		}
+		else
+		{
+			var eLineBreak = null ;
+			if ( sStartBlockTag.IEquals( 'pre' ) )
+				eLineBreak = this.Window.document.createTextNode( FCKBrowserInfo.IsIE ? '\r' : '\n' ) ;
+			else
+				eLineBreak = this.Window.document.createElement( 'br' ) ;
+			oRange.InsertNode( eLineBreak ) ;
+			// The space is required by Gecko only to make the cursor blink.
+			if ( FCKBrowserInfo.IsGecko )
+				FCKDomTools.InsertAfterNode( eLineBreak, this.Window.document.createTextNode( '' ) ) ;
+			// If we are at the end of a block, we must be sure the bogus node is available in that block.
+			if ( bIsEndOfBlock && FCKBrowserInfo.IsGeckoLike )
+				FCKTools.AppendBogusBr( eLineBreak.parentNode ) ;
+			if ( FCKBrowserInfo.IsIE )
+				oRange.SetStart( eLineBreak, 4 ) ;
+			else
+				oRange.SetStart( eLineBreak.nextSibling, 1 ) ;
+			if ( ! FCKBrowserInfo.IsIE )
+			{
+				var dummy = null ;
+				if ( FCKBrowserInfo.IsOpera )
+					dummy = this.Window.document.createElement( 'span' ) ;
+				else
+					dummy = this.Window.document.createElement( 'br' ) ;
+				eLineBreak.parentNode.insertBefore( dummy, eLineBreak.nextSibling ) ;
+				dummy.scrollIntoView( false ) ;
+				dummy.parentNode.removeChild( dummy ) ;
+			}
+		}
+		// This collapse guarantees the cursor will be blinking.
+		oRange.Collapse( true ) ;
+		oRange.Select() ;
+	}
+	// Release the resources used by the range.
+	oRange.Release() ;
+	return true ;
+}
+// Recreate the elements tree at the end of the source block, at the beginning
+// of the target block. Eg.:
+//	If source = <p><u>Some</u> sample <b><i>text</i></b></p> then target = <p><b><i></i></b></p>
+//	If source = <p><u>Some</u> sample text</p> then target = <p></p>
+FCKEnterKey.prototype._RecreateEndingTree = function( source, target )
+{
+	while ( ( source = source.lastChild ) && source.nodeType == 1 && FCKListsLib.InlineChildReqElements[ source.nodeName.toLowerCase() ] != null )
+		target = target.insertBefore( FCKDomTools.CloneElement( source ), target.firstChild ) ;
+}
+// Outdents a LI, maintaining the selection defined on a range.
+FCKEnterKey.prototype._OutdentWithSelection = function( li, range )
+{
+	var oBookmark = range.CreateBookmark() ;
+	FCKListHandler.OutdentListItem( li ) ;
+	range.MoveToBookmark( oBookmark ) ;
+	range.Select() ;
+}
+// Is all the contents under a node included by a range?
+FCKEnterKey.prototype._CheckIsAllContentsIncluded = function( range, node )
+{
+	var startOk = false ;
+	var endOk = false ;
+	/*
+	FCKDebug.Output( 'sc='+range.StartContainer.nodeName+
+			',so='+range._Range.startOffset+
+			',ec='+range.EndContainer.nodeName+
+			',eo='+range._Range.endOffset ) ;
+	*/
+	if ( range.StartContainer == node || range.StartContainer == node.firstChild )
+		startOk = ( range._Range.startOffset == 0 ) ;
+	if ( range.EndContainer == node || range.EndContainer == node.lastChild )
+	{
+		var nodeLength = range.EndContainer.nodeType == 3 ? range.EndContainer.length : range.EndContainer.childNodes.length ;
+		endOk = ( range._Range.endOffset == nodeLength ) ;
+	}
+	return startOk && endOk ;
+}
+// Kludge for #247
+FCKEnterKey.prototype._FixIESelectAllBug = function( range )
+{
+	var doc = this.Window.document ;
+	doc.body.innerHTML = '' ;
+	var editBlock ;
+	if ( FCKConfig.EnterMode.IEquals( ['div', 'p'] ) )
+	{
+		editBlock = doc.createElement( FCKConfig.EnterMode ) ;
+		doc.body.appendChild( editBlock ) ;
+	}
+	else
+		editBlock = doc.body ;
+	range.MoveToNodeContents( editBlock ) ;
+	range.Collapse( true ) ;
+	range.Select() ;
+	range.Release() ;
+}