Ticket #3176: 3176_2.patch

_source/plugins/find/dialogs/find.js

@@ -8 +8 @@
         // Element tag names which prevent characters counting.
         var characterBoundaryElementsEnum =
         {
-                address :1, blockquote :1, dl :1, h1 :1, h2 :1, h3 :1,
+                body :1, 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, div :1, td:1, th:1
         };
 
@@ -27 +27 @@
          */
         var cursorStep = function()
         {
+                if( !this.textNode )
+                        return null;
+
                 var obj = {
                         textNode : this.textNode,
                         offset : this.offset,
-                        character : this.textNode ? this.textNode.getText().charAt( this.offset ) : null,
+                        character : this.textNode.getText().charAt( this.offset ),
                         hitMatchBoundary : this._.matchBoundary
                 };
                 return obj;
@@ -88 +91 @@
                 };
 
                 characterWalker.prototype = {
+                        
+                        current : function()
+                        {
+                                return cursorStep.call( this );
+                        },
+                        
                         next : function()
                         {
                                 // Already at the end of document, no more character available.
@@ -107 +116 @@
 
                                 // If we are at the end of the text node, use dom walker to get
                                 // the next text node.
-                                var data = null;
-                                while ( !data || ( data.node && data.node.type !=
-                                        CKEDITOR.NODE_TEXT ) )
+                                var data;
+                                do
                                 {
                                         data = this._.walker.forward(
                                                 guardDomWalkerNonEmptyTextNode );
@@ -119 +127 @@
                                                 || ( data.node.type !== CKEDITOR.NODE_TEXT
                                                         && data.node.getName() in
                                                         characterBoundaryElementsEnum ) )
+                                        {
                                                 this._.matchBoundary = true;
+                                                
+                                                // Scope to content within body. 
+                                                if ( data.node && data.node.getName() == 'body' )
+                                                {
+                                                        data.textNode = null;
+                                                        break;
+                                                }
+                                        }
                                 }
+                                while ( data.node && data.node.type != CKEDITOR.NODE_TEXT );
+                                        
                                 this.textNode = data.node;
                                 this.offset = 0;
                                 return cursorStep.call( this );
@@ -128 +147 @@
 
                         back : function()
                         {
+                                // Already at the start of document, no more character available.
+                                if( this.textNode == null )
+                                        return null;
+                                
                                 this._.matchBoundary = false;
 
                                 // More characters -> decrement offset and return.
@@ -139 +162 @@
 
                                 // Start of text node -> use dom walker to get the previous text node.
                                 var data = null;
-                                while ( !data
-                                || ( data.node && data.node.type != CKEDITOR.NODE_TEXT ) )
+                                do
                                 {
                                         data = this._.walker.reverse( guardDomWalkerNonEmptyTextNode );
 
                                         // Block boundary? BR? Document boundary?
                                         if ( !data.node || ( data.node.type !== CKEDITOR.NODE_TEXT &&
                                         data.node.getName() in characterBoundaryElementsEnum ) )
+                                        {
                                                 this._.matchBoundary = true;
+                                                
+                                                // Scope to characters within body 
+                                                if ( data.node && data.node.getName() == 'body' )
+                                                {
+                                                        data.node = null;
+                                                        break;
+                                                }
+                                        }
                                 }
+                                while ( data.node && data.node.type != CKEDITOR.NODE_TEXT );
+
                                 this.textNode = data.node;
-                                this.offset = data.node.length - 1;
+                                this.offset = this.textNode? data.node.length - 1 : 0;
                                 return cursorStep.call( this );
                         }
                 };
@@ -194 +227 @@
                                 var startNode = domRange.startContainer,
                                         startIndex = domRange.startOffset,
                                         endNode = domRange.endContainer,
-                                        endIndex = domRange.endOffset,
-                                        boundaryNodes = domRange.getBoundaryNodes();
+                                        endIndex = domRange.endOffset;
 
                                 if ( startNode.type != CKEDITOR.NODE_TEXT )
                                 {
-                                        startNode = boundaryNodes.startNode;
+                                        startNode = domRange.getTouchedStartNode();
                                         while ( startNode.type != CKEDITOR.NODE_TEXT )
-                                                startNode = startNode.getFirst();
+                                                startNode = startNode.getNextSourceNode();
                                         startIndex = 0;
                                 }
 
                                 if ( endNode.type != CKEDITOR.NODE_TEXT )
                                 {
-                                        endNode = boundaryNodes.endNode;
+                                        endNode = domRange.getTouchedEndNode();
                                         while ( endNode.type != CKEDITOR.NODE_TEXT )
-                                                endNode = endNode.getLast();
-                                        endIndex = endNode.getLength();
+                                                endNode = endNode.getPreviousSourceNode();
+                                        endIndex = endNode.getLength() - 1;
                                 }
 
                                 // If the endNode is an empty text node, our walker would just walk through
                                 // it without stopping. So need to backtrack to the nearest non-emtpy text
                                 // node.
