radiant-ck_editor_filter-extension 0.2.0 → 0.2.1

data/public/javascripts/extensions/ck_editor_filter/ckeditor/_source/core/dom/elementpath.js

@@ -1,15 +1,15 @@
 /*
-Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 
 (function()
 {
 	// Elements that may be considered the "Block boundary" in an element path.
-	var pathBlockElements = { address:1,blockquote:1,dl:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1,li:1,dt:1,de:1 };
+	var pathBlockElements = { address:1,blockquote:1,dl:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1,li:1,dt:1,dd:1, legend:1 };
 
 	// Elements that may be considered the "Block limit" in an element path.
-	var pathBlockLimitElements = { body:1,div:1,table:1,tbody:1,tr:1,td:1,th:1,caption:1,form:1 };
+	var pathBlockLimitElements = { body:1,div:1,table:1,tbody:1,tr:1,td:1,th:1,caption:1,form:1,fieldset:1 };
 
 	// Check if an element contains any block element.
 	var checkHasBlock = function( element )
@@ -27,6 +27,9 @@ For licensing, see LICENSE.html or http://ckeditor.com/license
 		return false;
 	};
 
+	/**
+	 * @class
+	 */
 	CKEDITOR.dom.elementPath = function( lastNode )
 	{
 		var block = null;
@@ -100,5 +103,17 @@ CKEDITOR.dom.elementPath.prototype =
 		}
 
 		return true;
+	},
+
+	contains : function( tagNames )
+	{
+		var elements = this.elements;
+		for ( var i = 0 ; i < elements.length ; i++ )
+		{
+			if ( elements[ i ].getName() in tagNames )
+				return elements[ i ];
+		}
+
+		return null;
 	}
 };

data/public/javascripts/extensions/ck_editor_filter/ckeditor/_source/core/dom/event.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 

data/public/javascripts/extensions/ck_editor_filter/ckeditor/_source/core/dom/node.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 
@@ -107,24 +107,25 @@ CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,
 		{
 			var $clone = this.$.cloneNode( includeChildren );
 
-			if ( !cloneId )
+			var removeIds = function( node )
 			{
-				var removeIds = function( node )
-				{
-					if ( node.nodeType != CKEDITOR.NODE_ELEMENT )
-						return;
+				if ( node.nodeType != CKEDITOR.NODE_ELEMENT )
+					return;
 
-					node.removeAttribute( 'id', false ) ;
-					node.removeAttribute( '_cke_expando', false ) ;
+				if ( !cloneId )
+					node.removeAttribute( 'id', false );
+				node.removeAttribute( 'data-cke-expando', false );
 
+				if ( includeChildren )
+				{
 					var childs = node.childNodes;
-					for ( var i=0 ; i < childs.length ; i++ )
+					for ( var i=0; i < childs.length; i++ )
 						removeIds( childs[ i ] );
-				};
+				}
+			};
 
-				// The "id" attribute should never be cloned to avoid duplication.
-				removeIds( $clone );
-			}
+			// The "id" attribute should never be cloned to avoid duplication.
+			removeIds( $clone );
 
 			return new CKEDITOR.dom.node( $clone );
 		},
@@ -203,29 +204,12 @@ CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,
 			while ( node && node != $documentElement )
 			{
 				var parentNode = node.parentNode;
-				var currentIndex = -1;
 
 				if ( parentNode )
 				{
-					for ( var i = 0 ; i < parentNode.childNodes.length ; i++ )
-					{
-						var candidate = parentNode.childNodes[i];
-
-						if ( normalized &&
-								candidate.nodeType == 3 &&
-								candidate.previousSibling &&
-								candidate.previousSibling.nodeType == 3 )
-						{
-							continue;
-						}
-
-						currentIndex++;
-
-						if ( candidate == node )
-							break;
-					}
-
-					address.unshift( currentIndex );
+					// Get the node index. For performance, call getIndex
+					// directly, instead of creating a new node object.
+					address.unshift( this.getIndex.call( { $ : node }, normalized ) );
 				}
 
 				node = parentNode;
@@ -243,33 +227,31 @@ CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,
 		 */
 		getDocument : function()
 		{
-			var document = new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );
-
-			return (
-			this.getDocument = function()
-				{
-					return document;
-				})();
+			return new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );
 		},
 
