void FcitxKkcOnClose(void* arg, FcitxIMCloseEventType event)
{
FcitxKkc *kkc = (FcitxKkc*)arg;
if (event == CET_LostFocus) {
// TODO
} else if (event == CET_ChangeByUser) {
kkc_context_reset(kkc->context);
} else if (event == CET_ChangeByInactivate) {
KkcSegmentList* segments = kkc_context_get_segments(kkc->context);
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(kkc->owner);
if (config->bSendTextWhenSwitchEng) {
FcitxMessagesSetMessageCount(kkc->tempMsg, 0);
if (kkc_segment_list_get_cursor_pos(segments) >= 0) {
int i = 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);
FcitxMessagesAddMessageAtLast(kkc->tempMsg, MSG_INPUT, "%s", str);
}
} else {
gchar* str = kkc_context_get_input(kkc->context);
FcitxMessagesAddMessageAtLast(kkc->tempMsg, MSG_INPUT, "%s", str);
g_free(str);
}
if (FcitxMessagesGetMessageCount(kkc->tempMsg) > 0) {
char* commit = FcitxUIMessagesToCString(kkc->tempMsg);
FcitxInstanceCommitString(kkc->owner, FcitxInstanceGetCurrentIC(kkc->owner), commit);
free(commit);
}
}
kkc_context_reset(kkc->context);
}
}
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));
}
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 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
Conversion::update_preedit (void)
{
FcitxMessages* preedit;
if (m_anthy.support_client_preedit())
preedit = m_anthy.get_client_preedit();
else
preedit = m_anthy.get_preedit();
unsigned int seg_id;
ConversionSegments::iterator it;
for (it = m_segments.begin (), seg_id = 0;
it != m_segments.end ();
it++, seg_id++)
{
// create attribute for this segment
if (it->get_string().length () <= 0) {
continue;
}
FcitxMessageType type;
if ((int) seg_id == m_cur_segment) {
type = (FcitxMessageType) (MSG_HIGHLIGHT | MSG_CODE);
} else {
type = (FcitxMessageType) MSG_INPUT;
}
FcitxMessagesAddMessageAtLast(preedit, type, "%s", it->get_string().c_str());
}
}
static void
CloudSetClientPreedit(FcitxCloudPinyin *cloudpinyin, const char *str)
{
FcitxInputState *input = FcitxInstanceGetInputState(cloudpinyin->owner);
FcitxMessages *message = FcitxInputStateGetClientPreedit(input);
char *py;
char *string = GetCurrentString(cloudpinyin, &py);
FcitxMessagesSetMessageCount(message, 0);
if (py) {
*py = '\0';
FcitxMessagesAddMessageAtLast(message, MSG_INPUT, "%s%s", string, str);
} else {
FcitxMessagesAddMessageAtLast(message, MSG_INPUT, "%s", str);
}
fcitx_utils_free(string);
FcitxInstanceUpdateClientSideUI(
cloudpinyin->owner, FcitxInstanceGetCurrentIC(cloudpinyin->owner));
}
FCITX_EXPORT_API
int FcitxUINewMessageToOldStyleMessage(FcitxInstance* instance, FcitxMessages* msgUp, FcitxMessages* msgDown)
{
int i = 0;
FcitxInputState* input = instance->input;
int extraLength = input->iCursorPos;
FcitxMessagesSetMessageCount(msgUp, 0);
FcitxMessagesSetMessageCount(msgDown, 0);
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgAuxUp) ; i ++) {
FcitxMessagesAddMessageAtLast(msgUp, FcitxMessagesGetMessageType(input->msgAuxUp, i), "%s", FcitxMessagesGetMessageString(input->msgAuxUp, i));
extraLength += strlen(FcitxMessagesGetMessageString(input->msgAuxUp, i));
}
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgPreedit) ; i ++)
FcitxMessagesAddMessageAtLast(msgUp, FcitxMessagesGetMessageType(input->msgPreedit, i), "%s", FcitxMessagesGetMessageString(input->msgPreedit, i));
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgAuxDown) ; i ++)
FcitxMessagesAddMessageAtLast(msgDown, FcitxMessagesGetMessageType(input->msgAuxDown, i), "%s", FcitxMessagesGetMessageString(input->msgAuxDown, i));
FcitxCandidateWord* candWord = NULL;
for (candWord = FcitxCandidateWordGetCurrentWindow(input->candList), i = 0;
candWord != NULL;
candWord = FcitxCandidateWordGetCurrentWindowNext(input->candList, candWord), i ++) {
char strTemp[3] = { '\0', '\0', '\0' };
strTemp[0] = FcitxCandidateWordGetChoose(input->candList)[i];
if (instance->config->bPointAfterNumber)
strTemp[1] = '.';
unsigned int mod = FcitxCandidateWordGetModifier(input->candList);
FcitxMessagesAddMessageAtLast(msgDown, MSG_INDEX, "%s%s%s%s%s",
(mod & FcitxKeyState_Super) ? "M-" : "",
(mod & FcitxKeyState_Ctrl) ? "C-" : "",
(mod & FcitxKeyState_Alt) ? "A-" : "",
(mod & FcitxKeyState_Shift) ? "S-" : "",
strTemp);
FcitxMessageType type = candWord->wordType;
if (i == 0
&& FcitxCandidateWordGetCurrentPage(input->candList) == 0
&& type == MSG_OTHER
&& !FcitxInstanceGetContextBoolean(instance, CONTEXT_DISABLE_AUTO_FIRST_CANDIDATE_HIGHTLIGHT)
)
type = MSG_FIRSTCAND;
FcitxMessagesAddMessageAtLast(msgDown, type, "%s", candWord->strWord);
if (candWord->strExtra && strlen(candWord->strExtra) != 0)
FcitxMessagesAddMessageAtLast(msgDown, candWord->extraType, "%s", candWord->strExtra);
FcitxMessagesAddMessageAtLast(msgDown, MSG_OTHER, " ");
}
return extraLength;
}
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);
}
}
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;
}
FCITX_EXPORT_API
int FcitxUINewMessageToOldStyleMessage(FcitxInstance* instance, FcitxMessages* msgUp, FcitxMessages* msgDown)
{
int i = 0;
FcitxInputState* input = instance->input;
int extraLength = input->iCursorPos;
FcitxMessagesSetMessageCount(msgUp, 0);
FcitxMessagesSetMessageCount(msgDown, 0);
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgAuxUp) ; i ++) {
FcitxMessagesAddMessageAtLast(msgUp, FcitxMessagesGetMessageType(input->msgAuxUp, i), "%s", FcitxMessagesGetMessageString(input->msgAuxUp, i));
extraLength += strlen(FcitxMessagesGetMessageString(input->msgAuxUp, i));
}
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgPreedit) ; i ++)
FcitxMessagesAddMessageAtLast(msgUp, FcitxMessagesGetMessageType(input->msgPreedit, i), "%s", FcitxMessagesGetMessageString(input->msgPreedit, i));
for (i = 0; i < FcitxMessagesGetMessageCount(input->msgAuxDown) ; i ++)
FcitxMessagesAddMessageAtLast(msgDown, FcitxMessagesGetMessageType(input->msgAuxDown, i), "%s", FcitxMessagesGetMessageString(input->msgAuxDown, i));
FcitxCandidateWord* candWord = NULL;
for (candWord = FcitxCandidateWordGetCurrentWindow(input->candList), i = 0;
candWord != NULL;
candWord = FcitxCandidateWordGetCurrentWindowNext(input->candList, candWord), i ++) {
char strTemp[3] = { '\0', '\0', '\0' };
strTemp[0] = FcitxCandidateWordGetChoose(input->candList)[i];
if (instance->config->bPointAfterNumber)
strTemp[1] = '.';
FcitxMessagesAddMessageAtLast(msgDown, MSG_INDEX, "%s", strTemp);
FcitxMessageType type = candWord->wordType;
if (i == 0
&& FcitxCandidateWordGetCurrentPage(input->candList) == 0
&& type == MSG_OTHER)
type = MSG_FIRSTCAND;
FcitxMessagesAddMessageAtLast(msgDown, type, "%s", candWord->strWord);
if (candWord->strExtra && strlen(candWord->strExtra) != 0)
FcitxMessagesAddMessageAtLast(msgDown, candWord->extraType, "%s", candWord->strExtra);
FcitxMessagesAddMessageAtLast(msgDown, MSG_OTHER, " ");
}
return extraLength;
}
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;
}
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;
}
/**
* @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;
}
void FcitxLibpinyinUpdatePreedit(FcitxLibpinyin* libpinyin, char* sentence)
{
FcitxInstance* instance = libpinyin->owner->owner;
FcitxInputState* input = FcitxInstanceGetInputState(instance);
int offset = LibpinyinGetOffset(libpinyin);
if (libpinyin->type == LPT_Pinyin) {
int libpinyinLen = strlen(libpinyin->inst->m_raw_full_pinyin);
int fcitxLen = strlen(libpinyin->buf);
if (fcitxLen != libpinyinLen) {
strcpy(libpinyin->buf, libpinyin->inst->m_raw_full_pinyin);
libpinyin->cursor_pos += libpinyinLen - fcitxLen;
}
}
int pyoffset = LibpinyinGetPinyinOffset(libpinyin);
if (pyoffset > libpinyin->cursor_pos)
libpinyin->cursor_pos = pyoffset;
int hzlen = 0;
if (fcitx_utf8_strlen(sentence) > offset)
hzlen = fcitx_utf8_get_nth_char(sentence, offset) - sentence;
else
hzlen = strlen(sentence);
if (hzlen > 0) {
char* buf = (char*) fcitx_utils_malloc0((hzlen + 1) * sizeof(char));
strncpy(buf, sentence, hzlen);
buf[hzlen] = 0;
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_INPUT, "%s", buf);
free(buf);
}
int charcurpos = hzlen;
int lastpos = pyoffset;
int curoffset = pyoffset;
for (int i = offset; i < libpinyin->inst->m_pinyin_keys->len; i ++)
{
PinyinKey* pykey = &g_array_index(libpinyin->inst->m_pinyin_keys, PinyinKey, i);
PinyinKeyPos* pykeypos = &g_array_index(libpinyin->inst->m_pinyin_key_rests, PinyinKeyPos, i);
if (lastpos > 0) {
FcitxMessagesMessageConcatLast (FcitxInputStateGetPreedit(input), " ");
if (curoffset < libpinyin->cursor_pos)
charcurpos ++;
for (int j = lastpos; j < pykeypos->m_raw_begin; j ++) {
char temp[2] = {'\0', '\0'};
temp[0] = libpinyin->buf[j];
FcitxMessagesMessageConcatLast (FcitxInputStateGetPreedit(input), temp);
if (curoffset < libpinyin->cursor_pos)
{
curoffset ++;
charcurpos ++;
}
}
}
lastpos = pykeypos->m_raw_end;
switch (libpinyin->type) {
case LPT_Pinyin: {
gchar* pystring = pykey->get_pinyin_string();
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_CODE, "%s", pystring);
size_t pylen = strlen(pystring);
if (curoffset + pylen < libpinyin->cursor_pos) {
curoffset += pylen;
charcurpos += pylen;
}
else {
charcurpos += libpinyin->cursor_pos - curoffset;
curoffset = libpinyin->cursor_pos;
}
g_free(pystring);
break;
}
case LPT_Shuangpin: {
if (pykeypos->length() == 2) {
const char* initial = 0;
if (pykey->m_initial == CHEWING_ZERO_INITIAL)
initial = "'";
else
initial = get_initial_string(pykey);
if (curoffset + 1 <= libpinyin->cursor_pos) {
curoffset += 1;
charcurpos += strlen(initial);
}
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_CODE, "%s", initial);
if (curoffset + 1 <= libpinyin->cursor_pos) {
curoffset += 1;
charcurpos += strlen(get_middle_string(pykey)) + strlen(get_final_string(pykey));
}
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_CODE, "%s%s", get_middle_string(pykey), get_final_string(pykey));
}
else if (pykeypos->length() == 1) {
gchar* pystring = pykey->get_pinyin_string();
if (curoffset + 1 <= libpinyin->cursor_pos) {
curoffset += 1;
charcurpos += strlen(pystring);
}
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_CODE, "%s", pystring);
g_free(pystring);
}
break;
}
case LPT_Zhuyin: {
gchar* pystring = pykey->get_chewing_string();
FcitxMessagesAddMessageAtLast(FcitxInputStateGetPreedit(input), MSG_CODE, "%s", pystring);
if (curoffset + pykeypos->length() <= libpinyin->cursor_pos) {
curoffset += pykeypos->length();
charcurpos += strlen(pystring);
}
else {
int diff = libpinyin->cursor_pos - curoffset;
curoffset = libpinyin->cursor_pos;
size_t len = fcitx_utf8_strlen(pystring);
if (pykey->m_tone != CHEWING_ZERO_TONE)
len --;
if (diff > len)
charcurpos += strlen(pystring);
else {
charcurpos += fcitx_utf8_get_nth_char(pystring, diff) - pystring;
}
}
g_free(pystring);
break;
}
}
}
int buflen = strlen(libpinyin->buf);
if (lastpos < buflen) {
FcitxMessagesMessageConcatLast (FcitxInputStateGetPreedit(input), " ");
if (lastpos < libpinyin->cursor_pos)
charcurpos ++;
for (int i = lastpos; i < buflen; i ++)
{
char temp[2] = {'\0', '\0'};
temp[0] = libpinyin->buf[i];
FcitxMessagesMessageConcatLast (FcitxInputStateGetPreedit(input), temp);
if (lastpos < libpinyin->cursor_pos) {
charcurpos ++;
lastpos++;
}
}
}
FcitxInputStateSetCursorPos(input, charcurpos);
}
/**
* @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;
}
