2 * stash.c - this file is part of Geany, a fast and lightweight IDE
4 * Copyright 2008 The Geany contributors
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 * Lightweight library for reading/writing @c GKeyFile settings and synchronizing widgets with
26 * Note: Stash should only depend on GLib and GTK, but currently has some minor
27 * dependencies on Geany's utils.c.
30 * 'Setting' is used only for data stored on disk or in memory.
31 * 'Pref' can also include visual widget information.
33 * @section Memory Usage
34 * Stash will not duplicate strings if they are normally static arrays, such as
35 * keyfile group names and key names, string default values, widget_id names, property names.
37 * @section String Settings
38 * String settings and other dynamically allocated settings will be initialized to NULL when
39 * added to a StashGroup (so they can safely be reassigned later).
41 * @section Widget Support
42 * Widgets very commonly used in configuration dialogs will be supported with their own function.
43 * Widgets less commonly used such as @c GtkExpander or widget settings that aren't commonly needed
44 * to be persistent won't be directly supported, to keep the library lightweight. However, you can
45 * use stash_group_add_widget_property() to also save these settings for any read/write widget
46 * property. Macros could be added for common widget properties such as @c GtkExpander:"expanded".
48 * @section settings-example Settings Example
49 * Here we have some settings for how to make a cup - whether it should be made of china
50 * and who's going to make it. (Yes, it's a stupid example).
51 * @include stash-example.c
52 * @note You might want to handle the warning/error conditions differently from above.
54 * @section prefs-example GUI Prefs Example
55 * For prefs, it's the same as the above example but you tell Stash to add widget prefs instead of
58 * This example uses lookup strings for widgets as they are more flexible than widget pointers.
59 * Code to load and save the settings is omitted - see the first example instead.
61 * Here we show a dialog with a toggle button for whether the cup should have a handle.
62 * @include stash-gui-example.c
63 * @note This example should also work for other widget containers besides dialogs, e.g. popup menus.
66 /* Implementation Note
67 * We dynamically allocate prefs. It would be more efficient for user code to declare
68 * a static array of StashPref structs, but we don't do this because:
70 * * It would be more ugly (lots of casts and NULLs).
71 * * Less type checking.
72 * * The API & ABI would have to break when adding/changing fields.
74 * Usually the prefs code isn't what user code will spend most of its time doing, so this
75 * should be efficient enough.
80 #include "support.h" /* only for _("text") */
81 #include "utils.h" /* only for foreach_*, utils_get_setting_*(). Stash should not depend on Geany. */
83 #include <stdlib.h> /* only for atoi() */
86 /* GTK3 removed ComboBoxEntry, but we need a value to differentiate combo box with and
87 * without entries, and it must not collide with other GTypes */
88 #ifdef GTK_TYPE_COMBO_BOX_ENTRY
89 # define TYPE_COMBO_BOX_ENTRY GTK_TYPE_COMBO_BOX_ENTRY
90 #else /* !GTK_TYPE_COMBO_BOX_ENTRY */
91 # define TYPE_COMBO_BOX_ENTRY get_combo_box_entry_type()
92 static GType
get_combo_box_entry_type(void)
94 static volatile gsize type
= 0;
95 if (g_once_init_enter(&type
))
97 GType g_type
= g_type_register_static_simple(GTK_TYPE_COMBO_BOX
, "dummy-combo-box-entry",
98 sizeof(GtkComboBoxClass
), NULL
, sizeof(GtkComboBox
), NULL
, G_TYPE_FLAG_ABSTRACT
);
99 g_once_init_leave(&type
, g_type
);
103 #endif /* !GTK_TYPE_COMBO_BOX_ENTRY */
108 GType setting_type
; /* e.g. G_TYPE_INT */
109 gpointer setting
; /* Address of a variable */
110 const gchar
*key_name
;
111 gpointer default_value
; /* Default value, e.g. (gpointer)1 */
112 GType widget_type
; /* e.g. GTK_TYPE_TOGGLE_BUTTON */
113 StashWidgetID widget_id
; /* (GtkWidget*) or (gchar*) */
116 struct EnumWidget
*radio_buttons
;
117 const gchar
*property_name
;
118 } extra
; /* extra fields depending on widget_type */
121 typedef struct StashPref StashPref
;
125 guint refcount
; /* ref count for GBoxed implementation */
126 const gchar
*name
; /* group name to use in the keyfile */
127 GPtrArray
*entries
; /* array of (StashPref*) */
128 gboolean various
; /* mark group for display/edit in stash treeview */
129 gboolean use_defaults
; /* use default values if there's no keyfile entry */
132 typedef struct EnumWidget
134 StashWidgetID widget_id
;
140 typedef enum SettingAction
147 typedef enum PrefAction
155 static void handle_boolean_setting(StashGroup
*group
, StashPref
*se
,
156 GKeyFile
*config
, SettingAction action
)
158 gboolean
*setting
= se
->setting
;
163 *setting
= utils_get_setting_boolean(config
, group
->name
, se
->key_name
,
164 GPOINTER_TO_INT(se
->default_value
));
167 g_key_file_set_boolean(config
, group
->name
, se
->key_name
, *setting
);
173 static void handle_integer_setting(StashGroup
*group
, StashPref
*se
,
174 GKeyFile
*config
, SettingAction action
)
176 gint
*setting
= se
->setting
;
181 *setting
= utils_get_setting_integer(config
, group
->name
, se
->key_name
,
182 GPOINTER_TO_INT(se
->default_value
));
185 g_key_file_set_integer(config
, group
->name
, se
->key_name
, *setting
);
191 static void handle_string_setting(StashGroup
*group
, StashPref
*se
,
192 GKeyFile
*config
, SettingAction action
)
194 gchararray
*setting
= se
->setting
;
200 *setting
= utils_get_setting_string(config
, group
->name
, se
->key_name
,
204 g_key_file_set_string(config
, group
->name
, se
->key_name
,
205 *setting
? *setting
: "");
211 static void handle_strv_setting(StashGroup
*group
, StashPref
*se
,
212 GKeyFile
*config
, SettingAction action
)
214 gchararray
**setting
= se
->setting
;
219 g_strfreev(*setting
);
220 *setting
= g_key_file_get_string_list(config
, group
->name
, se
->key_name
,
222 if (*setting
== NULL
)
223 *setting
= g_strdupv(se
->default_value
);
228 /* don't try to save a NULL string vector */
229 const gchar
*dummy
[] = { "", NULL
};
230 const gchar
**strv
= *setting
? (const gchar
**)*setting
: dummy
;
232 g_key_file_set_string_list(config
, group
->name
, se
->key_name
,
233 strv
, g_strv_length((gchar
**)strv
));
240 static void keyfile_action(SettingAction action
, StashGroup
*group
, GKeyFile
*keyfile
)
245 foreach_ptr_array(entry
, i
, group
->entries
)
247 /* don't override settings with default values */
248 if (!group
->use_defaults
&& action
== SETTING_READ
&&
249 !g_key_file_has_key(keyfile
, group
->name
, entry
->key_name
, NULL
))
252 switch (entry
->setting_type
)
255 handle_boolean_setting(group
, entry
, keyfile
, action
); break;
257 handle_integer_setting(group
, entry
, keyfile
, action
); break;
259 handle_string_setting(group
, entry
, keyfile
, action
); break;
261 /* Note: G_TYPE_STRV is not a constant, can't use case label */
262 if (entry
->setting_type
== G_TYPE_STRV
)
263 handle_strv_setting(group
, entry
, keyfile
, action
);
265 g_warning("Unhandled type for %s::%s in %s()!", group
->name
, entry
->key_name
,
272 /** Reads key values from @a keyfile into the group settings.
273 * @note You should still call this even if the keyfile couldn't be loaded from disk
274 * so that all Stash settings are initialized to defaults.
276 * @param keyfile Usually loaded from a configuration file first. */
278 void stash_group_load_from_key_file(StashGroup
*group
, GKeyFile
*keyfile
)
280 keyfile_action(SETTING_READ
, group
, keyfile
);
284 /** Writes group settings into key values in @a keyfile.
285 * @a keyfile is usually written to a configuration file afterwards.
287 * @param keyfile . */
289 void stash_group_save_to_key_file(StashGroup
*group
, GKeyFile
*keyfile
)
291 keyfile_action(SETTING_WRITE
, group
, keyfile
);
295 /** Reads group settings from a configuration file using @c GKeyFile.
296 * @note Stash settings will be initialized to defaults if the keyfile
297 * couldn't be loaded from disk.
299 * @param filename Filename of the file to read, in locale encoding.
300 * @return @c TRUE if a key file could be loaded.
301 * @see stash_group_load_from_key_file().
304 gboolean
stash_group_load_from_file(StashGroup
*group
, const gchar
*filename
)
309 keyfile
= g_key_file_new();
310 ret
= g_key_file_load_from_file(keyfile
, filename
, 0, NULL
);
311 /* even on failure we load settings to apply defaults */
312 stash_group_load_from_key_file(group
, keyfile
);
314 g_key_file_free(keyfile
);
319 /** Writes group settings to a configuration file using @c GKeyFile.
322 * @param filename Filename of the file to write, in locale encoding.
323 * @param flags Keyfile options - @c G_KEY_FILE_NONE is the most efficient.
324 * @return 0 if the file was successfully written, otherwise the @c errno of the
325 * failed operation is returned.
326 * @see stash_group_save_to_key_file().
329 gint
stash_group_save_to_file(StashGroup
*group
, const gchar
*filename
,
336 keyfile
= g_key_file_new();
337 /* if we need to keep comments or translations, try to load first */
339 g_key_file_load_from_file(keyfile
, filename
, flags
, NULL
);
341 stash_group_save_to_key_file(group
, keyfile
);
342 data
= g_key_file_to_data(keyfile
, NULL
, NULL
);
343 ret
= utils_write_file(filename
, data
);
345 g_key_file_free(keyfile
);
350 static void free_stash_pref(StashPref
*pref
)
352 if (pref
->widget_type
== GTK_TYPE_RADIO_BUTTON
)
353 g_free(pref
->extra
.radio_buttons
);
355 g_slice_free(StashPref
, pref
);
359 /** Creates a new group.
360 * @param name Name used for @c GKeyFile group.
363 StashGroup
*stash_group_new(const gchar
*name
)
365 StashGroup
*group
= g_slice_new0(StashGroup
);
368 group
->entries
= g_ptr_array_new_with_free_func((GDestroyNotify
) free_stash_pref
);
369 group
->use_defaults
= TRUE
;
375 /** Frees the memory allocated for setting values in a group.
376 * Useful e.g. to avoid freeing strings individually.
377 * @note This is *not* called by stash_group_free().
380 void stash_group_free_settings(StashGroup
*group
)
385 foreach_ptr_array(entry
, i
, group
->entries
)
387 if (entry
->setting_type
== G_TYPE_STRING
)
388 g_free(*(gchararray
*) entry
->setting
);
389 else if (entry
->setting_type
== G_TYPE_STRV
)
390 g_strfreev(*(gchararray
**) entry
->setting
);
394 *(gpointer
**) entry
->setting
= NULL
;
399 static StashGroup
*stash_group_dup(StashGroup
*src
)
401 g_atomic_int_inc(&src
->refcount
);
410 void stash_group_free(StashGroup
*group
)
412 if (g_atomic_int_dec_and_test(&group
->refcount
))
414 g_ptr_array_free(group
->entries
, TRUE
);
415 g_slice_free(StashGroup
, group
);
420 /** Gets the GBoxed-derived GType for StashGroup
422 * @return StashGroup type . */
424 GType
stash_group_get_type(void);
426 G_DEFINE_BOXED_TYPE(StashGroup
, stash_group
, stash_group_dup
, stash_group_free
);
429 /* Used for selecting groups passed to stash_tree_setup().
430 * @c FALSE by default. */
431 void stash_group_set_various(StashGroup
*group
, gboolean various
)
433 group
->various
= various
;
437 /* When @c FALSE, Stash doesn't change the setting if there is no keyfile entry, so it
438 * remains whatever it was initialized/set to by user code.
439 * @c TRUE by default. */
440 void stash_group_set_use_defaults(StashGroup
*group
, gboolean use_defaults
)
442 group
->use_defaults
= use_defaults
;
447 add_pref(StashGroup
*group
, GType type
, gpointer setting
,
448 const gchar
*key_name
, gpointer default_value
)
450 StashPref init
= {type
, setting
, key_name
, default_value
, G_TYPE_NONE
, NULL
, {NULL
}};
451 StashPref
*entry
= g_slice_new(StashPref
);
455 /* init any pointer settings to NULL so they can be freed later */
456 if (type
== G_TYPE_STRING
||
458 if (group
->use_defaults
)
459 *(gpointer
**)setting
= NULL
;
461 g_ptr_array_add(group
->entries
, entry
);
466 /** Adds boolean setting.
468 * @param setting Address of setting variable.
469 * @param key_name Name for key in a @c GKeyFile.
470 * @param default_value Value to use if the key doesn't exist when loading. */
472 void stash_group_add_boolean(StashGroup
*group
, gboolean
*setting
,
473 const gchar
*key_name
, gboolean default_value
)
475 add_pref(group
, G_TYPE_BOOLEAN
, setting
, key_name
, GINT_TO_POINTER(default_value
));
479 /** Adds integer setting.
481 * @param setting Address of setting variable.
482 * @param key_name Name for key in a @c GKeyFile.
483 * @param default_value Value to use if the key doesn't exist when loading. */
485 void stash_group_add_integer(StashGroup
*group
, gint
*setting
,
486 const gchar
*key_name
, gint default_value
)
488 add_pref(group
, G_TYPE_INT
, setting
, key_name
, GINT_TO_POINTER(default_value
));
492 /** Adds string setting.
493 * The contents of @a setting will be initialized to @c NULL.
495 * @param setting Address of setting variable.
496 * @param key_name Name for key in a @c GKeyFile.
497 * @param default_value @nullable String to copy if the key doesn't exist when loading, or @c NULL. */
499 void stash_group_add_string(StashGroup
*group
, gchar
**setting
,
500 const gchar
*key_name
, const gchar
*default_value
)
502 add_pref(group
, G_TYPE_STRING
, setting
, key_name
, (gpointer
)default_value
);
506 /** Adds string vector setting (array of strings).
507 * The contents of @a setting will be initialized to @c NULL.
509 * @param setting Address of setting variable.
510 * @param key_name Name for key in a @c GKeyFile.
511 * @param default_value Vector to copy if the key doesn't exist when loading. Usually @c NULL. */
513 void stash_group_add_string_vector(StashGroup
*group
, gchar
***setting
,
514 const gchar
*key_name
, const gchar
**default_value
)
516 add_pref(group
, G_TYPE_STRV
, setting
, key_name
, (gpointer
)default_value
);
520 /* *** GTK-related functions *** */
522 static void handle_toggle_button(GtkWidget
*widget
, gboolean
*setting
,
528 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget
), *setting
);
531 *setting
= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget
));
537 static void handle_spin_button(GtkWidget
*widget
, StashPref
*entry
,
540 gint
*setting
= entry
->setting
;
542 g_assert(entry
->setting_type
== G_TYPE_INT
); /* only int spin prefs */
547 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget
), *setting
);
550 /* if the widget is focussed, the value might not be updated */
551 gtk_spin_button_update(GTK_SPIN_BUTTON(widget
));
552 *setting
= gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget
));
558 static void handle_combo_box(GtkWidget
*widget
, StashPref
*entry
,
561 gint
*setting
= entry
->setting
;
566 gtk_combo_box_set_active(GTK_COMBO_BOX(widget
), *setting
);
569 *setting
= gtk_combo_box_get_active(GTK_COMBO_BOX(widget
));
575 static void handle_entry(GtkWidget
*widget
, StashPref
*entry
,
578 gchararray
*setting
= entry
->setting
;
583 gtk_entry_set_text(GTK_ENTRY(widget
), *setting
);
587 *setting
= g_strdup(gtk_entry_get_text(GTK_ENTRY(widget
)));
593 static void handle_combo_box_entry(GtkWidget
*widget
, StashPref
*entry
,
596 widget
= gtk_bin_get_child(GTK_BIN(widget
));
597 handle_entry(widget
, entry
, action
);
601 /* taken from Glade 2.x generated support.c */
603 lookup_widget(GtkWidget
*widget
, const gchar
*widget_name
)
605 GtkWidget
*parent
, *found_widget
;
607 g_return_val_if_fail(widget
!= NULL
, NULL
);
608 g_return_val_if_fail(widget_name
!= NULL
, NULL
);
612 if (GTK_IS_MENU(widget
))
613 parent
= gtk_menu_get_attach_widget(GTK_MENU(widget
));
615 parent
= gtk_widget_get_parent(widget
);
617 parent
= (GtkWidget
*) g_object_get_data(G_OBJECT(widget
), "GladeParentKey");
623 found_widget
= (GtkWidget
*) g_object_get_data(G_OBJECT(widget
), widget_name
);
624 if (G_UNLIKELY(found_widget
== NULL
))
625 g_warning("Widget not found: %s", widget_name
);
631 get_widget(GtkWidget
*owner
, StashWidgetID widget_id
)
636 widget
= lookup_widget(owner
, (const gchar
*)widget_id
);
638 widget
= (GtkWidget
*)widget_id
;
640 if (!GTK_IS_WIDGET(widget
))
642 g_warning("Unknown widget in %s()!", G_STRFUNC
);
649 static void handle_radio_button(GtkWidget
*widget
, gint enum_id
, gboolean
*setting
,
655 if (*setting
== enum_id
)
656 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget
), TRUE
);
659 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget
)))
666 static void handle_radio_buttons(GtkWidget
*owner
, StashPref
*entry
,
669 EnumWidget
*field
= entry
->extra
.radio_buttons
;
671 GtkWidget
*widget
= NULL
;
675 widget
= get_widget(owner
, field
->widget_id
);
681 handle_radio_button(widget
, field
->enum_id
, entry
->setting
, action
);
683 if (!field
->widget_id
)
686 if (g_slist_length(gtk_radio_button_get_group(GTK_RADIO_BUTTON(widget
))) != count
)
687 g_warning("Missing/invalid radio button widget IDs found!");
691 static void handle_widget_property(GtkWidget
*widget
, StashPref
*entry
,
694 GObject
*object
= G_OBJECT(widget
);
695 const gchar
*name
= entry
->extra
.property_name
;
700 if (entry
->setting_type
== G_TYPE_BOOLEAN
)
701 g_object_set(object
, name
, *(gboolean
*)entry
->setting
, NULL
);
702 else if (entry
->setting_type
== G_TYPE_INT
)
703 g_object_set(object
, name
, *(gint
*)entry
->setting
, NULL
);
704 else if (entry
->setting_type
== G_TYPE_STRING
)
705 g_object_set(object
, name
, *(gchararray
*)entry
->setting
, NULL
);
706 else if (entry
->setting_type
== G_TYPE_STRV
)
707 g_object_set(object
, name
, *(gchararray
**)entry
->setting
, NULL
);
710 g_warning("Unhandled type %s for %s in %s()!", g_type_name(entry
->setting_type
),
711 entry
->key_name
, G_STRFUNC
);
715 if (entry
->setting_type
== G_TYPE_STRING
)
716 g_free(*(gchararray
*)entry
->setting
);
717 else if (entry
->setting_type
== G_TYPE_STRV
)
718 g_strfreev(*(gchararray
**)entry
->setting
);
720 g_object_get(object
, name
, entry
->setting
, NULL
);
726 static void pref_action(PrefAction action
, StashGroup
*group
, GtkWidget
*owner
)
731 foreach_ptr_array(entry
, i
, group
->entries
)
735 /* ignore settings with no widgets */
736 if (entry
->widget_type
== G_TYPE_NONE
)
739 /* radio buttons have several widgets */
740 if (entry
->widget_type
== GTK_TYPE_RADIO_BUTTON
)
742 handle_radio_buttons(owner
, entry
, action
);
746 widget
= get_widget(owner
, entry
->widget_id
);
749 g_warning("Unknown widget for %s::%s in %s()!", group
->name
, entry
->key_name
,
754 /* note: can't use switch for GTK_TYPE macros */
755 if (entry
->widget_type
== GTK_TYPE_TOGGLE_BUTTON
)
756 handle_toggle_button(widget
, entry
->setting
, action
);
757 else if (entry
->widget_type
== GTK_TYPE_SPIN_BUTTON
)
758 handle_spin_button(widget
, entry
, action
);
759 else if (entry
->widget_type
== GTK_TYPE_COMBO_BOX
)
760 handle_combo_box(widget
, entry
, action
);
761 else if (entry
->widget_type
== TYPE_COMBO_BOX_ENTRY
)
762 handle_combo_box_entry(widget
, entry
, action
);
763 else if (entry
->widget_type
== GTK_TYPE_ENTRY
)
764 handle_entry(widget
, entry
, action
);
765 else if (entry
->widget_type
== G_TYPE_PARAM
)
766 handle_widget_property(widget
, entry
, action
);
768 g_warning("Unhandled type for %s::%s in %s()!", group
->name
, entry
->key_name
,
774 /** Applies Stash settings to widgets, usually called before displaying the widgets.
775 * The @a owner argument depends on which type you use for @ref StashWidgetID.
777 * @param owner If non-NULL, used to lookup widgets by name, otherwise
778 * widget pointers are assumed.
779 * @see stash_group_update(). */
781 void stash_group_display(StashGroup
*group
, GtkWidget
*owner
)
783 pref_action(PREF_DISPLAY
, group
, owner
);
787 /** Applies widget values to Stash settings, usually called after displaying the widgets.
788 * The @a owner argument depends on which type you use for @ref StashWidgetID.
790 * @param owner If non-NULL, used to lookup widgets by name, otherwise
791 * widget pointers are assumed.
792 * @see stash_group_display(). */
794 void stash_group_update(StashGroup
*group
, GtkWidget
*owner
)
796 pref_action(PREF_UPDATE
, group
, owner
);
801 add_widget_pref(StashGroup
*group
, GType setting_type
, gpointer setting
,
802 const gchar
*key_name
, gpointer default_value
,
803 GType widget_type
, StashWidgetID widget_id
)
806 add_pref(group
, setting_type
, setting
, key_name
, default_value
);
808 entry
->widget_type
= widget_type
;
809 entry
->widget_id
= widget_id
;
814 /** Adds a @c GtkToggleButton (or @c GtkCheckButton) widget pref.
816 * @param setting Address of setting variable.
817 * @param key_name Name for key in a @c GKeyFile.
818 * @param default_value Value to use if the key doesn't exist when loading.
819 * @param widget_id @c GtkWidget pointer or string to lookup widget later.
820 * @see stash_group_add_radio_buttons(). */
822 void stash_group_add_toggle_button(StashGroup
*group
, gboolean
*setting
,
823 const gchar
*key_name
, gboolean default_value
, StashWidgetID widget_id
)
825 add_widget_pref(group
, G_TYPE_BOOLEAN
, setting
, key_name
, GINT_TO_POINTER(default_value
),
826 GTK_TYPE_TOGGLE_BUTTON
, widget_id
);
830 /** Adds a @c GtkRadioButton widget group pref.
832 * @param setting Address of setting variable.
833 * @param key_name Name for key in a @c GKeyFile.
834 * @param default_value Value to use if the key doesn't exist when loading.
835 * @param widget_id @c GtkWidget pointer or string to lookup widget later.
836 * @param enum_id Enum value for @a widget_id.
837 * @param ... pairs of @a widget_id, @a enum_id.
838 * Example (using widget lookup strings, but widget pointers can also work):
841 * stash_group_add_radio_buttons(group, &which_one_setting, "which_one", BAR,
842 * "radio_foo", FOO, "radio_bar", BAR, NULL);
845 void stash_group_add_radio_buttons(StashGroup
*group
, gint
*setting
,
846 const gchar
*key_name
, gint default_value
,
847 StashWidgetID widget_id
, gint enum_id
, ...)
850 add_widget_pref(group
, G_TYPE_INT
, setting
, key_name
, GINT_TO_POINTER(default_value
),
851 GTK_TYPE_RADIO_BUTTON
, NULL
);
854 EnumWidget
*item
, *array
;
856 /* count pairs of args */
857 va_start(args
, enum_id
);
860 if (!va_arg(args
, gpointer
))
867 array
= g_new0(EnumWidget
, count
+ 1);
868 entry
->extra
.radio_buttons
= array
;
870 va_start(args
, enum_id
);
871 foreach_c_array(item
, array
, count
)
876 item
->widget_id
= widget_id
;
877 item
->enum_id
= enum_id
;
881 item
->widget_id
= va_arg(args
, gpointer
);
882 item
->enum_id
= va_arg(args
, gint
);
889 /** Adds a @c GtkSpinButton widget pref.
891 * @param setting Address of setting variable.
892 * @param key_name Name for key in a @c GKeyFile.
893 * @param default_value Value to use if the key doesn't exist when loading.
894 * @param widget_id @c GtkWidget pointer or string to lookup widget later. */
896 void stash_group_add_spin_button_integer(StashGroup
*group
, gint
*setting
,
897 const gchar
*key_name
, gint default_value
, StashWidgetID widget_id
)
899 add_widget_pref(group
, G_TYPE_INT
, setting
, key_name
, GINT_TO_POINTER(default_value
),
900 GTK_TYPE_SPIN_BUTTON
, widget_id
);
904 /** Adds a @c GtkComboBox widget pref.
906 * @param setting Address of setting variable.
907 * @param key_name Name for key in a @c GKeyFile.
908 * @param default_value Value to use if the key doesn't exist when loading.
909 * @param widget_id @c GtkWidget pointer or string to lookup widget later.
910 * @see stash_group_add_combo_box_entry(). */
912 void stash_group_add_combo_box(StashGroup
*group
, gint
*setting
,
913 const gchar
*key_name
, gint default_value
, StashWidgetID widget_id
)
915 add_widget_pref(group
, G_TYPE_INT
, setting
, key_name
, GINT_TO_POINTER(default_value
),
916 GTK_TYPE_COMBO_BOX
, widget_id
);
920 /** Adds a @c GtkComboBoxEntry widget pref.
922 * @param setting Address of setting variable.
923 * @param key_name Name for key in a @c GKeyFile.
924 * @param default_value Value to use if the key doesn't exist when loading.
925 * @param widget_id @c GtkWidget pointer or string to lookup widget later. */
926 /* We could maybe also have something like stash_group_add_combo_box_entry_with_menu()
927 * for the history list - or should that be stored as a separate setting? */
929 void stash_group_add_combo_box_entry(StashGroup
*group
, gchar
**setting
,
930 const gchar
*key_name
, const gchar
*default_value
, StashWidgetID widget_id
)
932 add_widget_pref(group
, G_TYPE_STRING
, setting
, key_name
, (gpointer
)default_value
,
933 TYPE_COMBO_BOX_ENTRY
, widget_id
);
937 /** Adds a @c GtkEntry widget pref.
939 * @param setting Address of setting variable.
940 * @param key_name Name for key in a @c GKeyFile.
941 * @param default_value Value to use if the key doesn't exist when loading.
942 * @param widget_id @c GtkWidget pointer or string to lookup widget later. */
944 void stash_group_add_entry(StashGroup
*group
, gchar
**setting
,
945 const gchar
*key_name
, const gchar
*default_value
, StashWidgetID widget_id
)
947 add_widget_pref(group
, G_TYPE_STRING
, setting
, key_name
, (gpointer
)default_value
,
948 GTK_TYPE_ENTRY
, widget_id
);
952 static GType
object_get_property_type(GObject
*object
, const gchar
*property_name
)
954 GObjectClass
*klass
= G_OBJECT_GET_CLASS(object
);
957 ps
= g_object_class_find_property(klass
, property_name
);
958 return ps
->value_type
;
962 /** Adds a widget's read/write property to the stash group.
963 * The property will be set when calling
964 * stash_group_display(), and read when calling stash_group_update().
966 * @param setting Address of e.g. an integer if using an integer property.
967 * @param key_name Name for key in a @c GKeyFile.
968 * @param default_value Value to use if the key doesn't exist when loading.
969 * Should be cast into a pointer e.g. with @c GINT_TO_POINTER().
970 * @param widget_id @c GtkWidget pointer or string to lookup widget later.
971 * @param property_name .
972 * @param type can be @c 0 if passing a @c GtkWidget as the @a widget_id argument to look it up from the
974 * @warning Currently only string GValue properties will be freed before setting; patch for
975 * other types - see @c handle_widget_property(). */
977 void stash_group_add_widget_property(StashGroup
*group
, gpointer setting
,
978 const gchar
*key_name
, gpointer default_value
, StashWidgetID widget_id
,
979 const gchar
*property_name
, GType type
)
982 type
= object_get_property_type(G_OBJECT(widget_id
), property_name
);
984 add_widget_pref(group
, type
, setting
, key_name
, default_value
,
985 G_TYPE_PARAM
, widget_id
)->extra
.property_name
= property_name
;
997 struct StashTreeValue
999 const gchar
*group_name
;
1003 gchararray tree_string
;
1008 typedef struct StashTreeValue StashTreeValue
;
1011 static void stash_tree_renderer_set_data(GtkCellLayout
*cell_layout
, GtkCellRenderer
*cell
,
1012 GtkTreeModel
*model
, GtkTreeIter
*iter
, gpointer user_data
)
1014 GType cell_type
= GPOINTER_TO_SIZE(user_data
);
1015 StashTreeValue
*value
;
1017 gboolean matches_type
;
1019 gtk_tree_model_get(model
, iter
, STASH_TREE_VALUE
, &value
, -1);
1021 matches_type
= pref
->setting_type
== cell_type
;
1022 g_object_set(cell
, "visible", matches_type
, "sensitive", matches_type
,
1023 cell_type
== G_TYPE_BOOLEAN
? "activatable" : "editable", matches_type
, NULL
);
1027 switch (pref
->setting_type
)
1029 case G_TYPE_BOOLEAN
:
1030 g_object_set(cell
, "active", value
->data
.tree_int
, NULL
);
1034 gchar
*text
= g_strdup_printf("%d", value
->data
.tree_int
);
1035 g_object_set(cell
, "text", text
, NULL
);
1040 g_object_set(cell
, "text", value
->data
.tree_string
, NULL
);
1047 static void stash_tree_renderer_edited(gchar
*path_str
, gchar
*new_text
, GtkTreeModel
*model
)
1051 StashTreeValue
*value
;
1054 path
= gtk_tree_path_new_from_string(path_str
);
1055 gtk_tree_model_get_iter(model
, &iter
, path
);
1056 gtk_tree_model_get(model
, &iter
, STASH_TREE_VALUE
, &value
, -1);
1059 switch (pref
->setting_type
)
1061 case G_TYPE_BOOLEAN
:
1062 value
->data
.tree_int
= !value
->data
.tree_int
;
1065 value
->data
.tree_int
= atoi(new_text
);
1068 SETPTR(value
->data
.tree_string
, g_strdup(new_text
));
1072 gtk_tree_model_row_changed(model
, path
, &iter
);
1073 gtk_tree_path_free(path
);
1077 static void stash_tree_boolean_toggled(GtkCellRendererToggle
*cell
, gchar
*path_str
,
1078 GtkTreeModel
*model
)
1080 stash_tree_renderer_edited(path_str
, NULL
, model
);
1084 static void stash_tree_string_edited(GtkCellRenderer
*cell
, gchar
*path_str
, gchar
*new_text
,
1085 GtkTreeModel
*model
)
1087 stash_tree_renderer_edited(path_str
, new_text
, model
);
1091 static gboolean
stash_tree_discard_value(GtkTreeModel
*model
, GtkTreePath
*path
,
1092 GtkTreeIter
*iter
, gpointer user_data
)
1094 StashTreeValue
*value
;
1096 gtk_tree_model_get(model
, iter
, STASH_TREE_VALUE
, &value
, -1);
1097 /* don't access value->pref as it might already have been freed */
1098 g_free(value
->data
.tree_string
);
1105 static void stash_tree_destroy_cb(GtkWidget
*widget
, gpointer user_data
)
1107 GtkTreeModel
*model
= gtk_tree_view_get_model(GTK_TREE_VIEW(widget
));
1108 gtk_tree_model_foreach(model
, stash_tree_discard_value
, NULL
);
1112 static void stash_tree_append_pref(StashGroup
*group
, StashPref
*entry
, GtkListStore
*store
,
1116 StashTreeValue
*value
;
1118 value
= g_new0(StashTreeValue
, 1);
1120 value
->group_name
= group
->name
;
1121 value
->pref
= entry
;
1123 gtk_list_store_append(store
, &iter
);
1124 gtk_list_store_set(store
, &iter
, STASH_TREE_NAME
, entry
->key_name
,
1125 STASH_TREE_VALUE
, value
, -1);
1129 static void stash_tree_append_prefs(GPtrArray
*group_array
,
1130 GtkListStore
*store
, PrefAction action
)
1136 foreach_ptr_array(group
, i
, group_array
)
1140 foreach_ptr_array(entry
, j
, group
->entries
)
1141 stash_tree_append_pref(group
, entry
, store
, action
);
1147 /* Setups a simple editor for stash preferences based on the widget arguments.
1148 * group_array - Array of groups which's settings will be edited.
1149 * tree - GtkTreeView in which to edit the preferences. Must be empty. */
1150 void stash_tree_setup(GPtrArray
*group_array
, GtkTreeView
*tree
)
1152 GtkListStore
*store
;
1153 GtkTreeModel
*model
;
1154 GtkCellRenderer
*cell
;
1155 GtkTreeViewColumn
*column
;
1156 GtkAdjustment
*adjustment
;
1158 store
= gtk_list_store_new(STASH_TREE_COUNT
, G_TYPE_STRING
, G_TYPE_POINTER
);
1159 stash_tree_append_prefs(group_array
, store
, PREF_DISPLAY
);
1160 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store
), STASH_TREE_NAME
,
1161 GTK_SORT_ASCENDING
);
1163 model
= GTK_TREE_MODEL(store
);
1164 gtk_tree_view_set_model(tree
, model
);
1165 g_object_unref(G_OBJECT(store
));
1166 g_signal_connect(tree
, "destroy", G_CALLBACK(stash_tree_destroy_cb
), NULL
);
1168 cell
= gtk_cell_renderer_text_new();
1169 column
= gtk_tree_view_column_new_with_attributes(_("Name"), cell
, "text",
1170 STASH_TREE_NAME
, NULL
);
1171 gtk_tree_view_column_set_sort_column_id(column
, STASH_TREE_NAME
);
1172 gtk_tree_view_column_set_sort_indicator(column
, TRUE
);
1173 gtk_tree_view_append_column(tree
, column
);
1175 column
= gtk_tree_view_column_new();
1176 gtk_tree_view_column_set_title(column
, _("Value"));
1177 gtk_tree_view_append_column(tree
, column
);
1178 /* boolean renderer */
1179 cell
= gtk_cell_renderer_toggle_new();
1180 g_signal_connect(cell
, "toggled", G_CALLBACK(stash_tree_boolean_toggled
), model
);
1181 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column
), cell
, FALSE
);
1182 gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column
), cell
,
1183 stash_tree_renderer_set_data
, GSIZE_TO_POINTER(G_TYPE_BOOLEAN
), NULL
);
1184 /* string renderer */
1185 cell
= gtk_cell_renderer_text_new();
1186 g_object_set(cell
, "ellipsize", PANGO_ELLIPSIZE_END
, NULL
);
1187 g_signal_connect(cell
, "edited", G_CALLBACK(stash_tree_string_edited
), model
);
1188 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column
), cell
, TRUE
);
1189 gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column
), cell
,
1190 stash_tree_renderer_set_data
, GSIZE_TO_POINTER(G_TYPE_STRING
), NULL
);
1191 /* integer renderer */
1192 cell
= gtk_cell_renderer_spin_new();
1193 adjustment
= GTK_ADJUSTMENT(gtk_adjustment_new(0, G_MININT
, G_MAXINT
, 1, 10, 0));
1194 g_object_set(cell
, "adjustment", adjustment
, NULL
);
1195 g_signal_connect(cell
, "edited", G_CALLBACK(stash_tree_string_edited
), model
);
1196 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column
), cell
, FALSE
);
1197 gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column
), cell
,
1198 stash_tree_renderer_set_data
, GSIZE_TO_POINTER(G_TYPE_INT
), NULL
);
1202 static void stash_tree_display_pref(StashTreeValue
*value
, StashPref
*entry
)
1204 switch (entry
->setting_type
)
1206 case G_TYPE_BOOLEAN
:
1207 value
->data
.tree_int
= *(gboolean
*) entry
->setting
;
1210 value
->data
.tree_int
= *(gint
*) entry
->setting
;
1213 SETPTR(value
->data
.tree_string
, g_strdup(*(gchararray
*) entry
->setting
));
1216 g_warning("Unhandled type for %s::%s in %s()!", value
->group_name
,
1217 entry
->key_name
, G_STRFUNC
);
1222 static void stash_tree_update_pref(StashTreeValue
*value
, StashPref
*entry
)
1224 switch (entry
->setting_type
)
1226 case G_TYPE_BOOLEAN
:
1227 *(gboolean
*) entry
->setting
= value
->data
.tree_int
;
1230 *(gint
*) entry
->setting
= value
->data
.tree_int
;
1234 gchararray
*text
= entry
->setting
;
1235 SETPTR(*text
, g_strdup(value
->data
.tree_string
));
1239 g_warning("Unhandled type for %s::%s in %s()!", value
->group_name
,
1240 entry
->key_name
, G_STRFUNC
);
1245 static void stash_tree_action(GtkTreeModel
*model
, PrefAction action
)
1248 gboolean valid
= gtk_tree_model_get_iter_first(model
, &iter
);
1249 StashTreeValue
*value
;
1253 gtk_tree_model_get(model
, &iter
, STASH_TREE_VALUE
, &value
, -1);
1258 stash_tree_display_pref(value
, value
->pref
);
1261 stash_tree_update_pref(value
, value
->pref
);
1264 valid
= gtk_tree_model_iter_next(model
, &iter
);
1269 void stash_tree_display(GtkTreeView
*tree
)
1271 stash_tree_action(gtk_tree_view_get_model(tree
), PREF_DISPLAY
);
1275 void stash_tree_update(GtkTreeView
*tree
)
1277 stash_tree_action(gtk_tree_view_get_model(tree
), PREF_UPDATE
);