-		getIndex : function()
+		getIndex : function( normalized )
 		{
-			var $ = this.$;
+			// Attention: getAddress depends on this.$
 
-			var currentNode = $.parentNode && $.parentNode.firstChild;
-			var currentIndex = -1;
+			var current = this.$,
+				index = 0;
 
-			while ( currentNode )
+			while ( ( current = current.previousSibling ) )
 			{
-				currentIndex++;
-
-				if ( currentNode == $ )
-					return currentIndex;
+				// When normalizing, do not count it if this is an
+				// empty text node or if it's a text node following another one.
+				if ( normalized && current.nodeType == 3 &&
+					 ( !current.nodeValue.length ||
+					   ( current.previousSibling && current.previousSibling.nodeType == 3 ) ) )
+				{
+					continue;
+				}
 
-				currentNode = currentNode.nextSibling;
+				index++;
 			}
 
-			return -1;
+			return index;
 		},
 
 		getNextSourceNode : function( startFromSibling, nodeType, guard )
@@ -505,11 +487,18 @@ CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,
 		},
 
 		/**
-		 * Gets the closes ancestor node of a specified node name.
-		 * @param {String} name Node name of ancestor node.
-		 * @param {Boolean} includeSelf (Optional) Whether to include the current
-		 * node in the calculation or not.
-		 * @returns {CKEDITOR.dom.node} Ancestor node.
+		 * Gets the closest ancestor node of this node, specified by its node name.
+		 * @param {String} name The node name of the ancestor node to search.
+		 * @param {Boolean} [includeSelf] Whether to include the current
+		 * node in the search.
+		 * @returns {CKEDITOR.dom.node} The located ancestor node or null if not found.
+		 * @example
+		 * // Suppose we have the following HTML:
+		 * // &lt;div id="outer"&gt;&lt;div id="inner"&gt;&lt;p&gt;&lt;b&gt;Some text&lt;/b&gt;&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;
+		 * // If node == &lt;b&gt;
+		 * ascendant = node.getAscendant( 'div' );      // ascendant == &lt;div id="inner"&gt
+		 * ascendant = node.getAscendant( 'b' );        // ascendant == null
+		 * ascendant = node.getAscendant( 'b', true );  // ascendant == &lt;b&gt;
 		 */
 		getAscendant : function( name, includeSelf )
 		{
@@ -657,6 +646,45 @@ CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,
 					child.parentNode.removeChild( child ) ;
 				}
 			}
+		},
+
+		/**
+		 * Checks is this node is read-only (should not be changed). It
+		 * additionaly returns the element, if any, which defines the read-only
+		 * state of this node. It may be the node itself or any of its parent
+		 * nodes.
+		 * @returns {CKEDITOR.dom.element|Boolean} An element containing
+		 *		read-only attributes or "false" if none is found.
+		 * @since 3.5
+		 * @example
+		 * // For the following HTML:
+		 * // &lt;div contenteditable="false"&gt;Some &lt;b&gt;text&lt;/b&gt;&lt;/div&gt;
+		 *
+		 * // If "ele" is the above &lt;div&gt;
+		 * ele.isReadOnly();  // the &lt;div&gt; element
+		 *
+		 * // If "ele" is the above &lt;b&gt;
+		 * ele.isReadOnly();  // the &lt;div&gt; element
+		 */
+		isReadOnly : function()
+		{
+			var current = this;
+			while( current )
+			{
+				if ( current.type == CKEDITOR.NODE_ELEMENT )
+				{
+					if ( current.is( 'body' ) || !!current.data( 'cke-editable' ) )
+						break;
+
+					if ( current.getAttribute( 'contentEditable' ) == 'false' )
+						return current;
+					else if ( current.getAttribute( 'contentEditable' ) == 'true' )
+						break;
+				}
+				current = current.getParent();
+			}
+
+			return false;
 		}
 	}
 );

data/public/javascripts/extensions/ck_editor_filter/ckeditor/_source/core/dom/nodelist.js

