.: [WK2][EFL] Implementation of spellchecking feature.
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 17 Oct 2012 10:30:52 +0000 (10:30 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 17 Oct 2012 10:30:52 +0000 (10:30 +0000)
https://bugs.webkit.org/show_bug.cgi?id=91854

Patch by Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@sasmung.com> on 2012-10-17
Reviewed by Gyuyoung Kim.

Define SPELLCHECK macro and enable it for WK2-Efl.
The spellchecking implementation is based on the Enchant library.
It can be used by other WebKit ports.

* Source/cmake/FindEnchant.cmake: Added.
* Source/cmake/OptionsEfl.cmake: Enable spellchecking feature for WebKit2-EFL.
* Source/cmake/WebKitFeatures.cmake: Define the SPELLCHECK macro.
* Source/cmakeconfig.h.cmake: Add the feature.

Source/WebCore: [WK2][EFL] Implementation of spellchecking feature.
https://bugs.webkit.org/show_bug.cgi?id=91854

Patch by Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@samsung.com> on 2012-10-17
Reviewed by Gyuyoung Kim.

* PlatformEfl.cmake:
Add enchant-related compiler flags: header paths and the library flag.

Source/WebKit2: Implementation of spellchecking feature.
https://bugs.webkit.org/show_bug.cgi?id=91854

Patch by Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@samsung.com> on 2012-10-17
Reviewed by Gyuyoung Kim.

Add spelling implementation for WebKit2-EFL that is based on Enchant library.

Additionally the patch provides API to overwrite the default WebKit
spellchecker implementation as Enchant library doesn't ensure grammar checking.
Application is able to overwrite it by defining its own implementation and
setting appropriate callback functions.

* PlatformEfl.cmake:
Add enchant-related compiler flags: header paths and the library flag.

* UIProcess/API/efl/EWebKit2.h:
Add ewk_text_checker.h to the main WebKit2-EFL's header to be available for applications.

* UIProcess/API/efl/WebKitTextChecker.cpp: Added.
Implement the callbacks functions of WKTextChecker.

(WebKit):
(WebKit::isContinuousSpellCheckingEnabled):
(WebKit::setContinuousSpellCheckingEnabled):
(WebKit::uniqueSpellDocumentTag):
(WebKit::closeSpellDocumentWithTag):
(WebKit::checkSpellingOfString):
(WebKit::guessesForWord):
(WebKit::learnWord):
(WebKit::ignoreWord):
Those functions are directly given as callback functions for WKTextChecker's client.
They choose between WebKit's spelling implementation and client's ones.

(WebKit::availableSpellCheckingLanguages):
(WebKit::updateSpellCheckingLanguages):
(WebKit::loadedSpellCheckingLanguages):
They are used by ewk_settings.cpp file and allow to do not
expose 'textCheckerEnchant'.

* UIProcess/API/efl/WebKitTextChecker.h: Added.
Define the functions which choose between WebKit's spelling implementation and
the client's ones.

(WebKit):
* UIProcess/API/efl/ewk_context.cpp:
(_Ewk_Context::_Ewk_Context):
Attach the spellchecker feature for the context.

* UIProcess/API/efl/ewk_text_checker.cpp: Added.
(ewk_text_checker_callbacks_get):
An internal function to get the client's callback functions.

* UIProcess/API/efl/ewk_text_checker.h: Added.
Define API to set the client's own spelling implementation.

* UIProcess/API/efl/ewk_text_checker_private.h: Added.
(_Ewk_Text_Checker):
Define the struct with the client's callbacks responisble for spelling.

* UIProcess/API/efl/ewk_settings.cpp:
(onContinuousSpellCheckingIdler):
The application is notified about the spelling setting change on idler
to do not block WebKit.
The the continuous spell checking may be changed through the context menu option.

(spellCheckingLanguagesSetUpdate):
The dictionaries are requested on 'idler' to do not block WebKit.

(spellCheckingLanguagesSet):
Set the languages.

(ewk_settings_continuous_spell_checking_change_cb_set):
Set the callback function used to notify the client when the spelling
setting was changed by WebKit.

(ewk_settings_continuous_spell_checking_enabled_get):
(ewk_settings_continuous_spell_checking_enabled_set):
API to set/get the continuous spell checking.

(ewk_settings_spell_checking_available_languages_get):
(ewk_settings_spell_checking_languages_set):
(ewk_settings_spell_checking_languages_get):
API to get/set languages to use by WebKit implementation based on Enchant library.

* UIProcess/efl/TextCheckerEfl.cpp:
(WebKit::TextChecker::state):
(WebKit::TextChecker::isContinuousSpellCheckingAllowed):
(WebKit::TextChecker::setContinuousSpellCheckingEnabled):
(WebKit::TextChecker::setGrammarCheckingEnabled):
(WebKit::TextChecker::continuousSpellCheckingEnabledStateChanged):
(WebKit::TextChecker::grammarCheckingEnabledStateChanged):
(WebKit::TextChecker::uniqueSpellDocumentTag):
(WebKit::TextChecker::closeSpellDocumentWithTag):
(WebKit::TextChecker::checkSpellingOfString):
(WebKit::TextChecker::checkGrammarOfString): Remove WebCore namaspace as it's already defined for the whole file.
(WebKit::TextChecker::spellingUIIsShowing):
(WebKit::TextChecker::toggleSpellingUIIsShowing):
(WebKit::TextChecker::updateSpellingUIWithMisspelledWord):
(WebKit::TextChecker::updateSpellingUIWithGrammarString):
(WebKit::TextChecker::getGuessesForWord):
(WebKit::TextChecker::learnWord):
(WebKit::TextChecker::ignoreWord):
Those call WKTextChecker client's methods.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@131579 268f45cc-cd09-0410-ab3c-d52691b4dbfc

19 files changed:
ChangeLog
Source/WebCore/ChangeLog
Source/WebCore/PlatformEfl.cmake
Source/WebKit2/ChangeLog
Source/WebKit2/PlatformEfl.cmake
Source/WebKit2/UIProcess/API/efl/EWebKit2.h
Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.cpp [new file with mode: 0644]
Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.h [new file with mode: 0644]
Source/WebKit2/UIProcess/API/efl/ewk_context.cpp
Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp
Source/WebKit2/UIProcess/API/efl/ewk_settings.h
Source/WebKit2/UIProcess/API/efl/ewk_text_checker.cpp [new file with mode: 0644]
Source/WebKit2/UIProcess/API/efl/ewk_text_checker.h [new file with mode: 0644]
Source/WebKit2/UIProcess/API/efl/ewk_text_checker_private.h [new file with mode: 0644]
Source/WebKit2/UIProcess/efl/TextCheckerEfl.cpp
Source/cmake/FindEnchant.cmake [new file with mode: 0644]
Source/cmake/OptionsEfl.cmake
Source/cmake/WebKitFeatures.cmake
Source/cmakeconfig.h.cmake

index 838660f..dd8dc38 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,19 @@
+2012-10-17  Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@sasmung.com>
+
+        [WK2][EFL] Implementation of spellchecking feature.
+        https://bugs.webkit.org/show_bug.cgi?id=91854
+
+        Reviewed by Gyuyoung Kim.
+
+        Define SPELLCHECK macro and enable it for WK2-Efl.
+        The spellchecking implementation is based on the Enchant library.
+        It can be used by other WebKit ports.
+
+        * Source/cmake/FindEnchant.cmake: Added.
+        * Source/cmake/OptionsEfl.cmake: Enable spellchecking feature for WebKit2-EFL.
+        * Source/cmake/WebKitFeatures.cmake: Define the SPELLCHECK macro.
+        * Source/cmakeconfig.h.cmake: Add the feature.
+
 2012-10-16  Pablo Flouret  <pablof@motorola.com>
 
         Pre-process CSSGrammar.y before running through bison.
index 014344b..8844488 100644 (file)
@@ -1,3 +1,13 @@
+2012-10-17  Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@samsung.com>
+
+        [WK2][EFL] Implementation of spellchecking feature.
+        https://bugs.webkit.org/show_bug.cgi?id=91854
+
+        Reviewed by Gyuyoung Kim.
+
+        * PlatformEfl.cmake:
+        Add enchant-related compiler flags: header paths and the library flag.
+
 2012-10-17  Alexander Pavlov  <apavlov@chromium.org>
 
         Web Inspector: Avoid style updates when retrieving the inline stylesheet text
index a68072f..80072fa 100644 (file)
@@ -85,6 +85,7 @@ LIST(APPEND WebCore_SOURCES
   platform/PlatformStrategies.cpp
   platform/posix/FileSystemPOSIX.cpp
   platform/text/efl/TextBreakIteratorInternalICUEfl.cpp
+  platform/text/enchant/TextCheckerEnchant.cpp
 )
 
 IF (ENABLE_BATTERY_STATUS)
@@ -326,3 +327,12 @@ IF (ENABLE_WEB_AUDIO)
   INSTALL(FILES ${WEB_AUDIO_DATA} DESTINATION ${WEB_AUDIO_DIR})
   ADD_DEFINITIONS(-DUNINSTALLED_AUDIO_RESOURCES_DIR="${WEBCORE_DIR}/platform/audio/resources")
 ENDIF ()
+
+IF (ENABLE_SPELLCHECK)
+    LIST(APPEND WebCore_INCLUDE_DIRECTORIES
+        ${ENCHANT_INCLUDE_DIRS}
+    )
+    LIST(APPEND WebCore_LIBRARIES
+        ${ENCHANT_LIBRARIES}
+    )
+ENDIF()
index b04b8cd..5034831 100644 (file)
@@ -1,3 +1,109 @@
+2012-10-17  Grzegorz Czajkowski  <g.czajkowski@samsung.com>, Michal Roj <m.roj@samsung.com>
+
+        Implementation of spellchecking feature.
+        https://bugs.webkit.org/show_bug.cgi?id=91854
+
+        Reviewed by Gyuyoung Kim.
+
+        Add spelling implementation for WebKit2-EFL that is based on Enchant library.
+
+        Additionally the patch provides API to overwrite the default WebKit
+        spellchecker implementation as Enchant library doesn't ensure grammar checking.
+        Application is able to overwrite it by defining its own implementation and
+        setting appropriate callback functions.
+
+        * PlatformEfl.cmake:
+        Add enchant-related compiler flags: header paths and the library flag.
+
+        * UIProcess/API/efl/EWebKit2.h:
+        Add ewk_text_checker.h to the main WebKit2-EFL's header to be available for applications.
+
+        * UIProcess/API/efl/WebKitTextChecker.cpp: Added.
+        Implement the callbacks functions of WKTextChecker.
+
+        (WebKit):
+        (WebKit::isContinuousSpellCheckingEnabled):
+        (WebKit::setContinuousSpellCheckingEnabled):
+        (WebKit::uniqueSpellDocumentTag):
+        (WebKit::closeSpellDocumentWithTag):
+        (WebKit::checkSpellingOfString):
+        (WebKit::guessesForWord):
+        (WebKit::learnWord):
+        (WebKit::ignoreWord):
+        Those functions are directly given as callback functions for WKTextChecker's client.
+        They choose between WebKit's spelling implementation and client's ones.
+
+        (WebKit::availableSpellCheckingLanguages):
+        (WebKit::updateSpellCheckingLanguages):
+        (WebKit::loadedSpellCheckingLanguages):
+        They are used by ewk_settings.cpp file and allow to do not
+        expose 'textCheckerEnchant'.
+
+        * UIProcess/API/efl/WebKitTextChecker.h: Added.
+        Define the functions which choose between WebKit's spelling implementation and
+        the client's ones.
+
+        (WebKit):
+        * UIProcess/API/efl/ewk_context.cpp:
+        (_Ewk_Context::_Ewk_Context):
+        Attach the spellchecker feature for the context.
+
+        * UIProcess/API/efl/ewk_text_checker.cpp: Added.
+        (ewk_text_checker_callbacks_get):
+        An internal function to get the client's callback functions.
+
+        * UIProcess/API/efl/ewk_text_checker.h: Added.
+        Define API to set the client's own spelling implementation.
+
+        * UIProcess/API/efl/ewk_text_checker_private.h: Added.
+        (_Ewk_Text_Checker):
+        Define the struct with the client's callbacks responisble for spelling.
+
+        * UIProcess/API/efl/ewk_settings.cpp:
+        (onContinuousSpellCheckingIdler):
+        The application is notified about the spelling setting change on idler
+        to do not block WebKit.
+        The the continuous spell checking may be changed through the context menu option.
+
+        (spellCheckingLanguagesSetUpdate):
+        The dictionaries are requested on 'idler' to do not block WebKit.
+
+        (spellCheckingLanguagesSet):
+        Set the languages.
+
+        (ewk_settings_continuous_spell_checking_change_cb_set):
+        Set the callback function used to notify the client when the spelling
+        setting was changed by WebKit.
+
+        (ewk_settings_continuous_spell_checking_enabled_get):
+        (ewk_settings_continuous_spell_checking_enabled_set):
+        API to set/get the continuous spell checking.
+
+        (ewk_settings_spell_checking_available_languages_get):
+        (ewk_settings_spell_checking_languages_set):
+        (ewk_settings_spell_checking_languages_get):
+        API to get/set languages to use by WebKit implementation based on Enchant library.
+
+        * UIProcess/efl/TextCheckerEfl.cpp:
+        (WebKit::TextChecker::state):
+        (WebKit::TextChecker::isContinuousSpellCheckingAllowed):
+        (WebKit::TextChecker::setContinuousSpellCheckingEnabled):
+        (WebKit::TextChecker::setGrammarCheckingEnabled):
+        (WebKit::TextChecker::continuousSpellCheckingEnabledStateChanged):
+        (WebKit::TextChecker::grammarCheckingEnabledStateChanged):
+        (WebKit::TextChecker::uniqueSpellDocumentTag):
+        (WebKit::TextChecker::closeSpellDocumentWithTag):
+        (WebKit::TextChecker::checkSpellingOfString):
+        (WebKit::TextChecker::checkGrammarOfString): Remove WebCore namaspace as it's already defined for the whole file.
+        (WebKit::TextChecker::spellingUIIsShowing):
+        (WebKit::TextChecker::toggleSpellingUIIsShowing):
+        (WebKit::TextChecker::updateSpellingUIWithMisspelledWord):
+        (WebKit::TextChecker::updateSpellingUIWithGrammarString):
+        (WebKit::TextChecker::getGuessesForWord):
+        (WebKit::TextChecker::learnWord):
+        (WebKit::TextChecker::ignoreWord):
+        Those call WKTextChecker client's methods.
+
 2012-10-17  Mikhail Pozdnyakov  <mikhail.pozdnyakov@intel.com>
 
         [EFL][WK2] Ewk_Url_Scheme_Request has to be refactored
index 3eea943..d603c59 100644 (file)
@@ -46,6 +46,7 @@ LIST(APPEND WebKit2_SOURCES
     UIProcess/API/efl/NetworkInfoProvider.cpp
     UIProcess/API/efl/PageClientImpl.cpp
     UIProcess/API/efl/VibrationProvider.cpp
+    UIProcess/API/efl/WebKitTextChecker.cpp
     UIProcess/API/efl/ewk_back_forward_list.cpp
     UIProcess/API/efl/ewk_back_forward_list_item.cpp
     UIProcess/API/efl/ewk_context.cpp
@@ -65,6 +66,7 @@ LIST(APPEND WebKit2_SOURCES
     UIProcess/API/efl/ewk_popup_menu_item.cpp
     UIProcess/API/efl/ewk_resource.cpp
     UIProcess/API/efl/ewk_settings.cpp
+    UIProcess/API/efl/ewk_text_checker.cpp
     UIProcess/API/efl/ewk_url_request.cpp
     UIProcess/API/efl/ewk_url_response.cpp
     UIProcess/API/efl/ewk_url_scheme_request.cpp
@@ -136,6 +138,7 @@ LIST(APPEND WebKit2_INCLUDE_DIRECTORIES
     "${WEBCORE_DIR}/platform/efl"
     "${WEBCORE_DIR}/platform/graphics/cairo"
     "${WEBCORE_DIR}/platform/network/soup"
+    "${WEBCORE_DIR}/platform/text/enchant"
     "${WEBCORE_DIR}/svg/graphics"
     "${WEBKIT2_DIR}/Shared/efl"
     "${WEBKIT2_DIR}/Shared/soup"
@@ -242,6 +245,7 @@ SET (EWebKit2_HEADERS
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_popup_menu_item.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_resource.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_settings.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_text_checker.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_touch.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_url_request.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/UIProcess/API/efl/ewk_url_response.h"
@@ -349,3 +353,12 @@ IF (ENABLE_API_TESTS)
     ADD_LIBRARY(ewk2UnitTestInjectedBundleSample SHARED ${TEST_INJECTED_BUNDLE_DIR}/injected_bundle_sample.cpp)
     TARGET_LINK_LIBRARIES(ewk2UnitTestInjectedBundleSample ${WebKit2_LIBRARY_NAME})
 ENDIF ()
+
+IF (ENABLE_SPELLCHECK)
+    LIST(APPEND WebKit2_INCLUDE_DIRECTORIES
+        ${ENCHANT_INCLUDE_DIRS}
+    )
+    LIST(APPEND WebKit2_LIBRARIES
+        ${ENCHANT_LIBRARIES}
+    )
+ENDIF()
index 7d2f879..17afb11 100644 (file)
@@ -44,6 +44,7 @@
 #include "ewk_popup_menu_item.h"
 #include "ewk_resource.h"
 #include "ewk_settings.h"
+#include "ewk_text_checker.h"
 #include "ewk_touch.h"
 #include "ewk_url_request.h"
 #include "ewk_url_response.h"
diff --git a/Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.cpp b/Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.cpp
new file mode 100644 (file)
index 0000000..2ff39c4
--- /dev/null
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WebKitTextChecker.h"
+
+#if ENABLE(SPELLCHECK)
+
+#include "NotImplemented.h"
+#include "WKAPICast.h"
+#include "WKMutableArray.h"
+#include "WKRetainPtr.h"
+#include "WebPageProxy.h"
+#include "WebString.h"
+#include "ewk_settings.h"
+#include "ewk_text_checker_private.h"
+#include <Eina.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/text/CString.h>
+
+namespace WebKit {
+
+static OwnPtr<WebCore::TextCheckerEnchant> textCheckerEnchant = WebCore::TextCheckerEnchant::create();
+
+static Ewk_Text_Checker* ewkTextCheckerCallbacks = ewk_text_checker_callbacks_get();
+
+bool isContinuousSpellCheckingEnabled(const void*)
+{
+    return ewk_settings_continuous_spell_checking_enabled_get();
+}
+
+void setContinuousSpellCheckingEnabled(bool enabled, const void*)
+{
+    ewk_settings_continuous_spell_checking_enabled_set(enabled);
+}
+
+uint64_t uniqueSpellDocumentTag(WKPageRef page, const void*)
+{
+    if (ewkTextCheckerCallbacks->unique_spell_document_tag_get)
+        return ewkTextCheckerCallbacks->unique_spell_document_tag_get(toImpl(page)->viewWidget());
+
+    return 0;
+}
+
+void closeSpellDocumentWithTag(uint64_t tag, const void*)
+{
+    if (ewkTextCheckerCallbacks->unique_spell_document_tag_close)
+        ewkTextCheckerCallbacks->unique_spell_document_tag_close(tag);
+}
+
+void checkSpellingOfString(uint64_t tag, WKStringRef text, int32_t* misspellingLocation, int32_t* misspellingLength, const void*)
+{
+    if (ewkTextCheckerCallbacks->string_spelling_check)
+        ewkTextCheckerCallbacks->string_spelling_check(tag, toImpl(text)->string().utf8().data(), misspellingLocation, misspellingLength);
+    else
+        textCheckerEnchant->checkSpellingOfString(toImpl(text)->string(), *misspellingLocation, *misspellingLength);
+}
+
+WKArrayRef guessesForWord(uint64_t tag, WKStringRef word, const void*)
+{
+    WKMutableArrayRef suggestionsForWord = WKMutableArrayCreate();
+
+    if (ewkTextCheckerCallbacks->word_guesses_get) {
+        Eina_List* list = ewkTextCheckerCallbacks->word_guesses_get(tag, toImpl(word)->string().utf8().data());
+        void* item;
+
+        EINA_LIST_FREE(list, item) {
+            WKRetainPtr<WKStringRef> suggestion(AdoptWK, WKStringCreateWithUTF8CString(static_cast<char*>(item)));
+            WKArrayAppendItem(suggestionsForWord, suggestion.get());
+            free(item);
+        }
+    } else {
+        Vector<String> guesses = textCheckerEnchant->getGuessesForWord(toImpl(word)->string());
+        size_t numberOfGuesses = guesses.size();
+        for (size_t i = 0; i < numberOfGuesses; ++i) {
+            WKRetainPtr<WKStringRef> suggestion(AdoptWK, WKStringCreateWithUTF8CString(guesses[i].utf8().data()));
+            WKArrayAppendItem(suggestionsForWord, suggestion.get());
+        }
+    }
+
+    return suggestionsForWord;
+}
+
+void learnWord(uint64_t tag, WKStringRef word, const void*)
+{
+    if (ewkTextCheckerCallbacks->word_learn)
+        ewkTextCheckerCallbacks->word_learn(tag, toImpl(word)->string().utf8().data());
+    else
+        textCheckerEnchant->learnWord(toImpl(word)->string());
+}
+
+void ignoreWord(uint64_t tag, WKStringRef word, const void*)
+{
+    if (ewkTextCheckerCallbacks->word_ignore)
+        ewkTextCheckerCallbacks->word_ignore(tag, toImpl(word)->string().utf8().data());
+    else
+        textCheckerEnchant->ignoreWord(toImpl(word)->string());
+}
+
+Vector<String> availableSpellCheckingLanguages()
+{
+    return textCheckerEnchant->availableSpellCheckingLanguages();
+}
+
+void updateSpellCheckingLanguages(const Vector<String>& languages)
+{
+    textCheckerEnchant->updateSpellCheckingLanguages(languages);
+}
+
+Vector<String> loadedSpellCheckingLanguages()
+{
+    return textCheckerEnchant->loadedSpellCheckingLanguages();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(SPELLCHECK)
diff --git a/Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.h b/Source/WebKit2/UIProcess/API/efl/WebKitTextChecker.h
new file mode 100644 (file)
index 0000000..4123244
--- /dev/null
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebKitTextChecker_h
+#define WebKitTextChecker_h
+
+#if ENABLE(SPELLCHECK)
+
+#include "TextCheckerEnchant.h"
+#include "WKArray.h"
+#include "WKPage.h"
+#include "WKString.h"
+
+namespace WebKit {
+
+// The functions mainly choose between client's implementation of spelling and the WebKit one.
+
+// Callbacks required by WKTextChecker.
+bool isContinuousSpellCheckingEnabled(const void* clientInfo);
+void setContinuousSpellCheckingEnabled(bool enabled, const void* clientInfo);
+
+uint64_t uniqueSpellDocumentTag(WKPageRef page, const void* clientInfo);
+void closeSpellDocumentWithTag(uint64_t tag, const void* clientInfo);
+
+void checkSpellingOfString(uint64_t tag, WKStringRef text, int32_t* misspellingLocation, int32_t* misspellingLength, const void* clientInfo);
+WKArrayRef guessesForWord(uint64_t tag, WKStringRef word, const void* clientInfo);
+void learnWord(uint64_t tag, WKStringRef word, const void* clientInfo);
+void ignoreWord(uint64_t tag, WKStringRef word, const void* clientInfo);
+
+// Enchant's helper.
+Vector<String> availableSpellCheckingLanguages();
+void updateSpellCheckingLanguages(const Vector<String>& languages);
+Vector<String> loadedSpellCheckingLanguages();
+
+} // namespace WebKit
+
+#endif // ENABLE(SPELLCHECK)
+#endif // WebKitTextChecker_h
index e7f5220..6338eac 100644 (file)
 #include <wtf/HashMap.h>
 #include <wtf/text/WTFString.h>
 
+#if ENABLE(SPELLCHECK)
+#include "ewk_settings.h"
+#include "ewk_text_checker_private.h"
+#endif
+
 using namespace WebCore;
 using namespace WebKit;
 
@@ -117,6 +122,13 @@ struct _Ewk_Context {
         ewk_context_request_manager_client_attach(this);
         ewk_context_download_client_attach(this);
         ewk_context_history_client_attach(this);
+#if ENABLE(SPELLCHECK)
+        ewk_text_checker_client_attach();
+        if (ewk_settings_continuous_spell_checking_enabled_get()) {
+            // Load the default language.
+            ewk_settings_spell_checking_languages_set(0);
+        }
+#endif
     }
 };
 
index a9f6b09..8037611 100644 (file)
 #include <WebKit2/WKPreferences.h>
 #include <WebKit2/WKPreferencesPrivate.h>
 
+#if ENABLE(SPELLCHECK)
+#include "WKTextChecker.h"
+#include "WebKitTextChecker.h"
+#include <Ecore.h>
+#include <wtf/Vector.h>
+#include <wtf/text/CString.h>
+#endif
+
 using namespace WebKit;
 
+#if ENABLE(SPELLCHECK)
+static struct {
+    bool isContinuousSpellCheckingEnabled : 1;
+    Vector<String> spellCheckingLanguages;
+    Ewk_Settings_Continuous_Spell_Checking_Change_Cb onContinuousSpellChecking;
+} ewkTextCheckerSettings = { false, Vector<String>(), 0 };
+
+static Eina_Bool onContinuousSpellCheckingIdler(void*)
+{
+    if (ewkTextCheckerSettings.onContinuousSpellChecking)
+        ewkTextCheckerSettings.onContinuousSpellChecking(ewkTextCheckerSettings.isContinuousSpellCheckingEnabled);
+
+    return ECORE_CALLBACK_CANCEL;
+}
+
+static Eina_Bool spellCheckingLanguagesSetUpdate(void*)
+{
+    // FIXME: Consider to delegate calling of this method in WebProcess to do not delay/block UIProcess.
+    updateSpellCheckingLanguages(ewkTextCheckerSettings.spellCheckingLanguages);
+    return ECORE_CALLBACK_CANCEL;
+}
+
+static void spellCheckingLanguagesSet(const Vector<String>& newLanguages)
+{
+    ewkTextCheckerSettings.spellCheckingLanguages = newLanguages;
+    ecore_idler_add(spellCheckingLanguagesSetUpdate, 0);
+}
+#endif // ENABLE(SPELLCHECK)
+
 Eina_Bool ewk_settings_fullscreen_enabled_set(Ewk_Settings* settings, Eina_Bool enable)
 {
 #if ENABLE(FULLSCREEN_API)
@@ -148,3 +185,75 @@ Eina_Bool ewk_settings_dns_prefetching_enabled_get(const Ewk_Settings* settings)
 
     return WKPreferencesGetDNSPrefetchingEnabled(settings->preferences.get());
 }
+
+void ewk_settings_continuous_spell_checking_change_cb_set(Ewk_Settings_Continuous_Spell_Checking_Change_Cb callback)
+{
+#if ENABLE(SPELLCHECK)
+    ewkTextCheckerSettings.onContinuousSpellChecking = callback;
+#endif
+}
+
+Eina_Bool ewk_settings_continuous_spell_checking_enabled_get()
+{
+#if ENABLE(SPELLCHECK)
+    return ewkTextCheckerSettings.isContinuousSpellCheckingEnabled;
+#else
+    return false;
+#endif
+}
+
+void ewk_settings_continuous_spell_checking_enabled_set(Eina_Bool enable)
+{
+#if ENABLE(SPELLCHECK)
+    enable = !!enable;
+    if (ewkTextCheckerSettings.isContinuousSpellCheckingEnabled != enable) {
+        ewkTextCheckerSettings.isContinuousSpellCheckingEnabled = enable;
+
+        WKTextCheckerContinuousSpellCheckingEnabledStateChanged(enable);
+
+        // Sets the default language if user didn't specify any.
+        if (enable && loadedSpellCheckingLanguages().isEmpty())
+            spellCheckingLanguagesSet(Vector<String>());
+
+        if (ewkTextCheckerSettings.onContinuousSpellChecking)
+            ecore_idler_add(onContinuousSpellCheckingIdler, 0);
+    }
+#endif
+}
+
+Eina_List* ewk_settings_spell_checking_available_languages_get()
+{
+    Eina_List* listOflanguages = 0;
+#if ENABLE(SPELLCHECK)
+    Vector<String> languages = availableSpellCheckingLanguages();
+    size_t numberOfLanuages = languages.size();
+
+    for (size_t i = 0; i < numberOfLanuages; ++i)
+        listOflanguages = eina_list_append(listOflanguages, eina_stringshare_add(languages[i].utf8().data()));
+#endif
+    return listOflanguages;
+}
+
+void ewk_settings_spell_checking_languages_set(const char* languages)
+{
+#if ENABLE(SPELLCHECK)
+    Vector<String> newLanguages;
+    String::fromUTF8(languages).split(',', newLanguages);
+
+    spellCheckingLanguagesSet(newLanguages);
+#endif
+}
+
+Eina_List* ewk_settings_spell_checking_languages_get()
+{
+    Eina_List* listOflanguages = 0;
+#if ENABLE(SPELLCHECK)
+    Vector<String> languages = loadedSpellCheckingLanguages();
+    size_t numberOfLanuages = languages.size();
+
+    for (size_t i = 0; i < numberOfLanuages; ++i)
+        listOflanguages = eina_list_append(listOflanguages, eina_stringshare_add(languages[i].utf8().data()));
+
+#endif
+    return listOflanguages;
+}
index 8b17d1c..1f178b6 100644 (file)
@@ -44,6 +44,15 @@ extern "C" {
 typedef struct _Ewk_Settings Ewk_Settings;
 
 /**
+ * Creates a type name for the callback function used to notify the client when
+ * the continuous spell checking setting was changed by WebKit.
+ *
+ * @param enable @c EINA_TRUE if continuous spell checking is enabled or @c EINA_FALSE if it's disabled
+ */
+typedef void (*Ewk_Settings_Continuous_Spell_Checking_Change_Cb)(Eina_Bool enable);
+
+
+/**
  * Enables/disables the Javascript Fullscreen API. The Javascript API allows
  * to request full screen mode, for more information see:
  * http://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
@@ -219,6 +228,76 @@ EAPI Eina_Bool ewk_settings_dns_prefetching_enabled_set(Ewk_Settings *settings,
  */
 EAPI Eina_Bool ewk_settings_dns_prefetching_enabled_get(const Ewk_Settings *settings);
 
+/**
+ * Sets a callback function used to notify the client when
+ * the continuous spell checking setting was changed by WebKit.
+ *
+ * Specifying of this callback is needed if the application wants to receive notifications
+ * once WebKit changes this setting.
+ * If the application is not interested, this callback is not set.
+ * Changing of this setting at the WebKit level can be made as a result of modifying
+ * options in a Context Menu by a user.
+ *
+ * @param cb a new callback function to set or @c NULL to invalidate the previous one
+ */
+EAPI void ewk_settings_continuous_spell_checking_change_cb_set(Ewk_Settings_Continuous_Spell_Checking_Change_Cb cb);
+
+/**
+ * Queries if continuous spell checking is enabled.
+ *
+ * @return @c EINA_TRUE if continuous spell checking is enabled or @c EINA_FALSE if it's disabled
+ */
+EAPI Eina_Bool ewk_settings_continuous_spell_checking_enabled_get(void);
+
+/**
+ * Enables/disables continuous spell checking.
+ *
+ * Additionally, this function calls a callback function (if defined) to notify
+ * the client about the change of the setting.
+ * This feature is disabled by default.
+ *
+ * @see ewk_settings_continuous_spell_checking_change_cb_set
+ *
+ * @param enable @c EINA_TRUE to enable continuous spell checking or @c EINA_FALSE to disable
+ */
+EAPI void ewk_settings_continuous_spell_checking_enabled_set(Eina_Bool enable);
+
+/**
+ * Gets the the list of all available the spell checking languages to use.
+ *
+ * @see ewk_settings_spell_checking_languages_set
+ *
+ * @return the list with available spell checking languages, or @c NULL on failure
+ *         the Eina_List and its items should be freed after, use eina_stringshare_del()
+ */
+EAPI Eina_List *ewk_settings_spell_checking_available_languages_get(void);
+
+/**
+ * Sets @a languages as the list of languages to use by default WebKit
+ * implementation of spellchecker feature with Enchant library support.
+ *
+ * If @languages is @c NULL, the default language is used.
+ * If the default language can not be determined then any available dictionary will be used.
+ *
+ * @note This function invalidates the previously set languages.
+ *       The dictionaries are requested asynchronously.
+ *
+ * @param languages a list of comma (',') separated language codes
+ *        of the form 'en_US', ie, language_VARIANT, may be @c NULL.
+ */
+EAPI void ewk_settings_spell_checking_languages_set(const char *languages);
+
+/**
+ * Gets the the list of the spell checking languages in use.
+ *
+ * @see ewk_settings_spell_checking_available_languages_get
+ * @see ewk_settings_spell_checking_languages_set
+ *
+ * @return the list with the spell checking languages in use,
+ *         the Eina_List and its items should be freed after, use eina_stringshare_del()
+ */
+EAPI Eina_List *ewk_settings_spell_checking_languages_get(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Source/WebKit2/UIProcess/API/efl/ewk_text_checker.cpp b/Source/WebKit2/UIProcess/API/efl/ewk_text_checker.cpp
new file mode 100644 (file)
index 0000000..525d6d4
--- /dev/null
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ewk_text_checker.h"
+
+#if ENABLE(SPELLCHECK)
+
+#include "WKTextChecker.h"
+#include "WebKitTextChecker.h"
+#include "ewk_text_checker_private.h"
+
+using namespace WebKit;
+
+// Initializes the client's functions to @c 0 to be sure that they are not defined.
+static Ewk_Text_Checker ewkTextCheckerCallbacks = {
+    0, // unique_spell_document_tag_get
+    0, // unique_spell_document_tag_close
+    0, // string_spelling_check
+    0, // word_guesses_get
+    0, // word_learn
+    0 // word_ignore
+};
+
+#define EWK_TEXT_CHECKER_CALLBACK_SET(TYPE_NAME, NAME)  \
+void ewk_text_checker_##NAME##_cb_set(TYPE_NAME cb)     \
+{                                                       \
+    ewkTextCheckerCallbacks.NAME = cb;                  \
+}
+
+/**
+ * Attaches spellchecker feature.
+ *
+ * @internal
+ *
+ * The default spellchecker feature is based on Enchant library.
+ * Client may use own implementation of spellchecker previously set
+ * through the callback functions.
+ */
+void ewk_text_checker_client_attach()
+{
+    static bool didInitializeTextCheckerClient = false;
+    if (didInitializeTextCheckerClient)
+        return;
+
+    WKTextCheckerClient textCheckerClient = {
+        kWKTextCheckerClientCurrentVersion,
+        0, // clientInfo
+        0, // isContinuousSpellCheckingAllowed
+        isContinuousSpellCheckingEnabled,
+        setContinuousSpellCheckingEnabled,
+        0, // isGrammarCheckingEnabled
+        0, // setGrammarCheckingEnabled
+        uniqueSpellDocumentTag,
+        closeSpellDocumentWithTag,
+        checkSpellingOfString,
+        0, // checkGrammarOfString
+        0, // spellingUIIsShowing
+        0, // toggleSpellingUIIsShowing
+        0, // updateSpellingUIWithMisspelledWord
+        0, // updateSpellingUIWithGrammarString
+        guessesForWord,
+        learnWord,
+        ignoreWord
+    };
+    WKTextCheckerSetClient(&textCheckerClient);
+
+    didInitializeTextCheckerClient = true;
+}
+
+/*
+ * Gets the client's callbacks.
+ *
+ * @internal
+ *
+ * The client't callbacks are not defined by default.
+ * If the client hasn't set the callback, the corresponding callback will
+ * return @c 0 and the default WebKit implementation will be used for this
+ * functionality.
+ *
+ * @return the struct with the client's callbacks.
+ */
+Ewk_Text_Checker* ewk_text_checker_callbacks_get()
+{
+    return &ewkTextCheckerCallbacks;
+}
+
+#else
+
+// Defines an empty API to do not break build.
+#define EWK_TEXT_CHECKER_CALLBACK_SET(TYPE_NAME, NAME)  \
+void ewk_text_checker_##NAME##_cb_set(TYPE_NAME)        \
+{                                                       \
+}
+#endif // ENABLE(SPELLCHECK)
+
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_Unique_Spell_Document_Tag_Get_Cb, unique_spell_document_tag_get)
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_Unique_Spell_Document_Tag_Close_Cb, unique_spell_document_tag_close)
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_String_Spelling_Check_Cb, string_spelling_check)
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_Word_Guesses_Get_Cb, word_guesses_get)
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_Word_Learn_Cb, word_learn)
+EWK_TEXT_CHECKER_CALLBACK_SET(Ewk_Text_Checker_Word_Ignore_Cb, word_ignore)
diff --git a/Source/WebKit2/UIProcess/API/efl/ewk_text_checker.h b/Source/WebKit2/UIProcess/API/efl/ewk_text_checker.h
new file mode 100644 (file)
index 0000000..b7aea88
--- /dev/null
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file ewk_text_checker.h
+ * @brief Provides API to overwrite the default WebKit spellchecker implementation.
+ *
+ * There is one spellchecker object per application and it's disabled by default.
+ * It allows to check spelling in the editable areas.
+ * If application wants to enable the feature, API from ewk_settings.h
+ * should be used.
+ *
+ * The default WebKit spellchecker implementation is based on the Enchant library.
+ * It doesn't ensure grammar checking. Application is able to overwrite the default
+ * WebKit spellchecker implementation by defining its own implementation and setting
+ * appropriate callback functions.
+ */
+
+#ifndef ewk_text_checker_h
+#define ewk_text_checker_h
+
+#include <Evas.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Defines a type name for the callback function to return a tag (identifier) which is guaranteed to be unique.
+ *
+ * Unique tags help to avoid collisions with other objects that are checked for spelling mistakes.
+ *
+ * @param o the view object to get unique tag
+ *
+ * @return unique tag for the given @a o view object
+ */
+typedef uint64_t (*Ewk_Text_Checker_Unique_Spell_Document_Tag_Get_Cb)(const Evas_Object *o);
+
+/**
+ * Defines a type name for the callback function to close the prviously set tag.
+ *
+ * This callback will notify the receiver that the user has finished with the tagged document.
+ *
+ * @param tag the tag to be closed
+ */
+typedef void (*Ewk_Text_Checker_Unique_Spell_Document_Tag_Close_Cb)(uint64_t tag);
+
+/**
+ * Defines a type name for the callback function to search for a misspelled words in the given string.
+ *
+ * @param tag unique tag to notify the spell checker which document that @a text is associated,
+ *        in most cases not necessarily, just for ignored word,
+ *        @c 0 can be passed in for text not associated with a particular document
+ * @param text the text containing the words to spellcheck
+ * @param misspelling_location a pointer to store the beginning of the misspelled @a text, @c -1 if the @a text is correct
+ * @param misspelling_length a pointer to store the length of misspelled @a text, @c 0 if the @a text is correct
+ */
+typedef void (*Ewk_Text_Checker_String_Spelling_Check_Cb)(uint64_t tag, const char *text, int32_t *misspelling_location, int32_t *misspelling_length);
+
+/**
+ * Defines a type name for the callback function to get a list of suggested spellings for a misspelled @a word.
+ *
+ * @param tag unique tag to notify the spell checker which document that @a text is associated,
+ *        @c 0 can be passed for text not associated with a particular document
+ * @param word the word to get guesses
+ * @return a list of dynamically allocated strings (as char*) and
+ *         caller is responsible for destroying them.
+ */
+typedef Eina_List *(*Ewk_Text_Checker_Word_Guesses_Get_Cb)(uint64_t tag, const char *word);
+
+/**
+ * Sets a callback function to add the word to the spell checker dictionary.
+ *
+ * @param tag unique tag to notify the spell checker which document that @a text is associated,
+ *        @c 0 can be passed for text not associated with a particular document
+ * @param word the word to add
+ */
+typedef void (*Ewk_Text_Checker_Word_Learn_Cb)(uint64_t tag, const char *word);
+
+/**
+ * Sets a callback function to tell the spell checker to ignore a given word.
+ *
+ * @param tag unique tag to notify the spell checker which document that @a text is associated,
+ *        @c 0 can be passed for text not associated with a particular document
+ * @param word the word to ignore
+ */
+typedef void (*Ewk_Text_Checker_Word_Ignore_Cb)(uint64_t tag, const char *word);
+
+/**
+ * Sets a callback function to get a unique spell document tag.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_unique_spell_document_tag_get_cb_set(Ewk_Text_Checker_Unique_Spell_Document_Tag_Get_Cb cb);
+
+/**
+ * Sets a callback function to close a unique spell document tag.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_unique_spell_document_tag_close_cb_set(Ewk_Text_Checker_Unique_Spell_Document_Tag_Close_Cb cb);
+
+/**
+ * Sets a callback function to search for a misspelled words in the given string.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_string_spelling_check_cb_set(Ewk_Text_Checker_String_Spelling_Check_Cb cb);
+
+/**
+ * Sets a callback function to get an array of suggested spellings for a misspelled word.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_word_guesses_get_cb_set(Ewk_Text_Checker_Word_Guesses_Get_Cb cb);
+
+/**
+ * Sets a callback function to add the word to the spell checker dictionary.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_word_learn_cb_set(Ewk_Text_Checker_Word_Learn_Cb cb);
+
+/**
+ * Sets a callback function to tell the spell checker to ignore a given word.
+ *
+ * @param cb a new callback to set or @c NULL to restore the default WebKit callback implementation
+ */
+EAPI void ewk_text_checker_word_ignore_cb_set(Ewk_Text_Checker_Word_Ignore_Cb cb);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // ewk_text_checker_h
diff --git a/Source/WebKit2/UIProcess/API/efl/ewk_text_checker_private.h b/Source/WebKit2/UIProcess/API/efl/ewk_text_checker_private.h
new file mode 100644 (file)
index 0000000..d45505a
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ewk_text_checker_private_h
+#define ewk_text_checker_private_h
+
+#if ENABLE(SPELLCHECK)
+
+#include "ewk_text_checker.h"
+
+/**
+ * @brief Structure keeps client's callback functions.
+ *
+ * @internal
+ */
+struct _Ewk_Text_Checker {
+    Ewk_Text_Checker_Unique_Spell_Document_Tag_Get_Cb unique_spell_document_tag_get;
+    Ewk_Text_Checker_Unique_Spell_Document_Tag_Close_Cb unique_spell_document_tag_close;
+    Ewk_Text_Checker_String_Spelling_Check_Cb string_spelling_check;
+    Ewk_Text_Checker_Word_Guesses_Get_Cb word_guesses_get;
+    Ewk_Text_Checker_Word_Learn_Cb word_learn;
+    Ewk_Text_Checker_Word_Ignore_Cb word_ignore;
+};
+typedef _Ewk_Text_Checker Ewk_Text_Checker;
+
+Ewk_Text_Checker* ewk_text_checker_callbacks_get();
+
+// Makes it visible for WTR.
+EAPI void ewk_text_checker_client_attach();
+
+#endif // ENABLE(SPELLCHECK)
+#endif // ewk_text_checker_private_h
index 75a8a99..9ec3cc1 100644 (file)
@@ -1,5 +1,7 @@
 /*
- * Copyright (C) 2011 Samsung Electronics
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
+ * Copyright (C) 2011-2012 Samsung Electronics
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "TextChecker.h"
 
 #include "TextCheckerState.h"
-#include <WebCore/NotImplemented.h>
+
+#if ENABLE(SPELLCHECK)
+#include "WebTextChecker.h"
+#endif
 
 using namespace WebCore;
 
@@ -37,91 +42,185 @@ static TextCheckerState textCheckerState;
 
 const TextCheckerState& TextChecker::state()
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    static bool didInitializeState = false;
+    if (didInitializeState)
+        return textCheckerState;
+
+    WebTextCheckerClient& client = WebTextChecker::shared()->client();
+    textCheckerState.isContinuousSpellCheckingEnabled = client.continuousSpellCheckingEnabled();
+    textCheckerState.isGrammarCheckingEnabled = client.grammarCheckingEnabled();
+
+    didInitializeState = true;
+#endif
     return textCheckerState;
 }
 
 bool TextChecker::isContinuousSpellCheckingAllowed()
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    return WebTextChecker::shared()->client().continuousSpellCheckingAllowed();
+#else
     return false;
+#endif
 }
 
-void TextChecker::setContinuousSpellCheckingEnabled(bool)
+void TextChecker::setContinuousSpellCheckingEnabled(bool isContinuousSpellCheckingEnabled)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    if (state().isContinuousSpellCheckingEnabled == isContinuousSpellCheckingEnabled)
+        return;
+
+    textCheckerState.isContinuousSpellCheckingEnabled = isContinuousSpellCheckingEnabled;
+    WebTextChecker::shared()->client().setContinuousSpellCheckingEnabled(isContinuousSpellCheckingEnabled);
+#else
+    UNUSED_PARAM(isContinuousSpellCheckingEnabled);
+#endif
 }
 
-void TextChecker::setGrammarCheckingEnabled(bool)
+void TextChecker::setGrammarCheckingEnabled(bool isGrammarCheckingEnabled)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    if (state().isGrammarCheckingEnabled == isGrammarCheckingEnabled)
+        return;
+
+    textCheckerState.isGrammarCheckingEnabled = isGrammarCheckingEnabled;
+    WebTextChecker::shared()->client().setGrammarCheckingEnabled(isGrammarCheckingEnabled);
+#else
+    UNUSED_PARAM(isGrammarCheckingEnabled);
+#endif
 }
 
-void TextChecker::continuousSpellCheckingEnabledStateChanged(bool /*enabled*/)
+void TextChecker::continuousSpellCheckingEnabledStateChanged(bool enabled)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    textCheckerState.isContinuousSpellCheckingEnabled = enabled;
+#else
+    UNUSED_PARAM(enabled);
+#endif
 }
 
-void TextChecker::grammarCheckingEnabledStateChanged(bool /*enabled*/)
+void TextChecker::grammarCheckingEnabledStateChanged(bool enabled)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    textCheckerState.isGrammarCheckingEnabled = enabled;
+#else
+    UNUSED_PARAM(enabled);
+#endif
 }
 
