summaryrefslogtreecommitdiffstats
path: root/app/propgui/gimppropgui.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
commit3c57dd931145d43f2b0aef96c4d178135956bf91 (patch)
tree3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/propgui/gimppropgui.c
parentInitial commit. (diff)
downloadgimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz
gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'app/propgui/gimppropgui.c')
-rw-r--r--app/propgui/gimppropgui.c702
1 files changed, 702 insertions, 0 deletions
diff --git a/app/propgui/gimppropgui.c b/app/propgui/gimppropgui.c
new file mode 100644
index 0000000..fcc9a7e
--- /dev/null
+++ b/app/propgui/gimppropgui.c
@@ -0,0 +1,702 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * gimppropgui.c
+ * Copyright (C) 2002-2017 Michael Natterer <mitch@gimp.org>
+ * Sven Neumann <sven@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gegl-paramspecs.h>
+#include <gtk/gtk.h>
+
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "propgui-types.h"
+
+#include "gegl/gimp-gegl-utils.h"
+
+#include "operations/gimp-operation-config.h"
+
+#include "core/gimpcontext.h"
+
+#include "widgets/gimpcolorpanel.h"
+#include "widgets/gimpmessagebox.h"
+#include "widgets/gimpspinscale.h"
+#include "widgets/gimppropwidgets.h"
+
+#include "gimppropgui.h"
+#include "gimppropgui-channel-mixer.h"
+#include "gimppropgui-color-balance.h"
+#include "gimppropgui-color-rotate.h"
+#include "gimppropgui-color-to-alpha.h"
+#include "gimppropgui-convolution-matrix.h"
+#include "gimppropgui-diffraction-patterns.h"
+#include "gimppropgui-eval.h"
+#include "gimppropgui-focus-blur.h"
+#include "gimppropgui-generic.h"
+#include "gimppropgui-hue-saturation.h"
+#include "gimppropgui-motion-blur-circular.h"
+#include "gimppropgui-motion-blur-linear.h"
+#include "gimppropgui-motion-blur-zoom.h"
+#include "gimppropgui-newsprint.h"
+#include "gimppropgui-panorama-projection.h"
+#include "gimppropgui-recursive-transform.h"
+#include "gimppropgui-shadows-highlights.h"
+#include "gimppropgui-spiral.h"
+#include "gimppropgui-supernova.h"
+#include "gimppropgui-utils.h"
+#include "gimppropgui-vignette.h"
+
+#include "gimp-intl.h"
+
+
+#define HAS_KEY(p,k,v) gimp_gegl_param_spec_has_key (p, k, v)
+
+
+static gboolean gimp_prop_string_to_boolean (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data);
+static void gimp_prop_config_notify (GObject *config,
+ GParamSpec *pspec,
+ GtkWidget *widget);
+static void gimp_prop_widget_show (GtkWidget *widget,
+ GObject *config);
+static void gimp_prop_free_label_ref (GWeakRef *label_ref);
+
+/* public functions */
+
+GtkWidget *
+gimp_prop_widget_new (GObject *config,
+ const gchar *property_name,
+ GeglRectangle *area,
+ GimpContext *context,
+ GimpCreatePickerFunc create_picker_func,
+ GimpCreateControllerFunc create_controller_func,
+ gpointer creator,
+ const gchar **label)
+{
+ GParamSpec *pspec;
+
+ g_return_val_if_fail (G_IS_OBJECT (config), NULL);
+
+ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (config),
+ property_name);
+
+ return gimp_prop_widget_new_from_pspec (config, pspec, area, context,
+ create_picker_func,
+ create_controller_func,
+ creator,
+ label);
+}
+
+GtkWidget *
+gimp_prop_widget_new_from_pspec (GObject *config,
+ GParamSpec *pspec,
+ GeglRectangle *area,
+ GimpContext *context,
+ GimpCreatePickerFunc create_picker_func,
+ GimpCreateControllerFunc create_controller_func,
+ gpointer creator,
+ const gchar **label)
+{
+ GtkWidget *widget = NULL;
+
+ g_return_val_if_fail (G_IS_OBJECT (config), NULL);
+ g_return_val_if_fail (pspec != NULL, NULL);
+ g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
+ g_return_val_if_fail (label != NULL, NULL);
+
+ *label = NULL;
+
+ if (GEGL_IS_PARAM_SPEC_SEED (pspec))
+ {
+ widget = gimp_prop_random_seed_new (config, pspec->name);
+
+ *label = g_param_spec_get_nick (pspec);
+ }
+ else if (G_IS_PARAM_SPEC_INT (pspec) ||
+ G_IS_PARAM_SPEC_UINT (pspec) ||
+ G_IS_PARAM_SPEC_FLOAT (pspec) ||
+ G_IS_PARAM_SPEC_DOUBLE (pspec))
+ {
+ gdouble lower;
+ gdouble upper;
+ gdouble step;
+ gdouble page;
+ gint digits;
+
+ if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
+ {
+ GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
+
+ lower = gspec->ui_minimum;
+ upper = gspec->ui_maximum;
+ step = gspec->ui_step_small;
+ page = gspec->ui_step_big;
+ digits = gspec->ui_digits;
+ }
+ else if (GEGL_IS_PARAM_SPEC_INT (pspec))
+ {
+ GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
+
+ lower = gspec->ui_minimum;
+ upper = gspec->ui_maximum;
+ step = gspec->ui_step_small;
+ page = gspec->ui_step_big;
+ digits = 0;
+ }
+ else
+ {
+ gdouble value;
+
+ /* Get the min and max for the given property. */
+ _gimp_prop_widgets_get_numeric_values (config, pspec,
+ &value, &lower, &upper,
+ G_STRFUNC);
+
+ if ((upper - lower <= 1.0) &&
+ (G_IS_PARAM_SPEC_FLOAT (pspec) ||
+ G_IS_PARAM_SPEC_DOUBLE (pspec)))
+ {
+ step = 0.01;
+ page = 0.1;
+ digits = 4;
+ }
+ else if ((upper - lower <= 10.0) &&
+ (G_IS_PARAM_SPEC_FLOAT (pspec) ||
+ G_IS_PARAM_SPEC_DOUBLE (pspec)))
+ {
+ step = 0.1;
+ page = 1.0;
+ digits = 3;
+ }
+ else
+ {
+ step = 1.0;
+ page = 10.0;
+ digits = (G_IS_PARAM_SPEC_FLOAT (pspec) ||
+ G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0;
+ }
+ }
+
+ widget = gimp_prop_spin_scale_new (config, pspec->name, NULL,
+ step, page, digits);
+
+ if (HAS_KEY (pspec, "unit", "degree") &&
+ (upper - lower) == 360.0)
+ {
+ GtkWidget *hbox;
+ GtkWidget *dial;
+
+ gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), TRUE);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
+
+ gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+ gtk_widget_show (widget);
+
+ dial = gimp_prop_angle_dial_new (config, pspec->name);
+ g_object_set (dial,
+ "clockwise-angles", HAS_KEY (pspec, "direction", "cw"),
+ NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), dial, FALSE, FALSE, 0);
+ gtk_widget_show (dial);
+
+ gimp_help_set_help_data (hbox, g_param_spec_get_blurb (pspec), NULL);
+ gimp_prop_gui_bind_label (hbox, widget);
+
+ widget = hbox;
+ }
+ else if (HAS_KEY (pspec, "unit", "kelvin"))
+ {
+ GtkWidget *hbox;
+ GtkWidget *button;
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
+
+ gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+ gtk_widget_show (widget);
+
+ button = gimp_prop_kelvin_presets_new (config, pspec->name);
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ gimp_help_set_help_data (hbox, g_param_spec_get_blurb (pspec), NULL);
+ gimp_prop_gui_bind_label (hbox, widget);
+
+ widget = hbox;
+ }
+ else
+ {
+ gimp_prop_gui_bind_label (widget, widget);
+
+ if (area &&
+ (HAS_KEY (pspec, "unit", "pixel-coordinate") ||
+ HAS_KEY (pspec, "unit", "pixel-distance")) &&
+ (HAS_KEY (pspec, "axis", "x") ||
+ HAS_KEY (pspec, "axis", "y")))
+ {
+ gdouble min = lower;
+ gdouble max = upper;
+
+ if (HAS_KEY (pspec, "unit", "pixel-coordinate"))
+ {
+ /* limit pixel coordinate scales to the actual area */
+
+ gint off_x = area->x;
+ gint off_y = area->y;
+
+ if (HAS_KEY (pspec, "axis", "x"))
+ {
+ min = MAX (lower, off_x);
+ max = MIN (upper, off_x + area->width);
+ }
+ else if (HAS_KEY (pspec, "axis","y"))
+ {
+ min = MAX (lower, off_y);
+ max = MIN (upper, off_y + area->height);
+ }
+ }
+ else if (HAS_KEY (pspec, "unit", "pixel-distance"))
+ {
+ /* limit pixel distance scales to the same value on the
+ * x and y axes, so linked values have the same range,
+ * we use MAX (width, height), see issue #2540
+ */
+
+ max = MIN (upper, MAX (area->width, area->height));
+ }
+
+ gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget),
+ min, max);
+ }
+ }
+ }
+ else if (G_IS_PARAM_SPEC_STRING (pspec))
+ {
+ *label = g_param_spec_get_nick (pspec);
+
+ if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec))
+ {
+ widget =
+ gimp_prop_file_chooser_button_new (config, pspec->name,
+ g_param_spec_get_nick (pspec),
+ GTK_FILE_CHOOSER_ACTION_OPEN);
+ }
+ else if (HAS_KEY (pspec, "multiline", "true"))
+ {
+ GtkTextBuffer *buffer;
+ GtkWidget *view;
+
+ buffer = gimp_prop_text_buffer_new (config, pspec->name, -1);
+ view = gtk_text_view_new_with_buffer (buffer);
+ g_object_unref (buffer);
+
+ widget = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_size_request (widget, -1, 150);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget),
+ GTK_SHADOW_IN);
+ gtk_container_add (GTK_CONTAINER (widget), view);
+ gtk_widget_show (view);
+ }
+ else if (HAS_KEY (pspec, "error", "true"))
+ {
+ GtkWidget *l;
+
+ widget = gimp_message_box_new (GIMP_ICON_WILBER_EEK);
+ gimp_message_box_set_primary_text (GIMP_MESSAGE_BOX (widget), "%s",
+ *label);
+ gimp_message_box_set_text (GIMP_MESSAGE_BOX (widget), "%s", "");
+
+ l = GIMP_MESSAGE_BOX (widget)->label[1];
+
+ g_object_bind_property (config, pspec->name,
+ l, "label",
+ G_BINDING_SYNC_CREATE);
+ g_object_bind_property_full (config, pspec->name,
+ widget, "visible",
+ G_BINDING_SYNC_CREATE,
+ gimp_prop_string_to_boolean,
+ NULL,
+ NULL, NULL);
+ *label = NULL;
+ }
+ else
+ {
+ widget = gimp_prop_entry_new (config, pspec->name, -1);
+ }
+
+ }
+ else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
+ {
+ widget = gimp_prop_check_button_new (config, pspec->name,
+ g_param_spec_get_nick (pspec));
+
+ gimp_prop_gui_bind_label (widget, widget);
+ }
+ else if (G_IS_PARAM_SPEC_ENUM (pspec))
+ {
+ widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0);
+ gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget),
+ g_param_spec_get_nick (pspec));
+
+ gimp_prop_gui_bind_label (widget, widget);
+ }
+ else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
+ {
+ gboolean has_alpha;
+ GtkWidget *button;
+
+ has_alpha = gimp_param_spec_rgb_has_alpha (pspec);
+
+ widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
+
+ button = gimp_prop_color_button_new (config, pspec->name,
+ g_param_spec_get_nick (pspec),
+ 128, 24,
+ has_alpha ?
+ GIMP_COLOR_AREA_SMALL_CHECKS :
+ GIMP_COLOR_AREA_FLAT);
+ gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE);
+ gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context);
+ gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0);
+ gtk_widget_show (button);
+
+ gimp_prop_gui_bind_tooltip (button, widget);
+
+ if (create_picker_func)
+ {
+ button = create_picker_func (creator,
+ pspec->name,
+ GIMP_ICON_COLOR_PICKER_GRAY,
+ _("Pick color from the image"),
+ /* pick_abyss = */ FALSE,
+ NULL, NULL);
+ gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+ }
+
+ *label = g_param_spec_get_nick (pspec);
+ }
+ else
+ {
+ g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
+ g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
+ }
+
+ /* if we have any keys for dynamic properties, listen to config's notify
+ * signal, and update the properties accordingly.
+ */
+ if (gegl_param_spec_get_property_key (pspec, "sensitive") ||
+ gegl_param_spec_get_property_key (pspec, "visible") ||
+ gegl_param_spec_get_property_key (pspec, "label") ||
+ gegl_param_spec_get_property_key (pspec, "description"))
+ {
+ g_object_set_data (G_OBJECT (widget), "gimp-prop-pspec", pspec);
+
+ g_signal_connect_object (config, "notify",
+ G_CALLBACK (gimp_prop_config_notify),
+ widget, 0);
+
+ if (gegl_param_spec_get_property_key (pspec, "visible"))
+ {
+ /* a bit of a hack: if we have a dynamic "visible" property key,
+ * connect to the widget's "show" signal, so that we can intercept
+ * our caller's gtk_widget_show() call, and keep the widget hidden if
+ * necessary.
+ */
+ g_signal_connect (widget, "show",
+ G_CALLBACK (gimp_prop_widget_show),
+ config);
+ }
+
+ /* update all the properties now */
+ gimp_prop_config_notify (config, NULL, widget);
+ }
+
+ return widget;
+}
+
+
+typedef GtkWidget * (* GimpPropGuiNewFunc) (GObject *config,
+ GParamSpec **param_specs,
+ guint n_param_specs,
+ GeglRectangle *area,
+ GimpContext *context,
+ GimpCreatePickerFunc create_picker_func,
+ GimpCreateControllerFunc create_controller_func,
+ gpointer creator);
+
+static const struct
+{
+ const gchar *config_type;
+ GimpPropGuiNewFunc gui_new_func;
+}
+gui_new_funcs[] =
+{
+ { "GimpColorBalanceConfig",
+ _gimp_prop_gui_new_color_balance },
+ { "GimpHueSaturationConfig",
+ _gimp_prop_gui_new_hue_saturation },
+ { "GimpGegl-gegl-color-rotate-config",
+ _gimp_prop_gui_new_color_rotate },
+ { "GimpGegl-gegl-color-to-alpha-config",
+ _gimp_prop_gui_new_color_to_alpha },
+ { "GimpGegl-gegl-convolution-matrix-config",
+ _gimp_prop_gui_new_convolution_matrix },
+ { "GimpGegl-gegl-channel-mixer-config",
+ _gimp_prop_gui_new_channel_mixer },
+ { "GimpGegl-gegl-diffraction-patterns-config",
+ _gimp_prop_gui_new_diffraction_patterns },
+ { "GimpGegl-gegl-focus-blur-config",
+ _gimp_prop_gui_new_focus_blur },
+ { "GimpGegl-gegl-motion-blur-circular-config",
+ _gimp_prop_gui_new_motion_blur_circular },
+ { "GimpGegl-gegl-motion-blur-linear-config",
+ _gimp_prop_gui_new_motion_blur_linear },
+ { "GimpGegl-gegl-motion-blur-zoom-config",
+ _gimp_prop_gui_new_motion_blur_zoom },
+ { "GimpGegl-gegl-newsprint-config",
+ _gimp_prop_gui_new_newsprint },
+ { "GimpGegl-gegl-panorama-projection-config",
+ _gimp_prop_gui_new_panorama_projection },
+ { "GimpGegl-gegl-recursive-transform-config",
+ _gimp_prop_gui_new_recursive_transform },
+ { "GimpGegl-gegl-shadows-highlights-config",
+ _gimp_prop_gui_new_shadows_highlights },
+ { "GimpGegl-gegl-spiral-config",
+ _gimp_prop_gui_new_spiral },
+ { "GimpGegl-gegl-supernova-config",
+ _gimp_prop_gui_new_supernova },
+ { "GimpGegl-gegl-vignette-config",
+ _gimp_prop_gui_new_vignette },
+ { NULL,
+ _gimp_prop_gui_new_generic }
+};
+
+
+GtkWidget *
+gimp_prop_gui_new (GObject *config,
+ GType owner_type,
+ GParamFlags flags,
+ GeglRectangle *area,
+ GimpContext *context,
+ GimpCreatePickerFunc create_picker_func,
+ GimpCreateControllerFunc create_controller_func,
+ gpointer creator)
+{
+ GtkWidget *gui = NULL;
+ GParamSpec **param_specs;
+ guint n_param_specs;
+
+ g_return_val_if_fail (G_IS_OBJECT (config), NULL);
+ g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
+
+ param_specs = gimp_operation_config_list_properties (config,
+ owner_type, flags,
+ &n_param_specs);
+
+ if (param_specs)
+ {
+ const gchar *config_type_name = G_OBJECT_TYPE_NAME (config);
+ gint i;
+
+ for (i = 0; i < G_N_ELEMENTS (gui_new_funcs); i++)
+ {
+ if (! gui_new_funcs[i].config_type ||
+ ! strcmp (gui_new_funcs[i].config_type, config_type_name))
+ {
+ g_printerr ("GUI new func match: %s\n",
+ gui_new_funcs[i].config_type ?
+ gui_new_funcs[i].config_type : "generic fallback");
+
+ gui = gui_new_funcs[i].gui_new_func (config,
+ param_specs, n_param_specs,
+ area,
+ context,
+ create_picker_func,
+ create_controller_func,
+ creator);
+ break;
+ }
+ }
+
+ g_free (param_specs);
+ }
+ else
+ {
+ gui = gtk_label_new (_("This operation has no editable properties"));
+ gimp_label_set_attributes (GTK_LABEL (gui),
+ PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
+ -1);
+ gtk_misc_set_padding (GTK_MISC (gui), 0, 4);
+ }
+
+ return gui;
+}
+
+void
+gimp_prop_gui_bind_container (GtkWidget *source,
+ GtkWidget *target)
+{
+ g_object_bind_property (source, "sensitive",
+ target, "sensitive",
+ G_BINDING_SYNC_CREATE);
+ g_object_bind_property (source, "visible",
+ target, "visible",
+ G_BINDING_SYNC_CREATE);
+}
+
+void
+gimp_prop_gui_bind_label (GtkWidget *source,
+ GtkWidget *target)
+{
+ GWeakRef *label_ref;
+ const gchar *label;
+
+ /* we want to update "target"'s "label" property whenever the label
+ * expression associated with "source" is reevaluated, however, "source"
+ * might not itself have a "label" property we can bind to. just keep around
+ * a reference to "target", and update its label manually.
+ */
+ g_return_if_fail (g_object_get_data (G_OBJECT (source),
+ "gimp-prop-label-ref") == NULL);
+
+ label_ref = g_slice_new (GWeakRef);
+
+ g_weak_ref_init (label_ref, target);
+
+ g_object_set_data_full (G_OBJECT (source),
+ "gimp-prop-label-ref", label_ref,
+ (GDestroyNotify) gimp_prop_free_label_ref);
+
+ label = g_object_get_data (G_OBJECT (source), "gimp-prop-label");
+
+ if (label)
+ g_object_set (target, "label", label, NULL);
+
+ /* note that "source" might be its own label widget, in which case there's no
+ * need to bind the rest of the properties.
+ */
+ if (source != target)
+ gimp_prop_gui_bind_tooltip (source, target);
+}
+
+void
+gimp_prop_gui_bind_tooltip (GtkWidget *source,
+ GtkWidget *target)
+{
+ g_object_bind_property (source, "tooltip-text",
+ target, "tooltip-text",
+ G_BINDING_SYNC_CREATE);
+}
+
+
+/* private functions */
+
+static gboolean
+gimp_prop_string_to_boolean (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data)
+{
+ const gchar *string = g_value_get_string (from_value);
+
+ g_value_set_boolean (to_value, string && *string);
+
+ return TRUE;
+}
+
+static void
+gimp_prop_config_notify (GObject *config,
+ GParamSpec *pspec,
+ GtkWidget *widget)
+{
+ GParamSpec *widget_pspec;
+ GWeakRef *label_ref;
+ GtkWidget *label_widget;
+ gboolean sensitive;
+ gboolean visible;
+ gchar *label;
+ gchar *description;
+
+ widget_pspec = g_object_get_data (G_OBJECT (widget), "gimp-prop-pspec");
+ label_ref = g_object_get_data (G_OBJECT (widget), "gimp-prop-label-ref");
+
+ if (label_ref)
+ label_widget = g_weak_ref_get (label_ref);
+ else
+ label_widget = NULL;
+
+ sensitive = gimp_prop_eval_boolean (config, widget_pspec, "sensitive", TRUE);
+ visible = gimp_prop_eval_boolean (config, widget_pspec, "visible", TRUE);
+ label = gimp_prop_eval_string (config, widget_pspec, "label",
+ g_param_spec_get_nick (widget_pspec));
+ description = gimp_prop_eval_string (config, widget_pspec, "description",
+ g_param_spec_get_blurb (widget_pspec));
+
+ /* we store the label in (and pass ownership over it to) the widget's
+ * "gimp-prop-label" key, so that we can use it to initialize the label
+ * widget's label in gimp_prop_gui_bind_label() upon binding.
+ */
+ g_object_set_data_full (G_OBJECT (widget), "gimp-prop-label", label, g_free);
+
+ g_signal_handlers_block_by_func (widget,
+ gimp_prop_widget_show, config);
+
+ gtk_widget_set_sensitive (widget, sensitive);
+ gtk_widget_set_visible (widget, visible);
+ if (label_widget) g_object_set (label_widget, "label", label, NULL);
+ gimp_help_set_help_data (widget, description, NULL);
+
+ g_signal_handlers_unblock_by_func (widget,
+ gimp_prop_widget_show, config);
+
+ g_free (description);
+
+ if (label_widget)
+ g_object_unref (label_widget);
+}
+
+static void
+gimp_prop_widget_show (GtkWidget *widget,
+ GObject *config)
+{
+ GParamSpec *widget_pspec;
+ gboolean visible;
+
+ widget_pspec = g_object_get_data (G_OBJECT (widget), "gimp-prop-pspec");
+
+ visible = gimp_prop_eval_boolean (config, widget_pspec, "visible", TRUE);
+
+ gtk_widget_set_visible (widget, visible);
+}
+
+static void
+gimp_prop_free_label_ref (GWeakRef *label_ref)
+{
+ g_weak_ref_clear (label_ref);
+
+ g_slice_free (GWeakRef, label_ref);
+}