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;
}
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 {
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;
}
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;
}
void KeyboardLayoutWidget::drawKeyLabelHelper(QPainter* painter, int keysym, int angle, int glp, int x, int y, int width, int height, int padding, bool is_pressed)
{
if (keysym == 0)
return;
if (keysym == XK_VoidSymbol)
return;
if (padding >= height / 2)
padding = 0;
if (padding >= width / 2)
padding = 0;
Qt::Alignment align;
QRectF rect(padding, padding, (width - 2 * padding), (height - 2 * padding));
switch (glp) {
case KEYBOARD_DRAWING_POS_TOPLEFT:
align = Qt::AlignTop | Qt::AlignLeft;
break;
case KEYBOARD_DRAWING_POS_BOTTOMLEFT:
align = Qt::AlignBottom | Qt::AlignLeft;
break;
case KEYBOARD_DRAWING_POS_TOPRIGHT:
align = Qt::AlignTop | Qt::AlignRight;
break;
case KEYBOARD_DRAWING_POS_BOTTOMRIGHT:
align = Qt::AlignBottom | Qt::AlignRight;
break;
default:
return;
}
if (keysym == XK_ISO_Left_Tab)
keysym = XK_Tab;
keysym = (int) FcitxHotkeyPadToMain((FcitxKeySym) keysym);
uint32_t unicode = FcitxKeySymToUnicode((FcitxKeySym) keysym);
if (deadMap.contains(keysym)) {
unicode = deadMap[keysym];
}
QString text;
if (unicode
&& QChar(unicode).category() != QChar::Other_Control
&& !QChar(unicode).isSpace())
text.append(QChar(unicode));
else {
if (keysym == XK_Prior) {
text = "PgUp";
}
else if (keysym == XK_Next) {
text = "PgDn";
}
else {
text = QString(XKeysymToString(keysym));
}
}
if (text != "_") {
if (text.endsWith("_L") || text.endsWith("_R"))
text = text.replace('_', ' ');
else
text = text.replace('_', '\n');
}
painter->save();
QTransform trans;
trans.translate(x + padding / 2, y + padding / 2);
trans.rotate(angle / 10);
painter->setTransform(trans);
//painter->fillRect(QRectF(0, 0, width - padding, height - padding), QBrush(Qt::blue));
// painter->setClipRect(QRect(x + padding / 2, y + padding / 2, width - padding, height - padding));
trans.reset();
trans.translate(x, y);
trans.rotate(angle / 10);
QFont font = painter->font();
font.setPixelSize(TEXT_SIZE * (height / 2 - padding));
QFontMetricsF fm(font);
QStringList lines = text.split('\n');
foreach(const QString& line, lines) {
qreal w = fm.width(line);
if (w > (width - padding * 2) * TEXT_SIZE) {
double sz = font.pixelSize() / w * (width - padding * 2) * TEXT_SIZE;
if (sz < 1)
sz = 1;
font.setPixelSize(font.pixelSize() / w * (width - padding * 2) * TEXT_SIZE);
}
}
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;
}
