INPUT_RETURN_VALUE IMSelectorGetCand(void* arg, FcitxCandidateWord* candWord) { IMSelector* imselector = arg; FcitxInstance* instance = imselector->owner; if (!candWord->priv) { FcitxInstanceSetLocalIMName(instance, FcitxInstanceGetCurrentIC(instance), NULL); return IRV_CLEAN; } int index = FcitxInstanceGetIMIndexByName(imselector->owner, (char*) candWord->priv); if (index == 0) FcitxInstanceCloseIM(instance, FcitxInstanceGetCurrentIC(instance)); else { if (imselector->global) FcitxInstanceSwitchIMByIndex(instance, index); else FcitxInstanceSetLocalIMName(instance, FcitxInstanceGetCurrentIC(instance), (char*) candWord->priv); if (FcitxInstanceGetCurrentState(instance) != IS_ACTIVE) FcitxInstanceEnableIM(instance, FcitxInstanceGetCurrentIC(instance), false); } return IRV_CLEAN; }
void InputWindowMoveWindow(FcitxXlibWindow* window) { InputWindow* inputWindow = (InputWindow*) window; int x = 0, y = 0, w = 0, h = 0; FcitxInputContext* ic = FcitxInstanceGetCurrentIC(window->owner->owner); FcitxInstanceGetWindowRect(window->owner->owner, ic, &x, &y, &w, &h); FcitxRect rect = GetScreenGeometry(window->owner, x, y); int iTempInputWindowX, iTempInputWindowY; if (x < rect.x1) iTempInputWindowX = rect.x1; else iTempInputWindowX = x + inputWindow->iOffsetX; if (y < rect.y1) iTempInputWindowY = rect.y1; else iTempInputWindowY = y + h + inputWindow->iOffsetY; if ((iTempInputWindowX + window->width) > rect.x2) iTempInputWindowX = rect.x2 - window->width; if ((iTempInputWindowY + window->height) > rect.y2) { if (iTempInputWindowY > rect.y2) iTempInputWindowY = rect.y2 - window->height - 40; else /* better position the window */ iTempInputWindowY = iTempInputWindowY - window->height - ((h == 0)?40:h) - 2 * inputWindow->iOffsetY; } XMoveWindow(window->owner->dpy, window->wId, iTempInputWindowX, iTempInputWindowY); }
void FcitxUnikeyCommit(FcitxUnikey* unikey) { if (unikey->preeditstr->length() > 0) { FcitxInstanceCommitString(unikey->owner, FcitxInstanceGetCurrentIC(unikey->owner), unikey->preeditstr->c_str()); } FcitxUnikeyReset(unikey); }
INPUT_RETURN_VALUE IMSelectorClearLocal(void* arg) { IMSelector* imselector = arg; FcitxInstance* instance = imselector->owner; FcitxInstanceSetLocalIMName(instance, FcitxInstanceGetCurrentIC(instance), NULL); return IRV_CLEAN; }
INPUT_RETURN_VALUE FcitxRimeDoInputReal(void* arg, FcitxKeySym sym, unsigned int state) { FcitxRime *rime = (FcitxRime *)arg; if (rime->api->is_maintenance_mode()) { return IRV_TO_PROCESS; } if (!rime->api->find_session(rime->session_id)) { rime->session_id = rime->api->create_session(); } if (!rime->session_id) { // service disabled FcitxRimeUpdateStatus(rime); return IRV_TO_PROCESS; } boolean result = rime->api->process_key(rime->session_id, sym, state); RIME_STRUCT(RimeCommit, commit); if (rime->api->get_commit(rime->session_id, &commit)) { FcitxInputContext* ic = FcitxInstanceGetCurrentIC(rime->owner); FcitxInstanceCommitString(rime->owner, ic, commit.text); rime->api->free_commit(&commit); } FcitxRimeUpdateStatus(rime); if (!result) { FcitxRimeGetCandWords(rime); FcitxUIUpdateInputWindow(rime->owner); return IRV_TO_PROCESS; } else return IRV_DISPLAY_CANDWORDS; }
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; }
void FcitxKkcOnClose(void* arg, FcitxIMCloseEventType event) { FcitxKkc *kkc = (FcitxKkc*)arg; if (event == CET_LostFocus) { // TODO } else if (event == CET_ChangeByUser) { kkc_context_reset(kkc->context); } else if (event == CET_ChangeByInactivate) { KkcSegmentList* segments = kkc_context_get_segments(kkc->context); FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(kkc->owner); if (config->bSendTextWhenSwitchEng) { FcitxMessagesSetMessageCount(kkc->tempMsg, 0); if (kkc_segment_list_get_cursor_pos(segments) >= 0) { int i = 0; for (i = 0; i < kkc_segment_list_get_size(segments); i ++) { KkcSegment* segment = kkc_segment_list_get(segments, i); const gchar* str = kkc_segment_get_output(segment); FcitxMessagesAddMessageAtLast(kkc->tempMsg, MSG_INPUT, "%s", str); } } else { gchar* str = kkc_context_get_input(kkc->context); FcitxMessagesAddMessageAtLast(kkc->tempMsg, MSG_INPUT, "%s", str); g_free(str); } if (FcitxMessagesGetMessageCount(kkc->tempMsg) > 0) { char* commit = FcitxUIMessagesToCString(kkc->tempMsg); FcitxInstanceCommitString(kkc->owner, FcitxInstanceGetCurrentIC(kkc->owner), commit); free(commit); } } kkc_context_reset(kkc->context); } }
void FcitxNotificationItemGetToolTip(void* arg, DBusMessageIter* iter) { FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) arg; DBusMessageIter sub, ssub; char* iconNameToFree = NULL, *iconName, *title, *content; dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, 0, &sub); FcitxInputContext* ic = FcitxInstanceGetCurrentIC(notificationitem->owner); if (ic == NULL) { iconName = "input-keyboard"; title = _("No input window"); content = ""; } else { iconName = FcitxNotificationItemGetIconNameString(notificationitem); iconNameToFree = iconName; FcitxIM* im = FcitxInstanceGetCurrentIM(notificationitem->owner); title = im ? im->strName : _("Disabled"); content = im ? "" : _("Input Method Disabled"); } dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &iconName); dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "(iiay)", &ssub); dbus_message_iter_close_container(&sub, &ssub); dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &title); dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &content); dbus_message_iter_close_container(iter, &sub); fcitx_utils_free(iconNameToFree); }
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; }
FCITX_EXPORT_API void FcitxUIUpdateInputWindow(FcitxInstance *instance) { instance->uiflag |= UI_UPDATE; if (FcitxMessagesIsMessageChanged(instance->input->msgClientPreedit)) FcitxInstanceUpdatePreedit(instance, FcitxInstanceGetCurrentIC(instance)); }
static void CommitFirstCandidate(FcitxTablet* tablet) { char s[5]; // five chars should be plenty to hold a utf-8 char char* candidates = tablet->engineInstance->GetCandidates(tablet->engineData); int l = mblen(candidates, 10); memcpy(s, candidates, l); s[l] = '\0'; FcitxInstanceCommitString(tablet->fcitx, FcitxInstanceGetCurrentIC(tablet->fcitx), s); }
static void AutoEngCommit(FcitxAutoEngState *autoEngState) { FcitxInstance *instance = autoEngState->owner; FcitxInputContext *currentIC = FcitxInstanceGetCurrentIC(instance); FcitxInstanceCommitString(instance, currentIC, autoEngState->buf); AutoEngSetBuffLen(autoEngState, 0); }
void IMSelectorGetCands(IMSelector* imselector) { FcitxInstance* instance = imselector->owner; FcitxInputState *input = FcitxInstanceGetInputState(instance); UT_array* imes = FcitxInstanceGetIMEs(instance); FcitxInstanceCleanInputWindow(instance); FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input); FcitxCandidateWordSetPageSize(candList, 10); FcitxCandidateWordSetChoose(candList, DIGIT_STR_CHOOSE); FcitxInputStateSetShowCursor(input, false); FcitxCandidateWordSetOverrideDefaultHighlight(candList, false); FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical); FcitxIM* im = FcitxInstanceGetCurrentIM(instance); FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance); FcitxInputContext2* ic2 = (FcitxInputContext2*) ic; if (!ic) return; FcitxMessages *aux_up = FcitxInputStateGetAuxUp(input); FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS, imselector->global ? _("Select global input method: ") : _("Select local input method: ")); if (ic2->imname) { int idx = FcitxInstanceGetIMIndexByName(instance, ic2->imname); FcitxIM *im = fcitx_array_eltptr(imes, idx); if (im) { FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS, _("Current local input method is "), im->strName); } } else { FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS, _("No local input method")); } utarray_foreach(pim, imes, FcitxIM) { FcitxCandidateWord candWord; candWord.callback = IMSelectorGetCand; candWord.owner = imselector; candWord.strExtra = NULL; if (ic2->imname && strcmp(ic2->imname, pim->uniqueName) == 0) { candWord.priv = NULL; candWord.strWord = strdup(_("Clear local input method")); } else { candWord.priv = strdup(pim->uniqueName); candWord.strWord = strdup(pim->strName); } if (im && strcmp(im->uniqueName, pim->uniqueName) == 0) { candWord.wordType = MSG_CANDIATE_CURSOR; } else { candWord.wordType = MSG_OTHER; } FcitxCandidateWordAppend(candList, &candWord); }
static INPUT_RETURN_VALUE ClipboardCommitCallback(void *arg, FcitxCandidateWord *cand_word) { FcitxClipboard *clipboard = arg; FcitxInstance *instance = clipboard->owner; FcitxInstanceCommitString(instance, FcitxInstanceGetCurrentIC(instance), cand_word->priv); return IRV_FLAG_RESET_INPUT | IRV_FLAG_UPDATE_INPUT_WINDOW; }
static INPUT_RETURN_VALUE AutoEngPushKey(FcitxAutoEngState *autoEngState, char key) { INPUT_RETURN_VALUE res = IRV_DISPLAY_MESSAGE; if (autoEngState->auto_space) { if (AutoEngCheckAutoSpace(autoEngState, key)) { return res; } } if (autoEngState->config.maxKeep == 0) { if (key == ' ') { FcitxInstance *instance = autoEngState->owner; FcitxInputContext *currentIC = FcitxInstanceGetCurrentIC(instance); FcitxInstanceCommitString(instance, currentIC, autoEngState->buf); FcitxInstanceCommitString(instance, currentIC, " "); ResetAutoEng(autoEngState); return res | IRV_CLEAN; } } else if (autoEngState->config.maxKeep > 0) { char *found = autoEngState->buf + autoEngState->index; int i = autoEngState->config.maxKeep; do { found = memrchr(autoEngState->buf, ' ', found - autoEngState->buf); if (!found) { break; } } while (--i > 0); if (found && found != autoEngState->buf) { FcitxInstance *instance = autoEngState->owner; FcitxInputContext *currentIC = FcitxInstanceGetCurrentIC(instance); *found = '\0'; FcitxInstanceCommitString(instance, currentIC, autoEngState->buf); autoEngState->index = (autoEngState->buf + autoEngState->index - found); memmove(autoEngState->buf + 1, found + 1, autoEngState->index); *autoEngState->buf = ' '; } } autoEngState->buf[autoEngState->index++] = key; AutoEngSetBuffLen(autoEngState, autoEngState->index); return res; }
static void RemoteProcessEvent(void* p) { FcitxRemote* remote = (FcitxRemote*) p; unsigned int O; // lower 16bit 0->get 1->set, 2->reload, 3->toggle, 4->setIM int client_fd = UdAccept(remote->socket_fd); if (client_fd < 0) return; read(client_fd, &O, sizeof(int)); unsigned int cmd = O & 0xFFFF; unsigned int arg = (O >> 16) & 0xFFFF; switch (cmd) { /// {{{ case 0: SendIMState(remote, client_fd); break; case 1: /* arg is not state, due to backward compatible */ if (arg == 0) FcitxInstanceCloseIM(remote->owner, FcitxInstanceGetCurrentIC(remote->owner)); else { FcitxInstanceEnableIM(remote->owner, FcitxInstanceGetCurrentIC(remote->owner), false); } break; case 2: FcitxInstanceReloadConfig(remote->owner); break; case 3: FcitxInstanceChangeIMState(remote->owner, FcitxInstanceGetCurrentIC(remote->owner)); break; case 4: { char imname[MAX_IMNAME_LEN]; int n = read(client_fd, imname, MAX_IMNAME_LEN-1); imname[n] = '\0'; FcitxInstanceSwitchIMByName(remote->owner, imname); break; } default: break; /// }}} } close(client_fd); }
INPUT_RETURN_VALUE IMSelectorSelect(void* arg) { SelectorHandle* handle = arg; IMSelector* imselector = handle->imselector; FcitxInstance* instance = imselector->owner; FcitxIM* im = FcitxInstanceGetIMByIndex(instance, handle->idx); if (!im) return IRV_TO_PROCESS; if (handle->global) { FcitxInstanceSwitchIMByIndex(instance, handle->idx); } else { FcitxInstanceSetLocalIMName(instance, FcitxInstanceGetCurrentIC(instance), im->uniqueName); if (FcitxInstanceGetCurrentState(instance) != IS_ACTIVE) FcitxInstanceEnableIM(instance, FcitxInstanceGetCurrentIC(instance), false); } return IRV_CLEAN; }
INPUT_RETURN_VALUE FcitxThaiDoInput(void* arg, FcitxKeySym sym, unsigned int state) { FcitxThai* thai = (FcitxThai*) arg; struct thcell_t context_cell; struct thinpconv_t conv; tischar_t new_char; if ((state & (FcitxKeyState_Ctrl | FcitxKeyState_Alt)) || is_context_lost_key(sym)) { FcitxThaiForgetPrevChars(thai); return IRV_TO_PROCESS; } if (is_context_intact_key(sym)) { return IRV_TO_PROCESS; } new_char = keyval_to_tis(thai->config.kb_map, sym); if (0 == new_char) return IRV_TO_PROCESS; /* No correction -> just reject or commit */ if (!thai->config.do_correct) { thchar_t prev_char = FcitxThaiGetPrevChar(thai); if (!th_isaccept(prev_char, new_char, thai->config.isc_mode)) goto reject_char; return FcitxThaiCommitChars(thai, &new_char, 1); } FcitxThaiGetPrevCell(thai, &context_cell); if (!th_validate_leveled(context_cell, new_char, &conv, thai->config.isc_mode)) { goto reject_char; } if (conv.offset < 0) { FcitxInputContext* ic = FcitxInstanceGetCurrentIC(thai->owner); /* Can't correct context, just fall back to rejection */ if (!(ic->contextCaps & CAPACITY_SURROUNDING_TEXT)) goto reject_char; FcitxInstanceDeleteSurroundingText(thai->owner, ic, conv.offset, -conv.offset); } FcitxThaiForgetPrevChars(thai); FcitxThaiRememberPrevChars(thai, new_char); return FcitxThaiCommitChars(thai, conv.conv, strlen((char*)conv.conv)); reject_char: /* gdk_beep (); */ return true; }
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 FcitxNotificationItemGetIconName(void* arg, DBusMessageIter* iter) { FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) arg; FcitxInputContext* ic = FcitxInstanceGetCurrentIC(notificationitem->owner); if (ic == NULL) { const char* iconName = "input-keyboard"; dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &iconName); } else { char* iconName = FcitxNotificationItemGetIconNameString(notificationitem); dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &iconName); free(iconName); } }
Bool XIMCreateICHandler(FcitxXimFrontend* xim, IMChangeICStruct * call_data) { FcitxInstanceCreateIC(xim->owner, xim->frontendid, call_data); FcitxInputContext* ic = FcitxInstanceGetCurrentIC(xim->owner); if (ic == NULL) { ic = FcitxInstanceFindIC(xim->owner, xim->frontendid, &call_data->icid); if (FcitxInstanceSetCurrentIC(xim->owner, ic) && ic) FcitxUIOnInputFocus(xim->owner); } return True; }
void IMSelectorGetCands(IMSelector* imselector) { FcitxInstance* instance = imselector->owner; FcitxInputState *input = FcitxInstanceGetInputState(instance); FcitxIM* pim; UT_array* imes = FcitxInstanceGetIMEs(instance); FcitxInstanceCleanInputWindow(instance); FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), 10); FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE); FcitxInputStateSetShowCursor(input, false); FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance); FcitxInputContext2* ic2 = (FcitxInputContext2*) ic; if (!ic) return; FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, imselector->global ? _("Select global input method: ") : _("Select local input method: ")); if (ic2->imname) { int idx = FcitxInstanceGetIMIndexByName(instance, ic2->imname); FcitxIM* im = (FcitxIM*) utarray_eltptr(imes, idx); if (im) { FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, _("Current local input method is %s"), im->strName); } } else { FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, _("No local input method")); } for (pim = (FcitxIM *) utarray_front(imes); pim != NULL; pim = (FcitxIM *) utarray_next(imes, pim)) { FcitxCandidateWord candWord; candWord.callback = IMSelectorGetCand; candWord.owner = imselector; candWord.strExtra = NULL; if (ic2->imname && strcmp(ic2->imname, pim->uniqueName) == 0) { candWord.priv = NULL; candWord.strWord = strdup(_("Clear local input method")); } else { candWord.priv = strdup(pim->uniqueName); candWord.strWord = strdup(pim->strName); } candWord.wordType = MSG_OTHER; FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord); } }
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); } }
const char* FcitxNotificationItemGetLabel(FcitxNotificationItem* notificationitem) { const char* label = ""; #if 0 FcitxInputContext* ic = FcitxInstanceGetCurrentIC(notificationitem->owner); if (ic) { FcitxIM* im = FcitxInstanceGetCurrentIM(notificationitem->owner); if (im) { label = im->strName; } } #endif return label; }
void ResetPuncWhichStatus(void* arg) { FcitxPuncState* puncState = (FcitxPuncState*) arg; WidePunc *curPunc = puncState->curPunc; if (!curPunc) return; FcitxInputContext* ic = FcitxInstanceGetCurrentIC(puncState->owner); if (!ic) return; PuncWhich* puncWhich = FcitxInstanceGetICData(puncState->owner, ic, puncState->slot); fcitx_bitset_clear(puncWhich->bitset); }
static inline int GetPuncWhich(FcitxPuncState* puncState, WidePunc* punc) { FcitxInputContext* ic = FcitxInstanceGetCurrentIC(puncState->owner); if (!ic) return 0; PuncWhich* puncWhich = FcitxInstanceGetICData(puncState->owner, ic, puncState->slot); if (puncWhich->lastPunc != puncState->curPunc) { fcitx_bitset_clear(puncWhich->bitset); puncWhich->lastPunc = puncState->curPunc; } int result = fcitx_bitset_isset(puncWhich->bitset, punc->ASCII) ? 1 : 0; if (result >= punc->iCount) result = 0; return result; }
static inline void SetPuncWhich(FcitxPuncState* puncState, WidePunc* punc) { FcitxInputContext* ic = FcitxInstanceGetCurrentIC(puncState->owner); if (!ic) return; PuncWhich* puncWhich = FcitxInstanceGetICData(puncState->owner, ic, puncState->slot); FcitxBitSet* bitset = puncWhich->bitset; if (punc->iCount == 1) fcitx_bitset_unset(bitset, punc->ASCII); else { if (fcitx_bitset_isset(bitset, punc->ASCII)) fcitx_bitset_unset(bitset, punc->ASCII); else fcitx_bitset_set(bitset, punc->ASCII); } }
void SetTrackPos(FcitxXimFrontend* xim, FcitxInputContext* ic, IMChangeICStruct * call_data) { if (ic == NULL) return; int i; FcitxXimIC* ximic = GetXimIC(ic); if (call_data) { XICAttribute *pre_attr = ((IMChangeICStruct *) call_data)->preedit_attr; for (i = 0; i < (int)((IMChangeICStruct *) call_data)->preedit_attr_num; i++, pre_attr++) { if (!strcmp(XNSpotLocation, pre_attr->name)) { ximic->bHasCursorLocation = true; ximic->offset_x = (*(XPoint *) pre_attr->value).x; ximic->offset_y = (*(XPoint *) pre_attr->value).y; } } } Window window; if (!(window = ximic->focus_win)) window = ximic->client_win; if (window != None) { Window dst; XWindowAttributes attr; XGetWindowAttributes(xim->display, window, &attr); if (ximic->offset_x < 0 && ximic->offset_y < 0) { XTranslateCoordinates(xim->display, window, RootWindow(xim->display, xim->iScreen), 0, attr.height, &ic->offset_x, &ic->offset_y, &dst ); } else { XTranslateCoordinates(xim->display, window, RootWindow(xim->display, xim->iScreen), ximic->offset_x, ximic->offset_y, &ic->offset_x, &ic->offset_y, &dst); } } if (ic == FcitxInstanceGetCurrentIC(xim->owner)) FcitxUIMoveInputWindow(xim->owner); }
static int SimpleFrontendProcessKey(FcitxSimpleFrontend *simple, FcitxSimpleRequest *request) { FcitxInputState *input = FcitxInstanceGetInputState(simple->owner); if (simple->ic == NULL) simple->ic = FcitxInstanceCreateIC(simple->owner, simple->frontendid, NULL); FcitxInputContext* ic = FcitxInstanceGetCurrentIC(simple->owner); if (ic != simple->ic || ic->frontendid != simple->frontendid) { FcitxInstanceSetCurrentIC(simple->owner, simple->ic); FcitxUIOnInputFocus(simple->owner); } ic = simple->ic; FcitxKeySym sym; unsigned int state; state = request->state & FcitxKeyState_SimpleMask; state &= FcitxKeyState_UsedMask; FcitxHotkeyGetKey(request->key, state, &sym, &state); if (request->key == 0) return 0; //FcitxInstanceEnableIM(ipc->owner, ic, false); FcitxInputStateSetKeyCode(input, request->keycode); FcitxInputStateSetKeySym(input, request->key); FcitxInputStateSetKeyState(input, request->state); INPUT_RETURN_VALUE retVal = FcitxInstanceProcessKey(simple->owner, request->type == SE_KeyEventPress ? FCITX_PRESS_KEY : FCITX_RELEASE_KEY, 0, sym, state); FcitxInputStateSetKeyCode(input, 0); FcitxInputStateSetKeySym(input, 0); FcitxInputStateSetKeyState(input, 0); if (retVal & IRV_FLAG_FORWARD_KEY || retVal == IRV_TO_PROCESS) { return 0; } else { return 1; } }
const char* FcitxNotificationItemGetLabel(FcitxNotificationItem* notificationitem) { const char* label = ""; FcitxInputContext* ic = FcitxInstanceGetCurrentIC(notificationitem->owner); if (ic) { FcitxIM* im = FcitxInstanceGetCurrentIM(notificationitem->owner); if (im) { if (strncmp(im->uniqueName, "fcitx-keyboard-", strlen("fcitx-keyboard-")) == 0) { strncpy(notificationitem->layoutNameBuffer, im->uniqueName + strlen("fcitx-keyboard-"), 2); notificationitem->layoutNameBuffer[2] = '\0'; label = notificationitem->layoutNameBuffer; } } } return label; }