@@ -1,8 +1,11 @@
 /*
-Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 
+/**
+ * @class
+ */
 CKEDITOR.dom.nodeList = function( nativeList )
 {
 	this.$ = nativeList;

data/public/javascripts/extensions/ck_editor_filter/ckeditor/_source/core/dom/range.js

@@ -1,16 +1,90 @@
 /*
-Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 
+/**
+ * Creates a CKEDITOR.dom.range instance that can be used inside a specific
+ * DOM Document.
+ * @class Represents a delimited piece of content in a DOM Document.
+ * It is contiguous in the sense that it can be characterized as selecting all
+ * of the content between a pair of boundary-points.<br>
+ * <br>
+ * This class shares much of the W3C
+ * <a href="http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html">Document Object Model Range</a>
+ * ideas and features, adding several range manipulation tools to it, but it's
+ * not intended to be compatible with it.
+ * @param {CKEDITOR.dom.document} document The document into which the range
+ *		features will be available.
+ * @example
+ * // Create a range for the entire contents of the editor document body.
+ * var range = new CKEDITOR.dom.range( editor.document );
+ * range.selectNodeContents( editor.document.getBody() );
+ * // Delete the contents.
+ * range.deleteContents();
+ */
 CKEDITOR.dom.range = function( document )
 {
+	/**
+	 * Node within which the range begins.
+	 * @type {CKEDITOR.NODE_ELEMENT|CKEDITOR.NODE_TEXT}
+	 * @example
+	 * var range = new CKEDITOR.dom.range( editor.document );
+	 * range.selectNodeContents( editor.document.getBody() );
+	 * alert( range.startContainer.getName() );  // "body"
+	 */
 	this.startContainer	= null;
+
+	/**
+	 * Offset within the starting node of the range.
+	 * @type {Number}
+	 * @example
+	 * var range = new CKEDITOR.dom.range( editor.document );
+	 * range.selectNodeContents( editor.document.getBody() );
+	 * alert( range.startOffset );  // "0"
+	 */
 	this.startOffset	= null;
+
+	/**
+	 * Node within which the range ends.
+	 * @type {CKEDITOR.NODE_ELEMENT|CKEDITOR.NODE_TEXT}
+	 * @example
+	 * var range = new CKEDITOR.dom.range( editor.document );
+	 * range.selectNodeContents( editor.document.getBody() );
+	 * alert( range.endContainer.getName() );  // "body"
+	 */
 	this.endContainer	= null;
+
+	/**
+	 * Offset within the ending node of the range.
+	 * @type {Number}
+	 * @example
+	 * var range = new CKEDITOR.dom.range( editor.document );
+	 * range.selectNodeContents( editor.document.getBody() );
+	 * alert( range.endOffset );  // == editor.document.getBody().getChildCount()
+	 */
 	this.endOffset		= null;
+
+	/**
+	 * Indicates that this is a collapsed range. A collapsed range has it's
+	 * start and end boudaries at the very same point so nothing is contained
+	 * in it.
+	 * @example
+	 * var range = new CKEDITOR.dom.range( editor.document );
+	 * range.selectNodeContents( editor.document.getBody() );
+	 * alert( range.collapsed );  // "false"
+	 * range.collapse();
+	 * alert( range.collapsed );  // "true"
+	 */
 	this.collapsed		= true;
 
+	/**
+	 * The document within which the range can be used.
+	 * @type {CKEDITOR.dom.document}
+	 * @example
+	 * // Selects the body contents of the range document.
+	 * range.selectNodeContents( range.document.getBody() );
+	 */
 	this.document = document;
 };
 
@@ -29,7 +103,7 @@ CKEDITOR.dom.range = function( document )
 	// This is a shared function used to delete, extract and clone the range
 	// contents.
 	// V2
-	var execContentsAction = function( range, action, docFrag )
+	var execContentsAction = function( range, action, docFrag, mergeThen )
 	{
 		range.optimizeBookmark();
 
@@ -244,7 +318,17 @@ CKEDITOR.dom.range = function( document )
 				if ( removeStartNode && topEnd.$.parentNode == startNode.$.parentNode )
 					endIndex--;
 
-				range.setStart( topEnd.getParent(), endIndex );
+				// Merge splitted parents.
+				if ( mergeThen && topStart.type == CKEDITOR.NODE_ELEMENT )
+				{
+					var span = CKEDITOR.dom.element.createFromHtml( '<span ' +
+						'data-cke-bookmark="1" style="display:none">&nbsp;</span>', range.document );
+					span.insertAfter( topStart );
+					topStart.mergeSiblings( false );
+					range.moveToBookmark( { startNode : span } );
+				}
+				else
+					range.setStart( topEnd.getParent(), endIndex );
 			}
 
 			// Collapse it to the start.
@@ -275,9 +359,9 @@ CKEDITOR.dom.range = function( document )
 			if ( node.type == CKEDITOR.NODE_TEXT )
 			{
 				// If there's any visible text, then we're not at the start.
-				if ( CKEDITOR.tools.trim( node.getText() ).length )
+				if ( node.hasAscendant( 'pre' ) || CKEDITOR.tools.trim( node.getText() ).length )
 					return false;
-				}
+			}
 			else if ( node.type == CKEDITOR.NODE_ELEMENT )
 			{
 				// If there are non-empty inline elements (e.g. <img />), then we're not
@@ -305,7 +389,7 @@ CKEDITOR.dom.range = function( document )
 		return node.type != CKEDITOR.NODE_TEXT
 			    && node.getName() in CKEDITOR.dtd.$removeEmpty
 			    || !CKEDITOR.tools.trim( node.getText() )
-			    || node.getParent().hasAttribute( '_fck_bookmark' );
+			    || !!node.getParent().data( 'cke-bookmark' );
 	}
 
 	var whitespaceEval = new CKEDITOR.dom.walker.whitespaces(),
