// This function is called from within fcitx. It is called when the
// list of input candidates has changed. It extracts the candidates
// from the recognition engine and puts them into the format required
// by fcitx for displaying in its popup window
INPUT_RETURN_VALUE FcitxTabletGetCandWords(void* arg) {
FcitxTablet* tablet = (FcitxTablet*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(tablet->fcitx);
FcitxInstanceCleanInputWindow(tablet->fcitx);
char* c = tablet->engineInstance->GetCandidates(tablet->engineData);
int len = strlen(c);
int i = 0;
do {
int n = mblen(&c[i], len);
if(n <= 0) break;
FcitxCandidateWord cw;
cw.callback = FcitxTabletGetCandWord;
cw.strExtra = NULL;
cw.priv = NULL;
cw.owner = tablet;
cw.wordType = MSG_OTHER;
// TODO does fcitx free this?
cw.strWord = (char*) malloc(n+1);
memcpy(cw.strWord, &c[i], n);
cw.strWord[n] = 0;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &cw);
i += n;
} while(1);
return IRV_DISPLAY_CANDWORDS;
}
INPUT_RETURN_VALUE UnicodeGetCandWords(UnicodeModule* uni)
{
FcitxInputState *input = FcitxInstanceGetInputState(uni->owner);
FcitxInstanceCleanInputWindow(uni->owner);
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetPreedit(input),
MSG_INPUT, uni->buffer);
FcitxInputStateSetShowCursor(input, true);
FcitxInputStateSetCursorPos(input, strlen(uni->buffer));
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical);
UT_array* result = CharSelectDataFind(uni->charselectdata, uni->buffer);
utarray_foreach(c, result, uint32_t) {
char* s = fcitx_utils_malloc0(sizeof(char) * (UTF8_MAX_LENGTH + 1));
fcitx_ucs4_to_utf8(*c, s);
FcitxCandidateWord candWord;
candWord.callback = UnicodeGetCandWord;
candWord.owner = uni;
candWord.priv = NULL;
candWord.extraType = MSG_OTHER;
candWord.wordType = MSG_CODE;
candWord.strWord = s;
char* name = CharSelectDataName(uni->charselectdata, *c);
fcitx_utils_alloc_cat_str(candWord.strExtra, " ", name);
free(name);
FcitxCandidateWordAppend(candList, &candWord);
}
void IMSelectorGetCands(IMSelector* imselector)
{
FcitxInstance* instance = imselector->owner;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
UT_array* imes = FcitxInstanceGetIMEs(instance);
FcitxInstanceCleanInputWindow(instance);
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
FcitxCandidateWordSetPageSize(candList, 10);
FcitxCandidateWordSetChoose(candList, DIGIT_STR_CHOOSE);
FcitxInputStateSetShowCursor(input, false);
FcitxCandidateWordSetOverrideDefaultHighlight(candList, false);
FcitxCandidateWordSetLayoutHint(candList, CLH_Vertical);
FcitxIM* im = FcitxInstanceGetCurrentIM(instance);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance);
FcitxInputContext2* ic2 = (FcitxInputContext2*) ic;
if (!ic)
return;
FcitxMessages *aux_up = FcitxInputStateGetAuxUp(input);
FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS, imselector->global ?
_("Select global input method: ") :
_("Select local input method: "));
if (ic2->imname) {
int idx = FcitxInstanceGetIMIndexByName(instance, ic2->imname);
FcitxIM *im = fcitx_array_eltptr(imes, idx);
if (im) {
FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS,
_("Current local input method is "), im->strName);
}
} else {
FcitxMessagesAddMessageStringsAtLast(aux_up, MSG_TIPS,
_("No local input method"));
}
utarray_foreach(pim, imes, FcitxIM) {
FcitxCandidateWord candWord;
candWord.callback = IMSelectorGetCand;
candWord.owner = imselector;
candWord.strExtra = NULL;
if (ic2->imname && strcmp(ic2->imname, pim->uniqueName) == 0) {
candWord.priv = NULL;
candWord.strWord = strdup(_("Clear local input method"));
}
else {
candWord.priv = strdup(pim->uniqueName);
candWord.strWord = strdup(pim->strName);
}
if (im && strcmp(im->uniqueName, pim->uniqueName) == 0) {
candWord.wordType = MSG_CANDIATE_CURSOR;
} else {
candWord.wordType = MSG_OTHER;
}
FcitxCandidateWordAppend(candList, &candWord);
}
void IMSelectorGetCands(IMSelector* imselector)
{
FcitxInstance* instance = imselector->owner;
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxIM* pim;
UT_array* imes = FcitxInstanceGetIMEs(instance);
FcitxInstanceCleanInputWindow(instance);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), 10);
FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);
FcitxInputStateSetShowCursor(input, false);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance);
FcitxInputContext2* ic2 = (FcitxInputContext2*) ic;
if (!ic)
return;
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input),
MSG_TIPS, imselector->global ?
_("Select global input method: ") :
_("Select local input method: "));
if (ic2->imname) {
int idx = FcitxInstanceGetIMIndexByName(instance, ic2->imname);
FcitxIM* im = (FcitxIM*) utarray_eltptr(imes, idx);
if (im) {
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, _("Current local input method is %s"), im->strName);
}
}
else {
FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input),
MSG_TIPS,
_("No local input method"));
}
for (pim = (FcitxIM *) utarray_front(imes);
pim != NULL;
pim = (FcitxIM *) utarray_next(imes, pim)) {
FcitxCandidateWord candWord;
candWord.callback = IMSelectorGetCand;
candWord.owner = imselector;
candWord.strExtra = NULL;
if (ic2->imname && strcmp(ic2->imname, pim->uniqueName) == 0) {
candWord.priv = NULL;
candWord.strWord = strdup(_("Clear local input method"));
}
else {
candWord.priv = strdup(pim->uniqueName);
candWord.strWord = strdup(pim->strName);
}
candWord.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
}
void SwitchVK(FcitxVKState *vkstate)
{
FcitxInstance* instance = vkstate->owner;
if (vkstate->vkWindow == NULL)
vkstate->vkWindow = CreateVKWindow(vkstate);
VKWindow *vkWindow = vkstate->vkWindow;
if (!vkstate->iVKCount)
return;
vkstate->bVK = !vkstate->bVK;
if (vkstate->bVK) {
int x, y;
int dwidth, dheight;
InvokeVaArgs(vkstate->owner, FCITX_X11, GETSCREENSIZE,
&dwidth, &dheight);
if (!FcitxUISupportMainWindow(instance)) {
x = dwidth / 2 - VK_WINDOW_WIDTH / 2;
y = 40;
} else {
int mx = 0, my = 0, mw = 0, mh = 0;
FcitxUIGetMainWindowSize(instance, &mx, &my, &mw, &mh);
x = mx;
y = my + mh + 2;
if ((y + VK_WINDOW_HEIGHT) >= dheight)
y = my - VK_WINDOW_HEIGHT - 2;
if (y < 0)
y = 0;
}
if ((x + VK_WINDOW_WIDTH) >= dwidth)
x = dwidth - VK_WINDOW_WIDTH - 1;
if (x < 0)
x = 0;
XMoveWindow(vkWindow->dpy, vkWindow->window, x, y);
DisplayVKWindow(vkWindow);
FcitxUICloseInputWindow(instance);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance);
if (ic && FcitxInstanceGetCurrentState(instance) == IS_CLOSED)
FcitxInstanceEnableIM(instance, ic, true);
} else {
XUnmapWindow(vkWindow->dpy, vkWindow->window);
FcitxInstanceCleanInputWindow(instance);
FcitxUIUpdateInputWindow(instance);
}
}
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"));
}
void _QuickPhraseLaunch(QuickPhraseState* qpstate)
{
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
char c[2];
QuickPhraseFillKeyString(qpstate, c);
FcitxInstanceCleanInputWindow(qpstate->owner);
ShowQuickPhraseMessage(qpstate);
if (c[0]) {
int s = qpstate->curTriggerKey[0].sym;
char *strTemp = FcitxPuncGetPunc(qpstate->owner, &s);
const char* full = strTemp ? strTemp : c;
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, _("Space for %s Enter for %s") , full, c);
}
qpstate->enabled = true;
}
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 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;
}
FCITX_EXPORT_API
void FcitxUICloseInputWindow(FcitxInstance* instance)
{
FcitxInstanceCleanInputWindow(instance);
instance->uiflag |= UI_UPDATE;
}
/**
* @brief function DoInput has done everything for us.
*
* @param searchMode
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxChewingGetCandWords(void* arg)
{
FcitxChewing* chewing = (FcitxChewing*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(chewing->owner);
FcitxMessages *msgPreedit = FcitxInputStateGetPreedit(input);
FcitxMessages *clientPreedit = FcitxInputStateGetClientPreedit(input);
ChewingContext * c = chewing->context;
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(chewing->owner);
chewing_set_candPerPage(c, config->iMaxCandWord);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);
//clean up window asap
FcitxInstanceCleanInputWindow(chewing->owner);
char * buf_str = chewing_buffer_String(c);
char * zuin_str = chewing_zuin_String(c, NULL);
ConfigChewing(chewing);
FcitxLog(DEBUG, "%s %s", buf_str, zuin_str);
/* if not check done, so there is candidate word */
if (!chewing_cand_CheckDone(c)) {
//get candidate word
chewing_cand_Enumerate(c);
int index = 0;
while (chewing_cand_hasNext(c)) {
char* str = chewing_cand_String(c);
FcitxCandidateWord cw;
ChewingCandWord* w = (ChewingCandWord*) fcitx_utils_malloc0(sizeof(ChewingCandWord));
w->index = index;
cw.callback = FcitxChewingGetCandWord;
cw.owner = chewing;
cw.priv = w;
cw.strExtra = NULL;
cw.strWord = strdup(str);
cw.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &cw);
chewing_free(str);
index ++;
}
}
// setup cursor
FcitxInputStateSetShowCursor(input, true);
int buf_len = chewing_buffer_Len(c);
int cur = chewing_cursor_Current(c);
FcitxLog(DEBUG, "buf len: %d, cur: %d", buf_len, cur);
int rcur = FcitxChewingGetRawCursorPos(buf_str, cur);
FcitxInputStateSetCursorPos(input, rcur);
FcitxInputStateSetClientCursorPos(input, rcur);
// insert zuin in the middle
char * half1 = strndup(buf_str, rcur);
char * half2 = strdup(buf_str + rcur);
FcitxMessagesAddMessageAtLast(msgPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2);
FcitxMessagesAddMessageAtLast(clientPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2);
chewing_free(buf_str); chewing_free(zuin_str); free(half1); free(half2);
return IRV_DISPLAY_CANDWORDS;
}
INPUT_RETURN_VALUE FcitxRimeGetCandWords(void* arg)
{
FcitxRime *rime = (FcitxRime *)arg;
FcitxInputState *input = FcitxInstanceGetInputState(rime->owner);
FcitxInstanceCleanInputWindow(rime->owner);
RIME_STRUCT(RimeContext, context);
if (!rime->api->get_context(rime->session_id, &context)) {
return IRV_DISPLAY_CANDWORDS;
}
if (context.composition.length == 0) {
rime->api->free_context(&context);
return IRV_DISPLAY_CANDWORDS;
}
FcitxMessages* msgPreedit = FcitxInputStateGetPreedit(input);
FcitxMessages* msgClientPreedit = FcitxInputStateGetClientPreedit(input);
FcitxInputStateSetShowCursor(input, true);
FcitxInputStateSetCursorPos(input, context.composition.cursor_pos);
if (context.commit_text_preview) {
FcitxInputStateSetClientCursorPos(input, strlen(context.commit_text_preview));
}
/* converted text */
if (context.composition.sel_start > 0) {
char* temp = strndup(context.composition.preedit, context.composition.sel_start);
FcitxMessagesAddMessageAtLast(msgPreedit, MSG_OTHER, "%s", temp);
free(temp);
if (context.commit_text_preview) {
temp = strndup(context.commit_text_preview, context.composition.sel_start);
FcitxMessagesAddMessageAtLast(msgClientPreedit, MSG_INPUT, "%s", temp);
free(temp);
}
}
/* converting candidate */
if (context.composition.sel_start < context.composition.sel_end) {
char* temp = strndup(&context.composition.preedit[context.composition.sel_start], context.composition.sel_end - context.composition.sel_start);
FcitxMessagesAddMessageAtLast(msgPreedit, MSG_HIGHLIGHT | MSG_CODE, "%s", temp);
free(temp);
if (context.commit_text_preview) {
FcitxMessagesAddMessageAtLast(msgClientPreedit, MSG_HIGHLIGHT, "%s", &context.commit_text_preview[context.composition.sel_start]);
}
}
/* remaining input to convert */
if (context.composition.sel_end < strlen(context.composition.preedit)) {
FcitxMessagesAddMessageAtLast(msgPreedit, MSG_CODE, "%s", &context.composition.preedit[context.composition.sel_end]);
}
if (context.menu.num_candidates)
{
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
const char* digit = DIGIT_STR_CHOOSE;
char strChoose[11];
strChoose[10] = '\0';
FcitxCandidateWordSetPageSize(candList, 10);
int num_select_keys = context.menu.select_keys ? strlen(context.menu.select_keys) : 0;
int i;
for (i = 0; i < context.menu.num_candidates; ++i) {
FcitxCandidateWord candWord;
candWord.strWord = strdup (context.menu.candidates[i].text);
if (i == context.menu.highlighted_candidate_index)
candWord.wordType = MSG_CANDIATE_CURSOR;
else
candWord.wordType = MSG_OTHER;
candWord.strExtra = context.menu.candidates[i].comment ? strdup (context.menu.candidates[i].comment) : NULL;
candWord.extraType = MSG_CODE;
candWord.callback = FcitxRimeGetCandWord;
candWord.owner = rime;
int* priv = fcitx_utils_new(int);
*priv = i;
candWord.priv = priv;
FcitxCandidateWordAppend(candList, &candWord);
if (i < 10) {
if (i < num_select_keys) {
strChoose[i] = context.menu.select_keys[i];
}
else {
strChoose[i] = digit[i];
}
}
}
FcitxCandidateWordSetChoose(candList, strChoose);
FcitxCandidateWordSetOverridePaging(candList, context.menu.page_no != 0, !context.menu.is_last_page, FcitxRimePaging, rime, NULL);
}
INPUT_RETURN_VALUE FcitxKkcGetCandWords(void* arg)
{
FcitxKkc *kkc = (FcitxKkc*)arg;
FcitxInputState* input = FcitxInstanceGetInputState(kkc->owner);
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
FcitxMessages* clientPreedit = FcitxInputStateGetClientPreedit(input);
FcitxMessages* preedit = FcitxInputStateGetPreedit(input);
FcitxInstanceCleanInputWindow(kkc->owner);
FcitxMessages* message = FcitxInstanceICSupportPreedit(kkc->owner, FcitxInstanceGetCurrentIC(kkc->owner)) ? clientPreedit : preedit;
FcitxCandidateWordSetChoose(candList, DIGIT_STR_CHOOSE);
FcitxCandidateWordSetPageSize(candList, kkc->config.pageSize);
FcitxCandidateWordSetLayoutHint(candList, kkc->config.candidateLayout);
FcitxInputStateSetShowCursor(input, true);
KkcSegmentList* segments = kkc_context_get_segments(kkc->context);
if (kkc_segment_list_get_cursor_pos(segments) >= 0) {
int i = 0;
int offset = 0;
for (i = 0; i < kkc_segment_list_get_size(segments); i ++) {
KkcSegment* segment = kkc_segment_list_get(segments, i);
const gchar* str = kkc_segment_get_output(segment);
FcitxMessageType messageType = MSG_INPUT;
if (i < kkc_segment_list_get_cursor_pos(segments)) {
offset += strlen(str);
}
if (i == kkc_segment_list_get_cursor_pos(segments)) {
messageType = (FcitxMessageType) (MSG_HIGHLIGHT | MSG_OTHER);
}
FcitxMessagesAddMessageAtLast(message, messageType, "%s", str);
}
if (message == clientPreedit) {
FcitxInputStateSetClientCursorPos(input, offset);
} else {
FcitxInputStateSetCursorPos(input, offset);
}
} else {
gchar* str = kkc_context_get_input(kkc->context);
if (str && str[0]) {
FcitxMessagesAddMessageAtLast(message, MSG_INPUT, "%s", str);
if (message == clientPreedit) {
FcitxInputStateSetClientCursorPos(input, strlen(str));
} else {
FcitxInputStateSetCursorPos(input, strlen(str));
}
}
g_free(str);
}
KkcCandidateList* kkcCandidates = kkc_context_get_candidates(kkc->context);
if (kkc_candidate_list_get_page_visible(kkcCandidates)) {
int i, j;
guint size = kkc_candidate_list_get_size(kkcCandidates);
gint cursor_pos = kkc_candidate_list_get_cursor_pos(kkcCandidates);
guint page_start = kkc_candidate_list_get_page_start(kkcCandidates);
guint page_size = kkc_candidate_list_get_page_size(kkcCandidates);
for (i = kkc_candidate_list_get_page_start(kkcCandidates), j = 0; i < size; i ++, j++) {
FcitxCandidateWord word;
word.callback = FcitxKkcGetCandWord;
word.extraType = MSG_OTHER;
word.owner = kkc;
int* id = fcitx_utils_new(int);
*id = j;
word.priv = id;
word.strExtra = NULL;
word.strExtra = MSG_TIPS;
KkcCandidate* kkcCandidate = kkc_candidate_list_get(kkcCandidates, i);
if (kkc->config.showAnnotation && kkc_candidate_get_annotation(kkcCandidate)) {
fcitx_utils_alloc_cat_str(word.strExtra, " [", kkc_candidate_get_annotation(kkcCandidate), "]");
}
word.strWord = strdup(kkc_candidate_get_text(kkcCandidate));
if (i == cursor_pos) {
word.wordType = MSG_CANDIATE_CURSOR;
} else {
word.wordType = MSG_OTHER;
}
FcitxCandidateWordAppend(candList, &word);
}
FcitxCandidateWordSetFocus(candList, cursor_pos - page_start);
FcitxCandidateWordSetOverridePaging(candList,
(cursor_pos - page_start) >= page_size,
(size - page_start) / page_size != (cursor_pos - page_start) / page_size,
FcitxKkcPaging,
kkc,
NULL);
}
if (kkc_context_has_output(kkc->context)) {
gchar* str = kkc_context_poll_output(kkc->context);
FcitxInstanceCommitString(kkc->owner, FcitxInstanceGetCurrentIC(kkc->owner), str);
g_free(str);
}
return IRV_DISPLAY_CANDWORDS;
}
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;
}
