Ticket #3051: 3051_2.patch

_source/core/dom/walker.js

@@ -53 +53 @@
                         if ( node == this.endNode && !this.endInclusive )
                                 break;
 
-                        if ( !this.evaluator && this.evaluator( node ) !== false )
+                        if ( !this.evaluator || this.evaluator( node ) !== false )
                                 return node;
                         else if ( breakOnFalse && this.evaluator )
                                 return false;
@@ -67 +67 @@
 
         function iterateToLast( rtl )
         {
-                var node, last;
+                var node, last = null;
 
                 while ( node = iterate.call( this, rtl ) )
                         last = node;

_source/core/dom/range.js

@@ -1084 +1084 @@
                                 case CKEDITOR.ENLARGE_BLOCK_CONTENTS:
                                 case CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS:
                                         // DFS backward to get the block/list item boundary at or before the start.
-
-                                        // Get the boundaries nodes.
-                                        var startNode = this.getTouchedStartNode(),
-                                                endNode = this.getTouchedEndNode();
-
-                                        if ( startNode.type == CKEDITOR.NODE_ELEMENT && startNode.isBlockBoundary() )
+                                        // Get the outter boundaries nodes.
+                                        var startNode, endNode;
+                                        
+                                        // Use bookmark nodes to mock boundary nodes for collapsed
+                                        // range.
+                                        if( this.collapsed )
                                         {
-                                                this.setStartAt( startNode,
-                                                        CKEDITOR.dtd.$empty[ startNode.getName() ] ?
-                                                                CKEDITOR.POSITION_AFTER_END :
-                                                                CKEDITOR.POSITION_AFTER_START );
+                                                var bm = this.createBookmark();
+                                                startNode= bm.startNode;
+                                                endNode = startNode;
                                         }
                                         else
                                         {
-                                                // Get the function used to check the enlaarging limits.
-                                                var guardFunction = ( unit == CKEDITOR.ENLARGE_BLOCK_CONTENTS ?
-                                                                CKEDITOR.dom.domWalker.blockBoundary() :
-                                                                CKEDITOR.dom.domWalker.listItemBoundary() );
-
-                                                // Create the DOM walker, which will traverse the DOM.
-                                                var walker = new CKEDITOR.dom.domWalker( startNode );
+                                                var boundaries = this.getBoundaryNodes(),
+                                                        startNode = boundaries.startNode,
+                                                        endNode = boundaries.endNode;
+                                        }
 
-                                                // Go walk in reverse sense.
-                                                var data = walker.reverse( guardFunction );
-
-                                                var boundaryEvent = data.events.shift();
+                                        // function used to check the enlarging limits.
+                                        function checkOnBoundary( toNode, fromNode, customNodeNames )
+                                        {
+                                                // Check the enlarged node.
+                                                if( toNode && toNode.type == CKEDITOR.NODE_ELEMENT
+                                                        && toNode.isBlockBoundary( 
+                                                                unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS? { br : 1 } : null ) )    
+                                                        return true;
 
-                                                this.setStartBefore( boundaryEvent.from );
+                                                // Check the current node.
+                                                else if( currentNode.type == CKEDITOR.NODE_ELEMENT && 
+                                                                        currentNode.isBlockBoundary( 
+                                                                        unit == CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS? { br : 1 } : null ) 
+                                                                        && ( enlargedNode.$ == currentNode.$.parentNode 
+                                                                                        || enlargedNode.$ == currentNode.$.previousSibling ) )
+                                                        return true;
                                         }
-
-                                        if ( endNode.type == CKEDITOR.NODE_ELEMENT && endNode.isBlockBoundary() )
+                                        
+                                        // Enlarging the start boundary.
+                                        var walker = new CKEDITOR.dom.walker( startNode ),
+                                                enlargedNode = startNode, 
+                                                currentNode = enlargedNode;
+                                        while( enlargedNode )
                                         {
-                                                this.setEndAt( endNode,
-                                                        CKEDITOR.dtd.$empty[ endNode.getName() ] ?
-                                                                CKEDITOR.POSITION_BEFORE_START :
-                                                                CKEDITOR.POSITION_BEFORE_END );
+                                                // Check for those opening element.
+                                                if( !currentNode.getPrevious() && 
+                                                        checkOnBoundary( currentNode.getParent(), currentNode ) )
+                                                        break;
+                                                enlargedNode = walker.previous();
+                                                if( checkOnBoundary( enlargedNode, currentNode ) )
+                                                        break;
+                                                currentNode = enlargedNode;
                                         }
-                                        else
+                                        this.setStartAt( enlargedNode, CKEDITOR.POSITION_AFTER_END );
+                                        
+                                        // Enlarging the end boundary.
+                                        walker = new CKEDITOR.dom.walker( endNode ),
+                                                enlargedNode = endNode,
+                                                currentNode = enlargedNode;
+                                        while( enlargedNode )
                                         {
-                                                // DFS forward to get the block/list item boundary at or before the end.
-                                                walker.setNode( endNode );
-                                                data = walker.forward( guardFunction );
-                                                boundaryEvent = data.events.shift();
-
-                                                this.setEndAfter( boundaryEvent.from );
+                                                // Check for those closing element.
+                                                if( !currentNode.getNext() && 
+                                                        checkOnBoundary( currentNode.getParent(), currentNode ) )
+                                                        break;
+                                                enlargedNode = walker.next();
+                                                if( checkOnBoundary( enlargedNode, currentNode ) )
+                                                        break;
+                                                currentNode = enlargedNode;
+                                        }
+                                        this.setEndAt( enlargedNode, CKEDITOR.POSITION_BEFORE_START );
+                                        
+                                        if( bm )
+                                        {
+                                                // Backup current range.
+                                                var enlargedBm = this.createBookmark();
+                                                
+                                                // Destroy the marker bookmark.
+                                                this.moveToBookmark( bm );
+                                                this.moveToBookmark( enlargedBm );
                                         }
                         }
                 },