-int64_t TextChecker::uniqueSpellDocumentTag(WebPageProxy*)
+int64_t TextChecker::uniqueSpellDocumentTag(WebPageProxy* page)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    return WebTextChecker::shared()->client().uniqueSpellDocumentTag(page);
+#else
+    UNUSED_PARAM(page);
     return 0;
+#endif
 }
 
-void TextChecker::closeSpellDocumentWithTag(int64_t)
+void TextChecker::closeSpellDocumentWithTag(int64_t tag)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().closeSpellDocumentWithTag(tag);
+#else
+    UNUSED_PARAM(tag);
+#endif
 }
 
-void TextChecker::checkSpellingOfString(int64_t, const UChar*, uint32_t, int32_t&, int32_t&)
+void TextChecker::checkSpellingOfString(int64_t spellDocumentTag, const UChar* text, uint32_t length, int32_t& misspellingLocation, int32_t& misspellingLength)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().checkSpellingOfString(spellDocumentTag, String(text, length), misspellingLocation, misspellingLength);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(text);
+    UNUSED_PARAM(length);
+    UNUSED_PARAM(misspellingLocation);
+    UNUSED_PARAM(misspellingLength);
+#endif
 }
 
-void TextChecker::checkGrammarOfString(int64_t, const UChar*, uint32_t, Vector<WebCore::GrammarDetail>&, int32_t&, int32_t&)
+void TextChecker::checkGrammarOfString(int64_t spellDocumentTag, const UChar* text, uint32_t length, Vector<GrammarDetail>& grammarDetails, int32_t& badGrammarLocation, int32_t& badGrammarLength)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().checkGrammarOfString(spellDocumentTag, String(text, length), grammarDetails, badGrammarLocation, badGrammarLength);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(text);
+    UNUSED_PARAM(length);
+    UNUSED_PARAM(grammarDetails);
+    UNUSED_PARAM(badGrammarLocation);
+    UNUSED_PARAM(badGrammarLength);
+#endif
 }
 
 bool TextChecker::spellingUIIsShowing()
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    return WebTextChecker::shared()->client().spellingUIIsShowing();
+#else
     return false;
