gtk2/gtk/gtkwrapbox.c

/* gtkwrapbox.c
 * Copyright (C) 2007-2010 Openismus GmbH
 *
 * Authors:
 *      Tristan Van Berkom <tristanvb@openismus.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */


/**
 * SECTION:gtkwrapbox
 * @Short_Description: A container that wraps its children;
 * @Title: GtkWrapBox
 *
 * #GtkWrapBox allocates space for an ordered list of children
 * by wrapping them over in the box's orentation.
 *
 */

#include "config.h"
#include "gtksizerequest.h"
#include "gtkorientable.h"
#include "gtkwrapbox.h"
#include "gtkprivate.h"
#include "gtkintl.h"


typedef struct _GtkWrapBoxChild  GtkWrapBoxChild;

enum {
  PROP_0,
  PROP_ORIENTATION,
  PROP_ALLOCATION_MODE,
  PROP_HORIZONTAL_SPREADING,
  PROP_VERTICAL_SPREADING,
  PROP_HORIZONTAL_SPACING,
  PROP_VERTICAL_SPACING,
  PROP_MINIMUM_LINE_CHILDREN,
  PROP_NATURAL_LINE_CHILDREN
};

enum
{
  CHILD_PROP_0,
  CHILD_PROP_PACKING
};

struct _GtkWrapBoxPrivate
{
  GtkOrientation        orientation;
  GtkWrapAllocationMode mode;
  GtkWrapBoxSpreading   horizontal_spreading;
  GtkWrapBoxSpreading   vertical_spreading;

  guint16               vertical_spacing;
  guint16               horizontal_spacing;

  guint16               minimum_line_children;
  guint16               natural_line_children;

  GList                *children;
};

struct _GtkWrapBoxChild
{
  GtkWidget        *widget;

  GtkWrapBoxPacking packing;
};

/* GObjectClass */
static void gtk_wrap_box_get_property         (GObject             *object,
                                               guint                prop_id,
                                               GValue              *value,
                                               GParamSpec          *pspec);
static void gtk_wrap_box_set_property         (GObject             *object,
                                               guint                prop_id,
                                               const GValue        *value,
                                               GParamSpec          *pspec);

/* GtkWidgetClass */
static void gtk_wrap_box_size_allocate        (GtkWidget           *widget,
                                               GtkAllocation       *allocation);

/* GtkContainerClass */
static void gtk_wrap_box_add                  (GtkContainer        *container,
                                               GtkWidget           *widget);
static void gtk_wrap_box_remove               (GtkContainer        *container,
                                               GtkWidget           *widget);
static void gtk_wrap_box_forall               (GtkContainer        *container,
                                               gboolean             include_internals,
                                               GtkCallback          callback,
                                               gpointer             callback_data);
static void gtk_wrap_box_set_child_property   (GtkContainer        *container,
                                               GtkWidget           *child,
                                               guint                property_id,
                                               const GValue        *value,
                                               GParamSpec          *pspec);
static void gtk_wrap_box_get_child_property   (GtkContainer        *container,
                                               GtkWidget           *child,
                                               guint                property_id,
                                               GValue              *value,
                                               GParamSpec          *pspec);
static GType gtk_wrap_box_child_type          (GtkContainer        *container);


/* GtkSizeRequest */
static void gtk_wrap_box_size_request_init    (GtkSizeRequestIface *iface);
static GtkSizeRequestMode gtk_wrap_box_get_request_mode (GtkSizeRequest *widget);
static void gtk_wrap_box_get_width            (GtkSizeRequest      *widget,
                                               gint                *minimum_size,
                                               gint                *natural_size);
static void gtk_wrap_box_get_height           (GtkSizeRequest      *widget,
                                               gint                *minimum_size,
                                               gint                *natural_size);
static void gtk_wrap_box_get_height_for_width (GtkSizeRequest      *box,
                                               gint                 width,
                                               gint                *minimum_height,
                                               gint                *natural_height);
static void gtk_wrap_box_get_width_for_height (GtkSizeRequest      *box,
                                               gint                 width,
                                               gint                *minimum_height,
                                               gint                *natural_height);


G_DEFINE_TYPE_WITH_CODE (GtkWrapBox, gtk_wrap_box, GTK_TYPE_CONTAINER,
                         G_IMPLEMENT_INTERFACE (GTK_TYPE_SIZE_REQUEST,
                                                gtk_wrap_box_size_request_init)
                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))


#define ORIENTATION_SPREADING(box)					\
  (((GtkWrapBox *)(box))->priv->orientation == GTK_ORIENTATION_HORIZONTAL ? \
   ((GtkWrapBox *)(box))->priv->horizontal_spreading :			\
   ((GtkWrapBox *)(box))->priv->vertical_spreading)

#define OPPOSING_ORIENTATION_SPREADING(box)				\
  (((GtkWrapBox *)(box))->priv->orientation == GTK_ORIENTATION_HORIZONTAL ? \
   ((GtkWrapBox *)(box))->priv->vertical_spreading :			\
   ((GtkWrapBox *)(box))->priv->horizontal_spreading)



static void
gtk_wrap_box_class_init (GtkWrapBoxClass *class)
{
  GObjectClass      *gobject_class    = G_OBJECT_CLASS (class);
  GtkWidgetClass    *widget_class     = GTK_WIDGET_CLASS (class);
  GtkContainerClass *container_class  = GTK_CONTAINER_CLASS (class);

  gobject_class->get_property         = gtk_wrap_box_get_property;
  gobject_class->set_property         = gtk_wrap_box_set_property;

  widget_class->size_allocate         = gtk_wrap_box_size_allocate;

  container_class->add                = gtk_wrap_box_add;
  container_class->remove             = gtk_wrap_box_remove;
  container_class->forall             = gtk_wrap_box_forall;
  container_class->child_type         = gtk_wrap_box_child_type;
  container_class->set_child_property = gtk_wrap_box_set_child_property;
  container_class->get_child_property = gtk_wrap_box_get_child_property;
  gtk_container_class_handle_border_width (container_class);

  /* GObjectClass properties */
  g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");

  /**
   * GtkWrapBox:allocation-mode:
   *
   * The #GtkWrapAllocationMode to use.
   */
  g_object_class_install_property (gobject_class,
                                   PROP_ALLOCATION_MODE,
                                   g_param_spec_enum ("allocation-mode",
                                                      P_("Allocation Mode"),
                                                      P_("The allocation mode to use"),
                                                      GTK_TYPE_WRAP_ALLOCATION_MODE,
                                                      GTK_WRAP_ALLOCATE_FREE,
                                                      GTK_PARAM_READWRITE));

  /**
   * GtkWrapBox:horizontal-spreading:
   *
   * The #GtkWrapBoxSpreading to used to define what is done with extra
   * space in a given orientation.
   */
  g_object_class_install_property (gobject_class,
                                   PROP_HORIZONTAL_SPREADING,
                                   g_param_spec_enum ("horizontal-spreading",
                                                      P_("Horizontal Spreading"),
                                                      P_("The spreading mode to use horizontally"),
                                                      GTK_TYPE_WRAP_BOX_SPREADING,
                                                      GTK_WRAP_BOX_SPREAD_START,
                                                      GTK_PARAM_READWRITE));

  /**
   * GtkWrapBox:vertical-spreading:
   *
   * The #GtkWrapBoxSpreading to used to define what is done with extra
   * space in a given orientation.
   */
  g_object_class_install_property (gobject_class,
                                   PROP_VERTICAL_SPREADING,
                                   g_param_spec_enum ("vertical-spreading",
                                                      P_("Vertical Spreading"),
                                                      P_("The spreading mode to use vertically"),
                                                      GTK_TYPE_WRAP_BOX_SPREADING,
                                                      GTK_WRAP_BOX_SPREAD_START,
                                                      GTK_PARAM_READWRITE));


  /**
   * GtkWrapBox:minimum-line-children:
   *
   * The minimum number of children to allocate consecutively in the given orientation.
   *
   * <note><para>Setting the minimum children per line ensures
   * that a reasonably small height will be requested
   * for the overall minimum width of the box.</para></note>
   *
   */
  g_object_class_install_property (gobject_class,
                                   PROP_MINIMUM_LINE_CHILDREN,
                                   g_param_spec_uint ("minimum-line-children",
                                                      P_("Minimum Line Children"),
                                                      P_("The minimum number of children to allocate "
                                                        "consecutively in the given orientation."),
                                                      0,
                                                      65535,
                                                      0,
                                                      GTK_PARAM_READWRITE));

  /**
   * GtkWrapBox:natural-line-children:
   *
   * The maximum amount of children to request space for consecutively in the given orientation.
   *
   */
  g_object_class_install_property (gobject_class,
                                   PROP_NATURAL_LINE_CHILDREN,
                                   g_param_spec_uint ("natural-line-children",
                                                      P_("Natural Line Children"),
                                                      P_("The maximum amount of children to request space for "
                                                        "consecutively in the given orientation."),
                                                      0,
                                                      65535,
                                                      0,
                                                      GTK_PARAM_READWRITE));

  /**
   * GtkWrapBox:vertical-spacing:
   *
   * The amount of vertical space between two children.
   *
   */
  g_object_class_install_property (gobject_class,
                                   PROP_VERTICAL_SPACING,
                                   g_param_spec_uint ("vertical-spacing",
                                                     P_("Vertical spacing"),
                                                     P_("The amount of vertical space between two children"),
                                                     0,
                                                     65535,
                                                     0,
                                                     GTK_PARAM_READWRITE));

  /**
   * GtkWrapBox:horizontal-spacing:
   *
   * The amount of horizontal space between two children.
   *
   */
  g_object_class_install_property (gobject_class,
                                   PROP_HORIZONTAL_SPACING,
                                   g_param_spec_uint ("horizontal-spacing",
                                                     P_("Horizontal spacing"),
                                                     P_("The amount of horizontal space between two children"),
                                                     0,
                                                     65535,
                                                     0,
                                                     GTK_PARAM_READWRITE));

  /* GtkContainerClass child properties */

  /**
   * GtkWrapBox:packing:
   *
   * The #GtkWrapBoxPacking options to specify how to pack a child into the box.
   */
  gtk_container_class_install_child_property (container_class,
                                              CHILD_PROP_PACKING,
                                              g_param_spec_flags
                                              ("packing",
                                               P_("Packing"),
                                               P_("The packing options to use for this child"),
                                               GTK_TYPE_WRAP_BOX_PACKING, 0,
                                               GTK_PARAM_READWRITE));

  g_type_class_add_private (class, sizeof (GtkWrapBoxPrivate));
}

