自学教程：C++ FcitxInstanceGetInputState函数代码示例

static void* LuaCallCommand(void* arg, FcitxModuleFunctionArg args) {    LuaModule *luamodule = (LuaModule *)arg;    UT_array *result = InputCommand(luamodule, (const char *)args.args[0]);    if (result) {        FcitxInputState* input = FcitxInstanceGetInputState(GetFcitx(luamodule));        LuaResultItem *p = NULL;        while ((p = (LuaResultItem *)utarray_next(result, p))) {            FcitxCandidateWord candWord;            if (args.args[1] && args.args[2]) {                candWord.callback = args.args[1];                candWord.owner = args.args[2];            }            else {                candWord.callback = LuaGetCandWord;                candWord.owner = luamodule;            }            candWord.priv = p->help ? strdup(p->help) : NULL;            if (p->help || p->tip) {                asprintf(&candWord.strExtra, "%s%s%s", p->help ? p->help : "", p->help && p->tip ? " " : "", p->tip ? p->tip : "");            } else {                candWord.strExtra = NULL;            }            candWord.strWord = strdup(p->result);            candWord.wordType = MSG_TIPS;            candWord.extraType = MSG_CODE;            FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);        }        utarray_free(result);    }    return NULL;}

void CloudPinyinAddCandidateWord(void* arg){    FcitxCloudPinyin* cloudpinyin = (FcitxCloudPinyin*) arg;    FcitxIM* im = FcitxInstanceGetCurrentIM(cloudpinyin->owner);    FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);    if (cloudpinyin->initialized == false)        return;    /* check whether the current im is pinyin */    if (CHECK_VALID_IM)    {        /* there is something pending input */        if (FcitxInputStateGetRawInputBufferSize(input) >= cloudpinyin->config.iMinimumPinyinLength)        {            char* strToFree = NULL, *inputString;            strToFree = GetCurrentString(cloudpinyin);            inputString = SplitHZAndPY(strToFree);            if (inputString)            {                CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, inputString);                FcitxLog(LOGLEVEL, "%s", inputString);                if (cacheEntry == NULL)                    CloudPinyinAddInputRequest(cloudpinyin, inputString);                _CloudPinyinAddCandidateWord(cloudpinyin, inputString);            }            if (strToFree)                free(strToFree);        }    }    return;}

INPUT_RETURN_VALUE QuickPhraseDoInput(void* arg, FcitxKeySym sym, int state){    QuickPhraseState *qpstate = (QuickPhraseState*) arg;    FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);    FcitxGlobalConfig* fc = FcitxInstanceGetGlobalConfig(qpstate->owner);    int retVal = IRV_TO_PROCESS;    const FcitxHotkey* hkPrevPage = FcitxInstanceGetContextHotkey(qpstate->owner, CONTEXT_ALTERNATIVE_PREVPAGE_KEY);    if (hkPrevPage == NULL)        hkPrevPage = fc->hkPrevPage;    const FcitxHotkey* hkNextPage = FcitxInstanceGetContextHotkey(qpstate->owner, CONTEXT_ALTERNATIVE_NEXTPAGE_KEY);    if (hkNextPage == NULL)        hkNextPage = fc->hkNextPage;    if (FcitxHotkeyIsHotKey(sym, state, hkPrevPage)) {        if (FcitxCandidateWordGoPrevPage(FcitxInputStateGetCandidateList(input)))            retVal = IRV_DISPLAY_MESSAGE;    } else if (FcitxHotkeyIsHotKey(sym, state, hkNextPage)) {        if (FcitxCandidateWordGoNextPage(FcitxInputStateGetCandidateList(input)))            retVal = IRV_DISPLAY_MESSAGE;    } else if (FcitxHotkeyIsHotKeyDigit(sym, state)) {        int iKey = FcitxHotkeyCheckChooseKey(sym, state, DIGIT_STR_CHOOSE);        if (iKey >= 0)            retVal = FcitxCandidateWordChooseByIndex(FcitxInputStateGetCandidateList(input), iKey);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {        if (FcitxCandidateWordPageCount(FcitxInputStateGetCandidateList(input)) != 0)            retVal = FcitxCandidateWordChooseByIndex(FcitxInputStateGetCandidateList(input), 0);    }    return retVal;}

