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 window
INPUT_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_API
void* 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_VALUE
LuaGetCandWord(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_VALUE
AutoEngCheckSelect(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 boolean
AutoEngCheckPreedit(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_API
INPUT_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;
}
/**
* @brief handler called while preedit updated
*
* @param ppd preedit string
* @return void
**/
void FcitxWindowHandler::updatePreedit(const IPreeditString* ppd)
{
FcitxInstance* instance = owner->owner;
FcitxInputState* input = FcitxInstanceGetInputState(instance);
FcitxInputStateSetCursorPos(input, true);
candidate_flag = true;
const wstring& codeinput = this->owner->view->getPySegmentor()->getInputBuffer();
WCSTOMBS(FcitxInputStateGetRawInputBuffer(input), codeinput.c_str(), MAX_USER_INPUT);
FcitxInputStateSetRawInputBufferSize(input, strlen(FcitxInputStateGetRawInputBuffer(input)));
}
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 {