2 * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
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.
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.
29 #include "ContainerNode.h"
30 #include "EditingBoundary.h"
31 #include "TextAffinity.h"
32 #include "TextDirection.h"
33 #include <wtf/Assertions.h>
34 #include <wtf/PassRefPtr.h>
35 #include <wtf/RefPtr.h>
39 class CSSComputedStyleDeclaration;
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.
56 PositionIsOffsetInAnchor,
57 PositionIsBeforeAnchor,
58 PositionIsAfterAnchor,
59 PositionIsBeforeChildren,
60 PositionIsAfterChildren,
65 , m_anchorType(PositionIsOffsetInAnchor)
66 , m_isLegacyEditingPosition(false)
70 // For creating legacy editing positions: (Anchor type will be determined from editingIgnoresContent(node))
71 class LegacyEditingOffset {
73 int value() const { return m_offset; }
76 explicit LegacyEditingOffset(int offset) : m_offset(offset) { }
78 friend Position createLegacyEditingPosition(PassRefPtr<Node>, int offset);
82 Position(PassRefPtr<Node> anchorNode, LegacyEditingOffset);
84 // For creating before/after positions:
85 Position(PassRefPtr<Node> anchorNode, AnchorType);
86 Position(PassRefPtr<Text> textNode, unsigned offset);
88 // For creating offset positions:
89 // FIXME: This constructor should eventually go away. See bug 63040.
90 Position(PassRefPtr<Node> anchorNode, int offset, AnchorType);
92 AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
94 void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
96 // These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before])
97 // will return img->parentNode() and img->nodeIndex() from these functions.
98 Node* containerNode() const; // NULL for a before/after position anchored to a node with no parent
99 Text* containerText() const;
101 int computeOffsetInContainerNode() const; // O(n) for before/after-anchored positions, O(1) for parent-anchored positions
102 Position parentAnchoredEquivalent() const; // Convenience method for DOM positions that also fixes up some positions for editing
104 // Inline O(1) access for Positions which callers know to be parent-anchored
105 int offsetInContainerNode() const
107 ASSERT(anchorType() == PositionIsOffsetInAnchor);
111 // New code should not use this function.
112 int deprecatedEditingOffset() const
114 if (m_isLegacyEditingPosition || (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren))
116 return offsetForPositionAfterAnchor();
119 // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored
120 Node* computeNodeBeforePosition() const;
121 Node* computeNodeAfterPosition() const;
123 Node* anchorNode() const { return m_anchorNode.get(); }
125 // FIXME: Callers should be moved off of node(), node() is not always the container for this position.
126 // For nodes which editingIgnoresContent(node()) returns true, positions like [ignoredNode, 0]
127 // will be treated as before ignoredNode (thus node() is really after the position, not containing it).
128 Node* deprecatedNode() const { return m_anchorNode.get(); }
130 Document* document() const { return m_anchorNode ? m_anchorNode->document() : 0; }
131 Element* rootEditableElement() const
133 Node* container = containerNode();
134 return container ? container->rootEditableElement() : 0;
137 // These should only be used for PositionIsOffsetInAnchor positions, unless
138 // the position is a legacy editing position.
139 void moveToPosition(PassRefPtr<Node> anchorNode, int offset);
140 void moveToOffset(int offset);
142 bool isNull() const { return !m_anchorNode; }
143 bool isNotNull() const { return m_anchorNode; }
144 bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
146 Element* element() const;
147 PassRefPtr<CSSComputedStyleDeclaration> computedStyle() const;
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 Position previous(PositionMoveType = CodePoint) const;
153 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);
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;
164 // Returns true if the visually equivalent positions around have different editability
165 bool atEditingBoundary() const;
166 Node* parentEditingBoundary() const;
168 bool atStartOfTree() const;
169 bool atEndOfTree() const;
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 Position leadingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
174 Position trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
176 // These return useful visually equivalent positions.
177 Position upstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
178 Position downstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
180 bool isCandidate() const;
181 bool inRenderedText() const;
182 bool isRenderedCharacter() const;
183 bool rendersInDifferentPosition(const Position&) const;
185 void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
186 void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
188 TextDirection primaryDirection() const;
190 static bool hasRenderedNonAnonymousDescendantsWithHeight(RenderObject*);
191 static bool nodeIsUserSelectNone(Node*);
193 void debugPosition(const char* msg = "") const;
196 void formatForDebugger(char* buffer, unsigned length) const;
197 void showAnchorTypeAndOffset() const;
198 void showTreeForThis() const;
202 int offsetForPositionAfterAnchor() const;
204 int renderedOffset() const;
206 Position previousCharacterPosition(EAffinity) const;
207 Position nextCharacterPosition(EAffinity) const;
209 static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
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.
216 unsigned m_anchorType : 3;
217 bool m_isLegacyEditingPosition : 1;
220 inline Position createLegacyEditingPosition(PassRefPtr<Node> node, int offset)
222 return Position(node, Position::LegacyEditingOffset(offset));
225 inline bool operator==(const Position& a, const Position& b)
227 // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
228 // editing code will treat them as identical.
229 return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset() && a.anchorType() == b.anchorType();
232 inline bool operator!=(const Position& a, const Position& b)
237 // We define position creation functions to make callsites more readable.
238 // These are inline to prevent ref-churn when returning a Position object.
239 // If we ever add a PassPosition we can make these non-inline.
241 inline Position positionInParentBeforeNode(const Node* node)
243 // FIXME: This should ASSERT(node->parentNode())
244 // At least one caller currently hits this ASSERT though, which indicates
245 // that the caller is trying to make a position relative to a disconnected node (which is likely an error)
246 // Specifically, editing/deleting/delete-ligature-001.html crashes with ASSERT(node->parentNode())
247 return Position(node->nonShadowBoundaryParentNode(), node->nodeIndex(), Position::PositionIsOffsetInAnchor);
250 inline Position positionInParentAfterNode(const Node* node)
252 ASSERT(node->nonShadowBoundaryParentNode());
253 return Position(node->nonShadowBoundaryParentNode(), node->nodeIndex() + 1, Position::PositionIsOffsetInAnchor);
256 // positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
257 inline Position positionBeforeNode(Node* anchorNode)
260 return Position(anchorNode, Position::PositionIsBeforeAnchor);
263 inline Position positionAfterNode(Node* anchorNode)
266 return Position(anchorNode, Position::PositionIsAfterAnchor);
269 inline int lastOffsetInNode(Node* node)
271 return node->offsetInCharacters() ? node->maxCharacterOffset() : static_cast<int>(node->childNodeCount());
274 // firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to childNodeCount()
275 inline Position firstPositionInNode(Node* anchorNode)
277 if (anchorNode->isTextNode())
278 return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
279 return Position(anchorNode, Position::PositionIsBeforeChildren);
282 inline Position lastPositionInNode(Node* anchorNode)
284 if (anchorNode->isTextNode())
285 return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
286 return Position(anchorNode, Position::PositionIsAfterChildren);
289 } // namespace WebCore
292 // Outside the WebCore namespace for ease of invocation from gdb.
293 void showTree(const WebCore::Position&);
294 void showTree(const WebCore::Position*);