@@ -348,7 +432,10 @@ CKEDITOR.dom.range = function( document )
 			this.collapsed = true;
 		},
 
-		// The selection may be lost when cloning (due to the splitText() call).
+		/**
+		 *  The content nodes of the range are cloned and added to a document fragment, which is returned.
+		 *  <strong> Note: </strong> Text selection may lost after invoking this method. (caused by text node splitting).
+		 */
 		cloneContents : function()
 		{
 			var docFrag = new CKEDITOR.dom.documentFragment( this.document );
@@ -359,20 +446,29 @@ CKEDITOR.dom.range = function( document )
 			return docFrag;
 		},
 
-		deleteContents : function()
+		/**
+		 * Deletes the content nodes of the range permanently from the DOM tree.
+		 * @param {Boolean} [mergeThen] Merge any splitted elements result in DOM true due to partial selection.
+		 */
+		deleteContents : function( mergeThen )
 		{
 			if ( this.collapsed )
 				return;
 
-			execContentsAction( this, 0 );
+			execContentsAction( this, 0, null, mergeThen );
 		},
 
-		extractContents : function()
+		/**
+		 *  The content nodes of the range are cloned and added to a document fragment,
+		 * meanwhile they're removed permanently from the DOM tree.
+		 * @param {Boolean} [mergeThen] Merge any splitted elements result in DOM true due to partial selection.
+		 */
+		extractContents : function( mergeThen )
 		{
 			var docFrag = new CKEDITOR.dom.documentFragment( this.document );
 
 			if ( !this.collapsed )
-				execContentsAction( this, 1, docFrag );
+				execContentsAction( this, 1, docFrag, mergeThen );
 
 			return docFrag;
 		},
@@ -397,9 +493,10 @@ CKEDITOR.dom.range = function( document )
 			var startNode, endNode;
 			var baseId;
 			var clone;
+			var collapsed = this.collapsed;
 
 			startNode = this.document.createElement( 'span' );
-			startNode.setAttribute( '_fck_bookmark', 1 );
+			startNode.data( 'cke-bookmark', 1 );
 			startNode.setStyle( 'display', 'none' );
 
 			// For IE, it must have something inside, otherwise it may be
@@ -413,7 +510,7 @@ CKEDITOR.dom.range = function( document )
 			}
 
 			// If collapsed, the endNode will not be created.
-			if ( !this.collapsed )
+			if ( !collapsed )
 			{
 				endNode = startNode.clone();
 				endNode.setHtml( '&nbsp;' );
@@ -442,7 +539,8 @@ CKEDITOR.dom.range = function( document )
 			return {
 				startNode : serializable ? baseId + 'S' : startNode,
 				endNode : serializable ? baseId + 'E' : endNode,
-				serializable : serializable
+				serializable : serializable,
+				collapsed : collapsed
 			};
 		},
 
@@ -465,6 +563,8 @@ CKEDITOR.dom.range = function( document )
 			var startOffset	= this.startOffset,
 				endOffset	= this.endOffset;
 
+			var collapsed = this.collapsed;
+
 			var child, previous;
 
 			// If there is no range then get out of here.
@@ -489,6 +589,10 @@ CKEDITOR.dom.range = function( document )
 						startContainer = child;
 						startOffset = 0;
 					}
+
+					// Get the normalized offset.
+					if ( child && child.type == CKEDITOR.NODE_ELEMENT )
+						startOffset = child.getIndex( 1 );
 				}
 
 				// Normalize the start.
@@ -501,7 +605,7 @@ CKEDITOR.dom.range = function( document )
 				}
 
 				// Process the end only if not normalized.
