Ticket #6485: 6485_5.patch

_source/plugins/bidi/plugin.js

@@ -1 @@
-/*
+/*
 Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.html or http://ckeditor.com/license
 */
 
 (function()
 {
-        var guardElements = { table:1, ul:1, ol:1, blockquote:1, div:1 },
+        var guardElements = { table:1, tbody: 1, ul:1, ol:1, blockquote:1, div:1, tr: 1 },
                 directSelectionGuardElements = {},
                 // All guard elements which can have a direction applied on them.
                 allGuardElements = {};
@@ -130 +130 @@
                 return null;
         }
 
-        function getFullySelected( selection, elements )
+        function getFullySelected( range, elements )
         {
-                var ancestor = selection.getCommonAncestor();
-                if ( ancestor.type != CKEDITOR.NODE_ELEMENT )
-                        return;
+                var ancestor = range.getCommonAncestor( false, true );
 
-                var ranges = selection.getRanges();
-
-                // Join multiple ranges.
-                var range = new CKEDITOR.dom.range( selection.document );
-                range.setStart( ranges[ 0 ].startContainer, ranges[ 0 ].startOffset );
-                range.setEnd( ranges[ ranges.length - 1 ].endContainer, ranges[ ranges.length - 1 ].endOffset );
-
                 range.enlarge( CKEDITOR.ENLARGE_BLOCK_CONTENTS );
 
                 if ( range.checkBoundaryOfElement( ancestor, CKEDITOR.START )
                                 && range.checkBoundaryOfElement( ancestor, CKEDITOR.END ) )
                 {
-                        while ( ancestor.type == CKEDITOR.NODE_ELEMENT
-                                        && !( ancestor.getName() in elements )
-                                        && ancestor.getParent().getChildCount() == 1
+                        var parent;
+                        while ( ancestor && ancestor.type == CKEDITOR.NODE_ELEMENT
+                                        && ( parent = ancestor.getParent() )
+                                        && parent.getChildCount() == 1
+                                        && ( !( ancestor.getName() in elements ) || ( parent.getName() in elements ) )
                                         )
-                                ancestor = ancestor.getParent();
+                                ancestor = parent;
 
                         return ancestor.type == CKEDITOR.NODE_ELEMENT
                                         && ( ancestor.getName() in elements )
@@ -171 +164 @@
                         if ( ranges && ranges.length )
                         {
                                 var database = {};
-                                // Apply do directly selected elements from guardElements.
-                                var selectedElement = ranges[ 0 ].getEnclosedNode();
+
+                                // Creates bookmarks for selection, as we may split some blocks.
+                                var bookmarks = selection.createBookmarks();
+
+                                var rangeIterator = ranges.createIterator(),
+                                        range,
+                                        i = 0;
+
+                                while ( ( range = rangeIterator.getNextRange( 1 ) ) )
+                                {
+                                        // Apply do directly selected elements from guardElements.
+                                        var selectedElement = range.getEnclosedNode();
 
-                                // If this is not our element of interest, apply to fully selected elements from guardElements.
-                                if ( !selectedElement || selectedElement
-                                                && !( selectedElement.type == CKEDITOR.NODE_ELEMENT && selectedElement.getName() in directSelectionGuardElements )
-                                        )
-                                        selectedElement = getFullySelected( selection, guardElements );
+                                        // If this is not our element of interest, apply to fully selected elements from guardElements.
+                                        if ( !selectedElement || selectedElement
+                                                        && !( selectedElement.type == CKEDITOR.NODE_ELEMENT && selectedElement.getName() in directSelectionGuardElements )
+                                                )
+                                                selectedElement = getFullySelected( range, guardElements );
 
-                                if ( selectedElement && !selectedElement.isReadOnly() )
-                                        switchDir( selectedElement, dir, editor, database );
-                                
-                                // Creates bookmarks for selection, as we may split some blocks.
-                                var bookmarks = selection.createBookmarks();
-
-                                var iterator,
-                                        block;
+                                        if ( selectedElement && !selectedElement.isReadOnly() )
+                                                switchDir( selectedElement, dir, editor, database );
+
+                                        var iterator,
+                                                block;
 
-                                for ( var i = ranges.length - 1 ; i >= 0 ; i-- )
-                                {
-                                        // Array of elements processed as guardElements.
-                                        var processedElements = [];
                                         // Walker searching for guardElements.
-                                        var walker = new CKEDITOR.dom.walker( ranges[ i ] );
+                                        var walker = new CKEDITOR.dom.walker( range );
+
+                                        var start = bookmarks[ i ].startNode,
+                                                end = bookmarks[ i++ ].endNode;
+
                                         walker.evaluator = function( node )
                                         {
-                                                return node.type == CKEDITOR.NODE_ELEMENT
-                                                        && node.getName() in guardElements
-                                                        && !( node.getName() == ( enterMode == CKEDITOR.ENTER_P ) ? 'p' : 'div'
-                                                                && node.getParent().type == CKEDITOR.NODE_ELEMENT
-                                                                && node.getParent().getName() == 'blockquote'
-                                                        );
+                                                return !! ( node.type == CKEDITOR.NODE_ELEMENT
+                                                                && node.getName() in guardElements
+                                                                && !( node.getName() == ( enterMode == CKEDITOR.ENTER_P ) ? 'p' : 'div'
+                                                                        && node.getParent().type == CKEDITOR.NODE_ELEMENT
+                                                                        && node.getParent().getName() == 'blockquote' )
+                                                                // Element must be fully included in the range as well. (#6485).
+                                                                && node.getPosition( start ) & CKEDITOR.POSITION_FOLLOWING
+                                                                && ( ( node.getPosition( end ) & CKEDITOR.POSITION_PRECEDING + CKEDITOR.POSITION_CONTAINS ) == CKEDITOR.POSITION_PRECEDING ) );
                                         };
 
                                         while ( ( block = walker.next() ) )
                                                 switchDir( block, dir, editor, database );
 
-                                        iterator = ranges[ i ].createIterator();
+                                        iterator = range.createIterator();
                                         iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
 
                                         while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) )
                                                 !block.isReadOnly() && switchDir( block, dir, editor, database );
+                                }
 
-                                        CKEDITOR.dom.element.clearAllMarkers( database );
+                                CKEDITOR.dom.element.clearAllMarkers( database );
 
-                                        editor.forceNextSelectionCheck();
-                                        // Restore selection position.
-                                        selection.selectBookmarks( bookmarks );
-                                }
+                                editor.forceNextSelectionCheck();
+                                // Restore selection position.
+                                selection.selectBookmarks( bookmarks );
 
                                 editor.focus();
                         }

_source/core/dom/walker.js

@@ -385 +385 @@
                                                 && isBookmarkNode( parent ) );
                         // Is bookmark node?
                         isBookmark = contentOnly ? isBookmark : isBookmark || isBookmarkNode( node );
-                        return isReject ^ isBookmark;
+                        return !! ( isReject ^ isBookmark );
                 };
         };
 
