Home | History | Annotate | Download | only in dom 
      1 /*
      2  * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #ifndef Position_h
     27 #define Position_h
     28 
     29 #include "core/dom/ContainerNode.h"
     30 #include "core/editing/EditingBoundary.h"
     31 #include "core/editing/TextAffinity.h"
     32 #include "platform/text/TextDirection.h"
     33 #include "wtf/Assertions.h"
     34 #include "wtf/PassRefPtr.h"
     35 #include "wtf/RefPtr.h"
     36 
     37 namespace WebCore {
     38 
     39 class CSSComputedStyleDeclaration;
     40 class Element;
     41 class InlineBox;
     42 class Node;
     43 class Range;
     44 class RenderObject;
     45 class Text;
     46 
     47 enum PositionMoveType {
     48     CodePoint,       // Move by a single code point.
     49     Character,       // Move to the next Unicode character break.
     50     BackwardDeletion // Subject to platform conventions.
     51 };
     52 
     53 class Position {
     54     DISALLOW_ALLOCATION();
     55 public:
     56     enum AnchorType {
     57         PositionIsOffsetInAnchor,
     58         PositionIsBeforeAnchor,
     59         PositionIsAfterAnchor,
     60         PositionIsBeforeChildren,
     61         PositionIsAfterChildren,
     62     };
     63 
     64     Position()
     65         : m_offset(0)
     66         , m_anchorType(PositionIsOffsetInAnchor)
     67         , m_isLegacyEditingPosition(false)
     68     {
     69     }
     70 
     71     // For creating legacy editing positions: (Anchor type will be determined from editingIgnoresContent(node))
     72     class LegacyEditingOffset {
     73     public:
     74         int value() const { return m_offset; }
     75 
     76     private:
     77         explicit LegacyEditingOffset(int offset) : m_offset(offset) { }
     78 
     79         friend Position createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node>, int offset);
     80 
     81         int m_offset;
     82     };
     83     Position(PassRefPtrWillBeRawPtr<Node> anchorNode, LegacyEditingOffset);
     84 
     85     // For creating before/after positions:
     86     Position(PassRefPtrWillBeRawPtr<Node> anchorNode, AnchorType);
     87     Position(PassRefPtrWillBeRawPtr<Text> textNode, unsigned offset);
     88 
     89     // For creating offset positions:
     90     // FIXME: This constructor should eventually go away. See bug 63040.
     91     Position(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset, AnchorType);
     92 
     93     AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
     94 
     95     void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
     96 
     97     // These are always DOM compliant values.  Editing positions like [img, 0] (aka [img, before])
     98     // will return img->parentNode() and img->nodeIndex() from these functions.
     99     Node* containerNode() const; // NULL for a before/after position anchored to a node with no parent
    100     Text* containerText() const;
    101 
    102     int computeOffsetInContainerNode() const;  // O(n) for before/after-anchored positions, O(1) for parent-anchored positions
    103     Position parentAnchoredEquivalent() const; // Convenience method for DOM positions that also fixes up some positions for editing
    104 
    105     // Inline O(1) access for Positions which callers know to be parent-anchored
    106     int offsetInContainerNode() const
    107     {
    108         ASSERT(anchorType() == PositionIsOffsetInAnchor);
    109         return m_offset;
    110     }
    111 
    112     // New code should not use this function.
    113     int deprecatedEditingOffset() const
    114     {
    115         if (m_isLegacyEditingPosition || (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren))
    116             return m_offset;
    117         return offsetForPositionAfterAnchor();
    118     }
    119 
    120     // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored
    121     Node* computeNodeBeforePosition() const;
    122     Node* computeNodeAfterPosition() const;
    123 
    124     Node* anchorNode() const { return m_anchorNode.get(); }
    125 
    126     // FIXME: Callers should be moved off of node(), node() is not always the container for this position.
    127     // For nodes which editingIgnoresContent(node()) returns true, positions like [ignoredNode, 0]
    128     // will be treated as before ignoredNode (thus node() is really after the position, not containing it).
    129     Node* deprecatedNode() const { return m_anchorNode.get(); }
    130 
    131     Document* document() const { return m_anchorNode ? &m_anchorNode->document() : 0; }
    132     bool inDocument() const { return m_anchorNode && m_anchorNode->inDocument(); }
    133     Element* rootEditableElement() const
    134     {
    135         Node* container = containerNode();
    136         return container ? container->rootEditableElement() : 0;
    137     }
    138 
    139     // These should only be used for PositionIsOffsetInAnchor positions, unless
    140     // the position is a legacy editing position.
    141     void moveToPosition(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset);
    142     void moveToOffset(int offset);
    143 
    144     bool isNull() const { return !m_anchorNode; }
    145     bool isNotNull() const { return m_anchorNode; }
    146     bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
    147 
    148     Element* element() const;
    149     PassRefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyle() const;
    150 
    151     // Move up or down the DOM by one position.
    152     // Offsets are computed using render text for nodes that have renderers - but note that even when
    153     // using composed characters, the result may be inside a single user-visible character if a ligature is formed.
    154     Position previous(PositionMoveType = CodePoint) const;
    155     Position next(PositionMoveType = CodePoint) const;
    156     static int uncheckedPreviousOffset(const Node*, int current);
    157     static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
    158     static int uncheckedNextOffset(const Node*, int current);
    159 
    160     // These can be either inside or just before/after the node, depending on
    161     // if the node is ignored by editing or not.
    162     // FIXME: These should go away. They only make sense for legacy positions.
    163     bool atFirstEditingPositionForNode() const;
    164     bool atLastEditingPositionForNode() const;
    165 
    166     // Returns true if the visually equivalent positions around have different editability
    167     bool atEditingBoundary() const;
    168     Node* parentEditingBoundary() const;
    169 
    170     bool atStartOfTree() const;
    171     bool atEndOfTree() const;
    172 
    173     // FIXME: Make these non-member functions and put them somewhere in the editing directory.
    174     // These aren't really basic "position" operations. More high level editing helper functions.
    175     Position leadingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
    176     Position trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
    177 
    178     // These return useful visually equivalent positions.
    179     Position upstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
    180     Position downstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
    181 
    182     bool isCandidate() const;
    183     bool inRenderedText() const;
    184     bool isRenderedCharacter() const;
    185     bool rendersInDifferentPosition(const Position&) const;
    186 
    187     void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
    188     void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
    189 
    190     TextDirection primaryDirection() const;
    191 
    192     static bool hasRenderedNonAnonymousDescendantsWithHeight(RenderObject*);
    193     static bool nodeIsUserSelectNone(Node*);
    194     static bool nodeIsUserSelectAll(const Node*);
    195     static Node* rootUserSelectAllForNode(Node*);
    196 
    197     static ContainerNode* findParent(const Node*);
    198 
    199     void debugPosition(const char* msg = "") const;
    200 
    201 #ifndef NDEBUG
    202     void formatForDebugger(char* buffer, unsigned length) const;
    203     void showAnchorTypeAndOffset() const;
    204     void showTreeForThis() const;
    205 #endif
    206 
    207     void trace(Visitor*);
    208 
    209 private:
    210     int offsetForPositionAfterAnchor() const;
    211 
    212     int renderedOffset() const;
    213 
    214     Position previousCharacterPosition(EAffinity) const;
    215 
    216     static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
    217 
    218     RefPtrWillBeMember<Node> m_anchorNode;
    219     // m_offset can be the offset inside m_anchorNode, or if editingIgnoresContent(m_anchorNode)
    220     // returns true, then other places in editing will treat m_offset == 0 as "before the anchor"
    221     // and m_offset > 0 as "after the anchor node".  See parentAnchoredEquivalent for more info.
    222     int m_offset;
    223     unsigned m_anchorType : 3;
    224     bool m_isLegacyEditingPosition : 1;
    225 };
    226 
    227 inline Position createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node> node, int offset)
    228 {
    229     return Position(node, Position::LegacyEditingOffset(offset));
    230 }
    231 
    232 inline bool operator==(const Position& a, const Position& b)
    233 {
    234     // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
    235     // editing code will treat them as identical.
    236     return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset() && a.anchorType() == b.anchorType();
    237 }
    238 
    239 inline bool operator!=(const Position& a, const Position& b)
    240 {
    241     return !(a == b);
    242 }
    243 
    244 // We define position creation functions to make callsites more readable.
    245 // These are inline to prevent ref-churn when returning a Position object.
    246 // If we ever add a PassPosition we can make these non-inline.
    247 
    248 inline Position positionInParentBeforeNode(const Node& node)
    249 {
    250     // FIXME: This should ASSERT(node.parentNode())
    251     // At least one caller currently hits this ASSERT though, which indicates
    252     // that the caller is trying to make a position relative to a disconnected node (which is likely an error)
    253     // Specifically, editing/deleting/delete-ligature-001.html crashes with ASSERT(node->parentNode())
    254     return Position(node.parentNode(), node.nodeIndex(), Position::PositionIsOffsetInAnchor);
    255 }
    256 
    257 inline Position positionInParentAfterNode(const Node& node)
    258 {
    259     ASSERT(node.parentNode());
    260     return Position(node.parentNode(), node.nodeIndex() + 1, Position::PositionIsOffsetInAnchor);
    261 }
    262 
    263 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
    264 inline Position positionBeforeNode(Node* anchorNode)
    265 {
    266     ASSERT(anchorNode);
    267     return Position(anchorNode, Position::PositionIsBeforeAnchor);
    268 }
    269 
    270 inline Position positionAfterNode(Node* anchorNode)
    271 {
    272     ASSERT(anchorNode);
    273     return Position(anchorNode, Position::PositionIsAfterAnchor);
    274 }
    275 
    276 inline int lastOffsetInNode(Node* node)
    277 {
    278     return node->offsetInCharacters() ? node->maxCharacterOffset() : static_cast<int>(node->countChildren());
    279 }
    280 
    281 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to countChildren()
    282 inline Position firstPositionInNode(Node* anchorNode)
    283 {
    284     if (anchorNode->isTextNode())
    285         return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
    286     return Position(anchorNode, Position::PositionIsBeforeChildren);
    287 }
    288 
    289 inline Position lastPositionInNode(Node* anchorNode)
    290 {
    291     if (anchorNode->isTextNode())
    292         return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
    293     return Position(anchorNode, Position::PositionIsAfterChildren);
    294 }
    295 
    296 inline int minOffsetForNode(Node* anchorNode, int offset)
    297 {
    298     if (anchorNode->offsetInCharacters())
    299         return std::min(offset, anchorNode->maxCharacterOffset());
    300 
    301     int newOffset = 0;
    302     for (Node* node = anchorNode->firstChild(); node && newOffset < offset; node = node->nextSibling())
    303         newOffset++;
    304 
    305     return newOffset;
    306 }
    307 
    308 inline bool offsetIsBeforeLastNodeOffset(int offset, Node* anchorNode)
    309 {
    310     if (anchorNode->offsetInCharacters())
    311         return offset < anchorNode->maxCharacterOffset();
    312 
    313     int currentOffset = 0;
    314     for (Node* node = anchorNode->firstChild(); node && currentOffset < offset; node = node->nextSibling())
    315         currentOffset++;
    316 
    317 
    318     return offset < currentOffset;
    319 }
    320 
    321 class PositionWithAffinity {
    322     DISALLOW_ALLOCATION();
    323 public:
    324     PositionWithAffinity()
    325         : m_affinity(DOWNSTREAM)
    326     {
    327     }
    328 
    329     PositionWithAffinity(const Position& position, EAffinity affinity = DOWNSTREAM)
    330         : m_position(position)
    331         , m_affinity(affinity)
    332     {
    333     }
    334 
    335     EAffinity affinity() const { return m_affinity; }
    336     const Position& position() const { return m_position; }
    337 
    338     void trace(Visitor* visitor)
    339     {
    340         visitor->trace(m_position);
    341     }
    342 
    343 private:
    344     Position m_position;
    345     EAffinity m_affinity;
    346 };
    347 
    348 } // namespace WebCore
    349 
    350 #ifndef NDEBUG
    351 // Outside the WebCore namespace for ease of invocation from gdb.
    352 void showTree(const WebCore::Position&);
    353 void showTree(const WebCore::Position*);
    354 #endif
    355 
    356 #endif // Position_h
    357