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;
}
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;
}
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;
}
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 FcitxKkcDoInputReal(void* arg, FcitxKeySym sym, unsigned int state)
{
FcitxKkc *kkc = (FcitxKkc*)arg;
state = state & (FcitxKeyState_SimpleMask | _FcitxKeyState_Release);
KkcCandidateList* kkcCandidates = kkc_context_get_candidates(kkc->context);
if (kkc_candidate_list_get_page_visible(kkcCandidates)) {
if (FcitxHotkeyIsHotKeyDigit(sym, state)) {
return IRV_TO_PROCESS;
} else if (FcitxHotkeyIsHotKey(sym, state, kkc->config.prevPageKey)) {
return IRV_TO_PROCESS;
} else if (FcitxHotkeyIsHotKey(sym, state, kkc->config.nextPageKey)) {
return IRV_TO_PROCESS;
} else if (FcitxHotkeyIsHotKey(sym, state, kkc->config.cursorUpKey)) {
if (!(state & _FcitxKeyState_Release)) {
KkcCandidateList* kkcCandidates = kkc_context_get_candidates(kkc->context);
kkc_candidate_list_cursor_up(kkcCandidates);
return IRV_DISPLAY_CANDWORDS;
} else {
return IRV_TO_PROCESS;
}
} else if (FcitxHotkeyIsHotKey(sym, state, kkc->config.cursorDownKey)) {
if (!(state & _FcitxKeyState_Release)) {
KkcCandidateList* kkcCandidates = kkc_context_get_candidates(kkc->context);
kkc_candidate_list_cursor_down(kkcCandidates);
return IRV_DISPLAY_CANDWORDS;
} else {
return IRV_TO_PROCESS;
}
}
}
FcitxInputState* input = FcitxInstanceGetInputState(kkc->owner);
uint32_t keycode = FcitxInputStateGetKeyCode(input);
KkcKeyEvent* key = kkc_key_event_new_from_x_event(sym, keycode - 8, state);
if (!key) {
return IRV_TO_PROCESS;
}
gboolean retval = kkc_context_process_key_event(kkc->context, key);
g_object_unref(key);
if (retval) {
return IRV_DISPLAY_CANDWORDS;
}
return IRV_TO_PROCESS;
}
INPUT_RETURN_VALUE DoQWInput(void* arg, FcitxKeySym sym, unsigned int state)
{
FcitxQWState* qwstate = (FcitxQWState*) arg;
FcitxInputState* input = FcitxInstanceGetInputState(qwstate->owner);
char* strCodeInput = FcitxInputStateGetRawInputBuffer(input);
INPUT_RETURN_VALUE retVal;
retVal = IRV_TO_PROCESS;
if (FcitxHotkeyIsHotKeyDigit(sym, state)) {
if (FcitxInputStateGetRawInputBufferSize(input) != 4) {
strCodeInput[FcitxInputStateGetRawInputBufferSize(input)] = sym;
strCodeInput[FcitxInputStateGetRawInputBufferSize(input) + 1] = '\0';
FcitxInputStateSetRawInputBufferSize(input, FcitxInputStateGetRawInputBufferSize(input) + 1);
if (FcitxInputStateGetRawInputBufferSize(input) == 4) {
retVal = IRV_TO_PROCESS;
} else
retVal = IRV_DISPLAY_CANDWORDS;
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
if (!FcitxInputStateGetRawInputBufferSize(input))
return IRV_DONOT_PROCESS_CLEAN;
FcitxInputStateSetRawInputBufferSize(input, FcitxInputStateGetRawInputBufferSize(input) - 1);
strCodeInput[FcitxInputStateGetRawInputBufferSize(input)] = '\0';
if (!FcitxInputStateGetRawInputBufferSize(input))
retVal = IRV_CLEAN;
else {
retVal = IRV_DISPLAY_CANDWORDS;
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
if (!FcitxInputStateGetRawInputBufferSize(input))
return IRV_TO_PROCESS;
if (FcitxInputStateGetRawInputBufferSize(input) != 3)
return IRV_DO_NOTHING;
retVal = FcitxCandidateWordChooseByIndex(FcitxInputStateGetCandidateList(input), 0);
} else
return IRV_TO_PROCESS;
return retVal;
}
boolean IsHotKeyPunc(FcitxKeySym sym, unsigned int state)
{
if (FcitxHotkeyIsHotKeySimple(sym, state)
&& !FcitxHotkeyIsHotKeyDigit(sym, state)
&& !FcitxHotkeyIsHotKeyLAZ(sym, state)
&& !FcitxHotkeyIsHotKeyUAZ(sym, state)
&& !FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE))
return true;
return false;
}
// This function is called from within fcitx. It is called when user
// input is detected. This may be a keypress, or it may be triggered by
// a new stroke on the tablet (see FcitxTabletProcess)
INPUT_RETURN_VALUE FcitxTabletDoInput(void* arg, FcitxKeySym sym, unsigned int action) {
// The event module uses VoidSymbol as a trigger, this means other input methods
// will ignore it, actual actions will be passed in the action variable
FcitxTablet* tablet = (FcitxTablet*) arg;
if(sym == FcitxKey_VoidSymbol) {
// Depending on the tablet driver, we could add more actions, for
// example selecting candidates via the tablet
switch(action) {
case IME_RECOGNISE:
tablet->engineInstance->Process(tablet->engineData, tablet->strokesBuffer, (tablet->strokesPtr - tablet->strokesBuffer));
// call into recognition library, update candidate lists
return IRV_DISPLAY_CANDWORDS;
break;
case IME_COMMIT:
CommitFirstCandidate(tablet);
return IRV_CLEAN;
break;
default:
FcitxLog(ERROR, "IME asked to perform unknown action");
}
}
// Backspace and spacebar need to be handled specially
if(FcitxHotkeyIsHotKey(sym, action, FCITX_BACKSPACE)) {
if(CharacterInProgress(tablet)) {
// scrap the current character
ClearCharacter(tablet);
CommitFirstCandidate(tablet);
return IRV_CLEAN;
} else
return IRV_TO_PROCESS;
} else if(FcitxHotkeyIsHotKey(sym, action, FCITX_SPACE) || FcitxHotkeyIsHotKey(sym, action, FCITX_ENTER)) {
if(CharacterInProgress(tablet)) {
// commit the current character
return IRV_CLEAN;
} else
return IRV_TO_PROCESS;
}
return IRV_TO_PROCESS;
}
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;
const FcitxHotkey* hkPrevPage = FcitxInstanceGetContextHotkey(instance, CONTEXT_ALTERNATIVE_PREVPAGE_KEY);
if (hkPrevPage == NULL)
hkPrevPage = fc->hkPrevPage;
const FcitxHotkey* hkNextPage = FcitxInstanceGetContextHotkey(instance, CONTEXT_ALTERNATIVE_NEXTPAGE_KEY);
if (hkNextPage == NULL)
hkNextPage = fc->hkNextPage;
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
if (FcitxHotkeyIsHotKey(sym, state, hkPrevPage)) {
FcitxCandidateWordGoPrevPage(candList);
*retval = IRV_DISPLAY_MESSAGE;
} else if (FcitxHotkeyIsHotKey(sym, state, hkNextPage)) {
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;
} else {
*retval = IRV_DO_NOTHING;
}
return true;
}
boolean QuickPhrasePostFilter(void* arg, FcitxKeySym sym,
unsigned int state,
INPUT_RETURN_VALUE *retval
)
{
QuickPhraseState *qpstate = (QuickPhraseState*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
boolean disableQuickPhrase = FcitxInstanceGetContextBoolean(qpstate->owner, CONTEXT_DISABLE_QUICKPHRASE);
if (*retval != IRV_TO_PROCESS)
return false;
if (!disableQuickPhrase
&& !qpstate->enabled
&& FcitxInputStateGetRawInputBufferSize(input) == 0
&& FcitxHotkeyIsHotKey(sym, state, QuickPhraseTriggerKeys[qpstate->triggerKey])) {
FcitxInstanceCleanInputWindow(qpstate->owner);
FcitxInputStateSetShowCursor(input, true);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, "%s", _("Quick Phrase: "));
FcitxInputStateSetCursorPos(input, 0);
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);
const char* full = strTemp ? strTemp : c;
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, _("Space for %s Enter for %s") , full, c);
qpstate->enabled = true;
*retval = IRV_DISPLAY_MESSAGE;
return true;
}
return false;
}
static boolean
ClipboardPostHook(void *arg, FcitxKeySym sym, unsigned int state,
INPUT_RETURN_VALUE *ret_val)
{
FcitxClipboard *clipboard = arg;
FcitxClipboardConfig *config = &clipboard->config;
if (!((clipboard->primary.len && config->use_primary) ||
clipboard->clp_hist_len))
return false;
FcitxInstance *instance = clipboard->owner;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
if (FcitxInputStateGetRawInputBufferSize(input))
return false;
if (!FcitxHotkeyIsHotKey(sym, state, config->trigger_key))
return false;
clipboard->active = true;
FcitxCandidateWordList *cand_list = FcitxInputStateGetCandidateList(input);
FcitxGlobalConfig *gconfig = FcitxInstanceGetGlobalConfig(instance);
FcitxMessages *msg;
FcitxCandidateWord cand_word = {
.callback = ClipboardCommitCallback,
.wordType = MSG_OTHER,
.owner = clipboard
};
FcitxInstanceCleanInputWindow(instance);
FcitxCandidateWordSetLayoutHint(cand_list, CLH_Vertical);
FcitxCandidateWordSetPageSize(cand_list, gconfig->iMaxCandWord);
FcitxCandidateWordSetChooseAndModifier(
cand_list, DIGIT_STR_CHOOSE, cmodifiers[config->choose_modifier]);
if (clipboard->clp_hist_len) {
ClipboardSetCandWord(clipboard, &cand_word, clipboard->clp_hist_lst);
FcitxCandidateWordAppend(cand_list, &cand_word);
}
int primary_found;
if (clipboard->primary.len && config->use_primary) {
primary_found = ClipboardSelectionClipboardFind(
clipboard, clipboard->primary.str, clipboard->primary.len);
if (primary_found == 0)
goto skip_primary;
ClipboardSetCandWord(clipboard, &cand_word, &clipboard->primary);
FcitxCandidateWordAppend(cand_list, &cand_word);
} else {
primary_found = -1;
}
skip_primary:
msg = FcitxInputStateGetAuxUp(input);
FcitxInputStateSetShowCursor(input, false);
FcitxMessagesSetMessageCount(msg, 0);
FcitxMessagesAddMessageStringsAtLast(msg, MSG_TIPS,
_("Select to paste"));
unsigned int i;
for (i = 1;i < clipboard->clp_hist_len;i++) {
if ((int)i == primary_found)
continue;
ClipboardSetCandWord(clipboard, &cand_word,
clipboard->clp_hist_lst + i);
FcitxCandidateWordAppend(cand_list, &cand_word);
}
*ret_val = IRV_FLAG_UPDATE_INPUT_WINDOW;
return true;
}
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;
}
static INPUT_RETURN_VALUE
AutoEngCheckSelect(FcitxAutoEngState *autoEngState,
FcitxKeySym sym, unsigned int state)
{
FcitxInstance *instance = autoEngState->owner;
FcitxCandidateWordList *cand_list = FcitxInputStateGetCandidateList(
FcitxInstanceGetInputState(autoEngState->owner));
if (!FcitxCandidateWordGetListSize(cand_list))
return IRV_TO_PROCESS;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxGlobalConfig *fc = FcitxInstanceGetGlobalConfig(instance);
int key;
FcitxCandidateWord *cand_word;
if (FcitxHotkeyIsHotKey(sym, state, fc->nextWord)) {
if (!autoEngState->cursor_moved) {
cand_word = FcitxCandidateWordGetCurrentWindow(cand_list);
} else {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
cand_word = FcitxCandidateWordGetNext(cand_list, cand_word);
if (!cand_word) {
FcitxCandidateWordSetPage(cand_list, 0);
} else {
FcitxCandidateWordSetFocus(
cand_list, FcitxCandidateWordGetIndex(cand_list,
cand_word));
}
}
} else if (FcitxHotkeyIsHotKey(sym, state, fc->prevWord)) {
if (!autoEngState->cursor_moved) {
cand_word = FcitxCandidateWordGetByIndex(
cand_list,
FcitxCandidateWordGetCurrentWindowSize(cand_list) - 1);
} else {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
cand_word = FcitxCandidateWordGetPrev(cand_list, cand_word);
if (cand_word) {
FcitxCandidateWordSetFocus(
cand_list, FcitxCandidateWordGetIndex(cand_list,
cand_word));
}
}
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigPrevPageKey(instance, fc))) {
boolean has_prev_page;
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
has_prev_page = FcitxCandidateWordGoPrevPage(cand_list);
if (!autoEngState->cursor_moved) {
cand_word = NULL;
} else if (has_prev_page) {
cand_word = FcitxCandidateWordGetCurrentWindow(cand_list) +
FcitxCandidateWordGetCurrentWindowSize(cand_list) - 1;
}
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigNextPageKey(instance, fc))) {
boolean has_next_page;
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
has_next_page = FcitxCandidateWordGoNextPage(cand_list);
if (!autoEngState->cursor_moved) {
cand_word = NULL;
} else if (has_next_page) {
cand_word = FcitxCandidateWordGetCurrentWindow(cand_list);
}
} else if ((key = FcitxCandidateWordCheckChooseKey(cand_list,
sym, state)) >= 0) {
return FcitxCandidateWordChooseByIndex(cand_list, key);
} else {
return IRV_TO_PROCESS;
}
if (cand_word) {
FcitxCandidateWordSetType(cand_word, MSG_CANDIATE_CURSOR);
if (!autoEngState->cursor_moved)
AutoEngSwapBuff(autoEngState);
AutoEngSetBuff(autoEngState, cand_word->strWord, '\0');
autoEngState->cursor_moved = true;
} else if (autoEngState->cursor_moved) {
AutoEngSwapBuff(autoEngState);
autoEngState->cursor_moved = false;
} else {
return IRV_FLAG_UPDATE_INPUT_WINDOW;
}
FcitxMessages *client_preedit = FcitxInputStateGetClientPreedit(input);
FcitxMessages *preedit = FcitxInputStateGetPreedit(input);
FcitxMessagesSetMessageCount(client_preedit, 0);
FcitxMessagesSetMessageCount(preedit, 0);
FcitxMessagesAddMessageStringsAtLast(client_preedit, MSG_INPUT,
autoEngState->buf);
FcitxMessagesAddMessageStringsAtLast(preedit, MSG_INPUT,
autoEngState->buf);
FcitxInputStateSetCursorPos(input, autoEngState->index);
FcitxInputStateSetClientCursorPos(input, autoEngState->index);
return IRV_FLAG_UPDATE_INPUT_WINDOW;
}
static boolean
ClipboardPreHook(void *arg, FcitxKeySym sym, unsigned int state,
INPUT_RETURN_VALUE *ret_val)
{
FcitxClipboard *clipboard = arg;
FcitxInstance *instance = clipboard->owner;
if (!clipboard->active)
return false;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxCandidateWordList *cand_list = FcitxInputStateGetCandidateList(input);
FcitxGlobalConfig *fc = FcitxInstanceGetGlobalConfig(instance);
*ret_val = IRV_TO_PROCESS;
int key;
FcitxCandidateWord *cand_word;
if (FcitxHotkeyIsHotKey(sym, state, fc->nextWord)) {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
cand_word = FcitxCandidateWordGetNext(cand_list, cand_word);
if (!cand_word) {
FcitxCandidateWordSetPage(cand_list, 0);
cand_word = FcitxCandidateWordGetFirst(cand_list);
} else {
FcitxCandidateWordSetFocus(
cand_list, FcitxCandidateWordGetIndex(cand_list, cand_word));
}
} else if (FcitxHotkeyIsHotKey(sym, state, fc->prevWord)) {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
cand_word = FcitxCandidateWordGetPrev(cand_list, cand_word);
if (!cand_word) {
FcitxCandidateWordSetPage(
cand_list, FcitxCandidateWordPageCount(cand_list) - 1);
cand_word = FcitxCandidateWordGetLast(cand_list);
} else {
FcitxCandidateWordSetFocus(
cand_list, FcitxCandidateWordGetIndex(cand_list, cand_word));
}
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigPrevPageKey(instance, fc))) {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
if (!FcitxCandidateWordGoPrevPage(cand_list)) {
FcitxCandidateWordSetType(cand_word, MSG_CANDIATE_CURSOR);
*ret_val = IRV_DO_NOTHING;
return true;
}
cand_word = FcitxCandidateWordGetCurrentWindow(cand_list) +
FcitxCandidateWordGetCurrentWindowSize(cand_list) - 1;
} else if (FcitxHotkeyIsHotKey(sym, state,
FcitxConfigNextPageKey(instance, fc))) {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
if (!FcitxCandidateWordGoNextPage(cand_list)) {
FcitxCandidateWordSetType(cand_word, MSG_CANDIATE_CURSOR);
*ret_val = IRV_DO_NOTHING;
return true;
}
cand_word = FcitxCandidateWordGetCurrentWindow(cand_list);
} else if ((key = FcitxCandidateWordCheckChooseKey(cand_list,
sym, state)) >= 0) {
*ret_val = FcitxCandidateWordChooseByIndex(cand_list, key);
return true;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
cand_word = FcitxCandidateWordGetFocus(cand_list, true);
*ret_val = FcitxCandidateWordChooseByTotalIndex(
cand_list, FcitxCandidateWordGetIndex(cand_list, cand_word));
return true;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
*ret_val = IRV_FLAG_RESET_INPUT | IRV_FLAG_UPDATE_INPUT_WINDOW;
return true;
} else {
*ret_val = IRV_DO_NOTHING;
return true;
}
FcitxCandidateWordSetType(cand_word, MSG_CANDIATE_CURSOR);
*ret_val = IRV_FLAG_UPDATE_INPUT_WINDOW;
return true;
}
void XIMProcessKey(FcitxXimFrontend* xim, IMForwardEventStruct * call_data)
{
KeySym originsym;
FcitxKeySym sym;
XKeyEvent *kev;
int keyCount;
uint32_t state;
char strbuf[STRBUFLEN];
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(xim->owner);
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(xim->owner);
FcitxInputState* input = FcitxInstanceGetInputState(xim->owner);
if (ic == NULL) {
ic = FcitxInstanceFindIC(xim->owner, xim->frontendid, &call_data->icid);
if (FcitxInstanceSetCurrentIC(xim->owner, ic) && ic)
FcitxUIOnInputFocus(xim->owner);
}
if (ic == NULL)
return;
if (ic->frontendid != xim->frontendid || GetXimIC(ic)->id != call_data->icid) {
ic = FcitxInstanceFindIC(xim->owner, xim->frontendid, &call_data->icid);
if (ic == NULL)
return;
if (FcitxInstanceSetCurrentIC(xim->owner, ic))
FcitxUIOnInputFocus(xim->owner);
}
kev = (XKeyEvent *) & call_data->event;
memset(strbuf, 0, STRBUFLEN);
keyCount = XLookupString(kev, strbuf, STRBUFLEN, &originsym, NULL);
const uint32_t originstate = kev->state;
state = kev->state - (kev->state & FcitxKeyState_NumLock) - (kev->state & FcitxKeyState_CapsLock) - (kev->state & FcitxKeyState_ScrollLock);
state &= FcitxKeyState_UsedMask;
FcitxHotkeyGetKey((FcitxKeySym) originsym, state, &sym, &state);
FcitxLog(DEBUG,
"KeyRelease=%d state=%d KEYCODE=%d KEYSYM=%d keyCount=%d",
(call_data->event.type == KeyRelease), state, kev->keycode, (int) sym, keyCount);
xim->currentSerialNumberCallData = call_data->serial_number;
xim->currentSerialNumberKey = kev->serial;
FcitxKeyEventType type = (call_data->event.type == KeyRelease) ? (FCITX_RELEASE_KEY) : (FCITX_PRESS_KEY);
if (ic->state == IS_CLOSED) {
if (type == FCITX_PRESS_KEY && FcitxHotkeyIsHotKey(sym, state, config->hkTrigger)) {
FcitxInstanceEnableIM(xim->owner, ic, false);
return;
} else {
XimForwardKeyInternal(xim,
GetXimIC(ic),
&call_data->event
);
return;
}
}
FcitxInputStateSetKeyCode(input, kev->keycode);
FcitxInputStateSetKeySym(input, originsym);
FcitxInputStateSetKeyState(input, originstate);
INPUT_RETURN_VALUE retVal = FcitxInstanceProcessKey(xim->owner, type,
kev->time,
sym, state);
FcitxInputStateSetKeyCode(input, 0);
FcitxInputStateSetKeySym(input, 0);
FcitxInputStateSetKeyState(input, 0);
if ((retVal & IRV_FLAG_FORWARD_KEY) || retVal == IRV_TO_PROCESS) {
XimForwardKeyInternal(xim,
GetXimIC(ic),
&call_data->event
);
} else {
if (!GetXimIC(ic)->bHasCursorLocation)
SetTrackPos(xim, ic, NULL);
}
xim->currentSerialNumberCallData = xim->currentSerialNumberKey = 0L;
}
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;
}
/**
* @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 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;
}
FCITX_EXPORT_API
boolean FcitxHotkeyIsKey(FcitxKeySym sym, unsigned int state, FcitxKeySym symcmp, unsigned int statecmp)
{
FcitxHotkey key[2] = { {0, symcmp, statecmp }, {0, 0, 0} };
return FcitxHotkeyIsHotKey(sym ,state, key);
}
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 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;
}
