Esempio n. 1
0
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;
}
Esempio n. 2
0
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);
}
Esempio n. 3
0
void FcitxUnikeyCommit(FcitxUnikey* unikey)
{
    if (unikey->preeditstr->length() > 0) {
        FcitxInstanceCommitString(unikey->owner, FcitxInstanceGetCurrentIC(unikey->owner), unikey->preeditstr->c_str());
    }
    FcitxUnikeyReset(unikey);
}
Esempio n. 4
0
INPUT_RETURN_VALUE IMSelectorClearLocal(void* arg)
{
    IMSelector* imselector = arg;
    FcitxInstance* instance = imselector->owner;
    FcitxInstanceSetLocalIMName(instance, FcitxInstanceGetCurrentIC(instance), NULL);
    return IRV_CLEAN;
}
Esempio n. 5
0
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;
}
Esempio n. 6
0
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;
}
Esempio n. 7
0
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);
    }
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
File: ui.c Progetto: pkg-ime/fcitx
FCITX_EXPORT_API
void FcitxUIUpdateInputWindow(FcitxInstance *instance)
{
    instance->uiflag |= UI_UPDATE;

    if (FcitxMessagesIsMessageChanged(instance->input->msgClientPreedit))
        FcitxInstanceUpdatePreedit(instance, FcitxInstanceGetCurrentIC(instance));
}
Esempio n. 11
0
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);
}
Esempio n. 12
0
static void
AutoEngCommit(FcitxAutoEngState *autoEngState)
{
    FcitxInstance *instance = autoEngState->owner;
    FcitxInputContext *currentIC = FcitxInstanceGetCurrentIC(instance);
    FcitxInstanceCommitString(instance, currentIC, autoEngState->buf);
    AutoEngSetBuffLen(autoEngState, 0);
}
Esempio n. 13
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);
    }
Esempio n. 14
0
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;
}
Esempio n. 15
0
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;
}
Esempio n. 16
0
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);
}
Esempio n. 17
0
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;
}
Esempio n. 18
0
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;
}
Esempio n. 19
0
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;
}
Esempio n. 20
0
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);
    }
}
Esempio n. 21
0
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;
}
Esempio n. 22
0
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);
    }
}
Esempio n. 23
0
File: vk.c Progetto: areslp/fcitx
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);
    }
}
Esempio n. 24
0
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;
}
Esempio n. 25
0
File: punc.c Progetto: adaptee/fcitx
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);
}
Esempio n. 26
0
File: punc.c Progetto: adaptee/fcitx
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;
}
Esempio n. 27
0
File: punc.c Progetto: adaptee/fcitx
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);
    }
}
Esempio n. 28
0
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);
}
Esempio n. 29
0
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;
    }
}
Esempio n. 30
0
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;
}