--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/dom/Position.h Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef Position_h
+#define Position_h
+
+#include "TextAffinity.h"
+#include "TextDirection.h"
+#include "Node.h" // for position creation functions
+#include <wtf/Assertions.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+
+class CSSComputedStyleDeclaration;
+class Element;
+class InlineBox;
+class Node;
+class Range;
+class RenderObject;
+
+enum PositionMoveType {
+ CodePoint, // Move by a single code point.
+ Character, // Move to the next Unicode character break.
+ BackwardDeletion // Subject to platform conventions.
+};
+
+class Position {
+public:
+ enum AnchorType {
+ PositionIsOffsetInAnchor,
+ PositionIsAfterAnchor,
+ PositionIsBeforeAnchor
+ };
+
+ enum EditingBoundaryCrossingRule {
+ CanCrossEditingBoundary,
+ CannotCrossEditingBoundary
+ };
+
+ Position()
+ : m_offset(0)
+ , m_anchorType(PositionIsOffsetInAnchor)
+ , m_isLegacyEditingPosition(false)
+ {
+ }
+
+ // For creating legacy editing positions: (Anchor type will be determined from editingIgnoresContent(node))
+ Position(PassRefPtr<Node> anchorNode, int offset);
+
+ // For creating before/after positions:
+ Position(PassRefPtr<Node> anchorNode, AnchorType);
+ // For creating offset positions:
+ Position(PassRefPtr<Node> anchorNode, int offset, AnchorType);
+
+ AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
+
+ void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
+
+ // These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before])
+ // will return img->parentNode() and img->nodeIndex() from these functions.
+ Node* containerNode() const; // NULL for a before/after position anchored to a node with no parent
+ int computeOffsetInContainerNode() const; // O(n) for before/after-anchored positions, O(1) for parent-anchored positions
+
+ // Inline O(1) access for Positions which callers know to be parent-anchored
+ int offsetInContainerNode() const
+ {
+ ASSERT(anchorType() == PositionIsOffsetInAnchor);
+ return m_offset;
+ }
+
+ // New code should not use this function.
+ int deprecatedEditingOffset() const
+ {
+ // This should probably ASSERT(m_isLegacyEditingPosition);
+ return m_offset;
+ }
+
+ // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored
+ Node* computeNodeBeforePosition() const;
+ Node* computeNodeAfterPosition() const;
+
+ Node* anchorNode() const { return m_anchorNode.get(); }
+
+ // FIXME: Callers should be moved off of node(), node() is not always the container for this position.
+ // For nodes which editingIgnoresContent(node()) returns true, positions like [ignoredNode, 0]
+ // will be treated as before ignoredNode (thus node() is really after the position, not containing it).
+ Node* node() const { return m_anchorNode.get(); }
+
+ // These should only be used for PositionIsOffsetInAnchor positions, unless
+ // the position is a legacy editing position.
+ void moveToPosition(PassRefPtr<Node> anchorNode, int offset);
+ void moveToOffset(int offset);
+
+ bool isNull() const { return !m_anchorNode; }
+ bool isNotNull() const { return m_anchorNode; }
+ bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
+
+ Element* element() const;
+ PassRefPtr<CSSComputedStyleDeclaration> computedStyle() const;
+
+ // Move up or down the DOM by one position.
+ // Offsets are computed using render text for nodes that have renderers - but note that even when
+ // using composed characters, the result may be inside a single user-visible character if a ligature is formed.
+ Position previous(PositionMoveType = CodePoint) const;
+ Position next(PositionMoveType = CodePoint) const;
+ static int uncheckedPreviousOffset(const Node*, int current);
+ static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
+ static int uncheckedNextOffset(const Node*, int current);
+
+ // These can be either inside or just before/after the node, depending on
+ // if the node is ignored by editing or not.
+ bool atFirstEditingPositionForNode() const;
+ bool atLastEditingPositionForNode() const;
+
+ // Returns true if the visually equivalent positions around have different editability
+ bool atEditingBoundary() const;
+
+ bool atStartOfTree() const;
+ bool atEndOfTree() const;
+
+ // FIXME: Make these non-member functions and put them somewhere in the editing directory.
+ // These aren't really basic "position" operations. More high level editing helper functions.
+ Position leadingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
+ Position trailingWhitespacePosition(EAffinity, bool considerNonCollapsibleWhitespace = false) const;
+
+ // These return useful visually equivalent positions.
+ Position upstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
+ Position downstream(EditingBoundaryCrossingRule = CannotCrossEditingBoundary) const;
+
+ bool isCandidate() const;
+ bool inRenderedText() const;
+ bool isRenderedCharacter() const;
+ bool rendersInDifferentPosition(const Position&) const;
+
+ void getInlineBoxAndOffset(EAffinity, InlineBox*&, int& caretOffset) const;
+ void getInlineBoxAndOffset(EAffinity, TextDirection primaryDirection, InlineBox*&, int& caretOffset) const;
+
+ TextDirection primaryDirection() const;
+
+ static bool hasRenderedNonAnonymousDescendantsWithHeight(RenderObject*);
+ static bool nodeIsUserSelectNone(Node*);
+
+ void debugPosition(const char* msg = "") const;
+
+#ifndef NDEBUG
+ void formatForDebugger(char* buffer, unsigned length) const;
+ void showTreeForThis() const;
+#endif
+
+private:
+ int renderedOffset() const;
+
+ Position previousCharacterPosition(EAffinity) const;
+ Position nextCharacterPosition(EAffinity) const;
+
+ static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
+
+ RefPtr<Node> m_anchorNode;
+ // m_offset can be the offset inside m_anchorNode, or if editingIgnoresContent(m_anchorNode)
+ // returns true, then other places in editing will treat m_offset == 0 as "before the anchor"
+ // and m_offset > 0 as "after the anchor node". See rangeCompliantEquivalent for more info.
+ int m_offset;
+ unsigned m_anchorType : 2;
+ bool m_isLegacyEditingPosition : 1;
+};
+
+inline bool operator==(const Position& a, const Position& b)
+{
+ // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
+ // editing code will treat them as identical.
+ return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset();
+}
+
+inline bool operator!=(const Position& a, const Position& b)
+{
+ return !(a == b);
+}
+
+// We define position creation functions to make callsites more readable.
+// These are inline to prevent ref-churn when returning a Position object.
+// If we ever add a PassPosition we can make these non-inline.
+
+inline Position positionInParentBeforeNode(const Node* node)
+{
+ // FIXME: This should ASSERT(node->parentNode())
+ // At least one caller currently hits this ASSERT though, which indicates
+ // that the caller is trying to make a position relative to a disconnected node (which is likely an error)
+ // Specifically, editing/deleting/delete-ligature-001.html crashes with ASSERT(node->parentNode())
+ return Position(node->parentNode(), node->nodeIndex(), Position::PositionIsOffsetInAnchor);
+}
+
+inline Position positionInParentAfterNode(const Node* node)
+{
+ ASSERT(node->parentNode());
+ return Position(node->parentNode(), node->nodeIndex() + 1, Position::PositionIsOffsetInAnchor);
+}
+
+// positionBeforeNode and positionAfterNode return neighbor-anchored positions, construction is O(1)
+inline Position positionBeforeNode(Node* anchorNode)
+{
+ ASSERT(anchorNode);
+ return Position(anchorNode, Position::PositionIsBeforeAnchor);
+}
+
+inline Position positionAfterNode(Node* anchorNode)
+{
+ ASSERT(anchorNode);
+ return Position(anchorNode, Position::PositionIsAfterAnchor);
+}
+
+inline int lastOffsetInNode(Node* node)
+{
+ return node->offsetInCharacters() ? node->maxCharacterOffset() : static_cast<int>(node->childNodeCount());
+}
+
+// firstPositionInNode and lastPositionInNode return parent-anchored positions, lastPositionInNode construction is O(n) due to childNodeCount()
+inline Position firstPositionInNode(Node* anchorNode)
+{
+ return Position(anchorNode, 0, Position::PositionIsOffsetInAnchor);
+}
+
+inline Position lastPositionInNode(Node* anchorNode)
+{
+ return Position(anchorNode, lastOffsetInNode(anchorNode), Position::PositionIsOffsetInAnchor);
+}
+
+} // namespace WebCore
+
+#ifndef NDEBUG
+// Outside the WebCore namespace for ease of invocation from gdb.
+void showTree(const WebCore::Position&);
+void showTree(const WebCore::Position*);
+#endif
+
+#endif // Position_h