static void panel_menu_button_mateconf_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, PanelMenuButton *button) { MateConfValue *value; const char *key; key = panel_mateconf_basename (mateconf_entry_get_key (entry)); value = entry->value; if (!strcmp (key, "menu_path")) { if (value && value->type == MATECONF_VALUE_STRING) panel_menu_button_set_menu_path (button, mateconf_value_get_string (value)); } else if (!strcmp (key, "custom_icon")) { if (value && value->type == MATECONF_VALUE_STRING) panel_menu_button_set_custom_icon (button, mateconf_value_get_string (value)); } else if (!strcmp (key, "tooltip")) { if (value && value->type == MATECONF_VALUE_STRING) panel_menu_button_set_tooltip (button, mateconf_value_get_string (value)); } else if (!strcmp (key, "use_menu_path")) { if (value && value->type == MATECONF_VALUE_BOOL) panel_menu_button_set_use_menu_path (button, mateconf_value_get_bool (value)); } else if (!strcmp (key, "use_custom_icon")) { if (value && value->type == MATECONF_VALUE_BOOL) panel_menu_button_set_use_custom_icon (button, mateconf_value_get_bool (value)); } }
static gboolean get_mateconf_value_with_default (PlumaDrawspacesPlugin *plugin, const gchar *key, gboolean def) { MateConfValue *value; gboolean ret; value = mateconf_client_get (plugin->priv->mateconf_client, key, NULL); if (value != NULL && value->type == MATECONF_VALUE_BOOL) { ret = mateconf_value_get_bool (value); } else { ret = def; } if (value != NULL) { mateconf_value_free (value); } return ret; }
static void all_workspaces_changed(MateConfClient* client, guint cnxn_id, MateConfEntry* entry, PagerData* pager) { gboolean value = TRUE; /* Default value */ if (entry->value != NULL && entry->value->type == MATECONF_VALUE_BOOL) { value = mateconf_value_get_bool(entry->value); } pager->display_all = value; pager_update(pager); if (pager->all_workspaces_radio) { if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pager->all_workspaces_radio)) != value) { if (value) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->all_workspaces_radio), TRUE); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->current_only_radio), TRUE); } } if (!g_object_get_data(G_OBJECT(pager->num_rows_spin), NEVER_SENSITIVE)) gtk_widget_set_sensitive(pager->num_rows_spin, value); } }
static void display_workspace_names_changed(MateConfClient* client, guint cnxn_id, MateConfEntry* entry, PagerData* pager) { gboolean value = FALSE; /* Default value */ if (entry->value != NULL && entry->value->type == MATECONF_VALUE_BOOL) { value = mateconf_value_get_bool(entry->value); } if (value) { pager->display_mode = MATEWNCK_PAGER_DISPLAY_NAME; } else { pager->display_mode = MATEWNCK_PAGER_DISPLAY_CONTENT; } pager_update(pager); if (pager->display_workspaces_toggle && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pager->display_workspaces_toggle)) != value) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->display_workspaces_toggle), value); } }
static void chk_separate_group_per_window_toggled (MateConfPropertyEditor * peditor, const gchar * key, const MateConfValue * value, GtkBuilder * dialog) { gtk_widget_set_sensitive (WID ("chk_new_windows_inherit_layout"), mateconf_value_get_bool (value)); }
static void auto_complete_history_changed (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, MCData *mc) { if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL) return; mc->preferences.auto_complete_history = mateconf_value_get_bool (entry->value); }
void mateconf_bookmarks_hook_up_menu (MateConfEditorWindow *window, GtkWidget *menu, GtkWidget *add_bookmark, GtkWidget *edit_bookmarks) { MateConfClient *client; guint notify_id; g_object_set_data (G_OBJECT (menu), "editor-window", window); client = mateconf_client_get_default (); /* Add a notify function */ mateconf_client_add_dir (client, "/apps/mateconf-editor/bookmarks", MATECONF_CLIENT_PRELOAD_ONELEVEL, NULL); notify_id = mateconf_client_notify_add (client, "/apps/mateconf-editor/bookmarks", mateconf_bookmarks_key_changed, menu, NULL, NULL); g_object_set_data_full (G_OBJECT (menu), "notify-id", GINT_TO_POINTER (notify_id), remove_notify_id); notify_id = mateconf_client_notify_add (client, "/desktop/mate/interface/menus_have_icons", mateconf_bookmarks_have_icons_notify, menu, NULL, NULL); g_object_set_data_full (G_OBJECT (menu), "notify-id-x", GINT_TO_POINTER (notify_id), remove_notify_id); mateconf_bookmarks_update_menu (menu); { gboolean have_icons; MateConfValue *value; GError *err; err = NULL; value = mateconf_client_get (client, "/desktop/mate/interface/menus_have_icons", &err); if (err != NULL || value == NULL || value->type != MATECONF_VALUE_BOOL) return; have_icons = mateconf_value_get_bool (value); mateconf_bookmarks_set_have_icons (menu, have_icons); mateconf_value_free (value); } if ( ! mateconf_client_key_is_writable (client, "/apps/mateconf-editor/bookmarks", NULL)) { gtk_widget_set_sensitive (add_bookmark, FALSE); gtk_widget_set_sensitive (edit_bookmarks, FALSE); } g_object_unref (client); }
/* MateConf notification handlers */ static void show_default_theme_changed (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, MCData *mc) { if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL) return; mc->preferences.show_default_theme = mateconf_value_get_bool (entry->value); mc_applet_draw (mc); /* FIXME: we shouldn't have to redraw the whole applet */ }
static void mateconf_bookmarks_have_icons_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer data) { GtkWidget *menu; gboolean have_icons; menu = GTK_WIDGET (data); if (entry->value->type != MATECONF_VALUE_BOOL) return; have_icons = mateconf_value_get_bool (entry->value); mateconf_bookmarks_set_have_icons (menu, have_icons); }
static void mate_panel_applet_locked_change_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, GtkWidget *applet) { MateConfValue *value; gboolean locked; gboolean applet_locked; AppletInfo *info; PanelWidget *panel_widget; g_assert (applet != NULL); info = (AppletInfo *) g_object_get_data (G_OBJECT (applet), "applet_info"); if (info == NULL) return; value = mateconf_entry_get_value (entry); if (value == NULL || value->type != MATECONF_VALUE_BOOL) return; locked = mateconf_value_get_bool (value); panel_widget = mate_panel_applet_get_panel_widget (info); applet_locked = panel_widget_get_applet_locked (panel_widget, info->widget); if ((locked && applet_locked) || !(locked || applet_locked)) return; mate_panel_applet_toggle_locked (info); if (info->type == PANEL_OBJECT_APPLET) mate_panel_applet_frame_sync_menu_state (MATE_PANEL_APPLET_FRAME (info->widget)); else mate_panel_applet_recreate_menu (info); }
static void mateconf_notify_cb (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer user_data) { DrWright *dr = user_data; GtkWidget *item; if (!strcmp (entry->key, MATECONF_PATH "/type_time")) { if (entry->value->type == MATECONF_VALUE_INT) { dr->type_time = 60 * mateconf_value_get_int (entry->value); dr->warn_time = MIN (dr->type_time / 10, 5*60); dr->state = STATE_START; } } else if (!strcmp (entry->key, MATECONF_PATH "/break_time")) { if (entry->value->type == MATECONF_VALUE_INT) { dr->break_time = 60 * mateconf_value_get_int (entry->value); dr->state = STATE_START; } } else if (!strcmp (entry->key, MATECONF_PATH "/enabled")) { if (entry->value->type == MATECONF_VALUE_BOOL) { dr->enabled = mateconf_value_get_bool (entry->value); dr->state = STATE_START; item = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop/TakeABreak"); gtk_widget_set_sensitive (item, dr->enabled); update_status (dr); } } maybe_change_state (dr); }
static void on_mateconf_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer user_data) { PlumaDrawspacesPlugin *plugin = PLUMA_DRAWSPACES_PLUGIN (user_data); gboolean value; if (strcmp (entry->key, MATECONF_KEY_DRAW_TABS) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_TAB; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_TAB; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_SPACES) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_SPACE; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_SPACE; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_NEWLINE) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_NEWLINE; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_NEWLINE; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_NBSP) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_NBSP; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_NBSP; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_LEADING) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_LEADING; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_LEADING; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_TEXT) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_TEXT; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_TEXT; } } else if (strcmp (entry->key, MATECONF_KEY_DRAW_TRAILING) == 0) { value = mateconf_value_get_bool (entry->value); if (value) { plugin->priv->flags |= GTK_SOURCE_DRAW_SPACES_TRAILING; } else { plugin->priv->flags &= ~GTK_SOURCE_DRAW_SPACES_TRAILING; } } draw_spaces (plugin); }
gchar* mateconf_value_to_string(const MateConfValue* value) { /* These strings shouldn't be translated; they're primarily intended for machines to read, not humans, though I do use them in some debug spew */ gchar* retval = NULL; switch (value->type) { case MATECONF_VALUE_INT: retval = g_strdup_printf("%d", mateconf_value_get_int(value)); break; case MATECONF_VALUE_FLOAT: retval = mateconf_double_to_string(mateconf_value_get_float(value)); break; case MATECONF_VALUE_STRING: retval = g_strdup(mateconf_value_get_string(value)); break; case MATECONF_VALUE_BOOL: retval = mateconf_value_get_bool(value) ? g_strdup("true") : g_strdup("false"); break; case MATECONF_VALUE_LIST: { GSList* list; list = mateconf_value_get_list(value); if (list == NULL) retval = g_strdup("[]"); else { gchar* buf = NULL; guint bufsize = 64; guint cur = 0; g_assert(list != NULL); buf = g_malloc(bufsize+3); /* my +3 superstition */ buf[0] = '['; ++cur; g_assert(cur < bufsize); while (list != NULL) { gchar* tmp; gchar* elem; guint len; tmp = mateconf_value_to_string((MateConfValue*)list->data); g_assert(tmp != NULL); elem = escape_string(tmp, ",]"); g_free(tmp); len = strlen(elem); if ((cur + len + 2) >= bufsize) /* +2 for '\0' and comma */ { bufsize = MAX(bufsize*2, bufsize+len+4); buf = g_realloc(buf, bufsize+3); } g_assert(cur < bufsize); strcpy(&buf[cur], elem); cur += len; g_assert(cur < bufsize); g_free(elem); buf[cur] = ','; ++cur; g_assert(cur < bufsize); list = g_slist_next(list); } g_assert(cur < bufsize); buf[cur-1] = ']'; /* overwrites last comma */ buf[cur] = '\0'; retval = buf; } } break; case MATECONF_VALUE_PAIR: { gchar* tmp; gchar* car; gchar* cdr; if (mateconf_value_get_car (value)) tmp = mateconf_value_to_string(mateconf_value_get_car(value)); else tmp = g_strdup ("nil"); car = escape_string(tmp, ",)"); g_free(tmp); if (mateconf_value_get_cdr (value)) tmp = mateconf_value_to_string(mateconf_value_get_cdr(value)); else tmp = g_strdup ("nil"); cdr = escape_string(tmp, ",)"); g_free(tmp); retval = g_strdup_printf("(%s,%s)", car, cdr); g_free(car); g_free(cdr); } break; /* These remaining shouldn't really be used outside of debug spew... */ case MATECONF_VALUE_INVALID: retval = g_strdup("Invalid"); break; case MATECONF_VALUE_SCHEMA: { const gchar* locale; const gchar* type; const gchar* list_type; const gchar* car_type; const gchar* cdr_type; locale = mateconf_schema_get_locale(mateconf_value_get_schema(value)); type = mateconf_value_type_to_string(mateconf_schema_get_type(mateconf_value_get_schema(value))); list_type = mateconf_value_type_to_string(mateconf_schema_get_list_type(mateconf_value_get_schema(value))); car_type = mateconf_value_type_to_string(mateconf_schema_get_car_type(mateconf_value_get_schema(value))); cdr_type = mateconf_value_type_to_string(mateconf_schema_get_cdr_type(mateconf_value_get_schema(value))); retval = g_strdup_printf("Schema (type: `%s' list_type: '%s' " "car_type: '%s' cdr_type: '%s' locale: `%s')", type, list_type, car_type, cdr_type, locale ? locale : "(null)"); } break; default: g_assert_not_reached(); break; } return retval; }
int mateconf_value_compare (const MateConfValue *value_a, const MateConfValue *value_b) { g_return_val_if_fail (value_a != NULL, 0); g_return_val_if_fail (value_b != NULL, 0); /* Impose arbitrary type ordering, just to keep the * sort invariants stable. */ if (value_a->type < value_b->type) return -1; else if (value_a->type > value_b->type) return 1; switch (value_a->type) { case MATECONF_VALUE_INT: if (mateconf_value_get_int (value_a) < mateconf_value_get_int (value_b)) return -1; else if (mateconf_value_get_int (value_a) > mateconf_value_get_int (value_b)) return 1; else return 0; case MATECONF_VALUE_FLOAT: if (mateconf_value_get_float (value_a) < mateconf_value_get_float (value_b)) return -1; else if (mateconf_value_get_float (value_a) > mateconf_value_get_float (value_b)) return 1; else return 0; case MATECONF_VALUE_STRING: return strcmp (mateconf_value_get_string (value_a), mateconf_value_get_string (value_b)); case MATECONF_VALUE_BOOL: if (mateconf_value_get_bool (value_a) == mateconf_value_get_bool (value_b)) return 0; /* make TRUE > FALSE to maintain sort invariants */ else if (mateconf_value_get_bool (value_a)) return 1; else return -1; case MATECONF_VALUE_LIST: { GSList *list_a; GSList *list_b; list_a = mateconf_value_get_list (value_a); list_b = mateconf_value_get_list (value_b); while (list_a != NULL && list_b != NULL) { int result; result = mateconf_value_compare (list_a->data, list_b->data); if (result != 0) return result; list_a = g_slist_next (list_a); list_b = g_slist_next (list_b); } if (list_a) return 1; /* list_a is longer so "greater" */ else if (list_b) return -1; else return 0; } case MATECONF_VALUE_PAIR: { MateConfValue *a_car, *b_car, *a_cdr, *b_cdr; int result; a_car = mateconf_value_get_car (value_a); b_car = mateconf_value_get_car (value_b); a_cdr = mateconf_value_get_cdr (value_a); b_cdr = mateconf_value_get_cdr (value_b); if (a_car == NULL && b_car != NULL) return -1; else if (a_car != NULL && b_car == NULL) return 1; else if (a_car != NULL && b_car != NULL) { result = mateconf_value_compare (a_car, b_car); if (result != 0) return result; } if (a_cdr == NULL && b_cdr != NULL) return -1; else if (a_cdr != NULL && b_cdr == NULL) return 1; else if (a_cdr != NULL && b_cdr != NULL) { result = mateconf_value_compare (a_cdr, b_cdr); if (result != 0) return result; } return 0; } case MATECONF_VALUE_INVALID: return 0; case MATECONF_VALUE_SCHEMA: { const char *locale_a, *locale_b; MateConfValueType type_a, type_b; MateConfValueType list_type_a, list_type_b; MateConfValueType car_type_a, car_type_b; MateConfValueType cdr_type_a, cdr_type_b; const char *short_desc_a, *short_desc_b; const char *long_desc_a, *long_desc_b; int result; type_a = mateconf_schema_get_type (mateconf_value_get_schema (value_a)); type_b = mateconf_schema_get_type (mateconf_value_get_schema (value_b)); if (type_a < type_b) return -1; else if (type_a > type_b) return 1; short_desc_a = mateconf_schema_get_short_desc (mateconf_value_get_schema (value_a)); short_desc_b = mateconf_schema_get_short_desc (mateconf_value_get_schema (value_b)); result = null_safe_strcmp (short_desc_a, short_desc_b); if (result != 0) return result; long_desc_a = mateconf_schema_get_long_desc (mateconf_value_get_schema (value_a)); long_desc_b = mateconf_schema_get_long_desc (mateconf_value_get_schema (value_b)); result = null_safe_strcmp (long_desc_a, long_desc_b); if (result != 0) return result; locale_a = mateconf_schema_get_locale (mateconf_value_get_schema (value_a)); locale_b = mateconf_schema_get_locale (mateconf_value_get_schema (value_b)); result = null_safe_strcmp (locale_a, locale_b); if (result != 0) return result; if (type_a == MATECONF_VALUE_LIST) { list_type_a = mateconf_schema_get_list_type (mateconf_value_get_schema (value_a)); list_type_b = mateconf_schema_get_list_type (mateconf_value_get_schema (value_b)); if (list_type_a < list_type_b) return -1; else if (list_type_a > list_type_b) return 1; } if (type_a == MATECONF_VALUE_PAIR) { car_type_a = mateconf_schema_get_car_type (mateconf_value_get_schema (value_a)); car_type_b = mateconf_schema_get_car_type (mateconf_value_get_schema (value_b)); if (car_type_a < car_type_b) return -1; else if (car_type_a > car_type_b) return 1; cdr_type_a = mateconf_schema_get_cdr_type (mateconf_value_get_schema (value_a)); cdr_type_b = mateconf_schema_get_cdr_type (mateconf_value_get_schema (value_b)); if (cdr_type_a < cdr_type_b) return -1; else if (cdr_type_a > cdr_type_b) return 1; } return 0; } } g_assert_not_reached (); return 0; }
static gboolean handle_file (const gchar *filename) { GKeyFile *keyfile; MateConfClient *client; MateConfValue *value; gint i, j; gchar *mateconf_key; gchar **groups; gchar **keys; GVariantBuilder *builder; GVariant *v; const gchar *s; gchar *str; gint ii; GSList *list, *l; GSettings *settings; GError *error; keyfile = g_key_file_new (); error = NULL; if (!g_key_file_load_from_file (keyfile, filename, 0, &error)) { g_printerr ("%s\n", error->message); g_error_free (error); g_key_file_free (keyfile); return FALSE; } client = mateconf_client_get_default (); groups = g_key_file_get_groups (keyfile, NULL); for (i = 0; groups[i]; i++) { gchar **schema_path; schema_path = g_strsplit (groups[i], ":", 2); if (verbose) { g_print ("collecting settings for schema '%s'\n", schema_path[0]); if (schema_path[1]) g_print ("for storage at '%s'\n", schema_path[1]); } if (schema_path[1] != NULL) settings = g_settings_new_with_path (schema_path[0], schema_path[1]); else settings = g_settings_new (schema_path[0]); g_settings_delay (settings); error = NULL; if ((keys = g_key_file_get_keys (keyfile, groups[i], NULL, &error)) == NULL) { g_printerr ("%s", error->message); g_error_free (error); continue; } for (j = 0; keys[j]; j++) { if (strchr (keys[j], '/') != 0) { g_printerr ("Key '%s' contains a '/'\n", keys[j]); continue; } error = NULL; if ((mateconf_key = g_key_file_get_string (keyfile, groups[i], keys[j], &error)) == NULL) { g_printerr ("%s", error->message); g_error_free (error); continue; } error = NULL; if ((value = mateconf_client_get_without_default (client, mateconf_key, &error)) == NULL) { if (error) { g_printerr ("Failed to get MateConf key '%s': %s\n", mateconf_key, error->message); g_error_free (error); } else { if (verbose) g_print ("Skipping MateConf key '%s', no user value\n", mateconf_key); } g_free (mateconf_key); continue; } switch (value->type) { case MATECONF_VALUE_STRING: if (dry_run) g_print ("set key '%s' to string '%s'\n", keys[j], mateconf_value_get_string (value)); else g_settings_set (settings, keys[j], "s", mateconf_value_get_string (value)); break; case MATECONF_VALUE_INT: if (dry_run) g_print ("set key '%s' to integer '%d'\n", keys[j], mateconf_value_get_int (value)); else g_settings_set (settings, keys[j], "i", mateconf_value_get_int (value)); break; case MATECONF_VALUE_BOOL: if (dry_run) g_print ("set key '%s' to boolean '%d'\n", keys[j], mateconf_value_get_bool (value)); else g_settings_set (settings, keys[j], "b", mateconf_value_get_bool (value)); break; case MATECONF_VALUE_FLOAT: if (dry_run) g_print ("set key '%s' to double '%g'\n", keys[j], mateconf_value_get_float (value)); else g_settings_set (settings, keys[j], "d", mateconf_value_get_float (value)); break; case MATECONF_VALUE_LIST: switch (mateconf_value_get_list_type (value)) { case MATECONF_VALUE_STRING: builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY); list = mateconf_value_get_list (value); if (list != NULL) { for (l = list; l; l = l->next) { MateConfValue *lv = l->data; s = mateconf_value_get_string (lv); g_variant_builder_add (builder, "s", s); } v = g_variant_new ("as", builder); } else v = g_variant_new_array (G_VARIANT_TYPE_STRING, NULL, 0); g_variant_ref_sink (v); if (dry_run) { str = g_variant_print (v, FALSE); g_print ("set key '%s' to a list of strings: %s\n", keys[j], str); g_free (str); } else g_settings_set_value (settings, keys[j], v); g_variant_unref (v); g_variant_builder_unref (builder); break; case MATECONF_VALUE_INT: builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY); list = mateconf_value_get_list (value); if (list != NULL) { for (l = list; l; l = l->next) { MateConfValue *lv = l->data; ii = mateconf_value_get_int (lv); g_variant_builder_add (builder, "i", ii); } v = g_variant_new ("ai", builder); } else v = g_variant_new_array (G_VARIANT_TYPE_INT32, NULL, 0); g_variant_ref_sink (v); if (dry_run) { str = g_variant_print (v, FALSE); g_print ("set key '%s' to a list of integers: %s\n", keys[j], str); g_free (str); } else g_settings_set_value (settings, keys[j], v); g_variant_unref (v); g_variant_builder_unref (builder); break; default: g_printerr ("Keys of type 'list of %s' not handled yet\n", mateconf_value_type_to_string (mateconf_value_get_list_type (value))); break; } break; default: g_printerr ("Keys of type %s not handled yet\n", mateconf_value_type_to_string (value->type)); break; } mateconf_value_free (value); g_free (mateconf_key); } g_strfreev (keys); if (!dry_run) g_settings_apply (settings); g_object_unref (settings); g_strfreev (schema_path); } g_strfreev (groups); g_object_unref (client); return TRUE; }
static void web_mateconf_changed_cb(MateConfPropertyEditor* peditor, gchar* key, MateConfValue* value, MateDACapplet* capplet) { MateConfChangeSet *cs; GError *error = NULL; GList *list_entry; /* This function is used to update HTTPS,ABOUT and UNKNOWN handlers, which * should also use the same value as HTTP */ if (strcmp (key, DEFAULT_APPS_KEY_HTTP_EXEC) == 0) { gchar *short_browser, *pos; const gchar *value_str = mateconf_value_get_string (value); cs = mateconf_change_set_new (); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_HTTPS_EXEC, value); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_UNKNOWN_EXEC, value); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_ABOUT_EXEC, value); pos = strstr (value_str, " "); if (pos == NULL) short_browser = g_strdup (value_str); else short_browser = g_strndup (value_str, pos - value_str); mateconf_change_set_set_string (cs, DEFAULT_APPS_KEY_BROWSER_EXEC, short_browser); g_free (short_browser); list_entry = g_list_find_custom (capplet->web_browsers, value_str, (GCompareFunc) web_item_comp); if (list_entry) { MateDAWebItem *item = (MateDAWebItem *) list_entry->data; mateconf_change_set_set_bool (cs, DEFAULT_APPS_KEY_BROWSER_NREMOTE, item->netscape_remote); } mateconf_client_commit_change_set (capplet->mateconf, cs, TRUE, &error); if (error != NULL) { g_warning (_("Error saving configuration: %s"), error->message); g_error_free (error); error = NULL; } mateconf_change_set_unref (cs); } else if (strcmp (key, DEFAULT_APPS_KEY_HTTP_NEEDS_TERM) == 0) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (capplet->web_browser_terminal_checkbutton), mateconf_value_get_bool (value)); cs = mateconf_change_set_new (); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_HTTPS_NEEDS_TERM, value); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_UNKNOWN_NEEDS_TERM, value); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_ABOUT_NEEDS_TERM, value); mateconf_change_set_set (cs, DEFAULT_APPS_KEY_BROWSER_NEEDS_TERM, value); mateconf_client_commit_change_set (capplet->mateconf, cs, TRUE, &error); if (error != NULL) { g_warning (_("Error saving configuration: %s"), error->message); g_error_free (error); error = NULL; } mateconf_change_set_unref (cs); } }