RubyGems - adva - Versions diffs - 0.0.1 - Mend

adva 0.0.1

Files changed (1756) hide show

data/adva_fckeditor/app/assets/javascripts/adva_fckeditor/fckeditor/editor/_source/classes/fckdataprocessor.js ADDED

@@ -0,0 +1,119 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2009 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 ==
+ *
+ * The Data Processor is responsible for transforming the input and output data
+ * in the editor. For more info:
+ * http://dev.fckeditor.net/wiki/Components/DataProcessor
+ *
+ * The default implementation offers the base XHTML compatibility features of
+ * FCKeditor. Further Data Processors may be implemented for other purposes.
+ *
+ */
+var FCKDataProcessor = function()
+{}
+FCKDataProcessor.prototype =
+{
+	/*
+	 * Returns a string representing the HTML format of "data". The returned
+	 * value will be loaded in the editor.
+	 * The HTML must be from <html> to </html>, including <head>, <body> and
+	 * eventually the DOCTYPE.
+	 * Note: HTML comments may already be part of the data because of the
+	 * pre-processing made with ProtectedSource.
+	 *     @param {String} data The data to be converted in the
+	 *            DataProcessor specific format.
+	 */
+	ConvertToHtml : function( data )
+	{
+		// The default data processor must handle two different cases depending
+		// on the FullPage setting. Custom Data Processors will not be
+		// compatible with FullPage, much probably.
+		if ( FCKConfig.FullPage )
+		{
+			// Save the DOCTYPE.
+			FCK.DocTypeDeclaration = data.match( FCKRegexLib.DocTypeTag ) ;
+			// Check if the <body> tag is available.
+			if ( !FCKRegexLib.HasBodyTag.test( data ) )
+				data = '<body>' + data + '</body>' ;
+			// Check if the <html> tag is available.
+			if ( !FCKRegexLib.HtmlOpener.test( data ) )
+				data = '<html dir="' + FCKConfig.ContentLangDirection + '">' + data + '</html>' ;
+			// Check if the <head> tag is available.
+			if ( !FCKRegexLib.HeadOpener.test( data ) )
+				data = data.replace( FCKRegexLib.HtmlOpener, '$&<head><title></title></head>' ) ;
+			return data ;
+		}
+		else
+		{
+			var html =
+				FCKConfig.DocType +
+				'<html dir="' + FCKConfig.ContentLangDirection + '"' ;
+			// On IE, if you are using a DOCTYPE different of HTML 4 (like
+			// XHTML), you must force the vertical scroll to show, otherwise
+			// the horizontal one may appear when the page needs vertical scrolling.
+			// TODO : Check it with IE7 and make it IE6- if it is the case.
+			if ( FCKBrowserInfo.IsIE && FCKConfig.DocType.length > 0 && !FCKRegexLib.Html4DocType.test( FCKConfig.DocType ) )
+				html += ' style="overflow-y: scroll"' ;
+			html += '><head><title></title></head>' +
+				'<body' + FCKConfig.GetBodyAttributes() + '>' +
+				data +
+				'</body></html>' ;
+			return html ;
+		}
+	},
+	/*
+	 * Converts a DOM (sub-)tree to a string in the data format.
+	 *     @param {Object} rootNode The node that contains the DOM tree to be
+	 *            converted to the data format.
+	 *     @param {Boolean} excludeRoot Indicates that the root node must not
+	 *            be included in the conversion, only its children.
+	 *     @param {Boolean} format Indicates that the data must be formatted
+	 *            for human reading. Not all Data Processors may provide it.
+	 */
+	ConvertToDataFormat : function( rootNode, excludeRoot, ignoreIfEmptyParagraph, format )
+	{
+		var data = FCKXHtml.GetXHTML( rootNode, !excludeRoot, format ) ;
+		if ( ignoreIfEmptyParagraph && FCKRegexLib.EmptyOutParagraph.test( data ) )
+			return '' ;
+		return data ;
+	},
+	/*
+	 * Makes any necessary changes to a piece of HTML for insertion in the
+	 * editor selection position.
+	 *     @param {String} html The HTML to be fixed.
+	 */
+	FixHtml : function( html )
+	{
+		return html ;
+	}
+} ;

data/adva_fckeditor/app/assets/javascripts/adva_fckeditor/fckeditor/editor/_source/classes/fckdocumentfragment_gecko.js ADDED

