static void FcitxRimeStart(FcitxRime* rime, boolean fullcheck) { char* user_path = NULL; FILE* fp = FcitxXDGGetFileUserWithPrefix("rime", ".place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("rime", "", NULL, &user_path); //char* shared_data_dir = fcitx_utils_get_fcitx_path_with_filename("pkgdatadir", "rime"); const char* shared_data_dir = RIME_DATA_DIR; RIME_STRUCT(RimeTraits, fcitx_rime_traits); fcitx_rime_traits.shared_data_dir = shared_data_dir; fcitx_rime_traits.app_name = "rime.fcitx-rime"; fcitx_rime_traits.user_data_dir = user_path; fcitx_rime_traits.distribution_name = "Rime"; fcitx_rime_traits.distribution_code_name = "fcitx-rime"; fcitx_rime_traits.distribution_version = "0.2.3"; if (rime->firstRun) { rime->api->setup(&fcitx_rime_traits); rime->firstRun = false; } rime->api->initialize(&fcitx_rime_traits); rime->api->set_notification_handler(FcitxRimeNotificationHandler, rime); rime->api->start_maintenance(fullcheck); rime->session_id = rime->api->create_session(); free(user_path); }
/** * @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 ScelConverter::finished(int exitCode, QProcess::ExitStatus status) { if (status == QProcess::CrashExit) { emit message(QMessageBox::Critical, _("Converter crashed.")); emit finished(false); return; } if (exitCode != 0) { emit message(QMessageBox::Warning, _("Convert failed.")); emit finished(false); } char* fullName; FcitxXDGMakeDirUser("libpinyin/importdict"); FcitxXDGGetFileUserWithPrefix("libpinyin/importdict", m_name.toLocal8Bit().constData(), NULL, &fullName); if (QFile::rename(m_file.fileName(), QString::fromLocal8Bit(fullName))) { emit finished(true); } else { QFile::remove(m_file.fileName()); emit message(QMessageBox::Warning, _("Rename failed.")); emit finished(false); } free(fullName); }
bool DictModel::save() { char* name = NULL; FcitxXDGMakeDirUser("kkc"); FcitxXDGGetFileUserWithPrefix("kkc", "dictionary_list", NULL, &name); QString fileName = QString::fromLocal8Bit(name); QTemporaryFile tempFile(fileName); free(name); if (!tempFile.open()) { return false; } typedef QMap<QString, QString> DictType; Q_FOREACH(const DictType& dict, m_dicts) { boolean first = true; Q_FOREACH(const QString& key, dict.keys()) { if (first) { first = false; } else { tempFile.write(","); } tempFile.write(key.toUtf8()); tempFile.write("="); tempFile.write(dict[key].toUtf8()); } tempFile.write("\n"); }
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; }
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 void _fcitx_main_window_toggled_cb(GtkCellRenderer *renderer, gchar* str_path, gpointer user_data) { GtkTreeModel *model = (GtkTreeModel *)user_data; GtkTreePath *path = gtk_tree_path_new_from_string(str_path); GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, path); FcitxAddon* addon = NULL; gtk_tree_path_free(path); gtk_tree_model_get(model, &iter, LIST_ADDON, &addon, -1); if (!addon) return; addon->bEnabled = !addon->bEnabled; char *buf; asprintf(&buf, "%s.conf", addon->name); FILE* fp = FcitxXDGGetFileUserWithPrefix("addon", buf, "w", NULL); free(buf); if (fp) { fprintf(fp, "[Addon]\nEnabled=%s\n", addon->bEnabled ? "True" : "False"); fclose(fp); } g_object_set(renderer, "active", (gboolean) addon->bEnabled, NULL); }
int FcitxXErrorHandler(Display * dpy, XErrorEvent * event) { if (!x11handle) return 0; if (FcitxInstanceGetIsDestroying(x11handle->owner)) return 0; char str[256]; FILE* fp = NULL; fp = FcitxXDGGetFileUserWithPrefix("log", "crash.log", "w" , NULL); if (fp) { XGetErrorText(dpy, event->error_code, str, 255); fprintf(fp, "fcitx: %s\n", str); } FcitxInstanceSaveAllIM(x11handle->owner); if (fp) fclose(fp); if (event->error_code != 3 && event->error_code != BadMatch) { // xterm will generate 3 FcitxInstanceEnd(x11handle->owner); } return 0; }
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; }
static void ClipboardWriteHistory(FcitxClipboard *clipboard) { FILE *fp; fp = FcitxXDGGetFileUserWithPrefix("clipboard", "history.dat", "w", NULL); if (!fp) return; if (!clipboard->config.save_history) goto out; fcitx_utils_write_uint32(fp, clipboard->clp_hist_len); fcitx_utils_write_uint32(fp, clipboard->primary.len); unsigned int i; for (i = 0;i < clipboard->clp_hist_len;i++) { fcitx_utils_write_uint32(fp, clipboard->clp_hist_lst[i].len); } if (clipboard->primary.len) fwrite(clipboard->primary.str, 1, clipboard->primary.len, fp); for (i = 0;i < clipboard->clp_hist_len;i++) { if (clipboard->clp_hist_lst[i].len) fwrite(clipboard->clp_hist_lst[i].str, 1, clipboard->clp_hist_lst[i].len, fp); } out: fclose(fp); }
void SaveChewingConfig(FcitxChewingConfig* fc) { FcitxConfigFileDesc *configDesc = GetFcitxChewingConfigDesc(); FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-chewing.config", "wt", NULL); FcitxConfigSaveConfigFileFp(fp, &fc->config, configDesc); if (fp) fclose(fp); }
/** * @brief Save the config * * @return void **/ void SaveCloudPinyinConfig(FcitxCloudPinyinConfig* fs) { FcitxConfigFileDesc *configDesc = GetCloudPinyinConfigDesc(); FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-cloudpinyin.config", "wt", NULL); FcitxConfigSaveConfigFileFp(fp, &fs->config, configDesc); if (fp) fclose(fp); }
void FcitxTabletSaveConfig(FcitxTabletConfig* cfg) { FcitxConfigFileDesc *configDesc = GetFcitxTabletConfigDesc(); FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-tablet.config", "w", NULL); if(fp) { FcitxConfigSaveConfigFileFp(fp, &cfg->config, configDesc); fclose(fp); } }
/** * @brief Save the config * * @return void **/ void SaveLibpinyinConfig(FcitxLibpinyinConfig* fs) { FcitxConfigFileDesc *configDesc = GetLibpinyinConfigDesc(); FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-libpinyin.config", "w", NULL); FcitxConfigSaveConfigFileFp(fp, &fs->gconfig, configDesc); if (fp) fclose(fp); }
char* FcitxLibpinyinGetUserPath(LIBPINYIN_LANGUAGE_TYPE type) { char* user_path = NULL; if (type == LPLT_Simplified) { FILE* fp = FcitxXDGGetFileUserWithPrefix("libpinyin", "data/.place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("libpinyin", "data", NULL, &user_path); FcitxLog(INFO, "Libpinyin storage path %s", user_path); } else { FILE* fp = FcitxXDGGetFileUserWithPrefix("libpinyin", "zhuyin_data/.place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("libpinyin", "zhuyin_data", NULL, &user_path); } return user_path; }
void open_native_file(GtkButton *button, gpointer user_data) { FcitxSubConfigWidget* widget = (FcitxSubConfigWidget*) user_data; char *newpath = NULL; char* qtguiwrapper = fcitx_utils_get_fcitx_path_with_filename ("libdir", "fcitx/libexec/fcitx-qt-gui-wrapper"); if (qtguiwrapper) { gchar* argv[4]; argv[0] = qtguiwrapper; argv[1] = "--test"; argv[2] = widget->subconfig->nativepath; argv[3] = 0; int exit_status = 1; g_spawn_sync(NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, NULL); if (exit_status == 0) { gchar* argv2[3]; argv2[0] = qtguiwrapper; argv2[1] = widget->subconfig->nativepath; argv2[2] = 0; g_spawn_async(NULL, argv2, NULL, 0, NULL, NULL, NULL, NULL); free(newpath); } g_free(qtguiwrapper); if (exit_status == 0) { return; } } if (g_hash_table_size(widget->subconfig->filelist) > 0) { GHashTableIter iter; g_hash_table_iter_init(&iter, widget->subconfig->filelist); gpointer key; if (g_hash_table_iter_next(&iter, &key, NULL)) { FILE* fp = FcitxXDGGetFileWithPrefix("", key, "r", &newpath); if (fp) fclose(fp); } } else { FILE* fp = FcitxXDGGetFileUserWithPrefix("", widget->subconfig->nativepath, "w", &newpath); if (fp) { g_hash_table_insert(widget->subconfig->filelist, widget->subconfig->nativepath, NULL); fclose(fp); } } if (newpath) { gchar* filename = newpath; gchar* argv[3]; argv[0] = "xdg-open"; argv[1] = filename; argv[2] = 0; g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL); free(newpath); } }
static void SaveAutoEngConfig(FcitxAutoEngConfig* fs) { FcitxConfigFileDesc *configDesc = GetAutoEngConfigDesc(); FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-autoeng.config", "w", NULL); FcitxConfigSaveConfigFileFp(fp, &fs->gconfig, configDesc); if (fp) fclose(fp); }
void SaveLightUIConfig(FcitxLightUI *lightui) { FcitxConfigFileDesc* configDesc = GetLightUIDesc(); char *file; FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-light-ui.config", "w", &file); FcitxLog(INFO, "Save Config to %s", file); FcitxConfigSaveConfigFileFp(fp, &lightui->gconfig, configDesc); free(file); if (fp) fclose(fp); }
void SaveChttransConfig(FcitxChttrans* transState) { FcitxConfigFileDesc* configDesc = GetChttransConfigDesc(); char *file; FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-chttrans.config", "w", &file); FcitxLog(DEBUG, "Save Config to %s", file); FcitxConfigSaveConfigFileFp(fp, &transState->gconfig, configDesc); free(file); if (fp) fclose(fp); }
void SaveClassicUIConfig(FcitxClassicUI *classicui) { FcitxConfigFileDesc* configDesc = GetClassicUIDesc(); char *file; FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-classic-ui.config", "wt", &file); FcitxLog(DEBUG, "Save Config to %s", file); FcitxConfigSaveConfigFileFp(fp, &classicui->gconfig, configDesc); free(file); if (fp) fclose(fp); }
void SaveIMSelectorConfig(IMSelector* imselector) { FcitxConfigFileDesc* configDesc = GetIMSelectorConfig(); char *file; FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-imselector.config", "w", &file); FcitxLog(DEBUG, "Save Config to %s", file); FcitxConfigSaveConfigFileFp(fp, &imselector->gconfig, configDesc); free(file); if (fp) fclose(fp); }
void SaveQuickPhraseConfig(QuickPhraseState* qpstate) { FcitxConfigFileDesc* configDesc = GetQuickPhraseConfigDesc(); char *file; FILE *fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-quickphrase.config", "w", &file); FcitxLog(DEBUG, "Save Config to %s", file); FcitxConfigSaveConfigFileFp(fp, &qpstate->gconfig, configDesc); free(file); if (fp) fclose(fp); }
char* FcitxLibPinyinGetUserPath(LIBPINYIN_LANGUAGE_TYPE type) { char* user_path = NULL; #ifdef LIBPINYIN_TOOLS_FOUND if (type == LPLT_Simplified) { #endif FILE* fp = FcitxXDGGetFileUserWithPrefix("libpinyin", "data/.place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("libpinyin", "data", NULL, &user_path); #ifdef LIBPINYIN_TOOLS_FOUND } else { FILE* fp = FcitxXDGGetFileUserWithPrefix("libpinyin", "zhuyin_data/.place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("libpinyin", "zhuyin_data", NULL, &user_path); } #endif return user_path; }
void ShortcutModel::load(const QString& name) { setNeedSave(false); beginResetModel(); do { if (m_userRule) { g_object_unref(m_userRule); m_userRule = 0; } m_entries.clear(); KkcRuleMetadata* ruleMeta = kkc_rule_metadata_find(name.toUtf8().constData()); if (!ruleMeta) { return; } char* fcitxBasePath = NULL; FcitxXDGGetFileUserWithPrefix("kkc", "rules", NULL, &fcitxBasePath); KkcUserRule* userRule = kkc_user_rule_new(ruleMeta, fcitxBasePath, "fcitx-kkc", NULL); free(fcitxBasePath); if (!userRule) { break; } for (int mode = 0; mode < KKC_INPUT_MODE_DIRECT; mode ++) { KkcKeymap* keymap = kkc_rule_get_keymap(KKC_RULE(userRule), (KkcInputMode) mode); int length; KkcKeymapEntry* entries = kkc_keymap_entries(keymap, &length); for (int i = 0; i < length; i ++) { if (entries[i].command) { gchar* label = kkc_keymap_get_command_label(entries[i].command); m_entries << ShortcutEntry(QString::fromUtf8(entries[i].command), entries[i].key, QString::fromUtf8(label), (KkcInputMode) mode); g_free(label); } } for (int i = 0; i < length; i ++) { kkc_keymap_entry_destroy(&entries[i]); } g_free(entries); g_object_unref(keymap); } m_userRule = userRule; } while(0); endResetModel(); }
char* _fcitx_get_socket_path() { char* addressFile = NULL; char* machineId = dbus_get_local_machine_id(); asprintf(&addressFile, "%s-%d", machineId, fcitx_utils_get_display_number()); dbus_free(machineId); char* file = NULL; FcitxXDGGetFileUserWithPrefix("dbus", addressFile, NULL, &file); return file; }
static void FcitxNotifySaveDConfig(FcitxNotify *notify) { FILE *fp; fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-notify.config", "w", NULL); if (fp) { FcitxDesktopGroup *grp; grp = fcitx_desktop_file_ensure_group(¬ify->dconfig, "Notify/Notify"); FcitxDesktopEntry *ety; ety = fcitx_desktop_group_ensure_entry(grp, "HiddenNotify"); char *val = fcitx_string_map_to_string(notify->hide_notify, ';'); fcitx_desktop_entry_set_value(ety, val); free(val); fcitx_desktop_file_write_fp(¬ify->dconfig, fp); fclose(fp); } }
const QString& FcitxQtConnectionPrivate::socketFile() { if (!m_socketFile.isEmpty()) return m_socketFile; char* addressFile = NULL; asprintf(&addressFile, "%s-%d", localMachineId().data(), displayNumber()); char* file = NULL; FcitxXDGGetFileUserWithPrefix("dbus", addressFile, NULL, &file); QString path = QString::fromUtf8(file); free(file); free(addressFile); m_socketFile = path; return m_socketFile; }
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; }
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; }