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