Remove all uses of deprecatedCharacters from WebKit2
[WebKit-https.git] / Source / WebKit2 / UIProcess / efl / TextCheckerEfl.cpp
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
4  * Copyright (C) 2011-2013 Samsung Electronics
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25  * THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #include "config.h"
29 #include "TextChecker.h"
30
31 #include "NotImplemented.h"
32 #include "TextCheckerState.h"
33
34 #if ENABLE(SPELLCHECK)
35 #include "TextBreakIterator.h"
36 #include "TextCheckerClientEfl.h"
37 #include "WebTextChecker.h"
38 #endif
39
40 using namespace WebCore;
41
42 namespace WebKit {
43
44 static TextCheckerState textCheckerState;
45
46 const TextCheckerState& TextChecker::state()
47 {
48     static bool didInitializeState = false;
49     if (didInitializeState)
50         return textCheckerState;
51
52     textCheckerState.isContinuousSpellCheckingEnabled = false;
53     textCheckerState.isGrammarCheckingEnabled = false;
54
55     didInitializeState = true;
56
57     return textCheckerState;
58 }
59
60 bool TextChecker::isContinuousSpellCheckingAllowed()
61 {
62     notImplemented();
63     return false;
64 }
65
66 void TextChecker::setContinuousSpellCheckingEnabled(bool isContinuousSpellCheckingEnabled)
67 {
68 #if ENABLE(SPELLCHECK)
69     if (state().isContinuousSpellCheckingEnabled == isContinuousSpellCheckingEnabled)
70         return;
71
72     textCheckerState.isContinuousSpellCheckingEnabled = isContinuousSpellCheckingEnabled;
73
74     // Notify the client about the setting change.
75     WebTextChecker::shared()->client().setContinuousSpellCheckingEnabled(isContinuousSpellCheckingEnabled);
76 #else
77     UNUSED_PARAM(isContinuousSpellCheckingEnabled);
78 #endif
79 }
80
81 void TextChecker::setGrammarCheckingEnabled(bool)
82 {
83     notImplemented();
84 }
85
86 void TextChecker::continuousSpellCheckingEnabledStateChanged(bool enabled)
87 {
88 #if ENABLE(SPELLCHECK)
89     if (state().isContinuousSpellCheckingEnabled == enabled)
90         return;
91
92     textCheckerState.isContinuousSpellCheckingEnabled = enabled;
93 #else
94     UNUSED_PARAM(enabled);
95 #endif
96 }
97
98 void TextChecker::grammarCheckingEnabledStateChanged(bool)
99 {
100     notImplemented();
101 }
102
103 int64_t TextChecker::uniqueSpellDocumentTag(WebPageProxy* page)
104 {
105 #if ENABLE(SPELLCHECK)
106     return WebTextChecker::shared()->client().uniqueSpellDocumentTag(page);
107 #else
108     UNUSED_PARAM(page);
109     return 0;
110 #endif
111 }
112
113 void TextChecker::closeSpellDocumentWithTag(int64_t tag)
114 {
115 #if ENABLE(SPELLCHECK)
116     WebTextChecker::shared()->client().closeSpellDocumentWithTag(tag);
117 #else
118     UNUSED_PARAM(tag);
119 #endif
120 }
121
122 #if ENABLE(SPELLCHECK)
123 static unsigned nextWordOffset(StringView text, unsigned currentOffset)
124 {
125     // FIXME: avoid creating textIterator object here, it could be passed as a parameter.
126     //        isTextBreak() leaves the iterator pointing to the first boundary position at
127     //        or after "offset" (ubrk_isBoundary side effect).
128     //        For many word separators, the method doesn't properly determine the boundaries
129     //        without resetting the iterator.
130     TextBreakIterator* textIterator = wordBreakIterator(text);
131     if (!textIterator)
132         return currentOffset;
133
134     unsigned wordOffset = currentOffset;
135     while (wordOffset < text.length() && isTextBreak(textIterator, wordOffset))
136         ++wordOffset;
137
138     // Do not treat the word's boundary as a separator.
139     if (!currentOffset && wordOffset == 1)
140         return currentOffset;
141
142     // Omit multiple separators.
143     if ((wordOffset - currentOffset) > 1)
144         --wordOffset;
145
146     return wordOffset;
147 }
148 #endif // ENABLE(SPELLCHECK)
149
150 #if USE(UNIFIED_TEXT_CHECKING)
151 Vector<TextCheckingResult> TextChecker::checkTextOfParagraph(int64_t spellDocumentTag, StringView text, uint64_t checkingTypes)
152 {
153     Vector<TextCheckingResult> paragraphCheckingResult;
154 #if ENABLE(SPELLCHECK)
155     if (checkingTypes & TextCheckingTypeSpelling) {
156         TextBreakIterator* textIterator = wordBreakIterator(text);
157         if (!textIterator)
158             return paragraphCheckingResult;
159
160         // Omit the word separators at the beginning/end of the text to don't unnecessarily
161         // involve the client to check spelling for them.
162         unsigned offset = nextWordOffset(text, 0);
163         unsigned lengthStrip = text.length();
164         while (lengthStrip > 0 && isTextBreak(textIterator, lengthStrip - 1))
165             --lengthStrip;
166
167         while (offset < lengthStrip) {
168             int32_t misspellingLocation = -1;
169             int32_t misspellingLength = 0;
170             checkSpellingOfString(spellDocumentTag, text.substring(offset, lengthStrip - offset), misspellingLocation, misspellingLength);
171             if (!misspellingLength)
172                 break;
173
174             TextCheckingResult misspellingResult;
175             misspellingResult.type = TextCheckingTypeSpelling;
176             misspellingResult.location = offset + misspellingLocation;
177             misspellingResult.length = misspellingLength;
178             paragraphCheckingResult.append(misspellingResult);
179             offset += misspellingLocation + misspellingLength;
180             // Generally, we end up checking at the word separator, move to the adjacent word.
181             offset = nextWordOffset(text.substring(0, lengthStrip), offset);
182         }
183     }
184 #else
185     UNUSED_PARAM(spellDocumentTag);
186     UNUSED_PARAM(text);
187     UNUSED_PARAM(length);
188     UNUSED_PARAM(checkingTypes);
189 #endif
190     return paragraphCheckingResult;
191 }
192 #endif
193
194 void TextChecker::checkSpellingOfString(int64_t spellDocumentTag, StringView text, int32_t& misspellingLocation, int32_t& misspellingLength)
195 {
196 #if ENABLE(SPELLCHECK)
197     WebTextChecker::shared()->client().checkSpellingOfString(spellDocumentTag, text.toStringWithoutCopying(), misspellingLocation, misspellingLength);
198 #else
199     UNUSED_PARAM(spellDocumentTag);
200     UNUSED_PARAM(text);
201     UNUSED_PARAM(length);
202     UNUSED_PARAM(misspellingLocation);
203     UNUSED_PARAM(misspellingLength);
204 #endif
205 }
206
207 void TextChecker::checkGrammarOfString(int64_t, StringView, Vector<GrammarDetail>&, int32_t&, int32_t&)
208 {
209     notImplemented();
210 }
211
212 bool TextChecker::spellingUIIsShowing()
213 {
214     notImplemented();
215     return false;
216 }
217
218 void TextChecker::toggleSpellingUIIsShowing()
219 {
220     notImplemented();
221 }
222
223 void TextChecker::updateSpellingUIWithMisspelledWord(int64_t, const String&)
224 {
225     notImplemented();
226 }
227
228 void TextChecker::updateSpellingUIWithGrammarString(int64_t, const String&, const GrammarDetail&)
229 {
230     notImplemented();
231 }
232
233 void TextChecker::getGuessesForWord(int64_t spellDocumentTag, const String& word, const String& , Vector<String>& guesses)
234 {
235 #if ENABLE(SPELLCHECK)
236     WebTextChecker::shared()->client().guessesForWord(spellDocumentTag, word, guesses);
237 #else
238     UNUSED_PARAM(spellDocumentTag);
239     UNUSED_PARAM(word);
240     UNUSED_PARAM(guesses);
241 #endif
242 }
243
244 void TextChecker::learnWord(int64_t spellDocumentTag, const String& word)
245 {
246 #if ENABLE(SPELLCHECK)
247     WebTextChecker::shared()->client().learnWord(spellDocumentTag, word);
248 #else
249     UNUSED_PARAM(spellDocumentTag);
250     UNUSED_PARAM(word);
251 #endif
252 }
253
254 void TextChecker::ignoreWord(int64_t spellDocumentTag, const String& word)
255 {
256 #if ENABLE(SPELLCHECK)
257     WebTextChecker::shared()->client().ignoreWord(spellDocumentTag, word);
258 #else
259     UNUSED_PARAM(spellDocumentTag);
260     UNUSED_PARAM(word);
261 #endif
262 }
263
264 void TextChecker::requestCheckingOfString(PassRefPtr<TextCheckerCompletion> completion)
265 {
266 #if ENABLE(SPELLCHECK)
267     if (!completion)
268         return;
269
270     TextCheckingRequestData request = completion->textCheckingRequestData();
271     ASSERT(request.sequence() != unrequestedTextCheckingSequence);
272     ASSERT(request.mask() != TextCheckingTypeNone);
273
274     completion->didFinishCheckingText(checkTextOfParagraph(completion->spellDocumentTag(), request.text(), request.mask()));
275 #else
276     UNUSED_PARAM(completion);
277 #endif
278 }
279
280 } // namespace WebKit