- another attempt to fix the Windows build
[WebKit-https.git] / WebCore / editing / TextIterator.h
1 /*
2  * Copyright (C) 2004, 2006 Apple Computer, 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 KHTML_EDITING_VISIBLE_TEXT_H
27 #define KHTML_EDITING_VISIBLE_TEXT_H
28
29 #include "DeprecatedString.h"
30 #include "InlineTextBox.h"
31 #include "Range.h"
32 #include <wtf/Vector.h>
33
34 namespace WebCore {
35
36 // FIXME: Can't really answer this question correctly without knowing the white-space mode.
37 // FIXME: Move this along with the white-space position functions above
38 // somewhere else in the editing directory. It doesn't belong here.
39 inline bool isCollapsibleWhitespace(UChar c)
40 {
41     switch (c) {
42         case ' ':
43         case '\n':
44             return true;
45         default:
46             return false;
47     }
48 }
49
50 DeprecatedString plainText(const Range*);
51 PassRefPtr<Range> findPlainText(const Range*, const String&, bool forward, bool caseSensitive);
52
53 // Iterates through the DOM range, returning all the text, and 0-length boundaries
54 // at points where replaced elements break up the text flow.  The text comes back in
55 // chunks so as to optimize for performance of the iteration.
56
57 enum IteratorKind { CONTENT = 0, RUNFINDER = 1 };
58
59 class TextIterator
60 {
61 public:
62     TextIterator();
63     explicit TextIterator(const Range *, IteratorKind kind = CONTENT );
64     
65     bool atEnd() const { return !m_positionNode; }
66     void advance();
67     
68     int length() const { return m_textLength; }
69     const UChar* characters() const { return m_textCharacters; }
70     
71     PassRefPtr<Range> range() const;
72      
73     static int rangeLength(const Range *r);
74     static PassRefPtr<Range> rangeFromLocationAndLength(Document *doc, int rangeLocation, int rangeLength);
75     
76 private:
77     void exitNode();
78     bool handleTextNode();
79     bool handleReplacedElement();
80     bool handleNonTextNode();
81     void handleTextBox();
82     void emitCharacter(UChar, Node *textNode, Node *offsetBaseNode, int textStartOffset, int textEndOffset);
83     
84     // Current position, not necessarily of the text being returned, but position
85     // as we walk through the DOM tree.
86     Node *m_node;
87     int m_offset;
88     bool m_handledNode;
89     bool m_handledChildren;
90     
91     // End of the range.
92     Node *m_endContainer;
93     int m_endOffset;
94     Node *m_pastEndNode;
95     
96     // The current text and its position, in the form to be returned from the iterator.
97     Node *m_positionNode;
98     mutable Node *m_positionOffsetBaseNode;
99     mutable int m_positionStartOffset;
100     mutable int m_positionEndOffset;
101     const UChar* m_textCharacters;
102     int m_textLength;
103     
104     // Used when there is still some pending text from the current node; when these
105     // are false and 0, we go back to normal iterating.
106     bool m_needAnotherNewline;
107     InlineTextBox *m_textBox;
108     
109     // Used to do the whitespace collapsing logic.
110     Node *m_lastTextNode;    
111     bool m_lastTextNodeEndedWithCollapsedSpace;
112     UChar m_lastCharacter;
113     
114     // Used for whitespace characters that aren't in the DOM, so we can point at them.
115     UChar m_singleCharacterBuffer;
116     
117     // Used when text boxes are out of order (Hebrew/Arabic w/ embeded LTR text)
118     Vector<InlineTextBox*> m_sortedTextBoxes;
119     size_t m_sortedTextBoxesPosition;
120 };
121
122 // Iterates through the DOM range, returning all the text, and 0-length boundaries
123 // at points where replaced elements break up the text flow.  The text comes back in
124 // chunks so as to optimize for performance of the iteration.
125 class SimplifiedBackwardsTextIterator
126 {
127 public:
128     SimplifiedBackwardsTextIterator();
129     explicit SimplifiedBackwardsTextIterator(const Range *);
130     
131     bool atEnd() const { return !m_positionNode; }
132     void advance();
133     
134     int length() const { return m_textLength; }
135     const UChar* characters() const { return m_textCharacters; }
136     
137     PassRefPtr<Range> range() const;
138         
139 private:
140     void exitNode();
141     bool handleTextNode();
142     bool handleReplacedElement();
143     bool handleNonTextNode();
144     void emitCharacter(UChar, Node *Node, int startOffset, int endOffset);
145     void emitNewline();
146     
147     // Current position, not necessarily of the text being returned, but position
148     // as we walk through the DOM tree.
149     Node* m_node;
150     int m_offset;
151     bool m_handledNode;
152     bool m_handledChildren;
153     
154     // End of the range.
155     Node* m_startNode;
156     int m_startOffset;
157     
158     // The current text and its position, in the form to be returned from the iterator.
159     Node* m_positionNode;
160     int m_positionStartOffset;
161     int m_positionEndOffset;
162     const UChar* m_textCharacters;
163     int m_textLength;
164
165     // Used to do the whitespace logic.
166     Node* m_lastTextNode;    
167     UChar m_lastCharacter;
168     
169     // Used for whitespace characters that aren't in the DOM, so we can point at them.
170     UChar m_singleCharacterBuffer;
171 };
172
173 // Builds on the text iterator, adding a character position so we can walk one
174 // character at a time, or faster, as needed. Useful for searching.
175 class CharacterIterator {
176 public:
177     CharacterIterator();
178     explicit CharacterIterator(const Range *r);
179     
180     void advance(int numCharacters);
181     
182     bool atBreak() const { return m_atBreak; }
183     bool atEnd() const { return m_textIterator.atEnd(); }
184     
185     int length() const { return m_textIterator.length() - m_runOffset; }
186     const UChar* characters() const { return m_textIterator.characters() + m_runOffset; }
187     DeprecatedString string(int numChars);
188     
189     int characterOffset() const { return m_offset; }
190     PassRefPtr<Range> range() const;
191         
192 private:
193     int m_offset;
194     int m_runOffset;
195     bool m_atBreak;
196     
197     TextIterator m_textIterator;
198 };
199     
200 // Very similar to the TextIterator, except that the chunks of text returned are "well behaved",
201 // meaning they never end split up a word.  This is useful for spellcheck or (perhaps one day) searching.
202 class WordAwareIterator {
203 public:
204     WordAwareIterator();
205     explicit WordAwareIterator(const Range *r);
206
207     bool atEnd() const { return !m_didLookAhead && m_textIterator.atEnd(); }
208     void advance();
209     
210     int length() const;
211     const UChar* characters() const;
212     
213     // Range of the text we're currently returning
214     PassRefPtr<Range> range() const { return m_range; }
215
216 private:
217     // text from the previous chunk from the textIterator
218     const UChar* m_previousText;
219     int m_previousLength;
220
221     // many chunks from textIterator concatenated
222     DeprecatedString m_buffer;
223     
224     // Did we have to look ahead in the textIterator to confirm the current chunk?
225     bool m_didLookAhead;
226
227     RefPtr<Range> m_range;
228
229     TextIterator m_textIterator;
230 };
231
232 }
233
234 #endif