Null dereference loading Blink layout test editing/execCommand/delete-hidden-crash...
[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 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 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 "TextFlags.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 RenderBlock;
45 class VisiblePosition;
46 class VisibleSelection;
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 = nullptr);
61 Node* highestNodeToRemoveInPruning(Node*);
62 Node* lowestEditableAncestor(Node*);
63
64 Element* deprecatedEnclosingBlockFlowElement(Node*); // Use enclosingBlock instead.
65 Element* enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
66 Node* enclosingTableCell(const Position&);
67 Node* enclosingEmptyListItem(const VisiblePosition&);
68 Element* enclosingAnchorElement(const Position&);
69 Element* enclosingElementWithTag(const Position&, const QualifiedName&);
70 Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
71
72 Node* tabSpanNode(const Node*);
73 Node* isLastPositionBeforeTable(const VisiblePosition&);
74 Node* isFirstPositionAfterTable(const VisiblePosition&);
75
76 // These two deliver leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
77 Node* nextLeafNode(const Node*);
78 Node* previousLeafNode(const Node*);
79
80 // offset functions on Node
81
82 WEBCORE_EXPORT int lastOffsetForEditing(const Node*);
83 int caretMinOffset(const Node*);
84 int caretMaxOffset(const Node*);
85
86 // boolean functions on Node
87
88 bool hasEditableStyle(const Node&, EditableType);
89 bool isEditableNode(const Node&);
90
91 // FIXME: editingIgnoresContent, canHaveChildrenForEditing, and isAtomicNode
92 // should be renamed to reflect its usage.
93
94 // Returns true for nodes that either have no content, or have content that is ignored (skipped over) while editing.
95 // There are no VisiblePositions inside these nodes.
96 inline bool editingIgnoresContent(const Node* node)
97 {
98     return !node->canContainRangeEndPoint();
99 }
100
101 inline bool canHaveChildrenForEditing(const Node* node)
102 {
103     return !node->isTextNode() && node->canContainRangeEndPoint();
104 }
105
106 bool isAtomicNode(const Node*);
107 bool isBlock(const Node*);
108 bool isBlockFlowElement(const Node*);
109 bool isInline(const Node*);
110 bool isSpecialElement(const Node*);
111 bool isTabSpanNode(const Node*);
112 bool isTabSpanTextNode(const Node*);
113 bool isMailBlockquote(const Node*);
114 bool isRenderedTable(const Node*);
115 bool isTableCell(const Node*);
116 bool isEmptyTableCell(const Node*);
117 bool isTableStructureNode(const Node*);
118 bool isListElement(Node*);
119 bool isListItem(const Node*);
120 bool isNodeRendered(const Node*);
121 bool isNodeVisiblyContainedWithin(Node*, const Range*);
122 bool isRenderedAsNonInlineTableImageOrHR(const Node*);
123 bool areIdenticalElements(const Node*, const Node*);
124 bool isNonTableCellHTMLBlockElement(const Node*);
125
126 inline bool positionBeforeOrAfterNodeIsCandidate(Node* node)
127 {
128     return isRenderedTable(node) || editingIgnoresContent(node);
129 }
130
131 WEBCORE_EXPORT TextDirection directionOfEnclosingBlock(const Position&);
132
133 // -------------------------------------------------------------------------
134 // Position
135 // -------------------------------------------------------------------------
136     
137 // Functions returning Position
138     
139 Position nextCandidate(const Position&);
140 Position previousCandidate(const Position&);
141     
142 Position nextVisuallyDistinctCandidate(const Position&);
143 Position previousVisuallyDistinctCandidate(const Position&);
144
145 Position positionOutsideTabSpan(const Position&);
146 Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement = nullptr);
147 Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement = nullptr);
148 Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement = nullptr);
149
150 inline Position firstPositionInOrBeforeNode(Node* node)
151 {
152     if (!node)
153         return Position();
154     return editingIgnoresContent(node) ? positionBeforeNode(node) : firstPositionInNode(node);
155 }
156
157 inline Position lastPositionInOrAfterNode(Node* node)
158 {
159     if (!node)
160         return Position();
161     return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
162 }
163
164 Position firstEditablePositionAfterPositionInRoot(const Position&, Node*);
165 Position lastEditablePositionBeforePositionInRoot(const Position&, Node*);
166
167 // comparision functions on Position
168     
169 int comparePositions(const Position&, const Position&);
170
171 // boolean functions on Position
172
173 WEBCORE_EXPORT bool isEditablePosition(const Position&, EditableType = ContentIsEditable);
174 bool isRichlyEditablePosition(const Position&);
175 bool isFirstVisiblePositionInSpecialElement(const Position&);
176 bool isLastVisiblePositionInSpecialElement(const Position&);
177 bool lineBreakExistsAtPosition(const Position&);
178 bool isVisiblyAdjacent(const Position& first, const Position& second);
179 bool isAtUnsplittableElement(const Position&);
180
181 // miscellaneous functions on Position
182
183 unsigned numEnclosingMailBlockquotes(const Position&);
184 void updatePositionForNodeRemoval(Position&, Node&);
185
186 // -------------------------------------------------------------------------
187 // VisiblePosition
188 // -------------------------------------------------------------------------
189     
190 // Functions returning VisiblePosition
191
192 VisiblePosition visiblePositionBeforeNode(Node*);
193 VisiblePosition visiblePositionAfterNode(Node*);
194
195 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
196     
197 int comparePositions(const VisiblePosition&, const VisiblePosition&);
198
199 int indexForVisiblePosition(const VisiblePosition&, RefPtr<ContainerNode>& scope);
200 int indexForVisiblePosition(Node*, const VisiblePosition&, bool forSelectionPreservation);
201 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
202 VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node*, int index); // FIXME: Why do we need this version?
203
204 // -------------------------------------------------------------------------
205 // HTMLElement
206 // -------------------------------------------------------------------------
207     
208 // Functions returning HTMLElement
209     
210 WEBCORE_EXPORT Ref<HTMLElement> createDefaultParagraphElement(Document&);
211 Ref<HTMLElement> createBreakElement(Document&);
212 PassRefPtr<HTMLElement> createOrderedListElement(Document&);
213 PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
214 PassRefPtr<HTMLElement> createListItemElement(Document&);
215 Ref<HTMLElement> createHTMLElement(Document&, const QualifiedName&);
216 Ref<HTMLElement> createHTMLElement(Document&, const AtomicString&);
217
218 HTMLElement* enclosingList(Node*);
219 HTMLElement* outermostEnclosingList(Node*, Node* rootList = nullptr);
220 Node* enclosingListChild(Node*);
221
222 // -------------------------------------------------------------------------
223 // Element
224 // -------------------------------------------------------------------------
225
226 Ref<Element> createTabSpanElement(Document&);
227 Ref<Element> createTabSpanElement(Document&, PassRefPtr<Node> tabTextNode);
228 Ref<Element> createTabSpanElement(Document&, const String& tabText);
229 Ref<Element> createBlockPlaceholderElement(Document&);
230
231 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
232 Element* unsplittableElementForPosition(const Position&);
233
234 bool canMergeLists(Element* firstList, Element* secondList);
235     
236 // -------------------------------------------------------------------------
237 // VisibleSelection
238 // -------------------------------------------------------------------------
239
240 VisibleSelection selectionForParagraphIteration(const VisibleSelection&);
241
242 Position adjustedSelectionStartForStyleComputation(const VisibleSelection&);
243     
244 // -------------------------------------------------------------------------
245
246 // FIXME: This is only one of many definitions of whitespace, so the name is not specific enough.
247 inline bool isWhitespace(UChar c)
248 {
249     return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
250 }
251
252 // FIXME: Can't really answer this question correctly without knowing the white-space mode.
253 inline bool deprecatedIsCollapsibleWhitespace(UChar c)
254 {
255     return c == ' ' || c == '\n';
256 }
257
258 inline bool isAmbiguousBoundaryCharacter(UChar character)
259 {
260     // These are characters that can behave as word boundaries, but can appear within words.
261     // 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.
262     // FIXME: this is required until 6853027 is fixed and text checking can do this for us.
263     return character == '\'' || character == rightSingleQuotationMark || character == hebrewPunctuationGershayim;
264 }
265
266 String stringWithRebalancedWhitespace(const String&, bool startIsStartOfParagraph, bool endIsEndOfParagraph);
267 const String& nonBreakingSpaceString();
268
269 // Miscellaaneous functions that for caret rendering
270
271 RenderBlock* rendererForCaretPainting(Node*);
272 LayoutRect localCaretRectInRendererForCaretPainting(const VisiblePosition&, RenderBlock*&);
273 IntRect absoluteBoundsForLocalCaretRect(RenderBlock* rendererForCaretPainting, const LayoutRect&);
274
275 }
276
277 #endif