Index: /CKEditor/branches/prototype/_source/core/dom/document.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/document.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/dom/document.js (revision 2573) @@ -67,4 +67,25 @@ this.getHead().append( link ); } + }, + + createElement : function( name, attribsAndStyles ) + { + var element = new CKEDITOR.dom.element( name, this ); + + if ( attribsAndStyles ) + { + if ( attribsAndStyles.attributes ) + element.setAttributes( attribsAndStyles.attributes ); + + if ( attribsAndStyles.styles ) + element.setStyles( attribsAndStyles.styles ); + } + + return element; + }, + + createText : function( text ) + { + return new CKEDITOR.dom.text( '', this ); }, Index: /CKEditor/branches/prototype/_source/core/dom/documentFragment.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/documentFragment.js (revision 2573) +++ /CKEditor/branches/prototype/_source/core/dom/documentFragment.js (revision 2573) @@ -0,0 +1,45 @@ +/* + * CKEditor - The text editor for Internet - http://ckeditor.com + * Copyright (C) 2003-2008 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 == + */ + +CKEDITOR.dom.documentFragment = function( ownerDocument ) +{ + this.$ = CKEDITOR.env.ie ? ownerDocument.$.createElement( 'div' ) : ownerDocument.$.createDocumentFragment(); +}; + +(function() +{ + var elementPrototype = CKEDITOR.dom.element.prototype; + + CKEDITOR.dom.documentFragment.prototype = + { + type : CKEDITOR.NODE_DOCUMENT_FRAGMENT, + + append : elementPrototype.append, + + appendTo : function( targetElement ) + { + if ( CKEDITOR.env.ie ) + elementPrototype.moveChildren.call( this, targetElement ); + else + targetElement.$.appendChild( this.$ ); + } + }; +})(); Index: /CKEditor/branches/prototype/_source/core/dom/element.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/element.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/dom/element.js (revision 2573) @@ -94,4 +94,12 @@ { /** + * The node type. This is a constant value set to + * {@link CKEDITOR.NODE_ELEMENT}. + * @type Number + * @example + */ + type : CKEDITOR.NODE_ELEMENT, + + /** * Adds a CSS class to the element. It appends the class to the * already existing names. @@ -187,4 +195,20 @@ }, + contains : + CKEDITOR.env.ie || CKEDITOR.env.webkit ? + function( node ) + { + var $ = this.$; + + return node.type != CKEDITOR.NODE_ELEMENT ? + $.contains( node.getParent().$ ) : + $ != node.$ && $.contains( node.$ ); + } + : + function( node ) + { + return !!( this.$.compareDocumentPosition( node.$ ) & 16 ); + }, + /** * Moves the selection focus to this element. @@ -336,4 +360,16 @@ }, + getDtd : function() + { + var dtd = CKEDITOR.dtd[ this.getName() ]; + + this.getDtd = function() + { + return dtd; + }; + + return dtd; + }, + /** * Gets the computed tabindex for this element. @@ -386,4 +422,21 @@ /** + * Gets the text value of this element. + * + * Only in IE (which uses innerText), <br> will cause linebreaks, + * and sucessive whitespaces (including line breaks) will be reduced to + * a single space. This behavior is ok for us, for now. It may change + * in the future. + * @returns {String} The text value. + * @example + * var element = CKEDITOR.dom.element.createFromHtml( '<div>Same <i>text</i>.</div>' ); + * alert( element.getText() ); // "Sample text." + */ + getText : function() + { + return this.$.textContent || this.$.innerText; + }, + + /** * Gets the window object that contains this element. * @returns {CKEDITOR.dom.window} The window object. @@ -462,4 +515,10 @@ { var $ = this.$.firstChild; + return $ ? new CKEDITOR.dom.node( $ ) : null; + }, + + getLast : function() + { + var $ = this.$.lastChild; return $ ? new CKEDITOR.dom.node( $ ) : null; }, @@ -511,4 +570,26 @@ { this.setStyle( 'display', 'none' ); + }, + + moveChildren : function( target, toStart ) + { + var $ = this.$; + target = target.$; + + if ( $ == target ) + return; + + var child; + + if ( toStart ) + { + while ( (child = $.lastChild) ) + target.insertBefore( $.removeChild( child ), target.firstChild ); + } + else + { + while ( (child = $.firstChild) ) + target.appendChild( $.removeChild( child ) ); + } }, @@ -592,15 +673,4 @@ this.$.value = value; return this; - }, - - /** - * Removes the element from the document DOM. - * @example - * var element = CKEDITOR.dom.element.getById( 'MyElement' ); - * element.remove(); - */ - remove : function() - { - this.$.parentNode.removeChild( this.$ ); }, Index: /CKEditor/branches/prototype/_source/core/dom/node.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/node.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/dom/node.js (revision 2573) @@ -63,5 +63,5 @@ * @example */ -CKEDITOR.NODE_ELEMENT = 1; +CKEDITOR.NODE_ELEMENT = 1; /** @@ -70,5 +70,5 @@ * @example */ -CKEDITOR.NODE_TEXT = 3; +CKEDITOR.NODE_TEXT = 3; /** @@ -77,5 +77,7 @@ * @example */ -CKEDITOR.NODE_COMMENT = 8; +CKEDITOR.NODE_COMMENT = 8; + +CKEDITOR.NODE_DOCUMENT_FRAGMENT = 11; CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype, @@ -100,16 +102,7 @@ }, - /** - * Gets the parent element for this node. - * @returns {CKEDITOR.dom.element} The parent element. - * @example - * var node = editor.document.getBody().getFirst(); - * var parent = node.getParent(); - * alert( node.getName() ); // "body" - */ - getParent : function() - { - var parent = this.$.parentNode; - return parent ? new CKEDITOR.dom.element( this.$.parentNode ) : null; + clone : function( includeChildren ) + { + return new CKEDITOR.dom.node( this.$.cloneNode( includeChildren ) ); }, @@ -135,5 +128,5 @@ * Inserts this element before a node. * @param {CKEDITOR.dom.node} node The that will be after this element. - * @returns {CKEDITOR.dom.node} The node after this one after insertion. + * @returns {CKEDITOR.dom.node} The node being inserted. * @example * var em = new CKEDITOR.dom.element( 'em' ); @@ -146,4 +139,11 @@ { node.$.parentNode.insertBefore( this.$, node.$ ); + return node; + }, + + insertBeforeMe : function( node ) + { + this.$.parentNode.insertBefore( node.$, this.$ ); + return node; }, @@ -169,8 +169,83 @@ return rawNode ? new CKEDITOR.dom.node( rawNode ) : null; }, - + getChildCount : function() { return this.$.childNodes.length; + }, + + getIndex : function() + { + var $ = this.$; + + var currentNode = $.parentNode && $.parentNode.firstChild; + var currentIndex = -1; + + while ( currentNode ) + { + currentIndex++; + + if ( currentNode == $ ) + return currentIndex; + + currentNode = currentNode.nextSibling; + } + + return -1; + }, + + /** + * Gets the node following this node (next sibling). + * @returns {CKEDITOR.dom.node} The next node. + */ + getNext : function() + { + var next = this.$.nextSibling; + return next ? new CKEDITOR.dom.node( next ) : null; + }, + + getPrevious : function() + { + var previous = this.$.previousSibling; + return previous ? new CKEDITOR.dom.node( previous ) : null; + }, + + /** + * Gets the parent element for this node. + * @returns {CKEDITOR.dom.element} The parent element. + * @example + * var node = editor.document.getBody().getFirst(); + * var parent = node.getParent(); + * alert( node.getName() ); // "body" + */ + getParent : function() + { + var parent = this.$.parentNode; + return ( parent && parent.nodeType == 1 ) ? new CKEDITOR.dom.element( parent ) : null; + }, + + getParents : function() + { + var node = this; + var parents = []; + + do + { + parents.unshift( node ); + } + while ( ( node = node.getParent() ) ) + + return parents; + }, + + /** + * Removes this node from the document DOM. + * @example + * var element = CKEDITOR.dom.element.getById( 'MyElement' ); + * element.remove(); + */ + remove : function() + { + this.$.parentNode.removeChild( this.$ ); } } Index: /CKEditor/branches/prototype/_source/core/dom/range.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/range.js (revision 2573) +++ /CKEditor/branches/prototype/_source/core/dom/range.js (revision 2573) @@ -0,0 +1,995 @@ +/* + * CKEditor - The text editor for Internet - http://ckeditor.com + * Copyright (C) 2003-2008 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 == + */ + +CKEDITOR.dom.range = function( document ) +{ + this.startContainer = null; + this.startOffset = null; + this.endContainer = null; + this.endOffset = null; + this.collapsed = true; + + this.document = document; +}; + +(function() +{ + // Updates the "collapsed" property for the given range object. + var updateCollapsed = function( range ) + { + range.collapsed = ( range.startContainer.equals( range.endContainer ) && range.startOffset == range.endOffset ); + }; + + // This is a shared function used to delete, extract and clone the range + // contents. + // V2 + var execContentsAction = function( range, action, docFrag ) + { + var startNode = range.startContainer; + var endNode = range.endContainer; + + var startOffset = range.startOffset; + var endOffset = range.endOffset; + + var removeStartNode; + var removeEndNode; + + // For text containers, we must simply split the node and point to the + // second part. The removal will be handled by the rest of the code . + if ( endNode.type == CKEDITOR.NODE_TEXT ) + endNode = endNode.split( endOffset ); + else + { + // If the end container has children and the offset is pointing + // to a child, then we should start from it. + if ( endNode.getChildCount() > 0 ) + { + // If the offset points after the last node. + if ( endOffset >= endNode.getChildCount() ) + { + // Let's create a temporary node and mark it for removal. + endNode = endNode.append( range.document.createText( '' ) ); + removeEndNode = true; + } + else + endNode = endNode.getChild( endOffset ); + } + } + + // For text containers, we must simply split the node. The removal will + // be handled by the rest of the code . + if ( startNode.type == CKEDITOR.NODE_TEXT ) + { + startNode.split( startOffset ); + + // In cases the end node is the same as the start node, the above + // splitting will also split the end, so me must move the end to + // the second part of the split. + if ( startNode.equals( endNode ) ) + endNode = startNode.getNext(); + } + else + { + // If the start container has children and the offset is pointing + // to a child, then we should start from its previous sibling. + + // If the offset points to the first node, we don't have a + // sibling, so let's use the first one, but mark it for removal. + if ( !startOffset ) + { + // Let's create a temporary node and mark it for removal. + startNode = startNode.getFirst().insertBeforeMe( range.document.createText( '' ) ); + removeStartNode = true; + } + else if ( startOffset >= startNode.getChildCount() ) + { + // Let's create a temporary node and mark it for removal. + startNode = startNode.append( range.document.createText( '' ) ); + removeStartNode = true; + } + else + startNode = startNode.getChild( startOffset ).getPrevious(); + } + + // Get the parent nodes tree for the start and end boundaries. + var startParents = startNode.getParents(); + var endParents = endNode.getParents(); + + // Compare them, to find the top most siblings. + var i, topStart, topEnd; + + for ( i = 0 ; i < startParents.length ; i++ ) + { + topStart = startParents[ i ]; + topEnd = endParents[ i ]; + + // The compared nodes will match until we find the top most + // siblings (different nodes that have the same parent). + // "i" will hold the index in the parents array for the top + // most element. + if ( !topStart.equals( topEnd ) ) + break; + } + + var clone = docFrag, levelStartNode, levelClone, currentNode, currentSibling; + + // Remove all successive sibling nodes for every node in the + // startParents tree. + for ( var j = i ; j < startParents.length ; j++ ) + { + levelStartNode = startParents[j]; + + // For Extract and Clone, we must clone this level. + if ( clone && !levelStartNode.equals( startNode ) ) // action = 0 = Delete + levelClone = clone.append( levelStartNode.clone() ); + + currentNode = levelStartNode.getNext(); + + while( currentNode ) + { + // Stop processing when the current node matches a node in the + // endParents tree or if it is the endNode. + if ( currentNode.equals( endParents[ j ] ) || currentNode.equals( endNode ) ) + break; + + // Cache the next sibling. + currentSibling = currentNode.getNext(); + + // If cloning, just clone it. + if ( action == 2 ) // 2 = Clone + clone.append( currentNode.clone( true ) ); + else + { + // Both Delete and Extract will remove the node. + currentNode.remove(); + + // When Extracting, move the removed node to the docFrag. + if ( action == 1 ) // 1 = Extract + clone.append( currentNode ); + } + + currentNode = currentSibling; + } + + if ( clone ) + clone = levelClone; + } + + clone = docFrag; + + // Remove all previous sibling nodes for every node in the + // endParents tree. + for ( var k = i ; k < endParents.length ; k++ ) + { + levelStartNode = endParents[ k ]; + + // For Extract and Clone, we must clone this level. + if ( action > 0 && !levelStartNode.equals( endNode ) ) // action = 0 = Delete + levelClone = clone.append( levelStartNode.clone() ); + + // The processing of siblings may have already been done by the parent. + if ( !startParents[ k ] || levelStartNode.$.parentNode != startParents[ k ].$.parentNode ) + { + currentNode = levelStartNode.getPrevious(); + + while( currentNode ) + { + // Stop processing when the current node matches a node in the + // startParents tree or if it is the startNode. + if ( currentNode.equals( startParents[ k ] ) || currentNode.equals( startNode ) ) + break; + + // Cache the next sibling. + currentSibling = currentNode.getPrevious(); + + // If cloning, just clone it. + if ( action == 2 ) // 2 = Clone + clone.$.insertBefore( currentNode.$.cloneNode( true ), clone.$.firstChild ) ; + else + { + // Both Delete and Extract will remove the node. + currentNode.remove(); + + // When Extracting, mode the removed node to the docFrag. + if ( action == 1 ) // 1 = Extract + clone.$.insertBefore( currentNode.$, clone.$.firstChild ); + } + + currentNode = currentSibling; + } + } + + if ( clone ) + clone = levelClone; + } + + if ( action == 2 ) // 2 = Clone. + { + // No changes in the DOM should be done, so fix the split text (if any). + + var startTextNode = range.startContainer; + if ( startTextNode.type == CKEDITOR.NODE_TEXT ) + { + startTextNode.$.data += startTextNode.$.nextSibling.data; + startTextNode.$.parentNode.removeChild( startTextNode.$.nextSibling ); + } + + var endTextNode = range.endContainer; + if ( endTextNode.type == CKEDITOR.NODE_TEXT && endTextNode.$.nextSibling ) + { + endTextNode.$.data += endTextNode.$.nextSibling.data; + endTextNode.$.parentNode.removeChild( endTextNode.$.nextSibling ); + } + } + else + { + // Collapse the range. + + // If a node has been partially selected, collapse the range between + // topStart and topEnd. Otherwise, simply collapse it to the start. (W3C specs). + if ( topStart && topEnd && ( startNode.$.parentNode != topStart.$.parentNode || endNode.$.parentNode != topEnd.$.parentNode ) ) + { + var endIndex = topEnd.getIndex(); + + // If the start node is to be removed, we must correct the + // index to reflect the removal. + if ( removeStartNode && topEnd.$.parentNode == startNode.$.parentNode ) + endIndex--; + + range.setStart( topEnd.getParent(), endIndex ); + } + + // Collapse it to the start. + range.collapse( true ); + } + + // Cleanup any marked node. + if( removeStartNode ) + startNode.remove(); + + if( removeEndNode && endNode.$.parentNode ) + endNode.remove(); + }; + + CKEDITOR.dom.range.prototype = + { + clone : function() + { + var clone = new CKEDITOR.dom.range( this.document ); + + clone.startContainer = this.startContainer; + clone.startOffset = this.startOffset; + clone.endContainer = this.endContainer; + clone.endOffset = this.endOffset; + clone.collapsed = this.collapsed; + + return clone; + }, + + collapse : function( toStart ) + { + if ( toStart ) + { + this.endContainer = this.startContainer; + this.endOffset = this.startOffset; + } + else + { + this.startContainer = this.endContainer; + this.startOffset = this.endOffset; + } + + this.collapsed = true; + }, + + // The selection may be lost when cloning (due to the splitText() call). + cloneContents : function() + { + var docFrag = new CKEDITOR.dom.documentFragment( this.document ); + + if ( !this.collapsed ) + execContentsAction( this, 2, docFrag ); + + return docFrag; + }, + + deleteContents : function() + { + if ( this.collapsed ) + return; + + execContentsAction( this, 0 ); + }, + + extractContents : function() + { + var docFrag = new CKEDITOR.dom.documentFragment( this.document ); + + if ( !this.collapsed ) + execContentsAction( this, 1, docFrag ); + + return docFrag; + }, + + // This is an "intrusive" way to create a bookmark. It includes 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. + createBookmark : function() + { + var startNode, endNode; + var clone; + + startNode = this.document.createElement( 'span' ); + startNode.setAttribute( '_fck_bookmark', 1 ); + startNode.setStyle( 'display', 'display' ); + + // For IE, it must have something inside, otherwise it may be + // removed during DOM operations. + startNode.setHtml( ' ' ); + + // If collapsed, the endNode will not be created. + if ( !this.collapsed ) + { + endNode = startNode.clone(); + + clone = this.clone(); + clone.collapse(); + clone.insertNode( endNode ); + } + + clone = this.clone(); + clone.collapse( true ); + clone.insertNode( startNode ); + + // Update the range position. + if ( endNode ) + { + this.setStart( startNode, CKEDITOR.POSITION_AFTER_END ); + this.setEnd( endNode, CKEDITOR.POSITION_BEFORE_START ); + } + else + this.moveToPosition( startNode, CKEDITOR.POSITION_AFTER_END ); + + return { + startNode : startNode, + endNode : endNode + }; + }, + + getCommonAncestor : function() + { + var start = this.startContainer; + var end = this.endContainer; + + if ( start.equals( end ) ) + return start; + + if ( end.type == CKEDITOR.NODE_ELEMENT && end.contains( start ) ) + return end; + + if ( start.type != CKEDITOR.NODE_ELEMENT ) + start = start.getParent(); + + do + { + if ( start.contains( end ) ) + return start; + } + while( ( start = start.getParent() ) ) + + return null; + }, + + trim : function( ignoreStart, ignoreEnd ) + { + var startContainer = this.startContainer; + var startOffset = this.startOffset; + + var endContainer = this.endContainer; + var endOffset = this.endOffset; + + if ( !ignoreStart && startContainer.type == CKEDITOR.NODE_TEXT ) + { + // If the offset is zero, we just insert the new node before + // the start. + if ( !startOffset ) + { + startOffset = startContainer.getIndex(); + startContainer = startContainer.getParent(); + } + // If the offset is at the end, we'll insert it after the text + // node. + else if ( startOffset >= startContainer.getLength() ) + { + startOffset = startContainer.getIndex() + 1; + startContainer = startContainer.getParent(); + } + // In other case, we split the text node and insert the new + // node at the split point. + else + { + var nextText = startContainer.split( startOffset ); + + startOffset = startContainer.getIndex() + 1; + startContainer = startContainer.getParent(); + + // Check if it is necessary to update the end boundary. + if ( this.collapsed ) + this.setEnd( startContainer, startOffset ); + else if ( this.startContainer.equals( this.endContainer ) ) + this.setEnd( nextText, this.endOffset - this.startOffset ); + } + + this.setStart( startContainer, startOffset ); + } + + if ( !ignoreEnd && !this.collapsed && endContainer.type == CKEDITOR.NODE_TEXT ) + { + // If the offset is zero, we just insert the new node before + // the start. + if ( !endOffset ) + { + endOffset = endContainer.getIndex(); + endContainer = endContainer.getParent(); + } + // If the offset is at the end, we'll insert it after the text + // node. + else if ( endOffset >= endContainer.getLength() ) + { + endOffset = endContainer.getIndex() + 1; + endContainer = endContainer.getParent(); + } + // In other case, we split the text node and insert the new + // node at the split point. + else + { + endContainer.split( endOffset ); + + endOffset = endContainer.getIndex() + 1; + endContainer = endContainer.getParent(); + } + + this.setEnd( endContainer, endOffset ); + } + }, + + enlarge : function( unit ) + { + switch ( unit ) + { + case CKEDITOR.ENLARGE_ELEMENT : + + if ( this.collapsed ) + return; + + // Get the common ancestor. + var commonAncestor = this.getCommonAncestor(); + + // 1. For each boundary: + // a. Depending on its position, find out the first node to be checked (a sibling) or, if not available, to be enlarge. + // b. Go ahead checking siblings and enlarging the boundary as much as possible until the common ancestor is not reached. After reaching the common ancestor, just save the enlargeable node to be used later. + // 2. + + var startTop, endTop; + + var enlargeable, sibling, commonReached; + + // Indicates that the node can be added only if whitespace + // is available before it. + var needsWhiteSpace = false; + var isWhiteSpace; + var siblingText; + + // Process the start boundary. + + var container = this.startContainer; + var offset = this.startOffset; + + if ( container.type == CKEDITOR.NODE_TEXT ) + { + if ( offset ) + { + // Check if there is any non-space text before the + // offset. Otherwise, container is null. + container = !CKEDITOR.tools.trim( container.substring( 0, offset ) ).length && container; + + // If we found only whitespace in the node, it + // means that we'll need more whitespace to be able + // to expand. For example, can be expanded in + // "A [B]", but not in "A [B]". + needsWhiteSpace = !!container; + } + + if ( container ) + { + if ( !( sibling = container.getPrevious() ) ) + enlargeable = container.getParent(); + } + } + else + { + // If we have offset, get the node preceeding it as the + // first sibling to be checked. + if ( offset ) + sibling = container.getChild( offset - 1 ) || container.getLast(); + + // If there is no sibling, mark the container to be + // enlarged. + if ( !sibling ) + enlargeable = container; + } + + while ( enlargeable || sibling ) + { + if ( enlargeable && !sibling ) + { + // If we reached the common ancestor, mark the flag + // for it. + if ( !commonReached && enlargeable.equals( commonAncestor ) ) + commonReached = true; + + // If we don't need space or this element breaks + // the line, then enlarge it. + if ( !needsWhiteSpace || enlargeable.getComputedStyle( 'display' ) != 'inline' ) + { + needsWhiteSpace = false; + + // If the common ancestor has been reached, + // we'll not enlarge it immediately, but just + // mark it to be enlarged later if the end + // boundary also enlarges it. + if ( commonReached ) + startTop = enlargeable; + else + this.setStartBefore( enlargeable ); + } + + sibling = enlargeable.getPrevious(); + } + + // Check all sibling nodes preceeding the enlargeable + // node. The node wil lbe enlarged only if none of them + // blocks it. + while ( sibling ) + { + // This flag indicates that this node has + // whitespaces at the end. + isWhiteSpace = false; + + if ( sibling.type == CKEDITOR.NODE_TEXT ) + { + siblingText = sibling.getText(); + + if ( /[^\s]/.test( siblingText ) ) + sibling = null; + + isWhiteSpace = /\s$/.test( siblingText ); + } + else + { + // If this is a visible element. + if ( sibling.$.offsetWidth > 0 ) + { + // We'll accept it only if we need + // whitespace, and this is an inline + // element with whitespace only. + if ( needsWhiteSpace && CKEDITOR.dtd.$removeEmpty[ sibling.getName() ] ) + { + // It must contains spaces and inline elements only. + + var siblingText = sibling.getText(); + + if ( !(/[^\s]/).test( siblingText ) ) + sibling = null; + else + { + var allChildren = sibling.$.all || sibling.$.getElementsByTagName( '*' ); + for ( var i = 0, child ; child = allChildren[ i++ ] ; ) + { + if ( !CKEDITOR.dtd.$removeEmpty[ child.nodeName.toLowerCase() ] ) + { + sibling = null; + break; + } + } + } + + if ( sibling ) + isWhiteSpace = !!siblingText.length; + } + else + sibling = null; + } + } + + // A node with whitespaces has been found. + if ( isWhiteSpace ) + { + // Enlarge the last enlargeable node, if we + // were waiting for spaces. + if ( needsWhiteSpace ) + { + if ( commonReached ) + startTop = enlargeable; + else + this.setStartBefore( enlargeable ); + } + else + needsWhiteSpace = true; + } + + if ( sibling ) + { + var next = sibling.getPrevious(); + + if ( !enlargeable && !next ) + { + // Set the sibling as enlargeable, so it's + // parent will be get later outside this while. + enlargeable = sibling; + sibling = null; + break; + } + + sibling = next; + } + else + { + // If sibling has been set to null, then we + // need to stop enlarging. + enlargeable = null; + } + } + + if ( enlargeable ) + enlargeable = enlargeable.getParent(); + } + + // Process the end boundary. This is basically the same + // code used for the start boundary, with small changes to + // make it work in the oposite side (to the right). This + // makes it difficult to reuse the code here. So, fixes to + // the above code are likely to be replicated here. + + container = this.endContainer; + offset = this.endOffset; + + // Reset the common variables. + enlargeable = sibling = null; + commonReached = needsWhiteSpace = false; + + if ( container.type == CKEDITOR.NODE_TEXT ) + { + // Check if there is any non-space text after the + // offset. Otherwise, container is null. + container = !CKEDITOR.tools.trim( container.substring( offset ) ).length && container; + + // If we found only whitespace in the node, it + // means that we'll need more whitespace to be able + // to expand. For example, can be expanded in + // "A [B]", but not in "A [B]". + needsWhiteSpace = !( container && container.getLength() ); + + if ( container ) + { + if ( !( sibling = container.getNext() ) ) + enlargeable = container.getParent(); + } + } + else + { + if ( offset ) + sibling = container.getChild( offset ); + + if ( !sibling ) + enlargeable = container; + } + + while ( enlargeable || sibling ) + { + if ( enlargeable && !sibling ) + { + if ( !commonReached && enlargeable.equals( commonAncestor ) ) + commonReached = true; + + if ( !needsWhiteSpace || enlargeable.getComputedStyle( 'display' ) != 'inline' ) + { + needsWhiteSpace = false; + + if ( commonReached ) + endTop = enlargeable; + else + this.setEndAfter( enlargeable ); + } + + sibling = enlargeable.getNext(); + } + + while ( sibling ) + { + isWhiteSpace = false; + + if ( sibling.type == CKEDITOR.NODE_TEXT ) + { + siblingText = sibling.getText(); + + if ( /[^\s]/.test( siblingText ) ) + sibling = null; + + isWhiteSpace = /^\s/.test( siblingText ); + } + else + { + // If this is a visible element. + if ( sibling.$.offsetWidth > 0 ) + { + // We'll accept it only if we need + // whitespace, and this is an inline + // element with whitespace only. + if ( needsWhiteSpace && CKEDITOR.dtd.$removeEmpty[ sibling.getName() ] ) + { + // It must contains spaces and inline elements only. + + var siblingText = sibling.getText(); + + if ( !(/[^\s]/).test( siblingText ) ) + sibling = null; + else + { + var allChildren = sibling.$.all || sibling.$.getElementsByTagName( '*' ); + for ( var i = 0, child ; child = allChildren[ i++ ] ; ) + { + if ( !CKEDITOR.dtd.$removeEmpty[ child.nodeName.toLowerCase() ] ) + { + sibling = null; + break; + } + } + } + + if ( sibling ) + isWhiteSpace = !!siblingText.length; + } + else + sibling = null; + } + } + + if ( isWhiteSpace ) + { + if ( needsWhiteSpace ) + { + if ( commonReached ) + endTop = enlargeable; + else + this.setEndAfter( enlargeable ); + } + } + + if ( sibling ) + { + var next = sibling.getNext(); + + if ( !enlargeable && !next ) + { + enlargeable = sibling; + sibling = null; + break; + } + + sibling = next; + } + else + { + // If sibling has been set to null, then we + // need to stop enlarging. + enlargeable = null; + } + } + + if ( enlargeable ) + enlargeable = enlargeable.getParent(); + } + + // If the common ancestor can be enlarged by both boundaries, then include it also. + if ( startTop && endTop ) + { + commonAncestor = startTop.contains( endTop ) ? endTop : startTop; + + this.setStartBefore( commonAncestor ); + this.setEndAfter( commonAncestor ); + } + } + }, + + /** + * Inserts a node at the start of the range. The range will be expanded + * the contain the node. + */ + insertNode : function( node ) + { + this.trim( false, true ); + + var startContainer = this.startContainer; + var startOffset = this.startOffset; + + var nextNode = startContainer.getChild( startOffset ); + + if ( nextNode ) + node.insertBefore( nextNode ); + else + startContainer.append( node ); + + // Check if we need to update the end boundary. + if ( node.getParent().equals( this.endContainer ) ) + this.endOffset++; + + // Expand the range to embrace the new node. + this.setStartBefore( node ); + }, + + moveToPosition : function( node, position ) + { + this.setStartAt( node, position ); + this.collapse( true ); + }, + + selectNodeContents : function( node ) + { + this.setStart( node, 0 ); + this.setEnd( node, node.type == CKEDITOR.NODE_TEXT ? node.getLength() : node.getChildCount() ); + }, + + /** + * Sets the start position of a Range. + * @param {CKEDITOR.dom.node} startNode The node to start the range. + * @param {Number} startOffset An integer greater than or equal to zero + * representing the offset for the start of the range from the start + * of startNode. + */ + setStart : function( startNode, startOffset ) + { + // W3C requires a check for the new position. If it is after the end + // boundary, the range should be collapsed to the new start. It seams + // we will not need this check for our use of this class so we can + // ignore it for now. + + this.startContainer = startNode; + this.startOffset = startOffset; + + if ( !this.endContainer ) + { + this.endContainer = startNode; + this.endOffset = startOffset; + } + + updateCollapsed( this ); + }, + + /** + * Sets the end position of a Range. + * @param {CKEDITOR.dom.node} endNode The node to end the range. + * @param {Number} endOffset An integer greater than or equal to zero + * representing the offset for the end of the range from the start + * of endNode. + */ + setEnd : function( endNode, endOffset ) + { + // W3C requires a check for the new position. If it is before the start + // boundary, the range should be collapsed to the new end. It seams we + // will not need this check for our use of this class so we can ignore + // it for now. + + this.endContainer = endNode; + this.endOffset = endOffset; + + if ( !this.startContainer ) + { + this.startContainer = endNode; + this.startOffset = endOffset; + } + + updateCollapsed( this ); + }, + + setStartAfter : function( node ) + { + this.setStart( node.getParent(), node.getIndex() + 1 ); + }, + + setStartBefore : function( node ) + { + this.setStart( node.getParent(), node.getIndex() ); + }, + + setEndAfter : function( node ) + { + this.setEnd( node.getParent(), node.getIndex() + 1 ); + }, + + setEndBefore : function( node ) + { + this.setEnd( node.getParent(), node.getIndex() ); + }, + + setStartAt : function( node, position ) + { + switch( position ) + { + case CKEDITOR.POSITION_AFTER_START : + this.setStart( node, 0 ); + break; + + case CKEDITOR.POSITION_BEFORE_END : + if ( node.type == CKEDITOR.NODE_TEXT ) + this.setStart( node, node.getLength() ); + else + this.setStart( node, node.getChildCount() ); + break; + + case CKEDITOR.POSITION_BEFORE_START : + this.setStartBefore( node ); + break; + + case CKEDITOR.POSITION_AFTER_END : + this.setStartAfter( node ); + } + + updateCollapsed( this ); + }, + + setEndAt : function( node, position ) + { + switch( position ) + { + case CKEDITOR.POSITION_AFTER_START : + this.setEnd( node, 0 ); + break; + + case CKEDITOR.POSITION_BEFORE_END : + if ( node.type == CKEDITOR.NODE_TEXT ) + this.setEnd( node, node.getLength() ); + else + this.setEnd( node, node.getChildCount() ); + break; + + case CKEDITOR.POSITION_BEFORE_START : + this.setEndBefore( node ); + break; + + case CKEDITOR.POSITION_AFTER_END : + this.setEndAfter( node ); + } + + updateCollapsed( this ); + } + }; +})(); + +CKEDITOR.POSITION_AFTER_START = 1; // ^contents "^text" +CKEDITOR.POSITION_BEFORE_END = 2; // contents^ "text^" +CKEDITOR.POSITION_BEFORE_START = 3; // ^contents ^"text" +CKEDITOR.POSITION_AFTER_END = 4; // contents^ "text" + +CKEDITOR.ENLARGE_ELEMENT = 1; Index: /CKEditor/branches/prototype/_source/core/dom/text.js =================================================================== --- /CKEditor/branches/prototype/_source/core/dom/text.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/dom/text.js (revision 2573) @@ -62,2 +62,56 @@ CKEDITOR.dom.text.prototype = new CKEDITOR.dom.node(); + +CKEDITOR.tools.extend( CKEDITOR.dom.text.prototype, + /** @lends CKEDITOR.dom.text.prototype */ + { + /** + * The node type. This is a constant value set to + * {@link CKEDITOR.NODE_TEXT}. + * @type Number + * @example + */ + type : CKEDITOR.NODE_TEXT, + + getLength : function() + { + return this.$.nodeValue.length; + }, + + getText : function() + { + return this.$.nodeValue; + }, + + /** + * Breaks this text node into two nodes at the specified offset, + * keeping both in the tree as siblings. This node then only contains + * all the content up to the offset point. A new text node, which is + * inserted as the next sibling of this node, contains all the content + * at and after the offset point. When the offset is equal to the + * length of this node, the new node has no data. + * @param {Number} The position at which to split, starting from zero. + * @returns {CKEDITOR.dom.text} The new text node. + */ + split : function( offset ) + { + return new CKEDITOR.dom.text( this.$.splitText( offset ) ); + }, + + /** + * Extracts characters from indexA up to but not including indexB. + * @param {Number} indexA An integer between 0 and one less than the + * length of the text. + * @param {Number} [indexB] An integer between 0 and the length of the + * string. If omitted, extracts characters to the end of the text. + */ + substring : function( indexA, indexB ) + { + // We need the following check due to a Firefox bug + // https://bugzilla.mozilla.org/show_bug.cgi?id=458886 + if ( typeof indexB != 'number' ) + return this.$.nodeValue.substr( indexA ); + else + return this.$.nodeValue.substring( indexA, indexB ); + } + }); Index: /CKEditor/branches/prototype/_source/core/loader.js =================================================================== --- /CKEditor/branches/prototype/_source/core/loader.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/loader.js (revision 2573) @@ -40,5 +40,5 @@ var scripts = { - 'core/_bootstrap' : [ 'core/config', 'core/ckeditor', 'core/plugins', 'core/scriptloader', 'core/tools', /* The following are entries that we wnat to force loading to at the end to avoid dependence recursion */ 'core/dom/text' ], + 'core/_bootstrap' : [ 'core/config', 'core/ckeditor', 'core/plugins', 'core/scriptloader', 'core/tools', /* The following are entries that we wnat to force loading to at the end to avoid dependence recursion */ 'core/dom/text', 'core/dom/range' ], 'core/ajax' : [ 'core/xml' ], 'core/ckeditor' : [ 'core/ajax', 'core/ckeditor_basic', 'core/dom', 'core/dtd', 'core/dom/document', 'core/dom/element', 'core/editor', 'core/event', 'core/htmlparser', 'core/htmlparser/element', 'core/htmlparser/fragment', 'core/tools' ], @@ -48,8 +48,10 @@ 'core/dom' : [], 'core/dom/document' : [ 'core/dom','core/dom/element', 'core/dom/domobject', 'core/dom/window' ], + 'core/dom/documentfragment' : [ 'core/dom/element' ], 'core/dom/element' : [ 'core/dom', 'core/dom/document', 'core/dom/domobject', 'core/dom/node', 'core/tools' ], 'core/dom/event' : [], 'core/dom/node' : [ 'core/dom/domobject', 'core/tools' ], 'core/dom/domobject' : [ 'core/dom/event' ], + 'core/dom/range' : [ 'core/dom/document', 'core/dom/documentfragment', 'core/dom/element' ], 'core/dom/text' : [ 'core/dom/node', 'core/dom/domobject' ], 'core/dom/window' : [ 'core/dom/domobject' ], Index: /CKEditor/branches/prototype/_source/core/test.js =================================================================== --- /CKEditor/branches/prototype/_source/core/test.js (revision 2572) +++ /CKEditor/branches/prototype/_source/core/test.js (revision 2573) @@ -73,10 +73,10 @@ * Gets the inner HTML of an element, for testing purposes. */ - getInnerHtml : function( elementId ) + getInnerHtml : function( elementOrId ) { - var html = document.getElementById( elementId ).innerHTML; + var html = ( elementOrId.nodeType ? elementOrId : document.getElementById( elementOrId ) ).innerHTML; html = html.toLowerCase(); - html = html.replace( /"/g, '' ); - html = html.replace( /\s+_cke_expando=\d+/, '' ); + html = html.replace( /["\n\r]/g, '' ); + html = html.replace( /\s+_cke_expando=\d+/g, '' ); return html; } Index: /CKEditor/branches/prototype/_source/tests/core/dom/element.html =================================================================== --- /CKEditor/branches/prototype/_source/tests/core/dom/element.html (revision 2572) +++ /CKEditor/branches/prototype/_source/tests/core/dom/element.html (revision 2573) @@ -444,4 +444,32 @@ assert.areNotSame( a._, b._ ); + }, + + test_getText1 : function() + { + var element = new CKEDITOR.dom.element( document.getElementById( 'getText' ) ); + + // IE gives us a different result, which is ok for us (see code comments). + if ( CKEDITOR.env.ie ) + assert.areSame( 'Some \nsample text for testing', element.getText().replace( /\r\n|\r/g, '\n' ) ); + else + assert.areSame( 'Some sample text for testing', element.getText() ); + }, + + test_getText2 : function() + { + var element = new CKEDITOR.dom.element( document.getElementById( 'getText2' ).getElementsByTagName( 'b' )[0] ); + assert.areSame( ' ', element.getText() ); + }, + + test_getText3 : function() + { + var element = new CKEDITOR.dom.element( document.getElementById( 'getText3' ) ); + + // IE gives us a different result, which is ok for us (see code comments). + if ( CKEDITOR.env.ie ) + assert.areSame( 'A B', element.getText() ); + else + assert.areSame( 'A\nB', element.getText().replace( /\r\n|\r/g, '\n' ) ); }, @@ -468,4 +496,8 @@ +
Some
sample text for testing
+
A B
+
A +B
Index: /CKEditor/branches/prototype/_source/tests/core/dom/range.html =================================================================== --- /CKEditor/branches/prototype/_source/tests/core/dom/range.html (revision 2573) +++ /CKEditor/branches/prototype/_source/tests/core/dom/range.html (revision 2573) @@ -0,0 +1,1672 @@ + + + + CKEDITOR.dom.range + + + + + + + + + + + Index: /CKEditor/branches/prototype/_source/tests/core/dom/text.html =================================================================== --- /CKEditor/branches/prototype/_source/tests/core/dom/text.html (revision 2573) +++ /CKEditor/branches/prototype/_source/tests/core/dom/text.html (revision 2573) @@ -0,0 +1,69 @@ + + + + CKEDITOR.dom.text + + + + + + +

0123456789

+ + Index: /CKEditor/branches/prototype/_source/tests/core/dom/window.html =================================================================== --- /CKEditor/branches/prototype/_source/tests/core/dom/window.html (revision 2572) +++ /CKEditor/branches/prototype/_source/tests/core/dom/window.html (revision 2573) @@ -2,5 +2,5 @@ - CKEDITOR.dom.document + CKEDITOR.dom.window Index: /CKEditor/branches/prototype/_source/tests/test.js =================================================================== --- /CKEditor/branches/prototype/_source/tests/test.js (revision 2572) +++ /CKEditor/branches/prototype/_source/tests/test.js (revision 2573) @@ -71,5 +71,18 @@ { case runner.TEST_FAIL_EVENT: - outputResult( 'FAIL Test named "' + data.testName + '" failed with message: "' + htmlEncode( data.error.message ) + '".
Expected:
' + htmlEncode( data.error.expected ) + '
Actual:
' + htmlEncode( data.error.actual ) + '
' ); + + var expected = data.error.expected; + if ( expected && expected.nodeType ) + expected += ' (' + ( expected.nodeType == 1 ? expected.nodeName : expected.nodeValue ) + ')'; + + var actual = data.error.actual; + if ( actual && actual.nodeType ) + actual += ' (' + ( actual.nodeType == 1 ? actual.nodeName : actual.nodeValue ) + ')'; + + outputResult( + 'FAIL Test named "' + data.testName + + '" failed with message: "' + htmlEncode( data.error.message ) + + '".
Expected:
' + htmlEncode( expected ) + 
+						'
Actual:
' + htmlEncode( actual ) + '
' ); break; case runner.TEST_PASS_EVENT: Index: /CKEditor/branches/prototype/_source/tests/testall.html =================================================================== --- /CKEditor/branches/prototype/_source/tests/testall.html (revision 2572) +++ /CKEditor/branches/prototype/_source/tests/testall.html (revision 2573) @@ -15,4 +15,6 @@ 'core/dom/document', 'core/dom/element', + 'core/dom/range', + 'core/dom/window', 'core/env', 'core/event',