diff options
Diffstat (limited to 'libgimpwidgets/gimppropwidgets.c')
| -rw-r--r-- | libgimpwidgets/gimppropwidgets.c | 4352 |
1 files changed, 4352 insertions, 0 deletions
diff --git a/libgimpwidgets/gimppropwidgets.c b/libgimpwidgets/gimppropwidgets.c new file mode 100644 index 0000000..4304a9e --- /dev/null +++ b/libgimpwidgets/gimppropwidgets.c @@ -0,0 +1,4352 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball + * + * gimppropwidgets.c + * Copyright (C) 2002-2007 Michael Natterer <mitch@gimp.org> + * Sven Neumann <sven@gimp.org> + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <string.h> + +#include <gegl.h> +/* FIXME: #undef GTK_DISABLE_DEPRECATED */ +#undef GTK_DISABLE_DEPRECATED +#include <gtk/gtk.h> + +#include "libgimpcolor/gimpcolor.h" +#include "libgimpmath/gimpmath.h" +#include "libgimpbase/gimpbase.h" +#include "libgimpconfig/gimpconfig.h" + +#include "gimpwidgetstypes.h" + +#undef GIMP_DISABLE_DEPRECATED +#include "gimpoldwidgets.h" +#include "gimppropwidgets.h" +#include "gimpspinbutton.h" +#include "gimpunitmenu.h" + +#define GIMP_DISABLE_DEPRECATED +#include "gimpwidgets.h" + +#include "libgimp/libgimp-intl.h" + + +/** + * SECTION: gimppropwidgets + * @title: GimpPropWidgets + * @short_description: Editable views on #GObject properties. + * + * Editable views on #GObject properties. + **/ + + +/* utility function prototypes */ + +static void set_param_spec (GObject *object, + GtkWidget *widget, + GParamSpec *param_spec); +static void set_radio_spec (GObject *object, + GParamSpec *param_spec); +static GParamSpec * get_param_spec (GObject *object); + +static GParamSpec * find_param_spec (GObject *object, + const gchar *property_name, + const gchar *strloc); +static GParamSpec * check_param_spec (GObject *object, + const gchar *property_name, + GType type, + const gchar *strloc); +static GParamSpec * check_param_spec_w (GObject *object, + const gchar *property_name, + GType type, + const gchar *strloc); + +static gboolean get_numeric_values (GObject *object, + GParamSpec *param_spec, + gdouble *value, + gdouble *lower, + gdouble *upper, + const gchar *strloc); + +static void connect_notify (GObject *config, + const gchar *property_name, + GCallback callback, + gpointer callback_data); + + +/******************/ +/* check button */ +/******************/ + +static void gimp_prop_check_button_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_check_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button); + +/** + * gimp_prop_check_button_new: + * @config: Object to which property is attached. + * @property_name: Name of boolean property controlled by checkbutton. + * @label: Label to give checkbutton (including mnemonic). + * + * Creates a #GtkCheckButton that displays and sets the specified + * boolean property. + * If @label is #NULL, the @property_name's nick will be used as label + * of the returned button. + * + * Return value: The newly created #GtkCheckButton widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_check_button_new (GObject *config, + const gchar *property_name, + const gchar *label) +{ + GParamSpec *param_spec; + GtkWidget *button; + gboolean value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_BOOLEAN, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! label) + label = g_param_spec_get_nick (param_spec); + + g_object_get (config, + property_name, &value, + NULL); + + button = gtk_check_button_new_with_mnemonic (label); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), value); + + set_param_spec (G_OBJECT (button), button, param_spec); + + g_signal_connect (button, "toggled", + G_CALLBACK (gimp_prop_check_button_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_check_button_notify), + button); + + return button; +} + +static void +gimp_prop_check_button_callback (GtkWidget *widget, + GObject *config) +{ + GParamSpec *param_spec; + gboolean value; + gboolean v; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + value = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + { + g_object_set (config, param_spec->name, value, NULL); + + gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (widget)); + } +} + +static void +gimp_prop_check_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button) +{ + gboolean value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) != value) + { + g_signal_handlers_block_by_func (button, + gimp_prop_check_button_callback, + config); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), value); + gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (button)); + + g_signal_handlers_unblock_by_func (button, + gimp_prop_check_button_callback, + config); + } +} + + +static void gimp_prop_enum_check_button_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_enum_check_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button); + +/** + * gimp_prop_enum_check_button_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by checkbutton. + * @label: Label to give checkbutton (including mnemonic). + * @false_value: Enum value corresponding to unchecked state. + * @true_value: Enum value corresponding to checked state. + * + * Creates a #GtkCheckButton that displays and sets the specified + * property of type Enum. Note that this widget only allows two values + * for the enum, one corresponding to the "checked" state and the + * other to the "unchecked" state. + * If @label is #NULL, the @property_name's nick will be used as label + * of the returned button. + * + * Return value: The newly created #GtkCheckButton widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_enum_check_button_new (GObject *config, + const gchar *property_name, + const gchar *label, + gint false_value, + gint true_value) +{ + GParamSpec *param_spec; + GtkWidget *button; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! label) + label = g_param_spec_get_nick (param_spec); + + g_object_get (config, + property_name, &value, + NULL); + + button = gtk_check_button_new_with_mnemonic (label); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), + value == true_value); + + if (value != false_value && value != true_value) + gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); + + set_param_spec (G_OBJECT (button), button, param_spec); + + g_object_set_data (G_OBJECT (button), "false-value", + GINT_TO_POINTER (false_value)); + g_object_set_data (G_OBJECT (button), "true-value", + GINT_TO_POINTER (true_value)); + + g_signal_connect (button, "toggled", + G_CALLBACK (gimp_prop_enum_check_button_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_enum_check_button_notify), + button); + + return button; +} + +static void +gimp_prop_enum_check_button_callback (GtkWidget *widget, + GObject *config) +{ + GParamSpec *param_spec; + gint false_value; + gint true_value; + gint value; + gint v; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + false_value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + "false-value")); + true_value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + "true-value")); + + value = (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) ? + true_value : false_value); + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + { + g_object_set (config, param_spec->name, value, NULL); + + gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (widget), FALSE); + + gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (widget)); + } +} + +static void +gimp_prop_enum_check_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button) +{ + gint value; + gint false_value; + gint true_value; + gboolean active = FALSE; + gboolean inconsistent = FALSE; + + g_object_get (config, + param_spec->name, &value, + NULL); + + false_value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), + "false-value")); + true_value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), + "true-value")); + + if (value == true_value) + active = TRUE; + else if (value != false_value) + inconsistent = TRUE; + + gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), + inconsistent); + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) != active) + { + g_signal_handlers_block_by_func (button, + gimp_prop_enum_check_button_callback, + config); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active); + gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (button)); + + g_signal_handlers_unblock_by_func (button, + gimp_prop_enum_check_button_callback, + config); + } +} + + +/*************************/ +/* int/enum combo box */ +/*************************/ + +static void gimp_prop_int_combo_box_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_int_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *widget); + +static void gimp_prop_pointer_combo_box_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_pointer_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo_box); + +/** + * gimp_prop_int_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of int property controlled by combo box. + * @store: #GimpIntStore holding list of labels, values, etc. + * + * Creates a #GimpIntComboBox widget to display and set the specified + * property. The contents of the widget are determined by @store, + * which should be created using gimp_int_store_new(). + * + * Return value: The newly created #GimpIntComboBox widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_int_combo_box_new (GObject *config, + const gchar *property_name, + GimpIntStore *store) +{ + GParamSpec *param_spec; + GtkWidget *combo_box; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_INT, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX, + "model", store, + NULL); + + gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo_box), value); + + g_signal_connect (combo_box, "changed", + G_CALLBACK (gimp_prop_int_combo_box_callback), + config); + + set_param_spec (G_OBJECT (combo_box), combo_box, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_int_combo_box_notify), + combo_box); + + return combo_box; +} + +/** + * gimp_prop_pointer_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of GType/gpointer property controlled by combo box. + * @store: #GimpIntStore holding list of labels, values, etc. + * + * Creates a #GimpIntComboBox widget to display and set the specified + * property. The contents of the widget are determined by @store, + * which should be created using gimp_int_store_new(). + * Values are GType/gpointer data, and therefore must be stored in the + * "user-data" column, instead of the usual "value" column. + * + * Return value: The newly created #GimpIntComboBox widget. + * + * Since: 2.10 + */ +GtkWidget * +gimp_prop_pointer_combo_box_new (GObject *config, + const gchar *property_name, + GimpIntStore *store) +{ + GParamSpec *param_spec; + GtkWidget *combo_box; + gpointer property_value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_GTYPE, G_STRFUNC); + if (! param_spec) + { + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_POINTER, G_STRFUNC); + if (! param_spec) + return NULL; + } + + g_object_get (config, + property_name, &property_value, + NULL); + + /* We use a GimpIntComboBox but we cannot store gpointer in the + * "value" column, because gpointer is not a subset of gint. Instead + * we store the value in the "user-data" column which is a gpointer. + */ + combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX, + "model", store, + NULL); + + gimp_int_combo_box_set_active_by_user_data (GIMP_INT_COMBO_BOX (combo_box), + property_value); + + g_signal_connect (combo_box, "changed", + G_CALLBACK (gimp_prop_pointer_combo_box_callback), + config); + + set_param_spec (G_OBJECT (combo_box), combo_box, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_pointer_combo_box_notify), + combo_box); + + return combo_box; +} + +/** + * gimp_prop_enum_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by combo box. + * @minimum: Smallest allowed value of enum. + * @maximum: Largest allowed value of enum. + * + * Creates a #GimpIntComboBox widget to display and set the specified + * enum property. The @mimimum_value and @maximum_value give the + * possibility of restricting the allowed range to a subset of the + * enum. If the two values are equal (e.g., 0, 0), then the full + * range of the Enum is used. + * + * Return value: The newly created #GimpEnumComboBox widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_enum_combo_box_new (GObject *config, + const gchar *property_name, + gint minimum, + gint maximum) +{ + GParamSpec *param_spec; + GtkListStore *store = NULL; + GtkWidget *combo_box; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + if (minimum != maximum) + { + store = gimp_enum_store_new_with_range (param_spec->value_type, + minimum, maximum); + } + else if (param_spec->value_type == GIMP_TYPE_DESATURATE_MODE) + { + /* this is a bad hack, if we get more of those, we should probably + * think of something less ugly + */ + store = gimp_enum_store_new_with_values (param_spec->value_type, + 5, + GIMP_DESATURATE_LUMINANCE, + GIMP_DESATURATE_LUMA, + GIMP_DESATURATE_LIGHTNESS, + GIMP_DESATURATE_AVERAGE, + GIMP_DESATURATE_VALUE); + } + else if (param_spec->value_type == GIMP_TYPE_SELECT_CRITERION) + { + /* ditto */ + store = gimp_enum_store_new_with_values (param_spec->value_type, + 12, + GIMP_SELECT_CRITERION_COMPOSITE, + GIMP_SELECT_CRITERION_R, + GIMP_SELECT_CRITERION_G, + GIMP_SELECT_CRITERION_B, + GIMP_SELECT_CRITERION_A, + GIMP_SELECT_CRITERION_H, + GIMP_SELECT_CRITERION_S, + GIMP_SELECT_CRITERION_V, + GIMP_SELECT_CRITERION_LCH_L, + GIMP_SELECT_CRITERION_LCH_C, + GIMP_SELECT_CRITERION_LCH_H); + } + + if (store) + { + combo_box = g_object_new (GIMP_TYPE_ENUM_COMBO_BOX, + "model", store, + NULL); + g_object_unref (store); + } + else + { + combo_box = gimp_enum_combo_box_new (param_spec->value_type); + } + + gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo_box), value); + + g_signal_connect (combo_box, "changed", + G_CALLBACK (gimp_prop_int_combo_box_callback), + config); + + set_param_spec (G_OBJECT (combo_box), combo_box, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_int_combo_box_notify), + combo_box); + + return combo_box; +} + +static void +gimp_prop_int_combo_box_callback (GtkWidget *widget, + GObject *config) +{ + GParamSpec *param_spec; + gint value; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value)) + { + gint v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); + } +} + +static void +gimp_prop_int_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo_box) +{ + gint value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (combo_box, + gimp_prop_int_combo_box_callback, + config); + + gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo_box), value); + + g_signal_handlers_unblock_by_func (combo_box, + gimp_prop_int_combo_box_callback, + config); +} + +static void +gimp_prop_pointer_combo_box_callback (GtkWidget *widget, + GObject *config) +{ + GParamSpec *param_spec; + gpointer value; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + if (gimp_int_combo_box_get_active_user_data (GIMP_INT_COMBO_BOX (widget), + &value)) + { + gpointer v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); + } +} + +static void +gimp_prop_pointer_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo_box) +{ + gpointer value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (combo_box, + gimp_prop_pointer_combo_box_callback, + config); + + gimp_int_combo_box_set_active_by_user_data (GIMP_INT_COMBO_BOX (combo_box), + value); + + g_signal_handlers_unblock_by_func (combo_box, + gimp_prop_pointer_combo_box_callback, + config); +} + +/************************/ +/* boolean combo box */ +/************************/ + +static void gimp_prop_boolean_combo_box_callback (GtkWidget *combo, + GObject *config); +static void gimp_prop_boolean_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo); + + +/** + * gimp_prop_boolean_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of boolean property controlled by combo box. + * @true_text: Label used for entry corresponding to %TRUE value. + * @false_text: Label used for entry corresponding to %FALSE value. + * + * Creates a #GtkComboBox widget to display and set the specified + * boolean property. The combo box will have two entries, one + * displaying the @true_text label, the other displaying the + * @false_text label. + * + * Return value: The newly created #GtkComboBox widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_boolean_combo_box_new (GObject *config, + const gchar *property_name, + const gchar *true_text, + const gchar *false_text) +{ + GParamSpec *param_spec; + GtkWidget *combo; + gboolean value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_BOOLEAN, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + combo = gimp_int_combo_box_new (true_text, TRUE, + false_text, FALSE, + NULL); + + gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), value); + + g_signal_connect (combo, "changed", + G_CALLBACK (gimp_prop_boolean_combo_box_callback), + config); + + set_param_spec (G_OBJECT (combo), combo, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_boolean_combo_box_notify), + combo); + + return combo; +} + +static void +gimp_prop_boolean_combo_box_callback (GtkWidget *combo, + GObject *config) +{ + GParamSpec *param_spec; + gint value; + + param_spec = get_param_spec (G_OBJECT (combo)); + if (! param_spec) + return; + + if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &value)) + { + gint v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); + } +} + +static void +gimp_prop_boolean_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo) +{ + gboolean value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (combo, + gimp_prop_boolean_combo_box_callback, + config); + + gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), value); + + g_signal_handlers_unblock_by_func (combo, + gimp_prop_boolean_combo_box_callback, + config); +} + + +/*****************/ +/* radio boxes */ +/*****************/ + +static void gimp_prop_radio_button_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_radio_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button); + + +/** + * gimp_prop_enum_radio_frame_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by the radio buttons. + * @title: Label for the frame holding the buttons + * @minimum: Smallest value of enum to be included. + * @maximum: Largest value of enum to be included. + * + * Creates a group of radio buttons which function to set and display + * the specified enum property. The @minimum and @maximum arguments + * allow only a subset of the enum to be used. If the two arguments + * are equal (e.g., 0, 0), then the full range of the enum will be used. + * If @title is #NULL, the @property_name's nick will be used as label + * of the returned frame. + * + * Return value: A #GimpFrame containing the radio buttons. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_enum_radio_frame_new (GObject *config, + const gchar *property_name, + const gchar *title, + gint minimum, + gint maximum) +{ + GParamSpec *param_spec; + GtkWidget *frame; + GtkWidget *button; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! title) + title = g_param_spec_get_nick (param_spec); + + g_object_get (config, + property_name, &value, + NULL); + + if (minimum != maximum) + { + frame = gimp_enum_radio_frame_new_with_range (param_spec->value_type, + minimum, maximum, + gtk_label_new (title), + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + else + { + frame = gimp_enum_radio_frame_new (param_spec->value_type, + gtk_label_new (title), + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + + gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), value); + + set_radio_spec (G_OBJECT (button), param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_radio_button_notify), + button); + + g_object_set_data (G_OBJECT (frame), "radio-button", button); + + return frame; +} + +/** + * gimp_prop_enum_radio_box_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by the radio buttons. + * @minimum: Smallest value of enum to be included. + * @maximum: Largest value of enum to be included. + * + * Creates a group of radio buttons which function to set and display + * the specified enum property. The @minimum and @maximum arguments + * allow only a subset of the enum to be used. If the two arguments + * are equal (e.g., 0, 0), then the full range of the enum will be used. + * If you want to assign a label to the group of radio buttons, use + * gimp_prop_enum_radio_frame_new() instead of this function. + * + * Return value: A #GtkVBox containing the radio buttons. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_enum_radio_box_new (GObject *config, + const gchar *property_name, + gint minimum, + gint maximum) +{ + GParamSpec *param_spec; + GtkWidget *vbox; + GtkWidget *button; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + if (minimum != maximum) + { + vbox = gimp_enum_radio_box_new_with_range (param_spec->value_type, + minimum, maximum, + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + else + { + vbox = gimp_enum_radio_box_new (param_spec->value_type, + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + + gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), value); + + set_radio_spec (G_OBJECT (button), param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_radio_button_notify), + button); + + g_object_set_data (G_OBJECT (vbox), "radio-button", button); + + return vbox; +} + + +/***********/ +/* label */ +/***********/ + +static void gimp_prop_enum_label_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *label); + +/** + * gimp_prop_enum_label_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property to be displayed. + * + * Return value: The newly created #GimpEnumLabel widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_enum_label_new (GObject *config, + const gchar *property_name) +{ + GParamSpec *param_spec; + GtkWidget *label; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + label = gimp_enum_label_new (param_spec->value_type, value); + + set_param_spec (G_OBJECT (label), label, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_enum_label_notify), + label); + + return label; +} + +static void +gimp_prop_enum_label_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *label) +{ + gint value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + gimp_enum_label_set_value (GIMP_ENUM_LABEL (label), value); +} + + +/** + * gimp_prop_boolean_radio_frame_new: + * @config: Object to which property is attached. + * @property_name: Name of boolean property controlled by the radio buttons. + * @title: Label for the frame. + * @true_text: Label for the button corresponding to %TRUE. + * @false_text: Label for the button corresponding to %FALSE. + * + * Creates a pair of radio buttons which function to set and display + * the specified boolean property. + * If @title is #NULL, the @property_name's nick will be used as label + * of the returned frame. + * + * Return value: A #GimpFrame containing the radio buttons. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_boolean_radio_frame_new (GObject *config, + const gchar *property_name, + const gchar *title, + const gchar *true_text, + const gchar *false_text) +{ + GParamSpec *param_spec; + GtkWidget *frame; + GtkWidget *button; + gboolean value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_BOOLEAN, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! title) + title = g_param_spec_get_nick (param_spec); + + g_object_get (config, + property_name, &value, + NULL); + + frame = + gimp_int_radio_group_new (TRUE, title, + G_CALLBACK (gimp_prop_radio_button_callback), + config, value, + + false_text, FALSE, &button, + true_text, TRUE, NULL, + + NULL); + + set_radio_spec (G_OBJECT (button), param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_radio_button_notify), + button); + + g_object_set_data (G_OBJECT (frame), "radio-button", button); + + return frame; +} + +/** + * gimp_prop_enum_stock_box_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by the radio buttons. + * @stock_prefix: The prefix of the group of stock ids to use. + * @minimum: Smallest value of enum to be included. + * @maximum: Largest value of enum to be included. + * + * Creates a horizontal box of radio buttons with stock icons, which + * function to set and display the value of the specified Enum + * property. The stock_id for each icon is created by appending the + * enum_value's nick to the given @stock_prefix. See + * gimp_enum_stock_box_new() for more information. + * + * Return value: A #libgimpwidgets-gimpenumstockbox containing the radio buttons. + * + * Since: 2.4 + * + * Deprecated: 2.10 + */ +GtkWidget * +gimp_prop_enum_stock_box_new (GObject *config, + const gchar *property_name, + const gchar *stock_prefix, + gint minimum, + gint maximum) +{ + return gimp_prop_enum_icon_box_new (config, property_name, + stock_prefix, minimum, maximum); +} + +/** + * gimp_prop_enum_icon_box_new: + * @config: Object to which property is attached. + * @property_name: Name of enum property controlled by the radio buttons. + * @icon_prefix: The prefix of the group of icon names to use. + * @minimum: Smallest value of enum to be included. + * @maximum: Largest value of enum to be included. + * + * Creates a horizontal box of radio buttons with named icons, which + * function to set and display the value of the specified Enum + * property. The icon name for each icon is created by appending the + * enum_value's nick to the given @icon_prefix. See + * gimp_enum_icon_box_new() for more information. + * + * Return value: A #libgimpwidgets-gimpenumiconbox containing the radio buttons. + * + * Since: 2.10 + */ +GtkWidget * +gimp_prop_enum_icon_box_new (GObject *config, + const gchar *property_name, + const gchar *icon_prefix, + gint minimum, + gint maximum) +{ + GParamSpec *param_spec; + GtkWidget *box; + GtkWidget *button; + gint value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_ENUM, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + if (minimum != maximum) + { + box = gimp_enum_icon_box_new_with_range (param_spec->value_type, + minimum, maximum, + icon_prefix, + GTK_ICON_SIZE_MENU, + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + else + { + box = gimp_enum_icon_box_new (param_spec->value_type, + icon_prefix, + GTK_ICON_SIZE_MENU, + G_CALLBACK (gimp_prop_radio_button_callback), + config, + &button); + } + + gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), value); + + set_radio_spec (G_OBJECT (button), param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_radio_button_notify), + button); + + return box; +} + +static void +gimp_prop_radio_button_callback (GtkWidget *widget, + GObject *config) +{ + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) + { + GParamSpec *param_spec; + gint value; + gint v; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + "gimp-item-data")); + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); + } +} + +static void +gimp_prop_radio_button_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *button) +{ + gint value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), value); +} + + +/*****************/ +/* adjustments */ +/*****************/ + +static void gimp_prop_adjustment_callback (GtkAdjustment *adjustment, + GObject *config); +static void gimp_prop_adjustment_notify (GObject *config, + GParamSpec *param_spec, + GtkAdjustment *adjustment); + +/** + * gimp_prop_spin_button_new: + * @config: Object to which property is attached. + * @property_name: Name of double property controlled by the spin button. + * @step_increment: Step size. + * @page_increment: Page size. + * @digits: Number of digits after decimal point to display. + * + * Creates a spin button to set and display the value of the + * specified double property. + * + * Return value: A new #libgimpwidgets-gimpspinbutton. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_spin_button_new (GObject *config, + const gchar *property_name, + gdouble step_increment, + gdouble page_increment, + gint digits) +{ + GParamSpec *param_spec; + GtkWidget *spinbutton; + GtkAdjustment *adjustment; + gdouble value; + gdouble lower; + gdouble upper; + + param_spec = find_param_spec (config, property_name, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! get_numeric_values (config, + param_spec, &value, &lower, &upper, G_STRFUNC)) + return NULL; + + if (! G_IS_PARAM_SPEC_DOUBLE (param_spec)) + digits = 0; + + adjustment = (GtkAdjustment *) + gtk_adjustment_new (value, lower, upper, + step_increment, page_increment, 0); + + spinbutton = gimp_spin_button_new (adjustment, step_increment, digits); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + + set_param_spec (G_OBJECT (adjustment), spinbutton, param_spec); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_prop_adjustment_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_adjustment_notify), + adjustment); + + return spinbutton; +} + +/** + * gimp_prop_hscale_new: + * @config: Object to which property is attached. + * @property_name: Name of integer or double property controlled by the scale. + * @step_increment: Step size. + * @page_increment: Page size. + * @digits: Number of digits after decimal point to display. + * + * Creates a horizontal scale to control the value of the specified + * integer or double property. + * + * Return value: A new #GtkScale. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_hscale_new (GObject *config, + const gchar *property_name, + gdouble step_increment, + gdouble page_increment, + gint digits) +{ + GParamSpec *param_spec; + GtkWidget *scale; + GtkAdjustment *adjustment; + gdouble value; + gdouble lower; + gdouble upper; + + param_spec = find_param_spec (config, property_name, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! get_numeric_values (config, + param_spec, &value, &lower, &upper, G_STRFUNC)) + return NULL; + + if (! G_IS_PARAM_SPEC_DOUBLE (param_spec)) + digits = 0; + + adjustment = (GtkAdjustment *) + gtk_adjustment_new (value, lower, upper, + step_increment, page_increment, 0.0); + + scale = g_object_new (GTK_TYPE_SCALE, + "orientation", GTK_ORIENTATION_HORIZONTAL, + "adjustment", adjustment, + "digits", digits, + NULL); + + set_param_spec (G_OBJECT (adjustment), scale, param_spec); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_prop_adjustment_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_adjustment_notify), + adjustment); + + return scale; +} + +/** + * gimp_prop_scale_entry_new: + * @config: Object to which property is attached. + * @property_name: Name of double property controlled by the spin button. + * @table: The #GtkTable the widgets will be attached to. + * @column: The column to start with. + * @row: The row to attach the widgets. + * @label: The text for the #GtkLabel which will appear left of + * the #GtkHScale. + * @step_increment: Step size. + * @page_increment: Page size. + * @digits: Number of digits after decimal point to display. + * @limit_scale: %FALSE if the range of possible values of the + * GtkHScale should be the same as of the GtkSpinButton. + * @lower_limit: The scale's lower boundary if @scale_limits is %TRUE. + * @upper_limit: The scale's upper boundary if @scale_limits is %TRUE. + * + * Creates a #libgimpwidgets-gimpscaleentry (slider and spin button) + * to set and display the value of the specified double property. See + * gimp_scale_entry_new() for more information. + * If @label is #NULL, the @property_name's nick will be used as label + * of the returned object. + * + * Note that the @scale_limits boolean is the inverse of + * gimp_scale_entry_new()'s "constrain" parameter. + * + * Return value: The #GtkSpinButton's #GtkAdjustment. + * + * Since: 2.4 + */ +GtkObject * +gimp_prop_scale_entry_new (GObject *config, + const gchar *property_name, + GtkTable *table, + gint column, + gint row, + const gchar *label, + gdouble step_increment, + gdouble page_increment, + gint digits, + gboolean limit_scale, + gdouble lower_limit, + gdouble upper_limit) +{ + GParamSpec *param_spec; + GtkObject *adjustment; + const gchar *tooltip; + gdouble value; + gdouble lower; + gdouble upper; + + param_spec = find_param_spec (config, property_name, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! get_numeric_values (config, + param_spec, &value, &lower, &upper, G_STRFUNC)) + return NULL; + + if (! label) + label = g_param_spec_get_nick (param_spec); + + tooltip = g_param_spec_get_blurb (param_spec); + + if (! limit_scale) + { + adjustment = gimp_scale_entry_new (table, column, row, + label, -1, -1, + value, lower, upper, + step_increment, page_increment, + digits, + TRUE, 0.0, 0.0, + tooltip, + NULL); + } + else + { + adjustment = gimp_scale_entry_new (table, column, row, + label, -1, -1, + value, lower_limit, upper_limit, + step_increment, page_increment, + digits, + FALSE, lower, upper, + tooltip, + NULL); + } + + set_param_spec (G_OBJECT (adjustment), NULL, param_spec); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_prop_adjustment_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_adjustment_notify), + adjustment); + + return adjustment; +} + +static void +gimp_prop_widget_set_factor (GtkWidget *widget, + GtkAdjustment *adjustment, + gdouble factor, + gdouble step_increment, + gdouble page_increment, + gint digits) +{ + gdouble *factor_store; + gdouble old_factor = 1.0; + gdouble f; + + g_return_if_fail (widget == NULL || GTK_IS_SPIN_BUTTON (widget)); + g_return_if_fail (widget != NULL || GTK_IS_ADJUSTMENT (adjustment)); + g_return_if_fail (factor != 0.0); + g_return_if_fail (digits >= 0); + + if (! adjustment) + adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); + + g_return_if_fail (get_param_spec (G_OBJECT (adjustment)) != NULL); + + factor_store = g_object_get_data (G_OBJECT (adjustment), + "gimp-prop-adjustment-factor"); + if (factor_store) + { + old_factor = *factor_store; + } + else + { + factor_store = g_new (gdouble, 1); + g_object_set_data_full (G_OBJECT (adjustment), + "gimp-prop-adjustment-factor", + factor_store, (GDestroyNotify) g_free); + } + + *factor_store = factor; + + f = factor / old_factor; + + if (step_increment <= 0) + step_increment = f * gtk_adjustment_get_step_increment (adjustment); + + if (page_increment <= 0) + page_increment = f * gtk_adjustment_get_page_increment (adjustment); + + gtk_adjustment_configure (adjustment, + f * gtk_adjustment_get_value (adjustment), + f * gtk_adjustment_get_lower (adjustment), + f * gtk_adjustment_get_upper (adjustment), + step_increment, + page_increment, + f * gtk_adjustment_get_page_size (adjustment)); + + gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits); +} + +/** + * gimp_prop_opacity_entry_new: + * @config: Object to which property is attached. + * @property_name: Name of double property controlled by the spin button. + * @table: The #GtkTable the widgets will be attached to. + * @column: The column to start with. + * @row: The row to attach the widgets. + * @label: The text for the #GtkLabel which will appear left of the + * #GtkHScale. + * + * Creates a #libgimpwidgets-gimpscaleentry (slider and spin button) + * to set and display the value of the specified double property, + * which should represent an "opacity" variable with range 0 to 100. + * See gimp_scale_entry_new() for more information. + * + * Return value: The #GtkSpinButton's #GtkAdjustment. + * + * Since: 2.4 + */ +GtkObject * +gimp_prop_opacity_entry_new (GObject *config, + const gchar *property_name, + GtkTable *table, + gint column, + gint row, + const gchar *label) +{ + GtkObject *adjustment; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + adjustment = gimp_prop_scale_entry_new (config, property_name, + table, column, row, label, + 0.01, 0.1, 1, + FALSE, 0.0, 0.0); + + if (adjustment) + { + gimp_prop_widget_set_factor (GIMP_SCALE_ENTRY_SPINBUTTON (adjustment), + GTK_ADJUSTMENT (adjustment), + 100.0, 0.0, 0.0, 1); + } + + return adjustment; +} + + +static void +gimp_prop_adjustment_callback (GtkAdjustment *adjustment, + GObject *config) +{ + GParamSpec *param_spec; + gdouble value; + gdouble *factor; + + param_spec = get_param_spec (G_OBJECT (adjustment)); + if (! param_spec) + return; + + value = gtk_adjustment_get_value (adjustment); + + factor = g_object_get_data (G_OBJECT (adjustment), + "gimp-prop-adjustment-factor"); + if (factor) + value /= *factor; + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + gint v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (gint) value) + g_object_set (config, param_spec->name, (gint) value, NULL); + } + else if (G_IS_PARAM_SPEC_UINT (param_spec)) + { + guint v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (guint) value) + g_object_set (config, param_spec->name, (guint) value, NULL); + } + else if (G_IS_PARAM_SPEC_LONG (param_spec)) + { + glong v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (glong) value) + g_object_set (config, param_spec->name, (glong) value, NULL); + } + else if (G_IS_PARAM_SPEC_ULONG (param_spec)) + { + gulong v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (gulong) value) + g_object_set (config, param_spec->name, (gulong) value, NULL); + } + else if (G_IS_PARAM_SPEC_INT64 (param_spec)) + { + gint64 v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (gint64) value) + g_object_set (config, param_spec->name, (gint64) value, NULL); + } + else if (G_IS_PARAM_SPEC_UINT64 (param_spec)) + { + guint64 v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != (guint64) value) + g_object_set (config, param_spec->name, (guint64) value, NULL); + } + else if (G_IS_PARAM_SPEC_DOUBLE (param_spec)) + { + gdouble v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); + } +} + +static void +gimp_prop_adjustment_notify (GObject *config, + GParamSpec *param_spec, + GtkAdjustment *adjustment) +{ + gdouble value; + gdouble *factor; + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + gint int_value; + + g_object_get (config, param_spec->name, &int_value, NULL); + + value = int_value; + } + else if (G_IS_PARAM_SPEC_UINT (param_spec)) + { + guint uint_value; + + g_object_get (config, param_spec->name, &uint_value, NULL); + + value = uint_value; + } + else if (G_IS_PARAM_SPEC_LONG (param_spec)) + { + glong long_value; + + g_object_get (config, param_spec->name, &long_value, NULL); + + value = long_value; + } + else if (G_IS_PARAM_SPEC_ULONG (param_spec)) + { + gulong ulong_value; + + g_object_get (config, param_spec->name, &ulong_value, NULL); + + value = ulong_value; + } + else if (G_IS_PARAM_SPEC_INT64 (param_spec)) + { + gint64 int64_value; + + g_object_get (config, param_spec->name, &int64_value, NULL); + + value = int64_value; + } + else if (G_IS_PARAM_SPEC_UINT64 (param_spec)) + { + guint64 uint64_value; + + g_object_get (config, param_spec->name, &uint64_value, NULL); + +#if defined _MSC_VER && (_MSC_VER < 1300) + value = (gint64) uint64_value; +#else + value = uint64_value; +#endif + } + else if (G_IS_PARAM_SPEC_DOUBLE (param_spec)) + { + g_object_get (config, param_spec->name, &value, NULL); + } + else + { + g_warning ("%s: unhandled param spec of type %s", + G_STRFUNC, G_PARAM_SPEC_TYPE_NAME (param_spec)); + return; + } + + factor = g_object_get_data (G_OBJECT (adjustment), + "gimp-prop-adjustment-factor"); + if (factor) + value *= *factor; + + if (gtk_adjustment_get_value (adjustment) != value) + { + g_signal_handlers_block_by_func (adjustment, + gimp_prop_adjustment_callback, + config); + + gtk_adjustment_set_value (adjustment, value); + + g_signal_handlers_unblock_by_func (adjustment, + gimp_prop_adjustment_callback, + config); + } +} + + +/*************/ +/* memsize */ +/*************/ + +static void gimp_prop_memsize_callback (GimpMemsizeEntry *entry, + GObject *config); +static void gimp_prop_memsize_notify (GObject *config, + GParamSpec *param_spec, + GimpMemsizeEntry *entry); + +/** + * gimp_prop_memsize_entry_new: + * @config: Object to which property is attached. + * @property_name: Name of memsize property. + * + * Creates a #GimpMemsizeEntry (spin button and option menu) to set + * and display the value of the specified memsize property. See + * gimp_memsize_entry_new() for more information. + * + * Return value: A new #GimpMemsizeEntry. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_memsize_entry_new (GObject *config, + const gchar *property_name) +{ + GParamSpec *param_spec; + GParamSpecUInt64 *uint64_spec; + GtkWidget *entry; + guint64 value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_MEMSIZE, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + uint64_spec = G_PARAM_SPEC_UINT64 (param_spec); + + g_return_val_if_fail (uint64_spec->minimum <= GIMP_MAX_MEMSIZE, NULL); + g_return_val_if_fail (uint64_spec->maximum <= GIMP_MAX_MEMSIZE, NULL); + + entry = gimp_memsize_entry_new (value, + uint64_spec->minimum, + uint64_spec->maximum); + + set_param_spec (G_OBJECT (entry), + GIMP_MEMSIZE_ENTRY (entry)->spinbutton, + param_spec); + + g_signal_connect (entry, "value-changed", + G_CALLBACK (gimp_prop_memsize_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_memsize_notify), + entry); + + return entry; +} + + +static void +gimp_prop_memsize_callback (GimpMemsizeEntry *entry, + GObject *config) +{ + GParamSpec *param_spec; + guint64 value; + guint64 v; + + param_spec = get_param_spec (G_OBJECT (entry)); + if (! param_spec) + return; + + g_return_if_fail (G_IS_PARAM_SPEC_UINT64 (param_spec)); + + value = gimp_memsize_entry_get_value (entry); + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + g_object_set (config, param_spec->name, value, NULL); +} + +static void +gimp_prop_memsize_notify (GObject *config, + GParamSpec *param_spec, + GimpMemsizeEntry *entry) +{ + guint64 value; + + g_return_if_fail (G_IS_PARAM_SPEC_UINT64 (param_spec)); + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (entry->value != value) + { + g_signal_handlers_block_by_func (entry, + gimp_prop_memsize_callback, + config); + + gimp_memsize_entry_set_value (entry, value); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_memsize_callback, + config); + } +} + + +/***********/ +/* label */ +/***********/ + +static void gimp_prop_label_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *label); + +/** + * gimp_prop_label_new: + * @config: Object to which property is attached. + * @property_name: Name of string property. + * + * Creates a #GtkLabel to display the value of the specified property. + * The property should be a string property or at least transformable + * to a string. If the user should be able to edit the string, use + * gimp_prop_entry_new() instead. + * + * Return value: A new #GtkLabel widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_label_new (GObject *config, + const gchar *property_name) +{ + GParamSpec *param_spec; + GtkWidget *label; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = find_param_spec (config, property_name, G_STRFUNC); + + if (! param_spec) + return NULL; + + if (! g_value_type_transformable (param_spec->value_type, G_TYPE_STRING)) + { + g_warning ("%s: property '%s' of %s is not transformable to string", + G_STRLOC, + param_spec->name, + g_type_name (param_spec->owner_type)); + return NULL; + } + + label = gtk_label_new (NULL); + + set_param_spec (G_OBJECT (label), label, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_label_notify), + label); + + gimp_prop_label_notify (config, param_spec, label); + + return label; +} + +static void +gimp_prop_label_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *label) +{ + GValue value = G_VALUE_INIT; + + g_value_init (&value, param_spec->value_type); + + g_object_get_property (config, param_spec->name, &value); + + if (G_VALUE_HOLDS_STRING (&value)) + { + const gchar *str = g_value_get_string (&value); + + gtk_label_set_text (GTK_LABEL (label), str ? str : ""); + } + else + { + GValue str_value = G_VALUE_INIT; + const gchar *str; + + g_value_init (&str_value, G_TYPE_STRING); + g_value_transform (&value, &str_value); + + str = g_value_get_string (&str_value); + + gtk_label_set_text (GTK_LABEL (label), str ? str : ""); + + g_value_unset (&str_value); + } + + g_value_unset (&value); +} + + +/***********/ +/* entry */ +/***********/ + +static void gimp_prop_entry_callback (GtkWidget *entry, + GObject *config); +static void gimp_prop_entry_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *entry); + +/** + * gimp_prop_entry_new: + * @config: Object to which property is attached. + * @property_name: Name of string property. + * @max_len: Maximum allowed length of string. + * + * Creates a #GtkEntry to set and display the value of the specified + * string property. + * + * Return value: A new #GtkEntry widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_entry_new (GObject *config, + const gchar *property_name, + gint max_len) +{ + GParamSpec *param_spec; + GtkWidget *entry; + gchar *value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec (config, property_name, + G_TYPE_PARAM_STRING, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + entry = gtk_entry_new (); + gtk_entry_set_text (GTK_ENTRY (entry), value ? value : ""); + + g_free (value); + + if (max_len > 0) + gtk_entry_set_max_length (GTK_ENTRY (entry), max_len); + + gtk_editable_set_editable (GTK_EDITABLE (entry), + param_spec->flags & G_PARAM_WRITABLE); + + set_param_spec (G_OBJECT (entry), entry, param_spec); + + g_signal_connect (entry, "changed", + G_CALLBACK (gimp_prop_entry_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_entry_notify), + entry); + + return entry; +} + +static void +gimp_prop_entry_callback (GtkWidget *entry, + GObject *config) +{ + GParamSpec *param_spec; + const gchar *value; + gchar *v; + + param_spec = get_param_spec (G_OBJECT (entry)); + if (! param_spec) + return; + + value = gtk_entry_get_text (GTK_ENTRY (entry)); + + g_object_get (config, param_spec->name, &v, NULL); + + if (g_strcmp0 (v, value)) + { + g_signal_handlers_block_by_func (config, + gimp_prop_entry_notify, + entry); + + g_object_set (config, param_spec->name, value, NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_entry_notify, + entry); + } + + g_free (v); +} + +static void +gimp_prop_entry_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *entry) +{ + gchar *value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (entry, + gimp_prop_entry_callback, + config); + + gtk_entry_set_text (GTK_ENTRY (entry), value ? value : ""); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_entry_callback, + config); + + g_free (value); +} + + +/*****************/ +/* text buffer */ +/*****************/ + +static void gimp_prop_text_buffer_callback (GtkTextBuffer *text_buffer, + GObject *config); +static void gimp_prop_text_buffer_notify (GObject *config, + GParamSpec *param_spec, + GtkTextBuffer *text_buffer); + +/** + * gimp_prop_text_buffer_new: + * @config: Object to which property is attached. + * @property_name: Name of string property. + * @max_len: Maximum allowed length of text (in characters). + * + * Creates a #GtkTextBuffer to set and display the value of the + * specified string property. Unless the string is expected to + * contain multiple lines or a large amount of text, use + * gimp_prop_entry_new() instead. See #GtkTextView for information on + * how to insert a text buffer into a visible widget. + * + * If @max_len is 0 or negative, the text buffer allows an unlimited + * number of characters to be entered. + * + * Return value: A new #GtkTextBuffer. + * + * Since: 2.4 + */ +GtkTextBuffer * +gimp_prop_text_buffer_new (GObject *config, + const gchar *property_name, + gint max_len) +{ + GParamSpec *param_spec; + GtkTextBuffer *text_buffer; + gchar *value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_STRING, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + text_buffer = gtk_text_buffer_new (NULL); + gtk_text_buffer_set_text (text_buffer, value ? value : "", -1); + + g_free (value); + + if (max_len > 0) + g_object_set_data (G_OBJECT (text_buffer), "max-len", + GINT_TO_POINTER (max_len)); + + set_param_spec (G_OBJECT (text_buffer), NULL, param_spec); + + g_signal_connect (text_buffer, "changed", + G_CALLBACK (gimp_prop_text_buffer_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_text_buffer_notify), + text_buffer); + + return text_buffer; +} + +static void +gimp_prop_text_buffer_callback (GtkTextBuffer *text_buffer, + GObject *config) +{ + GParamSpec *param_spec; + GtkTextIter start_iter; + GtkTextIter end_iter; + gchar *text; + gint max_len; + + param_spec = get_param_spec (G_OBJECT (text_buffer)); + if (! param_spec) + return; + + gtk_text_buffer_get_bounds (text_buffer, &start_iter, &end_iter); + text = gtk_text_buffer_get_text (text_buffer, &start_iter, &end_iter, FALSE); + + max_len = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (text_buffer), + "max-length")); + + if (max_len > 0 && g_utf8_strlen (text, -1) > max_len) + { + g_message (dngettext (GETTEXT_PACKAGE "-libgimp", + "This text input field is limited to %d character.", + "This text input field is limited to %d characters.", + max_len), max_len); + + gtk_text_buffer_get_iter_at_offset (text_buffer, + &start_iter, max_len - 1); + gtk_text_buffer_get_end_iter (text_buffer, &end_iter); + + /* this calls us recursively, but in the else branch */ + gtk_text_buffer_delete (text_buffer, &start_iter, &end_iter); + } + else + { + gchar *v; + + g_object_get (config, param_spec->name, &v, NULL); + + if (g_strcmp0 (v, text)) + { + g_signal_handlers_block_by_func (config, + gimp_prop_text_buffer_notify, + text_buffer); + + g_object_set (config, param_spec->name, text, NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_text_buffer_notify, + text_buffer); + } + + g_free (v); + } + + g_free (text); +} + +static void +gimp_prop_text_buffer_notify (GObject *config, + GParamSpec *param_spec, + GtkTextBuffer *text_buffer) +{ + gchar *value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (text_buffer, + gimp_prop_text_buffer_callback, + config); + + gtk_text_buffer_set_text (text_buffer, value ? value : "", -1); + + g_signal_handlers_unblock_by_func (text_buffer, + gimp_prop_text_buffer_callback, + config); + + g_free (value); +} + + +/***********************/ +/* string combo box */ +/***********************/ + +static void gimp_prop_string_combo_box_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_string_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *widget); + +/** + * gimp_prop_string_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of int property controlled by combo box. + * @model: #GtkTreeStore holding list of values + * @id_column: column in @store that holds string IDs + * @label_column: column in @store that holds labels to use in the combo-box + * + * Creates a #GimpStringComboBox widget to display and set the + * specified property. The contents of the widget are determined by + * @store. + * + * Return value: The newly created #GimpStringComboBox widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_string_combo_box_new (GObject *config, + const gchar *property_name, + GtkTreeModel *model, + gint id_column, + gint label_column) +{ + GParamSpec *param_spec; + GtkWidget *combo_box; + gchar *value; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL); + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_STRING, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + combo_box = gimp_string_combo_box_new (model, id_column, label_column); + + gimp_string_combo_box_set_active (GIMP_STRING_COMBO_BOX (combo_box), value); + + g_signal_connect (combo_box, "changed", + G_CALLBACK (gimp_prop_string_combo_box_callback), + config); + + set_param_spec (G_OBJECT (combo_box), combo_box, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_string_combo_box_notify), + combo_box); + + return combo_box; +} + +static void +gimp_prop_string_combo_box_callback (GtkWidget *widget, + GObject *config) +{ + GParamSpec *param_spec; + gchar *value; + gchar *v; + + param_spec = get_param_spec (G_OBJECT (widget)); + if (! param_spec) + return; + + value = gimp_string_combo_box_get_active (GIMP_STRING_COMBO_BOX (widget)); + + g_object_get (config, param_spec->name, &v, NULL); + + if (g_strcmp0 (v, value)) + g_object_set (config, param_spec->name, value, NULL); + + g_free (value); + g_free (v); +} + +static void +gimp_prop_string_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo_box) +{ + gchar *value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (combo_box, + gimp_prop_string_combo_box_callback, + config); + + gimp_string_combo_box_set_active (GIMP_STRING_COMBO_BOX (combo_box), value); + + g_signal_handlers_unblock_by_func (combo_box, + gimp_prop_string_combo_box_callback, + config); + + g_free (value); +} + + +/*************************/ +/* file chooser button */ +/*************************/ + + +static GtkWidget * gimp_prop_file_chooser_button_setup (GtkWidget *button, + GObject *config, + GParamSpec *param_spec); +static void gimp_prop_file_chooser_button_callback (GtkFileChooser *button, + GObject *config); +static void gimp_prop_file_chooser_button_notify (GObject *config, + GParamSpec *param_spec, + GtkFileChooser *button); + + +/** + * gimp_prop_file_chooser_button_new: + * @config: object to which property is attached. + * @property_name: name of path property. + * @title: the title of the browse dialog. + * @action: the open mode for the widget. + * + * Creates a #GtkFileChooserButton to edit the specified path property. + * + * Note that #GtkFileChooserButton implements the #GtkFileChooser + * interface; you can use the #GtkFileChooser API with it. + * + * Return value: A new #GtkFileChooserButton. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_file_chooser_button_new (GObject *config, + const gchar *property_name, + const gchar *title, + GtkFileChooserAction action) +{ + GParamSpec *param_spec; + GtkWidget *button; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_CONFIG_PATH, G_STRFUNC); + if (! param_spec) + return NULL; + + button = gtk_file_chooser_button_new (title, action); + + return gimp_prop_file_chooser_button_setup (button, config, param_spec); +} + +/** + * gimp_prop_file_chooser_button_new_with_dialog: + * @config: object to which property is attached. + * @property_name: name of path property. + * @dialog: the #GtkFileChooserDialog widget to use. + * + * Creates a #GtkFileChooserButton to edit the specified path property. + * + * The button uses @dialog as it's file-picking window. Note that @dialog + * must be a #GtkFileChooserDialog (or subclass) and must not have + * %GTK_DIALOG_DESTROY_WITH_PARENT set. + * + * Note that #GtkFileChooserButton implements the #GtkFileChooser + * interface; you can use the #GtkFileChooser API with it. + * + * Return value: A new #GtkFileChooserButton. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_file_chooser_button_new_with_dialog (GObject *config, + const gchar *property_name, + GtkWidget *dialog) +{ + GParamSpec *param_spec; + GtkWidget *button; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (property_name != NULL, NULL); + g_return_val_if_fail (GTK_IS_FILE_CHOOSER_DIALOG (dialog), NULL); + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_CONFIG_PATH, G_STRFUNC); + if (! param_spec) + return NULL; + + button = gtk_file_chooser_button_new_with_dialog (dialog); + + return gimp_prop_file_chooser_button_setup (button, config, param_spec); +} + +static GtkWidget * +gimp_prop_file_chooser_button_setup (GtkWidget *button, + GObject *config, + GParamSpec *param_spec) +{ + gchar *value; + GFile *file = NULL; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (value) + { + file = gimp_file_new_for_config_path (value, NULL); + g_free (value); + } + + if (file) + { + gchar *basename = g_file_get_basename (file); + + if (basename && basename[0] == '.') + gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (button), TRUE); + + g_free (basename); + + gtk_file_chooser_set_file (GTK_FILE_CHOOSER (button), file, NULL); + g_object_unref (file); + } + + set_param_spec (G_OBJECT (button), button, param_spec); + + g_signal_connect (button, "file-set", + G_CALLBACK (gimp_prop_file_chooser_button_callback), + config); + + connect_notify (config, param_spec->name, + G_CALLBACK (gimp_prop_file_chooser_button_notify), + button); + + return button; +} + +static void +gimp_prop_file_chooser_button_callback (GtkFileChooser *button, + GObject *config) +{ + GParamSpec *param_spec; + GFile *file; + gchar *value = NULL; + gchar *v; + + param_spec = get_param_spec (G_OBJECT (button)); + if (! param_spec) + return; + + file = gtk_file_chooser_get_file (button); + + if (file) + { + value = gimp_file_get_config_path (file, NULL); + g_object_unref (file); + } + + g_object_get (config, param_spec->name, &v, NULL); + + if (g_strcmp0 (v, value)) + { + g_signal_handlers_block_by_func (config, + gimp_prop_file_chooser_button_notify, + button); + + g_object_set (config, param_spec->name, value, NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_file_chooser_button_notify, + button); + } + + g_free (value); + g_free (v); +} + +static void +gimp_prop_file_chooser_button_notify (GObject *config, + GParamSpec *param_spec, + GtkFileChooser *button) +{ + gchar *value; + GFile *file = NULL; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (value) + { + file = gimp_file_new_for_config_path (value, NULL); + g_free (value); + } + + g_signal_handlers_block_by_func (button, + gimp_prop_file_chooser_button_callback, + config); + + if (file) + { + gtk_file_chooser_set_file (button, file, NULL); + g_object_unref (file); + } + else + { + gtk_file_chooser_unselect_all (button); + } + + g_signal_handlers_unblock_by_func (button, + gimp_prop_file_chooser_button_callback, + config); +} + + +/*****************/ +/* path editor */ +/*****************/ + +static void gimp_prop_path_editor_path_callback (GimpPathEditor *editor, + GObject *config); +static void gimp_prop_path_editor_writable_callback (GimpPathEditor *editor, + GObject *config); +static void gimp_prop_path_editor_path_notify (GObject *config, + GParamSpec *param_spec, + GimpPathEditor *editor); +static void gimp_prop_path_editor_writable_notify (GObject *config, + GParamSpec *param_spec, + GimpPathEditor *editor); + +GtkWidget * +gimp_prop_path_editor_new (GObject *config, + const gchar *path_property_name, + const gchar *writable_property_name, + const gchar *filesel_title) +{ + GParamSpec *path_param_spec; + GParamSpec *writable_param_spec = NULL; + GtkWidget *editor; + gchar *value; + gchar *filename; + + g_return_val_if_fail (G_IS_OBJECT (config), NULL); + g_return_val_if_fail (path_property_name != NULL, NULL); + + path_param_spec = check_param_spec_w (config, path_property_name, + GIMP_TYPE_PARAM_CONFIG_PATH, G_STRFUNC); + if (! path_param_spec) + return NULL; + + if (writable_property_name) + { + writable_param_spec = check_param_spec_w (config, writable_property_name, + GIMP_TYPE_PARAM_CONFIG_PATH, + G_STRFUNC); + if (! writable_param_spec) + return NULL; + } + + g_object_get (config, + path_property_name, &value, + NULL); + + filename = value ? gimp_config_path_expand (value, TRUE, NULL) : NULL; + g_free (value); + + editor = gimp_path_editor_new (filesel_title, filename); + g_free (filename); + + if (writable_property_name) + { + g_object_get (config, + writable_property_name, &value, + NULL); + + filename = value ? gimp_config_path_expand (value, TRUE, NULL) : NULL; + g_free (value); + + gimp_path_editor_set_writable_path (GIMP_PATH_EDITOR (editor), filename); + g_free (filename); + } + + g_object_set_data (G_OBJECT (editor), "gimp-config-param-spec-path", + path_param_spec); + + g_signal_connect (editor, "path-changed", + G_CALLBACK (gimp_prop_path_editor_path_callback), + config); + + connect_notify (config, path_property_name, + G_CALLBACK (gimp_prop_path_editor_path_notify), + editor); + + if (writable_property_name) + { + g_object_set_data (G_OBJECT (editor), "gimp-config-param-spec-writable", + writable_param_spec); + + g_signal_connect (editor, "writable-changed", + G_CALLBACK (gimp_prop_path_editor_writable_callback), + config); + + connect_notify (config, writable_property_name, + G_CALLBACK (gimp_prop_path_editor_writable_notify), + editor); + } + + return editor; +} + +static void +gimp_prop_path_editor_path_callback (GimpPathEditor *editor, + GObject *config) +{ + GParamSpec *path_param_spec; + GParamSpec *writable_param_spec; + gchar *value; + gchar *utf8; + + path_param_spec = g_object_get_data (G_OBJECT (editor), + "gimp-config-param-spec-path"); + writable_param_spec = g_object_get_data (G_OBJECT (editor), + "gimp-config-param-spec-writable"); + if (! path_param_spec) + return; + + value = gimp_path_editor_get_path (editor); + utf8 = value ? gimp_config_path_unexpand (value, TRUE, NULL) : NULL; + g_free (value); + + g_signal_handlers_block_by_func (config, + gimp_prop_path_editor_path_notify, + editor); + + g_object_set (config, + path_param_spec->name, utf8, + NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_path_editor_path_notify, + editor); + + g_free (utf8); + + if (writable_param_spec) + { + value = gimp_path_editor_get_writable_path (editor); + utf8 = value ? gimp_config_path_unexpand (value, TRUE, NULL) : NULL; + g_free (value); + + g_signal_handlers_block_by_func (config, + gimp_prop_path_editor_writable_notify, + editor); + + g_object_set (config, + writable_param_spec->name, utf8, + NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_path_editor_writable_notify, + editor); + + g_free (utf8); + } +} + +static void +gimp_prop_path_editor_writable_callback (GimpPathEditor *editor, + GObject *config) +{ + GParamSpec *param_spec; + gchar *value; + gchar *utf8; + + param_spec = g_object_get_data (G_OBJECT (editor), + "gimp-config-param-spec-writable"); + if (! param_spec) + return; + + value = gimp_path_editor_get_writable_path (editor); + utf8 = value ? gimp_config_path_unexpand (value, TRUE, NULL) : NULL; + g_free (value); + + g_signal_handlers_block_by_func (config, + gimp_prop_path_editor_writable_notify, + editor); + + g_object_set (config, + param_spec->name, utf8, + NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_path_editor_writable_notify, + editor); + + g_free (utf8); +} + +static void +gimp_prop_path_editor_path_notify (GObject *config, + GParamSpec *param_spec, + GimpPathEditor *editor) +{ + gchar *value; + gchar *filename; + + g_object_get (config, + param_spec->name, &value, + NULL); + + filename = value ? gimp_config_path_expand (value, TRUE, NULL) : NULL; + g_free (value); + + g_signal_handlers_block_by_func (editor, + gimp_prop_path_editor_path_callback, + config); + + gimp_path_editor_set_path (editor, filename); + + g_signal_handlers_unblock_by_func (editor, + gimp_prop_path_editor_path_callback, + config); + + g_free (filename); +} + +static void +gimp_prop_path_editor_writable_notify (GObject *config, + GParamSpec *param_spec, + GimpPathEditor *editor) +{ + gchar *value; + gchar *filename; + + g_object_get (config, + param_spec->name, &value, + NULL); + + filename = value ? gimp_config_path_expand (value, TRUE, NULL) : NULL; + g_free (value); + + g_signal_handlers_block_by_func (editor, + gimp_prop_path_editor_writable_callback, + config); + + gimp_path_editor_set_writable_path (editor, filename); + + g_signal_handlers_unblock_by_func (editor, + gimp_prop_path_editor_writable_callback, + config); + + g_free (filename); +} + + +/***************/ +/* sizeentry */ +/***************/ + +static void gimp_prop_size_entry_callback (GimpSizeEntry *entry, + GObject *config); +static void gimp_prop_size_entry_notify (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry); +static void gimp_prop_size_entry_notify_unit (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry); +static gint gimp_prop_size_entry_num_chars (gdouble lower, + gdouble upper); + + +/** + * gimp_prop_size_entry_new: + * @config: Object to which property is attached. + * @property_name: Name of int or double property. + * @property_is_pixel: When %TRUE, the property value is in pixels, + * and in the selected unit otherwise. + * @unit_property_name: Name of unit property. + * @unit_format: A printf-like unit-format string as is used with + * gimp_unit_menu_new(). + * @update_policy: How the automatic pixel <-> real-world-unit + * calculations should be done. + * @resolution: The resolution (in dpi) for the field. + * + * Creates a #GimpSizeEntry to set and display the specified double or + * int property, and its associated unit property. Note that this + * function is only suitable for creating a size entry holding a + * single value. Use gimp_prop_coordinates_new() to create a size + * entry holding two values. + * + * Return value: A new #GimpSizeEntry widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_size_entry_new (GObject *config, + const gchar *property_name, + gboolean property_is_pixel, + const gchar *unit_property_name, + const gchar *unit_format, + GimpSizeEntryUpdatePolicy update_policy, + gdouble resolution) +{ + GtkWidget *entry; + GParamSpec *param_spec; + GParamSpec *unit_param_spec; + gboolean show_pixels; + gboolean show_percent; + gdouble value; + gdouble lower; + gdouble upper; + GimpUnit unit_value; + + param_spec = find_param_spec (config, property_name, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! get_numeric_values (config, + param_spec, &value, &lower, &upper, G_STRFUNC)) + return NULL; + + if (unit_property_name) + { + GValue value = G_VALUE_INIT; + + unit_param_spec = check_param_spec_w (config, unit_property_name, + GIMP_TYPE_PARAM_UNIT, G_STRFUNC); + if (! unit_param_spec) + return NULL; + + g_value_init (&value, unit_param_spec->value_type); + + g_value_set_int (&value, GIMP_UNIT_PIXEL); + show_pixels = (g_param_value_validate (unit_param_spec, + &value) == FALSE); + + g_value_set_int (&value, GIMP_UNIT_PERCENT); + show_percent = (g_param_value_validate (unit_param_spec, + &value) == FALSE); + + g_value_unset (&value); + + g_object_get (config, + unit_property_name, &unit_value, + NULL); + } + else + { + unit_param_spec = NULL; + unit_value = GIMP_UNIT_INCH; + show_pixels = FALSE; + show_percent = FALSE; + } + + entry = gimp_size_entry_new (1, unit_value, unit_format, + show_pixels, show_percent, FALSE, + gimp_prop_size_entry_num_chars (lower, upper) + 1 + + gimp_unit_get_scaled_digits (unit_value, resolution), + update_policy); + gtk_table_set_col_spacing (GTK_TABLE (entry), 1, 2); + + set_param_spec (NULL, + gimp_size_entry_get_help_widget (GIMP_SIZE_ENTRY (entry), 0), + param_spec); + + if (unit_param_spec) + set_param_spec (NULL, GIMP_SIZE_ENTRY (entry)->unitmenu, unit_param_spec); + + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (entry), unit_value); + + if (update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE) + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, + resolution, FALSE); + + gimp_size_entry_set_value_boundaries (GIMP_SIZE_ENTRY (entry), 0, + lower, upper); + + g_object_set_data (G_OBJECT (entry), "value-is-pixel", + GINT_TO_POINTER (property_is_pixel ? TRUE : FALSE)); + + if (property_is_pixel) + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, value); + else + gimp_size_entry_set_value (GIMP_SIZE_ENTRY (entry), 0, value); + + g_object_set_data (G_OBJECT (entry), "gimp-config-param-spec", + param_spec); + + g_signal_connect (entry, "refval-changed", + G_CALLBACK (gimp_prop_size_entry_callback), + config); + g_signal_connect (entry, "value-changed", + G_CALLBACK (gimp_prop_size_entry_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_size_entry_notify), + entry); + + if (unit_property_name) + { + g_object_set_data (G_OBJECT (entry), "gimp-config-param-spec-unit", + unit_param_spec); + + g_signal_connect (entry, "unit-changed", + G_CALLBACK (gimp_prop_size_entry_callback), + config); + + connect_notify (config, unit_property_name, + G_CALLBACK (gimp_prop_size_entry_notify_unit), + entry); + } + + return entry; +} + +static void +gimp_prop_size_entry_callback (GimpSizeEntry *entry, + GObject *config) +{ + GParamSpec *param_spec; + GParamSpec *unit_param_spec; + gdouble value; + gboolean value_is_pixel; + GimpUnit unit_value; + + param_spec = g_object_get_data (G_OBJECT (entry), "gimp-config-param-spec"); + if (! param_spec) + return; + + unit_param_spec = g_object_get_data (G_OBJECT (entry), + "gimp-config-param-spec-unit"); + + value_is_pixel = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry), + "value-is-pixel")); + + if (value_is_pixel) + value = gimp_size_entry_get_refval (entry, 0); + else + value = gimp_size_entry_get_value (entry, 0); + + unit_value = gimp_size_entry_get_unit (entry); + + if (unit_param_spec) + { + GimpUnit old_unit; + + g_object_get (config, + unit_param_spec->name, &old_unit, + NULL); + + if (unit_value == old_unit) + unit_param_spec = NULL; + } + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + g_object_set (config, + param_spec->name, ROUND (value), + + unit_param_spec ? + unit_param_spec->name : NULL, unit_value, + + NULL); + } + else if (G_IS_PARAM_SPEC_DOUBLE (param_spec)) + { + g_object_set (config, + param_spec->name, value, + + unit_param_spec ? + unit_param_spec->name : NULL, unit_value, + + NULL); + } +} + +static void +gimp_prop_size_entry_notify (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry) +{ + gdouble value; + gdouble entry_value; + gboolean value_is_pixel; + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + gint int_value; + + g_object_get (config, + param_spec->name, &int_value, + NULL); + + value = int_value; + } + else + { + g_object_get (config, + param_spec->name, &value, + NULL); + } + + value_is_pixel = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry), + "value-is-pixel")); + + if (value_is_pixel) + entry_value = gimp_size_entry_get_refval (entry, 0); + else + entry_value = gimp_size_entry_get_value (entry, 0); + + if (value != entry_value) + { + g_signal_handlers_block_by_func (entry, + gimp_prop_size_entry_callback, + config); + + if (value_is_pixel) + gimp_size_entry_set_refval (entry, 0, value); + else + gimp_size_entry_set_value (entry, 0, value); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_size_entry_callback, + config); + } +} + +static void +gimp_prop_size_entry_notify_unit (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry) +{ + GimpUnit value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (value != gimp_size_entry_get_unit (entry)) + { + g_signal_handlers_block_by_func (entry, + gimp_prop_size_entry_callback, + config); + + gimp_size_entry_set_unit (entry, value); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_size_entry_callback, + config); + } +} + +static gint +gimp_prop_size_entry_num_chars (gdouble lower, + gdouble upper) +{ + gint lower_chars = log (fabs (lower)) / log (10); + gint upper_chars = log (fabs (upper)) / log (10); + + if (lower < 0.0) + lower_chars++; + + if (upper < 0.0) + upper_chars++; + + return MAX (lower_chars, upper_chars); +} + + +/*****************/ +/* coordinates */ +/*****************/ + +static void gimp_prop_coordinates_callback (GimpSizeEntry *entry, + GObject *config); +static void gimp_prop_coordinates_notify_x (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry); +static void gimp_prop_coordinates_notify_y (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry); +static void gimp_prop_coordinates_notify_unit (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry); + + +/** + * gimp_prop_coordinates_new: + * @config: Object to which property is attached. + * @x_property_name: Name of int or double property for X coordinate. + * @y_property_name: Name of int or double property for Y coordinate. + * @unit_property_name: Name of unit property. + * @unit_format: A printf-like unit-format string as is used with + * gimp_unit_menu_new(). + * @update_policy: How the automatic pixel <-> real-world-unit + * calculations should be done. + * @xresolution: The resolution (in dpi) for the X coordinate. + * @yresolution: The resolution (in dpi) for the Y coordinate. + * @has_chainbutton: Whether to add a chainbutton to the size entry. + * + * Creates a #GimpSizeEntry to set and display two double or int + * properties, which will usually represent X and Y coordinates, and + * their associated unit property. + * + * Return value: A new #GimpSizeEntry widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_coordinates_new (GObject *config, + const gchar *x_property_name, + const gchar *y_property_name, + const gchar *unit_property_name, + const gchar *unit_format, + GimpSizeEntryUpdatePolicy update_policy, + gdouble xresolution, + gdouble yresolution, + gboolean has_chainbutton) +{ + GtkWidget *entry; + GtkWidget *chainbutton = NULL; + + entry = gimp_size_entry_new (2, GIMP_UNIT_INCH, unit_format, + FALSE, FALSE, TRUE, 10, + update_policy); + + if (has_chainbutton) + { + chainbutton = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); + gtk_table_attach_defaults (GTK_TABLE (entry), chainbutton, 1, 3, 3, 4); + gtk_widget_show (chainbutton); + } + + if (! gimp_prop_coordinates_connect (config, + x_property_name, + y_property_name, + unit_property_name, + entry, + chainbutton, + xresolution, + yresolution)) + { + gtk_widget_destroy (entry); + return NULL; + } + + return entry; +} + +gboolean +gimp_prop_coordinates_connect (GObject *config, + const gchar *x_property_name, + const gchar *y_property_name, + const gchar *unit_property_name, + GtkWidget *entry, + GtkWidget *chainbutton, + gdouble xresolution, + gdouble yresolution) +{ + GParamSpec *x_param_spec; + GParamSpec *y_param_spec; + GParamSpec *unit_param_spec; + gdouble x_value, x_lower, x_upper; + gdouble y_value, y_lower, y_upper; + GimpUnit unit_value; + gdouble *old_x_value; + gdouble *old_y_value; + GimpUnit *old_unit_value; + gboolean chain_checked; + + g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (entry), FALSE); + g_return_val_if_fail (GIMP_SIZE_ENTRY (entry)->number_of_fields == 2, FALSE); + g_return_val_if_fail (chainbutton == NULL || + GIMP_IS_CHAIN_BUTTON (chainbutton), FALSE); + + x_param_spec = find_param_spec (config, x_property_name, G_STRFUNC); + if (! x_param_spec) + return FALSE; + + y_param_spec = find_param_spec (config, y_property_name, G_STRFUNC); + if (! y_param_spec) + return FALSE; + + if (! get_numeric_values (config, x_param_spec, + &x_value, &x_lower, &x_upper, G_STRFUNC) || + ! get_numeric_values (config, y_param_spec, + &y_value, &y_lower, &y_upper, G_STRFUNC)) + return FALSE; + + if (unit_property_name) + { + unit_param_spec = check_param_spec_w (config, unit_property_name, + GIMP_TYPE_PARAM_UNIT, G_STRFUNC); + if (! unit_param_spec) + return FALSE; + + g_object_get (config, + unit_property_name, &unit_value, + NULL); + } + else + { + unit_param_spec = NULL; + unit_value = GIMP_UNIT_INCH; + } + + set_param_spec (NULL, + gimp_size_entry_get_help_widget (GIMP_SIZE_ENTRY (entry), 0), + x_param_spec); + set_param_spec (NULL, + gimp_size_entry_get_help_widget (GIMP_SIZE_ENTRY (entry), 1), + y_param_spec); + + if (unit_param_spec) + set_param_spec (NULL, + GIMP_SIZE_ENTRY (entry)->unitmenu, unit_param_spec); + + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (entry), unit_value); + + switch (GIMP_SIZE_ENTRY (entry)->update_policy) + { + case GIMP_SIZE_ENTRY_UPDATE_SIZE: + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, + xresolution, FALSE); + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, + yresolution, FALSE); + chain_checked = (ABS (x_value - y_value) < 1); + break; + + case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION: + chain_checked = (ABS (x_value - y_value) < GIMP_MIN_RESOLUTION); + break; + + default: + chain_checked = (x_value == y_value); + break; + } + + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 0, + x_lower, x_upper); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 1, + y_lower, y_upper); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, x_value); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, y_value); + + g_object_set_data (G_OBJECT (entry), "gimp-config-param-spec-x", + x_param_spec); + g_object_set_data (G_OBJECT (entry), "gimp-config-param-spec-y", + y_param_spec); + + old_x_value = g_new0 (gdouble, 1); + *old_x_value = x_value; + g_object_set_data_full (G_OBJECT (entry), "old-x-value", + old_x_value, + (GDestroyNotify) g_free); + + old_y_value = g_new0 (gdouble, 1); + *old_y_value = y_value; + g_object_set_data_full (G_OBJECT (entry), "old-y-value", + old_y_value, + (GDestroyNotify) g_free); + + if (chainbutton) + { + if (chain_checked) + gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chainbutton), TRUE); + + g_object_set_data (G_OBJECT (entry), "chainbutton", chainbutton); + } + + g_signal_connect (entry, "value-changed", + G_CALLBACK (gimp_prop_coordinates_callback), + config); + g_signal_connect (entry, "refval-changed", + G_CALLBACK (gimp_prop_coordinates_callback), + config); + + connect_notify (config, x_property_name, + G_CALLBACK (gimp_prop_coordinates_notify_x), + entry); + connect_notify (config, y_property_name, + G_CALLBACK (gimp_prop_coordinates_notify_y), + entry); + + if (unit_property_name) + { + g_object_set_data (G_OBJECT (entry), "gimp-config-param-spec-unit", + unit_param_spec); + + old_unit_value = g_new0 (GimpUnit, 1); + *old_unit_value = unit_value; + g_object_set_data_full (G_OBJECT (entry), "old-unit-value", + old_unit_value, + (GDestroyNotify) g_free); + + g_signal_connect (entry, "unit-changed", + G_CALLBACK (gimp_prop_coordinates_callback), + config); + + connect_notify (config, unit_property_name, + G_CALLBACK (gimp_prop_coordinates_notify_unit), + entry); + } + + return TRUE; +} + +static void +gimp_prop_coordinates_callback (GimpSizeEntry *entry, + GObject *config) +{ + GParamSpec *x_param_spec; + GParamSpec *y_param_spec; + GParamSpec *unit_param_spec; + gdouble x_value; + gdouble y_value; + GimpUnit unit_value; + gdouble *old_x_value; + gdouble *old_y_value; + GimpUnit *old_unit_value; + gboolean backwards; + + x_param_spec = g_object_get_data (G_OBJECT (entry), + "gimp-config-param-spec-x"); + y_param_spec = g_object_get_data (G_OBJECT (entry), + "gimp-config-param-spec-y"); + + if (! x_param_spec || ! y_param_spec) + return; + + unit_param_spec = g_object_get_data (G_OBJECT (entry), + "gimp-config-param-spec-unit"); + + x_value = gimp_size_entry_get_refval (entry, 0); + y_value = gimp_size_entry_get_refval (entry, 1); + unit_value = gimp_size_entry_get_unit (entry); + + old_x_value = g_object_get_data (G_OBJECT (entry), "old-x-value"); + old_y_value = g_object_get_data (G_OBJECT (entry), "old-y-value"); + old_unit_value = g_object_get_data (G_OBJECT (entry), "old-unit-value"); + + if (! old_x_value || ! old_y_value || (unit_param_spec && ! old_unit_value)) + return; + + /* + * FIXME: if the entry was created using gimp_coordinates_new, then + * the chain button is handled automatically and the following block + * of code is unnecessary (and, in fact, redundant). + */ + if (x_value != y_value) + { + GtkWidget *chainbutton; + + chainbutton = g_object_get_data (G_OBJECT (entry), "chainbutton"); + + if (chainbutton && + gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (chainbutton)) && + ! g_object_get_data (G_OBJECT (chainbutton), "constrains-ratio")) + { + if (x_value != *old_x_value) + y_value = x_value; + else if (y_value != *old_y_value) + x_value = y_value; + } + } + + backwards = (*old_x_value == x_value); + + if (*old_x_value == x_value && + *old_y_value == y_value && + (old_unit_value == NULL || *old_unit_value == unit_value)) + return; + + *old_x_value = x_value; + *old_y_value = y_value; + + if (old_unit_value) + *old_unit_value = unit_value; + + if (unit_param_spec) + g_object_set (config, + unit_param_spec->name, unit_value, + NULL); + + if (G_IS_PARAM_SPEC_INT (x_param_spec) && + G_IS_PARAM_SPEC_INT (y_param_spec)) + { + if (backwards) + g_object_set (config, + y_param_spec->name, ROUND (y_value), + x_param_spec->name, ROUND (x_value), + NULL); + else + g_object_set (config, + x_param_spec->name, ROUND (x_value), + y_param_spec->name, ROUND (y_value), + NULL); + + } + else if (G_IS_PARAM_SPEC_DOUBLE (x_param_spec) && + G_IS_PARAM_SPEC_DOUBLE (y_param_spec)) + { + if (backwards) + g_object_set (config, + y_param_spec->name, y_value, + x_param_spec->name, x_value, + NULL); + else + g_object_set (config, + x_param_spec->name, x_value, + y_param_spec->name, y_value, + NULL); + } +} + +static void +gimp_prop_coordinates_notify_x (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry) +{ + gdouble value; + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + gint int_value; + + g_object_get (config, + param_spec->name, &int_value, + NULL); + + value = int_value; + } + else + { + g_object_get (config, + param_spec->name, &value, + NULL); + } + + if (value != gimp_size_entry_get_refval (entry, 0)) + { + gdouble *old_x_value = g_object_get_data (G_OBJECT (entry), + "old-x-value"); + + g_signal_handlers_block_by_func (entry, + gimp_prop_coordinates_callback, + config); + + gimp_size_entry_set_refval (entry, 0, value); + + if (old_x_value) + *old_x_value = value; + + g_signal_emit_by_name (entry, "value-changed", + gimp_size_entry_get_value (entry, 0)); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_coordinates_callback, + config); + } +} + +static void +gimp_prop_coordinates_notify_y (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry) +{ + gdouble value; + + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + gint int_value; + + g_object_get (config, + param_spec->name, &int_value, + NULL); + + value = int_value; + } + else + { + g_object_get (config, + param_spec->name, &value, + NULL); + } + + if (value != gimp_size_entry_get_refval (entry, 1)) + { + gdouble *old_y_value = g_object_get_data (G_OBJECT (entry), + "old-y-value"); + + g_signal_handlers_block_by_func (entry, + gimp_prop_coordinates_callback, + config); + + gimp_size_entry_set_refval (entry, 1, value); + + if (old_y_value) + *old_y_value = value; + + g_signal_emit_by_name (entry, "value-changed", + gimp_size_entry_get_value (entry, 1)); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_coordinates_callback, + config); + } +} + +static void +gimp_prop_coordinates_notify_unit (GObject *config, + GParamSpec *param_spec, + GimpSizeEntry *entry) +{ + GimpUnit value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (value != gimp_size_entry_get_unit (entry)) + { + g_signal_handlers_block_by_func (entry, + gimp_prop_coordinates_callback, + config); + + gimp_size_entry_set_unit (entry, value); + + g_signal_handlers_unblock_by_func (entry, + gimp_prop_coordinates_callback, + config); + } +} + + +/****************/ +/* color area */ +/****************/ + +static void gimp_prop_color_area_callback (GtkWidget *widget, + GObject *config); +static void gimp_prop_color_area_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *area); + +/** + * gimp_prop_color_area_new: + * @config: Object to which property is attached. + * @property_name: Name of RGB property. + * @width: Width of color area. + * @height: Height of color area. + * @type: How transparency is represented. + * + * Creates a #GimpColorArea to set and display the value of an RGB + * property. + * + * Return value: A new #GimpColorArea widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_color_area_new (GObject *config, + const gchar *property_name, + gint width, + gint height, + GimpColorAreaType type) +{ + GParamSpec *param_spec; + GtkWidget *area; + GimpRGB *value; + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_RGB, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &value, + NULL); + + area = gimp_color_area_new (value, type, + GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); + gtk_widget_set_size_request (area, width, height); + + g_free (value); + + set_param_spec (G_OBJECT (area), area, param_spec); + + g_signal_connect (area, "color-changed", + G_CALLBACK (gimp_prop_color_area_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_color_area_notify), + area); + + return area; +} + +static void +gimp_prop_color_area_callback (GtkWidget *area, + GObject *config) +{ + GParamSpec *param_spec; + GimpRGB value; + + param_spec = get_param_spec (G_OBJECT (area)); + if (! param_spec) + return; + + gimp_color_area_get_color (GIMP_COLOR_AREA (area), &value); + + g_signal_handlers_block_by_func (config, + gimp_prop_color_area_notify, + area); + + g_object_set (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_color_area_notify, + area); +} + +static void +gimp_prop_color_area_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *area) +{ + GimpRGB *value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + g_signal_handlers_block_by_func (area, + gimp_prop_color_area_callback, + config); + + gimp_color_area_set_color (GIMP_COLOR_AREA (area), value); + + g_free (value); + + g_signal_handlers_unblock_by_func (area, + gimp_prop_color_area_callback, + config); +} + + +/********************/ +/* unit combo box */ +/********************/ + +static void gimp_prop_unit_combo_box_callback (GtkWidget *combo, + GObject *config); +static void gimp_prop_unit_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo); + +/** + * gimp_prop_unit_combo_box_new: + * @config: Object to which property is attached. + * @property_name: Name of Unit property. + * + * Creates a #GimpUnitComboBox to set and display the value of a Unit + * property. See gimp_unit_combo_box_new() for more information. + * + * Return value: A new #GimpUnitComboBox widget. + * + * Since: 2.8 + */ +GtkWidget * +gimp_prop_unit_combo_box_new (GObject *config, + const gchar *property_name) +{ + GParamSpec *param_spec; + GtkWidget *combo; + GtkTreeModel *model; + GimpUnit unit; + GValue value = G_VALUE_INIT; + gboolean show_pixels; + gboolean show_percent; + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_UNIT, G_STRFUNC); + if (! param_spec) + return NULL; + + g_value_init (&value, param_spec->value_type); + + g_value_set_int (&value, GIMP_UNIT_PIXEL); + show_pixels = (g_param_value_validate (param_spec, &value) == FALSE); + + g_value_set_int (&value, GIMP_UNIT_PERCENT); + show_percent = (g_param_value_validate (param_spec, &value) == FALSE); + + g_value_unset (&value); + + g_object_get (config, + property_name, &unit, + NULL); + + combo = gimp_unit_combo_box_new (); + model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo)); + gimp_unit_store_set_has_pixels (GIMP_UNIT_STORE (model), show_pixels); + gimp_unit_store_set_has_percent (GIMP_UNIT_STORE (model), show_percent); + + gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (combo), unit); + + set_param_spec (G_OBJECT (combo), combo, param_spec); + + g_signal_connect (combo, "changed", + G_CALLBACK (gimp_prop_unit_combo_box_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_unit_combo_box_notify), + combo); + + return combo; +} + +static void +gimp_prop_unit_combo_box_callback (GtkWidget *combo, + GObject *config) +{ + GParamSpec *param_spec; + GimpUnit value; + GimpUnit v; + + param_spec = get_param_spec (G_OBJECT (combo)); + if (! param_spec) + return; + + value = gimp_unit_combo_box_get_active (GIMP_UNIT_COMBO_BOX (combo)); + + g_object_get (config, param_spec->name, &v, NULL); + + if (v != value) + { + /* FIXME gimp_unit_menu_update (menu, &unit); */ + + g_signal_handlers_block_by_func (config, + gimp_prop_unit_combo_box_notify, + combo); + + g_object_set (config, param_spec->name, value, NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_unit_combo_box_notify, + combo); + } +} + +static void +gimp_prop_unit_combo_box_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *combo) +{ + GimpUnit unit; + + g_object_get (config, + param_spec->name, &unit, + NULL); + + g_signal_handlers_block_by_func (combo, + gimp_prop_unit_combo_box_callback, + config); + + gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (combo), unit); + + /* FIXME gimp_unit_menu_update (menu, &unit); */ + + g_signal_handlers_unblock_by_func (combo, + gimp_prop_unit_combo_box_callback, + config); +} + + +/***************/ +/* unit menu */ +/***************/ + +static void gimp_prop_unit_menu_callback (GtkWidget *menu, + GObject *config); +static void gimp_prop_unit_menu_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *menu); + +/** + * gimp_prop_unit_menu_new: + * @config: Object to which property is attached. + * @property_name: Name of Unit property. + * @unit_format: A printf-like format string which is used to create + * the unit strings. + * + * Creates a #GimpUnitMenu to set and display the value of a Unit + * property. See gimp_unit_menu_new() for more information. + * + * Return value: A new #GimpUnitMenu widget. + * + * Since: 2.4 + * + * Deprecated: 2.10 + */ +GtkWidget * +gimp_prop_unit_menu_new (GObject *config, + const gchar *property_name, + const gchar *unit_format) +{ + GParamSpec *param_spec; + GtkWidget *menu; + GimpUnit unit; + GValue value = G_VALUE_INIT; + gboolean show_pixels; + gboolean show_percent; + + param_spec = check_param_spec_w (config, property_name, + GIMP_TYPE_PARAM_UNIT, G_STRFUNC); + if (! param_spec) + return NULL; + + g_value_init (&value, param_spec->value_type); + + g_value_set_int (&value, GIMP_UNIT_PIXEL); + show_pixels = (g_param_value_validate (param_spec, &value) == FALSE); + + g_value_set_int (&value, GIMP_UNIT_PERCENT); + show_percent = (g_param_value_validate (param_spec, &value) == FALSE); + + g_value_unset (&value); + + g_object_get (config, + property_name, &unit, + NULL); + + menu = gimp_unit_menu_new (unit_format, + unit, show_pixels, show_percent, TRUE); + + set_param_spec (G_OBJECT (menu), menu, param_spec); + + g_signal_connect (menu, "unit-changed", + G_CALLBACK (gimp_prop_unit_menu_callback), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_unit_menu_notify), + menu); + + return menu; +} + +static void +gimp_prop_unit_menu_callback (GtkWidget *menu, + GObject *config) +{ + GParamSpec *param_spec; + GimpUnit unit; + + param_spec = get_param_spec (G_OBJECT (menu)); + if (! param_spec) + return; + + gimp_unit_menu_update (menu, &unit); + + g_signal_handlers_block_by_func (config, + gimp_prop_unit_menu_notify, + menu); + + g_object_set (config, + param_spec->name, unit, + NULL); + + g_signal_handlers_unblock_by_func (config, + gimp_prop_unit_menu_notify, + menu); +} + +static void +gimp_prop_unit_menu_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *menu) +{ + GimpUnit unit; + + g_object_get (config, + param_spec->name, &unit, + NULL); + + g_signal_handlers_block_by_func (menu, + gimp_prop_unit_menu_callback, + config); + + gimp_unit_menu_set_unit (GIMP_UNIT_MENU (menu), unit); + gimp_unit_menu_update (menu, &unit); + + g_signal_handlers_unblock_by_func (menu, + gimp_prop_unit_menu_callback, + config); +} + + +/***************/ +/* icon name */ +/***************/ + +static void gimp_prop_icon_image_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *image); + +/** + * gimp_prop_stock_image_new: + * @config: Object to which property is attached. + * @property_name: Name of string property. + * @icon_size: Size of desired stock image. + * + * Creates a widget to display a stock image representing the value of the + * specified string property, which should encode a Stock ID. + * See gtk_image_new_from_stock() for more information. + * + * Return value: A new #GtkImage widget. + * + * Since: 2.4 + * + * Deprecated: 2.10 + */ +GtkWidget * +gimp_prop_stock_image_new (GObject *config, + const gchar *property_name, + GtkIconSize icon_size) +{ + return gimp_prop_icon_image_new (config, property_name, icon_size); +} + +/** + * gimp_prop_icon_image_new: + * @config: Object to which property is attached. + * @property_name: Name of string property. + * @icon_size: Size of desired icon image. + * + * Creates a widget to display a icon image representing the value of the + * specified string property, which should encode an icon name. + * See gtk_image_new_from_icon_name() for more information. + * + * Return value: A new #GtkImage widget. + * + * Since: 2.10 + */ +GtkWidget * +gimp_prop_icon_image_new (GObject *config, + const gchar *property_name, + GtkIconSize icon_size) +{ + GParamSpec *param_spec; + GtkWidget *image; + gchar *icon_name; + + param_spec = check_param_spec (config, property_name, + G_TYPE_PARAM_STRING, G_STRFUNC); + if (! param_spec) + return NULL; + + g_object_get (config, + property_name, &icon_name, + NULL); + + image = gtk_image_new_from_icon_name (icon_name, icon_size); + + if (icon_name) + g_free (icon_name); + + set_param_spec (G_OBJECT (image), image, param_spec); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_icon_image_notify), + image); + + return image; +} + +static void +gimp_prop_icon_image_notify (GObject *config, + GParamSpec *param_spec, + GtkWidget *image) +{ + gchar *icon_name; + GtkIconSize icon_size; + + g_object_get (config, + param_spec->name, &icon_name, + NULL); + + gtk_image_get_icon_name (GTK_IMAGE (image), NULL, &icon_size); + gtk_image_set_from_icon_name (GTK_IMAGE (image), icon_name, icon_size); + + if (icon_name) + g_free (icon_name); +} + + +/**************/ +/* expander */ +/**************/ + +static void gimp_prop_expanded_notify (GtkExpander *expander, + GParamSpec *param_spec, + GObject *config); +static void gimp_prop_expander_notify (GObject *config, + GParamSpec *param_spec, + GtkExpander *expander); + + +/** + * gimp_prop_expander_new: + * @config: Object to which property is attached. + * @property_name: Name of boolean property. + * @label: Label for expander. + * + * Creates a #GtkExpander controlled by the specified boolean property. + * A value of %TRUE for the property corresponds to the expanded state + * for the widget. + * If @label is #NULL, the @property_name's nick will be used as label + * of the returned widget. + * + * Return value: A new #GtkExpander widget. + * + * Since: 2.4 + */ +GtkWidget * +gimp_prop_expander_new (GObject *config, + const gchar *property_name, + const gchar *label) +{ + GParamSpec *param_spec; + GtkWidget *expander; + gboolean value; + + param_spec = check_param_spec_w (config, property_name, + G_TYPE_PARAM_BOOLEAN, G_STRFUNC); + if (! param_spec) + return NULL; + + if (! label) + label = g_param_spec_get_nick (param_spec); + + g_object_get (config, + property_name, &value, + NULL); + + expander = g_object_new (GTK_TYPE_EXPANDER, + "label", label, + "expanded", value, + NULL); + + set_param_spec (G_OBJECT (expander), expander, param_spec); + + g_signal_connect (expander, "notify::expanded", + G_CALLBACK (gimp_prop_expanded_notify), + config); + + connect_notify (config, property_name, + G_CALLBACK (gimp_prop_expander_notify), + expander); + + return expander; +} + +static void +gimp_prop_expanded_notify (GtkExpander *expander, + GParamSpec *param_spec, + GObject *config) +{ + param_spec = get_param_spec (G_OBJECT (expander)); + if (! param_spec) + return; + + g_object_set (config, + param_spec->name, gtk_expander_get_expanded (expander), + NULL); +} + +static void +gimp_prop_expander_notify (GObject *config, + GParamSpec *param_spec, + GtkExpander *expander) +{ + gboolean value; + + g_object_get (config, + param_spec->name, &value, + NULL); + + if (gtk_expander_get_expanded (expander) != value) + { + g_signal_handlers_block_by_func (expander, + gimp_prop_expanded_notify, + config); + + gtk_expander_set_expanded (expander, value); + + g_signal_handlers_unblock_by_func (expander, + gimp_prop_expanded_notify, + config); + } +} + + +/*******************************/ +/* private utility functions */ +/*******************************/ + +static GQuark gimp_prop_widgets_param_spec_quark (void) G_GNUC_CONST; + +#define PARAM_SPEC_QUARK (gimp_prop_widgets_param_spec_quark ()) + +static GQuark +gimp_prop_widgets_param_spec_quark (void) +{ + static GQuark param_spec_quark = 0; + + if (! param_spec_quark) + param_spec_quark = g_quark_from_static_string ("gimp-config-param-spec"); + + return param_spec_quark; +} + +static void +set_param_spec (GObject *object, + GtkWidget *widget, + GParamSpec *param_spec) +{ + if (object) + { + g_object_set_qdata (object, PARAM_SPEC_QUARK, param_spec); + } + + if (widget) + { + const gchar *blurb = g_param_spec_get_blurb (param_spec); + + if (blurb) + gimp_help_set_help_data (widget, blurb, NULL); + } +} + +static void +set_radio_spec (GObject *object, + GParamSpec *param_spec) +{ + GSList *list; + + for (list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (object)); + list; + list = g_slist_next (list)) + { + set_param_spec (list->data, NULL, param_spec); + } +} + +static GParamSpec * +get_param_spec (GObject *object) +{ + return g_object_get_qdata (object, PARAM_SPEC_QUARK); +} + +static GParamSpec * +find_param_spec (GObject *object, + const gchar *property_name, + const gchar *strloc) +{ + GParamSpec *param_spec; + + param_spec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), + property_name); + + if (! param_spec) + g_warning ("%s: %s has no property named '%s'", + strloc, + g_type_name (G_TYPE_FROM_INSTANCE (object)), + property_name); + + return param_spec; +} + +static GParamSpec * +check_param_spec (GObject *object, + const gchar *property_name, + GType type, + const gchar *strloc) +{ + GParamSpec *param_spec; + + param_spec = find_param_spec (object, property_name, strloc); + + if (param_spec && ! g_type_is_a (G_TYPE_FROM_INSTANCE (param_spec), type)) + { + g_warning ("%s: property '%s' of %s is not a %s", + strloc, + param_spec->name, + g_type_name (param_spec->owner_type), + g_type_name (type)); + return NULL; + } + + return param_spec; +} + +static GParamSpec * +check_param_spec_w (GObject *object, + const gchar *property_name, + GType type, + const gchar *strloc) +{ + GParamSpec *param_spec; + + param_spec = check_param_spec (object, property_name, type, strloc); + + if (param_spec && + (param_spec->flags & G_PARAM_WRITABLE) == 0) + { + g_warning ("%s: property '%s' of %s is not writable", + strloc, + param_spec->name, + g_type_name (param_spec->owner_type)); + return NULL; + } + + return param_spec; +} + +static gboolean +get_numeric_values (GObject *object, + GParamSpec *param_spec, + gdouble *value, + gdouble *lower, + gdouble *upper, + const gchar *strloc) +{ + if (G_IS_PARAM_SPEC_INT (param_spec)) + { + GParamSpecInt *int_spec = G_PARAM_SPEC_INT (param_spec); + gint int_value; + + g_object_get (object, param_spec->name, &int_value, NULL); + + *value = int_value; + *lower = int_spec->minimum; + *upper = int_spec->maximum; + } + else if (G_IS_PARAM_SPEC_UINT (param_spec)) + { + GParamSpecUInt *uint_spec = G_PARAM_SPEC_UINT (param_spec); + guint uint_value; + + g_object_get (object, param_spec->name, &uint_value, NULL); + + *value = uint_value; + *lower = uint_spec->minimum; + *upper = uint_spec->maximum; + } + else if (G_IS_PARAM_SPEC_DOUBLE (param_spec)) + { + GParamSpecDouble *double_spec = G_PARAM_SPEC_DOUBLE (param_spec); + + g_object_get (object, param_spec->name, value, NULL); + + *lower = double_spec->minimum; + *upper = double_spec->maximum; + } + else + { + g_warning ("%s: property '%s' of %s is not numeric", + strloc, + param_spec->name, + g_type_name (G_TYPE_FROM_INSTANCE (object))); + return FALSE; + } + + return TRUE; +} + +static void +connect_notify (GObject *config, + const gchar *property_name, + GCallback callback, + gpointer callback_data) +{ + gchar *notify_name; + + notify_name = g_strconcat ("notify::", property_name, NULL); + + g_signal_connect_object (config, notify_name, callback, callback_data, 0); + + g_free (notify_name); +} |