Reviewed by Ken Kocienda.
[WebKit-https.git] / WebCore / khtml / editing / visible_text.h
1 /*
2  * Copyright (C) 2004 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 "dom/dom2_range.h"
30
31 namespace khtml {
32
33 class InlineTextBox;
34
35 // General utility functions
36
37 QString plainText(const DOM::Range &);
38 DOM::Range findPlainText(const DOM::Range &, const QString &, bool forward, bool caseSensitive);
39
40 // Iterates through the DOM range, returning all the text, and 0-length boundaries
41 // at points where replaced elements break up the text flow.  The text comes back in
42 // chunks so as to optimize for performance of the iteration.
43 class TextIterator
44 {
45 public:
46     TextIterator();
47     explicit TextIterator(const DOM::Range &);
48     
49     bool atEnd() const { return !m_positionNode; }
50     void advance();
51     
52     long length() const { return m_textLength; }
53     const QChar *characters() const { return m_textCharacters; }
54     
55     DOM::Range range() const;
56         
57 private:
58     void exitNode();
59     bool handleTextNode();
60     bool handleReplacedElement();
61     bool handleNonTextNode();
62     void handleTextBox();
63     void emitCharacter(QChar, DOM::NodeImpl *textNode, long textStartOffset, long textEndOffset);
64     
65     // Current position, not necessarily of the text being returned, but position
66     // as we walk through the DOM tree.
67     DOM::NodeImpl *m_node;
68     long m_offset;
69     bool m_handledNode;
70     bool m_handledChildren;
71     
72     // End of the range.
73     DOM::NodeImpl *m_endContainer;
74     long m_endOffset;
75     DOM::NodeImpl *m_pastEndNode;
76     
77     // The current text and its position, in the form to be returned from the iterator.
78     DOM::NodeImpl *m_positionNode;
79     long m_positionStartOffset;
80     long m_positionEndOffset;
81     const QChar *m_textCharacters;
82     long m_textLength;
83     
84     // Used when there is still some pending text from the current node; when these
85     // are false and 0, we go back to normal iterating.
86     bool m_needAnotherNewline;
87     InlineTextBox *m_textBox;
88     
89     // Used to do the whitespace collapsing logic.
90     DOM::NodeImpl *m_lastTextNode;    
91     bool m_lastTextNodeEndedWithCollapsedSpace;
92     QChar m_lastCharacter;
93     
94     // Used for whitespace characters that aren't in the DOM, so we can point at them.
95     QChar m_singleCharacterBuffer;
96 };
97
98 // Iterates through the DOM range, returning all the text, and 0-length boundaries
99 // at points where replaced elements break up the text flow.  The text comes back in
100 // chunks so as to optimize for performance of the iteration.
101 class SimplifiedBackwardsTextIterator
102 {
103 public:
104     SimplifiedBackwardsTextIterator();
105     explicit SimplifiedBackwardsTextIterator(const DOM::Range &);
106     
107     bool atEnd() const { return !m_positionNode; }
108     void advance();
109     
110     long length() const { return m_textLength; }
111     const QChar *characters() const { return m_textCharacters; }
112     
113     DOM::Range range() const;
114         
115 private:
116     void exitNode();
117     bool handleTextNode();
118     bool handleReplacedElement();
119     bool handleNonTextNode();
120     void emitCharacter(QChar, DOM::NodeImpl *Node, long startOffset, long endOffset);
121     
122     // Current position, not necessarily of the text being returned, but position
123     // as we walk through the DOM tree.
124     DOM::NodeImpl *m_node;
125     long m_offset;
126     bool m_handledNode;
127     bool m_handledChildren;
128     
129     // End of the range.
130     DOM::NodeImpl *m_startNode;
131     long m_startOffset;
132     
133     // The current text and its position, in the form to be returned from the iterator.
134     DOM::NodeImpl *m_positionNode;
135     long m_positionStartOffset;
136     long m_positionEndOffset;
137     const QChar *m_textCharacters;
138     long m_textLength;
139
140     // Used to do the whitespace logic.
141     DOM::NodeImpl *m_lastTextNode;    
142     QChar m_lastCharacter;
143     
144     // Used for whitespace characters that aren't in the DOM, so we can point at them.
145     QChar m_singleCharacterBuffer;
146 };
147
148 // Builds on the text iterator, adding a character position so we can walk one
149 // character at a time, or faster, as needed. Useful for searching.
150 class CharacterIterator {
151 public:
152     CharacterIterator();
153     explicit CharacterIterator(const DOM::Range &r);
154     
155     void advance(long numCharacters);
156     
157     bool atBreak() const { return m_atBreak; }
158     bool atEnd() const { return m_textIterator.atEnd(); }
159     
160     long length() const { return m_textIterator.length() - m_runOffset; }
161     const QChar *characters() const { return m_textIterator.characters() + m_runOffset; }
162     QString string(long numChars);
163     
164     long characterOffset() const { return m_offset; }
165     DOM::Range range() const;
166         
167 private:
168     long m_offset;
169     long m_runOffset;
170     bool m_atBreak;
171     
172     TextIterator m_textIterator;
173 };
174     
175 // Very similar to the TextIterator, except that the chunks of text returned are "well behaved",
176 // meaning they never end split up a word.  This is useful for spellcheck or (perhaps one day) searching.
177 class WordAwareIterator {
178 public:
179     WordAwareIterator();
180     explicit WordAwareIterator(const DOM::Range &r);
181
182     bool atEnd() const { return !m_didLookAhead && m_textIterator.atEnd(); }
183     void advance();
184     
185     long length() const;
186     const QChar *characters() const;
187     
188     // Range of the text we're currently returning
189     DOM::Range range() const { return m_range; }
190
191 private:
192     // text from the previous chunk from the textIterator
193     const QChar *m_previousText;
194     long m_previousLength;
195
196     // many chunks from textIterator concatenated
197     QString m_buffer;
198     
199     // Did we have to look ahead in the textIterator to confirm the current chunk?
200     bool m_didLookAhead;
201
202     DOM::Range m_range;
203
204     TextIterator m_textIterator;
205 };
206
207 }
208
209 #endif