Crash in InsertParagraphSeparatorCommand::doApply.
[WebKit-https.git] / Source / WebCore / editing / htmlediting.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 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 htmlediting_h
27 #define htmlediting_h
28
29 #include "EditingBoundary.h"
30 #include "Position.h"
31 #include "TextDirection.h"
32 #include <wtf/Forward.h>
33 #include <wtf/unicode/CharacterNames.h>
34
35 namespace WebCore {
36
37 class Document;
38 class Element;
39 class HTMLElement;
40 class HTMLTextFormControlElement;
41 class Node;
42 class Position;
43 class Range;
44 class VisiblePosition;
45 class VisibleSelection;
46
47
48 // This file contains a set of helper functions used by the editing commands
49
50 // -------------------------------------------------------------------------
51 // Node
52 // -------------------------------------------------------------------------
53
54 // Functions returning Node
55
56 Node* highestAncestor(Node*);
57 Node* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
58
59 Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*),
60     EditingBoundaryCrossingRule = CannotCrossEditingBoundary, Node* stayWithin = 0);
61 Node* highestNodeToRemoveInPruning(Node*);
62 Node* lowestEditableAncestor(Node*);
63
64 Element* enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
65 Node* enclosingTableCell(const Position&);
66 Node* enclosingEmptyListItem(const VisiblePosition&);
67 Node* enclosingAnchorElement(const Position&);
68 Node* enclosingNodeWithTag(const Position&, const QualifiedName&);
69 Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
70
71 Node* tabSpanNode(const Node*);
72 Node* isLastPositionBeforeTable(const VisiblePosition&);
73 Node* isFirstPositionAfterTable(const VisiblePosition&);
74
75 // offset functions on Node
76
77 int lastOffsetForEditing(const Node*);
78 int caretMinOffset(const Node*);
79 int caretMaxOffset(const Node*);
80
81 // boolean functions on Node
82
83 // FIXME: editingIgnoresContent, canHaveChildrenForEditing, and isAtomicNode
84 // should be renamed to reflect its usage.
85
86 // Returns true for nodes that either have no content, or have content that is ignored (skipped over) while editing.
87 // There are no VisiblePositions inside these nodes.
88 inline bool editingIgnoresContent(const Node* node)
89 {
90     return !node->canContainRangeEndPoint();
91 }
92
93 inline bool canHaveChildrenForEditing(const Node* node)
94 {
95     return !node->isTextNode() && node->canContainRangeEndPoint();
96 }
97
98 bool isAtomicNode(const Node*);
99 bool isBlock(const Node*);
100 bool isInline(const Node*);
101 bool isSpecialElement(const Node*);
102 bool isTabSpanNode(const Node*);
103 bool isTabSpanTextNode(const Node*);
104 bool isMailBlockquote(const Node*);
105 bool isTableElement(Node*);
106 bool isTableCell(const Node*);
107 bool isEmptyTableCell(const Node*);
108 bool isTableStructureNode(const Node*);
109 bool isListElement(Node*);
110 bool isListItem(Node*);
111 bool isNodeRendered(const Node*);
112 bool isNodeVisiblyContainedWithin(Node*, const Range*);
113 bool isRenderedAsNonInlineTableImageOrHR(const Node*);
114 bool areIdenticalElements(const Node*, const Node*);
115 bool isNonTableCellHTMLBlockElement(const Node*);
116 TextDirection directionOfEnclosingBlock(const Position&);
117
118 // -------------------------------------------------------------------------
119 // Position
120 // -------------------------------------------------------------------------
121     
122 // Functions returning Position
123     
124 Position nextCandidate(const Position&);
125 Position previousCandidate(const Position&);
126     
127 Position nextVisuallyDistinctCandidate(const Position&);
128 Position previousVisuallyDistinctCandidate(const Position&);
129
130 Position positionOutsideTabSpan(const Position&);
131 Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
132 Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
133 Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement=0);
134
135 inline Position firstPositionInOrBeforeNode(Node* node)
136 {
137     if (!node)
138         return Position();
139     return editingIgnoresContent(node) ? positionBeforeNode(node) : firstPositionInNode(node);
140 }
141
142 inline Position lastPositionInOrAfterNode(Node* node)
143 {
144     if (!node)
145         return Position();
146     return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
147 }
148
149 // comparision functions on Position
150     
151 int comparePositions(const Position&, const Position&);
152
153 // boolean functions on Position
154     
155 bool isEditablePosition(const Position&, EditableType = ContentIsEditable);
156 bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
157 bool isFirstVisiblePositionInSpecialElement(const Position&);
158 bool isLastVisiblePositionInSpecialElement(const Position&);
159 bool lineBreakExistsAtPosition(const Position&);
160 bool isVisiblyAdjacent(const Position& first, const Position& second);
161 bool isAtUnsplittableElement(const Position&);
162
163 // miscellaneous functions on Position
164
165 unsigned numEnclosingMailBlockquotes(const Position&);
166 void updatePositionForNodeRemoval(Position&, Node*);
167
168 // -------------------------------------------------------------------------
169 // VisiblePosition
170 // -------------------------------------------------------------------------
171     
172 // Functions returning VisiblePosition
173     
174 VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
175 VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
176 VisiblePosition visiblePositionBeforeNode(Node*);
177 VisiblePosition visiblePositionAfterNode(Node*);
178
179 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
180     
181 int comparePositions(const VisiblePosition&, const VisiblePosition&);
182
183 int indexForVisiblePosition(const VisiblePosition&, RefPtr<Element>& scope);
184 VisiblePosition visiblePositionForIndex(int index, Element *scope);
185
186 // -------------------------------------------------------------------------
187 // Range
188 // -------------------------------------------------------------------------
189
190 // Functions returning Range
191
192 PassRefPtr<Range> createRange(PassRefPtr<Document>, const VisiblePosition& start, const VisiblePosition& end, ExceptionCode&);
193 PassRefPtr<Range> extendRangeToWrappingNodes(PassRefPtr<Range> rangeToExtend, const Range* maximumRange, const Node* rootNode);
194 PassRefPtr<Range> avoidIntersectionWithNode(const Range*, Node*);
195
196 // -------------------------------------------------------------------------
197 // HTMLElement
198 // -------------------------------------------------------------------------
199     
200 // Functions returning HTMLElement
201     
202 PassRefPtr<HTMLElement> createDefaultParagraphElement(Document*);
203 PassRefPtr<HTMLElement> createBreakElement(Document*);
204 PassRefPtr<HTMLElement> createOrderedListElement(Document*);
205 PassRefPtr<HTMLElement> createUnorderedListElement(Document*);
206 PassRefPtr<HTMLElement> createListItemElement(Document*);
207 PassRefPtr<HTMLElement> createHTMLElement(Document*, const QualifiedName&);
208 PassRefPtr<HTMLElement> createHTMLElement(Document*, const AtomicString&);
209
210 HTMLElement* enclosingList(Node*);
211 HTMLElement* outermostEnclosingList(Node*, Node* rootList = 0);
212 Node* enclosingListChild(Node*);
213
214 // -------------------------------------------------------------------------
215 // Element
216 // -------------------------------------------------------------------------
217     
218 // Functions returning Element
219     
220 PassRefPtr<Element> createTabSpanElement(Document*);
221 PassRefPtr<Element> createTabSpanElement(Document*, PassRefPtr<Node> tabTextNode);
222 PassRefPtr<Element> createTabSpanElement(Document*, const String& tabText);
223 PassRefPtr<Element> createBlockPlaceholderElement(Document*);
224
225 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
226 Element* unsplittableElementForPosition(const Position&);
227
228 // Boolean functions on Element
229     
230 bool canMergeLists(Element* firstList, Element* secondList);
231     
232 // -------------------------------------------------------------------------
233 // VisibleSelection
234 // -------------------------------------------------------------------------
235
236 // Functions returning VisibleSelection
237 VisibleSelection avoidIntersectionWithNode(const VisibleSelection&, Node*);
238 VisibleSelection selectionForParagraphIteration(const VisibleSelection&);
239
240 Position adjustedSelectionStartForStyleComputation(const VisibleSelection&);
241     
242
243 // Miscellaneous functions on Text
244 inline bool isWhitespace(UChar c)
245 {
246     return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
247 }
248
249 inline bool isAmbiguousBoundaryCharacter(UChar character)
250 {
251     // These are characters that can behave as word boundaries, but can appear within words.
252     // If they are just typed, i.e. if they are immediately followed by a caret, we want to delay text checking until the next character has been typed.
253     // FIXME: this is required until 6853027 is fixed and text checking can do this for us.
254     return character == '\'' || character == rightSingleQuotationMark || character == hebrewPunctuationGershayim;
255 }
256
257 String stringWithRebalancedWhitespace(const String&, bool startIsStartOfParagraph, bool endIsEndOfParagraph);
258 const String& nonBreakingSpaceString();
259
260 }
261
262 #endif