@@ -0,0 +1,53 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2009 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 ==
+ *
+ * This is a generic Document Fragment object. It is not intended to provide
+ * the W3C implementation, but is a way to fix the missing of a real Document
+ * Fragment in IE (where document.createDocumentFragment() returns a normal
+ * document instead), giving a standard interface for it.
+ * (IE Implementation)
+ */
+var FCKDocumentFragment = function( parentDocument, baseDocFrag )
+{
+	this.RootNode = baseDocFrag || parentDocument.createDocumentFragment() ;
+}
+FCKDocumentFragment.prototype =
+{
+	// Append the contents of this Document Fragment to another element.
+	AppendTo : function( targetNode )
+	{
+		targetNode.appendChild( this.RootNode ) ;
+	},
+	AppendHtml : function( html )
+	{
+		var eTmpDiv = this.RootNode.ownerDocument.createElement( 'div' ) ;
+		eTmpDiv.innerHTML = html ;
+		FCKDomTools.MoveChildren( eTmpDiv, this.RootNode ) ;
+	},
+	InsertAfterNode : function( existingNode )
+	{
+		FCKDomTools.InsertAfterNode( existingNode, this.RootNode ) ;
+	}
+}

data/adva_fckeditor/app/assets/javascripts/adva_fckeditor/fckeditor/editor/_source/classes/fckdocumentfragment_ie.js ADDED

@@ -0,0 +1,58 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2009 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 ==
+ *
+ * This is a generic Document Fragment object. It is not intended to provide
+ * the W3C implementation, but is a way to fix the missing of a real Document
+ * Fragment in IE (where document.createDocumentFragment() returns a normal
+ * document instead), giving a standard interface for it.
+ * (IE Implementation)
+ */
+var FCKDocumentFragment = function( parentDocument )
+{
+	this._Document = parentDocument ;
+	this.RootNode = parentDocument.createElement( 'div' ) ;
+}
+// Append the contents of this Document Fragment to another node.
+FCKDocumentFragment.prototype =
+{
+	AppendTo : function( targetNode )
+	{
+		FCKDomTools.MoveChildren( this.RootNode, targetNode ) ;
+	},
+	AppendHtml : function( html )
+	{
+		var eTmpDiv = this._Document.createElement( 'div' ) ;
+		eTmpDiv.innerHTML = html ;
+		FCKDomTools.MoveChildren( eTmpDiv, this.RootNode ) ;
+	},
+	InsertAfterNode : function( existingNode )
+	{
+		var eRoot = this.RootNode ;
+		var eLast ;
+		while( ( eLast = eRoot.lastChild ) )
+			FCKDomTools.InsertAfterNode( existingNode, eRoot.removeChild( eLast ) ) ;
+	}
+} ;

data/adva_fckeditor/app/assets/javascripts/adva_fckeditor/fckeditor/editor/_source/classes/fckdomrange.js ADDED