-				if ( !this.isCollapsed )
+				if ( !collapsed )
 				{
 					// Find out if the start is pointing to a text node that
 					// will be normalized.
@@ -517,6 +621,10 @@ CKEDITOR.dom.range = function( document )
 							endContainer = child;
 							endOffset = 0;
 						}
+
+						// Get the normalized offset.
+						if ( child && child.type == CKEDITOR.NODE_ELEMENT )
+							endOffset = child.getIndex( 1 );
 					}
 
 					// Normalize the end.
@@ -532,10 +640,11 @@ CKEDITOR.dom.range = function( document )
 
 			return {
 				start		: startContainer.getAddress( normalized ),
-				end			: this.isCollapsed ? null : endContainer.getAddress( normalized ),
+				end			: collapsed ? null : endContainer.getAddress( normalized ),
 				startOffset	: startOffset,
 				endOffset	: endOffset,
 				normalized	: normalized,
+				collapsed	: collapsed,
 				is2			: true		// It's a createBookmark2 bookmark.
 			};
 		},
@@ -697,7 +806,7 @@ CKEDITOR.dom.range = function( document )
 		},
 
 		/**
-		 * Move the range out of bookmark nodes if they're been the container.
+		 * Move the range out of bookmark nodes if they'd been the container.
 		 */
 		optimizeBookmark: function()
 		{
@@ -705,10 +814,10 @@ CKEDITOR.dom.range = function( document )
 				endNode = this.endContainer;
 
 			if ( startNode.is && startNode.is( 'span' )
-				&& startNode.hasAttribute( '_fck_bookmark' ) )
+				&& startNode.data( 'cke-bookmark' ) )
 				this.setStartAt( startNode, CKEDITOR.POSITION_BEFORE_START );
 			if ( endNode && endNode.is && endNode.is( 'span' )
-				&& endNode.hasAttribute( '_fck_bookmark' ) )
+				&& endNode.data( 'cke-bookmark' ) )
 				this.setEndAt( endNode,  CKEDITOR.POSITION_AFTER_END );
 		},
 
@@ -793,7 +902,12 @@ CKEDITOR.dom.range = function( document )
 			}
 		},
 