static void
gtk_wrap_box_init (GtkWrapBox *box)
{
  GtkWrapBoxPrivate *priv;

  box->priv = priv =
    G_TYPE_INSTANCE_GET_PRIVATE (box, GTK_TYPE_WRAP_BOX, GtkWrapBoxPrivate);

  priv->orientation          = GTK_ORIENTATION_HORIZONTAL;
  priv->mode                 = GTK_WRAP_ALLOCATE_FREE;
  priv->horizontal_spreading = GTK_WRAP_BOX_SPREAD_START;
  priv->vertical_spreading   = GTK_WRAP_BOX_SPREAD_START;
  priv->horizontal_spacing   = 0;
  priv->vertical_spacing     = 0;
  priv->children             = NULL;

  gtk_widget_set_has_window (GTK_WIDGET (box), FALSE);
}

/*****************************************************
 *                  GObectClass                      *
 *****************************************************/
static void
gtk_wrap_box_get_property (GObject      *object,
                           guint         prop_id,
                           GValue       *value,
                           GParamSpec   *pspec)
{
  GtkWrapBox        *box  = GTK_WRAP_BOX (object);
  GtkWrapBoxPrivate *priv = box->priv;

  switch (prop_id)
    {
    case PROP_ORIENTATION:
      g_value_set_boolean (value, priv->orientation);
      break;
    case PROP_ALLOCATION_MODE:
      g_value_set_enum (value, priv->mode);
      break;
    case PROP_HORIZONTAL_SPREADING:
      g_value_set_enum (value, priv->horizontal_spreading);
      break;
    case PROP_VERTICAL_SPREADING:
      g_value_set_enum (value, priv->vertical_spreading);
      break;
    case PROP_HORIZONTAL_SPACING:
      g_value_set_uint (value, priv->horizontal_spacing);
      break;
    case PROP_VERTICAL_SPACING:
      g_value_set_uint (value, priv->vertical_spacing);
      break;
    case PROP_MINIMUM_LINE_CHILDREN:
      g_value_set_uint (value, priv->minimum_line_children);
      break;
    case PROP_NATURAL_LINE_CHILDREN:
      g_value_set_uint (value, priv->natural_line_children);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gtk_wrap_box_set_property (GObject      *object,
                           guint         prop_id,
                           const GValue *value,
                           GParamSpec   *pspec)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (object);
  GtkWrapBoxPrivate *priv   = box->priv;

  switch (prop_id)
    {
    case PROP_ORIENTATION:
      priv->orientation = g_value_get_enum (value);

      /* Re-box the children in the new orientation */
      gtk_widget_queue_resize (GTK_WIDGET (box));
      break;
    case PROP_ALLOCATION_MODE:
      gtk_wrap_box_set_allocation_mode (box, g_value_get_enum (value));
      break;
    case PROP_HORIZONTAL_SPREADING:
      gtk_wrap_box_set_horizontal_spreading (box, g_value_get_enum (value));
      break;
    case PROP_VERTICAL_SPREADING:
      gtk_wrap_box_set_vertical_spreading (box, g_value_get_enum (value));
      break;
    case PROP_HORIZONTAL_SPACING:
      gtk_wrap_box_set_horizontal_spacing (box, g_value_get_uint (value));
      break;
    case PROP_VERTICAL_SPACING:
      gtk_wrap_box_set_vertical_spacing (box, g_value_get_uint (value));
      break;
    case PROP_MINIMUM_LINE_CHILDREN:
      gtk_wrap_box_set_minimum_line_children (box, g_value_get_uint (value));
      break;
    case PROP_NATURAL_LINE_CHILDREN:
      gtk_wrap_box_set_natural_line_children (box, g_value_get_uint (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

/*****************************************************
 *                 GtkWidgetClass                    *
 *****************************************************/

static gint
get_visible_children (GtkWrapBox  *box)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GList             *list;
  gint               i = 0;

  for (list = priv->children; list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      i++;
    }

  return i;
}

static gint
get_visible_expand_children (GtkWrapBox     *box,
                             GtkOrientation  orientation,
                             GList          *cursor,
                             gint            n_visible)
{
  GList *list;
  gint   i, expand_children = 0;

  for (i = 0, list = cursor; (n_visible > 0 ? i < n_visible : TRUE) && list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      if ((orientation == GTK_ORIENTATION_HORIZONTAL && (child->packing & GTK_WRAP_BOX_H_EXPAND) != 0) ||
          (orientation == GTK_ORIENTATION_VERTICAL   && (child->packing & GTK_WRAP_BOX_V_EXPAND) != 0))
        expand_children++;

      i++;
    }

  return expand_children;
}

/* Used in columned modes where all items share at least their
 * equal widths or heights
 */
static void
get_average_item_size (GtkWrapBox      *box,
                       GtkOrientation   orientation,
                       gint            *min_size,
                       gint            *nat_size)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GList             *list;
  gint               max_min_size = 0;
  gint               max_nat_size = 0;

  for (list = priv->children; list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_min, child_nat;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
                                    &child_min, &child_nat);
      else
        gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
                                     &child_min, &child_nat);

      max_min_size = MAX (max_min_size, child_min);
      max_nat_size = MAX (max_nat_size, child_nat);
    }

  if (min_size)
    *min_size = max_min_size;

  if (nat_size)
    *nat_size = max_nat_size;
}


/* Gets the largest minimum/natural size for a given size
 * (used to get the largest item heights for a fixed item width and the opposite) */
static void
get_largest_size_for_opposing_orientation (GtkWrapBox         *box,
                                           GtkOrientation      orientation,
                                           gint                item_size,
                                           gint               *min_item_size,
                                           gint               *nat_item_size)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GList             *list;
  gint               max_min_size = 0;
  gint               max_nat_size = 0;

  for (list = priv->children; list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_min, child_nat;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child->widget),
                                               item_size,
                                               &child_min, &child_nat);
      else
        gtk_size_request_get_width_for_height (GTK_SIZE_REQUEST (child->widget),
                                               item_size,
                                               &child_min, &child_nat);

      max_min_size = MAX (max_min_size, child_min);
      max_nat_size = MAX (max_nat_size, child_nat);
    }

  if (min_item_size)
    *min_item_size = max_min_size;

  if (nat_item_size)
    *nat_item_size = max_nat_size;
}


/* Gets the largest minimum/natural size on a single line for a given size
 * (used to get the largest line heights for a fixed item width and the opposite
 * while itterating over a list of children, note the new index is returned) */
static GList *
get_largest_size_for_line_in_opposing_orientation (GtkWrapBox       *box,
                                                   GtkOrientation    orientation,
                                                   GList            *cursor,
                                                   gint              line_length,
                                                   GtkRequestedSize *item_sizes,
                                                   gint              extra_pixels,
                                                   gint             *min_item_size,
                                                   gint             *nat_item_size)
{
  GList  *list;
  gint    max_min_size = 0;
  gint    max_nat_size = 0;
  gint    i;

  for (list = cursor, i = 0; list && i < line_length; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_min, child_nat, this_item_size;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      /* Distribute the extra pixels to the first children in the line
       * (could be fancier and spread them out more evenly) */
      this_item_size = item_sizes[i].minimum_size;
      if (extra_pixels > 0 && ORIENTATION_SPREADING (box) == GTK_WRAP_BOX_SPREAD_EXPAND)
        {
          this_item_size++;
          extra_pixels--;
        }

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child->widget),
                                               this_item_size,
                                               &child_min, &child_nat);
      else
        gtk_size_request_get_width_for_height (GTK_SIZE_REQUEST (child->widget),
                                               this_item_size,
                                               &child_min, &child_nat);

      max_min_size = MAX (max_min_size, child_min);
      max_nat_size = MAX (max_nat_size, child_nat);

      i++;
    }

  if (min_item_size)
    *min_item_size = max_min_size;

  if (nat_item_size)
    *nat_item_size = max_nat_size;

  /* Return next item in the list */
  return list;
}