@@ -0,0 +1,935 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2009 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 ==
+ *
+ * Class for working with a selection range, much like the W3C DOM Range, but
+ * it is not intended to be an implementation of the W3C interface.
+ */
+var FCKDomRange = function( sourceWindow )
+{
+	this.Window = sourceWindow ;
+	this._Cache = {} ;
+}
+FCKDomRange.prototype =
+{
+	_UpdateElementInfo : function()
+	{
+		var innerRange = this._Range ;
+		if ( !innerRange )
+			this.Release( true ) ;
+		else
+		{
+			// For text nodes, the node itself is the StartNode.
+			var eStart	= innerRange.startContainer ;
+			var oElementPath = new FCKElementPath( eStart ) ;
+			this.StartNode			= eStart.nodeType == 3 ? eStart : eStart.childNodes[ innerRange.startOffset ] ;
+			this.StartContainer		= eStart ;
+			this.StartBlock			= oElementPath.Block ;
+			this.StartBlockLimit	= oElementPath.BlockLimit ;
+			if ( innerRange.collapsed )
+			{
+				this.EndNode		= this.StartNode ;
+				this.EndContainer	= this.StartContainer ;
+				this.EndBlock		= this.StartBlock ;
+				this.EndBlockLimit	= this.StartBlockLimit ;
+			}
+			else
+			{
+				var eEnd	= innerRange.endContainer ;
+				if ( eStart != eEnd )
+					oElementPath = new FCKElementPath( eEnd ) ;
+				// The innerRange.endContainer[ innerRange.endOffset ] is not
+				// usually part of the range, but the marker for the range end. So,
+				// let's get the previous available node as the real end.
+				var eEndNode = eEnd ;
+				if ( innerRange.endOffset == 0 )
+				{
+					while ( eEndNode && !eEndNode.previousSibling )
+						eEndNode = eEndNode.parentNode ;
+					if ( eEndNode )
+						eEndNode = eEndNode.previousSibling ;
+				}
+				else if ( eEndNode.nodeType == 1 )
+					eEndNode = eEndNode.childNodes[ innerRange.endOffset - 1 ] ;
+				this.EndNode			= eEndNode ;
+				this.EndContainer		= eEnd ;
+				this.EndBlock			= oElementPath.Block ;
+				this.EndBlockLimit		= oElementPath.BlockLimit ;
+			}
+		}
+		this._Cache = {} ;
+	},
+	CreateRange : function()
+	{
+		return new FCKW3CRange( this.Window.document ) ;
+	},
+	DeleteContents : function()
+	{
+		if ( this._Range )
+		{
+			this._Range.deleteContents() ;
+			this._UpdateElementInfo() ;
+		}
+	},
+	ExtractContents : function()
+	{
+		if ( this._Range )
+		{
+			var docFrag = this._Range.extractContents() ;
+			this._UpdateElementInfo() ;
+			return docFrag ;
+		}
+		return null ;
+	},
+	CheckIsCollapsed : function()
+	{
+		if ( this._Range )
+			return this._Range.collapsed ;
+		return false ;
+	},
+	Collapse : function( toStart )
+	{
+		if ( this._Range )
+			this._Range.collapse( toStart ) ;
+		this._UpdateElementInfo() ;
+	},
+	Clone : function()
+	{
+		var oClone = FCKTools.CloneObject( this ) ;
+		if ( this._Range )
+			oClone._Range = this._Range.cloneRange() ;
+		return oClone ;
+	},
+	MoveToNodeContents : function( targetNode )
+	{
+		if ( !this._Range )
+			this._Range = this.CreateRange() ;
+		this._Range.selectNodeContents( targetNode ) ;
+		this._UpdateElementInfo() ;
+	},
+	MoveToElementStart : function( targetElement )
+	{
+		this.SetStart(targetElement,1) ;
+		this.SetEnd(targetElement,1) ;
+	},
+	// Moves to the first editing point inside a element. For example, in a
+	// element tree like "<p><b><i></i></b> Text</p>", the start editing point
+	// is "<p><b><i>^</i></b> Text</p>" (inside <i>).
+	MoveToElementEditStart : function( targetElement )
+	{
+		var editableElement ;
+		while ( targetElement && targetElement.nodeType == 1 )
+		{
+			if ( FCKDomTools.CheckIsEditable( targetElement ) )
+				editableElement = targetElement ;
+			else if ( editableElement )
+				break ;		// If we already found an editable element, stop the loop.
+			targetElement = targetElement.firstChild ;
+		}
+		if ( editableElement )
+			this.MoveToElementStart( editableElement ) ;
+	},
+	InsertNode : function( node )
+	{
+		if ( this._Range )
+			this._Range.insertNode( node ) ;
+	},
+	CheckIsEmpty : function()
+	{
+		if ( this.CheckIsCollapsed() )
+			return true ;
+		// Inserts the contents of the range in a div tag.
+		var eToolDiv = this.Window.document.createElement( 'div' ) ;
+		this._Range.cloneContents().AppendTo( eToolDiv ) ;
+		FCKDomTools.TrimNode( eToolDiv ) ;
+		return ( eToolDiv.innerHTML.length == 0 ) ;
+	},
+	/**
+	 * Checks if the start boundary of the current range is "visually" (like a
+	 * selection caret) at the beginning of the block. It means that some
+	 * things could be brefore the range, like spaces or empty inline elements,
+	 * but it would still be considered at the beginning of the block.
+	 */
+	CheckStartOfBlock : function()
+	{
+		var cache = this._Cache ;
+		var bIsStartOfBlock = cache.IsStartOfBlock ;
+		if ( bIsStartOfBlock != undefined )
+			return bIsStartOfBlock ;
+		// Take the block reference.
+		var block = this.StartBlock || this.StartBlockLimit ;
+		var container	= this._Range.startContainer ;
+		var offset		= this._Range.startOffset ;
+		var currentNode ;
+		if ( offset > 0 )
+		{
+			// First, check the start container. If it is a text node, get the
+			// substring of the node value before the range offset.
+			if ( container.nodeType == 3 )
+			{
+				var textValue = container.nodeValue.substr( 0, offset ).Trim() ;
+				// If we have some text left in the container, we are not at
+				// the end for the block.
+				if ( textValue.length != 0 )
+					return cache.IsStartOfBlock = false ;
+			}
+			else
+				currentNode = container.childNodes[ offset - 1 ] ;
+		}
+		// We'll not have a currentNode if the container was a text node, or
+		// the offset is zero.
+		if ( !currentNode )
+			currentNode = FCKDomTools.GetPreviousSourceNode( container, true, null, block ) ;
+		while ( currentNode )
+		{
+			switch ( currentNode.nodeType )
+			{
+				case 1 :
+					// It's not an inline element.
+					if ( !FCKListsLib.InlineChildReqElements[ currentNode.nodeName.toLowerCase() ] )
+						return cache.IsStartOfBlock = false ;
+					break ;
+				case 3 :
+					// It's a text node with real text.
+					if ( currentNode.nodeValue.Trim().length > 0 )
+						return cache.IsStartOfBlock = false ;
+			}
+			currentNode = FCKDomTools.GetPreviousSourceNode( currentNode, false, null, block ) ;
+		}
+		return cache.IsStartOfBlock = true ;
+	},
+	/**
+	 * Checks if the end boundary of the current range is "visually" (like a
+	 * selection caret) at the end of the block. It means that some things
+	 * could be after the range, like spaces, empty inline elements, or a
+	 * single <br>, but it would still be considered at the end of the block.
+	 */
+	CheckEndOfBlock : function( refreshSelection )
+	{
+		var isEndOfBlock = this._Cache.IsEndOfBlock ;
+		if ( isEndOfBlock != undefined )
+			return isEndOfBlock ;
+		// Take the block reference.
+		var block = this.EndBlock || this.EndBlockLimit ;
+		var container	= this._Range.endContainer ;
+		var offset			= this._Range.endOffset ;
+		var currentNode ;
+		// First, check the end container. If it is a text node, get the
+		// substring of the node value after the range offset.
+		if ( container.nodeType == 3 )
+		{
+			var textValue = container.nodeValue ;
+			if ( offset < textValue.length )
+			{
+				textValue = textValue.substr( offset ) ;
+				// If we have some text left in the container, we are not at
+				// the end for the block.
+				if ( textValue.Trim().length != 0 )
+					return this._Cache.IsEndOfBlock = false ;
+			}
+		}
+		else
+			currentNode = container.childNodes[ offset ] ;
+		// We'll not have a currentNode if the container was a text node, of
+		// the offset is out the container children limits (after it probably).
+		if ( !currentNode )
+			currentNode = FCKDomTools.GetNextSourceNode( container, true, null, block ) ;
+		var hadBr = false ;
+		while ( currentNode )
+		{
+			switch ( currentNode.nodeType )
+			{
+				case 1 :
+					var nodeName = currentNode.nodeName.toLowerCase() ;
+					// It's an inline element.
+					if ( FCKListsLib.InlineChildReqElements[ nodeName ] )
+						break ;
+					// It is the first <br> found.
+					if ( nodeName == 'br' && !hadBr )
+					{
+						hadBr = true ;
+						break ;
+					}
+					return this._Cache.IsEndOfBlock = false ;
+				case 3 :
+					// It's a text node with real text.
+					if ( currentNode.nodeValue.Trim().length > 0 )
+						return this._Cache.IsEndOfBlock = false ;
+			}
+			currentNode = FCKDomTools.GetNextSourceNode( currentNode, false, null, block ) ;
+		}
+		if ( refreshSelection )
+			this.Select() ;
+		return this._Cache.IsEndOfBlock = true ;
+	},
+	// This is an "intrusive" way to create a bookmark. It includes <span> tags
+	// in the range boundaries. The advantage of it is that it is possible to
+	// handle DOM mutations when moving back to the bookmark.
+	// Attention: the inclusion of nodes in the DOM is a design choice and
+	// should not be changed as there are other points in the code that may be
+	// using those nodes to perform operations. See GetBookmarkNode.
+	// For performance, includeNodes=true if intended to SelectBookmark.
+	CreateBookmark : function( includeNodes )
+	{
+		// Create the bookmark info (random IDs).
+		var oBookmark =
+		{
+			StartId	: (new Date()).valueOf() + Math.floor(Math.random()*1000) + 'S',
+			EndId	: (new Date()).valueOf() + Math.floor(Math.random()*1000) + 'E'
+		} ;
+		var oDoc = this.Window.document ;
+		var eStartSpan ;
+		var eEndSpan ;
+		var oClone ;
+		// For collapsed ranges, add just the start marker.
+		if ( !this.CheckIsCollapsed() )
+		{
+			eEndSpan = oDoc.createElement( 'span' ) ;
+			eEndSpan.style.display = 'none' ;
+			eEndSpan.id = oBookmark.EndId ;
+			eEndSpan.setAttribute( '_fck_bookmark', true ) ;
+			// For IE, it must have something inside, otherwise it may be
+			// removed during DOM operations.
+//			if ( FCKBrowserInfo.IsIE )
+				eEndSpan.innerHTML = '&nbsp;' ;
+			oClone = this.Clone() ;
+			oClone.Collapse( false ) ;
+			oClone.InsertNode( eEndSpan ) ;
+		}
+		eStartSpan = oDoc.createElement( 'span' ) ;
+		eStartSpan.style.display = 'none' ;
+		eStartSpan.id = oBookmark.StartId ;
+		eStartSpan.setAttribute( '_fck_bookmark', true ) ;
+		// For IE, it must have something inside, otherwise it may be removed
+		// during DOM operations.
+//		if ( FCKBrowserInfo.IsIE )
+			eStartSpan.innerHTML = '&nbsp;' ;
+		oClone = this.Clone() ;
+		oClone.Collapse( true ) ;
+		oClone.InsertNode( eStartSpan ) ;
+		if ( includeNodes )
+		{
+			oBookmark.StartNode = eStartSpan ;
+			oBookmark.EndNode = eEndSpan ;
+		}
+		// Update the range position.
+		if ( eEndSpan )
+		{
+			this.SetStart( eStartSpan, 4 ) ;
+			this.SetEnd( eEndSpan, 3 ) ;
+		}
+		else
+			this.MoveToPosition( eStartSpan, 4 ) ;
+		return oBookmark ;
+	},
+	// This one should be a part of a hypothetic "bookmark" object.
+	GetBookmarkNode : function( bookmark, start )
+	{
+		var doc = this.Window.document ;
+		if ( start )
+			return bookmark.StartNode || doc.getElementById( bookmark.StartId ) ;
+		else
+			return bookmark.EndNode || doc.getElementById( bookmark.EndId ) ;
+	},
+	MoveToBookmark : function( bookmark, preserveBookmark )
+	{
+		var eStartSpan	= this.GetBookmarkNode( bookmark, true ) ;
+		var eEndSpan	= this.GetBookmarkNode( bookmark, false ) ;
+		this.SetStart( eStartSpan, 3 ) ;
+		if ( !preserveBookmark )
+			FCKDomTools.RemoveNode( eStartSpan ) ;
+		// If collapsed, the end span will not be available.
+		if ( eEndSpan )
+		{
+			this.SetEnd( eEndSpan, 3 ) ;
+			if ( !preserveBookmark )
+				FCKDomTools.RemoveNode( eEndSpan ) ;
+		}
+		else
+			this.Collapse( true ) ;
+		this._UpdateElementInfo() ;
+	},
+	// Non-intrusive bookmark algorithm
+	CreateBookmark2 : function()
+	{
+		// If there is no range then get out of here.
+		// It happens on initial load in Safari #962 and if the editor it's hidden also in Firefox
+		if ( ! this._Range )
+			return { "Start" : 0, "End" : 0 } ;
+		// First, we record down the offset values
+		var bookmark =
+		{
+			"Start" : [ this._Range.startOffset ],
+			"End" : [ this._Range.endOffset ]
+		} ;
+		// Since we're treating the document tree as normalized, we need to backtrack the text lengths
+		// of previous text nodes into the offset value.
+		var curStart = this._Range.startContainer.previousSibling ;
+		var curEnd = this._Range.endContainer.previousSibling ;
+		// Also note that the node that we use for "address base" would change during backtracking.
+		var addrStart = this._Range.startContainer ;
+		var addrEnd = this._Range.endContainer ;
+		while ( curStart && curStart.nodeType == 3 && addrStart.nodeType == 3 )
+		{
+			bookmark.Start[0] += curStart.length ;
+			addrStart = curStart ;
+			curStart = curStart.previousSibling ;
+		}
+		while ( curEnd && curEnd.nodeType == 3 && addrEnd.nodeType == 3 )
+		{
+			bookmark.End[0] += curEnd.length ;
+			addrEnd = curEnd ;
+			curEnd = curEnd.previousSibling ;
+		}
+		// If the object pointed to by the startOffset and endOffset are text nodes, we need
+		// to backtrack and add in the text offset to the bookmark addresses.
+		if ( addrStart.nodeType == 1 && addrStart.childNodes[bookmark.Start[0]] && addrStart.childNodes[bookmark.Start[0]].nodeType == 3 )
+		{
+			var curNode = addrStart.childNodes[bookmark.Start[0]] ;
+			var offset = 0 ;
+			while ( curNode.previousSibling && curNode.previousSibling.nodeType == 3 )
+			{
+				curNode = curNode.previousSibling ;
+				offset += curNode.length ;
+			}
+			addrStart = curNode ;
+			bookmark.Start[0] = offset ;
+		}
+		if ( addrEnd.nodeType == 1 && addrEnd.childNodes[bookmark.End[0]] && addrEnd.childNodes[bookmark.End[0]].nodeType == 3 )
+		{
+			var curNode = addrEnd.childNodes[bookmark.End[0]] ;
+			var offset = 0 ;
+			while ( curNode.previousSibling && curNode.previousSibling.nodeType == 3 )
+			{
+				curNode = curNode.previousSibling ;
+				offset += curNode.length ;
+			}
+			addrEnd = curNode ;
+			bookmark.End[0] = offset ;
+		}
+		// Then, we record down the precise position of the container nodes
+		// by walking up the DOM tree and counting their childNode index
+		bookmark.Start = FCKDomTools.GetNodeAddress( addrStart, true ).concat( bookmark.Start ) ;
+		bookmark.End = FCKDomTools.GetNodeAddress( addrEnd, true ).concat( bookmark.End ) ;
+		return bookmark;
+	},
+	MoveToBookmark2 : function( bookmark )
+	{
+		// Reverse the childNode counting algorithm in CreateBookmark2()
+		var curStart = FCKDomTools.GetNodeFromAddress( this.Window.document, bookmark.Start.slice( 0, -1 ), true ) ;
+		var curEnd = FCKDomTools.GetNodeFromAddress( this.Window.document, bookmark.End.slice( 0, -1 ), true ) ;
+		// Generate the W3C Range object and update relevant data
+		this.Release( true ) ;
+		this._Range = new FCKW3CRange( this.Window.document ) ;
+		var startOffset = bookmark.Start[ bookmark.Start.length - 1 ] ;
+		var endOffset = bookmark.End[ bookmark.End.length - 1 ] ;
+		while ( curStart.nodeType == 3 && startOffset > curStart.length )
+		{
+			if ( ! curStart.nextSibling || curStart.nextSibling.nodeType != 3 )
+				break ;
+			startOffset -= curStart.length ;
+			curStart = curStart.nextSibling ;
+		}
+		while ( curEnd.nodeType == 3 && endOffset > curEnd.length )
+		{
+			if ( ! curEnd.nextSibling || curEnd.nextSibling.nodeType != 3 )
+				break ;
+			endOffset -= curEnd.length ;
+			curEnd = curEnd.nextSibling ;
+		}
+		this._Range.setStart( curStart, startOffset ) ;
+		this._Range.setEnd( curEnd, endOffset ) ;
+		this._UpdateElementInfo() ;
+	},
+	MoveToPosition : function( targetElement, position )
+	{
+		this.SetStart( targetElement, position ) ;
+		this.Collapse( true ) ;
+	},
+	/*
+	 * Moves the position of the start boundary of the range to a specific position
+	 * relatively to a element.
+	 *		@position:
+	 *			1 = After Start		<target>^contents</target>
+	 *			2 = Before End		<target>contents^</target>
+	 *			3 = Before Start	^<target>contents</target>
+	 *			4 = After End		<target>contents</target>^
+	 */
+	SetStart : function( targetElement, position, noInfoUpdate )
+	{
+		var oRange = this._Range ;
+		if ( !oRange )
+			oRange = this._Range = this.CreateRange() ;
+		switch( position )
+		{
+			case 1 :		// After Start		<target>^contents</target>
+				oRange.setStart( targetElement, 0 ) ;
+				break ;
+			case 2 :		// Before End		<target>contents^</target>
+				oRange.setStart( targetElement, targetElement.childNodes.length ) ;
+				break ;
+			case 3 :		// Before Start		^<target>contents</target>
+				oRange.setStartBefore( targetElement ) ;
+				break ;
+			case 4 :		// After End		<target>contents</target>^
+				oRange.setStartAfter( targetElement ) ;
+		}
+		if ( !noInfoUpdate )
+			this._UpdateElementInfo() ;
+	},
+	/*
+	 * Moves the position of the start boundary of the range to a specific position
+	 * relatively to a element.
+	 *		@position:
+	 *			1 = After Start		<target>^contents</target>
+	 *			2 = Before End		<target>contents^</target>
+	 *			3 = Before Start	^<target>contents</target>
+	 *			4 = After End		<target>contents</target>^
+	 */
+	SetEnd : function( targetElement, position, noInfoUpdate )
+	{
+		var oRange = this._Range ;
+		if ( !oRange )
+			oRange = this._Range = this.CreateRange() ;
+		switch( position )
+		{
+			case 1 :		// After Start		<target>^contents</target>
+				oRange.setEnd( targetElement, 0 ) ;
+				break ;
+			case 2 :		// Before End		<target>contents^</target>
+				oRange.setEnd( targetElement, targetElement.childNodes.length ) ;
+				break ;
+			case 3 :		// Before Start		^<target>contents</target>
+				oRange.setEndBefore( targetElement ) ;
+				break ;
+			case 4 :		// After End		<target>contents</target>^
+				oRange.setEndAfter( targetElement ) ;
+		}
+		if ( !noInfoUpdate )
+			this._UpdateElementInfo() ;
+	},
+	Expand : function( unit )
+	{
+		var oNode, oSibling ;
+		switch ( unit )
+		{
+			// Expand the range to include all inline parent elements if we are
+			// are in their boundary limits.
+			// For example (where [ ] are the range limits):
+			//	Before =>		Some <b>[<i>Some sample text]</i></b>.
+			//	After =>		Some [<b><i>Some sample text</i></b>].
+			case 'inline_elements' :
+				// Expand the start boundary.
+				if ( this._Range.startOffset == 0 )
+				{
+					oNode = this._Range.startContainer ;
+					if ( oNode.nodeType != 1 )
+						oNode = oNode.previousSibling ? null : oNode.parentNode ;
+					if ( oNode )
+					{
+						while ( FCKListsLib.InlineNonEmptyElements[ oNode.nodeName.toLowerCase() ] )
+						{
+							this._Range.setStartBefore( oNode ) ;
+							if ( oNode != oNode.parentNode.firstChild )
+								break ;
+							oNode = oNode.parentNode ;
+						}
+					}
+				}
+				// Expand the end boundary.
+				oNode = this._Range.endContainer ;
+				var offset = this._Range.endOffset ;
+				if ( ( oNode.nodeType == 3 && offset >= oNode.nodeValue.length ) || ( oNode.nodeType == 1 && offset >= oNode.childNodes.length ) || ( oNode.nodeType != 1 && oNode.nodeType != 3 ) )
+				{
+					if ( oNode.nodeType != 1 )
+						oNode = oNode.nextSibling ? null : oNode.parentNode ;
+					if ( oNode )
+					{
+						while ( FCKListsLib.InlineNonEmptyElements[ oNode.nodeName.toLowerCase() ] )
+						{
+							this._Range.setEndAfter( oNode ) ;
+							if ( oNode != oNode.parentNode.lastChild )
+								break ;
+							oNode = oNode.parentNode ;
+						}
+					}
+				}
+				break ;
+			case 'block_contents' :
+			case 'list_contents' :
+				var boundarySet = FCKListsLib.BlockBoundaries ;
+				if ( unit == 'list_contents' || FCKConfig.EnterMode == 'br' )
+					boundarySet = FCKListsLib.ListBoundaries ;
+				if ( this.StartBlock && FCKConfig.EnterMode != 'br' && unit == 'block_contents' )
+					this.SetStart( this.StartBlock, 1 ) ;
+				else
+				{
+					// Get the start node for the current range.
+					oNode = this._Range.startContainer ;
+					// If it is an element, get the node right before of it (in source order).
+					if ( oNode.nodeType == 1 )
+					{
+						var lastNode = oNode.childNodes[ this._Range.startOffset ] ;
+						if ( lastNode )
+							oNode = FCKDomTools.GetPreviousSourceNode( lastNode, true ) ;
+						else
+							oNode = oNode.lastChild || oNode ;
+					}
+					// We must look for the left boundary, relative to the range
+					// start, which is limited by a block element.
+					while ( oNode
+							&& ( oNode.nodeType != 1
+								|| ( oNode != this.StartBlockLimit
+									&& !boundarySet[ oNode.nodeName.toLowerCase() ] ) ) )
+					{
+						this._Range.setStartBefore( oNode ) ;
+						oNode = oNode.previousSibling || oNode.parentNode ;
+					}
+				}
+				if ( this.EndBlock && FCKConfig.EnterMode != 'br' && unit == 'block_contents' && this.EndBlock.nodeName.toLowerCase() != 'li' )
+					this.SetEnd( this.EndBlock, 2 ) ;
+				else
+				{
+					oNode = this._Range.endContainer ;
+					if ( oNode.nodeType == 1 )
+						oNode = oNode.childNodes[ this._Range.endOffset ] || oNode.lastChild ;
+					// We must look for the right boundary, relative to the range
+					// end, which is limited by a block element.
+					while ( oNode
+							&& ( oNode.nodeType != 1
+								|| ( oNode != this.StartBlockLimit
+									&& !boundarySet[ oNode.nodeName.toLowerCase() ] ) ) )
+					{
+						this._Range.setEndAfter( oNode ) ;
+						oNode = oNode.nextSibling || oNode.parentNode ;
+					}
+					// In EnterMode='br', the end <br> boundary element must
+					// be included in the expanded range.
+					if ( oNode && oNode.nodeName.toLowerCase() == 'br' )
+						this._Range.setEndAfter( oNode ) ;
+				}
+				this._UpdateElementInfo() ;
+		}
+	},
+	/**
+	 * Split the block element for the current range. It deletes the contents
+	 * of the range and splits the block in the collapsed position, resulting
+	 * in two sucessive blocks. The range is then positioned in the middle of
+	 * them.
+	 *
+	 * It returns and object with the following properties:
+	 *		- PreviousBlock	: a reference to the block element that preceeds
+	 *		  the range after the split.
+	 *		- NextBlock : a reference to the block element that follows the
+	 *		  range after the split.
+	 *		- WasStartOfBlock : a boolean indicating that the range was
+	 *		  originaly at the start of the block.
+	 *		- WasEndOfBlock : a boolean indicating that the range was originaly
+	 *		  at the end of the block.
+	 *
+	 * If the range was originaly at the start of the block, no split will happen
+	 * and the PreviousBlock value will be null. The same is valid for the
+	 * NextBlock value if the range was at the end of the block.
+	 */
+	SplitBlock : function( forceBlockTag )
+	{
+		var blockTag = forceBlockTag || FCKConfig.EnterMode ;
+		if ( !this._Range )
+			this.MoveToSelection() ;
+		// The range boundaries must be in the same "block limit" element.
+		if ( this.StartBlockLimit == this.EndBlockLimit )
+		{
+			// Get the current blocks.
+			var eStartBlock		= this.StartBlock ;
+			var eEndBlock		= this.EndBlock ;
+			var oElementPath	= null ;
+			if ( blockTag != 'br' )
+			{
+				if ( !eStartBlock )
+				{
+					eStartBlock = this.FixBlock( true, blockTag ) ;
+					eEndBlock	= this.EndBlock ;	// FixBlock may have fixed the EndBlock too.
+				}
+				if ( !eEndBlock )
+					eEndBlock = this.FixBlock( false, blockTag ) ;
+			}
+			// Get the range position.
+			var bIsStartOfBlock	= ( eStartBlock != null && this.CheckStartOfBlock() ) ;
+			var bIsEndOfBlock	= ( eEndBlock != null && this.CheckEndOfBlock() ) ;
+			// Delete the current contents.
+			if ( !this.CheckIsEmpty() )
+				this.DeleteContents() ;
+			if ( eStartBlock && eEndBlock && eStartBlock == eEndBlock )
+			{
+				if ( bIsEndOfBlock )
+				{
+					oElementPath = new FCKElementPath( this.StartContainer ) ;
+					this.MoveToPosition( eEndBlock, 4 ) ;
+					eEndBlock = null ;
+				}
+				else if ( bIsStartOfBlock )
+				{
+					oElementPath = new FCKElementPath( this.StartContainer ) ;
+					this.MoveToPosition( eStartBlock, 3 ) ;
+					eStartBlock = null ;
+				}
+				else
+				{
+					// Extract the contents of the block from the selection point to the end of its contents.
+					this.SetEnd( eStartBlock, 2 ) ;
+					var eDocFrag = this.ExtractContents() ;
+					// Duplicate the block element after it.
+					eEndBlock = eStartBlock.cloneNode( false ) ;
+					eEndBlock.removeAttribute( 'id', false ) ;
+					// Place the extracted contents in the duplicated block.
+					eDocFrag.AppendTo( eEndBlock ) ;
+					FCKDomTools.InsertAfterNode( eStartBlock, eEndBlock ) ;
+					this.MoveToPosition( eStartBlock, 4 ) ;
+					// In Gecko, the last child node must be a bogus <br>.
+					// Note: bogus <br> added under <ul> or <ol> would cause lists to be incorrectly rendered.
+					if ( FCKBrowserInfo.IsGecko &&
+							! eStartBlock.nodeName.IEquals( ['ul', 'ol'] ) )
+						FCKTools.AppendBogusBr( eStartBlock ) ;
+				}
+			}
+			return {
+				PreviousBlock	: eStartBlock,
+				NextBlock		: eEndBlock,
+				WasStartOfBlock : bIsStartOfBlock,
+				WasEndOfBlock	: bIsEndOfBlock,
+				ElementPath		: oElementPath
+			} ;
+		}
+		return null ;
+	},
+	// Transform a block without a block tag in a valid block (orphan text in the body or td, usually).
+	FixBlock : function( isStart, blockTag )
+	{
+		// Bookmark the range so we can restore it later.
+		var oBookmark = this.CreateBookmark() ;
+		// Collapse the range to the requested ending boundary.
+		this.Collapse( isStart ) ;
+		// Expands it to the block contents.
+		this.Expand( 'block_contents' ) ;
+		// Create the fixed block.
+		var oFixedBlock = this.Window.document.createElement( blockTag ) ;
+		// Move the contents of the temporary range to the fixed block.
+		this.ExtractContents().AppendTo( oFixedBlock ) ;
+		FCKDomTools.TrimNode( oFixedBlock ) ;
+		// If the fixed block is empty (not counting bookmark nodes)
+		// Add a <br /> inside to expand it.
+		if ( FCKDomTools.CheckIsEmptyElement(oFixedBlock, function( element ) { return element.getAttribute('_fck_bookmark') != 'true' ; } )
+				&& FCKBrowserInfo.IsGeckoLike )
+				FCKTools.AppendBogusBr( oFixedBlock ) ;
+		// Insert the fixed block into the DOM.
+		this.InsertNode( oFixedBlock ) ;
+		// Move the range back to the bookmarked place.
+		this.MoveToBookmark( oBookmark ) ;
+		return oFixedBlock ;
+	},
+	Release : function( preserveWindow )
+	{
+		if ( !preserveWindow )
+			this.Window = null ;
+		this.StartNode = null ;
+		this.StartContainer = null ;
+		this.StartBlock = null ;
+		this.StartBlockLimit = null ;
+		this.EndNode = null ;
+		this.EndContainer = null ;
+		this.EndBlock = null ;
+		this.EndBlockLimit = null ;
+		this._Range = null ;
+		this._Cache = null ;
+	},
+	CheckHasRange : function()
+	{
+		return !!this._Range ;
+	},
+	GetTouchedStartNode : function()
+	{
+		var range = this._Range ;
+		var container = range.startContainer ;
+		if ( range.collapsed || container.nodeType != 1 )
+			return container ;
+		return container.childNodes[ range.startOffset ] || container ;
+	},
+	GetTouchedEndNode : function()
+	{
+		var range = this._Range ;
+		var container = range.endContainer ;
+		if ( range.collapsed || container.nodeType != 1 )
+			return container ;
+		return container.childNodes[ range.endOffset - 1 ] || container ;
+	}
+} ;