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)
 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
 710     return VisiblePosition(startBlock, startBlock->childNodeCount(), VP_DEFAULT_AFFINITY);
 711 }
 712
 713 bool inSameBlock(const VisiblePosition &a, const VisiblePosition &b)
 714 {
 715     return !a.isNull() && enclosingBlockFlowElement(a) == enclosingBlockFlowElement(b);
 716 }
 717
 718 bool isStartOfBlock(const VisiblePosition &pos)
 719 {
 720     return pos.isNotNull() && isEqualIgnoringAffinity(pos, startOfBlock(pos));
 721 }
 722
 723 bool isEndOfBlock(const VisiblePosition &pos)
 724 {
 725     return pos.isNotNull() && isEqualIgnoringAffinity(pos, endOfBlock(pos));
 726 }
 727
 728 // ---------
 729
 730 VisiblePosition startOfDocument(const VisiblePosition &c)
 731 {
 732     Position p = c.deepEquivalent();
 733     NodeImpl *node = p.node();
 734     if (!node)
 735         return VisiblePosition();
 736
 737     DocumentImpl *doc = node->getDocument();
 738     if (!doc)
 739         return VisiblePosition();
 740
 741     return VisiblePosition(doc->documentElement(), 0, DOWNSTREAM);
 742 }
 743
 744 VisiblePosition endOfDocument(const VisiblePosition &c)
 745 {
 746     Position p = c.deepEquivalent();
 747     NodeImpl *node = p.node();
 748     if (!node)
 749         return VisiblePosition();
 750
 751     DocumentImpl *doc = node->getDocument();
 752     if (!doc)
 753         return VisiblePosition();
 754
 755     NodeImpl *docElem = doc->documentElement();
 756     if (!node)
 757         return VisiblePosition();
 758
 759     return VisiblePosition(docElem, docElem->childNodeCount(), DOWNSTREAM);
 760 }
 761
 762 bool inSameDocument(const VisiblePosition &a, const VisiblePosition &b)
 763 {
 764     Position ap = a.deepEquivalent();
 765     NodeImpl *an = ap.node();
 766     if (!an)
 767         return false;
 768     Position bp = b.deepEquivalent();
 769     NodeImpl *bn = bp.node();
 770     if (an == bn)
 771         return true;
 772
 773     return an->getDocument() == bn->getDocument();
 774 }
 775
 776 bool isStartOfDocument(const VisiblePosition &p)
 777 {
 778     return p.isNotNull() && p.previous().isNull();
 779 }
 780
 781 bool isEndOfDocument(const VisiblePosition &p)
 782 {
 783     return p.isNotNull() && p.next().isNull();
 784 }
 785
 786 // ---------
 787
 788 VisiblePosition startOfEditableContent(const VisiblePosition &c)
 789 {
 790     Position p = c.deepEquivalent();
 791     NodeImpl *node = p.node();
 792     if (!node)
 793         return VisiblePosition();
 794
 795     if (!node->isContentEditable())
 796         return VisiblePosition();
 797
 798     return VisiblePosition(node->rootEditableElement(), 0, DOWNSTREAM);
 799 }
 800
 801 VisiblePosition endOfEditableContent(const VisiblePosition &c)
 802 {
 803     Position p = c.deepEquivalent();
 804     NodeImpl *node = p.node();
 805     if (!node)
 806         return VisiblePosition();
 807
 808     if (!node->isContentEditable())
 809         return VisiblePosition();
 810
 811     node = node->rootEditableElement();
 812     if (!node)
 813         return VisiblePosition();
 814
 815     return VisiblePosition(node, node->childNodeCount(), DOWNSTREAM);
 816 }
 817
 818 bool inSameEditableContent(const VisiblePosition &a, const VisiblePosition &b)
 819 {
 820     Position ap = a.deepEquivalent();
 821     NodeImpl *an = ap.node();
 822     if (!an)
 823         return false;
 824
 825     Position bp = b.deepEquivalent();
 826     NodeImpl *bn = bp.node();
 827     if (!bn)
 828         return false;
 829
 830     if (!an->isContentEditable() || !bn->isContentEditable())
 831         return false;
 832
 833     return an->rootEditableElement() == bn->rootEditableElement();
 834 }
 835
 836 bool isStartOfEditableContent(const VisiblePosition &p)
 837 {
 838     return !inSameEditableContent(p, p.previous());
 839 }
 840
 841 bool isEndOfEditableContent(const VisiblePosition &p)
 842 {
 843     return !inSameEditableContent(p, p.next());
 844 }
 845
 846 } // namespace khtml