+#endif
 }
 
 void TextChecker::toggleSpellingUIIsShowing()
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().toggleSpellingUIIsShowing();
+#endif
 }
 
-void TextChecker::updateSpellingUIWithMisspelledWord(int64_t, const String&)
+void TextChecker::updateSpellingUIWithMisspelledWord(int64_t spellDocumentTag, const String& misspelledWord)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().updateSpellingUIWithMisspelledWord(spellDocumentTag, misspelledWord);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(misspelledWord);
+#endif
 }
 
-void TextChecker::updateSpellingUIWithGrammarString(int64_t, const String&, const GrammarDetail&)
+void TextChecker::updateSpellingUIWithGrammarString(int64_t spellDocumentTag, const String& badGrammarPhrase, const GrammarDetail& grammarDetail)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().updateSpellingUIWithGrammarString(spellDocumentTag, badGrammarPhrase, grammarDetail);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(badGrammarPhrase);
+    UNUSED_PARAM(grammarDetail);
+#endif
 }
 
-void TextChecker::getGuessesForWord(int64_t, const String&, const String&, Vector<String>&)
+void TextChecker::getGuessesForWord(int64_t spellDocumentTag, const String& word, const String& , Vector<String>& guesses)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().guessesForWord(spellDocumentTag, word, guesses);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(word);
+    UNUSED_PARAM(guesses);
+#endif
 }
 
