FCITX_EXPORT_API
void FcitxInstanceDestroyIC(FcitxInstance* instance, int frontendid, void* filter)
{
FcitxInputContext *rec, *last;
UT_array* frontends = &instance->frontends;
FcitxAddon** pfrontend = (FcitxAddon**) utarray_eltptr(frontends, frontendid);
if (pfrontend == NULL)
return;
FcitxFrontend* frontend = (*pfrontend)->frontend;
last = NULL;
for (rec = instance->ic_list; rec != NULL; last = rec, rec = rec->next) {
if (rec->frontendid == frontendid && frontend->CheckIC((*pfrontend)->addonInstance, rec, filter)) {
if (last != NULL)
last->next = rec->next;
else
instance->ic_list = rec->next;
rec->next = instance->free_list;
instance->free_list = rec;
if (rec == FcitxInstanceGetCurrentIC(instance)) {
FcitxUICloseInputWindow(instance);
FcitxUIOnInputUnFocus(instance);
FcitxInstanceSetCurrentIC(instance, NULL);
}
frontend->DestroyIC((*pfrontend)->addonInstance, rec);
return;
}
}
return;
}
Bool XIMSetFocusHandler(FcitxXimFrontend* xim, IMChangeFocusStruct * call_data)
{
FcitxInputContext* ic = FcitxInstanceFindIC(xim->owner, xim->frontendid, &call_data->icid);
if (ic == NULL)
return True;
FcitxInputContext* oldic = FcitxInstanceGetCurrentIC(xim->owner);
if (oldic && oldic != ic)
FcitxUICommitPreedit(xim->owner);
if (!FcitxInstanceSetCurrentIC(xim->owner, ic))
return True;
SetTrackPos(xim, ic, NULL);
if (ic) {
FcitxUIOnInputFocus(xim->owner);
} else {
FcitxUICloseInputWindow(xim->owner);
FcitxUIMoveInputWindow(xim->owner);
}
return True;
}
void FcitxInstanceCleanUpIC(FcitxInstance* instance)
{
FcitxInputContext *rec = instance->ic_list, *last = NULL, *todel;
while (rec) {
FcitxAddon **pfrontend = FcitxInstanceGetPFrontend(instance,
rec->frontendid);
FcitxFrontend *frontend = (*pfrontend)->frontend;
pid_t pid = 0;
if (frontend->GetPid)
pid = frontend->GetPid((*pfrontend)->addonInstance, rec);
if (pid && !fcitx_utils_pid_exists(pid)) {
if (last != NULL)
last->next = rec->next;
else
instance->ic_list = rec->next;
todel = rec;
rec = rec->next;
todel->next = instance->free_list;
instance->free_list = todel;
frontend->DestroyIC((*pfrontend)->addonInstance, todel);
FreeICData(instance, todel);
if (todel == instance->CurrentIC) {
instance->CurrentIC = NULL;
FcitxUICloseInputWindow(instance);
FcitxUIOnInputUnFocus(instance);
FcitxInstanceSetCurrentIC(instance, NULL);
}
}
else {
last = rec;
rec = rec->next;
}
}
}
Bool XIMUnsetFocusHandler(FcitxXimFrontend* xim, IMChangeICStruct * call_data)
{
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(xim->owner);
if (ic && GetXimIC(ic)->id == call_data->icid) {
FcitxUICommitPreedit(xim->owner);
FcitxUICloseInputWindow(xim->owner);
FcitxInstanceSetCurrentIC(xim->owner, NULL);
FcitxUIOnInputUnFocus(xim->owner);
}
return True;
}
void SwitchVK(FcitxVKState *vkstate)
{
FcitxInstance* instance = vkstate->owner;
if (vkstate->vkWindow == NULL)
vkstate->vkWindow = CreateVKWindow(vkstate);
VKWindow *vkWindow = vkstate->vkWindow;
if (!vkstate->iVKCount)
return;
vkstate->bVK = !vkstate->bVK;
if (vkstate->bVK) {
int x, y;
int dwidth, dheight;
InvokeVaArgs(vkstate->owner, FCITX_X11, GETSCREENSIZE,
&dwidth, &dheight);
if (!FcitxUISupportMainWindow(instance)) {
x = dwidth / 2 - VK_WINDOW_WIDTH / 2;
y = 40;
} else {
int mx = 0, my = 0, mw = 0, mh = 0;
FcitxUIGetMainWindowSize(instance, &mx, &my, &mw, &mh);
x = mx;
y = my + mh + 2;
if ((y + VK_WINDOW_HEIGHT) >= dheight)
y = my - VK_WINDOW_HEIGHT - 2;
if (y < 0)
y = 0;
}
if ((x + VK_WINDOW_WIDTH) >= dwidth)
x = dwidth - VK_WINDOW_WIDTH - 1;
if (x < 0)
x = 0;
XMoveWindow(vkWindow->dpy, vkWindow->window, x, y);
DisplayVKWindow(vkWindow);
FcitxUICloseInputWindow(instance);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance);
if (ic && FcitxInstanceGetCurrentState(instance) == IS_CLOSED)
FcitxInstanceEnableIM(instance, ic, true);
} else {
XUnmapWindow(vkWindow->dpy, vkWindow->window);
FcitxInstanceCleanInputWindow(instance);
FcitxUIUpdateInputWindow(instance);
}
}
FCITX_EXPORT_API
void FcitxUIOnInputFocus(FcitxInstance* instance)
{
if (UI_FUNC_IS_VALID(OnInputFocus))
instance->ui->ui->OnInputFocus(instance->ui->addonInstance);
FcitxInstanceProcessInputFocusHook(instance);
FcitxInstanceResetInput(instance);
boolean changed = FcitxInstanceUpdateCurrentIM(instance, false);
if (instance->config->bShowInputWindowWhenFocusIn && changed)
FcitxInstanceShowInputSpeed(instance);
else
FcitxUICloseInputWindow(instance);
}
FCITX_EXPORT_API
void FcitxUIOnInputFocus(FcitxInstance* instance)
{
if (UI_FUNC_IS_VALID(OnInputFocus))
instance->ui->ui->OnInputFocus(instance->ui->addonInstance);
FcitxInstanceProcessInputFocusHook(instance);
FcitxInstanceResetInput(instance);
if (instance->config->firstAsInactive) {
if (FcitxInstanceGetCurrentState(instance) == IS_ACTIVE)
FcitxInstanceSwitchIM(instance, instance->lastIMIndex);
else if (FcitxInstanceGetCurrentState(instance) == IS_ENG) {
if (instance->iIMIndex != 0)
instance->lastIMIndex = instance->iIMIndex;
FcitxInstanceSwitchIMInternal(instance, 0, false);
}
}
FcitxUICloseInputWindow(instance);
}
FCITX_EXPORT_API
void FcitxUIOnInputFocus(FcitxInstance* instance)
{
if (UI_FUNC_IS_VALID(OnInputFocus))
instance->ui->ui->OnInputFocus(instance->ui->addonInstance);
FcitxInstanceProcessInputFocusHook(instance);
FcitxInstanceResetInput(instance);
boolean changed;
if (instance->lastIC == instance->CurrentIC && instance->delayedIM) {
FcitxInstanceSwitchIMByName(instance, instance->delayedIM);
changed = true;
} else {
changed = FcitxInstanceUpdateCurrentIM(instance, false, false);
}
if (instance->config->bShowInputWindowWhenFocusIn && changed)
FcitxInstanceShowInputSpeed(instance);
else
FcitxUICloseInputWindow(instance);
}
/**
* @brief function DoInput has done everything for us.
*
* @param searchMode
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxLibpinyinGetCandWords(void* arg)
{
FcitxLibpinyin* libpinyin = (FcitxLibpinyin* )arg;
FcitxInstance* instance = libpinyin->owner->owner;
FcitxInputState* input = FcitxInstanceGetInputState(instance);
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(libpinyin->owner->owner);
FcitxLibpinyinConfig* pyConfig = &libpinyin->owner->config;
struct _FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetPageSize(candList, config->iMaxCandWord);
FcitxUICloseInputWindow(instance);
strcpy(FcitxInputStateGetRawInputBuffer(input), libpinyin->buf);
FcitxInputStateSetRawInputBufferSize(input, strlen(libpinyin->buf));
FcitxInputStateSetShowCursor(input, true);
FcitxInputStateSetClientCursorPos(input, 0);
if (libpinyin->type == LPT_Zhuyin) {
FcitxKeyState state = candidateModifierMap[pyConfig->candidateModifiers];
FcitxCandidateWordSetChooseAndModifier(candList, "1234567890", state);
}
else
FcitxCandidateWordSetChoose(candList, "1234567890");
/* add punc */
if (libpinyin->type == LPT_Zhuyin
&& strlen(libpinyin->buf) == 1
&& LibpinyinCheckZhuyinKey((FcitxKeySym) libpinyin->buf[0], pyConfig->zhuyinLayout, pyConfig->useTone)
&& (libpinyin->buf[0] >= ' ' && libpinyin->buf[0] <= '\x7e') /* simple */
&& !(libpinyin->buf[0] >= 'a' && libpinyin->buf[0] <= 'z') /* not a-z */
&& !(libpinyin->buf[0] >= 'A' && libpinyin->buf[0] <= 'Z') /* not A-Z /*/
&& !(libpinyin->buf[0] >= '0' && libpinyin->buf[0] <= '9') /* not digit */
) {
int c = libpinyin->buf[0];
char *result = FcitxPuncGetPunc(instance, &c);
if (result) {
FcitxCandidateWord candWord;
FcitxLibpinyinCandWord* pyCand = (FcitxLibpinyinCandWord*) fcitx_utils_malloc0(sizeof(FcitxLibpinyinCandWord));
pyCand->ispunc = true;
candWord.callback = FcitxLibpinyinGetCandWord;
candWord.extraType = MSG_OTHER;
candWord.owner = libpinyin;
candWord.priv = pyCand;
candWord.strExtra = NULL;
candWord.strWord = strdup(result);
candWord.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
}
char* sentence = NULL;
pinyin_guess_sentence(libpinyin->inst);
sentence = LibpinyinGetSentence(libpinyin);
if (sentence) {
FcitxLibpinyinUpdatePreedit(libpinyin, sentence);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetClientPreedit(input), MSG_INPUT, "%s", sentence);
g_free(sentence);
}
else {
FcitxInputStateSetCursorPos(input, libpinyin->cursor_pos);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetClientPreedit(input), MSG_INPUT, "%s", libpinyin->buf);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", libpinyin->buf);
}
if (libpinyin->candidate)
g_array_free(libpinyin->candidate, TRUE);
libpinyin->candidate = g_array_new(FALSE, FALSE, sizeof(lookup_candidate_t));
pinyin_get_candidates(libpinyin->inst, LibpinyinGetOffset(libpinyin), libpinyin->candidate);
int i = 0;
for (i = 0 ; i < libpinyin->candidate->len; i ++) {
lookup_candidate_t token = g_array_index(libpinyin->candidate, lookup_candidate_t, i);
FcitxCandidateWord candWord;
FcitxLibpinyinCandWord* pyCand = (FcitxLibpinyinCandWord*) fcitx_utils_malloc0(sizeof(FcitxLibpinyinCandWord));
pyCand->ispunc = false;
pyCand->idx = i;
candWord.callback = FcitxLibpinyinGetCandWord;
candWord.extraType = MSG_OTHER;
candWord.owner = libpinyin;
candWord.priv = pyCand;
candWord.strExtra = NULL;
candWord.strWord = strdup(token.m_phrase_string);
candWord.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
return IRV_DISPLAY_CANDWORDS;
}
Bool XIMCloseHandler(FcitxXimFrontend* xim, IMOpenStruct * call_data)
{
FcitxUICloseInputWindow(xim->owner);
FcitxInstanceSaveAllIM(xim->owner);
return True;
}
