forked from AuroraMiddleware/gtk
b18b33ae82
In the early 2.14.x releases, GtkAdjustment was changed to enforce
that values are restricted to the range [lower, upper - page_size].
This has always been the documented behaviour, and the recommended
practice is to set page_size to 0 when using adjustments for simple
scalar values, like in a slider or spin button.
Due to the large number of applications that are affected by this
change, the behaviour has been reverted to the old behaviour in
2.14.3, with an explicit warning that this change will be
reintroduced in 2.90.
This reverts commit e6373738fc.
https://bugzilla.gnome.org/show_bug.cgi?id=619474
707 lines
19 KiB
C
707 lines
19 KiB
C
/* GTK - The GIMP Toolkit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* 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 2 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "gtkadjustment.h"
|
|
#include "gtkmarshalers.h"
|
|
#include "gtkprivate.h"
|
|
#include "gtkintl.h"
|
|
#include "gtkalias.h"
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_VALUE,
|
|
PROP_LOWER,
|
|
PROP_UPPER,
|
|
PROP_STEP_INCREMENT,
|
|
PROP_PAGE_INCREMENT,
|
|
PROP_PAGE_SIZE
|
|
};
|
|
|
|
enum
|
|
{
|
|
CHANGED,
|
|
VALUE_CHANGED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
|
|
static void gtk_adjustment_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec);
|
|
static void gtk_adjustment_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec);
|
|
static void gtk_adjustment_dispatch_properties_changed (GObject *object,
|
|
guint n_pspecs,
|
|
GParamSpec **pspecs);
|
|
|
|
static guint adjustment_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
static guint64 adjustment_changed_stamp = 0; /* protected by global gdk lock */
|
|
|
|
G_DEFINE_TYPE (GtkAdjustment, gtk_adjustment, GTK_TYPE_OBJECT)
|
|
|
|
static void
|
|
gtk_adjustment_class_init (GtkAdjustmentClass *class)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
|
|
|
|
gobject_class->set_property = gtk_adjustment_set_property;
|
|
gobject_class->get_property = gtk_adjustment_get_property;
|
|
gobject_class->dispatch_properties_changed = gtk_adjustment_dispatch_properties_changed;
|
|
|
|
class->changed = NULL;
|
|
class->value_changed = NULL;
|
|
|
|
/**
|
|
* GtkAdjustment:value:
|
|
*
|
|
* The value of the adjustment.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_VALUE,
|
|
g_param_spec_double ("value",
|
|
P_("Value"),
|
|
P_("The value of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkAdjustment:lower:
|
|
*
|
|
* The minimum value of the adjustment.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_LOWER,
|
|
g_param_spec_double ("lower",
|
|
P_("Minimum Value"),
|
|
P_("The minimum value of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkAdjustment:upper:
|
|
*
|
|
* The maximum value of the adjustment.
|
|
* Note that values will be restricted by
|
|
* <literal>upper - page-size</literal> if the page-size
|
|
* property is nonzero.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_UPPER,
|
|
g_param_spec_double ("upper",
|
|
P_("Maximum Value"),
|
|
P_("The maximum value of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkAdjustment:step-increment:
|
|
*
|
|
* The step increment of the adjustment.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_STEP_INCREMENT,
|
|
g_param_spec_double ("step-increment",
|
|
P_("Step Increment"),
|
|
P_("The step increment of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkAdjustment:page-increment:
|
|
*
|
|
* The page increment of the adjustment.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_PAGE_INCREMENT,
|
|
g_param_spec_double ("page-increment",
|
|
P_("Page Increment"),
|
|
P_("The page increment of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkAdjustment:page-size:
|
|
*
|
|
* The page size of the adjustment.
|
|
* Note that the page-size is irrelevant and should be set to zero
|
|
* if the adjustment is used for a simple scalar value, e.g. in a
|
|
* #GtkSpinButton.
|
|
*
|
|
* Since: 2.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_PAGE_SIZE,
|
|
g_param_spec_double ("page-size",
|
|
P_("Page Size"),
|
|
P_("The page size of the adjustment"),
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
adjustment_signals[CHANGED] =
|
|
g_signal_new (I_("changed"),
|
|
G_OBJECT_CLASS_TYPE (class),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (GtkAdjustmentClass, changed),
|
|
NULL, NULL,
|
|
_gtk_marshal_VOID__VOID,
|
|
G_TYPE_NONE, 0);
|
|
|
|
adjustment_signals[VALUE_CHANGED] =
|
|
g_signal_new (I_("value-changed"),
|
|
G_OBJECT_CLASS_TYPE (class),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (GtkAdjustmentClass, value_changed),
|
|
NULL, NULL,
|
|
_gtk_marshal_VOID__VOID,
|
|
G_TYPE_NONE, 0);
|
|
}
|
|
|
|
static void
|
|
gtk_adjustment_init (GtkAdjustment *adjustment)
|
|
{
|
|
adjustment->value = 0.0;
|
|
adjustment->lower = 0.0;
|
|
adjustment->upper = 0.0;
|
|
adjustment->step_increment = 0.0;
|
|
adjustment->page_increment = 0.0;
|
|
adjustment->page_size = 0.0;
|
|
}
|
|
|
|
static void
|
|
gtk_adjustment_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_VALUE:
|
|
g_value_set_double (value, adjustment->value);
|
|
break;
|
|
case PROP_LOWER:
|
|
g_value_set_double (value, adjustment->lower);
|
|
break;
|
|
case PROP_UPPER:
|
|
g_value_set_double (value, adjustment->upper);
|
|
break;
|
|
case PROP_STEP_INCREMENT:
|
|
g_value_set_double (value, adjustment->step_increment);
|
|
break;
|
|
case PROP_PAGE_INCREMENT:
|
|
g_value_set_double (value, adjustment->page_increment);
|
|
break;
|
|
case PROP_PAGE_SIZE:
|
|
g_value_set_double (value, adjustment->page_size);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_adjustment_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
|
|
gdouble double_value = g_value_get_double (value);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_VALUE:
|
|
gtk_adjustment_set_value (adjustment, double_value);
|
|
break;
|
|
case PROP_LOWER:
|
|
adjustment->lower = double_value;
|
|
break;
|
|
case PROP_UPPER:
|
|
adjustment->upper = double_value;
|
|
break;
|
|
case PROP_STEP_INCREMENT:
|
|
adjustment->step_increment = double_value;
|
|
break;
|
|
case PROP_PAGE_INCREMENT:
|
|
adjustment->page_increment = double_value;
|
|
break;
|
|
case PROP_PAGE_SIZE:
|
|
adjustment->page_size = double_value;
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_adjustment_dispatch_properties_changed (GObject *object,
|
|
guint n_pspecs,
|
|
GParamSpec **pspecs)
|
|
{
|
|
gboolean changed = FALSE;
|
|
gint i;
|
|
|
|
G_OBJECT_CLASS (gtk_adjustment_parent_class)->dispatch_properties_changed (object, n_pspecs, pspecs);
|
|
|
|
for (i = 0; i < n_pspecs; i++)
|
|
switch (pspecs[i]->param_id)
|
|
{
|
|
case PROP_LOWER:
|
|
case PROP_UPPER:
|
|
case PROP_STEP_INCREMENT:
|
|
case PROP_PAGE_INCREMENT:
|
|
case PROP_PAGE_SIZE:
|
|
changed = TRUE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
adjustment_changed_stamp++;
|
|
gtk_adjustment_changed (GTK_ADJUSTMENT (object));
|
|
}
|
|
}
|
|
|
|
GtkObject *
|
|
gtk_adjustment_new (gdouble value,
|
|
gdouble lower,
|
|
gdouble upper,
|
|
gdouble step_increment,
|
|
gdouble page_increment,
|
|
gdouble page_size)
|
|
{
|
|
return g_object_new (GTK_TYPE_ADJUSTMENT,
|
|
"lower", lower,
|
|
"upper", upper,
|
|
"step-increment", step_increment,
|
|
"page-increment", page_increment,
|
|
"page-size", page_size,
|
|
"value", value,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_value:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Gets the current value of the adjustment. See
|
|
* gtk_adjustment_set_value ().
|
|
*
|
|
* Return value: The current value of the adjustment.
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_value (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->value;
|
|
}
|
|
|
|
void
|
|
gtk_adjustment_set_value (GtkAdjustment *adjustment,
|
|
gdouble value)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
/* don't use CLAMP() so we don't end up below lower if upper - page_size
|
|
* is smaller than lower
|
|
*/
|
|
value = MIN (value, adjustment->upper - adjustment->page_size);
|
|
value = MAX (value, adjustment->lower);
|
|
|
|
if (value != adjustment->value)
|
|
{
|
|
adjustment->value = value;
|
|
|
|
gtk_adjustment_value_changed (adjustment);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_lower:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Retrieves the minimum value of the adjustment.
|
|
*
|
|
* Return value: The current minimum value of the adjustment.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_lower (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->lower;
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_set_lower:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @lower: the new minimum value
|
|
*
|
|
* Sets the minimum value of the adjustment.
|
|
*
|
|
* When setting multiple adjustment properties via their individual
|
|
* setters, multiple "changed" signals will be emitted. However, since
|
|
* the emission of the "changed" signal is tied to the emission of the
|
|
* "GObject::notify" signals of the changed properties, it's possible
|
|
* to compress the "changed" signals into one by calling
|
|
* g_object_freeze_notify() and g_object_thaw_notify() around the
|
|
* calls to the individual setters.
|
|
*
|
|
* Alternatively, using a single g_object_set() for all the properties
|
|
* to change, or using gtk_adjustment_configure() has the same effect
|
|
* of compressing "changed" emissions.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_set_lower (GtkAdjustment *adjustment,
|
|
gdouble lower)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
if (lower != adjustment->lower)
|
|
g_object_set (adjustment, "lower", lower, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_upper:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Retrieves the maximum value of the adjustment.
|
|
*
|
|
* Return value: The current maximum value of the adjustment.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_upper (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->upper;
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_set_upper:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @upper: the new maximum value
|
|
*
|
|
* Sets the maximum value of the adjustment.
|
|
*
|
|
* Note that values will be restricted by
|
|
* <literal>upper - page-size</literal> if the page-size
|
|
* property is nonzero.
|
|
*
|
|
* See gtk_adjustment_set_lower() about how to compress multiple
|
|
* emissions of the "changed" signal when setting multiple adjustment
|
|
* properties.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_set_upper (GtkAdjustment *adjustment,
|
|
gdouble upper)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
if (upper != adjustment->upper)
|
|
g_object_set (adjustment, "upper", upper, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_step_increment:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Retrieves the step increment of the adjustment.
|
|
*
|
|
* Return value: The current step increment of the adjustment.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_step_increment (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->step_increment;
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_set_step_increment:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @step_increment: the new step increment
|
|
*
|
|
* Sets the step increment of the adjustment.
|
|
*
|
|
* See gtk_adjustment_set_lower() about how to compress multiple
|
|
* emissions of the "changed" signal when setting multiple adjustment
|
|
* properties.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_set_step_increment (GtkAdjustment *adjustment,
|
|
gdouble step_increment)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
if (step_increment != adjustment->step_increment)
|
|
g_object_set (adjustment, "step-increment", step_increment, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_page_increment:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Retrieves the page increment of the adjustment.
|
|
*
|
|
* Return value: The current page increment of the adjustment.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_page_increment (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->page_increment;
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_set_page_increment:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @page_increment: the new page increment
|
|
*
|
|
* Sets the page increment of the adjustment.
|
|
*
|
|
* See gtk_adjustment_set_lower() about how to compress multiple
|
|
* emissions of the "changed" signal when setting multiple adjustment
|
|
* properties.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_set_page_increment (GtkAdjustment *adjustment,
|
|
gdouble page_increment)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
if (page_increment != adjustment->page_increment)
|
|
g_object_set (adjustment, "page-increment", page_increment, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_get_page_size:
|
|
* @adjustment: a #GtkAdjustment
|
|
*
|
|
* Retrieves the page size of the adjustment.
|
|
*
|
|
* Return value: The current page size of the adjustment.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
gdouble
|
|
gtk_adjustment_get_page_size (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
|
|
|
|
return adjustment->page_size;
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_set_page_size:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @page_size: the new page size
|
|
*
|
|
* Sets the page size of the adjustment.
|
|
*
|
|
* See gtk_adjustment_set_lower() about how to compress multiple
|
|
* emissions of the "changed" signal when setting multiple adjustment
|
|
* properties.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_set_page_size (GtkAdjustment *adjustment,
|
|
gdouble page_size)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
if (page_size != adjustment->page_size)
|
|
g_object_set (adjustment, "page-size", page_size, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_adjustment_configure:
|
|
* @adjustment: a #GtkAdjustment
|
|
* @value: the new value
|
|
* @lower: the new minimum value
|
|
* @upper: the new maximum value
|
|
* @step_increment: the new step increment
|
|
* @page_increment: the new page increment
|
|
* @page_size: the new page size
|
|
*
|
|
* Sets all properties of the adjustment at once.
|
|
*
|
|
* Use this function to avoid multiple emissions of the "changed"
|
|
* signal. See gtk_adjustment_set_lower() for an alternative way
|
|
* of compressing multiple emissions of "changed" into one.
|
|
*
|
|
* Since: 2.14
|
|
**/
|
|
void
|
|
gtk_adjustment_configure (GtkAdjustment *adjustment,
|
|
gdouble value,
|
|
gdouble lower,
|
|
gdouble upper,
|
|
gdouble step_increment,
|
|
gdouble page_increment,
|
|
gdouble page_size)
|
|
{
|
|
gboolean value_changed = FALSE;
|
|
guint64 old_stamp = adjustment_changed_stamp;
|
|
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
g_object_freeze_notify (G_OBJECT (adjustment));
|
|
|
|
g_object_set (adjustment,
|
|
"lower", lower,
|
|
"upper", upper,
|
|
"step-increment", step_increment,
|
|
"page-increment", page_increment,
|
|
"page-size", page_size,
|
|
NULL);
|
|
|
|
/* don't use CLAMP() so we don't end up below lower if upper - page_size
|
|
* is smaller than lower
|
|
*/
|
|
value = MIN (value, upper - page_size);
|
|
value = MAX (value, lower);
|
|
|
|
if (value != adjustment->value)
|
|
{
|
|
/* set value manually to make sure "changed" is emitted with the
|
|
* new value in place and is emitted before "value-changed"
|
|
*/
|
|
adjustment->value = value;
|
|
value_changed = TRUE;
|
|
}
|
|
|
|
g_object_thaw_notify (G_OBJECT (adjustment));
|
|
|
|
if (old_stamp == adjustment_changed_stamp)
|
|
gtk_adjustment_changed (adjustment); /* force emission before ::value-changed */
|
|
|
|
if (value_changed)
|
|
gtk_adjustment_value_changed (adjustment);
|
|
}
|
|
|
|
void
|
|
gtk_adjustment_changed (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
g_signal_emit (adjustment, adjustment_signals[CHANGED], 0);
|
|
}
|
|
|
|
void
|
|
gtk_adjustment_value_changed (GtkAdjustment *adjustment)
|
|
{
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
g_signal_emit (adjustment, adjustment_signals[VALUE_CHANGED], 0);
|
|
g_object_notify (G_OBJECT (adjustment), "value");
|
|
}
|
|
|
|
void
|
|
gtk_adjustment_clamp_page (GtkAdjustment *adjustment,
|
|
gdouble lower,
|
|
gdouble upper)
|
|
{
|
|
gboolean need_emission;
|
|
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
|
|
lower = CLAMP (lower, adjustment->lower, adjustment->upper);
|
|
upper = CLAMP (upper, adjustment->lower, adjustment->upper);
|
|
|
|
need_emission = FALSE;
|
|
|
|
if (adjustment->value + adjustment->page_size < upper)
|
|
{
|
|
adjustment->value = upper - adjustment->page_size;
|
|
need_emission = TRUE;
|
|
}
|
|
if (adjustment->value > lower)
|
|
{
|
|
adjustment->value = lower;
|
|
need_emission = TRUE;
|
|
}
|
|
|
|
if (need_emission)
|
|
gtk_adjustment_value_changed (adjustment);
|
|
}
|
|
|
|
#define __GTK_ADJUSTMENT_C__
|
|
#include "gtkaliasdef.c"
|