/* GtkToolPalette -- A tool palette with categories and DnD support

 * Copyright (C) 2008  Openismus GmbH

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * Authors:

 *      Mathias Hasselmann

 *      Jan Arne Petersen

 */

#include "config.h"

#include "gtktoolpaletteprivate.h"

#include <gtk/gtk.h>

#include <math.h>

#include <string.h>

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

#define ANIMATION_TIMEOUT        50

#define ANIMATION_DURATION      (ANIMATION_TIMEOUT * 4)

#define DEFAULT_ANIMATION_STATE  TRUE

#define DEFAULT_EXPANDER_SIZE    16

#define DEFAULT_HEADER_SPACING   2

#define DEFAULT_LABEL            ""

#define DEFAULT_COLLAPSED        FALSE

#define DEFAULT_ELLIPSIZE        PANGO_ELLIPSIZE_NONE

/**

 * SECTION:gtktoolitemgroup

 * @Short_description: A sub container used in a tool palette

 * @Title: GtkToolItemGroup

 *

 * A #GtkToolItemGroup is used together with #GtkToolPalette to add

 * #GtkToolItems to a palette like container with different

 * categories and drag and drop support.

 *

 * Since: 2.20

 */

enum

{

  PROP_NONE,

  PROP_LABEL,

  PROP_LABEL_WIDGET,

  PROP_COLLAPSED,

  PROP_ELLIPSIZE,

  PROP_RELIEF

};

enum

{

  CHILD_PROP_NONE,

  CHILD_PROP_HOMOGENEOUS,

  CHILD_PROP_EXPAND,

  CHILD_PROP_FILL,

  CHILD_PROP_NEW_ROW,

  CHILD_PROP_POSITION,

};

typedef struct _GtkToolItemGroupChild GtkToolItemGroupChild;

struct _GtkToolItemGroupPrivate

{

  GtkWidget         *header;

  GtkWidget         *label_widget;

  GList             *children;

  gboolean           animation;

  gint64             animation_start;

  GSource           *animation_timeout;

  GtkExpanderStyle   expander_style;

  gint               expander_size;

  gint               header_spacing;

  PangoEllipsizeMode ellipsize;

  gulong             focus_set_id;

  GtkWidget         *toplevel;

  GtkSettings       *settings;

  gulong             settings_connection;

  guint              collapsed : 1;

};

struct _GtkToolItemGroupChild

{

  GtkToolItem *item;

  guint        homogeneous : 1;

  guint        expand : 1;

  guint        fill : 1;

  guint        new_row : 1;

};

static void gtk_tool_item_group_tool_shell_init (GtkToolShellIface *iface);

G_DEFINE_TYPE_WITH_CODE (GtkToolItemGroup, gtk_tool_item_group, GTK_TYPE_CONTAINER,

G_IMPLEMENT_INTERFACE (GTK_TYPE_TOOL_SHELL, gtk_tool_item_group_tool_shell_init));

static GtkWidget*

gtk_tool_item_group_get_alignment (GtkToolItemGroup *group)

{

  return gtk_bin_get_child (GTK_BIN (group->priv->header));

}

static GtkOrientation

gtk_tool_item_group_get_orientation (GtkToolShell *shell)

{

  GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));

  if (GTK_IS_TOOL_PALETTE (parent))

    return gtk_orientable_get_orientation (GTK_ORIENTABLE (parent));

  return GTK_ORIENTATION_VERTICAL;

}

static GtkToolbarStyle

gtk_tool_item_group_get_style (GtkToolShell *shell)

{

  GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));

  if (GTK_IS_TOOL_PALETTE (parent))

    return gtk_tool_palette_get_style (GTK_TOOL_PALETTE (parent));

  return GTK_TOOLBAR_ICONS;

}

static GtkIconSize

gtk_tool_item_group_get_icon_size (GtkToolShell *shell)

{

  GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));

  if (GTK_IS_TOOL_PALETTE (parent))

    return gtk_tool_palette_get_icon_size (GTK_TOOL_PALETTE (parent));

  return GTK_ICON_SIZE_SMALL_TOOLBAR;

}

