Pileus Git - ~andy/gtk/blob - gtk/gtkadjustment.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28 #include "gtkadjustment.h"
  29 #include "gtkmarshalers.h"
  30 #include "gtkprivate.h"
  31 #include "gtkintl.h"
  32
  33
  34 /**
  35  * SECTION:gtkadjustment
  36  * @Short_description: A representation of an adjustable bounded value
  37  * @Title: GtkAdjustment
  38  *
  39  * The #GtkAdjustment object represents a value which has an associated lower
  40  * and upper bound, together with step and page increments, and a page size.
  41  * It is used within several GTK+ widgets, including
  42  * #GtkSpinButton, #GtkViewport, and #GtkRange (which is a base class for
  43  * #GtkHScrollbar, #GtkVScrollbar, #GtkHScale, and #GtkVScale).
  44  *
  45  * The #GtkAdjustment object does not update the value itself. Instead
  46  * it is left up to the owner of the #GtkAdjustment to control the value.
  47  *
  48  * The owner of the #GtkAdjustment typically calls the
  49  * gtk_adjustment_value_changed() and gtk_adjustment_changed() functions
  50  * after changing the value and its bounds. This results in the emission of the
  51  * #GtkAdjustment::value_changed or #GtkAdjustment::changed signal respectively.
  52  */
  53
  54
  55 struct _GtkAdjustmentPrivate {
  56   gdouble lower;
  57   gdouble upper;
  58   gdouble value;
  59   gdouble step_increment;
  60   gdouble page_increment;
  61   gdouble page_size;
  62 };
  63
  64 enum
  65 {
  66   PROP_0,
  67   PROP_VALUE,
  68   PROP_LOWER,
  69   PROP_UPPER,
  70   PROP_STEP_INCREMENT,
  71   PROP_PAGE_INCREMENT,
  72   PROP_PAGE_SIZE
  73 };
  74
  75 enum
  76 {
  77   CHANGED,
  78   VALUE_CHANGED,
  79   LAST_SIGNAL
  80 };
  81
  82
  83 static void gtk_adjustment_get_property                (GObject      *object,
  84                                                         guint         prop_id,
  85                                                         GValue       *value,
  86                                                         GParamSpec   *pspec);
  87 static void gtk_adjustment_set_property                (GObject      *object,
  88                                                         guint         prop_id,
  89                                                         const GValue *value,
  90                                                         GParamSpec   *pspec);
  91 static void gtk_adjustment_dispatch_properties_changed (GObject      *object,
  92                                                         guint         n_pspecs,
  93                                                         GParamSpec  **pspecs);
  94
  95 static guint adjustment_signals[LAST_SIGNAL] = { 0 };
  96
  97 static guint64 adjustment_changed_stamp = 0; /* protected by global gdk lock */
  98
  99 G_DEFINE_TYPE (GtkAdjustment, gtk_adjustment, G_TYPE_INITIALLY_UNOWNED)
 100
 101 static void
 102 gtk_adjustment_class_init (GtkAdjustmentClass *class)
 103 {
 104   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 105
 106   gobject_class->set_property                = gtk_adjustment_set_property;
 107   gobject_class->get_property                = gtk_adjustment_get_property;
 108   gobject_class->dispatch_properties_changed = gtk_adjustment_dispatch_properties_changed;
 109
 110   class->changed = NULL;
 111   class->value_changed = NULL;
 112
 113   /**
 114    * GtkAdjustment:value:
 115    *
 116    * The value of the adjustment.
 117    *
 118    * Since: 2.4
 119    */
 120   g_object_class_install_property (gobject_class,
 121                                    PROP_VALUE,
 122                                    g_param_spec_double ("value",
 123                                                         P_("Value"),
 124                                                         P_("The value of the adjustment"),
 125                                                         -G_MAXDOUBLE,
 126                                                         G_MAXDOUBLE,
 127                                                         0.0,
 128                                                         GTK_PARAM_READWRITE));
 129
 130   /**
 131    * GtkAdjustment:lower:
 132    *
 133    * The minimum value of the adjustment.
 134    *
 135    * Since: 2.4
 136    */
 137   g_object_class_install_property (gobject_class,
 138                                    PROP_LOWER,
 139                                    g_param_spec_double ("lower",
 140                                                         P_("Minimum Value"),
 141                                                         P_("The minimum value of the adjustment"),
 142                                                         -G_MAXDOUBLE,
 143                                                         G_MAXDOUBLE,
 144                                                         0.0,
 145                                                         GTK_PARAM_READWRITE));
 146
 147   /**
 148    * GtkAdjustment:upper:
 149    *
 150    * The maximum value of the adjustment.
 151    * Note that values will be restricted by
 152    * <literal>upper - page-size</literal> if the page-size
 153    * property is nonzero.
 154    *
 155    * Since: 2.4
 156    */
 157   g_object_class_install_property (gobject_class,
 158                                    PROP_UPPER,
 159                                    g_param_spec_double ("upper",
 160                                                         P_("Maximum Value"),
 161                                                         P_("The maximum value of the adjustment"),
 162                                                         -G_MAXDOUBLE,
 163                                                         G_MAXDOUBLE,
 164                                                         0.0,
 165                                                         GTK_PARAM_READWRITE));
 166
 167   /**
 168    * GtkAdjustment:step-increment:
 169    *
 170    * The step increment of the adjustment.
 171    *
 172    * Since: 2.4
 173    */
 174   g_object_class_install_property (gobject_class,
 175                                    PROP_STEP_INCREMENT,
 176                                    g_param_spec_double ("step-increment",
 177                                                         P_("Step Increment"),
 178                                                         P_("The step increment of the adjustment"),
 179                                                         -G_MAXDOUBLE,
 180                                                         G_MAXDOUBLE,
 181                                                         0.0,
 182                                                         GTK_PARAM_READWRITE));
 183
 184   /**
 185    * GtkAdjustment:page-increment:
 186    *
 187    * The page increment of the adjustment.
 188    *
 189    * Since: 2.4
 190    */
 191   g_object_class_install_property (gobject_class,
 192                                    PROP_PAGE_INCREMENT,
 193                                    g_param_spec_double ("page-increment",
 194                                                         P_("Page Increment"),
 195                                                         P_("The page increment of the adjustment"),
 196                                                         -G_MAXDOUBLE,
 197                                                         G_MAXDOUBLE,
 198                                                         0.0,
 199                                                         GTK_PARAM_READWRITE));
 200
 201   /**
 202    * GtkAdjustment:page-size:
 203    *
 204    * The page size of the adjustment.
 205    * Note that the page-size is irrelevant and should be set to zero
 206    * if the adjustment is used for a simple scalar value, e.g. in a
 207    * #GtkSpinButton.
 208    *
 209    * Since: 2.4
 210    */
 211   g_object_class_install_property (gobject_class,
 212                                    PROP_PAGE_SIZE,
 213                                    g_param_spec_double ("page-size",
 214                                                         P_("Page Size"),
 215                                                         P_("The page size of the adjustment"),
 216                                                         -G_MAXDOUBLE,
 217                                                         G_MAXDOUBLE,
 218                                                         0.0,
 219                                                         GTK_PARAM_READWRITE));
 220
 221   /**
 222    * GtkAdjustment::changed:
 223    * @adjustment: the object which received the signal.
 224    *
 225    * Emitted when one or more of the #GtkAdjustment fields have been changed,
 226    * other than the value field.
 227    */
 228   adjustment_signals[CHANGED] =
 229     g_signal_new (I_("changed"),
 230                   G_OBJECT_CLASS_TYPE (class),
 231                   G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 232                   G_STRUCT_OFFSET (GtkAdjustmentClass, changed),
 233                   NULL, NULL,
 234                   _gtk_marshal_VOID__VOID,
 235                   G_TYPE_NONE, 0);
 236
 237   /**
 238    * GtkAdjustment::value-changed:
 239    * @adjustment: the object which received the signal.
 240    *
 241    * Emitted when the #GtkAdjustment value field has been changed.
 242    */
 243   adjustment_signals[VALUE_CHANGED] =
 244     g_signal_new (I_("value-changed"),
 245                   G_OBJECT_CLASS_TYPE (class),
 246                   G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 247                   G_STRUCT_OFFSET (GtkAdjustmentClass, value_changed),
 248                   NULL, NULL,
 249                   _gtk_marshal_VOID__VOID,
 250                   G_TYPE_NONE, 0);
 251
 252   g_type_class_add_private (class, sizeof (GtkAdjustmentPrivate));
 253 }
 254
 255 static void
 256 gtk_adjustment_init (GtkAdjustment *adjustment)
 257 {
 258   adjustment->priv = G_TYPE_INSTANCE_GET_PRIVATE (adjustment,
 259                                                   GTK_TYPE_ADJUSTMENT,
 260                                                   GtkAdjustmentPrivate);
 261 }
 262
 263 static void
 264 gtk_adjustment_get_property (GObject    *object,
 265                              guint       prop_id,
 266                              GValue     *value,
 267                              GParamSpec *pspec)
 268 {
 269   GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
 270   GtkAdjustmentPrivate *priv = adjustment->priv;
 271
 272   switch (prop_id)
 273     {
 274     case PROP_VALUE:
 275       g_value_set_double (value, priv->value);
 276       break;
 277     case PROP_LOWER:
 278       g_value_set_double (value, priv->lower);
 279       break;
 280     case PROP_UPPER:
 281       g_value_set_double (value, priv->upper);
 282       break;
 283     case PROP_STEP_INCREMENT:
 284       g_value_set_double (value, priv->step_increment);
 285       break;
 286     case PROP_PAGE_INCREMENT:
 287       g_value_set_double (value, priv->page_increment);
 288       break;
 289     case PROP_PAGE_SIZE:
 290       g_value_set_double (value, priv->page_size);
 291       break;
 292     default:
 293       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 294       break;
 295     }
 296 }
 297
 298 static void
 299 gtk_adjustment_set_property (GObject      *object,
 300                              guint         prop_id,
 301                              const GValue *value,
 302                              GParamSpec   *pspec)
 303 {
 304   GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
 305   gdouble double_value = g_value_get_double (value);
 306   GtkAdjustmentPrivate *priv = adjustment->priv;
 307
 308   switch (prop_id)
 309     {
 310     case PROP_VALUE:
 311       gtk_adjustment_set_value (adjustment, double_value);
 312       break;
 313     case PROP_LOWER:
 314       priv->lower = double_value;
 315       break;
 316     case PROP_UPPER:
 317       priv->upper = double_value;
 318       break;
 319     case PROP_STEP_INCREMENT:
 320       priv->step_increment = double_value;
 321       break;
 322     case PROP_PAGE_INCREMENT:
 323       priv->page_increment = double_value;
 324       break;
 325     case PROP_PAGE_SIZE:
 326       priv->page_size = double_value;
 327       break;
 328     default:
 329       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 330       break;
 331     }
 332 }
 333
 334 static void
 335 gtk_adjustment_dispatch_properties_changed (GObject     *object,
 336                                             guint        n_pspecs,
 337                                             GParamSpec **pspecs)
 338 {
 339   gboolean changed = FALSE;
 340   gint i;
 341
 342   G_OBJECT_CLASS (gtk_adjustment_parent_class)->dispatch_properties_changed (object, n_pspecs, pspecs);
 343
 344   for (i = 0; i < n_pspecs; i++)
 345     switch (pspecs[i]->param_id)
 346       {
 347       case PROP_LOWER:
 348       case PROP_UPPER:
 349       case PROP_STEP_INCREMENT:
 350       case PROP_PAGE_INCREMENT:
 351       case PROP_PAGE_SIZE:
 352         changed = TRUE;
 353         break;
 354       default:
 355         break;
 356       }
 357
 358   if (changed)
 359     {
 360       adjustment_changed_stamp++;
 361       gtk_adjustment_changed (GTK_ADJUSTMENT (object));
 362     }
 363 }
 364
 365 /**
 366  * gtk_adjustment_new:
 367  * @value: the initial value.
 368  * @lower: the minimum value.
 369  * @upper: the maximum value.
 370  * @step_increment: the step increment.
 371  * @page_increment: the page increment.
 372  * @page_size: the page size.
 373  *
 374  * Creates a new #GtkAdjustment.
 375  *
 376  * Returns: a new #GtkAdjustment.
 377  */
 378 GtkAdjustment *
 379 gtk_adjustment_new (gdouble value,
 380                     gdouble lower,
 381                     gdouble upper,
 382                     gdouble step_increment,
 383                     gdouble page_increment,
 384                     gdouble page_size)
 385 {
 386   return g_object_new (GTK_TYPE_ADJUSTMENT,
 387                        "lower", lower,
 388                        "upper", upper,
 389                        "step-increment", step_increment,
 390                        "page-increment", page_increment,
 391                        "page-size", page_size,
 392                        "value", value,
 393                        NULL);
 394 }
 395
 396 /**
 397  * gtk_adjustment_get_value:
 398  * @adjustment: a #GtkAdjustment
 399  *
 400  * Gets the current value of the adjustment. See
 401  * gtk_adjustment_set_value ().
 402  *
 403  * Return value: The current value of the adjustment.
 404  **/
 405 gdouble
 406 gtk_adjustment_get_value (GtkAdjustment *adjustment)
 407 {
 408   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 409
 410   return adjustment->priv->value;
 411 }
 412
 413 /**
 414  * gtk_adjustment_set_value:
 415  * @adjustment: a #GtkAdjustment.
 416  * @value: the new value.
 417  *
 418  * Sets the #GtkAdjustment value. The value is clamped to lie between
 419  * #GtkAdjustment.lower and #GtkAdjustment.upper.
 420  *
 421  * Note that for adjustments which are used in a #GtkScrollbar, the effective
 422  * range of allowed values goes from #GtkAdjustment.lower to
 423  * #GtkAdjustment.upper - #GtkAdjustment.page_size.
 424  */
 425 void
 426 gtk_adjustment_set_value (GtkAdjustment *adjustment,
 427                           gdouble        value)
 428 {
 429   GtkAdjustmentPrivate *priv;
 430
 431   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 432
 433   priv = adjustment->priv;
 434
 435   /* don't use CLAMP() so we don't end up below lower if upper - page_size
 436    * is smaller than lower
 437    */
 438   value = MIN (value, priv->upper - priv->page_size);
 439   value = MAX (value, priv->lower);
 440
 441   if (value != priv->value)
 442     {
 443       priv->value = value;
 444
 445       gtk_adjustment_value_changed (adjustment);
 446     }
 447 }
 448
 449 /**
 450  * gtk_adjustment_get_lower:
 451  * @adjustment: a #GtkAdjustment
 452  *
 453  * Retrieves the minimum value of the adjustment.
 454  *
 455  * Return value: The current minimum value of the adjustment.
 456  *
 457  * Since: 2.14
 458  **/
 459 gdouble
 460 gtk_adjustment_get_lower (GtkAdjustment *adjustment)
 461 {
 462   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 463
 464   return adjustment->priv->lower;
 465 }
 466
 467 /**
 468  * gtk_adjustment_set_lower:
 469  * @adjustment: a #GtkAdjustment
 470  * @lower: the new minimum value
 471  *
 472  * Sets the minimum value of the adjustment.
 473  *
 474  * When setting multiple adjustment properties via their individual
 475  * setters, multiple "changed" signals will be emitted. However, since
 476  * the emission of the "changed" signal is tied to the emission of the
 477  * "GObject::notify" signals of the changed properties, it's possible
 478  * to compress the "changed" signals into one by calling
 479  * g_object_freeze_notify() and g_object_thaw_notify() around the
 480  * calls to the individual setters.
 481  *
 482  * Alternatively, using a single g_object_set() for all the properties
 483  * to change, or using gtk_adjustment_configure() has the same effect
 484  * of compressing "changed" emissions.
 485  *
 486  * Since: 2.14
 487  **/
 488 void
 489 gtk_adjustment_set_lower (GtkAdjustment *adjustment,
 490                           gdouble        lower)
 491 {
 492   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 493
 494   if (lower != adjustment->priv->lower)
 495     g_object_set (adjustment, "lower", lower, NULL);
 496 }
 497
 498 /**
 499  * gtk_adjustment_get_upper:
 500  * @adjustment: a #GtkAdjustment
 501  *
 502  * Retrieves the maximum value of the adjustment.
 503  *
 504  * Return value: The current maximum value of the adjustment.
 505  *
 506  * Since: 2.14
 507  **/
 508 gdouble
 509 gtk_adjustment_get_upper (GtkAdjustment *adjustment)
 510 {
 511   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 512
 513   return adjustment->priv->upper;
 514 }
 515
 516 /**
 517  * gtk_adjustment_set_upper:
 518  * @adjustment: a #GtkAdjustment
 519  * @upper: the new maximum value
 520  *
 521  * Sets the maximum value of the adjustment.
 522  *
 523  * Note that values will be restricted by
 524  * <literal>upper - page-size</literal> if the page-size
 525  * property is nonzero.
 526  *
 527  * See gtk_adjustment_set_lower() about how to compress multiple
 528  * emissions of the "changed" signal when setting multiple adjustment
 529  * properties.
 530  *
 531  * Since: 2.14
 532  **/
 533 void
 534 gtk_adjustment_set_upper (GtkAdjustment *adjustment,
 535                           gdouble        upper)
 536 {
 537   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 538
 539   if (upper != adjustment->priv->upper)
 540     g_object_set (adjustment, "upper", upper, NULL);
 541 }
 542
 543 /**
 544  * gtk_adjustment_get_step_increment:
 545  * @adjustment: a #GtkAdjustment
 546  *
 547  * Retrieves the step increment of the adjustment.
 548  *
 549  * Return value: The current step increment of the adjustment.
 550  *
 551  * Since: 2.14
 552  **/
 553 gdouble
 554 gtk_adjustment_get_step_increment (GtkAdjustment *adjustment)
 555 {
 556   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 557
 558   return adjustment->priv->step_increment;
 559 }
 560
 561 /**
 562  * gtk_adjustment_set_step_increment:
 563  * @adjustment: a #GtkAdjustment
 564  * @step_increment: the new step increment
 565  *
 566  * Sets the step increment of the adjustment.
 567  *
 568  * See gtk_adjustment_set_lower() about how to compress multiple
 569  * emissions of the "changed" signal when setting multiple adjustment
 570  * properties.
 571  *
 572  * Since: 2.14
 573  **/
 574 void
 575 gtk_adjustment_set_step_increment (GtkAdjustment *adjustment,
 576                                    gdouble        step_increment)
 577 {
 578   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 579
 580   if (step_increment != adjustment->priv->step_increment)
 581     g_object_set (adjustment, "step-increment", step_increment, NULL);
 582 }
 583
 584 /**
 585  * gtk_adjustment_get_page_increment:
 586  * @adjustment: a #GtkAdjustment
 587  *
 588  * Retrieves the page increment of the adjustment.
 589  *
 590  * Return value: The current page increment of the adjustment.
 591  *
 592  * Since: 2.14
 593  **/
 594 gdouble
 595 gtk_adjustment_get_page_increment (GtkAdjustment *adjustment)
 596 {
 597   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 598
 599   return adjustment->priv->page_increment;
 600 }
 601
 602 /**
 603  * gtk_adjustment_set_page_increment:
 604  * @adjustment: a #GtkAdjustment
 605  * @page_increment: the new page increment
 606  *
 607  * Sets the page increment of the adjustment.
 608  *
 609  * See gtk_adjustment_set_lower() about how to compress multiple
 610  * emissions of the "changed" signal when setting multiple adjustment
 611  * properties.
 612  *
 613  * Since: 2.14
 614  **/
 615 void
 616 gtk_adjustment_set_page_increment (GtkAdjustment *adjustment,
 617                                    gdouble        page_increment)
 618 {
 619   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 620
 621   if (page_increment != adjustment->priv->page_increment)
 622     g_object_set (adjustment, "page-increment", page_increment, NULL);
 623 }
 624
 625 /**
 626  * gtk_adjustment_get_page_size:
 627  * @adjustment: a #GtkAdjustment
 628  *
 629  * Retrieves the page size of the adjustment.
 630  *
 631  * Return value: The current page size of the adjustment.
 632  *
 633  * Since: 2.14
 634  **/
 635 gdouble
 636 gtk_adjustment_get_page_size (GtkAdjustment *adjustment)
 637 {
 638   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
 639
 640   return adjustment->priv->page_size;
 641 }
 642
 643 /**
 644  * gtk_adjustment_set_page_size:
 645  * @adjustment: a #GtkAdjustment
 646  * @page_size: the new page size
 647  *
 648  * Sets the page size of the adjustment.
 649  *
 650  * See gtk_adjustment_set_lower() about how to compress multiple
 651  * emissions of the "changed" signal when setting multiple adjustment
 652  * properties.
 653  *
 654  * Since: 2.14
 655  **/
 656 void
 657 gtk_adjustment_set_page_size (GtkAdjustment *adjustment,
 658                               gdouble        page_size)
 659 {
 660   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 661
 662   if (page_size != adjustment->priv->page_size)
 663     g_object_set (adjustment, "page-size", page_size, NULL);
 664 }
 665
 666 /**
 667  * gtk_adjustment_configure:
 668  * @adjustment: a #GtkAdjustment
 669  * @value: the new value
 670  * @lower: the new minimum value
 671  * @upper: the new maximum value
 672  * @step_increment: the new step increment
 673  * @page_increment: the new page increment
 674  * @page_size: the new page size
 675  *
 676  * Sets all properties of the adjustment at once.
 677  *
 678  * Use this function to avoid multiple emissions of the "changed"
 679  * signal. See gtk_adjustment_set_lower() for an alternative way
 680  * of compressing multiple emissions of "changed" into one.
 681  *
 682  * Since: 2.14
 683  **/
 684 void
 685 gtk_adjustment_configure (GtkAdjustment *adjustment,
 686                           gdouble        value,
 687                           gdouble        lower,
 688                           gdouble        upper,
 689                           gdouble        step_increment,
 690                           gdouble        page_increment,
 691                           gdouble        page_size)
 692 {
 693   GtkAdjustmentPrivate *priv;
 694   gboolean value_changed = FALSE;
 695   guint64 old_stamp = adjustment_changed_stamp;
 696
 697   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 698
 699   priv = adjustment->priv;
 700
 701   g_object_freeze_notify (G_OBJECT (adjustment));
 702
 703   g_object_set (adjustment,
 704                 "lower", lower,
 705                 "upper", upper,
 706                 "step-increment", step_increment,
 707                 "page-increment", page_increment,
 708                 "page-size", page_size,
 709                 NULL);
 710
 711   /* don't use CLAMP() so we don't end up below lower if upper - page_size
 712    * is smaller than lower
 713    */
 714   value = MIN (value, upper - page_size);
 715   value = MAX (value, lower);
 716
 717   if (value != priv->value)
 718     {
 719       /* set value manually to make sure "changed" is emitted with the
 720        * new value in place and is emitted before "value-changed"
 721        */
 722       priv->value = value;
 723       value_changed = TRUE;
 724     }
 725
 726   g_object_thaw_notify (G_OBJECT (adjustment));
 727
 728   if (old_stamp == adjustment_changed_stamp)
 729     gtk_adjustment_changed (adjustment); /* force emission before ::value-changed */
 730
 731   if (value_changed)
 732     gtk_adjustment_value_changed (adjustment);
 733 }
 734
 735 /**
 736  * gtk_adjustment_changed:
 737  * @adjustment: a #GtkAdjustment
 738  *
 739  * Emits a #GtkAdjustment::changed signal from the #GtkAdjustment.
 740  * This is typically called by the owner of the #GtkAdjustment after it has
 741  * changed any of the #GtkAdjustment fields other than the value.
 742  */
 743 void
 744 gtk_adjustment_changed (GtkAdjustment *adjustment)
 745 {
 746   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 747
 748   g_signal_emit (adjustment, adjustment_signals[CHANGED], 0);
 749 }
 750
 751 /**
 752  * gtk_adjustment_value_changed:
 753  * @adjustment: a #GtkAdjustment
 754  *
 755  * Emits a #GtkAdjustment::value_changed signal from the #GtkAdjustment.
 756  * This is typically called by the owner of the #GtkAdjustment after it has
 757  * changed the #GtkAdjustment value field.
 758  */
 759 void
 760 gtk_adjustment_value_changed (GtkAdjustment *adjustment)
 761 {
 762   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 763
 764   g_signal_emit (adjustment, adjustment_signals[VALUE_CHANGED], 0);
 765   g_object_notify (G_OBJECT (adjustment), "value");
 766 }
 767
 768 /**
 769  * gtk_adjustment_clamp_page:
 770  * @adjustment: a #GtkAdjustment.
 771  * @lower: the lower value.
 772  * @upper: the upper value.
 773  *
 774  * Updates the #GtkAdjustment #GtkAdjustment.value to ensure that the range
 775  * between @lower and @upper is in the current page (i.e. between
 776  * #GtkAdjustment.value and #GtkAdjustment.value + #GtkAdjustment.page_size).
 777  * If the range is larger than the page size, then only the start of it will
 778  * be in the current page.
 779  * A #GtkAdjustment::changed signal will be emitted if the value is changed.
 780  */
 781 void
 782 gtk_adjustment_clamp_page (GtkAdjustment *adjustment,
 783                            gdouble        lower,
 784                            gdouble        upper)
 785 {
 786   GtkAdjustmentPrivate *priv;
 787   gboolean need_emission;
 788
 789   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 790
 791   priv = adjustment->priv;
 792
 793   lower = CLAMP (lower, priv->lower, priv->upper);
 794   upper = CLAMP (upper, priv->lower, priv->upper);
 795
 796   need_emission = FALSE;
 797
 798   if (priv->value + priv->page_size < upper)
 799     {
 800       priv->value = upper - priv->page_size;
 801       need_emission = TRUE;
 802     }
 803   if (priv->value > lower)
 804     {
 805       priv->value = lower;
 806       need_emission = TRUE;
 807     }
 808
 809   if (need_emission)
 810     gtk_adjustment_value_changed (adjustment);
 811 }
 812
 813 /**
 814  * gtk_adjustment_get_minimum_increment:
 815  * @adjustment: a #GtkAdjustment
 816  *
 817  * Gets the smaller of step increment and page increment.
 818  *
 819  * Returns: the minimum increment of @adjustment
 820  *
 821  * Since: 3.2
 822  */
 823 gdouble
 824 gtk_adjustment_get_minimum_increment (GtkAdjustment *adjustment)
 825 {
 826   GtkAdjustmentPrivate *priv;
 827   gdouble minimum_increment;
 828
 829   g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0);
 830
 831   priv = adjustment->priv;
 832
 833     if (priv->step_increment != 0 && priv->page_increment != 0)
 834     {
 835       if (ABS (priv->step_increment) < ABS (priv->page_increment))
 836         minimum_increment = priv->step_increment;
 837       else
 838         minimum_increment = priv->page_increment;
 839     }
 840   else if (priv->step_increment == 0 && priv->page_increment == 0)
 841     {
 842       minimum_increment = 0;
 843     }
 844   else if (priv->step_increment == 0)
 845     {
 846       minimum_increment = priv->page_increment;
 847     }
 848   else
 849     {
 850       minimum_increment = priv->step_increment;
 851     }
 852
 853   return minimum_increment;
 854 }
 855