int main()
{
char* words[] = { "a", "b", "c" , "d", "e" };
char* extras[] = { "A", "B", "C" , "D", "E" };
FcitxInstance* instance = fcitx_utils_malloc0(sizeof(FcitxInstance));
instance->input = fcitx_utils_malloc0(sizeof(FcitxInputState));
instance->input->candList = FcitxCandidateWordNewList();
instance->config = fcitx_utils_malloc0(sizeof(FcitxGlobalConfig));
instance->config->bPointAfterNumber = true;
FcitxCandidateWord word;
word.callback = NULL;
word.owner = NULL;
word.priv = NULL;
int i = 0;
for (i = 0; i < 5; i ++) {
word.strWord = strdup(words[i]);
word.strExtra = strdup(extras[i]);
FcitxCandidateWordAppend(instance->input->candList, &word);
}
char* result = FcitxUICandidateWordToCString(instance);
if (strcmp(result, "1.aA 2.bB 3.cC 4.dD 5.eE ") == 0) {
return 0;
}
return 1;
}
char* BaiduParsePinyin(FcitxCloudPinyin* cloudpinyin, CurlQueue* queue)
{
char *start = NULL, *end = NULL;
static iconv_t conv = 0;
if (conv == 0)
conv = iconv_open("utf-8", "utf-16be");
if (conv == (iconv_t)(-1))
return NULL;
if ((start = strstr(queue->str, "[[[\"")) != NULL)
{
start += strlen( "[[[\"");
if ((end = strstr(start, "\",")) != NULL)
{
size_t length = end - start;
if (length % 6 != 0 || length == 0)
return NULL;
size_t i = 0, j = 0;
char* buf = fcitx_utils_malloc0((length / 6 + 1) * 2);
while (i < length)
{
if (start[i] == '\\' && start[i+1] == 'u')
{
if (ishex(start[i+2]) && ishex(start[i+3]) && ishex(start[i+4]) && ishex(start[i+5]))
{
buf[j++] = (tohex(start[i+2]) << 4) | tohex(start[i+3]);
buf[j++] = (tohex(start[i+4]) << 4) | tohex(start[i+5]);
}
else
break;
}
i += 6;
}
if (i != length)
{
free(buf);
return NULL;
}
buf[j++] = 0;
buf[j++] = 0;
size_t len = UTF8_MAX_LENGTH * (length / 6) * sizeof(char);
char* realstring = fcitx_utils_malloc0(UTF8_MAX_LENGTH * (length / 6) * sizeof(char));
IconvStr p = buf; char *pp = realstring;
iconv(conv, &p, &j, &pp, &len);
free(buf);
if (fcitx_utf8_check_string(realstring))
return realstring;
else
{
free(realstring);
return NULL;
}
}
}
return NULL;
}
void* FullWidthCharCreate(FcitxInstance* instance)
{
FcitxFullWidthChar* fwchar = fcitx_utils_malloc0(sizeof(FcitxFullWidthChar));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
fwchar->owner = instance;
FcitxStringFilterHook hk;
hk.arg = fwchar;
hk.func = ProcessFullWidthChar;
FcitxInstanceRegisterCommitFilter(instance, hk);
FcitxKeyFilterHook phk;
phk.arg = fwchar;
phk.func = FullWidthPostFilter;
FcitxInstanceRegisterPostInputFilter(instance, phk);
FcitxHotkeyHook hotkey;
hotkey.hotkey = config->hkFullWidthChar;
hotkey.hotkeyhandle = ToggleFullWidthStateWithHotkey;
hotkey.arg = fwchar;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxUIRegisterStatus(instance, fwchar, "fullwidth", _("Full Width Character"), _("Full Width Character"), ToggleFullWidthState, GetFullWidthState);
return fwchar;
}
char* ProcessFullWidthChar(void* arg, const char* str)
{
FcitxFullWidthChar* fwchar = (FcitxFullWidthChar*)arg;
FcitxProfile* profile = FcitxInstanceGetProfile(fwchar->owner);
if (profile->bUseFullWidthChar) {
size_t i = 0, ret_len = 0, len = fcitx_utf8_strlen(str);
char* ret = (char *) fcitx_utils_malloc0(sizeof(char) * (UTF8_MAX_LENGTH * len + 1));
const char* ps = str;
ret[0] = '\0';
for (; i < len; ++i) {
int wc;
int chr_len = fcitx_utf8_char_len(ps);
char *nps;
nps = fcitx_utf8_get_char(ps , &wc);
if (chr_len == 1 && ps[0] >= '\x20' && ps[0] <= '\x7e') {
strcat(ret, sCornerTrans[ps[0] - 32]);
ret_len += strlen(sCornerTrans[ps[0] - 32]);
} else {
strncat(ret, ps, chr_len);
ret_len += chr_len;
}
ps = nps;
}
ret[ret_len] = '\0';
return ret;
}
else
return NULL;
}
void* FullWidthCharCreate(FcitxInstance* instance)
{
FcitxFullWidthChar* fwchar = fcitx_utils_malloc0(sizeof(FcitxFullWidthChar));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
fwchar->owner = instance;
FcitxStringFilterHook hk;
hk.arg = fwchar;
hk.func = ProcessFullWidthChar;
FcitxInstanceRegisterCommitFilter(instance, hk);
FcitxKeyFilterHook phk;
phk.arg = fwchar;
phk.func = FullWidthPostFilter;
FcitxInstanceRegisterPostInputFilter(instance, phk);
FcitxHotkeyHook hotkey;
hotkey.hotkey = config->hkFullWidthChar;
hotkey.hotkeyhandle = ToggleFullWidthStateWithHotkey;
hotkey.arg = fwchar;
FcitxInstanceRegisterHotkeyFilter(instance, hotkey);
FcitxProfile* profile = FcitxInstanceGetProfile(instance);
FcitxUIRegisterStatus(instance, fwchar, "fullwidth",
profile->bUseFullWidthChar ? _("Full width Character") : _("Half width Character"),
_("Toggle Half/Full width Character"),
ToggleFullWidthState, GetFullWidthState);
FcitxInstanceRegisterWatchableContext(instance, CONTEXT_DISABLE_FULLWIDTH, FCT_Boolean, FCF_ResetOnInputMethodChange);
FcitxInstanceWatchContext(instance, CONTEXT_DISABLE_FULLWIDTH, DisableFullWidthCharChanged, fwchar);
return fwchar;
}
void CloudPinyinAddInputRequest(FcitxCloudPinyin* cloudpinyin, const char* strPinyin)
{
CURL* curl = CloudPinyinGetFreeCurlHandle(cloudpinyin);
if (!curl)
return;
CurlQueue* queue = fcitx_utils_malloc0(sizeof(CurlQueue)), *head = cloudpinyin->pendingQueue;
queue->curl = curl;
queue->next = NULL;
queue->type = RequestPinyin;
queue->pinyin = strdup(strPinyin);
queue->source = cloudpinyin->config.source;
char* urlstring = curl_escape(strPinyin, strlen(strPinyin));
char *url = NULL;
if (engine[cloudpinyin->config.source].RequestKey)
asprintf(&url, engine[cloudpinyin->config.source].RequestPinyin, cloudpinyin->key, urlstring);
else
asprintf(&url, engine[cloudpinyin->config.source].RequestPinyin, urlstring);
curl_free(urlstring);
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, queue);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CloudPinyinWriteFunction);
free(url);
/* push into pending queue */
pthread_mutex_lock(&cloudpinyin->pendingQueueLock);
while (head->next != NULL)
head = head->next;
head->next = queue;
pthread_mutex_unlock(&cloudpinyin->pendingQueueLock);
char c = 0;
write(cloudpinyin->pipeNotify, &c, sizeof(char));
}
void* IMSelectorCreate(FcitxInstance* instance)
{
IMSelector* imselector = fcitx_utils_malloc0(sizeof(IMSelector));
imselector->owner = instance;
if (!LoadIMSelectorConfig(imselector)) {
free(imselector);
return NULL;
}
FcitxKeyFilterHook hk;
hk.arg = imselector;
hk.func = IMSelectorPreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
FcitxHotkeyHook hkhk;
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorLocalTrigger;
hkhk.hotkey = imselector->localKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
hkhk.arg = imselector;
hkhk.hotkeyhandle = IMSelectorGlobalTrigger;
hkhk.hotkey = imselector->globalKey;
FcitxInstanceRegisterHotkeyFilter(instance, hkhk);
FcitxIMEventHook resethk;
resethk.arg = imselector;
resethk.func = IMSelectorReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
return imselector;
}
/**
* Interface for XIM Create Input Context
*
* @param context Input Context
* @param priv private data passed by CreateIC
* @return void
**/
void XimCreateIC(void* arg, FcitxInputContext* context, void *priv)
{
FcitxXimFrontend* xim = (FcitxXimFrontend*) arg;
IMChangeICStruct * call_data = (IMChangeICStruct *)priv;
context->privateic = fcitx_utils_malloc0(sizeof(FcitxXimIC));
FcitxXimIC* privic = (FcitxXimIC*) context->privateic;
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(xim->owner);
privic->connect_id = call_data->connect_id;
privic->id = ++ xim->icid;
privic->offset_x = -1;
privic->offset_y = -1;
StoreIC(privic, call_data);
SetTrackPos(xim, context, call_data);
call_data->icid = privic->id;
if (config->shareState == ShareState_PerProgram)
FcitxInstanceSetICStateFromSameApplication(xim->owner, xim->frontendid, context);
if (privic->input_style & XIMPreeditCallbacks)
context->contextCaps |= CAPACITY_PREEDIT;
else
context->contextCaps &= ~CAPACITY_PREEDIT;
return;
}
void* ChttransCreate(FcitxInstance* instance)
{
FcitxChttrans* transState = fcitx_utils_malloc0(sizeof(FcitxChttrans));
FcitxAddon* transAddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_CHTTRANS_NAME);
transState->owner = instance;
if (!LoadChttransConfig(transState)) {
free(transState);
return NULL;
}
FcitxHotkeyHook hk;
hk.arg = transState;
hk.hotkey = transState->hkToggle;
hk.hotkeyhandle = HotkeyToggleChttransState;
FcitxStringFilterHook shk;
shk.arg = transState;
shk.func = ChttransOutputFilter;
FcitxInstanceRegisterHotkeyFilter(instance, hk);
FcitxInstanceRegisterOutputFilter(instance, shk);
FcitxInstanceRegisterCommitFilter(instance, shk);
FcitxUIRegisterStatus(instance, transState, "chttrans",
transState->enabled ? _("Convert to Traditional Chinese") : _("Convert to Simplified Chinese"),
_("Toggle Simp/Trad Chinese Conversion"),
ToggleChttransState,
GetChttransEnabled);
FcitxInstanceWatchContext(instance, CONTEXT_IM_LANGUAGE, ChttransLanguageChanged, transState);
AddFunction(transAddon, ChttransS2T);
AddFunction(transAddon, ChttransT2S);
return transState;
}
size_t CloudPinyinWriteFunction(char *ptr, size_t size, size_t nmemb, void *userdata)
{
CurlQueue* queue = (CurlQueue*) userdata;
size_t realsize = size * nmemb;
/*
* We know that it isn't possible to overflow during multiplication if
* neither operand uses any of the most significant half of the bits in
* a size_t.
*/
if ((unsigned long long)((nmemb | size) &
((unsigned long long)SIZE_MAX << (sizeof(size_t) << 2))) &&
(realsize / size != nmemb))
return 0;
if (SIZE_MAX - queue->size - 1 < realsize)
realsize = SIZE_MAX - queue->size - 1;
if (queue->str != NULL)
queue->str = realloc(queue->str, queue->size + realsize + 1);
else
queue->str = fcitx_utils_malloc0(realsize + 1);
if (queue->str != NULL) {
memcpy(&(queue->str[queue->size]), ptr, realsize);
queue->size += realsize;
queue->str[queue->size] = '\0';
}
return realsize;
}
char* FcitxUIMessagesToCStringForCommit(FcitxMessages* messages)
{
int length = 0;
int i = 0;
int count = FcitxMessagesGetMessageCount(messages);
char *message_strs[count];
int msg_count = 0;
for (i = 0;i < count;i++) {
if ((FcitxMessagesGetClientMessageType(messages, i) &
MSG_DONOT_COMMIT_WHEN_UNFOCUS) == 0) {
char *msg_str = FcitxMessagesGetMessageString(messages, i);
message_strs[msg_count++] = msg_str;
length += strlen(msg_str);
}
}
char* str = fcitx_utils_malloc0(sizeof(char) * (length + 1));
for (i = 0;i < msg_count;i++) {
strcat(str, message_strs[i]);
}
return str;
}
void * QuickPhraseCreate(FcitxInstance *instance)
{
QuickPhraseState *qpstate = fcitx_utils_malloc0(sizeof(QuickPhraseState));
qpstate->owner = instance;
qpstate->enabled = false;
if (!LoadQuickPhraseConfig(&qpstate->config)) {
free(qpstate);
return NULL;
}
LoadQuickPhrase(qpstate);
FcitxKeyFilterHook hk;
hk.arg = qpstate;
hk.func = QuickPhrasePostFilter;
FcitxInstanceRegisterPostInputFilter(instance, hk);
hk.func = QuickPhrasePreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
FcitxIMEventHook resethk;
resethk.arg = qpstate;
resethk.func = QuickPhraseReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
FcitxInstanceRegisterWatchableContext(instance, CONTEXT_DISABLE_QUICKPHRASE, FCT_Boolean, FCF_ResetOnInputMethodChange);
FcitxAddon* addon = FcitxAddonsGetAddonByName(
FcitxInstanceGetAddons(instance),
FCITX_QUICKPHRASE_NAME);
FcitxModuleAddFunction(addon, QuickPhraseLaunch);
return qpstate;
}
static void IsoCodes639HandlerStartElement(void *ctx,
const xmlChar *name,
const xmlChar **atts)
{
FcitxIsoCodes* isocodes = ctx;
if (strcmp(XMLCHAR_CAST name, "iso_639_entry") == 0) {
FcitxIsoCodes639Entry* entry = fcitx_utils_malloc0(sizeof(FcitxIsoCodes639Entry));
int i = 0;
while(atts && atts[i*2] != 0) {
if (strcmp(XMLCHAR_CAST atts[i * 2], "iso_639_2B_code") == 0)
entry->iso_639_2B_code = strdup(XMLCHAR_CAST atts[i * 2 + 1]);
else if (strcmp(XMLCHAR_CAST atts[i * 2], "iso_639_2T_code") == 0)
entry->iso_639_2T_code = strdup(XMLCHAR_CAST atts[i * 2 + 1]);
else if (strcmp(XMLCHAR_CAST atts[i * 2], "iso_639_1_code") == 0)
entry->iso_639_1_code = strdup(XMLCHAR_CAST atts[i * 2 + 1]);
else if (strcmp(XMLCHAR_CAST atts[i * 2], "name") == 0)
entry->name = strdup(XMLCHAR_CAST atts[i * 2 + 1]);
i++;
}
if (!entry->iso_639_2B_code || !entry->iso_639_2T_code || !entry->name)
FcitxIsoCodes639EntryFree(entry);
else {
HASH_ADD_KEYPTR(hh1, isocodes->iso6392B, entry->iso_639_2B_code, strlen(entry->iso_639_2B_code), entry);
HASH_ADD_KEYPTR(hh2, isocodes->iso6392T, entry->iso_639_2T_code, strlen(entry->iso_639_2T_code), entry);
}
}
}
void _CloudPinyinAddCandidateWord(FcitxCloudPinyin* cloudpinyin, const char* pinyin)
{
CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, pinyin);
FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
int order = (cloudpinyin->config.iCandidateOrder <= 2) ?
1 : (cloudpinyin->config.iCandidateOrder - 1);
if (cacheEntry) {
FcitxCandidateWord* cand;
/* only check the first three page */
int pagesize = FcitxCandidateWordGetPageSize(candList);
int size = pagesize * CLOUDPINYIN_CHECK_PAGE_NUMBER;
int i;
if (cloudpinyin->config.iCandidateOrder <= 1) {
order = 0;
}
for (i = 0;i < size &&
(cand = FcitxCandidateWordGetByTotalIndex(candList, i));i++) {
if (strcmp(cand->strWord, cacheEntry->str) == 0) {
if (i > order && i >= pagesize) {
FcitxCandidateWordMoveByWord(candList, cand, order);
if (order == 0) {
CloudSetClientPreedit(cloudpinyin, cacheEntry->str);
}
}
return;
}
}
if (order == 0) {
CloudSetClientPreedit(cloudpinyin, cacheEntry->str);
}
}
FcitxCandidateWord candWord;
CloudCandWord* cloudCand = fcitx_utils_malloc0(sizeof(CloudCandWord));
if (cacheEntry) {
cloudCand->filled = true;
cloudCand->timestamp = 0;
candWord.strWord = strdup(cacheEntry->str);
} else {
cloudCand->filled = false;
cloudCand->timestamp = CloudGetTimeStamp();
candWord.strWord = strdup("..");
}
candWord.callback = CloudPinyinGetCandWord;
candWord.owner = cloudpinyin;
candWord.priv = cloudCand;
candWord.wordType = MSG_TIPS;
if (cloudpinyin->config.bDontShowSource)
candWord.strExtra = NULL;
else {
candWord.strExtra = strdup(_(" (via cloud)"));
candWord.extraType = MSG_TIPS;
}
FcitxCandidateWordInsert(candList, &candWord, order);
}
void * QuickPhraseCreate(FcitxInstance *instance)
{
QuickPhraseState *qpstate = fcitx_utils_malloc0(sizeof(QuickPhraseState));
qpstate->iFirstQuickPhrase = -1;
qpstate->owner = instance;
qpstate->enabled = false;
if (!LoadQuickPhraseConfig(qpstate)) {
free(qpstate);
return NULL;
}
LoadQuickPhrase(qpstate);
FcitxKeyFilterHook hk;
hk.arg = qpstate ;
hk.func = QuickPhrasePostFilter;
FcitxInstanceRegisterPostInputFilter(instance, hk);
hk.func = QuickPhrasePreFilter;
FcitxInstanceRegisterPreInputFilter(instance, hk);
FcitxIMEventHook resethk;
resethk.arg = qpstate;
resethk.func = QuickPhraseReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
FcitxInstanceRegisterWatchableContext(instance, CONTEXT_DISABLE_QUICKPHRASE, FCT_Boolean, FCF_ResetOnInputMethodChange);
return qpstate;
}
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);
}
FCITX_EXPORT_API
char* fcitx_utils_join_string_list(UT_array* list, char delm)
{
if (!list)
return NULL;
if (utarray_len(list) == 0)
return strdup("");
size_t len = 0;
char** str;
for (str = (char**) utarray_front(list);
str != NULL;
str = (char**) utarray_next(list, str))
{
len += strlen(*str) + 1;
}
char* result = (char*) fcitx_utils_malloc0(sizeof(char) * len);
char* p = result;
for (str = (char**) utarray_front(list);
str != NULL;
str = (char**) utarray_next(list, str))
{
size_t strl = strlen(*str);
strcpy(p, *str);
p[strl] = delm;
p += strl + 1;
}
result[len - 1] = '\0';
return result;
}
FcitxYaTableInfo* FcitxYaTableGetAllCFG()
{
FcitxYaTableInfo* head = NULL,* prev = NULL,* cur = NULL;
FcitxStringHashSet* configfiles = FcitxXDGGetFiles("yatable", NULL,
".conf");
HASH_FOREACH(file, configfiles, FcitxStringHashSet) {
FcitxConfigFileDesc* cfgdesc = FcitxYaTableConfigDesc();
if(cfgdesc == NULL) continue;
FILE* fcfg = FcitxXDGGetFileWithPrefix("yatable", file->name, "r",
NULL);
if(fcfg == NULL) continue;
FcitxConfigFile* cfgfile = FcitxConfigParseConfigFileFp(fcfg, cfgdesc);
cur = fcitx_utils_malloc0(sizeof(FcitxYaTableInfo));
cur->next = NULL;
if(head == NULL) {
head = cur;
} else {
prev->next = cur;
}
prev = cur;
YaTableInfoConfigBind(&(cur->info), cfgfile, cfgdesc);
FcitxConfigBindSync((FcitxGenericConfig*) &(cur->info));
FcitxConfigFreeConfigFile(cfgfile);
fclose(fcfg);
}
CharSelectData* CharSelectDataCreate()
{
CharSelectData* charselect = fcitx_utils_new(CharSelectData);
do {
FILE* fp = FcitxXDGGetFileWithPrefix("data", "charselectdata", "r", NULL);
if (!fp)
break;
fseek(fp, 0, SEEK_END);
long int size = ftell(fp);
fseek(fp, 0, SEEK_SET);
charselect->size = size;
charselect->dataFile = fcitx_utils_malloc0(size);
fread(charselect->dataFile, 1, size, fp);
fclose(fp);
CharSelectDataCreateIndex(charselect);
return charselect;
} while(0);
free(charselect);
return NULL;
}
void* LightUICreate(FcitxInstance* instance)
{
FcitxModuleFunctionArg arg;
FcitxLightUI* lightui = fcitx_utils_malloc0(sizeof(FcitxLightUI));
FcitxAddon* lightuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_LIGHT_UI_NAME);
lightui->owner = instance;
if (!LoadLightUIConfig(lightui))
{
free(lightui);
return NULL;
}
lightui->dpy = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);
if (lightui->dpy == NULL)
{
free(lightui);
return NULL;
}
lightui->isfallback = FcitxUIIsFallback(instance, lightuiaddon);
lightui->iScreen = DefaultScreen(lightui->dpy);
CreateFont(lightui);
lightui->protocolAtom = XInternAtom (lightui->dpy, "WM_PROTOCOLS", False);
lightui->killAtom = XInternAtom (lightui->dpy, "WM_DELETE_WINDOW", False);
/* Main Menu Initial */
FcitxMenuInit(&lightui->mainMenu);
FcitxUIMenu **menupp;
UT_array* uimenus = FcitxInstanceGetUIMenus(instance);
for (menupp = (FcitxUIMenu **) utarray_front(uimenus);
menupp != NULL;
menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)
)
{
FcitxUIMenu * menup = *menupp;
if (!menup->isSubMenu)
FcitxMenuAddMenuItem(&lightui->mainMenu, menup->name, MENUTYPE_SUBMENU, menup);
}
FcitxMenuAddMenuItem(&lightui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxMenuAddMenuItem(&lightui->mainMenu, _("Configure"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&lightui->mainMenu, _("Exit"), MENUTYPE_SIMPLE, NULL);
lightui->mainMenu.MenuAction = MainMenuAction;
lightui->mainMenu.priv = lightui;
lightui->mainMenu.mark = -1;
lightui->inputWindow = CreateInputWindow(lightui);
lightui->mainWindow = CreateMainWindow(lightui);
lightui->trayWindow = CreateTrayWindow(lightui);
lightui->mainMenuWindow = CreateMainMenuWindow(lightui);
FcitxIMEventHook resethk;
resethk.arg = lightui;
resethk.func = LightUIInputReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
return lightui;
}
FcitxLibpinyin* FcitxLibpinyinNew(FcitxLibpinyinAddonInstance* libpinyinaddon, LIBPINYIN_TYPE type)
{
FcitxLibpinyin* libpinyin = (FcitxLibpinyin*) fcitx_utils_malloc0(sizeof(FcitxLibpinyin));
libpinyin->inst = NULL;
libpinyin->fixed_string = g_array_new(FALSE, FALSE, sizeof(FcitxLibpinyinFixed));
libpinyin->type = type;
libpinyin->owner = libpinyinaddon;
return libpinyin;
}
/**
* @brief initialize the extra input method
*
* @param arg
* @return successful or not
**/
__EXPORT_API
void* FcitxChewingCreate(FcitxInstance* instance)
{
if (GetFcitxChewingConfigDesc() == NULL)
return NULL;
char* user_path = NULL;
FILE* fp = FcitxXDGGetFileUserWithPrefix("chewing", ".place_holder", "w", NULL);
if (fp)
fclose(fp);
FcitxXDGGetFileUserWithPrefix("chewing", "", NULL, &user_path);
FcitxLog(INFO, "Chewing storage path %s", user_path);
if (0 == chewing_Init(CHEWING_DATADIR, user_path)) {
FcitxLog(DEBUG, "chewing init ok");
} else {
FcitxLog(DEBUG, "chewing init failed");
return NULL;
}
FcitxChewing* chewing = (FcitxChewing*) fcitx_utils_malloc0(sizeof(FcitxChewing));
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
FcitxInputState *input = FcitxInstanceGetInputState(instance);
FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);
bindtextdomain("fcitx-chewing", LOCALEDIR);
chewing->context = chewing_new();
ChewingContext * c = chewing->context;
chewing->owner = instance;
chewing_set_ChiEngMode(c, CHINESE_MODE);
chewing_set_maxChiSymbolLen(c, 16);
// chewing will crash without set page
chewing_set_candPerPage(c, config->iMaxCandWord);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);
chewing_set_selKey(c, selKey, 10);
LoadChewingConfig(&chewing->config);
ConfigChewing(chewing);
FcitxInstanceRegisterIM(
instance,
chewing,
"chewing",
_("Chewing"),
"chewing",
FcitxChewingInit,
FcitxChewingReset,
FcitxChewingDoInput,
FcitxChewingGetCandWords,
NULL,
NULL,
FcitxChewingReloadConfig,
NULL,
1,
"zh_TW"
);
return chewing;
}
void TableCreateAutoPhrase(TableMetaData* tableMetaData, char iCount)
{
char *strHZ;
short i, j, k;
TableDict *tableDict = tableMetaData->tableDict;
if (!tableDict->autoPhrase)
return;
strHZ = (char*)fcitx_utils_malloc0((tableMetaData->iAutoPhraseLength * UTF8_MAX_LENGTH + 1) * sizeof(char));
/*
* 为了提高效率，此处只重新生成新录入字构成的词组
*/
j = tableDict->iHZLastInputCount - tableMetaData->iAutoPhraseLength - iCount;
if (j < 0)
j = 0;
for (; j < tableDict->iHZLastInputCount - 1; j++) {
for (i = tableMetaData->iAutoPhraseLength; i >= 2; i--) {
if ((j + i - 1) > tableDict->iHZLastInputCount)
continue;
strcpy(strHZ, tableDict->hzLastInput[j].strHZ);
for (k = 1; k < i; k++)
strcat(strHZ, tableDict->hzLastInput[j + k].strHZ);
//再去掉重复的词组
for (k = 0; k < tableDict->iAutoPhrase; k++) {
if (!strcmp(tableDict->autoPhrase[k].strHZ, strHZ))
goto _next;
}
//然后去掉系统中已经有的词组
if (TableFindPhrase(tableDict, strHZ))
goto _next;
TableCreatePhraseCode(tableDict, strHZ);
if (tableDict->iAutoPhrase != AUTO_PHRASE_COUNT) {
strcpy(tableDict->autoPhrase[tableDict->iAutoPhrase].strCode, tableDict->strNewPhraseCode);
strcpy(tableDict->autoPhrase[tableDict->iAutoPhrase].strHZ, strHZ);
tableDict->autoPhrase[tableDict->iAutoPhrase].iSelected = 0;
tableDict->iAutoPhrase++;
} else {
strcpy(tableDict->insertPoint->strCode, tableDict->strNewPhraseCode);
strcpy(tableDict->insertPoint->strHZ, strHZ);
tableDict->insertPoint->iSelected = 0;
tableDict->insertPoint = tableDict->insertPoint->next;
}
tableDict->iTableChanged++;
_next:
continue;
}
}
free(strHZ);
}
XlibMenu* CreateXlibMenu(FcitxClassicUI *classicui)
{
XlibMenu *menu = fcitx_utils_malloc0(sizeof(XlibMenu));
menu->owner = classicui;
InitXlibMenu(menu);
FcitxX11AddXEventHandler(classicui->owner, MenuWindowEventHandler, menu);
FcitxX11AddCompositeHandler(classicui->owner, ReloadXlibMenu, menu);
return menu;
}
void* FcitxUnikeyCreate(FcitxInstance* instance)
{
FcitxUnikey* unikey = (FcitxUnikey*) fcitx_utils_malloc0(sizeof(FcitxUnikey));
if (!LoadUnikeyConfig(&unikey->config))
{
free(unikey);
return NULL;
}
unikey->owner = instance;
unikey->preeditstr = new std::string;
union {
short s;
unsigned char b[2];
} endian;
endian.s = 0x1234;
if (endian.b[0] == 0x12)
unikey->conv = iconv_open("utf-8", "ucs-4be");
else
unikey->conv = iconv_open("utf-8", "ucs-4le");
FcitxIMIFace iface;
memset(&iface, 0, sizeof(FcitxIMIFace));
iface.Init = FcitxUnikeyInit;
iface.ResetIM = FcitxUnikeyReset;
iface.DoInput = FcitxUnikeyDoInput;
iface.ReloadConfig = ReloadConfigFcitxUnikey;
iface.Save = FcitxUnikeySave;
FcitxInstanceRegisterIMv2(
instance,
unikey,
"unikey",
_("Unikey"),
"unikey",
iface,
1,
"vi"
);
UnikeySetup();
InitializeBar(unikey);
InitializeMenu(unikey);
ConfigUnikey(unikey);
FcitxIMEventHook hk;
hk.arg = unikey;
hk.func = FcitxUnikeyResetUI;
FcitxInstanceRegisterResetInputHook(instance, hk);
return unikey;
}
FCITX_EXPORT_API
char* FcitxHotkeyGetReadableKeyString(FcitxKeySym sym, unsigned int state)
{
char *str;
size_t len = 0;
if (state & FcitxKeyState_Ctrl)
len += strlen("Ctrl+");
if (state & FcitxKeyState_Alt)
len += strlen("Alt+");
if (state & FcitxKeyState_Shift)
len += strlen("Shift+");
if (state & FcitxKeyState_Super)
len += strlen("Super+");
if (sym == FcitxKey_ISO_Left_Tab)
sym = FcitxKey_Tab;
char *key = FcitxHotkeyGetKeyListString(sym);
if (!key)
return NULL;
size_t keylen = strlen(key);
str = fcitx_utils_malloc0(sizeof(char) * (len + keylen + 1));
if (state & FcitxKeyState_Ctrl)
strcat(str, "Ctrl+");
if (state & FcitxKeyState_Alt)
strcat(str, "Alt+");
if (state & FcitxKeyState_Shift)
strcat(str, "Shift+");
if (state & FcitxKeyState_Super)
strcat(str, "Super+");
int i = 0;
for (i = 0; i < keylen; i ++) {
if (i == 0) {
continue;
}
key[i] = tolower(key[i]);
}
strcpy(str + len, key);
free(key);
return str;
}
TrayWindow* CreateTrayWindow(FcitxClassicUI *classicui)
{
TrayWindow *trayWindow = fcitx_utils_malloc0(sizeof(TrayWindow));
trayWindow->owner = classicui;
FcitxModuleFunctionArg arg;
arg.args[0] = TrayEventHandler;
arg.args[1] = trayWindow;
InvokeFunction(classicui->owner, FCITX_X11, ADDXEVENTHANDLER, arg);
InitTrayWindow(trayWindow);
return trayWindow;
}
void InitPYSplitData(FcitxPinyinConfig* pyconfig)
{
size_t size = sizeof(pySplitData) / sizeof(pySplitData[0]);
int i = 0;
for (i = 0; i < size; i ++) {
PYMappedSplitData* data = fcitx_utils_malloc0(sizeof(PYMappedSplitData));
sprintf(data->py, "%s %s", pySplitData[i].py1, pySplitData[i].py2);
data->freq = pySplitData[i].freq;
HASH_ADD_STR(pyconfig->splitData, py, data);
}
}
void _CloudPinyinAddCandidateWord(FcitxCloudPinyin* cloudpinyin, const char* pinyin)
{
CloudPinyinCache* cacheEntry = CloudPinyinCacheLookup(cloudpinyin, pinyin);
FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);
struct _FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
if (cacheEntry) {
FcitxCandidateWord* cand;
/* only check the first three page */
int size = FcitxCandidateWordGetPageSize(candList) * CLOUDPINYIN_CHECK_PAGE_NUMBER;
int i = 0;
for (cand = FcitxCandidateWordGetFirst(FcitxInputStateGetCandidateList(input));
cand != NULL;
cand = FcitxCandidateWordGetNext(FcitxInputStateGetCandidateList(input), cand))
{
if (strcmp(cand->strWord, cacheEntry->str) == 0)
return;
i ++;
if (i >= size)
break;
}
}
FcitxCandidateWord candWord;
CloudCandWord* cloudCand = fcitx_utils_malloc0(sizeof(CloudCandWord));
if (cacheEntry)
{
cloudCand->filled = true;
candWord.strWord = strdup(cacheEntry->str);
}
else
{
cloudCand->filled = false;
candWord.strWord = strdup("..");
}
candWord.callback = CloudPinyinGetCandWord;
candWord.owner = cloudpinyin;
candWord.priv = cloudCand;
candWord.wordType = MSG_TIPS;
if (cloudpinyin->config.bDontShowSource)
candWord.strExtra = NULL;
else {
candWord.strExtra = strdup(_(" (via cloud)"));
candWord.extraType = MSG_TIPS;
}
int order = cloudpinyin->config.iCandidateOrder - 1;
if (order < 0)
order = 0;
FcitxCandidateWordInsert(candList, &candWord, order);
}
FCITX_EXPORT_API
FcitxCandidateWordList* FcitxCandidateWordNewList()
{
FcitxCandidateWordList* candList = fcitx_utils_malloc0(sizeof(FcitxCandidateWordList));
utarray_init(&candList->candWords, &cand_icd);
utarray_reserve(&candList->candWords, 128);
candList->wordPerPage = 5; /* anyway put a default value for safety */
strncpy(candList->strChoose, DIGIT_STR_CHOOSE, MAX_CAND_WORD);
return candList;
}