Reviewed by Darin.
[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         // at paragraph end, the startofWord is the current position
204         if (isEndOfParagraph(c))
205             return c;
206         
207         p = c.next();
208         if (p.isNull())
209             return c;
210     }
211     return previousBoundary(p, startWordBoundary);
212 }
213
214 static unsigned endWordBoundary(const QChar *characters, unsigned length)
215 {
216     int start, end;
217     findWordBoundary(characters, length, 0, &start, &end);
218     return end;
219 }
220
221 VisiblePosition endOfWord(const VisiblePosition &c, EWordSide side)
222 {
223     VisiblePosition p = c;
224     if (side == LeftWordIfOnBoundary) {
225         p = c.previous();
226         if (p.isNull())
227             return c;
228     } else {
229         // at paragraph end, the endOfWord is the start of next paragraph
230         if (isEndOfParagraph(c)) {
231             p = c.next();
232             return p.isNotNull() ? p : c;
233         }
234     }
235     
236     return nextBoundary(p, endWordBoundary);
237 }
238
239 static unsigned previousWordPositionBoundary(const QChar *characters, unsigned length)
240 {
241     return nextWordFromIndex(characters, length, length, false);
242 }
243
244 VisiblePosition previousWordPosition(const VisiblePosition &c)
245 {
246     return previousBoundary(c, previousWordPositionBoundary);
247 }
248
249 static unsigned nextWordPositionBoundary(const QChar *characters, unsigned length)
250 {
251     return nextWordFromIndex(characters, length, 0, true);
252 }
253
254 VisiblePosition nextWordPosition(const VisiblePosition &c)
255 {
256     return nextBoundary(c, nextWordPositionBoundary);
257 }
258
259 // ---------
260
261 static RootInlineBox *rootBoxForLine(const VisiblePosition &c, EAffinity affinity)
262 {
263     Position p = c.deepEquivalent();
264     NodeImpl *node = p.node();
265     if (!node)
266         return 0;
267
268     RenderObject *renderer = node->renderer();
269     if (!renderer)
270         return 0;
271     
272     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
273     if (!box)
274         return 0;
275     
276     return box->root();
277 }
278
279 VisiblePosition startOfLine(const VisiblePosition &c, EAffinity affinity)
280 {
281     RootInlineBox *rootBox = rootBoxForLine(c, affinity);
282     if (!rootBox)
283         return VisiblePosition();
284     
285     InlineBox *startBox = rootBox->firstChild();
286     if (!startBox)
287         return VisiblePosition();
288
289     RenderObject *startRenderer = startBox->object();
290     if (!startRenderer)
291         return VisiblePosition();
292
293     NodeImpl *startNode = startRenderer->element();
294     if (!startNode)
295         return VisiblePosition();
296
297     long startOffset = 0;
298     if (startBox->isInlineTextBox()) {
299         InlineTextBox *startTextBox = static_cast<InlineTextBox *>(startBox);
300         startOffset = startTextBox->m_start;
301     }
302     return VisiblePosition(startNode, startOffset, affinity);
303 }
304
305 VisiblePosition endOfLine(const VisiblePosition &c, EAffinity affinity, EIncludeLineBreak includeLineBreak)
306 {
307     // FIXME: Need to implement the "include line break" version.
308     assert(includeLineBreak == DoNotIncludeLineBreak);
309
310     RootInlineBox *rootBox = rootBoxForLine(c, affinity);
311     if (!rootBox)
312         return VisiblePosition();
313     
314     InlineBox *endBox = rootBox->lastLeafChild();
315     if (!endBox)
316         return VisiblePosition();
317
318     RenderObject *endRenderer = endBox->object();
319     if (!endRenderer)
320         return VisiblePosition();
321
322     NodeImpl *endNode = endRenderer->element();
323     if (!endNode)
324         return VisiblePosition();
325
326     long endOffset = 1;
327     if (endNode->id() == ID_BR) {
328         endOffset = 0;
329     }
330     else if (endBox->isInlineTextBox()) {
331         InlineTextBox *endTextBox = static_cast<InlineTextBox *>(endBox);
332         endOffset = endTextBox->m_start + endTextBox->m_len;
333     }
334     return VisiblePosition(endNode, endOffset, affinity);
335 }
336
337 bool inSameLine(const VisiblePosition &a, EAffinity aa, const VisiblePosition &b, EAffinity ab)
338 {
339     return a.isNotNull() && startOfLine(a, aa) == startOfLine(b, ab);
340 }
341
342 bool isStartOfLine(const VisiblePosition &p, EAffinity affinity)
343 {
344     return p.isNotNull() && p == startOfLine(p, affinity);
345 }
346
347 bool isEndOfLine(const VisiblePosition &p, EAffinity affinity)
348 {
349     return p.isNotNull() && p == endOfLine(p, affinity, DoNotIncludeLineBreak);
350 }
351
352 VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
353 {
354     Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
355     NodeImpl *node = p.node();
356     if (!node)
357         return VisiblePosition();
358
359     RenderObject *renderer = node->renderer();
360     if (!renderer)
361         return VisiblePosition();
362
363     RenderBlock *containingBlock = 0;
364     RootInlineBox *root = 0;
365     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
366     if (box) {
367         root = box->root()->prevRootBox();
368         if (root)
369             containingBlock = renderer->containingBlock();
370     }
371
372     if (!root) {
373         // This containing editable block does not have a previous line.
374         // Need to move back to previous containing editable block in this root editable
375         // block and find the last root line box in that block.
376         NodeImpl *startBlock = node->enclosingBlockFlowElement();
377         NodeImpl *n = node->previousEditable();
378         while (n && startBlock == n->enclosingBlockFlowElement())
379             n = n->previousEditable();
380         while (n) {
381             if (!n->inSameRootEditableElement(node))
382                 break;
383             Position pos(n, n->caretMinOffset());
384             if (pos.inRenderedContent()) {
385                 assert(n->renderer());
386                 box = n->renderer()->inlineBox(n->caretMaxOffset());
387                 if (box) {
388                     // previous root line box found
389                     root = box->root();
390                     containingBlock = n->renderer()->containingBlock();
391                     break;
392                 }
393
394                 return VisiblePosition(pos, DOWNSTREAM);
395             }
396             n = n->previousEditable();
397         }
398     }
399     
400     if (root) {
401         int absx, absy;
402         containingBlock->absolutePosition(absx, absy);
403         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
404         EAffinity posAffinity;
405         Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
406         return VisiblePosition(pos, posAffinity);
407     }
408     
409     // Could not find a previous line. This means we must already be on the first line.
410     // Move to the start of the content in this block, which effectively moves us
411     // to the start of the line we're on.
412     return VisiblePosition(node->rootEditableElement(), 0, DOWNSTREAM);
413 }
414
415 VisiblePosition nextLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
416 {
417     Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
418     NodeImpl *node = p.node();
419     if (!node)
420         return VisiblePosition();
421
422     RenderObject *renderer = node->renderer();
423     if (!renderer)
424         return VisiblePosition();
425
426     RenderBlock *containingBlock = 0;
427     RootInlineBox *root = 0;
428     InlineBox *box = renderer->inlineBox(p.offset(), affinity);
429     if (box) {
430         root = box->root()->nextRootBox();
431         if (root)
432             containingBlock = renderer->containingBlock();
433     }
434
435     if (!root) {
436         // This containing editable block does not have a next line.
437         // Need to move forward to next containing editable block in this root editable
438         // block and find the first root line box in that block.
439         NodeImpl *startBlock = node->enclosingBlockFlowElement();
440         NodeImpl *n = node->nextEditable();
441         while (n && startBlock == n->enclosingBlockFlowElement())
442             n = n->nextEditable();
443         while (n) {
444             if (!n->inSameRootEditableElement(node))
445                 break;
446             Position pos(n, n->caretMinOffset());
447             if (pos.inRenderedContent()) {
448                 assert(n->renderer());
449                 box = n->renderer()->inlineBox(n->caretMinOffset());
450                 if (box) {
451                     // next root line box found
452                     root = box->root();
453                     containingBlock = n->renderer()->containingBlock();
454                     break;
455                 }
456
457                 return VisiblePosition(pos, DOWNSTREAM);
458             }
459             n = n->nextEditable();
460         }
461     }
462     
463     if (root) {
464         int absx, absy;
465         containingBlock->absolutePosition(absx, absy);
466         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
467         EAffinity posAffinity;
468         Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
469         return VisiblePosition(pos, posAffinity);
470     }    
471
472     // Could not find a next line. This means we must already be on the last line.
473     // Move to the end of the content in this block, which effectively moves us
474     // to the end of the line we're on.
475     ElementImpl *rootElement = node->rootEditableElement();
476     return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, affinity);
477 }
478
479 // ---------
480
481 static unsigned startSentenceBoundary(const QChar *characters, unsigned length)
482 {
483     int start, end;
484     findSentenceBoundary(characters, length, length, &start, &end);
485     return start;
486 }
487
488 VisiblePosition startOfSentence(const VisiblePosition &c)
489 {
490     return previousBoundary(c, startSentenceBoundary);
491 }
492
493 static unsigned endSentenceBoundary(const QChar *characters, unsigned length)
494 {
495     int start, end;
496     findSentenceBoundary(characters, length, 0, &start, &end);
497     return end;
498 }
499
500 VisiblePosition endOfSentence(const VisiblePosition &c)
501 {
502     return nextBoundary(c, endSentenceBoundary);
503 }
504
505 static unsigned previousSentencePositionBoundary(const QChar *characters, unsigned length)
506 {
507     return nextSentenceFromIndex(characters, length, length, false);
508 }
509
510 VisiblePosition previousSentencePosition(const VisiblePosition &c, EAffinity, int x)
511 {
512     return previousBoundary(c, previousSentencePositionBoundary);
513 }
514
515 static unsigned nextSentencePositionBoundary(const QChar *characters, unsigned length)
516 {
517     return nextSentenceFromIndex(characters, length, 0, true);
518 }
519
520 VisiblePosition nextSentencePosition(const VisiblePosition &c, EAffinity, int x)
521 {
522     return nextBoundary(c, nextSentencePositionBoundary);
523 }
524
525 VisiblePosition startOfParagraph(const VisiblePosition &c)
526 {
527     Position p = c.deepEquivalent();
528     NodeImpl *startNode = p.node();
529     if (!startNode)
530         return VisiblePosition();
531
532     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
533
534     NodeImpl *node = startNode;
535     long offset = p.offset();
536
537     for (NodeImpl *n = startNode; n; n = n->traversePreviousNodePostOrder(startBlock)) {
538         RenderObject *r = n->renderer();
539         if (!r)
540             continue;
541         RenderStyle *style = r->style();
542         if (style->visibility() != VISIBLE)
543             continue;
544         if (r->isBR() || r->isBlockFlow())
545             break;
546         if (r->isText()) {
547             if (style->whiteSpace() == PRE) {
548                 QChar *text = static_cast<RenderText *>(r)->text();
549                 long i = static_cast<RenderText *>(r)->length();
550                 long o = offset;
551                 if (n == startNode && o < i)
552                     i = kMax(0L, o);
553                 while (--i >= 0)
554                     if (text[i] == '\n')
555                         return VisiblePosition(n, i + 1, DOWNSTREAM);
556             }
557             node = n;
558             offset = 0;
559         } else if (r->isReplaced()) {
560             node = n;
561             offset = 0;
562         }
563     }
564
565     return VisiblePosition(node, offset, DOWNSTREAM);
566 }
567
568 VisiblePosition endOfParagraph(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
569 {
570     Position p = c.deepEquivalent();
571
572     NodeImpl *startNode = p.node();
573     if (!startNode)
574         return VisiblePosition();
575
576     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
577     NodeImpl *stayInsideBlock = includeLineBreak ? 0 : startBlock;
578     
579     NodeImpl *node = startNode;
580     long offset = p.offset();
581
582     for (NodeImpl *n = startNode; n; n = n->traverseNextNode(stayInsideBlock)) {
583         if (n->isContentEditable() != startNode->isContentEditable())
584             break;
585         RenderObject *r = n->renderer();
586         if (!r)
587             continue;
588         RenderStyle *style = r->style();
589         if (style->visibility() != VISIBLE)
590             continue;
591         if (r->isBR()) {
592             if (includeLineBreak)
593                 return VisiblePosition(n, 1, DOWNSTREAM);
594             break;
595         }
596         if (r->isBlockFlow()) {
597             if (includeLineBreak)
598                 return VisiblePosition(n, 0, DOWNSTREAM);
599             break;
600         }
601         if (r->isText()) {
602             if (includeLineBreak && !n->isAncestor(startBlock))
603                 return VisiblePosition(n, 0, DOWNSTREAM);
604             long length = static_cast<RenderText *>(r)->length();
605             if (style->whiteSpace() == PRE) {
606                 QChar *text = static_cast<RenderText *>(r)->text();
607                 long o = 0;
608                 if (n == startNode && offset < length)
609                     o = offset;
610                 for (long i = o; i < length; ++i)
611                     if (text[i] == '\n')
612                         return VisiblePosition(n, i + includeLineBreak, DOWNSTREAM);
613             }
614             node = n;
615             offset = length;
616         } else if (r->isReplaced()) {
617             node = n;
618             offset = 1;
619             if (includeLineBreak && !n->isAncestor(startBlock))
620                 break;
621         }
622     }
623
624     return VisiblePosition(node, offset, DOWNSTREAM);
625 }
626
627 bool inSameParagraph(const VisiblePosition &a, const VisiblePosition &b)
628 {
629     return a.isNotNull() && startOfParagraph(a) == startOfParagraph(b);
630 }
631
632 bool isStartOfParagraph(const VisiblePosition &pos)
633 {
634     return pos.isNotNull() && pos == startOfParagraph(pos);
635 }
636
637 bool isEndOfParagraph(const VisiblePosition &pos)
638 {
639     return pos.isNotNull() && pos == endOfParagraph(pos, DoNotIncludeLineBreak);
640 }
641
642 VisiblePosition previousParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
643 {
644     VisiblePosition pos = p;
645     do {
646         VisiblePosition n = previousLinePosition(pos, a, x);
647         if (n.isNull() || n == pos) {
648             return p;
649         }
650         pos = n;
651     } while (inSameParagraph(p, pos));
652     return pos;
653 }
654
655 VisiblePosition nextParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
656 {
657     VisiblePosition pos = p;
658     do {
659         VisiblePosition n = nextLinePosition(pos, a, x);
660         if (n.isNull() || n == pos) {
661             return p;
662         }
663         pos = n;
664     } while (inSameParagraph(p, pos));
665     return pos;
666 }
667
668 // ---------
669
670 VisiblePosition startOfBlock(const VisiblePosition &c)
671 {
672     Position p = c.deepEquivalent();
673     NodeImpl *startNode = p.node();
674     if (!startNode)
675         return VisiblePosition();
676     return VisiblePosition(Position(startNode->enclosingBlockFlowElement(), 0), DOWNSTREAM);
677 }
678
679 // written, but not yet tested
680 VisiblePosition endOfBlock(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
681 {
682     Position p = c.deepEquivalent();
683
684     NodeImpl *startNode = p.node();
685     if (!startNode)
686         return VisiblePosition();
687
688     NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
689     NodeImpl *stayInsideBlock = includeLineBreak ? 0 : startBlock;
690     
691     NodeImpl *node = startNode;
692     long offset = p.offset();
693
694     for (NodeImpl *n = startNode; n; n = n->traverseNextNode(stayInsideBlock)) {
695         RenderObject *r = n->renderer();
696         if (!r)
697             continue;
698         RenderStyle *style = r->style();
699         if (style->visibility() != VISIBLE)
700             continue;
701         if (r->isBlockFlow()) {
702             if (includeLineBreak)
703                 return VisiblePosition(n, 0, DOWNSTREAM);
704             break;
705         }
706         if (r->isText()) {
707             if (includeLineBreak && !n->isAncestor(startBlock))
708                 return VisiblePosition(n, 0, DOWNSTREAM);
709             node = n;
710             offset = static_cast<RenderText *>(r)->length();
711         } else if (r->isReplaced()) {
712             node = n;
713             offset = 1;
714             if (includeLineBreak && !n->isAncestor(startBlock))
715                 break;
716         }
717     }
718
719     return VisiblePosition(node, offset, DOWNSTREAM);
720 }
721
722 bool inSameBlock(const VisiblePosition &a, const VisiblePosition &b)
723 {
724     return a.isNotNull() && startOfBlock(a) == startOfBlock(b);
725 }
726
727 bool isStartOfBlock(const VisiblePosition &pos)
728 {
729     return pos.isNotNull() && pos == startOfBlock(pos);
730 }
731
732 bool isEndOfBlock(const VisiblePosition &pos)
733 {
734     return pos.isNotNull() && pos == endOfBlock(pos, DoNotIncludeLineBreak);
735 }
736
737 // ---------
738
739 VisiblePosition startOfDocument(const VisiblePosition &c)
740 {
741     Position p = c.deepEquivalent();
742     NodeImpl *node = p.node();
743     if (!node)
744         return VisiblePosition();
745
746     DocumentImpl *doc = node->getDocument();
747     if (!doc)
748         return VisiblePosition();
749
750     return VisiblePosition(doc->documentElement(), 0, DOWNSTREAM);
751 }
752
753 VisiblePosition endOfDocument(const VisiblePosition &c)
754 {
755     Position p = c.deepEquivalent();
756     NodeImpl *node = p.node();
757     if (!node)
758         return VisiblePosition();
759
760     DocumentImpl *doc = node->getDocument();
761     if (!doc)
762         return VisiblePosition();
763
764     NodeImpl *docElem = doc->documentElement();
765     if (!node)
766         return VisiblePosition();
767
768     return VisiblePosition(docElem, docElem->childNodeCount(), DOWNSTREAM);
769 }
770
771 bool inSameDocument(const VisiblePosition &a, const VisiblePosition &b)
772 {
773     Position ap = a.deepEquivalent();
774     NodeImpl *an = ap.node();
775     if (!an)
776         return false;
777     Position bp = b.deepEquivalent();
778     NodeImpl *bn = bp.node();
779     if (an == bn)
780         return true;
781
782     return an->getDocument() == bn->getDocument();
783 }
784
785 bool isStartOfDocument(const VisiblePosition &p)
786 {
787     return p.isNotNull() && p.previous().isNull();
788 }
789
790 bool isEndOfDocument(const VisiblePosition &p)
791 {
792     return p.isNotNull() && p.next().isNull();
793 }
794
795 } // namespace khtml