Reviewed by Kevin.
authormjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 9 May 2005 21:03:25 +0000 (21:03 +0000)
committermjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 9 May 2005 21:03:25 +0000 (21:03 +0000)
- remove code for DoNotStayInBlock variant of upstream/downstream and make
the methods take no parameters

        * khtml/editing/htmlediting.cpp:
        (khtml::CompositeEditCommand::deleteInsignificantTextDownstream):
        (khtml::CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary):
        (khtml::ApplyStyleCommand::applyRelativeFontStyleChange):
        (khtml::ApplyStyleCommand::applyInlineStyle):
        (khtml::ApplyStyleCommand::removeInlineStyle):
        (khtml::ApplyStyleCommand::nodeFullySelected):
        (khtml::ApplyStyleCommand::nodeFullyUnselected):
        (khtml::DeleteSelectionCommand::initializePositionData):
        (khtml::DeleteSelectionCommand::fixupWhitespace):
        (khtml::InsertLineBreakCommand::insertNodeAfterPosition):
        (khtml::InsertLineBreakCommand::insertNodeBeforePosition):
        (khtml::InsertLineBreakCommand::doApply):
        (khtml::InsertParagraphSeparatorCommand::doApply):
        (khtml::InsertParagraphSeparatorInQuotedContentCommand::doApply):
        (khtml::InsertTextCommand::prepareForTextInsertion):
        (khtml::InsertTextCommand::input):
        (khtml::InsertTextCommand::insertSpace):
        (khtml::ReplaceSelectionCommand::doApply):
        * khtml/editing/selection.cpp:
        (khtml::Selection::toRange):
        (khtml::Selection::validate):
        * khtml/editing/visible_position.cpp:
        (khtml::VisiblePosition::previousVisiblePosition):
        (khtml::VisiblePosition::nextVisiblePosition):
        (khtml::VisiblePosition::downstreamDeepEquivalent):
        (khtml::isFirstVisiblePositionInParagraph):
        (khtml::isFirstVisiblePositionInBlock):
        (khtml::isLastVisiblePositionInParagraph):
        * khtml/xml/dom2_rangeimpl.cpp:
        (DOM::RangeImpl::editingStartPosition):
        * khtml/xml/dom_position.cpp:
        (DOM::isStreamer):
        (DOM::Position::upstream):
        (DOM::Position::downstream):
        (DOM::Position::leadingWhitespacePosition):
        (DOM::Position::trailingWhitespacePosition):
        * khtml/xml/dom_position.h:
        * kwq/WebCoreBridge.mm:
        (-[WebCoreBridge smartDeleteRangeForProposedRange:]):

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

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/xml/dom2_rangeimpl.cpp
WebCore/khtml/xml/dom_position.cpp
WebCore/khtml/xml/dom_position.h
WebCore/kwq/WebCoreBridge.mm

index 4cdbeb8e3712f1ef7a3cb18aded2e390dfa232c9..0d082f64cb6968c6feed834cccaf821b7a4b4a94 100644 (file)
@@ -1,3 +1,51 @@
+2005-05-09  Maciej Stachowiak  <mjs@apple.com>
+
+        Reviewed by Kevin.
+
+       - remove code for DoNotStayInBlock variant of upstream/downstream and make
+       the methods take no parameters
+
+        * khtml/editing/htmlediting.cpp:
+        (khtml::CompositeEditCommand::deleteInsignificantTextDownstream):
+        (khtml::CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary):
+        (khtml::ApplyStyleCommand::applyRelativeFontStyleChange):
+        (khtml::ApplyStyleCommand::applyInlineStyle):
+        (khtml::ApplyStyleCommand::removeInlineStyle):
+        (khtml::ApplyStyleCommand::nodeFullySelected):
+        (khtml::ApplyStyleCommand::nodeFullyUnselected):
+        (khtml::DeleteSelectionCommand::initializePositionData):
+        (khtml::DeleteSelectionCommand::fixupWhitespace):
+        (khtml::InsertLineBreakCommand::insertNodeAfterPosition):
+        (khtml::InsertLineBreakCommand::insertNodeBeforePosition):
+        (khtml::InsertLineBreakCommand::doApply):
+        (khtml::InsertParagraphSeparatorCommand::doApply):
+        (khtml::InsertParagraphSeparatorInQuotedContentCommand::doApply):
+        (khtml::InsertTextCommand::prepareForTextInsertion):
+        (khtml::InsertTextCommand::input):
+        (khtml::InsertTextCommand::insertSpace):
+        (khtml::ReplaceSelectionCommand::doApply):
+        * khtml/editing/selection.cpp:
+        (khtml::Selection::toRange):
+        (khtml::Selection::validate):
+        * khtml/editing/visible_position.cpp:
+        (khtml::VisiblePosition::previousVisiblePosition):
+        (khtml::VisiblePosition::nextVisiblePosition):
+        (khtml::VisiblePosition::downstreamDeepEquivalent):
+        (khtml::isFirstVisiblePositionInParagraph):
+        (khtml::isFirstVisiblePositionInBlock):
+        (khtml::isLastVisiblePositionInParagraph):
+        * khtml/xml/dom2_rangeimpl.cpp:
+        (DOM::RangeImpl::editingStartPosition):
+        * khtml/xml/dom_position.cpp:
+        (DOM::isStreamer):
+        (DOM::Position::upstream):
+        (DOM::Position::downstream):
+        (DOM::Position::leadingWhitespacePosition):
+        (DOM::Position::trailingWhitespacePosition):
+        * khtml/xml/dom_position.h:
+        * kwq/WebCoreBridge.mm:
+        (-[WebCoreBridge smartDeleteRangeForProposedRange:]):
+
 2005-05-08  Maciej Stachowiak  <mjs@apple.com>
 
         Reviewed by Dave Harrison.