static PangoEllipsizeMode

gtk_tool_item_group_get_ellipsize_mode (GtkToolShell *shell)

{

  return GTK_TOOL_ITEM_GROUP (shell)->priv->ellipsize;

}

static gfloat

gtk_tool_item_group_get_text_alignment (GtkToolShell *shell)

{

  if (GTK_TOOLBAR_TEXT == gtk_tool_item_group_get_style (shell) ||

      GTK_TOOLBAR_BOTH_HORIZ == gtk_tool_item_group_get_style (shell))

    return 0.0;

  return 0.5;

}

static GtkOrientation

gtk_tool_item_group_get_text_orientation (GtkToolShell *shell)

{

  return GTK_ORIENTATION_HORIZONTAL;

}

static GtkSizeGroup *

gtk_tool_item_group_get_text_size_group (GtkToolShell *shell)

{

  GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (shell));

  if (GTK_IS_TOOL_PALETTE (parent))

    return _gtk_tool_palette_get_size_group (GTK_TOOL_PALETTE (parent));

  return NULL;

}

static void

animation_change_notify (GtkToolItemGroup *group)

{

  GtkSettings *settings = group->priv->settings;

  gboolean animation;

  if (settings)

    g_object_get (settings,

                  "gtk-enable-animations", &animation,

                  NULL);

  else

    animation = DEFAULT_ANIMATION_STATE;

  group->priv->animation = animation;

}

static void

gtk_tool_item_group_settings_change_notify (GtkSettings      *settings,

                                            const GParamSpec *pspec,

                                            GtkToolItemGroup *group)

{

  if (strcmp (pspec->name, "gtk-enable-animations") == 0)

    animation_change_notify (group);

}

static void

gtk_tool_item_group_screen_changed (GtkWidget *widget,

                                    GdkScreen *previous_screen)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkSettings *old_settings = priv->settings;

  GtkSettings *settings;

  if (gtk_widget_has_screen (GTK_WIDGET (group)))

    settings = gtk_widget_get_settings (GTK_WIDGET (group));

  else

    settings = NULL;

  if (settings == old_settings)

    return;

  if (old_settings)

  {

    g_signal_handler_disconnect (old_settings, priv->settings_connection);

    g_object_unref (old_settings);

  }

  if (settings)

  {

    priv->settings_connection =

      g_signal_connect (settings, "notify",

                        G_CALLBACK (gtk_tool_item_group_settings_change_notify),

                        group);

    priv->settings = g_object_ref (settings);

  }

  else

    priv->settings = NULL;

  animation_change_notify (group);

}

static void

gtk_tool_item_group_tool_shell_init (GtkToolShellIface *iface)

{

  iface->get_icon_size = gtk_tool_item_group_get_icon_size;

  iface->get_orientation = gtk_tool_item_group_get_orientation;

  iface->get_style = gtk_tool_item_group_get_style;

  iface->get_text_alignment = gtk_tool_item_group_get_text_alignment;

  iface->get_text_orientation = gtk_tool_item_group_get_text_orientation;

  iface->get_text_size_group = gtk_tool_item_group_get_text_size_group;

  iface->get_ellipsize_mode = gtk_tool_item_group_get_ellipsize_mode;

}

static gboolean

gtk_tool_item_group_header_expose_event_cb (GtkWidget      *widget,

                                            GdkEventExpose *event,

                                            gpointer        data)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkExpanderStyle expander_style;

  GtkOrientation orientation;

  gint x, y;

  GtkTextDirection direction;

  orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));

  expander_style = priv->expander_style;

  direction = gtk_widget_get_direction (widget);

  if (GTK_ORIENTATION_VERTICAL == orientation)

    {

      if (GTK_TEXT_DIR_RTL == direction)

        x = widget->allocation.x + widget->allocation.width - priv->expander_size / 2;

      else

        x = widget->allocation.x + priv->expander_size / 2;

      y = widget->allocation.y + widget->allocation.height / 2;

    }

  else

    {

      x = widget->allocation.x + widget->allocation.width / 2;

      y = widget->allocation.y + priv->expander_size / 2;

      /* Unfortunatly gtk_paint_expander() doesn't support rotated drawing

       * modes. Luckily the following shady arithmetics produce the desired

       * result. */

      expander_style = GTK_EXPANDER_EXPANDED - expander_style;

    }

  gtk_paint_expander (widget->style, widget->window,

                      priv->header->state,

                      &event->area, GTK_WIDGET (group),

                      "tool-palette-header", x, y,

                      expander_style);

  return FALSE;

}