INPUT_RETURN_VALUE QWGetCandWords(void *arg){    FcitxQWState* qwstate = (FcitxQWState*) arg;    FcitxInputState* input = FcitxInstanceGetInputState(qwstate->owner);    int             iQu, iWei;    int             i;    FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), 10);    FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);    if (FcitxInputStateGetRawInputBufferSize(input) == 3) {        iQu = (FcitxInputStateGetRawInputBuffer(input)[0] - '0') * 10 + FcitxInputStateGetRawInputBuffer(input)[1] - '0';        iWei = (FcitxInputStateGetRawInputBuffer(input)[2] - '0') * 10;        for (i = 0; i < 10; i++) {            FcitxCandidateWord candWord;            candWord.callback = QWGetCandWord;            candWord.owner = qwstate;            candWord.priv = NULL;            candWord.strExtra = NULL;            candWord.strWord = strdup(GetQuWei(qwstate, iQu, iWei + i + 1));            candWord.wordType = MSG_OTHER;            FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);        }    }    FcitxInputStateSetCursorPos(input, FcitxInputStateGetRawInputBufferSize(input));    FcitxMessagesSetMessageCount(FcitxInputStateGetPreedit(input), 0);    FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", FcitxInputStateGetRawInputBuffer(input));    return IRV_DISPLAY_CANDWORDS;}

void _CloudPinyinAddCandidateWord(FcitxCloudPinyin* cloudpinyin, const char* pinyin){    CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, pinyin);    FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);    FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);    int order = (cloudpinyin->config.iCandidateOrder <= 2) ?        1 : (cloudpinyin->config.iCandidateOrder - 1);    if (cacheEntry) {        FcitxCandidateWord* cand;        /* only check the first three page */        int pagesize = FcitxCandidateWordGetPageSize(candList);        int size = pagesize * CLOUDPINYIN_CHECK_PAGE_NUMBER;        int i;        if (cloudpinyin->config.iCandidateOrder <= 1) {            order = 0;        }        for (i = 0;i < size &&                 (cand = FcitxCandidateWordGetByTotalIndex(candList, i));i++) {            if (strcmp(cand->strWord, cacheEntry->str) == 0) {                if (i > order && i >= pagesize) {                    FcitxCandidateWordMoveByWord(candList, cand, order);                    if (order == 0) {                        CloudSetClientPreedit(cloudpinyin, cacheEntry->str);                    }                }                return;            }        }        if (order == 0) {            CloudSetClientPreedit(cloudpinyin, cacheEntry->str);        }    }    FcitxCandidateWord candWord;    CloudCandWord* cloudCand = fcitx_utils_malloc0(sizeof(CloudCandWord));    if (cacheEntry) {        cloudCand->filled = true;        cloudCand->timestamp = 0;        candWord.strWord = strdup(cacheEntry->str);    } else {        cloudCand->filled = false;        cloudCand->timestamp = CloudGetTimeStamp();        candWord.strWord = strdup("..");    }    candWord.callback = CloudPinyinGetCandWord;    candWord.owner = cloudpinyin;    candWord.priv = cloudCand;    candWord.wordType = MSG_TIPS;    if (cloudpinyin->config.bDontShowSource)        candWord.strExtra = NULL;    else {        candWord.strExtra = strdup(_(" (via cloud)"));        candWord.extraType = MSG_TIPS;    }    FcitxCandidateWordInsert(candList, &candWord, order);}

void XimUpdatePreedit(void* arg, FcitxInputContext* ic){    FcitxXimFrontend* xim = (FcitxXimFrontend*) arg;    FcitxInputState* input = FcitxInstanceGetInputState(xim->owner);    char* strPreedit = FcitxUIMessagesToCString(FcitxInputStateGetClientPreedit(input));    char* str = FcitxInstanceProcessOutputFilter(xim->owner, strPreedit);    if (str) {        free(strPreedit);        strPreedit = str;    }    if (strlen(strPreedit) == 0 && GetXimIC(ic)->bPreeditStarted == true) {        XimPreeditCallbackDraw(xim, GetXimIC(ic), strPreedit, 0);        XimPreeditCallbackDone(xim, GetXimIC(ic));        GetXimIC(ic)->bPreeditStarted = false;    }    if (strlen(strPreedit) != 0 && GetXimIC(ic)->bPreeditStarted == false) {        XimPreeditCallbackStart(xim, GetXimIC(ic));        GetXimIC(ic)->bPreeditStarted = true;    }    if (strlen(strPreedit) != 0) {        XimPreeditCallbackDraw(xim, GetXimIC(ic), strPreedit, FcitxInputStateGetClientCursorPos(input));    }    free(strPreedit);}

