64c2d18e0e1cc924aa3e2c39098a3ab4543effaa
[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 #pragma once
27
28 #include "ContainerNode.h"
29 #include "EditingBoundary.h"
30 #include "TextAffinity.h"
31
32 namespace WTF {
33 class TextStream;
34 }
35
36 namespace WebCore {
37
38 class InlineBox;
39 class RenderElement;
40 class Text;
41
42 struct BoundaryPoint;
43
44 enum PositionMoveType {
45     CodePoint,       // Move by a single code point.
46     Character,       // Move to the next Unicode character break.
47     BackwardDeletion // Subject to platform conventions.
48 };
49
50 class Position {
51 public:
52     enum AnchorType {
53         PositionIsOffsetInAnchor,
54         PositionIsBeforeAnchor,
55         PositionIsAfterAnchor,
56         PositionIsBeforeChildren,
57         PositionIsAfterChildren,
58     };
59
60     Position()
61         : m_anchorType(PositionIsOffsetInAnchor)
62         , m_isLegacyEditingPosition(false)
63     {
64     }
65
66     // For creating before/after positions:
67     WEBCORE_EXPORT Position(Node* anchorNode, AnchorType);
68     Position(Text* textNode, unsigned offset);
69
70     // For creating offset positions:
71     // FIXME: This constructor should eventually go away. See bug 63040.
72     WEBCORE_EXPORT Position(Node* anchorNode, int offset, AnchorType);
73
74     AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
75
76     void clear() { m_anchorNode = nullptr; m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
77
78     // These are always DOM compliant values.  Editing positions like [img, 0] (aka [img, before])
79     // will return img->parentNode() and img->computeNodeIndex() from these functions.
80     WEBCORE_EXPORT Node* containerNode() const; // null for a before/after position anchored to a node with no parent
81     Text* containerText() const;
82
83     int computeOffsetInContainerNode() const;  // O(n) for before/after-anchored positions, O(1) for parent-anchored positions
84     WEBCORE_EXPORT Position parentAnchoredEquivalent() const; // Convenience method for DOM positions that also fixes up some positions for editing
85
86     // Inline O(1) access for Positions which callers know to be parent-anchored
87     int offsetInContainerNode() const
88     {
89         ASSERT(anchorType() == PositionIsOffsetInAnchor);
90         return m_offset;
91     }
92
93     // New code should not use this function.
94     int deprecatedEditingOffset() const
95     {
96         if (m_isLegacyEditingPosition || (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren))
97             return m_offset;
98         return offsetForPositionAfterAnchor();
99     }
100
101     RefPtr<Node> firstNode() const;
102
103     // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored
104     WEBCORE_EXPORT Node* computeNodeBeforePosition() const;
105     WEBCORE_EXPORT Node* computeNodeAfterPosition() const;
106
107     Node* anchorNode() const { return m_anchorNode.get(); }
108
109     // FIXME: Callers should be moved off of node(), node() is not always the container for this position.
110     // For nodes which editingIgnoresContent(node()) returns true, positions like [ignoredNode, 0]
111     // will be treated as before ignoredNode (thus node() is really after the position, not containing it).
112     Node* deprecatedNode() const { return m_anchorNode.get(); }
113
114     Document* document() const { return m_anchorNode ? &m_anchorNode->document() : nullptr; }
115     TreeScope* treeScope() const { return m_anchorNode ? &m_anchorNode->treeScope() : nullptr; }
116     Element* rootEditableElement() const
117     {
118         Node* container = containerNode();
119         return container ? container->rootEditableElement() : nullptr;
120     }
121
122     // These should only be used for PositionIsOffsetInAnchor positions, unless
123     // the position is a legacy editing position.
124     void moveToPosition(Node* anchorNode, int offset);
125     void moveToOffset(int offset);
126
127     bool isNull() const { return !m_anchorNode; }
128     bool isNotNull() const { return m_anchorNode; }
129     bool isOrphan() const { return m_anchorNode && !m_anchorNode->isConnected(); }
130
131     Element* element() const;
132
133     // Move up or down the DOM by one position.
134     // Offsets are computed using render text for nodes that have renderers - but note that even when
135     // using composed characters, the result may be inside a single user-visible character if a ligature is formed.
136     WEBCORE_EXPORT Position previous(PositionMoveType = CodePoint) const;
137     WEBCORE_EXPORT Position next(PositionMoveType = CodePoint) const;
138     static int uncheckedPreviousOffset(const Node*, int current);
139     static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
140     static int uncheckedNextOffset(const Node*, int current);
141
142     // These can be either inside or just before/after the node, depending on
143     // if the node is ignored by editing or not.
144     // FIXME: These should go away. They only make sense for legacy positions.
145     bool atFirstEditingPositionForNode() const;
146     bool atLastEditingPositionForNode() const;
147
148     // Returns true if the visually equivalent positions around have different editability
149     bool atEditingBoundary() const;
150     Node* parentEditingBoundary() const;
151     
152     bool atStartOfTree() const;
153     bool atEndOfTree() const;
154
155     // FIXME: Make these non-member functions and put them somewhere in the editing directory.
156     // These aren't really basic "position" operations. More high level editing helper functions.
157     WEBCORE_EXPORT Position leadingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
158     WEBCORE_EXPORT Position trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
159     
160     // These return useful visually equivalent positions.
161     WEBCORE_EXPORT Position upstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
162     WEBCORE_EXPORT Position downstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
163     
164     bool isCandidate() const;
165     bool isRenderedCharacter() const;
166     bool rendersInDifferentPosition(const Position&) const;
167
168     void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
169     void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
170
171     TextDirection primaryDirection() const;
172
173     // Returns the number of positions that exist between two positions.
174     static unsigned positionCountBetweenPositions(const Position&, const Position&);
175
176     static bool hasRenderedNonAnonymousDescendantsWithHeight(const RenderElement&);
177     static bool nodeIsUserSelectNone(Node*);
178 #if ENABLE(USERSELECT_ALL)
179     static bool nodeIsUserSelectAll(const Node*);
180     static Node* rootUserSelectAllForNode(Node*);
181 #else
182     static bool nodeIsUserSelectAll(const Node*) { return false; }
183     static Node* rootUserSelectAllForNode(Node*) { return 0; }
184 #endif
185
186     void debugPosition(const char* msg = "") const;
187
188 #if ENABLE(TREE_DEBUGGING)
189     void formatForDebugger(char* buffer, unsigned length) const;
190     void showAnchorTypeAndOffset() const;
191     void showTreeForThis() const;
192 #endif
193
194     // This is a tentative enhancement of operator== to account for different position types.
195     // FIXME: Combine this function with operator==
196     bool equals(const Position&) const;
197
198 private:
199     // For creating legacy editing positions: (Anchor type will be determined from editingIgnoresContent(node))
200     enum class LegacyEditingPositionFlag { On };
201     WEBCORE_EXPORT Position(Node* anchorNode, unsigned offset, LegacyEditingPositionFlag);
202     friend Position createLegacyEditingPosition(Node*, unsigned offset);
203
204     WEBCORE_EXPORT int offsetForPositionAfterAnchor() const;
205     
206     Position previousCharacterPosition(EAffinity) const;
207     Position nextCharacterPosition(EAffinity) const;
208
209     static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
210
211     RefPtr<Node> m_anchorNode;
212     // m_offset can be the offset inside m_anchorNode, or if editingIgnoresContent(m_anchorNode)
213     // returns true, then other places in editing will treat m_offset == 0 as "before the anchor"
214     // and m_offset > 0 as "after the anchor node".  See parentAnchoredEquivalent for more info.
215     int m_offset { 0 };
216     unsigned m_anchorType : 3;
217     bool m_isLegacyEditingPosition : 1;
218 };
219
220 Position createLegacyEditingPosition(const BoundaryPoint&);
221
222 inline Position createLegacyEditingPosition(Node* node, unsigned offset)
223 {
224     return { node, offset, Position::LegacyEditingPositionFlag::On };
225 }
226
227 inline bool operator==(const Position& a, const Position& b)
228 {
229     // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
230     // editing code will treat them as identical.
231     return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset() && a.anchorType() == b.anchorType();
232 }
233
234 inline bool operator!=(const Position& a, const Position& b)
235 {
236     return !(a == b);
237 }
238
239 inline bool operator<(const Position& a, const Position& b)
240 {
241     if (a.isNull() || b.isNull())
242         return false;
243     if (a.anchorNode() == b.anchorNode())
244         return a.deprecatedEditingOffset() < b.deprecatedEditingOffset();
245     return b.anchorNode()->compareDocumentPosition(*a.anchorNode()) == Node::DOCUMENT_POSITION_PRECEDING;
246 }
247
248 inline bool operator>(const Position& a, const Position& b) 
249 {
250     return !a.isNull() && !b.isNull() && a != b && b < a;
251 }
252
253 inline bool operator>=(const Position& a, const Position& b) 
254 {
255     return !a.isNull() && !b.isNull() && (a == b || a > b);
256 }
257
258 inline bool operator<=(const Position& a, const Position& b) 
259 {
260     return !a.isNull() && !b.isNull() && (a == b || a < b);
261 }
262
263 Position positionInParentBeforeNode(Node*);
264 Position positionInParentAfterNode(Node*);
265
266 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
267 inline Position positionBeforeNode(Node* anchorNode)
268 {
269     ASSERT(anchorNode);
270     return Position(anchorNode, Position::PositionIsBeforeAnchor);
271 }
272
273 inline Position positionAfterNode(Node* anchorNode)
274 {
275     ASSERT(anchorNode);
276     return Position(anchorNode, Position::PositionIsAfterAnchor);
277 }
278
279 inline int lastOffsetInNode(Node* node)
280 {
281     return node->isCharacterDataNode() ? node->maxCharacterOffset() : static_cast<int>(node->countChildNodes());
282 }
283
284 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to countChildNodes()
285 inline Position firstPositionInNode(Node* anchorNode)
286 {
287     if (anchorNode->isTextNode())
288         return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
289     return Position(anchorNode, Position::PositionIsBeforeChildren);
290 }
291
292 inline Position lastPositionInNode(Node* anchorNode)
293 {
294     if (anchorNode->isTextNode())
295         return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
296     return Position(anchorNode, Position::PositionIsAfterChildren);
297 }
298
299 inline int minOffsetForNode(Node* anchorNode, int offset)
300 {
301     if (anchorNode->isCharacterDataNode())
302         return std::min(offset, anchorNode->maxCharacterOffset());
303
304     int newOffset = 0;
305     for (Node* node = anchorNode->firstChild(); node && newOffset < offset; node = node->nextSibling())
306         newOffset++;
307     
308     return newOffset;
309 }
310
311 inline bool offsetIsBeforeLastNodeOffset(int offset, Node* anchorNode)
312 {
313     if (anchorNode->isCharacterDataNode())
314         return offset < anchorNode->maxCharacterOffset();
315
316     int currentOffset = 0;
317     for (Node* node = anchorNode->firstChild(); node && currentOffset < offset; node = node->nextSibling())
318         currentOffset++;
319     
320     
321     return offset < currentOffset;
322 }
323
324 RefPtr<Node> commonShadowIncludingAncestor(const Position&, const Position&);
325
326 WTF::TextStream& operator<<(WTF::TextStream&, const Position&);
327
328 } // namespace WebCore
329
330 #if ENABLE(TREE_DEBUGGING)
331 // Outside the WebCore namespace for ease of invocation from the debugger.
332 void showTree(const WebCore::Position&);
333 void showTree(const WebCore::Position*);
334 #endif