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; }