boolean IMSelectorPreFilter(void* arg, FcitxKeySym sym, unsigned int state, INPUT_RETURN_VALUE* retval){    IMSelector* imselector = arg;    FcitxInstance* instance = imselector->owner;    FcitxInputState *input = FcitxInstanceGetInputState(instance);    FcitxGlobalConfig* fc = FcitxInstanceGetGlobalConfig(instance);    if (!imselector->triggered)        return false;    FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);    if (FcitxHotkeyIsHotKey(sym, state,                            FcitxConfigPrevPageKey(instance, fc))) {        FcitxCandidateWordGoPrevPage(candList);        *retval = IRV_DISPLAY_MESSAGE;    } else if (FcitxHotkeyIsHotKey(sym, state,                                   FcitxConfigNextPageKey(instance, fc))) {        FcitxCandidateWordGoNextPage(candList);        *retval = IRV_DISPLAY_MESSAGE;    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {        if (FcitxCandidateWordPageCount(candList) != 0)            *retval = FcitxCandidateWordChooseByIndex(candList, 0);    } else if (FcitxHotkeyIsHotKeyDigit(sym, state)) {        int iKey = FcitxHotkeyCheckChooseKey(sym, state, DIGIT_STR_CHOOSE);        if (iKey >= 0)            *retval = FcitxCandidateWordChooseByIndex(candList, iKey);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {        *retval = IRV_CLEAN;    }    if (*retval == IRV_TO_PROCESS)        *retval = IRV_DO_NOTHING;    return true;}

// This function is called from within fcitx. It is called when the// list of input candidates has changed. It extracts the candidates// from the recognition engine and puts them into the format required// by fcitx for displaying in its popup windowINPUT_RETURN_VALUE FcitxTabletGetCandWords(void* arg) {	FcitxTablet* tablet = (FcitxTablet*) arg;	FcitxInputState *input = FcitxInstanceGetInputState(tablet->fcitx);	FcitxInstanceCleanInputWindow(tablet->fcitx);	char* c = tablet->engineInstance->GetCandidates(tablet->engineData);	int len = strlen(c);	int i = 0;	do {		int n = mblen(&c[i], len);		if(n <= 0) break;		FcitxCandidateWord cw;		cw.callback = FcitxTabletGetCandWord;		cw.strExtra = NULL;		cw.priv = NULL;		cw.owner = tablet;		cw.wordType = MSG_OTHER;		// TODO does fcitx free this?		cw.strWord = (char*) malloc(n+1);		memcpy(cw.strWord, &c[i], n);		cw.strWord[n] = 0;		FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &cw);		i += n;	} while(1);	return IRV_DISPLAY_CANDWORDS;}

INPUT_RETURN_VALUE UnicodeGetCandWord(void* arg, FcitxCandidateWord* candWord){    UnicodeModule* uni = arg;    FcitxInputState *input = FcitxInstanceGetInputState(uni->owner);    strcpy(FcitxInputStateGetOutputString(input), candWord->strWord);    return IRV_COMMIT_STRING;}

boolean PostInputProcessAutoEng(void* arg, FcitxKeySym sym, unsigned int state, INPUT_RETURN_VALUE* retval){    FcitxAutoEngState* autoEngState = (FcitxAutoEngState*) arg;    FcitxInputState* input = FcitxInstanceGetInputState(autoEngState->owner);    //boolean disableCheckUAZ = FcitxInstanceGetContextBoolean(autoEngState->owner, CONTEXT_DISABLE_AUTOENG);    //if (disableCheckUAZ)    //    return false;        if (autoEngState->enable == false)        return false;	FcitxIM *im = FcitxInstanceGetCurrentIM(autoEngState->owner);	if (im == NULL || strcmp("sogoupinyin", im->uniqueName) != 0)		return false;    if (FcitxHotkeyIsHotKeyUAZ(sym, state) &&        (FcitxInputStateGetRawInputBufferSize(input) != 0 ||         (FcitxInputStateGetKeyState(input) & FcitxKeyState_CapsLock) == 0) &&        AutoEngCheckPreedit(autoEngState)) {        AutoEngSetBuff(autoEngState, FcitxInputStateGetRawInputBuffer(input),                       FcitxHotkeyPadToMain(sym));        AutoEngActivate(autoEngState, input, retval);        return true;    }    return false;}

INPUT_RETURN_VALUE UnicodeGetCandWords(UnicodeModule* uni){    FcitxInputState *input = FcitxInstanceGetInputState(uni->owner);    FcitxInstanceCleanInputWindow(uni->owner);    FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetPreedit(input),                                         MSG_INPUT, uni->buffer);    FcitxInputStateSetShowCursor(input, true);    FcitxInputStateSetCursorPos(input, strlen(uni->buffer));    FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);    FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical);    UT_array* result = CharSelectDataFind(uni->charselectdata, uni->buffer);    utarray_foreach(c, result, uint32_t) {        char* s = fcitx_utils_malloc0(sizeof(char) * (UTF8_MAX_LENGTH + 1));        fcitx_ucs4_to_utf8(*c, s);        FcitxCandidateWord candWord;        candWord.callback = UnicodeGetCandWord;        candWord.owner = uni;        candWord.priv = NULL;        candWord.extraType = MSG_OTHER;        candWord.wordType = MSG_CODE;        candWord.strWord = s;        char* name = CharSelectDataName(uni->charselectdata, *c);        fcitx_utils_alloc_cat_str(candWord.strExtra, " ", name);        free(name);        FcitxCandidateWordAppend(candList, &candWord);    }

