2009-03-10 Xan Lopez <xlopez@igalia.com>
authorxan@webkit.org <xan@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2009 16:10:24 +0000 (16:10 +0000)
committerxan@webkit.org <xan@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2009 16:10:24 +0000 (16:10 +0000)
        Reviewed by Darin Adler.

        https://bugs.webkit.org/show_bug.cgi?id=24491
        Rename posOffset to m_offset, get rid of accessor

        As suggested in dom/Position.h, this patch gets rid of the
        'offset()' accessor and renames posOffset to m_offset. I've used
        m_offset instead of offset to follow the style guide lines, since
        Position is still a class and not a structure. If the long term
        plan is still to make it a structure it would be pretty easy to
        just s/m_offset/offset/ globally when that is achieved.

        * dom/Position.cpp:
        (WebCore::Position::previous):
        (WebCore::Position::next):
        (WebCore::Position::atStart):
        (WebCore::Position::atEnd):
        (WebCore::Position::renderedOffset):
        (WebCore::Position::isCandidate):
        (WebCore::Position::inRenderedText):
        (WebCore::Position::isRenderedCharacter):
        (WebCore::Position::rendersInDifferentPosition):
        (WebCore::Position::leadingWhitespacePosition):
        (WebCore::Position::debugPosition):
        (WebCore::Position::formatForDebugger):
        * dom/Position.h:
        (WebCore::Position::Position):
        * dom/PositionIterator.h:
        (WebCore::PositionIterator::PositionIterator):
        * dom/Range.cpp:
        * dom/RangeBoundaryPoint.h:
        (WebCore::RangeBoundaryPoint::position):
        (WebCore::RangeBoundaryPoint::set):
        (WebCore::RangeBoundaryPoint::setOffset):
        (WebCore::RangeBoundaryPoint::setToChild):
        (WebCore::RangeBoundaryPoint::setToStart):
        (WebCore::RangeBoundaryPoint::setToEnd):
        (WebCore::RangeBoundaryPoint::childBeforeWillBeRemoved):
        * editing/ApplyStyleCommand.cpp:
        (WebCore::ApplyStyleCommand::applyRelativeFontStyleChange):
        (WebCore::ApplyStyleCommand::applyInlineStyleToRange):
        (WebCore::ApplyStyleCommand::removeInlineStyle):
        (WebCore::ApplyStyleCommand::nodeFullySelected):
        (WebCore::ApplyStyleCommand::nodeFullyUnselected):
        (WebCore::ApplyStyleCommand::splitTextAtStartIfNeeded):
        (WebCore::ApplyStyleCommand::splitTextAtEndIfNeeded):
        (WebCore::ApplyStyleCommand::splitTextElementAtStartIfNeeded):
        (WebCore::ApplyStyleCommand::splitTextElementAtEndIfNeeded):
        (WebCore::ApplyStyleCommand::mergeStartWithPreviousIfIdentical):
        (WebCore::ApplyStyleCommand::mergeEndWithNextIfIdentical):
        (WebCore::ApplyStyleCommand::joinChildTextNodes):
        * editing/BreakBlockquoteCommand.cpp:
        (WebCore::BreakBlockquoteCommand::doApply):
        * editing/CompositeEditCommand.cpp:
        (WebCore::CompositeEditCommand::insertNodeAt):
        (WebCore::CompositeEditCommand::positionOutsideTabSpan):
        (WebCore::CompositeEditCommand::rebalanceWhitespaceAt):
        (WebCore::CompositeEditCommand::prepareWhitespaceAtPositionForSplit):
        (WebCore::CompositeEditCommand::deleteInsignificantText):
        (WebCore::CompositeEditCommand::removePlaceholderAt):
        (WebCore::CompositeEditCommand::moveParagraphs):
        (WebCore::CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph):
        * editing/DeleteSelectionCommand.cpp:
        (WebCore::updatePositionForNodeRemoval):
        (WebCore::updatePositionForTextRemoval):
        (WebCore::DeleteSelectionCommand::handleGeneralDelete):
        (WebCore::DeleteSelectionCommand::fixupWhitespace):
        * editing/Editor.cpp:
        (WebCore::Editor::setComposition):
        (WebCore::Editor::advanceToNextMisspelling):
        (WebCore::Editor::getCompositionSelection):
        * editing/InsertLineBreakCommand.cpp:
        (WebCore::InsertLineBreakCommand::doApply):
        * editing/InsertParagraphSeparatorCommand.cpp:
        (WebCore::InsertParagraphSeparatorCommand::doApply):
        * editing/InsertTextCommand.cpp:
        (WebCore::InsertTextCommand::performTrivialReplace):
        (WebCore::InsertTextCommand::input):
        (WebCore::InsertTextCommand::insertTab):
        * editing/MoveSelectionCommand.cpp:
        (WebCore::MoveSelectionCommand::doApply):
        * editing/ReplaceSelectionCommand.cpp:
        (WebCore::ReplaceSelectionCommand::doApply):
        * editing/SelectionController.cpp:
        (WebCore::SelectionController::debugRenderer):
        * editing/TextIterator.cpp:
        (WebCore::TextIterator::rangeFromLocationAndLength):
        * editing/TypingCommand.cpp:
        (WebCore::TypingCommand::deleteKeyPressed):
        (WebCore::TypingCommand::forwardDeleteKeyPressed):
        * editing/VisiblePosition.cpp:
        (WebCore::VisiblePosition::characterAfter):
        (WebCore::VisiblePosition::debugPosition):
        (WebCore::makeRange):
        (WebCore::setStart):
        (WebCore::setEnd):
        * editing/VisibleSelection.cpp:
        (WebCore::VisibleSelection::toNormalizedRange):
        (WebCore::makeSearchRange):
        (WebCore::VisibleSelection::debugPosition):
        (WebCore::VisibleSelection::showTreeForThis):
        * editing/htmlediting.cpp:
        (WebCore::comparePositions):
        (WebCore::rangeCompliantEquivalent):
        (WebCore::isFirstPositionAfterTable):
        (WebCore::isLastPositionBeforeTable):
        * editing/visible_units.cpp:
        (WebCore::previousBoundary):
        (WebCore::nextBoundary):
        (WebCore::startPositionForLine):
        (WebCore::startOfLine):
        (WebCore::endPositionForLine):
        (WebCore::nextLinePosition):
        (WebCore::startOfParagraph):
        (WebCore::endOfParagraph):
        * page/AccessibilityObject.cpp:
        (WebCore::updateAXLineStartForVisiblePosition):
        * page/AccessibilityRenderObject.cpp:
        (WebCore::AccessibilityRenderObject::indexForVisiblePosition):
        * page/DOMSelection.cpp:
        (WebCore::DOMSelection::anchorOffset):
        (WebCore::DOMSelection::baseOffset):
        (WebCore::DOMSelection::focusOffset):
        (WebCore::DOMSelection::extentOffset):
        * page/EventHandler.cpp:
        (WebCore::EventHandler::handleMousePressEventSingleClick):
        * page/Frame.cpp:
        (WebCore::Frame::selectionLayoutChanged):
        * rendering/RenderTextControl.cpp:
        (WebCore::RenderTextControl::indexForVisiblePosition):
        * rendering/RenderTreeAsText.cpp:
        (WebCore::writeSelection):

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

30 files changed:
WebCore/ChangeLog
WebCore/dom/Position.cpp
WebCore/dom/Position.h
WebCore/dom/PositionIterator.h
WebCore/dom/Range.cpp
WebCore/dom/RangeBoundaryPoint.h
WebCore/editing/ApplyStyleCommand.cpp
WebCore/editing/BreakBlockquoteCommand.cpp
WebCore/editing/CompositeEditCommand.cpp
WebCore/editing/DeleteSelectionCommand.cpp
WebCore/editing/Editor.cpp
WebCore/editing/InsertLineBreakCommand.cpp
WebCore/editing/InsertParagraphSeparatorCommand.cpp
WebCore/editing/InsertTextCommand.cpp
WebCore/editing/MoveSelectionCommand.cpp
WebCore/editing/ReplaceSelectionCommand.cpp
WebCore/editing/SelectionController.cpp
WebCore/editing/TextIterator.cpp
WebCore/editing/TypingCommand.cpp
WebCore/editing/VisiblePosition.cpp
WebCore/editing/VisibleSelection.cpp
WebCore/editing/htmlediting.cpp
WebCore/editing/visible_units.cpp
WebCore/page/AccessibilityObject.cpp
WebCore/page/AccessibilityRenderObject.cpp
WebCore/page/DOMSelection.cpp
WebCore/page/EventHandler.cpp
WebCore/page/Frame.cpp
WebCore/rendering/RenderTextControl.cpp
WebCore/rendering/RenderTreeAsText.cpp

