summaryrefslogtreecommitdiffstats
path: root/app/widgets/gimppropwidgets.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--app/widgets/gimppropwidgets.c2355
1 files changed, 2355 insertions, 0 deletions
diff --git a/app/widgets/gimppropwidgets.c b/app/widgets/gimppropwidgets.c
new file mode 100644
index 0000000..22c0486
--- /dev/null
+++ b/app/widgets/gimppropwidgets.c
@@ -0,0 +1,2355 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * gimppropwidgets.c
+ * Copyright (C) 2002-2004 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 <stdlib.h>
+
+#include <gegl.h>
+#include <gegl-paramspecs.h>
+#include <gtk/gtk.h>
+
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpmath/gimpmath.h"
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "widgets-types.h"
+
+#include "core/gimpcontext.h"
+#include "core/gimpviewable.h"
+
+#include "gimpcolorbar.h"
+#include "gimpcolorpanel.h"
+#include "gimpcompressioncombobox.h"
+#include "gimpdial.h"
+#include "gimpdnd.h"
+#include "gimphandlebar.h"
+#include "gimpiconpicker.h"
+#include "gimplanguagecombobox.h"
+#include "gimplanguageentry.h"
+#include "gimplayermodebox.h"
+#include "gimpscalebutton.h"
+#include "gimpspinscale.h"
+#include "gimpview.h"
+#include "gimppolar.h"
+#include "gimppropwidgets.h"
+#include "gimpwidgets-utils.h"
+
+#include "gimp-intl.h"
+
+
+/* utility function prototypes */
+
+static void set_param_spec (GObject *object,
+ GtkWidget *widget,
+ 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 void connect_notify (GObject *config,
+ const gchar *property_name,
+ GCallback callback,
+ gpointer callback_data);
+
+
+/*********************/
+/* expanding frame */
+/*********************/
+
+/**
+ * gimp_prop_expanding_frame_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of boolean property.
+ * @button_label: Toggle widget title appearing as a frame title.
+ * @child: Child #GtkWidget of the returned frame.
+ * @button: Pointer to the #GtkCheckButton used as frame title
+ * if not #NULL.
+ *
+ * Creates a #GimpFrame containing @child, using a #GtkCheckButton as a
+ * title whose value is tied to the boolean @property_name.
+ * @child will be visible when @property_name is #TRUE, hidden otherwise.
+ * If @button_label is #NULL, the @property_name's nick will be used as
+ * label of the #GtkCheckButton title.
+ *
+ * Return value: A new #GimpFrame widget.
+ *
+ * Since GIMP 2.4
+ */
+GtkWidget *
+gimp_prop_expanding_frame_new (GObject *config,
+ const gchar *property_name,
+ const gchar *button_label,
+ GtkWidget *child,
+ GtkWidget **button)
+{
+ GParamSpec *param_spec;
+ GtkWidget *frame;
+ GtkWidget *toggle;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_BOOLEAN, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ if (! button_label)
+ button_label = g_param_spec_get_nick (param_spec);
+
+ frame = gimp_frame_new (NULL);
+
+ toggle = gimp_prop_check_button_new (config, property_name, button_label);
+ gtk_frame_set_label_widget (GTK_FRAME (frame), toggle);
+ gtk_widget_show (toggle);
+
+ gtk_container_add (GTK_CONTAINER (frame), child);
+
+ g_object_bind_property (G_OBJECT (config), property_name,
+ G_OBJECT (child), "visible",
+ G_BINDING_SYNC_CREATE);
+
+ if (button)
+ *button = toggle;
+
+ return frame;
+}
+
+
+/**********************/
+/* boolean icon box */
+/**********************/
+
+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);
+
+GtkWidget *
+gimp_prop_boolean_icon_box_new (GObject *config,
+ const gchar *property_name,
+ const gchar *true_icon,
+ const gchar *false_icon,
+ const gchar *true_tooltip,
+ const gchar *false_tooltip)
+{
+ GParamSpec *param_spec;
+ GtkWidget *box;
+ GtkWidget *button;
+ GtkWidget *first_button;
+ GtkWidget *image;
+ GSList *group = NULL;
+ 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);
+
+ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+
+ button = first_button = gtk_radio_button_new (group);
+ group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
+ gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+ gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ image = gtk_image_new_from_icon_name (true_icon, GTK_ICON_SIZE_MENU);
+ if (image)
+ {
+ gtk_container_add (GTK_CONTAINER (button), image);
+ gtk_widget_show (image);
+ }
+
+ gimp_help_set_help_data (button, true_tooltip, NULL);
+
+
+ g_object_set_data (G_OBJECT (button), "gimp-item-data",
+ GINT_TO_POINTER (TRUE));
+
+ set_param_spec (G_OBJECT (button), NULL, param_spec);
+
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (gimp_prop_radio_button_callback),
+ config);
+
+ button = gtk_radio_button_new (group);
+ gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+ gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ image = gtk_image_new_from_icon_name (false_icon, GTK_ICON_SIZE_MENU);
+ if (image)
+ {
+ gtk_container_add (GTK_CONTAINER (button), image);
+ gtk_widget_show (image);
+ }
+
+ gimp_help_set_help_data (button, false_tooltip, NULL);
+
+ g_object_set_data (G_OBJECT (button), "gimp-item-data",
+ GINT_TO_POINTER (FALSE));
+
+ set_param_spec (G_OBJECT (button), NULL, param_spec);
+
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (gimp_prop_radio_button_callback),
+ config);
+
+ gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (first_button), value);
+
+ 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);
+}
+
+
+/********************/
+/* layer mode box */
+/********************/
+
+/**
+ * gimp_prop_layer_mode_box_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of Enum property.
+ * @context: A context mask, determining the set of modes to
+ * include in the menu.
+ *
+ * Creates a #GimpLayerModeBox widget to display and set the specified
+ * Enum property, for which the enum must be #GimpLayerMode.
+ *
+ * Return value: The newly created #GimpLayerModeBox widget.
+ *
+ * Since GIMP 2.10
+ */
+GtkWidget *
+gimp_prop_layer_mode_box_new (GObject *config,
+ const gchar *property_name,
+ GimpLayerModeContext context)
+{
+ GParamSpec *param_spec;
+ GtkWidget *box;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_ENUM, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ box = gimp_layer_mode_box_new (context);
+
+ g_object_bind_property (config, property_name,
+ G_OBJECT (box), "layer-mode",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE);
+
+ return box;
+}
+
+
+/******************/
+/* color button */
+/******************/
+
+static void gimp_prop_color_button_callback (GtkWidget *widget,
+ GObject *config);
+static void gimp_prop_color_button_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *button);
+
+/**
+ * gimp_prop_color_button_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of #GimpRGB property.
+ * @title: Title of the #GimpColorPanel that is to be created
+ * @width: Width of color button.
+ * @height: Height of color button.
+ * @type: How transparency is represented.
+ *
+ * Creates a #GimpColorPanel to set and display the value of a #GimpRGB
+ * property. Pressing the button brings up a color selector dialog.
+ * If @title is #NULL, the @property_name's nick will be used as label
+ * of the returned widget.
+ *
+ * Return value: A new #GimpColorPanel widget.
+ *
+ * Since GIMP 2.4
+ */
+GtkWidget *
+gimp_prop_color_button_new (GObject *config,
+ const gchar *property_name,
+ const gchar *title,
+ gint width,
+ gint height,
+ GimpColorAreaType type)
+{
+ GParamSpec *param_spec;
+ GtkWidget *button;
+ GimpRGB *value;
+
+ param_spec = check_param_spec_w (config, property_name,
+ GIMP_TYPE_PARAM_RGB, 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);
+
+ button = gimp_color_panel_new (title, value, type, width, height);
+ g_free (value);
+
+ set_param_spec (G_OBJECT (button), button, param_spec);
+
+ g_signal_connect (button, "color-changed",
+ G_CALLBACK (gimp_prop_color_button_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_color_button_notify),
+ button);
+
+ return button;
+}
+
+static void
+gimp_prop_color_button_callback (GtkWidget *button,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ GimpRGB value;
+
+ param_spec = get_param_spec (G_OBJECT (button));
+ if (! param_spec)
+ return;
+
+ gimp_color_button_get_color (GIMP_COLOR_BUTTON (button), &value);
+
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_color_button_notify,
+ button);
+
+ g_object_set (config,
+ param_spec->name, &value,
+ NULL);
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_color_button_notify,
+ button);
+}
+
+static void
+gimp_prop_color_button_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *button)
+{
+ GimpRGB *value;
+
+ g_object_get (config,
+ param_spec->name, &value,
+ NULL);
+
+ g_signal_handlers_block_by_func (button,
+ gimp_prop_color_button_callback,
+ config);
+
+ gimp_color_button_set_color (GIMP_COLOR_BUTTON (button), value);
+
+ g_free (value);
+
+ g_signal_handlers_unblock_by_func (button,
+ gimp_prop_color_button_callback,
+ config);
+}
+
+
+/******************/
+/* scale button */
+/******************/
+
+static void gimp_prop_scale_button_callback (GtkWidget *widget,
+ gdouble value,
+ GObject *config);
+static void gimp_prop_scale_button_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *button);
+
+/**
+ * gimp_prop_scale_button_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of gdouble property
+ *
+ * Creates a #GimpScaleButton to set and display the value of a
+ * gdouble property in a very space-efficient way.
+ *
+ * Return value: A new #GimpScaleButton widget.
+ *
+ * Since GIMP 2.6
+ */
+GtkWidget *
+gimp_prop_scale_button_new (GObject *config,
+ const gchar *property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *button;
+ gdouble value;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_DOUBLE, G_STRFUNC);
+
+ if (! param_spec)
+ return NULL;
+
+ g_object_get (config,
+ param_spec->name, &value,
+ NULL);
+
+ button = gimp_scale_button_new (value,
+ G_PARAM_SPEC_DOUBLE (param_spec)->minimum,
+ G_PARAM_SPEC_DOUBLE (param_spec)->maximum);
+
+ set_param_spec (G_OBJECT (button), button, param_spec);
+
+ g_signal_connect (button, "value-changed",
+ G_CALLBACK (gimp_prop_scale_button_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_scale_button_notify),
+ button);
+
+ return button;
+}
+
+static void
+gimp_prop_scale_button_callback (GtkWidget *button,
+ gdouble value,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ gdouble v;
+
+ param_spec = get_param_spec (G_OBJECT (button));
+ if (! param_spec)
+ return;
+
+ g_object_get (config, param_spec->name, &v, NULL);
+
+ if (v != value)
+ {
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_scale_button_notify,
+ button);
+
+ g_object_set (config, param_spec->name, value, NULL);
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_scale_button_notify,
+ button);
+ }
+}
+
+static void
+gimp_prop_scale_button_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *button)
+{
+ gdouble value;
+
+ g_object_get (config,
+ param_spec->name, &value,
+ NULL);
+
+ g_signal_handlers_block_by_func (button,
+ gimp_prop_scale_button_callback,
+ config);
+
+ gtk_scale_button_set_value (GTK_SCALE_BUTTON (button), value);
+
+ g_signal_handlers_unblock_by_func (button,
+ gimp_prop_scale_button_callback,
+ config);
+}
+
+
+/*****************/
+/* 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_scale_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of gdouble property
+ * @label: Label of the created #GimpSpinScale.
+ * @step_increment:
+ * @page_increment:
+ * @digits:
+ *
+ * Creates a #GimpSpinScale to set and display the value of a
+ * gdouble property in a very space-efficient way.
+ * If @label is #NULL, the @property_name's nick will be used as label
+ * of the returned widget.
+ * The property's lower and upper values will be used as min/max of the
+ * #GimpSpinScale.
+ *
+ * Return value: A new #GimpSpinScale widget.
+ *
+ * Since GIMP 2.8
+ */
+GtkWidget *
+gimp_prop_spin_scale_new (GObject *config,
+ const gchar *property_name,
+ const gchar *label,
+ gdouble step_increment,
+ gdouble page_increment,
+ gint digits)
+{
+ GParamSpec *param_spec;
+ GtkAdjustment *adjustment;
+ GtkWidget *scale;
+ gdouble value;
+ gdouble lower;
+ gdouble upper;
+
+ param_spec = find_param_spec (config, property_name, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ /* The generic min and max for the property. */
+ if (! _gimp_prop_widgets_get_numeric_values (config, param_spec,
+ &value, &lower, &upper,
+ G_STRFUNC))
+ return NULL;
+
+ /* Get label. */
+ if (! label)
+ label = g_param_spec_get_nick (param_spec);
+
+ /* Also usable on int properties. */
+ 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 = gimp_spin_scale_new (adjustment, label, digits);
+
+ set_param_spec (G_OBJECT (adjustment), scale, param_spec);
+
+ if (GEGL_IS_PARAM_SPEC_DOUBLE (param_spec))
+ {
+ GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (param_spec);
+
+ gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale),
+ gspec->ui_minimum, gspec->ui_maximum);
+ gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), gspec->ui_gamma);
+ }
+ else if (GEGL_IS_PARAM_SPEC_INT (param_spec))
+ {
+ GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (param_spec);
+
+ gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale),
+ gspec->ui_minimum, gspec->ui_maximum);
+ gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), gspec->ui_gamma);
+ }
+
+ 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;
+}
+
+void
+gimp_prop_widget_set_factor (GtkWidget *widget,
+ gdouble factor,
+ gdouble step_increment,
+ gdouble page_increment,
+ gint digits)
+{
+ GtkAdjustment *adjustment;
+ gdouble *factor_store;
+ gdouble old_factor = 1.0;
+ gdouble f;
+
+ g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
+ g_return_if_fail (factor != 0.0);
+ g_return_if_fail (digits >= 0);
+
+ 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);
+}
+
+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);
+ }
+}
+
+
+/************/
+/* angles */
+/************/
+
+static gboolean
+deg_to_rad (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data)
+{
+ gdouble *lower = user_data;
+ gdouble value = g_value_get_double (from_value);
+
+ if (lower && *lower != 0.0)
+ {
+ if (value < 0.0)
+ value += 360.0;
+ }
+
+ value *= G_PI / 180.0;
+
+ g_value_set_double (to_value, value);
+
+ return TRUE;
+}
+
+static gboolean
+rad_to_deg (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data)
+{
+ gdouble *lower = user_data;
+ gdouble value = g_value_get_double (from_value);
+
+ value *= 180.0 / G_PI;
+
+ if (lower && *lower != 0.0)
+ {
+ if (value > (*lower + 360.0))
+ value -= 360.0;
+ }
+
+ g_value_set_double (to_value, value);
+
+ return TRUE;
+}
+
+/**
+ * gimp_prop_angle_dial_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @property_name: Name of gdouble property
+ *
+ * Creates a #GimpDial to set and display the value of a
+ * gdouble property that represents an angle.
+ *
+ * Return value: A new #GimpDial widget.
+ *
+ * Since GIMP 2.10
+ */
+GtkWidget *
+gimp_prop_angle_dial_new (GObject *config,
+ const gchar *property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *dial;
+ gdouble value;
+ gdouble lower;
+ gdouble upper;
+
+ param_spec = find_param_spec (config, property_name, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ if (! _gimp_prop_widgets_get_numeric_values (config, param_spec,
+ &value, &lower, &upper,
+ G_STRFUNC))
+ return NULL;
+
+ dial = gimp_dial_new ();
+
+ g_object_set (dial,
+ "size", 32,
+ "background", GIMP_CIRCLE_BACKGROUND_PLAIN,
+ "draw-beta", FALSE,
+ NULL);
+
+ set_param_spec (G_OBJECT (dial), dial, param_spec);
+
+ if (lower == 0.0 && upper == 2 * G_PI)
+ {
+ g_object_bind_property (config, property_name,
+ dial, "alpha",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE);
+ }
+ else if ((upper - lower) == 360.0)
+ {
+ gdouble *l = g_new0 (gdouble, 1);
+
+ *l = lower;
+
+ g_object_bind_property_full (config, property_name,
+ dial, "alpha",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE,
+ deg_to_rad,
+ rad_to_deg,
+ l, (GDestroyNotify) g_free);
+ }
+
+ return dial;
+}
+
+GtkWidget *
+gimp_prop_angle_range_dial_new (GObject *config,
+ const gchar *alpha_property_name,
+ const gchar *beta_property_name,
+ const gchar *clockwise_property_name)
+{
+ GParamSpec *alpha_param_spec;
+ GParamSpec *beta_param_spec;
+ GParamSpec *clockwise_param_spec;
+ GtkWidget *dial;
+
+ alpha_param_spec = find_param_spec (config, alpha_property_name, G_STRFUNC);
+ if (! alpha_param_spec)
+ return NULL;
+
+ beta_param_spec = find_param_spec (config, beta_property_name, G_STRFUNC);
+ if (! beta_param_spec)
+ return NULL;
+
+ clockwise_param_spec = find_param_spec (config, clockwise_property_name, G_STRFUNC);
+ if (! clockwise_param_spec)
+ return NULL;
+
+ dial = gimp_dial_new ();
+
+ g_object_set (dial,
+ "size", 96,
+ "border-width", 0,
+ "background", GIMP_CIRCLE_BACKGROUND_HSV,
+ NULL);
+
+ g_object_bind_property_full (config, alpha_property_name,
+ dial, "alpha",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE,
+ deg_to_rad,
+ rad_to_deg,
+ NULL, NULL);
+
+ g_object_bind_property_full (config, beta_property_name,
+ dial, "beta",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE,
+ deg_to_rad,
+ rad_to_deg,
+ NULL, NULL);
+
+ g_object_bind_property (config, clockwise_property_name,
+ dial, "clockwise-delta",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE);
+
+ return dial;
+}
+
+GtkWidget *
+gimp_prop_polar_new (GObject *config,
+ const gchar *angle_property_name,
+ const gchar *radius_property_name)
+{
+ GParamSpec *angle_param_spec;
+ GParamSpec *radius_param_spec;
+ GtkWidget *polar;
+
+ angle_param_spec = find_param_spec (config, angle_property_name, G_STRFUNC);
+ if (! angle_param_spec)
+ return NULL;
+
+ radius_param_spec = find_param_spec (config, radius_property_name, G_STRFUNC);
+ if (! radius_param_spec)
+ return NULL;
+
+ polar = gimp_polar_new ();
+
+ g_object_set (polar,
+ "size", 90,
+ "border-width", 3,
+ "background", GIMP_CIRCLE_BACKGROUND_HSV,
+ NULL);
+
+ g_object_bind_property_full (config, angle_property_name,
+ polar, "angle",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE,
+ deg_to_rad,
+ rad_to_deg,
+ NULL, NULL);
+
+ g_object_bind_property (config, radius_property_name,
+ polar, "radius",
+ G_BINDING_BIDIRECTIONAL |
+ G_BINDING_SYNC_CREATE);
+
+ return polar;
+}
+
+
+/************/
+/* ranges */
+/************/
+
+#define RANGE_GRADIENT_HEIGHT 12
+#define RANGE_CONTROL_HEIGHT 10
+
+GtkWidget *
+gimp_prop_range_new (GObject *config,
+ const gchar *lower_property_name,
+ const gchar *upper_property_name,
+ gdouble step_increment,
+ gdouble page_increment,
+ gint digits,
+ gboolean sorted)
+{
+ GtkWidget *vbox;
+ GtkWidget *color_bar;
+ GtkWidget *handle_bar;
+ GtkWidget *hbox;
+ GtkWidget *spin_button;
+ GtkAdjustment *adjustment1;
+ GtkAdjustment *adjustment2;
+
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+
+ color_bar = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL);
+ gtk_widget_set_size_request (color_bar, -1, RANGE_GRADIENT_HEIGHT);
+ gtk_box_pack_start (GTK_BOX (vbox), color_bar, FALSE, FALSE, 0);
+ gtk_widget_show (color_bar);
+
+ handle_bar = gimp_handle_bar_new (GTK_ORIENTATION_HORIZONTAL);
+ gtk_widget_set_size_request (handle_bar, -1, RANGE_CONTROL_HEIGHT);
+ gtk_box_pack_start (GTK_BOX (vbox), handle_bar, FALSE, FALSE, 0);
+ gtk_widget_show (handle_bar);
+
+ gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar), color_bar);
+
+ g_object_set_data (G_OBJECT (vbox), "gimp-range-handle-bar", handle_bar);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ spin_button = gimp_prop_spin_button_new (config, lower_property_name,
+ step_increment, page_increment,
+ digits);
+ adjustment1 = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin_button));
+ gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin_button), TRUE);
+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);
+ gtk_widget_show (spin_button);
+
+ gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 0, adjustment1);
+
+ spin_button = gimp_prop_spin_button_new (config, upper_property_name,
+ step_increment, page_increment,
+ digits);
+ adjustment2 = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin_button));
+ gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin_button), TRUE);
+ gtk_box_pack_end (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);
+ gtk_widget_show (spin_button);
+
+ gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 2, adjustment2);
+
+ if (sorted)
+ gimp_gtk_adjustment_chain (adjustment1, adjustment2);
+
+ return vbox;
+}
+
+void
+gimp_prop_range_set_ui_limits (GtkWidget *widget,
+ gdouble lower,
+ gdouble upper)
+{
+ GimpHandleBar *handle_bar;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ handle_bar = g_object_get_data (G_OBJECT (widget), "gimp-range-handle-bar");
+
+ gimp_handle_bar_set_limits (handle_bar, lower, upper);
+}
+
+
+/**********/
+/* view */
+/**********/
+
+static void gimp_prop_view_drop (GtkWidget *menu,
+ gint x,
+ gint y,
+ GimpViewable *viewable,
+ gpointer data);
+static void gimp_prop_view_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *view);
+
+/**
+ * gimp_prop_view_new:
+ * @config: #GimpConfig object to which property is attached.
+ * @context: a #Gimpcontext.
+ * @property_name: Name of #GimpViewable property.
+ * @size: Width and height of preview display.
+ *
+ * Creates a widget to display the value of a #GimpViewable property.
+ *
+ * Return value: A new #GimpView widget.
+ *
+ * Since GIMP 2.4
+ */
+GtkWidget *
+gimp_prop_view_new (GObject *config,
+ const gchar *property_name,
+ GimpContext *context,
+ gint size)
+{
+ GParamSpec *param_spec;
+ GtkWidget *view;
+ GimpViewable *viewable;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_OBJECT, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ if (! g_type_is_a (param_spec->value_type, GIMP_TYPE_VIEWABLE))
+ {
+ g_warning ("%s: property '%s' of %s is not a GimpViewable",
+ G_STRFUNC, property_name,
+ g_type_name (G_TYPE_FROM_INSTANCE (config)));
+ return NULL;
+ }
+
+ view = gimp_view_new_by_types (context,
+ GIMP_TYPE_VIEW,
+ param_spec->value_type,
+ size, 0, FALSE);
+
+ if (! view)
+ {
+ g_warning ("%s: cannot create view for type '%s'",
+ G_STRFUNC, g_type_name (param_spec->value_type));
+ return NULL;
+ }
+
+ g_object_get (config,
+ property_name, &viewable,
+ NULL);
+
+ if (viewable)
+ {
+ gimp_view_set_viewable (GIMP_VIEW (view), viewable);
+ g_object_unref (viewable);
+ }
+
+ set_param_spec (G_OBJECT (view), view, param_spec);
+
+ gimp_dnd_viewable_dest_add (view, param_spec->value_type,
+ gimp_prop_view_drop,
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_view_notify),
+ view);
+
+ return view;
+}
+
+static void
+gimp_prop_view_drop (GtkWidget *view,
+ gint x,
+ gint y,
+ GimpViewable *viewable,
+ gpointer data)
+{
+ GObject *config;
+ GParamSpec *param_spec;
+
+ param_spec = get_param_spec (G_OBJECT (view));
+ if (! param_spec)
+ return;
+
+ config = G_OBJECT (data);
+
+ g_object_set (config,
+ param_spec->name, viewable,
+ NULL);
+}
+
+static void
+gimp_prop_view_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *view)
+{
+ GimpViewable *viewable;
+
+ g_object_get (config,
+ param_spec->name, &viewable,
+ NULL);
+
+ gimp_view_set_viewable (GIMP_VIEW (view), viewable);
+
+ if (viewable)
+ g_object_unref (viewable);
+}
+
+
+/***********************
+ * number pair entry *
+ ***********************/
+
+typedef struct
+{
+ GObject *config;
+ const gchar *left_number_property;
+ const gchar *right_number_property;
+ const gchar *default_left_number_property;
+ const gchar *default_right_number_property;
+ const gchar *user_override_property;
+} GimpPropNumberPairEntryData;
+
+static void
+gimp_prop_number_pair_entry_data_free (GimpPropNumberPairEntryData *data)
+{
+ g_slice_free (GimpPropNumberPairEntryData, data);
+}
+
+
+static void gimp_prop_number_pair_entry_config_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkEntry *entry);
+static void gimp_prop_number_pair_entry_number_pair_numbers_changed
+ (GtkWidget *widget,
+ GimpPropNumberPairEntryData *data);
+static void gimp_prop_number_pair_entry_number_pair_user_override_notify
+ (GtkWidget *entry,
+ GParamSpec *param_spec,
+ GimpPropNumberPairEntryData *data);
+
+
+/**
+ * gimp_prop_number_pair_entry_new:
+ * @config: Object to which properties are attached.
+ * @left_number_property: Name of double property for left number.
+ * @right_number_property: Name of double property for right number.
+ * @default_left_number_property: Name of double property for default left number.
+ * @default_right_number_property: Name of double property for default right number.
+ * @user_override_property: Name of boolean property for user override mode.
+ * @connect_numbers_changed: %TRUE to connect to the widgets "numbers-changed"
+ * signal, %FALSE to not connect.
+ * @connect_ratio_changed: %TRUE to connect to the widgets "ratio-changed"
+ * signal, %FALSE to not connect.
+ * @separators:
+ * @allow_simplification:
+ * @min_valid_value:
+ * @max_valid_value: What to pass to gimp_number_pair_entry_new ().
+ *
+ * Return value: A #GimpNumberPairEntry widget.
+ */
+GtkWidget *
+gimp_prop_number_pair_entry_new (GObject *config,
+ const gchar *left_number_property,
+ const gchar *right_number_property,
+ const gchar *default_left_number_property,
+ const gchar *default_right_number_property,
+ const gchar *user_override_property,
+ gboolean connect_numbers_changed,
+ gboolean connect_ratio_changed,
+ const gchar *separators,
+ gboolean allow_simplification,
+ gdouble min_valid_value,
+ gdouble max_valid_value)
+{
+ GimpPropNumberPairEntryData *data;
+ GtkWidget *number_pair_entry;
+ gdouble left_number;
+ gdouble right_number;
+ gdouble default_left_number;
+ gdouble default_right_number;
+ gboolean user_override;
+
+
+ /* Setup config data */
+
+ data = g_slice_new (GimpPropNumberPairEntryData);
+
+ data->config = config;
+ data->left_number_property = left_number_property;
+ data->right_number_property = right_number_property;
+ data->default_left_number_property = default_left_number_property;
+ data->default_right_number_property = default_right_number_property;
+ data->user_override_property = user_override_property;
+
+
+ /* Read current values of config properties */
+
+ g_object_get (config,
+ left_number_property, &left_number,
+ right_number_property, &right_number,
+ default_left_number_property, &default_left_number,
+ default_right_number_property, &default_right_number,
+ user_override_property, &user_override,
+ NULL);
+
+
+ /* Create a GimpNumberPairEntry and setup with config property values */
+
+ number_pair_entry = gimp_number_pair_entry_new (separators,
+ allow_simplification,
+ min_valid_value,
+ max_valid_value);
+
+ g_object_set_data_full (G_OBJECT (number_pair_entry),
+ "gimp-prop-number-pair-entry-data", data,
+ (GDestroyNotify) gimp_prop_number_pair_entry_data_free);
+
+ gtk_entry_set_width_chars (GTK_ENTRY (number_pair_entry), 7);
+
+ gimp_number_pair_entry_set_user_override (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ user_override);
+ gimp_number_pair_entry_set_values (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ left_number,
+ right_number);
+ gimp_number_pair_entry_set_default_values (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ default_left_number,
+ default_right_number);
+
+
+ /* Connect to GimpNumberPairEntry signals */
+
+ if (connect_ratio_changed)
+ g_signal_connect (number_pair_entry, "ratio-changed",
+ G_CALLBACK (gimp_prop_number_pair_entry_number_pair_numbers_changed),
+ data);
+
+ if (connect_numbers_changed)
+ g_signal_connect (number_pair_entry, "numbers-changed",
+ G_CALLBACK (gimp_prop_number_pair_entry_number_pair_numbers_changed),
+ data);
+
+ g_signal_connect (number_pair_entry, "notify::user-override",
+ G_CALLBACK (gimp_prop_number_pair_entry_number_pair_user_override_notify),
+ data);
+
+
+ /* Connect to connfig object signals */
+
+ connect_notify (config, left_number_property,
+ G_CALLBACK (gimp_prop_number_pair_entry_config_notify),
+ number_pair_entry);
+ connect_notify (config, right_number_property,
+ G_CALLBACK (gimp_prop_number_pair_entry_config_notify),
+ number_pair_entry);
+ connect_notify (config, default_left_number_property,
+ G_CALLBACK (gimp_prop_number_pair_entry_config_notify),
+ number_pair_entry);
+ connect_notify (config, default_right_number_property,
+ G_CALLBACK (gimp_prop_number_pair_entry_config_notify),
+ number_pair_entry);
+ connect_notify (config, user_override_property,
+ G_CALLBACK (gimp_prop_number_pair_entry_config_notify),
+ number_pair_entry);
+
+
+ /* Done */
+
+ return number_pair_entry;
+}
+
+static void
+gimp_prop_number_pair_entry_config_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkEntry *number_pair_entry)
+{
+ GimpPropNumberPairEntryData *data =
+ g_object_get_data (G_OBJECT (number_pair_entry),
+ "gimp-prop-number-pair-entry-data");
+
+ g_return_if_fail (data != NULL);
+
+ if (strcmp (param_spec->name, data->left_number_property) == 0 ||
+ strcmp (param_spec->name, data->right_number_property) == 0)
+ {
+ gdouble left_number;
+ gdouble right_number;
+
+ g_object_get (config,
+ data->left_number_property, &left_number,
+ data->right_number_property, &right_number,
+ NULL);
+
+ gimp_number_pair_entry_set_values (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ left_number,
+ right_number);
+ }
+ else if (strcmp (param_spec->name, data->default_left_number_property) == 0 ||
+ strcmp (param_spec->name, data->default_right_number_property) == 0)
+ {
+ gdouble default_left_number;
+ gdouble default_right_number;
+
+ g_object_get (config,
+ data->default_left_number_property, &default_left_number,
+ data->default_right_number_property, &default_right_number,
+ NULL);
+
+ gimp_number_pair_entry_set_default_values (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ default_left_number,
+ default_right_number);
+ }
+ else if (strcmp (param_spec->name, data->user_override_property) == 0)
+ {
+ gboolean user_override;
+
+ g_object_get (config,
+ data->user_override_property, &user_override,
+ NULL);
+
+ gimp_number_pair_entry_set_user_override (GIMP_NUMBER_PAIR_ENTRY (number_pair_entry),
+ user_override);
+ }
+}
+
+static void
+gimp_prop_number_pair_entry_number_pair_numbers_changed (GtkWidget *widget,
+ GimpPropNumberPairEntryData *data)
+{
+ gdouble left_number;
+ gdouble right_number;
+
+ gimp_number_pair_entry_get_values (GIMP_NUMBER_PAIR_ENTRY (widget),
+ &left_number,
+ &right_number);
+
+ g_object_set (data->config,
+ data->left_number_property, left_number,
+ data->right_number_property, right_number,
+ NULL);
+}
+
+static void
+gimp_prop_number_pair_entry_number_pair_user_override_notify (GtkWidget *entry,
+ GParamSpec *param_spec,
+ GimpPropNumberPairEntryData *data)
+
+{
+ gboolean old_config_user_override;
+ gboolean new_config_user_override;
+
+ g_object_get (data->config,
+ data->user_override_property, &old_config_user_override,
+ NULL);
+
+ new_config_user_override =
+ gimp_number_pair_entry_get_user_override (GIMP_NUMBER_PAIR_ENTRY (entry));
+
+ /* Only set when property changed, to avoid deadlocks */
+ if (new_config_user_override != old_config_user_override)
+ g_object_set (data->config,
+ data->user_override_property, new_config_user_override,
+ NULL);
+}
+
+
+/************************/
+/* language combo-box */
+/************************/
+
+static void gimp_prop_language_combo_box_callback (GtkWidget *combo,
+ GObject *config);
+static void gimp_prop_language_combo_box_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *combo);
+
+GtkWidget *
+gimp_prop_language_combo_box_new (GObject *config,
+ const gchar *property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *combo;
+ gchar *value;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_STRING, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ combo = gimp_language_combo_box_new (FALSE, NULL);
+
+ g_object_get (config,
+ property_name, &value,
+ NULL);
+
+ gimp_language_combo_box_set_code (GIMP_LANGUAGE_COMBO_BOX (combo), value);
+ g_free (value);
+
+ set_param_spec (G_OBJECT (combo), combo, param_spec);
+
+ g_signal_connect (combo, "changed",
+ G_CALLBACK (gimp_prop_language_combo_box_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_language_combo_box_notify),
+ combo);
+
+ return combo;
+}
+
+static void
+gimp_prop_language_combo_box_callback (GtkWidget *combo,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ gchar *code;
+
+ param_spec = get_param_spec (G_OBJECT (combo));
+ if (! param_spec)
+ return;
+
+ code = gimp_language_combo_box_get_code (GIMP_LANGUAGE_COMBO_BOX (combo));
+
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_language_combo_box_notify,
+ combo);
+
+ g_object_set (config,
+ param_spec->name, code,
+ NULL);
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_language_combo_box_notify,
+ combo);
+
+ g_free (code);
+}
+
+static void
+gimp_prop_language_combo_box_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *combo)
+{
+ gchar *value;
+
+ g_object_get (config,
+ param_spec->name, &value,
+ NULL);
+
+ g_signal_handlers_block_by_func (combo,
+ gimp_prop_language_combo_box_callback,
+ config);
+
+ gimp_language_combo_box_set_code (GIMP_LANGUAGE_COMBO_BOX (combo), value);
+
+ g_signal_handlers_unblock_by_func (combo,
+ gimp_prop_language_combo_box_callback,
+ config);
+
+ g_free (value);
+}
+
+
+/********************/
+/* language entry */
+/********************/
+
+static void gimp_prop_language_entry_callback (GtkWidget *entry,
+ GObject *config);
+static void gimp_prop_language_entry_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *entry);
+
+GtkWidget *
+gimp_prop_language_entry_new (GObject *config,
+ const gchar *property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *entry;
+ gchar *value;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_STRING, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ entry = gimp_language_entry_new ();
+
+ g_object_get (config,
+ property_name, &value,
+ NULL);
+
+ gimp_language_entry_set_code (GIMP_LANGUAGE_ENTRY (entry), value);
+ g_free (value);
+
+ set_param_spec (G_OBJECT (entry), entry, param_spec);
+
+ g_signal_connect (entry, "changed",
+ G_CALLBACK (gimp_prop_language_entry_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_language_entry_notify),
+ entry);
+
+ return entry;
+}
+
+static void
+gimp_prop_language_entry_callback (GtkWidget *entry,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ const gchar *code;
+
+ param_spec = get_param_spec (G_OBJECT (entry));
+ if (! param_spec)
+ return;
+
+ code = gimp_language_entry_get_code (GIMP_LANGUAGE_ENTRY (entry));
+
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_language_entry_notify,
+ entry);
+
+ g_object_set (config,
+ param_spec->name, code,
+ NULL);
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_language_entry_notify,
+ entry);
+}
+
+static void
+gimp_prop_language_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_language_entry_callback,
+ config);
+
+ gimp_language_entry_set_code (GIMP_LANGUAGE_ENTRY (entry), value);
+
+ g_signal_handlers_unblock_by_func (entry,
+ gimp_prop_language_entry_callback,
+ config);
+
+ g_free (value);
+}
+
+
+/***********************/
+/* profile combo box */
+/***********************/
+
+static void gimp_prop_profile_combo_callback (GimpColorProfileComboBox *combo,
+ GObject *config);
+static void gimp_prop_profile_combo_notify (GObject *config,
+ const GParamSpec *param_spec,
+ GimpColorProfileComboBox *combo);
+
+GtkWidget *
+gimp_prop_profile_combo_box_new (GObject *config,
+ const gchar *property_name,
+ GtkListStore *profile_store,
+ const gchar *dialog_title,
+ GObject *profile_path_config,
+ const gchar *profile_path_property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *dialog;
+ GtkWidget *combo;
+ GFile *file = NULL;
+
+ param_spec = find_param_spec (config, property_name, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ if (G_IS_PARAM_SPEC_STRING (param_spec))
+ {
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_STRING, G_STRFUNC);
+ }
+ else
+ {
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_OBJECT, G_STRFUNC);
+ }
+
+ if (! param_spec)
+ return NULL;
+
+ dialog = gimp_color_profile_chooser_dialog_new (dialog_title, NULL,
+ GTK_FILE_CHOOSER_ACTION_OPEN);
+
+ if (profile_path_config && profile_path_property_name)
+ gimp_color_profile_chooser_dialog_connect_path (dialog,
+ profile_path_config,
+ profile_path_property_name);
+
+ if (G_IS_PARAM_SPEC_STRING (param_spec))
+ {
+ gchar *path;
+
+ g_object_get (config,
+ property_name, &path,
+ NULL);
+
+ if (path)
+ {
+ file = gimp_file_new_for_config_path (path, NULL);
+ g_free (path);
+ }
+ }
+ else
+ {
+ g_object_get (config, property_name, &file, NULL);
+ }
+
+ if (profile_store)
+ {
+ combo = gimp_color_profile_combo_box_new_with_model (dialog,
+ GTK_TREE_MODEL (profile_store));
+ }
+ else
+ {
+ gchar *filename;
+
+ filename = gimp_personal_rc_file ("profilerc");
+ combo = gimp_color_profile_combo_box_new (dialog, filename);
+ g_free (filename);
+ }
+
+ gimp_color_profile_combo_box_set_active_file (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
+ file, NULL);
+
+ if (file)
+ g_object_unref (file);
+
+ set_param_spec (G_OBJECT (combo), combo, param_spec);
+
+ g_signal_connect (combo, "changed",
+ G_CALLBACK (gimp_prop_profile_combo_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_profile_combo_notify),
+ combo);
+
+ return combo;
+}
+
+static void
+gimp_prop_profile_combo_callback (GimpColorProfileComboBox *combo,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ GFile *file;
+
+ param_spec = get_param_spec (G_OBJECT (combo));
+ if (! param_spec)
+ return;
+
+ file = gimp_color_profile_combo_box_get_active_file (combo);
+
+ if (! file)
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_profile_combo_notify,
+ combo);
+
+ if (G_IS_PARAM_SPEC_STRING (param_spec))
+ {
+ gchar *path = NULL;
+
+ if (file)
+ path = gimp_file_get_config_path (file, NULL);
+
+ g_object_set (config,
+ param_spec->name, path,
+ NULL);
+
+ g_free (path);
+ }
+ else
+ {
+ g_object_set (config,
+ param_spec->name, file,
+ NULL);
+ }
+
+ if (! file)
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_profile_combo_notify,
+ combo);
+
+ if (file)
+ g_object_unref (file);
+}
+
+static void
+gimp_prop_profile_combo_notify (GObject *config,
+ const GParamSpec *param_spec,
+ GimpColorProfileComboBox *combo)
+{
+ GFile *file = NULL;
+
+ if (G_IS_PARAM_SPEC_STRING (param_spec))
+ {
+ gchar *path;
+
+ g_object_get (config,
+ param_spec->name, &path,
+ NULL);
+
+ if (path)
+ {
+ file = gimp_file_new_for_config_path (path, NULL);
+ g_free (path);
+ }
+ }
+ else
+ {
+ g_object_get (config,
+ param_spec->name, &file,
+ NULL);
+
+ }
+
+ g_signal_handlers_block_by_func (combo,
+ gimp_prop_profile_combo_callback,
+ config);
+
+ gimp_color_profile_combo_box_set_active_file (combo, file, NULL);
+
+ g_signal_handlers_unblock_by_func (combo,
+ gimp_prop_profile_combo_callback,
+ config);
+
+ if (file)
+ g_object_unref (file);
+}
+
+
+/***************************/
+/* compression combo box */
+/***************************/
+
+static void gimp_prop_compression_combo_box_callback (GtkWidget *combo,
+ GObject *config);
+static void gimp_prop_compression_combo_box_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *combo);
+
+GtkWidget *
+gimp_prop_compression_combo_box_new (GObject *config,
+ const gchar *property_name)
+{
+ GParamSpec *param_spec;
+ GtkWidget *combo;
+ gchar *value;
+
+ param_spec = check_param_spec_w (config, property_name,
+ G_TYPE_PARAM_STRING, G_STRFUNC);
+ if (! param_spec)
+ return NULL;
+
+ combo = gimp_compression_combo_box_new ();
+
+ g_object_get (config,
+ property_name, &value,
+ NULL);
+
+ gimp_compression_combo_box_set_compression (
+ GIMP_COMPRESSION_COMBO_BOX (combo), value);
+ g_free (value);
+
+ set_param_spec (G_OBJECT (combo), combo, param_spec);
+
+ g_signal_connect (combo, "changed",
+ G_CALLBACK (gimp_prop_compression_combo_box_callback),
+ config);
+
+ connect_notify (config, property_name,
+ G_CALLBACK (gimp_prop_compression_combo_box_notify),
+ combo);
+
+ return combo;
+}
+
+static void
+gimp_prop_compression_combo_box_callback (GtkWidget *combo,
+ GObject *config)
+{
+ GParamSpec *param_spec;
+ gchar *compression;
+
+ param_spec = get_param_spec (G_OBJECT (combo));
+ if (! param_spec)
+ return;
+
+ compression = gimp_compression_combo_box_get_compression (
+ GIMP_COMPRESSION_COMBO_BOX (combo));
+
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_compression_combo_box_notify,
+ combo);
+
+ g_object_set (config,
+ param_spec->name, compression,
+ NULL);
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_compression_combo_box_notify,
+ combo);
+
+ g_free (compression);
+}
+
+static void
+gimp_prop_compression_combo_box_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *combo)
+{
+ gchar *value;
+
+ g_object_get (config,
+ param_spec->name, &value,
+ NULL);
+
+ g_signal_handlers_block_by_func (combo,
+ gimp_prop_compression_combo_box_callback,
+ config);
+
+ gimp_compression_combo_box_set_compression (
+ GIMP_COMPRESSION_COMBO_BOX (combo), value);
+
+ g_signal_handlers_unblock_by_func (combo,
+ gimp_prop_compression_combo_box_callback,
+ config);
+
+ g_free (value);
+}
+
+
+/*****************/
+/* icon picker */
+/*****************/
+
+static void gimp_prop_icon_picker_callback (GtkWidget *picker,
+ GParamSpec *param_spec,
+ GObject *config);
+static void gimp_prop_icon_picker_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *picker);
+
+GtkWidget *
+gimp_prop_icon_picker_new (GimpViewable *viewable,
+ Gimp *gimp)
+{
+ GObject *object = G_OBJECT (viewable);
+ GtkWidget *picker = NULL;
+ GdkPixbuf *pixbuf_value = NULL;
+ gchar *icon_name_value = NULL;
+
+ picker = gimp_icon_picker_new (gimp);
+
+ g_object_get (object,
+ "icon-name", &icon_name_value,
+ "icon-pixbuf", &pixbuf_value,
+ NULL);
+
+ gimp_icon_picker_set_icon_name (GIMP_ICON_PICKER (picker), icon_name_value);
+ gimp_icon_picker_set_icon_pixbuf (GIMP_ICON_PICKER (picker), pixbuf_value);
+
+ g_signal_connect (picker, "notify::icon-pixbuf",
+ G_CALLBACK (gimp_prop_icon_picker_callback),
+ object);
+
+ g_signal_connect (picker, "notify::icon-name",
+ G_CALLBACK (gimp_prop_icon_picker_callback),
+ object);
+
+ connect_notify (object, "icon-name",
+ G_CALLBACK (gimp_prop_icon_picker_notify),
+ picker);
+
+ connect_notify (object, "icon-pixbuf",
+ G_CALLBACK (gimp_prop_icon_picker_notify),
+ picker);
+
+ if (icon_name_value)
+ g_free (icon_name_value);
+ if (pixbuf_value)
+ g_object_unref (pixbuf_value);
+
+ return picker;
+}
+
+static void
+gimp_prop_icon_picker_callback (GtkWidget *picker,
+ GParamSpec *param_spec,
+ GObject *config)
+{
+ g_signal_handlers_block_by_func (config,
+ gimp_prop_icon_picker_notify,
+ picker);
+
+ if (! strcmp (param_spec->name, "icon-name"))
+ {
+ const gchar *value = gimp_icon_picker_get_icon_name (GIMP_ICON_PICKER (picker));
+
+ g_object_set (config,
+ "icon-name", value,
+ NULL);
+
+ }
+ else if (! strcmp (param_spec->name, "icon-pixbuf"))
+ {
+ GdkPixbuf *value = gimp_icon_picker_get_icon_pixbuf (GIMP_ICON_PICKER (picker));
+
+ g_object_set (config,
+ "icon-pixbuf", value,
+ NULL);
+ }
+
+
+ g_signal_handlers_unblock_by_func (config,
+ gimp_prop_icon_picker_notify,
+ picker);
+}
+
+static void
+gimp_prop_icon_picker_notify (GObject *config,
+ GParamSpec *param_spec,
+ GtkWidget *picker)
+{
+ g_signal_handlers_block_by_func (picker,
+ gimp_prop_icon_picker_callback,
+ config);
+
+ if (!strcmp (param_spec->name, "icon-name"))
+ {
+ gchar *value = NULL;
+
+ g_object_get (config,
+ "icon-name", &value,
+ NULL);
+
+ gimp_icon_picker_set_icon_name (GIMP_ICON_PICKER (picker), value);
+
+ if (value)
+ g_free (value);
+ }
+ else if (!strcmp (param_spec->name, "icon-pixbuf"))
+ {
+ GdkPixbuf *value = NULL;
+
+ g_object_get (config,
+ "icon-pixbuf", &value,
+ NULL);
+
+ gimp_icon_picker_set_icon_pixbuf (GIMP_ICON_PICKER (picker), value);
+
+ if (value)
+ g_object_unref (value);
+ }
+
+ g_signal_handlers_unblock_by_func (picker,
+ gimp_prop_icon_picker_callback,
+ config);
+}
+
+
+/******************************/
+/* public utility functions */
+/******************************/
+
+gboolean
+_gimp_prop_widgets_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;
+}
+
+
+/*******************************/
+/* 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 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 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);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-05 01:32:13 +0000