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

   1 /* GTK - The GIMP Toolkit
   2  * gtksizegroup.c:
   3  * Copyright (C) 2001 Red Hat Software
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include "gtkcontainer.h"
  23 #include "gtkintl.h"
  24 #include "gtkprivate.h"
  25 #include "gtksizegroup.h"
  26 #include "gtkalias.h"
  27
  28 enum {
  29   PROP_0,
  30   PROP_MODE,
  31   PROP_IGNORE_HIDDEN
  32 };
  33
  34 static void gtk_size_group_set_property (GObject      *object,
  35                                          guint         prop_id,
  36                                          const GValue *value,
  37                                          GParamSpec   *pspec);
  38 static void gtk_size_group_get_property (GObject      *object,
  39                                          guint         prop_id,
  40                                          GValue       *value,
  41                                          GParamSpec   *pspec);
  42
  43 static void add_group_to_closure  (GtkSizeGroup      *group,
  44                                    GtkSizeGroupMode   mode,
  45                                    GSList           **groups,
  46                                    GSList           **widgets);
  47 static void add_widget_to_closure (GtkWidget         *widget,
  48                                    GtkSizeGroupMode   mode,
  49                                    GSList           **groups,
  50                                    GSList           **widgets);
  51
  52 static GQuark size_groups_quark;
  53 static const gchar size_groups_tag[] = "gtk-size-groups";
  54
  55 static GQuark visited_quark;
  56 static const gchar visited_tag[] = "gtk-size-group-visited";
  57
  58 static GSList *
  59 get_size_groups (GtkWidget *widget)
  60 {
  61   return g_object_get_qdata (G_OBJECT (widget), size_groups_quark);
  62 }
  63
  64 static void
  65 set_size_groups (GtkWidget *widget,
  66                  GSList    *groups)
  67 {
  68   g_object_set_qdata (G_OBJECT (widget), size_groups_quark, groups);
  69 }
  70
  71 static void
  72 mark_visited (gpointer object)
  73 {
  74   g_object_set_qdata (object, visited_quark, "visited");
  75 }
  76
  77 static void
  78 mark_unvisited (gpointer object)
  79 {
  80   g_object_set_qdata (object, visited_quark, NULL);
  81 }
  82
  83 static gboolean
  84 is_visited (gpointer object)
  85 {
  86   return g_object_get_qdata (object, visited_quark) != NULL;
  87 }
  88
  89 static void
  90 add_group_to_closure (GtkSizeGroup    *group,
  91                       GtkSizeGroupMode mode,
  92                       GSList         **groups,
  93                       GSList         **widgets)
  94 {
  95   GSList *tmp_widgets;
  96
  97   *groups = g_slist_prepend (*groups, group);
  98   mark_visited (group);
  99
 100   tmp_widgets = group->widgets;
 101   while (tmp_widgets)
 102     {
 103       GtkWidget *tmp_widget = tmp_widgets->data;
 104
 105       if (!is_visited (tmp_widget))
 106         add_widget_to_closure (tmp_widget, mode, groups, widgets);
 107
 108       tmp_widgets = tmp_widgets->next;
 109     }
 110 }
 111
 112 static void
 113 add_widget_to_closure (GtkWidget       *widget,
 114                        GtkSizeGroupMode mode,
 115                        GSList         **groups,
 116                        GSList         **widgets)
 117 {
 118   GSList *tmp_groups;
 119
 120   *widgets = g_slist_prepend (*widgets, widget);
 121   mark_visited (widget);
 122
 123   tmp_groups = get_size_groups (widget);
 124   while (tmp_groups)
 125     {
 126       GtkSizeGroup *tmp_group = tmp_groups->data;
 127
 128       if ((tmp_group->mode == GTK_SIZE_GROUP_BOTH || tmp_group->mode == mode) &&
 129           !is_visited (tmp_group))
 130         add_group_to_closure (tmp_group, mode, groups, widgets);
 131
 132       tmp_groups = tmp_groups->next;
 133     }
 134 }
 135
 136 static void
 137 real_queue_resize (GtkWidget *widget)
 138 {
 139   GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED);
 140   GTK_PRIVATE_SET_FLAG (widget, GTK_REQUEST_NEEDED);
 141
 142   if (widget->parent)
 143     _gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
 144   else if (GTK_WIDGET_TOPLEVEL (widget) && GTK_IS_CONTAINER (widget))
 145     _gtk_container_queue_resize (GTK_CONTAINER (widget));
 146 }
 147
 148 static void
 149 reset_group_sizes (GSList *groups)
 150 {
 151   GSList *tmp_list = groups;
 152   while (tmp_list)
 153     {
 154       GtkSizeGroup *tmp_group = tmp_list->data;
 155
 156       tmp_group->have_width = FALSE;
 157       tmp_group->have_height = FALSE;
 158
 159       tmp_list = tmp_list->next;
 160     }
 161 }
 162
 163 static void
 164 queue_resize_on_widget (GtkWidget *widget,
 165                         gboolean   check_siblings)
 166 {
 167   GtkWidget *parent = widget;
 168   GSList *tmp_list;
 169
 170   while (parent)
 171     {
 172       GSList *widget_groups;
 173       GSList *groups;
 174       GSList *widgets;
 175
 176       if (widget == parent && !check_siblings)
 177         {
 178           real_queue_resize (widget);
 179           parent = parent->parent;
 180           continue;
 181         }
 182
 183       widget_groups = get_size_groups (parent);
 184       if (!widget_groups)
 185         {
 186           if (widget == parent)
 187             real_queue_resize (widget);
 188
 189           parent = parent->parent;
 190           continue;
 191         }
 192
 193       groups = NULL;
 194       widgets = NULL;
 195
 196       add_widget_to_closure (parent, GTK_SIZE_GROUP_HORIZONTAL, &groups, &widgets);
 197       g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
 198       g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
 199
 200       reset_group_sizes (groups);
 201
 202       tmp_list = widgets;
 203       while (tmp_list)
 204         {
 205           if (tmp_list->data == parent)
 206             {
 207               if (widget == parent)
 208                 real_queue_resize (parent);
 209             }
 210           else
 211             queue_resize_on_widget (tmp_list->data, FALSE);
 212
 213           tmp_list = tmp_list->next;
 214         }
 215
 216       g_slist_free (widgets);
 217       g_slist_free (groups);
 218
 219       groups = NULL;
 220       widgets = NULL;
 221
 222       add_widget_to_closure (parent, GTK_SIZE_GROUP_VERTICAL, &groups, &widgets);
 223       g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
 224       g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
 225
 226       reset_group_sizes (groups);
 227
 228       tmp_list = widgets;
 229       while (tmp_list)
 230         {
 231           if (tmp_list->data == parent)
 232             {
 233               if (widget == parent)
 234                 real_queue_resize (parent);
 235             }
 236           else
 237             queue_resize_on_widget (tmp_list->data, FALSE);
 238
 239           tmp_list = tmp_list->next;
 240         }
 241
 242       g_slist_free (widgets);
 243       g_slist_free (groups);
 244
 245       parent = parent->parent;
 246     }
 247 }
 248
 249 static void
 250 queue_resize_on_group (GtkSizeGroup *size_group)
 251 {
 252   if (size_group->widgets)
 253     queue_resize_on_widget (size_group->widgets->data, TRUE);
 254 }
 255
 256 static void
 257 gtk_size_group_class_init (GtkSizeGroupClass *klass)
 258 {
 259   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 260
 261   gobject_class->set_property = gtk_size_group_set_property;
 262   gobject_class->get_property = gtk_size_group_get_property;
 263
 264   g_object_class_install_property (gobject_class,
 265                                    PROP_MODE,
 266                                    g_param_spec_enum ("mode",
 267                                                       P_("Mode"),
 268                                                       P_("The directions in which the size group affects the requested sizes"
 269                                                         " of its component widgets"),
 270                                                       GTK_TYPE_SIZE_GROUP_MODE,
 271                                                       GTK_SIZE_GROUP_HORIZONTAL,                                                      GTK_PARAM_READWRITE));
 272
 273   /**
 274    * GtkSizeGroup:ignore-hidden:
 275    *
 276    * If %TRUE, unmapped widgets are ignored when determining
 277    * the size of the group.
 278    *
 279    * Since: 2.8
 280    */
 281   g_object_class_install_property (gobject_class,
 282                                    PROP_IGNORE_HIDDEN,
 283                                    g_param_spec_boolean ("ignore-hidden",
 284                                                          P_("Ignore hidden"),
 285                                                          P_("If TRUE, unmapped widgets are ignored "
 286                                                             "when determining the size of the group"),
 287                                                          FALSE,
 288                                                          GTK_PARAM_READWRITE));
 289
 290   size_groups_quark = g_quark_from_static_string (size_groups_tag);
 291   visited_quark = g_quark_from_string (visited_tag);
 292 }
 293
 294 static void
 295 gtk_size_group_init (GtkSizeGroup *size_group)
 296 {
 297   size_group->widgets = NULL;
 298   size_group->mode = GTK_SIZE_GROUP_HORIZONTAL;
 299   size_group->have_width = 0;
 300   size_group->have_height = 0;
 301   size_group->ignore_hidden = 0;
 302 }
 303
 304 G_DEFINE_TYPE (GtkSizeGroup, gtk_size_group, G_TYPE_OBJECT)
 305
 306 static void
 307 gtk_size_group_set_property (GObject      *object,
 308                              guint         prop_id,
 309                              const GValue *value,
 310                              GParamSpec   *pspec)
 311 {
 312   GtkSizeGroup *size_group = GTK_SIZE_GROUP (object);
 313
 314   switch (prop_id)
 315     {
 316     case PROP_MODE:
 317       gtk_size_group_set_mode (size_group, g_value_get_enum (value));
 318       break;
 319     case PROP_IGNORE_HIDDEN:
 320       gtk_size_group_set_ignore_hidden (size_group, g_value_get_boolean (value));
 321       break;
 322     default:
 323       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 324       break;
 325     }
 326 }
 327
 328 static void
 329 gtk_size_group_get_property (GObject      *object,
 330                              guint         prop_id,
 331                              GValue       *value,
 332                              GParamSpec   *pspec)
 333 {
 334   GtkSizeGroup *size_group = GTK_SIZE_GROUP (object);
 335
 336   switch (prop_id)
 337     {
 338     case PROP_MODE:
 339       g_value_set_enum (value, size_group->mode);
 340       break;
 341     case PROP_IGNORE_HIDDEN:
 342       g_value_set_boolean (value, size_group->ignore_hidden);
 343       break;
 344     default:
 345       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 346       break;
 347     }
 348 }
 349
 350 /**
 351  * gtk_size_group_new:
 352  * @mode: the mode for the new size group.
 353  *
 354  * Create a new #GtkSizeGroup.
 355
 356  * Return value: a newly created #GtkSizeGroup
 357  **/
 358 GtkSizeGroup *
 359 gtk_size_group_new (GtkSizeGroupMode  mode)
 360 {
 361   GtkSizeGroup *size_group = g_object_new (GTK_TYPE_SIZE_GROUP, NULL);
 362
 363   size_group->mode = mode;
 364
 365   return size_group;
 366 }
 367
 368 /**
 369  * gtk_size_group_set_mode:
 370  * @size_group: a #GtkSizeGroup
 371  * @mode: the mode to set for the size group.
 372  *
 373  * Sets the #GtkSizeGroupMode of the size group. The mode of the size
 374  * group determines whether the widgets in the size group should
 375  * all have the same horizontal requisition (%GTK_SIZE_GROUP_MODE_HORIZONTAL)
 376  * all have the same vertical requisition (%GTK_SIZE_GROUP_MODE_VERTICAL),
 377  * or should all have the same requisition in both directions
 378  * (%GTK_SIZE_GROUP_MODE_BOTH).
 379  **/
 380 void
 381 gtk_size_group_set_mode (GtkSizeGroup     *size_group,
 382                          GtkSizeGroupMode  mode)
 383 {
 384   g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
 385
 386   if (size_group->mode != mode)
 387     {
 388       if (size_group->mode != GTK_SIZE_GROUP_NONE)
 389         queue_resize_on_group (size_group);
 390       size_group->mode = mode;
 391       if (size_group->mode != GTK_SIZE_GROUP_NONE)
 392         queue_resize_on_group (size_group);
 393
 394       g_object_notify (G_OBJECT (size_group), "mode");
 395     }
 396 }
 397
 398 /**
 399  * gtk_size_group_get_mode:
 400  * @size_group: a #GtkSizeGroup
 401  *
 402  * Gets the current mode of the size group. See gtk_size_group_set_mode().
 403  *
 404  * Return value: the current mode of the size group.
 405  **/
 406 GtkSizeGroupMode
 407 gtk_size_group_get_mode (GtkSizeGroup *size_group)
 408 {
 409   g_return_val_if_fail (GTK_IS_SIZE_GROUP (size_group), GTK_SIZE_GROUP_BOTH);
 410
 411   return size_group->mode;
 412 }
 413
 414 /**
 415  * gtk_size_group_set_ignore_hidden:
 416  * @size_group: a #GtkSizeGroup
 417  * @ignore_hidden: whether unmapped widgets should be ignored
 418  *   when calculating the size
 419  *
 420  * Sets whether unmapped widgets should be ignored when
 421  * calculating the size.
 422  *
 423  * Since: 2.8
 424  */
 425 void
 426 gtk_size_group_set_ignore_hidden (GtkSizeGroup *size_group,
 427                                   gboolean      ignore_hidden)
 428 {
 429   g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
 430
 431   ignore_hidden = ignore_hidden != FALSE;
 432
 433   if (size_group->ignore_hidden != ignore_hidden)
 434     {
 435       size_group->ignore_hidden = ignore_hidden;
 436
 437       g_object_notify (G_OBJECT (size_group), "ignore-hidden");
 438     }
 439 }
 440
 441 /**
 442  * gtk_size_group_get_ignore_hidden:
 443  * @size_group: a #GtkSizeGroup
 444  *
 445  * Returns if invisible widgets are ignored when calculating the size.
 446  *
 447  * Returns: %TRUE if invisible widgets are ignored.
 448  *
 449  * Since: 2.8
 450  */
 451 gboolean
 452 gtk_size_group_get_ignore_hidden (GtkSizeGroup *size_group)
 453 {
 454   g_return_val_if_fail (GTK_IS_SIZE_GROUP (size_group), FALSE);
 455
 456   return size_group->ignore_hidden;
 457 }
 458
 459 static void
 460 gtk_size_group_widget_destroyed (GtkWidget    *widget,
 461                                  GtkSizeGroup *size_group)
 462 {
 463   gtk_size_group_remove_widget (size_group, widget);
 464 }
 465
 466 /**
 467  * gtk_size_group_add_widget:
 468  * @size_group: a #GtkSizeGroup
 469  * @widget: the #GtkWidget to add
 470  *
 471  * Adds a widget to a #GtkSizeGroup. In the future, the requisition
 472  * of the widget will be determined as the maximum of its requisition
 473  * and the requisition of the other widgets in the size group.
 474  * Whether this applies horizontally, vertically, or in both directions
 475  * depends on the mode of the size group. See gtk_size_group_set_mode().
 476  **/
 477 void
 478 gtk_size_group_add_widget (GtkSizeGroup     *size_group,
 479                            GtkWidget        *widget)
 480 {
 481   GSList *groups;
 482
 483   g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
 484   g_return_if_fail (GTK_IS_WIDGET (widget));
 485
 486   groups = get_size_groups (widget);
 487
 488   if (!g_slist_find (groups, size_group))
 489     {
 490       groups = g_slist_prepend (groups, size_group);
 491       set_size_groups (widget, groups);
 492
 493       size_group->widgets = g_slist_prepend (size_group->widgets, widget);
 494
 495       g_signal_connect (widget, "destroy",
 496                         G_CALLBACK (gtk_size_group_widget_destroyed),
 497                         size_group);
 498
 499       g_object_ref (size_group);
 500     }
 501
 502   queue_resize_on_group (size_group);
 503 }
 504
 505 /**
 506  * gtk_size_group_remove_widget:
 507  * @size_group: a #GtkSizeGrup
 508  * @widget: the #GtkWidget to remove
 509  *
 510  * Removes a widget from a #GtkSizeGroup.
 511  **/
 512 void
 513 gtk_size_group_remove_widget (GtkSizeGroup     *size_group,
 514                               GtkWidget        *widget)
 515 {
 516   GSList *groups;
 517
 518   g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
 519   g_return_if_fail (GTK_IS_WIDGET (widget));
 520   g_return_if_fail (g_slist_find (size_group->widgets, widget));
 521
 522   g_signal_handlers_disconnect_by_func (widget,
 523                                         gtk_size_group_widget_destroyed,
 524                                         size_group);
 525
 526   groups = get_size_groups (widget);
 527   groups = g_slist_remove (groups, size_group);
 528   set_size_groups (widget, groups);
 529
 530   size_group->widgets = g_slist_remove (size_group->widgets, widget);
 531   queue_resize_on_group (size_group);
 532   gtk_widget_queue_resize (widget);
 533
 534   g_object_unref (size_group);
 535 }
 536
 537 /**
 538  * gtk_size_group_get_widgets:
 539  * @size_group: a #GtkSizeGrup
 540  *
 541  * Returns the list of widgets associated with @size_group.
 542  *
 543  * Return value: a #GSList of widgets. The list is owned by GTK+
 544  *   and should not be modified.
 545  *
 546  * Since: 2.10
 547  **/
 548 GSList *
 549 gtk_size_group_get_widgets (GtkSizeGroup *size_group)
 550 {
 551      return size_group->widgets;
 552 }
 553
 554 static gint
 555 get_base_dimension (GtkWidget        *widget,
 556                     GtkSizeGroupMode  mode)
 557 {
 558   GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, FALSE);
 559
 560   if (mode == GTK_SIZE_GROUP_HORIZONTAL)
 561     {
 562       if (aux_info && aux_info->width > 0)
 563         return aux_info->width;
 564       else
 565         return widget->requisition.width;
 566     }
 567   else
 568     {
 569       if (aux_info && aux_info->height > 0)
 570         return aux_info->height;
 571       else
 572         return widget->requisition.height;
 573     }
 574 }
 575
 576 static void
 577 do_size_request (GtkWidget *widget)
 578 {
 579   if (GTK_WIDGET_REQUEST_NEEDED (widget))
 580     {
 581       gtk_widget_ensure_style (widget);
 582       GTK_PRIVATE_UNSET_FLAG (widget, GTK_REQUEST_NEEDED);
 583       g_signal_emit_by_name (widget,
 584                              "size_request",
 585                              &widget->requisition);
 586     }
 587 }
 588
 589 static gint
 590 compute_base_dimension (GtkWidget        *widget,
 591                         GtkSizeGroupMode  mode)
 592 {
 593   do_size_request (widget);
 594
 595   return get_base_dimension (widget, mode);
 596 }
 597
 598 static gint
 599 compute_dimension (GtkWidget        *widget,
 600                    GtkSizeGroupMode  mode)
 601 {
 602   GSList *widgets = NULL;
 603   GSList *groups = NULL;
 604   GSList *tmp_list;
 605   gint result = 0;
 606
 607   add_widget_to_closure (widget, mode, &groups, &widgets);
 608
 609   g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
 610   g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
 611
 612   g_slist_foreach (widgets, (GFunc)g_object_ref, NULL);
 613
 614   if (!groups)
 615     {
 616       result = compute_base_dimension (widget, mode);
 617     }
 618   else
 619     {
 620       GtkSizeGroup *group = groups->data;
 621
 622       if (mode == GTK_SIZE_GROUP_HORIZONTAL && group->have_width)
 623         result = group->requisition.width;
 624       else if (mode == GTK_SIZE_GROUP_VERTICAL && group->have_height)
 625         result = group->requisition.height;
 626       else
 627         {
 628           tmp_list = widgets;
 629           while (tmp_list)
 630             {
 631               GtkWidget *tmp_widget = tmp_list->data;
 632
 633               gint dimension = compute_base_dimension (tmp_widget, mode);
 634
 635               if (GTK_WIDGET_MAPPED (tmp_widget) || !group->ignore_hidden)
 636                 {
 637                   if (dimension > result)
 638                     result = dimension;
 639                 }
 640
 641               tmp_list = tmp_list->next;
 642             }
 643
 644           tmp_list = groups;
 645           while (tmp_list)
 646             {
 647               GtkSizeGroup *tmp_group = tmp_list->data;
 648
 649               if (mode == GTK_SIZE_GROUP_HORIZONTAL)
 650                 {
 651                   tmp_group->have_width = TRUE;
 652                   tmp_group->requisition.width = result;
 653                 }
 654               else
 655                 {
 656                   tmp_group->have_height = TRUE;
 657                   tmp_group->requisition.height = result;
 658                 }
 659
 660               tmp_list = tmp_list->next;
 661             }
 662         }
 663     }
 664
 665   g_slist_foreach (widgets, (GFunc)g_object_unref, NULL);
 666
 667   g_slist_free (widgets);
 668   g_slist_free (groups);
 669
 670   return result;
 671 }
 672
 673 static gint
 674 get_dimension (GtkWidget        *widget,
 675                GtkSizeGroupMode  mode)
 676 {
 677   GSList *widgets = NULL;
 678   GSList *groups = NULL;
 679   gint result = 0;
 680
 681   add_widget_to_closure (widget, mode, &groups, &widgets);
 682
 683   g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
 684   g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
 685
 686   if (!groups)
 687     {
 688       result = get_base_dimension (widget, mode);
 689     }
 690   else
 691     {
 692       GtkSizeGroup *group = groups->data;
 693
 694       if (mode == GTK_SIZE_GROUP_HORIZONTAL && group->have_width)
 695         result = group->requisition.width;
 696       else if (mode == GTK_SIZE_GROUP_VERTICAL && group->have_height)
 697         result = group->requisition.height;
 698     }
 699
 700   g_slist_free (widgets);
 701   g_slist_free (groups);
 702
 703   return result;
 704 }
 705
 706 static void
 707 get_fast_child_requisition (GtkWidget      *widget,
 708                             GtkRequisition *requisition)
 709 {
 710   GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, FALSE);
 711
 712   *requisition = widget->requisition;
 713
 714   if (aux_info)
 715     {
 716       if (aux_info->width > 0)
 717         requisition->width = aux_info->width;
 718       if (aux_info && aux_info->height > 0)
 719         requisition->height = aux_info->height;
 720     }
 721 }
 722
 723 /**
 724  * _gtk_size_group_get_child_requisition:
 725  * @widget: a #GtkWidget
 726  * @requisition: location to store computed requisition.
 727  *
 728  * Retrieve the "child requisition" of the widget, taking account grouping
 729  * of the widget's requisition with other widgets.
 730  **/
 731 void
 732 _gtk_size_group_get_child_requisition (GtkWidget      *widget,
 733                                        GtkRequisition *requisition)
 734 {
 735   if (requisition)
 736     {
 737       if (get_size_groups (widget))
 738         {
 739           requisition->width = get_dimension (widget, GTK_SIZE_GROUP_HORIZONTAL);
 740           requisition->height = get_dimension (widget, GTK_SIZE_GROUP_VERTICAL);
 741
 742           /* Only do the full computation if we actually have size groups */
 743         }
 744       else
 745         get_fast_child_requisition (widget, requisition);
 746     }
 747 }
 748
 749 /**
 750  * _gtk_size_group_compute_requisition:
 751  * @widget: a #GtkWidget
 752  * @requisition: location to store computed requisition.
 753  *
 754  * Compute the requisition of a widget taking into account grouping of
 755  * the widget's requisition with other widgets.
 756  **/
 757 void
 758 _gtk_size_group_compute_requisition (GtkWidget      *widget,
 759                                      GtkRequisition *requisition)
 760 {
 761   gint width;
 762   gint height;
 763
 764   if (get_size_groups (widget))
 765     {
 766       /* Only do the full computation if we actually have size groups */
 767
 768       width = compute_dimension (widget, GTK_SIZE_GROUP_HORIZONTAL);
 769       height = compute_dimension (widget, GTK_SIZE_GROUP_VERTICAL);
 770
 771       if (requisition)
 772         {
 773           requisition->width = width;
 774           requisition->height = height;
 775         }
 776     }
 777   else
 778     {
 779       do_size_request (widget);
 780
 781       if (requisition)
 782         get_fast_child_requisition (widget, requisition);
 783     }
 784 }
 785
 786 /**
 787  * _gtk_size_group_queue_resize:
 788  * @widget: a #GtkWidget
 789  *
 790  * Queue a resize on a widget, and on all other widgets grouped with this widget.
 791  **/
 792 void
 793 _gtk_size_group_queue_resize (GtkWidget *widget)
 794 {
 795   queue_resize_on_widget (widget, TRUE);
 796 }
 797
 798 #define __GTK_SIZE_GROUP_C__
 799 #include "gtkaliasdef.c"