@@ -399 +399 @@
                 {
                         var isWhitespace = node && ( node.type == CKEDITOR.NODE_TEXT )
                                                         && !CKEDITOR.tools.trim( node.getText() );
-                        return isReject ^ isWhitespace;
+                        return !! ( isReject ^ isWhitespace );
                 };
         };
 
@@ -418 +418 @@
                         // 'offsetHeight' instead of 'offsetWidth' for properly excluding
                         // all sorts of empty paragraph, e.g. <br />.
                         var isInvisible = whitespace( node ) || node.is && !node.$.offsetHeight;
-                        return isReject ^ isInvisible;
+                        return !! ( isReject ^ isInvisible );
                 };
         };
 

_source/plugins/domiterator/plugin.js

@@ -65 +65 @@
                                                            CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS : CKEDITOR.ENLARGE_BLOCK_CONTENTS );
 
                                 var walker = new CKEDITOR.dom.walker( range ),
-                                        ignoreBookmarkTextEvaluator = CKEDITOR.dom.walker.bookmark( true, true );
+                                        ignoreBookmarkTextEvaluator = CKEDITOR.dom.walker.bookmark( false, true );
                                 // Avoid anchor inside bookmark inner text.
                                 walker.evaluator = ignoreBookmarkTextEvaluator;
                                 this._.nextNode = walker.next();

_source/core/dom/rangelist.js

@@ -39 +39 @@
                         createIterator : function()
                         {
                                 var rangeList = this,
-                                        bookmarks = [],
+                                        bookmark = CKEDITOR.dom.walker.bookmark(),
+                                        emptySpaces = CKEDITOR.dom.walker.whitespaces(),
+                                        guard = function( node ) { return ! ( node.is && node.is( 'tr' ) ); },
+                                                bookmarks = [],
                                         current;
 
                                 /**
@@ -49 +52 @@
 
                                         /**
                                          * Retrieves the next range in the list.
+                                         * @param {Boolean} mergeConsequent Whether join two adjacent ranges into single, e.g. consequent table cells.
                                          */
-                                        getNextRange : function()
+                                        getNextRange : function( mergeConsequent )
                                         {
                                                 current = current == undefined ? 0 : current + 1;
 
@@ -65 +69 @@
                                                         if ( !current )
                                                         {
                                                                 // Make sure bookmark correctness by reverse processing.
-                                                                for ( var i = rangeList.length - 1; i > 0; i-- )
+                                                                for ( var i = rangeList.length - 1; i >= 0; i-- )
                                                                         bookmarks.unshift( rangeList[ i ].createBookmark( true ) );
                                                         }
-                                                        else
-                                                                range.moveToBookmark( bookmarks.shift() );
-                                                }
+
+                                                        if ( mergeConsequent )
+                                                        {
+                                                                // Figure out how many ranges should be merged.
+                                                                var mergeCount = 0;
+                                                                while ( rangeList[ current + mergeCount + 1 ] )
+                                                                {
+                                                                        var doc = range.document,
+                                                                                found = 0,
+                                                                                left =  doc.getById( bookmarks[ mergeCount ].endNode ),
+                                                                                right = doc.getById( bookmarks[ mergeCount + 1 ].startNode ),
+                                                                                next;
+
+                                                                        // Check subsequent range.
+                                                                        while ( 1 )
+                                                                        {
+                                                                                next = left.getNextSourceNode( false );
+                                                                                if ( !right.equals( next ) )
+                                                                                {
+                                                                                        // This could be yet another bookmark or
+                                                                                        // walking across block boundaries.
+                                                                                        if ( bookmark( next ) || ( next.type == CKEDITOR.NODE_ELEMENT && next.isBlockBoundary() ) )
+                                                                                        {
+                                                                                                left = next;
+                                                                                                continue;
+                                                                                        }
+                                                                                }
+                                                                                else
+                                                                                        found = 1;
+
+                                                                                break;
+                                                                        }
+
+                                                                        if ( !found )
+                                                                                break;
+
+                                                                        mergeCount++;
+                                                                }
+                                                        }
+
+                                                        range.moveToBookmark( bookmarks.shift() );
+                                                        
+                                                        // Merge ranges finally after moving to bookmarks.
+                                                        while( mergeCount-- )
+                                                        {
+                                                                var next = rangeList[ ++current ];
+                                                                next.moveToBookmark( bookmarks.shift() );
+                                                                range.setEnd( next.endContainer, next.endOffset );
+                                                        }
+                                                }
 
                                                 return range;
                                         }