/* Gets the largest minimum/natural size on a single line for a given allocated line size
 * (used to get the largest line heights for a width in pixels and the opposite
 * while itterating over a list of children, note the new index is returned) */
static GList *
get_largest_size_for_free_line_in_opposing_orientation (GtkWrapBox      *box,
                                                        GtkOrientation   orientation,
                                                        GList           *cursor,
                                                        gint             min_items,
                                                        gint             avail_size,
                                                        gint            *min_item_size,
                                                        gint            *nat_item_size,
                                                        gint            *extra_pixels,
                                                        GArray         **ret_array)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GtkRequestedSize  *sizes;
  GList             *list;
  GArray            *array;
  gint               max_min_size = 0;
  gint               max_nat_size = 0;
  gint               i, size = avail_size;
  gint               line_length, spacing;
  gint               expand_children = 0;
  gint               expand_per_child;
  gint               expand_remainder;

  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    spacing = priv->horizontal_spacing;
  else
    spacing = priv->vertical_spacing;

  /* First determine the length of this line in items (how many items fit) */
  for (i = 0, list = cursor; size > 0 && list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_size;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
                                    NULL, &child_size);
      else
        gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
                                     NULL, &child_size);

      if (i > 0)
        child_size += spacing;

      if (size - child_size >= 0)
        size -= child_size;
      else
        break;

      i++;
    }

  line_length = MAX (min_items, i);
  size        = avail_size;

  /* Collect the sizes of the items on this line */
  array = g_array_new (0, TRUE, sizeof (GtkRequestedSize));

  for (i = 0, list = cursor; i < line_length && list; list = list->next)
    {
      GtkWrapBoxChild  *child = list->data;
      GtkRequestedSize  requested;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      requested.data = child;
      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
                                    &requested.minimum_size,
                                    &requested.natural_size);
      else
        gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
                                     &requested.minimum_size,
                                     &requested.natural_size);

      if (i > 0)
        size -= spacing;

      size -= requested.minimum_size;

      g_array_append_val (array, requested);

      i++;
    }

  sizes = (GtkRequestedSize *)array->data;
  size  = gtk_distribute_natural_allocation (size, array->len, sizes);

  if (extra_pixels)
    *extra_pixels = size;

  /* Cut out any expand space if we're not distributing any */
  if (ORIENTATION_SPREADING (box) != GTK_WRAP_BOX_SPREAD_EXPAND)
    size = 0;

  /* Count how many children are going to expand... */
  expand_children = get_visible_expand_children (box, orientation,
                                                 cursor, line_length);

  /* If no child prefers to expand, they all get some expand space */
  if (expand_children == 0)
    {
      expand_per_child = size / line_length;
      expand_remainder = size % line_length;
    }
  else
    {
      expand_per_child = size / expand_children;
      expand_remainder = size % expand_children;
    }

  /* Now add the remaining expand space and get the collective size of this line
   * in the opposing orientation */
  for (i = 0, list = cursor; i < line_length && list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint child_min, child_nat;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      g_assert (child == sizes[i].data);

      if ((orientation == GTK_ORIENTATION_HORIZONTAL && (child->packing & GTK_WRAP_BOX_H_EXPAND) != 0) ||
          (orientation == GTK_ORIENTATION_VERTICAL   && (child->packing & GTK_WRAP_BOX_V_EXPAND) != 0) ||
          expand_children == 0)
        {
          sizes[i].minimum_size += expand_per_child;
          if (expand_remainder)
            {
              sizes[i].minimum_size++;
              expand_remainder--;
            }
        }

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child->widget),
                                               sizes[i].minimum_size,
                                               &child_min, &child_nat);
      else
        gtk_size_request_get_width_for_height (GTK_SIZE_REQUEST (child->widget),
                                               sizes[i].minimum_size,
                                               &child_min, &child_nat);

      max_min_size = MAX (max_min_size, child_min);
      max_nat_size = MAX (max_nat_size, child_nat);

      i++;
    }

  if (ret_array)
    *ret_array = array;
  else
    g_array_free (array, TRUE);

  if (min_item_size)
    *min_item_size = max_min_size;

  if (nat_item_size)
    *nat_item_size = max_nat_size;

  /* Return the next item */
  return list;
}

static void
allocate_child (GtkWrapBox      *box,
                GtkWrapBoxChild *child,
                gint             item_offset,
                gint             line_offset,
                gint             item_size,
                gint             line_size)
{
  GtkWrapBoxPrivate  *priv   = box->priv;
  GtkAllocation       widget_allocation;
  GtkAllocation       child_allocation;

  gtk_widget_get_allocation (GTK_WIDGET (box), &widget_allocation);

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      child_allocation.x      = widget_allocation.x + item_offset;
      child_allocation.y      = widget_allocation.y + line_offset;
      child_allocation.width  = item_size;
      child_allocation.height = line_size;
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      child_allocation.x      = widget_allocation.x + line_offset;
      child_allocation.y      = widget_allocation.y + item_offset;
      child_allocation.width  = line_size;
      child_allocation.height = item_size;
    }

  gtk_widget_size_allocate (child->widget, &child_allocation);
}

/* fit_aligned_item_requests() helper */
static gint
gather_aligned_item_requests (GtkWrapBox       *box,
                              GtkOrientation    orientation,
                              gint              line_length,
                              gint              item_spacing,
                              gint              n_children,
                              GtkRequestedSize *item_sizes)
{
  GtkWrapBoxPrivate *priv   = box->priv;
  GList             *list;
  gint               i;
  gint               extra_items, natural_line_size = 0;

  extra_items = n_children % line_length;

  for (list = priv->children, i = 0; list; list = list->next, i++)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_min, child_nat;
      gint             position;

      if (!gtk_widget_get_visible (child->widget))
        continue;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
                                    &child_min, &child_nat);
      else
        gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
                                     &child_min, &child_nat);

      /* Get the index and push it over for the last line when spreading to the end */
      position = i % line_length;

      if (ORIENTATION_SPREADING (box) == GTK_WRAP_BOX_SPREAD_END && i >= n_children - extra_items)
        position += line_length - extra_items;

      /* Round up the size of every column/row */
      item_sizes[position].minimum_size = MAX (item_sizes[position].minimum_size, child_min);
      item_sizes[position].natural_size = MAX (item_sizes[position].natural_size, child_nat);
    }

  for (i = 0; i < line_length; i++)
    natural_line_size += item_sizes[i].natural_size;

  natural_line_size += (line_length - 1) * item_spacing;

  return natural_line_size;
}

static GtkRequestedSize *
fit_aligned_item_requests (GtkWrapBox       *box, 
                           GtkOrientation    orientation, 
                           gint              avail_size,
                           gint              item_spacing,
                           gint             *line_length, /* in-out */
                           gint              n_children)
{
  GtkRequestedSize  *sizes, *try_sizes;
  gint               try_line_size, try_length;

  sizes = g_new0 (GtkRequestedSize, *line_length);

  /* get the sizes for the initial guess */
  try_line_size = 
    gather_aligned_item_requests (box, orientation, *line_length, item_spacing, n_children, sizes);

  /* Try columnizing the whole thing and adding an item to the end of the line;
   * try to fit as many columns into the available size as possible */
  for (try_length = *line_length + 1; try_line_size < avail_size; try_length++)
    {
      try_sizes     = g_new0 (GtkRequestedSize, try_length);
      try_line_size = gather_aligned_item_requests (box, orientation, try_length, item_spacing, 
                                                    n_children, try_sizes);

      if (try_line_size <= avail_size)
        {
          *line_length = try_length;

          g_free (sizes);
          sizes = try_sizes;
        }
      else
        {
          /* oops, this one failed; stick to the last size that fit and then return */
          g_free (try_sizes);
          break;
        }
    }

  return sizes;
}


typedef struct {
  GArray *requested;
  gint    extra_pixels;
} AllocatedLine;

