dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/libgimpwidgets/gimplabelspin.c

530 lines
17 KiB
C
Raw Normal View History

libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimplabelspin.c
* Copyright (C) 2020 Jehan
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* 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
* Library 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 <gegl.h>
#include <gtk/gtk.h>
#include "libgimpcolor/gimpcolor.h"
#include "libgimpmath/gimpmath.h"
#include "libgimpbase/gimpbase.h"
#include "gimpwidgets.h"
/**
* SECTION: gimplabelspin
* @title: GimpLabelSpin
* @short_description: Widget containing a spin button and a label.
*
* This widget is a subclass of #GimpLabeled with a #GimpSpinButton.
**/
enum
{
VALUE_CHANGED,
LAST_SIGNAL
};
enum
{
PROP_0,
PROP_VALUE,
PROP_LOWER,
PROP_UPPER,
PROP_DIGITS,
};
typedef struct _GimpLabelSpinPrivate
{
GimpLabeled parent_instance;
GtkWidget *spinbutton;
GtkAdjustment *spin_adjustment;
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gint digits;
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
} GimpLabelSpinPrivate;
static void gimp_label_spin_constructed (GObject *object);
static void gimp_label_spin_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_label_spin_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static GtkWidget * gimp_label_spin_populate (GimpLabeled *spin,
gint *x,
gint *y,
gint *width,
gint *height);
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
static void gimp_label_spin_update_spin_width (GimpLabelSpin *spin,
gdouble lower,
gdouble upper,
guint digits);
static void gimp_label_spin_update_settings (GimpLabelSpin *spin);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
G_DEFINE_TYPE_WITH_PRIVATE (GimpLabelSpin, gimp_label_spin, GIMP_TYPE_LABELED)
#define parent_class gimp_label_spin_parent_class
static guint gimp_label_spin_signals[LAST_SIGNAL] = { 0 };
static void
gimp_label_spin_class_init (GimpLabelSpinClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpLabeledClass *labeled_class = GIMP_LABELED_CLASS (klass);
gimp_label_spin_signals[VALUE_CHANGED] =
g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLabelSpinClass, value_changed),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
object_class->constructed = gimp_label_spin_constructed;
object_class->set_property = gimp_label_spin_set_property;
object_class->get_property = gimp_label_spin_get_property;
labeled_class->populate = gimp_label_spin_populate;
/**
* GimpLabelSpin:value:
*
* The currently set value.
*
* Since: 3.0
**/
g_object_class_install_property (object_class, PROP_VALUE,
g_param_spec_double ("value", NULL,
"Current value",
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
GIMP_PARAM_READWRITE));
/**
* GimpLabelSpin:lower:
*
* The lower bound of the spin button.
*
* Since: 3.0
**/
g_object_class_install_property (object_class, PROP_LOWER,
g_param_spec_double ("lower", NULL,
"Minimum value",
libgimpwidgets: fix #10821 Problem with LabelSpin widget For certain min/max values of the LabelSpin widget, in combination with zero digits, it proves impossible to change the initial value. The reason for this is that the step size may become less than 1.0. In which case, stepping doesn't work because the number of digits is set to zero. Let's check for this situation and when digits is zero set the step to 1.0 and make sure that page is at least the same value. While testing this I also noticed another issue: when initializing the upper value was set to 0.0 and the lower to 1.0 which leads to a critical because lower > upper. We fix this by switching the initial upper and lower values.
2024-04-17 09:44:12 +08:00
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/**
* GimpLabelSpin:upper:
*
* The upper bound of the spin button.
*
* Since: 3.0
**/
g_object_class_install_property (object_class, PROP_UPPER,
g_param_spec_double ("upper", NULL,
"Max value",
libgimpwidgets: fix #10821 Problem with LabelSpin widget For certain min/max values of the LabelSpin widget, in combination with zero digits, it proves impossible to change the initial value. The reason for this is that the step size may become less than 1.0. In which case, stepping doesn't work because the number of digits is set to zero. Let's check for this situation and when digits is zero set the step to 1.0 and make sure that page is at least the same value. While testing this I also noticed another issue: when initializing the upper value was set to 0.0 and the lower to 1.0 which leads to a critical because lower > upper. We fix this by switching the initial upper and lower values.
2024-04-17 09:44:12 +08:00
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/**
* GimpLabelSpin:digits:
*
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
* The number of decimal places to display. If -1, then the number is
* estimated.
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
*
* Since: 3.0
**/
g_object_class_install_property (object_class, PROP_DIGITS,
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
g_param_spec_int ("digits", NULL,
"The number of decimal places to display",
-1, G_MAXINT, -1,
GIMP_PARAM_READWRITE));
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
static void
gimp_label_spin_init (GimpLabelSpin *spin)
{
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
/* We want the adjustment to exist at init so that construction
* properties can apply (default values are bogus but should be
Issue #6446: Typo fixes.
2021-02-24 19:33:03 +08:00
* properly overridden with expected values if the object was created
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
* with gimp_label_spin_new().
*/
priv->spin_adjustment = gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 10.0, 0.0);
gtk_grid_set_row_spacing (GTK_GRID (spin), 6);
gtk_grid_set_column_spacing (GTK_GRID (spin), 6);
}
static void
gimp_label_spin_constructed (GObject *object)
{
GimpLabelSpin *spin = GIMP_LABEL_SPIN (object);
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
G_OBJECT_CLASS (parent_class)->constructed (object);
/* This is important to make this object into a property widget. It
* will allow config object to bind the "value" property of this
* widget, and therefore be updated automatically.
*/
g_object_bind_property (G_OBJECT (priv->spin_adjustment), "value",
G_OBJECT (spin), "value",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_update_settings (spin);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
static void
gimp_label_spin_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpLabelSpin *spin = GIMP_LABEL_SPIN (object);
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
switch (property_id)
{
case PROP_VALUE:
/* Avoid looping forever since we have bound this widget's
* "value" property with the spin button "value" property.
*/
if (gtk_adjustment_get_value (priv->spin_adjustment) != g_value_get_double (value))
gtk_adjustment_set_value (priv->spin_adjustment, g_value_get_double (value));
g_signal_emit (object, gimp_label_spin_signals[VALUE_CHANGED], 0);
break;
case PROP_LOWER:
gtk_adjustment_set_lower (priv->spin_adjustment,
g_value_get_double (value));
if (priv->spinbutton)
{
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_update_settings (spin);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
break;
case PROP_UPPER:
gtk_adjustment_set_upper (priv->spin_adjustment,
g_value_get_double (value));
if (priv->spinbutton)
{
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_update_settings (spin);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
break;
case PROP_DIGITS:
if (priv->spinbutton)
{
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
priv->digits = g_value_get_int (value);
gimp_label_spin_update_settings (spin);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_label_spin_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpLabelSpin *spin = GIMP_LABEL_SPIN (object);
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
GtkSpinButton *spinbutton = GTK_SPIN_BUTTON (priv->spinbutton);
switch (property_id)
{
case PROP_VALUE:
g_value_set_double (value, gtk_adjustment_get_value (priv->spin_adjustment));
break;
case PROP_LOWER:
g_value_set_double (value, gtk_adjustment_get_lower (priv->spin_adjustment));
break;
case PROP_UPPER:
g_value_set_double (value, gtk_adjustment_get_upper (priv->spin_adjustment));
break;
case PROP_DIGITS:
g_value_set_uint (value, gtk_spin_button_get_digits (spinbutton));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static GtkWidget *
gimp_label_spin_populate (GimpLabeled *labeled,
gint *x,
gint *y,
gint *width,
gint *height)
{
GimpLabelSpin *spin = GIMP_LABEL_SPIN (labeled);
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
priv->spinbutton = gimp_spin_button_new (priv->spin_adjustment, 2.0, 2.0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (priv->spinbutton), TRUE);
gtk_grid_attach (GTK_GRID (spin), priv->spinbutton, 1, 0, 1, 1);
gtk_widget_show (priv->spinbutton);
return priv->spinbutton;
}
static void
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_update_spin_width (GimpLabelSpin *spin,
gdouble lower,
gdouble upper,
guint digits)
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
{
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
gint width = 0;
g_return_if_fail (GIMP_IS_LABEL_SPIN (spin));
/* Necessary size to display the max/min integer values, with optional
* negative sign.
*/
width = (gint) floor (log10 (upper) + 1) + (upper < 0.0 ? 1 : 0);
width = MAX (width, (gint) floor (log10 (lower) + 1) + (lower < 0.0 ? 1 : 0));
/* Adding decimal digits and separator. */
width += (digits > 0 ? 1 + digits : 0);
/* Overlong spin button are useless. */
width = MIN (10, width);
gtk_entry_set_width_chars (GTK_ENTRY (priv->spinbutton), width);
}
static void
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_update_settings (GimpLabelSpin *spin)
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
{
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
gdouble lower;
gdouble upper;
gdouble step;
gdouble page;
gint digits = priv->digits;
libgimpwidgets: fix #10821 Problem with LabelSpin widget For certain min/max values of the LabelSpin widget, in combination with zero digits, it proves impossible to change the initial value. The reason for this is that the step size may become less than 1.0. In which case, stepping doesn't work because the number of digits is set to zero. Let's check for this situation and when digits is zero set the step to 1.0 and make sure that page is at least the same value. While testing this I also noticed another issue: when initializing the upper value was set to 0.0 and the lower to 1.0 which leads to a critical because lower > upper. We fix this by switching the initial upper and lower values.
2024-04-17 09:44:12 +08:00
gboolean adjust_step = (digits == 0);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
g_return_if_fail (GIMP_IS_LABEL_SPIN (spin));
g_object_get (spin,
"lower", &lower,
"upper", &upper,
NULL);
g_return_if_fail (upper >= lower);
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_range_estimate_settings (lower, upper, &step, &page,
digits < 0 ? &digits: NULL);
libgimpwidgets: fix #10821 Problem with LabelSpin widget For certain min/max values of the LabelSpin widget, in combination with zero digits, it proves impossible to change the initial value. The reason for this is that the step size may become less than 1.0. In which case, stepping doesn't work because the number of digits is set to zero. Let's check for this situation and when digits is zero set the step to 1.0 and make sure that page is at least the same value. While testing this I also noticed another issue: when initializing the upper value was set to 0.0 and the lower to 1.0 which leads to a critical because lower > upper. We fix this by switching the initial upper and lower values.
2024-04-17 09:44:12 +08:00
if (adjust_step && digits == 0 && step < 1.0)
{
step = 1.0;
if (page < step)
page = step;
}
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gimp_label_spin_set_increments (spin, step, page);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (priv->spinbutton), (guint) digits);
gimp_label_spin_update_spin_width (spin, lower, upper, (guint) digits);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
}
/* Public Functions */
/**
* gimp_label_spin_new:
* @text: The text for the #GtkLabel.
* @value: The initial value.
* @lower: The lower boundary.
* @upper: The upper boundary.
* @digits: The number of decimal digits.
*
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
* Suitable increment values are estimated based on the [@lower, @upper]
* range.
* If @digits is -1, then it will also be estimated based on the same
* range. Digits estimation will always be at least 1, so if you want to
* show integer values only, set 0 explicitly.
*
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
* Returns: (transfer full): The new #GimpLabelSpin widget.
**/
GtkWidget *
gimp_label_spin_new (const gchar *text,
gdouble value,
gdouble lower,
gdouble upper,
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
gint digits)
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
{
GtkWidget *labeled;
libgimp, libgimpbase, libgimpwidgets: new gimp_range_estimate_settings() Similar code was used in 2 places basically (GimpLabelSpin and GimpProcedureDialog) so just make it an utils function. It's good anyway to have a generic function to estimate suitable increments and decimal places depending on a range. As a consequence also gimp_label_spin_new() now takes a gint digits (instead of guint), with -1 meaning we want digits computed from the range. Similarly gimp_prop_scale_entry_new() docs adds the -1 meaning too.
2020-11-25 08:16:34 +08:00
g_return_val_if_fail (upper >= lower, NULL);
g_return_val_if_fail (digits >= -1, NULL);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
labeled = g_object_new (GIMP_TYPE_LABEL_SPIN,
"label", text,
"value", value,
"lower", lower,
"upper", upper,
"digits", digits,
NULL);
return labeled;
}
/**
* gimp_label_spin_set_value:
* @spin: The #GtkLabelSpin.
* @value: A new value.
*
* This function sets the value shown by @spin.
**/
void
gimp_label_spin_set_value (GimpLabelSpin *spin,
gdouble value)
{
g_return_if_fail (GIMP_IS_LABEL_SPIN (spin));
g_object_set (spin,
"value", value,
NULL);
}
/**
* gimp_label_spin_get_value:
* @spin: The #GtkLabelSpin.
*
* This function returns the value shown by @spin.
*
* Returns: The value currently set.
**/
gdouble
gimp_label_spin_get_value (GimpLabelSpin *spin)
{
gdouble value;
g_return_val_if_fail (GIMP_IS_LABEL_SPIN (spin), 0.0);
g_object_get (spin,
"value", &value,
NULL);
return value;
}
/**
* gimp_label_spin_set_increments:
* @spin: the #GimpLabelSpin.
* @step: the step increment.
* @page: the page increment.
*
* Set the step and page increments of the spin button.
* By default, these increment values are automatically computed
* depending on the range based on common usage. So you will likely not
* need to run this for most case. Yet if you want specific increments
* (which the widget cannot guess), you can call this function.
*/
void
gimp_label_spin_set_increments (GimpLabelSpin *spin,
gdouble step,
gdouble page)
{
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
GtkSpinButton *spinbutton;
gdouble lower;
gdouble upper;
g_return_if_fail (GIMP_IS_LABEL_SPIN (spin));
libgimpwidgets: improve gimp_label_spin_set_increments(). The assert tests were not taking well into account the case where upper == lower or where it's an integer spin which is just separated by 1 (both cases seem silly, but it makes sense in the case of generic — or even dynamic! — spin widgets where we want to adjust the min and max, e.g. depending on the property of the image, or on other settings.
2023-07-22 09:11:59 +08:00
g_return_if_fail (step <= page);
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
spinbutton = GTK_SPIN_BUTTON (priv->spinbutton);
gtk_spin_button_get_range (spinbutton, &lower, &upper);
g_return_if_fail (upper >= lower);
libgimpwidgets: improve gimp_label_spin_set_increments(). The assert tests were not taking well into account the case where upper == lower or where it's an integer spin which is just separated by 1 (both cases seem silly, but it makes sense in the case of generic — or even dynamic! — spin widgets where we want to adjust the min and max, e.g. depending on the property of the image, or on other settings.
2023-07-22 09:11:59 +08:00
g_return_if_fail ((upper == lower || step <= upper - lower) &&
(upper == lower || page <= upper - lower));
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
g_object_freeze_notify (G_OBJECT (spinbutton));
gtk_adjustment_set_step_increment (gtk_spin_button_get_adjustment (spinbutton), step);
gtk_adjustment_set_page_increment (gtk_spin_button_get_adjustment (spinbutton), page);
g_object_thaw_notify (G_OBJECT (spinbutton));
g_object_set (priv->spinbutton,
"climb-rate", step,
NULL);
}
libgimpwidgets: improved gimp_prop_scale_entry_new(), new function… … gimp_label_spin_set_digits() and deleted gimp_prop_opacity_entry_new() - The "digits" argument for the number of decimal places in gimp_prop_scale_entry_new() is now mostly useless since GimpLabelSpin (hence GimpScaleEntry too) got a nice estimation algorithm of sensible values. - Add gimp_label_spin_set_digits() function to manually set the digits property when we don't like the estimated value. - Also add a new "factor" argument to gimp_prop_scale_entry_new(). Its role is to allow a GimpScaleEntry showing a factored range, typically a [0, 100] range for some types of [0, 1] properties. - Remove gimp_prop_opacity_entry_new() which was basically a special-case of gimp_prop_scale_entry_new() and which can now be easily reproduced by simply set factor=100.0. - Update all usage of gimp_prop_scale_entry_new() in app/ and plug-ins/ with updated arguments. It is interesting to note that all existing usage were either integers (digits=1) or when double, the estimated decimal places are the same as the ones which were manually set (hence showing the generic estimation is not too bad). So the new function gimp_label_spin_set_digits() was not even needed once in current code.
2020-11-25 09:19:39 +08:00
/**
* gimp_label_spin_set_digits:
* @spin: the #GimpLabelSpin.
* @digits: the number of decimal places to display.
*
* Set the number of decimal place to display in the @spin's entry.
* If @digits is -1, then it will also be estimated based on @spin's
* range. Digits estimation will always be at least 1, so if you want to
* show integer values only, set 0 explicitly.
*/
void
gimp_label_spin_set_digits (GimpLabelSpin *spin,
gint digits)
{
g_return_if_fail (GIMP_IS_LABEL_SPIN (spin));
g_object_set (spin,
"digits", digits,
NULL);
}
libgimpwidgets: new GimpLabeled class and GimpLabelSpin subclass. There is currently no property widget which just creates a GimpSpinButton with a label. Just as the GimpScaleEntry was needed, this one is as well. I am creating a GimpLabeled abstract class which will represent various widgets with a label. While this may seem a bit over-engineered for such a basic feature, this will actually bring some consistency and a common parent. In particular this can be used to get the GtkLabel with a common interface to add them all in a common GtkSizeGroup when generating dialogs automatically, hence make dialogs with properly aligned labels and edition widgets.
2020-11-05 08:13:49 +08:00
/**
* gimp_label_spin_get_spin_button:
* @spin: The #GimpLabelSpin
*
* This function returns the #GimpSpinButton packed in @spin.
*
* Returns: (transfer none): The #GimpSpinButton contained in @spin.
**/
GtkWidget *
gimp_label_spin_get_spin_button (GimpLabelSpin *spin)
{
GimpLabelSpinPrivate *priv = gimp_label_spin_get_instance_private (spin);
g_return_val_if_fail (GIMP_IS_LABEL_SPIN (spin), NULL);
return priv->spinbutton;
}