WebCore/ChangeLog

 12009-09-16 Enrica Casucci <enrica@apple.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Reorganizing helper functions in htmlediting.h to group them by type of object they return/operate upon.
 6 https://bugs.webkit.org/show_bug.cgi?id=29319
 7
 8 * editing/IndentOutdentCommand.cpp:
 9 Removed implementation of isAtUnsplittableElement.
 10
 11 * editing/IndentOutdentCommand.h:
 12 Removed member function isAtUnsplittableElement, because it was not class specific and belonged logically among the helper functions.
 13
 14 * editing/htmlediting.cpp:
 15 (WebCore::isAtUnsplittableElement): added.The code has been taken from IndentOutdentCommand.
 16
 17 * editing/htmlediting.h:
 18 Reordered functions to group them by type of object returned or operate upon.
 19 Added comments.
 20 Added isAtUnsplittableElement declaration.
 21
 22
1232009-09-16 Geoffrey Garen <ggaren@apple.com>
224
325 Reviewed by Sam Weinig and Anders Carlsson.
48447

WebCore/editing/IndentOutdentCommand.cpp

@@void IndentOutdentCommand::indentIntoBlo
121121 targetBlockquote = 0;
122122}
123123
124 bool IndentOutdentCommand::isAtUnsplittableElement(const Position& pos) const
125 {
126  Node* node = pos.node();
127  return node == editableRootForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell);
128 }
129 
130124// Enclose all nodes between start and end by newParent, which is a sibling node of nodes between start and end
131125// FIXME: moveParagraph is overly complicated. We need to clean up moveParagraph so that it uses appendParagraphIntoNode
132126// or prepare more specialized functions and delete moveParagraph
48447

WebCore/editing/IndentOutdentCommand.h

@@private:
4646 virtual void doApply();
4747 virtual EditAction editingAction() const { return m_typeOfAction == Indent ? EditActionIndent : EditActionOutdent; }
4848
49  // FIXME: Does this belong in htmlediting.cpp?
50  bool isAtUnsplittableElement(const Position&) const;
5149 void appendParagraphIntoNode(const VisiblePosition& start, const VisiblePosition& end, Node* newParent);
5250 void removeUnnecessaryLineBreakAt(const Position& endOfParagraph);
5351
48447

WebCore/editing/htmlediting.cpp

@@bool isEditablePosition(const Position&
183183 return node->isContentEditable();
184184}
185185
 186bool isAtUnsplittableElement(const Position& pos)
 187{
 188 Node* node = pos.node();
 189 return (node == editableRootForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 190}
 191
 192
186193bool isRichlyEditablePosition(const Position& p)
187194{
188195 Node* node = p.node();
48447

WebCore/editing/htmlediting.h

@@class String;
4343class VisiblePosition;
4444class VisibleSelection;
4545
46 Position rangeCompliantEquivalent(const Position&);
47 Position rangeCompliantEquivalent(const VisiblePosition&);
 46
 47// This file contains a set of helper functions used by the editing commands
 48
 49// -------------------------------------------------------------------------
 50// Node
 51// -------------------------------------------------------------------------
 52
 53// Functions returning Node
 54
 55Node* highestAncestor(Node*);
 56Node* highestEditableRoot(const Position&);
 57Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*));
 58Node* lowestEditableAncestor(Node*);
 59
 60Node* enclosingBlock(Node*);
 61Node* enclosingTableCell(const Position&);
 62Node* enclosingEmptyListItem(const VisiblePosition&);
 63Node* enclosingAnchorElement(const Position&);
 64Node* enclosingNodeWithTag(const Position&, const QualifiedName&);
 65Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), bool onlyReturnEditableNodes = true);
 66
 67Node* tabSpanNode(const Node*);
 68Node* nearestMailBlockquote(const Node*);
 69Node* isLastPositionBeforeTable(const VisiblePosition&);
 70Node* isFirstPositionAfterTable(const VisiblePosition&);
 71
 72// offset functions on Node
 73
4874int lastOffsetForEditing(const Node*);
49 bool isAtomicNode(const Node*);
 75int caretMinOffset(const Node*);
 76int caretMaxOffset(const Node*);
 77
 78// boolean functions on Node
 79