static void
gtk_wrap_box_size_allocate (GtkWidget     *widget,
                            GtkAllocation *allocation)
{
  GtkWrapBox         *box  = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate  *priv = box->priv;
  gint                avail_size, avail_other_size, min_items, item_spacing, line_spacing;
  GtkWrapBoxSpreading item_spreading;
  GtkWrapBoxSpreading line_spreading;

  gtk_widget_set_allocation (widget, allocation);

  min_items = MAX (1, priv->minimum_line_children);

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      avail_size       = allocation->width;
      avail_other_size = allocation->height;
      item_spacing     = priv->horizontal_spacing;
      line_spacing     = priv->vertical_spacing;
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      avail_size       = allocation->height;
      avail_other_size = allocation->width;
      item_spacing     = priv->vertical_spacing;
      line_spacing     = priv->horizontal_spacing;
    }

  item_spreading = ORIENTATION_SPREADING (box);
  line_spreading    = OPPOSING_ORIENTATION_SPREADING (box);


  /*********************************************************
   * Deal with ALIGNED/HOMOGENEOUS modes first, start with * 
   * initial guesses at item/line sizes                    *
   *********************************************************/
  if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED ||
      priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
    {
      GtkRequestedSize *line_sizes = NULL;
      GtkRequestedSize *item_sizes = NULL;
      GList *list;
      gint   min_item_size, nat_item_size;
      gint   line_length;
      gint   item_size = 0;
      gint   line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0;
      gint   line_offset, item_offset, n_children, n_lines, line_count;
      gint   extra_pixels, extra_per_item = 0, extra_extra = 0;
      gint   extra_line_pixels, extra_per_line = 0, extra_line_extra = 0;
      gint   i, this_line_size;

      get_average_item_size (box, priv->orientation, &min_item_size, &nat_item_size);

      /* By default wrap at the natural item width */
      line_length = avail_size / (nat_item_size + item_spacing);

      /* After the above aproximation, check if we cant fit one more on the line */
      if (line_length * item_spacing + (line_length + 1) * nat_item_size <= avail_size)
        line_length++;

      /* Its possible we were allocated just less than the natural width of the
       * minimum item wrap length */
      line_length = MAX (min_items, line_length);

      /* Get how many lines we'll be needing to wrap */
      n_children = get_visible_children (box);

      /* Here we just use the largest height-for-width and use that for the height
       * of all lines */
      if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
        {
          n_lines    = n_children / line_length;
          if ((n_children % line_length) > 0)
            n_lines++;
          
          n_lines = MAX (n_lines, 1);

          /* Now we need the real item allocation size */
          item_size = (avail_size - (line_length - 1) * item_spacing) / line_length;
          
          /* Cut out the expand space if we're not distributing any */
          if (item_spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
            item_size = MIN (item_size, nat_item_size);
          
          get_largest_size_for_opposing_orientation (box, priv->orientation, item_size,
                                                     &min_fixed_line_size,
                                                     &nat_fixed_line_size);

          /* resolve a fixed 'line_size' */
          line_size = (avail_other_size - (n_lines - 1) * line_spacing) / n_lines;

	  if (line_spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
	    line_size = MIN (line_size, nat_fixed_line_size);

          /* Get the real extra pixels incase of GTK_WRAP_BOX_SPREAD_START lines */
          extra_pixels      = avail_size       - (line_length - 1) * item_spacing - item_size * line_length;
	  extra_line_pixels = avail_other_size - (n_lines - 1)     * line_spacing - line_size * n_lines;
        }
      else /* GTK_WRAP_ALLOCATE_ALIGNED */
        {
          GList            *list;
          gboolean          first_line = TRUE;

          /* Find the amount of columns that can fit aligned into the available space
           * and collect their requests.
           */
          item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
                                                  item_spacing, &line_length, n_children);

          /* Calculate the number of lines after determining the final line_length */
          n_lines    = n_children / line_length;
          if ((n_children % line_length) > 0)
            n_lines++;
          
          n_lines = MAX (n_lines, 1);
          line_sizes = g_new0 (GtkRequestedSize, n_lines);

          /* Get the available remaining size */
          avail_size -= (line_length - 1) * item_spacing;
          for (i = 0; i < line_length; i++)
            avail_size -= item_sizes[i].minimum_size;

          /* Perform a natural allocation on the columnized items and get the remaining pixels */
          extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);

          /* Now that we have the size of each column of items find the size of each individual 
           * line based on the aligned item sizes.
           */
          for (i = 0, list = priv->children; list != NULL; i++)
            {

              list =
                get_largest_size_for_line_in_opposing_orientation (box, priv->orientation,
                                                                   list, line_length,
                                                                   item_sizes, extra_pixels,
                                                                   &line_sizes[i].minimum_size,
                                                                   &line_sizes[i].natural_size);


              /* Its possible a line is made of completely invisible children */
              if (line_sizes[i].natural_size > 0)
                {
                  if (first_line)
                    first_line = FALSE;
                  else
                    avail_other_size -= line_spacing;

                  avail_other_size -= line_sizes[i].minimum_size;

                  line_sizes[i].data = GINT_TO_POINTER (i);
                }
            }

          /* Distribute space among lines naturally */
          extra_line_pixels = gtk_distribute_natural_allocation (avail_other_size, n_lines, line_sizes);
        }

      /*********************************************************
       * Initial sizes of items/lines guessed at this point,   * 
       * go on to distribute expand space if needed.           *
       *********************************************************/

      /* FIXME: This portion needs to consider which columns
       * and rows asked for expand space and distribute those
       * accordingly for the case of ALIGNED allocation.
       *
       * If at least one child in a column/row asked for expand;
       * we should make that row/column expand entirely.
       */

      /* Calculate expand space per item */
      if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
        {
          extra_per_item = extra_pixels / MAX (line_length -1, 1);
          extra_extra    = extra_pixels % MAX (line_length -1, 1);
        }
      else if (item_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
        {
          extra_per_item = extra_pixels / line_length;
          extra_extra    = extra_pixels % line_length;
        }

      /* Calculate expand space per line */
      if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
        {
          extra_per_line   = extra_line_pixels / MAX (n_lines -1, 1);
          extra_line_extra = extra_line_pixels % MAX (n_lines -1, 1);
        }
      else if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
        {
          extra_per_line   = extra_line_pixels / n_lines;
          extra_line_extra = extra_line_pixels % n_lines;
        }

      /*********************************************************
       * Prepare item/line initial offsets and jump into the   *
       * real allocation loop.                                 *
       *********************************************************/
      line_offset = item_offset = 0;

      /* prepend extra space to item_offset/line_offset for SPREAD_END */
      if (item_spreading == GTK_WRAP_BOX_SPREAD_END)
        item_offset += extra_pixels;

      if (line_spreading == GTK_WRAP_BOX_SPREAD_END)
	line_offset += extra_line_pixels;

      /* Get the allocation size for the first line */
      if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
	this_line_size = line_size;
      else 
	{
	  this_line_size  = line_sizes[0].minimum_size;

          if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
	    {
	      this_line_size += extra_per_line;

	      if (extra_line_extra > 0)
		this_line_size++;
	    }
	}

      for (i = 0, line_count = 0, list = priv->children; list; list = list->next)
        {
          GtkWrapBoxChild *child = list->data;
          gint             position;
          gint             this_item_size;

          if (!gtk_widget_get_visible (child->widget))
            continue;

          /* Get item position */
          position = i % line_length;

          /* adjust the line_offset/count at the beginning of each new line */
          if (i > 0 && position == 0)
            {
	      /* Push the line_offset */
	      line_offset += this_line_size + line_spacing;

	      if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
		{
		  line_offset += extra_per_line;
		      
		  if (line_count < extra_line_extra)
		    line_offset++;
		}

              line_count++;

	      /* Get the new line size */
	      if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
		this_line_size = line_size;
	      else
		{
		  this_line_size = line_sizes[line_count].minimum_size;

		  if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
		    {
		      this_line_size += extra_per_line;
		      
		      if (line_count < extra_line_extra)
			this_line_size++;
		    }
		}

              item_offset = 0;

              if (item_spreading == GTK_WRAP_BOX_SPREAD_END)
                {
                  item_offset += extra_pixels;

                  /* If we're on the last line, prepend the space for
                   * any leading items */
                  if (line_count == n_lines -1)
                    {
                      gint extra_items = n_children % line_length;

                      if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
                        {
                          item_offset += item_size * (line_length - extra_items);
                          item_offset += item_spacing * (line_length - extra_items);
                        }
                      else
                        {
                          gint j;

                          for (j = 0; j < (line_length - extra_items); j++)
                            {
                              item_offset += item_sizes[j].minimum_size;
                              item_offset += item_spacing;
                            }
                        }
                    }
                }
            }

          /* Push the index along for the last line when spreading to the end */
          if (item_spreading == GTK_WRAP_BOX_SPREAD_END &&
              line_count == n_lines -1)
            {
              gint extra_items = n_children % line_length;

              position += line_length - extra_items;
            }

          if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
            this_item_size = item_size;
          else /* aligned mode */
            this_item_size = item_sizes[position].minimum_size;

          if (item_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
            {
              this_item_size += extra_per_item;

              if (position < extra_extra)
                this_item_size++;
            }

          /* Do the actual allocation */
          allocate_child (box, child, item_offset, line_offset, this_item_size, this_line_size);

          item_offset += this_item_size;
          item_offset += item_spacing;

          /* deal with extra spacing here */
          if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
            {
              item_offset += extra_per_item;

              if (position < extra_extra)
                item_offset++;
            }

          i++;
        }

      g_free (item_sizes);
      g_free (line_sizes);
    }
  else /* GTK_WRAP_ALLOCATE_FREE */
    {
      /* Here we just fit as many children as we can allocate their natural size to
       * on each line and add the heights for each of them on each line */
      GtkRequestedSize  requested; 
      GtkRequestedSize *sizes = NULL;
      GList            *list = priv->children;
      gboolean          first_line = TRUE;
      gint              i, line_count = 0;
      gint              line_offset, item_offset;
      gint              extra_per_line = 0, extra_line_extra = 0;
      gint              extra_pixels;
      GArray           *array;
  
      array = g_array_new (0, TRUE, sizeof (GtkRequestedSize));

      while (list != NULL)
        {
          GArray         *line_array;
          AllocatedLine  *line;

          list =
            get_largest_size_for_free_line_in_opposing_orientation (box, priv->orientation,
                                                                    list, min_items, avail_size,
                                                                    &requested.minimum_size,
                                                                    &requested.natural_size,
                                                                    &extra_pixels,
                                                                    &line_array);

          /* Its possible a line is made of completely invisible children */
          if (requested.natural_size > 0)
            {
              if (first_line)
                first_line = FALSE;
              else
                avail_other_size -= line_spacing;

              avail_other_size -= requested.minimum_size;

              line = g_slice_new0 (AllocatedLine);
              line->requested    = line_array;
              line->extra_pixels = extra_pixels;

              requested.data  = line;

              g_array_append_val (array, requested);
            }
        }

      /* Distribute space among lines naturally */
      sizes            = (GtkRequestedSize *)array->data;
      avail_other_size = gtk_distribute_natural_allocation (avail_other_size, array->len, sizes);

      /* Calculate expand space per line */
      if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
        {
          extra_per_line   = avail_other_size / MAX (array->len -1, 1);
          extra_line_extra = avail_other_size % MAX (array->len -1, 1);
        }
      else if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
        {
          extra_per_line   = avail_other_size / array->len;
          extra_line_extra = avail_other_size % array->len;
        }

      if (line_spreading == GTK_WRAP_BOX_SPREAD_END)
	line_offset = avail_other_size;
      else
	line_offset = 0;

      for (line_count = 0; line_count < array->len; line_count++)
        {
          AllocatedLine    *line       = (AllocatedLine *)sizes[line_count].data;
          GArray           *line_array = line->requested;
          GtkRequestedSize *line_sizes = (GtkRequestedSize *)line_array->data;
          gint              line_size  = sizes[line_count].minimum_size;
          gint              extra_per_item = 0;
          gint              extra_extra = 0;

          /* Set line start offset */
          item_offset = 0;

	  if (line_spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
	    {
	      line_size += extra_per_line;

	      if (line_count < extra_line_extra)
		line_size++;
	    }

          if (item_spreading == GTK_WRAP_BOX_SPREAD_END)
            item_offset += line->extra_pixels;
          else if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
            {
              extra_per_item = line->extra_pixels / MAX (line_array->len -1, 1);
              extra_extra    = line->extra_pixels % MAX (line_array->len -1, 1);
            }

          for (i = 0; i < line_array->len; i++)
            {
              GtkWrapBoxChild *child     = line_sizes[i].data;
              gint             item_size = line_sizes[i].minimum_size;

              /* Do the actual allocation */
              allocate_child (box, child, item_offset, line_offset, item_size, line_size);

              /* Add extra space evenly between children */
              if (item_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
                {
                  item_offset += extra_per_item;
                  if (i < extra_extra)
                    item_offset++;
                }

              /* Move item cursor along for the next allocation */
              item_offset += item_spacing;
              item_offset += item_size;
            }

          /* New line, increment offset and reset item cursor */
          line_offset += line_spacing;
          line_offset += line_size;

	  if (line_spreading == GTK_WRAP_BOX_SPREAD_EVEN)
	    {
	      line_offset += extra_per_line;

	      if (line_count < extra_line_extra)
		line_offset++;
	    }

          /* Free the array for this line now its not needed anymore */
          g_array_free (line_array, TRUE);
          g_slice_free (AllocatedLine, line);
        }

      g_array_free (array, TRUE);
    }
}

/*****************************************************
 *                GtkContainerClass                  *
 *****************************************************/
static void
gtk_wrap_box_add (GtkContainer *container,
                  GtkWidget    *widget)
{
  gtk_wrap_box_insert_child (GTK_WRAP_BOX (container), widget, -1, 0);
}

static gint
find_child_in_list (GtkWrapBoxChild *child_in_list,
                    GtkWidget       *search)
{
  return (child_in_list->widget == search) ? 0 : -1;
}

static void
gtk_wrap_box_remove (GtkContainer *container,
                     GtkWidget    *widget)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (container);
  GtkWrapBoxPrivate *priv   = box->priv;
  GList             *list;

  list = g_list_find_custom (priv->children, widget,
                             (GCompareFunc)find_child_in_list);

  if (list)
    {
      GtkWrapBoxChild *child = list->data;
      gboolean was_visible = gtk_widget_get_visible (widget);

      gtk_widget_unparent (widget);

      g_slice_free (GtkWrapBoxChild, child);
      priv->children = g_list_delete_link (priv->children, list);

      if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
        gtk_widget_queue_resize (GTK_WIDGET (container));
    }
}

static void
gtk_wrap_box_forall (GtkContainer *container,
                     gboolean      include_internals,
                     GtkCallback   callback,
                     gpointer      callback_data)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (container);
  GtkWrapBoxPrivate *priv   = box->priv;
  GtkWrapBoxChild   *child;
  GList             *list;

  for (list = priv->children; list; list = list->next)
    {
      child = list->data;

      (* callback) (child->widget, callback_data);
    }
}

static GType
gtk_wrap_box_child_type (GtkContainer   *container)
{
  return GTK_TYPE_WIDGET;
}

static void
gtk_wrap_box_set_child_property (GtkContainer    *container,
                                 GtkWidget       *widget,
                                 guint            property_id,
                                 const GValue    *value,
                                 GParamSpec      *pspec)
{
  GtkWrapBox        *box  = GTK_WRAP_BOX (container);
  GtkWrapBoxPrivate *priv = box->priv;
  GtkWrapBoxChild   *child;
  GList             *list;

  list = g_list_find_custom (priv->children, widget,
                             (GCompareFunc)find_child_in_list);
  g_return_if_fail (list != NULL);

  child = list->data;

  switch (property_id)
    {
    case CHILD_PROP_PACKING:
      child->packing = g_value_get_flags (value);
      break;
    default:
      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
      break;
    }

  if (gtk_widget_get_visible (widget) &&
      gtk_widget_get_visible (GTK_WIDGET (box)))
    gtk_widget_queue_resize (widget);
}

static void
gtk_wrap_box_get_child_property (GtkContainer    *container,
                                 GtkWidget       *widget,
                                 guint            property_id,
                                 GValue          *value,
                                 GParamSpec      *pspec)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (container);
  GtkWrapBoxPrivate *priv   = box->priv;
  GtkWrapBoxChild   *child;
  GList             *list;

  list = g_list_find_custom (priv->children, widget,
                             (GCompareFunc)find_child_in_list);
  g_return_if_fail (list != NULL);

  child = list->data;

  switch (property_id)
    {
    case CHILD_PROP_PACKING:
      g_value_set_flags (value, child->packing);
      break;
    default:
      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
      break;
    }
}