index b5c9a222c515548bcc9a86098f37411499dd14ee..c980792f65843a39ac0aaf0e078c82ecf478b0be 100644 (file)
@@ -1,3 +1,138 @@
+2009-03-10  Xan Lopez  <xlopez@igalia.com>
+
+        Reviewed by Darin Adler.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24491
+        Rename posOffset to m_offset, get rid of accessor
+
+        As suggested in dom/Position.h, this patch gets rid of the
+        'offset()' accessor and renames posOffset to m_offset. I've used
+        m_offset instead of offset to follow the style guide lines, since
+        Position is still a class and not a structure. If the long term
+        plan is still to make it a structure it would be pretty easy to
+        just s/m_offset/offset/ globally when that is achieved.
+
+        * dom/Position.cpp:
+        (WebCore::Position::previous):
+        (WebCore::Position::next):
+        (WebCore::Position::atStart):
+        (WebCore::Position::atEnd):
+        (WebCore::Position::renderedOffset):
+        (WebCore::Position::isCandidate):
+        (WebCore::Position::inRenderedText):
+        (WebCore::Position::isRenderedCharacter):
+        (WebCore::Position::rendersInDifferentPosition):
+        (WebCore::Position::leadingWhitespacePosition):
+        (WebCore::Position::debugPosition):
+        (WebCore::Position::formatForDebugger):
+        * dom/Position.h:
+        (WebCore::Position::Position):
+        * dom/PositionIterator.h:
+        (WebCore::PositionIterator::PositionIterator):
+        * dom/Range.cpp:
+        * dom/RangeBoundaryPoint.h:
+        (WebCore::RangeBoundaryPoint::position):
+        (WebCore::RangeBoundaryPoint::set):
+        (WebCore::RangeBoundaryPoint::setOffset):
+        (WebCore::RangeBoundaryPoint::setToChild):
+        (WebCore::RangeBoundaryPoint::setToStart):
+        (WebCore::RangeBoundaryPoint::setToEnd):
+        (WebCore::RangeBoundaryPoint::childBeforeWillBeRemoved):
+        * editing/ApplyStyleCommand.cpp:
+        (WebCore::ApplyStyleCommand::applyRelativeFontStyleChange):
+        (WebCore::ApplyStyleCommand::applyInlineStyleToRange):
+        (WebCore::ApplyStyleCommand::removeInlineStyle):
+        (WebCore::ApplyStyleCommand::nodeFullySelected):
+        (WebCore::ApplyStyleCommand::nodeFullyUnselected):
+        (WebCore::ApplyStyleCommand::splitTextAtStartIfNeeded):
+        (WebCore::ApplyStyleCommand::splitTextAtEndIfNeeded):
+        (WebCore::ApplyStyleCommand::splitTextElementAtStartIfNeeded):
+        (WebCore::ApplyStyleCommand::splitTextElementAtEndIfNeeded):
+        (WebCore::ApplyStyleCommand::mergeStartWithPreviousIfIdentical):
+        (WebCore::ApplyStyleCommand::mergeEndWithNextIfIdentical):
+        (WebCore::ApplyStyleCommand::joinChildTextNodes):
+        * editing/BreakBlockquoteCommand.cpp:
+        (WebCore::BreakBlockquoteCommand::doApply):
+        * editing/CompositeEditCommand.cpp:
+        (WebCore::CompositeEditCommand::insertNodeAt):
+        (WebCore::CompositeEditCommand::positionOutsideTabSpan):
+        (WebCore::CompositeEditCommand::rebalanceWhitespaceAt):
+        (WebCore::CompositeEditCommand::prepareWhitespaceAtPositionForSplit):
+        (WebCore::CompositeEditCommand::deleteInsignificantText):
+        (WebCore::CompositeEditCommand::removePlaceholderAt):
+        (WebCore::CompositeEditCommand::moveParagraphs):
+        (WebCore::CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph):
+        * editing/DeleteSelectionCommand.cpp:
+        (WebCore::updatePositionForNodeRemoval):
+        (WebCore::updatePositionForTextRemoval):
+        (WebCore::DeleteSelectionCommand::handleGeneralDelete):
+        (WebCore::DeleteSelectionCommand::fixupWhitespace):
+        * editing/Editor.cpp:
+        (WebCore::Editor::setComposition):
+        (WebCore::Editor::advanceToNextMisspelling):
+        (WebCore::Editor::getCompositionSelection):
+        * editing/InsertLineBreakCommand.cpp:
+        (WebCore::InsertLineBreakCommand::doApply):
+        * editing/InsertParagraphSeparatorCommand.cpp:
+        (WebCore::InsertParagraphSeparatorCommand::doApply):
+        * editing/InsertTextCommand.cpp:
+        (WebCore::InsertTextCommand::performTrivialReplace):
+        (WebCore::InsertTextCommand::input):
+        (WebCore::InsertTextCommand::insertTab):
+        * editing/MoveSelectionCommand.cpp:
+        (WebCore::MoveSelectionCommand::doApply):
+        * editing/ReplaceSelectionCommand.cpp:
+        (WebCore::ReplaceSelectionCommand::doApply):
+        * editing/SelectionController.cpp:
+        (WebCore::SelectionController::debugRenderer):
+        * editing/TextIterator.cpp:
+        (WebCore::TextIterator::rangeFromLocationAndLength):
+        * editing/TypingCommand.cpp:
+        (WebCore::TypingCommand::deleteKeyPressed):
+        (WebCore::TypingCommand::forwardDeleteKeyPressed):
+        * editing/VisiblePosition.cpp:
+        (WebCore::VisiblePosition::characterAfter):
+        (WebCore::VisiblePosition::debugPosition):
+        (WebCore::makeRange):
+        (WebCore::setStart):
+        (WebCore::setEnd):
+        * editing/VisibleSelection.cpp:
+        (WebCore::VisibleSelection::toNormalizedRange):
+        (WebCore::makeSearchRange):
+        (WebCore::VisibleSelection::debugPosition):
+        (WebCore::VisibleSelection::showTreeForThis):
+        * editing/htmlediting.cpp:
+        (WebCore::comparePositions):
+        (WebCore::rangeCompliantEquivalent):
+        (WebCore::isFirstPositionAfterTable):
+        (WebCore::isLastPositionBeforeTable):
+        * editing/visible_units.cpp:
+        (WebCore::previousBoundary):
+        (WebCore::nextBoundary):
+        (WebCore::startPositionForLine):
+        (WebCore::startOfLine):
+        (WebCore::endPositionForLine):
+        (WebCore::nextLinePosition):
+        (WebCore::startOfParagraph):
+        (WebCore::endOfParagraph):
+        * page/AccessibilityObject.cpp:
+        (WebCore::updateAXLineStartForVisiblePosition):
+        * page/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::indexForVisiblePosition):
+        * page/DOMSelection.cpp:
+        (WebCore::DOMSelection::anchorOffset):
+        (WebCore::DOMSelection::baseOffset):
+        (WebCore::DOMSelection::focusOffset):
+        (WebCore::DOMSelection::extentOffset):
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::handleMousePressEventSingleClick):
+        * page/Frame.cpp:
+        (WebCore::Frame::selectionLayoutChanged):
+        * rendering/RenderTextControl.cpp:
+        (WebCore::RenderTextControl::indexForVisiblePosition):
+        * rendering/RenderTreeAsText.cpp:
+        (WebCore::writeSelection):
+
 2009-03-10  Darin Adler  <darin@apple.com>
 
         Reviewed by Dan Bernstein.
index 6a305b99b4c89f680211008b90f4ec593b738d08..dc0147f70a4d82da0b009de020cd5a56d943d7b1 100644 (file)
@@ -103,7 +103,7 @@ Position Position::previous(PositionMoveType moveType) const
     if (!n)
         return *this;
     
-    int o = offset();
+    int o = m_offset;
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(o >= 0);
 
@@ -142,7 +142,7 @@ Position Position::next(PositionMoveType moveType) const
     if (!n)
         return *this;
     
-    int o = offset();
+    int o = m_offset;
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(o >= 0);
 
@@ -187,7 +187,7 @@ bool Position::atStart() const
     if (!n)
         return true;
     
-    return offset() <= 0 && n->parent() == 0;
+    return m_offset <= 0 && n->parent() == 0;
 }
 
 bool Position::atEnd() const
@@ -196,26 +196,26 @@ bool Position::atEnd() const
     if (!n)
         return true;
     
-    return n->parent() == 0 && offset() >= maxDeepOffset(n);
+    return n->parent() == 0 && m_offset >= maxDeepOffset(n);
 }
 
 int Position::renderedOffset() const
 {
     if (!node()->isTextNode())
-        return offset();
+        return m_offset;
    
     if (!node()->renderer())
-        return offset();
+        return m_offset;
                     
     int result = 0;
     RenderText *textRenderer = toRenderText(node()->renderer());
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
-        if (offset() < start)
+        if (m_offset < start)
             return result;
-        if (offset() <= end) {
-            result += offset() - start;
+        if (m_offset <= end) {
+            result += m_offset - start;
             return result;
         }
         result += box->len();
@@ -574,17 +574,17 @@ bool Position::isCandidate() const
         return false;
 
     if (renderer->isBR())
-        return offset() == 0 && !nodeIsUserSelectNone(node()->parent());
+        return m_offset == 0 && !nodeIsUserSelectNone(node()->parent());
 
     if (renderer->isText())
         return inRenderedText() && !nodeIsUserSelectNone(node());
 
     if (isTableElement(node()) || editingIgnoresContent(node()))
-        return (offset() == 0 || offset() == maxDeepOffset(node())) && !nodeIsUserSelectNone(node()->parent());
+        return (m_offset == 0 || m_offset == maxDeepOffset(node())) && !nodeIsUserSelectNone(node()->parent());
 
     if (!node()->hasTagName(htmlTag) && renderer->isBlockFlow() && !hasRenderedNonAnonymousDescendantsWithHeight(renderer) &&
        (toRenderBox(renderer)->height() || node()->hasTagName(bodyTag)))
-        return offset() == 0 && !nodeIsUserSelectNone(node());
+        return m_offset == 0 && !nodeIsUserSelectNone(node());
     
     return false;
 }
@@ -600,15 +600,15 @@ bool Position::inRenderedText() const
     
     RenderText *textRenderer = toRenderText(renderer);
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
-        if (offset() < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
+        if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
-        if (box->containsCaretOffset(offset()))
+        if (box->containsCaretOffset(m_offset))
             // Return false for offsets inside composed characters.
-            return offset() == 0 || offset() == textRenderer->nextOffset(textRenderer->previousOffset(offset()));
+            return m_offset == 0 || m_offset == textRenderer->nextOffset(textRenderer->previousOffset(m_offset));
     }
     
     return false;
@@ -636,13 +636,13 @@ bool Position::isRenderedCharacter() const
     
     RenderText* textRenderer = toRenderText(renderer);
     for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
-        if (offset() < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
+        if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
-        if (offset() >= static_cast<int>(box->start()) && offset() < static_cast<int>(box->start() + box->len()))
+        if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
     
@@ -670,11 +670,11 @@ bool Position::rendersInDifferentPosition(const Position &pos) const
         if (node()->hasTagName(brTag))
             return false;
 
-        if (offset() == pos.offset())
+        if (m_offset == pos.m_offset)
             return false;
             
         if (!node()->isTextNode() && !pos.node()->isTextNode()) {
-            if (offset() != pos.offset())
+            if (m_offset != pos.m_offset)
                 return true;
         }
     }
@@ -748,7 +748,7 @@ Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNo
     Position prev = previousCharacterPosition(affinity);
     if (prev != *this && prev.node()->inSameContainingBlockFlowElement(node()) && prev.node()->isTextNode()) {
         String string = static_cast<Text *>(prev.node())->data();
-        UChar c = string[prev.offset()];
+        UChar c = string[prev.m_offset];
         if (considerNonCollapsibleWhitespace ? (isSpaceOrNewline(c) || c == noBreakSpace) : isCollapsibleWhitespace(c))
             if (isEditablePosition(prev))
                 return prev;
@@ -823,7 +823,7 @@ static InlineTextBox* searchAheadForBetterMatch(RenderObject* renderer)
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
-    caretOffset = offset();
+    caretOffset = m_offset;
     RenderObject* renderer = node()->renderer();
     if (!renderer->isText()) {
         inlineBox = renderer->isBox() ? toRenderBox(renderer)->inlineBoxWrapper() : 0;
@@ -957,7 +957,7 @@ void Position::debugPosition(const char* msg) const
     if (isNull())
         fprintf(stderr, "Position [%s]: null\n", msg);
     else
-        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, node()->nodeName().utf8().data(), node(), offset());
+        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, node()->nodeName().utf8().data(), node(), m_offset);
 }
 
 #ifndef NDEBUG
