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