/*****************************************************
 *               GtkSizeRequestIface                 *
 *****************************************************/

static void
gtk_wrap_box_size_request_init (GtkSizeRequestIface *iface)
{
  iface->get_request_mode     = gtk_wrap_box_get_request_mode;
  iface->get_width            = gtk_wrap_box_get_width;
  iface->get_height           = gtk_wrap_box_get_height;
  iface->get_height_for_width = gtk_wrap_box_get_height_for_width;
  iface->get_width_for_height = gtk_wrap_box_get_width_for_height;
}

static GtkSizeRequestMode
gtk_wrap_box_get_request_mode (GtkSizeRequest *widget)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate *priv   = box->priv;

  return (priv->orientation == GTK_ORIENTATION_HORIZONTAL) ?
    GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH : GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;
}

/* Gets the largest minimum and natural length of
 * 'line_length' consecutive items */
static void
get_largest_line_length (GtkWrapBox      *box,
                         GtkOrientation   orientation,
                         gint             line_length,
                         gint            *min_size,
                         gint            *nat_size)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GList             *list, *l;
  gint               max_min_size = 0;
  gint               max_nat_size = 0;
  gint               spacing;

  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    spacing = priv->horizontal_spacing;
  else
    spacing = priv->vertical_spacing;

  /* Get the largest size of 'line_length' consecutive items in the list.
   */
  for (list = priv->children; list; list = list->next)
    {
      gint   line_min = 0;
      gint   line_nat = 0;
      gint   i;

      for (l = list, i = 0; l && i < line_length; l = l->next)
        {
          GtkWrapBoxChild *child = l->data;
          gint             child_min, child_nat;

          if (!gtk_widget_get_visible (child->widget))
            continue;

          if (orientation == GTK_ORIENTATION_HORIZONTAL)
            gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
                                        &child_min, &child_nat);
          else /* GTK_ORIENTATION_VERTICAL */
            gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
                                         &child_min, &child_nat);

          line_min += child_min;
          line_nat += child_nat;

          i++;
        }

      max_min_size = MAX (max_min_size, line_min);
      max_nat_size = MAX (max_nat_size, line_nat);
    }

  max_min_size += (line_length - 1) * spacing;
  max_nat_size += (line_length - 1) * spacing;

  if (min_size)
    *min_size = max_min_size;

  if (nat_size)
    *nat_size = max_nat_size;
}