static void

gtk_tool_item_group_header_size_request_cb (GtkWidget      *widget,

                                            GtkRequisition *requisition,

                                            gpointer        data)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);

  requisition->height = MAX (requisition->height, group->priv->expander_size);

}

static void

gtk_tool_item_group_header_clicked_cb (GtkButton *button,

                                       gpointer   data)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (data);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkWidget *parent = gtk_widget_get_parent (data);

  if (priv->collapsed ||

      !GTK_IS_TOOL_PALETTE (parent) ||

      !gtk_tool_palette_get_exclusive (GTK_TOOL_PALETTE (parent), data))

    gtk_tool_item_group_set_collapsed (group, !priv->collapsed);

}

static void

gtk_tool_item_group_header_adjust_style (GtkToolItemGroup *group)

{

  GtkWidget *alignment = gtk_tool_item_group_get_alignment (group);

  GtkWidget *label_widget = gtk_bin_get_child (GTK_BIN (alignment));

  GtkWidget *widget = GTK_WIDGET (group);

  GtkToolItemGroupPrivate* priv = group->priv;

  gint dx = 0, dy = 0;

  GtkTextDirection direction = gtk_widget_get_direction (widget);

  gtk_widget_style_get (widget,

                        "header-spacing", &(priv->header_spacing),

                        "expander-size", &(priv->expander_size),

                        NULL);

  switch (gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group)))

    {

      case GTK_ORIENTATION_HORIZONTAL:

        dy = priv->header_spacing + priv->expander_size;

        if (GTK_IS_LABEL (label_widget))

          {

            gtk_label_set_ellipsize (GTK_LABEL (label_widget), PANGO_ELLIPSIZE_NONE);

            if (GTK_TEXT_DIR_RTL == direction)

              gtk_label_set_angle (GTK_LABEL (label_widget), -90);

            else

              gtk_label_set_angle (GTK_LABEL (label_widget), 90);

          }

       break;

      case GTK_ORIENTATION_VERTICAL:

        dx = priv->header_spacing + priv->expander_size;

        if (GTK_IS_LABEL (label_widget))

          {

            gtk_label_set_ellipsize (GTK_LABEL (label_widget), priv->ellipsize);

            gtk_label_set_angle (GTK_LABEL (label_widget), 0);

          }

        break;

    }

  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), dy, 0, dx, 0);

}

static void

gtk_tool_item_group_init (GtkToolItemGroup *group)

{

  GtkWidget *alignment;

  GtkToolItemGroupPrivate* priv;

  gtk_widget_set_redraw_on_allocate (GTK_WIDGET (group), FALSE);

  group->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (group,

                                             GTK_TYPE_TOOL_ITEM_GROUP,

                                             GtkToolItemGroupPrivate);

  priv->children = NULL;

  priv->header_spacing = DEFAULT_HEADER_SPACING;

  priv->expander_size = DEFAULT_EXPANDER_SIZE;

  priv->expander_style = GTK_EXPANDER_EXPANDED;

  priv->label_widget = gtk_label_new (NULL);

  gtk_misc_set_alignment (GTK_MISC (priv->label_widget), 0.0, 0.5);

  alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);

  gtk_container_add (GTK_CONTAINER (alignment), priv->label_widget);

  gtk_widget_show_all (alignment);

  gtk_widget_push_composite_child ();

  priv->header = gtk_button_new ();

  gtk_widget_set_composite_name (priv->header, "header");

  gtk_widget_pop_composite_child ();

  g_object_ref_sink (priv->header);

  gtk_button_set_focus_on_click (GTK_BUTTON (priv->header), FALSE);

  gtk_container_add (GTK_CONTAINER (priv->header), alignment);

  gtk_widget_set_parent (priv->header, GTK_WIDGET (group));

  gtk_tool_item_group_header_adjust_style (group);

  g_signal_connect_after (alignment, "expose-event",

                          G_CALLBACK (gtk_tool_item_group_header_expose_event_cb),

                          group);

  g_signal_connect_after (alignment, "size-request",

                          G_CALLBACK (gtk_tool_item_group_header_size_request_cb),

                          group);

  g_signal_connect (priv->header, "clicked",

                    G_CALLBACK (gtk_tool_item_group_header_clicked_cb),

                    group);

}

