Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / dom / Position.h
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 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 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 "ContainerNode.h"
30 #include "EditingBoundary.h"
31 #include "TextAffinity.h"
32 #include "TextFlags.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 RenderElement;
45 class RenderObject;
46 class Text;
47
48 enum PositionMoveType {
49     CodePoint,       // Move by a single code point.
50     Character,       // Move to the next Unicode character break.
51     BackwardDeletion // Subject to platform conventions.
52 };
53
54 class Position {
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(PassRefPtr<Node>, int offset);
80
81         int m_offset;
82     };
83     WEBCORE_EXPORT Position(PassRefPtr<Node> anchorNode, LegacyEditingOffset);
84
85     // For creating before/after positions:
86     WEBCORE_EXPORT Position(PassRefPtr<Node> anchorNode, AnchorType);
87     Position(PassRefPtr<Text> textNode, unsigned offset);
88
89     // For creating offset positions:
90     // FIXME: This constructor should eventually go away. See bug 63040.
91     WEBCORE_EXPORT Position(PassRefPtr<Node> anchorNode, int offset, AnchorType);
92
93     AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
94
95     void clear() { m_anchorNode = nullptr; 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->computeNodeIndex() from these functions.
99     WEBCORE_EXPORT 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     WEBCORE_EXPORT 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() : nullptr; }
132     Element* rootEditableElement() const
133     {
134         Node* container = containerNode();
135         return container ? container->rootEditableElement() : nullptr;
136     }
137
138     // These should only be used for PositionIsOffsetInAnchor positions, unless
139     // the position is a legacy editing position.
140     void moveToPosition(PassRefPtr<Node> anchorNode, int offset);
141     void moveToOffset(int offset);
142
143     bool isNull() const { return !m_anchorNode; }
144     bool isNotNull() const { return m_anchorNode; }
145     bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
146
147     Element* element() const;
148
149     // Move up or down the DOM by one position.
150     // Offsets are computed using render text for nodes that have renderers - but note that even when
151     // using composed characters, the result may be inside a single user-visible character if a ligature is formed.
152     WEBCORE_EXPORT Position previous(PositionMoveType = CodePoint) const;
153     WEBCORE_EXPORT Position next(PositionMoveType = CodePoint) const;
154     static int uncheckedPreviousOffset(const Node*, int current);
155     static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
156     static int uncheckedNextOffset(const Node*, int current);
157
158     // These can be either inside or just before/after the node, depending on
159     // if the node is ignored by editing or not.
160     // FIXME: These should go away. They only make sense for legacy positions.
161     bool atFirstEditingPositionForNode() const;
162     bool atLastEditingPositionForNode() const;
163
164     // Returns true if the visually equivalent positions around have different editability
165     bool atEditingBoundary() const;
166     Node* parentEditingBoundary() const;
167     
168     bool atStartOfTree() const;
169     bool atEndOfTree() const;
170
171     // FIXME: Make these non-member functions and put them somewhere in the editing directory.
172     // These aren't really basic "position" operations. More high level editing helper functions.
173     WEBCORE_EXPORT Position leadingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
174     WEBCORE_EXPORT Position trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
175     
176     // These return useful visually equivalent positions.
177     WEBCORE_EXPORT Position upstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
178     WEBCORE_EXPORT Position downstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
179     
180     bool isCandidate() const;
181     bool isRenderedCharacter() const;
182     bool rendersInDifferentPosition(const Position&) const;
183
184     void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
185     void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
186
187     TextDirection primaryDirection() const;
188
189     // Returns the number of positions that exist between two positions.
190     static unsigned positionCountBetweenPositions(const Position&, const Position&);
191
192     static bool hasRenderedNonAnonymousDescendantsWithHeight(const RenderElement&);
193     static bool nodeIsUserSelectNone(Node*);
194 #if ENABLE(USERSELECT_ALL)
195     static bool nodeIsUserSelectAll(const Node*);
196     static Node* rootUserSelectAllForNode(Node*);
197 #else
198     static bool nodeIsUserSelectAll(const Node*) { return false; }
199     static Node* rootUserSelectAllForNode(Node*) { return 0; }
200 #endif
201     static ContainerNode* findParent(const Node&);
202     
203     void debugPosition(const char* msg = "") const;
204
205 #if ENABLE(TREE_DEBUGGING)
206     void formatForDebugger(char* buffer, unsigned length) const;
207     void showAnchorTypeAndOffset() const;
208     void showTreeForThis() const;
209 #endif
210
211     // This is a tentative enhancement of operator== to account for different position types.
212     // FIXME: Combine this function with operator==
213     bool equals(const Position&) const;
214 private:
215     WEBCORE_EXPORT int offsetForPositionAfterAnchor() const;
216     
217     Position previousCharacterPosition(EAffinity) const;
218     Position nextCharacterPosition(EAffinity) const;
219
220     static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
221
222     RefPtr<Node> m_anchorNode;
223     // m_offset can be the offset inside m_anchorNode, or if editingIgnoresContent(m_anchorNode)
224     // returns true, then other places in editing will treat m_offset == 0 as "before the anchor"
225     // and m_offset > 0 as "after the anchor node".  See parentAnchoredEquivalent for more info.
226     int m_offset;
227     unsigned m_anchorType : 3;
228     bool m_isLegacyEditingPosition : 1;
229 };
230
231 inline Position createLegacyEditingPosition(PassRefPtr<Node> node, int offset)
232 {
233     return Position(node, Position::LegacyEditingOffset(offset));
234 }
235
236 inline bool operator==(const Position& a, const Position& b)
237 {
238     // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
239     // editing code will treat them as identical.
240     return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset() && a.anchorType() == b.anchorType();
241 }
242
243 inline bool operator!=(const Position& a, const Position& b)
244 {
245     return !(a == b);
246 }
247
248 inline bool operator<(const Position& a, const Position& b)
249 {
250     if (a.isNull() || b.isNull())
251         return false;
252     if (a.anchorNode() == b.anchorNode())
253         return a.deprecatedEditingOffset() < b.deprecatedEditingOffset();
254     return b.anchorNode()->compareDocumentPosition(a.anchorNode()) == Node::DOCUMENT_POSITION_PRECEDING;
255 }
256
257 inline bool operator>(const Position& a, const Position& b) 
258 {
259     return !a.isNull() && !b.isNull() && a != b && b < a;
260 }
261
262 inline bool operator>=(const Position& a, const Position& b) 
263 {
264     return !a.isNull() && !b.isNull() && (a == b || a > b);
265 }
266
267 inline bool operator<=(const Position& a, const Position& b) 
268 {
269     return !a.isNull() && !b.isNull() && (a == b || a < b);
270 }
271
272 // We define position creation functions to make callsites more readable.
273 // These are inline to prevent ref-churn when returning a Position object.
274 // If we ever add a PassPosition we can make these non-inline.
275
276 inline Position positionInParentBeforeNode(const Node* node)
277 {
278     ASSERT(node->parentNode());
279     return Position(node->parentNode(), node->computeNodeIndex(), Position::PositionIsOffsetInAnchor);
280 }
281
282 inline Position positionInParentAfterNode(const Node* node)
283 {
284     ASSERT(node->parentNode());
285     return Position(node->parentNode(), node->computeNodeIndex() + 1, Position::PositionIsOffsetInAnchor);
286 }
287
288 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
289 inline Position positionBeforeNode(Node* anchorNode)
290 {
291     ASSERT(anchorNode);
292     return Position(anchorNode, Position::PositionIsBeforeAnchor);
293 }
294
295 inline Position positionAfterNode(Node* anchorNode)
296 {
297     ASSERT(anchorNode);
298     return Position(anchorNode, Position::PositionIsAfterAnchor);
299 }
300
301 inline int lastOffsetInNode(Node* node)
302 {
303     return node->offsetInCharacters() ? node->maxCharacterOffset() : static_cast<int>(node->countChildNodes());
304 }
305
306 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to countChildNodes()
307 inline Position firstPositionInNode(Node* anchorNode)
308 {
309     if (anchorNode->isTextNode())
310         return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
311     return Position(anchorNode, Position::PositionIsBeforeChildren);
312 }
313
314 inline Position lastPositionInNode(Node* anchorNode)
315 {
316     if (anchorNode->isTextNode())
317         return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
318     return Position(anchorNode, Position::PositionIsAfterChildren);
319 }
320
321 inline int minOffsetForNode(Node* anchorNode, int offset)
322 {
323     if (anchorNode->offsetInCharacters())
324         return std::min(offset, anchorNode->maxCharacterOffset());
325
326     int newOffset = 0;
327     for (Node* node = anchorNode->firstChild(); node && newOffset < offset; node = node->nextSibling())
328         newOffset++;
329     
330     return newOffset;
331 }
332
333 inline bool offsetIsBeforeLastNodeOffset(int offset, Node* anchorNode)
334 {
335     if (anchorNode->offsetInCharacters())
336         return offset < anchorNode->maxCharacterOffset();
337
338     int currentOffset = 0;
339     for (Node* node = anchorNode->firstChild(); node && currentOffset < offset; node = node->nextSibling())
340         currentOffset++;
341     
342     
343     return offset < currentOffset;
344 }
345
346 } // namespace WebCore
347
348 #if ENABLE(TREE_DEBUGGING)
349 // Outside the WebCore namespace for ease of invocation from gdb.
350 void showTree(const WebCore::Position&);
351 void showTree(const WebCore::Position*);
352 #endif
353
354 #endif // Position_h