/* Gets the largest minimum and natural length of
 * 'line_length' consecutive items when aligned into rows/columns */
static void
get_largest_aligned_line_length (GtkWrapBox      *box,
				 GtkOrientation   orientation,
				 gint             line_length,
				 gint            *min_size,
				 gint            *nat_size)
{
  GtkWrapBoxPrivate *priv = box->priv;
  GList             *list;
  gint               max_min_size = 0;
  gint               max_nat_size = 0;
  gint               spacing, i;
  GtkRequestedSize  *aligned_item_sizes;

  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    spacing = priv->horizontal_spacing;
  else
    spacing = priv->vertical_spacing;

  aligned_item_sizes = g_new0 (GtkRequestedSize, line_length);

  /* Get the largest sizes of each index in the line.
   */
  for (list = priv->children, i = 0; list; list = list->next)
    {
      GtkWrapBoxChild *child = list->data;
      gint             child_min, child_nat;
      
      if (!gtk_widget_get_visible (child->widget))
	continue;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
	gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
				    &child_min, &child_nat);
      else /* GTK_ORIENTATION_VERTICAL */
	gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
				     &child_min, &child_nat);

      aligned_item_sizes[i % line_length].minimum_size = 
	MAX (aligned_item_sizes[i % line_length].minimum_size, child_min);

      aligned_item_sizes[i % line_length].natural_size = 
	MAX (aligned_item_sizes[i % line_length].natural_size, child_nat);

      i++;
    }

  /* Add up the largest indexes */
  for (i = 0; i < line_length; i++)
    {
      max_min_size += aligned_item_sizes[i].minimum_size;
      max_nat_size += aligned_item_sizes[i].natural_size;
    }

  g_free (aligned_item_sizes);

  max_min_size += (line_length - 1) * spacing;
  max_nat_size += (line_length - 1) * spacing;

  if (min_size)
    *min_size = max_min_size;

  if (nat_size)
    *nat_size = max_nat_size;
}


static void
gtk_wrap_box_get_width (GtkSizeRequest      *widget,
                        gint                *minimum_size,
                        gint                *natural_size)
{
  GtkWrapBox        *box  = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate *priv = box->priv;
  gint               min_item_width, nat_item_width;
  gint               min_items, nat_items;
  gint               min_width, nat_width;

  min_items = MAX (1, priv->minimum_line_children);
  nat_items = MAX (min_items, priv->natural_line_children);

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      min_width    = nat_width = 0;

      if (priv->mode == GTK_WRAP_ALLOCATE_FREE ||
	  priv->mode == GTK_WRAP_ALLOCATE_ALIGNED)
        {
	  /* In FREE and ALIGNED modes; horizontally oriented boxes
	   * need enough width for the widest row */
          if (min_items == 1)
            {
              get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL,
                                     &min_item_width, &nat_item_width);

              min_width += min_item_width;
              nat_width += nat_item_width;
            }
          else if (priv->mode == GTK_WRAP_ALLOCATE_FREE)
            {
              gint min_line_length, nat_line_length;

              get_largest_line_length (box, GTK_ORIENTATION_HORIZONTAL, min_items,
                                       &min_line_length, &nat_line_length);

              if (nat_items > min_items)
                get_largest_line_length (box, GTK_ORIENTATION_HORIZONTAL, nat_items,
                                         NULL, &nat_line_length);

              min_width += min_line_length;
              nat_width += nat_line_length;
            }
	  else /* GTK_WRAP_MODE_ALIGNED */
	    {
              gint min_line_length, nat_line_length;

              get_largest_aligned_line_length (box, GTK_ORIENTATION_HORIZONTAL, min_items,
					       &min_line_length, &nat_line_length);

              if (nat_items > min_items)
                get_largest_aligned_line_length (box, GTK_ORIENTATION_HORIZONTAL, nat_items,
						 NULL, &nat_line_length);

              min_width += min_line_length;
              nat_width += nat_line_length;
	    }
        }
      else /* In HOMOGENEOUS mode; horizontally oriented boxs
            * give the same width to all children */
        {
          get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL,
                                 &min_item_width, &nat_item_width);

          min_width += min_item_width * min_items;
          min_width += (min_items -1) * priv->horizontal_spacing;

          nat_width += nat_item_width * nat_items;
          nat_width += (nat_items -1) * priv->horizontal_spacing;
        }
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      /* Return the width for the minimum height */
      gint min_height;

      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height (widget, &min_height, NULL);
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width_for_height (widget, min_height, &min_width, &nat_width);

    }

  if (minimum_size)
    *minimum_size = min_width;

  if (natural_size)
    *natural_size = nat_width;
}

static void
gtk_wrap_box_get_height (GtkSizeRequest      *widget,
                         gint                *minimum_size,
                         gint                *natural_size)
{
  GtkWrapBox        *box  = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate *priv = box->priv;
  gint               min_item_height, nat_item_height;
  gint               min_items, nat_items;
  gint               min_height, nat_height;

  min_items = MAX (1, priv->minimum_line_children);
  nat_items = MAX (min_items, priv->natural_line_children);

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      /* Return the height for the minimum width */
      gint min_width;

      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width (widget, &min_width, NULL);
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height_for_width (widget, min_width, &min_height, &nat_height);
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      min_height   = nat_height = 0;

      if (priv->mode == GTK_WRAP_ALLOCATE_FREE ||
	  priv->mode == GTK_WRAP_ALLOCATE_ALIGNED)
        {
	  /* In FREE and ALIGNED modes; vertically oriented boxes
	   * need enough height for the tallest column */
          if (min_items == 1)
            {
              get_average_item_size (box, GTK_ORIENTATION_VERTICAL,
                                     &min_item_height, &nat_item_height);

              min_height += min_item_height;
              nat_height += nat_item_height;
            }
          else if (priv->mode == GTK_WRAP_ALLOCATE_FREE)
            {
              gint min_line_length, nat_line_length;

              get_largest_line_length (box, GTK_ORIENTATION_VERTICAL, min_items,
                                       &min_line_length, &nat_line_length);

              if (nat_items > min_items)
                get_largest_line_length (box, GTK_ORIENTATION_VERTICAL, nat_items,
                                         NULL, &nat_line_length);

              min_height += min_line_length;
              nat_height += nat_line_length;
            }
	  else /* GTK_WRAP_ALLOCATE_ALIGNED */
	    {
              gint min_line_length, nat_line_length;

              get_largest_aligned_line_length (box, GTK_ORIENTATION_VERTICAL, min_items,
					       &min_line_length, &nat_line_length);

              if (nat_items > min_items)
                get_largest_aligned_line_length (box, GTK_ORIENTATION_VERTICAL, nat_items,
						 NULL, &nat_line_length);

              min_height += min_line_length;
              nat_height += nat_line_length;
	    }

        }
      else /* In HOMOGENEOUS mode; vertically oriented boxs
            * give the same height to all children */
        {
          get_average_item_size (box, GTK_ORIENTATION_VERTICAL,
                                 &min_item_height, &nat_item_height);

          min_height += min_item_height * min_items;
          min_height += (min_items -1) * priv->vertical_spacing;

          nat_height += nat_item_height * nat_items;
          nat_height += (nat_items -1) * priv->vertical_spacing;
        }
    }

  if (minimum_size)
    *minimum_size = min_height;

  if (natural_size)
    *natural_size = nat_height;
}

