More WEBCORE_EXPORT macros!
[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 "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 // This file contains a set of helper functions used by the editing commands
48
49 // -------------------------------------------------------------------------
50 // Node
51 // -------------------------------------------------------------------------
52
53 // Functions returning Node
54
55 Node* highestAncestor(Node*);
56 Node* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
57
58 Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*),
59     EditingBoundaryCrossingRule = CannotCrossEditingBoundary, Node* stayWithin = 0);
60 Node* highestNodeToRemoveInPruning(Node*);
61 Node* lowestEditableAncestor(Node*);
62
63 Element* deprecatedEnclosingBlockFlowElement(Node*); // Use enclosingBlock instead.
64 Element* enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
65 Node* enclosingTableCell(const Position&);
66 Node* enclosingEmptyListItem(const VisiblePosition&);
67 Element* enclosingAnchorElement(const Position&);
68 Element* enclosingElementWithTag(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 // These two deliver leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
76 Node* nextLeafNode(const Node*);
77 Node* previousLeafNode(const Node*);
78
79 // offset functions on Node
80
81 WEBCORE_EXPORT int lastOffsetForEditing(const Node*);
82 int caretMinOffset(const Node*);
83 int caretMaxOffset(const Node*);
84
85 // boolean functions on Node
86
87 // FIXME: editingIgnoresContent, canHaveChildrenForEditing, and isAtomicNode
88 // should be renamed to reflect its usage.
89
90 // Returns true for nodes that either have no content, or have content that is ignored (skipped over) while editing.
91 // There are no VisiblePositions inside these nodes.
92 inline bool editingIgnoresContent(const Node* node)
93 {
94     return !node->canContainRangeEndPoint();
95 }
96
97 inline bool canHaveChildrenForEditing(const Node* node)
98 {
99     return !node->isTextNode() && node->canContainRangeEndPoint();
100 }
101
102 bool isAtomicNode(const Node*);
103 bool isBlock(const Node*);
104 bool isBlockFlowElement(const Node*);
105 bool isInline(const Node*);
106 bool isSpecialElement(const Node*);
107 bool isTabSpanNode(const Node*);
108 bool isTabSpanTextNode(const Node*);
109 bool isMailBlockquote(const Node*);
110 bool isRenderedTable(const Node*);
111 bool isTableCell(const Node*);
112 bool isEmptyTableCell(const Node*);
113 bool isTableStructureNode(const Node*);
114 bool isListElement(Node*);
115 bool isListItem(const Node*);
116 bool isNodeRendered(const Node*);
117 bool isNodeVisiblyContainedWithin(Node*, const Range*);
118 bool isRenderedAsNonInlineTableImageOrHR(const Node*);
119 bool areIdenticalElements(const Node*, const Node*);
120 bool isNonTableCellHTMLBlockElement(const Node*);
121
122 TextDirection directionOfEnclosingBlock(const Position&);
123
124 // -------------------------------------------------------------------------
125 // Position
126 // -------------------------------------------------------------------------
127     
128 // Functions returning Position
129     
130 Position nextCandidate(const Position&);
131 Position previousCandidate(const Position&);
132     
133 Position nextVisuallyDistinctCandidate(const Position&);
134 Position previousVisuallyDistinctCandidate(const Position&);
135
136 Position positionOutsideTabSpan(const Position&);
137 Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
138 Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
139 Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
140
141 inline Position firstPositionInOrBeforeNode(Node* node)
142 {
143     if (!node)
144         return Position();
145     return editingIgnoresContent(node) ? positionBeforeNode(node) : firstPositionInNode(node);
146 }
147
148 inline Position lastPositionInOrAfterNode(Node* node)
149 {
150     if (!node)
151         return Position();
152     return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
153 }
154
155 // comparision functions on Position
156     
157 int comparePositions(const Position&, const Position&);
158
159 // boolean functions on Position
160
161 enum EUpdateStyle { UpdateStyle, DoNotUpdateStyle };
162 WEBCORE_EXPORT bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
163 bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
164 bool isFirstVisiblePositionInSpecialElement(const Position&);
165 bool isLastVisiblePositionInSpecialElement(const Position&);
166 bool lineBreakExistsAtPosition(const Position&);
167 bool isVisiblyAdjacent(const Position& first, const Position& second);
168 bool isAtUnsplittableElement(const Position&);
169
170 // miscellaneous functions on Position
171
172 unsigned numEnclosingMailBlockquotes(const Position&);
173 void updatePositionForNodeRemoval(Position&, Node*);
174
175 // -------------------------------------------------------------------------
176 // VisiblePosition
177 // -------------------------------------------------------------------------
178     
179 // Functions returning VisiblePosition
180     
181 VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
182 VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
183 VisiblePosition visiblePositionBeforeNode(Node*);
184 VisiblePosition visiblePositionAfterNode(Node*);
185
186 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
187     
188 int comparePositions(const VisiblePosition&, const VisiblePosition&);
189
190 int indexForVisiblePosition(const VisiblePosition&, RefPtr<ContainerNode>& scope);
191 int indexForVisiblePosition(Node*, const VisiblePosition&, bool forSelectionPreservation);
192 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
193 VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node*, int index); // FIXME: Why do we need this version?
194
195 // -------------------------------------------------------------------------
196 // HTMLElement
197 // -------------------------------------------------------------------------
198     
199 // Functions returning HTMLElement
200     
201 WEBCORE_EXPORT PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
202 PassRefPtr<HTMLElement> createBreakElement(Document&);
203 PassRefPtr<HTMLElement> createOrderedListElement(Document&);
204 PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
205 PassRefPtr<HTMLElement> createListItemElement(Document&);
206 PassRefPtr<HTMLElement> createHTMLElement(Document&, const QualifiedName&);
207 PassRefPtr<HTMLElement> createHTMLElement(Document&, const AtomicString&);
208
209 HTMLElement* enclosingList(Node*);
210 HTMLElement* outermostEnclosingList(Node*, Node* rootList = 0);
211 Node* enclosingListChild(Node*);
212
213 // -------------------------------------------------------------------------
214 // Element
215 // -------------------------------------------------------------------------
216
217 PassRefPtr<Element> createTabSpanElement(Document&);
218 PassRefPtr<Element> createTabSpanElement(Document&, PassRefPtr<Node> tabTextNode);
219 PassRefPtr<Element> createTabSpanElement(Document&, const String& tabText);
220 PassRefPtr<Element> createBlockPlaceholderElement(Document&);
221
222 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
223 Element* unsplittableElementForPosition(const Position&);
224
225 bool canMergeLists(Element* firstList, Element* secondList);
226     
227 // -------------------------------------------------------------------------
228 // VisibleSelection
229 // -------------------------------------------------------------------------
230
231 VisibleSelection selectionForParagraphIteration(const VisibleSelection&);
232
233 Position adjustedSelectionStartForStyleComputation(const VisibleSelection&);
234     
235 // -------------------------------------------------------------------------
236
237 // FIXME: This is only one of many definitions of whitespace, so the name is not specific enough.
238 inline bool isWhitespace(UChar c)
239 {
240     return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
241 }
242
243 // FIXME: Can't really answer this question correctly without knowing the white-space mode.
244 inline bool deprecatedIsCollapsibleWhitespace(UChar c)
245 {
246     return c == ' ' || c == '\n';
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 // Miscellaaneous functions that for caret rendering
261
262 RenderObject* rendererForCaretPainting(Node*);
263 LayoutRect localCaretRectInRendererForCaretPainting(const VisiblePosition&, RenderObject*&);
264 IntRect absoluteBoundsForLocalCaretRect(RenderObject* rendererForCaretPainting, const LayoutRect&);
265
266 }
267
268 #endif