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 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));
}
/**
* @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)));
}
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;
}
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;
}
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);
}
}
INPUT_RETURN_VALUE QuickPhraseGetLuaCandWord(void* arg, FcitxCandidateWord* candWord)
{
QuickPhraseState *qpstate = (QuickPhraseState*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
if (candWord->strExtra) {
strcat(FcitxInputStateGetRawInputBuffer(input), candWord->strExtra);
ShowQuickPhraseMessage(qpstate);
return QuickPhraseGetCandWords(qpstate);
}
else {
strcpy(FcitxInputStateGetOutputString(input), candWord->strWord);
return IRV_COMMIT_STRING;
}
}
void ShowAutoEngMessage(FcitxAutoEngState* autoEngState)
{
FcitxInputState* input = FcitxInstanceGetInputState(autoEngState->owner);
FcitxInstanceCleanInputWindow(autoEngState->owner);
if (autoEngState->buf[0] == '\0')
return;
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", autoEngState->buf);
strcpy(FcitxInputStateGetRawInputBuffer(input), autoEngState->buf);
FcitxInputStateSetRawInputBufferSize(input, strlen(autoEngState->buf));
FcitxInputStateSetCursorPos(input, FcitxInputStateGetRawInputBufferSize(input));
FcitxInputStateSetShowCursor(input, true);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, _("Press Enter to input text"));
}
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;
}
static void
ShowAutoEngMessage(FcitxAutoEngState *autoEngState, INPUT_RETURN_VALUE *retval)
{
FcitxInputState* input = FcitxInstanceGetInputState(autoEngState->owner);
char *raw_buff;
int buff_len;
FcitxInstanceCleanInputWindow(autoEngState->owner);
if (autoEngState->buf[0] == '\0')
return;
raw_buff = FcitxInputStateGetRawInputBuffer(input);
buff_len = strlen(autoEngState->buf);
strncpy(raw_buff, autoEngState->buf, MAX_USER_INPUT);
if (buff_len > MAX_USER_INPUT) {
raw_buff[MAX_USER_INPUT] = '\0';
FcitxInputStateSetRawInputBufferSize(input, MAX_USER_INPUT);
} else {
FcitxInputStateSetRawInputBufferSize(input, buff_len);
}
if (buff_len > AUTOENG_MAX_PREEDIT) {
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetPreedit(input),
MSG_INPUT, autoEngState->buf +
buff_len - AUTOENG_MAX_PREEDIT);
FcitxInputStateSetCursorPos(input, AUTOENG_MAX_PREEDIT);
} else {
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetPreedit(input),
MSG_INPUT, autoEngState->buf);
FcitxInputStateSetCursorPos(input, autoEngState->index);
}
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetClientPreedit(input),
MSG_INPUT, autoEngState->buf);
FcitxInputStateSetClientCursorPos(input, autoEngState->index);
FcitxInputStateSetShowCursor(input, true);
// AutoEngGetSpellHint(autoEngState);
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxDown(input),
MSG_TIPS,
//_("Press Enter to input text"));
" ");
*retval |= IRV_FLAG_UPDATE_INPUT_WINDOW;
}
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 (FcitxHotkeyIsHotKeyUAZ(sym, state) &&
(FcitxInputStateGetRawInputBufferSize(input) != 0 ||
(FcitxInputStateGetKeyState(input) & FcitxKeyState_CapsLock) == 0) &&
AutoEngCheckPreedit(autoEngState)) {
*retval = IRV_DISPLAY_MESSAGE;
FcitxInputStateSetShowCursor(input, false);
AutoEngSetBuff(autoEngState, FcitxInputStateGetRawInputBuffer(input),
FcitxHotkeyPadToMain(sym));
autoEngState->active = true;
ShowAutoEngMessage(autoEngState, retval);
return true;
}
return false;
}
/**
* @brief function DoInput has done everything for us.
*
* @param searchMode
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxLibpinyinGetCandWords(void* arg)
{
FcitxLibpinyin* libpinyin = (FcitxLibpinyin* )arg;
FcitxInstance* instance = libpinyin->owner->owner;
FcitxInputState* input = FcitxInstanceGetInputState(instance);
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(libpinyin->owner->owner);
FcitxLibpinyinConfig* pyConfig = &libpinyin->owner->config;
struct _FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetPageSize(candList, config->iMaxCandWord);
FcitxUICloseInputWindow(instance);
strcpy(FcitxInputStateGetRawInputBuffer(input), libpinyin->buf);
FcitxInputStateSetRawInputBufferSize(input, strlen(libpinyin->buf));
FcitxInputStateSetShowCursor(input, true);
FcitxInputStateSetClientCursorPos(input, 0);
if (libpinyin->type == LPT_Zhuyin) {
FcitxKeyState state = candidateModifierMap[pyConfig->candidateModifiers];
FcitxCandidateWordSetChooseAndModifier(candList, "1234567890", state);
}
else
FcitxCandidateWordSetChoose(candList, "1234567890");
/* add punc */
if (libpinyin->type == LPT_Zhuyin
&& strlen(libpinyin->buf) == 1
&& LibpinyinCheckZhuyinKey((FcitxKeySym) libpinyin->buf[0], pyConfig->zhuyinLayout, pyConfig->useTone)
&& (libpinyin->buf[0] >= ' ' && libpinyin->buf[0] <= '\x7e') /* simple */
&& !(libpinyin->buf[0] >= 'a' && libpinyin->buf[0] <= 'z') /* not a-z */
&& !(libpinyin->buf[0] >= 'A' && libpinyin->buf[0] <= 'Z') /* not A-Z /*/
&& !(libpinyin->buf[0] >= '0' && libpinyin->buf[0] <= '9') /* not digit */
) {
int c = libpinyin->buf[0];
char *result = FcitxPuncGetPunc(instance, &c);
if (result) {
FcitxCandidateWord candWord;
FcitxLibpinyinCandWord* pyCand = (FcitxLibpinyinCandWord*) fcitx_utils_malloc0(sizeof(FcitxLibpinyinCandWord));
pyCand->ispunc = true;
candWord.callback = FcitxLibpinyinGetCandWord;
candWord.extraType = MSG_OTHER;
candWord.owner = libpinyin;
candWord.priv = pyCand;
candWord.strExtra = NULL;
candWord.strWord = strdup(result);
candWord.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
}
char* sentence = NULL;
pinyin_guess_sentence(libpinyin->inst);
sentence = LibpinyinGetSentence(libpinyin);
if (sentence) {
FcitxLibpinyinUpdatePreedit(libpinyin, sentence);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetClientPreedit(input), MSG_INPUT, "%s", sentence);
g_free(sentence);
}
else {
FcitxInputStateSetCursorPos(input, libpinyin->cursor_pos);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetClientPreedit(input), MSG_INPUT, "%s", libpinyin->buf);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", libpinyin->buf);
}
if (libpinyin->candidate)
g_array_free(libpinyin->candidate, TRUE);
libpinyin->candidate = g_array_new(FALSE, FALSE, sizeof(lookup_candidate_t));
pinyin_get_candidates(libpinyin->inst, LibpinyinGetOffset(libpinyin), libpinyin->candidate);
int i = 0;
for (i = 0 ; i < libpinyin->candidate->len; i ++) {
lookup_candidate_t token = g_array_index(libpinyin->candidate, lookup_candidate_t, i);
FcitxCandidateWord candWord;
FcitxLibpinyinCandWord* pyCand = (FcitxLibpinyinCandWord*) fcitx_utils_malloc0(sizeof(FcitxLibpinyinCandWord));
pyCand->ispunc = false;
pyCand->idx = i;
candWord.callback = FcitxLibpinyinGetCandWord;
candWord.extraType = MSG_OTHER;
candWord.owner = libpinyin;
candWord.priv = pyCand;
candWord.strExtra = NULL;
candWord.strWord = strdup(token.m_phrase_string);
candWord.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
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;
}
INPUT_RETURN_VALUE QuickPhraseGetCandWords(QuickPhraseState* qpstate)
{
int iInputLen;
QUICK_PHRASE searchKey, *pKey, *currentQuickPhrase, *lastQuickPhrase;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
FcitxInstance *instance = qpstate->owner;
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
FcitxInstanceCleanInputWindowDown(qpstate->owner);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);
FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);
pKey = &searchKey;
{
FcitxModuleFunctionArg arg;
char *text = FcitxInputStateGetRawInputBuffer(input);
arg.args[0] = text;
arg.args[1] = QuickPhraseGetLuaCandWord;
arg.args[2] = qpstate;
InvokeFunction(qpstate->owner, FCITX_LUA, CALLCOMMAND, arg);
}
if (!qpstate->quickPhrases)
return IRV_DISPLAY_MESSAGE;
iInputLen = strlen(FcitxInputStateGetRawInputBuffer(input));
if (iInputLen > QUICKPHRASE_CODE_LEN)
return IRV_DISPLAY_MESSAGE;
strcpy(searchKey.strCode, FcitxInputStateGetRawInputBuffer(input));
currentQuickPhrase = utarray_custom_bsearch(pKey, qpstate->quickPhrases, false, PhraseCmp);
qpstate->iFirstQuickPhrase = utarray_eltidx(qpstate->quickPhrases, currentQuickPhrase);
lastQuickPhrase = utarray_custom_bsearch(pKey, qpstate->quickPhrases, false, PhraseCmpA);
qpstate->iLastQuickPhrase = utarray_eltidx(qpstate->quickPhrases, lastQuickPhrase);
if (qpstate->iLastQuickPhrase < 0)
qpstate->iLastQuickPhrase = utarray_len(qpstate->quickPhrases);
if (!currentQuickPhrase || strncmp(FcitxInputStateGetRawInputBuffer(input), currentQuickPhrase->strCode, iInputLen)) {
currentQuickPhrase = NULL;
return IRV_DISPLAY_MESSAGE;
}
for (currentQuickPhrase = (QUICK_PHRASE*) utarray_eltptr(qpstate->quickPhrases,
qpstate->iFirstQuickPhrase);
currentQuickPhrase != NULL;
currentQuickPhrase = (QUICK_PHRASE*) utarray_next(qpstate->quickPhrases, currentQuickPhrase)) {
if (!strncmp(FcitxInputStateGetRawInputBuffer(input), currentQuickPhrase->strCode, iInputLen)) {
QuickPhraseCand* qpcand = fcitx_utils_malloc0(sizeof(QuickPhraseCand));
qpcand->cand = currentQuickPhrase;
FcitxCandidateWord candWord;
candWord.callback = QuickPhraseGetCandWord;
candWord.owner = qpstate;
candWord.priv = qpcand;
candWord.strExtra = strdup(currentQuickPhrase->strCode + iInputLen);
candWord.strWord = strdup(currentQuickPhrase->strPhrase);
candWord.wordType = MSG_OTHER;
candWord.extraType = MSG_CODE;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
}
return IRV_DISPLAY_MESSAGE;
}
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;
}