static void

gtk_tool_item_group_set_property (GObject      *object,

                                  guint         prop_id,

                                  const GValue *value,

                                  GParamSpec   *pspec)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);

  switch (prop_id)

    {

      case PROP_LABEL:

        gtk_tool_item_group_set_label (group, g_value_get_string (value));

        break;

      case PROP_LABEL_WIDGET:

        gtk_tool_item_group_set_label_widget (group, g_value_get_object (value));

	break;

      case PROP_COLLAPSED:

        gtk_tool_item_group_set_collapsed (group, g_value_get_boolean (value));

        break;

      case PROP_ELLIPSIZE:

        gtk_tool_item_group_set_ellipsize (group, g_value_get_enum (value));

        break;

      case PROP_RELIEF:

        gtk_tool_item_group_set_header_relief (group, g_value_get_enum(value));

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_tool_item_group_get_property (GObject    *object,

                                  guint       prop_id,

                                  GValue     *value,

                                  GParamSpec *pspec)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);

  switch (prop_id)

    {

      case PROP_LABEL:

        g_value_set_string (value, gtk_tool_item_group_get_label (group));

        break;

      case PROP_LABEL_WIDGET:

        g_value_set_object (value,

			    gtk_tool_item_group_get_label_widget (group));

        break;

      case PROP_COLLAPSED:

        g_value_set_boolean (value, gtk_tool_item_group_get_collapsed (group));

        break;

      case PROP_ELLIPSIZE:

        g_value_set_enum (value, gtk_tool_item_group_get_ellipsize (group));

        break;

      case PROP_RELIEF:

        g_value_set_enum (value, gtk_tool_item_group_get_header_relief (group));

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_tool_item_group_finalize (GObject *object)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);

  if (group->priv->children)

    {

      g_list_free (group->priv->children);

      group->priv->children = NULL;

    }

  G_OBJECT_CLASS (gtk_tool_item_group_parent_class)->finalize (object);

}

static void

gtk_tool_item_group_dispose (GObject *object)

{

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (object);

  GtkToolItemGroupPrivate* priv = group->priv;

  if (priv->toplevel)

    {

      /* disconnect focus tracking handler */

      g_signal_handler_disconnect (priv->toplevel,

                                   priv->focus_set_id);

      priv->focus_set_id = 0;

      priv->toplevel = NULL;

    }

  G_OBJECT_CLASS (gtk_tool_item_group_parent_class)->dispose (object);

}

static void

gtk_tool_item_group_get_item_size (GtkToolItemGroup *group,

                                   GtkRequisition   *item_size,

                                   gboolean          homogeneous_only,

                                   gint             *requested_rows)

{

  GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (group));

  if (GTK_IS_TOOL_PALETTE (parent))

    _gtk_tool_palette_get_item_size (GTK_TOOL_PALETTE (parent), item_size, homogeneous_only, requested_rows);

  else

    _gtk_tool_item_group_item_size_request (group, item_size, homogeneous_only, requested_rows);

}

static void

gtk_tool_item_group_size_request (GtkWidget      *widget,

                                  GtkRequisition *requisition)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkOrientation orientation;

  GtkRequisition item_size;

  gint requested_rows;

  if (priv->children && gtk_tool_item_group_get_label_widget (group))

    {

      gtk_widget_size_request (priv->header, requisition);

      gtk_widget_show (priv->header);

    }

  else

    {

      requisition->width = requisition->height = 0;

      gtk_widget_hide (priv->header);

    }

  gtk_tool_item_group_get_item_size (group, &item_size, FALSE, &requested_rows);

  orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));

  if (GTK_ORIENTATION_VERTICAL == orientation)

    requisition->width = MAX (requisition->width, item_size.width);

  else

    requisition->height = MAX (requisition->height, item_size.height * requested_rows);

  requisition->width += border_width * 2;

  requisition->height += border_width * 2;

}