INPUT_RETURN_VALUE QuickPhraseGetCandWord(void* arg, FcitxCandidateWord* candWord){    QuickPhraseState *qpstate = (QuickPhraseState*) arg;    QuickPhraseCand* qpcand = candWord->priv;    FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);    strcpy(FcitxInputStateGetOutputString(input), qpcand->cand->strPhrase);    return IRV_COMMIT_STRING;}

INPUT_RETURN_VALUE FcitxKkcDoInput(void* arg, FcitxKeySym _sym, unsigned int _state){    FcitxKkc *kkc = (FcitxKkc*)arg;    FcitxInputState* input = FcitxInstanceGetInputState(kkc->owner);    FcitxKeySym sym = (FcitxKeySym) FcitxInputStateGetKeySym(input);    uint32_t state = FcitxInputStateGetKeyState(input);    return FcitxKkcDoInputReal(arg, sym, state);}

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);    }

void ShowQuickPhraseMessage(QuickPhraseState *qpstate){    FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);    FcitxInputStateSetCursorPos(input, strlen(FcitxInputStateGetRawInputBuffer(input)));    FcitxInstanceCleanInputWindowUp(qpstate->owner);    FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, "%s", _("Quick Phrase: "));    FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", FcitxInputStateGetRawInputBuffer(input));    FcitxMessagesAddMessageAtLast(FcitxInputStateGetClientPreedit(input), MSG_INPUT, "%s", FcitxInputStateGetRawInputBuffer(input));}

INPUT_RETURN_VALUE QWGetCandWord(void *arg, FcitxCandidateWord* candWord){    FcitxQWState* qwstate = (FcitxQWState*) arg;    FcitxInputState* input = FcitxInstanceGetInputState(qwstate->owner);    strcpy(FcitxInputStateGetOutputString(input),           candWord->strWord);    return IRV_COMMIT_STRING;}

/** * @brief initialize the extra input method * * @param arg * @return successful or not **/__EXPORT_APIvoid* FcitxChewingCreate(FcitxInstance* instance){    if (GetFcitxChewingConfigDesc() == NULL)        return NULL;        char* user_path = NULL;    FILE* fp = FcitxXDGGetFileUserWithPrefix("chewing", ".place_holder", "w", NULL);    if (fp)        fclose(fp);    FcitxXDGGetFileUserWithPrefix("chewing", "", NULL, &user_path);    FcitxLog(INFO, "Chewing storage path %s", user_path);    if (0 == chewing_Init(CHEWING_DATADIR, user_path)) {        FcitxLog(DEBUG, "chewing init ok");    } else {        FcitxLog(DEBUG, "chewing init failed");        return NULL;    }        FcitxChewing* chewing = (FcitxChewing*) fcitx_utils_malloc0(sizeof(FcitxChewing));    FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);    FcitxInputState *input = FcitxInstanceGetInputState(instance);    FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);        bindtextdomain("fcitx-chewing", LOCALEDIR);    chewing->context = chewing_new();    ChewingContext * c = chewing->context;    chewing->owner = instance;    chewing_set_ChiEngMode(c, CHINESE_MODE);    chewing_set_maxChiSymbolLen(c, 16);    // chewing will crash without set page    chewing_set_candPerPage(c, config->iMaxCandWord);    FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);    chewing_set_selKey(c, selKey, 10);    LoadChewingConfig(&chewing->config);    ConfigChewing(chewing);    FcitxInstanceRegisterIM(        instance,        chewing,        "chewing",        _("Chewing"),        "chewing",        FcitxChewingInit,        FcitxChewingReset,        FcitxChewingDoInput,        FcitxChewingGetCandWords,        NULL,        NULL,        FcitxChewingReloadConfig,        NULL,        1,        "zh_TW"    );    return chewing;}

