bool_t save_preset_file (EqualizerPreset * preset, const char * filename) { GKeyFile *rcfile; int i; char *data; gsize len; GError *error = NULL; rcfile = g_key_file_new(); g_key_file_set_double(rcfile, "Equalizer preset", "Preamp", preset->preamp); for (i = 0; i < 10; i++) { char tmp[7]; g_snprintf(tmp, sizeof(tmp), "Band%d", i); g_key_file_set_double(rcfile, "Equalizer preset", tmp, preset->bands[i]); } data = g_key_file_to_data(rcfile, &len, &error); bool_t success = FALSE; VFSFile * file = vfs_fopen (filename, "w"); if (file == NULL) goto DONE; if (vfs_fwrite (data, 1, strlen (data), file) == strlen (data)) success = TRUE; vfs_fclose (file); DONE: g_free(data); g_key_file_free(rcfile); return success; }
/** \brief Save rotator configuration. * \param conf Pointer to the rotator configuration. * * This function saves the rotator configuration stored in conf to a * .rig file. conf->name must contain the file name of the configuration * (no path, just file name and without the .rot extension). */ void rotor_conf_save (rotor_conf_t *conf) { GKeyFile *cfg = NULL; gchar *confdir; gchar *fname; if (conf->name == NULL) return; /* create a config structure */ cfg = g_key_file_new(); g_key_file_set_string (cfg, GROUP, KEY_HOST, conf->host); g_key_file_set_integer (cfg, GROUP, KEY_PORT, conf->port); g_key_file_set_integer (cfg, GROUP, KEY_AZTYPE, conf->aztype); g_key_file_set_double (cfg, GROUP, KEY_MINAZ, conf->minaz); g_key_file_set_double (cfg, GROUP, KEY_MAXAZ, conf->maxaz); g_key_file_set_double (cfg, GROUP, KEY_MINEL, conf->minel); g_key_file_set_double (cfg, GROUP, KEY_MAXEL, conf->maxel); /* build filename */ confdir = get_hwconf_dir(); fname = g_strconcat (confdir, G_DIR_SEPARATOR_S, conf->name, ".rot", NULL); g_free (confdir); /* save information */ gpredict_save_key_file (cfg, fname); /* cleanup */ g_free (fname); g_key_file_free (cfg); }
/** * facq_source_nidaq_to_file: * @src: A #FacqSourceNidaq object casted to #FacqSource. * @file: A #GKeyFile object. * @group: The group name to use in the #GKeyFile, @file. * * Implements the facq_source_nidaq_to_file() method. * Stores the device, the buffer size, the maximum and minimum * expected values, the sampling period, the poll interval * and the list of channels inside a #GKeyFile. * This is used by facq_stream_save() function, and you shouldn't * need to call this. */ void facq_source_nidaq_to_file(FacqSource *src,GKeyFile *file,const gchar *group) { const FacqStreamData *stmd = NULL; FacqSourceNidaq *source = FACQ_SOURCE_NIDAQ(src); stmd = facq_source_get_stream_data(src); g_key_file_set_string(file,group,"dev",source->priv->device); g_key_file_set_double(file,group,"ni-bufsize",source->priv->nibufsize); g_key_file_set_double(file,group,"max",stmd->max[0]); g_key_file_set_double(file,group,"min",stmd->min[0]); g_key_file_set_double(file,group,"period",stmd->period); g_key_file_set_double(file,group,"sleep-us",(gdouble)source->priv->sleep_us); facq_chanlist_to_key_file(stmd->chanlist,file,group); }
XUL_APIEXPORT void xul_prefs_gdouble_set(xul_t * xul, const gchar * group, const gchar * key, gdouble value) { g_assert(XUL_IS_VALID(xul)); g_key_file_set_double(xul->prefs->keyfile, group, key, value); }
static void set_default_data ( VikLayerParamData data, const gchar *group, const gchar *name, VikLayerParamType ptype ) { switch ( ptype ) { case VIK_LAYER_PARAM_DOUBLE: g_key_file_set_double ( keyfile, group, name, data.d ); break; case VIK_LAYER_PARAM_UINT: g_key_file_set_integer ( keyfile, group, name, data.u ); break; case VIK_LAYER_PARAM_INT: g_key_file_set_integer ( keyfile, group, name, data.i ); break; case VIK_LAYER_PARAM_BOOLEAN: g_key_file_set_boolean ( keyfile, group, name, data.b ); break; case VIK_LAYER_PARAM_STRING: g_key_file_set_string ( keyfile, group, name, data.s ); break; case VIK_LAYER_PARAM_COLOR: { gchar *str = g_strdup_printf ( "#%.2x%.2x%.2x", (int)(data.c.red/256),(int)(data.c.green/256),(int)(data.c.blue/256)); g_key_file_set_string ( keyfile, group, name, str ); g_free ( str ); break; } default: break; } }
void libbalsa_conf_set_double_(const char *path, double value, gboolean priv) { g_key_file_set_double(LBC_KEY_FILE(priv), lbc_groups->data, path, value); LBC_CHANGED(priv); }
static void save_records (OfficeRunner *run) { GKeyFile *keyfile; GList *l; char *data, *path; GError *error = NULL; guint i; path = get_records_dir (); if (g_mkdir_with_parents (path, 0755) < 0) { g_warning ("Failed to create directory '%s'", path); g_free (path); return; } g_free (path); keyfile = g_key_file_new (); for (l = run->records, i = 0; l != NULL; l = l->next, i++) { ORecord *o = l->data; g_key_file_set_double (keyfile, cups[i], "time", o->time); } data = g_key_file_to_data (keyfile, NULL, NULL); g_key_file_free (keyfile); path = get_records_path (); if (g_file_set_contents (path, data, -1, &error) == FALSE) { g_warning ("Failed to save records to '%s': %s", path, error->message); g_error_free (error); } g_free (path); g_free (data); }
void rclib_settings_set_double(const gchar *group_name, const gchar *key, gdouble value) { settings_dirty = TRUE; if(settings_keyfile==NULL) return; g_key_file_set_double(settings_keyfile, group_name, key, value); }
/* * save all settings as a resource file "print-settings" * and as an image parasite */ void print_settings_save (PrintData *data) { GKeyFile *key_file = print_settings_key_file_from_settings (data); /* image setup */ if (gimp_image_is_valid (data->image_id)) { g_key_file_set_integer (key_file, "image-setup", "unit", data->unit); g_key_file_set_double (key_file, "image-setup", "x-resolution", data->xres); g_key_file_set_double (key_file, "image-setup", "y-resolution", data->yres); g_key_file_set_double (key_file, "image-setup", "x-offset", data->offset_x); g_key_file_set_double (key_file, "image-setup", "y-offset", data->offset_y); g_key_file_set_integer (key_file, "image-setup", "center-mode", data->center); g_key_file_set_boolean (key_file, "image-setup", "use-full-page", data->use_full_page); g_key_file_set_boolean (key_file, "image-setup", "crop-marks", data->draw_crop_marks); print_utils_key_file_save_as_parasite (key_file, data->image_id, PRINT_SETTINGS_NAME); } /* some settings shouldn't be made persistent on a global level, * so they are only stored in the image, not in the rcfile */ g_key_file_remove_key (key_file, "image-setup", "x-resolution", NULL); g_key_file_remove_key (key_file, "image-setup", "y-resolution", NULL); g_key_file_remove_key (key_file, "image-setup", "x-offset", NULL); g_key_file_remove_key (key_file, "image-setup", "y-offset", NULL); g_key_file_remove_key (key_file, PRINT_SETTINGS_NAME, "n-copies", NULL); print_utils_key_file_save_as_rcfile (key_file, PRINT_SETTINGS_NAME); g_key_file_free (key_file); }
gboolean ol_config_set_double (OlConfig *config, const char *group, const char *name, double value) { ol_assert_ret (config != NULL, FALSE); ol_assert_ret (name != NULL, FALSE); g_key_file_set_double (OL_CONFIG_GET_PRIVATE (config)->config, group, name, value); ol_config_emit_change (config, group, name); ol_config_save (config); }
// save all stored preferences to file void save_preferences (char *filepad) { gchar *data; gsize len; GString *label = g_string_new_len("", 20); int i; g_key_file_set_double (settings, "display", "opacity", conf.opacity); g_key_file_set_string (settings, "display", "font", conf.font); g_key_file_set_integer (settings, "display", "x", conf.x); g_key_file_set_integer (settings, "display", "y", conf.y); g_key_file_set_integer (settings, "display", "lx", conf.lx); g_key_file_set_integer (settings, "display", "ly", conf.ly); g_key_file_set_integer (settings, "display", "dx", conf.dx); g_key_file_set_integer (settings, "display", "dy", conf.dy); g_key_file_set_boolean (settings, "display", "tooltips", conf.tips); g_key_file_set_string (settings, "reader", "device", conf.device); g_key_file_set_integer (settings, "reader", "speed", conf.speed); g_key_file_set_uint64 (settings, "reader", "lijnkleur", conf.lijnkleur); g_key_file_set_uint64 (settings, "reader", "rasterkleur", conf.rasterkleur); g_key_file_set_boolean (settings, "reader", "raster", conf.raster); g_key_file_set_boolean (settings, "reader", "speech", conf.speech); g_key_file_set_integer (settings, "reader", "voice", conf.voice); g_key_file_set_integer (settings, "keys", "paste0", conf.paste[0]); g_key_file_set_integer (settings, "keys", "paste1", conf.paste[1]); g_key_file_set_integer (settings, "keys", "backspace0", conf.backspace[0]); g_key_file_set_integer (settings, "keys", "backspace1", conf.backspace[1]); g_key_file_set_integer (settings, "GB1", "key", conf.keymode[0].key); g_key_file_set_integer (settings, "GB1", "mode", conf.keymode[0].mode); g_key_file_set_integer (settings, "BIG5", "key", conf.keymode[1].key); g_key_file_set_integer (settings, "BIG5", "mode", conf.keymode[1].mode); g_key_file_set_integer (settings, "DIGITS", "key", conf.keymode[2].key); g_key_file_set_integer (settings, "DIGITS", "mode", conf.keymode[2].mode); g_key_file_set_integer (settings, "LOWERCASE", "key", conf.keymode[3].key); g_key_file_set_integer (settings, "LOWERCASE", "mode", conf.keymode[3].mode); g_key_file_set_integer (settings, "UPPERCASE", "key", conf.keymode[4].key); g_key_file_set_integer (settings, "UPPERCASE", "mode", conf.keymode[4].mode); g_key_file_set_integer (settings, "PUNC", "key", conf.keymode[5].key); g_key_file_set_integer (settings, "PUNC", "mode", conf.keymode[5].mode); g_key_file_set_integer (settings, "DEFAULT", "key", conf.keymode[6].key); g_key_file_set_integer (settings, "DEFAULT", "mode", conf.keymode[6].mode); for (i=0; i<13; i++) { g_string_sprintf(label, "key%d", i+1); g_key_file_set_integer (settings, "keydefs", label->str, conf.defkey[i].key); g_string_sprintf(label, "label%d", i+1); g_key_file_set_string (settings, "keydefs", label->str, conf.defkey[i].label); } data = g_key_file_to_data (settings, &len, NULL); g_file_set_contents (filepad, data, len, NULL); g_string_free(label, TRUE); g_free(data); }
bool_t equalizer_write_preset_file (Index * list, const char * basename) { char *filename; int i; GKeyFile *rcfile; char *data; gsize len; GError *error = NULL; rcfile = g_key_file_new(); for (int p = 0; p < index_count (list); p ++) { EqualizerPreset * preset = index_get (list, p); char * tmp = g_strdup_printf ("Preset%d", p); g_key_file_set_string(rcfile, "Presets", tmp, preset->name); g_free(tmp); g_key_file_set_double(rcfile, preset->name, "Preamp", preset->preamp); for (i = 0; i < 10; i++) { tmp = g_strdup_printf("Band%d", i); g_key_file_set_double(rcfile, preset->name, tmp, preset->bands[i]); g_free(tmp); } } filename = g_build_filename (get_path (AUD_PATH_USER_DIR), basename, NULL); data = g_key_file_to_data(rcfile, &len, &error); bool_t success = g_file_set_contents (filename, data, len, & error); g_free(data); g_key_file_free(rcfile); g_free(filename); return success; }
static gchar *_cairo_dock_generate_desktop_file_for_file (const gchar *cURI, const gchar *cDockName, double fOrder, GError **erreur) { //\___________________ On recupere le type mime du fichier. gchar *cIconName = NULL, *cName = NULL, *cRealURI = NULL; gboolean bIsDirectory; int iVolumeID; double fUnusedOrder; if (! cairo_dock_fm_get_file_info (cURI, &cName, &cRealURI, &cIconName, &bIsDirectory, &iVolumeID, &fUnusedOrder, mySystem.iFileSortType) || cIconName == NULL) return NULL; cd_message (" -> cIconName : %s; bIsDirectory : %d; iVolumeID : %d\n", cIconName, bIsDirectory, iVolumeID); if (bIsDirectory) { int answer = cairo_dock_ask_general_question_and_wait (_("Do you want to monitor the content of the directory ?")); if (answer != GTK_RESPONSE_YES) bIsDirectory = FALSE; } //\___________________ On ouvre le patron. gchar *cDesktopFileTemplate = cairo_dock_get_launcher_template_conf_file (bIsDirectory ? CAIRO_DOCK_LAUNCHER_FOR_CONTAINER : CAIRO_DOCK_LAUNCHER_FROM_DESKTOP_FILE); GKeyFile *pKeyFile = cairo_dock_open_key_file (cDesktopFileTemplate); g_free (cDesktopFileTemplate); if (pKeyFile == NULL) return NULL; //\___________________ On renseigne ce qu'on peut. g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", fOrder); g_key_file_set_string (pKeyFile, "Desktop Entry", "Container", cDockName); g_key_file_set_string (pKeyFile, "Desktop Entry", "Base URI", cURI); g_key_file_set_string (pKeyFile, "Desktop Entry", "Name", cName); g_free (cName); g_key_file_set_string (pKeyFile, "Desktop Entry", "Exec", cRealURI); g_free (cRealURI); g_key_file_set_string (pKeyFile, "Desktop Entry", "Icon", (cIconName != NULL ? cIconName : "")); g_free (cIconName); g_key_file_set_boolean (pKeyFile, "Desktop Entry", "Is mounting point", (iVolumeID > 0)); //\___________________ On lui choisit un nom de fichier tel qu'il n'y ait pas de collision. gchar *cNewDesktopFileName = cairo_dock_generate_desktop_filename ("file-launcher.desktop", g_cCurrentLaunchersPath); //\___________________ On ecrit tout. gchar *cNewDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, cNewDesktopFileName); cairo_dock_write_keys_to_file (pKeyFile, cNewDesktopFilePath); g_free (cNewDesktopFilePath); g_key_file_free (pKeyFile); return cNewDesktopFileName; }
static void lr_fastestmirrorcache_update(LrFastestMirrorCache *cache, gchar *url, gint64 ts, double connecttime) { if (!cache || !cache->keyfile || !url) return; GKeyFile *keyfile = cache->keyfile; g_key_file_set_int64(keyfile, url, CACHE_KEY_TS, ts); g_key_file_set_double(keyfile, url, CACHE_KEY_CONNECTTIME, connecttime); }
void MetadataManager::setDouble(String uri, const char* name, double value) { XOJ_CHECK_TYPE(MetadataManager); if (uri.isEmpty()) { return; } loadConfigFile(); g_key_file_set_double(this->config, uri.c_str(), name, value); updateAccessTime(uri); }
gboolean settings_write_config_file(GError **err) { g_return_val_if_fail(err == NULL || *err == NULL, FALSE); // Make sure the destination path exists gchar *configFileDir = g_path_get_dirname(settings.configFileName); g_mkdir_with_parents(configFileDir, 0777); g_free(configFileDir); GKeyFile *file = g_key_file_new(); // Intentional no error checking g_key_file_load_from_file(file, settings.configFileName, G_KEY_FILE_KEEP_COMMENTS, NULL); // Write settings according to the description list for (int i = 0; i < G_N_ELEMENTS(settingsList); i++) { SettingDescription desc = settingsList[i]; switch (desc.type) { case BOOLEAN: g_key_file_set_boolean(file, desc.group_name, desc.key, *(gboolean *)desc.setting); break; case STRING: if (*(gchar **)desc.setting) { g_key_file_set_string(file, desc.group_name, desc.key, *(gchar **)desc.setting); } else { g_key_file_set_string(file, desc.group_name, desc.key, ""); } break; case INTEGER: g_key_file_set_integer(file, desc.group_name, desc.key, *(gint *)desc.setting); break; case DOUBLE: g_key_file_set_double(file, desc.group_name, desc.key, *(gdouble *)desc.setting); break; } } gchar *string = g_key_file_to_data(file, NULL, NULL); g_key_file_free(file); if (!g_file_set_contents(settings.configFileName, string, -1, err)) { g_free(string); g_prefix_error(err, "Failed to write configuration file '%s' : ", settings.configFileName); return FALSE; } g_free(string); return TRUE; }
/** \brief Save rotator configuration. * \param conf Pointer to the rotator configuration. * * This function saves the rotator configuration stored in conf to a * .rig file. conf->name must contain the file name of the configuration * (no path, just file name and without the .rot extension). */ void rotor_conf_save (rotor_conf_t *conf) { GKeyFile *cfg = NULL; gchar *confdir; gchar *fname; gchar *data; gsize len; if (conf->name == NULL) return; /* create a config structure */ cfg = g_key_file_new(); g_key_file_set_string (cfg, GROUP, KEY_HOST, conf->host); g_key_file_set_integer (cfg, GROUP, KEY_PORT, conf->port); g_key_file_set_integer (cfg, GROUP, KEY_AZTYPE, conf->aztype); g_key_file_set_double (cfg, GROUP, KEY_MINAZ, conf->minaz); g_key_file_set_double (cfg, GROUP, KEY_MAXAZ, conf->maxaz); g_key_file_set_double (cfg, GROUP, KEY_MINEL, conf->minel); g_key_file_set_double (cfg, GROUP, KEY_MAXEL, conf->maxel); /* convert to text sdata */ data = g_key_file_to_data (cfg, &len, NULL); confdir = get_hwconf_dir(); fname = g_strconcat (confdir, G_DIR_SEPARATOR_S, conf->name, ".rot", NULL); g_free (confdir); g_file_set_contents (fname, data, len, NULL); g_free (fname); g_free (data); g_key_file_free (cfg); }
/** * anjuta_session_set_float: * @session: an #AnjutaSession object * @section: Section. * @key: Key name. * @value: Key value * * Set a float @value to @key in given @section. */ void anjuta_session_set_float (AnjutaSession *session, const gchar *section, const gchar *key, gfloat value) { g_return_if_fail (ANJUTA_IS_SESSION (session)); g_return_if_fail (section != NULL); g_return_if_fail (key != NULL); if (!value) { g_key_file_remove_key (session->priv->key_file, section, key, NULL); return; } g_key_file_set_double (session->priv->key_file, section, key, value); }
gchar *gldi_stack_icon_add_conf_file (const gchar *cDockName, double fOrder) { //\__________________ open the template. const gchar *cTemplateFile = GLDI_SHARE_DATA_DIR"/"CAIRO_DOCK_CONTAINER_CONF_FILE; GKeyFile *pKeyFile = cairo_dock_open_key_file (cTemplateFile); g_return_val_if_fail (pKeyFile != NULL, NULL); //\__________________ fill the parameters g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", fOrder); g_key_file_set_string (pKeyFile, "Desktop Entry", "Container", cDockName); gchar *cNewDesktopFileName = cairo_dock_generate_unique_filename ("container.desktop", g_cCurrentLaunchersPath); //\__________________ write the keys. gchar *cNewDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, cNewDesktopFileName); cairo_dock_write_keys_to_conf_file (pKeyFile, cNewDesktopFilePath); g_free (cNewDesktopFilePath); g_key_file_free (pKeyFile); return cNewDesktopFileName; }
void gm_pref_store_set_float(GmPrefStore * store, const gchar * key, gfloat value) { if (store == NULL) return; #if HAVE_GSETTINGS g_settings_set_double(store->settings, key, value); #else #ifdef HAVE_GCONF gchar *full_key; full_key = g_strdup_printf("/apps/%s/preferences/%s", store->context, key); gconf_client_set_float(store->gconf, full_key, value, NULL); g_free(full_key); #else g_key_file_set_double(store->keyfile, store->context, key, value); #endif #endif }
static gchar *_cairo_dock_generate_desktop_file_for_edition (CairoDockNewLauncherType iNewLauncherType, const gchar *cDockName, double fOrder, GError **erreur) { //\___________________ On ouvre le patron. gchar *cDesktopFileTemplate = cairo_dock_get_launcher_template_conf_file (iNewLauncherType); GKeyFile *pKeyFile = cairo_dock_open_key_file (cDesktopFileTemplate); g_free (cDesktopFileTemplate); if (pKeyFile == NULL) return NULL; //\___________________ On renseigne ce qu'on peut. g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", fOrder); g_key_file_set_string (pKeyFile, "Desktop Entry", "Container", cDockName); //\___________________ On lui choisit un nom de fichier tel qu'il n'y ait pas de collision, et qu'il soit comprehensible par l'utilisateur, au cas ou il voudrait les modifier a la main. gchar *cNewDesktopFileName = cairo_dock_generate_desktop_filename (iNewLauncherType == CAIRO_DOCK_LAUNCHER_FOR_CONTAINER ? "container.desktop" : iNewLauncherType == CAIRO_DOCK_LAUNCHER_FOR_SEPARATOR ? "separator.desktop" : "launcher.desktop", g_cCurrentLaunchersPath); //\___________________ On ecrit tout. gchar *cNewDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, cNewDesktopFileName); cairo_dock_write_keys_to_file (pKeyFile, cNewDesktopFilePath); g_free (cNewDesktopFilePath); g_key_file_free (pKeyFile); return cNewDesktopFileName; }
void cid_save_data (CidMainContainer **pCid) { CidMainContainer *cid = *pCid; if (!cid_load_key_file(pCid, cid->config->cConfFile)) cid_exit(CID_ERROR_READING_FILE,"Key File error"); if (cid->pWindow!=NULL) cid_get_data(pCid); // [System] configuration g_key_file_set_integer (cid->pKeyFile, "System", "PLAYER", cid->config->iPlayer); g_key_file_set_integer (cid->pKeyFile, "System", "INTER", cid->config->iInter/1000); g_key_file_set_integer (cid->pKeyFile, "System", "SYMBOL_COLOR", cid->config->iSymbolColor); g_key_file_set_boolean (cid->pKeyFile, "System", "MONITOR", cid->config->bMonitorPlayer); g_key_file_set_boolean (cid->pKeyFile, "System", "STATE", cid->config->bPlayerState); g_key_file_set_boolean (cid->pKeyFile, "System", "TITLE", cid->config->bDisplayTitle); g_key_file_set_boolean (cid->pKeyFile, "System", "CONTROLS", cid->config->bDisplayControl); g_key_file_set_double (cid->pKeyFile, "System", "POLICE_SIZE",(cid->config->dPoliceSize)); g_key_file_set_double_list (cid->pKeyFile, "System", "POLICE_COLOR", (cid->config->dPoliceColor), cid->config->gPlainTextSize); g_key_file_set_double_list (cid->pKeyFile, "System", "OUTLINE_COLOR", (cid->config->dOutlineTextColor), cid->config->gOutlineTextSize); // [Options] configuration g_key_file_set_boolean (cid->pKeyFile, "Options", "ANIMATION", cid->config->bRunAnimation); g_key_file_set_boolean (cid->pKeyFile, "Options", "HIDE", cid->config->bHide); if (strcmp(cid->config->cDefaultImage,TESTING_DIR"/"TESTING_COVER)!=0 && strcmp(cid->config->cDefaultImage,CID_DEFAULT_IMAGE)!=0) g_key_file_set_string (cid->pKeyFile, "Options", "IMAGE", cid->config->cDefaultImage); else g_key_file_set_string (cid->pKeyFile, "Options", "IMAGE", ""); g_key_file_set_boolean (cid->pKeyFile, "Options", "THREAD", cid->config->bThreaded); g_key_file_set_boolean (cid->pKeyFile, "Options", "DOWNLOAD", cid->config->bDownload); g_key_file_set_integer (cid->pKeyFile, "Options", "ANIMATION_TYPE", cid->config->iAnimationType); g_key_file_set_integer (cid->pKeyFile, "Options", "ANIMATION_SPEED", cid->config->iAnimationSpeed); g_key_file_set_integer (cid->pKeyFile, "Options", "DELAY", cid->config->iTimeToWait); g_key_file_set_integer (cid->pKeyFile, "Options", "D_SIZE", cid->config->iImageSize); g_key_file_set_boolean (cid->pKeyFile, "Options", "B_UNSTABLE", cid->config->bUnstable); if (strcmp(cid->config->cDLPath,cid->defaut->cDLPath) != 0) g_key_file_set_string (cid->pKeyFile, "Options", "DL_PATH", cid->config->cDLPath); else g_key_file_set_string (cid->pKeyFile, "Options", "DL_PATH", ""); // [Behaviour] configuration gint pSize[2] = {cid->config->iWidth,cid->config->iHeight}; gsize iReadSize = sizeof (pSize) / sizeof (*pSize); g_key_file_set_integer_list (cid->pKeyFile, "Behaviour", "SIZE", pSize, iReadSize); g_key_file_set_integer (cid->pKeyFile, "Behaviour", "GAP_X",cid->config->iPosX); g_key_file_set_integer (cid->pKeyFile, "Behaviour", "GAP_Y",cid->config->iPosY); g_key_file_set_double (cid->pKeyFile, "Behaviour", "ROTATION",(cid->config->dRotate)); g_key_file_set_double_list (cid->pKeyFile, "Behaviour", "COLOR", (cid->config->dColor), cid->config->gColorSize); g_key_file_set_double_list (cid->pKeyFile, "Behaviour", "FLYING_COLOR", (cid->config->dFlyingColor), cid->config->gFlyingColorSize); g_key_file_set_boolean (cid->pKeyFile, "Behaviour", "KEEP_CORNERS", cid->config->bKeepCorners); g_key_file_set_boolean (cid->pKeyFile, "Behaviour", "ALL_DESKTOP", cid->config->bAllDesktop); g_key_file_set_boolean (cid->pKeyFile, "Behaviour", "LOCK", cid->config->bLockPosition); g_key_file_set_boolean (cid->pKeyFile, "Behaviour", "MASK", cid->config->bMask); g_key_file_set_boolean (cid->pKeyFile, "Behaviour", "SWITCH_ABOVE", cid->config->bShowAbove); // [MPD] configuration gchar *cDefaultDir = g_strdup_printf ("%s/Music", g_getenv ("HOME")); if (cid->mpd_dir != NULL && strcmp (cid->mpd_dir, cDefaultDir) != 0) g_key_file_set_string (cid->pKeyFile, "MPD", "MPD_DIR", cid->mpd_dir); else g_key_file_set_string (cid->pKeyFile, "MPD", "MPD_DIR", ""); g_free (cDefaultDir); g_key_file_set_string (cid->pKeyFile, "MPD", "MPD_HOST", cid->mpd_host); gchar *cEncrypted = NULL; cid_encrypt_string (cid->mpd_pass, &cEncrypted); g_key_file_set_string (cid->pKeyFile, "MPD", "MPD_PASS", cEncrypted); g_free (cEncrypted); g_key_file_set_integer (cid->pKeyFile, "MPD", "MPD_PORT", cid->mpd_port); cid_write_keys_to_file (cid->pKeyFile, cid->config->cConfFile); }
static void ol_config_init (OlConfig *self) { OlConfigPrivate *priv = OL_CONFIG_GET_PRIVATE (self); priv->config = g_key_file_new (); if (!g_key_file_load_from_file (priv->config, ol_config_get_path (), G_KEY_FILE_KEEP_COMMENTS, NULL)) { } int i; for (i = 0; i < ol_get_array_len (config_bool); i++) { if (!g_key_file_has_key (priv->config, config_bool[i].group, config_bool[i].name, NULL)) { g_key_file_set_boolean (priv->config, config_bool[i].group, config_bool[i].name, config_bool[i].default_value); } } for (i = 0; i < ol_get_array_len (config_int); i++) { if (!g_key_file_has_key (priv->config, config_int[i].group, config_int[i].name, NULL)) { g_key_file_set_integer (priv->config, config_int[i].group, config_int[i].name, config_int[i].default_value); } } for (i = 0; i < ol_get_array_len (config_double); i++) { if (!g_key_file_has_key (priv->config, config_double[i].group, config_double[i].name, NULL)) { g_key_file_set_double (priv->config, config_double[i].group, config_double[i].name, config_double[i].default_value); } } for (i = 0; i < ol_get_array_len (config_str); i++) { if (!g_key_file_has_key (priv->config, config_str[i].group, config_str[i].name, NULL)) { g_key_file_set_string (priv->config, config_str[i].group, config_str[i].name, config_str[i].default_value); } } for (i = 0; i < ol_get_array_len (config_str_list); i++) { ol_debugf ("%s\n", config_str_list[i].name); if (!g_key_file_has_key (priv->config, config_str_list[i].group, config_str_list[i].name, NULL)) { int len = 0; if (config_str_list[i].len > 0) { len = config_str_list[i].len; } else { while (config_str_list[i].default_value[len] != NULL) len++; } ol_debugf ("name:%s len:%d\n", config_str_list[i].name, len); g_key_file_set_string_list (priv->config, config_str_list[i].group, config_str_list[i].name, config_str_list[i].default_value, len); } } }
/** * fm_folder_config_set_double * @fc: a configuration descriptor * @key: a key to search * @val: data to set * * Associates double @val with @key for given folder configuration. * * Since: 1.2.0 */ void fm_folder_config_set_double(FmFolderConfig *fc, const char *key, gdouble val) { fc->changed = TRUE; g_key_file_set_double(fc->kf, fc->group, key, val); }
// load preferences from file void load_preferences (char *filepad) { char txt[100]; GString *label = g_string_new_len("", 20); int i, p, choice = -1; GdkDevice *device, *nodevice; GList *list; TS keus; if (settings == NULL) settings = g_key_file_new(); if (g_key_file_load_from_file(settings, filepad, G_KEY_FILE_NONE, NULL) == FALSE) { // set defaults gchar *data; gsize len; // default settings when xpen.cfg not found g_key_file_set_integer (settings, "display", "x", -1); g_key_file_set_integer (settings, "display", "y", -1); g_key_file_set_integer (settings, "display", "lx", -1); g_key_file_set_integer (settings, "display", "ly", -1); g_key_file_set_integer (settings, "display", "dx", 300); g_key_file_set_integer (settings, "display", "dy", 400); g_key_file_set_double (settings, "display", "opacity", 0.7); g_key_file_set_string (settings, "display", "font", gtk_font_button_get_font_name(GTK_FONT_BUTTON(fontbutton))); g_key_file_set_boolean (settings, "display", "tooltips", TRUE); g_key_file_set_string (settings, "reader", "device", "stylus"); g_key_file_set_integer (settings, "reader", "speed", 6); g_key_file_set_uint64 (settings, "reader", "lijnkleur", 0x514942); g_key_file_set_uint64 (settings, "reader", "rasterkleur", 0xAB8C6D); g_key_file_set_boolean (settings, "reader", "raster", TRUE); g_key_file_set_boolean (settings, "reader", "speech", FALSE); g_key_file_set_string (settings, "reader", "command", "aplay -q"); g_key_file_set_integer (settings, "reader", "voice", 0); g_key_file_set_integer (settings, "keys", "paste0", 37); g_key_file_set_integer (settings, "keys", "paste1", 55); g_key_file_set_integer (settings, "keys", "backspace0", 0); g_key_file_set_integer (settings, "keys", "backspace1", 22); g_key_file_set_integer (settings, "GB1", "key", 0); g_key_file_set_integer (settings, "GB1", "mode", 0); g_key_file_set_integer (settings, "BIG5", "key", CTRL_R); g_key_file_set_integer (settings, "BIG5", "mode", BIG5); g_key_file_set_integer (settings, "DIGITS", "key", ALT_L); g_key_file_set_integer (settings, "DIGITS", "mode", DIGITS); g_key_file_set_integer (settings, "LOWERCASE", "key", ALT_L); g_key_file_set_integer (settings, "LOWERCASE", "mode", LOWERCASE); g_key_file_set_integer (settings, "UPPERCASE", "key", 0); g_key_file_set_integer (settings, "UPPERCASE", "mode", 0); g_key_file_set_integer (settings, "PUNC", "key", 0); g_key_file_set_integer (settings, "PUNC", "mode", 0); g_key_file_set_integer (settings, "DEFAULT", "key", ESC); g_key_file_set_integer (settings, "DEFAULT", "mode", (GB1|GB2|DIGITS)); g_key_file_set_string (settings, "keydefs", "label1", "Control-Left"); g_key_file_set_integer (settings, "keydefs", "key1", CTRL_L); g_key_file_set_string (settings, "keydefs", "label2", "Control-Right"); g_key_file_set_integer (settings, "keydefs", "key2", CTRL_R); g_key_file_set_string (settings, "keydefs", "label3", "Shift-Left"); g_key_file_set_integer (settings, "keydefs", "key3", SHIFT_L); g_key_file_set_string (settings, "keydefs", "label4", "Shift-Right"); g_key_file_set_integer (settings, "keydefs", "key4", SHIFT_R); g_key_file_set_string (settings, "keydefs", "label5", "Alt-Left"); g_key_file_set_integer (settings, "keydefs", "key5", ALT_L); g_key_file_set_string (settings, "keydefs", "label6", "Alt-Right"); g_key_file_set_integer (settings, "keydefs", "key6", ALT_R); g_key_file_set_string (settings, "keydefs", "label7", "Escape"); g_key_file_set_integer (settings, "keydefs", "key7", ESC); g_key_file_set_string (settings, "keydefs", "label8", "Caps-Lock"); g_key_file_set_integer (settings, "keydefs", "key8", CAPS); g_key_file_set_string (settings, "keydefs", "label9", "Num-Lock"); g_key_file_set_integer (settings, "keydefs", "key9", NUMS); g_key_file_set_string (settings, "keydefs", "label10", "Scroll-Lock"); g_key_file_set_integer (settings, "keydefs", "key10", SCROLLS); g_key_file_set_string (settings, "keydefs", "label11", "Pause/Break"); g_key_file_set_integer (settings, "keydefs", "key11", PAUSE); g_key_file_set_string (settings, "keydefs", "label12", "not set"); g_key_file_set_integer (settings, "keydefs", "key12", 0); g_key_file_set_string (settings, "keydefs", "label13", "not set"); g_key_file_set_integer (settings, "keydefs", "key13", 0); data = g_key_file_to_data (settings, &len, NULL); // save defaults g_file_set_contents (filepad, data, len, NULL); g_free(data); } // fill the preferences structure conf.x = g_key_file_get_integer (settings, "display", "x", NULL); conf.y = g_key_file_get_integer (settings, "display", "y", NULL); conf.lx = g_key_file_get_integer (settings, "display", "lx", NULL); conf.ly = g_key_file_get_integer (settings, "display", "ly", NULL); conf.dx = g_key_file_get_integer (settings, "display", "dx", NULL); conf.dy = g_key_file_get_integer (settings, "display", "dy", NULL); conf.opacity = g_key_file_get_double (settings, "display", "opacity", NULL); conf.tips = g_key_file_get_boolean (settings, "display", "tooltips", NULL); conf.font = g_key_file_get_string (settings, "display", "font", NULL); conf.device = g_key_file_get_string (settings, "reader", "device", NULL); conf.speed = g_key_file_get_integer (settings, "reader", "speed", NULL); conf.lijnkleur = g_key_file_get_uint64 (settings, "reader", "lijnkleur", NULL); conf.rasterkleur = g_key_file_get_uint64 (settings, "reader", "rasterkleur", NULL); conf.raster = g_key_file_get_boolean (settings, "reader", "raster", NULL); conf.speech = g_key_file_get_boolean (settings, "reader", "speech", NULL); conf.voice = g_key_file_get_integer (settings, "reader", "voice", NULL); conf.paste[0] = g_key_file_get_integer (settings, "keys", "paste0", NULL); conf.paste[1] = g_key_file_get_integer (settings, "keys", "paste1", NULL); conf.backspace[0] = g_key_file_get_integer (settings, "keys", "backspace0", NULL); conf.backspace[1] = g_key_file_get_integer (settings, "keys", "backspace1", NULL); conf.keymode[0].key = g_key_file_get_integer (settings, "GB1", "key", NULL); conf.keymode[0].mode = g_key_file_get_integer (settings, "GB1", "mode", NULL); conf.keymode[1].key = g_key_file_get_integer (settings, "BIG5", "key", NULL); conf.keymode[1].mode = g_key_file_get_integer (settings, "BIG5", "mode", NULL); conf.keymode[2].key = g_key_file_get_integer (settings, "DIGITS", "key", NULL); conf.keymode[2].mode = g_key_file_get_integer (settings, "DIGITS", "mode", NULL); conf.keymode[3].key = g_key_file_get_integer (settings, "LOWERCASE", "key", NULL); conf.keymode[3].mode = g_key_file_get_integer (settings, "LOWERCASE", "mode", NULL); conf.keymode[4].key = g_key_file_get_integer (settings, "UPPERCASE", "key", NULL); conf.keymode[4].mode = g_key_file_get_integer (settings, "UPPERCASE", "mode", NULL); conf.keymode[5].key = g_key_file_get_integer (settings, "PUNC", "key", NULL); conf.keymode[5].mode = g_key_file_get_integer (settings, "PUNC", "mode", NULL); conf.keymode[6].key = g_key_file_get_integer (settings, "DEFAULT", "key", NULL); conf.keymode[6].mode = g_key_file_get_integer (settings, "DEFAULT", "mode", NULL); // set speech + command GTK_TOGGLE_BUTTON(checkbutton9)->active = conf.speech; gtk_combo_box_set_active(GTK_COMBO_BOX(combobox1), conf.voice); for (i=0; i<13; i++) { g_string_sprintf(label, "key%d", i+1); conf.defkey[i].key = g_key_file_get_integer (settings, "keydefs", label->str, NULL); g_string_sprintf(label, "label%d", i+1); conf.defkey[i].label = g_key_file_get_string (settings, "keydefs", label->str, NULL); } // start setting all widgets with the values from the configuration (conf) // set tooltips GTK_TOGGLE_BUTTON(checkbutton8)->active = conf.tips; // set the 13 buttons/entries in preferences for (i=0; i<13; i++) { if (conf.defkey[i].key > 0) { g_string_sprintf(label, "key = %d", conf.defkey[i].key); gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), label->str); gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), conf.defkey[i].label); } else { gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), "not set"); gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), ""); } } g_string_free(label, TRUE); // set the default recognition mode mode = conf.keymode[6].mode; keus = (mode & BIG5) ? Traditional : Simplified; selecteer(keus); // set the labels of the hotkeys (preferences) for (i=0; i<7; i++) { bool found; hotkey[conf.keymode[i].key] |= conf.keymode[i].mode; // set the hotkeys found = FALSE; for (p=0; p<13; p++) { if (conf.defkey[p].key > 0) { if (conf.keymode[i].key == conf.defkey[p].key) { strcpy(txt, conf.defkey[p].label); found = TRUE; break; } } } if (found == FALSE) { if (conf.keymode[i].key > 0) sprintf(txt, "key = %d", conf.keymode[i].key); else strcpy(txt, "not set"); } gtk_button_set_label(GTK_BUTTON(modebits[i].button), txt); // set the default checkboxes (preferences) if (conf.keymode[6].mode & GB1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[0].check), TRUE); if (conf.keymode[6].mode & BIG5) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[1].check), TRUE); if (conf.keymode[6].mode & DIGITS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[2].check), TRUE); if (conf.keymode[6].mode & LOWERCASE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[3].check), TRUE); if (conf.keymode[6].mode & UPPERCASE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[4].check), TRUE); if (conf.keymode[6].mode & PUNC) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[5].check), TRUE); } // fill combobox with input-devices list = gdk_devices_list(); device = (GdkDevice *) list->data; // default device nodevice = NULL; for (p=0; list->next; p++) { strcpy(txt, gdk_device_get_name((GdkDevice *)list->data)); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), txt); if (strstr(txt, conf.device)) { device = (GdkDevice *) list->data; choice = p; } nodevice = (GdkDevice *) list->data; list = list->next; } if (choice == -1) { // prefered device not found choice = p-1; device = nodevice; } //g_list_free(list); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), choice); gdk_device_set_source (device, GDK_SOURCE_PEN); gdk_device_set_mode(device, GDK_MODE_SCREEN); // set line color lijnkleur.pixel = conf.lijnkleur; sprintf(txt, "#%.6X", lijnkleur.pixel); gdk_color_parse(txt, &lijnkleur); gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton1), &lijnkleur); // set raster color rasterkleur.pixel = conf.rasterkleur; sprintf(txt, "#%.6X", rasterkleur.pixel); gdk_color_parse(txt, &rasterkleur); gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton2), &rasterkleur); // set raster on/off check button GTK_TOGGLE_BUTTON(checkbutton1)->active = conf.raster; // set main window opacity slider gtk_adjustment_set_value(opacity, conf.opacity); // set the 9 candidate buttons with a default font for (i=0; i< 9; i++) { PangoFontDescription *pfont; pfont = pango_font_description_from_string(conf.font); gtk_widget_modify_font (GTK_WIDGET(knop[i]), pfont ); pango_font_description_free(pfont); } // set the font selection button with the font title gtk_font_button_set_font_name(GTK_FONT_BUTTON(fontbutton), conf.font); // set the recognize speed slider gtk_adjustment_set_value(speed, conf.speed); WTSetSpeed(conf.speed); // set the default paste and backspace entry fields gtk_entry_set_text(GTK_ENTRY(entry1), key2string(conf.paste[1], conf.paste[0])); gtk_entry_set_text(GTK_ENTRY(entry2), key2string(conf.backspace[1], conf.backspace[0])); }
void a_settings_set_double ( const gchar *name, gdouble val ) { g_key_file_set_double ( keyfile, VIKING_SETTINGS_GROUP, name, val ); }
void cairo_dock_swap_icons (CairoDock *pDock, Icon *icon1, Icon *icon2) { //g_print ("%s (%s, %s) : %.2f <-> %.2f\n", __func__, icon1->acName, icon2->acName, icon1->fOrder, icon2->fOrder); if (! ( (CAIRO_DOCK_IS_APPLI (icon1) && CAIRO_DOCK_IS_APPLI (icon2)) || (CAIRO_DOCK_IS_LAUNCHER (icon1) && CAIRO_DOCK_IS_LAUNCHER (icon2)) || (CAIRO_DOCK_IS_APPLET (icon1) && CAIRO_DOCK_IS_APPLET (icon2)) ) ) return ; //\_________________ On intervertit les ordres des 2 lanceurs. double fSwap = icon1->fOrder; icon1->fOrder = icon2->fOrder; icon2->fOrder = fSwap; //\_________________ On change l'ordre dans les fichiers des 2 lanceurs. if (CAIRO_DOCK_IS_LAUNCHER (icon1)) // ce sont des lanceurs. { gchar *cDesktopFilePath; GKeyFile* pKeyFile; if (icon1->acDesktopFileName != NULL) { cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon1->acDesktopFileName); pKeyFile = cairo_dock_open_key_file (cDesktopFilePath); if (pKeyFile == NULL) return ; g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", icon1->fOrder); cairo_dock_write_keys_to_file (pKeyFile, cDesktopFilePath); g_key_file_free (pKeyFile); g_free (cDesktopFilePath); } if (icon2->acDesktopFileName != NULL) { cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon2->acDesktopFileName); pKeyFile = cairo_dock_open_key_file (cDesktopFilePath); if (pKeyFile == NULL) return ; g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", icon2->fOrder); cairo_dock_write_keys_to_file (pKeyFile, cDesktopFilePath); g_key_file_free (pKeyFile); g_free (cDesktopFilePath); } } //\_________________ On les intervertit dans la liste. if (pDock->pFirstDrawnElement != NULL && (pDock->pFirstDrawnElement->data == icon1 || pDock->pFirstDrawnElement->data == icon2)) pDock->pFirstDrawnElement = NULL; pDock->icons = g_list_remove (pDock->icons, icon1); pDock->icons = g_list_remove (pDock->icons, icon2); pDock->icons = g_list_insert_sorted (pDock->icons, icon1, (GCompareFunc) cairo_dock_compare_icons_order); pDock->icons = g_list_insert_sorted (pDock->icons, icon2, (GCompareFunc) cairo_dock_compare_icons_order); //\_________________ On recalcule la largeur max, qui peut avoir ete influencee par le changement d'ordre. cairo_dock_update_dock_size (pDock); //\_________________ On met a jour l'ordre des applets dans le fichier de conf. if (CAIRO_DOCK_IS_APPLET (icon1)) cairo_dock_update_module_instance_order (icon1->pModuleInstance, icon1->fOrder); if (CAIRO_DOCK_IS_APPLET (icon2)) cairo_dock_update_module_instance_order (icon2->pModuleInstance, icon2->fOrder); if (fabs (icon2->fOrder - icon1->fOrder) < 1e-3) { cairo_dock_normalize_icons_order (pDock->icons, icon1->iType); } }
static gboolean save_placemarks (PlacemarksPlugin *plugin) { PlacemarksPluginPrivate *priv; GKeyFile *file; GtkTreeIter iter; gchar *data, *filename, *path; GError *error = NULL; gint i = 0; priv = PLACEMARKS_PLUGIN (plugin)->priv; file = g_key_file_new (); if (gtk_tree_model_get_iter_first (priv->model, &iter)) { do { gchar *id; gchar *name; gfloat lat, lon; gint zoom; id = g_strdup_printf ("Placemark%d", i++), gtk_tree_model_get (priv->model, &iter, COL_NAME, &name, COL_LAT, &lat, COL_LON, &lon, COL_ZOOM, &zoom, -1); g_key_file_set_string (file, id, "name", name); g_key_file_set_double (file, id, "latitude", lat); g_key_file_set_double (file, id, "longitude", lon); g_key_file_set_integer (file, id, "zoom", zoom); g_free (id); g_free (name); } while (gtk_tree_model_iter_next (priv->model, &iter)); } data = g_key_file_to_data (file, NULL, NULL); filename = g_build_filename (g_get_user_data_dir (), "emerillon", "placemarks.ini", NULL); path = g_path_get_dirname (filename); if (g_mkdir_with_parents (path, 0700) != 0) g_error ("Error creating %s directory", path); g_free (path); if (!g_file_set_contents (filename, data, -1, &error)) { g_warning ("Error writing %s: %s", filename, error->message); g_error_free (error); } g_key_file_free (file); g_free (data); g_free (filename); return FALSE; }
gchar *gldi_launcher_add_conf_file (const gchar *cOrigin, const gchar *cDockName, double fOrder) { //\__________________ open the template. const gchar *cTemplateFile = GLDI_SHARE_DATA_DIR"/"CAIRO_DOCK_LAUNCHER_CONF_FILE; GKeyFile *pKeyFile = cairo_dock_open_key_file (cTemplateFile); g_return_val_if_fail (pKeyFile != NULL, NULL); //\__________________ fill the parameters gchar *cFilePath = NULL; if (cOrigin != NULL && *cOrigin != '/') // transform the origin URI into a path or a file name. { if (strncmp (cOrigin, "application://", 14) == 0) // Ubuntu >= 11.04: it's now an "app" URI cFilePath = g_strdup (cOrigin + 14); // in this case we don't have the actual path of the .desktop, but that doesn't matter. else cFilePath = g_filename_from_uri (cOrigin, NULL, NULL); } else // no origin or already a path. cFilePath = g_strdup (cOrigin); g_key_file_set_string (pKeyFile, "Desktop Entry", "Origin", cFilePath?cFilePath:""); g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", fOrder); g_key_file_set_string (pKeyFile, "Desktop Entry", "Container", cDockName); //\__________________ in the case of a script, set ourselves a valid name and command. if (cFilePath != NULL && g_str_has_suffix (cFilePath, ".sh")) { gchar *cName = g_path_get_basename (cFilePath); g_key_file_set_string (pKeyFile, "Desktop Entry", "Name", cName); g_free (cName); g_key_file_set_string (pKeyFile, "Desktop Entry", "Exec", cFilePath); g_key_file_set_boolean (pKeyFile, "Desktop Entry", "Terminal", TRUE); } //\__________________ in the case of a custom launcher, set a command (the launcher would be invalid without). if (cFilePath == NULL) { g_key_file_set_string (pKeyFile, "Desktop Entry", "Exec", _("Enter a command")); g_key_file_set_string (pKeyFile, "Desktop Entry", "Name", _("New launcher")); } //\__________________ generate a unique and readable filename. gchar *cBaseName = (cFilePath ? *cFilePath == '/' ? g_path_get_basename (cFilePath) : g_strdup (cFilePath) : g_path_get_basename (cTemplateFile)); if (! g_str_has_suffix (cBaseName, ".desktop")) // if we have a script (.sh file) => add '.desktop' { gchar *cTmpBaseName = g_strdup_printf ("%s.desktop", cBaseName); g_free (cBaseName); cBaseName = cTmpBaseName; } gchar *cNewDesktopFileName = cairo_dock_generate_unique_filename (cBaseName, g_cCurrentLaunchersPath); g_free (cBaseName); //\__________________ write the keys. gchar *cNewDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, cNewDesktopFileName); cairo_dock_write_keys_to_conf_file (pKeyFile, cNewDesktopFilePath); g_free (cNewDesktopFilePath); g_free (cFilePath); g_key_file_free (pKeyFile); return cNewDesktopFileName; }
void configure_program_dialog(GtkWidget *widget, gpointer user_data) { /** Program configuration dailog window. **/ #ifdef DEBUG DEBUG_FUNC_MARK #endif GtkWidget *configure_dialog = gtk_dialog_new() ; gtk_window_set_icon_from_file(GTK_WINDOW(configure_dialog), PATH_TO_PRG_WIN_ICON, NULL) ; gtk_window_set_title(GTK_WINDOW(configure_dialog), "Configure program") ; gtk_window_set_position(GTK_WINDOW(configure_dialog), GTK_WIN_POS_CENTER_ALWAYS) ; gtk_window_set_resizable(GTK_WINDOW(configure_dialog), FALSE); gtk_widget_set_size_request(configure_dialog,-1,-1) ; gtk_window_set_modal(GTK_WINDOW(configure_dialog), FALSE) ; gtk_window_set_destroy_with_parent(GTK_WINDOW(configure_dialog), TRUE) ; gtk_window_set_decorated(GTK_WINDOW(configure_dialog), TRUE) ; gtk_window_set_type_hint(GTK_WINDOW(configure_dialog), GDK_WINDOW_TYPE_HINT_NORMAL) ; gtk_window_set_transient_for(GTK_WINDOW(configure_dialog), GTK_WINDOW(gui->window)) ; gtk_container_set_border_width(GTK_CONTAINER(configure_dialog), 12) ; #define DIALOG_DEFAULT_SPACE 12 /** ***** [START] Icon set choice [START] ***** **/ GtkWidget *icon_set_choice_frame = gtk_frame_new(" Icon set ") ; GtkWidget *icon_set_choice_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ; gtk_container_set_border_width(GTK_CONTAINER(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ; gtk_box_set_spacing(GTK_BOX(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ; gtk_box_set_homogeneous(GTK_BOX(icon_set_choice_hbox), TRUE) ; GtkWidget *radiobutton_icons_high_contrast = gtk_radio_button_new_with_label(NULL, " HighContrast") ; GtkWidget *image_icons_high_contrast ; GtkWidget *radiobutton_icons_oxygen = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_icons_high_contrast)), " Oxygen") ; GtkWidget *image_icons_oxygen ; gtk_widget_set_tooltip_markup(radiobutton_icons_high_contrast, "Set the <b>HighContrast</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_widget_set_tooltip_markup(radiobutton_icons_oxygen, "Set the <b>Oxygen</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), FALSE) ; gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), FALSE) ; if (settings.icon_set_oxygen) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), TRUE) ; image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-angry.png") ; image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-smile-big.png") ; } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), TRUE) ; image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-smile-big.png") ; image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-angry.png") ; } gtk_button_set_image(GTK_BUTTON(radiobutton_icons_high_contrast), image_icons_high_contrast) ; gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_high_contrast), TRUE) ; gtk_button_set_image(GTK_BUTTON(radiobutton_icons_oxygen), image_icons_oxygen) ; gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_oxygen), TRUE) ; gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_high_contrast, TRUE, TRUE, 0) ; gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_oxygen, TRUE, TRUE, 0) ; gtk_container_add(GTK_CONTAINER(icon_set_choice_frame), icon_set_choice_hbox) ; /** ***** [END] Icon set choice [END] ***** **/ /** ***** [START] Playing settings [START] ***** **/ GtkWidget *playing_settings_frame = gtk_frame_new(" Player settings ") ; GtkWidget *playing_settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ; gtk_container_set_border_width(GTK_CONTAINER(playing_settings_vbox), DIALOG_DEFAULT_SPACE) ; GtkWidget *playing_settings_repeat_all = gtk_check_button_new_with_label(" Repeat all mode. ") ; gtk_widget_set_tooltip_markup(playing_settings_repeat_all, "Enable the <b>repeat all</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all), is_repeat_all) ; GtkWidget *playing_settings_shuffle = gtk_check_button_new_with_label(" Shuffle mode. ") ; gtk_widget_set_tooltip_markup(playing_settings_shuffle, "Enable the <b>shuffle</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle), is_shuffle ) ; GtkWidget *playing_settings_volume_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ; GtkWidget *playing_settings_volume_label_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ; GtkWidget *playing_settings_volume_image = gtk_image_new_from_file( (settings.path_to_button_icons + "audio-volume-medium.png").c_str() ) ; GtkWidget *playing_settings_volume_label = gtk_label_new(" Default Volume:") ; gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_image, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_label, FALSE, FALSE, 0) ; GtkWidget *playing_settings_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1.0) ; gtk_widget_set_tooltip_markup(playing_settings_volume_scale, "Set the <b>default player volume</b> at start.\nThis will <b>not</b> update the player settings.\nYou must press the <b>Apply</b> button to store your configuration.") ; gtk_range_set_value(GTK_RANGE(playing_settings_volume_scale), settings.volume) ; gtk_scale_set_draw_value(GTK_SCALE(playing_settings_volume_scale), TRUE) ; gtk_scale_set_has_origin(GTK_SCALE(playing_settings_volume_scale), TRUE) ; gtk_scale_set_value_pos(GTK_SCALE(playing_settings_volume_scale), GTK_POS_TOP) ; gtk_scale_add_mark(GTK_SCALE(playing_settings_volume_scale), 50.0, GTK_POS_TOP, NULL) ; gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_label_hbox, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_scale, TRUE, TRUE, 0) ; gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_repeat_all, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_shuffle, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_volume_hbox, FALSE, FALSE, 0) ; gtk_container_add(GTK_CONTAINER(playing_settings_frame), playing_settings_vbox) ; /** ***** [END] Playing settings [END] ***** **/ /** ***** [START] Interface size setting [START] ***** **/ GtkWidget *interface_size_frame = gtk_frame_new(" Interface size ") ; GtkWidget *interface_size_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ; gtk_container_set_border_width(GTK_CONTAINER(interface_size_hbox), DIALOG_DEFAULT_SPACE) ; GtkWidget *interface_size_radiobutton_little = gtk_radio_button_new_with_label(NULL, " Little") ; GtkWidget *interface_size_radiobutton_middle = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Medium") ; GtkWidget *interface_size_radiobutton_big = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Big ") ; GtkWidget *interface_size_little_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-little.png").c_str() ) ; GtkWidget *interface_size_middle_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-middle.png").c_str() ) ; GtkWidget *interface_size_big_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-big.png").c_str() ) ; gtk_widget_set_tooltip_markup(interface_size_radiobutton_little, "Set the <b>interface size</b> on <b>little</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_widget_set_tooltip_markup(interface_size_radiobutton_middle, "Set the <b>interface size</b> on <b>middle</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_widget_set_tooltip_markup(interface_size_radiobutton_big, "Set the <b>interface size</b> on <b>big</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_little), interface_size_little_image) ; gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_middle), interface_size_middle_image) ; gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_big), interface_size_big_image ) ; gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_little), TRUE) ; gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_middle), TRUE) ; gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_big), TRUE) ; gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), FALSE) ; gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), FALSE) ; gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), FALSE) ; switch (settings.image_resized_size) { case IMAGE_RESIZED_SIZE_LITTLE : gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), TRUE) ; break ; case IMAGE_RESIZED_SIZE_MIDDLE : gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), TRUE) ; break ; case IMAGE_RESIZED_SIZE_BIG : gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), TRUE) ; break ; default : break ; } gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_little, TRUE, TRUE, 0) ; gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_middle, TRUE, TRUE, 0) ; gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_big, TRUE, TRUE, 0) ; gtk_box_set_homogeneous(GTK_BOX(interface_size_hbox), TRUE) ; gtk_box_set_spacing(GTK_BOX(interface_size_hbox), DIALOG_DEFAULT_SPACE) ; gtk_container_add(GTK_CONTAINER(interface_size_frame), interface_size_hbox) ; /** ***** [END] Interface size setting [END] ***** **/ /** ***** [START] Music folder setting [START] ***** **/ GtkWidget *folder_selecting_frame = gtk_frame_new(" Music folder ") ; GtkWidget *folder_selecting_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ; gtk_container_set_border_width(GTK_CONTAINER(folder_selecting_box), DIALOG_DEFAULT_SPACE) ; GtkWidget *folder_selecting_button = gtk_file_chooser_button_new("Set the Music folder to open per default.", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ; gtk_widget_set_tooltip_markup(folder_selecting_button, "Set the folder to open per default: your <b>default music folder</b>.\n<i>The default folder from the folder selector</i>.\nSet it simply to your <b>Music folder</b>.\nChanges are immediatly applied.\nBut you must press the <b>Apply</b> button to store your configuration.") ; gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(folder_selecting_button), "Set the Music folder to open per default.") ; const char *user_music_folder = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC) ; gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_selecting_button), (g_file_test(settings.path_to_music_folder.c_str(), G_FILE_TEST_IS_DIR)) ? settings.path_to_music_folder.c_str() : (user_music_folder != NULL) ? user_music_folder : g_get_home_dir() ) ; gtk_box_pack_start(GTK_BOX(folder_selecting_box), folder_selecting_button, TRUE, TRUE, 0) ; gtk_container_add(GTK_CONTAINER(folder_selecting_frame), folder_selecting_box) ; /** ***** [END] Music folder setting [END] ***** **/ /** ***** [START] Dialog main content box [START] ***** **/ GtkWidget *content_area = gtk_dialog_get_content_area( GTK_DIALOG(configure_dialog) ) ; gtk_box_pack_start(GTK_BOX(content_area), icon_set_choice_frame, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(content_area), playing_settings_frame, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(content_area), interface_size_frame, FALSE, FALSE, 0) ; gtk_box_pack_start(GTK_BOX(content_area), folder_selecting_frame, FALSE, FALSE, 0) ; gtk_box_set_spacing(GTK_BOX(content_area), DIALOG_DEFAULT_SPACE) ; /** ***** [END] Dialog main content box [END] ***** **/ /** ***** [START] Dialog action buttons [START] ***** **/ GtkWidget *button_close = gtk_button_new_with_label("Close") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Cancel", GTK_RESPONSE_CANCEL) ; GtkWidget *image_close = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-close.png").c_str()) ; gtk_widget_set_tooltip_markup(button_close, "<b>Close</b> the configuration window and don't store any setting.") ; gtk_button_set_image(GTK_BUTTON(button_close), image_close) ; gtk_button_set_always_show_image(GTK_BUTTON(button_close), TRUE) ; GtkWidget *button_ok = gtk_button_new_with_label("Apply") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Apply", GTK_RESPONSE_APPLY) ; GtkWidget *image_ok = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-ok.png").c_str()) ; gtk_widget_set_tooltip_markup(button_ok, "<b>Register</b> all the settings as <i>your default configuration</i> at start.") ; gtk_button_set_image(GTK_BUTTON(button_ok), image_ok) ; gtk_button_set_always_show_image(GTK_BUTTON(button_ok), TRUE) ; gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_close, GTK_RESPONSE_CLOSE) ; gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_ok, GTK_RESPONSE_APPLY) ; GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(configure_dialog)) ; gtk_container_set_border_width(GTK_CONTAINER(action_area), 0) ; gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_EDGE) ; /** ***** [END] Dialog action buttons [END] ***** **/ Radio_Config high_contrast_radiobutton ; high_contrast_radiobutton.button = radiobutton_icons_high_contrast ; high_contrast_radiobutton.image = image_icons_high_contrast ; high_contrast_radiobutton.volume = playing_settings_volume_image ; high_contrast_radiobutton.cancel = image_close ; high_contrast_radiobutton.apply = image_ok ; high_contrast_radiobutton.little = interface_size_little_image ; high_contrast_radiobutton.middle = interface_size_middle_image ; high_contrast_radiobutton.big = interface_size_big_image ; Radio_Config oxygen_radiobutton ; oxygen_radiobutton.button = radiobutton_icons_oxygen ; oxygen_radiobutton.image = image_icons_oxygen ; oxygen_radiobutton.volume = playing_settings_volume_image ; oxygen_radiobutton.cancel = image_close ; oxygen_radiobutton.apply = image_ok ; oxygen_radiobutton.little = interface_size_little_image ; oxygen_radiobutton.middle = interface_size_middle_image ; oxygen_radiobutton.big = interface_size_big_image ; g_signal_connect(G_OBJECT(radiobutton_icons_high_contrast), "clicked", G_CALLBACK(configure_high_contrast_radiobutton), &high_contrast_radiobutton) ; g_signal_connect(G_OBJECT(radiobutton_icons_oxygen), "clicked", G_CALLBACK(configure_oxygen_radiobutton), &oxygen_radiobutton ) ; int little = -1 ; int middle = 0 ; int big = 1 ; g_signal_connect(G_OBJECT(interface_size_radiobutton_little), "clicked", G_CALLBACK(reconfigure_interface_size), &little) ; g_signal_connect(G_OBJECT(interface_size_radiobutton_middle), "clicked", G_CALLBACK(reconfigure_interface_size), &middle) ; g_signal_connect(G_OBJECT(interface_size_radiobutton_big), "clicked", G_CALLBACK(reconfigure_interface_size), &big) ; g_signal_connect(G_OBJECT(playing_settings_repeat_all), "toggled", G_CALLBACK(repeat_all_feature_set), NULL) ; g_signal_connect(G_OBJECT(playing_settings_shuffle), "toggled", G_CALLBACK(shuffle_feature_set), NULL) ; g_signal_connect(G_OBJECT(playing_settings_volume_scale), "value-changed", G_CALLBACK(get_volume), NULL) ; g_signal_connect(G_OBJECT(folder_selecting_button), "file-set", G_CALLBACK(set_default_folder), NULL) ; gtk_widget_show_all(configure_dialog) ; int response = gtk_dialog_run(GTK_DIALOG(configure_dialog)) ; switch (response) { case GTK_RESPONSE_APPLY : { GKeyFile *conf_file = g_key_file_new() ; GError *error = NULL ; settings.is_repeat_all = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all)) ; settings.is_shuffle = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle)) ; // Set configuration settings to configuration file buffer. g_key_file_set_string(conf_file, "Config", "Buttons_Icons_Path", settings.path_to_button_icons.c_str()) ; g_key_file_set_string(conf_file, "Config", "Menu_Icons_Path", settings.path_to_menu_icons.c_str()) ; g_key_file_set_string(conf_file, "Config", "Music_Folder", settings.path_to_music_folder.c_str()) ; g_key_file_set_boolean(conf_file, "Config", "Is_Oxygen", settings.icon_set_oxygen) ; g_key_file_set_boolean(conf_file, "Config", "Repeat_all", settings.is_repeat_all) ; g_key_file_set_boolean(conf_file, "Config", "Shuffle", settings.is_shuffle) ; g_key_file_set_double(conf_file, "Config", "Volume", settings.volume) ; g_key_file_set_uint64(conf_file, "Config", "Buttons_space", settings.space_buttons) ; g_key_file_set_uint64(conf_file, "Config", "Display_Size", settings.display_size) ; g_key_file_set_uint64(conf_file, "Config", "Image_Resizing", settings.image_resized_size) ; g_key_file_set_string(conf_file, "Config", "Sized_Default_Image", settings.path_to_default_image.c_str()) ; // Write to configuration file g_key_file_save_to_file(conf_file, PATH_TO_CONF_FILE, &error); // Setting global variables. cover_image = settings.path_to_default_image ; current_folder = settings.path_to_music_folder ; if ( error != NULL ) { display_message_dialog("Error store configuration !", "Cannot store the configuration.") ; #ifdef DEBUG fprintf(stdout,"\n%s: Error store configuratiom settings.\n", prgname.c_str() ) ; fflush(stdout) ; #endif } else { // Success #ifdef DEBUG fprintf(stdout,"\n%s: Success store configuratiom settings.\n", prgname.c_str() ) ; #endif } } break ; case GTK_RESPONSE_CLOSE : // Do nothing. break ; } gtk_widget_destroy(configure_dialog) ; return ; }