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 GSList * mc_load_macros (MCData *mc) { MateConfValue *macro_patterns; MateConfValue *macro_commands; GSList *macros_list = NULL; MateConfClient *client; client = mateconf_client_get_default (); macro_patterns = mateconf_client_get (client, "/apps/mini-commander/macro_patterns", NULL); macro_commands = mateconf_client_get (client, "/apps/mini-commander/macro_commands", NULL); if (macro_patterns && macro_commands) { GSList *patterns; GSList *commands; patterns = mateconf_value_get_list (macro_patterns); commands = mateconf_value_get_list (macro_commands); for (; patterns && commands; patterns = patterns->next, commands = commands->next) { MateConfValue *v1 = patterns->data; MateConfValue *v2 = commands->data; MCMacro *macro; const char *pattern, *command; pattern = mateconf_value_get_string (v1); command = mateconf_value_get_string (v2); if (!(macro = mc_macro_new (pattern, command))) continue; macros_list = g_slist_prepend (macros_list, macro); } } else { int i; for (i = 0; i < G_N_ELEMENTS (mc_default_macros); i++) macros_list = g_slist_prepend (macros_list, mc_macro_new (mc_default_macros [i].pattern, mc_default_macros [i].command)); } macros_list = g_slist_reverse (macros_list); if (macro_commands) mateconf_value_free (macro_commands); if (macro_patterns) mateconf_value_free (macro_patterns); return macros_list; }
/* Notification callback for our label widgets that * monitor the current value of a mateconf key. i.e. * we are conceptually "configuring" the label widgets */ static void configurable_widget_config_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer user_data) { GtkWidget *label = user_data; g_return_if_fail (GTK_IS_LABEL (label)); /* Note that value can be NULL (unset) or it can have * the wrong type! Need to check that to survive * mateconftool --break-key */ if (mateconf_entry_get_value (entry) == NULL) { gtk_label_set_text (GTK_LABEL (label), ""); } else if (mateconf_entry_get_value (entry)->type == MATECONF_VALUE_STRING) { gtk_label_set_text (GTK_LABEL (label), mateconf_value_get_string (mateconf_entry_get_value (entry))); } else { /* A real app would probably fall back to a reasonable default * in this case, instead of putting funky stuff in the GUI. */ gtk_label_set_text (GTK_LABEL (label), "!type error!"); } }
static void set_model_text (GtkWidget * picker, MateConfValue * value) { XklConfigItem *ci = xkl_config_item_new (); const char *model = NULL; if (value != NULL && value->type == MATECONF_VALUE_STRING) { model = mateconf_value_get_string (value); if (model != NULL && model[0] == '\0') model = NULL; } if (model == NULL) { model = initial_config.model; if (model == NULL) model = ""; } g_snprintf (ci->name, sizeof (ci->name), "%s", model); if (xkl_config_registry_find_model (config_registry, ci)) { char *d; d = xci_desc_to_utf8 (ci); gtk_button_set_label (GTK_BUTTON (picker), d); g_free (d); } else { gtk_button_set_label (GTK_BUTTON (picker), _("Unknown")); } g_object_unref (G_OBJECT (ci)); }
static MateConfValue* combo_conv_to_widget (MateConfPropertyEditor *peditor, const MateConfValue *value) { MateConfValue *ret; GList *entry, *handlers; const gchar *command; gint index; g_object_get (G_OBJECT (peditor), "data", &handlers, NULL); command = mateconf_value_get_string (value); if (handlers) { entry = g_list_find_custom (handlers, command, (GCompareFunc) generic_item_comp); if (entry) index = g_list_position (handlers, entry); else index = g_list_length (handlers) + 1; } else { /* if the item has no handlers lsit then select the Custom item */ index = 1; } ret = mateconf_value_new (MATECONF_VALUE_INT); mateconf_value_set_int (ret, index); return ret; }
static void calendar_sources_selected_sources_notify (MateConfClient *client, guint cnx_id, MateConfEntry *entry, CalendarSourceData *source_data) { GSList *l; if (!entry->value || entry->value->type != MATECONF_VALUE_LIST || mateconf_value_get_list_type (entry->value) != MATECONF_VALUE_STRING) return; dprintf ("Selected sources key (%s) changed, reloading\n", entry->key); for (l = source_data->selected_sources; l; l = l->next) g_free (l->data); source_data->selected_sources = NULL; for (l = mateconf_value_get_list (entry->value); l; l = l->next) { const char *source = mateconf_value_get_string (l->data); source_data->selected_sources = g_slist_prepend (source_data->selected_sources, g_strdup (source)); } source_data->selected_sources = g_slist_reverse (source_data->selected_sources); calendar_sources_load_esource_list (source_data); }
void font_changed_cb (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, Idol *idol) { const gchar *font; GtkFontButton *item; item = GTK_FONT_BUTTON (gtk_builder_get_object (idol->xml, "font_sel_button")); font = mateconf_value_get_string (entry->value); gtk_font_button_set_font_name (item, font); bacon_video_widget_set_subtitle_font (idol->bvw, font); }
void encoding_changed_cb (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, Idol *idol) { const gchar *encoding; GtkComboBox *item; item = GTK_COMBO_BOX (gtk_builder_get_object (idol->xml, "subtitle_encoding_combo")); encoding = mateconf_value_get_string (entry->value); idol_subtitle_encoding_set (item, encoding); bacon_video_widget_set_subtitle_encoding (idol->bvw, encoding); }
static void panel_action_button_type_changed (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, PanelActionButton *button) { int type; const char *action_type; g_return_if_fail (PANEL_IS_ACTION_BUTTON (button)); if (!entry->value || entry->value->type != MATECONF_VALUE_STRING) return; action_type = mateconf_value_get_string (entry->value); if (!mateconf_string_to_enum (panel_action_type_map, action_type, &type)) return; panel_action_button_set_type (button, type); }
static void panel_addto_name_notify (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, PanelAddtoDialog *dialog) { MateConfValue *value; const char *key; const char *text = NULL; key = panel_mateconf_basename (mateconf_entry_get_key (entry)); if (strcmp (key, "name")) return; value = mateconf_entry_get_value (entry); if (value && value->type == MATECONF_VALUE_STRING) text = mateconf_value_get_string (value); if (text) panel_addto_name_change (dialog, text); }
void mc_load_preferences (MCData *mc) { MateConfValue *history; GError *error = NULL; g_return_if_fail (mc != NULL); g_return_if_fail (PANEL_IS_APPLET (mc->applet)); mc->preferences.show_default_theme = mate_panel_applet_mateconf_get_bool (mc->applet, "show_default_theme", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.show_default_theme = MC_DEFAULT_SHOW_DEFAULT_THEME; } mc->preferences.auto_complete_history = mate_panel_applet_mateconf_get_bool (mc->applet, "autocomplete_history", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.auto_complete_history = MC_DEFAULT_AUTO_COMPLETE_HISTORY; } mc->preferences.normal_size_x = mate_panel_applet_mateconf_get_int (mc->applet, "normal_size_x", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.normal_size_x = MC_DEFAULT_NORMAL_SIZE_X; } mc->preferences.normal_size_x = MAX (mc->preferences.normal_size_x, 50); mc->preferences.normal_size_y = mate_panel_applet_mateconf_get_int (mc->applet, "normal_size_y", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.normal_size_y = MC_DEFAULT_NORMAL_SIZE_Y; } mc->preferences.normal_size_y = CLAMP (mc->preferences.normal_size_y, 5, 200); mc->preferences.cmd_line_color_fg_r = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_fg_r", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_fg_r = MC_DEFAULT_CMD_LINE_COLOR_FG_R; } mc->preferences.cmd_line_color_fg_g = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_fg_g", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_fg_g = MC_DEFAULT_CMD_LINE_COLOR_FG_G; } mc->preferences.cmd_line_color_fg_b = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_fg_b", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_fg_b = MC_DEFAULT_CMD_LINE_COLOR_FG_B; } mc->preferences.cmd_line_color_bg_r = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_bg_r", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_bg_r = MC_DEFAULT_CMD_LINE_COLOR_BG_R; } mc->preferences.cmd_line_color_bg_g = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_bg_g", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_bg_g = MC_DEFAULT_CMD_LINE_COLOR_BG_G; } mc->preferences.cmd_line_color_bg_b = mate_panel_applet_mateconf_get_int (mc->applet, "cmd_line_color_bg_b", &error); if (error) { g_error_free (error); error = NULL; mc->preferences.cmd_line_color_bg_b = MC_DEFAULT_CMD_LINE_COLOR_BG_B; } mc->preferences.macros = mc_load_macros (mc); history = mate_panel_applet_mateconf_get_value (mc->applet, "history", NULL); if (history) { GSList *l; for (l = mateconf_value_get_list (history); l; l = l->next) { const char *entry = NULL; if ((entry = mateconf_value_get_string (l->data))) append_history_entry (mc, entry, TRUE); } mateconf_value_free (history); } mc_setup_listeners (mc); mc->preferences.idle_macros_loader_id = 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 MateConfValue * application_font_to_mateconf (MateConfPropertyEditor *peditor, MateConfValue *value) { MateConfValue *new_value; const char *new_font; GtkWidget *font_button; gint danger_level; font_button = GTK_WIDGET (mateconf_property_editor_get_ui_control (peditor)); g_return_val_if_fail (font_button != NULL, NULL); new_value = mateconf_value_new (MATECONF_VALUE_STRING); new_font = mateconf_value_get_string (value); if (font_dangerous (old_font)) { /* If we're already too large, we don't warn again. */ mateconf_value_set_string (new_value, new_font); return new_value; } danger_level = font_dangerous (new_font); if (danger_level) { GtkWidget *warning_dialog, *apply_button; const gchar *warning_label; gchar *warning_label2; warning_label = _("Font may be too large"); if (danger_level > MAX_FONT_POINT_WITHOUT_WARNING) { warning_label2 = g_strdup_printf (ngettext ( "The font selected is %d point large, " "and may make it difficult to effectively " "use the computer. It is recommended that " "you select a size smaller than %d.", "The font selected is %d points large, " "and may make it difficult to effectively " "use the computer. It is recommended that " "you select a size smaller than %d.", danger_level), danger_level, MAX_FONT_POINT_WITHOUT_WARNING); } else { warning_label2 = g_strdup_printf (ngettext ( "The font selected is %d point large, " "and may make it difficult to effectively " "use the computer. It is recommended that " "you select a smaller sized font.", "The font selected is %d points large, " "and may make it difficult to effectively " "use the computer. It is recommended that " "you select a smaller sized font.", danger_level), danger_level); } warning_dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "%s", warning_label); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (warning_dialog), "%s", warning_label2); gtk_dialog_add_button (GTK_DIALOG (warning_dialog), _("Use previous font"), GTK_RESPONSE_CLOSE); apply_button = gtk_button_new_with_label (_("Use selected font")); gtk_button_set_image (GTK_BUTTON (apply_button), gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON)); gtk_dialog_add_action_widget (GTK_DIALOG (warning_dialog), apply_button, GTK_RESPONSE_APPLY); gtk_widget_set_can_default (apply_button, TRUE); gtk_widget_show (apply_button); gtk_dialog_set_default_response (GTK_DIALOG (warning_dialog), GTK_RESPONSE_CLOSE); g_free (warning_label2); if (gtk_dialog_run (GTK_DIALOG (warning_dialog)) == GTK_RESPONSE_APPLY) { mateconf_value_set_string (new_value, new_font); } else { mateconf_value_set_string (new_value, old_font); gtk_font_button_set_font_name (GTK_FONT_BUTTON (font_button), old_font); } gtk_widget_destroy (warning_dialog); } else { mateconf_value_set_string (new_value, new_font); } return new_value; }
static gboolean mateconf_tree_model_search_iter_foreach (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { Node *node; SearchIter *st; gchar *found; GSList *values, *list; st = (SearchIter *) data; if (st->searching == NULL) { return TRUE; } if (st->res >= 1) { gtk_widget_show (GTK_WIDGET (st->output_window)); } while (gtk_events_pending ()) gtk_main_iteration (); node = iter->user_data; found = g_strrstr ((char*) node->path, (char*) st->pattern); if (found != NULL) { /* We found the pattern in the tree */ gchar *key = mateconf_tree_model_get_mateconf_path (MATECONF_TREE_MODEL (model), iter); gedit_output_window_append_line (st->output_window, key, FALSE); g_free (key); st->res++; return FALSE; } if (!st->search_keys && !st->search_values) { return FALSE; } values = mateconf_client_all_entries (MATECONF_TREE_MODEL (model)->client, (const char*) node->path , NULL); for (list = values; list; list = list->next) { const gchar *key; MateConfEntry *entry = list->data; key = mateconf_entry_get_key (entry); /* Search in the key names */ if (st->search_keys) { found = g_strrstr (key, (char*) st->pattern); if (found != NULL) { /* We found the pattern in the final key name */ gedit_output_window_append_line (st->output_window, key, FALSE); st->res++; mateconf_entry_unref (entry); /* After finding an entry continue the list to find other matches */ continue; } } /* Search in the values */ if (st->search_values) { const char *mateconf_string; MateConfValue *mateconf_value = mateconf_entry_get_value (entry); /* FIXME: We are only looking into strings... should we do in * int's? */ if (mateconf_value != NULL && mateconf_value->type == MATECONF_VALUE_STRING) mateconf_string = mateconf_value_get_string (mateconf_value); else { mateconf_entry_unref (entry); continue; } found = g_strrstr (mateconf_string, (char*) st->pattern); if (found != NULL) { /* We found the pattern in the key value */ gedit_output_window_append_line (st->output_window, key, FALSE); st->res++; mateconf_entry_unref (entry); continue; } } mateconf_entry_unref (entry); } return FALSE; }
void idol_setup_preferences (Idol *idol) { GtkWidget *menu, *content_area; gboolean show_visuals, auto_resize, is_local, no_deinterlace, lock_screensaver_on_audio, auto_chapters; int connection_speed; guint i, hidden; char *visual, *font, *encoding; GList *list, *l; BvwAudioOutType audio_out; MateConfValue *value; GObject *item; static struct { const char *name; BvwVideoProperty prop; const char *label; } props[4] = { { "tpw_contrast_scale", BVW_VIDEO_CONTRAST, "tpw_contrast_label" }, { "tpw_saturation_scale", BVW_VIDEO_SATURATION, "tpw_saturation_label" }, { "tpw_bright_scale", BVW_VIDEO_BRIGHTNESS, "tpw_brightness_label" }, { "tpw_hue_scale", BVW_VIDEO_HUE, "tpw_hue_label" } }; g_return_if_fail (idol->gc != NULL); is_local = idol_display_is_local (); mateconf_client_add_dir (idol->gc, MATECONF_PREFIX, MATECONF_CLIENT_PRELOAD_ONELEVEL, NULL); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/auto_resize", (MateConfClientNotifyFunc) auto_resize_changed_cb, idol, NULL, NULL); mateconf_client_add_dir (idol->gc, "/desktop/mate/lockdown", MATECONF_CLIENT_PRELOAD_ONELEVEL, NULL); /* Work-around builder dialogue not parenting properly for * On top windows */ item = gtk_builder_get_object (idol->xml, "tpw_notebook"); idol->prefs = gtk_dialog_new_with_buttons (_("Preferences"), GTK_WINDOW (idol->win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); gtk_container_set_border_width (GTK_CONTAINER (idol->prefs), 5); content_area = gtk_dialog_get_content_area (GTK_DIALOG (idol->prefs)); gtk_box_set_spacing (GTK_BOX (content_area), 2); gtk_widget_reparent (GTK_WIDGET (item), content_area); gtk_widget_show_all (content_area); item = gtk_builder_get_object (idol->xml, "idol_preferences_window"); gtk_widget_destroy (GTK_WIDGET (item)); g_signal_connect (G_OBJECT (idol->prefs), "response", G_CALLBACK (gtk_widget_hide), NULL); g_signal_connect (G_OBJECT (idol->prefs), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (idol->prefs, "destroy", G_CALLBACK (gtk_widget_destroyed), &idol->prefs); /* Remember position */ idol->remember_position = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/remember_position", NULL); item = gtk_builder_get_object (idol->xml, "tpw_remember_position_checkbutton"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), idol->remember_position); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/remember_position", (MateConfClientNotifyFunc) remember_position_changed_cb, idol, NULL, NULL); /* Auto-resize */ auto_resize = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/auto_resize", NULL); item = gtk_builder_get_object (idol->xml, "tpw_display_checkbutton"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), auto_resize); bacon_video_widget_set_auto_resize (BACON_VIDEO_WIDGET (idol->bvw), auto_resize); /* Screensaver audio locking */ lock_screensaver_on_audio = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/lock_screensaver_on_audio", NULL); if (lock_screensaver_on_audio != FALSE) item = gtk_builder_get_object (idol->xml, "tpw_audio_toggle_button"); else item = gtk_builder_get_object (idol->xml, "tpw_video_toggle_button"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), TRUE); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/lock_screensaver_on_audio", (MateConfClientNotifyFunc) lock_screensaver_on_audio_changed_cb, idol, NULL, NULL); /* Disable deinterlacing */ item = gtk_builder_get_object (idol->xml, "tpw_no_deinterlace_checkbutton"); no_deinterlace = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/disable_deinterlacing", NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), no_deinterlace); bacon_video_widget_set_deinterlacing (idol->bvw, !no_deinterlace); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/disable_deinterlacing", (MateConfClientNotifyFunc) no_deinterlace_changed_cb, idol, NULL, NULL); /* Connection Speed */ connection_speed = bacon_video_widget_get_connection_speed (idol->bvw); item = gtk_builder_get_object (idol->xml, "tpw_speed_combobox"); gtk_combo_box_set_active (GTK_COMBO_BOX (item), connection_speed); /* Enable visuals */ item = gtk_builder_get_object (idol->xml, "tpw_visuals_checkbutton"); show_visuals = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/show_vfx", NULL); if (is_local == FALSE && show_visuals != FALSE) show_visuals = ask_show_visuals (idol); g_signal_handlers_disconnect_by_func (item, checkbutton2_toggled_cb, idol); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), show_visuals); idol_prefs_set_show_visuals (idol, show_visuals); g_signal_connect (item, "toggled", G_CALLBACK (checkbutton2_toggled_cb), idol); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/show_vfx", (MateConfClientNotifyFunc) show_vfx_changed_cb, idol, NULL, NULL); /* Auto-load subtitles */ item = gtk_builder_get_object (idol->xml, "tpw_auto_subtitles_checkbutton"); idol->autoload_subs = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/autoload_subtitles", NULL); g_signal_handlers_disconnect_by_func (item, checkbutton3_toggled_cb, idol); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), idol->autoload_subs); g_signal_connect (item, "toggled", G_CALLBACK (checkbutton3_toggled_cb), idol); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/autoload_subtitles", (MateConfClientNotifyFunc) autoload_subtitles_changed_cb, idol, NULL, NULL); /* Auto-load external chapters */ item = gtk_builder_get_object (idol->xml, "tpw_auto_chapters_checkbutton"); auto_chapters = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/autoload_chapters", NULL); g_signal_handlers_disconnect_by_func (item, auto_chapters_toggled_cb, idol); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), auto_chapters); g_signal_connect (item, "toggled", G_CALLBACK (auto_chapters_toggled_cb), idol); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/autoload_chapters", (MateConfClientNotifyFunc) autoload_chapters_changed_cb, idol, NULL, NULL); /* Visuals list */ list = bacon_video_widget_get_visuals_list (idol->bvw); menu = gtk_menu_new (); gtk_widget_show (menu); visual = mateconf_client_get_string (idol->gc, MATECONF_PREFIX"/visual", NULL); if (visual == NULL || strcmp (visual, "") == 0) { g_free (visual); visual = g_strdup ("goom"); } item = gtk_builder_get_object (idol->xml, "tpw_visuals_type_combobox"); i = 0; for (l = list; l != NULL; l = l->next) { const char *name = l->data; gtk_combo_box_append_text (GTK_COMBO_BOX (item), name); if (strcmp (name, visual) == 0) gtk_combo_box_set_active (GTK_COMBO_BOX (item), i); i++; } g_free (visual); /* Visualisation quality */ i = mateconf_client_get_int (idol->gc, MATECONF_PREFIX"/visual_quality", NULL); bacon_video_widget_set_visuals_quality (idol->bvw, i); item = gtk_builder_get_object (idol->xml, "tpw_visuals_size_combobox"); gtk_combo_box_set_active (GTK_COMBO_BOX (item), i); /* Brightness and all */ hidden = 0; for (i = 0; i < G_N_ELEMENTS (props); i++) { int prop_value; item = gtk_builder_get_object (idol->xml, props[i].name); prop_value = bacon_video_widget_get_video_property (idol->bvw, props[i].prop); if (prop_value >= 0) gtk_range_set_value (GTK_RANGE (item), (gdouble) prop_value); else { gtk_range_set_value (GTK_RANGE (item), (gdouble) 65535/2); gtk_widget_hide (GTK_WIDGET (item)); item = gtk_builder_get_object (idol->xml, props[i].label); gtk_widget_hide (GTK_WIDGET (item)); hidden++; } } if (hidden == G_N_ELEMENTS (props)) { item = gtk_builder_get_object (idol->xml, "tpw_bright_contr_vbox"); gtk_widget_hide (GTK_WIDGET (item)); } /* Sound output type */ item = gtk_builder_get_object (idol->xml, "tpw_sound_output_combobox"); audio_out = bacon_video_widget_get_audio_out_type (idol->bvw); gtk_combo_box_set_active (GTK_COMBO_BOX (item), audio_out); /* Subtitle font selection */ item = gtk_builder_get_object (idol->xml, "font_sel_button"); gtk_font_button_set_title (GTK_FONT_BUTTON (item), _("Select Subtitle Font")); font = mateconf_client_get_string (idol->gc, MATECONF_PREFIX"/subtitle_font", NULL); if (font && strcmp (font, "") != 0) { gtk_font_button_set_font_name (GTK_FONT_BUTTON (item), font); bacon_video_widget_set_subtitle_font (idol->bvw, font); } g_free (font); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/subtitle_font", (MateConfClientNotifyFunc) font_changed_cb, idol, NULL, NULL); /* Subtitle encoding selection */ item = gtk_builder_get_object (idol->xml, "subtitle_encoding_combo"); idol_subtitle_encoding_init (GTK_COMBO_BOX (item)); value = mateconf_client_get_without_default (idol->gc, MATECONF_PREFIX"/subtitle_encoding", NULL); /* Make sure the default is UTF-8 */ if (value != NULL) { if (mateconf_value_get_string (value) == NULL) { encoding = g_strdup ("UTF-8"); } else { encoding = g_strdup (mateconf_value_get_string (value)); if (encoding[0] == '\0') { g_free (encoding); encoding = g_strdup ("UTF-8"); } } mateconf_value_free (value); } else { encoding = g_strdup ("UTF-8"); } idol_subtitle_encoding_set (GTK_COMBO_BOX(item), encoding); if (encoding && strcasecmp (encoding, "") != 0) { bacon_video_widget_set_subtitle_encoding (idol->bvw, encoding); } g_free (encoding); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/subtitle_encoding", (MateConfClientNotifyFunc) encoding_changed_cb, idol, NULL, NULL); /* Disable keyboard shortcuts */ idol->disable_kbd_shortcuts = mateconf_client_get_bool (idol->gc, MATECONF_PREFIX"/disable_keyboard_shortcuts", NULL); mateconf_client_notify_add (idol->gc, MATECONF_PREFIX"/disable_keyboard_shortcuts", (MateConfClientNotifyFunc) disable_kbd_shortcuts_changed_cb, idol, NULL, NULL); }
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; }
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; }
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); } }