static INPUT_RETURN_VALUELuaGetCandWord(void *arg, FcitxCandidateWord *candWord){    FCITX_UNUSED(arg);    LuaModule *luamodule = (LuaModule*)candWord->owner;    FcitxInputState *input = FcitxInstanceGetInputState(GetFcitx(luamodule));    strncpy(FcitxInputStateGetOutputString(input),            candWord->strWord, MAX_USER_INPUT);    return IRV_COMMIT_STRING;}

/** * @brief sunpinyin called this function while commit the string * * @param str committed string * @return void **/void FcitxWindowHandler::commit(const TWCHAR* str){    FcitxInstance* instance = owner->owner;    FcitxInputState* input = FcitxInstanceGetInputState(instance);    char *buf_ = FcitxInputStateGetOutputString(input);    memset(buf_, 0, MAX_USER_INPUT);    WCSTOMBS(buf_, str, MAX_USER_INPUT);    commit_flag = true;    FcitxInputStateSetCursorPos(input, false);}

static boolean PreInputProcessAutoEng(void* arg, FcitxKeySym sym,                                      unsigned int state,                                      INPUT_RETURN_VALUE *retval){    FcitxAutoEngState *autoEngState = (FcitxAutoEngState*)arg;    FcitxInputState *input = FcitxInstanceGetInputState(autoEngState->owner);    //boolean disableCheckUAZ = FcitxInstanceGetContextBoolean(    //    autoEngState->owner, CONTEXT_DISABLE_AUTOENG);    //if (disableCheckUAZ)    //    return false;    if (autoEngState->enable == false)        return false;		FcitxIM *im = FcitxInstanceGetCurrentIM(autoEngState->owner);	if (im == NULL || strcmp("sogoupinyin", im->uniqueName) != 0)		return false;    FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);    if (!autoEngState->active) {        if (FcitxHotkeyIsHotKeySimple(sym, state)) {            AutoEngSetBuff(autoEngState,                           FcitxInputStateGetRawInputBuffer(input), keymain);            if (SwitchToEng(autoEngState, autoEngState->buf)) {                AutoEngActivate(autoEngState, input, retval);                return true;            }        }        return false;    }    if ((*retval = AutoEngCheckSelect(autoEngState, sym, state))) {        return true;    } else if (FcitxHotkeyIsHotKeySimple(keymain, state)) {        *retval = AutoEngPushKey(autoEngState, keymain);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {        AutoEngSetBuffLen(autoEngState, --autoEngState->index);        if (autoEngState->index == 0) {            ResetAutoEng(autoEngState);            *retval = IRV_CLEAN;        } else {            *retval = IRV_DISPLAY_MESSAGE;        }    } else if (FcitxHotkeyIsHotkeyCursorMove(sym, state)) {        *retval = IRV_DO_NOTHING;        return true;    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {        AutoEngCommit(autoEngState);        ResetAutoEng(autoEngState);        *retval = IRV_FLAG_UPDATE_INPUT_WINDOW | IRV_FLAG_RESET_INPUT;    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {        *retval = IRV_CLEAN;        return true;    }    ShowAutoEngMessage(autoEngState, retval);    return true;}

static INPUT_RETURN_VALUEAutoEngCheckSelect(FcitxAutoEngState *autoEngState,                   FcitxKeySym sym, unsigned int state){    FcitxCandidateWordList *candList = FcitxInputStateGetCandidateList(        FcitxInstanceGetInputState(autoEngState->owner));    int iKey = FcitxCandidateWordCheckChooseKey(candList, sym, state);    if (iKey >= 0)        return FcitxCandidateWordChooseByIndex(candList, iKey);    return 0;}

static booleanAutoEngCheckPreedit(FcitxAutoEngState *autoEngState){    FcitxInputState *input;    char *preedit;    input = FcitxInstanceGetInputState(autoEngState->owner);    preedit = FcitxUIMessagesToCString(FcitxInputStateGetPreedit(input));    boolean res = !(preedit && *fcitx_utils_get_ascii_end(preedit));    free(preedit);    return res;}

/** * @brief Process Key Input and return the status * * @param keycode keycode from XKeyEvent * @param state state from XKeyEvent * @param count count from XKeyEvent * @return INPUT_RETURN_VALUE **/__EXPORT_APIINPUT_RETURN_VALUE FcitxChewingDoInput(void* arg, FcitxKeySym sym, unsigned int state){    FcitxChewing* chewing = (FcitxChewing*) arg;    FcitxInputState *input = FcitxInstanceGetInputState(chewing->owner);    ChewingContext * c = chewing->context;    if (FcitxCandidateWordGetListSize(FcitxInputStateGetCandidateList(input)) > 0        && (FcitxHotkeyIsHotKeyDigit(sym, state) || FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT) || FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT)))        return IRV_TO_PROCESS;    if (FcitxHotkeyIsHotKeySimple(sym, state)) {        int scan_code = (int) sym & 0xff;        chewing_handle_Default(c, scan_code);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {        chewing_handle_Backspace(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {        chewing_handle_Esc(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_DELETE)) {        chewing_handle_Del(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {        chewing_handle_Space(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_UP)) {        chewing_handle_Up(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_DOWN)) {        chewing_handle_Down(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGUP)) {        chewing_handle_PageDown(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGDN)) {        chewing_handle_PageUp(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT)) {        chewing_handle_Right(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT)) {        chewing_handle_Left(c);    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {        chewing_handle_Enter(c);    } else if (state == FcitxKeyState_Ctrl && FcitxHotkeyIsHotKeyDigit(sym, FcitxKeyState_None)) {        chewing_handle_CtrlNum(c, sym);    } else {        // to do: more chewing_handle        return IRV_TO_PROCESS;    }    if (chewing_keystroke_CheckAbsorb(c)) {        return IRV_DISPLAY_CANDWORDS;    } else if (chewing_keystroke_CheckIgnore(c)) {        return IRV_TO_PROCESS;    } else if (chewing_commit_Check(c)) {        char* str = chewing_commit_String(c);        strcpy(FcitxInputStateGetOutputString(input), str);        chewing_free(str);        return IRV_COMMIT_STRING;    } else        return IRV_DISPLAY_CANDWORDS;}

void _CloudPinyinAddCandidateWord(FcitxCloudPinyin* cloudpinyin, const char* pinyin){    CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, pinyin);    FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);    struct _FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);        if (cacheEntry) {        FcitxCandidateWord* cand;        /* only check the first three page */        int size = FcitxCandidateWordGetPageSize(candList) * CLOUDPINYIN_CHECK_PAGE_NUMBER;        int i = 0;        for (cand = FcitxCandidateWordGetFirst(FcitxInputStateGetCandidateList(input));             cand != NULL;             cand = FcitxCandidateWordGetNext(FcitxInputStateGetCandidateList(input), cand))        {            if (strcmp(cand->strWord, cacheEntry->str) == 0)                return;            i ++;            if (i >= size)                break;        }    }    FcitxCandidateWord candWord;    CloudCandWord* cloudCand = fcitx_utils_malloc0(sizeof(CloudCandWord));    if (cacheEntry)    {        cloudCand->filled = true;        candWord.strWord = strdup(cacheEntry->str);    }    else    {        cloudCand->filled = false;        candWord.strWord = strdup("..");    }    candWord.callback = CloudPinyinGetCandWord;    candWord.owner = cloudpinyin;    candWord.priv = cloudCand;    candWord.wordType = MSG_TIPS;    if (cloudpinyin->config.bDontShowSource)        candWord.strExtra = NULL;    else {        candWord.strExtra = strdup(_(" (via cloud)"));        candWord.extraType = MSG_TIPS;    }    int order = cloudpinyin->config.iCandidateOrder - 1;    if (order < 0)        order = 0;    FcitxCandidateWordInsert(candList, &candWord, order);}

void CloudPinyinFillCandidateWord(FcitxCloudPinyin* cloudpinyin, const char* pinyin){    CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, pinyin);    FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);    struct _FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);    if (cacheEntry)    {        FcitxCandidateWord* candWord;        for (candWord = FcitxCandidateWordGetFirst(candList);             candWord != NULL;             candWord = FcitxCandidateWordGetNext(candList, candWord))        {            if (candWord->owner == cloudpinyin)                break;        }        if (candWord == NULL)            return;        CloudCandWord* cloudCand = candWord->priv;        if (cloudCand->filled)            return;        FcitxCandidateWord* cand;        int i = 0;        int size = FcitxCandidateWordGetPageSize(candList) * CLOUDPINYIN_CHECK_PAGE_NUMBER;        for (cand = FcitxCandidateWordGetFirst(candList);             cand != NULL;             cand = FcitxCandidateWordGetNext(candList, cand))        {            if (strcmp(cand->strWord, cacheEntry->str) == 0) {                FcitxCandidateWordRemove(candList, candWord);                FcitxUIUpdateInputWindow(cloudpinyin->owner);                candWord = NULL;                break;            }            i ++;            if (i >= size)                break;        }                if (candWord)        {            if (cloudCand->filled == false)            {                cloudCand->filled = true;                free(candWord->strWord);                candWord->strWord = strdup(cacheEntry->str);                FcitxUIUpdateInputWindow(cloudpinyin->owner);            }        }    }}

void LuaUpdateCandidateWordHookCallback(void *arg) {    LuaModule *luamodule = (LuaModule *)arg;    FcitxInputState* input = FcitxInstanceGetInputState(GetFcitx(luamodule));    char *text = FcitxInputStateGetRawInputBuffer(input);    UT_array *result = InputTrigger(luamodule, text);    if (result) {        LuaResultItem *p;        while ((p = (LuaResultItem *)utarray_next(result, p))) {            AddToCandList(luamodule, text, p->result);        }        utarray_free(result);    }}

void AddToCandList(LuaModule *luamodule, const char *in, const char *out) {    FcitxCandidateWord candWord;    candWord.callback = LuaGetCandWord;    candWord.owner = luamodule;    candWord.priv = NULL;    candWord.wordType = MSG_TIPS;    candWord.strExtra = NULL;    candWord.strWord = strdup(out);    FcitxInputState* input = FcitxInstanceGetInputState(GetFcitx(luamodule));    FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);    FcitxCandidateWordInsert(candList, &candWord, 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);    }}