@@ -971,7 +971,7 @@ void Position::formatForDebugger(char* buffer, unsigned length) const
     else {
         char s[1024];
         result += "offset ";
-        result += String::number(offset());
+        result += String::number(m_offset);
         result += " of ";
         node()->formatForDebugger(s, sizeof(s));
         result += s;
index 77de678e79c814186e3993234a35a4dcae916433..71ee247675ec4faf2ee42fd2dd624b443f3dd33e 100644 (file)
@@ -53,15 +53,14 @@ enum PositionMoveType {
 class Position {
 public:
     RefPtr<Node> container;
-    int posOffset; // to be renamed to offset when we get rid of offset()
+    int m_offset;
 
-    Position() : posOffset(0) { }
-    Position(PassRefPtr<Node> c, int o) : container(c), posOffset(o) { }
+    Position() : m_offset(0) { }
+    Position(PassRefPtr<Node> c, int o) : container(c), m_offset(o) { }
 
-    void clear() { container.clear(); posOffset = 0; }
+    void clear() { container.clear(); m_offset = 0; }
 
     Node* node() const { return container.get(); }
-    int offset() const { return posOffset; }
     Element* documentElement() const;
 
     bool isNull() const { return !container; }
@@ -118,7 +117,7 @@ private:
 
 inline bool operator==(const Position& a, const Position& b)
 {
-    return a.container == b.container && a.posOffset == b.posOffset;
+    return a.container == b.container && a.m_offset == b.m_offset;
 }
 
 inline bool operator!=(const Position& a, const Position& b)
index 54f502066adcf4cc1a1cfa38a23486e84e7489f1..98a2ccb968ea708bdb98a923293371135ebeb8f1 100644 (file)
@@ -45,8 +45,8 @@ public:
 
     PositionIterator(const Position& pos)
         : m_parent(pos.node())
-        , m_child(m_parent->childNode(pos.offset()))
-        , m_offset(m_child ? 0 : pos.offset())
+        , m_child(m_parent->childNode(pos.m_offset))
+        , m_offset(m_child ? 0 : pos.m_offset)
     {
     }
     operator Position() const;
index 4fde019cc5fdbd1d919083dba9a6873ad05b37d8..f74e09e0116d547dec45d2610b32bf6db5dc9925 100644 (file)
@@ -89,7 +89,7 @@ PassRefPtr<Range> Range::create(PassRefPtr<Document> ownerDocument, PassRefPtr<N
 
 PassRefPtr<Range> Range::create(PassRefPtr<Document> ownerDocument, const Position& start, const Position& end)
 {
-    return adoptRef(new Range(ownerDocument, start.container.get(), start.posOffset, end.container.get(), end.posOffset));
+    return adoptRef(new Range(ownerDocument, start.container.get(), start.m_offset, end.container.get(), end.m_offset));
 }
 
 Range::~Range()
@@ -524,7 +524,7 @@ short Range::compareBoundaryPoints(Node* containerA, int offsetA, Node* containe
 
 short Range::compareBoundaryPoints(const Position& a, const Position& b)
 {
-    return compareBoundaryPoints(a.container.get(), a.posOffset, b.container.get(), b.posOffset);
+    return compareBoundaryPoints(a.container.get(), a.m_offset, b.container.get(), b.m_offset);
 }
 
 bool Range::boundaryPointsValid() const
index 4cb7bf515437c7ee48b45828b592cfb230e89381..39c735ee2f4a6b2ff5c3ca242d646c4fd0d97cac 100644 (file)
@@ -82,16 +82,16 @@ inline Node* RangeBoundaryPoint::childBefore() const
 
 inline const Position& RangeBoundaryPoint::position() const
 {
-    if (m_position.posOffset >= 0)
+    if (m_position.m_offset >= 0)
         return m_position;
     ASSERT(m_childBefore);
-    m_position.posOffset = m_childBefore->nodeIndex() + 1;
+    m_position.m_offset = m_childBefore->nodeIndex() + 1;
     return m_position;
 }
 
 inline int RangeBoundaryPoint::offset() const
 {
-    return position().posOffset;
+    return position().m_offset;
 }
 
 inline void RangeBoundaryPoint::clear()
@@ -105,7 +105,7 @@ inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node
     ASSERT(offset >= 0);
     ASSERT(childBefore == (offset ? container->childNode(offset - 1) : 0));
     m_position.container = container;
-    m_position.posOffset = offset;
+    m_position.m_offset = offset;
     m_childBefore = childBefore;
 }
 
@@ -113,9 +113,9 @@ inline void RangeBoundaryPoint::setOffset(int offset)
 {
     ASSERT(m_position.container);
     ASSERT(m_position.container->offsetInCharacters());
-    ASSERT(m_position.posOffset >= 0);
+    ASSERT(m_position.m_offset >= 0);
     ASSERT(!m_childBefore);
-    m_position.posOffset = offset;
+    m_position.m_offset = offset;
 }
 
 inline void RangeBoundaryPoint::setToChild(Node* child)
@@ -124,14 +124,14 @@ inline void RangeBoundaryPoint::setToChild(Node* child)
     ASSERT(child->parentNode());
     m_position.container = child->parentNode();
     m_childBefore = child->previousSibling();
-    m_position.posOffset = m_childBefore ? invalidOffset : 0;
+    m_position.m_offset = m_childBefore ? invalidOffset : 0;
 }
 
 inline void RangeBoundaryPoint::setToStart(PassRefPtr<Node> container)
 {
     ASSERT(container);
     m_position.container = container;
-    m_position.posOffset = 0;
+    m_position.m_offset = 0;
     m_childBefore = 0;
 }
 
@@ -140,27 +140,27 @@ inline void RangeBoundaryPoint::setToEnd(PassRefPtr<Node> container)
     ASSERT(container);
     m_position.container = container;
     if (m_position.container->offsetInCharacters()) {
-        m_position.posOffset = m_position.container->maxCharacterOffset();
+        m_position.m_offset = m_position.container->maxCharacterOffset();
         m_childBefore = 0;
     } else {
         m_childBefore = m_position.container->lastChild();
-        m_position.posOffset = m_childBefore ? invalidOffset : 0;
+        m_position.m_offset = m_childBefore ? invalidOffset : 0;
     }
 }
 
 inline void RangeBoundaryPoint::childBeforeWillBeRemoved()
 {
-    ASSERT(m_position.posOffset);
+    ASSERT(m_position.m_offset);
     m_childBefore = m_childBefore->previousSibling();
     if (!m_childBefore)
-        m_position.posOffset = 0;
-    else if (m_position.posOffset > 0)
-        --m_position.posOffset;
+        m_position.m_offset = 0;
+    else if (m_position.m_offset > 0)
+        --m_position.m_offset;
 }
 
 inline void RangeBoundaryPoint::invalidateOffset() const
 {
-    m_position.posOffset = invalidOffset;
+    m_position.m_offset = invalidOffset;
 }
 
 inline bool operator==(const RangeBoundaryPoint& a, const RangeBoundaryPoint& b)
index d888aed6e797f8db0460d8bd80cdb32db9d7a1f2..87edefd8b0c5162a3bbec0183a1285d4a20bef68 100644 (file)
@@ -520,7 +520,7 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclaration
     
     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
     Node *startNode = start.node();
-    if (startNode->isTextNode() && start.offset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
+    if (startNode->isTextNode() && start.m_offset >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
         startNode = startNode->traverseNextNode();
 
     // Store away font size before making any changes to the document.
@@ -868,7 +868,7 @@ void ApplyStyleCommand::applyInlineStyleToRange(CSSMutableStyleDeclaration* styl
 
     bool rangeIsEmpty = false;
 
-    if (start.offset() >= caretMaxOffset(start.node())) {
+    if (start.m_offset >= caretMaxOffset(start.node())) {
         node = node->traverseNextNode();
         Position newStart = Position(node, 0);
         if (Range::compareBoundaryPoints(end, newStart) < 0)
@@ -878,7 +878,7 @@ void ApplyStyleCommand::applyInlineStyleToRange(CSSMutableStyleDeclaration* styl
     if (!rangeIsEmpty) {
         // pastEndNode is the node after the last fully selected node.
         Node* pastEndNode = end.node();
-        if (end.offset() >= caretMaxOffset(end.node()))
+        if (end.m_offset >= caretMaxOffset(end.node()))
             pastEndNode = end.node()->traverseNextSibling();
         // FIXME: Callers should perform this operation on a Range that includes the br
         // if they want style applied to the empty line.
@@ -1239,14 +1239,14 @@ void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration>
                 if (s.node() == elem) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
-                    ASSERT(s.offset() <= caretMinOffset(s.node()));
+                    ASSERT(s.m_offset <= caretMinOffset(s.node()));
                     s = Position(next, 0);
                 }
                 if (e.node() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
-                    ASSERT(e.offset() >= maxRangeOffset(e.node()));
+                    ASSERT(e.m_offset >= maxRangeOffset(e.node()));
                     e = Position(prev, maxRangeOffset(prev));
                 }
             }
@@ -1267,7 +1267,7 @@ bool ApplyStyleCommand::nodeFullySelected(Node *node, const Position &start, con
     ASSERT(node->isElementNode());
 
     Position pos = Position(node, node->childNodeCount()).upstream();
-    return Range::compareBoundaryPoints(node, 0, start.node(), start.offset()) >= 0 &&
+    return Range::compareBoundaryPoints(node, 0, start.node(), start.m_offset) >= 0 &&
         Range::compareBoundaryPoints(pos, end) <= 0;
 }
 
@@ -1278,7 +1278,7 @@ bool ApplyStyleCommand::nodeFullyUnselected(Node *node, const Position &start, c
 
     Position pos = Position(node, node->childNodeCount()).upstream();
     bool isFullyBeforeStart = Range::compareBoundaryPoints(pos, start) < 0;
-    bool isFullyAfterEnd = Range::compareBoundaryPoints(node, 0, end.node(), end.offset()) > 0;
+    bool isFullyAfterEnd = Range::compareBoundaryPoints(node, 0, end.node(), end.m_offset) > 0;
 
     return isFullyBeforeStart || isFullyAfterEnd;
 }
@@ -1286,11 +1286,11 @@ bool ApplyStyleCommand::nodeFullyUnselected(Node *node, const Position &start, c
 
 bool ApplyStyleCommand::splitTextAtStartIfNeeded(const Position &start, const Position &end)
 {
-    if (start.node()->isTextNode() && start.offset() > caretMinOffset(start.node()) && start.offset() < caretMaxOffset(start.node())) {
-        int endOffsetAdjustment = start.node() == end.node() ? start.offset() : 0;
+    if (start.node()->isTextNode() && start.m_offset > caretMinOffset(start.node()) && start.m_offset < caretMaxOffset(start.node())) {
+        int endOffsetAdjustment = start.node() == end.node() ? start.m_offset : 0;
         Text *text = static_cast<Text *>(start.node());
-        splitTextNode(text, start.offset());
-        updateStartEnd(Position(start.node(), 0), Position(end.node(), end.offset() - endOffsetAdjustment));
+        splitTextNode(text, start.m_offset);
+        updateStartEnd(Position(start.node(), 0), Position(end.node(), end.m_offset - endOffsetAdjustment));
         return true;
     }
     return false;
@@ -1298,15 +1298,15 @@ bool ApplyStyleCommand::splitTextAtStartIfNeeded(const Position &start, const Po
 
 bool ApplyStyleCommand::splitTextAtEndIfNeeded(const Position &start, const Position &end)
 {
-    if (end.node()->isTextNode() && end.offset() > caretMinOffset(end.node()) && end.offset() < caretMaxOffset(end.node())) {
+    if (end.node()->isTextNode() && end.m_offset > caretMinOffset(end.node()) && end.m_offset < caretMaxOffset(end.node())) {
         Text *text = static_cast<Text *>(end.node());
-        splitTextNode(text, end.offset());
+        splitTextNode(text, end.m_offset);
         
         Node *prevNode = text->previousSibling();
         ASSERT(prevNode);
         Node *startNode = start.node() == end.node() ? prevNode : start.node();
         ASSERT(startNode);
-        updateStartEnd(Position(startNode, start.offset()), Position(prevNode, caretMaxOffset(prevNode)));
+        updateStartEnd(Position(startNode, start.m_offset), Position(prevNode, caretMaxOffset(prevNode)));
         return true;
     }
     return false;
@@ -1314,12 +1314,12 @@ bool ApplyStyleCommand::splitTextAtEndIfNeeded(const Position &start, const Posi
 
 bool ApplyStyleCommand::splitTextElementAtStartIfNeeded(const Position &start, const Position &end)
 {
-    if (start.node()->isTextNode() && start.offset() > caretMinOffset(start.node()) && start.offset() < caretMaxOffset(start.node())) {
-        int endOffsetAdjustment = start.node() == end.node() ? start.offset() : 0;
+    if (start.node()->isTextNode() && start.m_offset > caretMinOffset(start.node()) && start.m_offset < caretMaxOffset(start.node())) {
+        int endOffsetAdjustment = start.node() == end.node() ? start.m_offset : 0;
         Text *text = static_cast<Text *>(start.node());
-        splitTextNodeContainingElement(text, start.offset());
+        splitTextNodeContainingElement(text, start.m_offset);
 
-        updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex()), Position(end.node(), end.offset() - endOffsetAdjustment));
+        updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex()), Position(end.node(), end.m_offset - endOffsetAdjustment));
         return true;
     }
     return false;
@@ -1327,15 +1327,15 @@ bool ApplyStyleCommand::splitTextElementAtStartIfNeeded(const Position &start, c
 
 bool ApplyStyleCommand::splitTextElementAtEndIfNeeded(const Position &start, const Position &end)
 {
-    if (end.node()->isTextNode() && end.offset() > caretMinOffset(end.node()) && end.offset() < caretMaxOffset(end.node())) {
+    if (end.node()->isTextNode() && end.m_offset > caretMinOffset(end.node()) && end.m_offset < caretMaxOffset(end.node())) {
         Text *text = static_cast<Text *>(end.node());
-        splitTextNodeContainingElement(text, end.offset());
+        splitTextNodeContainingElement(text, end.m_offset);
 
         Node *prevNode = text->parent()->previousSibling()->lastChild();
         ASSERT(prevNode);
         Node *startNode = start.node() == end.node() ? prevNode : start.node();
         ASSERT(startNode);
-        updateStartEnd(Position(startNode, start.offset()), Position(prevNode->parent(), prevNode->nodeIndex() + 1));
+        updateStartEnd(Position(startNode, start.m_offset), Position(prevNode->parent(), prevNode->nodeIndex() + 1));
         return true;
     }
     return false;
@@ -1379,10 +1379,10 @@ static bool areIdenticalElements(Node *first, Node *second)
 bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position &start, const Position &end)
 {
     Node *startNode = start.node();
-    int startOffset = start.offset();
+    int startOffset = start.m_offset;
 
     if (isAtomicNode(start.node())) {
-        if (start.offset() != 0)
+        if (start.m_offset != 0)
             return false;
 
         // note: prior siblings could be unrendered elements. it's silly to miss the
@@ -1411,7 +1411,7 @@ bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position &start,
 
         int startOffsetAdjustment = startChild->nodeIndex();
         int endOffsetAdjustment = startNode == end.node() ? startOffsetAdjustment : 0;
-        updateStartEnd(Position(startNode, startOffsetAdjustment), Position(end.node(), end.offset() + endOffsetAdjustment)); 
+        updateStartEnd(Position(startNode, startOffsetAdjustment), Position(end.node(), end.m_offset + endOffsetAdjustment)); 
         return true;
     }
 
@@ -1421,7 +1421,7 @@ bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position &start,
 bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position &start, const Position &end)
 {
     Node *endNode = end.node();
-    int endOffset = end.offset();
+    int endOffset = end.m_offset;
 
     if (isAtomicNode(endNode)) {
         if (endOffset < caretMaxOffset(endNode))
@@ -1451,7 +1451,7 @@ bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position &start, const
         ASSERT(startNode);
 
         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
-        updateStartEnd(Position(startNode, start.offset()), Position(nextElement, endOffset));
+        updateStartEnd(Position(startNode, start.m_offset), Position(nextElement, endOffset));
         return true;
     }
 
@@ -1607,9 +1607,9 @@ void ApplyStyleCommand::joinChildTextNodes(Node *node, const Position &start, co
             Text *childText = static_cast<Text *>(child);
             Text *nextText = static_cast<Text *>(next);
             if (next == start.node())
-                newStart = Position(childText, childText->length() + start.offset());
+                newStart = Position(childText, childText->length() + start.m_offset);
             if (next == end.node())
-                newEnd = Position(childText, childText->length() + end.offset());
+                newEnd = Position(childText, childText->length() + end.m_offset);
             String textToMove = nextText->data();
             insertTextIntoNode(childText, childText->length(), textToMove);
             removeNode(next);
index 44a44c520d3db2de3c582b7b18c809fa3e713d66..909efdd597eaae6071dafabfd6f6e016aadfdcd5 100644 (file)
@@ -85,12 +85,12 @@ void BreakBlockquoteCommand::doApply()
     // Split at pos if in the middle of a text node.
     if (startNode->isTextNode()) {
         Text* textNode = static_cast<Text*>(startNode);
-        if ((unsigned)pos.offset() >= textNode->length()) {
+        if ((unsigned)pos.m_offset >= textNode->length()) {
             startNode = startNode->traverseNextNode();
             ASSERT(startNode);
-        } else if (pos.offset() > 0)
-            splitTextNode(textNode, pos.offset());
-    } else if (pos.offset() > 0) {
+        } else if (pos.m_offset > 0)
+            splitTextNode(textNode, pos.m_offset);
+    } else if (pos.m_offset > 0) {
         startNode = startNode->traverseNextNode();
         ASSERT(startNode);
     }
index 73d1c41baa23673339b8ea14ba2be7f9c41be2f4..37375d51a4fdfc7c6d8a6c15740eb4945251a861 100644 (file)
@@ -157,7 +157,7 @@ void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Posi
     // likewise for replaced elements, brs, etc.
     Position p = rangeCompliantEquivalent(editingPosition);
     Node* refChild = p.node();
-    int offset = p.offset();
+    int offset = p.m_offset;
     
     if (canHaveChildrenForEditing(refChild)) {
         Node* child = refChild->firstChild();
@@ -323,13 +323,13 @@ Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
     
     Node* tabSpan = tabSpanNode(pos.node());
     
-    if (pos.offset() <= caretMinOffset(pos.node()))
+    if (pos.m_offset <= caretMinOffset(pos.node()))
         return positionBeforeNode(tabSpan);
         
-    if (pos.offset() >= caretMaxOffset(pos.node()))
+    if (pos.m_offset >= caretMaxOffset(pos.node()))
         return positionAfterNode(tabSpan);
 
-    splitTextNodeContainingElement(static_cast<Text *>(pos.node()), pos.offset());
+    splitTextNodeContainingElement(static_cast<Text *>(pos.node()), pos.m_offset);
     return positionBeforeNode(tabSpan);
 }
 
@@ -388,7 +388,7 @@ void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
     String text = textNode->data();
     ASSERT(!text.isEmpty());
 
-    int offset = position.offset();
+    int offset = position.m_offset;
     // If neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
     if (!isWhitespace(text[offset])) {
         offset--;
@@ -445,9 +445,9 @@ void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& positio
     Position previous(previousVisiblePos.deepEquivalent());
     
     if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.node()->isTextNode() && !previous.node()->hasTagName(brTag))
-        replaceTextInNode(static_cast<Text*>(previous.node()), previous.offset(), 1, nonBreakingSpaceString());
+        replaceTextInNode(static_cast<Text*>(previous.node()), previous.m_offset, 1, nonBreakingSpaceString());
     if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.node()->isTextNode() && !position.node()->hasTagName(brTag))
-        replaceTextInNode(static_cast<Text*>(position.node()), position.offset(), 1, nonBreakingSpaceString());
+        replaceTextInNode(static_cast<Text*>(position.node()), position.m_offset, 1, nonBreakingSpaceString());
 }
 
 void CompositeEditCommand::rebalanceWhitespace()
@@ -538,8 +538,8 @@ void CompositeEditCommand::deleteInsignificantText(const Position& start, const
         next = node->traverseNextNode();
         if (node->isTextNode()) {
             Text* textNode = static_cast<Text*>(node);
-            int startOffset = node == start.node() ? start.offset() : 0;
-            int endOffset = node == end.node() ? end.offset() : textNode->length();
+            int startOffset = node == start.node() ? start.m_offset : 0;
+            int endOffset = node == end.node() ? end.m_offset : textNode->length();
             deleteInsignificantText(textNode, startOffset, endOffset);
         }
         if (node == end.node())
@@ -612,10 +612,10 @@ void CompositeEditCommand::removePlaceholderAt(const VisiblePosition& visiblePos
     // the start of a paragraph will render it superfluous.
     // FIXME: This doesn't remove placeholders at the end of anonymous blocks.
     if (isEndOfBlock(visiblePosition) && isStartOfParagraph(visiblePosition)) {
-        if (p.node()->hasTagName(brTag) && p.offset() == 0)
+        if (p.node()->hasTagName(brTag) && p.m_offset == 0)
             removeNode(p.node());
         else if (lineBreakExistsAtPosition(visiblePosition))
-            deleteTextFromNode(static_cast<Text*>(p.node()), p.offset(), 1);
+            deleteTextFromNode(static_cast<Text*>(p.node()), p.m_offset, 1);
     }
 }
 
@@ -778,7 +778,7 @@ void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagrap
     // start and end can't be used directly to create a Range; they are "editing positions"
     Position startRangeCompliant = rangeCompliantEquivalent(start);
     Position endRangeCompliant = rangeCompliantEquivalent(end);
-    RefPtr<Range> range = Range::create(document(), startRangeCompliant.node(), startRangeCompliant.offset(), endRangeCompliant.node(), endRangeCompliant.offset());
+    RefPtr<Range> range = Range::create(document(), startRangeCompliant.node(), startRangeCompliant.m_offset, endRangeCompliant.node(), endRangeCompliant.m_offset);
 
     // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move.  It 
     // shouldn't matter though, since moved paragraphs will usually be quite small.
@@ -827,7 +827,7 @@ void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagrap
             if (textNode->length() == 1)
                 removeNodeAndPruneAncestors(node);
             else 
-                deleteTextFromNode(textNode, position.offset(), 1);
+                deleteTextFromNode(textNode, position.m_offset, 1);
         }
     }
 
@@ -949,7 +949,7 @@ bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
         removeNode(caretPos.node());
         prune(beforeBR.node());
     } else {
-        ASSERT(caretPos.offset() == 0);
+        ASSERT(caretPos.m_offset == 0);
         Text* textNode = static_cast<Text*>(caretPos.node());
         Node* parentNode = textNode->parentNode();
         // The preserved newline must be the first thing in the node, since otherwise the previous
index e8b748b286b708b199abf61d4b213b0d3326957d..850c1e5090b2d67f67494e29c3182a1209e6d19d 100644 (file)
@@ -312,8 +312,8 @@ static void updatePositionForNodeRemoval(Node* node, Position& position)
 {
     if (position.isNull())
         return;
-    if (node->parent() == position.node() && node->nodeIndex() < (unsigned)position.offset())
-        position = Position(position.node(), position.offset() - 1);
+    if (node->parent() == position.node() && node->nodeIndex() < (unsigned)position.m_offset)
+        position = Position(position.node(), position.m_offset - 1);
     if (position.node() == node || position.node()->isDescendantOf(node))
         position = positionBeforeNode(node);
 }
@@ -379,9 +379,9 @@ void DeleteSelectionCommand::removeNode(PassRefPtr<Node> node)
 static void updatePositionForTextRemoval(Node* node, int offset, int count, Position& position)
 {
     if (position.node() == node) {
-        if (position.offset() > offset + count)
-            position = Position(position.node(), position.offset() - count);
-        else if (position.offset() > offset)
+        if (position.m_offset > offset + count)
+            position = Position(position.node(), position.m_offset - count);
+        else if (position.m_offset > offset)
             position = Position(position.node(), offset);
     }
 }
@@ -398,7 +398,7 @@ void DeleteSelectionCommand::deleteTextFromNode(PassRefPtr<Text> node, unsigned
 
 void DeleteSelectionCommand::handleGeneralDelete()
 {
-    int startOffset = m_upstreamStart.offset();
+    int startOffset = m_upstreamStart.m_offset;
     Node* startNode = m_upstreamStart.node();
     
     // Never remove the start block unless it's a table, in which case we won't merge content in.
@@ -425,16 +425,16 @@ void DeleteSelectionCommand::handleGeneralDelete()
     if (startNode == m_downstreamEnd.node()) {
         // The selection to delete is all in one node.
         if (!startNode->renderer() || 
-            (startOffset == 0 && m_downstreamEnd.offset() >= maxDeepOffset(startNode))) {
+            (startOffset == 0 && m_downstreamEnd.m_offset >= maxDeepOffset(startNode))) {
             // just delete
             removeNode(startNode);
-        } else if (m_downstreamEnd.offset() - startOffset > 0) {
+        } else if (m_downstreamEnd.m_offset - startOffset > 0) {
             if (startNode->isTextNode()) {
                 // in a text node that needs to be trimmed
                 Text *text = static_cast<Text *>(startNode);
-                deleteTextFromNode(text, startOffset, m_downstreamEnd.offset() - startOffset);
+                deleteTextFromNode(text, startOffset, m_downstreamEnd.m_offset - startOffset);
             } else {
-                removeChildrenInRange(startNode, startOffset, m_downstreamEnd.offset());
+                removeChildrenInRange(startNode, startOffset, m_downstreamEnd.m_offset);
                 m_endingPosition = m_upstreamStart;
             }
         }
@@ -465,14 +465,14 @@ void DeleteSelectionCommand::handleGeneralDelete()
                 // if we just removed a node from the end container, update end position so the
                 // check above will work
                 if (node->parentNode() == m_downstreamEnd.node()) {
-                    ASSERT(node->nodeIndex() < (unsigned)m_downstreamEnd.offset());
-                    m_downstreamEnd = Position(m_downstreamEnd.node(), m_downstreamEnd.offset() - 1);
+                    ASSERT(node->nodeIndex() < (unsigned)m_downstreamEnd.m_offset);
+                    m_downstreamEnd = Position(m_downstreamEnd.node(), m_downstreamEnd.m_offset - 1);
                 }
                 removeNode(node.get());
                 node = nextNode.get();
             } else {
                 Node* n = node->lastDescendant();
-                if (m_downstreamEnd.node() == n && m_downstreamEnd.offset() >= caretMaxOffset(n)) {
+                if (m_downstreamEnd.node() == n && m_downstreamEnd.m_offset >= caretMaxOffset(n)) {
                     removeNode(node.get());
                     node = 0;
                 } else
@@ -480,16 +480,16 @@ void DeleteSelectionCommand::handleGeneralDelete()
             }
         }
         
-        if (m_downstreamEnd.node() != startNode && !m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()) && m_downstreamEnd.node()->inDocument() && m_downstreamEnd.offset() >= caretMinOffset(m_downstreamEnd.node())) {
-            if (m_downstreamEnd.offset() >= maxDeepOffset(m_downstreamEnd.node()) && !canHaveChildrenForEditing(m_downstreamEnd.node())) {
+        if (m_downstreamEnd.node() != startNode && !m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()) && m_downstreamEnd.node()->inDocument() && m_downstreamEnd.m_offset >= caretMinOffset(m_downstreamEnd.node())) {
+            if (m_downstreamEnd.m_offset >= maxDeepOffset(m_downstreamEnd.node()) && !canHaveChildrenForEditing(m_downstreamEnd.node())) {
                 // The node itself is fully selected, not just its contents.  Delete it.
                 removeNode(m_downstreamEnd.node());
             } else {
                 if (m_downstreamEnd.node()->isTextNode()) {
                     // in a text node that needs to be trimmed
                     Text *text = static_cast<Text *>(m_downstreamEnd.node());
-                    if (m_downstreamEnd.offset() > 0) {
-                        deleteTextFromNode(text, 0, m_downstreamEnd.offset());
+                    if (m_downstreamEnd.m_offset > 0) {
+                        deleteTextFromNode(text, 0, m_downstreamEnd.m_offset);
                         m_downstreamEnd = Position(text, 0);
                     }
                 // Remove children of m_downstreamEnd.node() that come after m_upstreamStart.
@@ -507,7 +507,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
                         if (n)
                             offset = n->nodeIndex() + 1;
                     }
-                    removeChildrenInRange(m_downstreamEnd.node(), offset, m_downstreamEnd.offset());
+                    removeChildrenInRange(m_downstreamEnd.node(), offset, m_downstreamEnd.m_offset);
                     m_downstreamEnd = Position(m_downstreamEnd.node(), offset);
                 }
             }
@@ -522,12 +522,12 @@ void DeleteSelectionCommand::fixupWhitespace()
     if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter()) {
         Text* textNode = static_cast<Text*>(m_leadingWhitespace.node());
         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
-        replaceTextInNode(textNode, m_leadingWhitespace.offset(), 1, nonBreakingSpaceString());
+        replaceTextInNode(textNode, m_leadingWhitespace.m_offset, 1, nonBreakingSpaceString());
     }
     if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter()) {
         Text* textNode = static_cast<Text*>(m_trailingWhitespace.node());
         ASSERT(!textNode->renderer() ||textNode->renderer()->style()->collapseWhiteSpace());
-        replaceTextInNode(textNode, m_trailingWhitespace.offset(), 1, nonBreakingSpaceString());
+        replaceTextInNode(textNode, m_trailingWhitespace.m_offset, 1, nonBreakingSpaceString());
     }
 }
 
index 18887681143f1856188c4a958860ef3134517ba6..ef29747557d42eea467788906c266b672ae0b0d8 100644 (file)
@@ -1290,9 +1290,9 @@ void Editor::setComposition(const String& text, const Vector<CompositionUnderlin
         TypingCommand::insertText(m_frame->document(), text, true, true);
 
         Node* baseNode = m_frame->selection()->base().node();
-        unsigned baseOffset = m_frame->selection()->base().offset();
+        unsigned baseOffset = m_frame->selection()->base().m_offset;
         Node* extentNode = m_frame->selection()->extent().node();
-        unsigned extentOffset = m_frame->selection()->extent().offset();
+        unsigned extentOffset = m_frame->selection()->extent().m_offset;
 
         if (baseNode && baseNode == extentNode && baseNode->isTextNode() && baseOffset + text.length() == extentOffset) {
             m_compositionNode = static_cast<Text*>(baseNode);
@@ -1696,7 +1696,7 @@ void Editor::advanceToNextMisspelling(bool startBeforeSelection)
             return;
         
         Position rangeCompliantPosition = rangeCompliantEquivalent(position);
-        spellingSearchRange->setStart(rangeCompliantPosition.node(), rangeCompliantPosition.offset(), ec);
+        spellingSearchRange->setStart(rangeCompliantPosition.node(), rangeCompliantPosition.m_offset, ec);
         startedWithSelection = false;   // won't need to wrap
     }
     
@@ -2268,13 +2268,13 @@ bool Editor::getCompositionSelection(unsigned& selectionStart, unsigned& selecti
     if (end.node() != m_compositionNode)
         return false;
 
-    if (static_cast<unsigned>(start.offset()) < m_compositionStart)
+    if (static_cast<unsigned>(start.m_offset) < m_compositionStart)
         return false;
-    if (static_cast<unsigned>(end.offset()) > m_compositionEnd)
+    if (static_cast<unsigned>(end.m_offset) > m_compositionEnd)
         return false;
 
-    selectionStart = start.offset() - m_compositionStart;
-    selectionEnd = start.offset() - m_compositionEnd;
+    selectionStart = start.m_offset - m_compositionStart;
+    selectionEnd = start.m_offset - m_compositionEnd;
     return true;
 }
 
index 857ae268f0a938bfb9011176e2ae889f436c8131..984c6f114075913553b6b4abb92838d3ababf3f6 100644 (file)
@@ -118,7 +118,7 @@ void InsertLineBreakCommand::doApply()
         
         VisiblePosition endingPosition(Position(nodeToInsert.get(), 0));
         setEndingSelection(VisibleSelection(endingPosition));
-    } else if (pos.offset() <= caretMinOffset(pos.node())) {
+    } else if (pos.m_offset <= caretMinOffset(pos.node())) {
         insertNodeAt(nodeToInsert.get(), pos);
         
         // Insert an extra br or '\n' if the just inserted one collapsed.
@@ -128,7 +128,7 @@ void InsertLineBreakCommand::doApply()
         setEndingSelection(VisibleSelection(positionAfterNode(nodeToInsert.get()), DOWNSTREAM));
     // If we're inserting after all of the rendered text in a text node, or into a non-text node,
     // a simple insertion is sufficient.
-    } else if (pos.offset() >= caretMaxOffset(pos.node()) || !pos.node()->isTextNode()) {
+    } else if (pos.m_offset >= caretMaxOffset(pos.node()) || !pos.node()->isTextNode()) {
         insertNodeAt(nodeToInsert.get(), pos);
         setEndingSelection(VisibleSelection(positionAfterNode(nodeToInsert.get()), DOWNSTREAM));
     } else {
@@ -137,7 +137,7 @@ void InsertLineBreakCommand::doApply()
         
         // Do the split
         Text* textNode = static_cast<Text*>(pos.node());
-        splitTextNode(textNode, pos.offset());
+        splitTextNode(textNode, pos.m_offset);
         insertNodeBefore(nodeToInsert, textNode);
         Position endingPosition = Position(textNode, 0);
         
index b81489eb6f16cbd827e391ad9819fcaa312fa809..ec388146e97ace63ee07aced4dbe43bac0153c78 100644 (file)
@@ -199,7 +199,7 @@ void InsertParagraphSeparatorCommand::doApply()
         if (isFirstInBlock && !nestNewBlock)
             refNode = startBlock;
         else if (pos.node() == startBlock && nestNewBlock) {
-            refNode = startBlock->childNode(pos.offset());
+            refNode = startBlock->childNode(pos.m_offset);
             ASSERT(refNode); // must be true or we'd be in the end of block case
         } else
             refNode = pos.node();
@@ -248,15 +248,15 @@ void InsertParagraphSeparatorCommand::doApply()
     if (leadingWhitespace.isNotNull()) {
         Text* textNode = static_cast<Text*>(leadingWhitespace.node());
         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
-        replaceTextInNode(textNode, leadingWhitespace.offset(), 1, nonBreakingSpaceString());
+        replaceTextInNode(textNode, leadingWhitespace.m_offset, 1, nonBreakingSpaceString());
     }
     
     // Split at pos if in the middle of a text node.
     if (startNode->isTextNode()) {
         Text *textNode = static_cast<Text *>(startNode);
-        bool atEnd = (unsigned)pos.offset() >= textNode->length();
-        if (pos.offset() > 0 && !atEnd) {
-            splitTextNode(textNode, pos.offset());
+        bool atEnd = (unsigned)pos.m_offset >= textNode->length();
+        if (pos.m_offset > 0 && !atEnd) {
+            splitTextNode(textNode, pos.m_offset);
             pos = Position(startNode, 0);
             visiblePos = VisiblePosition(pos);
             splitText = true;
@@ -288,7 +288,7 @@ void InsertParagraphSeparatorCommand::doApply()
     // Move the start node and the siblings of the start node.
     if (startNode != startBlock) {
         Node *n = startNode;
-        if (pos.offset() >= caretMaxOffset(startNode))
+        if (pos.m_offset >= caretMaxOffset(startNode))
             n = startNode->nextSibling();
 
         while (n && n != blockToInsert) {
index 4dfd541e1779d96c9db3215196316a647e71a5d2..52da5d04ece5b826b7c87ac0c968f859fadbc32c 100644 (file)
@@ -89,9 +89,9 @@ bool InsertTextCommand::performTrivialReplace(const String& text, bool selectIns
     if (start.node() != end.node() || !start.node()->isTextNode() || isTabSpanTextNode(start.node()))
         return false;
         
-    replaceTextInNode(static_cast<Text*>(start.node()), start.offset(), end.offset() - start.offset(), text);
+    replaceTextInNode(static_cast<Text*>(start.node()), start.m_offset, end.m_offset - start.m_offset, text);
     
-    Position endPosition(start.node(), start.offset() + text.length());
+    Position endPosition(start.node(), start.m_offset + text.length());
     
     // We could have inserted a part of composed character sequence,
     // so we are basically treating ending selection as a range to avoid validation.
@@ -155,7 +155,7 @@ void InsertTextCommand::input(const String& originalText, bool selectInsertedTex
         startPosition = prepareForTextInsertion(startPosition);
         removePlaceholderAt(VisiblePosition(startPosition));
         Text *textNode = static_cast<Text *>(startPosition.node());
-        int offset = startPosition.offset();
+        int offset = startPosition.m_offset;
 
         insertTextIntoNode(textNode, offset, text);
         endPosition = Position(textNode, offset + text.length());
@@ -207,7 +207,7 @@ Position InsertTextCommand::insertTab(const Position& pos)
     Position insertPos = VisiblePosition(pos, DOWNSTREAM).deepEquivalent();
         
     Node *node = insertPos.node();
-    unsigned int offset = insertPos.offset();
+    unsigned int offset = insertPos.m_offset;
 
     // keep tabs coalesced in tab span
     if (isTabSpanTextNode(node)) {
index a5dddbc9319b924566c879f7cc490d90e126a49e..2c656e79afe41a8b9579c62c2a146bd72cfb1a68 100644 (file)
@@ -48,14 +48,14 @@ void MoveSelectionCommand::doApply()
         
     // Update the position otherwise it may become invalid after the selection is deleted.
     Node *positionNode = m_position.node();
-    int positionOffset = m_position.offset();
+    int positionOffset = m_position.m_offset;
     Position selectionEnd = selection.end();
-    int selectionEndOffset = selectionEnd.offset();    
+    int selectionEndOffset = selectionEnd.m_offset;    
     if (selectionEnd.node() == positionNode && selectionEndOffset < positionOffset) {
         positionOffset -= selectionEndOffset;
         Position selectionStart = selection.start();
         if (selectionStart.node() == positionNode) {
-            positionOffset += selectionStart.offset();
+            positionOffset += selectionStart.m_offset;
         }
         pos = Position(positionNode, positionOffset);
     }
index a16c49aac14a9d0d44ed6baebfc860922301e066..6029174debef17b792b6c35c061417da7a7414af 100644 (file)
@@ -864,7 +864,7 @@ void ReplaceSelectionCommand::doApply()
     
     // We inserted before the startBlock to prevent nesting, and the content before the startBlock wasn't in its own block and
     // didn't have a br after it, so the inserted content ended up in the same paragraph.
-    if (startBlock && insertionPos.node() == startBlock->parentNode() && (unsigned)insertionPos.offset() < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
+    if (startBlock && insertionPos.node() == startBlock->parentNode() && (unsigned)insertionPos.m_offset < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
         insertNodeAt(createBreakElement(document()).get(), startOfInsertedContent.deepEquivalent());
     
     Position lastPositionToSelect;
index 1faa68398ecb8aa93a998db4e72e78d4d6bbc954..ae03c1baa0723f05389aaf70bc423f1fcf83f775 100644 (file)
@@ -932,9 +932,9 @@ void SelectionController::debugRenderer(RenderObject *r, bool selected) const
         if (selected) {
             int offset = 0;
             if (r->node() == m_sel.start().node())
-                offset = m_sel.start().offset();
+                offset = m_sel.start().m_offset;
             else if (r->node() == m_sel.end().node())
-                offset = m_sel.end().offset();
+                offset = m_sel.end().m_offset;
                 
             int pos;
             InlineTextBox *box = textRenderer->findNextInlineTextBox(offset, pos);
index a350292742c66e32ae0ce4f83ac0ea41cae9b6c4..fa23cd3463cda296564144e553d854160ed4eadf 100644 (file)
@@ -1483,7 +1483,7 @@ PassRefPtr<Range> TextIterator::rangeFromLocationAndLength(Element *scope, int r
                 Position runEnd = VisiblePosition(runStart).next().deepEquivalent();
                 if (runEnd.isNotNull()) {
                     ExceptionCode ec = 0;
-                    textRunRange->setEnd(runEnd.node(), runEnd.offset(), ec);
+                    textRunRange->setEnd(runEnd.node(), runEnd.m_offset, ec);
                     ASSERT(!ec);
                 }
             }
index 01579c6bffb5ffd96687160294c2c15f7bfee34f..ddd2f31e30e666e8d5d12b443d3c953963a4ab47 100644 (file)
@@ -411,7 +411,7 @@ void TypingCommand::deleteKeyPressed(TextGranularity granularity, bool killRing)
 
             selectionToDelete = selection.selection();
 
-            if (granularity == CharacterGranularity && selectionToDelete.end().node() == selectionToDelete.start().node() && selectionToDelete.end().offset() - selectionToDelete.start().offset() > 1) {
+            if (granularity == CharacterGranularity && selectionToDelete.end().node() == selectionToDelete.start().node() && selectionToDelete.end().m_offset - selectionToDelete.start().m_offset > 1) {
                 // If there are multiple Unicode code points to be deleted, adjust the range to match platform conventions.
                 selectionToDelete.setWithoutValidation(selectionToDelete.end(), selectionToDelete.end().previous(BackwardDeletion));
             }
@@ -476,7 +476,7 @@ void TypingCommand::forwardDeleteKeyPressed(TextGranularity granularity, bool ki
             if (visibleEnd == endOfParagraph(visibleEnd))
                 downstreamEnd = visibleEnd.next(true).deepEquivalent().downstream();
             // When deleting tables: Select the table first, then perform the deletion
-            if (downstreamEnd.node() && downstreamEnd.node()->renderer() && downstreamEnd.node()->renderer()->isTable() && downstreamEnd.offset() == 0) {
+            if (downstreamEnd.node() && downstreamEnd.node()->renderer() && downstreamEnd.node()->renderer()->isTable() && downstreamEnd.m_offset == 0) {
                 setEndingSelection(VisibleSelection(endingSelection().end(), Position(downstreamEnd.node(), maxDeepOffset(downstreamEnd.node())), DOWNSTREAM));
                 typingAddedToOpenCommand();
                 return;
@@ -499,10 +499,10 @@ void TypingCommand::forwardDeleteKeyPressed(TextGranularity granularity, bool ki
                 else {
                     int extraCharacters;
                     if (selectionToDelete.start().node() == selectionToDelete.end().node())
-                        extraCharacters = selectionToDelete.end().offset() - selectionToDelete.start().offset();
+                        extraCharacters = selectionToDelete.end().m_offset - selectionToDelete.start().m_offset;
                     else
-                        extraCharacters = selectionToDelete.end().offset();
-                    extent = Position(extent.node(), extent.offset() + extraCharacters);
+                        extraCharacters = selectionToDelete.end().m_offset;
+                    extent = Position(extent.node(), extent.m_offset + extraCharacters);
                 }
                 selectionAfterUndo.setWithoutValidation(startingSelection().start(), extent);
             }
index 5799ff4f631f83f4208511c4f349229d3b82ac07..495c8d8e7bffb766821912c7d45baa9fbab02dcd 100644 (file)
@@ -518,7 +518,7 @@ UChar VisiblePosition::characterAfter() const
     if (!node || !node->isTextNode())
         return 0;
     Text* textNode = static_cast<Text*>(pos.node());
-    int offset = pos.offset();
+    int offset = pos.m_offset;
     if ((unsigned)offset >= textNode->length())
         return 0;
     return textNode->data()[offset];
@@ -574,7 +574,7 @@ void VisiblePosition::debugPosition(const char* msg) const
     if (isNull())
         fprintf(stderr, "Position [%s]: null\n", msg);
     else
-        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, m_deepPosition.node()->nodeName().utf8().data(), m_deepPosition.node(), m_deepPosition.offset());
+        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, m_deepPosition.node()->nodeName().utf8().data(), m_deepPosition.node(), m_deepPosition.m_offset);
 }
 
 #ifndef NDEBUG
@@ -598,7 +598,7 @@ PassRefPtr<Range> makeRange(const VisiblePosition &start, const VisiblePosition
     
     Position s = rangeCompliantEquivalent(start);
     Position e = rangeCompliantEquivalent(end);
-    return Range::create(s.node()->document(), s.node(), s.offset(), e.node(), e.offset());
+    return Range::create(s.node()->document(), s.node(), s.m_offset, e.node(), e.m_offset);
 }
 
 VisiblePosition startVisiblePosition(const Range *r, EAffinity affinity)
@@ -619,7 +619,7 @@ bool setStart(Range *r, const VisiblePosition &visiblePosition)
         return false;
     Position p = rangeCompliantEquivalent(visiblePosition);
     int code = 0;
-    r->setStart(p.node(), p.offset(), code);
+    r->setStart(p.node(), p.m_offset, code);
     return code == 0;
 }
 
@@ -629,7 +629,7 @@ bool setEnd(Range *r, const VisiblePosition &visiblePosition)
         return false;
     Position p = rangeCompliantEquivalent(visiblePosition);
     int code = 0;
-    r->setEnd(p.node(), p.offset(), code);
+    r->setEnd(p.node(), p.m_offset, code);
     return code == 0;
 }
 
index b99f41c271ea2e4d6ec2edb58e76eb293c411298..f263cdeff8f3887c20729d665d5d1cf3bde9e246 100644 (file)
@@ -169,7 +169,7 @@ PassRefPtr<Range> VisibleSelection::toNormalizedRange() const
         ASSERT(isRange());
         s = m_start.downstream();
         e = m_end.upstream();
-        if (Range::compareBoundaryPoints(s.node(), s.offset(), e.node(), e.offset()) > 0) {
+        if (Range::compareBoundaryPoints(s.node(), s.m_offset, e.node(), e.m_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.
             Position tmp = s;
@@ -213,7 +213,7 @@ static PassRefPtr<Range> makeSearchRange(const Position& pos)
 
     Position start(rangeCompliantEquivalent(pos));
     searchRange->selectNodeContents(boundary, ec);
-    searchRange->setStart(start.node(), start.offset(), ec);
+    searchRange->setStart(start.node(), start.m_offset, ec);
 
     ASSERT(!ec);
     if (ec)
@@ -588,13 +588,13 @@ void VisibleSelection::debugPosition() const
 
     if (m_start == m_end) {
         Position pos = m_start;
-        fprintf(stderr, "pos:        %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.offset());
+        fprintf(stderr, "pos:        %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.m_offset);
     } else {
         Position pos = m_start;
-        fprintf(stderr, "start:      %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.offset());
+        fprintf(stderr, "start:      %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.m_offset);
         fprintf(stderr, "-----------------------------------\n");
         pos = m_end;
-        fprintf(stderr, "end:        %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.offset());
+        fprintf(stderr, "end:        %s %p:%d\n", pos.node()->nodeName().utf8().data(), pos.node(), pos.m_offset);
         fprintf(stderr, "-----------------------------------\n");
     }
 
@@ -628,7 +628,7 @@ void VisibleSelection::showTreeForThis() const
 {
     if (start().node()) {
         start().node()->showTreeAndMark(start().node(), "S", end().node(), "E");
-        fprintf(stderr, "start offset: %d, end offset: %d\n", start().offset(), end().offset());
+        fprintf(stderr, "start offset: %d, end offset: %d\n", start().m_offset, end().m_offset);
     }
 }
 
index 507e8c0417ed756ec3202363855b2f799cb3b0c5..37a6db160978095de0c43f1655967d8ccdcb305e 100644 (file)
@@ -98,8 +98,8 @@ int comparePositions(const Position& a, const Position& b)
     ASSERT(nodeA);
     Node* nodeB = b.node();
     ASSERT(nodeB);
-    int offsetA = a.offset();
-    int offsetB = b.offset();
+    int offsetA = a.m_offset;
+    int offsetB = b.m_offset;
 
     Node* shadowAncestorA = nodeA->shadowAncestorNode();
     if (shadowAncestorA == nodeA)
@@ -321,17 +321,17 @@ Position rangeCompliantEquivalent(const Position& pos)
 
     Node* node = pos.node();
 
-    if (pos.offset() <= 0) {
+    if (pos.m_offset <= 0) {
         if (node->parentNode() && (editingIgnoresContent(node) || isTableElement(node)))
             return positionBeforeNode(node);
         return Position(node, 0);
     }
 
     if (node->offsetInCharacters())
-        return Position(node, min(node->maxCharacterOffset(), pos.offset()));
+        return Position(node, min(node->maxCharacterOffset(), pos.m_offset));
 
     int maxCompliantOffset = node->childNodeCount();
-    if (pos.offset() > maxCompliantOffset) {
+    if (pos.m_offset > maxCompliantOffset) {
         if (node->parentNode())
             return positionAfterNode(node);
 
@@ -341,12 +341,12 @@ Position rangeCompliantEquivalent(const Position& pos)
     } 
 
     // Editing should never generate positions like this.
-    if ((pos.offset() < maxCompliantOffset) && editingIgnoresContent(node)) {
+    if ((pos.m_offset < maxCompliantOffset) && editingIgnoresContent(node)) {
         ASSERT_NOT_REACHED();
         return node->parentNode() ? positionBeforeNode(node) : Position(node, 0);
     }
     
-    if (pos.offset() == maxCompliantOffset && (editingIgnoresContent(node) || isTableElement(node)))
+    if (pos.m_offset == maxCompliantOffset && (editingIgnoresContent(node) || isTableElement(node)))
         return positionAfterNode(node);
     
     return Position(pos);
@@ -541,7 +541,7 @@ Position positionOutsideContainingSpecialElement(const Position &pos, Node **con
 Node* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 {
     Position upstream(visiblePosition.deepEquivalent().upstream());
-    if (upstream.node() && upstream.node()->renderer() && upstream.node()->renderer()->isTable() && upstream.offset() == maxDeepOffset(upstream.node()))
+    if (upstream.node() && upstream.node()->renderer() && upstream.node()->renderer()->isTable() && upstream.m_offset == maxDeepOffset(upstream.node()))
         return upstream.node();
     
     return 0;
@@ -550,7 +550,7 @@ Node* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 Node* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
 {
     Position downstream(visiblePosition.deepEquivalent().downstream());
-    if (downstream.node() && downstream.node()->renderer() && downstream.node()->renderer()->isTable() && downstream.offset() == 0)
+    if (downstream.node() && downstream.node()->renderer() && downstream.node()->renderer()->isTable() && downstream.m_offset == 0)
         return downstream.node();
     
     return 0;
index 5ba9c4a6cc2c981070c5495c3a7ac8412afd0e1f..3b88f11537ffd6996535d8c057fcc2b72de52dec 100644 (file)
@@ -63,8 +63,8 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
     RefPtr<Range> searchRange = Range::create(d);
     
     int exception = 0;
-    searchRange->setStart(start.node(), start.offset(), exception);
-    searchRange->setEnd(end.node(), end.offset(), exception);
+    searchRange->setStart(start.node(), start.m_offset, exception);
+    searchRange->setEnd(end.node(), end.m_offset, exception);
     
     ASSERT(!exception);
     if (exception)
@@ -134,7 +134,7 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
     Position start(rangeCompliantEquivalent(pos));
     ExceptionCode ec = 0;
     searchRange->selectNodeContents(boundary, ec);
-    searchRange->setStart(start.node(), start.offset(), ec);
+    searchRange->setStart(start.node(), start.m_offset, ec);
     TextIterator it(searchRange.get(), true);
     Vector<UChar, 1024> string;
     unsigned next = 0;
@@ -286,7 +286,7 @@ static VisiblePosition startPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.offset() == 0)
+        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.m_offset == 0)
             return positionAvoidingFirstPositionInTable(c);
         
         return VisiblePosition();
@@ -333,7 +333,7 @@ VisiblePosition startOfLine(const VisiblePosition& c)
         // greater than the input position.  This fix is to account for the discrepancy between lines with webkit-line-break:after-white-space 
         // style versus lines without that style, which would break before a space by default. 
         Position p = visPos.deepEquivalent();
-        if (p.offset() > c.deepEquivalent().offset() && p.node()->isSameNode(c.deepEquivalent().node())) {
+        if (p.m_offset > c.deepEquivalent().m_offset && p.node()->isSameNode(c.deepEquivalent().node())) {
             visPos = c.previous();
             if (visPos.isNull())
                 return VisiblePosition();
@@ -354,7 +354,7 @@ static VisiblePosition endPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.offset() == 0)
+        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.m_offset == 0)
             return c;
         return VisiblePosition();
     }
@@ -571,7 +571,7 @@ VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, int x)
         // Need to move forward to next containing editable block in this root editable
         // block and find the first root line box in that block.
         Node* startBlock = enclosingBlock(node);
-        Node* n = nextLeafWithSameEditability(node, p.offset());
+        Node* n = nextLeafWithSameEditability(node, p.m_offset);
         while (n && startBlock == enclosingBlock(n))
             n = nextLeafWithSameEditability(n);
         while (n) {
@@ -679,13 +679,13 @@ VisiblePosition startOfParagraph(const VisiblePosition &c)
     if (startNode->renderer()
         && ((startNode->renderer()->isTable() && !startNode->renderer()->isInline())
             || startNode->renderer()->isHR())
-        && p.offset() == maxDeepOffset(startNode))
+        && p.m_offset == maxDeepOffset(startNode))
         return VisiblePosition(Position(startNode, 0));
 
     Node* startBlock = enclosingBlock(startNode);
 
     Node *node = startNode;
-    int offset = p.offset();
+    int offset = p.m_offset;
 
     Node *n = startNode;
     while (n) {
@@ -742,14 +742,14 @@ VisiblePosition endOfParagraph(const VisiblePosition &c)
     if (startNode->renderer()
         && ((startNode->renderer()->isTable() && !startNode->renderer()->isInline())
             || startNode->renderer()->isHR())
-        && p.offset() == 0)
+        && p.m_offset == 0)
         return VisiblePosition(Position(startNode, maxDeepOffset(startNode)));
     
     Node* startBlock = enclosingBlock(startNode);
     Node *stayInsideBlock = startBlock;
     
     Node *node = startNode;
-    int offset = p.offset();
+    int offset = p.m_offset;
 
     Node *n = startNode;
     while (n) {
index 87d1138a0759d32b023cd7248134eb56af6286f9..c6e07950bb5e11e5e84efad35a42572a68186cd7 100644 (file)
@@ -404,7 +404,7 @@ static VisiblePosition updateAXLineStartForVisiblePosition(const VisiblePosition
         if (!p.node())
             break;
         renderer = p.node()->renderer();
-        if (!renderer || renderer->isRenderBlock() && !p.offset())
+        if (!renderer || renderer->isRenderBlock() && !p.m_offset)
             break;
         InlineBox* box;
         int ignoredCaretOffset;
index 0f652a3f6674bd50f32506dbc1f71cbfcef995d7..10d78aad9d875a9f77be31e8c303896e980749c8 100644 (file)
@@ -1687,7 +1687,7 @@ int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& po
     ExceptionCode ec = 0;
     RefPtr<Range> range = Range::create(m_renderer->document());
     range->setStart(node, 0, ec);
-    range->setEnd(indexPosition.node(), indexPosition.offset(), ec);
+    range->setEnd(indexPosition.node(), indexPosition.m_offset, ec);
     return TextIterator::rangeLength(range.get());
 }
 
index deabd95ce1659054f10ec732c09371c3171f79b8..014eceb46e75a2e6ceb15493ad89e5830efee689 100644 (file)
@@ -82,14 +82,14 @@ int DOMSelection::anchorOffset() const
     const VisibleSelection& selection = m_frame->selection()->selection();
     Position anchor = selection.isBaseFirst() ? selection.start() : selection.end();
     anchor = rangeCompliantEquivalent(anchor);
-    return anchor.offset();
+    return anchor.m_offset;
 }
 
 int DOMSelection::baseOffset() const
 {
     if (!m_frame)
         return 0;
-    return rangeCompliantEquivalent(m_frame->selection()->selection().base()).offset();
+    return rangeCompliantEquivalent(m_frame->selection()->selection().base()).m_offset;
 }
 
 Node* DOMSelection::focusNode() const
@@ -118,14 +118,14 @@ int DOMSelection::focusOffset() const
     const VisibleSelection& selection = m_frame->selection()->selection();
     Position focus = selection.isBaseFirst() ? selection.end() : selection.start();
     focus = rangeCompliantEquivalent(focus);
-    return focus.offset();
+    return focus.m_offset;
 }
 
 int DOMSelection::extentOffset() const
 {
     if (!m_frame)
         return 0;
-    return rangeCompliantEquivalent(m_frame->selection()->selection().extent()).offset();
+    return rangeCompliantEquivalent(m_frame->selection()->selection().extent()).m_offset;
 }
 
 bool DOMSelection::isCollapsed() const
index 54fc035bb2db11ab0820cf08044ffa33e000cc46..89817ba6bb7d87232c1a108a3530b6d77ad32dbe 100644 (file)
@@ -307,7 +307,7 @@ bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestR
         // was created right-to-left
         Position start = newSelection.start();
         Position end = newSelection.end();
-        short before = Range::compareBoundaryPoints(pos.node(), pos.offset(), start.node(), start.offset());
+        short before = Range::compareBoundaryPoints(pos.node(), pos.m_offset, start.node(), start.m_offset);
         if (before <= 0)
             newSelection = VisibleSelection(pos, end);
         else
index df1c77ff80c80f3ca637b51f2f113ee5e4fef1ac..13b5682bb0931a43fc053a00bdc9357f0f229a01 100644 (file)
@@ -648,7 +648,7 @@ void Frame::selectionLayoutChanged()
         if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
             RenderObject *startRenderer = startPos.node()->renderer();
             RenderObject *endRenderer = endPos.node()->renderer();
-            view->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
+            view->setSelection(startRenderer, startPos.m_offset, endRenderer, endPos.m_offset);
         }
     }
 }
index 1e5223352a38b90ecd66dde9814bd4de1c5fb94f..32d8290bc9c223f9d8070926aeac6a3aa2d44f4a 100644 (file)
@@ -293,7 +293,7 @@ int RenderTextControl::indexForVisiblePosition(const VisiblePosition& pos)
     RefPtr<Range> range = Range::create(document());
     range->setStart(m_innerText.get(), 0, ec);
     ASSERT(!ec);
-    range->setEnd(indexPosition.node(), indexPosition.offset(), ec);
+    range->setEnd(indexPosition.node(), indexPosition.m_offset, ec);
     ASSERT(!ec);
     return TextIterator::rangeLength(range.get());
 }
index e73fefb6972095c723a9d4a6999b9851435bed13..2350491e7601d8a56252a20acd84cc00c813f38a 100644 (file)
@@ -518,13 +518,13 @@ static void writeSelection(TextStream& ts, const RenderObject* o)
 
     VisibleSelection selection = frame->selection()->selection();
     if (selection.isCaret()) {
-        ts << "caret: position " << selection.start().offset() << " of " << nodePosition(selection.start().node());
+        ts << "caret: position " << selection.start().m_offset << " of " << nodePosition(selection.start().node());
         if (selection.affinity() == UPSTREAM)
             ts << " (upstream affinity)";
         ts << "\n";
     } else if (selection.isRange())
-        ts << "selection start: position " << selection.start().offset() << " of " << nodePosition(selection.start().node()) << "\n"
-           << "selection end:   position " << selection.end().offset() << " of " << nodePosition(selection.end().node()) << "\n";
+        ts << "selection start: position " << selection.start().m_offset << " of " << nodePosition(selection.start().node()) << "\n"
+           << "selection end:   position " << selection.end().m_offset << " of " << nodePosition(selection.end().node()) << "\n";
 }
 
 String externalRepresentation(RenderObject* o)