5080bool editingIgnoresContent(const Node*);
5181bool canHaveChildrenForEditing(const Node*);
52 Node* highestEditableRoot(const Position&);
53 VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
54 VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
55 int comparePositions(const Position&, const Position&);
56 int comparePositions(const VisiblePosition&, const VisiblePosition&);
57 Node* lowestEditableAncestor(Node*);
 82bool isAtomicNode(const Node*);
 83bool isBlock(const Node*);
 84bool isSpecialElement(const Node*);
 85bool isTabSpanNode(const Node*);
 86bool isTabSpanTextNode(const Node*);
 87bool isMailBlockquote(const Node*);
 88bool isTableElement(Node*);
 89bool isTableCell(const Node*);
 90bool isTableStructureNode(const Node*);
 91bool isListElement(Node*);
 92bool isNodeRendered(const Node*);
 93bool isNodeVisiblyContainedWithin(Node*, const Range*);
 94
 95
 96// -------------------------------------------------------------------------
 97// Position
 98// -------------------------------------------------------------------------
 99
 100// Functions returning Position
 101
 102Position rangeCompliantEquivalent(const Position&);
 103Position rangeCompliantEquivalent(const VisiblePosition&);
 104
58105Position nextCandidate(const Position&);
59 Position nextVisuallyDistinctCandidate(const Position&);
60106Position previousCandidate(const Position&);
 107
 108Position nextVisuallyDistinctCandidate(const Position&);
61109Position previousVisuallyDistinctCandidate(const Position&);
62 bool isEditablePosition(const Position&);
63 bool isRichlyEditablePosition(const Position&);
64 Element* editableRootForPosition(const Position&);
65 Element* unsplittableElementForPosition(const Position&);
66 bool isBlock(const Node*);
67 Node* enclosingBlock(Node*);
68 
69 String stringWithRebalancedWhitespace(const String&, bool, bool);
70 const String& nonBreakingSpaceString();
71 
72 //------------------------------------------------------------------------------------------
73 
74110
 111Position positionBeforeTabSpan(const Position&);
 112Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
 113Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
 114Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
 115
75116// Position creation functions are inline to prevent ref-churn.
76117// Other Position creation functions are in Position.h
77118// but these depend on lastOffsetForEditing which is defined in htmlediting.h.

@@inline Position lastDeepEditingPositionF
91132 ASSERT(anchorNode);
92133 return Position(anchorNode, lastOffsetForEditing(anchorNode));
93134}
 135
 136// comparision functions on Position
 137
 138int comparePositions(const Position&, const Position&);
94139
 140// boolean functions on Position
 141
 142bool isEditablePosition(const Position&);
 143bool isRichlyEditablePosition(const Position&);
 144bool isFirstVisiblePositionInSpecialElement(const Position&);
 145bool isLastVisiblePositionInSpecialElement(const Position&);
 146bool lineBreakExistsAtPosition(const Position&);
 147bool isVisiblyAdjacent(const Position& first, const Position& second);
 148bool isAtUnsplittableElement(const Position&);
 149
 150unsigned numEnclosingMailBlockquotes(const Position&);
 151
 152// -------------------------------------------------------------------------
 153// VisiblePosition
 154// -------------------------------------------------------------------------
 155
 156// Functions returning VisiblePosition
 157
 158VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
 159VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
95160VisiblePosition visiblePositionBeforeNode(Node*);
96161VisiblePosition visiblePositionAfterNode(Node*);
 162
 163bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
 164
 165int comparePositions(const VisiblePosition&, const VisiblePosition&);
 166int indexForVisiblePosition(const VisiblePosition&);
 167
 168// -------------------------------------------------------------------------
 169// Range
 170// -------------------------------------------------------------------------
 171
 172// Functions returning Range
 173
97174PassRefPtr<Range> createRange(PassRefPtr<Document>, const VisiblePosition& start, const VisiblePosition& end, ExceptionCode&);
98175PassRefPtr<Range> extendRangeToWrappingNodes(PassRefPtr<Range> rangeToExtend, const Range* maximumRange, const Node* rootNode);
99 
100176PassRefPtr<Range> avoidIntersectionWithNode(const Range*, Node*);
101 VisibleSelection avoidIntersectionWithNode(const VisibleSelection&, Node*);
102 
103 bool isSpecialElement(const Node*);
104 bool validBlockTag(const AtomicString&);
105177
 178// -------------------------------------------------------------------------
 179// HTMLElement
 180// -------------------------------------------------------------------------
 181
 182// Functions returning HTMLElement
 183
