void* IMSelectorCreate(FcitxInstance* instance)
{
IMSelector* imselector = fcitx_utils_malloc0(sizeof(IMSelector));
imselector->owner = instance;
if (!LoadIMSelectorConfig(imselector)) {
free(imselector);
return NULL;
}
FcitxKeyFilterHook hk;
hk.arg = imselector;
hk.func = IMSelectorPreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
FcitxHotkeyHook hkhk;
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorLocalTrigger;
hkhk.hotkey = imselector->localKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorGlobalTrigger;
hkhk.hotkey = imselector->globalKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
FcitxIMEventHook resethk;
resethk.arg = imselector;
resethk.func = IMSelectorReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
return imselector;
}
void* UnicodeCreate(FcitxInstance* instance)
{
UnicodeModule* uni = fcitx_utils_new(UnicodeModule);
uni->owner = instance;
if (!UnicodeLoadConfig(uni)) {
free(uni);
return NULL;
}
FcitxIMEventHook imhk;
imhk.arg = uni;
imhk.func = UnicodeReset;
FcitxInstanceRegisterResetInputHook(instance, imhk);
FcitxKeyFilterHook kfhk;
kfhk.arg = uni;
kfhk.func = UnicodePreFilter;
FcitxInstanceRegisterPreInputFilter(instance, kfhk);
kfhk.arg = &uni->enable;
kfhk.func = FcitxDummyReleaseInputHook;
FcitxInstanceRegisterPreReleaseInputFilter(instance, kfhk);
FcitxHotkeyHook hkhk;
hkhk.arg = uni;
hkhk.hotkey = uni->key;
hkhk.hotkeyhandle = UnicodeHotkey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
return uni;
}
void* ChttransCreate(FcitxInstance* instance)
{
FcitxChttrans* transState = fcitx_utils_malloc0(sizeof(FcitxChttrans));
FcitxAddon* transAddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_CHTTRANS_NAME);
transState->owner = instance;
if (!LoadChttransConfig(transState)) {
free(transState);
return NULL;
}
FcitxHotkeyHook hk;
hk.arg = transState;
hk.hotkey = transState->hkToggle;
hk.hotkeyhandle = HotkeyToggleChttransState;
FcitxStringFilterHook shk;
shk.arg = transState;
shk.func = ChttransOutputFilter;
FcitxInstanceRegisterHotkeyFilter(instance, hk);
FcitxInstanceRegisterOutputFilter(instance, shk);
FcitxInstanceRegisterCommitFilter(instance, shk);
FcitxUIRegisterStatus(instance, transState, "chttrans",
transState->enabled ? _("Convert to Traditional Chinese") : _("Convert to Simplified Chinese"),
_("Toggle Simp/Trad Chinese Conversion"),
ToggleChttransState,
GetChttransEnabled);
FcitxInstanceWatchContext(instance, CONTEXT_IM_LANGUAGE, ChttransLanguageChanged, transState);
AddFunction(transAddon, ChttransS2T);
AddFunction(transAddon, ChttransT2S);
return transState;
}
void* FullWidthCharCreate(FcitxInstance* instance)
{
FcitxFullWidthChar* fwchar = fcitx_utils_malloc0(sizeof(FcitxFullWidthChar));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
fwchar->owner = instance;
FcitxStringFilterHook hk;
hk.arg = fwchar;
hk.func = ProcessFullWidthChar;
FcitxInstanceRegisterCommitFilter(instance, hk);
FcitxKeyFilterHook phk;
phk.arg = fwchar;
phk.func = FullWidthPostFilter;
FcitxInstanceRegisterPostInputFilter(instance, phk);
FcitxHotkeyHook hotkey;
hotkey.hotkey = config->hkFullWidthChar;
hotkey.hotkeyhandle = ToggleFullWidthStateWithHotkey;
hotkey.arg = fwchar;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxUIRegisterStatus(instance, fwchar, "fullwidth", _("Full Width Character"), _("Full Width Character"), ToggleFullWidthState, GetFullWidthState);
return fwchar;
}
void* FullWidthCharCreate(FcitxInstance* instance)
{
FcitxFullWidthChar* fwchar = fcitx_utils_malloc0(sizeof(FcitxFullWidthChar));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
fwchar->owner = instance;
FcitxStringFilterHook hk;
hk.arg = fwchar;
hk.func = ProcessFullWidthChar;
FcitxInstanceRegisterCommitFilter(instance, hk);
FcitxKeyFilterHook phk;
phk.arg = fwchar;
phk.func = FullWidthPostFilter;
FcitxInstanceRegisterPostInputFilter(instance, phk);
FcitxHotkeyHook hotkey;
hotkey.hotkey = config->hkFullWidthChar;
hotkey.hotkeyhandle = ToggleFullWidthStateWithHotkey;
hotkey.arg = fwchar;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxProfile* profile = FcitxInstanceGetProfile(instance);
FcitxUIRegisterStatus(instance, fwchar, "fullwidth",
profile->bUseFullWidthChar ? _("Full width Character") : _("Half width Character"),
_("Toggle Half/Full width Character"),
ToggleFullWidthState, GetFullWidthState);
FcitxInstanceRegisterWatchableContext(instance, CONTEXT_DISABLE_FULLWIDTH, FCT_Boolean, FCF_ResetOnInputMethodChange);
FcitxInstanceWatchContext(instance, CONTEXT_DISABLE_FULLWIDTH, DisableFullWidthCharChanged, fwchar);
return fwchar;
}
void* PuncCreate(FcitxInstance* instance)
{
FcitxPuncState* puncState = fcitx_utils_malloc0(sizeof(FcitxPuncState));
FcitxAddon* puncaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_PUNC_NAME);
puncState->owner = instance;
LoadPuncDict(puncState);
FcitxKeyFilterHook hk;
hk.arg = puncState;
hk.func = ProcessPunc;
FcitxInstanceRegisterPostInputFilter(instance, hk);
hk.func = PuncPreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
puncState->cLastIsAutoConvert = '\0';
puncState->bLastIsNumber = false;
FcitxHotkeyHook hotkey;
hotkey.hotkey = FcitxInstanceGetGlobalConfig(instance)->hkPunc;
hotkey.hotkeyhandle = TogglePuncStateWithHotkey;
hotkey.arg = puncState;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxIMEventHook hook;
hook.arg = puncState;
hook.func = ResetPunc;
FcitxInstanceRegisterResetInputHook(instance, hook);
hook.func = ResetPuncWhichStatus;
FcitxInstanceRegisterInputUnFocusHook(instance, hook);
FcitxInstanceWatchContext(instance, CONTEXT_IM_LANGUAGE, PuncLanguageChanged, puncState);
FcitxProfile* profile = FcitxInstanceGetProfile(instance);
FcitxUIRegisterStatus(instance, puncState, "punc",
profile->bUseWidePunc ? _("Full width punct") : _("Latin punct"),
_("Toggle Full Width Punctuation"), TogglePuncState, GetPuncState);
puncState->slot = FcitxInstanceAllocDataForIC(instance, PuncWhichAlloc, PuncWhichCopy, PuncWhichFree, puncState);
FcitxModuleAddFunction(puncaddon, PuncGetPunc);
FcitxModuleAddFunction(puncaddon, PuncGetPunc2);
return puncState;
}
void *VKCreate(FcitxInstance* instance)
{
FcitxVKState *vkstate = fcitx_utils_malloc0(sizeof(FcitxVKState));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
vkstate->owner = instance;
FcitxHotkeyHook hotkey;
hotkey.hotkey = config->hkVK;
hotkey.hotkeyhandle = ToggleVKStateWithHotkey;
hotkey.arg = vkstate;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxUIRegisterStatus(instance, vkstate, "vk", _("Toggle Virtual Keyboard"), _("Virtual Keyboard State"), ToggleVKState, GetVKState);
LoadVKMapFile(vkstate);
FcitxKeyFilterHook hk;
hk.arg = vkstate ;
hk.func = VKPreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
FcitxIMEventHook resethk;
resethk.arg = vkstate;
resethk.func = VKReset;
FcitxInstanceRegisterTriggerOnHook(instance, resethk);
FcitxInstanceRegisterTriggerOffHook(instance, resethk);
resethk.func = VKUpdate;
FcitxInstanceRegisterInputFocusHook(instance, resethk);
FcitxInstanceRegisterInputUnFocusHook(instance, resethk);
FcitxMenuInit(&vkstate->vkmenu);
vkstate->vkmenu.candStatusBind = strdup("vk");
vkstate->vkmenu.name = strdup(_("Virtual Keyboard"));
vkstate->vkmenu.UpdateMenu = UpdateVKMenu;
vkstate->vkmenu.MenuAction = VKMenuAction;
vkstate->vkmenu.priv = vkstate;
vkstate->vkmenu.isSubMenu = false;
FcitxUIRegisterMenu(instance, &vkstate->vkmenu);
return vkstate;
}
void *ChttransCreate(FcitxInstance* instance)
{
FcitxChttrans *transState = fcitx_utils_new(FcitxChttrans);
transState->owner = instance;
transState->enableIM = fcitx_string_map_new(NULL, '\0');
if (!LoadChttransConfig(transState)) {
fcitx_string_map_free(transState->enableIM);
free(transState);
return NULL;
}
FcitxHotkeyHook hk;
hk.arg = transState;
hk.hotkey = transState->hkToggle;
hk.hotkeyhandle = HotkeyToggleChttransState;
FcitxStringFilterHook shk;
shk.arg = transState;
shk.func = ChttransOutputFilter;
FcitxIMEventHook imhk;
imhk.arg = transState;
imhk.func = ChttransIMChanged;
FcitxInstanceRegisterHotkeyFilter(instance, hk);
FcitxInstanceRegisterOutputFilter(instance, shk);
FcitxInstanceRegisterCommitFilter(instance, shk);
FcitxInstanceRegisterIMChangedHook(instance, imhk);
FcitxUIRegisterStatus(instance, transState, "chttrans",
ChttransEnabled(transState) ? _("Traditional Chinese") : _("Simplified Chinese"),
_("Toggle Simp/Trad Chinese Conversion"),
ToggleChttransState,
GetChttransEnabled);
FcitxInstanceWatchContext(instance, CONTEXT_IM_LANGUAGE,
ChttransLanguageChanged, transState);
FcitxChttransAddFunctions(instance);
return transState;
}
void* IMSelectorCreate(FcitxInstance* instance)
{
IMSelector* imselector = fcitx_utils_malloc0(sizeof(IMSelector));
imselector->owner = instance;
if (!LoadIMSelectorConfig(imselector)) {
free(imselector);
return NULL;
}
FcitxKeyFilterHook hk;
hk.arg = imselector;
hk.func = IMSelectorPreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
hk.arg = &imselector->triggered;
hk.func = FcitxDummyReleaseInputHook;
FcitxInstanceRegisterPreReleaseInputFilter(instance, hk);
FcitxHotkeyHook hkhk;
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorLocalTrigger;
hkhk.hotkey = imselector->localKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorGlobalTrigger;
hkhk.hotkey = imselector->globalKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorClearLocal;
hkhk.hotkey = imselector->clearLocalKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
/* this key is ignore the very first input method which is for inactive */
#define _ADD_HANDLE(X, ISGLOBAL) \
do { \
SelectorHandle* handle = &imselector->handle[ISGLOBAL][X - 1]; \
handle->global = ISGLOBAL; \
handle->idx = X; \
handle->imselector = imselector; \
hkhk.arg = handle; \
hkhk.hotkeyhandle = IMSelectorSelect; \
hkhk.hotkey = imselector->selectorKey[ISGLOBAL][X - 1]; \
FcitxInstanceRegisterHotkeyFilter(instance, hkhk); \
} while(0);
_ADD_HANDLE(1, false);
_ADD_HANDLE(2, false);
_ADD_HANDLE(3, false);
_ADD_HANDLE(4, false);
_ADD_HANDLE(5, false);
_ADD_HANDLE(6, false);
_ADD_HANDLE(7, false);
_ADD_HANDLE(8, false);
_ADD_HANDLE(9, false);
_ADD_HANDLE(1, true);
_ADD_HANDLE(2, true);
_ADD_HANDLE(3, true);
_ADD_HANDLE(4, true);
_ADD_HANDLE(5, true);
_ADD_HANDLE(6, true);
_ADD_HANDLE(7, true);
_ADD_HANDLE(8, true);
_ADD_HANDLE(9, true);
FcitxIMEventHook resethk;
resethk.arg = imselector;
resethk.func = IMSelectorReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
return imselector;
}
void* CloudPinyinCreate(FcitxInstance* instance)
{
FcitxCloudPinyin *cloudpinyin = fcitx_utils_new(FcitxCloudPinyin);
bindtextdomain("fcitx-cloudpinyin", LOCALEDIR);
bind_textdomain_codeset("fcitx-cloudpinyin", "UTF-8");
cloudpinyin->owner = instance;
int pipe1[2];
int pipe2[2];
if (!CloudPinyinConfigLoad(&cloudpinyin->config))
{
free(cloudpinyin);
return NULL;
}
if (pipe(pipe1) < 0)
{
free(cloudpinyin);
return NULL;
}
if (pipe(pipe2) < 0) {
close(pipe1[0]);
close(pipe1[1]);
free(cloudpinyin);
return NULL;
}
cloudpinyin->pipeRecv = pipe1[0];
cloudpinyin->pipeNotify = pipe2[1];
fcntl(pipe1[0], F_SETFL, O_NONBLOCK);
fcntl(pipe1[1], F_SETFL, O_NONBLOCK);
fcntl(pipe2[0], F_SETFL, O_NONBLOCK);
fcntl(pipe2[1], F_SETFL, O_NONBLOCK);
cloudpinyin->pendingQueue = fcitx_utils_malloc0(sizeof(CurlQueue));
cloudpinyin->finishQueue = fcitx_utils_malloc0(sizeof(CurlQueue));
pthread_mutex_init(&cloudpinyin->pendingQueueLock, NULL);
pthread_mutex_init(&cloudpinyin->finishQueueLock, NULL);
FcitxFetchThread* fetch = fcitx_utils_malloc0(sizeof(FcitxFetchThread));
cloudpinyin->fetch = fetch;
fetch->owner = cloudpinyin;
fetch->pipeRecv = pipe2[0];
fetch->pipeNotify = pipe1[1];
fetch->pendingQueueLock = &cloudpinyin->pendingQueueLock;
fetch->finishQueueLock = &cloudpinyin->finishQueueLock;
fetch->queue = fcitx_utils_malloc0(sizeof(CurlQueue));
FcitxIMEventHook hook;
hook.arg = cloudpinyin;
hook.func = CloudPinyinAddCandidateWord;
FcitxInstanceRegisterUpdateCandidateWordHook(instance, hook);
hook.arg = cloudpinyin;
hook.func = CloudPinyinHookForNewRequest;
FcitxInstanceRegisterResetInputHook(instance, hook);
FcitxInstanceRegisterInputFocusHook(instance, hook);
FcitxInstanceRegisterInputUnFocusHook(instance, hook);
FcitxInstanceRegisterTriggerOnHook(instance, hook);
FcitxHotkeyHook hkhook;
hkhook.arg = cloudpinyin;
hkhook.hotkey = cloudpinyin->config.hkToggle.hotkey;
hkhook.hotkeyhandle = CloudPinyinToggle;
FcitxInstanceRegisterHotkeyFilter(instance, hkhook);
pthread_create(&cloudpinyin->pid, NULL, FetchThread, fetch);
CloudPinyinRequestKey(cloudpinyin);
return cloudpinyin;
}