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