3280491bffec3f77377d942cbc0556ccbf2212d9
[WebKit-https.git] / WebCore / khtml / editing / visible_units.cpp
1 /*
2  * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "visible_units.h"
27
28 #include <qstring.h>
29
30 #include "htmltags.h"
31 #include "misc/helper.h"
32 #include "rendering/render_text.h"
33 #include "rendering/render_block.h"
34 #include "visible_position.h"
35 #include "visible_text.h"
36 #include "xml/dom_docimpl.h"
37 #include "xml/dom_elementimpl.h"
38
39 using DOM::DocumentImpl;
40 using DOM::ElementImpl;
41 using DOM::NodeImpl;
42 using DOM::Position;
43 using DOM::Range;
44
45 namespace khtml {
46
47 static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
48 {
49     Position pos = c.deepEquivalent();
50     NodeImpl *n = pos.node();
51     if (!n)
52         return VisiblePosition();
53     DocumentImpl *d = n->getDocument();
54     if (!d)
55         return VisiblePosition();
56     NodeImpl *de = d->documentElement();
57     if (!de)
58         return VisiblePosition();
59     NodeImpl *boundary = n->enclosingBlockFlowElement();
60     if (!boundary)
61         return VisiblePosition();
62     bool isContentEditable = boundary->isContentEditable();
63     while (boundary && boundary != de && boundary->parentNode() && isContentEditable == boundary->parentNode()->isContentEditable()) {
64         boundary = boundary->parentNode();
65     }
66
67     Range searchRange(d);
68     searchRange.setStartBefore(boundary);
69     Position end(pos.equivalentRangeCompliantPosition());
70     searchRange.setEnd(end.node(), end.offset());
71     SimplifiedBackwardsTextIterator it(searchRange);
72     QString string;
73     unsigned next = 0;
74     while (!it.atEnd() && it.length() > 0) {
75         // iterate to get chunks until the searchFunction returns a non-zero value.
76         string.prepend(it.characters(), it.length());
77         next = searchFunction(string.unicode(), string.length());
78         if (next != 0)
79             break;
80         it.advance();
81     }
82     
83     if (it.atEnd() && next == 0) {
84         Range range(it.range());
85         pos = Position(range.startContainer().handle(), range.startOffset());
86     }
87     else if (!it.atEnd() && it.length() == 0) {
88         // Got a zero-length chunk.
89         // This means we have hit a replaced element.
90         // Make a check to see if the position should be before or after the replaced element
91         // by performing an additional check with a modified string which uses an "X" 
92         // character to stand in for the replaced element.
93         QChar chars[2];
94         chars[0] = 'X';
95         chars[1] = ' ';
96         string.prepend(chars, 2);
97         unsigned pastImage = searchFunction(string.unicode(), string.length());
98         Range range(it.range());
99         if (pastImage == 0)
100             pos = Position(range.startContainer().handle(), range.startOffset());
101         else
102             pos = Position(range.endContainer().handle(), range.endOffset());
103     }
104     else if (next != 0) {
105         // The simpler iterator used in this function, as compared to the one used in 
106         // nextWordPosition(), gives us results we can use directly without having to 
107         // iterate again to translate the next value into a DOM position. 
108         NodeImpl *node = it.range().startContainer().handle();
109         if (node->isTextNode() || (node->renderer() && node->renderer()->isBR())) {
110             // The next variable contains a usable index into a text node
111             pos = Position(node, next);
112         }
113         else {
114             // If we are not in a text node, we ended on a node boundary, so the
115             // range start offset should be used.
116             pos = Position(node, it.range().startOffset());
117         }
118     }
119
120     return VisiblePosition(pos, DOWNSTREAM, VisiblePosition::INIT_UP);
121 }
122
123 static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
124 {
125     Position pos = c.deepEquivalent();
126     NodeImpl *n = pos.node();
127     if (!n)
128         return VisiblePosition();
129     DocumentImpl *d = n->getDocument();
130     if (!d)
131         return VisiblePosition();
132     NodeImpl *de = d->documentElement();
133     if (!de)
134         return VisiblePosition();
135     NodeImpl *boundary = n->enclosingBlockFlowElement();
136     if (!boundary)
137         return VisiblePosition();
138     bool isContentEditable = boundary->isContentEditable();
139     while (boundary && boundary != de && boundary->parentNode() && isContentEditable == boundary->parentNode()->isContentEditable()) {
140         boundary = boundary->parentNode();
141     }
142
143     Range searchRange(d);
144     Position start(pos.equivalentRangeCompliantPosition());
145     searchRange.setStart(start.node(), start.offset());
146     searchRange.setEndAfter(boundary);
147     TextIterator it(searchRange, RUNFINDER);
148     QString string;
149     unsigned next = 0;
150     while (!it.atEnd() && it.length() > 0) {
151         // Keep asking the iterator for chunks until the search function
152         // returns an end value not equal to the length of the string passed to it.
153         string.append(it.characters(), it.length());
154         next = searchFunction(string.unicode(), string.length());
155         if (next != string.length())
156             break;
157         it.advance();
158     }
159     
160     if (it.atEnd() && next == string.length()) {
161         Range range(it.range());
162         pos = Position(range.startContainer().handle(), range.startOffset());
163     }
164     else if (!it.atEnd() && it.length() == 0) {
165         // Got a zero-length chunk.
166         // This means we have hit a replaced element.
167         // Make a check to see if the position should be before or after the replaced element
168         // by performing an additional check with a modified string which uses an "X" 
169         // character to stand in for the replaced element.
170         QChar chars[2];
171         chars[0] = ' ';
172         chars[1] = 'X';
173         string.append(chars, 2);
174         unsigned pastImage = searchFunction(string.unicode(), string.length());
175         Range range(it.range());
176         if (next != pastImage)
177             pos = Position(range.endContainer().handle(), range.endOffset());
178         else
179             pos = Position(range.startContainer().handle(), range.startOffset());
180     }
181     else if (next != 0) {
182         // Use the character iterator to translate the next value into a DOM position.
183         CharacterIterator charIt(searchRange);
184         charIt.advance(next - 1);
185         pos = Position(charIt.range().endContainer().handle(), charIt.range().endOffset());
186     }
187     return VisiblePosition(pos, UPSTREAM, VisiblePosition::INIT_UP);
188 }
189
190 // ---------
191
192 static unsigned startWordBoundary(const QChar *characters, unsigned length)
193 {
194     int start, end;
195     findWordBoundary(characters, length, length, &start, &end);
196     return start;
197 }
198
199 VisiblePosition startOfWord(const VisiblePosition &c, EWordSide side)
200 {
201     VisiblePosition p = c;
202     if (side == RightWordIfOnBoundary) {
203         p = c.next();
204         if (p.isNull())
205             return c;
206     }
207     return previousBoundary(p, startWordBoundary);
208 }
209
210 static unsigned endWordBoundary(const QChar *characters, unsigned length)
211 {
212     int start, end;
213     findWordBoundary(characters, length, 0, &start, &end);
214     return end;
215 }
216
217 VisiblePosition endOfWord(const VisiblePosition &c, EWordSide side)
218 {
219     VisiblePosition p = c;
220     if (side == LeftWordIfOnBoundary) {
221         p = c.previous();
222         if (p.isNull())
223             return c;
224     }
225     return nextBoundary(p, endWordBoundary);
226 }
227
228 static unsigned previousWordPositionBoundary(const QChar *characters, unsigned length)
229 {
230     return nextWordFromIndex(characters, length, length, false);
231 }
232
233 VisiblePosition previousWordPosition(const VisiblePosition &c)
234 {
235     return previousBoundary(c, previousWordPositionBoundary);
236 }
237
238 static unsigned nextWordPositionBoundary(const QChar *characters, unsigned length)
239 {
240     return nextWordFromIndex(characters, length, 0, true);
241 }
242
243 VisiblePosition nextWordPosition(const VisiblePosition &c)
244 {
245     return nextBoundary(c, nextWordPositionBoundary);
246 }
247
248 // ---------
249
250 static RootInlineBox *rootBoxForLine(const VisiblePosition &c, EAffinity affinity)
251 {
252     Position p = c.deepEquivalent();
253     NodeImpl *node = p.node();
254     if (!node)
255         return 0;
256
257     RenderObject *renderer = node->renderer();
258     if (!renderer)
259         return 0;
260     
261     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
262     if (!box)
263         return 0;
264     
265     return box->root();
266 }
267
268 VisiblePosition startOfLine(const VisiblePosition &c, EAffinity affinity)
269 {
270     RootInlineBox *rootBox = rootBoxForLine(c, affinity);
271     if (!rootBox)
272         return VisiblePosition();
273     
274     InlineBox *startBox = rootBox->firstChild();
275     if (!startBox)
276         return VisiblePosition();
277
278     RenderObject *startRenderer = startBox->object();
279     if (!startRenderer)
280         return VisiblePosition();
281
282     NodeImpl *startNode = startRenderer->element();
283     if (!startNode)
284         return VisiblePosition();
285
286     long startOffset = 0;
287     if (startBox->isInlineTextBox()) {
288         InlineTextBox *startTextBox = static_cast<InlineTextBox *>(startBox);
289         startOffset = startTextBox->m_start;
290     }
291     return VisiblePosition(startNode, startOffset, affinity);
292 }
293
294 VisiblePosition endOfLine(const VisiblePosition &c, EAffinity affinity, EIncludeLineBreak includeLineBreak)
295 {
296     // FIXME: Need to implement the "include line break" version.
297     assert(includeLineBreak == DoNotIncludeLineBreak);
298
299     RootInlineBox *rootBox = rootBoxForLine(c, affinity);
300     if (!rootBox)
301         return VisiblePosition();
302     
303     InlineBox *endBox = rootBox->lastLeafChild();
304     if (!endBox)
305         return VisiblePosition();
306
307     RenderObject *endRenderer = endBox->object();
308     if (!endRenderer)
309         return VisiblePosition();
310
311     NodeImpl *endNode = endRenderer->element();
312     if (!endNode)
313         return VisiblePosition();
314
315     long endOffset = 1;
316     if (endNode->id() == ID_BR) {
317         endOffset = 0;
318     }
319     else if (endBox->isInlineTextBox()) {
320         InlineTextBox *endTextBox = static_cast<InlineTextBox *>(endBox);
321         endOffset = endTextBox->m_start + endTextBox->m_len;
322     }
323     return VisiblePosition(endNode, endOffset, affinity);
324 }
325
326 bool inSameLine(const VisiblePosition &a, EAffinity aa, const VisiblePosition &b, EAffinity ab)
327 {
328     return a.isNotNull() && startOfLine(a, aa) == startOfLine(b, ab);
329 }
330
331 bool isStartOfLine(const VisiblePosition &p, EAffinity affinity)
332 {
333     return p.isNotNull() && p == startOfLine(p, affinity);
334 }
335
336 bool isEndOfLine(const VisiblePosition &p, EAffinity affinity)
337 {
338     return p.isNotNull() && p == endOfLine(p, affinity, DoNotIncludeLineBreak);
339 }
340
341 VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
342 {
343     Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
344     NodeImpl *node = p.node();
345     if (!node)
346         return VisiblePosition();
347
348     RenderObject *renderer = node->renderer();
349     if (!renderer)
350         return VisiblePosition();
351
352     RenderBlock *containingBlock = 0;
353     RootInlineBox *root = 0;
354     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
355     if (box) {
356         root = box->root()->prevRootBox();
357         if (root)
358             containingBlock = renderer->containingBlock();
359     }
360
361     if (!root) {
362         // This containing editable block does not have a previous line.
363         // Need to move back to previous containing editable block in this root editable
364         // block and find the last root line box in that block.
365         NodeImpl *startBlock = node->enclosingBlockFlowElement();
366         NodeImpl *n = node->previousEditable();
367         while (n && startBlock == n->enclosingBlockFlowElement())
368             n = n->previousEditable();
369         while (n) {
370             if (!n->inSameRootEditableElement(node))
371                 break;
372             Position pos(n, n->caretMinOffset());
373             if (pos.inRenderedContent()) {
374                 assert(n->renderer());
375                 box = n->renderer()->inlineBox(n->caretMaxOffset());
376                 if (box) {
377                     // previous root line box found
378                     root = box->root();
379                     containingBlock = n->renderer()->containingBlock();
380                     break;
381                 }
382
383                 return VisiblePosition(pos, UPSTREAM);
384             }
385             n = n->previousEditable();
386         }
387     }
388     
389     if (root) {
390         int absx, absy;
391         containingBlock->absolutePosition(absx, absy);
392         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
393         EAffinity posAffinity;
394         Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
395         return VisiblePosition(pos, posAffinity);
396     }
397     
398     // Could not find a previous line. This means we must already be on the first line.
399     // Move to the start of the content in this block, which effectively moves us
400     // to the start of the line we're on.
401     return VisiblePosition(node->rootEditableElement(), 0, UPSTREAM);
402 }
403
404 VisiblePosition nextLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
405 {
406     Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
407     NodeImpl *node = p.node();
408     if (!node)
409         return VisiblePosition();
410
411     RenderObject *renderer = node->renderer();
412     if (!renderer)
413         return VisiblePosition();
414
415     RenderBlock *containingBlock = 0;
416     RootInlineBox *root = 0;
417     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
418     if (box) {
419         root = box->root()->nextRootBox();
420         if (root)
421             containingBlock = renderer->containingBlock();
422     }
423
424     if (!root) {
425         // This containing editable block does not have a next line.
426         // Need to move forward to next containing editable block in this root editable
427         // block and find the first root line box in that block.
428         NodeImpl *startBlock = node->enclosingBlockFlowElement();
429         NodeImpl *n = node->nextEditable();
430         while (n && startBlock == n->enclosingBlockFlowElement())
431             n = n->nextEditable();
432         while (n) {
433             if (!n->inSameRootEditableElement(node))
434                 break;
435             Position pos(n, n->caretMinOffset());
436             if (pos.inRenderedContent()) {
437                 assert(n->renderer());
438                 box = n->renderer()->inlineBox(n->caretMinOffset());
439                 if (box) {
440                     // next root line box found
441                     root = box->root();
442                     containingBlock = n->renderer()->containingBlock();
443                     break;
444                 }
445
446                 return VisiblePosition(pos, UPSTREAM);
447             }
448             n = n->nextEditable();
449         }
450     }
451     
452     if (root) {
453         int absx, absy;
454         containingBlock->absolutePosition(absx, absy);
455         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
456         EAffinity posAffinity;
457         Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
458         return VisiblePosition(pos, posAffinity);
459     }    
460
461     // Could not find a next line. This means we must already be on the last line.
462     // Move to the end of the content in this block, which effectively moves us
463     // to the end of the line we're on.
464     ElementImpl *rootElement = node->rootEditableElement();
465     return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, affinity);
466 }
467
468 // ---------
469
470 static unsigned startSentenceBoundary(const QChar *characters, unsigned length)
471 {
472     int start, end;
473     findSentenceBoundary(characters, length, length, &start, &end);
474     return start;
475 }
476
477 VisiblePosition startOfSentence(const VisiblePosition &c)
478 {
479     return previousBoundary(c, startSentenceBoundary);
480 }
481
482 static unsigned endSentenceBoundary(const QChar *characters, unsigned length)
483 {
484     int start, end;
485     findSentenceBoundary(characters, length, 0, &start, &end);
486     return end;
487 }
488
489 VisiblePosition endOfSentence(const VisiblePosition &c)
490 {
491     return nextBoundary(c, endSentenceBoundary);
492 }
493
494 static unsigned previousSentencePositionBoundary(const QChar *characters, unsigned length)
495 {
496     return nextSentenceFromIndex(characters, length, length, false);
497 }
498
499 VisiblePosition previousSentencePosition(const VisiblePosition &c, EAffinity, int x)
500 {
501     return previousBoundary(c, previousSentencePositionBoundary);
502 }
503
504 static unsigned nextSentencePositionBoundary(const QChar *characters, unsigned length)
505 {
506     return nextSentenceFromIndex(characters, length, 0, true);
507 }
508
509 VisiblePosition nextSentencePosition(const VisiblePosition &c, EAffinity, int x)
510 {
511     return nextBoundary(c, nextSentencePositionBoundary);
512 }
513
514 VisiblePosition startOfParagraph(const VisiblePosition &c)
515 {
516     Position p = c.deepEquivalent();
517     NodeImpl *startNode = p.node();
518     if (!startNode)
519         return VisiblePosition();
520
521     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
522
523     NodeImpl *node = startNode;
524     long offset = p.offset();
525
526     for (NodeImpl *n = startNode; n; n = n->traversePreviousNodePostOrder(startBlock)) {
527         RenderObject *r = n->renderer();
528         if (!r)
529             continue;
530         RenderStyle *style = r->style();
531         if (style->visibility() != VISIBLE)
532             continue;
533         if (r->isBR() || r->isBlockFlow())
534             break;
535         if (r->isText()) {
536             if (style->whiteSpace() == PRE) {
537                 QChar *text = static_cast<RenderText *>(r)->text();
538                 long i = static_cast<RenderText *>(r)->length();
539                 long o = offset;
540                 if (n == startNode && o < i)
541                     i = kMax(0L, o);
542                 while (--i >= 0)
543                     if (text[i] == '\n')
544                         return VisiblePosition(n, i + 1, DOWNSTREAM);
545             }
546             node = n;
547             offset = 0;
548         } else if (r->isReplaced()) {
549             node = n;
550             offset = 0;
551         }
552     }
553
554     return VisiblePosition(node, offset, DOWNSTREAM);
555 }
556
557 VisiblePosition endOfParagraph(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
558 {
559     Position p = c.deepEquivalent();
560
561     NodeImpl *startNode = p.node();
562     if (!startNode)
563         return VisiblePosition();
564
565     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
566     NodeImpl *stayInsideBlock = includeLineBreak ? 0 : startBlock;
567     
568     NodeImpl *node = startNode;
569     long offset = p.offset();
570
571     for (NodeImpl *n = startNode; n; n = n->traverseNextNode(stayInsideBlock)) {
572         if (n->isContentEditable() != startNode->isContentEditable())
573             break;
574         RenderObject *r = n->renderer();
575         if (!r)
576             continue;
577         RenderStyle *style = r->style();
578         if (style->visibility() != VISIBLE)
579             continue;
580         if (r->isBR()) {
581             if (includeLineBreak)
582                 return VisiblePosition(n, 1, UPSTREAM);
583             break;
584         }
585         if (r->isBlockFlow()) {
586             if (includeLineBreak)
587                 return VisiblePosition(n, 0, UPSTREAM);
588             break;
589         }
590         if (r->isText()) {
591             if (includeLineBreak && !n->isAncestor(startBlock))
592                 return VisiblePosition(n, 0, UPSTREAM);
593             long length = static_cast<RenderText *>(r)->length();
594             if (style->whiteSpace() == PRE) {
595                 QChar *text = static_cast<RenderText *>(r)->text();
596                 long o = 0;
597                 if (n == startNode && offset < length)
598                     o = offset;
599                 for (long i = o; i < length; ++i)
600                     if (text[i] == '\n')
601                         return VisiblePosition(n, i + includeLineBreak, UPSTREAM);
602             }
603             node = n;
604             offset = length;
605         } else if (r->isReplaced()) {
606             node = n;
607             offset = 1;
608             if (includeLineBreak && !n->isAncestor(startBlock))
609                 break;
610         }
611     }
612
613     return VisiblePosition(node, offset, UPSTREAM);
614 }
615
616 bool inSameParagraph(const VisiblePosition &a, const VisiblePosition &b)
617 {
618     return a.isNotNull() && startOfParagraph(a) == startOfParagraph(b);
619 }
620
621 bool isStartOfParagraph(const VisiblePosition &pos)
622 {
623     return pos.isNotNull() && pos == startOfParagraph(pos);
624 }
625
626 bool isEndOfParagraph(const VisiblePosition &pos)
627 {
628     return pos.isNotNull() && pos == endOfParagraph(pos, DoNotIncludeLineBreak);
629 }
630
631 VisiblePosition previousParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
632 {
633     VisiblePosition pos = p;
634     do {
635         VisiblePosition n = previousLinePosition(pos, a, x);
636         if (n.isNull() || n == pos) {
637             return p;
638         }
639         pos = n;
640     } while (inSameParagraph(p, pos));
641     return pos;
642 }
643
644 VisiblePosition nextParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
645 {
646     VisiblePosition pos = p;
647     do {
648         VisiblePosition n = nextLinePosition(pos, a, x);
649         if (n.isNull() || n == pos) {
650             return p;
651         }
652         pos = n;
653     } while (inSameParagraph(p, pos));
654     return pos;
655 }
656
657 // ---------
658
659 VisiblePosition startOfBlock(const VisiblePosition &c)
660 {
661     Position p = c.deepEquivalent();
662     NodeImpl *startNode = p.node();
663     if (!startNode)
664         return VisiblePosition();
665     return VisiblePosition(Position(startNode->enclosingBlockFlowElement(), 0), DOWNSTREAM);
666 }
667
668 // written, but not yet tested
669 VisiblePosition endOfBlock(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
670 {
671     Position p = c.deepEquivalent();
672
673     NodeImpl *startNode = p.node();
674     if (!startNode)
675         return VisiblePosition();
676
677     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
678     NodeImpl *stayInsideBlock = includeLineBreak ? 0 : startBlock;
679     
680     NodeImpl *node = startNode;
681     long offset = p.offset();
682
683     for (NodeImpl *n = startNode; n; n = n->traverseNextNode(stayInsideBlock)) {
684         RenderObject *r = n->renderer();
685         if (!r)
686             continue;
687         RenderStyle *style = r->style();
688         if (style->visibility() != VISIBLE)
689             continue;
690         if (r->isBlockFlow()) {
691             if (includeLineBreak)
692                 return VisiblePosition(n, 0, DOWNSTREAM);
693             break;
694         }
695         if (r->isText()) {
696             if (includeLineBreak && !n->isAncestor(startBlock))
697                 return VisiblePosition(n, 0, DOWNSTREAM);
698             node = n;
699             offset = static_cast<RenderText *>(r)->length();
700         } else if (r->isReplaced()) {
701             node = n;
702             offset = 1;
703             if (includeLineBreak && !n->isAncestor(startBlock))
704                 break;
705         }
706     }
707
708     return VisiblePosition(node, offset, DOWNSTREAM);
709 }
710
711 bool inSameBlock(const VisiblePosition &a, const VisiblePosition &b)
712 {
713     return a.isNotNull() && startOfBlock(a) == startOfBlock(b);
714 }
715
716 bool isStartOfBlock(const VisiblePosition &pos)
717 {
718     return pos.isNotNull() && pos == startOfBlock(pos);
719 }
720
721 bool isEndOfBlock(const VisiblePosition &pos)
722 {
723     return pos.isNotNull() && pos == endOfBlock(pos, DoNotIncludeLineBreak);
724 }
725
726 // ---------
727
728 VisiblePosition startOfDocument(const VisiblePosition &c)
729 {
730     Position p = c.deepEquivalent();
731     NodeImpl *node = p.node();
732     if (!node)
733         return VisiblePosition();
734
735     DocumentImpl *doc = node->getDocument();
736     if (!doc)
737         return VisiblePosition();
738
739     return VisiblePosition(doc->documentElement(), 0, DOWNSTREAM);
740 }
741
742 VisiblePosition endOfDocument(const VisiblePosition &c)
743 {
744     Position p = c.deepEquivalent();
745     NodeImpl *node = p.node();
746     if (!node)
747         return VisiblePosition();
748
749     DocumentImpl *doc = node->getDocument();
750     if (!doc)
751         return VisiblePosition();
752
753     NodeImpl *docElem = doc->documentElement();
754     if (!node)
755         return VisiblePosition();
756
757     return VisiblePosition(docElem, docElem->childNodeCount(), DOWNSTREAM);
758 }
759
760 bool inSameDocument(const VisiblePosition &a, const VisiblePosition &b)
761 {
762     Position ap = a.deepEquivalent();
763     NodeImpl *an = ap.node();
764     if (!an)
765         return false;
766     Position bp = b.deepEquivalent();
767     NodeImpl *bn = bp.node();
768     if (an == bn)
769         return true;
770
771     return an->getDocument() == bn->getDocument();
772 }
773
774 bool isStartOfDocument(const VisiblePosition &p)
775 {
776     return p.isNotNull() && p.previous().isNull();
777 }
778
779 bool isEndOfDocument(const VisiblePosition &p)
780 {
781     return p.isNotNull() && p.next().isNull();
782 }
783
784 } // namespace khtml