static void
gtk_wrap_box_get_height_for_width (GtkSizeRequest      *widget,
                                   gint                 width,
                                   gint                *minimum_height,
                                   gint                *natural_height)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate *priv   = box->priv;
  gint               min_item_width, nat_item_width;
  gint               min_items;
  gint               min_height, nat_height;
  gint               avail_size, n_children;

  min_items = MAX (1, priv->minimum_line_children);

  min_height = 0;
  nat_height = 0;

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      gint min_width;

      n_children = get_visible_children (box);

      /* Make sure its no smaller than the minimum */
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width (widget, &min_width, NULL);

      avail_size  = MAX (width, min_width);

      if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED ||
          priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
        {
          gint line_length;
          gint item_size, extra_pixels;

          get_average_item_size (box, GTK_ORIENTATION_HORIZONTAL, &min_item_width, &nat_item_width);

          /* By default wrap at the natural item width */
          line_length = avail_size / (nat_item_width + priv->horizontal_spacing);

          /* After the above aproximation, check if we cant fit one more on the line */
          if (line_length * priv->horizontal_spacing + (line_length + 1) * nat_item_width <= avail_size)
            line_length++;

          /* Its possible we were allocated just less than the natural width of the
           * minimum item wrap length */
          line_length = MAX (min_items, line_length);

          /* Now we need the real item allocation size */
          item_size = (avail_size - (line_length - 1) * priv->horizontal_spacing) / line_length;

          /* Cut out the expand space if we're not distributing any */
          if (priv->horizontal_spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
            {
              item_size    = MIN (item_size, nat_item_width);
              extra_pixels = 0;
            }
          else
            /* Collect the extra pixels for expand children */
            extra_pixels = (avail_size - (line_length - 1) * priv->horizontal_spacing) % line_length;

          if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
            {
              gint min_item_height, nat_item_height;
              gint lines;

              /* Here we just use the largest height-for-width and
               * add up the size accordingly */
              get_largest_size_for_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL, item_size,
                                                         &min_item_height, &nat_item_height);

              /* Round up how many lines we need to allocate for */
              lines      = n_children / line_length;
              if ((n_children % line_length) > 0)
                lines++;

              min_height = min_item_height * lines;
              nat_height = nat_item_height * lines;

              min_height += (lines - 1) * priv->vertical_spacing;
              nat_height += (lines - 1) * priv->vertical_spacing;
            }
          else /* GTK_WRAP_ALLOCATE_ALIGNED */
            {
              GList *list = priv->children;
              gint min_line_height, nat_line_height, i;
              gboolean first_line = TRUE;
              GtkRequestedSize *item_sizes;

              /* First get the size each set of items take to span the line
               * when aligning the items above and below after wrapping.
               */
              item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
                                                      priv->horizontal_spacing, &line_length, n_children);


              /* Get the available remaining size */
              avail_size -= (line_length - 1) * priv->horizontal_spacing;
              for (i = 0; i < line_length; i++)
                avail_size -= item_sizes[i].minimum_size;

              extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);

              while (list != NULL)
                {
                  list =
                    get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL,
                                                                       list, line_length,
                                                                       item_sizes, extra_pixels,
                                                                       &min_line_height, &nat_line_height);

                  /* Its possible the line only had invisible widgets */
                  if (nat_line_height > 0)
                    {
                      if (first_line)
                        first_line = FALSE;
                      else
                        {
                          min_height += priv->vertical_spacing;
                          nat_height += priv->vertical_spacing;
                        }

                      min_height += min_line_height;
                      nat_height += nat_line_height;
                    }
                }

              g_free (item_sizes);
            }
        }
      else /* GTK_WRAP_ALLOCATE_FREE */
        {
          /* Here we just fit as many children as we can allocate their natural size to
           * on each line and add the heights for each of them on each line */
          GList *list = priv->children;
          gint min_line_height = 0, nat_line_height = 0;
          gboolean first_line = TRUE;

          while (list != NULL)
            {
              list =
                get_largest_size_for_free_line_in_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL,
                                                                        list, min_items, avail_size,
                                                                        &min_line_height, &nat_line_height,
                                                                        NULL, NULL);

              /* Its possible the last line only had invisible widgets */
              if (nat_line_height > 0)
                {
                  if (first_line)
                    first_line = FALSE;
                  else
                    {
                      min_height += priv->vertical_spacing;
                      nat_height += priv->vertical_spacing;
                    }

                  min_height += min_line_height;
                  nat_height += nat_line_height;
                }
            }
        }
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      /* Return the minimum height */
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height (widget, &min_height, &nat_height);
    }

  if (minimum_height)
    *minimum_height = min_height;

  if (natural_height)
    *natural_height = nat_height;
}

static void
gtk_wrap_box_get_width_for_height (GtkSizeRequest      *widget,
                                   gint                 height,
                                   gint                *minimum_width,
                                   gint                *natural_width)
{
  GtkWrapBox        *box = GTK_WRAP_BOX (widget);
  GtkWrapBoxPrivate *priv   = box->priv;
  gint               min_item_height, nat_item_height;
  gint               min_items;
  gint               min_width, nat_width;
  gint               avail_size, n_children;

  min_items = MAX (1, priv->minimum_line_children);

  min_width = 0;
  nat_width = 0;

  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      /* Return the minimum width */
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width (widget, &min_width, &nat_width);
    }
  else /* GTK_ORIENTATION_VERTICAL */
    {
      gint min_height;

      n_children = get_visible_children (box);

      /* Make sure its no smaller than the minimum */
      GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height (widget, &min_height, NULL);

      avail_size  = MAX (height, min_height);

      if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED ||
          priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
        {
          gint line_length;
          gint item_size, extra_pixels;

          get_average_item_size (box, GTK_ORIENTATION_VERTICAL, &min_item_height, &nat_item_height);

          /* By default wrap at the natural item width */
          line_length = avail_size / (nat_item_height + priv->vertical_spacing);

          /* After the above aproximation, check if we cant fit one more on the line */
          if (line_length * priv->vertical_spacing + (line_length + 1) * nat_item_height <= avail_size)
            line_length++;

          /* Its possible we were allocated just less than the natural width of the
           * minimum item wrap length */
          line_length = MAX (min_items, line_length);

          /* Now we need the real item allocation size */
          item_size = (avail_size - (line_length - 1) * priv->vertical_spacing) / line_length;

          /* Cut out the expand space if we're not distributing any */
          if (priv->vertical_spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
            {
              item_size    = MIN (item_size, nat_item_height);
              extra_pixels = 0;
            }
          else
            /* Collect the extra pixels for expand children */
            extra_pixels = (avail_size - (line_length - 1) * priv->vertical_spacing) % line_length;

          if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
            {
              gint min_item_width, nat_item_width;
              gint lines;

              /* Here we just use the largest height-for-width and
               * add up the size accordingly */
              get_largest_size_for_opposing_orientation (box, GTK_ORIENTATION_VERTICAL, item_size,
                                                         &min_item_width, &nat_item_width);

              /* Round up how many lines we need to allocate for */
              n_children = get_visible_children (box);
              lines      = n_children / line_length;
              if ((n_children % line_length) > 0)
                lines++;

              min_width = min_item_width * lines;
              nat_width = nat_item_width * lines;

              min_width += (lines - 1) * priv->horizontal_spacing;
              nat_width += (lines - 1) * priv->horizontal_spacing;
            }
          else /* GTK_WRAP_ALLOCATE_ALIGNED */
            {
              GList *list = priv->children;
              gint min_line_width, nat_line_width, i;
              gboolean first_line = TRUE;
              GtkRequestedSize *item_sizes;

              /* First get the size each set of items take to span the line
               * when aligning the items above and below after wrapping.
               */
              item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
                                                      priv->vertical_spacing, &line_length, n_children);

              /* Get the available remaining size */
              avail_size -= (line_length - 1) * priv->horizontal_spacing;
              for (i = 0; i < line_length; i++)
                avail_size -= item_sizes[i].minimum_size;

              extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);

              while (list != NULL)
                {
                  list =
                    get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_VERTICAL,
                                                                       list, line_length,
                                                                       item_sizes, extra_pixels,
                                                                       &min_line_width, &nat_line_width);

                  /* Its possible the last line only had invisible widgets */
                  if (nat_line_width > 0)
                    {
                      if (first_line)
                        first_line = FALSE;
                      else
                        {
                          min_width += priv->horizontal_spacing;
                          nat_width += priv->horizontal_spacing;
                        }

                      min_width += min_line_width;
                      nat_width += nat_line_width;
                    }
                }
              g_free (item_sizes);
            }
        }
      else /* GTK_WRAP_ALLOCATE_FREE */
        {
          /* Here we just fit as many children as we can allocate their natural size to
           * on each line and add the heights for each of them on each line */
          GList *list = priv->children;
          gint min_line_width = 0, nat_line_width = 0;
          gboolean first_line = TRUE;

          while (list != NULL)
            {
              list =
                get_largest_size_for_free_line_in_opposing_orientation (box, GTK_ORIENTATION_VERTICAL,
                                                                        list, min_items, avail_size,
                                                                        &min_line_width, &nat_line_width,
                                                                        NULL, NULL);

              /* Its possible the last line only had invisible widgets */
              if (nat_line_width > 0)
                {
                  if (first_line)
                    first_line = FALSE;
                  else
                    {
                      min_width += priv->horizontal_spacing;
                      nat_width += priv->horizontal_spacing;
                    }

                  min_width += min_line_width;
                  nat_width += nat_line_width;
                }
            }
        }
    }

  if (minimum_width)
    *minimum_width = min_width;

  if (natural_width)
    *natural_width = nat_width;
}

/*****************************************************
 *                       API                         *
 *****************************************************/

/**
 * gtk_wrap_box_new:
 * @mode: The #GtkWrapAllocationMode to use
 * @horizontal_spreading: The horizontal #GtkWrapBoxSpreading policy to use
 * @vertical_spreading: The vertical #GtkWrapBoxSpreading policy to use
 * @horizontal_spacing: The horizontal spacing to add between children
 * @vertical_spacing: The vertical spacing to add between children
 *
 * Creates an #GtkWrapBox.
 *
 * Returns: A new #GtkWrapBox container
 */