static gboolean

gtk_tool_item_group_is_item_visible (GtkToolItemGroup      *group,

                                     GtkToolItemGroupChild *child)

{

  GtkToolbarStyle style;

  GtkOrientation orientation;

  orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));

  style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));

  /* horizontal tool palettes with text style support only homogeneous items */

  if (!child->homogeneous &&

      GTK_ORIENTATION_HORIZONTAL == orientation &&

      GTK_TOOLBAR_TEXT == style)

    return FALSE;

  return

    (gtk_widget_get_visible (GTK_WIDGET (child->item))) &&

    (GTK_ORIENTATION_VERTICAL == orientation ?

     gtk_tool_item_get_visible_vertical (child->item) :

     gtk_tool_item_get_visible_horizontal (child->item));

}

static inline unsigned

udiv (unsigned x,

      unsigned y)

{

  return (x + y - 1) / y;

}

static void

gtk_tool_item_group_real_size_query (GtkWidget      *widget,

                                     GtkAllocation  *allocation,

                                     GtkRequisition *inquery)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkRequisition item_size;

  GtkAllocation item_area;

  GtkOrientation orientation;

  GtkToolbarStyle style;

  gint min_rows;

  orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));

  style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));

  /* figure out the size of homogeneous items */

  gtk_tool_item_group_get_item_size (group, &item_size, TRUE, &min_rows);

  if (GTK_ORIENTATION_VERTICAL == orientation)

    item_size.width = MIN (item_size.width, allocation->width);

  else

    item_size.height = MIN (item_size.height, allocation->height);

  item_size.width  = MAX (item_size.width, 1);

  item_size.height = MAX (item_size.height, 1);

  item_area.width = 0;

  item_area.height = 0;

  /* figure out the required columns (n_columns) and rows (n_rows) to place all items */

  if (!priv->collapsed || !priv->animation || priv->animation_timeout)

    {

      guint n_columns;

      gint n_rows;

      GList *it;

      if (GTK_ORIENTATION_VERTICAL == orientation)

        {

          gboolean new_row = FALSE;

          gint row = -1;

          guint col = 0;

          item_area.width = allocation->width - 2 * border_width;

          n_columns = MAX (item_area.width / item_size.width, 1);

          /* calculate required rows for n_columns columns */

          for (it = priv->children; it != NULL; it = it->next)

            {

              GtkToolItemGroupChild *child = it->data;

              if (!gtk_tool_item_group_is_item_visible (group, child))

                continue;

              if (new_row || child->new_row)

                {

                  new_row = FALSE;

                  row++;

                  col = 0;

                }

              if (child->expand)

                new_row = TRUE;

              if (child->homogeneous)

                {

                  col++;

                  if (col >= n_columns)

                    new_row = TRUE;

                }

              else

                {

                  GtkRequisition req = {0, 0};

                  guint width;

                  gtk_widget_size_request (GTK_WIDGET (child->item), &req;;

                  width = udiv (req.width, item_size.width);

                  col += width;

                  if (col > n_columns)

                    row++;

                  col = width;

                  if (col >= n_columns)

                    new_row = TRUE;

                }

            }

          n_rows = row + 2;

        }

      else

        {

          guint *row_min_width;

          gint row = -1;

          gboolean new_row = TRUE;

          guint col = 0, min_col, max_col = 0, all_items = 0;

          gint i;

          item_area.height = allocation->height - 2 * border_width;

          n_rows = MAX (item_area.height / item_size.height, min_rows);

          row_min_width = g_new0 (guint, n_rows);

          /* calculate minimal and maximal required cols and minimal required rows */

          for (it = priv->children; it != NULL; it = it->next)

            {

              GtkToolItemGroupChild *child = it->data;

              if (!gtk_tool_item_group_is_item_visible (group, child))

                continue;

              if (new_row || child->new_row)

                {

                  new_row = FALSE;

                  row++;

                  col = 0;

                  row_min_width[row] = 1;

                }

              if (child->expand)

                new_row = TRUE;

              if (child->homogeneous)

                {

                  col++;

                  all_items++;

                }

              else

                {

                  GtkRequisition req = {0, 0};

                  guint width;

                  gtk_widget_size_request (GTK_WIDGET (child->item), &req;;

                  width = udiv (req.width, item_size.width);

                  col += width;

                  all_items += width;

                  row_min_width[row] = MAX (row_min_width[row], width);

                }

              max_col = MAX (max_col, col);

            }

          /* calculate minimal required cols */

          min_col = udiv (all_items, n_rows);

          for (i = 0; i <= row; i++)

            {

              min_col = MAX (min_col, row_min_width[i]);

            }

          /* simple linear search for minimal required columns for the given maximal number of rows (n_rows) */

          for (n_columns = min_col; n_columns < max_col; n_columns ++)

            {

              new_row = TRUE;

              row = -1;

              /* calculate required rows for n_columns columns */

              for (it = priv->children; it != NULL; it = it->next)

                {

                  GtkToolItemGroupChild *child = it->data;

                  if (!gtk_tool_item_group_is_item_visible (group, child))

                    continue;

                  if (new_row || child->new_row)

                    {

                      new_row = FALSE;

                      row++;

                      col = 0;

                    }

                  if (child->expand)

                    new_row = TRUE;

                  if (child->homogeneous)

                    {

                      col++;

                      if (col >= n_columns)

                        new_row = TRUE;

                    }

                  else

                    {

                      GtkRequisition req = {0, 0};

                      guint width;

                      gtk_widget_size_request (GTK_WIDGET (child->item), &req;;

                      width = udiv (req.width, item_size.width);

                      col += width;

                      if (col > n_columns)

                        row++;

                      col = width;

                      if (col >= n_columns)

                        new_row = TRUE;

                    }

                }

              if (row < n_rows)

                break;

            }

        }

      item_area.width = item_size.width * n_columns;

      item_area.height = item_size.height * n_rows;

    }

  inquery->width = 0;

  inquery->height = 0;

  /* figure out header widget size */

  if (gtk_widget_get_visible (priv->header))

    {

      GtkRequisition child_requisition;

      gtk_widget_size_request (priv->header, &child_requisition);

      if (GTK_ORIENTATION_VERTICAL == orientation)

        inquery->height += child_requisition.height;

      else

        inquery->width += child_requisition.width;

    }

  /* report effective widget size */

  inquery->width += item_area.width + 2 * border_width;

  inquery->height += item_area.height + 2 * border_width;

}

static void

gtk_tool_item_group_real_size_allocate (GtkWidget     *widget,

                                        GtkAllocation *allocation)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  GtkToolItemGroup *group = GTK_TOOL_ITEM_GROUP (widget);

  GtkToolItemGroupPrivate* priv = group->priv;

  GtkRequisition child_requisition;

  GtkAllocation child_allocation;

  GtkRequisition item_size;

  GtkAllocation item_area;

  GtkOrientation orientation;

  GtkToolbarStyle style;

  GList *it;

  gint n_columns, n_rows = 1;

  gint min_rows;

  GtkTextDirection direction = gtk_widget_get_direction (widget);

  orientation = gtk_tool_shell_get_orientation (GTK_TOOL_SHELL (group));

  style = gtk_tool_shell_get_style (GTK_TOOL_SHELL (group));

  /* chain up */

  GTK_WIDGET_CLASS (gtk_tool_item_group_parent_class)->size_allocate (widget, allocation);

  child_allocation.x = border_width;

  child_allocation.y = border_width;

  /* place the header widget */

  if (gtk_widget_get_visible (priv->header))

    {

      gtk_widget_size_request (priv->header, &child_requisition);

      if (GTK_ORIENTATION_VERTICAL == orientation)