Reviewed by Darin.
authorharrison <harrison@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 14 Feb 2005 18:19:18 +0000 (18:19 +0000)
committerharrison <harrison@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 14 Feb 2005 18:19:18 +0000 (18:19 +0000)
        <rdar://problem/4004305> REGRESSION (Mail): Command-right-arrow on wrapped text goes to end of previous line

        Fixed nextLinePosition to calculate affinity rather than take it as a parameter.  Propagated the parameter change out to related methods.

        * khtml/editing/htmlediting.cpp:
        (khtml::DeleteSelectionCommand::initializePositionData):
        (khtml::InsertLineBreakCommand::doApply):
        (khtml::InsertParagraphSeparatorCommand::doApply):
        (khtml::InsertTextCommand::input):
        (khtml::ReplaceSelectionCommand::doApply):
        (khtml::ReplaceSelectionCommand::applyStyleToInsertedNodes):
        * khtml/editing/selection.cpp:
        (khtml::Selection::modifyExtendingRightForward):
        (khtml::Selection::modifyMovingRightForward):
        (khtml::Selection::modifyExtendingLeftBackward):
        (khtml::Selection::modifyMovingLeftBackward):
        (khtml::Selection::modify):
        (khtml::Selection::validate):
        * khtml/editing/visible_position.cpp:
        (khtml::visiblePositionsOnDifferentLines):
        * khtml/editing/visible_units.cpp:
        (khtml::rootBoxForLine):
        (khtml::startOfLine):
        (khtml::endOfLine):
        (khtml::inSameLine):
        (khtml::isStartOfLine):
        (khtml::isEndOfLine):
        (khtml::previousLinePosition):
        (khtml::nextLinePosition):
        (khtml::previousSentencePosition):
        (khtml::nextSentencePosition):
        (khtml::previousParagraphPosition):
        (khtml::nextParagraphPosition):
        * khtml/editing/visible_units.h:
        * khtml/khtml_events.cpp:
        (khtml::MouseEvent::offset):
        * khtml/khtml_part.cpp:
        (KHTMLPart::isPointInsideSelection):
        (KHTMLPart::selectClosestWordFromMouseEvent):
        (KHTMLPart::handleMousePressEventTripleClick):
        (KHTMLPart::handleMousePressEventSingleClick):
        (KHTMLPart::handleMouseMoveEventSelection):
        (KHTMLPart::khtmlMouseReleaseEvent):
        * khtml/rendering/render_block.cpp:
        (khtml::RenderBlock::positionForCoordinates):
        * khtml/rendering/render_block.h:
        * khtml/rendering/render_br.cpp:
        (RenderBR::positionForCoordinates):
        * khtml/rendering/render_br.h:
        * khtml/rendering/render_container.cpp:
        (RenderContainer::positionForCoordinates):
        * khtml/rendering/render_container.h:
        * khtml/rendering/render_inline.cpp:
        (RenderInline::positionForCoordinates):
        * khtml/rendering/render_inline.h:
        * khtml/rendering/render_object.cpp:
        (RenderObject::caretRect):
        (RenderObject::positionForCoordinates):
        * khtml/rendering/render_object.h:
        * khtml/rendering/render_replaced.cpp:
        (RenderReplaced::positionForCoordinates):
        * khtml/rendering/render_replaced.h:
        * khtml/rendering/render_text.cpp:
        (RenderText::positionForCoordinates):
        * khtml/rendering/render_text.h:
        * khtml/xml/dom_position.cpp:
        (DOM::Position::previousCharacterPosition):
        (DOM::Position::nextCharacterPosition):
        (DOM::Position::leadingWhitespacePosition):
        (DOM::Position::trailingWhitespacePosition):
        * khtml/xml/dom_position.h:
        * kwq/KWQAccObject.mm:
        (-[KWQAccObject value]):
        (-[KWQAccObject accessibilityAttributeValue:]):
        (-[KWQAccObject doAXLineForTextMarker:]):
        (-[KWQAccObject doAXTextMarkerRangeForLine:]):
        (-[KWQAccObject doAXTextMarkerForPosition:]):
        (-[KWQAccObject doAXLeftLineTextMarkerRangeForTextMarker:]):
        (-[KWQAccObject doAXRightLineTextMarkerRangeForTextMarker:]):
        (-[KWQAccObject doAXNextLineEndTextMarkerForTextMarker:]):
        (-[KWQAccObject doAXPreviousLineStartTextMarkerForTextMarker:]):
        * kwq/KWQKHTMLPart.mm:
        * kwq/WebCoreBridge.mm:
        (-[WebCoreBridge _visiblePositionForPoint:]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@8589 268f45cc-cd09-0410-ab3c-d52691b4dbfc

28 files changed:
WebCore/ChangeLog-2005-08-23
WebCore/khtml/editing/SelectionController.cpp
WebCore/khtml/editing/htmlediting.cpp
WebCore/khtml/editing/selection.cpp
WebCore/khtml/editing/visible_position.cpp
WebCore/khtml/editing/visible_units.cpp
WebCore/khtml/editing/visible_units.h
WebCore/khtml/khtml_events.cpp
WebCore/khtml/khtml_part.cpp
WebCore/khtml/rendering/render_block.cpp
WebCore/khtml/rendering/render_block.h
WebCore/khtml/rendering/render_br.cpp
WebCore/khtml/rendering/render_br.h
WebCore/khtml/rendering/render_container.cpp
WebCore/khtml/rendering/render_container.h
WebCore/khtml/rendering/render_inline.cpp
WebCore/khtml/rendering/render_inline.h
WebCore/khtml/rendering/render_object.cpp
WebCore/khtml/rendering/render_object.h
WebCore/khtml/rendering/render_replaced.cpp
WebCore/khtml/rendering/render_replaced.h
WebCore/khtml/rendering/render_text.cpp
WebCore/khtml/rendering/render_text.h
WebCore/khtml/xml/dom_position.cpp
WebCore/khtml/xml/dom_position.h
WebCore/kwq/KWQAccObject.mm
WebCore/kwq/KWQKHTMLPart.mm
WebCore/kwq/WebCoreBridge.mm

index 9caeaa919aae03d07856080f6678ccf1f091ac9b..8c34d402c43d71ba8bbe8b468d8860e777654548 100644 (file)
@@ -1,3 +1,92 @@
+2005-02-14  David Harrison  <harrison@apple.com>
+
+        Reviewed by Darin.
+
+        <rdar://problem/4004305> REGRESSION (Mail): Command-right-arrow on wrapped text goes to end of previous line
+
+        Fixed nextLinePosition to calculate affinity rather than take it as a parameter.  Propagated the parameter change out to related methods.
+
+        * khtml/editing/htmlediting.cpp:
+        (khtml::DeleteSelectionCommand::initializePositionData):
+        (khtml::InsertLineBreakCommand::doApply):
+        (khtml::InsertParagraphSeparatorCommand::doApply):
+        (khtml::InsertTextCommand::input):
+        (khtml::ReplaceSelectionCommand::doApply):
+        (khtml::ReplaceSelectionCommand::applyStyleToInsertedNodes):
+        * khtml/editing/selection.cpp:
+        (khtml::Selection::modifyExtendingRightForward):
+        (khtml::Selection::modifyMovingRightForward):
+        (khtml::Selection::modifyExtendingLeftBackward):
+        (khtml::Selection::modifyMovingLeftBackward):
+        (khtml::Selection::modify):
+        (khtml::Selection::validate):
+        * khtml/editing/visible_position.cpp:
+        (khtml::visiblePositionsOnDifferentLines):
+        * khtml/editing/visible_units.cpp:
+        (khtml::rootBoxForLine):
+        (khtml::startOfLine):
+        (khtml::endOfLine):
+        (khtml::inSameLine):
+        (khtml::isStartOfLine):
+        (khtml::isEndOfLine):
+        (khtml::previousLinePosition):
+        (khtml::nextLinePosition):
+        (khtml::previousSentencePosition):
+        (khtml::nextSentencePosition):
+        (khtml::previousParagraphPosition):
+        (khtml::nextParagraphPosition):
+        * khtml/editing/visible_units.h:
+        * khtml/khtml_events.cpp:
+        (khtml::MouseEvent::offset):
+        * khtml/khtml_part.cpp:
+        (KHTMLPart::isPointInsideSelection):
+        (KHTMLPart::selectClosestWordFromMouseEvent):
+        (KHTMLPart::handleMousePressEventTripleClick):
+        (KHTMLPart::handleMousePressEventSingleClick):
+        (KHTMLPart::handleMouseMoveEventSelection):
+        (KHTMLPart::khtmlMouseReleaseEvent):
+        * khtml/rendering/render_block.cpp:
+        (khtml::RenderBlock::positionForCoordinates):
+        * khtml/rendering/render_block.h:
+        * khtml/rendering/render_br.cpp:
+        (RenderBR::positionForCoordinates):
+        * khtml/rendering/render_br.h:
+        * khtml/rendering/render_container.cpp:
+        (RenderContainer::positionForCoordinates):
+        * khtml/rendering/render_container.h:
+        * khtml/rendering/render_inline.cpp:
+        (RenderInline::positionForCoordinates):
+        * khtml/rendering/render_inline.h:
+        * khtml/rendering/render_object.cpp:
+        (RenderObject::caretRect):
+        (RenderObject::positionForCoordinates):
+        * khtml/rendering/render_object.h:
+        * khtml/rendering/render_replaced.cpp:
+        (RenderReplaced::positionForCoordinates):
+        * khtml/rendering/render_replaced.h:
+        * khtml/rendering/render_text.cpp:
+        (RenderText::positionForCoordinates):
+        * khtml/rendering/render_text.h:
+        * khtml/xml/dom_position.cpp:
+        (DOM::Position::previousCharacterPosition):
+        (DOM::Position::nextCharacterPosition):
+        (DOM::Position::leadingWhitespacePosition):
+        (DOM::Position::trailingWhitespacePosition):
+        * khtml/xml/dom_position.h:
+        * kwq/KWQAccObject.mm:
+        (-[KWQAccObject value]):
+        (-[KWQAccObject accessibilityAttributeValue:]):
+        (-[KWQAccObject doAXLineForTextMarker:]):
+        (-[KWQAccObject doAXTextMarkerRangeForLine:]):
+        (-[KWQAccObject doAXTextMarkerForPosition:]):
+        (-[KWQAccObject doAXLeftLineTextMarkerRangeForTextMarker:]):
+        (-[KWQAccObject doAXRightLineTextMarkerRangeForTextMarker:]):
+        (-[KWQAccObject doAXNextLineEndTextMarkerForTextMarker:]):
+        (-[KWQAccObject doAXPreviousLineStartTextMarkerForTextMarker:]):
+        * kwq/KWQKHTMLPart.mm:
+        * kwq/WebCoreBridge.mm:
+        (-[WebCoreBridge _visiblePositionForPoint:]):
+
 05-02-07  Maciej Stachowiak  <mjs@apple.com>
 
         Reviewed by Ken and John.
index 54ece719458c0016fa39ed9fcc894be65602eb9e..5ee8317e1d23dfb95752bd556f5245583ee106dd 100644 (file)
@@ -253,13 +253,13 @@ VisiblePosition Selection::modifyExtendingRightForward(ETextGranularity granular
             pos = nextWordPosition(pos);
             break;
         case PARAGRAPH:
-            pos = nextParagraphPosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = nextParagraphPosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE:
-            pos = nextLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE_BOUNDARY:
-            pos = endOfLine(VisiblePosition(m_end, m_affinity), UPSTREAM);
+            pos = endOfLine(VisiblePosition(m_end, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = endOfParagraph(VisiblePosition(m_end, m_affinity));
@@ -286,31 +286,18 @@ VisiblePosition Selection::modifyMovingRightForward(ETextGranularity granularity
             pos = nextWordPosition(VisiblePosition(m_extent, m_affinity));
             break;
         case PARAGRAPH:
-            pos = nextParagraphPosition(VisiblePosition(m_end, m_affinity), m_affinity, xPosForVerticalArrowNavigation(END, isRange()));
+            pos = nextParagraphPosition(VisiblePosition(m_end, m_affinity), xPosForVerticalArrowNavigation(END, isRange()));
             break;
         case LINE: {
-            // This somewhat complicated code is needed to handle the case where there is a
-            // whole line selected (like when the user clicks at the start of a line and hits shift+down-arrow),
-            // and then hits an (unshifted) down arrow. Since the whole-line selection considers its
-            // ending point to be the start of the next line, it may be necessary to juggle the 
-            // position to use as the VisiblePosition to pass to nextLinePosition(). If this juggling
-            // is not done, you can wind up skipping a line. See these two bugs for more information:
-            // <rdar://problem/3875618> REGRESSION (Mail): Hitting down arrow with full line selected skips line (br case)
-            // <rdar://problem/3875641> REGRESSION (Mail): Hitting down arrow with full line selected skips line (div case)
-            if (isCaret()) {
-                pos = VisiblePosition(m_end, m_affinity);
-            } else if (isRange()) {
-                Position p(m_end.upstream());
-                if (p.node()->id() == ID_BR)
-                    pos = VisiblePosition(Position(p.node(), 0), UPSTREAM);
-                else
-                    pos = VisiblePosition(p, UPSTREAM);
-            }
-            pos = nextLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(END, isRange()));
+            // down-arrowing from a range selection that ends at the start of a line needs
+            // to leave the selection at that line start (no need to call nextLinePosition!)
+            pos = VisiblePosition(m_end, m_affinity);
+            if (!isRange() || !isStartOfLine(pos))
+                pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(END, isRange()));
             break;
         }
         case LINE_BOUNDARY:
-            pos = endOfLine(VisiblePosition(m_end, m_affinity), UPSTREAM);
+            pos = endOfLine(VisiblePosition(m_end, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = endOfParagraph(VisiblePosition(m_end, m_affinity));
@@ -333,13 +320,13 @@ VisiblePosition Selection::modifyExtendingLeftBackward(ETextGranularity granular
             pos = previousWordPosition(pos);
             break;
         case PARAGRAPH:
-            pos = previousParagraphPosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = previousParagraphPosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE:
-            pos = previousLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = previousLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE_BOUNDARY:
-            pos = startOfLine(VisiblePosition(m_start, m_affinity), DOWNSTREAM);
+            pos = startOfLine(VisiblePosition(m_start, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = startOfParagraph(VisiblePosition(m_start, m_affinity));
@@ -365,13 +352,13 @@ VisiblePosition Selection::modifyMovingLeftBackward(ETextGranularity granularity
             pos = previousWordPosition(VisiblePosition(m_extent, m_affinity));
             break;
         case PARAGRAPH:
-            pos = previousParagraphPosition(VisiblePosition(m_start, m_affinity), m_affinity, xPosForVerticalArrowNavigation(START, isRange()));
+            pos = previousParagraphPosition(VisiblePosition(m_start, m_affinity), xPosForVerticalArrowNavigation(START, isRange()));
             break;
         case LINE:
-            pos = previousLinePosition(VisiblePosition(m_start, m_affinity), m_affinity, xPosForVerticalArrowNavigation(START, isRange()));
+            pos = previousLinePosition(VisiblePosition(m_start, m_affinity), xPosForVerticalArrowNavigation(START, isRange()));
             break;
         case LINE_BOUNDARY:
-            pos = startOfLine(VisiblePosition(m_start, m_affinity), DOWNSTREAM);
+            pos = startOfLine(VisiblePosition(m_start, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = startOfParagraph(VisiblePosition(m_start, m_affinity));
@@ -449,6 +436,7 @@ bool Selection::modify(EAlter alter, int verticalDistance)
     if (up)
         verticalDistance = -verticalDistance;
 
+    // can dump this UPSTREAM when we have m_extentAffinity
     m_affinity = UPSTREAM;
     setModifyBias(alter, up ? BACKWARD : FORWARD);
 
@@ -475,7 +463,7 @@ bool Selection::modify(EAlter alter, int verticalDistance)
     VisiblePosition result;
     VisiblePosition next;
     for (VisiblePosition p = pos; ; p = next) {
-        next = (up ? previousLinePosition : nextLinePosition)(p, m_affinity, xPos);
+        next = (up ? previousLinePosition : nextLinePosition)(p, xPos);
         if (next.isNull() || next == p)
             break;
         int nextY;
@@ -879,11 +867,11 @@ void Selection::validate(ETextGranularity granularity)
             VisiblePosition start = m_baseIsStart ? VisiblePosition(m_base, m_affinity)   : VisiblePosition(m_extent, m_affinity);
             VisiblePosition end   = m_baseIsStart ? VisiblePosition(m_extent, m_affinity) : VisiblePosition(m_base, m_affinity);
             EWordSide side = RightWordIfOnBoundary;
-            if (isEndOfDocument(start) || (isEndOfLine(start, m_affinity) && !isStartOfLine(start, m_affinity) && !isEndOfParagraph(start)))
+            if (isEndOfDocument(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
                 side = LeftWordIfOnBoundary;
             m_start = startOfWord(start, side).deepEquivalent();
             side = RightWordIfOnBoundary;
-            if (isEndOfDocument(end) || (isEndOfLine(end, m_affinity) && !isStartOfLine(end, m_affinity) && !isEndOfParagraph(end)))
+            if (isEndOfDocument(end) || (isEndOfLine(end) && !isStartOfLine(end) && !isEndOfParagraph(end)))
                 side = LeftWordIfOnBoundary;
             m_end = endOfWord(end, side).deepEquivalent();
             
@@ -892,17 +880,17 @@ void Selection::validate(ETextGranularity granularity)
         case LINE:
         case LINE_BOUNDARY:
             if (m_baseIsStart) {
-                m_start = startOfLine(VisiblePosition(m_base, m_affinity), m_affinity).deepEquivalent();
-                m_end = endOfLine(VisiblePosition(m_extent, m_affinity), m_affinity, IncludeLineBreak).deepEquivalent();
+                m_start = startOfLine(VisiblePosition(m_base, m_affinity)).deepEquivalent();
+                m_end = endOfLine(VisiblePosition(m_extent, m_affinity), IncludeLineBreak).deepEquivalent();
             } else {
-                m_start = startOfLine(VisiblePosition(m_extent, m_affinity), m_affinity).deepEquivalent();
-                m_end = endOfLine(VisiblePosition(m_base, m_affinity), m_affinity, IncludeLineBreak).deepEquivalent();
+                m_start = startOfLine(VisiblePosition(m_extent, m_affinity)).deepEquivalent();
+                m_end = endOfLine(VisiblePosition(m_base, m_affinity), IncludeLineBreak).deepEquivalent();
             }
             break;
         case PARAGRAPH:
             if (m_baseIsStart) {
                 VisiblePosition pos(m_base, m_affinity);
-                if (isStartOfLine(pos, m_affinity) && isEndOfDocument(pos))
+                if (isStartOfLine(pos) && isEndOfDocument(pos))
                     pos = pos.previous();
                 m_start = startOfParagraph(pos).deepEquivalent();
                 m_end = endOfParagraph(VisiblePosition(m_extent, m_affinity), IncludeLineBreak).deepEquivalent();
index 570bf1f99bee1bc6a86a417a94a546b07104a5f1..1aaa46a4b7478c20d374749ce5840239c00227d6 100644 (file)
@@ -2227,17 +2227,18 @@ void DeleteSelectionCommand::initializePositionData()
     //
     // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection
     //
-    m_leadingWhitespace = m_upstreamStart.leadingWhitespacePosition();
+    m_leadingWhitespace = m_upstreamStart.leadingWhitespacePosition(m_selectionToDelete.startAffinity());
     bool hasLeadingWhitespaceBeforeAdjustment = m_leadingWhitespace.isNotNull();
     if (m_smartDelete && hasLeadingWhitespaceBeforeAdjustment) {
-        Position pos = VisiblePosition(start, m_selectionToDelete.startAffinity()).previous().deepEquivalent();
+        VisiblePosition visiblePos = VisiblePosition(start, m_selectionToDelete.startAffinity()).previous();
+        Position pos = visiblePos.deepEquivalent();
         // Expand out one character upstream for smart delete and recalculate
         // positions based on this change.
         m_upstreamStart = pos.upstream(StayInBlock);
         m_downstreamStart = pos.downstream(StayInBlock);
-        m_leadingWhitespace = m_upstreamStart.leadingWhitespacePosition();
+        m_leadingWhitespace = m_upstreamStart.leadingWhitespacePosition(visiblePos.affinity());
     }
-    m_trailingWhitespace = m_downstreamEnd.trailingWhitespacePosition();
+    m_trailingWhitespace = m_downstreamEnd.trailingWhitespacePosition(VP_DEFAULT_AFFINITY);
     // Note: trailing whitespace is only considered for smart delete if there is no leading
     // whitespace, as in the case where you double-click the first word of a paragraph.
     if (m_smartDelete && !hasLeadingWhitespaceBeforeAdjustment && m_trailingWhitespace.isNotNull()) {
@@ -2246,7 +2247,7 @@ void DeleteSelectionCommand::initializePositionData()
         Position pos = VisiblePosition(end, m_selectionToDelete.endAffinity()).next().deepEquivalent();
         m_upstreamEnd = pos.upstream(StayInBlock);
         m_downstreamEnd = pos.downstream(StayInBlock);
-        m_trailingWhitespace = m_downstreamEnd.trailingWhitespacePosition();
+        m_trailingWhitespace = m_downstreamEnd.trailingWhitespacePosition(VP_DEFAULT_AFFINITY);
     }
     m_trailingWhitespaceValid = true;
     
@@ -2266,7 +2267,7 @@ void DeleteSelectionCommand::initializePositionData()
     //
     VisiblePosition visibleEnd(end, m_selectionToDelete.endAffinity());
     if (isFirstVisiblePositionInParagraph(visibleEnd) || isLastVisiblePositionInParagraph(visibleEnd)) {
-        Position previousLineStart = previousLinePosition(visibleEnd, DOWNSTREAM, 0).deepEquivalent();
+        Position previousLineStart = previousLinePosition(visibleEnd, 0).deepEquivalent();
         if (previousLineStart.isNull() || RangeImpl::compareBoundaryPoints(previousLineStart, m_downstreamStart) >= 0)
             m_mergeBlocksAfterDelete = false;
     }
@@ -2920,7 +2921,9 @@ void InsertLineBreakCommand::doApply()
         int exception;
         rangeAroundNode->selectNode(nodeToInsert, exception);
 
-        setEndingSelection(Selection(rangeAroundNode, DOWNSTREAM, UPSTREAM));
+        // affinity is not really important since this is a temp selection
+        // just for calling applyStyle
+        setEndingSelection(Selection(rangeAroundNode, khtml::SEL_DEFAULT_AFFINITY, khtml::SEL_DEFAULT_AFFINITY));
         applyStyle(typingStyle);
 
         setEndingSelection(selectionBeforeStyle);
@@ -3154,7 +3157,8 @@ void InsertParagraphSeparatorCommand::doApply()
     }
 
     // Make sure we do not cause a rendered space to become unrendered.
-    Position leadingWhitespace = pos.leadingWhitespacePosition();
+    // FIXME: We need the affinity for pos, but pos.downstream(StayInBlock) does not give it
+    Position leadingWhitespace = pos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
     if (leadingWhitespace.isNotNull()) {
         TextImpl *textNode = static_cast<TextImpl *>(leadingWhitespace.node());
         replaceTextInNode(textNode, leadingWhitespace.offset(), 1, nonBreakingSpaceString());
@@ -3433,7 +3437,8 @@ void InsertTextCommand::input(const DOMString &text, bool selectInsertedText)
     
     // Delete any insignificant text that could get in the way of whitespace turning
     // out correctly after the insertion.
-    deleteInsignificantTextDownstream(endingSelection().end().trailingWhitespacePosition());
+    selection = endingSelection();
+    deleteInsignificantTextDownstream(selection.end().trailingWhitespacePosition(selection.endAffinity()));
     
     // Make sure the document is set up to receive text
     Position startPosition = prepareForTextInsertion(adjustDownstream);
@@ -4316,15 +4321,17 @@ void ReplaceSelectionCommand::doApply()
     // check whether to "smart replace" needs to add leading and/or trailing space
     bool addLeadingSpace = false;
     bool addTrailingSpace = false;
+    // FIXME: We need the affinity for startPos and endPos, but Position::downstream
+    // and Position::upstream do not give it
     if (m_smartReplace) {
-        addLeadingSpace = startPos.leadingWhitespacePosition().isNotNull();
+        addLeadingSpace = startPos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY).isNotNull();
         if (addLeadingSpace) {
             QChar previousChar = VisiblePosition(startPos, VP_DEFAULT_AFFINITY).previous().character();
             if (!previousChar.isNull()) {
                 addLeadingSpace = !part->isCharacterSmartReplaceExempt(previousChar, true);
             }
         }
-        addTrailingSpace = endPos.trailingWhitespacePosition().isNotNull();
+        addTrailingSpace = endPos.trailingWhitespacePosition(VP_DEFAULT_AFFINITY).isNotNull();
         if (addTrailingSpace) {
             QChar thisChar = VisiblePosition(endPos, VP_DEFAULT_AFFINITY).character();
             if (!thisChar.isNull()) {
@@ -4623,7 +4630,9 @@ void ReplaceSelectionCommand::applyStyleToInsertedNodes()
                 int exceptionCode = 0;
                 rangeAroundNode->selectNode(node, exceptionCode);
                 ASSERT(exceptionCode == 0);
-                setEndingSelection(Selection(rangeAroundNode, DOWNSTREAM, UPSTREAM));
+                               // affinity is not really important since this is a temp selection
+                               // just for calling applyStyle
+                setEndingSelection(Selection(rangeAroundNode, SEL_DEFAULT_AFFINITY, SEL_DEFAULT_AFFINITY));
                 applyStyle(desiredStyle);
                 rangeAroundNode->deref();
             }
index 54ece719458c0016fa39ed9fcc894be65602eb9e..5ee8317e1d23dfb95752bd556f5245583ee106dd 100644 (file)
@@ -253,13 +253,13 @@ VisiblePosition Selection::modifyExtendingRightForward(ETextGranularity granular
             pos = nextWordPosition(pos);
             break;
         case PARAGRAPH:
-            pos = nextParagraphPosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = nextParagraphPosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE:
-            pos = nextLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE_BOUNDARY:
-            pos = endOfLine(VisiblePosition(m_end, m_affinity), UPSTREAM);
+            pos = endOfLine(VisiblePosition(m_end, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = endOfParagraph(VisiblePosition(m_end, m_affinity));
@@ -286,31 +286,18 @@ VisiblePosition Selection::modifyMovingRightForward(ETextGranularity granularity
             pos = nextWordPosition(VisiblePosition(m_extent, m_affinity));
             break;
         case PARAGRAPH:
-            pos = nextParagraphPosition(VisiblePosition(m_end, m_affinity), m_affinity, xPosForVerticalArrowNavigation(END, isRange()));
+            pos = nextParagraphPosition(VisiblePosition(m_end, m_affinity), xPosForVerticalArrowNavigation(END, isRange()));
             break;
         case LINE: {
-            // This somewhat complicated code is needed to handle the case where there is a
-            // whole line selected (like when the user clicks at the start of a line and hits shift+down-arrow),
-            // and then hits an (unshifted) down arrow. Since the whole-line selection considers its
-            // ending point to be the start of the next line, it may be necessary to juggle the 
-            // position to use as the VisiblePosition to pass to nextLinePosition(). If this juggling
-            // is not done, you can wind up skipping a line. See these two bugs for more information:
-            // <rdar://problem/3875618> REGRESSION (Mail): Hitting down arrow with full line selected skips line (br case)
-            // <rdar://problem/3875641> REGRESSION (Mail): Hitting down arrow with full line selected skips line (div case)
-            if (isCaret()) {
-                pos = VisiblePosition(m_end, m_affinity);
-            } else if (isRange()) {
-                Position p(m_end.upstream());
-                if (p.node()->id() == ID_BR)
-                    pos = VisiblePosition(Position(p.node(), 0), UPSTREAM);
-                else
-                    pos = VisiblePosition(p, UPSTREAM);
-            }
-            pos = nextLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(END, isRange()));
+            // down-arrowing from a range selection that ends at the start of a line needs
+            // to leave the selection at that line start (no need to call nextLinePosition!)
+            pos = VisiblePosition(m_end, m_affinity);
+            if (!isRange() || !isStartOfLine(pos))
+                pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(END, isRange()));
             break;
         }
         case LINE_BOUNDARY:
-            pos = endOfLine(VisiblePosition(m_end, m_affinity), UPSTREAM);
+            pos = endOfLine(VisiblePosition(m_end, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = endOfParagraph(VisiblePosition(m_end, m_affinity));
@@ -333,13 +320,13 @@ VisiblePosition Selection::modifyExtendingLeftBackward(ETextGranularity granular
             pos = previousWordPosition(pos);
             break;
         case PARAGRAPH:
-            pos = previousParagraphPosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = previousParagraphPosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE:
-            pos = previousLinePosition(pos, m_affinity, xPosForVerticalArrowNavigation(EXTENT));
+            pos = previousLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));
             break;
         case LINE_BOUNDARY:
-            pos = startOfLine(VisiblePosition(m_start, m_affinity), DOWNSTREAM);
+            pos = startOfLine(VisiblePosition(m_start, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = startOfParagraph(VisiblePosition(m_start, m_affinity));
@@ -365,13 +352,13 @@ VisiblePosition Selection::modifyMovingLeftBackward(ETextGranularity granularity
             pos = previousWordPosition(VisiblePosition(m_extent, m_affinity));
             break;
         case PARAGRAPH:
-            pos = previousParagraphPosition(VisiblePosition(m_start, m_affinity), m_affinity, xPosForVerticalArrowNavigation(START, isRange()));
+            pos = previousParagraphPosition(VisiblePosition(m_start, m_affinity), xPosForVerticalArrowNavigation(START, isRange()));
             break;
         case LINE:
-            pos = previousLinePosition(VisiblePosition(m_start, m_affinity), m_affinity, xPosForVerticalArrowNavigation(START, isRange()));
+            pos = previousLinePosition(VisiblePosition(m_start, m_affinity), xPosForVerticalArrowNavigation(START, isRange()));
             break;
         case LINE_BOUNDARY:
-            pos = startOfLine(VisiblePosition(m_start, m_affinity), DOWNSTREAM);
+            pos = startOfLine(VisiblePosition(m_start, m_affinity));
             break;
         case PARAGRAPH_BOUNDARY:
             pos = startOfParagraph(VisiblePosition(m_start, m_affinity));
@@ -449,6 +436,7 @@ bool Selection::modify(EAlter alter, int verticalDistance)
     if (up)
         verticalDistance = -verticalDistance;
 
+    // can dump this UPSTREAM when we have m_extentAffinity
     m_affinity = UPSTREAM;
     setModifyBias(alter, up ? BACKWARD : FORWARD);
 
@@ -475,7 +463,7 @@ bool Selection::modify(EAlter alter, int verticalDistance)
     VisiblePosition result;
     VisiblePosition next;
     for (VisiblePosition p = pos; ; p = next) {
-        next = (up ? previousLinePosition : nextLinePosition)(p, m_affinity, xPos);
+        next = (up ? previousLinePosition : nextLinePosition)(p, xPos);
         if (next.isNull() || next == p)
             break;
         int nextY;
@@ -879,11 +867,11 @@ void Selection::validate(ETextGranularity granularity)
             VisiblePosition start = m_baseIsStart ? VisiblePosition(m_base, m_affinity)   : VisiblePosition(m_extent, m_affinity);
             VisiblePosition end   = m_baseIsStart ? VisiblePosition(m_extent, m_affinity) : VisiblePosition(m_base, m_affinity);
             EWordSide side = RightWordIfOnBoundary;
-            if (isEndOfDocument(start) || (isEndOfLine(start, m_affinity) && !isStartOfLine(start, m_affinity) && !isEndOfParagraph(start)))
+            if (isEndOfDocument(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
                 side = LeftWordIfOnBoundary;
             m_start = startOfWord(start, side).deepEquivalent();
             side = RightWordIfOnBoundary;
-            if (isEndOfDocument(end) || (isEndOfLine(end, m_affinity) && !isStartOfLine(end, m_affinity) && !isEndOfParagraph(end)))
+            if (isEndOfDocument(end) || (isEndOfLine(end) && !isStartOfLine(end) && !isEndOfParagraph(end)))
                 side = LeftWordIfOnBoundary;
             m_end = endOfWord(end, side).deepEquivalent();
             
@@ -892,17 +880,17 @@ void Selection::validate(ETextGranularity granularity)
         case LINE:
         case LINE_BOUNDARY:
             if (m_baseIsStart) {
-                m_start = startOfLine(VisiblePosition(m_base, m_affinity), m_affinity).deepEquivalent();
-                m_end = endOfLine(VisiblePosition(m_extent, m_affinity), m_affinity, IncludeLineBreak).deepEquivalent();
+                m_start = startOfLine(VisiblePosition(m_base, m_affinity)).deepEquivalent();
+                m_end = endOfLine(VisiblePosition(m_extent, m_affinity), IncludeLineBreak).deepEquivalent();
             } else {
-                m_start = startOfLine(VisiblePosition(m_extent, m_affinity), m_affinity).deepEquivalent();
-                m_end = endOfLine(VisiblePosition(m_base, m_affinity), m_affinity, IncludeLineBreak).deepEquivalent();
+                m_start = startOfLine(VisiblePosition(m_extent, m_affinity)).deepEquivalent();
+                m_end = endOfLine(VisiblePosition(m_base, m_affinity), IncludeLineBreak).deepEquivalent();
             }
             break;
         case PARAGRAPH:
             if (m_baseIsStart) {
                 VisiblePosition pos(m_base, m_affinity);
-                if (isStartOfLine(pos, m_affinity) && isEndOfDocument(pos))
+                if (isStartOfLine(pos) && isEndOfDocument(pos))
                     pos = pos.previous();
                 m_start = startOfParagraph(pos).deepEquivalent();
                 m_end = endOfParagraph(VisiblePosition(m_extent, m_affinity), IncludeLineBreak).deepEquivalent();
index 102497012114013b72747dd27713f992ef271455..6e7b692fb2985fa39d84095fa0c07c4e6ce0a0ce 100644 (file)
@@ -477,8 +477,8 @@ bool visiblePositionsOnDifferentLines(const VisiblePosition &pos1, const Visible
     RenderObject *r2 = p2.node()->renderer();
     if (r1->isBlockFlow() || r2->isBlockFlow())
         return r1 == r2 ? false : true;
-    InlineBox *b1 = r1 ? r1->inlineBox(p1.offset()) : 0;
-    InlineBox *b2 = r2 ? r2->inlineBox(p2.offset()) : 0;
+    InlineBox *b1 = r1 ? r1->inlineBox(p1.offset(), pos1.affinity()) : 0;
+    InlineBox *b2 = r2 ? r2->inlineBox(p2.offset(), pos2.affinity()) : 0;
     return (b1 && b2 && b1->root() != b2->root());
 }
 
index 284b84a27ad5d468242038a05ecb876628ba7047..5b74ee52af007438ee883f1513ac3d61a26ca964 100644 (file)
@@ -258,7 +258,7 @@ VisiblePosition nextWordPosition(const VisiblePosition &c)
 
 // ---------
 
-static RootInlineBox *rootBoxForLine(const VisiblePosition &c, EAffinity affinity)
+static RootInlineBox *rootBoxForLine(const VisiblePosition &c)
 {
     Position p = c.deepEquivalent();
     NodeImpl *node = p.node();
@@ -269,16 +269,16 @@ static RootInlineBox *rootBoxForLine(const VisiblePosition &c, EAffinity affinit
     if (!renderer)
         return 0;
     
-    InlineBox *box = renderer->inlineBox(p.offset(), affinity);
+    InlineBox *box = renderer->inlineBox(p.offset(), c.affinity());
     if (!box)
         return 0;
     
     return box->root();
 }
 
-VisiblePosition startOfLine(const VisiblePosition &c, EAffinity affinity)
+VisiblePosition startOfLine(const VisiblePosition &c)
 {
-    RootInlineBox *rootBox = rootBoxForLine(c, affinity);
+    RootInlineBox *rootBox = rootBoxForLine(c);
     if (!rootBox)
         return VisiblePosition();
     
@@ -299,15 +299,15 @@ VisiblePosition startOfLine(const VisiblePosition &c, EAffinity affinity)
         InlineTextBox *startTextBox = static_cast<InlineTextBox *>(startBox);
         startOffset = startTextBox->m_start;
     }
-    return VisiblePosition(startNode, startOffset, affinity);
+    return VisiblePosition(startNode, startOffset, DOWNSTREAM);
 }
 
-VisiblePosition endOfLine(const VisiblePosition &c, EAffinity affinity, EIncludeLineBreak includeLineBreak)
+VisiblePosition endOfLine(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
 {
     // FIXME: Need to implement the "include line break" version.
     assert(includeLineBreak == DoNotIncludeLineBreak);
 
-    RootInlineBox *rootBox = rootBoxForLine(c, affinity);
+    RootInlineBox *rootBox = rootBoxForLine(c);
     if (!rootBox)
         return VisiblePosition();
     
@@ -326,32 +326,39 @@ VisiblePosition endOfLine(const VisiblePosition &c, EAffinity affinity, EInclude
     long endOffset = 1;
     if (endNode->id() == ID_BR) {
         endOffset = 0;
-    }
-    else if (endBox->isInlineTextBox()) {
+    } else if (endBox->isInlineTextBox()) {
         InlineTextBox *endTextBox = static_cast<InlineTextBox *>(endBox);
         endOffset = endTextBox->m_start + endTextBox->m_len;
     }
-    return VisiblePosition(endNode, endOffset, affinity);
+
+    // generate VisiblePosition with correct affinity
+    VisiblePosition result = VisiblePosition(endNode, endOffset, DOWNSTREAM);
+    VisiblePosition temp = result;
+    temp.setAffinity(UPSTREAM);
+    if (visiblePositionsOnDifferentLines(temp, result))
+        result.setAffinity(UPSTREAM);
+    
+    return result;
 }
 
-bool inSameLine(const VisiblePosition &a, EAffinity aa, const VisiblePosition &b, EAffinity ab)
+bool inSameLine(const VisiblePosition &a, const VisiblePosition &b)
 {
-    return a.isNotNull() && startOfLine(a, aa) == startOfLine(b, ab);
+    return a.isNotNull() && startOfLine(a) == startOfLine(b);
 }
 
-bool isStartOfLine(const VisiblePosition &p, EAffinity affinity)
+bool isStartOfLine(const VisiblePosition &p)
 {
-    return p.isNotNull() && p == startOfLine(p, affinity);
+    return p.isNotNull() && p == startOfLine(p);
 }
 
-bool isEndOfLine(const VisiblePosition &p, EAffinity affinity)
+bool isEndOfLine(const VisiblePosition &p)
 {
-    return p.isNotNull() && p == endOfLine(p, affinity, DoNotIncludeLineBreak);
+    return p.isNotNull() && p == endOfLine(p, DoNotIncludeLineBreak);
 }
 
-VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
+VisiblePosition previousLinePosition(const VisiblePosition &c, int x)
 {
-    Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
+    Position p = c.affinity() == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
     NodeImpl *node = p.node();
     if (!node)
         return VisiblePosition();
@@ -362,7 +369,7 @@ VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinit
 
     RenderBlock *containingBlock = 0;
     RootInlineBox *root = 0;
-    InlineBox *box = renderer->inlineBox(p.offset(), affinity);
+    InlineBox *box = renderer->inlineBox(p.offset(), c.affinity());
     if (box) {
         root = box->root()->prevRootBox();
         if (root)
@@ -401,9 +408,7 @@ VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinit
         int absx, absy;
         containingBlock->absolutePosition(absx, absy);
         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
-        EAffinity posAffinity;
-        Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
-        return VisiblePosition(pos, posAffinity);
+        return renderer->positionForCoordinates(x, absy + root->topOverflow());
     }
     
     // Could not find a previous line. This means we must already be on the first line.
@@ -412,9 +417,9 @@ VisiblePosition previousLinePosition(const VisiblePosition &c, EAffinity affinit
     return VisiblePosition(node->rootEditableElement(), 0, DOWNSTREAM);
 }
 
-VisiblePosition nextLinePosition(const VisiblePosition &c, EAffinity affinity, int x)
+VisiblePosition nextLinePosition(const VisiblePosition &c, int x)
 {
-    Position p = affinity == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
+    Position p = c.affinity() == UPSTREAM ? c.deepEquivalent() : c.downstreamDeepEquivalent();
     NodeImpl *node = p.node();
     if (!node)
         return VisiblePosition();
@@ -425,7 +430,7 @@ VisiblePosition nextLinePosition(const VisiblePosition &c, EAffinity affinity, i
 
     RenderBlock *containingBlock = 0;
     RootInlineBox *root = 0;
-    InlineBox *box = renderer->inlineBox(p.offset(), affinity);
+    InlineBox *box = renderer->inlineBox(p.offset(), c.affinity());
     if (box) {
         root = box->root()->nextRootBox();
         if (root)
@@ -464,16 +469,14 @@ VisiblePosition nextLinePosition(const VisiblePosition &c, EAffinity affinity, i
         int absx, absy;
         containingBlock->absolutePosition(absx, absy);
         RenderObject *renderer = root->closestLeafChildForXPos(x, absx)->object();
-        EAffinity posAffinity;
-        Position pos = renderer->positionForCoordinates(x, absy + root->topOverflow(), &posAffinity);
-        return VisiblePosition(pos, posAffinity);
+        return renderer->positionForCoordinates(x, absy + root->topOverflow());
     }    
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     ElementImpl *rootElement = node->rootEditableElement();
-    return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, affinity);
+    return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, DOWNSTREAM);
 }
 
 // ---------
@@ -507,7 +510,7 @@ static unsigned previousSentencePositionBoundary(const QChar *characters, unsign
     return nextSentenceFromIndex(characters, length, length, false);
 }
 
-VisiblePosition previousSentencePosition(const VisiblePosition &c, EAffinity, int x)
+VisiblePosition previousSentencePosition(const VisiblePosition &c, int x)
 {
     return previousBoundary(c, previousSentencePositionBoundary);
 }
@@ -517,7 +520,7 @@ static unsigned nextSentencePositionBoundary(const QChar *characters, unsigned l
     return nextSentenceFromIndex(characters, length, 0, true);
 }
 
-VisiblePosition nextSentencePosition(const VisiblePosition &c, EAffinity, int x)
+VisiblePosition nextSentencePosition(const VisiblePosition &c, int x)
 {
     return nextBoundary(c, nextSentencePositionBoundary);
 }
@@ -639,11 +642,11 @@ bool isEndOfParagraph(const VisiblePosition &pos)
     return pos.isNotNull() && pos == endOfParagraph(pos, DoNotIncludeLineBreak);
 }
 
-VisiblePosition previousParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
+VisiblePosition previousParagraphPosition(const VisiblePosition &p, int x)
 {
     VisiblePosition pos = p;
     do {
-        VisiblePosition n = previousLinePosition(pos, a, x);
+        VisiblePosition n = previousLinePosition(pos, x);
         if (n.isNull() || n == pos) {
             return p;
         }
@@ -652,11 +655,11 @@ VisiblePosition previousParagraphPosition(const VisiblePosition &p, EAffinity a,
     return pos;
 }
 
-VisiblePosition nextParagraphPosition(const VisiblePosition &p, EAffinity a, int x)
+VisiblePosition nextParagraphPosition(const VisiblePosition &p, int x)
 {
     VisiblePosition pos = p;
     do {
-        VisiblePosition n = nextLinePosition(pos, a, x);
+        VisiblePosition n = nextLinePosition(pos, x);
         if (n.isNull() || n == pos) {
             return p;
         }
index e6ce51497737bff53b998460a526d60c861d1837..404b2468bf087e4755922b71e06c3cc9cf34dc1a 100644 (file)
@@ -42,13 +42,13 @@ VisiblePosition previousWordPosition(const VisiblePosition &);
 VisiblePosition nextWordPosition(const VisiblePosition &);
 
 // lines
-VisiblePosition startOfLine(const VisiblePosition &, EAffinity);
-VisiblePosition endOfLine(const VisiblePosition &, EAffinity, EIncludeLineBreak = DoNotIncludeLineBreak);
-VisiblePosition previousLinePosition(const VisiblePosition &, EAffinity, int x);
-VisiblePosition nextLinePosition(const VisiblePosition &, EAffinity, int x);
-bool inSameLine(const VisiblePosition &, EAffinity, const VisiblePosition &, EAffinity);
-bool isStartOfLine(const VisiblePosition &, EAffinity);
-bool isEndOfLine(const VisiblePosition &, EAffinity);
+VisiblePosition startOfLine(const VisiblePosition &);
+VisiblePosition endOfLine(const VisiblePosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
+VisiblePosition previousLinePosition(const VisiblePosition &, int x);
+VisiblePosition nextLinePosition(const VisiblePosition &, int x);
+bool inSameLine(const VisiblePosition &, const VisiblePosition &);
+bool isStartOfLine(const VisiblePosition &);
+bool isEndOfLine(const VisiblePosition &);
 
 // sentences
 VisiblePosition startOfSentence(const VisiblePosition &);
@@ -59,8 +59,8 @@ VisiblePosition nextSentencePosition(const VisiblePosition &);
 // paragraphs (perhaps a misnomer, can be divided by line break elements)
 VisiblePosition startOfParagraph(const VisiblePosition &);
 VisiblePosition endOfParagraph(const VisiblePosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
-VisiblePosition previousParagraphPosition(const VisiblePosition &, EAffinity, int x);
-VisiblePosition nextParagraphPosition(const VisiblePosition &, EAffinity, int x);
+VisiblePosition previousParagraphPosition(const VisiblePosition &, int x);
+VisiblePosition nextParagraphPosition(const VisiblePosition &, int x);
 bool inSameParagraph(const VisiblePosition &, const VisiblePosition &);
 bool isStartOfParagraph(const VisiblePosition &);
 bool isEndOfParagraph(const VisiblePosition &);
index 5c5c3a9c81b0a53fe9b86a0c367ed6daaf9fee8f..3beaec4b17358e7b500ae59f10a7b33d2786991f 100644 (file)
@@ -60,7 +60,7 @@ long khtml::MouseEvent::offset() const
         if (inner.nodeType() == Node::TEXT_NODE)
             inner = inner.parentNode();
         if (inner.handle()->renderer())
-            pos = inner.handle()->renderer()->positionForCoordinates(m_x, m_y);
+            pos = inner.handle()->renderer()->positionForCoordinates(m_x, m_y).deepEquivalent();
     }
     return pos.offset();
 }
index ce03b68982693e893d0842093ba9a83b3b76a734..e744effd6af1153e46ad89dababa00ceea1335f9 100644 (file)
@@ -4438,7 +4438,7 @@ bool KHTMLPart::isPointInsideSelection(int x, int y)
     if (!innerNode || !innerNode->renderer())
         return false;
     
-    Position pos(innerNode->renderer()->positionForCoordinates(x, y));
+    Position pos(innerNode->renderer()->positionForCoordinates(x, y).deepEquivalent());
     if (pos.isNull())
         return false;
 
@@ -4464,10 +4464,9 @@ void KHTMLPart::selectClosestWordFromMouseEvent(QMouseEvent *mouse, DOM::Node &i
     Selection selection;
 
     if (!innerNode.isNull() && innerNode.handle()->renderer() && innerNode.handle()->renderer()->shouldSelect()) {
-        EAffinity affinity;
-        Position pos(innerNode.handle()->renderer()->positionForCoordinates(x, y, &affinity));
+        VisiblePosition pos(innerNode.handle()->renderer()->positionForCoordinates(x, y));
         if (pos.isNotNull()) {
-            selection.moveTo(pos, affinity);
+            selection.moveTo(pos);
             selection.expandUsingGranularity(WORD);
         }
     }
@@ -4498,10 +4497,9 @@ void KHTMLPart::handleMousePressEventTripleClick(khtml::MousePressEvent *event)
     
     if (mouse->button() == LeftButton && !innerNode.isNull() && innerNode.handle()->renderer() &&
         innerNode.handle()->renderer()->shouldSelect()) {
-        EAffinity affinity;
-        Position pos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y(), &affinity));
+        VisiblePosition pos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y()));
         if (pos.isNotNull()) {
-            selection.moveTo(pos, affinity);
+            selection.moveTo(pos);
             selection.expandUsingGranularity(PARAGRAPH);
         }
     }
@@ -4533,11 +4531,12 @@ void KHTMLPart::handleMousePressEventSingleClick(khtml::MousePressEvent *event)
             if (!extendSelection && isPointInsideSelection(event->x(), event->y())) {
                 return;
             }
-            EAffinity affinity;
-            Position pos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y(), &affinity));
-            if (pos.isNull())
-                pos = Position(innerNode.handle(), innerNode.handle()->caretMinOffset());
 
+            VisiblePosition visiblePos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y()));
+            if (visiblePos.isNull())
+                visiblePos = VisiblePosition(innerNode.handle(), innerNode.handle()->caretMinOffset(), khtml::DOWNSTREAM);
+            Position pos = visiblePos.deepEquivalent();
+            
             sel = selection();
             if (extendSelection && sel.isCaretOrRange()) {
                 sel.clearModifyBias();
@@ -4547,9 +4546,9 @@ void KHTMLPart::handleMousePressEventSingleClick(khtml::MousePressEvent *event)
                 Position start = sel.start();
                 short before = RangeImpl::compareBoundaryPoints(pos.node(), pos.offset(), start.node(), start.offset());
                 if (before <= 0) {
-                    sel.setBaseAndExtent(pos, affinity, sel.end(), sel.endAffinity());
+                    sel.setBaseAndExtent(pos, visiblePos.affinity(), sel.end(), sel.endAffinity());
                 } else {
-                    sel.setBaseAndExtent(start, sel.startAffinity(), pos, affinity);
+                    sel.setBaseAndExtent(start, sel.startAffinity(), pos, visiblePos.affinity());
                 }
 
                 if (d->m_selectionGranularity != CHARACTER) {
@@ -4557,7 +4556,7 @@ void KHTMLPart::handleMousePressEventSingleClick(khtml::MousePressEvent *event)
                 }
                 d->m_beganSelectingText = true;
             } else {
-                sel = Selection(pos, affinity);
+                sel = Selection(visiblePos);
                 d->m_selectionGranularity = CHARACTER;
             }
         }
@@ -4753,8 +4752,7 @@ void KHTMLPart::handleMouseMoveEventSelection(khtml::MouseMoveEvent *event)
        return;
 
     // handle making selection
-    EAffinity affinity;
-    Position pos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y(), &affinity));
+    VisiblePosition pos(innerNode.handle()->renderer()->positionForCoordinates(event->x(), event->y()));
 
     // Don't modify the selection if we're not on a node.
     if (pos.isNull())
@@ -4766,10 +4764,10 @@ void KHTMLPart::handleMouseMoveEventSelection(khtml::MouseMoveEvent *event)
     sel.clearModifyBias();
     if (!d->m_beganSelectingText) {
         d->m_beganSelectingText = true;
-        sel.moveTo(pos, affinity);
+        sel.moveTo(pos);
     }
 
-    sel.setExtent(pos, affinity);
+    sel.setExtent(pos);
     if (d->m_selectionGranularity != CHARACTER) {
         sel.expandUsingGranularity(d->m_selectionGranularity);
     }
@@ -4841,9 +4839,8 @@ void KHTMLPart::khtmlMouseReleaseEvent( khtml::MouseReleaseEvent *event )
         Selection selection;
         NodeImpl *node = d->m_selection.base().node();
         if (node->isContentEditable() && node->renderer()) {
-            EAffinity affinity;
-            Position pos = node->renderer()->positionForCoordinates(event->x(), event->y(), &affinity);
-            selection.moveTo(pos, affinity);
+            VisiblePosition pos = node->renderer()->positionForCoordinates(event->x(), event->y());
+            selection.moveTo(pos);
         }
         setSelection(selection);
     }
index 672be94dbc47b307dd95989f414143420647d371..4be990f25654e2c01376c830982e1fdeeacbb832 100644 (file)
@@ -2553,13 +2553,10 @@ Position RenderBlock::positionForRenderer(RenderObject *renderer, bool start) co
     return Position(node, offset);
 }
 
-Position RenderBlock::positionForCoordinates(int _x, int _y, EAffinity *affinity)
+VisiblePosition RenderBlock::positionForCoordinates(int _x, int _y)
 {
-    if (affinity)
-        *affinity = DOWNSTREAM;
-
     if (isTable())
-        return RenderFlow::positionForCoordinates(_x, _y, affinity); 
+        return RenderFlow::positionForCoordinates(_x, _y); 
 
     int absx, absy;
     absolutePosition(absx, absy);
@@ -2569,19 +2566,19 @@ Position RenderBlock::positionForCoordinates(int _x, int _y, EAffinity *affinity
 
     if (_y < top)
         // y coordinate is above block
-        return positionForRenderer(firstLeafChild(), true);
+        return VisiblePosition(positionForRenderer(firstLeafChild(), true), DOWNSTREAM);
 
     if (_y >= bottom)
         // y coordinate is below block
-        return positionForRenderer(lastLeafChild(), false);
+        return VisiblePosition(positionForRenderer(lastLeafChild(), false), DOWNSTREAM);
 
     if (childrenInline()) {
         if (!firstRootBox())
-            return Position(element(), 0);
+            return VisiblePosition(element(), 0, DOWNSTREAM);
             
         if (_y >= top && _y < absy + firstRootBox()->topOverflow())
             // y coordinate is above first root line box
-            return positionForBox(firstRootBox()->firstLeafChild(), true);
+            return VisiblePosition(positionForBox(firstRootBox()->firstLeafChild(), true), DOWNSTREAM);
         
         // look for the closest line box in the root box which is at the passed-in y coordinate
         for (RootInlineBox *root = firstRootBox(); root; root = root->nextRootBox()) {
@@ -2596,16 +2593,16 @@ Position RenderBlock::positionForCoordinates(int _x, int _y, EAffinity *affinity
                 InlineBox *closestBox = root->closestLeafChildForXPos(_x, absx);
                 if (closestBox) {
                     // pass the box a y position that is inside it
-                    return closestBox->object()->positionForCoordinates(_x, absy + closestBox->m_y, affinity);
+                    return closestBox->object()->positionForCoordinates(_x, absy + closestBox->m_y);
                 }
             }
         }
 
         if (lastRootBox())
             // y coordinate is below last root line box
-            return positionForBox(lastRootBox()->lastLeafChild(), false);
+            return VisiblePosition(positionForBox(lastRootBox()->lastLeafChild(), false), DOWNSTREAM);
         
-        return Position(element(), 0);
+        return VisiblePosition(element(), 0, DOWNSTREAM);
     }
     
     // see if any child blocks exist at this y coordinate
@@ -2621,16 +2618,16 @@ Position RenderBlock::positionForCoordinates(int _x, int _y, EAffinity *affinity
         else
             bottom = top + contentHeight();
         if (_y >= top && _y < bottom) {
-            return renderer->positionForCoordinates(_x, _y, affinity);
+            return renderer->positionForCoordinates(_x, _y);
         }
     }
 
     // pass along to the first child
     if (firstChild())
-        return firstChild()->positionForCoordinates(_x, _y, affinity);
+        return firstChild()->positionForCoordinates(_x, _y);
     
     // still no luck...return this render object's element and offset 0
-    return Position(element(), 0);
+    return VisiblePosition(element(), 0, DOWNSTREAM);
 }
 
 void RenderBlock::calcMinMaxWidth()
index 75e90fe8fcce4f7c4d7bacfac0f5dffaa8ff594b..611cb1771fe2145c2821b0ba4f509da62c628eb1 100644 (file)
@@ -189,7 +189,7 @@ public:
 
     bool isPointInScrollbar(int x, int y, int tx, int ty);
 
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
     
     virtual void calcMinMaxWidth();
     void calcInlineMinMaxWidth();
index 23a91d03ccc5b8f2e73d5c7533955d75db5f43eb..116513f6e1fa547ff5ef3e8c8804dc77d3e3ba0f 100644 (file)
@@ -101,11 +101,9 @@ unsigned long RenderBR::caretMaxRenderedOffset() const
     return 1;
 }
 
-Position RenderBR::positionForCoordinates(int _x, int _y, EAffinity *affinity)
+VisiblePosition RenderBR::positionForCoordinates(int _x, int _y)
 {
-    if (affinity)
-        *affinity = DOWNSTREAM;
-    return Position(element(), 0);
+    return VisiblePosition(element(), 0, DOWNSTREAM);
 }
 
 QRect RenderBR::caretRect(int offset, EAffinity affinity, int *extraWidthToEndOfLine)
index 0e54c4b884a889a484a5cd6532097dfa35f06749..9202444de9694c16ca0c74116c3b0dfa05baaf48 100644 (file)
@@ -63,7 +63,7 @@ public:
     virtual long caretMaxOffset() const;
     virtual unsigned long caretMaxRenderedOffset() const;
     
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
     virtual QRect caretRect(int offset, EAffinity affinity = UPSTREAM, int *extraWidthToEndOfLine = 0);
 
     virtual InlineBox *inlineBox(long offset, EAffinity affinity = UPSTREAM);
index fbbd8e44da92aafd7b101dd901238be1ba96ca78..ae1d83c4a0423b947dafc430f1a7ea8cc657622e 100644 (file)
@@ -461,14 +461,11 @@ void RenderContainer::removeLeftoverAnonymousBoxes()
        parent()->removeLeftoverAnonymousBoxes();
 }
 
-Position RenderContainer::positionForCoordinates(int _x, int _y, EAffinity *affinity)
+VisiblePosition RenderContainer::positionForCoordinates(int _x, int _y)
 {
-    if (affinity)
-        *affinity = UPSTREAM;
-
     // no children...return this render object's element, if there is one, and offset 0
     if (!firstChild())
-        return Position(element(), 0);
+        return VisiblePosition(element(), 0, DOWNSTREAM);
 
     // look for the geometrically-closest child and pass off to that child
     int min = INT_MAX;
@@ -493,9 +490,9 @@ Position RenderContainer::positionForCoordinates(int _x, int _y, EAffinity *affi
     }
     
     if (closestRenderer)
-        return closestRenderer->positionForCoordinates(_x, _y, affinity);
+        return closestRenderer->positionForCoordinates(_x, _y);
     
-    return Position(element(), 0);
+    return VisiblePosition(element(), 0, DOWNSTREAM);
 }
     
 #undef DEBUG_LAYOUT
index fce9116feaaa567239782b05e6f18c1eb8b91210..571cc32e07d7020d3c0c6f0302b77ce571490b6d 100644 (file)
@@ -61,7 +61,7 @@ public:
 
     void updatePseudoChild(RenderStyle::PseudoId type, RenderObject* child);
 
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
 
 private:
     void setFirstChild(RenderObject *first) { m_first = first; }
index a8e19c0c85c6103cbb041f3dff35b4adfc91eb96..800065777ab60f89c059e45867c796ef13b9dc88 100644 (file)
@@ -343,12 +343,12 @@ bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
     return hitTestLines(info, _x, _y, _tx, _ty, hitTestAction);
 }
 
-Position RenderInline::positionForCoordinates(int x, int y, EAffinity *affinity)
+VisiblePosition RenderInline::positionForCoordinates(int x, int y)
 {
     for (RenderObject *c = continuation(); c; c = c->continuation()) {
         if (c->isInline() || c->firstChild())
-            return c->positionForCoordinates(x, y, affinity);
+            return c->positionForCoordinates(x, y);
     }
 
-    return RenderFlow::positionForCoordinates(x, y, affinity);
+    return RenderFlow::positionForCoordinates(x, y);
 }
index 3582b0b4e250ab1a2d336d79b9c1b140c46fbecc..321b3a5f3560e64d7274c516838af5c8eb4982b1 100644 (file)
@@ -77,7 +77,7 @@ public:
 
     void absoluteRects(QValueList<QRect>& rects, int _tx, int _ty);
 
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
     
 protected:
     static RenderInline* cloneInline(RenderFlow* src);
index d7f59d071db4765dba67409b817607706b281153..e8382c58917d5a495094d8d01c0f24fb677b931d 100644 (file)
@@ -1671,7 +1671,7 @@ bool RenderObject::absolutePosition(int &xPos, int &yPos, bool f)
     }
 }
 
-QRect RenderObject::caretRect(int, EAffinity, int *extraWidthToEndOfLine)
+QRect RenderObject::caretRect(int offset, EAffinity affinity, int *extraWidthToEndOfLine)
 {
    if (extraWidthToEndOfLine)
        *extraWidthToEndOfLine = 0;
@@ -1862,12 +1862,9 @@ void RenderObject::arenaDelete(RenderArena *arena, void *base)
     arena->free(*(size_t *)base, base);
 }
 
-Position RenderObject::positionForCoordinates(int x, int y, EAffinity *affinity)
+VisiblePosition RenderObject::positionForCoordinates(int x, int y)
 {
-    if (affinity)
-        *affinity = UPSTREAM;
-
-    return Position(element(), caretMinOffset());
+    return VisiblePosition(element(), caretMinOffset(), DOWNSTREAM);
 }
 
 bool RenderObject::mouseInside() const
index 03356ea04a5fc2b8a5108e4e34f4c775e26d26da..84f815957d3abddaf3d83fe2a475cf1fb853f395 100644 (file)
@@ -36,6 +36,7 @@
 #include "rendering/render_style.h"
 #include "khtml_events.h"
 #include "xml/dom_docimpl.h"
+#include "visible_position.h"
 
 #include "KWQScrollBar.h"
 
@@ -520,7 +521,7 @@ public:
                              HitTestAction hitTestAction);
     void setInnerNode(NodeInfo& info);
 
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
     
     virtual void dirtyLinesFromChangedChild(RenderObject* child, bool adding = true);
     
index 9520cc2837fcf79d22e963bd1e1c05226ff2a4c2..c7c7723f1a3ccedb01c3bffa011e3ac80fba6ccd 100644 (file)
@@ -135,14 +135,11 @@ unsigned long RenderReplaced::caretMaxRenderedOffset() const
     return 1; 
 }
 
-Position RenderReplaced::positionForCoordinates(int _x, int _y, EAffinity *affinity)
+VisiblePosition RenderReplaced::positionForCoordinates(int _x, int _y)
 {
-    if (affinity)
-        *affinity = UPSTREAM;
-
     InlineBox *box = inlineBoxWrapper();
     if (!box)
-        return Position(element(), 0);
+        return VisiblePosition(element(), 0, DOWNSTREAM);
 
     RootInlineBox *root = box->root();
 
@@ -153,21 +150,19 @@ Position RenderReplaced::positionForCoordinates(int _x, int _y, EAffinity *affin
     int bottom = root->nextRootBox() ? absy + root->nextRootBox()->topOverflow() : absy + root->bottomOverflow();
 
     if (_y < top)
-        return Position(element(), caretMinOffset()); // coordinates are above
+        return VisiblePosition(element(), caretMinOffset(), DOWNSTREAM); // coordinates are above
     
     if (_y >= bottom)
-        return Position(element(), caretMaxOffset()); // coordinates are below
+        return VisiblePosition(element(), caretMaxOffset(), DOWNSTREAM); // coordinates are below
     
     if (element()) {
-        if (_x <= absx + xPos() + (width() / 2)) {
-            if (affinity)
-                *affinity = DOWNSTREAM;
-            return Position(element(), 0);
-        }
-        return Position(element(), 1);
+        if (_x <= absx + xPos() + (width() / 2))
+            return VisiblePosition(element(), 0, DOWNSTREAM);
+
+        return VisiblePosition(element(), 1, DOWNSTREAM);
     }
 
-    return RenderBox::positionForCoordinates(_x, _y, affinity);
+    return RenderBox::positionForCoordinates(_x, _y);
 }
 
 QRect RenderReplaced::selectionRect()
index 72e4dced03f09c142703d2fd4cd518e0dee988c5..23550a56eefde5528dcb0224aa333c9f81a00cd1 100644 (file)
@@ -57,7 +57,7 @@ public:
     virtual long caretMinOffset() const;
     virtual long caretMaxOffset() const;
     virtual unsigned long caretMaxRenderedOffset() const;
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
     
     virtual bool canBeSelectionLeaf() const { return true; }
     virtual SelectionState selectionState() const { return m_selectionState; }
index fa34d5608247e7bfd43442470accfa49bda27a67..bce052a0ee4ac0ce024317a3e0ceb39a447918c9 100644 (file)
@@ -902,16 +902,10 @@ InlineTextBox* RenderText::findNextInlineTextBox(int offset, int &pos) const
     return s;
 }
 
-Position RenderText::positionForCoordinates(int _x, int _y, EAffinity *affinity)
+VisiblePosition RenderText::positionForCoordinates(int _x, int _y)
 {
-    EAffinity a;
-    if (!affinity)
-        affinity = &a;
-    
-    if (!firstTextBox() || stringLength() == 0) {
-        *affinity = DOWNSTREAM;
-        return Position(element(), 0);
-    }
+    if (!firstTextBox() || stringLength() == 0)
+        return VisiblePosition(element(), 0, DOWNSTREAM);
 
     int absx, absy;
     containingBlock()->absolutePosition(absx, absy);
@@ -919,15 +913,13 @@ Position RenderText::positionForCoordinates(int _x, int _y, EAffinity *affinity)
     if (firstTextBox() && _y < absy + firstTextBox()->root()->bottomOverflow() && _x < absx + firstTextBox()->m_x) {
         // at the y coordinate of the first line or above
         // and the x coordinate is to the left than the first text box left edge
-        *affinity = DOWNSTREAM;
-        return Position(element(), firstTextBox()->m_start);
+        return VisiblePosition(element(), firstTextBox()->m_start, DOWNSTREAM);
     }
 
     if (lastTextBox() && _y >= absy + lastTextBox()->root()->topOverflow() && _x >= absx + lastTextBox()->m_x + lastTextBox()->m_width) {
         // at the y coordinate of the last line or below
         // and the x coordinate is to the right than the last text box right edge
-        *affinity = DOWNSTREAM;
-        return Position(element(), lastTextBox()->m_start + lastTextBox()->m_len);
+        return VisiblePosition(element(), lastTextBox()->m_start + lastTextBox()->m_len, DOWNSTREAM);
     }
 
     for (InlineTextBox *box = firstTextBox(); box; box = box->nextTextBox()) {
@@ -936,27 +928,22 @@ Position RenderText::positionForCoordinates(int _x, int _y, EAffinity *affinity)
                 // and the x coordinate is to the left of the right edge of this box
                 // check to see if position goes in this box
                 int offset = box->offsetForPosition(_x - absx);
-                if (offset != -1) {
-                    *affinity = DOWNSTREAM;
-                    return Position(element(), offset + box->m_start);
-                }
+                if (offset != -1)
+                    return VisiblePosition(element(), offset + box->m_start, DOWNSTREAM);
             }
             else if (!box->prevOnLine() && _x < absx + box->m_x) {
                 // box is first on line
                 // and the x coordinate is to the left of the first text box left edge
-                *affinity = DOWNSTREAM;
-                return Position(element(), box->m_start);
+                return VisiblePosition(element(), box->m_start, DOWNSTREAM);
             }
             else if (!box->nextOnLine() && _x >= absx + box->m_x + box->m_width)
                 // box is last on line
                 // and the x coordinate is to the right of the last text box right edge
-                *affinity = UPSTREAM;
-                return Position(element(), box->m_start + box->m_len);
+                return VisiblePosition(element(), box->m_start + box->m_len, UPSTREAM);
         }
     }
     
-    *affinity = DOWNSTREAM;
-    return Position(element(), 0);
+    return VisiblePosition(element(), 0, DOWNSTREAM);
 }
 
 static RenderObject *firstRendererOnNextLine(InlineBox *box)
index d9c4190964953bacf9ebbb588f7845dac4fedba2..2e833615d8cbeb5fdc93412cb3e301c835496013 100644 (file)
@@ -182,7 +182,7 @@ public:
 
     virtual void absoluteRects(QValueList<QRect>& rects, int _tx, int _ty);
 
-    virtual DOM::Position positionForCoordinates(int x, int y, EAffinity * = 0);
+    virtual VisiblePosition positionForCoordinates(int x, int y);
 
     unsigned int length() const { return str->l; }
     QChar *text() const { return str->s; }
index 92c66f8474c0361101710454583ff81f911fde37..4495c00ea546e64dcf5c65eea94a5a7a884ee066 100644 (file)
@@ -182,7 +182,7 @@ long Position::renderedOffset() const
     return result;
 }
 
-Position Position::previousCharacterPosition() const
+Position Position::previousCharacterPosition(EAffinity affinity) const
 {
     if (isNull())
         return Position();
@@ -190,7 +190,7 @@ Position Position::previousCharacterPosition() const
     NodeImpl *fromRootEditableElement = node()->rootEditableElement();
     PositionIterator it(*this);
 
-    bool atStartOfLine = isFirstVisiblePositionOnLine(VisiblePosition(*this, khtml::DOWNSTREAM));
+    bool atStartOfLine = isFirstVisiblePositionOnLine(VisiblePosition(*this, affinity));
     bool rendered = inRenderedContent();
     
     while (!it.atStart()) {
@@ -210,7 +210,7 @@ Position Position::previousCharacterPosition() const
     return *this;
 }
 
-Position Position::nextCharacterPosition() const
+Position Position::nextCharacterPosition(EAffinity affinity) const
 {
     if (isNull())
         return Position();
@@ -218,7 +218,7 @@ Position Position::nextCharacterPosition() const
     NodeImpl *fromRootEditableElement = node()->rootEditableElement();
     PositionIterator it(*this);
 
-    bool atEndOfLine = isLastVisiblePositionOnLine(VisiblePosition(*this, khtml::UPSTREAM));
+    bool atEndOfLine = isLastVisiblePositionOnLine(VisiblePosition(*this, affinity));
     bool rendered = inRenderedContent();
     
     while (!it.atEnd()) {
@@ -615,7 +615,7 @@ static inline bool isWS(const QChar &c)
     return c.isSpace() && c != nonBreakingSpace;
 }
 
-Position Position::leadingWhitespacePosition() const
+Position Position::leadingWhitespacePosition(EAffinity affinity) const
 {
     if (isNull())
         return Position();
@@ -623,7 +623,7 @@ Position Position::leadingWhitespacePosition() const
     if (upstream(StayInBlock).node()->id() == ID_BR)
         return Position();
     
-    Position prev = previousCharacterPosition();
+    Position prev = previousCharacterPosition(affinity);
     if (prev != *this && prev.node()->inSameContainingBlockFlowElement(node()) && prev.node()->isTextNode()) {
         DOMString string = static_cast<TextImpl *>(prev.node())->data();
         if (isWS(string[prev.offset()]))
@@ -633,7 +633,7 @@ Position Position::leadingWhitespacePosition() const
     return Position();
 }
 
-Position Position::trailingWhitespacePosition() const
+Position Position::trailingWhitespacePosition(EAffinity affinity) const
 {
     if (isNull())
         return Position();
@@ -651,7 +651,7 @@ Position Position::trailingWhitespacePosition() const
     if (downstream(StayInBlock).node()->id() == ID_BR)
         return Position();
 
-    Position next = nextCharacterPosition();
+    Position next = nextCharacterPosition(affinity);
     if (next != *this && next.node()->inSameContainingBlockFlowElement(node()) && next.node()->isTextNode()) {
         DOMString string = static_cast<TextImpl *>(next.node())->data();
         if (isWS(string[0]))
index 6a53f7870d68ab74605732268eea0039c707299b..a46fefcb02417084199e926dd1530e05e0760baf 100644 (file)
@@ -59,8 +59,8 @@ public:
     ElementImpl *element() const;
     CSSComputedStyleDeclarationImpl *computedStyle() const;
 
-    Position leadingWhitespacePosition() const;
-    Position trailingWhitespacePosition() const;
+    Position leadingWhitespacePosition(khtml::EAffinity affinity) const;
+    Position trailingWhitespacePosition(khtml::EAffinity affinity) const;
 
     // These functions only consider leaf nodes, and if stayInBlock is true, blocks.
     // Hence, the results from these functions are idiosyncratic, and until you
@@ -92,8 +92,8 @@ private:
 
     bool inRenderedText() const;
 
-    Position previousCharacterPosition() const;
-    Position nextCharacterPosition() const;
+    Position previousCharacterPosition(khtml::EAffinity affinity) const;
+    Position nextCharacterPosition(khtml::EAffinity affinity) const;
     
     NodeImpl *m_node;
     long m_offset;
index 951cb0123d732986bfc9bf5bacf4c84f110bfdda..b2b50c4f6874f11d3b7c1708e9e747c0fa845d1d 100644 (file)
@@ -500,14 +500,9 @@ extern "C" void NSAccessibilityUnregisterUniqueIdForUIElement(id element);
         if (!docPart)
             return nil;
         
-        // FIXME: should use startOfDocument and endOfDocument here
-        EAffinity startAffinity;
-        Position startPos = m_renderer->positionForCoordinates (0, 0, &startAffinity);
-        EAffinity endAffinity;
-        Position endPos = m_renderer->positionForCoordinates (LONG_MAX, LONG_MAX, &endAffinity);
-
-        VisiblePosition startVisiblePosition = VisiblePosition(startPos, startAffinity);
-        VisiblePosition endVisiblePosition   = VisiblePosition(endPos, endAffinity);
+        // FIXME: should use startOfDocument and endOfDocument (or rangeForDocument?) here
+        VisiblePosition startVisiblePosition = m_renderer->positionForCoordinates (0, 0);
+        VisiblePosition endVisiblePosition   = m_renderer->positionForCoordinates (LONG_MAX, LONG_MAX);
         QString qString   = plainText(makeRange(startVisiblePosition, endVisiblePosition));
         
         // transform it to a CFString and return that
@@ -975,16 +970,14 @@ static QRect boundingBoxRect(RenderObject* obj)
     
     if ([attributeName isEqualToString: (NSString *) kAXStartTextMarkerAttribute]) {
         // FIXME: should use startOfDocument here
-        EAffinity startAffinity;
-        Position startPos = [self topRenderer]->positionForCoordinates (0, 0, &startAffinity);
-        return (id) [self textMarkerForVisiblePosition: VisiblePosition(startPos, startAffinity)];
+        VisiblePosition startPos = [self topRenderer]->positionForCoordinates (0, 0);
+        return (id) [self textMarkerForVisiblePosition: startPos];
     }
 
     if ([attributeName isEqualToString: (NSString *) kAXEndTextMarkerAttribute]) {
         // FIXME: should use endOfDocument here
-        EAffinity endAffinity;
-        Position endPos = [self topRenderer]->positionForCoordinates (LONG_MAX, LONG_MAX, &endAffinity);
-        return (id) [self textMarkerForVisiblePosition: VisiblePosition(endPos, endAffinity)];
+        VisiblePosition endPos = [self topRenderer]->positionForCoordinates (LONG_MAX, LONG_MAX);
+        return (id) [self textMarkerForVisiblePosition: endPos];
     }
 #endif
 
@@ -1062,7 +1055,7 @@ static QRect boundingBoxRect(RenderObject* obj)
     while (visiblePos.isNotNull() && visiblePos != savedVisiblePos) {
         lineCount += 1;
         savedVisiblePos = visiblePos;
-        visiblePos = previousLinePosition(visiblePos, khtml::DOWNSTREAM, 0);
+        visiblePos = previousLinePosition(visiblePos, 0);
     }
     
     return [NSNumber numberWithUnsignedInt:lineCount];
@@ -1076,13 +1069,11 @@ static QRect boundingBoxRect(RenderObject* obj)
     // iterate over the lines
     // NOTE: BUG this is wrong when lineNumber is lineCount+1,  because nextLinePosition takes you to the
     // last offset of the last line
-    EAffinity affinity;
-    Position pos = [self topRenderer]->positionForCoordinates (0, 0, &affinity);
-    VisiblePosition visiblePos = VisiblePosition(pos, affinity);
+    VisiblePosition visiblePos = [self topRenderer]->positionForCoordinates (0, 0);
     VisiblePosition savedVisiblePos;
     while (--lineCount != 0) {
         savedVisiblePos = visiblePos;
-        visiblePos = nextLinePosition(visiblePos, visiblePos.affinity(), 0);
+        visiblePos = nextLinePosition(visiblePos, 0);
         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
             return nil;
     }
@@ -1125,9 +1116,8 @@ static QRect boundingBoxRect(RenderObject* obj)
     NSPoint windowpoint = [[view window] convertScreenToBase: screenpoint];
     NSPoint ourpoint = [view convertPoint:windowpoint fromView:nil];
 
-    EAffinity affinity;
-    Position pos = [self topRenderer]->positionForCoordinates ((int)ourpoint.x, (int)ourpoint.y, &affinity);
-    return (id) [self textMarkerForVisiblePosition:VisiblePosition(pos, affinity)];
+    VisiblePosition pos = [self topRenderer]->positionForCoordinates ((int)ourpoint.x, (int)ourpoint.y);
+    return (id) [self textMarkerForVisiblePosition:pos];
 }
 
 - (id)doAXBoundsForTextMarkerRange: (AXTextMarkerRangeRef) textMarkerRange
@@ -1488,8 +1478,8 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
     if (prevVisiblePos.isNull())
         return nil;
     
-    VisiblePosition startPosition = startOfLine(prevVisiblePos, prevVisiblePos.affinity());
-    VisiblePosition endPosition = endOfLine(prevVisiblePos, prevVisiblePos.affinity());
+    VisiblePosition startPosition = startOfLine(prevVisiblePos);
+    VisiblePosition endPosition = endOfLine(prevVisiblePos);
     return (id) [self textMarkerRangeFromVisiblePositions:startPosition andEndPos:endPosition];
 }
 
@@ -1504,8 +1494,8 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
     if (nextVisiblePos.isNull())
         return nil;
         
-    VisiblePosition startPosition = startOfLine(nextVisiblePos, nextVisiblePos.affinity());
-    VisiblePosition endPosition = endOfLine(nextVisiblePos, nextVisiblePos.affinity());
+    VisiblePosition startPosition = startOfLine(nextVisiblePos);
+    VisiblePosition endPosition = endOfLine(nextVisiblePos);
     return (id) [self textMarkerRangeFromVisiblePositions:startPosition andEndPos:endPosition];
 }
 
@@ -1570,7 +1560,7 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
     if (nextVisiblePos.isNull())
         return nil;
         
-    VisiblePosition endPosition = endOfLine(nextVisiblePos, nextVisiblePos.affinity());
+    VisiblePosition endPosition = endOfLine(nextVisiblePos);
     return (id) [self textMarkerForVisiblePosition: endPosition];
 }
 
@@ -1585,7 +1575,7 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
     if (prevVisiblePos.isNull())
         return nil;
         
-    VisiblePosition startPosition = startOfLine(prevVisiblePos, prevVisiblePos.affinity());
+    VisiblePosition startPosition = startOfLine(prevVisiblePos);
     return (id) [self textMarkerForVisiblePosition: startPosition];
 }
 
index a7253b709c307359a79ac2639ebaedd15366b146..ea287f84c67e8ec3ced832bc648145fe2e674201 100644 (file)
@@ -145,7 +145,6 @@ using khtml::startVisiblePosition;
 using khtml::StyleDashboardRegion;
 using khtml::TextIterator;
 using khtml::DOWNSTREAM;
-using khtml::UPSTREAM;
 using khtml::VISIBLE;
 using khtml::VisiblePosition;
 using khtml::WordAwareIterator;
index 79f73f330cb7c8548928fcf65af1e069ae21a4ec..73dc598984fc7c448eac5eff5f1dcba17964005b 100644 (file)
@@ -1695,9 +1695,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     if (!node->renderer())
         return VisiblePosition();
     
-    EAffinity affinity;
-    Position pos = node->renderer()->positionForCoordinates((int)point.x, (int)point.y, &affinity);
-    return VisiblePosition(pos, affinity);
+    return node->renderer()->positionForCoordinates((int)point.x, (int)point.y);
 }
 
 - (void)moveDragCaretToPoint:(NSPoint)point