boolean LoadChttransConfig(FcitxChttrans* transState)
{
FcitxConfigFileDesc* configDesc = GetChttransConfigDesc();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-chttrans.config",
"r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT)
SaveChttransConfig(transState);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxChttransConfigBind(transState, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)transState);
if (fp)
fclose(fp);
return true;
}
static boolean
LoadAutoEngConfig(FcitxAutoEngConfig *config)
{
FcitxConfigFileDesc *configDesc = GetAutoEngConfigDesc();
if (configDesc == NULL)
return false;
FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-autoeng.config",
"r", NULL);
if (!fp) {
if (errno == ENOENT)
SaveAutoEngConfig(config);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxAutoEngConfigConfigBind(config, cfile, configDesc);
FcitxConfigBindSync(&config->gconfig);
if (config->chooseModifier > AECM_CTRL)
config->chooseModifier = AECM_CTRL;
if (fp)
fclose(fp);
return true;
}
boolean LoadQuickPhraseConfig(QuickPhraseState* qpstate)
{
FcitxConfigFileDesc* configDesc = GetQuickPhraseConfigDesc();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-quickphrase.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT)
SaveQuickPhraseConfig(qpstate);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
QuickPhraseStateConfigBind(qpstate, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)qpstate);
if (fp)
fclose(fp);
return true;
}
boolean LoadIMSelectorConfig(IMSelector* imselector)
{
FcitxConfigFileDesc* configDesc = GetIMSelectorConfig();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-imselector.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT)
SaveIMSelectorConfig(imselector);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
IMSelectorConfigBind(imselector, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)imselector);
if (fp)
fclose(fp);
return true;
}
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);
}
boolean LoadChewingConfig(FcitxChewingConfig* fs)
{
FcitxConfigFileDesc *configDesc = GetFcitxChewingConfigDesc();
if (!configDesc)
return false;
FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-chewing.config", "rt", NULL);
if (!fp) {
if (errno == ENOENT)
SaveChewingConfig(fs);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxChewingConfigConfigBind(fs, cfile, configDesc);
FcitxConfigBindSync(&fs->config);
if (fp)
fclose(fp);
return true;
}
boolean FcitxTabletLoadConfig(FcitxTabletConfig* cfg) {
FcitxConfigFileDesc *configDesc = GetFcitxTabletConfigDesc();
if(configDesc == NULL)
return false;
FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-tablet.config", "r", NULL);
if (!fp && errno == ENOENT) {
// Create the file if it doesn't exist
FcitxTabletSaveConfig(cfg);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxTabletConfigConfigBind(cfg, cfile, configDesc);
FcitxConfigBindSync(&cfg->config);
if(fp)
fclose(fp);
return true;
}
/**
* @brief Load the config file for fcitx-cloudpinyin
*
* @param Bool is reload or not
**/
boolean CloudPinyinConfigLoad(FcitxCloudPinyinConfig* fs)
{
FcitxConfigFileDesc *configDesc = GetCloudPinyinConfigDesc();
if (configDesc == NULL)
return false;
FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-cloudpinyin.config", "r", NULL);
if (!fp)
{
if (errno == ENOENT)
CloudPinyinConfigSave(fs);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxCloudPinyinConfigConfigBind(fs, cfile, configDesc);
FcitxConfigBindSync(&fs->config);
if (fp)
fclose(fp);
return true;
}
boolean LoadChttransConfig(FcitxChttrans* transState)
{
FcitxConfigFileDesc* configDesc = GetChttransConfigDesc();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-chttrans.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
boolean newconfig = false;
if (!fp) {
if (errno == ENOENT)
SaveChttransConfig(transState);
newconfig = true;
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxChttransConfigBind(transState, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)transState);
if (newconfig) {
char *p = fcitx_utils_get_current_langcode();
/* also check en_HK for default setting */
if (strcmp(p, "zh_TW") == 0 || strcmp(p, "en_HK") == 0 || strcmp(p, "zh_HK") == 0) {
transState->enabled = true;
SaveChttransConfig(transState);
}
free(p);
}
if (fp)
fclose(fp);
return true;
}
boolean LoadClassicUIConfig(FcitxClassicUI* classicui)
{
FcitxConfigFileDesc* configDesc = GetClassicUIDesc();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-classic-ui.config", "rt", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT)
SaveClassicUIConfig(classicui);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxClassicUIConfigBind(classicui, cfile, configDesc);
FcitxConfigBindSync(&classicui->gconfig);
if (fp)
fclose(fp);
return true;
}
boolean LoadLightUIConfig(FcitxLightUI* lightui)
{
FcitxConfigFileDesc* configDesc = GetLightUIDesc();
if (configDesc == NULL)
return false;
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-light-ui.config", "r", &file);
FcitxLog(INFO, _("Load Config File %s"), file);
free(file);
if (!fp) {
if (errno == ENOENT)
SaveLightUIConfig(lightui);
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxLightUIConfigBind(lightui, cfile, configDesc);
FcitxConfigBindSync(&lightui->gconfig);
if (fp)
fclose(fp);
return true;
}
/**
@加载皮肤配置文件
*/
int LoadSkinConfig(FcitxSkin* sc, char** skinType)
{
FILE *fp;
boolean isreload = False;
int ret = 0;
if (sc->config.configFile) {
utarray_done(&sc->skinMainBar.skinPlacement);
FcitxConfigFree(&sc->config);
UnloadImage(sc);
}
memset(sc, 0, sizeof(FcitxSkin));
utarray_init(&sc->skinMainBar.skinPlacement, &place_icd);
reload:
if (!isreload) {
char *buf;
fcitx_utils_alloc_cat_str(buf, *skinType, "/fcitx_skin.conf");
fp = FcitxXDGGetFileWithPrefix("skin", buf, "r", NULL);
free(buf);
} else {
char *path = fcitx_utils_get_fcitx_path_with_filename(
"pkgdatadir", "/skin/default/fcitx_skin.conf");
fp = fopen(path, "r");
free(path);
}
if (fp) {
FcitxConfigFile *cfile;
FcitxConfigFileDesc* skinDesc = GetSkinDesc();
if (sc->config.configFile == NULL) {
cfile = FcitxConfigParseConfigFileFp(fp, skinDesc);
} else {
cfile = sc->config.configFile;
cfile = FcitxConfigParseIniFp(fp, cfile);
}
if (!cfile) {
fclose(fp);
fp = NULL;
} else {
FcitxSkinConfigBind(sc, cfile, skinDesc);
FcitxConfigBindSync((FcitxGenericConfig*)sc);
}
}
if (!fp) {
if (isreload) {
FcitxLog(FATAL, _("Can not load default skin, is installion correct?"));
perror("fopen");
ret = 1; // 如果安装目录里面也没有配置文件，那就只好告诉用户，无法运行了
} else {
perror("fopen");
FcitxLog(WARNING, _("Can not load skin %s, return to default"), *skinType);
if (*skinType)
free(*skinType);
*skinType = strdup("default");
isreload = true;
goto reload;
}
}
if (fp)
fclose(fp);
sc->skinType = skinType;
return ret;
}
void* XimCreate(FcitxInstance* instance, int frontendid)
{
if (ximfrontend != NULL)
return NULL;
FcitxXimFrontend *xim = fcitx_utils_new(FcitxXimFrontend);
if (xim == NULL)
return NULL;
ximfrontend = xim;
char *imname = NULL;
char *p;
UT_array *addons = FcitxInstanceGetAddons(instance);
FcitxAddon *ximaddon = FcitxAddonsGetAddonByName(addons, "fcitx-xim");
xim->display = FcitxX11GetDisplay(instance);
if (xim->display == NULL) {
FcitxLog(FATAL, _("X11 not initialized"));
free(xim);
return NULL;
}
xim->iScreen = DefaultScreen(xim->display);
xim->owner = instance;
xim->frontendid = frontendid;
xim->xim_window = XCreateWindow(xim->display, DefaultRootWindow(xim->display),
0, 0, 1, 1, 0, 0, InputOnly,
CopyFromParent, 0, NULL);
if (!xim->xim_window) {
FcitxLog(FATAL, _("Can't Create imWindow"));
free(xim);
return NULL;
}
if (!imname) {
imname = getenv("XMODIFIERS");
if (imname) {
if (!strncmp(imname, "@im=", strlen("@im="))) {
imname += 4;
} else {
FcitxLog(WARNING, _("XMODIFIERS Error."));
imname = DEFAULT_IMNAME;
}
} else {
FcitxLog(WARNING, _("Please set XMODIFIERS."));
imname = DEFAULT_IMNAME;
}
}
XimQueueInit(xim);
if (GetXimConfigDesc() == NULL)
xim->bUseOnTheSpotStyle = false;
else {
FcitxConfigFileDesc* configDesc = GetXimConfigDesc();
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT) {
char *file;
FILE *fp2 = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "w", &file);
FcitxLog(DEBUG, "Save Config to %s", file);
FcitxConfigSaveConfigFileFp(fp2, &xim->gconfig, configDesc);
free(file);
if (fp2)
fclose(fp2);
}
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxXimFrontendConfigBind(xim, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)xim);
if (fp)
fclose(fp);
}
XIMStyles input_styles;
if (xim->bUseOnTheSpotStyle) {
input_styles.count_styles =
sizeof(OnTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles.supported_styles = OnTheSpot_Styles;
} else {
input_styles.count_styles =
sizeof(OverTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles.supported_styles = OverTheSpot_Styles;
}
XIMEncodings encodings = {
.count_encodings = sizeof(zhEncodings) / sizeof(XIMEncoding) - 1,
.supported_encodings = zhEncodings
};
p = getenv("LC_CTYPE");
if (!p) {
p = getenv("LC_ALL");
if (!p)
p = getenv("LANG");
}
if (p) {
int p_l = strlen(p);
if (strlen(LOCALES_STRING) + p_l + 1 < LOCALES_BUFSIZE) {
strLocale[strlen(LOCALES_STRING)] = ',';
memcpy(strLocale + strlen(LOCALES_STRING) + 1, p, p_l + 1);
}
}
xim->ims = IMOpenIM(xim->display,
IMModifiers, "Xi18n",
IMServerWindow, xim->xim_window,
IMServerName, imname,
IMLocale, strLocale,
IMServerTransport, "X/",
IMInputStyles, &input_styles,
IMEncodingList, &encodings,
IMProtocolHandler, XimProtocolHandler,
IMFilterEventMask, KeyPressMask | KeyReleaseMask,
NULL);
if (xim->ims == (XIMS) NULL) {
FcitxLog(ERROR, _("Start XIM error. Another XIM daemon named %s is running?"), imname);
XimDestroy(xim);
FcitxInstanceEnd(instance);
return NULL;
}
FcitxModuleAddFunction(ximaddon, XimConsumeQueue);
return xim;
}
Bool XimProtocolHandler(XIMS _ims, IMProtocol * call_data)
{
switch (call_data->major_code) {
case XIM_OPEN:
FcitxLog(DEBUG, "XIM_OPEN:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_CLOSE:
FcitxLog(DEBUG, "XIM_CLOSE:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_CREATE_IC:
FcitxLog(DEBUG, "XIM_CREATE_IC:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_DESTROY_IC:
FcitxLog(DEBUG, "XIM_DESTROY_IC:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_SET_IC_VALUES:
FcitxLog(DEBUG, "XIM_SET_IC_VALUES:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_GET_IC_VALUES:
FcitxLog(DEBUG, "XIM_GET_IC_VALUES:\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_FORWARD_EVENT:
FcitxLog(DEBUG, "XIM_FORWARD_EVENT:\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_SET_IC_FOCUS:
FcitxLog(DEBUG, "XIM_SET_IC_FOCUS:\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_UNSET_IC_FOCUS:
FcitxLog(DEBUG, "XIM_UNSET_IC_FOCUS:\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_RESET_IC:
FcitxLog(DEBUG, "XIM_RESET_IC:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
case XIM_TRIGGER_NOTIFY:
FcitxLog(DEBUG, "XIM_TRIGGER_NOTIFY:\t\ticid=%d\tconnect_id=%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id);
break;
default:
FcitxLog(DEBUG, "XIM_DEFAULT:\t\ticid=%d\tconnect_id=%d\t%d", ((IMForwardEventStruct *) call_data)->icid,
((IMForwardEventStruct *) call_data)->connect_id, call_data->major_code);
break;
}
switch (call_data->major_code) {
case XIM_OPEN:
return XIMOpenHandler(ximfrontend, (IMOpenStruct *) call_data);
case XIM_CLOSE:
return XIMCloseHandler(ximfrontend, (IMOpenStruct *) call_data);
case XIM_CREATE_IC:
return XIMCreateICHandler(ximfrontend, (IMChangeICStruct *) call_data);
case XIM_DESTROY_IC:
return XIMDestroyICHandler(ximfrontend, (IMChangeICStruct *) call_data);
case XIM_SET_IC_VALUES:
return XIMSetICValuesHandler(ximfrontend, (IMChangeICStruct *) call_data);
case XIM_GET_IC_VALUES:
return XIMGetICValuesHandler(ximfrontend, (IMChangeICStruct *) call_data);
case XIM_FORWARD_EVENT:
XIMProcessKey(ximfrontend, (IMForwardEventStruct *) call_data);
return True;
case XIM_SET_IC_FOCUS:
return XIMSetFocusHandler(ximfrontend, (IMChangeFocusStruct *) call_data);
case XIM_UNSET_IC_FOCUS:
return XIMUnsetFocusHandler(ximfrontend, (IMChangeICStruct *) call_data);;
case XIM_RESET_IC:
return True;
case XIM_PREEDIT_START_REPLY:
return 0;
case XIM_PREEDIT_CARET_REPLY:
return 0;
case XIM_SYNC_REPLY:
return 0;
default:
return True;
}
}
boolean XimDestroy(void* arg)
{
FcitxXimFrontend* xim = (FcitxXimFrontend*) arg;
/**
* Destroy the window BEFORE(!!!!!) CloseIM!!!
* Work arround for a bug in libX11. See wengxt's commit log:
* f773dd4f7152a4b4b7f406fe01bff466e0de3dc2
* [xim, x11] correctly shutdown xim, destroy x11 with error handling
**/
if (xim->xim_window) {
XDestroyWindow(xim->display, xim->xim_window);
}
if (xim->ims) {
IMCloseIM(xim->ims);
xim->ims = NULL;
}
XimQueueDestroy(xim);
free(xim);
return true;
}
static void
fcitx_config_widget_setup_ui(FcitxConfigWidget *self)
{
FcitxConfigFileDesc* cfdesc = self->cfdesc;
GtkWidget *cvbox = GTK_WIDGET(self);
GtkWidget *configNotebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(cvbox), configNotebook, TRUE, TRUE, 0);
if (cfdesc) {
bindtextdomain(cfdesc->domain, LOCALEDIR);
bind_textdomain_codeset(cfdesc->domain, "UTF-8");
FILE *fp;
fp = FcitxXDGGetFileWithPrefix(self->prefix, self->name, "r", NULL);
self->gconfig.configFile = FcitxConfigParseConfigFileFp(fp, cfdesc);
FcitxConfigGroupDesc *cgdesc = NULL;
FcitxConfigOptionDesc *codesc = NULL;
for (cgdesc = cfdesc->groupsDesc;
cgdesc != NULL;
cgdesc = (FcitxConfigGroupDesc*)cgdesc->hh.next) {
codesc = cgdesc->optionsDesc;
if (codesc == NULL)
continue;
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *table = gtk_table_new(2, HASH_COUNT(codesc), FALSE);
GtkWidget *plabel = gtk_label_new(D_(cfdesc->domain, cgdesc->groupName));
GtkWidget *scrollwnd = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(table), 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwnd), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwnd), table);
gtk_box_pack_start(GTK_BOX(hbox), scrollwnd, TRUE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(configNotebook),
hbox,
plabel);
int i = 0;
for (; codesc != NULL;
codesc = (FcitxConfigOptionDesc*)codesc->hh.next, i++) {
const char *s;
if (codesc->desc && strlen(codesc->desc) != 0)
s = D_(cfdesc->domain, codesc->desc);
else
s = D_(cfdesc->domain, codesc->optionName);
GtkWidget *inputWidget = NULL;
void *argument = NULL;
switch (codesc->type) {
case T_Integer:
inputWidget = gtk_spin_button_new_with_range(-1.0, 10000.0, 1.0);
argument = inputWidget;
break;
case T_Color:
inputWidget = gtk_color_button_new();
argument = inputWidget;
break;
case T_Boolean:
inputWidget = gtk_check_button_new();
argument = inputWidget;
break;
case T_Font: {
inputWidget = gtk_hbox_new(FALSE, 0);
argument = gtk_font_button_new();
GtkWidget *button = gtk_button_new_with_label(_("Clear font setting"));
gtk_box_pack_start(GTK_BOX(inputWidget), argument, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button, FALSE, FALSE, 0);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(argument), FALSE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(argument), FALSE);
g_signal_connect(G_OBJECT(button), "clicked", (GCallback) set_none_font_clicked, argument);
}
break;
case T_Enum: {
int i;
FcitxConfigEnum *e = &codesc->configEnum;
#if GTK_CHECK_VERSION(2, 24, 0)
inputWidget = gtk_combo_box_text_new();
for (i = 0; i < e->enumCount; i ++) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(inputWidget), D_(cfdesc->domain, e->enumDesc[i]));
}
#else
inputWidget = gtk_combo_box_new_text();
for (i = 0; i < e->enumCount; i ++)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(inputWidget), D_(cfdesc->domain, e->enumDesc[i]));
}
#endif
argument = inputWidget;
}
break;
case T_Hotkey: {
GtkWidget *button[2];
button[0] = keygrab_button_new();
button[1] = keygrab_button_new();
inputWidget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button[0], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button[1], FALSE, TRUE, 0);
argument = g_array_new(FALSE, FALSE, sizeof(void*));
g_array_append_val(argument, button[0]);
g_array_append_val(argument, button[1]);
}
break;
case T_File:
case T_Char:
case T_String:
inputWidget = gtk_entry_new();
argument = inputWidget;
break;
default:
break;
}
if (inputWidget) {
GtkWidget* label = gtk_label_new(s);
g_object_set(label, "xalign", 0.0f, NULL);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i + 1, GTK_FILL, GTK_SHRINK, 5, 5);
gtk_table_attach(GTK_TABLE(table), inputWidget, 1, 2, i, i + 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 4);
FcitxConfigBindValue(self->gconfig.configFile, cgdesc->groupName, codesc->optionName, NULL, sync_filter, argument);
}
}
}
FcitxConfigBindSync(&self->gconfig);
}
if (self->parser) {
GHashTable* subconfigs = self->parser->subconfigs;
if (g_hash_table_size(subconfigs) != 0) {
GtkWidget *table = gtk_table_new(2, g_hash_table_size(subconfigs), FALSE);
GtkWidget *plabel = gtk_label_new(_("Other"));
GtkWidget *scrollwnd = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *viewport = gtk_viewport_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollwnd), viewport);
gtk_container_add(GTK_CONTAINER(viewport), table);
gtk_notebook_append_page(GTK_NOTEBOOK(configNotebook),
scrollwnd,
plabel);
HashForeachContext context;
context.i = 0;
context.table = table;
context.widget = self;
g_hash_table_foreach(subconfigs, hash_foreach_cb, &context);
}
}
gtk_widget_set_size_request(configNotebook, 500, -1);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(configNotebook), TRUE);
}
void* XimCreate(FcitxInstance* instance, int frontendid)
{
if (ximfrontend != NULL)
return NULL;
FcitxXimFrontend* xim = fcitx_utils_malloc0(sizeof(FcitxXimFrontend));
if (xim == NULL)
return NULL;
ximfrontend = xim;
XIMStyles *input_styles;
XIMEncodings *encodings;
char *imname = NULL;
char *p;
xim->display = InvokeVaArgs(instance, FCITX_X11, GETDISPLAY);
if (xim->display == NULL) {
FcitxLog(FATAL, _("X11 not initialized"));
free(xim);
return NULL;
}
FcitxAddon* ximaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), "fcitx-xim");
xim->x11addon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), "fcitx-x11");
xim->iScreen = DefaultScreen(xim->display);
xim->owner = instance;
xim->frontendid = frontendid;
xim->ximWindow = XCreateSimpleWindow(xim->display, DefaultRootWindow(xim->display), 0, 0, 1, 1, 1, 0, 0);
if (xim->ximWindow == (Window) NULL) {
FcitxLog(FATAL, _("Can't Create imWindow"));
free(xim);
return NULL;
}
if (!imname) {
imname = getenv("XMODIFIERS");
if (imname) {
if (strstr(imname, "@im="))
imname += 4;
else {
FcitxLog(WARNING, _("XMODIFIERS Error."));
imname = DEFAULT_IMNAME;
}
} else {
FcitxLog(WARNING, _("Please set XMODIFIERS."));
imname = DEFAULT_IMNAME;
}
}
XimQueueInit(xim);
if (GetXimConfigDesc() == NULL)
xim->bUseOnTheSpotStyle = false;
else {
FcitxConfigFileDesc* configDesc = GetXimConfigDesc();
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT) {
char *file;
FILE *fp2 = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "w", &file);
FcitxLog(DEBUG, "Save Config to %s", file);
FcitxConfigSaveConfigFileFp(fp2, &xim->gconfig, configDesc);
free(file);
if (fp2)
fclose(fp2);
}
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxXimFrontendConfigBind(xim, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)xim);
if (fp)
fclose(fp);
}
input_styles = (XIMStyles *) malloc(sizeof(XIMStyles));
if (xim->bUseOnTheSpotStyle) {
input_styles->count_styles = sizeof(OnTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles->supported_styles = OnTheSpot_Styles;
} else {
input_styles->count_styles = sizeof(OverTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles->supported_styles = OverTheSpot_Styles;
}
encodings = (XIMEncodings *) malloc(sizeof(XIMEncodings));
encodings->count_encodings = sizeof(zhEncodings) / sizeof(XIMEncoding) - 1;
encodings->supported_encodings = zhEncodings;
p = getenv("LC_CTYPE");
if (!p) {
p = getenv("LC_ALL");
if (!p)
p = getenv("LANG");
}
if (p) {
if (!strcasestr(strLocale, p)) {
strcat(strLocale, ",");
strcat(strLocale, p);
}
}
xim->ims = IMOpenIM(xim->display,
IMModifiers, "Xi18n",
IMServerWindow, xim->ximWindow,
IMServerName, imname,
IMLocale, strLocale,
IMServerTransport, "X/",
IMInputStyles, input_styles,
IMEncodingList, encodings,
IMProtocolHandler, XimProtocolHandler,
IMFilterEventMask, KeyPressMask | KeyReleaseMask,
NULL);
free(input_styles);
free(encodings);
if (xim->ims == (XIMS) NULL) {
FcitxLog(ERROR, _("Start XIM error. Another XIM daemon named %s is running?"), imname);
free(xim);
FcitxInstanceEnd(instance);
return NULL;
}
FcitxModuleAddFunction(ximaddon, XimConsumeQueue);
return xim;
}
FcitxAddon* FcitxAddonsLoadInternal(UT_array* addons, boolean reloadIM)
{
char **addonPath;
size_t len;
size_t start;
if (!reloadIM)
utarray_clear(addons);
start = utarray_len(addons);
FcitxStringHashSet* sset = FcitxXDGGetFiles("addon", NULL, ".conf");
addonPath = FcitxXDGGetPathWithPrefix(&len, "addon");
char *paths[len];
HASH_FOREACH(string, sset, FcitxStringHashSet) {
// FIXME: if it will cause realloc, then it's evil for fcitx 4.2 series
if (reloadIM && addons->i == addons->n) {
break;
}
int i;
for (i = len - 1; i >= 0; i--) {
fcitx_utils_alloc_cat_str(paths[i], addonPath[len - i - 1],
"/", string->name);
FcitxLog(DEBUG, "Load Addon Config File:%s", paths[i]);
}
FcitxConfigFile* cfile = FcitxConfigParseMultiConfigFile(paths, len, FcitxAddonGetConfigDesc());
if (cfile) {
utarray_extend_back(addons);
FcitxAddon *a = (FcitxAddon*) utarray_back(addons);
utarray_init(&a->functionList, fcitx_ptr_icd);
FcitxAddonConfigBind(a, cfile, FcitxAddonGetConfigDesc());
FcitxConfigBindSync((FcitxGenericConfig*)a);
FcitxLog(DEBUG, _("Addon Config %s is %s"), string->name, (a->bEnabled) ? "Enabled" : "Disabled");
boolean error = false;
if (reloadIM) {
if (a->category != AC_INPUTMETHOD)
error = true;
}
/* if loaded, don't touch the old one */
if (FcitxAddonsGetAddonByNameInternal(addons, a->name, true) != a)
error = true;
if (error)
utarray_pop_back(addons);
else
FcitxLog(INFO, _("Load Addon Config File:%s"), string->name);
}
for (i = len - 1;i >= 0;i--) {
free(paths[i]);
}
}
FcitxXDGFreePath(addonPath);
fcitx_utils_free_string_hash_set(sset);
size_t to = utarray_len(addons);
utarray_sort_range(addons, AddonPriorityCmp, start, to);
return (FcitxAddon*)utarray_eltptr(addons, start);
}
