TextCheckerGtk.cpp [plain text]
#include "config.h"
#include "TextChecker.h"
#include "TextCheckerState.h"
#include "WebProcessPool.h"
#include <WebCore/NotImplemented.h>
#include <WebCore/TextCheckerEnchant.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/text/TextBreakIterator.h>
using namespace WebCore;
namespace WebKit {
#if ENABLE(SPELLCHECK)
static WebCore::TextCheckerEnchant& enchantTextChecker()
{
static NeverDestroyed<WebCore::TextCheckerEnchant> checker;
return checker;
}
#endif
TextCheckerState& checkerState()
{
static TextCheckerState textCheckerState;
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
textCheckerState.isContinuousSpellCheckingEnabled = false;
textCheckerState.isGrammarCheckingEnabled = false;
});
return textCheckerState;
}
const TextCheckerState& TextChecker::state()
{
return checkerState();
}
#if ENABLE(SPELLCHECK)
static void updateStateForAllProcessPools()
{
for (const auto& processPool : WebProcessPool::allProcessPools())
processPool->textCheckerStateChanged();
}
#endif
bool TextChecker::isContinuousSpellCheckingAllowed()
{
#if ENABLE(SPELLCHECK)
return true;
#else
return false;
#endif
}
void TextChecker::setContinuousSpellCheckingEnabled(bool isContinuousSpellCheckingEnabled)
{
#if ENABLE(SPELLCHECK)
if (checkerState().isContinuousSpellCheckingEnabled == isContinuousSpellCheckingEnabled)
return;
checkerState().isContinuousSpellCheckingEnabled = isContinuousSpellCheckingEnabled;
updateStateForAllProcessPools();
#else
UNUSED_PARAM(isContinuousSpellCheckingEnabled);
#endif
}
void TextChecker::setGrammarCheckingEnabled(bool isGrammarCheckingEnabled)
{
#if ENABLE(SPELLCHECK)
if (checkerState().isGrammarCheckingEnabled == isGrammarCheckingEnabled)
return;
checkerState().isGrammarCheckingEnabled = isGrammarCheckingEnabled;
updateStateForAllProcessPools();
#else
UNUSED_PARAM(isGrammarCheckingEnabled);
#endif
}
void TextChecker::continuousSpellCheckingEnabledStateChanged(bool enabled)
{
#if ENABLE(SPELLCHECK)
checkerState().isContinuousSpellCheckingEnabled = enabled;
#else
UNUSED_PARAM(enabled);
#endif
}
void TextChecker::grammarCheckingEnabledStateChanged(bool enabled)
{
#if ENABLE(SPELLCHECK)
checkerState().isGrammarCheckingEnabled = enabled;
#else
UNUSED_PARAM(enabled);
#endif
}
int64_t TextChecker::uniqueSpellDocumentTag(WebPageProxy*)
{
return 0;
}
void TextChecker::closeSpellDocumentWithTag(int64_t )
{
}
void TextChecker::checkSpellingOfString(int64_t , StringView text, int32_t& misspellingLocation, int32_t& misspellingLength)
{
#if ENABLE(SPELLCHECK)
misspellingLocation = -1;
misspellingLength = 0;
enchantTextChecker().checkSpellingOfString(text.toStringWithoutCopying(), misspellingLocation, misspellingLength);
#else
UNUSED_PARAM(text);
UNUSED_PARAM(misspellingLocation);
UNUSED_PARAM(misspellingLength);
#endif
}
void TextChecker::checkGrammarOfString(int64_t , StringView , Vector<WebCore::GrammarDetail>& , int32_t& , int32_t& )
{
}
bool TextChecker::spellingUIIsShowing()
{
return false;
}
void TextChecker::toggleSpellingUIIsShowing()
{
}
void TextChecker::updateSpellingUIWithMisspelledWord(int64_t , const String& )
{
}
void TextChecker::updateSpellingUIWithGrammarString(int64_t , const String& , const GrammarDetail& )
{
}
void TextChecker::getGuessesForWord(int64_t , const String& word, const String& , int32_t , Vector<String>& guesses, bool)
{
#if ENABLE(SPELLCHECK)
guesses = enchantTextChecker().getGuessesForWord(word);
#else
UNUSED_PARAM(word);
UNUSED_PARAM(guesses);
#endif
}
void TextChecker::learnWord(int64_t , const String& word)
{
#if ENABLE(SPELLCHECK)
enchantTextChecker().learnWord(word);
#else
UNUSED_PARAM(word);
#endif
}
void TextChecker::ignoreWord(int64_t , const String& word)
{
#if ENABLE(SPELLCHECK)
enchantTextChecker().ignoreWord(word);
#else
UNUSED_PARAM(word);
#endif
}
void TextChecker::requestCheckingOfString(PassRefPtr<TextCheckerCompletion> completion, int32_t insertionPoint)
{
#if ENABLE(SPELLCHECK)
if (!completion)
return;
TextCheckingRequestData request = completion->textCheckingRequestData();
ASSERT(request.sequence() != unrequestedTextCheckingSequence);
ASSERT(request.mask() != TextCheckingTypeNone);
completion->didFinishCheckingText(checkTextOfParagraph(completion->spellDocumentTag(), request.text(), insertionPoint, request.mask(), false));
#else
UNUSED_PARAM(completion);
#endif
}
#if USE(UNIFIED_TEXT_CHECKING) && ENABLE(SPELLCHECK)
static unsigned nextWordOffset(StringView text, unsigned currentOffset)
{
TextBreakIterator* textIterator = wordBreakIterator(text);
if (!textIterator)
return currentOffset;
unsigned wordOffset = currentOffset;
while (wordOffset < text.length() && isTextBreak(textIterator, wordOffset))
++wordOffset;
if (!currentOffset && wordOffset == 1)
return currentOffset;
if ((wordOffset - currentOffset) > 1)
--wordOffset;
return wordOffset;
}
#endif
#if USE(UNIFIED_TEXT_CHECKING)
Vector<TextCheckingResult> TextChecker::checkTextOfParagraph(int64_t spellDocumentTag, StringView text, int32_t insertionPoint, uint64_t checkingTypes, bool)
{
UNUSED_PARAM(insertionPoint);
#if ENABLE(SPELLCHECK)
if (!(checkingTypes & TextCheckingTypeSpelling))
return Vector<TextCheckingResult>();
TextBreakIterator* textIterator = wordBreakIterator(text);
if (!textIterator)
return Vector<TextCheckingResult>();
unsigned offset = nextWordOffset(text, 0);
unsigned lengthStrip = text.length();
while (lengthStrip > 0 && isTextBreak(textIterator, lengthStrip - 1))
--lengthStrip;
Vector<TextCheckingResult> paragraphCheckingResult;
while (offset < lengthStrip) {
int32_t misspellingLocation = -1;
int32_t misspellingLength = 0;
checkSpellingOfString(spellDocumentTag, text.substring(offset, lengthStrip - offset), misspellingLocation, misspellingLength);
if (!misspellingLength)
break;
TextCheckingResult misspellingResult;
misspellingResult.type = TextCheckingTypeSpelling;
misspellingResult.location = offset + misspellingLocation;
misspellingResult.length = misspellingLength;
paragraphCheckingResult.append(misspellingResult);
offset += misspellingLocation + misspellingLength;
offset = nextWordOffset(text.substring(0, lengthStrip), offset);
}
return paragraphCheckingResult;
#else
UNUSED_PARAM(spellDocumentTag);
UNUSED_PARAM(text);
UNUSED_PARAM(checkingTypes);
return Vector<TextCheckingResult>();
#endif // ENABLE(SPELLCHECK)
}
#endif // USE(UNIFIED_TEXT_CHECKING)
void TextChecker::setSpellCheckingLanguages(const Vector<String>& languages)
{
#if ENABLE(SPELLCHECK)
enchantTextChecker().updateSpellCheckingLanguages(languages);
#else
UNUSED_PARAM(languages);
#endif
}
Vector<String> TextChecker::loadedSpellCheckingLanguages()
{
#if ENABLE(SPELLCHECK)
return enchantTextChecker().loadedSpellCheckingLanguages();
#else
return Vector<String>();
#endif
}
}