-void TextChecker::learnWord(int64_t, const String&)
+void TextChecker::learnWord(int64_t spellDocumentTag, const String& word)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().learnWord(spellDocumentTag, word);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(word);
+#endif
 }
 
-void TextChecker::ignoreWord(int64_t, const String&)
+void TextChecker::ignoreWord(int64_t spellDocumentTag, const String& word)
 {
-    notImplemented();
+#if ENABLE(SPELLCHECK)
+    WebTextChecker::shared()->client().ignoreWord(spellDocumentTag, word);
+#else
+    UNUSED_PARAM(spellDocumentTag);
+    UNUSED_PARAM(word);
+#endif
 }
 
 } // namespace WebKit
diff --git a/Source/cmake/FindEnchant.cmake b/Source/cmake/FindEnchant.cmake
new file mode 100644 (file)
index 0000000..d69c71c
--- /dev/null
@@ -0,0 +1,43 @@
+# - Try to find Enchant
+# Once done, this will define
+#
+#  ENCHANT_INCLUDE_DIRS - the Enchant include drectories
+#  ENCHANT_LIBRARIES - link these to use Enchant
+#
+# Copyright (C) 2012 Samsung Electronics
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1.  Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+# 2.  Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS
+# IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+FIND_PACKAGE(PkgConfig)
+PKG_CHECK_MODULES(PC_ENCHANT enchant)
+
+FIND_PATH(ENCHANT_INCLUDE_DIRS
+    NAMES enchant.h
+    PATHS ${PC_ENCHANT_INCLUDEDIR}
+          ${PC_ENCHANT_INCLUDE_DIRS}
+)
+
+FIND_LIBRARY(ENCHANT_LIBRARIES
+    NAMES enchant
+    PATHS ${PC_ENCHANT_LIBDIR}
+          ${PC_ENCHANT_LIBRARY_DIRS}
+)
index e929d23..c87656a 100644 (file)
@@ -82,6 +82,7 @@ WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_REGIONS ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_REQUEST_ANIMATION_FRAME ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_SHADOW_DOM ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_SHARED_WORKERS ON)
+WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_SPELLCHECK ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_VIBRATION ON)
 WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_VIDEO ON)
