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