void QuickPhraseFillKeyString(QuickPhraseState* qpstate, char c[2])
{
c[1] = 0;
if (qpstate->curTriggerKey[0].state != FcitxKeyState_None)
c[0] = 0;
else {
if (!FcitxHotkeyIsHotKeySimple(qpstate->curTriggerKey[0].sym, 0))
c[0] = 0;
else {
c[0] = (qpstate->curTriggerKey[0].sym & 0xff);
}
}
}
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 {
INPUT_RETURN_VALUE DoVKInput(FcitxVKState* vkstate, KeySym sym, int state)
{
char *pstr = NULL;
FcitxInputState *input = FcitxInstanceGetInputState(vkstate->owner);
if (FcitxHotkeyIsHotKeySimple(sym, state))
pstr = VKGetSymbol(vkstate, sym);
if (!pstr)
return IRV_TO_PROCESS;
else {
strcpy(FcitxInputStateGetOutputString(input), pstr);
return IRV_COMMIT_STRING;
}
}
boolean FullWidthPostFilter(void* arg, FcitxKeySym sym,
unsigned int state,
INPUT_RETURN_VALUE *retval
)
{
FcitxFullWidthChar* fwchar = (FcitxFullWidthChar*)arg;
FcitxProfile* profile = FcitxInstanceGetProfile(fwchar->owner);
if (*retval != IRV_TO_PROCESS)
return false;
if (profile->bUseFullWidthChar && FcitxHotkeyIsHotKeySimple(sym, state)) {
sprintf(FcitxInputStateGetOutputString(FcitxInstanceGetInputState(fwchar->owner)), "%s", sCornerTrans[sym - 32]);
*retval = IRV_COMMIT_STRING;
return true;
}
return false;
}
boolean UnicodePreFilter(void* arg, FcitxKeySym sym, unsigned int state,
INPUT_RETURN_VALUE *r)
{
INPUT_RETURN_VALUE retVal = IRV_TO_PROCESS;
do {
UnicodeModule *uni = arg;
if (!uni->enable) {
return false;
}
FcitxInstance *instance = uni->owner;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxGlobalConfig *fc = FcitxInstanceGetGlobalConfig(instance);
FcitxCandidateWordList *candList;
FcitxCandidateWord *candWord;
candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetPageSize(candList, fc->iMaxCandWord);
FcitxCandidateWordSetChooseAndModifier(candList, DIGIT_STR_CHOOSE,
FcitxKeyState_Alt);
if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigPrevPageKey(instance, fc))) {
if (FcitxCandidateWordGoPrevPage(candList))
retVal = IRV_DISPLAY_MESSAGE;
else
retVal = IRV_DO_NOTHING;
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigNextPageKey(instance, fc))) {
if (FcitxCandidateWordGoNextPage(candList))
retVal = IRV_DISPLAY_MESSAGE;
else
retVal = IRV_DO_NOTHING;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
size_t len = strlen(uni->buffer);
if (len > 0)
uni->buffer[--len] = '\0';
if (len == 0) {
retVal = IRV_CLEAN;
} else {
retVal = UnicodeGetCandWords(uni);
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
retVal = IRV_CLEAN;
} else if (FcitxHotkeyIsHotKey(sym, state, fc->nextWord)) {
candWord = FcitxCandidateWordGetFocus(candList, true);
candWord = FcitxCandidateWordGetNext(candList, candWord);
if (!candWord) {
FcitxCandidateWordSetPage(candList, 0);
candWord = FcitxCandidateWordGetFirst(candList);
} else {
FcitxCandidateWordSetFocus(
candList, FcitxCandidateWordGetIndex(candList, candWord));
}
if (candWord) {
FcitxCandidateWordSetType(candWord, MSG_CANDIATE_CURSOR);
retVal = IRV_FLAG_UPDATE_INPUT_WINDOW;
}
} else if (FcitxHotkeyIsHotKey(sym, state, fc->prevWord)) {
candWord = FcitxCandidateWordGetFocus(candList, true);
candWord = FcitxCandidateWordGetPrev(candList, candWord);
if (!candWord) {
FcitxCandidateWordSetPage(
candList, FcitxCandidateWordPageCount(candList) - 1);
candWord = FcitxCandidateWordGetLast(candList);
} else {
FcitxCandidateWordSetFocus(
candList, FcitxCandidateWordGetIndex(candList, candWord));
}
if (candWord) {
FcitxCandidateWordSetType(candWord, MSG_CANDIATE_CURSOR);
retVal = IRV_FLAG_UPDATE_INPUT_WINDOW;
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
candWord = FcitxCandidateWordGetFocus(candList, true);
if (candWord) {
retVal = FcitxCandidateWordChooseByTotalIndex(
candList, FcitxCandidateWordGetIndex(candList, candWord));
}
}
if (retVal == IRV_TO_PROCESS) {
int index = FcitxCandidateWordCheckChooseKey(candList, sym, state);
if (index >= 0)
retVal = FcitxCandidateWordChooseByIndex(candList, index);
}
FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);
if (retVal == IRV_TO_PROCESS && FcitxHotkeyIsHotKeySimple(keymain, state)) {
char buf[2];
buf[0] = keymain;
buf[1] = '\0';
if (strlen(uni->buffer) < MAX_USER_INPUT)
strcat(uni->buffer, buf);
retVal = UnicodeGetCandWords(uni);
}
} while(0);
if (retVal == IRV_TO_PROCESS) {
retVal = IRV_DO_NOTHING;
}
*r = retVal;
return true;
}
/**
* @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 FcitxLibpinyinDoInput(void* arg, FcitxKeySym sym, unsigned int state)
{
FcitxLibpinyin* libpinyin = (FcitxLibpinyin*) arg;
FcitxLibpinyinConfig* config = &libpinyin->owner->config;
FcitxInputState* input = FcitxInstanceGetInputState(libpinyin->owner->owner);
if (FcitxHotkeyIsHotKeySimple(sym, state))
{
/* there is some special case that ';' is used */
if (FcitxHotkeyIsHotKeyLAZ(sym, state)
|| sym == '\''
|| (FcitxHotkeyIsHotKey(sym, state, FCITX_SEMICOLON) && libpinyin->type == LPT_Shuangpin && (config->spScheme == FCITX_SHUANG_PIN_MS || config->spScheme == FCITX_SHUANG_PIN_ZIGUANG))
|| (libpinyin->type == LPT_Zhuyin && LibpinyinCheckZhuyinKey(sym, config->zhuyinLayout, config->useTone))
)
{
if (strlen(libpinyin->buf) == 0 && (sym == '\'' || sym == ';'))
return IRV_TO_PROCESS;
if (strlen(libpinyin->buf) < MAX_PINYIN_INPUT)
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->buf[libpinyin->cursor_pos] != 0)
{
memmove(libpinyin->buf + libpinyin->cursor_pos + 1, libpinyin->buf + libpinyin->cursor_pos, len - libpinyin->cursor_pos);
}
libpinyin->buf[len + 1] = 0;
libpinyin->buf[libpinyin->cursor_pos] = (char) (sym & 0xff);
libpinyin->cursor_pos ++;
size_t parselen = FcitxLibpinyinParse(libpinyin, libpinyin->buf);
if (parselen == 0 && strlen(libpinyin->buf) == 1 && libpinyin->type != LPT_Shuangpin
&& !(libpinyin->type == LPT_Pinyin && !libpinyin->owner->config.incomplete)
&& !(libpinyin->type == LPT_Zhuyin && !libpinyin->owner->config.chewingIncomplete))
{
FcitxLibpinyinReset(libpinyin);
return IRV_TO_PROCESS;
}
return IRV_DISPLAY_CANDWORDS;
}
else
return IRV_DO_NOTHING;
}
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)
|| (libpinyin->type == LPT_Zhuyin && FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)))
{
size_t len = strlen(libpinyin->buf);
if (len == 0)
return IRV_TO_PROCESS;
return FcitxCandidateWordChooseByIndex(FcitxInputStateGetCandidateList(input), 0);
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_LIBPINYIN_SHIFT_ENTER)) {
size_t len = strlen(libpinyin->buf);
if (len == 0)
return IRV_TO_PROCESS;
strcpy(FcitxInputStateGetOutputString(input), libpinyin->buf);
return IRV_COMMIT_STRING;
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE) || FcitxHotkeyIsHotKey(sym, state, FCITX_DELETE))
{
if (strlen(libpinyin->buf) > 0)
{
int offset = LibpinyinGetOffset(libpinyin);
if (offset != 0 && FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE))
{
g_array_remove_index_fast(libpinyin->fixed_string, libpinyin->fixed_string->len - 1);
pinyin_clear_constraint(libpinyin->inst, LibpinyinGetOffset(libpinyin));
}
else
{
if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE))
{
if (libpinyin->cursor_pos > 0)
libpinyin->cursor_pos -- ;
else
return IRV_DO_NOTHING;
}
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos == (int)len)
return IRV_DO_NOTHING;
memmove(libpinyin->buf + libpinyin->cursor_pos, libpinyin->buf + libpinyin->cursor_pos + 1, len - libpinyin->cursor_pos - 1);
libpinyin->buf[strlen(libpinyin->buf) - 1] = 0;
if (libpinyin->buf[0] == '\0')
return IRV_CLEAN;
else
FcitxLibpinyinParse(libpinyin, libpinyin->buf);
}
return IRV_DISPLAY_CANDWORDS;
}
else
return IRV_TO_PROCESS;
}
else
{
if (strlen(libpinyin->buf) > 0)
{
if (FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT))
{
if (libpinyin->cursor_pos > 0)
{
if ( libpinyin->cursor_pos == LibpinyinGetPinyinOffset(libpinyin))
{
g_array_remove_index_fast(libpinyin->fixed_string, libpinyin->fixed_string->len - 1);
pinyin_clear_constraint(libpinyin->inst, LibpinyinGetOffset(libpinyin));
return IRV_DISPLAY_CANDWORDS;
}
else
{
libpinyin->cursor_pos--;
return IRV_DISPLAY_CANDWORDS;
}
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT))
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos < (int) len)
{
libpinyin->cursor_pos ++ ;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_HOME))
{
int offset = LibpinyinGetPinyinOffset(libpinyin);
if ( libpinyin->cursor_pos != offset)
{
libpinyin->cursor_pos = offset;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_END))
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos != (int) len)
{
libpinyin->cursor_pos = len ;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
}
else {
return IRV_TO_PROCESS;
}
}
return IRV_TO_PROCESS;
}
/**
* @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 * ctx = chewing->context;
int zuin_len;
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
if (FcitxCandidateWordGetListSize(candList) > 0) {
if (FcitxHotkeyIsHotKeyDigit(sym, state) || FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT) || FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT))
return IRV_TO_PROCESS;
if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
if (FcitxCandidateWordGoNextPage(candList))
return IRV_DISPLAY_MESSAGE;
else
return IRV_DO_NOTHING;
}
}
if (FcitxHotkeyIsHotKeySimple(sym, state)) {
int scan_code = (int) sym & 0xff;
chewing_handle_Default(ctx, scan_code);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
char * zuin_str = chewing_zuin_String(ctx, &zuin_len);
chewing_free(zuin_str);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_TO_PROCESS;
chewing_handle_Backspace(ctx);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_CLEAN;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
chewing_handle_Esc(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_DELETE)) {
char * zuin_str = chewing_zuin_String(ctx, &zuin_len);
chewing_free(zuin_str);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_TO_PROCESS;
chewing_handle_Del(ctx);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_CLEAN;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
chewing_handle_Space(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_UP)) {
chewing_handle_Up(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_DOWN)) {
chewing_handle_Down(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGUP)) {
chewing_handle_PageDown(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGDN)) {
chewing_handle_PageUp(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT)) {
chewing_handle_Right(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT)) {
chewing_handle_Left(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
chewing_handle_Enter(ctx);
} else if (state == FcitxKeyState_Ctrl && FcitxHotkeyIsHotKeyDigit(sym, FcitxKeyState_None)) {
chewing_handle_CtrlNum(ctx, sym);
} else {
// to do: more chewing_handle
return IRV_TO_PROCESS;
}
if (chewing_keystroke_CheckAbsorb(ctx)) {
return IRV_DISPLAY_CANDWORDS;
} else if (chewing_keystroke_CheckIgnore(ctx)) {
return IRV_TO_PROCESS;
} else if (chewing_commit_Check(ctx)) {
char* str = chewing_commit_String(ctx);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(chewing->owner);
FcitxInstanceCommitString(chewing->owner, ic, str);
chewing_free(str);
return IRV_DISPLAY_CANDWORDS;
} else
return IRV_DISPLAY_CANDWORDS;
}
static boolean ProcessAutoEng(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->active) {
FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);
if (FcitxHotkeyIsHotKeySimple(keymain, state)) {
if (autoEngState->index < MAX_USER_INPUT) {
autoEngState->buf[autoEngState->index] = keymain;
autoEngState->index++;
autoEngState->buf[autoEngState->index] = '\0';
*retval = IRV_DISPLAY_MESSAGE;
} else
*retval = IRV_DO_NOTHING;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
autoEngState->index -- ;
autoEngState->buf[autoEngState->index] = '\0';
if (autoEngState->index == 0) {
ResetAutoEng(autoEngState);
*retval = IRV_CLEAN;
} else
*retval = IRV_DISPLAY_MESSAGE;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
strcpy(FcitxInputStateGetOutputString(input), autoEngState->buf);
ResetAutoEng(autoEngState);
*retval = IRV_COMMIT_STRING;
}
ShowAutoEngMessage(autoEngState);
return true;
}
if (FcitxHotkeyIsHotKeySimple(sym, state)) {
if (FcitxInputStateGetRawInputBufferSize(input) == 0 && FcitxHotkeyIsHotKeyUAZ(sym, state)) {
autoEngState->index = 1;
autoEngState->buf[0] = sym;
autoEngState->buf[1] = '\0';
*retval = IRV_DISPLAY_MESSAGE;
FcitxInputStateSetShowCursor(input, false);
autoEngState->index = strlen(autoEngState->buf);
autoEngState->active = true;
ShowAutoEngMessage(autoEngState);
return true;
}
strncpy(autoEngState->buf, FcitxInputStateGetRawInputBuffer(input), MAX_USER_INPUT);
if (strlen(autoEngState->buf) >= MAX_USER_INPUT - 1)
return false;
autoEngState->index = strlen(autoEngState->buf);
autoEngState->buf[autoEngState->index ++ ] = sym;
autoEngState->buf[autoEngState->index] = '\0';
if (SwitchToEng(autoEngState, autoEngState->buf)) {
*retval = IRV_DISPLAY_MESSAGE;
FcitxInputStateSetShowCursor(input, false);
autoEngState->index = strlen(autoEngState->buf);
autoEngState->active = true;
ShowAutoEngMessage(autoEngState);
return true;
}
}
return false;
}
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) {
FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);
if (FcitxHotkeyIsHotKeySimple(keymain, state)) {
*retval = QuickPhraseDoInput(qpstate, keymain, state);
if (*retval == IRV_TO_PROCESS) {
if (strlen(FcitxInputStateGetRawInputBuffer(input)) == 0
&& (FcitxHotkeyIsHotKey(keymain, state, QuickPhraseTriggerKeys[qpstate->triggerKey]) || FcitxHotkeyIsHotKey(keymain, state, FCITX_SPACE))) {
char c[2] = { (char) (QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym & 0xff), '\0'};
FcitxModuleFunctionArg farg;
FcitxKeySym s = QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym;
farg.args[0] = &s;
char* strTemp = InvokeFunction(qpstate->owner, FCITX_PUNC, GETPUNC, farg);
strcpy(FcitxInputStateGetOutputString(input), strTemp ? strTemp : c);
*retval = IRV_COMMIT_STRING;
} else {
char buf[2];
buf[0] = keymain;
buf[1] = '\0';
if (strlen(FcitxInputStateGetRawInputBuffer(input)) < MAX_USER_INPUT)
strcat(FcitxInputStateGetRawInputBuffer(input), buf);
ShowQuickPhraseMessage(qpstate);
*retval = QuickPhraseGetCandWords(qpstate);
}
} else
return true;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
size_t len = strlen(FcitxInputStateGetRawInputBuffer(input));
if (len > 0)
FcitxInputStateGetRawInputBuffer(input)[--len] = '\0';
if (len == 0) {
*retval = IRV_CLEAN;
} else {
ShowQuickPhraseMessage(qpstate);
*retval = QuickPhraseGetCandWords(qpstate);
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
if (strlen(FcitxInputStateGetRawInputBuffer(input)) > 0) {
strcpy(FcitxInputStateGetOutputString(input), FcitxInputStateGetRawInputBuffer(input));
QuickPhraseReset(qpstate);
*retval = IRV_COMMIT_STRING;
} else {
char c[2] = { (char) (QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym & 0xff), '\0'};
strcpy(FcitxInputStateGetOutputString(input), c);
*retval = IRV_COMMIT_STRING;
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
*retval = IRV_CLEAN;
} else
*retval = IRV_DO_NOTHING;
if (*retval == IRV_DISPLAY_MESSAGE) {
FcitxMessagesSetMessageCount(FcitxInputStateGetAuxDown(input), 0);
if (FcitxCandidateWordPageCount(FcitxInputStateGetCandidateList(input)) == 0)
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, "%s", _("Press Enter to input text"));
}
return true;
}
return false;
}
boolean UnicodePreFilter(void* arg, FcitxKeySym sym, unsigned int state,
INPUT_RETURN_VALUE *r)
{
INPUT_RETURN_VALUE retVal = IRV_TO_PROCESS;
do {
UnicodeModule *uni = arg;
if (!uni->enable)
break;
FcitxInstance *instance = uni->owner;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxGlobalConfig *fc = FcitxInstanceGetGlobalConfig(instance);
FcitxCandidateWordList *candList;
candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetPageSize(candList, 4);
FcitxCandidateWordSetChooseAndModifier(candList, DIGIT_STR_CHOOSE,
FcitxKeyState_Alt);
if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigNextPageKey(instance, fc))) {
if (FcitxCandidateWordGoPrevPage(candList))
retVal = IRV_DISPLAY_MESSAGE;
else
retVal = IRV_DO_NOTHING;
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigNextPageKey(instance, fc))) {
if (FcitxCandidateWordGoNextPage(candList))
retVal = IRV_DISPLAY_MESSAGE;
else
retVal = IRV_DO_NOTHING;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
size_t len = strlen(uni->buffer);
if (len > 0)
uni->buffer[--len] = '\0';
if (len == 0) {
retVal = IRV_CLEAN;
} else {
retVal = UnicodeGetCandWords(uni);
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
retVal = IRV_CLEAN;
}
if (retVal == IRV_TO_PROCESS) {
int index = FcitxCandidateWordCheckChooseKey(candList, sym, state);
if (index >= 0)
retVal = FcitxCandidateWordChooseByIndex(candList, index);
}
FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);
if (retVal == IRV_TO_PROCESS && FcitxHotkeyIsHotKeySimple(keymain, state)) {
char buf[2];
buf[0] = keymain;
buf[1] = '\0';
if (strlen(uni->buffer) < MAX_USER_INPUT)
strcat(uni->buffer, buf);
retVal = UnicodeGetCandWords(uni);
}
} while(0);
*r = retVal;
if (retVal == IRV_TO_PROCESS)
return false;
return true;
}
boolean ProcessPunc(void* arg, FcitxKeySym sym, unsigned int state, INPUT_RETURN_VALUE* retVal)
{
FcitxPuncState* puncState = (FcitxPuncState*) arg;
FcitxInstance* instance = puncState->owner;
FcitxInputState* input = FcitxInstanceGetInputState(puncState->owner);
FcitxProfile* profile = FcitxInstanceGetProfile(instance);
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
char *pPunc = NULL;
if (*retVal != IRV_TO_PROCESS)
return false;
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
if (FcitxCandidateWordPageCount(candList) != 0 && FcitxCandidateWordGetHasGoneToNextPage(candList) ) {
const FcitxHotkey* hkPrevPage = FcitxInstanceGetContextHotkey(instance, CONTEXT_ALTERNATIVE_PREVPAGE_KEY);
if (hkPrevPage == NULL)
hkPrevPage = config->hkPrevPage;
if (FcitxHotkeyIsHotKey(sym, state, hkPrevPage)) {
return false;
}
}
/*
* comparing with upper case, if paging is occupied,
* punc will not let next page pass
*/
if (FcitxCandidateWordPageCount(candList) != 0) {
const FcitxHotkey* hkNextPage = FcitxInstanceGetContextHotkey(instance, CONTEXT_ALTERNATIVE_NEXTPAGE_KEY);
if (hkNextPage == NULL)
hkNextPage = config->hkNextPage;
if (FcitxHotkeyIsHotKey(sym, state, hkNextPage)) {
return false;
}
}
FcitxKeySym origsym = sym;
sym = FcitxHotkeyPadToMain(sym);
if (profile->bUseWidePunc) {
if (puncState->bLastIsNumber && config->bEngPuncAfterNumber
&& (FcitxHotkeyIsHotKey(origsym, state, FCITX_PERIOD)
|| FcitxHotkeyIsHotKey(origsym, state, FCITX_SEMICOLON)
|| FcitxHotkeyIsHotKey(origsym, state, FCITX_COMMA))) {
puncState->cLastIsAutoConvert = origsym;
puncState->bLastIsNumber = false;
*retVal = IRV_DONOT_PROCESS;
return true;
}
if (FcitxHotkeyIsHotKeySimple(sym, state))
pPunc = GetPunc(puncState, origsym);
}
/*
* 在有候选词未输入的情况下，选择第一个候选词并输入标点
*/
if (IsHotKeyPunc(sym, state)) {
FcitxInputStateGetOutputString(input)[0] = '\0';
INPUT_RETURN_VALUE ret = IRV_TO_PROCESS;
if (!FcitxInputStateGetIsInRemind(input))
ret = FcitxCandidateWordChooseByTotalIndex(FcitxInputStateGetCandidateList(input), 0);
/* if there is nothing to commit */
if (ret == IRV_TO_PROCESS) {
if (pPunc) {
strcat(FcitxInputStateGetOutputString(input), pPunc);
*retVal = IRV_PUNC;
FcitxInstanceCleanInputWindow(instance);
return true;
} else
return false;
} else {
if (pPunc)
strcat(FcitxInputStateGetOutputString(input), pPunc);
else {
char buf[2] = { sym, 0 };
strcat(FcitxInputStateGetOutputString(input), buf);
}
FcitxInstanceCleanInputWindow(instance);
*retVal = IRV_PUNC;
return true;
}
return false;
}
if (profile->bUseWidePunc) {
if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)
&& puncState->cLastIsAutoConvert) {
char *pPunc;
FcitxInstanceForwardKey(puncState->owner, FcitxInstanceGetCurrentIC(instance), FCITX_PRESS_KEY, sym, state);
pPunc = GetPunc(puncState, puncState->cLastIsAutoConvert);
if (pPunc)
FcitxInstanceCommitString(puncState->owner, FcitxInstanceGetCurrentIC(instance), pPunc);
puncState->cLastIsAutoConvert = 0;
*retVal = IRV_DO_NOTHING;
return true;
} else if (FcitxHotkeyIsHotKeySimple(sym, state)) {
if (FcitxHotkeyIsHotKeyDigit(sym, state))
puncState->bLastIsNumber = true;
else {
puncState->bLastIsNumber = false;
}
}
}
puncState->cLastIsAutoConvert = 0;
return false;
}
