Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
SUSE:SLE-15-SP3:GA
mozc
fcitx-mozc-2.23.2815.102.1.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File fcitx-mozc-2.23.2815.102.1.patch of Package mozc
diff --git a/src/unix/fcitx/eim.cc b/src/unix/fcitx/eim.cc new file mode 100644 index 00000000..ce3e205a --- /dev/null +++ b/src/unix/fcitx/eim.cc @@ -0,0 +1,271 @@ +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 <fcitx/instance.h> +#include <fcitx/ime.h> +#include <fcitx/hook.h> +#include <fcitx/module.h> +#include <fcitx/keys.h> +#include <fcitx-config/xdg.h> +#include "fcitx_mozc.h" +#include "mozc_connection.h" +#include "mozc_response_parser.h" +#include "base/init_mozc.h" + +typedef struct _FcitxMozcState { + mozc::fcitx::FcitxMozc* mozc; + int inUsageState; +} FcitxMozcState; + + +static void* FcitxMozcCreate(FcitxInstance* instance); +static void FcitxMozcDestroy(void *arg); +static boolean FcitxMozcInit(void *arg); /**< FcitxMozcInit */ +static void FcitxMozcResetIM(void *arg); /**< FcitxMozcResetIM */ +static void FcitxMozcReset(void *arg); /**< FcitxMozcResetIM */ +static INPUT_RETURN_VALUE FcitxMozcDoInput(void *arg, FcitxKeySym, unsigned int); /**< FcitxMozcDoInput */ +static INPUT_RETURN_VALUE FcitxMozcDoReleaseInput(void *arg, FcitxKeySym, unsigned int); /**< FcitxMozcDoInput */ +static void FcitxMozcSave(void *arg); /**< FcitxMozcSave */ +static void FcitxMozcReloadConfig(void *arg); /**< FcitxMozcReloadConfig */ + +extern "C" { + +FCITX_EXPORT_API +FcitxIMClass ime = { + FcitxMozcCreate, + FcitxMozcDestroy +}; +FCITX_EXPORT_API +int ABI_VERSION = FCITX_ABI_VERSION; + +} + +static inline bool CheckLayout(FcitxInstance* instance) +{ + char *layout = NULL, *variant = NULL; + FcitxModuleFunctionArg args; + args.args[0] = &layout; + args.args[1] = &variant; + bool layout_is_jp = false; + FcitxModuleInvokeFunctionByName(instance, "fcitx-xkb", 1, args); + if (layout && strcmp(layout, "jp") == 0) + layout_is_jp = true; + + fcitx_utils_free(layout); + fcitx_utils_free(variant); + + + return layout_is_jp; +} + +static void* FcitxMozcCreate(FcitxInstance* instance) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) fcitx_utils_malloc0(sizeof(FcitxMozcState)); + bindtextdomain("fcitx-mozc", LOCALEDIR); + bind_textdomain_codeset("fcitx-mozc", "UTF-8"); + + int argc = 1; + char argv0[] = "fcitx_mozc"; + char *_argv[] = { argv0 }; + char **argv = _argv; + mozc::InitMozc(argv[0], &argc, &argv, true); + mozcState->mozc = new mozc::fcitx::FcitxMozc( + instance, + mozc::fcitx::MozcConnection::CreateMozcConnection(), + new mozc::fcitx::MozcResponseParser + ); + + mozcState->mozc->SetCompositionMode(mozc::commands::HIRAGANA); + + FcitxIMEventHook hk; + hk.arg = mozcState; + hk.func = FcitxMozcReset; + + FcitxInstanceRegisterResetInputHook(instance, hk); + + FcitxIMIFace iface; + memset(&iface, 0, sizeof(FcitxIMIFace)); + iface.Init = FcitxMozcInit; + iface.ResetIM = FcitxMozcResetIM; + iface.DoInput = FcitxMozcDoInput; + iface.DoReleaseInput = FcitxMozcDoReleaseInput; + iface.ReloadConfig = FcitxMozcReloadConfig; + iface.Save = FcitxMozcSave; + + + FcitxInstanceRegisterIMv2( + instance, + mozcState, + "mozc", + "Mozc", + mozcState->mozc->GetIconFile("mozc.png").c_str(), + iface, + 1, + "ja" + ); + + return mozcState; +} + +static void FcitxMozcDestroy(void *arg) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + delete mozcState->mozc; + free(mozcState); +} + +static const FcitxHotkey MOZC_CTRL_ALT_H[2] = { + {NULL, FcitxKey_H, FcitxKeyState_Ctrl_Alt}, + {NULL, FcitxKey_None, 0} +}; + +INPUT_RETURN_VALUE FcitxMozcDoInput(void* arg, FcitxKeySym _sym, unsigned int _state) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + FcitxInstance* instance = mozcState->mozc->GetInstance(); + FcitxInputState* input = FcitxInstanceGetInputState(mozcState->mozc->GetInstance()); + + if (mozcState->inUsageState) { + if (FcitxHotkeyIsHotKey(_sym, _state, FCITX_ESCAPE)) { + mozcState->inUsageState = false; + // send a dummy key to let server send us the candidate info back without side effect + mozcState->mozc->process_key_event(FcitxKey_VoidSymbol, 0, 0, CheckLayout(instance), false); + return IRV_DISPLAY_CANDWORDS; + } else { + return IRV_DO_NOTHING; + } + } + + if (FcitxHotkeyIsHotKey(_sym, _state, MOZC_CTRL_ALT_H)) { + std::pair< string, string > usage = mozcState->mozc->GetUsage(); + if (usage.first.size() != 0 || usage.second.size() != 0) { + mozcState->inUsageState = true; + FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(mozcState->mozc->GetInputState()); + + // clear preedit, but keep client preedit + FcitxMessages* preedit = FcitxInputStateGetPreedit(input); + FcitxMessagesSetMessageCount(preedit, 0); + FcitxInputStateSetShowCursor(input, false); + + // clear aux + FcitxMessages* auxUp = FcitxInputStateGetAuxUp(input); + FcitxMessages* auxDown = FcitxInputStateGetAuxDown(input); + FcitxMessagesSetMessageCount(auxUp, 0); + FcitxMessagesSetMessageCount(auxDown, 0); + + // clear candidate table + FcitxCandidateWordReset(candList); + FcitxCandidateWordSetPageSize(candList, 9); + FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical); + FcitxCandidateWordSetChoose(candList, "\0\0\0\0\0\0\0\0\0\0"); + FcitxMessagesAddMessageAtLast(preedit, MSG_TIPS, "%s [%s]", usage.first.c_str(), _("Press Escape to go back")); + + UT_array* lines = fcitx_utils_split_string(usage.second.c_str(), '\n'); + utarray_foreach(line, lines, char*) { + FcitxCandidateWord candWord; + candWord.callback = NULL; + candWord.extraType = MSG_OTHER; + candWord.strExtra = NULL; + candWord.priv = NULL; + candWord.strWord = strdup(*line); + candWord.wordType = MSG_OTHER; + candWord.owner = NULL; + FcitxCandidateWordAppend(candList, &candWord); + } + utarray_free(lines); + return IRV_DISPLAY_MESSAGE; + } + } + + FCITX_UNUSED(_sym); + FCITX_UNUSED(_state); + FcitxKeySym sym = (FcitxKeySym) FcitxInputStateGetKeySym(input); + uint32 keycode = FcitxInputStateGetKeyCode(input); + uint32 state = FcitxInputStateGetKeyState(input); + bool result = mozcState->mozc->process_key_event(sym, keycode, state, CheckLayout(instance), false); + if (!result) + return IRV_TO_PROCESS; + else + return IRV_DISPLAY_CANDWORDS; +} + +INPUT_RETURN_VALUE FcitxMozcDoReleaseInput(void* arg, FcitxKeySym _sym, unsigned int _state) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + FcitxInstance* instance = mozcState->mozc->GetInstance(); + FcitxInputState* input = FcitxInstanceGetInputState(mozcState->mozc->GetInstance()); + FCITX_UNUSED(_sym); + FCITX_UNUSED(_state); + + if (mozcState->inUsageState) { + return IRV_DONOT_PROCESS; + } + + FcitxKeySym sym = (FcitxKeySym) FcitxInputStateGetKeySym(input); + uint32 keycode = FcitxInputStateGetKeyCode(input); + uint32 state = FcitxInputStateGetKeyState(input); + bool result = mozcState->mozc->process_key_event(sym, keycode, state, CheckLayout(instance), true); + if (!result) + return IRV_TO_PROCESS; + else + return IRV_DISPLAY_CANDWORDS; +} + + + +boolean FcitxMozcInit(void* arg) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + mozcState->mozc->init(); + return true; +} + +void FcitxMozcReloadConfig(void* arg) +{ + +} + +void FcitxMozcSave(void* arg) +{ + FCITX_UNUSED(arg); +} + +void FcitxMozcResetIM(void* arg) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + mozcState->inUsageState = false; + mozcState->mozc->resetim(); +} + +void FcitxMozcReset(void* arg) +{ + FcitxMozcState* mozcState = (FcitxMozcState*) arg; + mozcState->mozc->reset(); + +} diff --git a/src/unix/fcitx/fcitx-mozc.conf b/src/unix/fcitx/fcitx-mozc.conf new file mode 100644 index 00000000..65d0e113 --- /dev/null +++ b/src/unix/fcitx/fcitx-mozc.conf @@ -0,0 +1,11 @@ +[Addon] +Name=fcitx-mozc +GeneralName=Mozc +Comment=Mozc support for Fcitx +Category=InputMethod +Enabled=True +Library=fcitx-mozc.so +Type=SharedLibrary +SubConfig= +IMRegisterMethod=ConfigFile +LoadLocal=True diff --git a/src/unix/fcitx/fcitx.gyp b/src/unix/fcitx/fcitx.gyp new file mode 100644 index 00000000..e59d43a3 --- /dev/null +++ b/src/unix/fcitx/fcitx.gyp @@ -0,0 +1,111 @@ +# +# Copyright (c) 2010-2012 fcitx Project http://code.google.com/p/fcitx/ +# +# All rights reserved. +# +# 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. +# 3. Neither the name of authors nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# 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 HOLDERS 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. +# + +{ + 'variables': { + 'use_fcitx%': 'YES', + 'relative_dir': 'unix/fcitx', + 'gen_out_dir': '<(SHARED_INTERMEDIATE_DIR)/<(relative_dir)', + 'pkg_config_libs': [ + 'fcitx', + 'fcitx-config', + 'fcitx-utils', + ], + 'fcitx_dep_include_dirs': [ + ], + 'fcitx_dependencies': [ + '../../base/base.gyp:base', + '../../client/client.gyp:client', + '../../ipc/ipc.gyp:ipc', + '../../session/session_base.gyp:ime_switch_util', + '../../protocol/protocol.gyp:commands_proto', + ], + }, + 'conditions': [['use_fcitx=="YES"', { + 'targets': [ + { + 'target_name': 'gen_fcitx_mozc_i18n', + 'type': 'none', + 'actions': [ + { + 'action_name': 'gen_fcitx_mozc_i18n', + 'inputs': [ + './gen_fcitx_mozc_i18n.sh' + ], + 'outputs': [ + '<(gen_out_dir)/po/zh_CN.mo', + '<(gen_out_dir)/po/zh_TW.mo', + '<(gen_out_dir)/po/ja.mo', + '<(gen_out_dir)/po/de.mo', + ], + 'action': [ + 'sh', + './gen_fcitx_mozc_i18n.sh', + '<(gen_out_dir)/po', + ], + }], + }, + { + 'target_name': 'fcitx-mozc', + 'product_prefix': '', + 'type': 'loadable_module', + 'sources': [ + 'fcitx_mozc.cc', + 'fcitx_key_translator.cc', + 'fcitx_key_event_handler.cc', + 'mozc_connection.cc', + 'mozc_response_parser.cc', + 'surrounding_text_util.cc', + 'eim.cc', + ], + 'dependencies': [ + '<@(fcitx_dependencies)', + 'gen_fcitx_mozc_i18n', + ], + 'cflags': [ + '<!@(pkg-config --cflags <@(pkg_config_libs))', + ], + 'include_dirs': [ + '<@(fcitx_dep_include_dirs)', + ], + 'defines': [ + 'LOCALEDIR="<!@(fcitx4-config --prefix)/share/locale/"', + ], + }, + ], + }, { + 'targets': [ + { + 'target_name': 'no_fcitx_dummy', + 'type': 'none', + } + ]} + ]], +} diff --git a/src/unix/fcitx/fcitx_key_event_handler.cc b/src/unix/fcitx/fcitx_key_event_handler.cc new file mode 100644 index 00000000..4ec8b5d0 --- /dev/null +++ b/src/unix/fcitx/fcitx_key_event_handler.cc @@ -0,0 +1,243 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/fcitx_key_event_handler.h" + +#include <map> + +#include "base/logging.h" +#include "base/singleton.h" + +namespace mozc { +namespace fcitx { + +namespace { +// TODO(hsumita): Removes this class, and moves |data_| into member +// variables of KeyEventhandler. +class AdditionalModifiersData { + public: + AdditionalModifiersData() { + data_[commands::KeyEvent::LEFT_ALT] = commands::KeyEvent::ALT; + data_[commands::KeyEvent::RIGHT_ALT] = commands::KeyEvent::ALT; + data_[commands::KeyEvent::LEFT_CTRL] = commands::KeyEvent::CTRL; + data_[commands::KeyEvent::RIGHT_CTRL] = commands::KeyEvent::CTRL; + data_[commands::KeyEvent::LEFT_SHIFT] = commands::KeyEvent::SHIFT; + data_[commands::KeyEvent::RIGHT_SHIFT] = commands::KeyEvent::SHIFT; + } + const std::map<uint32, commands::KeyEvent::ModifierKey> &data() { + return data_; + } + + private: + std::map<uint32, commands::KeyEvent::ModifierKey> data_; +}; + +// TODO(hsumita): Moves this function into member functions of +// KeyEventHandler. +void AddAdditionalModifiers( + std::set<commands::KeyEvent::ModifierKey> *modifier_keys_set) { + DCHECK(modifier_keys_set); + + const std::map<uint32, commands::KeyEvent::ModifierKey> &data = + Singleton<AdditionalModifiersData>::get()->data(); + + // Adds MODIFIER if there are (LEFT|RIGHT)_MODIFIER like LEFT_SHIFT. + for (std::set<commands::KeyEvent::ModifierKey>::const_iterator it = + modifier_keys_set->begin(); it != modifier_keys_set->end(); ++it) { + std::map<uint32, commands::KeyEvent::ModifierKey>::const_iterator item = + data.find(*it); + if (item != data.end()) { + modifier_keys_set->insert(item->second); + } + } +} + +bool IsModifierToBeSentOnKeyUp(const commands::KeyEvent &key_event) { + if (key_event.modifier_keys_size() == 0) { + return false; + } + + if (key_event.modifier_keys_size() == 1 && + key_event.modifier_keys(0) == commands::KeyEvent::CAPS) { + return false; + } + + return true; +} +} // namespace + +KeyEventHandler::KeyEventHandler() : key_translator_(new KeyTranslator) { + Clear(); +} + +bool KeyEventHandler::GetKeyEvent( + FcitxKeySym keyval, uint32 keycode, uint32 modifiers, + config::Config::PreeditMethod preedit_method, + bool layout_is_jp, bool is_key_up, commands::KeyEvent *key) { + DCHECK(key); + key->Clear(); + + if (!key_translator_->Translate( + keyval, keycode, modifiers, preedit_method, layout_is_jp, key)) { + LOG(ERROR) << "Translate failed"; + return false; + } + + return ProcessModifiers(is_key_up, keyval, key); +} + +void KeyEventHandler::Clear() { + is_non_modifier_key_pressed_ = false; + currently_pressed_modifiers_.clear(); + modifiers_to_be_sent_.clear(); +} + +bool KeyEventHandler::ProcessModifiers(bool is_key_up, uint32 keyval, + commands::KeyEvent *key_event) { + // Manage modifier key event. + // Modifier key event is sent on key up if non-modifier key has not been + // pressed since key down of modifier keys and no modifier keys are pressed + // anymore. + // Following examples are expected behaviors. + // + // E.g.) Shift key is special. If Shift + printable key is pressed, key event + // does NOT have shift modifiers. It is handled by KeyTranslator class. + // <Event from ibus> <Event to server> + // Shift down | None + // "a" down | A + // "a" up | None + // Shift up | None + // + // E.g.) Usual key is sent on key down. Modifier keys are not sent if usual + // key is sent. + // <Event from ibus> <Event to server> + // Ctrl down | None + // "a" down | Ctrl+a + // "a" up | None + // Ctrl up | None + // + // E.g.) Modifier key is sent on key up. + // <Event from ibus> <Event to server> + // Shift down | None + // Shift up | Shift + // + // E.g.) Multiple modifier keys are sent on the last key up. + // <Event from ibus> <Event to server> + // Shift down | None + // Control down | None + // Shift up | None + // Control up | Control+Shift + // + // Essentialy we cannot handle modifier key evnet perfectly because + // - We cannot get current keyboard status with ibus. If some modifiers + // are pressed or released without focusing the target window, we + // cannot handle it. + // E.g.) + // <Event from ibus> <Event to server> + // Ctrl down | None + // (focuses out, Ctrl up, focuses in) + // Shift down | None + // Shift up | None (But we should send Shift key) + // To avoid a inconsistent state as much as possible, we clear states + // when key event without modifier keys is sent. + + const bool is_modifier_only = + !(key_event->has_key_code() || key_event->has_special_key()); + + // We may get only up/down key event when a user moves a focus. + // This code handles such situation as much as possible. + // This code has a bug. If we send Shift + 'a', KeyTranslator removes a shift + // modifier and converts 'a' to 'A'. This codes does NOT consider these + // situation since we don't have enough data to handle it. + // TODO(hsumita): Moves the logic about a handling of Shift or Caps keys from + // KeyTranslator to MozcEngine. + if (key_event->modifier_keys_size() == 0) { + Clear(); + } + + if (!currently_pressed_modifiers_.empty() && !is_modifier_only) { + is_non_modifier_key_pressed_ = true; + } + if (is_non_modifier_key_pressed_) { + modifiers_to_be_sent_.clear(); + } + + if (is_key_up) { + currently_pressed_modifiers_.erase(keyval); + if (!is_modifier_only) { + return false; + } + if (!currently_pressed_modifiers_.empty() || + modifiers_to_be_sent_.empty()) { + is_non_modifier_key_pressed_ = false; + return false; + } + if (is_non_modifier_key_pressed_) { + return false; + } + DCHECK(!is_non_modifier_key_pressed_); + + // Modifier key event fires + key_event->mutable_modifier_keys()->Clear(); + for (std::set<commands::KeyEvent::ModifierKey>::const_iterator it = + modifiers_to_be_sent_.begin(); + it != modifiers_to_be_sent_.end(); + ++it) { + key_event->add_modifier_keys(*it); + } + modifiers_to_be_sent_.clear(); + } else if (is_modifier_only) { + // TODO(hsumita): Supports a key sequence below. + // - Ctrl down + // - a down + // - Alt down + // We should add Alt key to |currently_pressed_modifiers|, but current + // implementation does NOT do it. + if (currently_pressed_modifiers_.empty() || + !modifiers_to_be_sent_.empty()) { + for (size_t i = 0; i < key_event->modifier_keys_size(); ++i) { + modifiers_to_be_sent_.insert(key_event->modifier_keys(i)); + } + AddAdditionalModifiers(&modifiers_to_be_sent_); + } + currently_pressed_modifiers_.insert(keyval); + return false; + } + + // Clear modifier data just in case if |key| has no modifier keys. + if (!IsModifierToBeSentOnKeyUp(*key_event)) { + Clear(); + } + + return true; +} + +} // namespace ibus +} // namespace mozc diff --git a/src/unix/fcitx/fcitx_key_event_handler.h b/src/unix/fcitx/fcitx_key_event_handler.h new file mode 100644 index 00000000..7b759a18 --- /dev/null +++ b/src/unix/fcitx/fcitx_key_event_handler.h @@ -0,0 +1,79 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_KEY_EVENT_HANDLER_H_ +#define MOZC_UNIX_FCITX_KEY_EVENT_HANDLER_H_ + +#include <set> +#include <memory> + +#include "base/port.h" +#include "protocol/config.pb.h" +#include "protocol/commands.pb.h" +#include "unix/fcitx/fcitx_key_translator.h" + +namespace mozc { +namespace fcitx { + +class KeyEventHandler { + public: + KeyEventHandler(); + + // Converts a key event came from fcitx to commands::KeyEvent. This is a + // stateful method. It stores modifier keys states since ibus doesn't send + // an enough information about the modifier keys. + bool GetKeyEvent(FcitxKeySym keyval, uint32 keycode, uint32 modifiers, + config::Config::PreeditMethod preedit_method, + bool layout_is_jp, bool is_key_up, commands::KeyEvent *key); + + // Clears states. + void Clear(); + + private: + + // Manages modifier keys. Returns false if it should not be sent to server. + bool ProcessModifiers(bool is_key_up, uint32 keyval, + commands::KeyEvent *key_event); + + std::unique_ptr<KeyTranslator> key_translator_; + // Non modifier key is pressed or not after all keys are released. + bool is_non_modifier_key_pressed_; + // Currently pressed modifier keys. It is set of keyval. + std::set<uint32> currently_pressed_modifiers_; + // Pending modifier keys. + std::set<commands::KeyEvent::ModifierKey> modifiers_to_be_sent_; + + DISALLOW_COPY_AND_ASSIGN(KeyEventHandler); +}; + +} // namespace fcitx +} // namespace mozc + +#endif // MOZC_UNIX_FCITX_KEY_EVENT_HANDLER_H_ diff --git a/src/unix/fcitx/fcitx_key_translator.cc b/src/unix/fcitx/fcitx_key_translator.cc new file mode 100644 index 00000000..44347abf --- /dev/null +++ b/src/unix/fcitx/fcitx_key_translator.cc @@ -0,0 +1,521 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/fcitx_key_translator.h" + +#include "base/logging.h" + +namespace { + +const struct SpecialKeyMap { + uint32 from; + mozc::commands::KeyEvent::SpecialKey to; +} special_key_map[] = { + {FcitxKey_VoidSymbol, mozc::commands::KeyEvent::NO_SPECIALKEY}, + {FcitxKey_space, mozc::commands::KeyEvent::SPACE}, + {FcitxKey_Return, mozc::commands::KeyEvent::ENTER}, + {FcitxKey_Left, mozc::commands::KeyEvent::LEFT}, + {FcitxKey_Right, mozc::commands::KeyEvent::RIGHT}, + {FcitxKey_Up, mozc::commands::KeyEvent::UP}, + {FcitxKey_Down, mozc::commands::KeyEvent::DOWN}, + {FcitxKey_Escape, mozc::commands::KeyEvent::ESCAPE}, + {FcitxKey_Delete, mozc::commands::KeyEvent::DEL}, + {FcitxKey_BackSpace, mozc::commands::KeyEvent::BACKSPACE}, + {FcitxKey_Insert, mozc::commands::KeyEvent::INSERT}, + {FcitxKey_Henkan, mozc::commands::KeyEvent::HENKAN}, + {FcitxKey_Muhenkan, mozc::commands::KeyEvent::MUHENKAN}, + {FcitxKey_Hiragana, mozc::commands::KeyEvent::KANA}, + {FcitxKey_Hiragana_Katakana, mozc::commands::KeyEvent::KANA}, + {FcitxKey_Katakana, mozc::commands::KeyEvent::KATAKANA}, + {FcitxKey_Zenkaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Hankaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Zenkaku_Hankaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Eisu_toggle, mozc::commands::KeyEvent::EISU}, + {FcitxKey_Home, mozc::commands::KeyEvent::HOME}, + {FcitxKey_End, mozc::commands::KeyEvent::END}, + {FcitxKey_Tab, mozc::commands::KeyEvent::TAB}, + {FcitxKey_F1, mozc::commands::KeyEvent::F1}, + {FcitxKey_F2, mozc::commands::KeyEvent::F2}, + {FcitxKey_F3, mozc::commands::KeyEvent::F3}, + {FcitxKey_F4, mozc::commands::KeyEvent::F4}, + {FcitxKey_F5, mozc::commands::KeyEvent::F5}, + {FcitxKey_F6, mozc::commands::KeyEvent::F6}, + {FcitxKey_F7, mozc::commands::KeyEvent::F7}, + {FcitxKey_F8, mozc::commands::KeyEvent::F8}, + {FcitxKey_F9, mozc::commands::KeyEvent::F9}, + {FcitxKey_F10, mozc::commands::KeyEvent::F10}, + {FcitxKey_F11, mozc::commands::KeyEvent::F11}, + {FcitxKey_F12, mozc::commands::KeyEvent::F12}, + {FcitxKey_F13, mozc::commands::KeyEvent::F13}, + {FcitxKey_F14, mozc::commands::KeyEvent::F14}, + {FcitxKey_F15, mozc::commands::KeyEvent::F15}, + {FcitxKey_F16, mozc::commands::KeyEvent::F16}, + {FcitxKey_F17, mozc::commands::KeyEvent::F17}, + {FcitxKey_F18, mozc::commands::KeyEvent::F18}, + {FcitxKey_F19, mozc::commands::KeyEvent::F19}, + {FcitxKey_F20, mozc::commands::KeyEvent::F20}, + {FcitxKey_F21, mozc::commands::KeyEvent::F21}, + {FcitxKey_F22, mozc::commands::KeyEvent::F22}, + {FcitxKey_F23, mozc::commands::KeyEvent::F23}, + {FcitxKey_F24, mozc::commands::KeyEvent::F24}, + {FcitxKey_Page_Up, mozc::commands::KeyEvent::PAGE_UP}, + {FcitxKey_Page_Down, mozc::commands::KeyEvent::PAGE_DOWN}, + + // Keypad (10-key). + {FcitxKey_KP_0, mozc::commands::KeyEvent::NUMPAD0}, + {FcitxKey_KP_1, mozc::commands::KeyEvent::NUMPAD1}, + {FcitxKey_KP_2, mozc::commands::KeyEvent::NUMPAD2}, + {FcitxKey_KP_3, mozc::commands::KeyEvent::NUMPAD3}, + {FcitxKey_KP_4, mozc::commands::KeyEvent::NUMPAD4}, + {FcitxKey_KP_5, mozc::commands::KeyEvent::NUMPAD5}, + {FcitxKey_KP_6, mozc::commands::KeyEvent::NUMPAD6}, + {FcitxKey_KP_7, mozc::commands::KeyEvent::NUMPAD7}, + {FcitxKey_KP_8, mozc::commands::KeyEvent::NUMPAD8}, + {FcitxKey_KP_9, mozc::commands::KeyEvent::NUMPAD9}, + {FcitxKey_KP_Equal, mozc::commands::KeyEvent::EQUALS}, // [=] + {FcitxKey_KP_Multiply, mozc::commands::KeyEvent::MULTIPLY}, // [*] + {FcitxKey_KP_Add, mozc::commands::KeyEvent::ADD}, // [+] + {FcitxKey_KP_Separator, mozc::commands::KeyEvent::SEPARATOR}, // enter + {FcitxKey_KP_Subtract, mozc::commands::KeyEvent::SUBTRACT}, // [-] + {FcitxKey_KP_Decimal, mozc::commands::KeyEvent::DECIMAL}, // [.] + {FcitxKey_KP_Divide, mozc::commands::KeyEvent::DIVIDE}, // [/] + {FcitxKey_KP_Space, mozc::commands::KeyEvent::SPACE}, + {FcitxKey_KP_Tab, mozc::commands::KeyEvent::TAB}, + {FcitxKey_KP_Enter, mozc::commands::KeyEvent::ENTER}, + {FcitxKey_KP_Home, mozc::commands::KeyEvent::HOME}, + {FcitxKey_KP_Left, mozc::commands::KeyEvent::LEFT}, + {FcitxKey_KP_Up, mozc::commands::KeyEvent::UP}, + {FcitxKey_KP_Right, mozc::commands::KeyEvent::RIGHT}, + {FcitxKey_KP_Down, mozc::commands::KeyEvent::DOWN}, + {FcitxKey_KP_Page_Up, mozc::commands::KeyEvent::PAGE_UP}, + {FcitxKey_KP_Page_Down, mozc::commands::KeyEvent::PAGE_DOWN}, + {FcitxKey_KP_End, mozc::commands::KeyEvent::END}, + {FcitxKey_KP_Delete, mozc::commands::KeyEvent::DEL}, + {FcitxKey_KP_Insert, mozc::commands::KeyEvent::INSERT}, + {FcitxKey_Caps_Lock, mozc::commands::KeyEvent::CAPS_LOCK}, + + // Shift+TAB. + {FcitxKey_ISO_Left_Tab, mozc::commands::KeyEvent::TAB}, + + // TODO(mazda): Handle following keys? + // - FcitxKey_Kana_Lock? FcitxKey_KEY_Kana_Shift? +}; + +const struct ModifierKeyMap { + uint32 from; + mozc::commands::KeyEvent::ModifierKey to; +} modifier_key_map[] = { + {FcitxKey_Shift_L, mozc::commands::KeyEvent::LEFT_SHIFT}, + {FcitxKey_Shift_R, mozc::commands::KeyEvent::RIGHT_SHIFT}, + {FcitxKey_Control_L, mozc::commands::KeyEvent::LEFT_CTRL}, + {FcitxKey_Control_R, mozc::commands::KeyEvent::RIGHT_CTRL}, + {FcitxKey_Alt_L, mozc::commands::KeyEvent::LEFT_ALT}, + {FcitxKey_Alt_R, mozc::commands::KeyEvent::RIGHT_ALT}, + {FcitxKeyState_CapsLock, mozc::commands::KeyEvent::CAPS}, +}; + +const struct ModifierMaskMap { + uint32 from; + mozc::commands::KeyEvent::ModifierKey to; +} modifier_mask_map[] = { + {FcitxKeyState_Shift, mozc::commands::KeyEvent::SHIFT}, + {FcitxKeyState_Ctrl, mozc::commands::KeyEvent::CTRL}, + {FcitxKeyState_Alt, mozc::commands::KeyEvent::ALT}, +}; + +// TODO(team): Add kana_map_dv to support Dvoraklayout. +const struct KanaMap { + uint32 code; + const char *no_shift; + const char *shift; +} kana_map_jp[] = { + { '1' , "\xe3\x81\xac", "\xe3\x81\xac" }, // "ぬ", "ぬ" + { '!' , "\xe3\x81\xac", "\xe3\x81\xac" }, // "ぬ", "ぬ" + { '2' , "\xe3\x81\xb5", "\xe3\x81\xb5" }, // "ふ", "ふ" + { '\"', "\xe3\x81\xb5", "\xe3\x81\xb5" }, // "ふ", "ふ" + { '3' , "\xe3\x81\x82", "\xe3\x81\x81" }, // "あ", "ぁ" + { '#' , "\xe3\x81\x82", "\xe3\x81\x81" }, // "あ", "ぁ" + { '4' , "\xe3\x81\x86", "\xe3\x81\x85" }, // "う", "ぅ" + { '$' , "\xe3\x81\x86", "\xe3\x81\x85" }, // "う", "ぅ" + { '5' , "\xe3\x81\x88", "\xe3\x81\x87" }, // "え", "ぇ" + { '%' , "\xe3\x81\x88", "\xe3\x81\x87" }, // "え", "ぇ" + { '6' , "\xe3\x81\x8a", "\xe3\x81\x89" }, // "お", "ぉ" + { '&' , "\xe3\x81\x8a", "\xe3\x81\x89" }, // "お", "ぉ" + { '7' , "\xe3\x82\x84", "\xe3\x82\x83" }, // "や", "ゃ" + { '\'', "\xe3\x82\x84", "\xe3\x82\x83" }, // "や", "ゃ" + { '8' , "\xe3\x82\x86", "\xe3\x82\x85" }, // "ゆ", "ゅ" + { '(' , "\xe3\x82\x86", "\xe3\x82\x85" }, // "ゆ", "ゅ" + { '9' , "\xe3\x82\x88", "\xe3\x82\x87" }, // "よ", "ょ" + { ')' , "\xe3\x82\x88", "\xe3\x82\x87" }, // "よ", "ょ" + { '0' , "\xe3\x82\x8f", "\xe3\x82\x92" }, // "わ", "を" + { '-' , "\xe3\x81\xbb", "\xe3\x81\xbb" }, // "ほ", "ほ" + { '=' , "\xe3\x81\xbb", "\xe3\x81\xbb" }, // "ほ", "ほ" + { '^' , "\xe3\x81\xb8", "\xe3\x82\x92" }, // "へ", "を" + { '~' , "\xe3\x81\xb8", "\xe3\x82\x92" }, // "へ", "を" + { '|' , "\xe3\x83\xbc", "\xe3\x83\xbc" }, // "ー", "ー" + { 'q' , "\xe3\x81\x9f", "\xe3\x81\x9f" }, // "た", "た" + { 'Q' , "\xe3\x81\x9f", "\xe3\x81\x9f" }, // "た", "た" + { 'w' , "\xe3\x81\xa6", "\xe3\x81\xa6" }, // "て", "て" + { 'W' , "\xe3\x81\xa6", "\xe3\x81\xa6" }, // "て", "て" + { 'e' , "\xe3\x81\x84", "\xe3\x81\x83" }, // "い", "ぃ" + { 'E' , "\xe3\x81\x84", "\xe3\x81\x83" }, // "い", "ぃ" + { 'r' , "\xe3\x81\x99", "\xe3\x81\x99" }, // "す", "す" + { 'R' , "\xe3\x81\x99", "\xe3\x81\x99" }, // "す", "す" + { 't' , "\xe3\x81\x8b", "\xe3\x81\x8b" }, // "か", "か" + { 'T' , "\xe3\x81\x8b", "\xe3\x81\x8b" }, // "か", "か" + { 'y' , "\xe3\x82\x93", "\xe3\x82\x93" }, // "ん", "ん" + { 'Y' , "\xe3\x82\x93", "\xe3\x82\x93" }, // "ん", "ん" + { 'u' , "\xe3\x81\xaa", "\xe3\x81\xaa" }, // "な", "な" + { 'U' , "\xe3\x81\xaa", "\xe3\x81\xaa" }, // "な", "な" + { 'i' , "\xe3\x81\xab", "\xe3\x81\xab" }, // "に", "に" + { 'I' , "\xe3\x81\xab", "\xe3\x81\xab" }, // "に", "に" + { 'o' , "\xe3\x82\x89", "\xe3\x82\x89" }, // "ら", "ら" + { 'O' , "\xe3\x82\x89", "\xe3\x82\x89" }, // "ら", "ら" + { 'p' , "\xe3\x81\x9b", "\xe3\x81\x9b" }, // "せ", "せ" + { 'P' , "\xe3\x81\x9b", "\xe3\x81\x9b" }, // "せ", "せ" + { '@' , "\xe3\x82\x9b", "\xe3\x82\x9b" }, // "゛", "゛" + { '`' , "\xe3\x82\x9b", "\xe3\x82\x9b" }, // "゛", "゛" + { '[' , "\xe3\x82\x9c", "\xe3\x80\x8c" }, // "゜", "「" + { '{' , "\xe3\x82\x9c", "\xe3\x80\x8c" }, // "゜", "「" + { 'a' , "\xe3\x81\xa1", "\xe3\x81\xa1" }, // "ち", "ち" + { 'A' , "\xe3\x81\xa1", "\xe3\x81\xa1" }, // "ち", "ち" + { 's' , "\xe3\x81\xa8", "\xe3\x81\xa8" }, // "と", "と" + { 'S' , "\xe3\x81\xa8", "\xe3\x81\xa8" }, // "と", "と" + { 'd' , "\xe3\x81\x97", "\xe3\x81\x97" }, // "し", "し" + { 'D' , "\xe3\x81\x97", "\xe3\x81\x97" }, // "し", "し" + { 'f' , "\xe3\x81\xaf", "\xe3\x81\xaf" }, // "は", "は" + { 'F' , "\xe3\x81\xaf", "\xe3\x81\xaf" }, // "は", "は" + { 'g' , "\xe3\x81\x8d", "\xe3\x81\x8d" }, // "き", "き" + { 'G' , "\xe3\x81\x8d", "\xe3\x81\x8d" }, // "き", "き" + { 'h' , "\xe3\x81\x8f", "\xe3\x81\x8f" }, // "く", "く" + { 'H' , "\xe3\x81\x8f", "\xe3\x81\x8f" }, // "く", "く" + { 'j' , "\xe3\x81\xbe", "\xe3\x81\xbe" }, // "ま", "ま" + { 'J' , "\xe3\x81\xbe", "\xe3\x81\xbe" }, // "ま", "ま" + { 'k' , "\xe3\x81\xae", "\xe3\x81\xae" }, // "の", "の" + { 'K' , "\xe3\x81\xae", "\xe3\x81\xae" }, // "の", "の" + { 'l' , "\xe3\x82\x8a", "\xe3\x82\x8a" }, // "り", "り" + { 'L' , "\xe3\x82\x8a", "\xe3\x82\x8a" }, // "り", "り" + { ';' , "\xe3\x82\x8c", "\xe3\x82\x8c" }, // "れ", "れ" + { '+' , "\xe3\x82\x8c", "\xe3\x82\x8c" }, // "れ", "れ" + { ':' , "\xe3\x81\x91", "\xe3\x81\x91" }, // "け", "け" + { '*' , "\xe3\x81\x91", "\xe3\x81\x91" }, // "け", "け" + { ']' , "\xe3\x82\x80", "\xe3\x80\x8d" }, // "む", "」" + { '}' , "\xe3\x82\x80", "\xe3\x80\x8d" }, // "む", "」" + { 'z' , "\xe3\x81\xa4", "\xe3\x81\xa3" }, // "つ", "っ" + { 'Z' , "\xe3\x81\xa4", "\xe3\x81\xa3" }, // "つ", "っ" + { 'x' , "\xe3\x81\x95", "\xe3\x81\x95" }, // "さ", "さ" + { 'X' , "\xe3\x81\x95", "\xe3\x81\x95" }, // "さ", "さ" + { 'c' , "\xe3\x81\x9d", "\xe3\x81\x9d" }, // "そ", "そ" + { 'C' , "\xe3\x81\x9d", "\xe3\x81\x9d" }, // "そ", "そ" + { 'v' , "\xe3\x81\xb2", "\xe3\x81\xb2" }, // "ひ", "ひ" + { 'V' , "\xe3\x81\xb2", "\xe3\x81\xb2" }, // "ひ", "ひ" + { 'b' , "\xe3\x81\x93", "\xe3\x81\x93" }, // "こ", "こ" + { 'B' , "\xe3\x81\x93", "\xe3\x81\x93" }, // "こ", "こ" + { 'n' , "\xe3\x81\xbf", "\xe3\x81\xbf" }, // "み", "み" + { 'N' , "\xe3\x81\xbf", "\xe3\x81\xbf" }, // "み", "み" + { 'm' , "\xe3\x82\x82", "\xe3\x82\x82" }, // "も", "も" + { 'M' , "\xe3\x82\x82", "\xe3\x82\x82" }, // "も", "も" + { ',' , "\xe3\x81\xad", "\xe3\x80\x81" }, // "ね", "、" + { '<' , "\xe3\x81\xad", "\xe3\x80\x81" }, // "ね", "、" + { '.' , "\xe3\x82\x8b", "\xe3\x80\x82" }, // "る", "。" + { '>' , "\xe3\x82\x8b", "\xe3\x80\x82" }, // "る", "。" + { '/' , "\xe3\x82\x81", "\xe3\x83\xbb" }, // "め", "・" + { '?' , "\xe3\x82\x81", "\xe3\x83\xbb" }, // "め", "・" + { '_' , "\xe3\x82\x8d", "\xe3\x82\x8d" }, // "ろ", "ろ" + // A backslash is handled in a special way because it is input by + // two different keys (the one next to Backslash and the one next + // to Right Shift). + { '\\', "", "" }, +}, kana_map_us[] = { + { '`' , "\xe3\x82\x8d", "\xe3\x82\x8d" }, // "ろ", "ろ" + { '~' , "\xe3\x82\x8d", "\xe3\x82\x8d" }, // "ろ", "ろ" + { '1' , "\xe3\x81\xac", "\xe3\x81\xac" }, // "ぬ", "ぬ" + { '!' , "\xe3\x81\xac", "\xe3\x81\xac" }, // "ぬ", "ぬ" + { '2' , "\xe3\x81\xb5", "\xe3\x81\xb5" }, // "ふ", "ふ" + { '@' , "\xe3\x81\xb5", "\xe3\x81\xb5" }, // "ふ", "ふ" + { '3' , "\xe3\x81\x82", "\xe3\x81\x81" }, // "あ", "ぁ" + { '#' , "\xe3\x81\x82", "\xe3\x81\x81" }, // "あ", "ぁ" + { '4' , "\xe3\x81\x86", "\xe3\x81\x85" }, // "う", "ぅ" + { '$' , "\xe3\x81\x86", "\xe3\x81\x85" }, // "う", "ぅ" + { '5' , "\xe3\x81\x88", "\xe3\x81\x87" }, // "え", "ぇ" + { '%' , "\xe3\x81\x88", "\xe3\x81\x87" }, // "え", "ぇ" + { '6' , "\xe3\x81\x8a", "\xe3\x81\x89" }, // "お", "ぉ" + { '^' , "\xe3\x81\x8a", "\xe3\x81\x89" }, // "お", "ぉ" + { '7' , "\xe3\x82\x84", "\xe3\x82\x83" }, // "や", "ゃ" + { '&' , "\xe3\x82\x84", "\xe3\x82\x83" }, // "や", "ゃ" + { '8' , "\xe3\x82\x86", "\xe3\x82\x85" }, // "ゆ", "ゅ" + { '*' , "\xe3\x82\x86", "\xe3\x82\x85" }, // "ゆ", "ゅ" + { '9' , "\xe3\x82\x88", "\xe3\x82\x87" }, // "よ", "ょ" + { '(' , "\xe3\x82\x88", "\xe3\x82\x87" }, // "よ", "ょ" + { '0' , "\xe3\x82\x8f", "\xe3\x82\x92" }, // "わ", "を" + { ')' , "\xe3\x82\x8f", "\xe3\x82\x92" }, // "わ", "を" + { '-' , "\xe3\x81\xbb", "\xe3\x83\xbc" }, // "ほ", "ー" + { '_' , "\xe3\x81\xbb", "\xe3\x83\xbc" }, // "ほ", "ー" + { '=' , "\xe3\x81\xb8", "\xe3\x81\xb8" }, // "へ", "へ" + { '+' , "\xe3\x81\xb8", "\xe3\x81\xb8" }, // "へ", "へ" + { 'q' , "\xe3\x81\x9f", "\xe3\x81\x9f" }, // "た", "た" + { 'Q' , "\xe3\x81\x9f", "\xe3\x81\x9f" }, // "た", "た" + { 'w' , "\xe3\x81\xa6", "\xe3\x81\xa6" }, // "て", "て" + { 'W' , "\xe3\x81\xa6", "\xe3\x81\xa6" }, // "て", "て" + { 'e' , "\xe3\x81\x84", "\xe3\x81\x83" }, // "い", "ぃ" + { 'E' , "\xe3\x81\x84", "\xe3\x81\x83" }, // "い", "ぃ" + { 'r' , "\xe3\x81\x99", "\xe3\x81\x99" }, // "す", "す" + { 'R' , "\xe3\x81\x99", "\xe3\x81\x99" }, // "す", "す" + { 't' , "\xe3\x81\x8b", "\xe3\x81\x8b" }, // "か", "か" + { 'T' , "\xe3\x81\x8b", "\xe3\x81\x8b" }, // "か", "か" + { 'y' , "\xe3\x82\x93", "\xe3\x82\x93" }, // "ん", "ん" + { 'Y' , "\xe3\x82\x93", "\xe3\x82\x93" }, // "ん", "ん" + { 'u' , "\xe3\x81\xaa", "\xe3\x81\xaa" }, // "な", "な" + { 'U' , "\xe3\x81\xaa", "\xe3\x81\xaa" }, // "な", "な" + { 'i' , "\xe3\x81\xab", "\xe3\x81\xab" }, // "に", "に" + { 'I' , "\xe3\x81\xab", "\xe3\x81\xab" }, // "に", "に" + { 'o' , "\xe3\x82\x89", "\xe3\x82\x89" }, // "ら", "ら" + { 'O' , "\xe3\x82\x89", "\xe3\x82\x89" }, // "ら", "ら" + { 'p' , "\xe3\x81\x9b", "\xe3\x81\x9b" }, // "せ", "せ" + { 'P' , "\xe3\x81\x9b", "\xe3\x81\x9b" }, // "せ", "せ" + { '[' , "\xe3\x82\x9b", "\xe3\x82\x9b" }, // "゛", "゛" + { '{' , "\xe3\x82\x9b", "\xe3\x82\x9b" }, // "゛", "゛" + { ']' , "\xe3\x82\x9c", "\xe3\x80\x8c" }, // "゜", "「" + { '}' , "\xe3\x82\x9c", "\xe3\x80\x8c" }, // "゜", "「" + { '\\', "\xe3\x82\x80", "\xe3\x80\x8d" }, // "む", "」" + { '|' , "\xe3\x82\x80", "\xe3\x80\x8d" }, // "む", "」" + { 'a' , "\xe3\x81\xa1", "\xe3\x81\xa1" }, // "ち", "ち" + { 'A' , "\xe3\x81\xa1", "\xe3\x81\xa1" }, // "ち", "ち" + { 's' , "\xe3\x81\xa8", "\xe3\x81\xa8" }, // "と", "と" + { 'S' , "\xe3\x81\xa8", "\xe3\x81\xa8" }, // "と", "と" + { 'd' , "\xe3\x81\x97", "\xe3\x81\x97" }, // "し", "し" + { 'D' , "\xe3\x81\x97", "\xe3\x81\x97" }, // "し", "し" + { 'f' , "\xe3\x81\xaf", "\xe3\x81\xaf" }, // "は", "は" + { 'F' , "\xe3\x81\xaf", "\xe3\x81\xaf" }, // "は", "は" + { 'g' , "\xe3\x81\x8d", "\xe3\x81\x8d" }, // "き", "き" + { 'G' , "\xe3\x81\x8d", "\xe3\x81\x8d" }, // "き", "き" + { 'h' , "\xe3\x81\x8f", "\xe3\x81\x8f" }, // "く", "く" + { 'H' , "\xe3\x81\x8f", "\xe3\x81\x8f" }, // "く", "く" + { 'j' , "\xe3\x81\xbe", "\xe3\x81\xbe" }, // "ま", "ま" + { 'J' , "\xe3\x81\xbe", "\xe3\x81\xbe" }, // "ま", "ま" + { 'k' , "\xe3\x81\xae", "\xe3\x81\xae" }, // "の", "の" + { 'K' , "\xe3\x81\xae", "\xe3\x81\xae" }, // "の", "の" + { 'l' , "\xe3\x82\x8a", "\xe3\x82\x8a" }, // "り", "り" + { 'L' , "\xe3\x82\x8a", "\xe3\x82\x8a" }, // "り", "り" + { ';' , "\xe3\x82\x8c", "\xe3\x82\x8c" }, // "れ", "れ" + { ':' , "\xe3\x82\x8c", "\xe3\x82\x8c" }, // "れ", "れ" + { '\'', "\xe3\x81\x91", "\xe3\x81\x91" }, // "け", "け" + { '\"', "\xe3\x81\x91", "\xe3\x81\x91" }, // "け", "け" + { 'z' , "\xe3\x81\xa4", "\xe3\x81\xa3" }, // "つ", "っ" + { 'Z' , "\xe3\x81\xa4", "\xe3\x81\xa3" }, // "つ", "っ" + { 'x' , "\xe3\x81\x95", "\xe3\x81\x95" }, // "さ", "さ" + { 'X' , "\xe3\x81\x95", "\xe3\x81\x95" }, // "さ", "さ" + { 'c' , "\xe3\x81\x9d", "\xe3\x81\x9d" }, // "そ", "そ" + { 'C' , "\xe3\x81\x9d", "\xe3\x81\x9d" }, // "そ", "そ" + { 'v' , "\xe3\x81\xb2", "\xe3\x81\xb2" }, // "ひ", "ひ" + { 'V' , "\xe3\x81\xb2", "\xe3\x81\xb2" }, // "ひ", "ひ" + { 'b' , "\xe3\x81\x93", "\xe3\x81\x93" }, // "こ", "こ" + { 'B' , "\xe3\x81\x93", "\xe3\x81\x93" }, // "こ", "こ" + { 'n' , "\xe3\x81\xbf", "\xe3\x81\xbf" }, // "み", "み" + { 'N' , "\xe3\x81\xbf", "\xe3\x81\xbf" }, // "み", "み" + { 'm' , "\xe3\x82\x82", "\xe3\x82\x82" }, // "も", "も" + { 'M' , "\xe3\x82\x82", "\xe3\x82\x82" }, // "も", "も" + { ',' , "\xe3\x81\xad", "\xe3\x80\x81" }, // "ね", "、" + { '<' , "\xe3\x81\xad", "\xe3\x80\x81" }, // "ね", "、" + { '.' , "\xe3\x82\x8b", "\xe3\x80\x82" }, // "る", "。" + { '>' , "\xe3\x82\x8b", "\xe3\x80\x82" }, // "る", "。" + { '/' , "\xe3\x82\x81", "\xe3\x83\xbb" }, // "め", "・" + { '?' , "\xe3\x82\x81", "\xe3\x83\xbb" }, // "め", "・" +}; + +} // namespace + +namespace mozc { +namespace fcitx { + +KeyTranslator::KeyTranslator() { + Init(); +} + +KeyTranslator::~KeyTranslator() { +} + +// TODO(nona): Fix 'Shift-0' behavior b/4338394 +bool KeyTranslator::Translate(FcitxKeySym keyval, + uint32 keycode, + uint32 modifiers, + config::Config::PreeditMethod method, + bool layout_is_jp, + commands::KeyEvent *out_event) const { + DCHECK(out_event) << "out_event is NULL"; + out_event->Clear(); + + /* this is key we cannot handle, don't process it */ + if (modifiers & FcitxKeyState_Super) + return false; + + // Due to historical reasons, many linux ditributions set Hiragana_Katakana + // key as Hiragana key (which is Katkana key with shift modifier). So, we + // translate Hiragana_Katanaka key as Hiragana key by mapping table, and + // Shift + Hiragana_Katakana key as Katakana key by functionally. + // TODO(nona): Fix process modifier to handle right shift + if (IsHiraganaKatakanaKeyWithShift(keyval, keycode, modifiers)) { + modifiers &= ~FcitxKeyState_Shift; + keyval = FcitxKey_Katakana; + } + string kana_key_string; + if ((method == config::Config::KANA) && IsKanaAvailable( + keyval, keycode, modifiers, layout_is_jp, &kana_key_string)) { + out_event->set_key_code(keyval); + out_event->set_key_string(kana_key_string); + } else if (IsAscii(keyval, keycode, modifiers)) { + if (FcitxKeyState_CapsLock & modifiers) { + out_event->add_modifier_keys(commands::KeyEvent::CAPS); + } + out_event->set_key_code(keyval); + } else if (IsModifierKey(keyval, keycode, modifiers)) { + ModifierKeyMap::const_iterator i = modifier_key_map_.find(keyval); + DCHECK(i != modifier_key_map_.end()); + out_event->add_modifier_keys(i->second); + } else if (IsSpecialKey(keyval, keycode, modifiers)) { + SpecialKeyMap::const_iterator i = special_key_map_.find(keyval); + DCHECK(i != special_key_map_.end()); + out_event->set_special_key(i->second); + } else { + VLOG(1) << "Unknown keyval: " << keyval; + return false; + } + + for (ModifierKeyMap::const_iterator i = modifier_mask_map_.begin(); + i != modifier_mask_map_.end(); ++i) { + // Do not set a SHIFT modifier when |keyval| is a printable key by following + // the Mozc's rule. + if ((i->second == commands::KeyEvent::SHIFT) && + IsPrintable(keyval, keycode, modifiers)) { + continue; + } + + if (i->first & modifiers) { + out_event->add_modifier_keys(i->second); + } + } + + return true; +} + +void KeyTranslator::Init() { + for (int i = 0; i < arraysize(special_key_map); ++i) { + CHECK(special_key_map_.insert(std::make_pair(special_key_map[i].from, + special_key_map[i].to)).second); + } + for (int i = 0; i < arraysize(modifier_key_map); ++i) { + CHECK(modifier_key_map_.insert(std::make_pair(modifier_key_map[i].from, + modifier_key_map[i].to)).second); + } + for (int i = 0; i < arraysize(modifier_mask_map); ++i) { + CHECK(modifier_mask_map_.insert(std::make_pair(modifier_mask_map[i].from, + modifier_mask_map[i].to)).second); + } + for (int i = 0; i < arraysize(kana_map_jp); ++i) { + CHECK(kana_map_jp_.insert( + std::make_pair(kana_map_jp[i].code, std::make_pair( + kana_map_jp[i].no_shift, kana_map_jp[i].shift))).second); + } + for (int i = 0; i < arraysize(kana_map_us); ++i) { + CHECK(kana_map_us_.insert( + std::make_pair(kana_map_us[i].code, std::make_pair( + kana_map_us[i].no_shift, kana_map_us[i].shift))).second); + } +} + +bool KeyTranslator::IsModifierKey(uint32 keyval, + uint32 keycode, + uint32 modifiers) const { + return modifier_key_map_.find(keyval) != modifier_key_map_.end(); +} + +bool KeyTranslator::IsSpecialKey(uint32 keyval, + uint32 keycode, + uint32 modifiers) const { + return special_key_map_.find(keyval) != special_key_map_.end(); +} + +bool KeyTranslator::IsHiraganaKatakanaKeyWithShift(uint32 keyval, + uint32 keycode, + uint32 modifiers) { + return ((modifiers & FcitxKeyState_Shift) && (keyval == FcitxKey_Hiragana_Katakana)); +} + +bool KeyTranslator::IsKanaAvailable(uint32 keyval, + uint32 keycode, + uint32 modifiers, + bool layout_is_jp, + string *out) const { + if ((modifiers & FcitxKeyState_Ctrl) || (modifiers & FcitxKeyState_Alt)) { + return false; + } + const KanaMap &kana_map = layout_is_jp ? kana_map_jp_ : kana_map_us_; + KanaMap::const_iterator iter = kana_map.find(keyval); + if (iter == kana_map.end()) { + return false; + } + + if (out) { + // When a Japanese keyboard is in use, the yen-sign key and the backslash + // key generate the same |keyval|. In this case, we have to check |keycode| + // to return an appropriate string. See the following IBus issue for + // details: http://code.google.com/p/ibus/issues/detail?id=52 + if (keyval == '\\' && layout_is_jp) { + if (keycode == 132 || keycode == 133) { + *out = "\xe3\x83\xbc"; // "ー" + } else { + *out = "\xe3\x82\x8d"; // "ろ" + } + } else { + *out = (modifiers & FcitxKeyState_Shift) ? + iter->second.second : iter->second.first; + } + } + return true; +} + +// TODO(nona): resolve S-'0' problem (b/4338394). +// TODO(nona): Current printable detection is weak. To enhance accuracy, use xkb +// key map +bool KeyTranslator::IsPrintable(uint32 keyval, uint32 keycode, uint32 modifiers) { + if ((modifiers & FcitxKeyState_Ctrl) || (modifiers & FcitxKeyState_Alt)) { + return false; + } + return IsAscii(keyval, keycode, modifiers); +} + +bool KeyTranslator::IsAscii(uint32 keyval, uint32 keycode, uint32 modifiers) { + return (keyval > FcitxKey_space && + // Note: Space key (0x20) is a special key in Mozc. + keyval <= FcitxKey_asciitilde); // 0x7e. +} + +} // namespace ibus +} // namespace mozc diff --git a/src/unix/fcitx/fcitx_key_translator.h b/src/unix/fcitx/fcitx_key_translator.h new file mode 100644 index 00000000..b473672f --- /dev/null +++ b/src/unix/fcitx/fcitx_key_translator.h @@ -0,0 +1,121 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_FCITX_KEY_TRANSLATOR_H_ +#define MOZC_UNIX_FCITX_FCITX_KEY_TRANSLATOR_H_ + +#include <map> +#include <set> +#include <string> + +#include <fcitx-config/hotkey.h> + +#include "base/port.h" +#include "protocol/commands.pb.h" +#include <fcitx/ime.h> + +namespace mozc { + +namespace fcitx { + +// This class is responsible for converting scim::KeyEvent object (defined in +// /usr/include/scim-1.0/scim_event.h) to IPC input for mozc_server. +class KeyTranslator { +public: + KeyTranslator(); + virtual ~KeyTranslator(); + + // Converts scim_key into Mozc key code and stores them on out_translated. + // scim_key must satisfy the following precondition: CanConvert(scim_key) + bool Translate(FcitxKeySym keyval, + uint32 keycode, + uint32 modifiers, + mozc::config::Config::PreeditMethod method, + bool layout_is_jp, + mozc::commands::KeyEvent *out_event) const; + +private: + typedef std::map<uint32, commands::KeyEvent::SpecialKey> SpecialKeyMap; + typedef std::map<uint32, commands::KeyEvent::ModifierKey> ModifierKeyMap; + typedef std::map<uint32, std::pair<string, string> > KanaMap; + + // Returns true iff key is modifier key such as SHIFT, ALT, or CAPSLOCK. + bool IsModifierKey(uint32 keyval, + uint32 keycode, + uint32 modifiers) const; + + // Returns true iff key is special key such as ENTER, ESC, or PAGE_UP. + bool IsSpecialKey(uint32 keyval, + uint32 keycode, + uint32 modifiers) const; + + // Returns true iff |keyval| is a key with a kana assigned. + bool IsKanaAvailable(uint32 keyval, + uint32 keycode, + uint32 modifiers, + bool layout_is_jp, + string *out) const; + + // Returns true iff key is ASCII such as '0', 'A', or '!'. + static bool IsAscii(uint32 keyval, + uint32 keycode, + uint32 modifiers); + + // Returns true iff key is printable. + static bool IsPrintable(uint32 keyval, uint32 keycode, uint32 modifiers); + + // Returns true iff key is HiraganaKatakana with shift modifier. + static bool IsHiraganaKatakanaKeyWithShift(uint32 keyval, + uint32 keycode, + uint32 modifiers); + + // Initializes private fields. + void Init(); + + // Stores a mapping from ibus keys to Mozc's special keys. + SpecialKeyMap special_key_map_; + // Stores a mapping from ibus modifier keys to Mozc's modifier keys. + ModifierKeyMap modifier_key_map_; + // Stores a mapping from ibus modifier masks to Mozc's modifier keys. + ModifierKeyMap modifier_mask_map_; + // Stores a mapping from ASCII to Kana character. For example, ASCII character + // '4' is mapped to Japanese 'Hiragana Letter U' (without Shift modifier) and + // 'Hiragana Letter Small U' (with Shift modifier). + KanaMap kana_map_jp_; // mapping for JP keyboard. + KanaMap kana_map_us_; // mapping for US keyboard. + + DISALLOW_COPY_AND_ASSIGN(KeyTranslator); +}; + +} // namespace fcitx + +} // namespace mozc + +#endif // MOZC_UNIX_FCITX_FCITX_KEY_TRANSLATOR_H_ diff --git a/src/unix/fcitx/fcitx_mozc.cc b/src/unix/fcitx/fcitx_mozc.cc new file mode 100644 index 00000000..0c8ce651 --- /dev/null +++ b/src/unix/fcitx/fcitx_mozc.cc @@ -0,0 +1,557 @@ +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/fcitx_mozc.h" + +#include <string> +#include <fcitx/candidate.h> +#include <fcitx/module.h> +#include <fcitx-config/xdg.h> + +#include "base/const.h" +#include "base/logging.h" +#include "base/process.h" +#include "base/util.h" +#include "base/file_util.h" +#include "base/system_util.h" +#include "unix/fcitx/mozc_connection.h" +#include "unix/fcitx/mozc_response_parser.h" +#include <fcitx/context.h> + +#define N_(x) (x) + +namespace +{ + +static const std::string empty_string; + +const struct CompositionMode +{ + const char *icon; + const char *label; + const char *description; + mozc::commands::CompositionMode mode; +} kPropCompositionModes[] = +{ + { + "mozc-direct.png", + "A", + N_("Direct"), + mozc::commands::DIRECT, + }, { + "mozc-hiragana.png", + "\xe3\x81\x82", // Hiragana letter A in UTF-8. + N_("Hiragana"), + mozc::commands::HIRAGANA, + }, { + "mozc-katakana_full.png", + "\xe3\x82\xa2", // Katakana letter A. + N_("Full Katakana"), + mozc::commands::FULL_KATAKANA, + }, { + "mozc-alpha_half.png", + "A", + N_("Half ASCII"), + mozc::commands::HALF_ASCII, + }, { + "mozc-alpha_full.png", + "\xef\xbc\xa1", // Full width ASCII letter A. + N_("Full ASCII"), + mozc::commands::FULL_ASCII, + }, { + "mozc-katakana_half.png", + "\xef\xbd\xb1", // Half width Katakana letter A. + N_("Half Katakana"), + mozc::commands::HALF_KATAKANA, + }, +}; +const size_t kNumCompositionModes = arraysize ( kPropCompositionModes ); + +// This array must correspond with the CompositionMode enum in the +// mozc/session/command.proto file. +static_assert ( + mozc::commands::NUM_OF_COMPOSITIONS == arraysize ( kPropCompositionModes ), + "number of modes must match" ); + +} // namespace + +INPUT_RETURN_VALUE FcitxMozcGetCandidateWord(void* arg, FcitxCandidateWord* candWord) +{ + mozc::fcitx::FcitxMozc* fcitx_mozc = (mozc::fcitx::FcitxMozc*) arg; + fcitx_mozc->select_candidate(candWord); + + return IRV_DISPLAY_CANDWORDS; +} + + +namespace mozc +{ + +namespace fcitx +{ + +// For unittests. +FcitxMozc::FcitxMozc ( FcitxInstance* inst, + MozcConnectionInterface *connection, + MozcResponseParser *parser ) : + instance(inst), + input(FcitxInstanceGetInputState(inst)), + connection_ ( connection ), + parser_ ( parser ), + composition_mode_ ( mozc::commands::HIRAGANA ) +{ + // mozc::Logging::SetVerboseLevel(1); + VLOG ( 1 ) << "FcitxMozc created."; + const bool is_vertical = true; + parser_->set_use_annotation ( is_vertical ); + InitializeBar(); + InitializeMenu(); + SetCompositionMode( mozc::commands::HIRAGANA ); +} + +FcitxMozc::~FcitxMozc() +{ + VLOG ( 1 ) << "FcitxMozc destroyed."; +} + +// This function is called from SCIM framework when users press or release a +// key. +bool FcitxMozc::process_key_event (FcitxKeySym sym, uint32 keycode, uint32 state, bool layout_is_jp, bool is_key_up) +{ + string error; + mozc::commands::Output raw_response; + if ( !connection_->TrySendKeyEvent ( + GetInstance(), sym, keycode, state, composition_mode_, layout_is_jp, is_key_up, &raw_response, &error ) ) + { + // TODO(yusukes): Show |error|. + return false; // not consumed. + } + + return ParseResponse ( raw_response ); +} + +// This function is called from SCIM framework when users click the candidate +// window. +void FcitxMozc::select_candidate ( FcitxCandidateWord* candWord ) +{ + int32 *id = (int32*) candWord->priv; + + if ( *id == kBadCandidateId ) + { + LOG ( ERROR ) << "The clicked candidate doesn't have unique ID."; + return; + } + VLOG ( 1 ) << "select_candidate, id=" << *id; + + string error; + mozc::commands::Output raw_response; + if ( !connection_->TrySendClick ( *id, &raw_response, &error ) ) + { + LOG ( ERROR ) << "IPC failed. error=" << error; + SetAuxString ( error ); + DrawAll(); + } + else + { + ParseResponse ( raw_response ); + } +} + +// This function is called from SCIM framework. +void FcitxMozc::resetim() +{ + VLOG ( 1 ) << "resetim"; + string error; + mozc::commands::Output raw_response; + if ( connection_->TrySendCommand ( + mozc::commands::SessionCommand::REVERT, &raw_response, &error ) ) + { + parser_->ParseResponse ( raw_response, this ); + } + ClearAll(); // just in case. + DrawAll(); + +} + +void FcitxMozc::reset() +{ + FcitxIM* im = FcitxInstanceGetCurrentIM(instance); + if (!im || strcmp(im->uniqueName, "mozc") != 0) { + FcitxUISetStatusVisable(instance, "mozc-tool", false); + FcitxUISetStatusVisable(instance, "mozc-composition-mode", false); + } + else { + FcitxUISetStatusVisable(instance, "mozc-tool", true); + FcitxUISetStatusVisable(instance, "mozc-composition-mode", true); + connection_->UpdatePreeditMethod(); + } +} + +bool FcitxMozc::paging(bool prev) +{ + VLOG ( 1 ) << "paging"; + string error; + mozc::commands::SessionCommand::CommandType command = + prev ? mozc::commands::SessionCommand::CONVERT_PREV_PAGE + : mozc::commands::SessionCommand::CONVERT_NEXT_PAGE; + mozc::commands::Output raw_response; + if ( connection_->TrySendCommand ( + command, &raw_response, &error ) ) + { + parser_->ParseResponse ( raw_response, this ); + return true; + } + return false; +} + +// This function is called from SCIM framework when the ic gets focus. +void FcitxMozc::init() +{ + VLOG ( 1 ) << "init"; + boolean flag = true; + FcitxInstanceSetContext(instance, CONTEXT_DISABLE_AUTOENG, &flag); + FcitxInstanceSetContext(instance, CONTEXT_DISABLE_FULLWIDTH, &flag); + FcitxInstanceSetContext(instance, CONTEXT_DISABLE_QUICKPHRASE, &flag); + FcitxInstanceSetContext(instance, CONTEXT_IM_KEYBOARD_LAYOUT, "jp"); + FcitxInstanceSetContext(instance, "CONTEXT_DISABLE_AUTO_FIRST_CANDIDATE_HIGHTLIGHT", &flag); + + connection_->UpdatePreeditMethod(); + DrawAll(); +} + +// This function is called when the ic loses focus. +void FcitxMozc::focus_out() +{ + VLOG ( 1 ) << "focus_out"; + string error; + mozc::commands::Output raw_response; + if ( connection_->TrySendCommand ( + mozc::commands::SessionCommand::REVERT, &raw_response, &error ) ) + { + parser_->ParseResponse ( raw_response, this ); + } + ClearAll(); // just in case. + DrawAll(); + // TODO(yusukes): Call client::SyncData() like ibus-mozc. +} + + +bool FcitxMozc::ParseResponse ( const mozc::commands::Output &raw_response ) +{ + ClearAll(); + const bool consumed = parser_->ParseResponse ( raw_response, this ); + if ( !consumed ) + { + VLOG ( 1 ) << "The input was not consumed by Mozc."; + } + OpenUrl(); + DrawAll(); + return consumed; +} + +void FcitxMozc::SetResultString ( const std::string &result_string ) +{ + FcitxInstanceCommitString(instance, FcitxInstanceGetCurrentIC(instance), result_string.c_str()); +} + +void FcitxMozc::SetPreeditInfo ( const PreeditInfo *preedit_info ) +{ + preedit_info_.reset ( preedit_info ); +} + +void FcitxMozc::SetAuxString ( const std::string &str ) +{ + aux_ = str; +} + +void FcitxMozc::SetCompositionMode ( mozc::commands::CompositionMode mode ) +{ + composition_mode_ = mode; + DCHECK(composition_mode_ < kNumCompositionModes); + if (composition_mode_ < kNumCompositionModes) { + FcitxUISetStatusString(instance, + "mozc-composition-mode", + _(kPropCompositionModes[composition_mode_].label), + _(kPropCompositionModes[composition_mode_].description)); + } +} + +void FcitxMozc::SendCompositionMode(mozc::commands::CompositionMode mode) +{ + // Send the SWITCH_INPUT_MODE command. + string error; + mozc::commands::Output raw_response; + if (connection_->TrySendCompositionMode( + kPropCompositionModes[mode].mode, &raw_response, &error)) { + parser_->ParseResponse(raw_response, this); + } +} + + +void FcitxMozc::SetUrl ( const string &url ) +{ + url_ = url; +} + +void FcitxMozc::ClearAll() +{ + SetPreeditInfo ( NULL ); + SetAuxString ( "" ); + FcitxCandidateWordReset(FcitxInputStateGetCandidateList(input)); + url_.clear(); +} + +void FcitxMozc::DrawPreeditInfo() +{ + FcitxMessages* preedit = FcitxInputStateGetPreedit(input); + FcitxMessages* clientpreedit = FcitxInputStateGetClientPreedit(input); + FcitxMessagesSetMessageCount(preedit, 0); + FcitxMessagesSetMessageCount(clientpreedit, 0); + if ( preedit_info_.get() ) + { + VLOG ( 1 ) << "DrawPreeditInfo: cursor=" << preedit_info_->cursor_pos; + + FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance); + boolean supportPreedit = FcitxInstanceICSupportPreedit(instance, ic); + + if (!supportPreedit) + FcitxInputStateSetShowCursor(input, true); + + for (int i = 0; i < preedit_info_->preedit.size(); i ++) { + if (!supportPreedit) + FcitxMessagesAddMessageAtLast(preedit, preedit_info_->preedit[i].type, "%s", preedit_info_->preedit[i].str.c_str()); + FcitxMessagesAddMessageAtLast(clientpreedit, preedit_info_->preedit[i].type, "%s", preedit_info_->preedit[i].str.c_str()); + } + if (!supportPreedit) + FcitxInputStateSetCursorPos(input, preedit_info_->cursor_pos); + FcitxInputStateSetClientCursorPos(input, preedit_info_->cursor_pos); + } + else { + FcitxInputStateSetShowCursor(input, false); + } + if ( !aux_.empty() ) { + FcitxMessagesAddMessageAtLast(preedit, MSG_TIPS, "%s[%s]", preedit_info_.get() ? " " : "", aux_.c_str()); + } +} + +void FcitxMozc::DrawAux() +{ + FcitxMessages* auxUp = FcitxInputStateGetAuxUp(input); + FcitxMessages* auxDown = FcitxInputStateGetAuxDown(input); + FcitxMessagesSetMessageCount(auxUp, 0); + FcitxMessagesSetMessageCount(auxDown, 0); +} + +void FcitxMozc::DrawAll() +{ + DrawPreeditInfo(); + DrawAux(); +} + +void FcitxMozc::OpenUrl() +{ + if ( url_.empty() ) + { + return; + } + mozc::Process::OpenBrowser ( url_ ); + url_.clear(); +} + +static const char* GetCompositionIconName(void* arg) +{ + FcitxMozc* mozc = (FcitxMozc*) arg; + return mozc->GetCurrentCompositionModeIcon().c_str(); +} + + +static const char* GetMozcToolIcon(void* arg) +{ + FcitxMozc* mozc = (FcitxMozc*) arg; + return mozc->GetIconFile("mozc-tool.png").c_str(); +} + +void FcitxMozc::InitializeBar() +{ + VLOG ( 1 ) << "Registering properties"; + + FcitxUIRegisterComplexStatus(instance, this, + "mozc-composition-mode", + _("Composition Mode"), + _("Composition Mode"), + NULL, + GetCompositionIconName + ); + + if ( mozc::FileUtil::FileExists ( mozc::FileUtil::JoinPath ( + mozc::SystemUtil::GetServerDirectory(), mozc::kMozcTool ) ) ) + { + FcitxUIRegisterComplexStatus(instance, this, + "mozc-tool", + _("Tool"), + _("Tool"), + NULL, + GetMozcToolIcon + ); + } + FcitxUISetStatusVisable(instance, "mozc-tool", false); + FcitxUISetStatusVisable(instance, "mozc-composition-mode", false); +} + +boolean CompositionMenuAction(struct _FcitxUIMenu *menu, int index) +{ + FcitxMozc* mozc = (FcitxMozc*) menu->priv; + mozc->SendCompositionMode((mozc::commands::CompositionMode) index); + return true; +} + +void UpdateCompositionMenu(struct _FcitxUIMenu *menu) +{ + FcitxMozc* mozc = (FcitxMozc*) menu->priv; + menu->mark = mozc->GetCompositionMode(); +} + +boolean ToolMenuAction(struct _FcitxUIMenu *menu, int index) +{ + string args; + switch(index) { + case 0: + args = "--mode=config_dialog"; + break; + case 1: + args = "--mode=dictionary_tool"; + break; + case 2: + args = "--mode=hand_writing"; + break; + case 3: + args = "--mode=character_palette"; + break; + case 4: + args = "--mode=word_register_dialog"; + break; + case 5: + args = "--mode=about_dialog"; + break; + } + mozc::Process::SpawnMozcProcess("mozc_tool", args); + return true; +} + +void UpdateToolMenu(struct _FcitxUIMenu *menu) +{ + return; +} + +void FcitxMozc::InitializeMenu() +{ + FcitxMenuInit(&this->compositionMenu); + compositionMenu.name = strdup(_("Composition Mode")); + compositionMenu.candStatusBind = strdup("mozc-composition-mode"); + compositionMenu.UpdateMenu = UpdateCompositionMenu; + compositionMenu.MenuAction = CompositionMenuAction; + compositionMenu.priv = this; + compositionMenu.isSubMenu = false; + int i; + for (i = 0; i < kNumCompositionModes; i ++) + FcitxMenuAddMenuItem(&compositionMenu, _(kPropCompositionModes[i].description), MENUTYPE_SIMPLE, NULL); + + FcitxUIRegisterMenu(instance, &compositionMenu); + + FcitxMenuInit(&this->toolMenu); + toolMenu.name = strdup(_("Mozc Tool")); + toolMenu.candStatusBind = strdup("mozc-tool"); + toolMenu.UpdateMenu = UpdateToolMenu; + toolMenu.MenuAction = ToolMenuAction; + toolMenu.priv = this; + toolMenu.isSubMenu = false; + FcitxMenuAddMenuItem(&toolMenu, _("Configuration Tool"), MENUTYPE_SIMPLE, NULL); + FcitxMenuAddMenuItem(&toolMenu, _("Dictionary Tool"), MENUTYPE_SIMPLE, NULL); + FcitxMenuAddMenuItem(&toolMenu, _("Hand Writing"), MENUTYPE_SIMPLE, NULL); + FcitxMenuAddMenuItem(&toolMenu, _("Character Palette"), MENUTYPE_SIMPLE, NULL); + FcitxMenuAddMenuItem(&toolMenu, _("Add Word"), MENUTYPE_SIMPLE, NULL); + FcitxMenuAddMenuItem(&toolMenu, _("About Mozc"), MENUTYPE_SIMPLE, NULL); + FcitxUIRegisterMenu(instance, &toolMenu); +} + +bool FcitxMozc::SendCommand(const mozc::commands::SessionCommand& session_command, commands::Output* new_output) +{ + string error; + return connection_->TrySendRawCommand(session_command, new_output, &error); +} + + +FcitxInputState* FcitxMozc::GetInputState() +{ + return input; +} + +const std::string& FcitxMozc::GetIconFile(const std::string key) +{ + if (iconMap.count(key)) { + return iconMap[key]; + } + + char* retFile; + FILE* fp = FcitxXDGGetFileWithPrefix("mozc/icon", key.c_str(), "r", &retFile); + if (fp) + fclose(fp); + if (retFile) { + iconMap[key] = std::string(retFile); + free(retFile); + } + else { + iconMap[key] = ""; + } + return iconMap[key]; +} + + +const std::string& FcitxMozc::GetCurrentCompositionModeIcon() { + DCHECK(composition_mode_ < kNumCompositionModes); + if (composition_mode_ < kNumCompositionModes) { + return GetIconFile(kPropCompositionModes[composition_mode_].icon); + } + return empty_string; +} + +void FcitxMozc::SetUsage(const string& title_, const string& description_) +{ + title = title_; + description = description_; +} + +std::pair< string, string > FcitxMozc::GetUsage() +{ + return make_pair(title, description); +} + +} // namespace fcitx + +} // namespace mozc_unix_scim diff --git a/src/unix/fcitx/fcitx_mozc.h b/src/unix/fcitx/fcitx_mozc.h new file mode 100644 index 00000000..0610d6e2 --- /dev/null +++ b/src/unix/fcitx/fcitx_mozc.h @@ -0,0 +1,176 @@ +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_FCITX_MOZC_H_ +#define MOZC_UNIX_FCITX_FCITX_MOZC_H_ + +#include <memory> + +#include <fcitx/instance.h> +#include <fcitx/candidate.h> +#include <fcitx-config/hotkey.h> +#include <libintl.h> + +#include "base/port.h" +#include "base/run_level.h" +#include "protocol/commands.pb.h" +#include "client/client_interface.h" +#include "mozc_connection.h" + +#define _(x) dgettext("fcitx-mozc", (x)) + +INPUT_RETURN_VALUE FcitxMozcGetCandidateWord(void* arg, FcitxCandidateWord* candWord);; + +namespace mozc +{ + +namespace fcitx +{ +const int32 kBadCandidateId = -12345; +class IMEngineFactory; +class MozcConnectionInterface; +class MozcResponseParser; +class KeyTranslator; + +struct PreeditItem { + std::string str; + FcitxMessageType type; +}; + +// Preedit string and its attributes. +struct PreeditInfo +{ + uint32 cursor_pos; + + std::vector<PreeditItem> preedit; +}; + +class FcitxMozc +{ +public: + // This constructor is used by unittests. + FcitxMozc ( FcitxInstance* instance, + MozcConnectionInterface *connection, + MozcResponseParser *parser ); + virtual ~FcitxMozc(); + + bool process_key_event (FcitxKeySym sym, uint32 keycode, uint32 state, bool layout_is_jp, bool is_key_up); + void select_candidate ( FcitxCandidateWord* candWord ); + void resetim(); + void reset(); + void init(); + void focus_out(); + bool paging(bool prev); + + // Functions called by the MozcResponseParser class to update UI. + + // Displays a 'result' (aka 'commit string') on FCITX UI. + void SetResultString ( const std::string &result_string ); + // Displays a 'preedit' string on FCITX UI. This function takes ownership + // of preedit_info. If the parameter is NULL, hides the string currently + // displayed. + void SetPreeditInfo ( const PreeditInfo *preedit_info ); + // Displays an auxiliary message (e.g., an error message, a title of + // candidate window). If the string is empty (""), hides the message + // currently being displayed. + void SetAuxString ( const std::string &str ); + // Sets a current composition mode (e.g., Hankaku Katakana). + void SetCompositionMode ( mozc::commands::CompositionMode mode ); + + void SendCompositionMode ( mozc::commands::CompositionMode mode ); + + // Sets the url to be opened by the default browser. + void SetUrl ( const string &url ); + + const std::string& GetIconFile(const std::string key); + + const std::string& GetCurrentCompositionModeIcon(); + + mozc::commands::CompositionMode GetCompositionMode() { return composition_mode_; } + + FcitxInstance* GetInstance() { return instance; } + + FcitxInputState* GetInputState(); + + mozc::client::ClientInterface* GetClient() { return connection_->GetClient(); } + + bool SendCommand(const mozc::commands::SessionCommand& session_command, mozc::commands::Output* new_output); + + void SetUsage(const std::string& title, const std::string& description); + + std::pair<std::string, std::string> GetUsage(); + + void DrawAll(); + +private: + friend class FcitxMozcTest; + + // Adds Mozc-specific icons to FCITX toolbar. + void InitializeBar(); + + void InitializeMenu(); + + // Parses the response from mozc_server. Returns whether the server consumes + // the input or not (true means 'consumed'). + bool ParseResponse ( const mozc::commands::Output &request ); + + void ClearAll(); + void DrawPreeditInfo(); + void DrawAux(); + + // Open url_ with a default browser. + void OpenUrl(); + + FcitxInstance* instance; + FcitxInputState* input; + const std::unique_ptr<MozcConnectionInterface> connection_; + const std::unique_ptr<MozcResponseParser> parser_; + + // Strings and a window currently displayed on FCITX UI. + std::unique_ptr<const PreeditInfo> preedit_info_; + std::string aux_; // error tooltip, or candidate window title. + string url_; // URL to be opened by a browser. + mozc::commands::CompositionMode composition_mode_; + + std::map<std::string, std::string> iconMap; + + FcitxUIMenu compositionMenu; + FcitxUIMenu toolMenu; + string description; + string title; + + DISALLOW_COPY_AND_ASSIGN ( FcitxMozc ); +}; + +} // namespace fcitx + +} // namespace mozc + +#endif // MOZC_UNIX_FCITX_FCITX_MOZC_H_ + diff --git a/src/unix/fcitx/gen_fcitx_mozc_i18n.sh b/src/unix/fcitx/gen_fcitx_mozc_i18n.sh new file mode 100755 index 00000000..97ff4a49 --- /dev/null +++ b/src/unix/fcitx/gen_fcitx_mozc_i18n.sh @@ -0,0 +1,10 @@ +#!/bin/sh + +objdir="$1" + +mkdir -p "$1" + +for pofile in po/*.po +do + msgfmt "$pofile" -o "$1/`basename ${pofile} .po`.mo" +done diff --git a/src/unix/fcitx/mozc.conf b/src/unix/fcitx/mozc.conf new file mode 100644 index 00000000..ad192303 --- /dev/null +++ b/src/unix/fcitx/mozc.conf @@ -0,0 +1,7 @@ +[InputMethod] +UniqueName=mozc +Name=Mozc +IconName=/usr/share/fcitx/mozc/icon/mozc.png +Priority=1 +LangCode=ja +Parent=fcitx-mozc diff --git a/src/unix/fcitx/mozc_connection.cc b/src/unix/fcitx/mozc_connection.cc new file mode 100755 index 00000000..068dcf46 --- /dev/null +++ b/src/unix/fcitx/mozc_connection.cc @@ -0,0 +1,209 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/mozc_connection.h" + +#include <string> + +#include "base/logging.h" +#include "base/util.h" +#include "client/client.h" +#include "ipc/ipc.h" +#include "protocol/commands.pb.h" +#include "session/ime_switch_util.h" +#include "unix/fcitx/fcitx_key_event_handler.h" +#include "unix/fcitx/surrounding_text_util.h" +#include "fcitx_mozc.h" + +namespace mozc { +namespace fcitx { + +MozcConnectionInterface::~MozcConnectionInterface() { +} + +mozc::client::ClientInterface* CreateAndConfigureClient() { + mozc::client::ClientInterface *client = client::ClientFactory::NewClient(); + // Currently client capability is fixed. + commands::Capability capability; + capability.set_text_deletion(commands::Capability::DELETE_PRECEDING_TEXT); + client->set_client_capability(capability); + return client; +} + +MozcConnection::MozcConnection( + mozc::client::ServerLauncherInterface *server_launcher, + mozc::IPCClientFactoryInterface *client_factory) + : handler_(new KeyEventHandler), + preedit_method_(mozc::config::Config::ROMAN), + client_factory_(client_factory) { + VLOG(1) << "MozcConnection is created"; + mozc::client::ClientInterface *client = CreateAndConfigureClient(); + client->SetServerLauncher(server_launcher); + client->SetIPCClientFactory(client_factory_.get()); + client_.reset(client); + + if (client_->EnsureConnection()) { + UpdatePreeditMethod(); + } + VLOG(1) + << "Current preedit method is " + << (preedit_method_ == mozc::config::Config::ROMAN ? "Roman" : "Kana"); +} + +MozcConnection::~MozcConnection() { + client_->SyncData(); + VLOG(1) << "MozcConnection is destroyed"; +} + +void MozcConnection::UpdatePreeditMethod() { + mozc::config::Config config; + if (!client_->GetConfig(&config)) { + LOG(ERROR) << "GetConfig failed"; + return; + } + preedit_method_ = config.has_preedit_method() ? + config.preedit_method() : config::Config::ROMAN; +} + +bool MozcConnection::TrySendKeyEvent( + FcitxInstance* instance, + FcitxKeySym sym, uint32 keycode, uint32 state, + mozc::commands::CompositionMode composition_mode, + bool layout_is_jp, + bool is_key_up, + mozc::commands::Output *out, + string *out_error) const { + DCHECK(out); + DCHECK(out_error); + + // Call EnsureConnection just in case MozcConnection::MozcConnection() fails + // to establish the server connection. + if (!client_->EnsureConnection()) { + *out_error = "EnsureConnection failed"; + VLOG(1) << "EnsureConnection failed"; + return false; + } + + mozc::commands::KeyEvent event; + if (!handler_->GetKeyEvent(sym, keycode, state, preedit_method_, layout_is_jp, is_key_up, &event)) + return false; + + if ((composition_mode == mozc::commands::DIRECT) && + !mozc::config::ImeSwitchUtil::IsDirectModeCommand(event)) { + VLOG(1) << "In DIRECT mode. Not consumed."; + return false; // not consumed. + } + + commands::Context context; + SurroundingTextInfo surrounding_text_info; + if (GetSurroundingText(instance, + &surrounding_text_info)) { + context.set_preceding_text(surrounding_text_info.preceding_text); + context.set_following_text(surrounding_text_info.following_text); + } + + VLOG(1) << "TrySendKeyEvent: " << std::endl << event.DebugString(); + if (!client_->SendKeyWithContext(event, context, out)) { + *out_error = "SendKey failed"; + VLOG(1) << "ERROR"; + return false; + } + VLOG(1) << "OK: " << std::endl << out->DebugString(); + return true; +} + +bool MozcConnection::TrySendClick(int32 unique_id, + mozc::commands::Output *out, + string *out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(mozc::commands::SessionCommand::SELECT_CANDIDATE); + command.set_id(unique_id); + return TrySendRawCommand(command, out, out_error); +} + +bool MozcConnection::TrySendCompositionMode( + mozc::commands::CompositionMode mode, + mozc::commands::Output *out, + string *out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(mozc::commands::SessionCommand::SWITCH_INPUT_MODE); + command.set_composition_mode(mode); + return TrySendRawCommand(command, out, out_error); +} + +bool MozcConnection::TrySendCommand( + mozc::commands::SessionCommand::CommandType type, + mozc::commands::Output *out, + string *out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(type); + return TrySendRawCommand(command, out, out_error); +} + + + +bool MozcConnection::TrySendRawCommand( + const mozc::commands::SessionCommand& command, + mozc::commands::Output *out, + string *out_error) const { + VLOG(1) << "TrySendRawCommand: " << std::endl << command.DebugString(); + if (!client_->SendCommand(command, out)) { + *out_error = "SendCommand failed"; + VLOG(1) << "ERROR"; + return false; + } + VLOG(1) << "OK: " << std::endl << out->DebugString(); + return true; +} + +mozc::client::ClientInterface* MozcConnection::GetClient() +{ + return client_.get(); +} + +MozcConnection *MozcConnection::CreateMozcConnection() { + mozc::client::ServerLauncher *server_launcher + = new mozc::client::ServerLauncher; + + return new MozcConnection(server_launcher, new mozc::IPCClientFactory); +} + +} // namespace fcitx + +} // namespace mozc diff --git a/src/unix/fcitx/mozc_connection.h b/src/unix/fcitx/mozc_connection.h new file mode 100755 index 00000000..0181bf73 --- /dev/null +++ b/src/unix/fcitx/mozc_connection.h @@ -0,0 +1,152 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_MOZC_CONNECTION_H_ +#define MOZC_UNIX_FCITX_MOZC_CONNECTION_H_ + +#include <string> +#include <memory> + +#include <fcitx-config/hotkey.h> +#include <fcitx/instance.h> + +#include "base/port.h" +#include "protocol/commands.pb.h" +#include "unix/fcitx/fcitx_key_event_handler.h" + +namespace mozc { + +class IPCClientInterface; +class IPCClientFactoryInterface; + +namespace client { +class ClientInterface; +class ServerLauncherInterface; +} // namespace client + +} // namespace mozc + +namespace mozc { + +namespace fcitx { + +class KeyTranslator; + +// This class is for mozc_response_parser_test.cc. +class MozcConnectionInterface { + public: + virtual ~MozcConnectionInterface(); + + virtual bool TrySendKeyEvent(FcitxInstance* instance, + FcitxKeySym sym, uint32 keycode, uint32 state, + mozc::commands::CompositionMode composition_mode, + bool layout_is_jp, + bool is_key_up, + mozc::commands::Output *out, + string *out_error) const = 0; + virtual bool TrySendClick(int32 unique_id, + mozc::commands::Output *out, + string *out_error) const = 0; + virtual bool TrySendCompositionMode(mozc::commands::CompositionMode mode, + mozc::commands::Output *out, + string *out_error) const = 0; + virtual bool TrySendCommand(mozc::commands::SessionCommand::CommandType type, + mozc::commands::Output *out, + string *out_error) const = 0; + + virtual bool TrySendRawCommand(const mozc::commands::SessionCommand& command, + mozc::commands::Output *out, + string *out_error) const = 0; + virtual mozc::client::ClientInterface* GetClient() = 0; + virtual void UpdatePreeditMethod() = 0; +}; + +class MozcConnection : public MozcConnectionInterface { + public: + static const int kNoSession; + + static MozcConnection *CreateMozcConnection(); + virtual ~MozcConnection(); + + // Sends key event to the server. If the IPC succeeds, returns true and the + // response is stored on 'out' (and 'out_error' is not modified). If the IPC + // fails, returns false and the error message is stored on 'out_error'. In + // this case, 'out' is not modified. + virtual bool TrySendKeyEvent(FcitxInstance* instance, + FcitxKeySym sym, uint32 keycode, uint32 state, + mozc::commands::CompositionMode composition_mode, + bool layout_is_jp, + bool is_key_up, + mozc::commands::Output *out, + string *out_error) const; + + // Sends 'mouse click on the candidate window' event to the server. + virtual bool TrySendClick(int32 unique_id, + mozc::commands::Output *out, + string *out_error) const; + + // Sends composition mode to the server. + virtual bool TrySendCompositionMode(mozc::commands::CompositionMode mode, + mozc::commands::Output *out, + string *out_error) const; + + // Sends a command to the server. + virtual bool TrySendCommand(mozc::commands::SessionCommand::CommandType type, + mozc::commands::Output *out, + string *out_error) const; + + virtual bool TrySendRawCommand(const mozc::commands::SessionCommand& command, + mozc::commands::Output *out, + string *out_error) const; + + virtual mozc::client::ClientInterface* GetClient(); + + virtual void UpdatePreeditMethod(); + + private: + friend class MozcConnectionTest; + MozcConnection(mozc::client::ServerLauncherInterface *server_launcher, + mozc::IPCClientFactoryInterface *client_factory); + + const std::unique_ptr<KeyEventHandler> handler_; + mozc::config::Config::PreeditMethod preedit_method_; + // Keep definition order of client_factory_ and client_. + // We should delete client_ before deleting client_factory_. + std::unique_ptr<mozc::IPCClientFactoryInterface> client_factory_; + std::unique_ptr<mozc::client::ClientInterface> client_; + + DISALLOW_COPY_AND_ASSIGN(MozcConnection); +}; + +} // namespace fcitx + +} // namespace mozc + +#endif // MOZC_UNIX_SCIM_MOZC_CONNECTION_H_ diff --git a/src/unix/fcitx/mozc_response_parser.cc b/src/unix/fcitx/mozc_response_parser.cc new file mode 100755 index 00000000..cd9ed811 --- /dev/null +++ b/src/unix/fcitx/mozc_response_parser.cc @@ -0,0 +1,448 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/mozc_response_parser.h" + +#include <string> +#include <vector> + +#include "base/logging.h" +#include "base/process.h" +#include "base/util.h" +#include "protocol/commands.pb.h" +#include "unix/fcitx/fcitx_mozc.h" +#include "unix/fcitx/surrounding_text_util.h" +#include <fcitx/candidate.h> + +namespace { + +// Returns a position that determines a preedit cursor position _AND_ top-left +// position of a candidate window. Note that we can't set these two positions +// independently. That's a SCIM's limitation. +uint32 GetCursorPosition(const mozc::commands::Output &response) { + if (!response.has_preedit()) { + return 0; + } + if (response.preedit().has_highlighted_position()) { + return response.preedit().highlighted_position(); + } + return response.preedit().cursor(); +} + +string CreateDescriptionString(const string &description) { + return " [" + description + "]"; +} + +} // namespace + +namespace mozc { + +namespace fcitx { + +MozcResponseParser::MozcResponseParser() + : use_annotation_(false) { +} + +MozcResponseParser::~MozcResponseParser() { +} + +void MozcResponseParser::UpdateDeletionRange(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const +{ + if (response.has_deletion_range() && + response.deletion_range().offset() <= 0 && + response.deletion_range().offset() + response.deletion_range().length() >= 0) { + FcitxInstanceDeleteSurroundingText(fcitx_mozc->GetInstance(), + FcitxInstanceGetCurrentIC(fcitx_mozc->GetInstance()), + response.deletion_range().offset(), + response.deletion_range().length()); + } +} + +void MozcResponseParser::LaunchTool(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const +{ + FCITX_UNUSED(fcitx_mozc); + if (response.has_launch_tool_mode()) { + fcitx_mozc->GetClient()->LaunchToolWithProtoBuf(response); + } +} + +void MozcResponseParser::ExecuteCallback(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const +{ + if (!response.has_callback()) { + return; + } + + if (!response.callback().has_session_command()) { + LOG(ERROR) << "callback does not have session_command"; + return; + } + + const commands::SessionCommand &callback_command = + response.callback().session_command(); + + if (!callback_command.has_type()) { + LOG(ERROR) << "callback_command has no type"; + return; + } + + commands::SessionCommand session_command; + session_command.set_type(callback_command.type()); + + // TODO(nona): Make a function to handle CONVERT_REVERSE. + // Used by CONVERT_REVERSE and/or UNDO + // This value represents how many characters are selected as a relative + // distance of characters. Positive value represents forward text selection + // and negative value represents backword text selection. + // Note that you should not allow 0x80000000 for |relative_selected_length| + // because you cannot safely use |-relative_selected_length| nor + // |abs(relative_selected_length)| in this case due to integer overflow. + SurroundingTextInfo surrounding_text_info; + + switch (callback_command.type()) { + case commands::SessionCommand::UNDO: + break; + case commands::SessionCommand::CONVERT_REVERSE: { + + if (!GetSurroundingText(fcitx_mozc->GetInstance(), + &surrounding_text_info)) { + return; + } + + session_command.set_text(surrounding_text_info.selection_text); + break; + } + default: + return; + } + + commands::Output new_output; + if (!fcitx_mozc->SendCommand(session_command, &new_output)) { + LOG(ERROR) << "Callback Command Failed"; + return; + } + + if (callback_command.type() == commands::SessionCommand::CONVERT_REVERSE) { + // We need to remove selected text as a first step of reconversion. + commands::DeletionRange *range = new_output.mutable_deletion_range(); + // Use DeletionRange field to remove the selected text. + // For forward selection (that is, |relative_selected_length > 0|), the + // offset should be a negative value to delete preceding text. + // For backward selection (that is, |relative_selected_length < 0|), + // IBus and/or some applications seem to expect |offset == 0| somehow. + const int32 offset = surrounding_text_info.relative_selected_length > 0 + ? -surrounding_text_info.relative_selected_length // forward selection + : 0; // backward selection + range->set_offset(offset); + range->set_length(abs(surrounding_text_info.relative_selected_length)); + } + + VLOG(1) << "New output" << new_output.DebugString(); + + ParseResponse(new_output, fcitx_mozc); +} + +bool MozcResponseParser::ParseResponse(const mozc::commands::Output &response, + FcitxMozc *fcitx_mozc) const { + DCHECK(fcitx_mozc); + if (!fcitx_mozc) { + return false; + } + + fcitx_mozc->SetUsage("", ""); + + UpdateDeletionRange(response, fcitx_mozc); + + // We should check the mode field first since the response for a + // SWITCH_INPUT_MODE request only contains mode and id fields. + if (response.has_mode()) { + fcitx_mozc->SetCompositionMode(response.mode()); + } + + if (!response.consumed()) { + // The key was not consumed by Mozc. + return false; + } + + if (response.has_result()) { + const mozc::commands::Result &result = response.result(); + ParseResult(result, fcitx_mozc); + } + + // First, determine the cursor position. + if (response.has_preedit()) { + const mozc::commands::Preedit &preedit = response.preedit(); + ParsePreedit(preedit, GetCursorPosition(response), fcitx_mozc); + } + + // Then show the candidate window. + if (response.has_candidates()) { + const mozc::commands::Candidates &candidates = response.candidates(); + ParseCandidates(candidates, fcitx_mozc); + } + + if (response.has_url()) { + const string &url = response.url(); + fcitx_mozc->SetUrl(url); + } + LaunchTool(response, fcitx_mozc); + ExecuteCallback(response, fcitx_mozc); + + return true; // mozc consumed the key. +} + +void MozcResponseParser::set_use_annotation(bool use_annotation) { + use_annotation_ = use_annotation; +} + +void MozcResponseParser::ParseResult(const mozc::commands::Result &result, + FcitxMozc *fcitx_mozc) const { + switch (result.type()) { + case mozc::commands::Result::NONE: { + fcitx_mozc->SetAuxString("No result"); // not a fatal error. + break; + } + case mozc::commands::Result::STRING: { + fcitx_mozc->SetResultString(result.value()); + break; + } + } +} + +static boolean FcitxMozcPaging(void* arg, boolean prev) +{ + FcitxMozc* mozc = static_cast<FcitxMozc*>(arg); + return mozc->paging(prev); +} + +void MozcResponseParser::ParseCandidates( + const mozc::commands::Candidates &candidates, FcitxMozc *fcitx_mozc) const { + const commands::Footer &footer = candidates.footer(); + bool hasPrev = false; + bool hasNext = false; + if (candidates.has_footer()) { + string auxString; + if (footer.has_label()) { + // TODO(yusukes,mozc-team): label() is not localized. Currently, it's always + // written in Japanese (in UTF-8). + auxString += footer.label(); + } else if (footer.has_sub_label()) { + // Windows client shows sub_label() only when label() is not specified. We + // follow the policy. + auxString += footer.sub_label(); + } + + if (footer.has_index_visible() && footer.index_visible()) { + // Max size of candidates is 200 so 128 is sufficient size for the buffer. + char index_buf[128] = {0}; + const int result = snprintf(index_buf, + sizeof(index_buf) - 1, + "%s%d/%d", + (auxString.empty() ? "" : " "), + candidates.focused_index() + 1, + candidates.size()); + DCHECK_GE(result, 0) << "snprintf in ComposeAuxiliaryText failed"; + auxString += index_buf; + + if (candidates.candidate_size() > 0) { + + if (candidates.candidate(0).index() > 0) { + hasPrev = true; + } + if (candidates.candidate(candidates.candidate_size() - 1).index() + 1 < candidates.size()) { + hasNext = true; + } + } + } + fcitx_mozc->SetAuxString(auxString); + } + + FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(fcitx_mozc->GetInputState()); + FcitxCandidateWordReset(candList); + FcitxCandidateWordSetPageSize(candList, 9); + if (candidates.has_direction() && + candidates.direction() == commands::Candidates::HORIZONTAL) { + FcitxCandidateWordSetLayoutHint(candList, CLH_Horizontal); + } else { + FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical); + } + + std::map<int32, std::pair<string, string> > usage_map; + if (candidates.has_usages()) { + const commands::InformationList& usages = candidates.usages(); + for (size_t i = 0; i < usages.information().size(); ++i) { + const commands::Information& information = usages.information(i); + if (!information.has_id() || !information.has_description()) + continue; + usage_map[information.id()].first = information.title(); + usage_map[information.id()].second = information.description(); + } + } + +#define EMPTY_STR_CHOOSE "\0\0\0\0\0\0\0\0\0\0" + std::vector<char> choose; + + int focused_index = -1; + int local_index = -1; + if (candidates.has_focused_index()) { + focused_index = candidates.focused_index(); + } + for (int i = 0; i < candidates.candidate_size(); ++i) { + const commands::Candidates::Candidate& candidate = candidates.candidate(i); + const uint32 index = candidate.index(); + FcitxMessageType type; + if (focused_index != -1 && index == focused_index) { + local_index = i; + type = MSG_FIRSTCAND; + } else { + type = MSG_OTHER; + } + int32* id = (int32*) fcitx_utils_malloc0(sizeof(int32)); + FcitxCandidateWord candWord; + candWord.callback = FcitxMozcGetCandidateWord; + candWord.extraType = MSG_OTHER; + candWord.strExtra = NULL; + candWord.priv = id; + candWord.strWord = NULL; + candWord.wordType = type; + candWord.owner = fcitx_mozc; + + string value; + if (use_annotation_ && + candidate.has_annotation() && + candidate.annotation().has_prefix()) { + value = candidate.annotation().prefix(); + } + value += candidate.value(); + if (use_annotation_ && + candidate.has_annotation() && + candidate.annotation().has_suffix()) { + value += candidate.annotation().suffix(); + } + if (use_annotation_ && + candidate.has_annotation() && + candidate.annotation().has_description()) { + // Display descriptions ([HALF][KATAKANA], [GREEK], [Black square], etc). + value += CreateDescriptionString( + candidate.annotation().description()); + } + + if (use_annotation_ && focused_index != -1 && index == focused_index) { + local_index = i; + type = MSG_FIRSTCAND; + + if (candidate.has_information_id()) { + std::map<int32, std::pair<string, string> >::iterator it = + usage_map.find(candidate.information_id()); + if (it != usage_map.end()) { + fcitx_mozc->SetUsage(it->second.first, it->second.second); + } + value += CreateDescriptionString(_("Press Ctrl+Alt+H to show usages.")); + } + } + + if (candidate.has_annotation() && + candidate.annotation().has_shortcut()) { + choose.push_back(candidate.annotation().shortcut().c_str()[0]); + } + + candWord.strWord = strdup(value.c_str()); + + if (candidate.has_id()) { + const int32 cid = candidate.id(); + DCHECK_NE(kBadCandidateId, cid) << "Unexpected id is passed."; + *id = cid; + } else { + // The parent node of the cascading window does not have an id since the + // node does not contain a candidate word. + *id = kBadCandidateId; + } + FcitxCandidateWordAppend(candList, &candWord); + } + + while (choose.size() < 10) { + choose.push_back('\0'); + } + + if (footer.has_index_visible() && footer.index_visible()) + FcitxCandidateWordSetChoose(candList, choose.data()); + else + FcitxCandidateWordSetChoose(candList, EMPTY_STR_CHOOSE); + FcitxCandidateWordSetFocus(candList, local_index); + FcitxCandidateWordSetOverridePaging(candList, hasPrev, hasNext, FcitxMozcPaging, fcitx_mozc, NULL); +} + +static int GetRawCursorPos(const char * str, int upos) +{ + unsigned int i; + int pos = 0; + for (i = 0; i < upos; i++) { + pos += fcitx_utf8_char_len(fcitx_utf8_get_nth_char((char*)str, i)); + } + return pos; +} + + +void MozcResponseParser::ParsePreedit(const mozc::commands::Preedit &preedit, + uint32 position, + FcitxMozc *fcitx_mozc) const { + PreeditInfo *info = new PreeditInfo; + std::string s; + + for (int i = 0; i < preedit.segment_size(); ++i) { + const mozc::commands::Preedit_Segment &segment = preedit.segment(i); + const std::string &str = segment.value(); + FcitxMessageType type = MSG_INPUT; + + switch (segment.annotation()) { + case mozc::commands::Preedit_Segment::NONE: + type = (FcitxMessageType) (MSG_INPUT | MSG_NOUNDERLINE); + break; + case mozc::commands::Preedit_Segment::UNDERLINE: + type = (FcitxMessageType) (MSG_TIPS); + break; + case mozc::commands::Preedit_Segment::HIGHLIGHT: + type = (FcitxMessageType) (MSG_CODE | MSG_NOUNDERLINE | MSG_HIGHLIGHT); + break; + } + s += str; + + PreeditItem item; + item.type = type; + item.str = str; + info->preedit.push_back(item); + } + info->cursor_pos = GetRawCursorPos(s.c_str(), position); + + fcitx_mozc->SetPreeditInfo(info); +} + +} // namespace fcitx + +} // namespace mozc diff --git a/src/unix/fcitx/mozc_response_parser.h b/src/unix/fcitx/mozc_response_parser.h new file mode 100755 index 00000000..beeef709 --- /dev/null +++ b/src/unix/fcitx/mozc_response_parser.h @@ -0,0 +1,97 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ +#define MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ + +#include "base/port.h" + +namespace mozc +{ +namespace commands +{ + +class Candidates; +class Input; +class Output; +class Preedit; +class Result; + +} // namespace commands +} // namespace mozc + +namespace mozc +{ + +namespace fcitx +{ + +class FcitxMozc; + +// This class parses IPC response from mozc_server (mozc::commands::Output) and +// updates the FCITX UI. +class MozcResponseParser +{ +public: + MozcResponseParser(); + ~MozcResponseParser(); + + // Parses a response from Mozc server and sets persed information on fcitx_mozc + // object. Returns true if response.consumed() is true. fcitx_mozc must be non + // NULL. This function does not take ownership of fcitx_mozc. + bool ParseResponse ( const mozc::commands::Output &response, + FcitxMozc *fcitx_mozc ) const; + + // Setter for use_annotation_. If use_annotation_ is true, ParseCandidates() + // uses annotation infomation. + void set_use_annotation ( bool use_annotation ); + +private: + void UpdateDeletionRange(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const; + void LaunchTool(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const; + void ExecuteCallback(const mozc::commands::Output& response, FcitxMozc* fcitx_mozc) const; + void ParseResult ( const mozc::commands::Result &result, + FcitxMozc *fcitx_mozc ) const; + void ParseCandidates ( const mozc::commands::Candidates &candidates, + FcitxMozc *fcitx_mozc ) const; + void ParsePreedit ( const mozc::commands::Preedit &preedit, + uint32 position, + FcitxMozc *fcitx_mozc ) const; + + bool use_annotation_; + + DISALLOW_COPY_AND_ASSIGN ( MozcResponseParser ); +}; + +} // namespace fcitx + +} // namespace mozc + +#endif // MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ diff --git a/src/unix/fcitx/po/Messages.sh b/src/unix/fcitx/po/Messages.sh new file mode 100755 index 00000000..be341716 --- /dev/null +++ b/src/unix/fcitx/po/Messages.sh @@ -0,0 +1,33 @@ +#!/bin/sh + +BASEDIR="../" # root of translatable sources +PROJECT="fcitx-mozc" # project name +BUGADDR="fcitx-dev@googlegroups.com" # MSGID-Bugs +WDIR="`pwd`" # working dir + +echo "Preparing rc files" + +echo "Done preparing rc files" +echo "Extracting messages" + +# see above on sorting + +find "${BASEDIR}" -name '*.cc' -o -name '*.h' -o -name '*.c' | sort > "${WDIR}/infiles.list" + +xgettext --from-code=UTF-8 -k_ -kN_ --msgid-bugs-address="${BUGADDR}" --files-from=infiles.list \ + -D "${BASEDIR}" -D "${WDIR}" -o "${PROJECT}.pot" || \ + { echo "error while calling xgettext. aborting."; exit 1; } +echo "Done extracting messages" + +echo "Merging translations" +catalogs=`find . -name '*.po'` +for cat in $catalogs; do + echo "$cat" + msgmerge -o "$cat.new" "$cat" "${WDIR}/${PROJECT}.pot" + mv "$cat.new" "$cat" +done + +echo "Done merging translations" +echo "Cleaning up" +rm "${WDIR}/infiles.list" +echo "Done" diff --git a/src/unix/fcitx/po/ca.po b/src/unix/fcitx/po/ca.po new file mode 100644 index 00000000..b8b10f5a --- /dev/null +++ b/src/unix/fcitx/po/ca.po @@ -0,0 +1,88 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# Robert Antoni Buj Gelonch <rbuj@fedoraproject.org>, 2017 +# Walter Garcia-Fontes <walter.garcia@upf.edu>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-21 00:03-0800\n" +"PO-Revision-Date: 2017-12-20 05:19+0000\n" +"Last-Translator: Robert Antoni Buj Gelonch <rbuj@fedoraproject.org>\n" +"Language-Team: Catalan (http://www.transifex.com/fcitx/fcitx/language/ca/)\n" +"Language: ca\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: ../eim.cc:187 +msgid "Press Escape to go back" +msgstr "Premeu Esc per tornar" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "Directe" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "Hiragana" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "Katakana complet" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "ASCII mig" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "ASCII complet" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "Mig katakana" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "Mode de composició" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "Eina" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Eina mozc" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "Eina de configuració" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "Eina de diccionari" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "Escriptura a mà" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "Paleta de caràcters" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "Afegeix una paraula" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "Quant al mozc" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Premeu Ctrl+Alt+H per mostrar els usos." diff --git a/src/unix/fcitx/po/da.po b/src/unix/fcitx/po/da.po new file mode 100644 index 00000000..21f8e0b3 --- /dev/null +++ b/src/unix/fcitx/po/da.po @@ -0,0 +1,87 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# scootergrisen, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-10-18 06:03-0700\n" +"PO-Revision-Date: 2017-10-18 12:19+0000\n" +"Last-Translator: scootergrisen\n" +"Language-Team: Danish (http://www.transifex.com/fcitx/fcitx/language/da/)\n" +"Language: da\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: ../eim.cc:187 +msgid "Press Escape to go back" +msgstr "Tryk på Escape for at gå tilbage" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "Direkte" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "Hiragana" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "Fuld Katakana" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "Halv ASCII" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "Fuld ASCII" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "Halv Katakana" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "Kompositionstilstand" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "Værktøj" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Mozc-værktøj" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "Konfigurationsværktøj" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "Ordbogsværktøj" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "Håndskrift" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "Tegnpalet" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "Tilføj ord" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "Om Mozc" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Tryk på Ctrl+Alt+H for at vise anvendelser." diff --git a/src/unix/fcitx/po/de.po b/src/unix/fcitx/po/de.po new file mode 100644 index 00000000..11960867 --- /dev/null +++ b/src/unix/fcitx/po/de.po @@ -0,0 +1,91 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# Lucius Annaeus Seneca, 2013 +# mar well <m.wellendorf@gmx.de>, 2013 +# Seneca, 2013 +# csslayer <wengxt@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2013 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2015-08-03 18:01+0200\n" +"PO-Revision-Date: 2013-11-16 14:13+0000\n" +"Last-Translator: csslayer <wengxt@gmail.com>\n" +"Language-Team: German (http://www.transifex.com/fcitx/fcitx/language/de/)\n" +"Language: de\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: ../eim.cc:181 +msgid "Press Escape to go back" +msgstr "ESC drücken um zurück zu kehren" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "Direkt" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "Hiragana" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "Normalbreite Katakana" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "6-Bit ASCII (Half ASCII)" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "7-Bit ASCII (Full ASCII)" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "Halbbreite Katakana" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "Kompositionsmodus" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "Werkzeug" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Mozc Werkzeug" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "Konfigurationswerkzeug" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "Wörterbuchwerkzeug" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "Eingabe Handschrift" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "Palette Symbole" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "Wort hinzufügen" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "Über Mozc" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Ctrl+Alt+H um die Hilfe anzuzeigen" diff --git a/src/unix/fcitx/po/fcitx-mozc.pot b/src/unix/fcitx/po/fcitx-mozc.pot new file mode 100644 index 00000000..d9983e40 --- /dev/null +++ b/src/unix/fcitx/po/fcitx-mozc.pot @@ -0,0 +1,86 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2013-11-14 13:55-0500\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" +"Language-Team: LANGUAGE <LL@li.org>\n" +"Language: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=CHARSET\n" +"Content-Transfer-Encoding: 8bit\n" + +#: ../eim.cc:184 +msgid "Press Escape to go back" +msgstr "" + +#: ../fcitx_mozc.cc:68 +msgid "Direct" +msgstr "" + +#: ../fcitx_mozc.cc:73 +msgid "Hiragana" +msgstr "" + +#: ../fcitx_mozc.cc:78 +msgid "Full Katakana" +msgstr "" + +#: ../fcitx_mozc.cc:83 +msgid "Half ASCII" +msgstr "" + +#: ../fcitx_mozc.cc:88 +msgid "Full ASCII" +msgstr "" + +#: ../fcitx_mozc.cc:93 +msgid "Half Katakana" +msgstr "" + +#: ../fcitx_mozc.cc:410 ../fcitx_mozc.cc:411 ../fcitx_mozc.cc:484 +msgid "Composition Mode" +msgstr "" + +#: ../fcitx_mozc.cc:421 ../fcitx_mozc.cc:422 +msgid "Tool" +msgstr "" + +#: ../fcitx_mozc.cc:497 +msgid "Mozc Tool" +msgstr "" + +#: ../fcitx_mozc.cc:503 +msgid "Configuration Tool" +msgstr "" + +#: ../fcitx_mozc.cc:504 +msgid "Dictionary Tool" +msgstr "" + +#: ../fcitx_mozc.cc:505 +msgid "Hand Writing" +msgstr "" + +#: ../fcitx_mozc.cc:506 +msgid "Character Palette" +msgstr "" + +#: ../fcitx_mozc.cc:507 +msgid "Add Word" +msgstr "" + +#: ../fcitx_mozc.cc:508 +msgid "About Mozc" +msgstr "" + +#: ../mozc_response_parser.cc:374 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "" diff --git a/src/unix/fcitx/po/ja.po b/src/unix/fcitx/po/ja.po new file mode 100644 index 00000000..a3f4d5f3 --- /dev/null +++ b/src/unix/fcitx/po/ja.po @@ -0,0 +1,93 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# しろう, 2013 +# AWASHIRO Ikuya <ikunya@gmail.com>, 2013 +# AWASHIRO Ikuya <ikunya@gmail.com>, 2012-2013 +# WAKAYAMA Shirou <shirou.faw@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2012 +# csslayer <wengxt@gmail.com>, 2012-2013 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2015-08-03 18:01+0200\n" +"PO-Revision-Date: 2013-11-16 14:13+0000\n" +"Last-Translator: csslayer <wengxt@gmail.com>\n" +"Language-Team: Japanese (http://www.transifex.com/fcitx/fcitx/language/ja/)\n" +"Language: ja\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: ../eim.cc:181 +msgid "Press Escape to go back" +msgstr "Escキーを押して戻る" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "直接入力" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "ひらがな" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "全角カタカナ" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "半角英数" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "全角英数" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "半角カタカナ" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "変換モード" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "ツール" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Mozc ツール" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "設定ツール" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "辞書ツール" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "手書き文字認識" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "文字パレット" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "単語登録" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "Mozc について" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Ctrl+Alt+H キーを押して用例を表示" diff --git a/src/unix/fcitx/po/ko.po b/src/unix/fcitx/po/ko.po new file mode 100644 index 00000000..0d4b46a6 --- /dev/null +++ b/src/unix/fcitx/po/ko.po @@ -0,0 +1,87 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# Bon Keun Seo <scobyseo@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-07-15 14:20-0700\n" +"PO-Revision-Date: 2017-07-09 21:58+0000\n" +"Last-Translator: Bon Keun Seo <scobyseo@gmail.com>\n" +"Language-Team: Korean (http://www.transifex.com/fcitx/fcitx/language/ko/)\n" +"Language: ko\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: ../eim.cc:187 +msgid "Press Escape to go back" +msgstr "돌아가려면 ESC를 누르세요" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "직접입력" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "히라가나" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "전각 가타가나" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "반각 아스키" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "전각 아스키" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "반각 가타가나" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "조합 모드" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "도구" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Mozc 도구" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "설정 도구" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "사전 도구" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "손 글씨" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "글자 팔레트" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "단어 추가" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "Mozc에 대해" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "사용법을 보려면 Ctrl+Alt+H를 누르세요." diff --git a/src/unix/fcitx/po/ru.po b/src/unix/fcitx/po/ru.po new file mode 100644 index 00000000..22c1fcc3 --- /dev/null +++ b/src/unix/fcitx/po/ru.po @@ -0,0 +1,89 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# TotalCaesar659 <x24cm5b8c54q6szxw@yandex.ru>, 2016 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2016-12-01 08:40-0800\n" +"PO-Revision-Date: 2016-11-30 23:24+0000\n" +"Last-Translator: TotalCaesar659 <x24cm5b8c54q6szxw@yandex.ru>\n" +"Language-Team: Russian (http://www.transifex.com/fcitx/fcitx/language/ru/)\n" +"Language: ru\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" +"%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || (n" +"%100>=11 && n%100<=14)? 2 : 3);\n" + +#: ../eim.cc:187 +msgid "Press Escape to go back" +msgstr "Нажмите для перехода назад" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "Прямой" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "Хирагана" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "Полная катакана" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "Половинный " + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "Полный " + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "Половинная катакана" + +#: ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:407 ../fcitx_mozc.cc:475 +msgid "Composition Mode" +msgstr "Режим композиции" + +#: ../fcitx_mozc.cc:417 ../fcitx_mozc.cc:418 +msgid "Tool" +msgstr "Инструмент" + +#: ../fcitx_mozc.cc:488 +msgid "Mozc Tool" +msgstr "Инструмент Mozc" + +#: ../fcitx_mozc.cc:494 +msgid "Configuration Tool" +msgstr "Инструмент настройки" + +#: ../fcitx_mozc.cc:495 +msgid "Dictionary Tool" +msgstr "Инструмент словаря" + +#: ../fcitx_mozc.cc:496 +msgid "Hand Writing" +msgstr "Ручное письмо" + +#: ../fcitx_mozc.cc:497 +msgid "Character Palette" +msgstr "Палитра символов" + +#: ../fcitx_mozc.cc:498 +msgid "Add Word" +msgstr "Добавить слово" + +#: ../fcitx_mozc.cc:499 +msgid "About Mozc" +msgstr "О " + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Нажмите Ctrl+Alt+H, чтобы показать использование." diff --git a/src/unix/fcitx/po/zh_CN.po b/src/unix/fcitx/po/zh_CN.po new file mode 100644 index 00000000..6e46bc64 --- /dev/null +++ b/src/unix/fcitx/po/zh_CN.po @@ -0,0 +1,92 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2012 +# wwj402 <wwj402@gmail.com>, 2013 +# wwj402 <wwj402@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2012-2013 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2015-07-21 12:01+0200\n" +"PO-Revision-Date: 2013-11-16 14:13+0000\n" +"Last-Translator: csslayer <wengxt@gmail.com>\n" +"Language-Team: Chinese (China) (http://www.transifex.com/projects/p/fcitx/" +"language/zh_CN/)\n" +"Language: zh_CN\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: ../eim.cc:181 +msgid "Press Escape to go back" +msgstr "按下 Escape 返回" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "直接键盘输入" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "平假名" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "全角片假名" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "半角 ASCII" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "全角 ASCII" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "半角片假名" + +#: ../fcitx_mozc.cc:405 ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:474 +msgid "Composition Mode" +msgstr "编辑模式" + +#: ../fcitx_mozc.cc:416 ../fcitx_mozc.cc:417 +msgid "Tool" +msgstr "工具" + +#: ../fcitx_mozc.cc:487 +msgid "Mozc Tool" +msgstr "Mozc 工具" + +#: ../fcitx_mozc.cc:493 +msgid "Configuration Tool" +msgstr "配置工具" + +#: ../fcitx_mozc.cc:494 +msgid "Dictionary Tool" +msgstr "词典工具" + +#: ../fcitx_mozc.cc:495 +msgid "Hand Writing" +msgstr "手写输入" + +#: ../fcitx_mozc.cc:496 +msgid "Character Palette" +msgstr "字符映射表" + +#: ../fcitx_mozc.cc:497 +msgid "Add Word" +msgstr "添加单词" + +#: ../fcitx_mozc.cc:498 +msgid "About Mozc" +msgstr "关于 Mozc" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "按下 Ctrl+Alt+H 显示用法。" diff --git a/src/unix/fcitx/po/zh_TW.po b/src/unix/fcitx/po/zh_TW.po new file mode 100644 index 00000000..69a6c5c0 --- /dev/null +++ b/src/unix/fcitx/po/zh_TW.po @@ -0,0 +1,91 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# +# Translators: +# Alisha <alisha.4m@gmail.com>, 2012 +# csslayer <wengxt@gmail.com>, 2013 +# csslayer <wengxt@gmail.com>, 2012 +# csslayer <wengxt@gmail.com>, 2012-2013 +msgid "" +msgstr "" +"Project-Id-Version: fcitx\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2015-07-21 12:01+0200\n" +"PO-Revision-Date: 2013-11-16 14:13+0000\n" +"Last-Translator: csslayer <wengxt@gmail.com>\n" +"Language-Team: Chinese (Taiwan) (http://www.transifex.com/projects/p/fcitx/" +"language/zh_TW/)\n" +"Language: zh_TW\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: ../eim.cc:181 +msgid "Press Escape to go back" +msgstr "按下 Escape 返回" + +#: ../fcitx_mozc.cc:65 +msgid "Direct" +msgstr "直接鍵盤輸入" + +#: ../fcitx_mozc.cc:70 +msgid "Hiragana" +msgstr "平假名" + +#: ../fcitx_mozc.cc:75 +msgid "Full Katakana" +msgstr "全形片假名" + +#: ../fcitx_mozc.cc:80 +msgid "Half ASCII" +msgstr "半形 ASCII" + +#: ../fcitx_mozc.cc:85 +msgid "Full ASCII" +msgstr "全形 ASCII" + +#: ../fcitx_mozc.cc:90 +msgid "Half Katakana" +msgstr "半形片假名" + +#: ../fcitx_mozc.cc:405 ../fcitx_mozc.cc:406 ../fcitx_mozc.cc:474 +msgid "Composition Mode" +msgstr "編輯模式" + +#: ../fcitx_mozc.cc:416 ../fcitx_mozc.cc:417 +msgid "Tool" +msgstr "工具" + +#: ../fcitx_mozc.cc:487 +msgid "Mozc Tool" +msgstr "Mozc 工具" + +#: ../fcitx_mozc.cc:493 +msgid "Configuration Tool" +msgstr "設定工具" + +#: ../fcitx_mozc.cc:494 +msgid "Dictionary Tool" +msgstr "字典工具" + +#: ../fcitx_mozc.cc:495 +msgid "Hand Writing" +msgstr "手寫輸入" + +#: ../fcitx_mozc.cc:496 +msgid "Character Palette" +msgstr "字符映射表" + +#: ../fcitx_mozc.cc:497 +msgid "Add Word" +msgstr "添加單詞" + +#: ../fcitx_mozc.cc:498 +msgid "About Mozc" +msgstr "關於 Mozc" + +#: ../mozc_response_parser.cc:366 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "按下 Ctrl+Alt+H 顯示用法。" diff --git a/src/unix/fcitx/surrounding_text_util.cc b/src/unix/fcitx/surrounding_text_util.cc new file mode 100644 index 00000000..d6ccc34a --- /dev/null +++ b/src/unix/fcitx/surrounding_text_util.cc @@ -0,0 +1,242 @@ +// Copyright 2010-2013, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx/surrounding_text_util.h" + +#include <limits> +#include <string> +#include <fcitx/instance.h> +#include <fcitx/module/clipboard/fcitx-clipboard.h> + +#include "base/port.h" +#include "base/logging.h" +#include "base/util.h" + +namespace mozc { +namespace fcitx { + +bool SurroundingTextUtil::GetSafeDelta(uint from, uint to, int32 *delta) { + DCHECK(delta); + + static_assert(sizeof(int64) >= sizeof(uint), + "int64 must be sufficient to store a guint value."); + static_assert(sizeof(int64) == sizeof(llabs(0)), + "|llabs(0)| must returns a 64-bit integer."); + const int64 kInt32AbsMax = + llabs(static_cast<int64>(std::numeric_limits<int32>::max())); + const int64 kInt32AbsMin = + llabs(static_cast<int64>(std::numeric_limits<int32>::min())); + const int64 kInt32SafeAbsMax = + std::min(kInt32AbsMax, kInt32AbsMin); + + const int64 diff = static_cast<int64>(from) - static_cast<int64>(to); + if (llabs(diff) > kInt32SafeAbsMax) { + return false; + } + + *delta = static_cast<int32>(diff); + return true; +} + +namespace { + +// Moves |iter| with |skip_count| characters. +// Returns false if |iter| reaches to the end before skipping +// |skip_count| characters. +bool Skip(ConstChar32Iterator *iter, size_t skip_count) { + for (size_t i = 0; i < skip_count; ++i) { + if (iter->Done()) { + return false; + } + iter->Next(); + } + return true; +} + +// Returns true if |prefix_iter| is the prefix of |iter|. +// Returns false if |prefix_iter| is an empty sequence. +// Otherwise returns false. +// This function receives ConstChar32Iterator as pointer because +// ConstChar32Iterator is defined as non-copyable. +bool StartsWith(ConstChar32Iterator *iter, + ConstChar32Iterator *prefix_iter) { + if (iter->Done() || prefix_iter->Done()) { + return false; + } + + while (true) { + if (iter->Get() != prefix_iter->Get()) { + return false; + } + prefix_iter->Next(); + if (prefix_iter->Done()) { + return true; + } + iter->Next(); + if (iter->Done()) { + return false; + } + } +} + + +// Returns true if |surrounding_text| contains |selected_text| +// from |cursor_pos| to |*anchor_pos|. +// Otherwise returns false. +bool SearchAnchorPosForward( + const string &surrounding_text, + const string &selected_text, + size_t selected_chars_len, + uint cursor_pos, + uint *anchor_pos) { + + ConstChar32Iterator iter(surrounding_text); + // Move |iter| to cursor pos. + if (!Skip(&iter, cursor_pos)) { + return false; + } + + ConstChar32Iterator sel_iter(selected_text); + if (!StartsWith(&iter, &sel_iter)) { + return false; + } + *anchor_pos = cursor_pos + selected_chars_len; + return true; +} + +// Returns true if |surrounding_text| contains |selected_text| +// from |*anchor_pos| to |cursor_pos|. +// Otherwise returns false. +bool SearchAnchorPosBackward( + const string &surrounding_text, + const string &selected_text, + size_t selected_chars_len, + uint cursor_pos, + uint *anchor_pos) { + if (cursor_pos < selected_chars_len) { + return false; + } + + ConstChar32Iterator iter(surrounding_text); + // Skip |iter| to (potential) anchor pos. + const uint skip_count = cursor_pos - selected_chars_len; + DCHECK_LE(skip_count, cursor_pos); + if (!Skip(&iter, skip_count)) { + return false; + } + + ConstChar32Iterator sel_iter(selected_text); + if (!StartsWith(&iter, &sel_iter)) { + return false; + } + *anchor_pos = cursor_pos - selected_chars_len; + return true; +} + +} // namespace + +bool SurroundingTextUtil::GetAnchorPosFromSelection( + const string &surrounding_text, + const string &selected_text, + uint cursor_pos, + uint *anchor_pos) { + DCHECK(anchor_pos); + + if (surrounding_text.empty()) { + return false; + } + + if (selected_text.empty()) { + return false; + } + + const size_t selected_chars_len = Util::CharsLen(selected_text); + + if (SearchAnchorPosForward(surrounding_text, selected_text, + selected_chars_len, + cursor_pos, anchor_pos)) { + return true; + } + + return SearchAnchorPosBackward(surrounding_text, selected_text, + selected_chars_len, + cursor_pos, anchor_pos); +} + +bool GetSurroundingText(FcitxInstance* instance, + SurroundingTextInfo *info) { + FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance); + if (!ic || !(ic->contextCaps & CAPACITY_SURROUNDING_TEXT)) { + return false; + } + + uint cursor_pos = 0; + uint anchor_pos = 0; + char* str = NULL; + + if (!FcitxInstanceGetSurroundingText(instance, ic, &str, &cursor_pos, &anchor_pos)) { + return false; + } + + const string surrounding_text(str); + free(str); + + if (cursor_pos == anchor_pos) { + const char* primary = NULL; + + if ((primary = FcitxClipboardGetPrimarySelection(instance, NULL)) != NULL) { + uint new_anchor_pos = 0; + const string primary_text(primary); + if (SurroundingTextUtil::GetAnchorPosFromSelection( + surrounding_text, primary_text, + cursor_pos, &new_anchor_pos)) { + anchor_pos = new_anchor_pos; + } + } + } + + if (!SurroundingTextUtil::GetSafeDelta(cursor_pos, anchor_pos, + &info->relative_selected_length)) { + LOG(ERROR) << "Too long text selection."; + return false; + } + + const size_t selection_start = std::min(cursor_pos, anchor_pos); + const size_t selection_length = std::abs(info->relative_selected_length); + Util::SubStringPiece(surrounding_text, 0, selection_start) + .CopyToString(&info->preceding_text); + Util::SubStringPiece(surrounding_text, selection_start, selection_length) + .CopyToString(&info->selection_text); + Util::SubStringPiece(surrounding_text, selection_start + selection_length) + .CopyToString(&info->following_text); + return true; +} + +} // namespace fcitx +} // namespace mozc diff --git a/src/unix/fcitx/surrounding_text_util.h b/src/unix/fcitx/surrounding_text_util.h new file mode 100644 index 00000000..5bf661db --- /dev/null +++ b/src/unix/fcitx/surrounding_text_util.h @@ -0,0 +1,87 @@ +// Copyright 2010-2013, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_ +#define MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_ + +#include <string> +#include <fcitx/instance.h> + +#include "base/port.h" + +namespace mozc { +namespace fcitx { + +struct SurroundingTextInfo { + SurroundingTextInfo() + : relative_selected_length(0) {} + + int32 relative_selected_length; + std::string preceding_text; + std::string selection_text; + std::string following_text; +}; + +class SurroundingTextUtil { + public: + // Calculates |from| - |to| and stores the result into |delta| with + // checking integer overflow. + // Returns true when neither |abs(delta)| nor |-delta| does not cause + // integer overflow, that is, |delta| is in a safe range. + // Returns false otherwise. + static bool GetSafeDelta(uint from, uint to, int32 *delta); + + // Returns true if + // 1. |surrounding_text| contains |selected_text| + // from |cursor_pos| to |*anchor_pos|. + // or, + // 2. |surrounding_text| contains |selected_text| + // from |*anchor_pos| to |cursor_pos|. + // with calculating |*anchor_pos|, + // where |cursor_pos| and |*anchor_pos| are counts of Unicode characters. + // When both 1) and 2) are satisfied, this function calculates + // |*anchor_pos| for case 1). + // Otherwise returns false. + static bool GetAnchorPosFromSelection( + const string &surrounding_text, + const string &selected_text, + uint cursor_pos, + uint *anchor_pos); + + private: + DISALLOW_IMPLICIT_CONSTRUCTORS(SurroundingTextUtil); +}; + +bool GetSurroundingText(FcitxInstance* instance, + SurroundingTextInfo *info); + +} // namespace fcitx +} // namespace mozc + +#endif // MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_ diff --git a/src/unix/fcitx5/Messages.sh b/src/unix/fcitx5/Messages.sh new file mode 100755 index 00000000..3bd2d00d --- /dev/null +++ b/src/unix/fcitx5/Messages.sh @@ -0,0 +1,29 @@ +#!/bin/bash +DOMAIN=fcitx5-mozc +POT_FILE=po/$DOMAIN.pot +set -x +XGETTEXT="xgettext --package-name=$DOMAIN --add-comments --sort-output --msgid-bugs-address=fcitx-dev@googlegroups.com" +source_files=$(find . -name \*.cpp -o -name \*.cc -o -name \*.h) +$XGETTEXT --keyword=_ --keyword=N_ --language=C++ -o ${POT_FILE} $source_files +#desktop_files=$(find . -name \*.conf.in -o -name \*.conf.in.in -o -name \*.desktop.in) +#$XGETTEXT --language=Desktop $desktop_files -j -o ${POT_FILE} + +sed -i 's|^"Content-Type: text/plain; charset=CHARSET\\n"|"Content-Type: text/plain; charset=utf-8\\n"|g' ${POT_FILE} + +# Due to transifex problem, delete the date. +#sed -i '/^"PO-Revision-Date/d' ${POT_FILE} +#sed -i '/^"PO-Revision-Date/d' ${POT_FILE} +sed -i '/^# FIRST AUTHOR/d' ${POT_FILE} +sed -i '/^#, fuzzy/d' ${POT_FILE} +sed -i 's|^"Language: \\n"|"Language: LANG\\n"|g' ${POT_FILE} + +echo > po/LINGUAS + +for pofile in $(ls po/*.po | sort); do + pofilebase=$(basename $pofile) + pofilebase=${pofilebase/.po/} + msgmerge -U --backup=none $pofile ${POT_FILE} + project_line=$(grep "Project-Id-Version" ${POT_FILE} | head -n 1 | tr --delete '\n' | sed -e 's/[\/&]/\\&/g') + sed -i "s|.*Project-Id-Version.*|$project_line|g" $pofile + echo $pofilebase >> po/LINGUAS +done diff --git a/src/unix/fcitx5/fcitx5.gyp b/src/unix/fcitx5/fcitx5.gyp new file mode 100644 index 00000000..7f6941db --- /dev/null +++ b/src/unix/fcitx5/fcitx5.gyp @@ -0,0 +1,140 @@ +# +# Copyright (c) 2010-2017 fcitx Project http://github.com/fcitx/ +# +# All rights reserved. +# +# 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. +# 3. Neither the name of authors nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# 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 HOLDERS 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. +# + +{ + 'variables': { + 'use_fcitx5%': 'YES', + 'relative_dir': 'unix/fcitx5', + 'gen_out_dir': '<(SHARED_INTERMEDIATE_DIR)/<(relative_dir)', + 'fcitx_dependencies': [ + '../../base/base.gyp:base', + '../../client/client.gyp:client', + '../../ipc/ipc.gyp:ipc', + '../../session/session_base.gyp:ime_switch_util', + '../../protocol/protocol.gyp:commands_proto', + ], + }, + 'conditions': [['use_fcitx5=="YES"', { + 'targets': [ + { + # Meta target to set up build environment for ibus. Required 'cflags' + # and 'link_settings' will be automatically injected into any target + # which directly or indirectly depends on this target. + 'target_name': 'fcitx5_build_environment', + 'type': 'none', + 'variables': { + 'target_libs': [ + 'Fcitx5Core', + 'Fcitx5Config', + 'Fcitx5Utils', + 'Fcitx5Module', + ], + }, + 'all_dependent_settings': { + 'cflags': [ + '<!@(pkg-config --cflags <@(target_libs))', + ], + 'link_settings': { + 'libraries': [ + '<!@(pkg-config --libs-only-l <@(target_libs))', + ], + 'ldflags': [ + '<!@(pkg-config --libs-only-L <@(target_libs))', + ], + }, + }, + }, + { + 'target_name': 'gen_fcitx_mozc_i18n', + 'type': 'none', + 'actions': [ + { + 'action_name': 'gen_fcitx_mozc_i18n', + 'inputs': [ + './gen_fcitx_mozc_i18n.sh' + ], + 'outputs': [ + '<(gen_out_dir)/po/zh_CN.mo', + '<(gen_out_dir)/po/zh_TW.mo', + '<(gen_out_dir)/po/ja.mo', + '<(gen_out_dir)/po/de.mo', + ], + 'action': [ + 'sh', + './gen_fcitx_mozc_i18n.sh', + '<(gen_out_dir)/po', + ], + }], + }, + { + 'target_name': 'fcitx5-mozc', + 'product_prefix': '', + 'type': 'loadable_module', + 'sources': [ + 'fcitx_key_translator.cc', + 'fcitx_key_event_handler.cc', + 'surrounding_text_util.cc', + 'mozc_connection.cc', + 'mozc_response_parser.cc', + 'mozc_engine.cc', + 'mozc_state.cc', + ], + 'dependencies': [ + '<@(fcitx_dependencies)', + 'gen_fcitx_mozc_i18n', + 'fcitx5_build_environment', + ], + 'cflags_cc': [ + '-std=c++14', + ], + 'cflags_cc!': [ + '-std=gnu++0x' + ], + 'cflags!': [ + '-fno-exceptions', + ], + 'ldflags': [ + '-Wl,--no-undefined', + '-Wl,--as-needed', + ], + 'defines': [ + 'FCITX_GETTEXT_DOMAIN="fcitx5-mozc"', + ], + }, + ], + }, { + 'targets': [ + { + 'target_name': 'no_fcitx5_dummy', + 'type': 'none', + } + ]} + ]], +} diff --git a/src/unix/fcitx5/fcitx_key_event_handler.cc b/src/unix/fcitx5/fcitx_key_event_handler.cc new file mode 100644 index 00000000..0203a92c --- /dev/null +++ b/src/unix/fcitx5/fcitx_key_event_handler.cc @@ -0,0 +1,244 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012-2017, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/fcitx_key_event_handler.h" + +#include <map> + +#include "base/logging.h" +#include "base/singleton.h" + +namespace fcitx { + +namespace { +// TODO(hsumita): Removes this class, and moves |data_| into member +// variables of KeyEventhandler. +class AdditionalModifiersData { + public: + AdditionalModifiersData() { + data_[mozc::commands::KeyEvent::LEFT_ALT] = mozc::commands::KeyEvent::ALT; + data_[mozc::commands::KeyEvent::RIGHT_ALT] = mozc::commands::KeyEvent::ALT; + data_[mozc::commands::KeyEvent::LEFT_CTRL] = mozc::commands::KeyEvent::CTRL; + data_[mozc::commands::KeyEvent::RIGHT_CTRL] = + mozc::commands::KeyEvent::CTRL; + data_[mozc::commands::KeyEvent::LEFT_SHIFT] = + mozc::commands::KeyEvent::SHIFT; + data_[mozc::commands::KeyEvent::RIGHT_SHIFT] = + mozc::commands::KeyEvent::SHIFT; + } + const std::map<uint32, mozc::commands::KeyEvent::ModifierKey> &data() { + return data_; + } + + private: + std::map<uint32, mozc::commands::KeyEvent::ModifierKey> data_; +}; + +// TODO(hsumita): Moves this function into member functions of +// KeyEventHandler. +void AddAdditionalModifiers( + std::set<mozc::commands::KeyEvent::ModifierKey> *modifier_keys_set) { + DCHECK(modifier_keys_set); + + const std::map<uint32, mozc::commands::KeyEvent::ModifierKey> &data = + mozc::Singleton<AdditionalModifiersData>::get()->data(); + + // Adds MODIFIER if there are (LEFT|RIGHT)_MODIFIER like LEFT_SHIFT. + for (std::set<mozc::commands::KeyEvent::ModifierKey>::const_iterator it = + modifier_keys_set->begin(); + it != modifier_keys_set->end(); ++it) { + std::map<uint32, mozc::commands::KeyEvent::ModifierKey>::const_iterator + item = data.find(*it); + if (item != data.end()) { + modifier_keys_set->insert(item->second); + } + } +} + +bool IsModifierToBeSentOnKeyUp(const mozc::commands::KeyEvent &key_event) { + if (key_event.modifier_keys_size() == 0) { + return false; + } + + if (key_event.modifier_keys_size() == 1 && + key_event.modifier_keys(0) == mozc::commands::KeyEvent::CAPS) { + return false; + } + + return true; +} +} // namespace + +KeyEventHandler::KeyEventHandler() : key_translator_(new KeyTranslator) { + Clear(); +} + +bool KeyEventHandler::GetKeyEvent( + KeySym keyval, uint32 keycode, KeyStates modifiers, + mozc::config::Config::PreeditMethod preedit_method, bool layout_is_jp, + bool is_key_up, mozc::commands::KeyEvent *key) { + DCHECK(key); + key->Clear(); + + if (!key_translator_->Translate(keyval, keycode, modifiers, preedit_method, + layout_is_jp, key)) { + LOG(ERROR) << "Translate failed"; + return false; + } + + return ProcessModifiers(is_key_up, keyval, key); +} + +void KeyEventHandler::Clear() { + is_non_modifier_key_pressed_ = false; + currently_pressed_modifiers_.clear(); + modifiers_to_be_sent_.clear(); +} + +bool KeyEventHandler::ProcessModifiers(bool is_key_up, uint32 keyval, + mozc::commands::KeyEvent *key_event) { + // Manage modifier key event. + // Modifier key event is sent on key up if non-modifier key has not been + // pressed since key down of modifier keys and no modifier keys are pressed + // anymore. + // Following examples are expected behaviors. + // + // E.g.) Shift key is special. If Shift + printable key is pressed, key event + // does NOT have shift modifiers. It is handled by KeyTranslator class. + // <Event from ibus> <Event to server> + // Shift down | None + // "a" down | A + // "a" up | None + // Shift up | None + // + // E.g.) Usual key is sent on key down. Modifier keys are not sent if usual + // key is sent. + // <Event from ibus> <Event to server> + // Ctrl down | None + // "a" down | Ctrl+a + // "a" up | None + // Ctrl up | None + // + // E.g.) Modifier key is sent on key up. + // <Event from ibus> <Event to server> + // Shift down | None + // Shift up | Shift + // + // E.g.) Multiple modifier keys are sent on the last key up. + // <Event from ibus> <Event to server> + // Shift down | None + // Control down | None + // Shift up | None + // Control up | Control+Shift + // + // Essentialy we cannot handle modifier key evnet perfectly because + // - We cannot get current keyboard status with ibus. If some modifiers + // are pressed or released without focusing the target window, we + // cannot handle it. + // E.g.) + // <Event from ibus> <Event to server> + // Ctrl down | None + // (focuses out, Ctrl up, focuses in) + // Shift down | None + // Shift up | None (But we should send Shift key) + // To avoid a inconsistent state as much as possible, we clear states + // when key event without modifier keys is sent. + + const bool is_modifier_only = + !(key_event->has_key_code() || key_event->has_special_key()); + + // We may get only up/down key event when a user moves a focus. + // This code handles such situation as much as possible. + // This code has a bug. If we send Shift + 'a', KeyTranslator removes a shift + // modifier and converts 'a' to 'A'. This codes does NOT consider these + // situation since we don't have enough data to handle it. + // TODO(hsumita): Moves the logic about a handling of Shift or Caps keys from + // KeyTranslator to MozcEngine. + if (key_event->modifier_keys_size() == 0) { + Clear(); + } + + if (!currently_pressed_modifiers_.empty() && !is_modifier_only) { + is_non_modifier_key_pressed_ = true; + } + if (is_non_modifier_key_pressed_) { + modifiers_to_be_sent_.clear(); + } + + if (is_key_up) { + currently_pressed_modifiers_.erase(keyval); + if (!is_modifier_only) { + return false; + } + if (!currently_pressed_modifiers_.empty() || + modifiers_to_be_sent_.empty()) { + is_non_modifier_key_pressed_ = false; + return false; + } + if (is_non_modifier_key_pressed_) { + return false; + } + DCHECK(!is_non_modifier_key_pressed_); + + // Modifier key event fires + key_event->mutable_modifier_keys()->Clear(); + for (std::set<mozc::commands::KeyEvent::ModifierKey>::const_iterator it = + modifiers_to_be_sent_.begin(); + it != modifiers_to_be_sent_.end(); ++it) { + key_event->add_modifier_keys(*it); + } + modifiers_to_be_sent_.clear(); + } else if (is_modifier_only) { + // TODO(hsumita): Supports a key sequence below. + // - Ctrl down + // - a down + // - Alt down + // We should add Alt key to |currently_pressed_modifiers|, but current + // implementation does NOT do it. + if (currently_pressed_modifiers_.empty() || + !modifiers_to_be_sent_.empty()) { + for (size_t i = 0; i < key_event->modifier_keys_size(); ++i) { + modifiers_to_be_sent_.insert(key_event->modifier_keys(i)); + } + AddAdditionalModifiers(&modifiers_to_be_sent_); + } + currently_pressed_modifiers_.insert(keyval); + return false; + } + + // Clear modifier data just in case if |key| has no modifier keys. + if (!IsModifierToBeSentOnKeyUp(*key_event)) { + Clear(); + } + + return true; +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/fcitx_key_event_handler.h b/src/unix/fcitx5/fcitx_key_event_handler.h new file mode 100644 index 00000000..555718da --- /dev/null +++ b/src/unix/fcitx5/fcitx_key_event_handler.h @@ -0,0 +1,78 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012-2017, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 UNIX_FCITX5_FCITX_KEY_EVENT_HANDLER_H_ +#define UNIX_FCITX5_FCITX_KEY_EVENT_HANDLER_H_ + +#include <fcitx-utils/key.h> +#include <memory> +#include <set> + +#include "base/port.h" +#include "protocol/commands.pb.h" +#include "protocol/config.pb.h" +#include "unix/fcitx5/fcitx_key_translator.h" + +namespace fcitx { + +class KeyEventHandler { + public: + KeyEventHandler(); + + // Converts a key event came from fcitx to commands::KeyEvent. This is a + // stateful method. It stores modifier keys states since ibus doesn't send + // an enough information about the modifier keys. + bool GetKeyEvent(KeySym keyval, uint32 keycode, KeyStates modifiers, + mozc::config::Config::PreeditMethod preedit_method, + bool layout_is_jp, bool is_key_up, + mozc::commands::KeyEvent *key); + + // Clears states. + void Clear(); + + private: + // Manages modifier keys. Returns false if it should not be sent to server. + bool ProcessModifiers(bool is_key_up, uint32 keyval, + mozc::commands::KeyEvent *key_event); + + std::unique_ptr<KeyTranslator> key_translator_; + // Non modifier key is pressed or not after all keys are released. + bool is_non_modifier_key_pressed_; + // Currently pressed modifier keys. It is set of keyval. + std::set<uint32> currently_pressed_modifiers_; + // Pending modifier keys. + std::set<mozc::commands::KeyEvent::ModifierKey> modifiers_to_be_sent_; + + DISALLOW_COPY_AND_ASSIGN(KeyEventHandler); +}; + +} // namespace fcitx + +#endif // UNIX_FCITX5_FCITX_KEY_EVENT_HANDLER_H_ diff --git a/src/unix/fcitx5/fcitx_key_translator.cc b/src/unix/fcitx5/fcitx_key_translator.cc new file mode 100644 index 00000000..3c06d119 --- /dev/null +++ b/src/unix/fcitx5/fcitx_key_translator.cc @@ -0,0 +1,526 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012-2017, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/fcitx_key_translator.h" + +#include "base/logging.h" + +namespace fcitx { + +namespace { + +const struct { + uint32 from; + mozc::commands::KeyEvent::SpecialKey to; +} special_key_map[] = { + {FcitxKey_VoidSymbol, mozc::commands::KeyEvent::NO_SPECIALKEY}, + {FcitxKey_space, mozc::commands::KeyEvent::SPACE}, + {FcitxKey_Return, mozc::commands::KeyEvent::ENTER}, + {FcitxKey_Left, mozc::commands::KeyEvent::LEFT}, + {FcitxKey_Right, mozc::commands::KeyEvent::RIGHT}, + {FcitxKey_Up, mozc::commands::KeyEvent::UP}, + {FcitxKey_Down, mozc::commands::KeyEvent::DOWN}, + {FcitxKey_Escape, mozc::commands::KeyEvent::ESCAPE}, + {FcitxKey_Delete, mozc::commands::KeyEvent::DEL}, + {FcitxKey_BackSpace, mozc::commands::KeyEvent::BACKSPACE}, + {FcitxKey_Insert, mozc::commands::KeyEvent::INSERT}, + {FcitxKey_Henkan, mozc::commands::KeyEvent::HENKAN}, + {FcitxKey_Muhenkan, mozc::commands::KeyEvent::MUHENKAN}, + {FcitxKey_Hiragana, mozc::commands::KeyEvent::KANA}, + {FcitxKey_Hiragana_Katakana, mozc::commands::KeyEvent::KANA}, + {FcitxKey_Katakana, mozc::commands::KeyEvent::KATAKANA}, + {FcitxKey_Zenkaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Hankaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Zenkaku_Hankaku, mozc::commands::KeyEvent::HANKAKU}, + {FcitxKey_Eisu_toggle, mozc::commands::KeyEvent::EISU}, + {FcitxKey_Home, mozc::commands::KeyEvent::HOME}, + {FcitxKey_End, mozc::commands::KeyEvent::END}, + {FcitxKey_Tab, mozc::commands::KeyEvent::TAB}, + {FcitxKey_F1, mozc::commands::KeyEvent::F1}, + {FcitxKey_F2, mozc::commands::KeyEvent::F2}, + {FcitxKey_F3, mozc::commands::KeyEvent::F3}, + {FcitxKey_F4, mozc::commands::KeyEvent::F4}, + {FcitxKey_F5, mozc::commands::KeyEvent::F5}, + {FcitxKey_F6, mozc::commands::KeyEvent::F6}, + {FcitxKey_F7, mozc::commands::KeyEvent::F7}, + {FcitxKey_F8, mozc::commands::KeyEvent::F8}, + {FcitxKey_F9, mozc::commands::KeyEvent::F9}, + {FcitxKey_F10, mozc::commands::KeyEvent::F10}, + {FcitxKey_F11, mozc::commands::KeyEvent::F11}, + {FcitxKey_F12, mozc::commands::KeyEvent::F12}, + {FcitxKey_F13, mozc::commands::KeyEvent::F13}, + {FcitxKey_F14, mozc::commands::KeyEvent::F14}, + {FcitxKey_F15, mozc::commands::KeyEvent::F15}, + {FcitxKey_F16, mozc::commands::KeyEvent::F16}, + {FcitxKey_F17, mozc::commands::KeyEvent::F17}, + {FcitxKey_F18, mozc::commands::KeyEvent::F18}, + {FcitxKey_F19, mozc::commands::KeyEvent::F19}, + {FcitxKey_F20, mozc::commands::KeyEvent::F20}, + {FcitxKey_F21, mozc::commands::KeyEvent::F21}, + {FcitxKey_F22, mozc::commands::KeyEvent::F22}, + {FcitxKey_F23, mozc::commands::KeyEvent::F23}, + {FcitxKey_F24, mozc::commands::KeyEvent::F24}, + {FcitxKey_Page_Up, mozc::commands::KeyEvent::PAGE_UP}, + {FcitxKey_Page_Down, mozc::commands::KeyEvent::PAGE_DOWN}, + + // Keypad (10-key). + {FcitxKey_KP_0, mozc::commands::KeyEvent::NUMPAD0}, + {FcitxKey_KP_1, mozc::commands::KeyEvent::NUMPAD1}, + {FcitxKey_KP_2, mozc::commands::KeyEvent::NUMPAD2}, + {FcitxKey_KP_3, mozc::commands::KeyEvent::NUMPAD3}, + {FcitxKey_KP_4, mozc::commands::KeyEvent::NUMPAD4}, + {FcitxKey_KP_5, mozc::commands::KeyEvent::NUMPAD5}, + {FcitxKey_KP_6, mozc::commands::KeyEvent::NUMPAD6}, + {FcitxKey_KP_7, mozc::commands::KeyEvent::NUMPAD7}, + {FcitxKey_KP_8, mozc::commands::KeyEvent::NUMPAD8}, + {FcitxKey_KP_9, mozc::commands::KeyEvent::NUMPAD9}, + {FcitxKey_KP_Equal, mozc::commands::KeyEvent::EQUALS}, // [=] + {FcitxKey_KP_Multiply, mozc::commands::KeyEvent::MULTIPLY}, // [*] + {FcitxKey_KP_Add, mozc::commands::KeyEvent::ADD}, // [+] + {FcitxKey_KP_Separator, mozc::commands::KeyEvent::SEPARATOR}, // enter + {FcitxKey_KP_Subtract, mozc::commands::KeyEvent::SUBTRACT}, // [-] + {FcitxKey_KP_Decimal, mozc::commands::KeyEvent::DECIMAL}, // [.] + {FcitxKey_KP_Divide, mozc::commands::KeyEvent::DIVIDE}, // [/] + {FcitxKey_KP_Space, mozc::commands::KeyEvent::SPACE}, + {FcitxKey_KP_Tab, mozc::commands::KeyEvent::TAB}, + {FcitxKey_KP_Enter, mozc::commands::KeyEvent::ENTER}, + {FcitxKey_KP_Home, mozc::commands::KeyEvent::HOME}, + {FcitxKey_KP_Left, mozc::commands::KeyEvent::LEFT}, + {FcitxKey_KP_Up, mozc::commands::KeyEvent::UP}, + {FcitxKey_KP_Right, mozc::commands::KeyEvent::RIGHT}, + {FcitxKey_KP_Down, mozc::commands::KeyEvent::DOWN}, + {FcitxKey_KP_Page_Up, mozc::commands::KeyEvent::PAGE_UP}, + {FcitxKey_KP_Page_Down, mozc::commands::KeyEvent::PAGE_DOWN}, + {FcitxKey_KP_End, mozc::commands::KeyEvent::END}, + {FcitxKey_KP_Delete, mozc::commands::KeyEvent::DEL}, + {FcitxKey_KP_Insert, mozc::commands::KeyEvent::INSERT}, + {FcitxKey_Caps_Lock, mozc::commands::KeyEvent::CAPS_LOCK}, + + // Shift+TAB. + {FcitxKey_ISO_Left_Tab, mozc::commands::KeyEvent::TAB}, + + // TODO(mazda): Handle following keys? + // - FcitxKey_Kana_Lock? FcitxKey_KEY_Kana_Shift? +}; + +const struct { + uint32 from; + mozc::commands::KeyEvent::ModifierKey to; +} modifier_key_map[] = { + {FcitxKey_Shift_L, mozc::commands::KeyEvent::LEFT_SHIFT}, + {FcitxKey_Shift_R, mozc::commands::KeyEvent::RIGHT_SHIFT}, + {FcitxKey_Control_L, mozc::commands::KeyEvent::LEFT_CTRL}, + {FcitxKey_Control_R, mozc::commands::KeyEvent::RIGHT_CTRL}, + {FcitxKey_Alt_L, mozc::commands::KeyEvent::LEFT_ALT}, + {FcitxKey_Alt_R, mozc::commands::KeyEvent::RIGHT_ALT}, + {static_cast<uint32_t>(KeyState::CapsLock), mozc::commands::KeyEvent::CAPS}, +}; + +const struct { + uint32 from; + mozc::commands::KeyEvent::ModifierKey to; +} modifier_mask_map[] = { + {static_cast<uint32_t>(KeyState::Shift), mozc::commands::KeyEvent::SHIFT}, + {static_cast<uint32_t>(KeyState::Ctrl), mozc::commands::KeyEvent::CTRL}, + {static_cast<uint32_t>(KeyState::Alt), mozc::commands::KeyEvent::ALT}, +}; + +// TODO(team): Add kana_map_dv to support Dvoraklayout. +const struct { + uint32 code; + const char *no_shift; + const char *shift; +} kana_map_jp[] = + { + {'1', "\xe3\x81\xac", "\xe3\x81\xac"}, // "ぬ", "ぬ" + {'!', "\xe3\x81\xac", "\xe3\x81\xac"}, // "ぬ", "ぬ" + {'2', "\xe3\x81\xb5", "\xe3\x81\xb5"}, // "ふ", "ふ" + {'\"', "\xe3\x81\xb5", "\xe3\x81\xb5"}, // "ふ", "ふ" + {'3', "\xe3\x81\x82", "\xe3\x81\x81"}, // "あ", "ぁ" + {'#', "\xe3\x81\x82", "\xe3\x81\x81"}, // "あ", "ぁ" + {'4', "\xe3\x81\x86", "\xe3\x81\x85"}, // "う", "ぅ" + {'$', "\xe3\x81\x86", "\xe3\x81\x85"}, // "う", "ぅ" + {'5', "\xe3\x81\x88", "\xe3\x81\x87"}, // "え", "ぇ" + {'%', "\xe3\x81\x88", "\xe3\x81\x87"}, // "え", "ぇ" + {'6', "\xe3\x81\x8a", "\xe3\x81\x89"}, // "お", "ぉ" + {'&', "\xe3\x81\x8a", "\xe3\x81\x89"}, // "お", "ぉ" + {'7', "\xe3\x82\x84", "\xe3\x82\x83"}, // "や", "ゃ" + {'\'', "\xe3\x82\x84", "\xe3\x82\x83"}, // "や", "ゃ" + {'8', "\xe3\x82\x86", "\xe3\x82\x85"}, // "ゆ", "ゅ" + {'(', "\xe3\x82\x86", "\xe3\x82\x85"}, // "ゆ", "ゅ" + {'9', "\xe3\x82\x88", "\xe3\x82\x87"}, // "よ", "ょ" + {')', "\xe3\x82\x88", "\xe3\x82\x87"}, // "よ", "ょ" + {'0', "\xe3\x82\x8f", "\xe3\x82\x92"}, // "わ", "を" + {'-', "\xe3\x81\xbb", "\xe3\x81\xbb"}, // "ほ", "ほ" + {'=', "\xe3\x81\xbb", "\xe3\x81\xbb"}, // "ほ", "ほ" + {'^', "\xe3\x81\xb8", "\xe3\x82\x92"}, // "へ", "を" + {'~', "\xe3\x81\xb8", "\xe3\x82\x92"}, // "へ", "を" + {'|', "\xe3\x83\xbc", "\xe3\x83\xbc"}, // "ー", "ー" + {'q', "\xe3\x81\x9f", "\xe3\x81\x9f"}, // "た", "た" + {'Q', "\xe3\x81\x9f", "\xe3\x81\x9f"}, // "た", "た" + {'w', "\xe3\x81\xa6", "\xe3\x81\xa6"}, // "て", "て" + {'W', "\xe3\x81\xa6", "\xe3\x81\xa6"}, // "て", "て" + {'e', "\xe3\x81\x84", "\xe3\x81\x83"}, // "い", "ぃ" + {'E', "\xe3\x81\x84", "\xe3\x81\x83"}, // "い", "ぃ" + {'r', "\xe3\x81\x99", "\xe3\x81\x99"}, // "す", "す" + {'R', "\xe3\x81\x99", "\xe3\x81\x99"}, // "す", "す" + {'t', "\xe3\x81\x8b", "\xe3\x81\x8b"}, // "か", "か" + {'T', "\xe3\x81\x8b", "\xe3\x81\x8b"}, // "か", "か" + {'y', "\xe3\x82\x93", "\xe3\x82\x93"}, // "ん", "ん" + {'Y', "\xe3\x82\x93", "\xe3\x82\x93"}, // "ん", "ん" + {'u', "\xe3\x81\xaa", "\xe3\x81\xaa"}, // "な", "な" + {'U', "\xe3\x81\xaa", "\xe3\x81\xaa"}, // "な", "な" + {'i', "\xe3\x81\xab", "\xe3\x81\xab"}, // "に", "に" + {'I', "\xe3\x81\xab", "\xe3\x81\xab"}, // "に", "に" + {'o', "\xe3\x82\x89", "\xe3\x82\x89"}, // "ら", "ら" + {'O', "\xe3\x82\x89", "\xe3\x82\x89"}, // "ら", "ら" + {'p', "\xe3\x81\x9b", "\xe3\x81\x9b"}, // "せ", "せ" + {'P', "\xe3\x81\x9b", "\xe3\x81\x9b"}, // "せ", "せ" + {'@', "\xe3\x82\x9b", "\xe3\x82\x9b"}, // "゛", "゛" + {'`', "\xe3\x82\x9b", "\xe3\x82\x9b"}, // "゛", "゛" + {'[', "\xe3\x82\x9c", "\xe3\x80\x8c"}, // "゜", "「" + {'{', "\xe3\x82\x9c", "\xe3\x80\x8c"}, // "゜", "「" + {'a', "\xe3\x81\xa1", "\xe3\x81\xa1"}, // "ち", "ち" + {'A', "\xe3\x81\xa1", "\xe3\x81\xa1"}, // "ち", "ち" + {'s', "\xe3\x81\xa8", "\xe3\x81\xa8"}, // "と", "と" + {'S', "\xe3\x81\xa8", "\xe3\x81\xa8"}, // "と", "と" + {'d', "\xe3\x81\x97", "\xe3\x81\x97"}, // "し", "し" + {'D', "\xe3\x81\x97", "\xe3\x81\x97"}, // "し", "し" + {'f', "\xe3\x81\xaf", "\xe3\x81\xaf"}, // "は", "は" + {'F', "\xe3\x81\xaf", "\xe3\x81\xaf"}, // "は", "は" + {'g', "\xe3\x81\x8d", "\xe3\x81\x8d"}, // "き", "き" + {'G', "\xe3\x81\x8d", "\xe3\x81\x8d"}, // "き", "き" + {'h', "\xe3\x81\x8f", "\xe3\x81\x8f"}, // "く", "く" + {'H', "\xe3\x81\x8f", "\xe3\x81\x8f"}, // "く", "く" + {'j', "\xe3\x81\xbe", "\xe3\x81\xbe"}, // "ま", "ま" + {'J', "\xe3\x81\xbe", "\xe3\x81\xbe"}, // "ま", "ま" + {'k', "\xe3\x81\xae", "\xe3\x81\xae"}, // "の", "の" + {'K', "\xe3\x81\xae", "\xe3\x81\xae"}, // "の", "の" + {'l', "\xe3\x82\x8a", "\xe3\x82\x8a"}, // "り", "り" + {'L', "\xe3\x82\x8a", "\xe3\x82\x8a"}, // "り", "り" + {';', "\xe3\x82\x8c", "\xe3\x82\x8c"}, // "れ", "れ" + {'+', "\xe3\x82\x8c", "\xe3\x82\x8c"}, // "れ", "れ" + {':', "\xe3\x81\x91", "\xe3\x81\x91"}, // "け", "け" + {'*', "\xe3\x81\x91", "\xe3\x81\x91"}, // "け", "け" + {']', "\xe3\x82\x80", "\xe3\x80\x8d"}, // "む", "」" + {'}', "\xe3\x82\x80", "\xe3\x80\x8d"}, // "む", "」" + {'z', "\xe3\x81\xa4", "\xe3\x81\xa3"}, // "つ", "っ" + {'Z', "\xe3\x81\xa4", "\xe3\x81\xa3"}, // "つ", "っ" + {'x', "\xe3\x81\x95", "\xe3\x81\x95"}, // "さ", "さ" + {'X', "\xe3\x81\x95", "\xe3\x81\x95"}, // "さ", "さ" + {'c', "\xe3\x81\x9d", "\xe3\x81\x9d"}, // "そ", "そ" + {'C', "\xe3\x81\x9d", "\xe3\x81\x9d"}, // "そ", "そ" + {'v', "\xe3\x81\xb2", "\xe3\x81\xb2"}, // "ひ", "ひ" + {'V', "\xe3\x81\xb2", "\xe3\x81\xb2"}, // "ひ", "ひ" + {'b', "\xe3\x81\x93", "\xe3\x81\x93"}, // "こ", "こ" + {'B', "\xe3\x81\x93", "\xe3\x81\x93"}, // "こ", "こ" + {'n', "\xe3\x81\xbf", "\xe3\x81\xbf"}, // "み", "み" + {'N', "\xe3\x81\xbf", "\xe3\x81\xbf"}, // "み", "み" + {'m', "\xe3\x82\x82", "\xe3\x82\x82"}, // "も", "も" + {'M', "\xe3\x82\x82", "\xe3\x82\x82"}, // "も", "も" + {',', "\xe3\x81\xad", "\xe3\x80\x81"}, // "ね", "、" + {'<', "\xe3\x81\xad", "\xe3\x80\x81"}, // "ね", "、" + {'.', "\xe3\x82\x8b", "\xe3\x80\x82"}, // "る", "。" + {'>', "\xe3\x82\x8b", "\xe3\x80\x82"}, // "る", "。" + {'/', "\xe3\x82\x81", "\xe3\x83\xbb"}, // "め", "・" + {'?', "\xe3\x82\x81", "\xe3\x83\xbb"}, // "め", "・" + {'_', "\xe3\x82\x8d", "\xe3\x82\x8d"}, // "ろ", "ろ" + // A backslash is handled in a special way because it is input by + // two different keys (the one next to Backslash and the one next + // to Right Shift). + {'\\', "", ""}, +}, + kana_map_us[] = { + {'`', "\xe3\x82\x8d", "\xe3\x82\x8d"}, // "ろ", "ろ" + {'~', "\xe3\x82\x8d", "\xe3\x82\x8d"}, // "ろ", "ろ" + {'1', "\xe3\x81\xac", "\xe3\x81\xac"}, // "ぬ", "ぬ" + {'!', "\xe3\x81\xac", "\xe3\x81\xac"}, // "ぬ", "ぬ" + {'2', "\xe3\x81\xb5", "\xe3\x81\xb5"}, // "ふ", "ふ" + {'@', "\xe3\x81\xb5", "\xe3\x81\xb5"}, // "ふ", "ふ" + {'3', "\xe3\x81\x82", "\xe3\x81\x81"}, // "あ", "ぁ" + {'#', "\xe3\x81\x82", "\xe3\x81\x81"}, // "あ", "ぁ" + {'4', "\xe3\x81\x86", "\xe3\x81\x85"}, // "う", "ぅ" + {'$', "\xe3\x81\x86", "\xe3\x81\x85"}, // "う", "ぅ" + {'5', "\xe3\x81\x88", "\xe3\x81\x87"}, // "え", "ぇ" + {'%', "\xe3\x81\x88", "\xe3\x81\x87"}, // "え", "ぇ" + {'6', "\xe3\x81\x8a", "\xe3\x81\x89"}, // "お", "ぉ" + {'^', "\xe3\x81\x8a", "\xe3\x81\x89"}, // "お", "ぉ" + {'7', "\xe3\x82\x84", "\xe3\x82\x83"}, // "や", "ゃ" + {'&', "\xe3\x82\x84", "\xe3\x82\x83"}, // "や", "ゃ" + {'8', "\xe3\x82\x86", "\xe3\x82\x85"}, // "ゆ", "ゅ" + {'*', "\xe3\x82\x86", "\xe3\x82\x85"}, // "ゆ", "ゅ" + {'9', "\xe3\x82\x88", "\xe3\x82\x87"}, // "よ", "ょ" + {'(', "\xe3\x82\x88", "\xe3\x82\x87"}, // "よ", "ょ" + {'0', "\xe3\x82\x8f", "\xe3\x82\x92"}, // "わ", "を" + {')', "\xe3\x82\x8f", "\xe3\x82\x92"}, // "わ", "を" + {'-', "\xe3\x81\xbb", "\xe3\x83\xbc"}, // "ほ", "ー" + {'_', "\xe3\x81\xbb", "\xe3\x83\xbc"}, // "ほ", "ー" + {'=', "\xe3\x81\xb8", "\xe3\x81\xb8"}, // "へ", "へ" + {'+', "\xe3\x81\xb8", "\xe3\x81\xb8"}, // "へ", "へ" + {'q', "\xe3\x81\x9f", "\xe3\x81\x9f"}, // "た", "た" + {'Q', "\xe3\x81\x9f", "\xe3\x81\x9f"}, // "た", "た" + {'w', "\xe3\x81\xa6", "\xe3\x81\xa6"}, // "て", "て" + {'W', "\xe3\x81\xa6", "\xe3\x81\xa6"}, // "て", "て" + {'e', "\xe3\x81\x84", "\xe3\x81\x83"}, // "い", "ぃ" + {'E', "\xe3\x81\x84", "\xe3\x81\x83"}, // "い", "ぃ" + {'r', "\xe3\x81\x99", "\xe3\x81\x99"}, // "す", "す" + {'R', "\xe3\x81\x99", "\xe3\x81\x99"}, // "す", "す" + {'t', "\xe3\x81\x8b", "\xe3\x81\x8b"}, // "か", "か" + {'T', "\xe3\x81\x8b", "\xe3\x81\x8b"}, // "か", "か" + {'y', "\xe3\x82\x93", "\xe3\x82\x93"}, // "ん", "ん" + {'Y', "\xe3\x82\x93", "\xe3\x82\x93"}, // "ん", "ん" + {'u', "\xe3\x81\xaa", "\xe3\x81\xaa"}, // "な", "な" + {'U', "\xe3\x81\xaa", "\xe3\x81\xaa"}, // "な", "な" + {'i', "\xe3\x81\xab", "\xe3\x81\xab"}, // "に", "に" + {'I', "\xe3\x81\xab", "\xe3\x81\xab"}, // "に", "に" + {'o', "\xe3\x82\x89", "\xe3\x82\x89"}, // "ら", "ら" + {'O', "\xe3\x82\x89", "\xe3\x82\x89"}, // "ら", "ら" + {'p', "\xe3\x81\x9b", "\xe3\x81\x9b"}, // "せ", "せ" + {'P', "\xe3\x81\x9b", "\xe3\x81\x9b"}, // "せ", "せ" + {'[', "\xe3\x82\x9b", "\xe3\x82\x9b"}, // "゛", "゛" + {'{', "\xe3\x82\x9b", "\xe3\x82\x9b"}, // "゛", "゛" + {']', "\xe3\x82\x9c", "\xe3\x80\x8c"}, // "゜", "「" + {'}', "\xe3\x82\x9c", "\xe3\x80\x8c"}, // "゜", "「" + {'\\', "\xe3\x82\x80", "\xe3\x80\x8d"}, // "む", "」" + {'|', "\xe3\x82\x80", "\xe3\x80\x8d"}, // "む", "」" + {'a', "\xe3\x81\xa1", "\xe3\x81\xa1"}, // "ち", "ち" + {'A', "\xe3\x81\xa1", "\xe3\x81\xa1"}, // "ち", "ち" + {'s', "\xe3\x81\xa8", "\xe3\x81\xa8"}, // "と", "と" + {'S', "\xe3\x81\xa8", "\xe3\x81\xa8"}, // "と", "と" + {'d', "\xe3\x81\x97", "\xe3\x81\x97"}, // "し", "し" + {'D', "\xe3\x81\x97", "\xe3\x81\x97"}, // "し", "し" + {'f', "\xe3\x81\xaf", "\xe3\x81\xaf"}, // "は", "は" + {'F', "\xe3\x81\xaf", "\xe3\x81\xaf"}, // "は", "は" + {'g', "\xe3\x81\x8d", "\xe3\x81\x8d"}, // "き", "き" + {'G', "\xe3\x81\x8d", "\xe3\x81\x8d"}, // "き", "き" + {'h', "\xe3\x81\x8f", "\xe3\x81\x8f"}, // "く", "く" + {'H', "\xe3\x81\x8f", "\xe3\x81\x8f"}, // "く", "く" + {'j', "\xe3\x81\xbe", "\xe3\x81\xbe"}, // "ま", "ま" + {'J', "\xe3\x81\xbe", "\xe3\x81\xbe"}, // "ま", "ま" + {'k', "\xe3\x81\xae", "\xe3\x81\xae"}, // "の", "の" + {'K', "\xe3\x81\xae", "\xe3\x81\xae"}, // "の", "の" + {'l', "\xe3\x82\x8a", "\xe3\x82\x8a"}, // "り", "り" + {'L', "\xe3\x82\x8a", "\xe3\x82\x8a"}, // "り", "り" + {';', "\xe3\x82\x8c", "\xe3\x82\x8c"}, // "れ", "れ" + {':', "\xe3\x82\x8c", "\xe3\x82\x8c"}, // "れ", "れ" + {'\'', "\xe3\x81\x91", "\xe3\x81\x91"}, // "け", "け" + {'\"', "\xe3\x81\x91", "\xe3\x81\x91"}, // "け", "け" + {'z', "\xe3\x81\xa4", "\xe3\x81\xa3"}, // "つ", "っ" + {'Z', "\xe3\x81\xa4", "\xe3\x81\xa3"}, // "つ", "っ" + {'x', "\xe3\x81\x95", "\xe3\x81\x95"}, // "さ", "さ" + {'X', "\xe3\x81\x95", "\xe3\x81\x95"}, // "さ", "さ" + {'c', "\xe3\x81\x9d", "\xe3\x81\x9d"}, // "そ", "そ" + {'C', "\xe3\x81\x9d", "\xe3\x81\x9d"}, // "そ", "そ" + {'v', "\xe3\x81\xb2", "\xe3\x81\xb2"}, // "ひ", "ひ" + {'V', "\xe3\x81\xb2", "\xe3\x81\xb2"}, // "ひ", "ひ" + {'b', "\xe3\x81\x93", "\xe3\x81\x93"}, // "こ", "こ" + {'B', "\xe3\x81\x93", "\xe3\x81\x93"}, // "こ", "こ" + {'n', "\xe3\x81\xbf", "\xe3\x81\xbf"}, // "み", "み" + {'N', "\xe3\x81\xbf", "\xe3\x81\xbf"}, // "み", "み" + {'m', "\xe3\x82\x82", "\xe3\x82\x82"}, // "も", "も" + {'M', "\xe3\x82\x82", "\xe3\x82\x82"}, // "も", "も" + {',', "\xe3\x81\xad", "\xe3\x80\x81"}, // "ね", "、" + {'<', "\xe3\x81\xad", "\xe3\x80\x81"}, // "ね", "、" + {'.', "\xe3\x82\x8b", "\xe3\x80\x82"}, // "る", "。" + {'>', "\xe3\x82\x8b", "\xe3\x80\x82"}, // "る", "。" + {'/', "\xe3\x82\x81", "\xe3\x83\xbb"}, // "め", "・" + {'?', "\xe3\x82\x81", "\xe3\x83\xbb"}, // "め", "・" +}; + +} // namespace + +KeyTranslator::KeyTranslator() { Init(); } + +KeyTranslator::~KeyTranslator() {} + +// TODO(nona): Fix 'Shift-0' behavior b/4338394 +bool KeyTranslator::Translate(KeySym keyval, uint32 keycode, + KeyStates modifiers, + mozc::config::Config::PreeditMethod method, + bool layout_is_jp, + mozc::commands::KeyEvent *out_event) const { + DCHECK(out_event) << "out_event is NULL"; + out_event->Clear(); + + /* this is key we cannot handle, don't process it */ + if (modifiers & KeyState::Super) return false; + + // Due to historical reasons, many linux ditributions set Hiragana_Katakana + // key as Hiragana key (which is Katkana key with shift modifier). So, we + // translate Hiragana_Katanaka key as Hiragana key by mapping table, and + // Shift + Hiragana_Katakana key as Katakana key by functionally. + // TODO(nona): Fix process modifier to handle right shift + if (IsHiraganaKatakanaKeyWithShift(keyval, keycode, modifiers)) { + modifiers.unset(KeyState::Shift); + keyval = FcitxKey_Katakana; + } + string kana_key_string; + if ((method == mozc::config::Config::KANA) && + IsKanaAvailable(keyval, keycode, modifiers, layout_is_jp, + &kana_key_string)) { + out_event->set_key_code(keyval); + out_event->set_key_string(kana_key_string); + } else if (IsAscii(keyval, keycode, modifiers)) { + if (modifiers & KeyState::CapsLock) { + out_event->add_modifier_keys(mozc::commands::KeyEvent::CAPS); + } + out_event->set_key_code(keyval); + } else if (IsModifierKey(keyval, keycode, modifiers)) { + ModifierKeyMap::const_iterator i = modifier_key_map_.find(keyval); + DCHECK(i != modifier_key_map_.end()); + out_event->add_modifier_keys(i->second); + } else if (IsSpecialKey(keyval, keycode, modifiers)) { + SpecialKeyMap::const_iterator i = special_key_map_.find(keyval); + DCHECK(i != special_key_map_.end()); + out_event->set_special_key(i->second); + } else { + VLOG(1) << "Unknown keyval: " << keyval; + return false; + } + + for (ModifierKeyMap::const_iterator i = modifier_mask_map_.begin(); + i != modifier_mask_map_.end(); ++i) { + // Do not set a SHIFT modifier when |keyval| is a printable key by following + // the Mozc's rule. + if ((i->second == mozc::commands::KeyEvent::SHIFT) && + IsPrintable(keyval, keycode, modifiers)) { + continue; + } + + if (i->first & modifiers) { + out_event->add_modifier_keys(i->second); + } + } + + return true; +} + +void KeyTranslator::Init() { + for (int i = 0; i < arraysize(special_key_map); ++i) { + CHECK(special_key_map_ + .insert(std::make_pair(special_key_map[i].from, + special_key_map[i].to)) + .second); + } + for (int i = 0; i < arraysize(modifier_key_map); ++i) { + CHECK(modifier_key_map_ + .insert(std::make_pair(modifier_key_map[i].from, + modifier_key_map[i].to)) + .second); + } + for (int i = 0; i < arraysize(modifier_mask_map); ++i) { + CHECK(modifier_mask_map_ + .insert(std::make_pair(modifier_mask_map[i].from, + modifier_mask_map[i].to)) + .second); + } + for (int i = 0; i < arraysize(kana_map_jp); ++i) { + CHECK(kana_map_jp_ + .insert(std::make_pair(kana_map_jp[i].code, + std::make_pair(kana_map_jp[i].no_shift, + kana_map_jp[i].shift))) + .second); + } + for (int i = 0; i < arraysize(kana_map_us); ++i) { + CHECK(kana_map_us_ + .insert(std::make_pair(kana_map_us[i].code, + std::make_pair(kana_map_us[i].no_shift, + kana_map_us[i].shift))) + .second); + } +} + +bool KeyTranslator::IsModifierKey(KeySym keyval, uint32 keycode, + KeyStates modifiers) const { + return modifier_key_map_.find(keyval) != modifier_key_map_.end(); +} + +bool KeyTranslator::IsSpecialKey(KeySym keyval, uint32 keycode, + KeyStates modifiers) const { + return special_key_map_.find(keyval) != special_key_map_.end(); +} + +bool KeyTranslator::IsHiraganaKatakanaKeyWithShift(KeySym keyval, + uint32 keycode, + KeyStates modifiers) { + return ((modifiers & KeyState::Shift) && + (keyval == FcitxKey_Hiragana_Katakana)); +} + +bool KeyTranslator::IsKanaAvailable(KeySym keyval, uint32 keycode, + KeyStates modifiers, bool layout_is_jp, + string *out) const { + if ((modifiers & KeyState::Ctrl) || (modifiers & KeyState::Alt)) { + return false; + } + const auto &kana_map = layout_is_jp ? kana_map_jp_ : kana_map_us_; + KanaMap::const_iterator iter = kana_map.find(keyval); + if (iter == kana_map.end()) { + return false; + } + + if (out) { + // When a Japanese keyboard is in use, the yen-sign key and the backslash + // key generate the same |keyval|. In this case, we have to check |keycode| + // to return an appropriate string. See the following IBus issue for + // details: http://code.google.com/p/ibus/issues/detail?id=52 + if (keyval == '\\' && layout_is_jp) { + if (keycode == 132 || keycode == 133) { + *out = "\xe3\x83\xbc"; // "ー" + } else { + *out = "\xe3\x82\x8d"; // "ろ" + } + } else { + *out = (modifiers & KeyState::Shift) ? iter->second.second + : iter->second.first; + } + } + return true; +} + +// TODO(nona): resolve S-'0' problem (b/4338394). +// TODO(nona): Current printable detection is weak. To enhance accuracy, use xkb +// key map +bool KeyTranslator::IsPrintable(KeySym keyval, uint32 keycode, + KeyStates modifiers) { + if ((modifiers & KeyState::Ctrl) || (modifiers & KeyState::Alt)) { + return false; + } + return IsAscii(keyval, keycode, modifiers); +} + +bool KeyTranslator::IsAscii(KeySym keyval, uint32 keycode, + KeyStates modifiers) { + return (keyval > FcitxKey_space && + // Note: Space key (0x20) is a special key in Mozc. + keyval <= FcitxKey_asciitilde); // 0x7e. +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/fcitx_key_translator.h b/src/unix/fcitx5/fcitx_key_translator.h new file mode 100644 index 00000000..a78be640 --- /dev/null +++ b/src/unix/fcitx5/fcitx_key_translator.h @@ -0,0 +1,102 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012-2017, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 UNIX_FCITX5_FCITX_KEY_TRANSLATOR_H_ +#define UNIX_FCITX5_FCITX_KEY_TRANSLATOR_H_ + +#include <fcitx-utils/key.h> +#include <map> +#include <set> +#include <string> + +#include "base/port.h" +#include "protocol/commands.pb.h" + +namespace fcitx { + +// This class is responsible for converting fcitx's key to IPC input for +// mozc_server. +class KeyTranslator { + public: + KeyTranslator(); + virtual ~KeyTranslator(); + + // Converts fcitx key into Mozc key code and stores them on out_translated. + bool Translate(KeySym keyval, uint32 keycode, KeyStates modifiers, + mozc::config::Config::PreeditMethod method, bool layout_is_jp, + mozc::commands::KeyEvent *out_event) const; + + private: + typedef std::map<uint32, mozc::commands::KeyEvent::SpecialKey> SpecialKeyMap; + typedef std::map<uint32, mozc::commands::KeyEvent::ModifierKey> + ModifierKeyMap; + typedef std::map<uint32, std::pair<string, string> > KanaMap; + + // Returns true iff key is modifier key such as SHIFT, ALT, or CAPSLOCK. + bool IsModifierKey(KeySym keyval, uint32 keycode, KeyStates modifiers) const; + + // Returns true iff key is special key such as ENTER, ESC, or PAGE_UP. + bool IsSpecialKey(KeySym keyval, uint32 keycode, KeyStates modifiers) const; + + // Returns true iff |keyval| is a key with a kana assigned. + bool IsKanaAvailable(KeySym keyval, uint32 keycode, KeyStates modifiers, + bool layout_is_jp, string *out) const; + + // Returns true iff key is ASCII such as '0', 'A', or '!'. + static bool IsAscii(KeySym keyval, uint32 keycode, KeyStates modifiers); + + // Returns true iff key is printable. + static bool IsPrintable(KeySym keyval, uint32 keycode, KeyStates modifiers); + + // Returns true iff key is HiraganaKatakana with shift modifier. + static bool IsHiraganaKatakanaKeyWithShift(KeySym keyval, uint32 keycode, + KeyStates modifiers); + + // Initializes private fields. + void Init(); + + // Stores a mapping from ibus keys to Mozc's special keys. + SpecialKeyMap special_key_map_; + // Stores a mapping from ibus modifier keys to Mozc's modifier keys. + ModifierKeyMap modifier_key_map_; + // Stores a mapping from ibus modifier masks to Mozc's modifier keys. + ModifierKeyMap modifier_mask_map_; + // Stores a mapping from ASCII to Kana character. For example, ASCII character + // '4' is mapped to Japanese 'Hiragana Letter U' (without Shift modifier) and + // 'Hiragana Letter Small U' (with Shift modifier). + KanaMap kana_map_jp_; // mapping for JP keyboard. + KanaMap kana_map_us_; // mapping for US keyboard. + + DISALLOW_COPY_AND_ASSIGN(KeyTranslator); +}; + +} // namespace fcitx + +#endif // MOZC_UNIX_FCITX_FCITX_KEY_TRANSLATOR_H_ diff --git a/src/unix/fcitx5/gen_fcitx_mozc_i18n.sh b/src/unix/fcitx5/gen_fcitx_mozc_i18n.sh new file mode 100755 index 00000000..97ff4a49 --- /dev/null +++ b/src/unix/fcitx5/gen_fcitx_mozc_i18n.sh @@ -0,0 +1,10 @@ +#!/bin/sh + +objdir="$1" + +mkdir -p "$1" + +for pofile in po/*.po +do + msgfmt "$pofile" -o "$1/`basename ${pofile} .po`.mo" +done diff --git a/src/unix/fcitx5/mozc-addon.conf b/src/unix/fcitx5/mozc-addon.conf new file mode 100644 index 00000000..e520d4b9 --- /dev/null +++ b/src/unix/fcitx5/mozc-addon.conf @@ -0,0 +1,9 @@ +[Addon] +Name=mozc +Category=InputMethod +Library=fcitx5-mozc +Type=SharedLibrary +OnDemand=True + +[Addon/OptionalDependencies] +0=clipboard diff --git a/src/unix/fcitx5/mozc.conf b/src/unix/fcitx5/mozc.conf new file mode 100644 index 00000000..ab0b7aa5 --- /dev/null +++ b/src/unix/fcitx5/mozc.conf @@ -0,0 +1,6 @@ +[InputMethod] +Name=Mozc +Icon=PREFIX/share/fcitx5/mozc/icon/mozc.png +Label=あ +LangCode=ja +Addon=mozc diff --git a/src/unix/fcitx5/mozc_connection.cc b/src/unix/fcitx5/mozc_connection.cc new file mode 100644 index 00000000..0cc930b0 --- /dev/null +++ b/src/unix/fcitx5/mozc_connection.cc @@ -0,0 +1,69 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/mozc_connection.h" + +#include <string> + +#include "base/logging.h" +#include "base/util.h" +#include "client/client.h" +#include "ipc/ipc.h" +#include "protocol/commands.pb.h" +#include "session/ime_switch_util.h" + +namespace fcitx { + +mozc::client::ClientInterface *CreateAndConfigureClient() { + mozc::client::ClientInterface *client = + mozc::client::ClientFactory::NewClient(); + // Currently client capability is fixed. + mozc::commands::Capability capability; + capability.set_text_deletion( + mozc::commands::Capability::DELETE_PRECEDING_TEXT); + client->set_client_capability(capability); + return client; +} + +MozcConnection::MozcConnection() + : client_factory_(mozc::IPCClientFactory::GetIPCClientFactory()) { + VLOG(1) << "MozcConnection is created"; +} + +MozcConnection::~MozcConnection() { VLOG(1) << "MozcConnection is destroyed"; } + +mozc::client::ClientInterface *MozcConnection::CreateClient() { + mozc::client::ClientInterface *client = CreateAndConfigureClient(); + client->SetServerLauncher(new mozc::client::ServerLauncher); + client->SetIPCClientFactory(client_factory_); + return client; +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/mozc_connection.h b/src/unix/fcitx5/mozc_connection.h new file mode 100644 index 00000000..4f7b09c2 --- /dev/null +++ b/src/unix/fcitx5/mozc_connection.h @@ -0,0 +1,72 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX5_MOZC_CONNECTION_H_ +#define MOZC_UNIX_FCITX5_MOZC_CONNECTION_H_ + +#include <memory> +#include <string> + +#include "base/port.h" +#include "protocol/commands.pb.h" +#include "unix/fcitx5/fcitx_key_event_handler.h" + +namespace mozc { + +class IPCClientInterface; +class IPCClientFactoryInterface; + +namespace client { +class ClientInterface; +class ServerLauncherInterface; +} // namespace client + +} // namespace mozc + +namespace fcitx { + +class MozcConnection { + public: + static const int kNoSession; + + MozcConnection(); + virtual ~MozcConnection(); + + mozc::client::ClientInterface* CreateClient(); + + private: + mozc::IPCClientFactoryInterface* client_factory_; + + DISALLOW_COPY_AND_ASSIGN(MozcConnection); +}; + +} // namespace fcitx + +#endif // MOZC_UNIX_FCITX5_MOZC_CONNECTION_H_ diff --git a/src/unix/fcitx5/mozc_engine.cc b/src/unix/fcitx5/mozc_engine.cc new file mode 100644 index 00000000..59c3b0aa --- /dev/null +++ b/src/unix/fcitx5/mozc_engine.cc @@ -0,0 +1,273 @@ +/* + * Copyright (C) 2017~2017 by CSSlayer + * wengxt@gmail.com + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; see the file COPYING. If not, + * see <http://www.gnu.org/licenses/>. + */ + +#include "unix/fcitx5/mozc_engine.h" + +#include <fcitx-utils/i18n.h> +#include <fcitx-utils/log.h> +#include <fcitx-utils/standardpath.h> +#include <fcitx/inputcontext.h> +#include <fcitx/inputcontextmanager.h> +#include <fcitx/userinterfacemanager.h> +#include <vector> + +#include "base/init_mozc.h" +#include "base/process.h" +#include "unix/fcitx5/mozc_connection.h" +#include "unix/fcitx5/mozc_response_parser.h" + +namespace fcitx { + +const struct CompositionMode { + const char *name; + const char *icon; + const char *label; + const char *description; + mozc::commands::CompositionMode mode; +} kPropCompositionModes[] = { + { + "mozc-mode-direct", + "mozc-direct.png", + "A", + N_("Direct"), + mozc::commands::DIRECT, + }, + { + "mozc-mode-hiragana", + "mozc-hiragana.png", + "\xe3\x81\x82", // Hiragana letter A in UTF-8. + N_("Hiragana"), + mozc::commands::HIRAGANA, + }, + { + "mozc-mode-katakana_full", + "mozc-katakana_full.png", + "\xe3\x82\xa2", // Katakana letter A. + N_("Full Katakana"), + mozc::commands::FULL_KATAKANA, + }, + { + + "mozc-mode-alpha_half", + "mozc-alpha_half.png", + "A", + N_("Half ASCII"), + mozc::commands::HALF_ASCII, + }, + { + + "mozc-mode-alpha_full", + "mozc-alpha_full.png", + "\xef\xbc\xa1", // Full width ASCII letter A. + N_("Full ASCII"), + mozc::commands::FULL_ASCII, + }, + { + "mozc-mode-katakana_full", + "mozc-katakana_half.png", + "\xef\xbd\xb1", // Half width Katakana letter A. + N_("Half Katakana"), + mozc::commands::HALF_KATAKANA, + }, +}; +const size_t kNumCompositionModes = arraysize(kPropCompositionModes); + +std::string MozcModeAction::shortText(InputContext *ic) const { + return _("Composition Mode"); +} + +std::string MozcModeAction::longText(InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + return _(kPropCompositionModes[mozc_state->GetCompositionMode()].description); +} + +std::string MozcModeAction::icon(InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + return stringutils::joinPath( + StandardPath::global().fcitxPath("pkgdatadir"), "mozc/icon", + kPropCompositionModes[mozc_state->GetCompositionMode()].icon); +} + +MozcModeSubAction::MozcModeSubAction(MozcEngine *engine, + mozc::commands::CompositionMode mode) + : engine_(engine), mode_(mode) { + setShortText(kPropCompositionModes[mode].label); + setLongText(_(kPropCompositionModes[mode].description)); + setIcon(stringutils::joinPath(StandardPath::global().fcitxPath("pkgdatadir"), + "mozc/icon", kPropCompositionModes[mode].icon)); + setCheckable(true); +} + +bool MozcModeSubAction::isChecked(InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + return mozc_state->GetCompositionMode() == mode_; +} + +void MozcModeSubAction::activate(InputContext *ic) { + auto mozc_state = engine_->mozcState(ic); + mozc_state->SendCompositionMode(mode_); +} + +// This array must correspond with the CompositionMode enum in the +// mozc/session/command.proto file. +static_assert(mozc::commands::NUM_OF_COMPOSITIONS == kNumCompositionModes, + "number of modes must match"); + +Instance *Init(Instance *instance) { + int argc = 1; + char argv0[] = "fcitx_mozc"; + char *_argv[] = {argv0}; + char **argv = _argv; + mozc::InitMozc(argv[0], &argc, &argv, true); + return instance; +} + +MozcEngine::MozcEngine(Instance *instance) + : instance_(Init(instance)), + connection_(std::make_unique<MozcConnection>()), + factory_([this](InputContext &ic) { + return new MozcState(&ic, connection_->CreateClient(), this); + }), + modeAction_(this) { + instance_->inputContextManager().registerProperty("mozcState", &factory_); + instance_->userInterfaceManager().registerAction("mozc-mode", &modeAction_); + instance_->userInterfaceManager().registerAction("mozc-tool", &toolAction_); + toolAction_.setShortText(_("Tool")); + toolAction_.setLongText(_("Tool")); + toolAction_.setIcon( + stringutils::joinPath(StandardPath::global().fcitxPath("pkgdatadir"), + "mozc/icon", "mozc-tool.png")); + + int i = 0; + for (auto &modeAction : modeActions_) { + instance_->userInterfaceManager().registerAction( + kPropCompositionModes[i].name, &modeAction); + modeMenu_.addAction(&modeAction); + i++; + } + + instance_->userInterfaceManager().registerAction("mozc-tool-config", + &configToolAction_); + configToolAction_.setShortText(_("Configuration Tool")); + configToolAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=config_dialog"); + }); + + instance_->userInterfaceManager().registerAction("mozc-tool-dict", + &dictionaryToolAction_); + dictionaryToolAction_.setShortText(_("Dictionary Tool")); + dictionaryToolAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=dictionary_tool"); + }); + + instance_->userInterfaceManager().registerAction("mozc-tool-handwriting", + &handWritingAction_); + handWritingAction_.setShortText(_("Hand Writing")); + handWritingAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=hand_writing"); + }); + + instance_->userInterfaceManager().registerAction("mozc-tool-character", + &characterPaletteAction_); + characterPaletteAction_.setShortText(_("Character Palette")); + characterPaletteAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=character_palette"); + }); + + instance_->userInterfaceManager().registerAction("mozc-tool-add", + &addWordAction_); + addWordAction_.setShortText("Add Word"); + addWordAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=word_register_dialog"); + }); + + instance_->userInterfaceManager().registerAction("mozc-tool-about", + &aboutAction_); + aboutAction_.setShortText("About Mozc"); + aboutAction_.connect<SimpleAction::Activated>([](InputContext *) { + mozc::Process::SpawnMozcProcess("mozc_tool", "--mode=about_dialog"); + }); + + toolMenu_.addAction(&configToolAction_); + toolMenu_.addAction(&dictionaryToolAction_); + toolMenu_.addAction(&handWritingAction_); + toolMenu_.addAction(&characterPaletteAction_); + toolMenu_.addAction(&addWordAction_); + toolMenu_.addAction(&aboutAction_); + + modeAction_.setMenu(&modeMenu_); + toolAction_.setMenu(&toolMenu_); +} + +MozcEngine::~MozcEngine() {} + +void MozcEngine::reloadConfig() {} +void MozcEngine::activate(const fcitx::InputMethodEntry &, + fcitx::InputContextEvent &event) { + auto ic = event.inputContext(); + auto mozc_state = mozcState(ic); + mozc_state->FocusIn(); + ic->statusArea().addAction(StatusGroup::InputMethod, &modeAction_); + ic->statusArea().addAction(StatusGroup::InputMethod, &toolAction_); +} +void MozcEngine::deactivate(const fcitx::InputMethodEntry &entry, + fcitx::InputContextEvent &event) { + auto ic = event.inputContext(); + auto mozc_state = mozcState(ic); + mozc_state->FocusOut(); + ic->statusArea().clearGroup(StatusGroup::InputMethod); +} +void MozcEngine::keyEvent(const InputMethodEntry &, KeyEvent &event) { + auto mozc_state = mozcState(event.inputContext()); + + // TODO: check layout + if (mozc_state->ProcessKeyEvent(event.rawKey().sym(), event.rawKey().code(), + event.rawKey().states(), false, + event.isRelease())) { + event.filterAndAccept(); + } +} + +void MozcEngine::reset(const InputMethodEntry &, InputContextEvent &event) { + auto mozc_state = mozcState(event.inputContext()); + mozc_state->Reset(); +} + +void MozcEngine::save() {} + +std::string MozcEngine::subMode(const fcitx::InputMethodEntry &, + fcitx::InputContext &ic) { + return modeAction_.longText(&ic); +} + +MozcState *MozcEngine::mozcState(InputContext *ic) { + return ic->propertyFor(&factory_); +} + +void MozcEngine::compositionModeUpdated(InputContext *ic) { + modeAction_.update(ic); + for (auto &modeAction : modeActions_) { + modeAction.update(ic); + } +} + +AddonInstance *MozcEngine::clipboardAddon() { return clipboard(); } +} // namespace fcitx + +FCITX_ADDON_FACTORY(fcitx::MozcEngineFactory) diff --git a/src/unix/fcitx5/mozc_engine.h b/src/unix/fcitx5/mozc_engine.h new file mode 100644 index 00000000..d75c8dba --- /dev/null +++ b/src/unix/fcitx5/mozc_engine.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2017~2017 by CSSlayer + * wengxt@gmail.com + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; see the file COPYING. If not, + * see <http://www.gnu.org/licenses/>. + */ +#ifndef _FCITX_UNIX_FCITX5_MOZC_ENGINE_H_ +#define _FCITX_UNIX_FCITX5_MOZC_ENGINE_H_ + +#include <fcitx/action.h> +#include <fcitx/addonfactory.h> +#include <fcitx/addonmanager.h> +#include <fcitx/inputmethodengine.h> +#include <fcitx/instance.h> +#include <fcitx/menu.h> + +#include "unix/fcitx5/mozc_state.h" + +namespace fcitx { + +class MozcConnection; +class MozcResponseParser; +class MozcEngine; + +class MozcModeAction : public Action { + public: + MozcModeAction(MozcEngine *engine) : engine_(engine) {} + + std::string shortText(fcitx::InputContext *) const override; + std::string longText(fcitx::InputContext *) const override; + std::string icon(fcitx::InputContext *) const override; + + private: + MozcEngine *engine_; +}; + +class MozcModeSubAction : public SimpleAction { + public: + MozcModeSubAction(MozcEngine *engine, mozc::commands::CompositionMode mode); + bool isChecked(fcitx::InputContext *) const override; + void activate(fcitx::InputContext *) override; + + private: + MozcEngine *engine_; + mozc::commands::CompositionMode mode_; +}; + +class MozcEngine final : public InputMethodEngine { + public: + MozcEngine(Instance *instance); + ~MozcEngine(); + Instance *instance() { return instance_; } + void activate(const InputMethodEntry &entry, + InputContextEvent &event) override; + void deactivate(const fcitx::InputMethodEntry &entry, + fcitx::InputContextEvent &event) override; + void keyEvent(const InputMethodEntry &entry, KeyEvent &keyEvent) override; + void reloadConfig() override; + void reset(const InputMethodEntry &entry, InputContextEvent &event) override; + void save() override; + std::string subMode(const fcitx::InputMethodEntry &, + fcitx::InputContext &) override; + + MozcState *mozcState(InputContext *ic); + AddonInstance *clipboardAddon(); + + void compositionModeUpdated(InputContext *ic); + + private: + Instance *instance_; + std::unique_ptr<MozcConnection> connection_; + FactoryFor<MozcState> factory_; + MozcModeAction modeAction_; + SimpleAction toolAction_; + MozcModeSubAction modeActions_[mozc::commands::NUM_OF_COMPOSITIONS] = { + {this, mozc::commands::DIRECT}, + {this, mozc::commands::HIRAGANA}, + {this, mozc::commands::FULL_KATAKANA}, + {this, mozc::commands::FULL_ASCII}, + {this, mozc::commands::HALF_ASCII}, + {this, mozc::commands::HALF_KATAKANA}, + }; + + SimpleAction configToolAction_, dictionaryToolAction_, handWritingAction_, + characterPaletteAction_, addWordAction_, aboutAction_; + Menu toolMenu_; + Menu modeMenu_; + + FCITX_ADDON_DEPENDENCY_LOADER(clipboard, instance_->addonManager()); +}; + +class MozcEngineFactory : public AddonFactory { + public: + AddonInstance *create(AddonManager *manager) override { + return new MozcEngine(manager->instance()); + } +}; +} // namespace fcitx + +#endif // _FCITX_UNIX_FCITX5_MOZC_ENGINE_H_ diff --git a/src/unix/fcitx5/mozc_response_parser.cc b/src/unix/fcitx5/mozc_response_parser.cc new file mode 100644 index 00000000..248416ed --- /dev/null +++ b/src/unix/fcitx5/mozc_response_parser.cc @@ -0,0 +1,483 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/mozc_response_parser.h" + +#include <fcitx-utils/i18n.h> +#include <fcitx-utils/utf8.h> +#include <fcitx/candidatelist.h> +#include <fcitx/inputcontext.h> +#include <fcitx/inputpanel.h> +#include <string> +#include <vector> + +#include "base/logging.h" +#include "base/process.h" +#include "base/util.h" +#include "protocol/commands.pb.h" +#include "unix/fcitx5/mozc_engine.h" +#include "unix/fcitx5/surrounding_text_util.h" + +namespace fcitx { + +namespace { + +// Returns a position that determines a preedit cursor position _AND_ top-left +// position of a candidate window. Note that we can't set these two positions +// independently. That's a SCIM's limitation. +uint32 GetCursorPosition(const mozc::commands::Output &response) { + if (!response.has_preedit()) { + return 0; + } + if (response.preedit().has_highlighted_position()) { + return response.preedit().highlighted_position(); + } + return response.preedit().cursor(); +} + +string CreateDescriptionString(const string &description) { + return " [" + description + "]"; +} + +class MozcCandidateWord final : public CandidateWord { + public: + MozcCandidateWord(int id, string text, MozcEngine *engine) + : CandidateWord(Text(text)), id_(id), engine_(engine) {} + + void select(InputContext *inputContext) const override { + auto mozc_state = engine_->mozcState(inputContext); + mozc_state->SelectCandidate(id_); + } + + private: + int id_; + MozcEngine *engine_; +}; + +class MozcCandidateList final : public CandidateList, + public PageableCandidateList { + public: + MozcCandidateList(const mozc::commands::Candidates &candidates, + InputContext *ic, MozcEngine *engine, bool use_annotation) { + setPageable(this); + bool index_visible = false; + if (candidates.has_footer()) { + const auto &footer = candidates.footer(); + index_visible = footer.has_index_visible() && footer.index_visible(); + } + + if (candidates.candidate_size() > 0) { + if (candidates.candidate(0).index() > 0) { + hasPrev_ = true; + } + if (candidates.candidate(candidates.candidate_size() - 1).index() + 1 < + candidates.size()) { + hasNext_ = true; + } + } + if (candidates.has_direction() && + candidates.direction() == mozc::commands::Candidates::HORIZONTAL) { + layout_ = CandidateLayoutHint::Horizontal; + } + + int focused_index = -1; + cursor_ = -1; + if (candidates.has_focused_index()) { + focused_index = candidates.focused_index(); + } + + labels_.reserve(candidates.candidate_size()); + + for (int i = 0; i < candidates.candidate_size(); ++i) { + const mozc::commands::Candidates::Candidate &candidate = + candidates.candidate(i); + const uint32 index = candidate.index(); + + string value; + if (use_annotation && candidate.has_annotation() && + candidate.annotation().has_prefix()) { + value = candidate.annotation().prefix(); + } + value += candidate.value(); + if (use_annotation && candidate.has_annotation() && + candidate.annotation().has_suffix()) { + value += candidate.annotation().suffix(); + } + if (use_annotation && candidate.has_annotation() && + candidate.annotation().has_description()) { + // Display descriptions ([HALF][KATAKANA], [GREEK], [Black square], + // etc). + value += CreateDescriptionString(candidate.annotation().description()); + } + + if (use_annotation && candidates.has_focused_index() && + index == focused_index) { + if (candidate.has_information_id()) { + value += + CreateDescriptionString(_("Press Ctrl+Alt+H to show usages.")); + } + cursor_ = i; + } + + if (candidate.has_annotation() && candidate.annotation().has_shortcut()) { + labels_.emplace_back(candidate.annotation().shortcut()); + } else if (index_visible) { + labels_.emplace_back(std::to_string(i + 1)); + } else { + labels_.emplace_back(); + } + + int32 id = kBadCandidateId; + if (candidate.has_id()) { + id = candidate.id(); + DCHECK_NE(kBadCandidateId, id) << "Unexpected id is passed."; + } + candidateWords_.emplace_back( + std::make_shared<MozcCandidateWord>(id, value, engine)); + } + } + + const Text &label(int idx) const override { + checkIndex(idx); + return labels_[idx]; + } + + std::shared_ptr<const CandidateWord> candidate(int idx) const override { + checkIndex(idx); + return candidateWords_[idx]; + } + int size() const override { return candidateWords_.size(); } + + int cursorIndex() const override { return cursor_; } + + CandidateLayoutHint layoutHint() const override { return layout_; } + + bool hasPrev() const override { return hasPrev_; } + bool hasNext() const override { return hasNext_; } + void prev() override { + auto mozc_state = engine_->mozcState(ic_); + mozc_state->Paging(true); + } + void next() override { + auto mozc_state = engine_->mozcState(ic_); + mozc_state->Paging(false); + } + + bool usedNextBefore() const override { return true; } + + private: + void checkIndex(int idx) const { + if (idx < 0 && idx >= size()) { + throw std::invalid_argument("invalid index"); + } + } + + InputContext *ic_; + MozcEngine *engine_; + std::vector<Text> labels_; + bool hasPrev_ = false; + bool hasNext_ = false; + CandidateLayoutHint layout_ = CandidateLayoutHint::Vertical; + int cursor_ = -1; + std::vector<std::shared_ptr<CandidateWord>> candidateWords_; +}; + +} // namespace + +MozcResponseParser::MozcResponseParser(MozcEngine *engine) + : engine_(engine), use_annotation_(false) {} + +MozcResponseParser::~MozcResponseParser() {} + +void MozcResponseParser::UpdateDeletionRange( + const mozc::commands::Output &response, InputContext *ic) const { + if (response.has_deletion_range() && + response.deletion_range().offset() <= 0 && + response.deletion_range().offset() + response.deletion_range().length() >= + 0) { + ic->deleteSurroundingText(response.deletion_range().offset(), + response.deletion_range().length()); + } +} + +void MozcResponseParser::LaunchTool(const mozc::commands::Output &response, + InputContext *ic) const { + if (response.has_launch_tool_mode()) { + auto mozc_state = engine_->mozcState(ic); + mozc_state->GetClient()->LaunchToolWithProtoBuf(response); + } +} + +void MozcResponseParser::ExecuteCallback(const mozc::commands::Output &response, + InputContext *ic) const { + if (!response.has_callback()) { + return; + } + + if (!response.callback().has_session_command()) { + LOG(ERROR) << "callback does not have session_command"; + return; + } + + const mozc::commands::SessionCommand &callback_command = + response.callback().session_command(); + + if (!callback_command.has_type()) { + LOG(ERROR) << "callback_command has no type"; + return; + } + + mozc::commands::SessionCommand session_command; + session_command.set_type(callback_command.type()); + + // TODO(nona): Make a function to handle CONVERT_REVERSE. + // Used by CONVERT_REVERSE and/or UNDO + // This value represents how many characters are selected as a relative + // distance of characters. Positive value represents forward text selection + // and negative value represents backword text selection. + // Note that you should not allow 0x80000000 for |relative_selected_length| + // because you cannot safely use |-relative_selected_length| nor + // |abs(relative_selected_length)| in this case due to integer overflow. + SurroundingTextInfo surrounding_text_info; + + switch (callback_command.type()) { + case mozc::commands::SessionCommand::UNDO: + break; + case mozc::commands::SessionCommand::CONVERT_REVERSE: { + if (!GetSurroundingText(ic, &surrounding_text_info, + engine_->clipboardAddon())) { + return; + } + + session_command.set_text(surrounding_text_info.selection_text); + break; + } + default: + return; + } + + auto mozc_state = engine_->mozcState(ic); + mozc::commands::Output new_output; + if (!mozc_state->SendCommand(session_command, &new_output)) { + LOG(ERROR) << "Callback Command Failed"; + return; + } + + if (callback_command.type() == + mozc::commands::SessionCommand::CONVERT_REVERSE) { + // We need to remove selected text as a first step of reconversion. + mozc::commands::DeletionRange *range = new_output.mutable_deletion_range(); + // Use DeletionRange field to remove the selected text. + // For forward selection (that is, |relative_selected_length > 0|), the + // offset should be a negative value to delete preceding text. + // For backward selection (that is, |relative_selected_length < 0|), + // IBus and/or some applications seem to expect |offset == 0| somehow. + const int32 offset = + surrounding_text_info.relative_selected_length > 0 + ? -surrounding_text_info + .relative_selected_length // forward selection + : 0; // backward selection + range->set_offset(offset); + range->set_length(abs(surrounding_text_info.relative_selected_length)); + } + + VLOG(1) << "New output" << new_output.DebugString(); + + ParseResponse(new_output, ic); +} + +bool MozcResponseParser::ParseResponse(const mozc::commands::Output &response, + InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + mozc_state->SetUsage("", ""); + + UpdateDeletionRange(response, ic); + + // We should check the mode field first since the response for a + // SWITCH_INPUT_MODE request only contains mode and id fields. + if (response.has_mode()) { + mozc_state->SetCompositionMode(response.mode()); + } + + if (!response.consumed()) { + // The key was not consumed by Mozc. + return false; + } + + if (response.has_result()) { + const mozc::commands::Result &result = response.result(); + ParseResult(result, ic); + } + + // First, determine the cursor position. + if (response.has_preedit()) { + const mozc::commands::Preedit &preedit = response.preedit(); + ParsePreedit(preedit, GetCursorPosition(response), ic); + } + + // Then show the candidate window. + if (response.has_candidates()) { + const mozc::commands::Candidates &candidates = response.candidates(); + ParseCandidates(candidates, ic); + } + + if (response.has_url()) { + const string &url = response.url(); + mozc_state->SetUrl(url); + } + LaunchTool(response, ic); + ExecuteCallback(response, ic); + + return true; // mozc consumed the key. +} + +void MozcResponseParser::SetUseAnnotation(bool use_annotation) { + use_annotation_ = use_annotation; +} + +void MozcResponseParser::ParseResult(const mozc::commands::Result &result, + InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + switch (result.type()) { + case mozc::commands::Result::NONE: { + mozc_state->SetAuxString("No result"); // not a fatal error. + break; + } + case mozc::commands::Result::STRING: { + mozc_state->SetResultString(result.value()); + break; + } + } +} + +void MozcResponseParser::ParseCandidates( + const mozc::commands::Candidates &candidates, InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + const mozc::commands::Footer &footer = candidates.footer(); + if (candidates.has_footer()) { + string auxString; + if (footer.has_label()) { + // TODO(yusukes,mozc-team): label() is not localized. Currently, it's + // always + // written in Japanese (in UTF-8). + auxString += footer.label(); + } else if (footer.has_sub_label()) { + // Windows client shows sub_label() only when label() is not specified. We + // follow the policy. + auxString += footer.sub_label(); + } + + if (footer.has_index_visible() && footer.index_visible()) { + if (!auxString.empty()) { + auxString += " "; + } + auxString += std::to_string(candidates.focused_index() + 1); + auxString += "/"; + auxString += std::to_string(candidates.size()); + } + mozc_state->SetAuxString(auxString); + } + + ic->inputPanel().setCandidateList(std::make_unique<MozcCandidateList>( + candidates, ic, engine_, use_annotation_)); + + int focused_index = -1; + if (candidates.has_focused_index()) { + focused_index = candidates.focused_index(); + } + + if (focused_index >= 0) { + std::map<int32, std::pair<string, string>> usage_map; + if (candidates.has_usages()) { + const mozc::commands::InformationList &usages = candidates.usages(); + for (size_t i = 0; i < usages.information().size(); ++i) { + const mozc::commands::Information &information = usages.information(i); + if (!information.has_id() || !information.has_description()) continue; + usage_map[information.id()].first = information.title(); + usage_map[information.id()].second = information.description(); + } + } + + for (int i = 0; i < candidates.candidate_size(); ++i) { + const mozc::commands::Candidates::Candidate &candidate = + candidates.candidate(i); + const uint32 index = candidate.index(); + if (use_annotation_ && index == focused_index && + candidate.has_information_id()) { + std::map<int32, std::pair<string, string>>::iterator it = + usage_map.find(candidate.information_id()); + if (it != usage_map.end()) { + mozc_state->SetUsage(it->second.first, it->second.second); + } + } + } + } +} + +void MozcResponseParser::ParsePreedit(const mozc::commands::Preedit &preedit, + uint32 position, InputContext *ic) const { + auto mozc_state = engine_->mozcState(ic); + Text preedit_text; + string s; + + for (int i = 0; i < preedit.segment_size(); ++i) { + const mozc::commands::Preedit_Segment &segment = preedit.segment(i); + const string &str = segment.value(); + if (!utf8::validate(str)) { + continue; + } + TextFormatFlags format_flag; + + switch (segment.annotation()) { + case mozc::commands::Preedit_Segment::NONE: + break; + case mozc::commands::Preedit_Segment::UNDERLINE: + format_flag = TextFormatFlag::Underline; + break; + case mozc::commands::Preedit_Segment::HIGHLIGHT: + format_flag = TextFormatFlag::HighLight; + break; + } + s += str; + + preedit_text.append(str, format_flag); + } + + int cursor = -1; + auto charLength = utf8::length(s); + if (charLength >= position) { + cursor = utf8::ncharByteLength(s.begin(), position); + } + preedit_text.setCursor(cursor); + + mozc_state->SetPreeditInfo(std::move(preedit_text)); +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/mozc_response_parser.h b/src/unix/fcitx5/mozc_response_parser.h new file mode 100644 index 00000000..8bb8366b --- /dev/null +++ b/src/unix/fcitx5/mozc_response_parser.h @@ -0,0 +1,93 @@ +// Copyright 2010-2012, Google Inc. +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ +#define MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ + +#include "base/port.h" + +namespace mozc { +namespace commands { + +class Candidates; +class Input; +class Output; +class Preedit; +class Result; + +} // namespace commands +} // namespace mozc + +namespace fcitx { + +class InputContext; +class MozcEngine; + +// This class parses IPC response from mozc_server (mozc::commands::Output) and +// updates the FCITX UI. +class MozcResponseParser { + public: + MozcResponseParser(MozcEngine *engine); + ~MozcResponseParser(); + + // Parses a response from Mozc server and sets persed information on + // fcitx_mozc + // object. Returns true if response.consumed() is true. fcitx_mozc must be non + // NULL. This function does not take ownership of fcitx_mozc. + bool ParseResponse(const mozc::commands::Output &response, + InputContext *ic) const; + + // Setter for use_annotation_. If use_annotation_ is true, ParseCandidates() + // uses annotation infomation. + void SetUseAnnotation(bool use_annotation); + + private: + void UpdateDeletionRange(const mozc::commands::Output &response, + InputContext *ic) const; + void LaunchTool(const mozc::commands::Output &response, + InputContext *ic) const; + void ExecuteCallback(const mozc::commands::Output &response, + InputContext *ic) const; + void ParseResult(const mozc::commands::Result &result, + InputContext *ic) const; + void ParseCandidates(const mozc::commands::Candidates &candidates, + InputContext *ic) const; + void ParsePreedit(const mozc::commands::Preedit &preedit, uint32 position, + InputContext *ic) const; + + MozcEngine *engine_; + bool use_annotation_; + + DISALLOW_COPY_AND_ASSIGN(MozcResponseParser); +}; + +} // namespace fcitx + +#endif // MOZC_UNIX_FCITX_MOZC_RESPONSE_PARSER_H_ diff --git a/src/unix/fcitx5/mozc_state.cc b/src/unix/fcitx5/mozc_state.cc new file mode 100644 index 00000000..3dc3bdd2 --- /dev/null +++ b/src/unix/fcitx5/mozc_state.cc @@ -0,0 +1,441 @@ +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/mozc_state.h" + +#include <fcitx-utils/i18n.h> +#include <fcitx-utils/log.h> +#include <fcitx-utils/stringutils.h> +#include <fcitx/candidatelist.h> +#include <fcitx/inputpanel.h> +#include <string> + +#include "base/const.h" +#include "base/file_util.h" +#include "base/logging.h" +#include "base/process.h" +#include "base/system_util.h" +#include "base/util.h" +#include "session/ime_switch_util.h" +#include "unix/fcitx5/fcitx_key_event_handler.h" +#include "unix/fcitx5/mozc_connection.h" +#include "unix/fcitx5/mozc_engine.h" +#include "unix/fcitx5/mozc_response_parser.h" +#include "unix/fcitx5/surrounding_text_util.h" + +namespace { + +const struct CompositionMode { + const char* icon; + const char* label; + const char* description; + mozc::commands::CompositionMode mode; +} kPropCompositionModes[] = { + { + "mozc-direct.png", + "A", + N_("Direct"), + mozc::commands::DIRECT, + }, + { + "mozc-hiragana.png", + "\xe3\x81\x82", // Hiragana letter A in UTF-8. + N_("Hiragana"), + mozc::commands::HIRAGANA, + }, + { + "mozc-katakana_full.png", + "\xe3\x82\xa2", // Katakana letter A. + N_("Full Katakana"), + mozc::commands::FULL_KATAKANA, + }, + { + "mozc-alpha_half.png", + "A", + N_("Half ASCII"), + mozc::commands::HALF_ASCII, + }, + { + "mozc-alpha_full.png", + "\xef\xbc\xa1", // Full width ASCII letter A. + N_("Full ASCII"), + mozc::commands::FULL_ASCII, + }, + { + "mozc-katakana_half.png", + "\xef\xbd\xb1", // Half width Katakana letter A. + N_("Half Katakana"), + mozc::commands::HALF_KATAKANA, + }, +}; +const size_t kNumCompositionModes = arraysize(kPropCompositionModes); + +// This array must correspond with the CompositionMode enum in the +// mozc/session/command.proto file. +static_assert(mozc::commands::NUM_OF_COMPOSITIONS == + arraysize(kPropCompositionModes), + "number of modes must match"); + +} // namespace + +namespace fcitx { + +// For unittests. +MozcState::MozcState(InputContext* ic, mozc::client::ClientInterface* client, + MozcEngine* engine) + : ic_(ic), + client_(client), + engine_(engine), + handler_(std::make_unique<KeyEventHandler>()), + parser_(std::make_unique<MozcResponseParser>(engine_)) { + // mozc::Logging::SetVerboseLevel(1); + VLOG(1) << "MozcState created."; + const bool is_vertical = true; + parser_->SetUseAnnotation(is_vertical); + + if (client_->EnsureConnection()) { + UpdatePreeditMethod(); + } +} + +MozcState::~MozcState() { + client_->SyncData(); + VLOG(1) << "MozcState destroyed."; +} + +void MozcState::UpdatePreeditMethod() { + mozc::config::Config config; + if (!client_->GetConfig(&config)) { + LOG(ERROR) << "GetConfig failed"; + return; + } + preedit_method_ = config.has_preedit_method() ? config.preedit_method() + : mozc::config::Config::ROMAN; +} + +bool MozcState::TrySendKeyEvent( + InputContext* ic, KeySym sym, uint32 keycode, KeyStates state, + mozc::commands::CompositionMode composition_mode, bool layout_is_jp, + bool is_key_up, mozc::commands::Output* out, string* out_error) const { + DCHECK(out); + DCHECK(out_error); + + // Call EnsureConnection just in case MozcState::MozcConnection() fails + // to establish the server connection. + if (!client_->EnsureConnection()) { + *out_error = "EnsureConnection failed"; + VLOG(1) << "EnsureConnection failed"; + return false; + } + + mozc::commands::KeyEvent event; + if (!handler_->GetKeyEvent(sym, keycode, state, preedit_method_, layout_is_jp, + is_key_up, &event)) + return false; + + if ((composition_mode == mozc::commands::DIRECT) && + !mozc::config::ImeSwitchUtil::IsDirectModeCommand(event)) { + VLOG(1) << "In DIRECT mode. Not consumed."; + return false; // not consumed. + } + + mozc::commands::Context context; + SurroundingTextInfo surrounding_text_info; + if (GetSurroundingText(ic, &surrounding_text_info, + engine_->clipboardAddon())) { + context.set_preceding_text(surrounding_text_info.preceding_text); + context.set_following_text(surrounding_text_info.following_text); + } + + VLOG(1) << "TrySendKeyEvent: " << std::endl << event.DebugString(); + if (!client_->SendKeyWithContext(event, context, out)) { + *out_error = "SendKey failed"; + VLOG(1) << "ERROR"; + return false; + } + VLOG(1) << "OK: " << std::endl << out->DebugString(); + return true; +} + +bool MozcState::TrySendClick(int32 unique_id, mozc::commands::Output* out, + string* out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(mozc::commands::SessionCommand::SELECT_CANDIDATE); + command.set_id(unique_id); + return TrySendRawCommand(command, out, out_error); +} + +bool MozcState::TrySendCompositionMode(mozc::commands::CompositionMode mode, + mozc::commands::Output* out, + string* out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(mozc::commands::SessionCommand::SWITCH_INPUT_MODE); + command.set_composition_mode(mode); + return TrySendRawCommand(command, out, out_error); +} + +bool MozcState::TrySendCommand(mozc::commands::SessionCommand::CommandType type, + mozc::commands::Output* out, + string* out_error) const { + DCHECK(out); + DCHECK(out_error); + + mozc::commands::SessionCommand command; + command.set_type(type); + return TrySendRawCommand(command, out, out_error); +} + +bool MozcState::TrySendRawCommand(const mozc::commands::SessionCommand& command, + mozc::commands::Output* out, + string* out_error) const { + VLOG(1) << "TrySendRawCommand: " << std::endl << command.DebugString(); + if (!client_->SendCommand(command, out)) { + *out_error = "SendCommand failed"; + VLOG(1) << "ERROR"; + return false; + } + VLOG(1) << "OK: " << std::endl << out->DebugString(); + return true; +} + +// This function is called when users press or release a key. +bool MozcState::ProcessKeyEvent(KeySym sym, uint32 keycode, KeyStates state, + bool layout_is_jp, bool is_key_up) { + auto normalized_key = Key(sym, state).normalize(); + if (displayUsage_) { + if (is_key_up) { + return true; + } + + if (normalized_key.check(Key(FcitxKey_Escape))) { + displayUsage_ = false; + ProcessKeyEvent(FcitxKey_VoidSymbol, 0, KeyState::None, layout_is_jp, + false); + } + return true; + } + + if (normalized_key.check(Key(FcitxKey_H, KeyState::Ctrl_Alt))) { + if (!title_.empty() || !description_.empty()) { + DisplayUsage(); + return true; + } + } + + string error; + mozc::commands::Output raw_response; + if (!TrySendKeyEvent(ic_, sym, keycode, state, composition_mode_, + layout_is_jp, is_key_up, &raw_response, &error)) { + // TODO(yusukes): Show |error|. + return false; // not consumed. + } + + return ParseResponse(raw_response); +} + +// This function is called from SCIM framework when users click the candidate +// window. +void MozcState::SelectCandidate(int32 id) { + if (id == kBadCandidateId) { + LOG(ERROR) << "The clicked candidate doesn't have unique ID."; + return; + } + VLOG(1) << "select_candidate, id=" << id; + + string error; + mozc::commands::Output raw_response; + if (!TrySendClick(id, &raw_response, &error)) { + LOG(ERROR) << "IPC failed. error=" << error; + SetAuxString(error); + DrawAll(); + } else { + ParseResponse(raw_response); + } +} + +// This function is called from SCIM framework. +void MozcState::Reset() { + VLOG(1) << "resetim"; + string error; + mozc::commands::Output raw_response; + if (TrySendCommand(mozc::commands::SessionCommand::REVERT, &raw_response, + &error)) { + parser_->ParseResponse(raw_response, ic_); + } + ClearAll(); // just in case. + DrawAll(); +} + +bool MozcState::Paging(bool prev) { + VLOG(1) << "paging"; + string error; + mozc::commands::SessionCommand::CommandType command = + prev ? mozc::commands::SessionCommand::CONVERT_PREV_PAGE + : mozc::commands::SessionCommand::CONVERT_NEXT_PAGE; + mozc::commands::Output raw_response; + if (TrySendCommand(command, &raw_response, &error)) { + parser_->ParseResponse(raw_response, ic_); + return true; + } + return false; +} + +// This function is called when the ic gets focus. +void MozcState::FocusIn() { + VLOG(1) << "MozcState::FocusIn()"; + + UpdatePreeditMethod(); + DrawAll(); +} + +// This function is called when the ic loses focus. +void MozcState::FocusOut() { + VLOG(1) << "MozcState::FocusOut()"; + string error; + mozc::commands::Output raw_response; + if (TrySendCommand(mozc::commands::SessionCommand::REVERT, &raw_response, + &error)) { + parser_->ParseResponse(raw_response, ic_); + } + ClearAll(); // just in case. + DrawAll(); + // TODO(yusukes): Call client::SyncData() like ibus-mozc. +} + +bool MozcState::ParseResponse(const mozc::commands::Output& raw_response) { + ClearAll(); + const bool consumed = parser_->ParseResponse(raw_response, ic_); + if (!consumed) { + VLOG(1) << "The input was not consumed by Mozc."; + } + OpenUrl(); + DrawAll(); + return consumed; +} + +void MozcState::SetResultString(const string& result_string) { + ic_->commitString(result_string); +} + +void MozcState::SetPreeditInfo(Text preedit_info) { + preedit_ = std::move(preedit_info); +} + +void MozcState::SetAuxString(const string& str) { aux_ = str; } + +void MozcState::SetCompositionMode(mozc::commands::CompositionMode mode) { + composition_mode_ = mode; + DCHECK(composition_mode_ < kNumCompositionModes); + engine_->compositionModeUpdated(ic_); +} + +void MozcState::SendCompositionMode(mozc::commands::CompositionMode mode) { + // Send the SWITCH_INPUT_MODE command. + string error; + mozc::commands::Output raw_response; + if (TrySendCompositionMode(kPropCompositionModes[mode].mode, &raw_response, + &error)) { + auto oldMode = composition_mode_; + parser_->ParseResponse(raw_response, ic_); + if (oldMode != composition_mode_) { + engine_->instance()->showInputMethodInformation(ic_); + } + } +} + +void MozcState::SetUrl(const string& url) { url_ = url; } + +void MozcState::ClearAll() { + SetPreeditInfo(Text()); + SetAuxString(""); + ic_->inputPanel().reset(); + url_.clear(); +} + +void MozcState::DrawAll() { + Text preedit = preedit_; + if (!aux_.empty()) { + string aux; + if (preedit.size()) { + aux += " "; + } + aux += "["; + aux += aux_; + aux += "]"; + preedit.append(aux); + } + ic_->inputPanel().setPreedit(std::move(preedit)); + ic_->inputPanel().setClientPreedit(preedit_); + ic_->updatePreedit(); + ic_->updateUserInterface(UserInterfaceComponent::InputPanel); +} + +void MozcState::OpenUrl() { + if (url_.empty()) { + return; + } + mozc::Process::OpenBrowser(url_); + url_.clear(); +} + +bool MozcState::SendCommand( + const mozc::commands::SessionCommand& session_command, + mozc::commands::Output* new_output) { + string error; + return TrySendRawCommand(session_command, new_output, &error); +} + +void MozcState::SetUsage(const string& title, const string& description) { + title_ = title; + description_ = description; +} + +void MozcState::DisplayUsage() { + displayUsage_ = true; + + ic_->inputPanel().reset(); + auto candidateList = std::make_unique<DisplayOnlyCandidateList>(); + + auto lines = stringutils::split(description_, "\n"); + candidateList->setLayoutHint(CandidateLayoutHint::Vertical); + candidateList->setContent(lines); + ic_->inputPanel().setCandidateList(std::move(candidateList)); + auto str = title_ + " [" + _("Press Escape to go back") + "]"; + ic_->inputPanel().setAuxUp(Text(str)); + ic_->updatePreedit(); + ic_->updateUserInterface(UserInterfaceComponent::InputPanel); +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/mozc_state.h b/src/unix/fcitx5/mozc_state.h new file mode 100644 index 00000000..01eb59a1 --- /dev/null +++ b/src/unix/fcitx5/mozc_state.h @@ -0,0 +1,165 @@ +// Copyright 2012~2013, Weng Xuetian <wengxt@gmail.com> +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_FCITX_MOZC_H_ +#define MOZC_UNIX_FCITX_FCITX_MOZC_H_ + +#include <memory> + +#include <fcitx-utils/key.h> +#include <fcitx/inputcontextproperty.h> +#include <fcitx/text.h> + +#include "base/port.h" +#include "base/run_level.h" +#include "client/client_interface.h" +#include "protocol/commands.pb.h" + +namespace fcitx { +const int32 kBadCandidateId = -12345; +class MozcConnectionInterface; +class MozcResponseParser; +class KeyTranslator; +class KeyEventHandler; +class MozcEngine; + +class MozcState : public InputContextProperty { + public: + // This constructor is used by unittests. + MozcState(InputContext* ic, mozc::client::ClientInterface* client, + MozcEngine* engine); + virtual ~MozcState(); + + void UpdatePreeditMethod(); + + bool ProcessKeyEvent(KeySym sym, uint32 keycode, KeyStates state, + bool layout_is_jp, bool is_key_up); + void SelectCandidate(int idx); + void Reset(); + void FocusIn(); + void FocusOut(); + bool Paging(bool prev); + + // Functions called by the MozcResponseParser class to update UI. + + // Displays a 'result' (aka 'commit string') on FCITX UI. + void SetResultString(const string& result_string); + // Displays a 'preedit' string on FCITX UI. This function takes ownership + // of preedit_info. If the parameter is NULL, hides the string currently + // displayed. + void SetPreeditInfo(Text preedit_info); + // Displays an auxiliary message (e.g., an error message, a title of + // candidate window). If the string is empty (""), hides the message + // currently being displayed. + void SetAuxString(const string& str); + // Sets a current composition mode (e.g., Hankaku Katakana). + void SetCompositionMode(mozc::commands::CompositionMode mode); + + void SendCompositionMode(mozc::commands::CompositionMode mode); + + // Sets the url to be opened by the default browser. + void SetUrl(const string& url); + + const string& GetIconFile(const string key); + + mozc::commands::CompositionMode GetCompositionMode() { + return composition_mode_; + } + + mozc::client::ClientInterface* GetClient() { return client_.get(); } + + bool SendCommand(const mozc::commands::SessionCommand& session_command, + mozc::commands::Output* new_output); + + void SetUsage(const string& title, const string& description); + + void DrawAll(); + + private: + void DisplayUsage(); + // Sends key event to the server. If the IPC succeeds, returns true and the + // response is stored on 'out' (and 'out_error' is not modified). If the IPC + // fails, returns false and the error message is stored on 'out_error'. In + // this case, 'out' is not modified. + bool TrySendKeyEvent(InputContext* ic, KeySym sym, uint32 keycode, + KeyStates state, + mozc::commands::CompositionMode composition_mode, + bool layout_is_jp, bool is_key_up, + mozc::commands::Output* out, string* out_error) const; + + // Sends 'mouse click on the candidate window' event to the server. + bool TrySendClick(int32 unique_id, mozc::commands::Output* out, + string* out_error) const; + + // Sends composition mode to the server. + bool TrySendCompositionMode(mozc::commands::CompositionMode mode, + mozc::commands::Output* out, + string* out_error) const; + + // Sends a command to the server. + bool TrySendCommand(mozc::commands::SessionCommand::CommandType type, + mozc::commands::Output* out, string* out_error) const; + + bool TrySendRawCommand(const mozc::commands::SessionCommand& command, + mozc::commands::Output* out, string* out_error) const; + + // Parses the response from mozc_server. Returns whether the server consumes + // the input or not (true means 'consumed'). + bool ParseResponse(const mozc::commands::Output& request); + + void ClearAll(); + void DrawPreeditInfo(); + void DrawAux(); + + // Open url_ with a default browser. + void OpenUrl(); + + InputContext* ic_; + std::unique_ptr<mozc::client::ClientInterface> client_; + MozcEngine* engine_; + + mozc::commands::CompositionMode composition_mode_ = mozc::commands::HIRAGANA; + mozc::config::Config::PreeditMethod preedit_method_ = + mozc::config::Config::ROMAN; + const std::unique_ptr<KeyEventHandler> handler_; + const std::unique_ptr<MozcResponseParser> parser_; + + bool displayUsage_ = false; + Text preedit_; + string aux_; // error tooltip, or candidate window title. + string url_; // URL to be opened by a browser. + string description_; + string title_; + + DISALLOW_COPY_AND_ASSIGN(MozcState); +}; + +} // namespace fcitx + +#endif // MOZC_UNIX_FCITX_FCITX_MOZC_H_ diff --git a/src/unix/fcitx5/po/LINGUAS b/src/unix/fcitx5/po/LINGUAS new file mode 100644 index 00000000..68faae50 --- /dev/null +++ b/src/unix/fcitx5/po/LINGUAS @@ -0,0 +1,9 @@ + +ca +da +de +ja +ko +ru +zh_CN +zh_TW diff --git a/src/unix/fcitx5/po/ca.po b/src/unix/fcitx5/po/ca.po new file mode 100644 index 00000000..29dc3af8 --- /dev/null +++ b/src/unix/fcitx5/po/ca.po @@ -0,0 +1,80 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# Robert Antoni Buj Gelonch <rbuj@fedoraproject.org>, 2017 +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-20 00:01-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Catalan (https://www.transifex.com/fcitx/teams/12005/ca/)\n" +"Language: ca\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "Paleta de caràcters" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "Mode de composició" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "Eina de configuració" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "Eina de diccionari" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "Directe" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "ASCII complet" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "Katakana complet" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "ASCII mig" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "Mig katakana" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "Escriptura a mà" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "Hiragana" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Premeu Ctrl+Alt+H per mostrar els usos." + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "Premeu Esc per tornar" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "Eina" diff --git a/src/unix/fcitx5/po/da.po b/src/unix/fcitx5/po/da.po new file mode 100644 index 00000000..679bce1f --- /dev/null +++ b/src/unix/fcitx5/po/da.po @@ -0,0 +1,79 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# scootergrisen <scootergrisen@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: scootergrisen <scootergrisen@gmail.com>, 2017\n" +"Language-Team: Danish (https://www.transifex.com/fcitx/teams/12005/da/)\n" +"Language: da\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "Tegnpalet" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "Kompositionstilstand" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "Konfigurationsværktøj" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "Ordbogsværktøj" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "Direkte" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "Fuld ASCII" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "Fuld Katakana" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "Halv ASCII" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "Halv Katakana" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "Håndskrift" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "Hiragana" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Tryk på Ctrl+Alt+H for at vise anvendelser." + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "Tryk på Escape for at gå tilbage" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "Værktøj" diff --git a/src/unix/fcitx5/po/de.po b/src/unix/fcitx5/po/de.po new file mode 100644 index 00000000..e13a6852 --- /dev/null +++ b/src/unix/fcitx5/po/de.po @@ -0,0 +1,79 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: German (https://www.transifex.com/fcitx/teams/12005/de/)\n" +"Language: de\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "Palette Symbole" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "Kompositionsmodus" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "Konfigurationswerkzeug" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "Wörterbuchwerkzeug" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "Direkt" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "7-Bit ASCII (Full ASCII)" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "Normalbreite Katakana" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "6-Bit ASCII (Half ASCII)" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "Halbbreite Katakana" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "Eingabe Handschrift" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "Hiragana" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Ctrl+Alt+H um die Hilfe anzuzeigen" + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "ESC drücken um zurück zu kehren" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "Werkzeug" diff --git a/src/unix/fcitx5/po/fcitx5-mozc.pot b/src/unix/fcitx5/po/fcitx5-mozc.pot new file mode 100644 index 00000000..c18c29ac --- /dev/null +++ b/src/unix/fcitx5/po/fcitx5-mozc.pot @@ -0,0 +1,76 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" +"Language-Team: LANGUAGE <LL@li.org>\n" +"Language: LANG\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "" + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "" diff --git a/src/unix/fcitx5/po/ja.po b/src/unix/fcitx5/po/ja.po new file mode 100644 index 00000000..03dcef0b --- /dev/null +++ b/src/unix/fcitx5/po/ja.po @@ -0,0 +1,79 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Japanese (https://www.transifex.com/fcitx/teams/12005/ja/)\n" +"Language: ja\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "文字パレット" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "変換モード" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "設定ツール" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "辞書ツール" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "直接入力" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "全角英数" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "全角カタカナ" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "半角英数" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "半角カタカナ" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "手書き文字認識" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "ひらがな" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Ctrl+Alt+H キーを押して用例を表示" + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "Escキーを押して戻る" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "ツール" diff --git a/src/unix/fcitx5/po/ko.po b/src/unix/fcitx5/po/ko.po new file mode 100644 index 00000000..f6c6c78c --- /dev/null +++ b/src/unix/fcitx5/po/ko.po @@ -0,0 +1,79 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Korean (https://www.transifex.com/fcitx/teams/12005/ko/)\n" +"Language: ko\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "글자 팔레트" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "조합 모드" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "설정 도구" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "사전 도구" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "직접입력" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "전각 아스키" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "전각 가타가나" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "반각 아스키" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "반각 가타가나" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "손 글씨" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "히라가나" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "사용법을 보려면 Ctrl+Alt+H를 누르세요." + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "돌아가려면 ESC를 누르세요" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "도구" diff --git a/src/unix/fcitx5/po/ru.po b/src/unix/fcitx5/po/ru.po new file mode 100644 index 00000000..22c312dd --- /dev/null +++ b/src/unix/fcitx5/po/ru.po @@ -0,0 +1,81 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Russian (https://www.transifex.com/fcitx/teams/12005/ru/)\n" +"Language: ru\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" +"%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || (n" +"%100>=11 && n%100<=14)? 2 : 3);\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "Палитра символов" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "Режим композиции" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "Инструмент настройки" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "Инструмент словаря" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "Прямой" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "Полный " + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "Полная катакана" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "Половинный " + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "Половинная катакана" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "Ручное письмо" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "Хирагана" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "Нажмите Ctrl+Alt+H, чтобы показать использование." + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "Нажмите для перехода назад" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "Инструмент" diff --git a/src/unix/fcitx5/po/zh_CN.po b/src/unix/fcitx5/po/zh_CN.po new file mode 100644 index 00000000..90d282cf --- /dev/null +++ b/src/unix/fcitx5/po/zh_CN.po @@ -0,0 +1,80 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Chinese (China) (https://www.transifex.com/fcitx/teams/12005/" +"zh_CN/)\n" +"Language: zh_CN\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "字符映射表" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "编辑模式" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "配置工具" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "词典工具" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "直接键盘输入" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "全角 ASCII" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "全角片假名" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "半角 ASCII" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "半角片假名" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "手写输入" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "平假名" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "按下 Ctrl+Alt+H 显示用法。" + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "按下 Escape 返回" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "工具" diff --git a/src/unix/fcitx5/po/zh_TW.po b/src/unix/fcitx5/po/zh_TW.po new file mode 100644 index 00000000..5b58a31e --- /dev/null +++ b/src/unix/fcitx5/po/zh_TW.po @@ -0,0 +1,80 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the fcitx5-mozc package. +# +# Translators: +# csslayer <wengxt@gmail.com>, 2017 +msgid "" +msgstr "" +"Project-Id-Version: fcitx5-mozc\n" +"Report-Msgid-Bugs-To: fcitx-dev@googlegroups.com\n" +"POT-Creation-Date: 2017-12-12 09:52-0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: csslayer <wengxt@gmail.com>, 2017\n" +"Language-Team: Chinese (Taiwan) (https://www.transifex.com/fcitx/teams/12005/" +"zh_TW/)\n" +"Language: zh_TW\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +#: mozc_engine.cc:174 +msgid "Character Palette" +msgstr "字符映射表" + +#: mozc_engine.cc:78 +msgid "Composition Mode" +msgstr "編輯模式" + +#: mozc_engine.cc:153 +msgid "Configuration Tool" +msgstr "設定工具" + +#: mozc_engine.cc:160 +msgid "Dictionary Tool" +msgstr "字典工具" + +#: mozc_state.cc:61 mozc_engine.cc:45 +msgid "Direct" +msgstr "直接鍵盤輸入" + +#. Full width ASCII letter A. +#: mozc_state.cc:80 mozc_engine.cc:67 +msgid "Full ASCII" +msgstr "全形 ASCII" + +#. Katakana letter A. +#: mozc_state.cc:71 mozc_engine.cc:56 +msgid "Full Katakana" +msgstr "全形片假名" + +#: mozc_state.cc:74 mozc_engine.cc:60 +msgid "Half ASCII" +msgstr "半形 ASCII" + +#. Half width Katakana letter A. +#: mozc_state.cc:85 mozc_engine.cc:72 +msgid "Half Katakana" +msgstr "半形片假名" + +#: mozc_engine.cc:167 +msgid "Hand Writing" +msgstr "手寫輸入" + +#. Hiragana letter A in UTF-8. +#: mozc_state.cc:66 mozc_engine.cc:51 +msgid "Hiragana" +msgstr "平假名" + +#: mozc_response_parser.cc:144 +msgid "Press Ctrl+Alt+H to show usages." +msgstr "按下 Ctrl+Alt+H 顯示用法。" + +#: mozc_state.cc:426 +msgid "Press Escape to go back" +msgstr "按下 Escape 返回" + +#: mozc_engine.cc:137 mozc_engine.cc:138 +msgid "Tool" +msgstr "工具" diff --git a/src/unix/fcitx5/surrounding_text_util.cc b/src/unix/fcitx5/surrounding_text_util.cc new file mode 100644 index 00000000..b4847fc2 --- /dev/null +++ b/src/unix/fcitx5/surrounding_text_util.cc @@ -0,0 +1,220 @@ +// Copyright 2010-2013, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 "unix/fcitx5/surrounding_text_util.h" + +#include <fcitx-module/clipboard/clipboard_public.h> +#include <fcitx/inputcontext.h> +#include <limits> +#include <string> + +#include "base/logging.h" +#include "base/port.h" +#include "base/util.h" + +namespace fcitx { + +using namespace mozc; + +bool SurroundingTextUtil::GetSafeDelta(uint from, uint to, int32 *delta) { + DCHECK(delta); + + static_assert(sizeof(int64) >= sizeof(uint), + "int64 must be sufficient to store a guint value."); + static_assert(sizeof(int64) == sizeof(llabs(0)), + "|llabs(0)| must returns a 64-bit integer."); + const int64 kInt32AbsMax = + llabs(static_cast<int64>(std::numeric_limits<int32>::max())); + const int64 kInt32AbsMin = + llabs(static_cast<int64>(std::numeric_limits<int32>::min())); + const int64 kInt32SafeAbsMax = std::min(kInt32AbsMax, kInt32AbsMin); + + const int64 diff = static_cast<int64>(from) - static_cast<int64>(to); + if (llabs(diff) > kInt32SafeAbsMax) { + return false; + } + + *delta = static_cast<int32>(diff); + return true; +} + +namespace { + +// Moves |iter| with |skip_count| characters. +// Returns false if |iter| reaches to the end before skipping +// |skip_count| characters. +bool Skip(ConstChar32Iterator *iter, size_t skip_count) { + for (size_t i = 0; i < skip_count; ++i) { + if (iter->Done()) { + return false; + } + iter->Next(); + } + return true; +} + +// Returns true if |prefix_iter| is the prefix of |iter|. +// Returns false if |prefix_iter| is an empty sequence. +// Otherwise returns false. +// This function receives ConstChar32Iterator as pointer because +// ConstChar32Iterator is defined as non-copyable. +bool StartsWith(ConstChar32Iterator *iter, ConstChar32Iterator *prefix_iter) { + if (iter->Done() || prefix_iter->Done()) { + return false; + } + + while (true) { + if (iter->Get() != prefix_iter->Get()) { + return false; + } + prefix_iter->Next(); + if (prefix_iter->Done()) { + return true; + } + iter->Next(); + if (iter->Done()) { + return false; + } + } +} + +// Returns true if |surrounding_text| contains |selected_text| +// from |cursor_pos| to |*anchor_pos|. +// Otherwise returns false. +bool SearchAnchorPosForward(const string &surrounding_text, + const string &selected_text, + size_t selected_chars_len, uint cursor_pos, + uint *anchor_pos) { + ConstChar32Iterator iter(surrounding_text); + // Move |iter| to cursor pos. + if (!Skip(&iter, cursor_pos)) { + return false; + } + + ConstChar32Iterator sel_iter(selected_text); + if (!StartsWith(&iter, &sel_iter)) { + return false; + } + *anchor_pos = cursor_pos + selected_chars_len; + return true; +} + +// Returns true if |surrounding_text| contains |selected_text| +// from |*anchor_pos| to |cursor_pos|. +// Otherwise returns false. +bool SearchAnchorPosBackward(const string &surrounding_text, + const string &selected_text, + size_t selected_chars_len, uint cursor_pos, + uint *anchor_pos) { + if (cursor_pos < selected_chars_len) { + return false; + } + + ConstChar32Iterator iter(surrounding_text); + // Skip |iter| to (potential) anchor pos. + const uint skip_count = cursor_pos - selected_chars_len; + DCHECK_LE(skip_count, cursor_pos); + if (!Skip(&iter, skip_count)) { + return false; + } + + ConstChar32Iterator sel_iter(selected_text); + if (!StartsWith(&iter, &sel_iter)) { + return false; + } + *anchor_pos = cursor_pos - selected_chars_len; + return true; +} + +} // namespace + +bool SurroundingTextUtil::GetAnchorPosFromSelection( + const string &surrounding_text, const string &selected_text, + uint cursor_pos, uint *anchor_pos) { + DCHECK(anchor_pos); + + if (surrounding_text.empty()) { + return false; + } + + if (selected_text.empty()) { + return false; + } + + const size_t selected_chars_len = Util::CharsLen(selected_text); + + if (SearchAnchorPosForward(surrounding_text, selected_text, + selected_chars_len, cursor_pos, anchor_pos)) { + return true; + } + + return SearchAnchorPosBackward(surrounding_text, selected_text, + selected_chars_len, cursor_pos, anchor_pos); +} + +bool GetSurroundingText(InputContext *ic, SurroundingTextInfo *info, + AddonInstance *clipboard) { + if (!ic->capabilityFlags().test(CapabilityFlag::SurroundingText) || + !ic->surroundingText().isValid()) { + return false; + } + + const auto surrounding_text = ic->surroundingText().text(); + uint cursor_pos = ic->surroundingText().cursor(); + uint anchor_pos = ic->surroundingText().anchor(); + + if (cursor_pos == anchor_pos && clipboard) { + string primary = clipboard->call<IClipboard::primary>(ic); + if (!primary.empty()) { + uint new_anchor_pos = 0; + if (SurroundingTextUtil::GetAnchorPosFromSelection( + surrounding_text, primary, cursor_pos, &new_anchor_pos)) { + anchor_pos = new_anchor_pos; + } + } + } + + if (!SurroundingTextUtil::GetSafeDelta(cursor_pos, anchor_pos, + &info->relative_selected_length)) { + LOG(ERROR) << "Too long text selection."; + return false; + } + + const size_t selection_start = std::min(cursor_pos, anchor_pos); + const size_t selection_length = std::abs(info->relative_selected_length); + Util::SubStringPiece(surrounding_text, 0, selection_start) + .CopyToString(&info->preceding_text); + Util::SubStringPiece(surrounding_text, selection_start, selection_length) + .CopyToString(&info->selection_text); + Util::SubStringPiece(surrounding_text, selection_start + selection_length) + .CopyToString(&info->following_text); + return true; +} + +} // namespace fcitx diff --git a/src/unix/fcitx5/surrounding_text_util.h b/src/unix/fcitx5/surrounding_text_util.h new file mode 100644 index 00000000..68a23b46 --- /dev/null +++ b/src/unix/fcitx5/surrounding_text_util.h @@ -0,0 +1,84 @@ +// Copyright 2010-2013, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// 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 +// OWNER 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 MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_ +#define MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_ + +#include <fcitx/inputcontext.h> +#include <string> + +#include "base/port.h" + +namespace fcitx { + +class AddonInstance; + +struct SurroundingTextInfo { + SurroundingTextInfo() : relative_selected_length(0) {} + + int32 relative_selected_length; + string preceding_text; + string selection_text; + string following_text; +}; + +class SurroundingTextUtil { + public: + // Calculates |from| - |to| and stores the result into |delta| with + // checking integer overflow. + // Returns true when neither |abs(delta)| nor |-delta| does not cause + // integer overflow, that is, |delta| is in a safe range. + // Returns false otherwise. + static bool GetSafeDelta(uint from, uint to, int32 *delta); + + // Returns true if + // 1. |surrounding_text| contains |selected_text| + // from |cursor_pos| to |*anchor_pos|. + // or, + // 2. |surrounding_text| contains |selected_text| + // from |*anchor_pos| to |cursor_pos|. + // with calculating |*anchor_pos|, + // where |cursor_pos| and |*anchor_pos| are counts of Unicode characters. + // When both 1) and 2) are satisfied, this function calculates + // |*anchor_pos| for case 1). + // Otherwise returns false. + static bool GetAnchorPosFromSelection(const string &surrounding_text, + const string &selected_text, + uint cursor_pos, uint *anchor_pos); + + private: + DISALLOW_IMPLICIT_CONSTRUCTORS(SurroundingTextUtil); +}; + +bool GetSurroundingText(InputContext *ic, SurroundingTextInfo *info, + AddonInstance *clipboard); + +} // namespace fcitx + +#endif // MOZC_UNIX_FCITX_SURROUNDING_TEXT_URIL_H_
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
