e9c8dc132d14bd53d3bb95617cd9cf4235d3094f
[WebKit-https.git] / WebCore / 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 "config.h"
27 #include "visible_units.h"
28
29 #include "Document.h"
30 #include "Element.h"
31 #include "RenderBlock.h"
32 #include "TextBoundaries.h"
33 #include "htmlediting.h"
34 #include "HTMLNames.h"
35 #include "TextIterator.h"
36
37 namespace WebCore {
38
39 using namespace HTMLNames;
40
41 static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const UChar *, unsigned))
42 {
43     Position pos = c.deepEquivalent();
44     Node *n = pos.node();
45     if (!n)
46         return VisiblePosition();
47     Document *d = n->document();
48     Node *de = d->documentElement();
49     if (!de)
50         return VisiblePosition();
51     Node *boundary = n->enclosingBlockFlowElement();
52     if (!boundary)
53         return VisiblePosition();
54     bool isContentEditable = boundary->isContentEditable();
55     while (boundary && boundary != de && boundary->parentNode() && isContentEditable == boundary->parentNode()->isContentEditable())
56         boundary = boundary->parentNode();
57
58     Position start = rangeCompliantEquivalent(Position(boundary, 0));
59     Position end = rangeCompliantEquivalent(pos);
60     RefPtr<Range> searchRange = new Range(d);
61     
62     int exception = 0;
63     searchRange->setStart(start.node(), start.offset(), exception);
64     searchRange->setEnd(end.node(), end.offset(), exception);
65     
66     ASSERT(!exception);
67     if (exception)
68         return VisiblePosition();
69         
70     SimplifiedBackwardsTextIterator it(searchRange.get());
71     DeprecatedString string;
72     unsigned next = 0;
73     bool inTextSecurityMode = start.node() && start.node()->renderer() && start.node()->renderer()->style()->textSecurity() != TSNONE;
74     while (!it.atEnd() && it.length() > 0) {
75         // iterate to get chunks until the searchFunction returns a non-zero value.
76         String iteratorString(it.characters(), it.length());
77         // Treat bullets used in the text security mode as regular characters when looking for boundaries
78         if (inTextSecurityMode)
79             iteratorString = iteratorString.impl()->secure('x');
80         string.prepend(iteratorString.deprecatedString());
81         next = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
82         if (next != 0)
83             break;
84         it.advance();
85     }
86     
87     if (it.atEnd() && next == 0) {
88         pos = it.range()->startPosition();
89     } else if (!it.atEnd() && it.length() == 0) {
90         // Got a zero-length chunk.
91         // This means we have hit a replaced element.
92         // Make a check to see if the position should be before or after the replaced element
93         // by performing an additional check with a modified string which uses an "X" 
94         // character to stand in for the replaced element.
95         DeprecatedChar chars[2];
96         chars[0] = 'X';
97         chars[1] = ' ';
98         string.prepend(chars, 2);
99         unsigned pastImage = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
100         RefPtr<Range> range(it.range());
101         if (pastImage == 0)
102             pos = Position(range->startContainer(exception), range->startOffset(exception));
103         else
104             pos = Position(range->endContainer(exception), range->endOffset(exception));
105     } else if (next != 0) {
106         // The simpler iterator used in this function, as compared to the one used in 
107         // nextWordPosition(), gives us results we can use directly without having to 
108         // iterate again to translate the next value into a DOM position. 
109         Node *node = it.range()->startContainer(exception);
110         if (node->isTextNode() || (node->renderer() && node->renderer()->isBR()))
111             // The next variable contains a usable index into a text node
112             pos = Position(node, next);
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(exception));
117     }
118
119     return VisiblePosition(pos, DOWNSTREAM);
120 }
121
122 static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const UChar *, unsigned))
123 {
124     Position pos = c.deepEquivalent();
125     Node *n = pos.node();
126     if (!n)
127         return VisiblePosition();
128     Document *d = n->document();
129     Node *de = d->documentElement();
130     if (!de)
131         return VisiblePosition();
132     Node *boundary = n->enclosingBlockFlowElement();
133     if (!boundary)
134         return VisiblePosition();
135     bool isContentEditable = boundary->isContentEditable();
136     while (boundary && boundary != de && boundary->parentNode() && isContentEditable == boundary->parentNode()->isContentEditable())
137         boundary = boundary->parentNode();
138
139     RefPtr<Range> searchRange(d->createRange());
140     Position start(rangeCompliantEquivalent(pos));
141     ExceptionCode ec = 0;
142     searchRange->selectNodeContents(boundary, ec);
143     searchRange->setStart(start.node(), start.offset(), ec);
144     TextIterator it(searchRange.get(), RUNFINDER);
145     DeprecatedString string;
146     unsigned next = 0;
147     bool inTextSecurityMode = start.node() && start.node()->renderer() && start.node()->renderer()->style()->textSecurity() != TSNONE;
148     while (!it.atEnd() && it.length() > 0) {
149         // Keep asking the iterator for chunks until the search function
150         // returns an end value not equal to the length of the string passed to it.
151         String iteratorString(it.characters(), it.length());
152         // Treat bullets used in the text security mode as regular characters when looking for boundaries
153         if (inTextSecurityMode)
154             iteratorString = iteratorString.impl()->secure('x');
155         string.append(iteratorString.deprecatedString());
156         next = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
157         if (next != string.length())
158             break;
159         it.advance();
160     }
161     
162     if (it.atEnd() && next == string.length()) {
163         pos = it.range()->startPosition();
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         DeprecatedChar chars[2];
171         chars[0] = ' ';
172         chars[1] = 'X';
173         string.append(chars, 2);
174         unsigned pastImage = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
175         RefPtr<Range> range(it.range());
176         int exception = 0;
177         if (next != pastImage)
178             pos = Position(range->endContainer(exception), range->endOffset(exception));
179         else
180             pos = Position(range->startContainer(exception), range->startOffset(exception));
181     } else if (next != 0) {
182         // Use the character iterator to translate the next value into a DOM position.
183         CharacterIterator charIt(searchRange.get());
184         charIt.advance(next - 1);
185         pos = charIt.range()->endPosition();
186     }
187
188     // generate VisiblePosition, use UPSTREAM affinity if possible
189     return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
190 }
191
192 // ---------
193
194 static unsigned startWordBoundary(const UChar* characters, unsigned length)
195 {
196     int start, end;
197     findWordBoundary(characters, length, length, &start, &end);
198     return start;
199 }
200
201 VisiblePosition startOfWord(const VisiblePosition &c, EWordSide side)
202 {
203     // FIXME: This returns a null VP for c at the start of the document
204     // and side == LeftWordIfOnBoundary
205     VisiblePosition p = c;
206     if (side == RightWordIfOnBoundary) {
207         // at paragraph end, the startofWord is the current position
208         if (isEndOfParagraph(c))
209             return c;
210         
211         p = c.next();
212         if (p.isNull())
213             return c;
214     }
215     return previousBoundary(p, startWordBoundary);
216 }
217
218 static unsigned endWordBoundary(const UChar* characters, unsigned length)
219 {
220     int start, end;
221     findWordBoundary(characters, length, 0, &start, &end);
222     return end;
223 }
224
225 VisiblePosition endOfWord(const VisiblePosition &c, EWordSide side)
226 {
227     VisiblePosition p = c;
228     if (side == LeftWordIfOnBoundary) {
229         if (isStartOfParagraph(c))
230             return c;
231             
232         p = c.previous();
233         if (p.isNull())
234             return c;
235     } else {
236         // at paragraph end, the endOfWord is the start of next paragraph
237         if (isEndOfParagraph(c)) {
238             p = c.next();
239             return p.isNotNull() ? p : c;
240         }
241     }
242     
243     return nextBoundary(p, endWordBoundary);
244 }
245
246 static unsigned previousWordPositionBoundary(const UChar* characters, unsigned length)
247 {
248     return findNextWordFromIndex(characters, length, length, false);
249 }
250
251 VisiblePosition previousWordPosition(const VisiblePosition &c)
252 {
253     return previousBoundary(c, previousWordPositionBoundary);
254 }
255
256 static unsigned nextWordPositionBoundary(const UChar* characters, unsigned length)
257 {
258     return findNextWordFromIndex(characters, length, 0, true);
259 }
260
261 VisiblePosition nextWordPosition(const VisiblePosition &c)
262 {
263     return nextBoundary(c, nextWordPositionBoundary);
264 }
265
266 // ---------
267
268 static RootInlineBox *rootBoxForLine(const VisiblePosition &c)
269 {
270     Position p = c.deepEquivalent();
271     Node *node = p.node();
272     if (!node)
273         return 0;
274
275     RenderObject *renderer = node->renderer();
276     if (!renderer)
277         return 0;
278     
279     InlineBox *box = renderer->inlineBox(p.offset(), c.affinity());
280     if (!box)
281         return 0;
282     
283     return box->root();
284 }
285
286 VisiblePosition startOfLine(const VisiblePosition &c)
287 {
288     RootInlineBox *rootBox = rootBoxForLine(c);
289     if (!rootBox)
290         return VisiblePosition();
291     
292     // Generated content (e.g. list markers and CSS :before and :after
293     // pseudoelements) have no corresponding DOM element, and so cannot be
294     // represented by a VisiblePosition.  Use whatever follows instead.
295     InlineBox *startBox = rootBox->firstLeafChild();
296     Node *startNode;
297     while (1) {
298         if (!startBox)
299             return VisiblePosition();
300
301         RenderObject *startRenderer = startBox->object();
302         if (!startRenderer)
303             return VisiblePosition();
304
305         startNode = startRenderer->element();
306         if (startNode)
307             break;
308         
309         startBox = startBox->nextLeafChild();
310     }
311     
312     int startOffset = 0;
313     if (startBox->isInlineTextBox()) {
314         InlineTextBox *startTextBox = static_cast<InlineTextBox *>(startBox);
315         startOffset = startTextBox->m_start;
316     }
317     
318     return VisiblePosition(startNode, startOffset, DOWNSTREAM);
319 }
320
321 VisiblePosition endOfLine(const VisiblePosition &c)
322 {
323     RootInlineBox *rootBox = rootBoxForLine(c);
324     if (!rootBox)
325         return VisiblePosition();
326     
327     // Generated content (e.g. list markers and CSS :before and :after
328     // pseudoelements) have no corresponding DOM element, and so cannot be
329     // represented by a VisiblePosition.  Use whatever precedes instead.
330     Node *endNode;
331     InlineBox *endBox = rootBox->lastLeafChild();
332     while (1) {
333         if (!endBox)
334             return VisiblePosition();
335
336         RenderObject *endRenderer = endBox->object();
337         if (!endRenderer)
338             return VisiblePosition();
339
340         endNode = endRenderer->element();
341         if (endNode)
342             break;
343         
344         endBox = endBox->prevLeafChild();
345     }
346     
347     int endOffset = 1;
348     if (endNode->hasTagName(brTag)) {
349         endOffset = 0;
350     } else if (endBox->isInlineTextBox()) {
351         InlineTextBox *endTextBox = static_cast<InlineTextBox *>(endBox);
352         endOffset = endTextBox->m_start;
353         if (!endTextBox->isLineBreak())
354             endOffset += endTextBox->m_len;
355     }
356     
357     return VisiblePosition(endNode, endOffset, VP_UPSTREAM_IF_POSSIBLE);
358 }
359
360 bool inSameLine(const VisiblePosition &a, const VisiblePosition &b)
361 {
362     return a.isNotNull() && startOfLine(a) == startOfLine(b);
363 }
364
365 bool isStartOfLine(const VisiblePosition &p)
366 {
367     return p.isNotNull() && p == startOfLine(p);
368 }
369
370 bool isEndOfLine(const VisiblePosition &p)
371 {
372     return p.isNotNull() && p == endOfLine(p);
373 }
374
375 VisiblePosition previousLinePosition(const VisiblePosition &visiblePosition, int x)
376 {
377     Position p = visiblePosition.deepEquivalent();
378     Node *node = p.node();
379     Node* highestRoot = highestEditableRoot(p);
380     if (!node)
381         return VisiblePosition();
382     
383     node->document()->updateLayoutIgnorePendingStylesheets();
384     
385     RenderObject *renderer = node->renderer();
386     if (!renderer)
387         return VisiblePosition();
388
389     RenderBlock *containingBlock = 0;
390     RootInlineBox *root = 0;
391     InlineBox *box = renderer->inlineBox(p.offset(), visiblePosition.affinity());
392     if (box) {
393         root = box->root()->prevRootBox();
394         if (root)
395             containingBlock = renderer->containingBlock();
396     }
397
398     if (!root) {
399         // This containing editable block does not have a previous line.
400         // Need to move back to previous containing editable block in this root editable
401         // block and find the last root line box in that block.
402         Node *startBlock = node->enclosingBlockFlowElement();
403         Node *n = node->previousEditable();
404         while (n && startBlock == n->enclosingBlockFlowElement())
405             n = n->previousEditable();
406         while (n) {
407             if (highestEditableRoot(Position(n, 0)) != highestRoot)
408                 break;
409             Position pos(n, n->caretMinOffset());
410             if (pos.inRenderedContent()) {
411                 assert(n->renderer());
412                 box = n->renderer()->inlineBox(n->caretMaxOffset());
413                 if (box) {
414                     // previous root line box found
415                     root = box->root();
416                     containingBlock = n->renderer()->containingBlock();
417                     break;
418                 }
419
420                 return VisiblePosition(pos, DOWNSTREAM);
421             }
422             n = n->previousEditable();
423         }
424     }
425     
426     if (root) {
427         int absx, absy;
428         containingBlock->absolutePositionForContent(absx, absy);
429         if (containingBlock->hasOverflowClip())
430             containingBlock->layer()->subtractScrollOffset(absx, absy);
431         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
432         Node* node = renderer->element();
433         if (editingIgnoresContent(node))
434             return Position(node->parent(), node->nodeIndex());
435         return renderer->positionForCoordinates(x, absy + root->topOverflow());
436     }
437     
438     // Could not find a previous line. This means we must already be on the first line.
439     // Move to the start of the content in this block, which effectively moves us
440     // to the start of the line we're on.
441     return VisiblePosition(node->rootEditableElement(), 0, DOWNSTREAM);
442 }
443
444 VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, int x)
445 {
446     Position p = visiblePosition.deepEquivalent();
447     Node *node = p.node();
448     Node* highestRoot = highestEditableRoot(p);
449     if (!node)
450         return VisiblePosition();
451     
452     node->document()->updateLayoutIgnorePendingStylesheets();
453
454     RenderObject *renderer = node->renderer();
455     if (!renderer)
456         return VisiblePosition();
457
458     RenderBlock *containingBlock = 0;
459     RootInlineBox *root = 0;
460     InlineBox *box = renderer->inlineBox(p.offset(), visiblePosition.affinity());
461     if (box) {
462         root = box->root()->nextRootBox();
463         if (root)
464             containingBlock = renderer->containingBlock();
465     }
466
467     if (!root) {
468         // This containing editable block does not have a next line.
469         // Need to move forward to next containing editable block in this root editable
470         // block and find the first root line box in that block.
471         Node *startBlock = node->enclosingBlockFlowElement();
472         Node *n = node->nextEditable(p.offset());
473         while (n && startBlock == n->enclosingBlockFlowElement())
474             n = n->nextEditable();
475         while (n) {
476             if (highestEditableRoot(Position(n, 0)) != highestRoot)
477                 break;
478             Position pos(n, n->caretMinOffset());
479             if (pos.inRenderedContent()) {
480                 assert(n->renderer());
481                 box = n->renderer()->inlineBox(n->caretMinOffset());
482                 if (box) {
483                     // next root line box found
484                     root = box->root();
485                     containingBlock = n->renderer()->containingBlock();
486                     break;
487                 }
488
489                 return VisiblePosition(pos, DOWNSTREAM);
490             }
491             n = n->nextEditable();
492         }
493     }
494     
495     if (root) {
496         int absx, absy;
497         containingBlock->absolutePositionForContent(absx, absy);
498         if (containingBlock->hasOverflowClip())
499             containingBlock->layer()->subtractScrollOffset(absx, absy);
500         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
501         Node* node = renderer->element();
502         if (editingIgnoresContent(node))
503             return Position(node->parent(), node->nodeIndex());
504         return renderer->positionForCoordinates(x, absy + root->topOverflow());
505     }    
506
507     // Could not find a next line. This means we must already be on the last line.
508     // Move to the end of the content in this block, which effectively moves us
509     // to the end of the line we're on.
510     Element *rootElement = node->rootEditableElement();
511     return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, DOWNSTREAM);
512 }
513
514 // ---------
515
516 static unsigned startSentenceBoundary(const UChar* characters, unsigned length)
517 {
518     int start, end;
519     findSentenceBoundary(characters, length, length, &start, &end);
520     return start;
521 }
522
523 VisiblePosition startOfSentence(const VisiblePosition &c)
524 {
525     return previousBoundary(c, startSentenceBoundary);
526 }
527
528 static unsigned endSentenceBoundary(const UChar* characters, unsigned length)
529 {
530     int start, end;
531     findSentenceBoundary(characters, length, 0, &start, &end);
532     return end;
533 }
534
535 VisiblePosition endOfSentence(const VisiblePosition &c)
536 {
537     return nextBoundary(c, endSentenceBoundary);
538 }
539
540 static unsigned previousSentencePositionBoundary(const UChar* characters, unsigned length)
541 {
542     return findNextSentenceFromIndex(characters, length, length, false);
543 }
544
545 VisiblePosition previousSentencePosition(const VisiblePosition &c)
546 {
547     return previousBoundary(c, previousSentencePositionBoundary);
548 }
549
550 static unsigned nextSentencePositionBoundary(const UChar* characters, unsigned length)
551 {
552     return findNextSentenceFromIndex(characters, length, 0, true);
553 }
554
555 VisiblePosition nextSentencePosition(const VisiblePosition &c)
556 {
557     return nextBoundary(c, nextSentencePositionBoundary);
558 }
559
560 VisiblePosition startOfParagraph(const VisiblePosition &c)
561 {
562     Position p = c.deepEquivalent();
563     // FIXME: Use the leftmost candidate.  Canonicalization should give us the leftmost candidate,
564     // but it sometimes doesn't because of 8622.
565     if (p.upstream().inRenderedContent()) {
566         p = p.upstream();
567         ASSERT(VisiblePosition(p) == c);
568     }
569
570     Node *startNode = p.node();
571
572     if (!startNode)
573         return VisiblePosition();
574     
575     if (startNode->renderer()
576         && ((startNode->renderer()->isTable() && !startNode->renderer()->isInline())
577             || startNode->renderer()->isHR())
578         && p.offset() == maxDeepOffset(startNode))
579         return VisiblePosition(Position(startNode, 0));
580
581     Node *startBlock = startNode->enclosingBlockFlowElement();
582
583     Node *node = startNode;
584     int offset = p.offset();
585
586     Node *n = startNode;
587     while (n) {
588         if (n->isContentEditable() != startNode->isContentEditable())
589             break;
590         RenderObject *r = n->renderer();
591         if (!r) {
592             n = n->traversePreviousNodePostOrder(startBlock);
593             continue;
594         }
595         RenderStyle *style = r->style();
596         if (style->visibility() != VISIBLE) {
597             n = n->traversePreviousNodePostOrder(startBlock);
598             continue;
599         }
600         // FIXME: isBlockFlow should not exclude non-inline tables
601         if (r->isBR() || r->isBlockFlow() || (r->isTable() && !r->isInline()))
602             break;
603             
604         if (r->isText()) {
605             if (style->preserveNewline()) {
606                 const UChar* text = static_cast<RenderText*>(r)->text();
607                 int i = static_cast<RenderText*>(r)->length();
608                 int o = offset;
609                 if (n == startNode && o < i)
610                     i = max(0, o);
611                 while (--i >= 0)
612                     if (text[i] == '\n')
613                         return VisiblePosition(n, i + 1, DOWNSTREAM);
614             }
615             node = n;
616             offset = 0;
617             n = n->traversePreviousNodePostOrder(startBlock);
618         } else if (editingIgnoresContent(n) || isTableElement(n)) {
619             node = n;
620             offset = 0;
621             n = n->previousSibling() ? n->previousSibling() : n->traversePreviousNodePostOrder(startBlock);
622         } else
623             n = n->traversePreviousNodePostOrder(startBlock);
624     }
625
626     return VisiblePosition(node, offset, DOWNSTREAM);
627 }
628
629 VisiblePosition endOfParagraph(const VisiblePosition &c)
630 {    
631     if (c.isNull())
632         return VisiblePosition();
633
634     Position p = c.deepEquivalent();
635     Node* startNode = p.node();
636
637     if (startNode->renderer()
638         && ((startNode->renderer()->isTable() && !startNode->renderer()->isInline())
639             || startNode->renderer()->isHR())
640         && p.offset() == 0)
641         return VisiblePosition(Position(startNode, maxDeepOffset(startNode)));
642     
643     Node *startBlock = startNode->enclosingBlockFlowElement();
644     Node *stayInsideBlock = startBlock;
645     
646     Node *node = startNode;
647     int offset = p.offset();
648
649     Node *n = startNode;
650     while (n) {
651         if (n->isContentEditable() != startNode->isContentEditable())
652             break;
653         RenderObject *r = n->renderer();
654         if (!r) {
655             n = n->traverseNextNode(stayInsideBlock);
656             continue;
657         }
658         RenderStyle *style = r->style();
659         if (style->visibility() != VISIBLE) {
660             n = n->traverseNextNode(stayInsideBlock);
661             continue;
662         }
663         
664         // FIXME: isBlockFlow should not exclude non-inline tables
665         if (r->isBR() || r->isBlockFlow() || (r->isTable() && !r->isInline()))
666             break;
667             
668         // FIXME: We avoid returning a position where the renderer can't accept the caret.
669         // We should probably do this in other cases such as startOfParagraph.
670         if (r->isText() && r->caretMaxRenderedOffset() > 0) {
671             int length = static_cast<RenderText *>(r)->length();
672             if (style->preserveNewline()) {
673                 const UChar* text = static_cast<RenderText *>(r)->text();
674                 int o = n == startNode ? offset : 0;
675                 for (int i = o; i < length; ++i)
676                     if (text[i] == '\n')
677                         return VisiblePosition(n, i, DOWNSTREAM);
678             }
679             node = n;
680             offset = r->caretMaxOffset();
681             n = n->traverseNextNode(stayInsideBlock);
682         } else if (editingIgnoresContent(n) || isTableElement(n)) {
683             node = n;
684             offset = maxDeepOffset(n);
685             n = n->traverseNextSibling(stayInsideBlock);
686         } else
687             n = n->traverseNextNode(stayInsideBlock);
688     }
689
690     return VisiblePosition(node, offset, DOWNSTREAM);
691 }
692
693 bool inSameParagraph(const VisiblePosition &a, const VisiblePosition &b)
694 {
695     return a.isNotNull() && startOfParagraph(a) == startOfParagraph(b);
696 }
697
698 bool isStartOfParagraph(const VisiblePosition &pos)
699 {
700     return pos.isNotNull() && pos == startOfParagraph(pos);
701 }
702
703 bool isEndOfParagraph(const VisiblePosition &pos)
704 {
705     return pos.isNotNull() && pos == endOfParagraph(pos);
706 }
707
708 VisiblePosition previousParagraphPosition(const VisiblePosition &p, int x)
709 {
710     VisiblePosition pos = p;
711     do {
712         VisiblePosition n = previousLinePosition(pos, x);
713         if (n.isNull() || n == pos)
714             return p;
715         pos = n;
716     } while (inSameParagraph(p, pos));
717     return pos;
718 }
719
720 VisiblePosition nextParagraphPosition(const VisiblePosition &p, int x)
721 {
722     VisiblePosition pos = p;
723     do {
724         VisiblePosition n = nextLinePosition(pos, x);
725         if (n.isNull() || n == pos)
726             return p;
727         pos = n;
728     } while (inSameParagraph(p, pos));
729     return pos;
730 }
731
732 // ---------
733
734 VisiblePosition startOfBlock(const VisiblePosition &c)
735 {
736     Position p = c.deepEquivalent();
737     Node *startNode = p.node();
738     if (!startNode)
739         return VisiblePosition();
740     return VisiblePosition(Position(startNode->enclosingBlockFlowElement(), 0), DOWNSTREAM);
741 }
742
743 VisiblePosition endOfBlock(const VisiblePosition &c)
744 {
745     Position p = c.deepEquivalent();
746
747     Node *startNode = p.node();
748     if (!startNode)
749         return VisiblePosition();
750
751     Node *startBlock = startNode->enclosingBlockFlowElement();
752     
753     return VisiblePosition(startBlock, startBlock->childNodeCount(), VP_DEFAULT_AFFINITY);   
754 }
755
756 bool inSameBlock(const VisiblePosition &a, const VisiblePosition &b)
757 {
758     return !a.isNull() && enclosingBlockFlowElement(a) == enclosingBlockFlowElement(b);
759 }
760
761 bool isStartOfBlock(const VisiblePosition &pos)
762 {
763     return pos.isNotNull() && pos == startOfBlock(pos);
764 }
765
766 bool isEndOfBlock(const VisiblePosition &pos)
767 {
768     return pos.isNotNull() && pos == endOfBlock(pos);
769 }
770
771 // ---------
772
773 VisiblePosition startOfDocument(const Node* node)
774 {
775     if (!node)
776         return VisiblePosition();
777     
778     return VisiblePosition(node->document()->documentElement(), 0, DOWNSTREAM);
779 }
780
781 VisiblePosition startOfDocument(const VisiblePosition &c)
782 {
783     return startOfDocument(c.deepEquivalent().node());
784 }
785
786 VisiblePosition endOfDocument(const Node* node)
787 {
788     if (!node || !node->document())
789         return VisiblePosition();
790     
791     Element* doc = node->document()->documentElement();
792     return VisiblePosition(doc, doc->childNodeCount(), DOWNSTREAM);
793 }
794
795 VisiblePosition endOfDocument(const VisiblePosition &c)
796 {
797     return endOfDocument(c.deepEquivalent().node());
798 }
799
800 bool inSameDocument(const VisiblePosition &a, const VisiblePosition &b)
801 {
802     Position ap = a.deepEquivalent();
803     Node *an = ap.node();
804     if (!an)
805         return false;
806     Position bp = b.deepEquivalent();
807     Node *bn = bp.node();
808     if (an == bn)
809         return true;
810
811     return an->document() == bn->document();
812 }
813
814 bool isStartOfDocument(const VisiblePosition &p)
815 {
816     return p.isNotNull() && p.previous().isNull();
817 }
818
819 bool isEndOfDocument(const VisiblePosition &p)
820 {
821     return p.isNotNull() && p.next().isNull();
822 }
823
824 // ---------
825
826 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
827 {
828     Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
829     if (!highestRoot)
830         return VisiblePosition();
831
832     return VisiblePosition(highestRoot, 0, DOWNSTREAM);
833 }
834
835 VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
836 {
837     Node* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
838     if (!highestRoot)
839         return VisiblePosition();
840
841     return VisiblePosition(highestRoot, maxDeepOffset(highestRoot), DOWNSTREAM);
842 }
843
844 }