106184PassRefPtr<HTMLElement> createDefaultParagraphElement(Document*);
107185PassRefPtr<HTMLElement> createBreakElement(Document*);
108186PassRefPtr<HTMLElement> createOrderedListElement(Document*);

@@PassRefPtr<HTMLElement> createListItemEl
111189PassRefPtr<HTMLElement> createHTMLElement(Document*, const QualifiedName&);
112190PassRefPtr<HTMLElement> createHTMLElement(Document*, const AtomicString&);
113191
114 bool isTabSpanNode(const Node*);
115 bool isTabSpanTextNode(const Node*);
116 Node* tabSpanNode(const Node*);
117 Position positionBeforeTabSpan(const Position&);
 192HTMLElement* enclosingList(Node*);
 193HTMLElement* outermostEnclosingList(Node*);
 194HTMLElement* enclosingListChild(Node*);
 195
 196// -------------------------------------------------------------------------
 197// Element
 198// -------------------------------------------------------------------------
 199
 200// Functions returning Element
 201
118202PassRefPtr<Element> createTabSpanElement(Document*);
119203PassRefPtr<Element> createTabSpanElement(Document*, PassRefPtr<Node> tabTextNode);
120204PassRefPtr<Element> createTabSpanElement(Document*, const String& tabText);
121 
122 bool isNodeRendered(const Node*);
123 bool isMailBlockquote(const Node*);
124 Node* nearestMailBlockquote(const Node*);
125 unsigned numEnclosingMailBlockquotes(const Position&);
126 int caretMinOffset(const Node*);
127 int caretMaxOffset(const Node*);
128 
129 //------------------------------------------------------------------------------------------
130 
131 bool isTableStructureNode(const Node*);
132205PassRefPtr<Element> createBlockPlaceholderElement(Document*);
133206
134 bool isFirstVisiblePositionInSpecialElement(const Position&);
135 Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
136 bool isLastVisiblePositionInSpecialElement(const Position&);
137 Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
138 Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
139 Node* isLastPositionBeforeTable(const VisiblePosition&);
140 Node* isFirstPositionAfterTable(const VisiblePosition&);
 207Element* editableRootForPosition(const Position&);
 208Element* unsplittableElementForPosition(const Position&);
141209
142 Node* enclosingNodeWithTag(const Position&, const QualifiedName&);
143 Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), bool onlyReturnEditableNodes = true);
144 Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*));
145 Node* enclosingTableCell(const Position&);
146 Node* enclosingEmptyListItem(const VisiblePosition&);
147 Node* enclosingAnchorElement(const Position&);
148 bool isListElement(Node*);
149 HTMLElement* enclosingList(Node*);
150 HTMLElement* outermostEnclosingList(Node*);
151 HTMLElement* enclosingListChild(Node*);
 210// Boolean functions on Element
 211
152212bool canMergeLists(Element* firstList, Element* secondList);
153 Node* highestAncestor(Node*);
154 bool isTableElement(Node*);
155 bool isTableCell(const Node*);
156 
157 bool lineBreakExistsAtPosition(const Position&);
158 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
 213
 214// -------------------------------------------------------------------------
 215// VisibleSelection
 216// -------------------------------------------------------------------------
 217
 218// Functions returning VisibleSelection
159219
 220VisibleSelection avoidIntersectionWithNode(const VisibleSelection&, Node*);
160221VisibleSelection selectionForParagraphIteration(const VisibleSelection&);
 222
 223
 224// Miscellaneous functions on String
 225
 226String stringWithRebalancedWhitespace(const String&, bool, bool);
 227const String& nonBreakingSpaceString();
 228bool validBlockTag(const AtomicString&);
 229
161230
162 int indexForVisiblePosition(const VisiblePosition&);
163 bool isVisiblyAdjacent(const Position& first, const Position& second);
164 bool isNodeVisiblyContainedWithin(Node*, const Range*);
165231}
166232
167233#endif
48447