@@ -184,3 +185,7 @@ IF (WTF_USE_TILED_BACKING_STORE)
   FIND_PACKAGE(OpenGL REQUIRED)
 ENDIF()
 
+IF (ENABLE_SPELLCHECK)
+      FIND_PACKAGE(Enchant REQUIRED)
+      ADD_DEFINITIONS(-DENABLE_SPELLCHECK=1)
+ENDIF()
index f1d8659..b7f75d8 100644 (file)
@@ -98,6 +98,7 @@ MACRO (WEBKIT_OPTION_BEGIN)
     WEBKIT_OPTION_DEFINE(ENABLE_SCRIPTED_SPEECH "Toggle Scripted Speech API support" OFF)
     WEBKIT_OPTION_DEFINE(ENABLE_SHADOW_DOM "Toggle Shadow DOM support" OFF)
     WEBKIT_OPTION_DEFINE(ENABLE_SHARED_WORKERS "Toggle SharedWorkers support" OFF)
+    WEBKIT_OPTION_DEFINE(ENABLE_SPELLCHECK "Toggle Spellchecking support (requires Enchant)" OFF)
     WEBKIT_OPTION_DEFINE(ENABLE_SQL_DATABASE "Toggle SQL Database Support" ON)
     WEBKIT_OPTION_DEFINE(ENABLE_STYLE_SCOPED "Toggle <style scoped> support" OFF)
     WEBKIT_OPTION_DEFINE(ENABLE_SVG "Toggle SVG support" ON)
index 3fb5562..20505cb 100644 (file)
@@ -94,6 +94,7 @@
 #cmakedefine01 ENABLE_SHADOW_DOM
 #cmakedefine01 ENABLE_SHARED_WORKERS
 #cmakedefine01 ENABLE_SMOOTH_SCROLLING
+#cmakedefine01 ENABLE_SPELLCHECK
 #cmakedefine01 ENABLE_SQL_DATABASE
 #cmakedefine01 ENABLE_STYLE_SCOPED
 #cmakedefine01 ENABLE_SVG