index 2446ffe94a8f1a22b3621c16178a1619f9163342..ba1b9491b514a75f50734988108167a0d101918c 100644 (file)
@@ -60,7 +60,6 @@ using DOM::NodeImpl;
 using DOM::Position;
 using DOM::Range;
 using DOM::RangeImpl;
-using DOM::StayInBlock;
 
 namespace khtml {
 
@@ -623,7 +622,7 @@ Range Selection::toRange() const
         // If the selection is a caret, move the range start upstream. This helps us match
         // the conventions of text editors tested, which make style determinations based
         // on the character before the caret, if any. 
-        s = m_start.upstream(StayInBlock).equivalentRangeCompliantPosition();
+        s = m_start.upstream().equivalentRangeCompliantPosition();
         e = s;
     }
     else {
@@ -639,8 +638,8 @@ Range Selection::toRange() const
         //                       ^ selected
         //
         ASSERT(isRange());
-        s = m_start.downstream(StayInBlock);
-        e = m_end.upstream(StayInBlock);
+        s = m_start.downstream();
+        e = m_end.upstream();
         if (RangeImpl::compareBoundaryPoints(s.node(), s.offset(), e.node(), e.offset()) > 0) {
             // Make sure the start is before the end.
             // The end can wind up before the start if collapsed whitespace is the only thing selected.
@@ -918,7 +917,7 @@ void Selection::validate(ETextGranularity granularity)
         ASSERT(m_end.isNull());
         m_state = NONE;
     }
-    else if (m_start == m_end || m_start.upstream(StayInBlock) == m_end.upstream(StayInBlock)) {
+    else if (m_start == m_end || m_start.upstream() == m_end.upstream()) {
         m_state = CARET;
     }
     else {
@@ -929,8 +928,8 @@ void Selection::validate(ETextGranularity granularity)
         // purposes of comparing selections). This is an ideal point of the code
         // to do this operation, since all selection changes that result in a RANGE 
         // come through here before anyone uses it.
-        m_start = m_start.downstream(StayInBlock);
-        m_end = m_end.upstream(StayInBlock);
+        m_start = m_start.downstream();
+        m_end = m_end.upstream();
     }
 
     m_needsLayout = true;
index d14410cfac118a0b8b12e1a6fd41ccc3134b15e7..41845be21ac5c7d1e22e598082325e6f6ada08c8 100644 (file)
@@ -73,7 +73,6 @@ using DOM::DOMStringImpl;
 using DOM::DoNotUpdateLayout;
 using DOM::EditingTextImpl;
 using DOM::ElementImpl;
-using DOM::EStayInBlock;
 using DOM::HTMLElementImpl;
 using DOM::HTMLImageElementImpl;
 using DOM::NamedAttrMapImpl;
@@ -83,7 +82,6 @@ using DOM::NodeListImpl;
 using DOM::Position;
 using DOM::Range;
 using DOM::RangeImpl;
-using DOM::StayInBlock;
 using DOM::TextImpl;
 using DOM::TreeWalkerImpl;
 
@@ -1093,7 +1091,7 @@ void CompositeEditCommand::deleteInsignificantText(const Position &start, const
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(const DOM::Position &pos)
 {
-    Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream(StayInBlock);
+    Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
     deleteInsignificantText(pos, end);
 }
 
@@ -1185,8 +1183,8 @@ void CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Posi
     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
     VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
     VisiblePosition visibleParagraphEnd(endOfParagraph(visiblePos, IncludeLineBreak));
-    Position paragraphStart = visibleParagraphStart.deepEquivalent().upstream(StayInBlock);
-    Position paragraphEnd = visibleParagraphEnd.deepEquivalent().upstream(StayInBlock);
+    Position paragraphStart = visibleParagraphStart.deepEquivalent().upstream();
+    Position paragraphEnd = visibleParagraphEnd.deepEquivalent().upstream();
     
     // Perform some checks to see if we need to perform work in this function.
     if (paragraphStart.node()->isBlockFlow()) {
@@ -1234,7 +1232,7 @@ void CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Posi
         insertNodeAfter(newBlock, paragraphStart.node());
     }
     else {
-        insertNodeBefore(newBlock, paragraphStart.upstream(StayInBlock).node());
+        insertNodeBefore(newBlock, paragraphStart.upstream().node());
     }
 
     while (moveNode && !moveNode->isBlockFlow()) {
@@ -1590,8 +1588,8 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclarationI
     
     // Adjust to the positions we want to use for applying style.
     Selection selection = endingSelection();
-    Position start(selection.start().downstream(StayInBlock));
-    Position end(selection.end().upstream(StayInBlock));
+    Position start(selection.start().downstream());
+    Position end(selection.end().upstream());
     if (RangeImpl::compareBoundaryPoints(end, start) < 0) {
         Position swap = start;
         start = end;
@@ -1625,7 +1623,7 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclarationI
     }
 
     NodeImpl *beyondEnd = end.node()->traverseNextNode(); // Calculate loop end point.
-    start = start.upstream(StayInBlock); // Move upstream to ensure we do not add redundant spans.
+    start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
     NodeImpl *startNode = start.node();
     if (startNode->isTextNode() && start.offset() >= startNode->caretMaxOffset()) // Move out of text node if range does not include its characters.
         startNode = startNode->traverseNextNode();
@@ -1691,8 +1689,8 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclarationI
 void ApplyStyleCommand::applyInlineStyle(CSSMutableStyleDeclarationImpl *style)
 {
     // adjust to the positions we want to use for applying style
-    Position start(endingSelection().start().downstream(StayInBlock).equivalentRangeCompliantPosition());
-    Position end(endingSelection().end().upstream(StayInBlock));
+    Position start(endingSelection().start().downstream().equivalentRangeCompliantPosition());
+    Position end(endingSelection().end().upstream());
 
     if (RangeImpl::compareBoundaryPoints(end, start) < 0) {
         Position swap = start;
@@ -1722,7 +1720,7 @@ void ApplyStyleCommand::applyInlineStyle(CSSMutableStyleDeclarationImpl *style)
     // This will ensure we remove all traces of the relevant styles from the selection
     // and prevent us from adding redundant ones, as described in:
     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
-    removeInlineStyle(style, start.upstream(StayInBlock), end);
+    removeInlineStyle(style, start.upstream(), end);
     start = endingSelection().start();
     end = endingSelection().end();
 
@@ -2066,7 +2064,7 @@ void ApplyStyleCommand::removeInlineStyle(CSSMutableStyleDeclarationImpl *style,
     CSSValueImpl *textDecorationSpecialProperty = style->getPropertyCSSValue(CSS_PROP__KHTML_TEXT_DECORATIONS_IN_EFFECT);
 
     if (textDecorationSpecialProperty) {
-        pushDownTextDecorationStyleAtBoundaries(start.downstream(StayInBlock), end.upstream(StayInBlock));
+        pushDownTextDecorationStyleAtBoundaries(start.downstream(), end.upstream());
         style = style->copy();
         style->setProperty(CSS_PROP_TEXT_DECORATION, textDecorationSpecialProperty->cssText(), style->getPropertyPriority(CSS_PROP__KHTML_TEXT_DECORATIONS_IN_EFFECT));
     }
@@ -2127,7 +2125,7 @@ bool ApplyStyleCommand::nodeFullySelected(NodeImpl *node, const Position &start,
     ASSERT(node);
     ASSERT(node->isElementNode());
 
-    Position pos = Position(node, node->childNodeCount()).upstream(StayInBlock);
+    Position pos = Position(node, node->childNodeCount()).upstream();
     return RangeImpl::compareBoundaryPoints(node, 0, start.node(), start.offset()) >= 0 &&
         RangeImpl::compareBoundaryPoints(pos, end) <= 0;
 }
@@ -2137,7 +2135,7 @@ bool ApplyStyleCommand::nodeFullyUnselected(NodeImpl *node, const Position &star
     ASSERT(node);
     ASSERT(node->isElementNode());
 
-    Position pos = Position(node, node->childNodeCount()).upstream(StayInBlock);
+    Position pos = Position(node, node->childNodeCount()).upstream();
     bool isFullyBeforeStart = RangeImpl::compareBoundaryPoints(pos, start) < 0;
     bool isFullyAfterEnd = RangeImpl::compareBoundaryPoints(node, 0, end.node(), end.offset()) > 0;
 
@@ -2594,10 +2592,10 @@ void DeleteSelectionCommand::initializePositionData()
     Position end = m_selectionToDelete.end();
     end = positionOutsideContainingSpecialElement(end);
 
-    m_upstreamStart = positionBeforePossibleContainingSpecialElement(start.upstream(StayInBlock));
-    m_downstreamStart = positionBeforePossibleContainingSpecialElement(start.downstream(StayInBlock));
-    m_upstreamEnd = positionAfterPossibleContainingSpecialElement(end.upstream(StayInBlock));
-    m_downstreamEnd = positionAfterPossibleContainingSpecialElement(end.downstream(StayInBlock));
+    m_upstreamStart = positionBeforePossibleContainingSpecialElement(start.upstream());
+    m_downstreamStart = positionBeforePossibleContainingSpecialElement(start.downstream());
+    m_upstreamEnd = positionAfterPossibleContainingSpecialElement(end.upstream());
+    m_downstreamEnd = positionAfterPossibleContainingSpecialElement(end.downstream());
 
     //
     // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection
@@ -2620,8 +2618,8 @@ void DeleteSelectionCommand::initializePositionData()
             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_upstreamStart = pos.upstream();
+            m_downstreamStart = pos.downstream();
             m_leadingWhitespace = m_upstreamStart.leadingWhitespacePosition(visiblePos.affinity());
         }
         
@@ -2631,8 +2629,8 @@ void DeleteSelectionCommand::initializePositionData()
             // Expand out one character downstream for smart delete and recalculate
             // positions based on this change.
             pos = VisiblePosition(end, m_selectionToDelete.endAffinity()).next().deepEquivalent();
-            m_upstreamEnd = pos.upstream(StayInBlock);
-            m_downstreamEnd = pos.downstream(StayInBlock);
+            m_upstreamEnd = pos.upstream();
+            m_downstreamEnd = pos.downstream();
             m_trailingWhitespace = m_downstreamEnd.trailingWhitespacePosition(VP_DEFAULT_AFFINITY);
         }
     }
@@ -2928,7 +2926,7 @@ void DeleteSelectionCommand::fixupWhitespace()
             }
         }
         else {
-            Position pos = m_endingPosition.downstream(StayInBlock);
+            Position pos = m_endingPosition.downstream();
             pos = Position(pos.node(), pos.offset() - 1);
             if (nextCharacterIsCollapsibleWhitespace(pos) && !pos.isRenderedCharacter()) {
                 LOG(Editing, "replace trailing [invalid]");
@@ -3253,7 +3251,7 @@ void InsertLineBreakCommand::insertNodeAfterPosition(NodeImpl *node, const Posit
     // Insert the BR after the caret position. In the case the
     // position is a block, do an append. We don't want to insert
     // the BR *after* the block.
-    Position upstream(pos.upstream(StayInBlock));
+    Position upstream(pos.upstream());
     NodeImpl *cb = pos.node()->enclosingBlockFlowElement();
     if (cb == pos.node())
         appendNode(node, cb);
@@ -3266,7 +3264,7 @@ void InsertLineBreakCommand::insertNodeBeforePosition(NodeImpl *node, const Posi
     // Insert the BR after the caret position. In the case the
     // position is a block, do an append. We don't want to insert
     // the BR *before* the block.
-    Position upstream(pos.upstream(StayInBlock));
+    Position upstream(pos.upstream());
     NodeImpl *cb = pos.node()->enclosingBlockFlowElement();
     if (cb == pos.node())
         appendNode(node, cb);
@@ -3282,7 +3280,7 @@ void InsertLineBreakCommand::doApply()
     ElementImpl *breakNode = createBreakElement(document());
     NodeImpl *nodeToInsert = breakNode;
     
-    Position pos(selection.start().upstream(StayInBlock));
+    Position pos(selection.start().upstream());
 
     pos = positionOutsideContainingSpecialElement(pos);
 
@@ -3318,7 +3316,7 @@ void InsertLineBreakCommand::doApply()
     else if (atStart) {
         LOG(Editing, "input newline case 2");
         // Insert node before downstream position, and place caret there as well. 
-        Position endingPosition = pos.downstream(StayInBlock);
+        Position endingPosition = pos.downstream();
         insertNodeBeforePosition(nodeToInsert, endingPosition);
         setEndingSelection(endingPosition, DOWNSTREAM);
     }
@@ -3326,7 +3324,7 @@ void InsertLineBreakCommand::doApply()
         LOG(Editing, "input newline case 3");
         // Insert BR after this node. Place caret in the position that is downstream
         // of the current position, reckoned before inserting the BR in between.
-        Position endingPosition = pos.downstream(StayInBlock);
+        Position endingPosition = pos.downstream();
         insertNodeAfterPosition(nodeToInsert, pos);
         setEndingSelection(endingPosition, DOWNSTREAM);
     }
@@ -3556,7 +3554,7 @@ void InsertParagraphSeparatorCommand::doApply()
 
     if (prevInDifferentBlock || isFirstInBlock) {
         LOG(Editing, "insert paragraph separator: first in block case");
-        pos = pos.downstream(StayInBlock);
+        pos = pos.downstream();
         pos = positionOutsideContainingSpecialElement(pos);
         Position refPos;
         NodeImpl *refNode;
@@ -3585,14 +3583,14 @@ void InsertParagraphSeparatorCommand::doApply()
     // Check if pos.node() is a <br>. If it is, and the document is in quirks mode, 
     // then this <br> will collapse away when we add a block after it. Add an extra <br>.
     if (!document()->inStrictMode()) {
-        Position upstreamPos = pos.upstream(StayInBlock);
+        Position upstreamPos = pos.upstream();
         if (upstreamPos.node()->id() == ID_BR)
             insertNodeAfter(createBreakElement(document()), upstreamPos.node());
     }
     
     // Move downstream. Typing style code will take care of carrying along the 
     // style of the upstream position.
-    pos = pos.downstream(StayInBlock);
+    pos = pos.downstream();
     startNode = pos.node();
 
     // Build up list of ancestors in between the start node and the start block.
@@ -3602,7 +3600,7 @@ void InsertParagraphSeparatorCommand::doApply()
     }
 
     // Make sure we do not cause a rendered space to become unrendered.
-    // FIXME: We need the affinity for pos, but pos.downstream(StayInBlock) does not give it
+    // FIXME: We need the affinity for pos, but pos.downstream() does not give it
     Position leadingWhitespace = pos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
     if (leadingWhitespace.isNotNull()) {
         TextImpl *textNode = static_cast<TextImpl *>(leadingWhitespace.node());
@@ -3715,7 +3713,7 @@ void InsertParagraphSeparatorInQuotedContentCommand::doApply()
     EAffinity affinity = selection.startAffinity();
     if (selection.isRange()) {
         deleteSelection(false, false);
-        pos = endingSelection().start().upstream(StayInBlock);
+        pos = endingSelection().start().upstream();
         affinity = endingSelection().startAffinity();
     }
     
@@ -3859,9 +3857,9 @@ Position InsertTextCommand::prepareForTextInsertion(bool adjustDownstream)
     
     Position pos = selection.start();
     if (adjustDownstream)
-        pos = pos.downstream(StayInBlock);
+        pos = pos.downstream();
     else
-        pos = pos.upstream(StayInBlock);
+        pos = pos.upstream();
     
     Selection typingStyleRange;
 
@@ -3898,7 +3896,7 @@ void InsertTextCommand::input(const DOMString &text, bool selectInsertedText)
     assert(text.find('\n') == -1);
 
     Selection selection = endingSelection();
-    bool adjustDownstream = isFirstVisiblePositionOnLine(VisiblePosition(selection.start().downstream(StayInBlock), DOWNSTREAM));
+    bool adjustDownstream = isFirstVisiblePositionOnLine(VisiblePosition(selection.start().downstream(), DOWNSTREAM));
 
     // Delete the current selection, or collapse whitespace, as needed
     if (selection.isRange())
@@ -3996,7 +3994,7 @@ void InsertTextCommand::insertSpace(TextImpl *textNode, unsigned long offset)
         // By checking the character at the downstream position, we can
         // check if there is a rendered WS at the caret
         Position pos(textNode, offset);
-        Position downstream = pos.downstream(StayInBlock);
+        Position downstream = pos.downstream();
         if (downstream.offset() < (long)text.length() && isCollapsibleWhitespace(text[downstream.offset()]))
             count--; // leave this WS in
         if (count > 0)
@@ -4822,7 +4820,7 @@ void ReplaceSelectionCommand::doApply()
     // decide whether to later append nodes to the end
     NodeImpl *beyondEndNode = 0;
     if (!isEndOfParagraph(visibleEnd) && !m_fragment.hasInterchangeNewlineAtEnd()) {
-        Position beyondEndPos = selection.end().downstream(StayInBlock);
+        Position beyondEndPos = selection.end().downstream();
         if (!isFirstVisiblePositionInSpecialElement(beyondEndPos))
             beyondEndNode = beyondEndPos.node();
     }
@@ -4893,7 +4891,7 @@ void ReplaceSelectionCommand::doApply()
     NodeImpl *block = startPos.node()->enclosingBlockFlowElement();
     NodeImpl *linePlaceholder = findBlockPlaceholder(block);
     if (!linePlaceholder) {
-        Position downstream = startPos.downstream(StayInBlock);
+        Position downstream = startPos.downstream();
         downstream = positionOutsideContainingSpecialElement(downstream);
         if (downstream.node()->id() == ID_BR && downstream.offset() == 0 && 
             m_fragment.hasInterchangeNewlineAtEnd() &&
@@ -4969,7 +4967,7 @@ void ReplaceSelectionCommand::doApply()
         else if (!insertionBlockIsRoot && isProbablyBlock(refNode) && isLastVisiblePositionInBlock(visiblePos)) {
             insertNodeAfterAndUpdateNodesInserted(refNode, insertionBlock);
         } else if (mergeStart && !isProbablyBlock(refNode)) {
-            Position pos = visiblePos.next().deepEquivalent().downstream(StayInBlock);
+            Position pos = visiblePos.next().deepEquivalent().downstream();
             insertNodeAtAndUpdateNodesInserted(refNode, pos.node(), pos.offset());
         } else {
             insertNodeAtAndUpdateNodesInserted(refNode, insertionPos.node(), insertionPos.offset());
@@ -5026,7 +5024,7 @@ void ReplaceSelectionCommand::doApply()
         removeLinePlaceholderIfNeeded(linePlaceholder);
 
         if (!m_lastNodeInserted) {
-            lastPositionToSelect = endingSelection().end().downstream(StayInBlock);
+            lastPositionToSelect = endingSelection().end().downstream();
         }
         else {
             bool insertParagraph = false;
@@ -5046,12 +5044,12 @@ void ReplaceSelectionCommand::doApply()
                 VisiblePosition next = pos.next();
 
                 // Select up to the paragraph separator that was added.
-                lastPositionToSelect = next.deepEquivalent().downstream(StayInBlock);
+                lastPositionToSelect = next.deepEquivalent().downstream();
                 updateNodesInserted(lastPositionToSelect.node());
             } else {
                 // Select up to the preexising paragraph separator.
                 VisiblePosition next = pos.next();
-                lastPositionToSelect = next.deepEquivalent().downstream(StayInBlock);
+                lastPositionToSelect = next.deepEquivalent().downstream();
             }
         }
     } 
index 2446ffe94a8f1a22b3621c16178a1619f9163342..ba1b9491b514a75f50734988108167a0d101918c 100644 (file)
@@ -60,7 +60,6 @@ using DOM::NodeImpl;
 using DOM::Position;
 using DOM::Range;
 using DOM::RangeImpl;
-using DOM::StayInBlock;
 
 namespace khtml {
 
@@ -623,7 +622,7 @@ Range Selection::toRange() const
         // If the selection is a caret, move the range start upstream. This helps us match
         // the conventions of text editors tested, which make style determinations based
         // on the character before the caret, if any. 
-        s = m_start.upstream(StayInBlock).equivalentRangeCompliantPosition();
+        s = m_start.upstream().equivalentRangeCompliantPosition();
         e = s;
     }
     else {
@@ -639,8 +638,8 @@ Range Selection::toRange() const
         //                       ^ selected
         //
         ASSERT(isRange());
-        s = m_start.downstream(StayInBlock);
-        e = m_end.upstream(StayInBlock);
+        s = m_start.downstream();
+        e = m_end.upstream();
         if (RangeImpl::compareBoundaryPoints(s.node(), s.offset(), e.node(), e.offset()) > 0) {
             // Make sure the start is before the end.
             // The end can wind up before the start if collapsed whitespace is the only thing selected.
@@ -918,7 +917,7 @@ void Selection::validate(ETextGranularity granularity)
         ASSERT(m_end.isNull());
         m_state = NONE;
     }
-    else if (m_start == m_end || m_start.upstream(StayInBlock) == m_end.upstream(StayInBlock)) {
+    else if (m_start == m_end || m_start.upstream() == m_end.upstream()) {
         m_state = CARET;
     }
     else {
@@ -929,8 +928,8 @@ void Selection::validate(ETextGranularity granularity)
         // purposes of comparing selections). This is an ideal point of the code
         // to do this operation, since all selection changes that result in a RANGE 
         // come through here before anyone uses it.
-        m_start = m_start.downstream(StayInBlock);
-        m_end = m_end.upstream(StayInBlock);
+        m_start = m_start.downstream();
+        m_end = m_end.upstream();
     }
 
     m_needsLayout = true;
index 2ed433c16af6d412ee55753ce3bb1538accffaa4..2ab359164940bfb9e5ff4d2f612d3711d09b9845 100644 (file)
@@ -48,7 +48,6 @@ using DOM::UsingComposedCharacters;
 using DOM::Position;
 using DOM::Range;
 using DOM::RangeImpl;
-using DOM::StayInBlock;
 using DOM::TextImpl;
 
 namespace khtml {
@@ -189,13 +188,13 @@ Position VisiblePosition::previousVisiblePosition(const Position &pos)
         return Position();
 
     Position test = deepEquivalent(pos);
-    Position downstreamTest = test.downstream(StayInBlock);
+    Position downstreamTest = test.downstream();
     bool acceptAnyVisiblePosition = !isCandidate(test);
 
     Position current = test;
     while (!current.atStart()) {
         current = current.previous(UsingComposedCharacters);
-        if (isCandidate(current) && (acceptAnyVisiblePosition || (downstreamTest != current.downstream(StayInBlock)))) {
+        if (isCandidate(current) && (acceptAnyVisiblePosition || (downstreamTest != current.downstream()))) {
             return current;
         }
     }
@@ -212,10 +211,10 @@ Position VisiblePosition::nextVisiblePosition(const Position &pos)
     bool acceptAnyVisiblePosition = !isCandidate(test);
 
     Position current = test;
-    Position downstreamTest = test.downstream(StayInBlock);
+    Position downstreamTest = test.downstream();
     while (!current.atEnd()) {
         current = current.next(UsingComposedCharacters);
-        if (isCandidate(current) && (acceptAnyVisiblePosition || (downstreamTest != current.downstream(StayInBlock)))) {
+        if (isCandidate(current) && (acceptAnyVisiblePosition || (downstreamTest != current.downstream()))) {
             return current;
         }
     }
@@ -310,13 +309,13 @@ Position VisiblePosition::downstreamDeepEquivalent() const
     if (pos.isNull() || pos.atEnd())
         return pos;
 
-    Position downstreamTest = pos.downstream(StayInBlock);
+    Position downstreamTest = pos.downstream();
 
     Position current = pos;
     while (!current.atEnd()) {
         current = current.next(UsingComposedCharacters);
         if (isCandidate(current)) {
-            if (downstreamTest != current.downstream(StayInBlock))
+            if (downstreamTest != current.downstream())
                 break;
             pos = current;
         }
@@ -538,7 +537,7 @@ bool isFirstVisiblePositionInParagraph(const VisiblePosition &pos)
     if (pos.isNull())
         return false;
 
-    return pos.deepEquivalent().upstream(StayInBlock).node()->id() == ID_BR || isFirstVisiblePositionInBlock(pos);
+    return pos.deepEquivalent().upstream().node()->id() == ID_BR || isFirstVisiblePositionInBlock(pos);
 }
 
 bool isFirstVisiblePositionInBlock(const VisiblePosition &pos)
@@ -546,7 +545,7 @@ bool isFirstVisiblePositionInBlock(const VisiblePosition &pos)
     if (pos.isNull())
         return false;
 
-    Position upstream = pos.deepEquivalent().upstream(StayInBlock);
+    Position upstream = pos.deepEquivalent().upstream();
     return upstream.node()->isBlockFlow() && upstream.offset() == 0;
 }
 
@@ -573,7 +572,7 @@ bool isLastVisiblePositionInParagraph(const VisiblePosition &pos)
     if (pos.isNull())
         return false;
 
-    return pos.deepEquivalent().downstream(StayInBlock).node()->id() == ID_BR || isLastVisiblePositionInBlock(pos);
+    return pos.deepEquivalent().downstream().node()->id() == ID_BR || isLastVisiblePositionInBlock(pos);
 }
 
 bool isLastVisiblePositionInBlock(const VisiblePosition &pos)
index 8818aab0d5b218f99335f87b1e19d8414d2f98f2..053e3bdbde1327abbf37f595f00708d317fc09fa 100644 (file)
@@ -1321,11 +1321,11 @@ Position RangeImpl::editingStartPosition() const
 
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(pos))
-        return pos.next().position().downstream(StayInBlock);
+        return pos.next().position().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
-    return pos.position().downstream(StayInBlock);
+    return pos.position().downstream();
 }
 
 NodeImpl *RangeImpl::pastEndNode() const
index fcefa0ccab3490b951f2d33da38b7f80d11c7854..9883072dc9109a9fe580b509acc0ff088d0902aa 100644 (file)
@@ -317,7 +317,7 @@ Position Position::nextCharacterPosition(EAffinity affinity) const
 
 // upstream() and downstream() want to return positions that are either in a
 // text node or at just before a non-text node.  This method checks for that.
-static bool     isStreamer (Position pos)
+static bool isStreamer (Position pos)
 {
     NodeImpl *currentNode = pos.node();
     if (!currentNode)
@@ -334,14 +334,11 @@ static bool     isStreamer (Position pos)
 // for <rdar://problem/4103339>.  See also Ken's comments in the header.  Fundamentally, upstream()
 // scans backward in the DOM starting at "this" to return a visible DOM position that is either in
 // a text node, or just after a replaced or BR element (btw downstream() also considers empty blocks).
-// If "stayInBlock" is specified, the search stops when it would have entered into a part of the DOM
-// with a different enclosing block, including a nested one.  Otherwise, the search stops at the start
-// of the entire DOM tree.  If "stayInBlock" stops the search, this method returns the highest previous
-// position that is either in an atomic node (i.e. text) or is the end of a non-atomic node
-// (_regardless_ of visibility).  If the end-of-DOM stopped the search, this method returns the 
-// highest previous visible node that is either in an atomic node (i.e. text) or is the end of a
-// non-atomic node.
-Position Position::upstream(EStayInBlock stayInBlock) const
+// The search stops when it would have entered into a part of the DOM with a different enclosing 
+// block, including a nested one. Then this method returns the highest previous position that is
+// either in an atomic node (i.e. text) or is the end of a non-atomic node (_regardless_ of 
+// visibility).  
+Position Position::upstream() const
 {
     // start at equivalent deep position
     Position start = equivalentDeepPosition();
@@ -350,7 +347,7 @@ Position Position::upstream(EStayInBlock stayInBlock) const
         return Position();
     
     // iterate backward from there, looking for a qualified position
-    NodeImpl *block = stayInBlock ? startNode->enclosingBlockFlowOrTableElement() : 0;
+    NodeImpl *block = startNode->enclosingBlockFlowOrTableElement();
     Position lastVisible = *this;
     Position lastStreamer = *this;
     Position currentPos = start;
@@ -360,7 +357,7 @@ Position Position::upstream(EStayInBlock stayInBlock) const
 
         // limit traversal to block or table enclosing the original element
         // NOTE: This includes not going into nested blocks
-        if (stayInBlock && block != currentNode->enclosingBlockFlowOrTableElement())
+        if (block != currentNode->enclosingBlockFlowOrTableElement())
             return lastStreamer;
 
         // track last streamer position (regardless of visibility)
@@ -419,13 +416,11 @@ Position Position::upstream(EStayInBlock stayInBlock) const
 // for <rdar://problem/4103339>.  See also Ken's comments in the header.  Fundamentally, downstream()
 // scans forward in the DOM starting at "this" to return the first visible DOM position that is
 // either in a text node, or just before a replaced, BR element, or empty block flow element (i.e.
-// non-text nodes with no children).  If "stayInBlock" is specified, the search stops when it would
+// non-text nodes with no children).  The search stops when it would
 // have entered into a part of the DOM with a different enclosing block, including a nested one.
-// Otherwise, the search stops at the end of the entire DOM tree.  If "stayInBlock" stops the search,
-// this method returns the first previous position that is either in an atomic node (i.e. text) or is
-// at offset 0 (_regardless_ of visibility).  If the end-of-DOM stopped the search, this method returns
-// the first previous visible node that is either in an atomic node (i.e. text) or is at offset 0.
-Position Position::downstream(EStayInBlock stayInBlock) const
+// If the search stops, this method returns the first previous position that is either in an
+//  atomic node (i.e. text) or is at offset 0 (_regardless_ of visibility).
+Position Position::downstream() const
 {
     // start at equivalent deep position
     Position start = equivalentDeepPosition();
@@ -434,7 +429,7 @@ Position Position::downstream(EStayInBlock stayInBlock) const
         return Position();
 
     // iterate forward from there, looking for a qualified position
-    NodeImpl *block = stayInBlock ? startNode->enclosingBlockFlowOrTableElement() : 0;
+    NodeImpl *block = startNode->enclosingBlockFlowOrTableElement();
     Position lastVisible = *this;
     Position lastStreamer = *this;
     Position currentPos = start;
@@ -450,7 +445,7 @@ Position Position::downstream(EStayInBlock stayInBlock) const
         // limit traversal to block or table enclosing the original element
         // return the last streamer position regardless of visibility
         // NOTE: This includes not going into nested blocks
-        if (stayInBlock && block != currentNode->enclosingBlockFlowOrTableElement())
+        if (block != currentNode->enclosingBlockFlowOrTableElement())
             return lastStreamer;
         
         // track last streamer position (regardless of visibility)
@@ -768,7 +763,7 @@ Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNo
     if (isNull())
         return Position();
     
-    if (upstream(StayInBlock).node()->id() == ID_BR)
+    if (upstream().node()->id() == ID_BR)
         return Position();
 
     Position prev = previousCharacterPosition(affinity);
@@ -798,7 +793,7 @@ Position Position::trailingWhitespacePosition(EAffinity affinity, bool considerN
         }
     }
 
-    if (downstream(StayInBlock).node()->id() == ID_BR)
+    if (downstream().node()->id() == ID_BR)
         return Position();
 
     Position next = nextCharacterPosition(affinity);
index df802548a177474306075342fc2a54c7e3863128..8fc84f8bdbe4d9d59fa85b94e791fc4f404c787d 100644 (file)
@@ -36,7 +36,6 @@ class NodeImpl;
 class Range;
 class RangeImpl;
 
-enum EStayInBlock { DoNotStayInBlock = false, StayInBlock = true };
 enum EUsingComposedCharacters { NotUsingComposedCharacters = false, UsingComposedCharacters = true };
 
 class Position
@@ -71,7 +70,7 @@ public:
     Position leadingWhitespacePosition(khtml::EAffinity affinity, bool considerNonCollapsibleWhitespace = false) const;
     Position trailingWhitespacePosition(khtml::EAffinity affinity, bool considerNonCollapsibleWhitespace = false) const;
 
-    // These functions only consider leaf nodes, and if stayInBlock is true, blocks.
+    // These functions only consider leaf nodes and blocks.
     // Hence, the results from these functions are idiosyncratic, and until you
     // become familiar with the results, you may find using these functions confusing.
     // I have hopes to make the results of these functions less ambiguous in the near
@@ -81,8 +80,8 @@ public:
     // same position as the caller's position. The same goes for downstream position
     // except that it is the latest position for earliest position in the above 
     // description.
-    Position upstream(EStayInBlock stayInBlock) const;
-    Position downstream(EStayInBlock stayInBlock) const;
+    Position upstream() const;
+    Position downstream() const;
     
     Position equivalentRangeCompliantPosition() const;
     Position equivalentDeepPosition() const;
index 81757b7f2a2740f516b5dbc5a739b46e5c14cb0f..bb398fa2d629df71921fea50742aae93026135e0 100644 (file)
@@ -1759,10 +1759,10 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
 
     Position start(startContainer, [proposedRange startOffset]);
     Position end(endContainer, [proposedRange endOffset]);
-    Position newStart = start.upstream(DOM::StayInBlock).leadingWhitespacePosition(khtml::DOWNSTREAM, true);
+    Position newStart = start.upstream().leadingWhitespacePosition(khtml::DOWNSTREAM, true);
     if (newStart.isNull())
         newStart = start;
-    Position newEnd = end.downstream(DOM::StayInBlock).trailingWhitespacePosition(khtml::DOWNSTREAM, true);
+    Position newEnd = end.downstream().trailingWhitespacePosition(khtml::DOWNSTREAM, true);
     if (newEnd.isNull())
         newEnd = end;