2014-12-18 21:43:51 +00:00
|
|
|
// Copyright (c) 2014 GitHub, Inc.
|
|
|
|
// Use of this source code is governed by the MIT license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
|
|
|
#include "atom/renderer/api/atom_api_spell_check_client.h"
|
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
#include <algorithm>
|
2014-12-19 00:44:38 +00:00
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include "atom/common/native_mate_converters/string16_converter.h"
|
2014-12-19 01:41:42 +00:00
|
|
|
#include "base/logging.h"
|
2014-12-19 00:44:38 +00:00
|
|
|
#include "native_mate/converter.h"
|
2014-12-19 01:41:42 +00:00
|
|
|
#include "native_mate/dictionary.h"
|
|
|
|
#include "third_party/icu/source/common/unicode/uscript.h"
|
2014-12-19 00:44:38 +00:00
|
|
|
#include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
|
2014-12-19 01:41:42 +00:00
|
|
|
#include "third_party/WebKit/public/web/WebTextCheckingResult.h"
|
2014-12-19 00:44:38 +00:00
|
|
|
|
2014-12-18 21:43:51 +00:00
|
|
|
namespace atom {
|
|
|
|
|
|
|
|
namespace api {
|
|
|
|
|
2014-12-19 01:41:42 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
bool HasWordCharacters(const base::string16& text, int index) {
|
|
|
|
const base::char16* data = text.data();
|
|
|
|
int length = text.length();
|
|
|
|
while (index < length) {
|
2016-03-08 04:40:10 +00:00
|
|
|
uint32_t code = 0;
|
2014-12-19 01:41:42 +00:00
|
|
|
U16_NEXT(data, index, length, code);
|
|
|
|
UErrorCode error = U_ZERO_ERROR;
|
|
|
|
if (uscript_getScript(code, &error) != USCRIPT_COMMON)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2014-12-20 05:01:47 +00:00
|
|
|
SpellCheckClient::SpellCheckClient(const std::string& language,
|
|
|
|
bool auto_spell_correct_turned_on,
|
|
|
|
v8::Isolate* isolate,
|
2015-05-22 11:11:22 +00:00
|
|
|
v8::Local<v8::Object> provider)
|
2016-03-08 14:28:53 +00:00
|
|
|
: isolate_(isolate),
|
2014-12-20 05:01:47 +00:00
|
|
|
provider_(isolate, provider) {
|
2014-12-20 04:42:19 +00:00
|
|
|
character_attributes_.SetDefaultLanguage(language);
|
|
|
|
|
|
|
|
// Persistent the method.
|
|
|
|
mate::Dictionary dict(isolate, provider);
|
|
|
|
dict.Get("spellCheck", &spell_check_);
|
|
|
|
}
|
2014-12-18 21:43:51 +00:00
|
|
|
|
|
|
|
SpellCheckClient::~SpellCheckClient() {}
|
|
|
|
|
2017-04-11 07:18:40 +00:00
|
|
|
void SpellCheckClient::checkSpelling(
|
2014-12-18 21:43:51 +00:00
|
|
|
const blink::WebString& text,
|
2014-12-20 04:42:19 +00:00
|
|
|
int& misspelling_start,
|
|
|
|
int& misspelling_len,
|
|
|
|
blink::WebVector<blink::WebString>* optional_suggestions) {
|
2014-12-20 06:13:07 +00:00
|
|
|
std::vector<blink::WebTextCheckingResult> results;
|
2017-04-11 07:18:40 +00:00
|
|
|
SpellCheckText(text.utf16(), true, &results);
|
2014-12-20 06:13:07 +00:00
|
|
|
if (results.size() == 1) {
|
|
|
|
misspelling_start = results[0].location;
|
|
|
|
misspelling_len = results[0].length;
|
2014-12-20 04:42:19 +00:00
|
|
|
}
|
2014-12-18 21:43:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SpellCheckClient::requestCheckingOfText(
|
|
|
|
const blink::WebString& textToCheck,
|
|
|
|
blink::WebTextCheckingCompletion* completionCallback) {
|
2017-04-11 07:18:40 +00:00
|
|
|
base::string16 text(textToCheck.utf16());
|
2014-12-19 01:41:42 +00:00
|
|
|
if (text.empty() || !HasWordCharacters(text, 0)) {
|
2014-12-19 00:44:38 +00:00
|
|
|
completionCallback->didCancelCheckingText();
|
2014-12-19 01:41:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
std::vector<blink::WebTextCheckingResult> results;
|
|
|
|
SpellCheckText(text, false, &results);
|
|
|
|
completionCallback->didFinishCheckingText(results);
|
2014-12-18 21:43:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SpellCheckClient::showSpellingUI(bool show) {
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SpellCheckClient::isShowingSpellingUI() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpellCheckClient::updateSpellingUIWithMisspelledWord(
|
|
|
|
const blink::WebString& word) {
|
|
|
|
}
|
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
void SpellCheckClient::SpellCheckText(
|
|
|
|
const base::string16& text,
|
|
|
|
bool stop_at_first_result,
|
|
|
|
std::vector<blink::WebTextCheckingResult>* results) {
|
|
|
|
if (text.length() == 0 || spell_check_.IsEmpty())
|
|
|
|
return;
|
2014-12-19 00:44:38 +00:00
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
base::string16 word;
|
|
|
|
int word_start;
|
|
|
|
int word_length;
|
|
|
|
if (!text_iterator_.IsInitialized() &&
|
|
|
|
!text_iterator_.Initialize(&character_attributes_, true)) {
|
|
|
|
// We failed to initialize text_iterator_, return as spelled correctly.
|
|
|
|
VLOG(1) << "Failed to initialize SpellcheckWordIterator";
|
|
|
|
return;
|
|
|
|
}
|
2014-12-19 00:44:38 +00:00
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
base::string16 in_word(text);
|
|
|
|
text_iterator_.SetText(in_word.c_str(), in_word.size());
|
|
|
|
while (text_iterator_.GetNextWord(&word, &word_start, &word_length)) {
|
|
|
|
// Found a word (or a contraction) that the spellchecker can check the
|
|
|
|
// spelling of.
|
|
|
|
if (SpellCheckWord(word))
|
|
|
|
continue;
|
2014-12-19 00:44:38 +00:00
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
// If the given word is a concatenated word of two or more valid words
|
|
|
|
// (e.g. "hello:hello"), we should treat it as a valid word.
|
|
|
|
if (IsValidContraction(word))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
blink::WebTextCheckingResult result;
|
|
|
|
result.location = word_start;
|
|
|
|
result.length = word_length;
|
|
|
|
results->push_back(result);
|
|
|
|
|
|
|
|
if (stop_at_first_result)
|
|
|
|
return;
|
|
|
|
}
|
2014-12-19 00:44:38 +00:00
|
|
|
}
|
|
|
|
|
2014-12-20 06:13:07 +00:00
|
|
|
bool SpellCheckClient::SpellCheckWord(const base::string16& word_to_check) {
|
2014-12-20 04:42:19 +00:00
|
|
|
if (spell_check_.IsEmpty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
v8::HandleScope handle_scope(isolate_);
|
2015-05-22 11:11:22 +00:00
|
|
|
v8::Local<v8::Value> word = mate::ConvertToV8(isolate_, word_to_check);
|
|
|
|
v8::Local<v8::Value> result = spell_check_.NewHandle()->Call(
|
2014-12-20 04:42:19 +00:00
|
|
|
provider_.NewHandle(), 1, &word);
|
|
|
|
|
|
|
|
if (result->IsBoolean())
|
|
|
|
return result->BooleanValue();
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns whether or not the given string is a valid contraction.
|
|
|
|
// This function is a fall-back when the SpellcheckWordIterator class
|
|
|
|
// returns a concatenated word which is not in the selected dictionary
|
|
|
|
// (e.g. "in'n'out") but each word is valid.
|
|
|
|
bool SpellCheckClient::IsValidContraction(const base::string16& contraction) {
|
|
|
|
if (!contraction_iterator_.IsInitialized() &&
|
|
|
|
!contraction_iterator_.Initialize(&character_attributes_, false)) {
|
|
|
|
// We failed to initialize the word iterator, return as spelled correctly.
|
|
|
|
VLOG(1) << "Failed to initialize contraction_iterator_";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
contraction_iterator_.SetText(contraction.c_str(), contraction.length());
|
|
|
|
|
|
|
|
base::string16 word;
|
|
|
|
int word_start;
|
|
|
|
int word_length;
|
|
|
|
|
|
|
|
while (contraction_iterator_.GetNextWord(&word, &word_start, &word_length)) {
|
2014-12-20 06:13:07 +00:00
|
|
|
if (!SpellCheckWord(word))
|
2014-12-20 04:42:19 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-12-18 21:43:51 +00:00
|
|
|
} // namespace api
|
|
|
|
|
|
|
|
} // namespace atom
|