-		enlarge : function( unit )
+		/**
+		 * Expands the range so that partial units are completely contained.
+		 * @param unit {Number} The unit type to expand with.
+		 * @param {Boolean} [excludeBrs=false] Whether include line-breaks when expanding.
+		 */
+		enlarge : function( unit, excludeBrs )
 		{
 			switch ( unit )
 			{
@@ -914,7 +1028,8 @@ CKEDITOR.dom.range = function( document )
 								// If this is a visible element.
 								// We need to check for the bookmark attribute because IE insists on
 								// rendering the display:none nodes we use for bookmarks. (#3363)
-								if ( sibling.$.offsetWidth > 0 && !sibling.getAttribute( '_fck_bookmark' ) )
+								// Line-breaks (br) are rendered with zero width, which we don't want to include. (#7041)
+								if ( ( sibling.$.offsetWidth > 0 || excludeBrs && sibling.is( 'br' ) ) && !sibling.data( 'cke-bookmark' ) )
 								{
 									// We'll accept it only if we need
 									// whitespace, and this is an inline
@@ -925,7 +1040,7 @@ CKEDITOR.dom.range = function( document )
 
 										siblingText = sibling.getText();
 
-										if ( !(/[^\s\ufeff]/).test( siblingText ) )	// Spaces + Zero Width No-Break Space (U+FEFF)
+										if ( (/[^\s\ufeff]/).test( siblingText ) )	// Spaces + Zero Width No-Break Space (U+FEFF)
 											sibling = null;
 										else
 										{
@@ -1073,7 +1188,8 @@ CKEDITOR.dom.range = function( document )
 								// If this is a visible element.
 								// We need to check for the bookmark attribute because IE insists on
 								// rendering the display:none nodes we use for bookmarks. (#3363)
-								if ( sibling.$.offsetWidth > 0 && !sibling.getAttribute( '_fck_bookmark' ) )
+								// Line-breaks (br) are rendered with zero width, which we don't want to include. (#7041)
+								if ( ( sibling.$.offsetWidth > 0 || excludeBrs && sibling.is( 'br' ) ) && !sibling.data( 'cke-bookmark' ) )
 								{
 									// We'll accept it only if we need
 									// whitespace, and this is an inline
@@ -1084,7 +1200,7 @@ CKEDITOR.dom.range = function( document )
 
 										siblingText = sibling.getText();
 
-										if ( !(/[^\s\ufeff]/).test( siblingText ) )
+										if ( (/[^\s\ufeff]/).test( siblingText ) )
 											sibling = null;
 										else
 										{
@@ -1166,13 +1282,13 @@ CKEDITOR.dom.range = function( document )
 
 					var walker = new CKEDITOR.dom.walker( walkerRange ),
 					    blockBoundary,  // The node on which the enlarging should stop.
-						tailBr, //
-					    defaultGuard = CKEDITOR.dom.walker.blockBoundary(
+						tailBr, // In case BR as block boundary.
+					    notBlockBoundary = CKEDITOR.dom.walker.blockBoundary(
 								( unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS ) ? { br : 1 } : null ),
 						// Record the encountered 'blockBoundary' for later use.
 						boundaryGuard = function( node )
 						{
-							var retval = defaultGuard( node );
+							var retval = notBlockBoundary( node );
 							if ( !retval )
 								blockBoundary = node;
 							return retval;
@@ -1193,8 +1309,9 @@ CKEDITOR.dom.range = function( document )
 					// It's the body which stop the enlarging if no block boundary found.
 					blockBoundary = blockBoundary || body;
 
-					// Start the range at different position by comparing
-					// the document position of it with 'enlargeable' node.
+					// Start the range either after the end of found block (<p>...</p>[text)
+					// or at the start of block (<p>[text...), by comparing the document position
+					// with 'enlargeable' node.
 					this.setStartAt(
 							blockBoundary,
 							!blockBoundary.is( 'br' ) &&
@@ -1220,8 +1337,8 @@ CKEDITOR.dom.range = function( document )
 					// It's the body which stop the enlarging if no block boundary found.
 					blockBoundary = blockBoundary || body;
 
-					// Start the range at different position by comparing
-					// the document position of it with 'enlargeable' node.
+					// Close the range either before the found block start (text]<p>...</p>) or at the block end (...text]</p>)
+					// by comparing the document position with 'enlargeable' node.
 					this.setEndAt(
 							blockBoundary,
 							( !enlargeable && this.checkEndOfBlock()
@@ -1235,6 +1352,111 @@ CKEDITOR.dom.range = function( document )
 			}
 		},
 
+		/**
+		 *  Descrease the range to make sure that boundaries
+		*  always anchor beside text nodes or innermost element.
+		 * @param {Number} mode  ( CKEDITOR.SHRINK_ELEMENT | CKEDITOR.SHRINK_TEXT ) The shrinking mode.
+		 * <dl>
+		 * 	 <dt>CKEDITOR.SHRINK_ELEMENT</dt>
+		 * 	 <dd>Shrink the range boundaries to the edge of the innermost element.</dd>
+		 * 	 <dt>CKEDITOR.SHRINK_TEXT</dt>
+		 * 	 <dd>Shrink the range boudaries to anchor by the side of enclosed text  node, range remains if there's no text nodes on boundaries at all.</dd>
+		  * </dl>
+		 * @param {Boolean} selectContents Whether result range anchors at the inner OR outer boundary of the node.
+		 */
+		shrink : function( mode, selectContents )
+		{
+			// Unable to shrink a collapsed range.
+			if ( !this.collapsed )
+			{
+				mode = mode || CKEDITOR.SHRINK_TEXT;
+
+				var walkerRange = this.clone();
+
+				var startContainer = this.startContainer,
+					endContainer = this.endContainer,
+					startOffset = this.startOffset,
+					endOffset = this.endOffset,
+					collapsed = this.collapsed;
+
+				// Whether the start/end boundary is moveable.
+				var moveStart = 1,
+						moveEnd = 1;
+
+				if ( startContainer && startContainer.type == CKEDITOR.NODE_TEXT )
+				{
+					if ( !startOffset )
+						walkerRange.setStartBefore( startContainer );
+					else if ( startOffset >= startContainer.getLength( ) )
+						walkerRange.setStartAfter( startContainer );
+					else
+					{
+						// Enlarge the range properly to avoid walker making
+						// DOM changes caused by triming the text nodes later.
+						walkerRange.setStartBefore( startContainer );
+						moveStart = 0;
+					}
+				}
+
+				if ( endContainer && endContainer.type == CKEDITOR.NODE_TEXT )
+				{
+					if ( !endOffset )
+						walkerRange.setEndBefore( endContainer );
+					else if ( endOffset >= endContainer.getLength( ) )
+						walkerRange.setEndAfter( endContainer );
+					else
+					{
+						walkerRange.setEndAfter( endContainer );
+						moveEnd = 0;
+					}
+				}
+
+				var walker = new CKEDITOR.dom.walker( walkerRange ),
+					isBookmark = CKEDITOR.dom.walker.bookmark();
+
+				walker.evaluator = function( node )
+				{
+					return node.type == ( mode == CKEDITOR.SHRINK_ELEMENT ?
+						CKEDITOR.NODE_ELEMENT : CKEDITOR.NODE_TEXT );
+				};
+
+				var currentElement;
+				walker.guard = function( node, movingOut )
+				{
+					if ( isBookmark( node ) )
+						return true;
+
+					// Stop when we're shrink in element mode while encountering a text node.
+					if ( mode == CKEDITOR.SHRINK_ELEMENT && node.type == CKEDITOR.NODE_TEXT )
+						return false;
+
+					// Stop when we've already walked "through" an element.
+					if ( movingOut && node.equals( currentElement ) )
+						return false;
+
+					if ( !movingOut && node.type == CKEDITOR.NODE_ELEMENT )
+						currentElement = node;
+
+					return true;
+				};
+
+				if ( moveStart )
+				{
+					var textStart = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastForward' : 'next']();
+					textStart && this.setStartAt( textStart, selectContents ? CKEDITOR.POSITION_AFTER_START : CKEDITOR.POSITION_BEFORE_START );
+				}
+
+				if ( moveEnd )
+				{
+					walker.reset();
+					var textEnd = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastBackward' : 'previous']();
+					textEnd && this.setEndAt( textEnd, selectContents ? CKEDITOR.POSITION_BEFORE_END : CKEDITOR.POSITION_AFTER_END );
+				}
+
+				return !!( moveStart || moveEnd );
+			}
+		},
+
 		/**
 		 * Inserts a node at the start of the range. The range will be expanded
 		 * the contain the node.
@@ -1288,6 +1510,11 @@ CKEDITOR.dom.range = function( document )
 			// we will not need this check for our use of this class so we can
 			// ignore it for now.
 
+			// Fixing invalid range start inside dtd empty elements.
+			if( startNode.type == CKEDITOR.NODE_ELEMENT
+				&& CKEDITOR.dtd.$empty[ startNode.getName() ] )
+				startOffset = startNode.getIndex(), startNode = startNode.getParent();
+
 			this.startContainer	= startNode;
 			this.startOffset	= startOffset;
 
@@ -1314,6 +1541,11 @@ CKEDITOR.dom.range = function( document )
 			// will not need this check for our use of this class so we can ignore
 			// it for now.
 
+			// Fixing invalid range end inside dtd empty elements.
+			if( endNode.type == CKEDITOR.NODE_ELEMENT
+				&& CKEDITOR.dtd.$empty[ endNode.getName() ] )
+				endOffset = endNode.getIndex() + 1, endNode = endNode.getParent();
+
 			this.endContainer	= endNode;
 			this.endOffset		= endOffset;
 
@@ -1520,26 +1752,36 @@ CKEDITOR.dom.range = function( document )
 		},
 
 		/**
-		 * Check whether current range is on the inner edge of the specified element.
-		 * @param {Number} checkType ( CKEDITOR.START | CKEDITOR.END ) The checking side.
+		 * Check whether a range boundary is at the inner boundary of a given
+		 * element.
 		 * @param {CKEDITOR.dom.element} element The target element to check.
+		 * @param {Number} checkType The boundary to check for both the range
+		 *		and the element. It can be CKEDITOR.START or CKEDITOR.END.
+		 * @returns {Boolean} "true" if the range boundary is at the inner
+		 *		boundary of the element.
 		 */
 		checkBoundaryOfElement : function( element, checkType )
 		{
+			var checkStart = ( checkType == CKEDITOR.START );
+
+			// Create a copy of this range, so we can manipulate it for our checks.
 			var walkerRange = this.clone();
+
+			// Collapse the range at the proper size.
+			walkerRange.collapse( checkStart );
+
 			// Expand the range to element boundary.
-			walkerRange[ checkType == CKEDITOR.START ?
-			 'setStartAt' : 'setEndAt' ]
-			 ( element, checkType == CKEDITOR.START ?
-			   CKEDITOR.POSITION_AFTER_START
-			   : CKEDITOR.POSITION_BEFORE_END );
+			walkerRange[ checkStart ? 'setStartAt' : 'setEndAt' ]
+			 ( element, checkStart ? CKEDITOR.POSITION_AFTER_START : CKEDITOR.POSITION_BEFORE_END );
 
-			var walker = new CKEDITOR.dom.walker( walkerRange ),
-			 retval = false;
+			// Create the walker, which will check if we have anything useful
+			// in the range.
+			var walker = new CKEDITOR.dom.walker( walkerRange );
 			walker.evaluator = elementBoundaryEval;
-			return walker[ checkType == CKEDITOR.START ?
-				'checkBackward' : 'checkForward' ]();
+
+			return walker[ checkStart ? 'checkBackward' : 'checkForward' ]();
 		},
+
 		// Calls to this function may produce changes to the DOM. The range may
 		// be updated to reflect such changes.
 		checkStartOfBlock : function()
@@ -1610,6 +1852,47 @@ CKEDITOR.dom.range = function( document )
 			return walker.checkForward();
 		},
 
+		/**
+		 * Check if elements at which the range boundaries anchor are read-only,
+		 * with respect to "contenteditable" attribute.
+		 */
+		checkReadOnly : ( function()
+		{
+			function checkNodesEditable( node, anotherEnd )
+			{
+				while( node )
+				{
+					if ( node.type == CKEDITOR.NODE_ELEMENT )
+					{
+						if ( node.getAttribute( 'contentEditable' ) == 'false'
+							&& !node.data( 'cke-editable' ) )
+						{
+							return 0;
+						}
+						// Range enclosed entirely in an editable element.
+						else if ( node.is( 'html' )
+							|| node.getAttribute( 'contentEditable' ) == 'true'
+							&& ( node.contains( anotherEnd ) || node.equals( anotherEnd ) ) )
+						{
+							break;
+						}
+					}
+					node = node.getParent();
+				}
+
+				return 1;
+			}
+
+			return function()
+			{
+				var startNode = this.startContainer,
+					endNode = this.endContainer;
+
+				// Check if elements path at both boundaries are editable.
+				return !( checkNodesEditable( startNode, endNode ) && checkNodesEditable( endNode, startNode ) );
+			};
+		})(),
+
 		/**
 		 * Moves the range boundaries to the first/end editing point inside an
 		 * element. For example, in an element tree like
@@ -1623,6 +1906,10 @@ CKEDITOR.dom.range = function( document )
 		{
 			var isEditable;
 
+			// Empty elements are rejected.
+			if ( CKEDITOR.dtd.$empty[ el.getName() ] )
+				return false;
+
 			while ( el && el.type == CKEDITOR.NODE_ELEMENT )
 			{
 				isEditable = el.isEditable();
@@ -1681,8 +1968,15 @@ CKEDITOR.dom.range = function( document )
 		 */
 		getEnclosedNode : function()
 		{
-			var walkerRange = this.clone(),
-				walker = new CKEDITOR.dom.walker( walkerRange ),
+			var walkerRange = this.clone();
+
+			// Optimize and analyze the range to avoid DOM destructive nature of walker. (#5780)
+			walkerRange.optimize();
+			if ( walkerRange.startContainer.type != CKEDITOR.NODE_ELEMENT
+					|| walkerRange.endContainer.type != CKEDITOR.NODE_ELEMENT )
+				return null;
+
+			var walker = new CKEDITOR.dom.walker( walkerRange ),
 				isNotBookmarks = CKEDITOR.dom.walker.bookmark( true ),
 				isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
 				evaluator = function( node )
@@ -1726,10 +2020,13 @@ CKEDITOR.ENLARGE_ELEMENT = 1;
 CKEDITOR.ENLARGE_BLOCK_CONTENTS = 2;
 CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS = 3;
 
-/**
- * Check boundary types.
- * @see CKEDITOR.dom.range::checkBoundaryOfElement
- */
+// Check boundary types.
+// @see CKEDITOR.dom.range.prototype.checkBoundaryOfElement
 CKEDITOR.START = 1;
 CKEDITOR.END = 2;
 CKEDITOR.STARTEND = 3;
+
+// Shrink range types.
+// @see CKEDITOR.dom.range.prototype.shrink
+CKEDITOR.SHRINK_ELEMENT = 1;
+CKEDITOR.SHRINK_TEXT = 2;