void
viewer_save_preferences (Viewer *viewer, const char *fname)
{
GKeyFile *preferences = g_key_file_new ();
dbg ("saving viewer settings...\n");
for (int ridx = 0; ridx < viewer->renderers->len; ridx++) {
Renderer *renderer = g_ptr_array_index (viewer->renderers, ridx);
g_key_file_set_boolean (preferences, "__libviewer_enabled_renderers",
renderer->name, renderer->enabled);
if (renderer->widget) {
g_key_file_set_boolean (preferences, "__libviewer_show_renderers",
renderer->name, renderer->expanded);
}
}
FILE *fp = fopen (fname, "w");
if (!fp) {
perror ("error saving preferences");
return;
}
g_signal_emit (G_OBJECT (viewer), viewer_signals[SAVE_PREFERENCES_SIGNAL],
0, preferences);
gsize len = 0;
char *data = g_key_file_to_data (preferences, &len, NULL);
fwrite (data, len, 1, fp);
free (data);
fclose (fp);
g_key_file_free (preferences);
}
static gboolean ril_radio_settings_get_config(struct ril_radio_settings *rsd)
{
gboolean needsconfig = FALSE;
gboolean value = FALSE;
/* Hmm... One file shared by all modems... Why?? */
GKeyFile *keyfile = storage_open(NULL, RIL_STORE);
char **alreadyset = g_key_file_get_groups(keyfile, NULL);
if (alreadyset[0])
value = g_key_file_get_boolean(
keyfile, alreadyset[0], LTE_FLAG, NULL);
else if (rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO)
value = TRUE;
if (!value && rsd->ratmode == PREF_NET_TYPE_LTE_GSM_WCDMA) {
g_key_file_set_boolean(keyfile,
LTE_FLAG, LTE_FLAG, TRUE);
needsconfig = TRUE;
} else if (value && rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) {
g_key_file_set_boolean(keyfile,
LTE_FLAG, LTE_FLAG, FALSE);
needsconfig = TRUE;
}
g_strfreev(alreadyset);
storage_close(NULL, RIL_STORE, keyfile, TRUE);
DBG("needsconfig %d, rat mode %d", needsconfig, rsd->ratmode);
return needsconfig;
}
gchar *
gst_validate_media_info_to_string (GstValidateMediaInfo * mi, gsize * length)
{
GKeyFile *kf = g_key_file_new ();
gchar *data = NULL;
gchar *str;
/* file info */
g_key_file_set_string (kf, "file-info", "uri", mi->uri);
g_key_file_set_uint64 (kf, "file-info", "file-size", mi->file_size);
/* media info */
g_key_file_set_uint64 (kf, "media-info", "file-duration", mi->duration);
g_key_file_set_boolean (kf, "media-info", "seekable", mi->seekable);
g_key_file_set_boolean (kf, "media-info", "is-image", mi->is_image);
if (mi->stream_info && mi->stream_info->caps) {
str = gst_caps_to_string (mi->stream_info->caps);
g_key_file_set_string (kf, "media-info", "caps", str);
g_free (str);
}
/* playback tests */
g_key_file_set_string (kf, "playback-tests", "playback-error",
mi->playback_error ? mi->playback_error : "");
g_key_file_set_string (kf, "playback-tests", "reverse-playback-error",
mi->reverse_playback_error ? mi->reverse_playback_error : "");
g_key_file_set_string (kf, "playback-tests", "track-switch-error",
mi->track_switch_error ? mi->track_switch_error : "");
data = g_key_file_to_data (kf, length, NULL);
g_key_file_free (kf);
return data;
}
static void
on_configure_response(G_GNUC_UNUSED GtkDialog *dialog, gint response, G_GNUC_UNUSED gpointer user_data)
{
if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY)
{
GKeyFile *config = g_key_file_new();
gchar *config_dir = g_path_get_dirname(config_file);
gboolean configure_toogle_status;
g_free(mailer);
mailer = g_strdup(gtk_entry_get_text(GTK_ENTRY(pref_widgets.entry)));
configure_toogle_status =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.checkbox_icon_to_toolbar));
if (icon_in_toolbar ^ configure_toogle_status)
/* Only do anything if a status change is needed */
{
if (icon_in_toolbar == TRUE)
{
/* We need to remove the toolbar icon */
cleanup_icon();
}
else
{
/* We need to show the toolbar icon */
show_icon();
}
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_widgets.checkbox_use_addressdialog)) == TRUE)
use_address_dialog = TRUE;
else
use_address_dialog = FALSE;
g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
g_key_file_set_string(config, "tools", "mailer", mailer);
g_key_file_set_boolean(config, "tools", "address_usage", use_address_dialog);
g_key_file_set_boolean(config, "icon", "show_icon", icon_in_toolbar);
if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Plugin configuration directory could not be created."));
}
else
{
/* write config to file */
gchar *data = g_key_file_to_data(config, NULL, NULL);
utils_write_file(config_file, data);
g_free(data);
}
g_key_file_free(config);
g_free(config_dir);
}
}
static gboolean ril_get_net_config(struct radio_data *rsd)
{
GKeyFile *keyfile;
GError *err = NULL;
char *path = RIL_CONFIG;
char **alreadyset = NULL;
gboolean needsconfig = FALSE;
gboolean value = FALSE;
rsd->ratmode = PREF_NET_TYPE_GSM_WCDMA_AUTO;
/*
* First we need to check should the LTE be on
* or not
*/
keyfile = g_key_file_new();
g_key_file_set_list_separator(keyfile, ',');
if (g_key_file_load_from_file(keyfile, path, 0, &err)) {
if (g_key_file_has_group(keyfile, LTE_FLAG))
rsd->ratmode = PREF_NET_TYPE_LTE_GSM_WCDMA;
} else {
g_error_free(err);
needsconfig = TRUE;
}
g_key_file_free(keyfile);
/* Then we need to check if it already set */
keyfile = storage_open(NULL, RIL_STORE);
alreadyset = g_key_file_get_groups(keyfile, NULL);
if (alreadyset[0])
value = g_key_file_get_boolean(
keyfile, alreadyset[0], LTE_FLAG, NULL);
else if (rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO)
value = TRUE;
if (!value && rsd->ratmode == PREF_NET_TYPE_LTE_GSM_WCDMA) {
g_key_file_set_boolean(keyfile,
LTE_FLAG, LTE_FLAG, TRUE);
needsconfig = TRUE;
} else if (value && rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) {
g_key_file_set_boolean(keyfile,
LTE_FLAG, LTE_FLAG, FALSE);
needsconfig = TRUE;
}
g_strfreev(alreadyset);
storage_close(NULL, RIL_STORE, keyfile, TRUE);
return needsconfig;
}
// 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);
}
static void keyfile_add_entry_info(GKeyFile *keyfile,
const gchar *key,
const gchar *value,
const gchar *label,
gboolean is_secret,
gboolean should_ask) {
g_key_file_set_string(keyfile, key, "Value", value);
g_key_file_set_string(keyfile, key, "Label", label);
g_key_file_set_boolean(keyfile, key, "IsSecret", is_secret);
g_key_file_set_boolean(keyfile, key, "ShouldAsk", should_ask);
}
/**************************************************
* save_common
*
* save settings to a key file
**************************************************/
bool
CsvImportSettings::save_common (void)
{
auto keyfile = gnc_state_get_current ();
auto group = csv_group_prefix + m_settings_type + " - " + m_name;
// Start Saving the Common settings
g_key_file_set_string (keyfile, group.c_str(), CSV_NAME, m_name.c_str());
g_key_file_set_integer (keyfile, group.c_str(), CSV_SKIP_START, m_skip_start_lines);
g_key_file_set_integer (keyfile, group.c_str(), CSV_SKIP_END, m_skip_end_lines);
g_key_file_set_boolean (keyfile, group.c_str(), CSV_SKIP_ALT, m_skip_alt_lines);
g_key_file_set_boolean (keyfile, group.c_str(), CSV_FORMAT,
(m_file_format == GncImpFileFormat::CSV) ? true : false);
g_key_file_set_string (keyfile, group.c_str(), CSV_SEP, m_separators.c_str());
g_key_file_set_integer (keyfile, group.c_str(), CSV_DATE, m_date_format);
std::ostringstream cmt_ss;
cmt_ss << "Supported date formats: ";
int fmt_num = 0;
std::for_each (GncDate::c_formats.cbegin(), GncDate::c_formats.cend(),
[&cmt_ss, &fmt_num](const GncDateFormat& fmt)
{ cmt_ss << fmt_num++ << ": '" << fmt.m_fmt << "', "; });
auto cmt = cmt_ss.str().substr(0, static_cast<long>(cmt_ss.tellp()) - 2);
g_key_file_set_comment (keyfile, group.c_str(), CSV_DATE, cmt.c_str(), nullptr);
g_key_file_set_integer (keyfile, group.c_str(), CSV_CURRENCY, m_currency_format);
g_key_file_set_string (keyfile, group.c_str(), CSV_ENCODING, m_encoding.c_str());
if (!m_column_widths.empty())
g_key_file_set_integer_list (keyfile, group.c_str(), CSV_COL_WIDTHS,
(gint*)(m_column_widths.data()), m_column_widths.size());
// Do a test read of encoding
GError *key_error = nullptr;
bool error = false;
auto enc_val = g_key_file_get_string (keyfile, group.c_str(), CSV_ENCODING, &key_error);
auto enc_str = std::string{enc_val};
if (enc_val)
g_free (enc_val);
if ((key_error) || (enc_str != m_encoding.c_str()))
{
if (key_error)
{
g_warning ("Error reading group %s key %s: %s", group.c_str(), CSV_ENCODING, key_error->message);
g_error_free (key_error);
}
else
g_warning ("Error comparing group %s key %s: '%s' and '%s'", group.c_str(), CSV_ENCODING, enc_str.c_str(), group.c_str());
error = true;
}
return error;
}
void cd_mail_create_imap_params( GKeyFile *pKeyFile, gchar *pMailAccountName )
{
g_key_file_set_string (pKeyFile, pMailAccountName, "type", "imap");
g_key_file_set_comment (pKeyFile, pMailAccountName, "type", ">0 ", NULL);
g_key_file_set_string (pKeyFile, pMailAccountName, "host", "imap.myhost.org");
g_key_file_set_comment (pKeyFile, pMailAccountName, "host", "s0 server address:", NULL);
g_key_file_set_string (pKeyFile, pMailAccountName, "username", "myLogin");
g_key_file_set_comment (pKeyFile, pMailAccountName, "username", "s0 username:"******"password", "");
g_key_file_set_comment (pKeyFile, pMailAccountName, "password", "p0 password:"******"port", 0);
g_key_file_set_comment (pKeyFile, pMailAccountName, "port", "i0 port:\n{Enter 0 to use the default port. Default ports are 143 for IMAP4 and 993 for IMAP4 over SSL.}", NULL);
g_key_file_set_boolean (pKeyFile, pMailAccountName, "use secure connection", FALSE);
g_key_file_set_comment (pKeyFile, pMailAccountName, "use secure connection", "b0 use secure connection (SSL)", NULL);
g_key_file_set_string (pKeyFile, pMailAccountName, "server_directory", "Inbox");
g_key_file_set_comment (pKeyFile, pMailAccountName, "server_directory", "s0 directory on server:", NULL);
g_key_file_set_integer (pKeyFile, pMailAccountName, "timeout mn", 10);
g_key_file_set_comment (pKeyFile, pMailAccountName, "timeout mn", "I0[1;30] timeout:\n{In minutes.}", NULL);
}
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;
}
}
static void mame_gui_prefs_save_bool (MameGuiPrefs *pr, GParamSpec *param, gpointer user_data)
{
gchar *key;
gboolean value;
g_return_if_fail (pr->priv->prefs_ini_file != NULL);
g_return_if_fail (pr->priv->filename != NULL);
key = g_strdup (g_param_spec_get_name (param));
g_return_if_fail (key != NULL);
g_object_get (pr, key, &value, NULL);
GMAMEUI_DEBUG ("Saving %s - setting boolean value %s with value %d",
pr->priv->filename, key, value);
/* Set the value and save the file */
g_key_file_set_boolean (pr->priv->prefs_ini_file, "Preferences", key, value);
g_key_file_save_to_file (pr->priv->prefs_ini_file, pr->priv->filename);
g_free (key);
/* FIXME TODO Preferences is a temporary group name - need to find a way to
add more groups */
}
/**
* Store a boolean configuration value.
* @param param The parameter to store.
* @param value The value of the parameter.
*
* This function stores a boolean configuration value in the configuration
* table.
*/
void sat_cfg_set_bool(sat_cfg_bool_e param, gboolean value)
{
if (param < SAT_CFG_BOOL_NUM)
{
if (config == NULL)
{
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Module not initialised\n"),
__func__);
}
else
{
g_key_file_set_boolean (config,
sat_cfg_bool[param].group,
sat_cfg_bool[param].key,
value);
}
}
else
{
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Unknown BOOL param index (%d)\n"),
__func__, param);
}
}
static void save_settings(void)
{
GKeyFile *config = g_key_file_new();
gchar *data;
gchar *config_dir = g_path_get_dirname(config_file);
g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
g_key_file_set_integer(config, "geniuspaste", "website", website_selected);
g_key_file_set_boolean(config, "geniuspaste", "open_browser", check_button_is_checked);
g_key_file_set_string(config, "geniuspaste", "author_name", author_name);
if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Plugin configuration directory could not be created."));
}
else
{
data = g_key_file_to_data(config, NULL, NULL);
utils_write_file(config_file, data);
g_free(data);
}
g_free(config_dir);
g_key_file_free(config);
}
void appconfig_write_file() {
GKeyFile *keyfile = g_key_file_new();
g_key_file_load_from_file(keyfile, config_filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
ConfigOption *option = config_options;
for (option=config_options; option->key; option++) {
switch (option->type) {
case INTEGER:
g_key_file_set_integer(keyfile, "wavbreaker", option->key,
config_option_get_integer(option));
break;
case BOOLEAN:
g_key_file_set_boolean(keyfile, "wavbreaker", option->key,
config_option_get_integer(option));
break;
case STRING:
g_key_file_set_string(keyfile, "wavbreaker", option->key,
config_option_get_string(option));
break;
default:
g_warning("Invalid option type: %d\n", option->type);
break;
}
}
if (!g_key_file_save_to_file(keyfile, config_filename, NULL)) {
g_warning("Could not save settings");
}
g_key_file_free(keyfile);
}
static void save_window_show_toolbar(GKeyFile *keyfile)
{
const bool show_toolbar = gtk_check_menu_item_get_active(
GTK_CHECK_MENU_ITEM(gui.menuitem_treeview_show_toolbar));
g_key_file_set_boolean(keyfile, "window", "show-toolbar", show_toolbar);
}
void rclib_settings_set_boolean(const gchar *group_name,
const gchar *key, gboolean value)
{
settings_dirty = TRUE;
if(settings_keyfile==NULL) return;
g_key_file_set_boolean(settings_keyfile, group_name, key, value);
}
void
propono_cache_prefs_set_boolean (const gchar *group, const gchar *key, gboolean value)
{
g_return_if_fail (keyfile != NULL);
g_key_file_set_boolean (keyfile, group, key, value);
}
static void matenu_settings_save_boolean (MatenuSettings* self, const char* key, gboolean value) {
GError * _inner_error_;
g_return_if_fail (self != NULL);
g_return_if_fail (key != NULL);
_inner_error_ = NULL;
{
if (!matenu_settings_is_tristate (value)) {
g_key_file_set_boolean (self->keyfile, "GlobalMenu:Client", key, value);
} else {
g_key_file_remove_key (self->keyfile, "GlobalMenu:Client", key, &_inner_error_);
if (_inner_error_ != NULL) {
goto __catch3_g_error;
}
}
}
goto __finally3;
__catch3_g_error:
{
g_clear_error (&_inner_error_);
_inner_error_ = NULL;
{
}
}
__finally3:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
void
libbalsa_conf_set_bool_(const char *path, gboolean value, gboolean priv)
{
g_key_file_set_boolean(LBC_KEY_FILE(priv), lbc_groups->data, path,
value);
LBC_CHANGED(priv);
}
void
egg_desktop_file_set_boolean (EggDesktopFile * desktop_file, const char *key,
gboolean value)
{
return g_key_file_set_boolean (desktop_file->key_file,
EGG_DESKTOP_FILE_GROUP, key, value);
}
static void save_settings(void)
{
GKeyFile *config = g_key_file_new();
gchar *data;
gchar *config_dir = g_path_get_dirname(config_file);
g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
g_key_file_set_boolean(config, "geanyprj", "display_sidebar", display_sidebar);
if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Plugin configuration directory could not be created."));
}
else
{
/* write config to file */
data = g_key_file_to_data(config, NULL, NULL);
utils_write_file(config_file, data);
g_free(data);
}
g_free(config_dir);
g_key_file_free(config);
}
void PluginInfoCache::updatePluginInfo(const String& pluginPath, const PluginModuleInfo& plugin)
{
time_t lastModified;
if (!WebCore::getFileModificationTime(pluginPath, lastModified))
return;
CString pluginGroup = pluginPath.utf8();
g_key_file_set_uint64(m_cacheFile.get(), pluginGroup.data(), "mtime", static_cast<guint64>(lastModified));
g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "name", plugin.info.name.utf8().data());
g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "description", plugin.info.desc.utf8().data());
#if PLUGIN_ARCHITECTURE(X11)
String mimeDescription = NetscapePluginModule::buildMIMEDescription(plugin.info.mimes);
g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "mime-description", mimeDescription.utf8().data());
#endif
g_key_file_set_boolean(m_cacheFile.get(), pluginGroup.data(), "requires-gtk2", plugin.requiresGtk2);
if (m_cachePath && !m_readOnlyMode) {
// Save the cache file in an idle to make sure it happens in the main thread and
// it's done only once when this is called multiple times in a very short time.
std::lock_guard<std::mutex> lock(m_mutex);
if (m_saveToFileIdle.isScheduled())
return;
m_saveToFileIdle.schedule("[WebKit] PluginInfoCache::saveToFile", std::bind(&PluginInfoCache::saveToFile, this), G_PRIORITY_DEFAULT_IDLE);
}
}
static int device_save(struct connman_device *device)
{
const char *ident = __connman_profile_active_ident();
GKeyFile *keyfile;
gchar *identifier;
DBG("device %p", device);
keyfile = __connman_storage_open_profile(ident);
if (keyfile == NULL)
return 0;
identifier = g_strdup_printf("device_%s", device->name);
if (identifier == NULL)
goto done;
g_key_file_set_boolean(keyfile, identifier,
"Powered", device->powered_persistent);
done:
g_free(identifier);
__connman_storage_close_profile(ident, keyfile, TRUE);
return 0;
}
void test_setboolean()
{
GKeyFile *keyfile;
gboolean *value;
gsize n = 2;
gboolean list[2] = {TRUE,FALSE};
const gchar *data =
"[1]\n"
"key1=true\n"
"key2=false\n";
keyfile = load_data (data, 0);
check_boolean_value (keyfile, "1", "key1", TRUE);
g_key_file_set_boolean(keyfile,"1","key1",FALSE);
check_boolean_value (keyfile, "1", "key1", FALSE);
g_key_file_set_boolean_list(keyfile,"1","key1",list,2);
value = g_key_file_get_boolean_list(keyfile, "1", "key1",&n, NULL);
g_assert(value[0] == TRUE);
g_assert(value[1] == FALSE);
}
static void save_state(struct connman_technology *technology)
{
GKeyFile *keyfile;
gchar *identifier;
DBG("technology %p", technology);
keyfile = __connman_storage_load_global();
if (keyfile == NULL)
keyfile = g_key_file_new();
identifier = g_strdup_printf("%s", get_name(technology->type));
if (identifier == NULL)
goto done;
g_key_file_set_boolean(keyfile, identifier, "Enable",
technology->enable_persistent);
done:
g_free(identifier);
__connman_storage_save_global(keyfile);
g_key_file_free(keyfile);
return;
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS,
NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.4.7 otr.warn to enc.warn
err = NULL;
gboolean otr_warn = g_key_file_get_boolean(prefs, PREF_GROUP_UI, "otr.warn", &err);
if (err == NULL) {
g_key_file_set_boolean(prefs, PREF_GROUP_UI, _get_key(PREF_ENC_WARN), otr_warn);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "otr.warn", NULL);
} else {
g_error_free(err);
}
// migrate pre 0.4.7 time settings format
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "");
}
}
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time.statusbar", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time.statusbar", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "");
}
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
}
static void _dentry_hidden_toggled(GtkToggleButton *togglebutton,
FmFilePropertiesDEntryData *data)
{
/* g_debug("no display toggled"); */
g_key_file_set_boolean(data->kf, GRP_NAME, "Hidden",
gtk_toggle_button_get_active(togglebutton));
data->changed = TRUE;
}
static void
save_settings (GrubChooseDefaultWindow *win)
{
GrubChooseDefaultWindowPrivate *priv = GET_PRIVATE (win);
GError * error = NULL;
gboolean r;
gchar * data;
gchar * dir;
gsize len;
DBG ("Saving settings...");
DBG ("Saving reboot as %d", priv->reboot);
DBG ("Saving once as %d", priv->once);
g_key_file_set_boolean (priv->config, MAIN_GROUP, "reboot", priv->reboot);
g_key_file_set_boolean (priv->config, MAIN_GROUP, "once", priv->once);
/*
* Don't save this, it's a user setting
g_object_get (priv->box, "gchd", &gchd, NULL);
g_key_file_set_string (priv->config, MAIN_GROUP, "grub_dir", gchd_get_grub_dir (gchd));
*/
data = g_key_file_to_data (priv->config, &len, &error);
if (!data)
{
grub_choose_default_error (GTK_WIDGET (win), error);
g_error_free (error);
return;
}
dir = g_path_get_dirname (priv->config_fn);
if (!g_file_test (priv->config_fn, G_FILE_TEST_EXISTS))
g_mkdir (dir, 0770);
g_free (dir);
r = g_file_set_contents (priv->config_fn, data, len, &error);
if (!r)
{
grub_choose_default_error (GTK_WIDGET (win), error);
g_error_free (error);
return;
}
}
void
prefs_set_boolean(preference_t pref, gboolean value)
{
const char *group = _get_group(pref);
const char *key = _get_key(pref);
g_key_file_set_boolean(prefs, group, key, value);
_save_prefs();
}
void
notmuch_config_set_maildir_synchronize_flags (notmuch_config_t *config,
notmuch_bool_t synchronize_flags)
{
g_key_file_set_boolean (config->key_file,
"maildir", "synchronize_flags", synchronize_flags);
config->maildir_synchronize_flags = synchronize_flags;
}