boolean QuickPhrasePreFilter(void *arg, FcitxKeySym sym,                             unsigned int state,                             INPUT_RETURN_VALUE *retval){    QuickPhraseState *qpstate = (QuickPhraseState*) arg;    FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);    if (!qpstate->enabled)        return false;    char c[2];    QuickPhraseFillKeyString(qpstate, c);    FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);    *retval = QuickPhraseDoInput(qpstate, keymain, state);    if (*retval != IRV_TO_PROCESS)        return true;    if (FcitxHotkeyIsHotKeySimple(keymain, state)) {        if (c[0] && strlen(qpstate->buffer) == 0 &&            ((qpstate->useDupKeyInput &&              FcitxHotkeyIsHotKey(keymain, state, qpstate->curTriggerKey)) ||             FcitxHotkeyIsHotKey(keymain, state, FCITX_SPACE))) {            int s = qpstate->curTriggerKey[0].sym;            char *strTemp = FcitxPuncGetPunc(qpstate->owner, &s);            strcpy(FcitxInputStateGetOutputString(input), strTemp ? strTemp : c);            *retval = IRV_COMMIT_STRING;        } else {            char buf[2];            buf[0] = keymain;            buf[1] = '/0';            if (strlen(qpstate->buffer) < MAX_USER_INPUT)                strcat(qpstate->buffer, buf);            ShowQuickPhraseMessage(qpstate);            *retval = QuickPhraseGetCandWords(qpstate);        }    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {        size_t len = strlen(qpstate->buffer);        if (len > 0)            qpstate->buffer[--len] = '/0';        if (len == 0) {            *retval = IRV_CLEAN;        } else {            ShowQuickPhraseMessage(qpstate);            *retval = QuickPhraseGetCandWords(qpstate);        }    } else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {        size_t len = strlen(qpstate->buffer);        if (len > 0) {            if (qpstate->append) {                fcitx_utils_cat_str(FcitxInputStateGetOutputString(input),                                    2, (const char*[]){c, qpstate->buffer},                                    (size_t[]){strlen(c), len});            } else {