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

   1 /* GtkToolPalette -- A tool palette with categories and DnD support
   2  * Copyright (C) 2008  Openismus GmbH
   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.1 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 Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors:
  19  *      Mathias Hasselmann
  20  *      Jan Arne Petersen
  21  */
  22
  23 #include "config.h"
  24
  25 #include "gtktoolpaletteprivate.h"
  26
  27 #include <gtk/gtk.h>
  28 #include <math.h>
  29 #include <string.h>
  30 #include "gtkprivate.h"
  31 #include "gtkintl.h"
  32 #include "gtkalias.h"
  33
  34 #define ANIMATION_TIMEOUT        50
  35 #define ANIMATION_DURATION      (ANIMATION_TIMEOUT * 4)
  36 #define DEFAULT_ANIMATION_STATE  TRUE
  37 #define DEFAULT_EXPANDER_SIZE    16
  38 #define DEFAULT_HEADER_SPACING   2
  39
  40 #define DEFAULT_LABEL            ""
  41 #define DEFAULT_COLLAPSED        FALSE
  42 #define DEFAULT_ELLIPSIZE        PANGO_ELLIPSIZE_NONE
  43
  44 /**
  45  * SECTION:gtktoolitemgroup
  46  * @Short_description: A sub container used in a tool palette
  47  * @Title: GtkToolItemGroup
  48  *
  49  * A #GtkToolItemGroup is used together with #GtkToolPalette to add
  50  * #GtkToolItem<!-- -->s to a palette like container with different
  51  * categories and drag and drop support.
  52  *
  53  * Since: 2.20
  54  */
  55
  56 enum
  57 {
  58   PROP_NONE,
  59   PROP_LABEL,
  60   PROP_LABEL_WIDGET,
  61   PROP_COLLAPSED,
  62   PROP_ELLIPSIZE,
  63   PROP_RELIEF
  64 };
  65
  66 enum
  67 {
  68   CHILD_PROP_NONE,
  69   CHILD_PROP_HOMOGENEOUS,
  70   CHILD_PROP_EXPAND,
  71   CHILD_PROP_FILL,
  72   CHILD_PROP_NEW_ROW,
  73   CHILD_PROP_POSITION,
  74 };
  75
  76 typedef struct _GtkToolItemGroupChild GtkToolItemGroupChild;
  77
  78 struct _GtkToolItemGroupPrivate
  79 {
  80   GtkWidget         *header;
  81   GtkWidget         *label_widget;
  82
  83   GList             *children;
  84
  85   gboolean           animation;
  86   gint64             animation_start;
  87   GSource           *animation_timeout;
  88   GtkExpanderStyle   expander_style;
  89   gint               expander_size;
  90   gint               header_spacing;
  91   PangoEllipsizeMode ellipsize;
  92
  93   gulong             focus_set_id;
  94   GtkWidget         *toplevel;
  95
  96   GtkSettings       *settings;
  97   gulong             settings_connection;
  98
  99   guint              collapsed : 1;
 100 };
 101
 102 struct _GtkToolItemGroupChild
 103 {
 104   GtkToolItem *item;
 105
 106   guint        homogeneous : 1;
 107   guint        expand : 1;
 108   guint        fill : 1;
 109   guint        new_row : 1;
 110 };
 111
 112 static void gtk_tool_item_group_tool_shell_init (GtkToolShellIface *iface);
 113
 114 G_DEFINE_TYPE_WITH_CODE (GtkToolItemGroup, gtk_tool_item_group, GTK_TYPE_CONTAINER,
 115 G_IMPLEMENT_INTERFACE (GTK_TYPE_TOOL_SHELL, gtk_tool_item_group_tool_shell_init));
 116
 117 static GtkWidget*
 118 gtk_tool_item_group_get_alignment (GtkToolItemGroup *group)
 119 {
 120   return gtk_bin_get_child (GTK_BIN (group->priv->header));
 121 }
 122
 123 static GtkOrientation
 124 gtk_tool_item_group_get_orientation (GtkToolShell *shell)
 125 {
 126   GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));
 127
 128   if (GTK_IS_TOOL_PALETTE (parent))
 129     return gtk_orientable_get_orientation (GTK_ORIENTABLE (parent));
 130
 131   return GTK_ORIENTATION_VERTICAL;
 132 }
 133
 134 static GtkToolbarStyle
 135 gtk_tool_item_group_get_style (GtkToolShell *shell)
 136 {
 137   GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));
 138
 139   if (GTK_IS_TOOL_PALETTE (parent))
 140     return gtk_tool_palette_get_style (GTK_TOOL_PALETTE (parent));
 141
 142   return GTK_TOOLBAR_ICONS;
 143 }
 144
 145 static GtkIconSize
 146 gtk_tool_item_group_get_icon_size (GtkToolShell *shell)
 147 {
 148   GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));
 149
 150   if (GTK_IS_TOOL_PALETTE (parent))
 151     return gtk_tool_palette_get_icon_size (GTK_TOOL_PALETTE (parent));
 152
 153   return GTK_ICON_SIZE_SMALL_TOOLBAR;
 154 }
 155
 156 static PangoEllipsizeMode
 157 gtk_tool_item_group_get_ellipsize_mode (GtkToolShell *shell)
 158 {
 159   return GTK_TOOL_ITEM_GROUP (shell)->priv->ellipsize;
 160 }
 161
 162 static gfloat
 163 gtk_tool_item_group_get_text_alignment (GtkToolShell *shell)
 164 {
 165   if (GTK_TOOLBAR_TEXT == gtk_tool_item_group_get_style (shell) ||
 166       GTK_TOOLBAR_BOTH_HORIZ == gtk_tool_item_group_get_style (shell))
 167     return 0.0;
 168
 169   return 0.5;
 170 }
 171
 172 static GtkOrientation
 173 gtk_tool_item_group_get_text_orientation (GtkToolShell *shell)
 174 {
 175   return GTK_ORIENTATION_HORIZONTAL;
 176 }
 177
 178 static GtkSizeGroup *
 179 gtk_tool_item_group_get_text_size_group (GtkToolShell *shell)
 180 {
 181   GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));
 182
 183   if (GTK_IS_TOOL_PALETTE (parent))
 184     return _gtk_tool_palette_get_size_group (GTK_TOOL_PALETTE (parent));
 185
 186   return NULL;
 187 }
 188
 189 static void
 190 animation_change_notify (GtkToolItemGroup *group)
 191 {
 192   GtkSettings *settings = group->priv->settings;
 193   gboolean animation;
 194
 195   if (settings)
 196     g_object_get (settings,
 197                   "gtk-enable-animations", &animation,
 198                   NULL);
 199   else
 200     animation = DEFAULT_ANIMATION_STATE;
 201
 202   group->priv->animation = animation;
 203 }
 204
 205 static void
 206 gtk_tool_item_group_settings_change_notify (GtkSettings      *settings,
 207                                             const GParamSpec *pspec,
 208                                             GtkToolItemGroup *group)
 209 {
 210   if (strcmp (pspec->name, "gtk-enable-animations") == 0)
 211     animation_change_notify (group);
 212 }
 213
 214 static void
 215 gtk_tool_item_group_screen_changed (GtkWidget *widget,
 216                                     GdkScreen *previous_screen)
 217 {
 218   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);
 219   GtkToolItemGroupPrivate* priv = group->priv;
 220   GtkSettings *old_settings = priv->settings;
 221   GtkSettings *settings;
 222
 223   if (gtk_widget_has_screen (GTK_WIDGET (group)))
 224     settings = gtk_widget_get_settings (GTK_WIDGET (group));
 225   else
 226     settings = NULL;
 227
 228   if (settings == old_settings)
 229     return;
 230
 231   if (old_settings)
 232   {
 233     g_signal_handler_disconnect (old_settings, priv->settings_connection);
 234     g_object_unref (old_settings);
 235   }
 236
 237   if (settings)
 238   {
 239     priv->settings_connection =
 240       g_signal_connect (settings, "notify",
 241                         G_CALLBACK (gtk_tool_item_group_settings_change_notify),
 242                         group);
 243     priv->settings = g_object_ref (settings);
 244   }
 245   else
 246     priv->settings = NULL;
 247
 248   animation_change_notify (group);
 249 }
 250
 251 static void
 252 gtk_tool_item_group_tool_shell_init (GtkToolShellIface *iface)
 253 {
 254   iface->get_icon_size = gtk_tool_item_group_get_icon_size;
 255   iface->get_orientation = gtk_tool_item_group_get_orientation;
 256   iface->get_style = gtk_tool_item_group_get_style;
 257   iface->get_text_alignment = gtk_tool_item_group_get_text_alignment;
 258   iface->get_text_orientation = gtk_tool_item_group_get_text_orientation;
 259   iface->get_text_size_group = gtk_tool_item_group_get_text_size_group;
 260   iface->get_ellipsize_mode = gtk_tool_item_group_get_ellipsize_mode;
 261 }
 262
 263 static gboolean
 264 gtk_tool_item_group_header_expose_event_cb (GtkWidget      *widget,
 265                                             GdkEventExpose *event,
 266                                             gpointer        data)
 267 {
 268   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);
 269   GtkToolItemGroupPrivate* priv = group->priv;
 270   GtkExpanderStyle expander_style;
 271   GtkOrientation orientation;
 272   gint x, y;
 273   GtkTextDirection direction;
 274
 275   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
 276   expander_style = priv->expander_style;
 277   direction = gtk_widget_get_direction (widget);
 278
 279   if (GTK_ORIENTATION_VERTICAL == orientation)
 280     {
 281       if (GTK_TEXT_DIR_RTL == direction)
 282         x = widget->allocation.x + widget->allocation.width - priv->expander_size / 2;
 283       else
 284         x = widget->allocation.x + priv->expander_size / 2;
 285       y = widget->allocation.y + widget->allocation.height / 2;
 286     }
 287   else
 288     {
 289       x = widget->allocation.x + widget->allocation.width / 2;
 290       y = widget->allocation.y + priv->expander_size / 2;
 291
 292       /* Unfortunatly gtk_paint_expander() doesn't support rotated drawing
 293        * modes. Luckily the following shady arithmetics produce the desired
 294        * result. */
 295       expander_style = GTK_EXPANDER_EXPANDED - expander_style;
 296     }
 297
 298   gtk_paint_expander (widget->style, widget->window,
 299                       priv->header->state,
 300                       &event->area, GTK_WIDGET (group),
 301                       "tool-palette-header", x, y,
 302                       expander_style);
 303
 304   return FALSE;
 305 }
 306
 307 static void
 308 gtk_tool_item_group_header_size_request_cb (GtkWidget      *widget,
 309                                             GtkRequisition *requisition,
 310                                             gpointer        data)
 311 {
 312   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);
 313   requisition->height = MAX (requisition->height, group->priv->expander_size);
 314 }
 315
 316 static void
 317 gtk_tool_item_group_header_clicked_cb (GtkButton *button,
 318                                        gpointer   data)
 319 {
 320   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);
 321   GtkToolItemGroupPrivate* priv = group->priv;
 322   GtkWidget *parent = gtk_widget_get_parent (data);
 323
 324   if (priv->collapsed ||
 325       !GTK_IS_TOOL_PALETTE (parent) ||
 326       !gtk_tool_palette_get_exclusive (GTK_TOOL_PALETTE (parent), data))
 327     gtk_tool_item_group_set_collapsed (group, !priv->collapsed);
 328 }
 329
 330 static void
 331 gtk_tool_item_group_header_adjust_style (GtkToolItemGroup *group)
 332 {
 333   GtkWidget *alignment = gtk_tool_item_group_get_alignment (group);
 334   GtkWidget *label_widget = gtk_bin_get_child (GTK_BIN (alignment));
 335   GtkWidget *widget = GTK_WIDGET (group);
 336   GtkToolItemGroupPrivate* priv = group->priv;
 337   gint dx = 0, dy = 0;
 338   GtkTextDirection direction = gtk_widget_get_direction (widget);
 339
 340   gtk_widget_style_get (widget,
 341                         "header-spacing", &(priv->header_spacing),
 342                         "expander-size", &(priv->expander_size),
 343                         NULL);
 344
 345   switch (gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group)))
 346     {
 347       case GTK_ORIENTATION_HORIZONTAL:
 348         dy = priv->header_spacing + priv->expander_size;
 349
 350         if (GTK_IS_LABEL (label_widget))
 351           {
 352             gtk_label_set_ellipsize (GTK_LABEL (label_widget), PANGO_ELLIPSIZE_NONE);
 353             if (GTK_TEXT_DIR_RTL == direction)
 354               gtk_label_set_angle (GTK_LABEL (label_widget), -90);
 355             else
 356               gtk_label_set_angle (GTK_LABEL (label_widget), 90);
 357           }
 358        break;
 359
 360       case GTK_ORIENTATION_VERTICAL:
 361         dx = priv->header_spacing + priv->expander_size;
 362
 363         if (GTK_IS_LABEL (label_widget))
 364           {
 365             gtk_label_set_ellipsize (GTK_LABEL (label_widget), priv->ellipsize);
 366             gtk_label_set_angle (GTK_LABEL (label_widget), 0);
 367           }
 368         break;
 369     }
 370
 371   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), dy, 0, dx, 0);
 372 }
 373
 374 static void
 375 gtk_tool_item_group_init (GtkToolItemGroup *group)
 376 {
 377   GtkWidget *alignment;
 378   GtkToolItemGroupPrivate* priv;
 379
 380   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (group), FALSE);
 381
 382   group->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
 383                                              GTK_TYPE_TOOL_ITEM_GROUP,
 384                                              GtkToolItemGroupPrivate);
 385
 386   priv->children = NULL;
 387   priv->header_spacing = DEFAULT_HEADER_SPACING;
 388   priv->expander_size = DEFAULT_EXPANDER_SIZE;
 389   priv->expander_style = GTK_EXPANDER_EXPANDED;
 390
 391   priv->label_widget = gtk_label_new (NULL);
 392   gtk_misc_set_alignment (GTK_MISC (priv->label_widget), 0.0, 0.5);
 393   alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
 394   gtk_container_add (GTK_CONTAINER (alignment), priv->label_widget);
 395   gtk_widget_show_all (alignment);
 396
 397   gtk_widget_push_composite_child ();
 398   priv->header = gtk_button_new ();
 399   gtk_widget_set_composite_name (priv->header, "header");
 400   gtk_widget_pop_composite_child ();
 401
 402   g_object_ref_sink (priv->header);
 403   gtk_button_set_focus_on_click (GTK_BUTTON (priv->header), FALSE);
 404   gtk_container_add (GTK_CONTAINER (priv->header), alignment);
 405   gtk_widget_set_parent (priv->header, GTK_WIDGET (group));
 406
 407   gtk_tool_item_group_header_adjust_style (group);
 408
 409   g_signal_connect_after (alignment, "expose-event",
 410                           G_CALLBACK (gtk_tool_item_group_header_expose_event_cb),
 411                           group);
 412   g_signal_connect_after (alignment, "size-request",
 413                           G_CALLBACK (gtk_tool_item_group_header_size_request_cb),
 414                           group);
 415
 416   g_signal_connect (priv->header, "clicked",
 417                     G_CALLBACK (gtk_tool_item_group_header_clicked_cb),
 418                     group);
 419 }
 420
 421 static void
 422 gtk_tool_item_group_set_property (GObject      *object,
 423                                   guint         prop_id,
 424                                   const GValue *value,
 425                                   GParamSpec   *pspec)
 426 {
 427   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);
 428
 429   switch (prop_id)
 430     {
 431       case PROP_LABEL:
 432         gtk_tool_item_group_set_label (group, g_value_get_string (value));
 433         break;
 434
 435       case PROP_LABEL_WIDGET:
 436         gtk_tool_item_group_set_label_widget (group, g_value_get_object (value));
 437
 438       case PROP_COLLAPSED:
 439         gtk_tool_item_group_set_collapsed (group, g_value_get_boolean (value));
 440         break;
 441
 442       case PROP_ELLIPSIZE:
 443         gtk_tool_item_group_set_ellipsize (group, g_value_get_enum (value));
 444         break;
 445
 446       case PROP_RELIEF:
 447         gtk_tool_item_group_set_header_relief (group, g_value_get_enum(value));
 448         break;
 449
 450       default:
 451         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 452         break;
 453     }
 454 }
 455
 456 static void
 457 gtk_tool_item_group_get_property (GObject    *object,
 458                                   guint       prop_id,
 459                                   GValue     *value,
 460                                   GParamSpec *pspec)
 461 {
 462   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);
 463
 464   switch (prop_id)
 465     {
 466       case PROP_LABEL:
 467         g_value_set_string (value, gtk_tool_item_group_get_label (group));
 468         break;
 469
 470       case PROP_LABEL_WIDGET:
 471         g_value_set_object (value,
 472                             gtk_tool_item_group_get_label_widget (group));
 473         break;
 474
 475       case PROP_COLLAPSED:
 476         g_value_set_boolean (value, gtk_tool_item_group_get_collapsed (group));
 477         break;
 478
 479       case PROP_ELLIPSIZE:
 480         g_value_set_enum (value, gtk_tool_item_group_get_ellipsize (group));
 481         break;
 482
 483       case PROP_RELIEF:
 484         g_value_set_enum (value, gtk_tool_item_group_get_header_relief (group));
 485         break;
 486
 487       default:
 488         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 489         break;
 490     }
 491 }
 492
 493 static void
 494 gtk_tool_item_group_finalize (GObject *object)
 495 {
 496   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);
 497
 498   if (group->priv->children)
 499     {
 500       g_list_free (group->priv->children);
 501       group->priv->children = NULL;
 502     }
 503
 504   G_OBJECT_CLASS (gtk_tool_item_group_parent_class)->finalize (object);
 505 }
 506
 507 static void
 508 gtk_tool_item_group_dispose (GObject *object)
 509 {
 510   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);
 511   GtkToolItemGroupPrivate* priv = group->priv;
 512
 513   if (priv->toplevel)
 514     {
 515       /* disconnect focus tracking handler */
 516       g_signal_handler_disconnect (priv->toplevel,
 517                                    priv->focus_set_id);
 518
 519       priv->focus_set_id = 0;
 520       priv->toplevel = NULL;
 521     }
 522
 523   G_OBJECT_CLASS (gtk_tool_item_group_parent_class)->dispose (object);
 524 }
 525
 526 static void
 527 gtk_tool_item_group_get_item_size (GtkToolItemGroup *group,
 528                                    GtkRequisition   *item_size,
 529                                    gboolean          homogeneous_only,
 530                                    gint             *requested_rows)
 531 {
 532   GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (group));
 533
 534   if (GTK_IS_TOOL_PALETTE (parent))
 535     _gtk_tool_palette_get_item_size (GTK_TOOL_PALETTE (parent), item_size, homogeneous_only, requested_rows);
 536   else
 537     _gtk_tool_item_group_item_size_request (group, item_size, homogeneous_only, requested_rows);
 538 }
 539
 540 static void
 541 gtk_tool_item_group_size_request (GtkWidget      *widget,
 542                                   GtkRequisition *requisition)
 543 {
 544   const gint border_width = GTK_CONTAINER (widget)->border_width;
 545   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);
 546   GtkToolItemGroupPrivate* priv = group->priv;
 547   GtkOrientation orientation;
 548   GtkRequisition item_size;
 549   gint requested_rows;
 550
 551   if (priv->children && gtk_tool_item_group_get_label_widget (group))
 552     {
 553       gtk_widget_size_request (priv->header, requisition);
 554       gtk_widget_show (priv->header);
 555     }
 556   else
 557     {
 558       requisition->width = requisition->height = 0;
 559       gtk_widget_hide (priv->header);
 560     }
 561
 562   gtk_tool_item_group_get_item_size (group, &item_size, FALSE, &requested_rows);
 563
 564   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
 565
 566   if (GTK_ORIENTATION_VERTICAL == orientation)
 567     requisition->width = MAX (requisition->width, item_size.width);
 568   else
 569     requisition->height = MAX (requisition->height, item_size.height * requested_rows);
 570
 571   requisition->width += border_width * 2;
 572   requisition->height += border_width * 2;
 573 }
 574
 575 static gboolean
 576 gtk_tool_item_group_is_item_visible (GtkToolItemGroup      *group,
 577                                      GtkToolItemGroupChild *child)
 578 {
 579   GtkToolbarStyle style;
 580   GtkOrientation orientation;
 581
 582   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
 583   style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));
 584
 585   /* horizontal tool palettes with text style support only homogeneous items */
 586   if (!child->homogeneous &&
 587       GTK_ORIENTATION_HORIZONTAL == orientation &&
 588       GTK_TOOLBAR_TEXT == style)
 589     return FALSE;
 590
 591   return
 592     (gtk_widget_get_visible (GTK_WIDGET (child->item))) &&
 593     (GTK_ORIENTATION_VERTICAL == orientation ?
 594      gtk_tool_item_get_visible_vertical (child->item) :
 595      gtk_tool_item_get_visible_horizontal (child->item));
 596 }
 597
 598 static inline unsigned
 599 udiv (unsigned x,
 600       unsigned y)
 601 {
 602   return (x + y - 1) / y;
 603 }
 604
 605 static void
 606 gtk_tool_item_group_real_size_query (GtkWidget      *widget,
 607                                      GtkAllocation  *allocation,
 608                                      GtkRequisition *inquery)
 609 {
 610   const gint border_width = GTK_CONTAINER (widget)->border_width;
 611   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);
 612   GtkToolItemGroupPrivate* priv = group->priv;
 613
 614   GtkRequisition item_size;
 615   GtkAllocation item_area;
 616
 617   GtkOrientation orientation;
 618   GtkToolbarStyle style;
 619
 620   gint min_rows;
 621
 622   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
 623   style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));
 624
 625   /* figure out the size of homogeneous items */
 626   gtk_tool_item_group_get_item_size (group, &item_size, TRUE, &min_rows);
 627
 628   if (GTK_ORIENTATION_VERTICAL == orientation)
 629     item_size.width = MIN (item_size.width, allocation->width);
 630   else
 631     item_size.height = MIN (item_size.height, allocation->height);
 632
 633   item_area.width = 0;
 634   item_area.height = 0;
 635
 636   /* figure out the required columns (n_columns) and rows (n_rows) to place all items */
 637   if (!priv->collapsed || !priv->animation || priv->animation_timeout)
 638     {
 639       guint n_columns;
 640       gint n_rows;
 641       GList *it;
 642
 643       if (GTK_ORIENTATION_VERTICAL == orientation)
 644         {
 645           gboolean new_row = FALSE;
 646           gint row = -1;
 647           guint col = 0;
 648
 649           item_area.width = allocation->width - 2 * border_width;
 650           n_columns = MAX (item_area.width / item_size.width, 1);
 651
 652           /* calculate required rows for n_columns columns */
 653           for (it = priv->children; it != NULL; it = it->next)
 654             {
 655               GtkToolItemGroupChild *child = it->data;
 656
 657               if (!gtk_tool_item_group_is_item_visible (group, child))
 658                 continue;
 659
 660               if (new_row || child->new_row)
 661                 {
 662                   new_row = FALSE;
 663                   row++;
 664                   col = 0;
 665                 }
 666
 667               if (child->expand)
 668                 new_row = TRUE;
 669
 670               if (child->homogeneous)
 671                 {
 672                   col++;
 673                   if (col >= n_columns)
 674                     new_row = TRUE;
 675                 }
 676               else
 677                 {
 678                   GtkRequisition req = {0, 0};
 679                   guint width;
 680
 681                   gtk_widget_size_request (GTK_WIDGET (child->item), &req);
 682
 683                   width = udiv (req.width, item_size.width);
 684                   col += width;
 685
 686                   if (col > n_columns)
 687                     row++;
 688
 689                   col = width;
 690
 691                   if (col >= n_columns)
 692                     new_row = TRUE;
 693                 }
 694             }
 695           n_rows = row + 2;
 696         }
 697       else
 698         {
 699           guint *row_min_width;
 700           gint row = -1;
 701           gboolean new_row = TRUE;
 702           guint col = 0, min_col, max_col = 0, all_items = 0;
 703           gint i;
 704
 705           item_area.height = allocation->height - 2 * border_width;
 706           n_rows = MAX (item_area.height / item_size.height, min_rows);
 707
 708           row_min_width = g_new0 (guint, n_rows);
 709
 710           /* calculate minimal and maximal required cols and minimal required rows */
 711           for (it = priv->children; it != NULL; it = it->next)
 712             {
 713               GtkToolItemGroupChild *child = it->data;
 714
 715               if (!gtk_tool_item_group_is_item_visible (group, child))
 716                 continue;
 717
 718               if (new_row || child->new_row)
 719                 {
 720                   new_row = FALSE;
 721                   row++;
 722                   col = 0;
 723                   row_min_width[row] = 1;
 724                 }
 725
 726               if (child->expand)
 727                 new_row = TRUE;
 728
 729               if (child->homogeneous)
 730                 {
 731                   col++;
 732                   all_items++;
 733                 }
 734               else
 735                 {
 736                   GtkRequisition req = {0, 0};
 737                   guint width;
 738
 739                   gtk_widget_size_request (GTK_WIDGET (child->item), &req);
 740
 741                   width = udiv (req.width, item_size.width);
 742
 743                   col += width;
 744                   all_items += width;
 745
 746                   row_min_width[row] = MAX (row_min_width[row], width);
 747                 }
 748
 749               max_col = MAX (max_col, col);
 750             }
 751
 752           /* calculate minimal required cols */
 753           min_col = udiv (all_items, n_rows);
 754
 755           for (i = 0; i <= row; i++)
 756             {
 757               min_col = MAX (min_col, row_min_width[i]);
 758             }
 759
 760           /* simple linear search for minimal required columns for the given maximal number of rows (n_rows) */
 761           for (n_columns = min_col; n_columns < max_col; n_columns ++)
 762             {
 763               new_row = TRUE;
 764               row = -1;
 765               /* calculate required rows for n_columns columns */
 766               for (it = priv->children; it != NULL; it = it->next)
 767                 {
 768                   GtkToolItemGroupChild *child = it->data;
 769
 770                   if (!gtk_tool_item_group_is_item_visible (group, child))
 771                     continue;
 772
 773                   if (new_row || child->new_row)
 774                     {
 775                       new_row = FALSE;
 776                       row++;
 777                       col = 0;
 778                     }
 779
 780                   if (child->expand)
 781                     new_row = TRUE;
 782
 783                   if (child->homogeneous)
 784                     {
 785                       col++;
 786                       if (col >= n_columns)
 787                         new_row = TRUE;
 788                     }
 789                   else
 790                     {
 791                       GtkRequisition req = {0, 0};
 792                       guint width;
 793
 794                       gtk_widget_size_request (GTK_WIDGET (child->item), &req);
 795
 796                       width = udiv (req.width, item_size.width);
 797                       col += width;
 798
 799                       if (col > n_columns)
 800                         row++;
 801
 802                       col = width;
 803
 804                       if (col >= n_columns)
 805                         new_row = TRUE;
 806                     }
 807                 }
 808
 809               if (row < n_rows)
 810                 break;
 811             }
 812         }
 813
 814       item_area.width = item_size.width * n_columns;
 815       item_area.height = item_size.height * n_rows;
 816     }
 817
 818   inquery->width = 0;
 819   inquery->height = 0;
 820
 821   /* figure out header widget size */
 822   if (gtk_widget_get_visible (priv->header))
 823     {
 824       GtkRequisition child_requisition;
 825
 826       gtk_widget_size_request (priv->header, &child_requisition);
 827
 828       if (GTK_ORIENTATION_VERTICAL == orientation)
 829         inquery->height += child_requisition.height;
 830       else
 831         inquery->width += child_requisition.width;
 832     }
 833
 834   /* report effective widget size */
 835   inquery->width += item_area.width + 2 * border_width;
 836   inquery->height += item_area.height + 2 * border_width;
 837 }
 838
 839 static void
 840 gtk_tool_item_group_real_size_allocate (GtkWidget     *widget,
 841                                         GtkAllocation *allocation)
 842 {
 843   const gint border_width = GTK_CONTAINER (widget)->border_width;
 844   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);
 845   GtkToolItemGroupPrivate* priv = group->priv;
 846   GtkRequisition child_requisition;
 847   GtkAllocation child_allocation;
 848
 849   GtkRequisition item_size;
 850   GtkAllocation item_area;
 851
 852   GtkOrientation orientation;
 853   GtkToolbarStyle style;
 854
 855   GList *it;
 856
 857   gint n_columns, n_rows = 1;
 858   gint min_rows;
 859
 860   GtkTextDirection direction = gtk_widget_get_direction (widget);
 861
 862   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
 863   style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));
 864
 865   /* chain up */
 866   GTK_WIDGET_CLASS (gtk_tool_item_group_parent_class)->size_allocate (widget, allocation);
 867
 868   child_allocation.x = border_width;
 869   child_allocation.y = border_width;
 870
 871   /* place the header widget */
 872   if (gtk_widget_get_visible (priv->header))
 873     {
 874       gtk_widget_size_request (priv->header, &child_requisition);
 875
 876       if (GTK_ORIENTATION_VERTICAL == orientation)
 877         {
 878           child_allocation.width = allocation->width;
 879           child_allocation.height = child_requisition.height;
 880         }
 881       else
 882         {
 883           child_allocation.width = child_requisition.width;
 884           child_allocation.height = allocation->height;
 885
 886           if (GTK_TEXT_DIR_RTL == direction)
 887             child_allocation.x = allocation->width - border_width - child_allocation.width;
 888         }
 889
 890       gtk_widget_size_allocate (priv->header, &child_allocation);
 891
 892       if (GTK_ORIENTATION_VERTICAL == orientation)
 893         child_allocation.y += child_allocation.height;
 894       else if (GTK_TEXT_DIR_RTL != direction)
 895         child_allocation.x += child_allocation.width;
 896       else
 897         child_allocation.x = border_width;
 898     }
 899   else
 900     child_requisition.width = child_requisition.height = 0;
 901
 902   /* figure out the size of homogeneous items */
 903   gtk_tool_item_group_get_item_size (group, &item_size, TRUE, &min_rows);
 904
 905   /* figure out the available columns and size of item_area */
 906   if (GTK_ORIENTATION_VERTICAL == orientation)
 907     {
 908       item_size.width = MIN (item_size.width, allocation->width);
 909
 910       item_area.width = allocation->width - 2 * border_width;
 911       item_area.height = allocation->height - 2 * border_width - child_requisition.height;
 912
 913       n_columns = MAX (item_area.width / item_size.width, 1);
 914
 915       item_size.width = item_area.width / n_columns;
 916     }
 917   else
 918     {
 919       item_size.height = MIN (item_size.height, allocation->height);
 920
 921       item_area.width = allocation->width - 2 * border_width - child_requisition.width;
 922       item_area.height = allocation->height - 2 * border_width;
 923
 924       n_columns = MAX (item_area.width / item_size.width, 1);
 925       n_rows = MAX (item_area.height / item_size.height, min_rows);
 926
 927       item_size.height = item_area.height / n_rows;
 928     }
 929
 930   item_area.x = child_allocation.x;
 931   item_area.y = child_allocation.y;
 932
 933   /* when expanded or in transition, place the tool items in a grid like layout */
 934   if (!priv->collapsed || !priv->animation || priv->animation_timeout)
 935     {
 936       gint col = 0, row = 0;
 937
 938       for (it = priv->children; it != NULL; it = it->next)
 939         {
 940           GtkToolItemGroupChild *child = it->data;
 941           gint col_child;
 942
 943           if (!gtk_tool_item_group_is_item_visible (group, child))
 944             {
 945               gtk_widget_set_child_visible (GTK_WIDGET (child->item), FALSE);
 946
 947               continue;
 948             }
 949
 950           /* for non homogeneous widgets request the required size */
 951           child_requisition.width = 0;
 952
 953           if (!child->homogeneous)
 954             {
 955               gtk_widget_size_request (GTK_WIDGET (child->item), &child_requisition);
 956               child_requisition.width = MIN (child_requisition.width, item_area.width);
 957             }
 958
 959           /* select next row if at end of row */
 960           if (col > 0 && (child->new_row || (col * item_size.width) + MAX (child_requisition.width, item_size.width) > item_area.width))
 961             {
 962               row++;
 963               col = 0;
 964               child_allocation.y += child_allocation.height;
 965             }
 966
 967           col_child = col;
 968
 969           /* calculate the position and size of the item */
 970           if (!child->homogeneous)
 971             {
 972               gint col_width;
 973               gint width;
 974
 975               if (!child->expand)
 976                 col_width = udiv (child_requisition.width, item_size.width);
 977               else
 978                 col_width = n_columns - col;
 979
 980               width = col_width * item_size.width;
 981
 982               if (GTK_TEXT_DIR_RTL == direction)
 983                 col_child = (n_columns - col - col_width);
 984
 985               if (child->fill)
 986                 {
 987                   child_allocation.x = item_area.x + col_child * item_size.width;
 988                   child_allocation.width = width;
 989                 }
 990               else
 991                 {
 992                   child_allocation.x =
 993                     (item_area.x + col_child * item_size.width +
 994                     (width - child_requisition.width) / 2);
 995                   child_allocation.width = child_requisition.width;
 996                 }
 997
 998               col += col_width;
 999             }
1000           else
1001             {
1002               if (GTK_TEXT_DIR_RTL == direction)
1003                 col_child = (n_columns - col - 1);
1004
1005               child_allocation.x = item_area.x + col_child * item_size.width;
1006               child_allocation.width = item_size.width;
1007
1008               col++;
1009             }
1010
1011           child_allocation.height = item_size.height;
1012
1013           gtk_widget_size_allocate (GTK_WIDGET (child->item), &child_allocation);
1014           gtk_widget_set_child_visible (GTK_WIDGET (child->item), TRUE);
1015         }
1016
1017       child_allocation.y += item_size.height;
1018     }
1019
1020   /* or just hide all items, when collapsed */
1021
1022   else
1023     {
1024       for (it = priv->children; it != NULL; it = it->next)
1025         {
1026           GtkToolItemGroupChild *child = it->data;
1027
1028           gtk_widget_set_child_visible (GTK_WIDGET (child->item), FALSE);
1029         }
1030     }
1031 }
1032
1033 static void
1034 gtk_tool_item_group_size_allocate (GtkWidget     *widget,
1035                                    GtkAllocation *allocation)
1036 {
1037   gtk_tool_item_group_real_size_allocate (widget, allocation);
1038
1039   if (gtk_widget_get_mapped (widget))
1040     gdk_window_invalidate_rect (widget->window, NULL, FALSE);
1041 }
1042
1043 static void
1044 gtk_tool_item_group_set_focus_cb (GtkWidget *window,
1045                                   GtkWidget *widget,
1046                                   gpointer   user_data)
1047 {
1048   GtkAdjustment *adjustment;
1049   GtkWidget *p;
1050
1051   /* Find this group's parent widget in the focused widget's anchestry. */
1052   for (p = widget; p; p = gtk_widget_get_parent (p))
1053     if (p == user_data)
1054       {
1055         p = gtk_widget_get_parent (p);
1056         break;
1057       }
1058
1059   if (GTK_IS_TOOL_PALETTE (p))
1060     {
1061       /* Check that the focused widgets is fully visible within
1062        * the group's parent widget and make it visible otherwise. */
1063
1064       adjustment = gtk_tool_palette_get_hadjustment (GTK_TOOL_PALETTE (p));
1065       adjustment = gtk_tool_palette_get_vadjustment (GTK_TOOL_PALETTE (p));
1066
1067       if (adjustment)
1068         {
1069           int y;
1070
1071           /* Handle vertical adjustment. */
1072           if (gtk_widget_translate_coordinates
1073                 (widget, p, 0, 0, NULL, &y) && y < 0)
1074             {
1075               y += adjustment->value;
1076               gtk_adjustment_clamp_page (adjustment, y, y + widget->allocation.height);
1077             }
1078           else if (gtk_widget_translate_coordinates
1079                       (widget, p, 0, widget->allocation.height, NULL, &y) &&
1080                    y > p->allocation.height)
1081             {
1082               y += adjustment->value;
1083               gtk_adjustment_clamp_page (adjustment, y - widget->allocation.height, y);
1084             }
1085         }
1086
1087       adjustment = gtk_tool_palette_get_hadjustment (GTK_TOOL_PALETTE (p));
1088
1089       if (adjustment)
1090         {
1091           int x;
1092
1093           /* Handle horizontal adjustment. */
1094           if (gtk_widget_translate_coordinates
1095                 (widget, p, 0, 0, &x, NULL) && x < 0)
1096             {
1097               x += adjustment->value;
1098               gtk_adjustment_clamp_page (adjustment, x, x + widget->allocation.width);
1099             }
1100           else if (gtk_widget_translate_coordinates
1101                       (widget, p, widget->allocation.width, 0, &x, NULL) &&
1102                    x > p->allocation.width)
1103             {
1104               x += adjustment->value;
1105               gtk_adjustment_clamp_page (adjustment, x - widget->allocation.width, x);
1106             }
1107
1108           return;
1109         }
1110     }
1111 }
1112
1113 static void
1114 gtk_tool_item_group_set_toplevel_window (GtkToolItemGroup *group,
1115                                          GtkWidget        *toplevel)
1116 {
1117   GtkToolItemGroupPrivate* priv = group->priv;
1118
1119   if (toplevel != priv->toplevel)
1120     {
1121       if (priv->toplevel)
1122         {
1123           /* Disconnect focus tracking handler. */
1124           g_signal_handler_disconnect (priv->toplevel,
1125                                        priv->focus_set_id);
1126
1127           priv->focus_set_id = 0;
1128           priv->toplevel = NULL;
1129         }
1130
1131       if (toplevel)
1132         {
1133           /* Install focus tracking handler. We connect to the window's
1134            * set-focus signal instead of connecting to the focus signal of
1135            * each child to:
1136            *
1137            * 1) Reduce the number of signal handlers used.
1138            * 2) Avoid special handling for group headers.
1139            * 3) Catch focus grabs not only for direct children,
1140            *    but also for nested widgets.
1141            */
1142           priv->focus_set_id =
1143             g_signal_connect (toplevel, "set-focus",
1144                               G_CALLBACK (gtk_tool_item_group_set_focus_cb),
1145                               group);
1146
1147           priv->toplevel = toplevel;
1148         }
1149     }
1150 }
1151
1152 static void
1153 gtk_tool_item_group_realize (GtkWidget *widget)
1154 {
1155   GtkWidget *toplevel_window;
1156   const gint border_width = GTK_CONTAINER (widget)->border_width;
1157   gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1158   GdkWindowAttr attributes;
1159   GdkDisplay *display;
1160
1161   attributes.window_type = GDK_WINDOW_CHILD;
1162   attributes.x = widget->allocation.x + border_width;
1163   attributes.y = widget->allocation.y + border_width;
1164   attributes.width = widget->allocation.width - border_width * 2;
1165   attributes.height = widget->allocation.height - border_width * 2;
1166   attributes.wclass = GDK_INPUT_OUTPUT;
1167   attributes.visual = gtk_widget_get_visual (widget);
1168   attributes.colormap = gtk_widget_get_colormap (widget);
1169   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK
1170                         | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
1171                         | GDK_BUTTON_MOTION_MASK;
1172
1173   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1174                                    &attributes, attributes_mask);
1175
1176   display = gdk_drawable_get_display (widget->window);
1177
1178   if (gdk_display_supports_composite (display))
1179     gdk_window_set_composited (widget->window, TRUE);
1180
1181   gdk_window_set_user_data (widget->window, widget);
1182   widget->style = gtk_style_attach (widget->style, widget->window);
1183   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
1184   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1185
1186   gtk_container_forall (GTK_CONTAINER (widget),
1187                         (GtkCallback) gtk_widget_set_parent_window,
1188                         widget->window);
1189
1190   gtk_widget_queue_resize_no_redraw (widget);
1191
1192   toplevel_window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
1193   gtk_tool_item_group_set_toplevel_window (GTK_TOOL_ITEM_GROUP (widget),
1194                                            toplevel_window);
1195 }
1196
1197 static void
1198 gtk_tool_item_group_unrealize (GtkWidget *widget)
1199 {
1200   gtk_tool_item_group_set_toplevel_window (GTK_TOOL_ITEM_GROUP (widget), NULL);
1201   GTK_WIDGET_CLASS (gtk_tool_item_group_parent_class)->unrealize (widget);
1202 }
1203
1204 static void
1205 gtk_tool_item_group_style_set (GtkWidget *widget,
1206                                GtkStyle  *previous_style)
1207 {
1208   gtk_tool_item_group_header_adjust_style (GTK_TOOL_ITEM_GROUP (widget));
1209   GTK_WIDGET_CLASS (gtk_tool_item_group_parent_class)->style_set (widget, previous_style);
1210 }
1211
1212 static void
1213 gtk_tool_item_group_add (GtkContainer *container,
1214                          GtkWidget    *widget)
1215 {
1216   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (container));
1217   g_return_if_fail (GTK_IS_TOOL_ITEM (widget));
1218
1219   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (container),
1220                               GTK_TOOL_ITEM (widget), -1);
1221 }
1222
1223 static void
1224 gtk_tool_item_group_remove (GtkContainer *container,
1225                             GtkWidget    *child)
1226 {
1227   GtkToolItemGroup *group;
1228   GtkToolItemGroupPrivate* priv;
1229   GList *it;
1230
1231   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (container));
1232   group = GTK_TOOL_ITEM_GROUP (container);
1233   priv = group->priv;
1234
1235   for (it = priv->children; it != NULL; it = it->next)
1236     {
1237       GtkToolItemGroupChild *child_info = it->data;
1238
1239       if ((GtkWidget *)child_info->item == child)
1240         {
1241           g_object_unref (child);
1242           gtk_widget_unparent (child);
1243
1244           g_free (child_info);
1245           priv->children = g_list_delete_link (priv->children, it);
1246
1247           gtk_widget_queue_resize (GTK_WIDGET (container));
1248           break;
1249         }
1250     }
1251 }
1252
1253 static void
1254 gtk_tool_item_group_forall (GtkContainer *container,
1255                             gboolean      internals,
1256                             GtkCallback   callback,
1257                             gpointer      callback_data)
1258 {
1259   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (container);
1260   GtkToolItemGroupPrivate* priv = group->priv;
1261   GList *children;
1262
1263   if (internals && priv->header)
1264     callback (priv->header, callback_data);
1265
1266   children = priv->children;
1267   while (children)
1268     {
1269       GtkToolItemGroupChild *child = children->data;
1270       children = children->next; /* store pointer before call to callback
1271                                     because the child pointer is invalid if the
1272                                     child->item is removed from the item group
1273                                     in callback */
1274
1275       callback (GTK_WIDGET (child->item), callback_data);
1276     }
1277 }
1278
1279 static GType
1280 gtk_tool_item_group_child_type (GtkContainer *container)
1281 {
1282   return GTK_TYPE_TOOL_ITEM;
1283 }
1284
1285 static GtkToolItemGroupChild *
1286 gtk_tool_item_group_get_child (GtkToolItemGroup  *group,
1287                                GtkToolItem       *item,
1288                                gint              *position,
1289                                GList            **link)
1290 {
1291   guint i;
1292   GList *it;
1293
1294   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), NULL);
1295   g_return_val_if_fail (GTK_IS_TOOL_ITEM (item), NULL);
1296
1297   for (it = group->priv->children, i = 0; it != NULL; it = it->next, ++i)
1298     {
1299       GtkToolItemGroupChild *child = it->data;
1300
1301       if (child->item == item)
1302         {
1303           if (position)
1304             *position = i;
1305
1306           if (link)
1307             *link = it;
1308
1309           return child;
1310         }
1311     }
1312
1313   return NULL;
1314 }
1315
1316 static void
1317 gtk_tool_item_group_get_item_packing (GtkToolItemGroup *group,
1318                                       GtkToolItem      *item,
1319                                       gboolean         *homogeneous,
1320                                       gboolean         *expand,
1321                                       gboolean         *fill,
1322                                       gboolean         *new_row)
1323 {
1324   GtkToolItemGroupChild *child;
1325
1326   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1327   g_return_if_fail (GTK_IS_TOOL_ITEM (item));
1328
1329   child = gtk_tool_item_group_get_child (group, item, NULL, NULL);
1330   if (!child)
1331     return;
1332
1333   if (expand)
1334     *expand = child->expand;
1335
1336   if (homogeneous)
1337     *homogeneous = child->homogeneous;
1338
1339   if (fill)
1340     *fill = child->fill;
1341
1342   if (new_row)
1343     *new_row = child->new_row;
1344 }
1345
1346 static void
1347 gtk_tool_item_group_set_item_packing (GtkToolItemGroup *group,
1348                                       GtkToolItem      *item,
1349                                       gboolean          homogeneous,
1350                                       gboolean          expand,
1351                                       gboolean          fill,
1352                                       gboolean          new_row)
1353 {
1354   GtkToolItemGroupChild *child;
1355   gboolean changed = FALSE;
1356
1357   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1358   g_return_if_fail (GTK_IS_TOOL_ITEM (item));
1359
1360   child = gtk_tool_item_group_get_child (group, item, NULL, NULL);
1361   if (!child)
1362     return;
1363
1364   gtk_widget_freeze_child_notify (GTK_WIDGET (item));
1365
1366   if (child->homogeneous != homogeneous)
1367     {
1368       child->homogeneous = homogeneous;
1369       changed = TRUE;
1370       gtk_widget_child_notify (GTK_WIDGET (item), "homogeneous");
1371     }
1372   if (child->expand != expand)
1373     {
1374       child->expand = expand;
1375       changed = TRUE;
1376       gtk_widget_child_notify (GTK_WIDGET (item), "expand");
1377     }
1378   if (child->fill != fill)
1379     {
1380       child->fill = fill;
1381       changed = TRUE;
1382       gtk_widget_child_notify (GTK_WIDGET (item), "fill");
1383     }
1384   if (child->new_row != new_row)
1385     {
1386       child->new_row = new_row;
1387       changed = TRUE;
1388       gtk_widget_child_notify (GTK_WIDGET (item), "new-row");
1389     }
1390
1391   gtk_widget_thaw_child_notify (GTK_WIDGET (item));
1392
1393   if (changed
1394       && gtk_widget_get_visible (GTK_WIDGET (group))
1395       && gtk_widget_get_visible (GTK_WIDGET (item)))
1396     gtk_widget_queue_resize (GTK_WIDGET (group));
1397 }
1398
1399 static void
1400 gtk_tool_item_group_set_child_property (GtkContainer *container,
1401                                         GtkWidget    *child,
1402                                         guint         prop_id,
1403                                         const GValue *value,
1404                                         GParamSpec   *pspec)
1405 {
1406   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (container);
1407   GtkToolItem *item = GTK_TOOL_ITEM (child);
1408   gboolean homogeneous, expand, fill, new_row;
1409
1410   if (prop_id != CHILD_PROP_POSITION)
1411     gtk_tool_item_group_get_item_packing (group, item,
1412                                           &homogeneous,
1413                                           &expand,
1414                                           &fill,
1415                                           &new_row);
1416
1417   switch (prop_id)
1418     {
1419       case CHILD_PROP_HOMOGENEOUS:
1420         gtk_tool_item_group_set_item_packing (group, item,
1421                                               g_value_get_boolean (value),
1422                                               expand,
1423                                               fill,
1424                                               new_row);
1425         break;
1426
1427       case CHILD_PROP_EXPAND:
1428         gtk_tool_item_group_set_item_packing (group, item,
1429                                               homogeneous,
1430                                               g_value_get_boolean (value),
1431                                               fill,
1432                                               new_row);
1433         break;
1434
1435       case CHILD_PROP_FILL:
1436         gtk_tool_item_group_set_item_packing (group, item,
1437                                               homogeneous,
1438                                               expand,
1439                                               g_value_get_boolean (value),
1440                                               new_row);
1441         break;
1442
1443       case CHILD_PROP_NEW_ROW:
1444         gtk_tool_item_group_set_item_packing (group, item,
1445                                               homogeneous,
1446                                               expand,
1447                                               fill,
1448                                               g_value_get_boolean (value));
1449         break;
1450
1451       case CHILD_PROP_POSITION:
1452         gtk_tool_item_group_set_item_position (group, item, g_value_get_int (value));
1453         break;
1454
1455       default:
1456         GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);
1457         break;
1458     }
1459 }
1460
1461 static void
1462 gtk_tool_item_group_get_child_property (GtkContainer *container,
1463                                         GtkWidget    *child,
1464                                         guint         prop_id,
1465                                         GValue       *value,
1466                                         GParamSpec   *pspec)
1467 {
1468   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (container);
1469   GtkToolItem *item = GTK_TOOL_ITEM (child);
1470   gboolean homogeneous, expand, fill, new_row;
1471
1472   if (prop_id != CHILD_PROP_POSITION)
1473     gtk_tool_item_group_get_item_packing (group, item,
1474                                           &homogeneous,
1475                                           &expand,
1476                                           &fill,
1477                                           &new_row);
1478
1479   switch (prop_id)
1480     {
1481       case CHILD_PROP_HOMOGENEOUS:
1482         g_value_set_boolean (value, homogeneous);
1483         break;
1484
1485        case CHILD_PROP_EXPAND:
1486         g_value_set_boolean (value, expand);
1487         break;
1488
1489        case CHILD_PROP_FILL:
1490         g_value_set_boolean (value, fill);
1491         break;
1492
1493        case CHILD_PROP_NEW_ROW:
1494         g_value_set_boolean (value, new_row);
1495         break;
1496
1497      case CHILD_PROP_POSITION:
1498         g_value_set_int (value, gtk_tool_item_group_get_item_position (group, item));
1499         break;
1500
1501       default:
1502         GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);
1503         break;
1504     }
1505 }
1506
1507 static void
1508 gtk_tool_item_group_class_init (GtkToolItemGroupClass *cls)
1509 {
1510   GObjectClass       *oclass = G_OBJECT_CLASS (cls);
1511   GtkWidgetClass     *wclass = GTK_WIDGET_CLASS (cls);
1512   GtkContainerClass  *cclass = GTK_CONTAINER_CLASS (cls);
1513
1514   oclass->set_property       = gtk_tool_item_group_set_property;
1515   oclass->get_property       = gtk_tool_item_group_get_property;
1516   oclass->finalize           = gtk_tool_item_group_finalize;
1517   oclass->dispose            = gtk_tool_item_group_dispose;
1518
1519   wclass->size_request       = gtk_tool_item_group_size_request;
1520   wclass->size_allocate      = gtk_tool_item_group_size_allocate;
1521   wclass->realize            = gtk_tool_item_group_realize;
1522   wclass->unrealize          = gtk_tool_item_group_unrealize;
1523   wclass->style_set          = gtk_tool_item_group_style_set;
1524   wclass->screen_changed     = gtk_tool_item_group_screen_changed;
1525
1526   cclass->add                = gtk_tool_item_group_add;
1527   cclass->remove             = gtk_tool_item_group_remove;
1528   cclass->forall             = gtk_tool_item_group_forall;
1529   cclass->child_type         = gtk_tool_item_group_child_type;
1530   cclass->set_child_property = gtk_tool_item_group_set_child_property;
1531   cclass->get_child_property = gtk_tool_item_group_get_child_property;
1532
1533   g_object_class_install_property (oclass, PROP_LABEL,
1534                                    g_param_spec_string ("label",
1535                                                         P_("Label"),
1536                                                         P_("The human-readable title of this item group"),
1537                                                         DEFAULT_LABEL,
1538                                                         GTK_PARAM_READWRITE));
1539
1540   g_object_class_install_property (oclass, PROP_LABEL_WIDGET,
1541                                    g_param_spec_object  ("label-widget",
1542                                                         P_("Label widget"),
1543                                                         P_("A widget to display in place of the usual label"),
1544                                                         GTK_TYPE_WIDGET,
1545                                                         GTK_PARAM_READWRITE));
1546
1547   g_object_class_install_property (oclass, PROP_COLLAPSED,
1548                                    g_param_spec_boolean ("collapsed",
1549                                                          P_("Collapsed"),
1550                                                          P_("Wether the group has been collapsed and items are hidden"),
1551                                                          DEFAULT_COLLAPSED,
1552                                                          GTK_PARAM_READWRITE));
1553
1554   g_object_class_install_property (oclass, PROP_ELLIPSIZE,
1555                                    g_param_spec_enum ("ellipsize",
1556                                                       P_("ellipsize"),
1557                                                       P_("Ellipsize for item group headers"),
1558                                                       PANGO_TYPE_ELLIPSIZE_MODE, DEFAULT_ELLIPSIZE,
1559                                                       GTK_PARAM_READWRITE));
1560
1561   g_object_class_install_property (oclass, PROP_RELIEF,
1562                                    g_param_spec_enum ("header-relief",
1563                                                       P_("Header Relief"),
1564                                                       P_("Relief of the group header button"),
1565                                                       GTK_TYPE_RELIEF_STYLE, GTK_RELIEF_NORMAL,
1566                                                       GTK_PARAM_READWRITE));
1567
1568   gtk_widget_class_install_style_property (wclass,
1569                                            g_param_spec_int ("expander-size",
1570                                                              P_("Expander Size"),
1571                                                              P_("Size of the expander arrow"),
1572                                                              0,
1573                                                              G_MAXINT,
1574                                                              DEFAULT_EXPANDER_SIZE,
1575                                                              GTK_PARAM_READABLE));
1576
1577   gtk_widget_class_install_style_property (wclass,
1578                                            g_param_spec_int ("header-spacing",
1579                                                              P_("Header Spacing"),
1580                                                              P_("Spacing between expander arrow and caption"),
1581                                                              0,
1582                                                              G_MAXINT,
1583                                                              DEFAULT_HEADER_SPACING,
1584                                                              GTK_PARAM_READABLE));
1585
1586   gtk_container_class_install_child_property (cclass, CHILD_PROP_HOMOGENEOUS,
1587                                               g_param_spec_boolean ("homogeneous",
1588                                                                     P_("Homogeneous"),
1589                                                                     P_("Whether the item should be the same size as other homogeneous items"),
1590                                                                     TRUE,
1591                                                                     GTK_PARAM_READWRITE));
1592
1593   gtk_container_class_install_child_property (cclass, CHILD_PROP_EXPAND,
1594                                               g_param_spec_boolean ("expand",
1595                                                                     P_("Expand"),
1596                                                                     P_("Whether the item should receive extra space when the group grows"),
1597                                                                     FALSE,
1598                                                                     GTK_PARAM_READWRITE));
1599
1600   gtk_container_class_install_child_property (cclass, CHILD_PROP_FILL,
1601                                               g_param_spec_boolean ("fill",
1602                                                                     P_("Fill"),
1603                                                                     P_("Whether the item should fill the available space"),
1604                                                                     TRUE,
1605                                                                     GTK_PARAM_READWRITE));
1606
1607   gtk_container_class_install_child_property (cclass, CHILD_PROP_NEW_ROW,
1608                                               g_param_spec_boolean ("new-row",
1609                                                                     P_("New Row"),
1610                                                                     P_("Whether the item should start a new row"),
1611                                                                     FALSE,
1612                                                                     GTK_PARAM_READWRITE));
1613
1614   gtk_container_class_install_child_property (cclass, CHILD_PROP_POSITION,
1615                                               g_param_spec_int ("position",
1616                                                                 P_("Position"),
1617                                                                 P_("Position of the item within this group"),
1618                                                                 0,
1619                                                                 G_MAXINT,
1620                                                                 0,
1621                                                                 GTK_PARAM_READWRITE));
1622
1623   g_type_class_add_private (cls, sizeof (GtkToolItemGroupPrivate));
1624 }
1625
1626 /**
1627  * gtk_tool_item_group_new:
1628  * @label: the label of the new group
1629  *
1630  * Creates a new tool item group with label @label.
1631  *
1632  * Returns: a new #GtkToolItemGroup.
1633  *
1634  * Since: 2.20
1635  */
1636 GtkWidget*
1637 gtk_tool_item_group_new (const gchar *label)
1638 {
1639   return g_object_new (GTK_TYPE_TOOL_ITEM_GROUP, "label", label, NULL);
1640 }
1641
1642 /**
1643  * gtk_tool_item_group_set_label:
1644  * @group: a #GtkToolItemGroup
1645  * @label: the new human-readable label of of the group
1646  *
1647  * Sets the label of the tool item group. The label is displayed in the header
1648  * of the group.
1649  *
1650  * Since: 2.20
1651  */
1652 void
1653 gtk_tool_item_group_set_label (GtkToolItemGroup *group,
1654                                const gchar      *label)
1655 {
1656   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1657
1658   if (!label)
1659     gtk_tool_item_group_set_label_widget (group, NULL);
1660   else
1661     {
1662       GtkWidget *child = gtk_label_new (label);
1663       gtk_widget_show (child);
1664
1665       gtk_tool_item_group_set_label_widget (group, child);
1666     }
1667
1668   g_object_notify (G_OBJECT (group), "label");
1669 }
1670
1671 /**
1672  * gtk_tool_item_group_set_label_widget:
1673  * @group: a #GtkToolItemGroup
1674  * @label_widget: the widget to be displayed in place of the usual label
1675  *
1676  * Sets the label of the tool item group.
1677  * The label widget is displayed in the header of the group, in place
1678  * of the usual label.
1679  *
1680  * Since: 2.20
1681  */
1682 void
1683 gtk_tool_item_group_set_label_widget (GtkToolItemGroup *group,
1684                                       GtkWidget        *label_widget)
1685 {
1686   GtkToolItemGroupPrivate* priv;
1687   GtkWidget *alignment;
1688
1689   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1690   g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
1691   g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);
1692
1693   priv = group->priv;
1694
1695   if (priv->label_widget == label_widget)
1696     return;
1697
1698   alignment = gtk_tool_item_group_get_alignment (group);
1699
1700   if (priv->label_widget)
1701     {
1702       gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);
1703       gtk_container_remove (GTK_CONTAINER (alignment), priv->label_widget);
1704     }
1705
1706
1707   if (label_widget)
1708       gtk_container_add (GTK_CONTAINER (alignment), label_widget);
1709
1710   priv->label_widget = label_widget;
1711
1712   if (gtk_widget_get_visible (GTK_WIDGET (group)))
1713     gtk_widget_queue_resize (GTK_WIDGET (group));
1714
1715   /* Only show the header widget if the group has children: */
1716   if (label_widget && priv->children)
1717     gtk_widget_show (priv->header);
1718   else
1719     gtk_widget_hide (priv->header);
1720
1721   g_object_freeze_notify (G_OBJECT (group));
1722   g_object_notify (G_OBJECT (group), "label-widget");
1723   g_object_notify (G_OBJECT (group), "label");
1724   g_object_thaw_notify (G_OBJECT (group));
1725 }
1726
1727 /**
1728  * gtk_tool_item_group_set_header_relief:
1729  * @group: a #GtkToolItemGroup
1730  * @style: the #GtkReliefStyle
1731  *
1732  * Set the button relief of the group header.
1733  * See gtk_button_set_relief() for details.
1734  *
1735  * Since: 2.20
1736  */
1737 void
1738 gtk_tool_item_group_set_header_relief (GtkToolItemGroup *group,
1739                                        GtkReliefStyle    style)
1740 {
1741   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1742
1743   gtk_button_set_relief (GTK_BUTTON (group->priv->header), style);
1744 }
1745
1746 static gint64
1747 gtk_tool_item_group_get_animation_timestamp (GtkToolItemGroup *group)
1748 {
1749   GTimeVal now;
1750
1751   g_source_get_current_time (group->priv->animation_timeout, &now);
1752   return (now.tv_sec * G_USEC_PER_SEC + now.tv_usec - group->priv->animation_start) / 1000;
1753 }
1754
1755 static void
1756 gtk_tool_item_group_force_expose (GtkToolItemGroup *group)
1757 {
1758   GtkToolItemGroupPrivate* priv = group->priv;
1759
1760   if (GTK_WIDGET_REALIZED (priv->header))
1761     {
1762       GtkWidget *alignment = gtk_tool_item_group_get_alignment (group);
1763       GdkRectangle area;
1764
1765       /* Find the header button's arrow area... */
1766       area.x = alignment->allocation.x;
1767       area.y = alignment->allocation.y + (alignment->allocation.height - priv->expander_size) / 2;
1768       area.height = priv->expander_size;
1769       area.width = priv->expander_size;
1770
1771       /* ... and invalidated it to get it animated. */
1772       gdk_window_invalidate_rect (priv->header->window, &area, TRUE);
1773     }
1774
1775   if (GTK_WIDGET_REALIZED (group))
1776     {
1777       GtkWidget *widget = GTK_WIDGET (group);
1778       GtkWidget *parent = gtk_widget_get_parent (widget);
1779       int x, y, width, height;
1780
1781       /* Find the tool item area button's arrow area... */
1782       width = widget->allocation.width;
1783       height = widget->allocation.height;
1784
1785       gtk_widget_translate_coordinates (widget, parent, 0, 0, &x, &y);
1786
1787       if (gtk_widget_get_visible (priv->header))
1788         {
1789           height -= priv->header->allocation.height;
1790           y += priv->header->allocation.height;
1791         }
1792
1793       /* ... and invalidated it to get it animated. */
1794       gtk_widget_queue_draw_area (parent, x, y, width, height);
1795     }
1796 }
1797
1798 static gboolean
1799 gtk_tool_item_group_animation_cb (gpointer data)
1800 {
1801   GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);
1802   GtkToolItemGroupPrivate* priv = group->priv;
1803   gint64 timestamp = gtk_tool_item_group_get_animation_timestamp (group);
1804   gboolean retval;
1805
1806   GDK_THREADS_ENTER ();
1807
1808   /* Enque this early to reduce number of expose events. */
1809   gtk_widget_queue_resize_no_redraw (GTK_WIDGET (group));
1810
1811   /* Figure out current style of the expander arrow. */
1812   if (priv->collapsed)
1813     {
1814       if (priv->expander_style == GTK_EXPANDER_EXPANDED)
1815         priv->expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
1816       else
1817         priv->expander_style = GTK_EXPANDER_COLLAPSED;
1818     }
1819   else
1820     {
1821       if (priv->expander_style == GTK_EXPANDER_COLLAPSED)
1822         priv->expander_style = GTK_EXPANDER_SEMI_EXPANDED;
1823       else
1824         priv->expander_style = GTK_EXPANDER_EXPANDED;
1825     }
1826
1827   gtk_tool_item_group_force_expose (group);
1828
1829   /* Finish animation when done. */
1830   if (timestamp >= ANIMATION_DURATION)
1831     priv->animation_timeout = NULL;
1832
1833   retval = (priv->animation_timeout != NULL);
1834
1835   GDK_THREADS_LEAVE ();
1836
1837   return retval;
1838 }
1839
1840 /**
1841  * gtk_tool_item_group_set_collapsed:
1842  * @group: a #GtkToolItemGroup
1843  * @collapsed: whether the @group should be collapsed or expanded
1844  *
1845  * Sets whether the @group should be collapsed or expanded.
1846  *
1847  * Since: 2.20
1848  */
1849 void
1850 gtk_tool_item_group_set_collapsed (GtkToolItemGroup *group,
1851                                    gboolean          collapsed)
1852 {
1853   GtkWidget *parent;
1854   GtkToolItemGroupPrivate* priv;
1855
1856   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1857
1858   priv = group->priv;
1859
1860   parent = gtk_widget_get_parent (GTK_WIDGET (group));
1861   if (GTK_IS_TOOL_PALETTE (parent) && !collapsed)
1862     _gtk_tool_palette_set_expanding_child (GTK_TOOL_PALETTE (parent),
1863                                            GTK_WIDGET (group));
1864   if (collapsed != priv->collapsed)
1865     {
1866       if (priv->animation)
1867         {
1868           GTimeVal now;
1869
1870           g_get_current_time (&now);
1871
1872           if (priv->animation_timeout)
1873             g_source_destroy (priv->animation_timeout);
1874
1875           priv->animation_start = (now.tv_sec * G_USEC_PER_SEC + now.tv_usec);
1876           priv->animation_timeout = g_timeout_source_new (ANIMATION_TIMEOUT);
1877
1878           g_source_set_callback (priv->animation_timeout,
1879                                  gtk_tool_item_group_animation_cb,
1880                                  group, NULL);
1881
1882           g_source_attach (priv->animation_timeout, NULL);
1883         }
1884         else
1885         {
1886           priv->expander_style = GTK_EXPANDER_COLLAPSED;
1887           gtk_tool_item_group_force_expose (group);
1888         }
1889
1890       priv->collapsed = collapsed;
1891       g_object_notify (G_OBJECT (group), "collapsed");
1892     }
1893 }
1894
1895 /**
1896  * gtk_tool_item_group_set_ellipsize:
1897  * @group: a #GtkToolItemGroup
1898  * @ellipsize: the #PangoEllipsizeMode labels in @group should use
1899  *
1900  * Sets the ellipsization mode which should be used by labels in @group.
1901  *
1902  * Since: 2.20
1903  */
1904 void
1905 gtk_tool_item_group_set_ellipsize (GtkToolItemGroup   *group,
1906                                    PangoEllipsizeMode  ellipsize)
1907 {
1908   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1909
1910   if (ellipsize != group->priv->ellipsize)
1911     {
1912       group->priv->ellipsize = ellipsize;
1913       gtk_tool_item_group_header_adjust_style (group);
1914       g_object_notify (G_OBJECT (group), "ellipsize");
1915       _gtk_tool_item_group_palette_reconfigured (group);
1916     }
1917 }
1918
1919 /**
1920  * gtk_tool_item_group_get_label:
1921  * @group: a #GtkToolItemGroup
1922  *
1923  * Gets the label of @group.
1924  *
1925  * Returns: the label of @group. The label is an internal string of @group
1926  *     and must not be modified. Note that %NULL is returned if a custom
1927  *     label has been set with gtk_tool_item_group_set_label_widget()
1928  *
1929  * Since: 2.20
1930  */
1931 G_CONST_RETURN gchar*
1932 gtk_tool_item_group_get_label (GtkToolItemGroup *group)
1933 {
1934   GtkToolItemGroupPrivate *priv;
1935
1936   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), NULL);
1937
1938   priv = group->priv;
1939
1940   if (GTK_IS_LABEL (priv->label_widget))
1941     return gtk_label_get_label (GTK_LABEL (priv->label_widget));
1942   else
1943     return NULL;
1944 }
1945
1946 /**
1947  * gtk_tool_item_group_get_label_widget:
1948  * @group: a #GtkToolItemGroup
1949  *
1950  * Gets the label widget of @group.
1951  * See gtk_tool_item_group_set_label_widget().
1952  *
1953  * Returns: the label widget of @group
1954  *
1955  * Since: 2.20
1956  */
1957 GtkWidget*
1958 gtk_tool_item_group_get_label_widget (GtkToolItemGroup *group)
1959 {
1960   GtkWidget *alignment = gtk_tool_item_group_get_alignment (group);
1961
1962   return gtk_bin_get_child (GTK_BIN (alignment));
1963 }
1964
1965 /**
1966  * gtk_tool_item_group_get_collapsed:
1967  * @group: a GtkToolItemGroup
1968  *
1969  * Gets whether @group is collapsed or expanded.
1970  *
1971  * Returns: %TRUE if @group is collapsed, %FALSE if it is expanded
1972  *
1973  * Since: 2.20
1974  */
1975 gboolean
1976 gtk_tool_item_group_get_collapsed (GtkToolItemGroup *group)
1977 {
1978   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), DEFAULT_COLLAPSED);
1979
1980   return group->priv->collapsed;
1981 }
1982
1983 /**
1984  * gtk_tool_item_group_get_ellipsize:
1985  * @group: a #GtkToolItemGroup
1986  *
1987  * Gets the ellipsization mode of @group.
1988  *
1989  * Returns: the #PangoEllipsizeMode of @group
1990  *
1991  * Since: 2.20
1992  */
1993 PangoEllipsizeMode
1994 gtk_tool_item_group_get_ellipsize (GtkToolItemGroup *group)
1995 {
1996   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), DEFAULT_ELLIPSIZE);
1997
1998   return group->priv->ellipsize;
1999 }
2000
2001 /**
2002  * gtk_tool_item_group_get_header_relief:
2003  * @group: a #GtkToolItemGroup
2004  *
2005  * Gets the relief mode of the header button of @group.
2006  *
2007  * Returns: the #GtkReliefStyle
2008  *
2009  * Since: 2.20
2010  */
2011 GtkReliefStyle
2012 gtk_tool_item_group_get_header_relief (GtkToolItemGroup   *group)
2013 {
2014   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), GTK_RELIEF_NORMAL);
2015
2016   return gtk_button_get_relief (GTK_BUTTON (group->priv->header));
2017 }
2018
2019 /**
2020  * gtk_tool_item_group_insert:
2021  * @group: a #GtkToolItemGroup
2022  * @item: the #GtkToolItem to insert into @group
2023  * @position: the position of @item in @group, starting with 0.
2024  *     The position -1 means end of list.
2025  *
2026  * Inserts @item at @position in the list of children of @group.
2027  *
2028  * Since: 2.20
2029  */
2030 void
2031 gtk_tool_item_group_insert (GtkToolItemGroup *group,
2032                             GtkToolItem      *item,
2033                             gint              position)
2034 {
2035   GtkWidget *parent, *child_widget;
2036   GtkToolItemGroupChild *child;
2037
2038   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
2039   g_return_if_fail (GTK_IS_TOOL_ITEM (item));
2040   g_return_if_fail (position >= -1);
2041
2042   parent = gtk_widget_get_parent (GTK_WIDGET (group));
2043
2044   child = g_new (GtkToolItemGroupChild, 1);
2045   child->item = g_object_ref_sink (item);
2046   child->homogeneous = TRUE;
2047   child->expand = FALSE;
2048   child->fill = TRUE;
2049   child->new_row = FALSE;
2050
2051   group->priv->children = g_list_insert (group->priv->children, child, position);
2052
2053   if (GTK_IS_TOOL_PALETTE (parent))
2054     _gtk_tool_palette_child_set_drag_source (GTK_WIDGET (item), parent);
2055
2056   child_widget = gtk_bin_get_child (GTK_BIN (item));
2057
2058   if (GTK_IS_BUTTON (child_widget))
2059     gtk_button_set_focus_on_click (GTK_BUTTON (child_widget), TRUE);
2060
2061   gtk_widget_set_parent (GTK_WIDGET (item), GTK_WIDGET (group));
2062 }
2063
2064 /**
2065  * gtk_tool_item_group_set_item_position:
2066  * @group: a #GtkToolItemGroup
2067  * @item: the #GtkToolItem to move to a new position, should
2068  *     be a child of @group.
2069  * @position: the new position of @item in @group, starting with 0.
2070  *     The position -1 means end of list.
2071  *
2072  * Sets the position of @item in the list of children of @group.
2073  *
2074  * Since: 2.20
2075  */
2076 void
2077 gtk_tool_item_group_set_item_position (GtkToolItemGroup *group,
2078                                        GtkToolItem      *item,
2079                                        gint              position)
2080 {
2081   gint old_position;
2082   GList *link;
2083   GtkToolItemGroupChild *child;
2084   GtkToolItemGroupPrivate* priv;
2085
2086   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
2087   g_return_if_fail (GTK_IS_TOOL_ITEM (item));
2088   g_return_if_fail (position >= -1);
2089
2090   child = gtk_tool_item_group_get_child (group, item, &old_position, &link);
2091   priv = group->priv;
2092
2093   g_return_if_fail (child != NULL);
2094
2095   if (position == old_position)
2096     return;
2097
2098   priv->children = g_list_delete_link (priv->children, link);
2099   priv->children = g_list_insert (priv->children, child, position);
2100
2101   gtk_widget_child_notify (GTK_WIDGET (item), "position");
2102   if (gtk_widget_get_visible (GTK_WIDGET (group)) &&
2103       gtk_widget_get_visible (GTK_WIDGET (item)))
2104     gtk_widget_queue_resize (GTK_WIDGET (group));
2105 }
2106
2107 /**
2108  * gtk_tool_item_group_get_item_position:
2109  * @group: a #GtkToolItemGroup
2110  * @item: a #GtkToolItem
2111  *
2112  * Gets the position of @item in @group as index.
2113  *
2114  * Returns: the index of @item in @group or -1 if @item is no child of @group
2115  *
2116  * Since: 2.20
2117  */
2118 gint
2119 gtk_tool_item_group_get_item_position (GtkToolItemGroup *group,
2120                                        GtkToolItem      *item)
2121 {
2122   gint position;
2123
2124   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), -1);
2125   g_return_val_if_fail (GTK_IS_TOOL_ITEM (item), -1);
2126
2127   if (gtk_tool_item_group_get_child (group, item, &position, NULL))
2128     return position;
2129
2130   return -1;
2131 }
2132
2133 /**
2134  * gtk_tool_item_group_get_n_items:
2135  * @group: a #GtkToolItemGroup
2136  *
2137  * Gets the number of tool items in @group.
2138  *
2139  * Returns: the number of tool items in @group
2140  *
2141  * Since: 2.20
2142  */
2143 guint
2144 gtk_tool_item_group_get_n_items (GtkToolItemGroup *group)
2145 {
2146   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), 0);
2147
2148   return g_list_length (group->priv->children);
2149 }
2150
2151 /**
2152  * gtk_tool_item_group_get_nth_item:
2153  * @group: a #GtkToolItemGroup
2154  * @index: the index
2155  *
2156  * Gets the tool item at @index in group.
2157  *
2158  * Returns: the #GtkToolItem at index
2159  *
2160  * Since: 2.20
2161  */
2162 GtkToolItem*
2163 gtk_tool_item_group_get_nth_item (GtkToolItemGroup *group,
2164                                   guint             index)
2165 {
2166   GtkToolItemGroupChild *child;
2167
2168   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), NULL);
2169
2170   child = g_list_nth_data (group->priv->children, index);
2171
2172   return child != NULL ? child->item : NULL;
2173 }
2174
2175 /**
2176  * gtk_tool_item_group_get_drop_item:
2177  * @group: a #GtkToolItemGroup
2178  * @x: the x position
2179  * @y: the y position
2180  *
2181  * Gets the tool item at position (x, y).
2182  *
2183  * Returns: the #GtkToolItem at position (x, y)
2184  *
2185  * Since: 2.20
2186  */
2187 GtkToolItem*
2188 gtk_tool_item_group_get_drop_item (GtkToolItemGroup *group,
2189                                    gint              x,
2190                                    gint              y)
2191 {
2192   GtkAllocation *allocation;
2193   GtkOrientation orientation;
2194   GList *it;
2195
2196   g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), NULL);
2197
2198   allocation = &GTK_WIDGET (group)->allocation;
2199   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
2200
2201   g_return_val_if_fail (x >= 0 && x < allocation->width, NULL);
2202   g_return_val_if_fail (y >= 0 && y < allocation->height, NULL);
2203
2204   for (it = group->priv->children; it != NULL; it = it->next)
2205     {
2206       GtkToolItemGroupChild *child = it->data;
2207       GtkToolItem *item = child->item;
2208       gint x0, y0;
2209
2210       if (!item || !gtk_tool_item_group_is_item_visible (group, child))
2211         continue;
2212
2213       allocation = &GTK_WIDGET (item)->allocation;
2214
2215       x0 = x - allocation->x;
2216       y0 = y - allocation->y;
2217
2218       if (x0 >= 0 && x0 < allocation->width &&
2219           y0 >= 0 && y0 < allocation->height)
2220         return item;
2221     }
2222
2223   return NULL;
2224 }
2225
2226 void
2227 _gtk_tool_item_group_item_size_request (GtkToolItemGroup *group,
2228                                         GtkRequisition   *item_size,
2229                                         gboolean          homogeneous_only,
2230                                         gint             *requested_rows)
2231 {
2232   GtkRequisition child_requisition;
2233   GList *it;
2234   gint rows = 0;
2235   gboolean new_row = TRUE;
2236   GtkOrientation orientation;
2237   GtkToolbarStyle style;
2238
2239   g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
2240   g_return_if_fail (NULL != item_size);
2241
2242   orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));
2243   style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));
2244
2245   item_size->width = item_size->height = 0;
2246
2247   for (it = group->priv->children; it != NULL; it = it->next)
2248     {
2249       GtkToolItemGroupChild *child = it->data;
2250
2251       if (!gtk_tool_item_group_is_item_visible (group, child))
2252         continue;
2253
2254       if (child->new_row || new_row)
2255         {
2256           rows++;
2257           new_row = FALSE;
2258         }
2259
2260       if (!child->homogeneous && child->expand)
2261           new_row = TRUE;
2262
2263       gtk_widget_size_request (GTK_WIDGET (child->item), &child_requisition);
2264
2265       if (!homogeneous_only || child->homogeneous)
2266         item_size->width = MAX (item_size->width, child_requisition.width);
2267       item_size->height = MAX (item_size->height, child_requisition.height);
2268     }
2269
2270   if (requested_rows)
2271     *requested_rows = rows;
2272 }
2273
2274 void
2275 _gtk_tool_item_group_paint (GtkToolItemGroup *group,
2276                             cairo_t          *cr)
2277 {
2278   GtkWidget *widget = GTK_WIDGET (group);
2279   GtkToolItemGroupPrivate* priv = group->priv;
2280
2281   gdk_cairo_set_source_pixmap (cr, widget->window,
2282                                widget->allocation.x,
2283                                widget->allocation.y);
2284
2285   if (priv->animation_timeout)
2286     {
2287       GtkOrientation orientation = gtk_tool_item_group_get_orientation (GTK_TOOL_SHELL (group));
2288       cairo_pattern_t *mask;
2289       gdouble v0, v1;
2290
2291       if (GTK_ORIENTATION_VERTICAL == orientation)
2292         v1 = widget->allocation.height;
2293       else
2294         v1 = widget->allocation.width;
2295
2296       v0 = v1 - 256;
2297
2298       if (!gtk_widget_get_visible (priv->header))
2299         v0 = MAX (v0, 0);
2300       else if (GTK_ORIENTATION_VERTICAL == orientation)
2301         v0 = MAX (v0, priv->header->allocation.height);
2302       else
2303         v0 = MAX (v0, priv->header->allocation.width);
2304
2305       v1 = MIN (v0 + 256, v1);
2306
2307       if (GTK_ORIENTATION_VERTICAL == orientation)
2308         {
2309           v0 += widget->allocation.y;
2310           v1 += widget->allocation.y;
2311
2312           mask = cairo_pattern_create_linear (0.0, v0, 0.0, v1);
2313         }
2314       else
2315         {
2316           v0 += widget->allocation.x;
2317           v1 += widget->allocation.x;
2318
2319           mask = cairo_pattern_create_linear (v0, 0.0, v1, 0.0);
2320         }
2321
2322       cairo_pattern_add_color_stop_rgba (mask, 0.00, 0.0, 0.0, 0.0, 1.00);
2323       cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.25);
2324       cairo_pattern_add_color_stop_rgba (mask, 0.50, 0.0, 0.0, 0.0, 0.10);
2325       cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.01);
2326       cairo_pattern_add_color_stop_rgba (mask, 1.00, 0.0, 0.0, 0.0, 0.00);
2327
2328       cairo_mask (cr, mask);
2329       cairo_pattern_destroy (mask);
2330     }
2331   else
2332     cairo_paint (cr);
2333 }
2334
2335 gint
2336 _gtk_tool_item_group_get_size_for_limit (GtkToolItemGroup *group,
2337                                          gint              limit,
2338                                          gboolean          vertical,
2339                                          gboolean          animation)
2340 {
2341   GtkRequisition requisition;
2342   GtkToolItemGroupPrivate* priv = group->priv;
2343
2344   gtk_widget_size_request (GTK_WIDGET (group), &requisition);
2345
2346   if (!priv->collapsed || priv->animation_timeout)
2347     {
2348       GtkAllocation allocation = { 0, 0, requisition.width, requisition.height };
2349       GtkRequisition inquery;
2350
2351       if (vertical)
2352         allocation.width = limit;
2353       else
2354         allocation.height = limit;
2355
2356       gtk_tool_item_group_real_size_query (GTK_WIDGET (group),
2357                                            &allocation, &inquery);
2358
2359       if (vertical)
2360         inquery.height -= requisition.height;
2361       else
2362         inquery.width -= requisition.width;
2363
2364       if (priv->animation_timeout && animation)
2365         {
2366           gint64 timestamp = gtk_tool_item_group_get_animation_timestamp (group);
2367
2368           timestamp = MIN (timestamp, ANIMATION_DURATION);
2369
2370           if (priv->collapsed)
2371             timestamp = ANIMATION_DURATION - timestamp;
2372
2373           if (vertical)
2374             {
2375               inquery.height *= timestamp;
2376               inquery.height /= ANIMATION_DURATION;
2377             }
2378           else
2379             {
2380               inquery.width *= timestamp;
2381               inquery.width /= ANIMATION_DURATION;
2382             }
2383         }
2384
2385       if (vertical)
2386         requisition.height += inquery.height;
2387       else
2388         requisition.width += inquery.width;
2389     }
2390
2391   return (vertical ? requisition.height : requisition.width);
2392 }
2393
2394 gint
2395 _gtk_tool_item_group_get_height_for_width (GtkToolItemGroup *group,
2396                                            gint              width)
2397 {
2398   return _gtk_tool_item_group_get_size_for_limit (group, width, TRUE, group->priv->animation);
2399 }
2400
2401 gint
2402 _gtk_tool_item_group_get_width_for_height (GtkToolItemGroup *group,
2403                                            gint              height)
2404 {
2405   return _gtk_tool_item_group_get_size_for_limit (group, height, FALSE, TRUE);
2406 }
2407
2408 static void
2409 gtk_tool_palette_reconfigured_foreach_item (GtkWidget *child,
2410                                             gpointer   data)
2411 {
2412   if (GTK_IS_TOOL_ITEM (child))
2413     gtk_tool_item_toolbar_reconfigured (GTK_TOOL_ITEM (child));
2414 }
2415
2416
2417 void
2418 _gtk_tool_item_group_palette_reconfigured (GtkToolItemGroup *group)
2419 {
2420   gtk_container_foreach (GTK_CONTAINER (group),
2421                          gtk_tool_palette_reconfigured_foreach_item,
2422                          NULL);
2423
2424   gtk_tool_item_group_header_adjust_style (group);
2425 }
2426
2427
2428 #define __GTK_TOOL_ITEM_GROUP_C__
2429 #include "gtkaliasdef.c"