-                                if ( endNode.getLength() < 1 )
+                                if ( endNode && endNode.getLength() < 1 )
                                 {
                                         while ( ( endNode = endNode.getPreviousSourceNode() ) && !( endNode.type == CKEDITOR.NODE_TEXT && endNode.getLength() > 0 ) )
-                                        { /*jsl:pass*/ }
-
-                                        endIndex = endNode.getLength();
+                                                endIndex = endNode.getLength() - 1;
                                 }
 
-                                var cursor = new characterWalker( startNode, startIndex );
-                                this._.cursors = [ cursor ];
-                                if ( !( cursor.textNode.equals( endNode ) && cursor.offset == endIndex - 1 ) )
+                                var walker = new characterWalker( startNode, startIndex ), cursor;
+                                
+                                // DomRange contains at least one character.
+                                ( this._.cursors = [] ).push( cursor = walker.current() );
+                                do
                                 {
-                                        do
-                                        {
-                                                cursor = new characterWalker( cursor );
-                                                cursor.next();
-                                                this._.cursors.push( cursor );
-                                        }
-                                        while ( !( cursor.textNode.equals( endNode ) && cursor.offset == endIndex - 1 ) );
+                                        cursor = walker.next();
+                                        this._.cursors.push( cursor );
                                 }
+                                while ( !( cursor.textNode.equals( endNode ) && cursor.offset == endIndex ) );
 
                                 this._.rangeLength = this._.cursors.length;
                         },
@@ -303 +331 @@
                                 var retval = this._.walker.back(),
                                         cursors = this._.cursors;
 
-                                if ( retval.hitMatchBoundary )
+                                if ( !retval || retval.hitMatchBoundary )
                                         this._.cursors = cursors = [];
-
+                                if( retval )
+                                {
                                 cursors.unshift( retval );
                                 if ( cursors.length > this._.rangeLength )
                                         cursors.pop();
+                                }
 
                                 return retval;
                         },
@@ -319 +349 @@
                                         cursors = this._.cursors;
 
                                 // Clear the cursors queue if we've crossed a match boundary.
-                                if ( retval.hitMatchBoundary )
+                                if ( !retval || retval.hitMatchBoundary )
                                         this._.cursors = cursors = [];
+                                
+                                if ( retval )
+                                {
+                                        cursors.push( retval );
+                                        if ( cursors.length > this._.rangeLength )
+                                                cursors.shift();
+                                }
 
-                                cursors.push( retval );
-                                if ( cursors.length > this._.rangeLength )
-                                        cursors.shift();
-
                                 return retval;
                         },
 
@@ -454 +487 @@
                                                 matchState = matcher.feedCharacter( character );
                                                 if ( matchState == KMP_MATCHED )
                                                         break;
-                                                if ( this.range.moveNext().hitMatchBoundary )
+                                                var next = this.range.moveNext();
+                                                if ( next && next.hitMatchBoundary )
                                                         matcher.reset();
                                         }
 
@@ -466 +500 @@
                                                                 tail = cursors[ cursors.length - 1 ],
                                                                 head = cursors[ 0 ],
                                                                 headWalker = new characterWalker( head ),
-                                                                tailWalker = new characterWalker( tail );
+                                                                tailWalker = new characterWalker( tail ),
+                                                                headBoundaryCursor = headWalker.back(),
+                                                                tailBoundaryCursor = tailWalker.next();
 
-                                                        if ( ! ( isWordSeparator(
-                                                                                headWalker.back().character )
-                                                                                && isWordSeparator(
-                                                                                tailWalker.next().character ) ) )
-                                                                continue;
+                                                        if ( !( ( !headBoundaryCursor 
+                                                                || headBoundaryCursor.hitMatchBoundary 
+                                                                || isWordSeparator( headBoundaryCursor.character ) )
+                                                                &&
+                                                                ( !tailBoundaryCursor 
+                                                                || tailBoundaryCursor.hitMatchBoundary 
+                                                                || isWordSeparator( tailBoundaryCursor.character ) ) ) )
+                                                                {
+                                                                        matchState = KMP_NOMATCH;
+                                                                        matcher.reset();
+                                                                        continue;
+                                                                }
                                                 }
 
                                                 this.range.setMatched();

_source/core/dom/range.js

@@ -1525 +1525 @@
                         if ( this.collapsed || container.type != CKEDITOR.NODE_ELEMENT )
                                 return container ;
 
-                        return container.getChild[ this.endOffset - 1 ] || container ;
+                        return container.getChild( this.endOffset - 1 )|| container ;
                 }
         };
 })();