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