GtkWidget *
gtk_wrap_box_new (GtkWrapAllocationMode mode,
                  GtkWrapBoxSpreading   horizontal_spreading,
                  GtkWrapBoxSpreading   vertical_spreading,
                  guint                 horizontal_spacing,
                  guint                 vertical_spacing)
{
  return (GtkWidget *)g_object_new (GTK_TYPE_WRAP_BOX,
                                    "allocation-mode", mode,
                                    "horizontal-spreading", horizontal_spreading,
                                    "vertical-spreading", vertical_spreading,
                                    "vertical-spacing", vertical_spacing,
                                    "horizontal-spacing", horizontal_spacing,
                                    NULL);
}

/**
 * gtk_wrap_box_set_allocation_mode:
 * @box: An #GtkWrapBox
 * @mode: The #GtkWrapAllocationMode to use.
 *
 * Sets the allocation mode for @box's children.
 */
void
gtk_wrap_box_set_allocation_mode (GtkWrapBox           *box,
                                  GtkWrapAllocationMode mode)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->mode != mode)
    {
      priv->mode = mode;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "allocation-mode");
    }
}

/**
 * gtk_wrap_box_get_allocation_mode:
 * @box: An #GtkWrapBox
 *
 * Gets the allocation mode.
 *
 * Returns: The #GtkWrapAllocationMode for @box.
 */
GtkWrapAllocationMode
gtk_wrap_box_get_allocation_mode (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->mode;
}


/**
 * gtk_wrap_box_set_horizontal_spreading:
 * @box: An #GtkWrapBox
 * @spreading: The #GtkWrapBoxSpreading to use.
 *
 * Sets the horizontal spreading mode for @box's children.
 */
void
gtk_wrap_box_set_horizontal_spreading (GtkWrapBox          *box,
				       GtkWrapBoxSpreading  spreading)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->horizontal_spreading != spreading)
    {
      priv->horizontal_spreading = spreading;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "horizontal-spreading");
    }
}

/**
 * gtk_wrap_box_get_horizontal_spreading:
 * @box: An #GtkWrapBox
 *
 * Gets the horizontal spreading mode.
 *
 * Returns: The horizontal #GtkWrapBoxSpreading for @box.
 */
GtkWrapBoxSpreading
gtk_wrap_box_get_horizontal_spreading (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->horizontal_spreading;
}


/**
 * gtk_wrap_box_set_vertical_spreading:
 * @box: An #GtkWrapBox
 * @spreading: The #GtkWrapBoxSpreading to use.
 *
 * Sets the vertical spreading mode for @box's children.
 */
void
gtk_wrap_box_set_vertical_spreading (GtkWrapBox          *box,
				     GtkWrapBoxSpreading  spreading)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->vertical_spreading != spreading)
    {
      priv->vertical_spreading = spreading;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "vertical-spreading");
    }
}

/**
 * gtk_wrap_box_get_vertical_spreading:
 * @box: An #GtkWrapBox
 *
 * Gets the vertical spreading mode.
 *
 * Returns: The vertical #GtkWrapBoxSpreading for @box.
 */
GtkWrapBoxSpreading
gtk_wrap_box_get_vertical_spreading (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->vertical_spreading;
}


/**
 * gtk_wrap_box_set_vertical_spacing:
 * @box: An #GtkWrapBox
 * @spacing: The spacing to use.
 *
 * Sets the vertical space to add between children.
 */
void
gtk_wrap_box_set_vertical_spacing  (GtkWrapBox    *box,
                                    guint          spacing)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->vertical_spacing != spacing)
    {
      priv->vertical_spacing = spacing;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "vertical-spacing");
    }
}

/**
 * gtk_wrap_box_get_vertical_spacing:
 * @box: An #GtkWrapBox
 *
 * Gets the vertical spacing.
 *
 * Returns: The vertical spacing.
 */
guint
gtk_wrap_box_get_vertical_spacing  (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->vertical_spacing;
}

/**
 * gtk_wrap_box_set_horizontal_spacing:
 * @box: An #GtkWrapBox
 * @spacing: The spacing to use.
 *
 * Sets the horizontal space to add between children.
 */
void
gtk_wrap_box_set_horizontal_spacing (GtkWrapBox    *box,
                                     guint          spacing)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->horizontal_spacing != spacing)
    {
      priv->horizontal_spacing = spacing;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "horizontal-spacing");
    }
}

/**
 * gtk_wrap_box_get_horizontal_spacing:
 * @box: An #GtkWrapBox
 *
 * Gets the horizontal spacing.
 *
 * Returns: The horizontal spacing.
 */
guint
gtk_wrap_box_get_horizontal_spacing (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->horizontal_spacing;
}

/**
 * gtk_wrap_box_set_minimum_line_children:
 * @box: An #GtkWrapBox
 * @n_children: The minimum amount of children per line.
 *
 * Sets the minimum amount of children to line up
 * in @box's orientation before wrapping.
 */
void
gtk_wrap_box_set_minimum_line_children (GtkWrapBox *box,
                                        guint       n_children)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->minimum_line_children != n_children)
    {
      priv->minimum_line_children = n_children;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "minimum-line-children");
    }
}

/**
 * gtk_wrap_box_get_minimum_line_children:
 * @box: An #GtkWrapBox
 *
 * Gets the minimum amount of children per line.
 *
 * Returns: The minimum amount of children per line.
 */
guint
gtk_wrap_box_get_minimum_line_children (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->minimum_line_children;
}

/**
 * gtk_wrap_box_set_natural_line_children:
 * @box: An #GtkWrapBox
 * @n_children: The natural amount of children per line.
 *
 * Sets the natural length of items to request and
 * allocate space for in @box's orientation.
 *
 * Setting the natural amount of children per line
 * limits the overall natural size request to be no more
 * than @n_children items long in the given orientation.
 */
void
gtk_wrap_box_set_natural_line_children (GtkWrapBox *box,
                                        guint       n_children)
{
  GtkWrapBoxPrivate *priv;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));

  priv = box->priv;

  if (priv->natural_line_children != n_children)
    {
      priv->natural_line_children = n_children;

      gtk_widget_queue_resize (GTK_WIDGET (box));

      g_object_notify (G_OBJECT (box), "natural-line-children");
    }
}

/**
 * gtk_wrap_box_get_natural_line_children:
 * @box: An #GtkWrapBox
 *
 * Gets the natural amount of children per line.
 *
 * Returns: The natural amount of children per line.
 */
guint
gtk_wrap_box_get_natural_line_children (GtkWrapBox *box)
{
  g_return_val_if_fail (GTK_IS_WRAP_BOX (box), FALSE);

  return box->priv->natural_line_children;
}


/**
 * gtk_wrap_box_insert_child:
 * @box: And #GtkWrapBox
 * @widget: the child #GtkWidget to add
 * @index: the position in the child list to insert, specify -1 to append to the list.
 * @packing: The #GtkWrapBoxPacking options to use.
 *
 * Adds a child to an #GtkWrapBox with its packing options set
 *
 */
void
gtk_wrap_box_insert_child (GtkWrapBox        *box,
                           GtkWidget         *widget,
                           gint               index,
                           GtkWrapBoxPacking  packing)
{
  GtkWrapBoxPrivate *priv;
  GtkWrapBoxChild   *child;
  GList             *list;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));
  g_return_if_fail (GTK_IS_WIDGET (widget));

  priv = box->priv;

  list = g_list_find_custom (priv->children, widget,
                             (GCompareFunc)find_child_in_list);
  g_return_if_fail (list == NULL);

  child           = g_slice_new0 (GtkWrapBoxChild);
  child->widget   = widget;
  child->packing  = packing;

  priv->children = g_list_insert (priv->children, child, index);

  gtk_widget_set_parent (widget, GTK_WIDGET (box));
}

/**
 * gtk_wrap_box_reorder_child:
 * @box: An #GtkWrapBox
 * @widget: The child to reorder
 * @index: The new child position
 *
 * Reorders the child @widget in @box's list of children.
 */
void
gtk_wrap_box_reorder_child (GtkWrapBox *box,
                            GtkWidget  *widget,
                            guint       index)
{
  GtkWrapBoxPrivate *priv;
  GtkWrapBoxChild   *child;
  GList             *list;

  g_return_if_fail (GTK_IS_WRAP_BOX (box));
  g_return_if_fail (GTK_IS_WIDGET (widget));

  priv = box->priv;

  list = g_list_find_custom (priv->children, widget,
                             (GCompareFunc)find_child_in_list);
  g_return_if_fail (list != NULL);

  if (g_list_position (priv->children, list) != index)
    {
      child = list->data;
      priv->children = g_list_delete_link (priv->children, list);
      priv->children = g_list_insert (priv->children, child, index);

      gtk_widget_queue_resize (GTK_WIDGET (box));
    }
}