+++ /dev/null
-/* 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 positions child widgets in sequence according to its
- * orientation. For instance, with the horizontal orientation, the widgets
- * will be arranged from left to right, starting a new row under the
- * previous row when necessary. Reducing the width in this case will
- * require more rows, so a larger height will be requested.
- *
- * Likewise, with the vertical orientation, the widgets will be arranged
- * from top to bottom, starting a new column to the right when necessary.
- * Reducing the height will require more columns, so a larger width will be
- * requested.
- *
- * Unlike a GtkTable, the child widgets do not need to align in a grid.
- */
-
-#include "config.h"
-#include "gtksizerequest.h"
-#include "gtkorientable.h"
-#include "gtkwrapbox.h"
-#include "gtkprivate.h"
-#include "gtkintl.h"
-#include "gtktypeutils.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);
-
-
-/* GtkWidget */
-static GtkSizeRequestMode gtk_wrap_box_get_request_mode (GtkWidget *widget);
-static void gtk_wrap_box_get_preferred_width (GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_wrap_box_get_preferred_height (GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_wrap_box_get_preferred_height_for_width (GtkWidget *box,
- gint width,
- gint *minimum_height,
- gint *natural_height);
-static void gtk_wrap_box_get_preferred_width_for_height (GtkWidget *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_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;
- widget_class->get_request_mode = gtk_wrap_box_get_request_mode;
- widget_class->get_preferred_width = gtk_wrap_box_get_preferred_width;
- widget_class->get_preferred_height = gtk_wrap_box_get_preferred_height;
- widget_class->get_preferred_height_for_width = gtk_wrap_box_get_preferred_height_for_width;
- widget_class->get_preferred_width_for_height = gtk_wrap_box_get_preferred_width_for_height;
-
- 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_widget_get_preferred_width (child->widget, &child_min, &child_nat);
- else
- gtk_widget_get_preferred_height (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_widget_get_preferred_height_for_width (child->widget,
- item_size,
- &child_min, &child_nat);
- else
- gtk_widget_get_preferred_width_for_height (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_widget_get_preferred_height_for_width (child->widget,
- this_item_size,
- &child_min, &child_nat);
- else
- gtk_widget_get_preferred_width_for_height (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_widget_get_preferred_width (child->widget, NULL, &child_size);
- else
- gtk_widget_get_preferred_height (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_widget_get_preferred_width (child->widget,
- &requested.minimum_size,
- &requested.natural_size);
- else
- gtk_widget_get_preferred_height (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_widget_get_preferred_height_for_width (child->widget,
- sizes[i].minimum_size,
- &child_min, &child_nat);
- else
- gtk_widget_get_preferred_width_for_height (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_widget_get_preferred_width (child->widget,
- &child_min, &child_nat);
- else
- gtk_widget_get_preferred_height (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;
- }
-}
-
-/*****************************************************
- * size requests *
- *****************************************************/
-
-
-static GtkSizeRequestMode
-gtk_wrap_box_get_request_mode (GtkWidget *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_widget_get_preferred_width (child->widget,
- &child_min, &child_nat);
- else /* GTK_ORIENTATION_VERTICAL */
- gtk_widget_get_preferred_height (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_widget_get_preferred_width (child->widget,
- &child_min, &child_nat);
- else /* GTK_ORIENTATION_VERTICAL */
- gtk_widget_get_preferred_height (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_preferred_width (GtkWidget *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_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, NULL);
- GTK_WIDGET_GET_CLASS (widget)->get_preferred_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_preferred_height (GtkWidget *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_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
- GTK_WIDGET_GET_CLASS (widget)->get_preferred_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_preferred_height_for_width (GtkWidget *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_WIDGET_GET_CLASS (widget)->get_preferred_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_WIDGET_GET_CLASS (widget)->get_preferred_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_preferred_width_for_height (GtkWidget *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_WIDGET_GET_CLASS (widget)->get_preferred_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_WIDGET_GET_CLASS (widget)->get_preferred_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));
- }
-}
+++ /dev/null
-/* testwrapbox.c
- * Copyright (C) 2010 Openismus GmbH
- *
- * Author:
- * 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.
- */
-
-#include <gtk/gtk.h>
-
-enum {
- SIMPLE_ITEMS = 0,
- WRAPPY_ITEMS,
- STOCK_ITEMS
-};
-
-#define INITIAL_ALLOCATION_MODE GTK_WRAP_ALLOCATE_HOMOGENEOUS
-#define INITIAL_SPREADING GTK_WRAP_BOX_SPREAD_START
-#define INITIAL_MINIMUM_LENGTH 3
-#define INITIAL_HSPACING 2
-#define INITIAL_VSPACING 2
-
-static GtkWrapBox *the_wrapbox = NULL;
-static gint items_type = SIMPLE_ITEMS;
-static GtkOrientation text_orientation = GTK_ORIENTATION_HORIZONTAL;
-static gboolean items_xexpand = TRUE;
-static gboolean items_yexpand = TRUE;
-
-
-static void
-populate_wrapbox_simple (GtkWrapBox *wrapbox)
-{
- GtkWidget *widget, *frame;
- gint i;
-
- for (i = 0; i < 30; i++)
- {
- gchar *text = g_strdup_printf ("Item %02d", i);
-
- widget = gtk_label_new (text);
- frame = gtk_frame_new (NULL);
- gtk_widget_show (widget);
- gtk_widget_show (frame);
-
- gtk_container_add (GTK_CONTAINER (frame), widget);
-
- if (text_orientation == GTK_ORIENTATION_VERTICAL)
- gtk_label_set_angle (GTK_LABEL (widget), 90);
-
- gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), frame, -1,
- (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
- (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0));
-
- g_free (text);
- }
-}
-
-static void
-populate_wrapbox_wrappy (GtkWrapBox *wrapbox)
-{
- GtkWidget *widget, *frame;
- gint i;
-
- const gchar *strings[] = {
- "These are", "some wrappy label", "texts", "of various", "lengths.",
- "They should always be", "shown", "consecutively. Except it's",
- "hard to say", "where exactly the", "label", "will wrap", "and where exactly",
- "the actual", "container", "will wrap.", "This label is really really really long !",
- "Let's add some more", "labels to the",
- "mix. Just to", "make sure we", "got something to work", "with here."
- };
-
- for (i = 0; i < G_N_ELEMENTS (strings); i++)
- {
- widget = gtk_label_new (strings[i]);
- frame = gtk_frame_new (NULL);
- gtk_widget_show (widget);
- gtk_widget_show (frame);
-
- if (text_orientation == GTK_ORIENTATION_VERTICAL)
- gtk_label_set_angle (GTK_LABEL (widget), 90);
-
- gtk_container_add (GTK_CONTAINER (frame), widget);
-
- gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
- gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
- gtk_label_set_width_chars (GTK_LABEL (widget), 10);
-
- gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), frame, -1,
- (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
- (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0));
- }
-}
-
-
-static void
-populate_wrapbox_stock (GtkWrapBox *wrapbox)
-{
- GtkWidget *widget;
- static GSList *stock_ids = NULL;
- GSList *l;
- gint i;
-
- if (!stock_ids)
- stock_ids = gtk_stock_list_ids ();
-
- for (i = 0, l = stock_ids; i < 30 && l != NULL; i++, l = l->next)
- {
- gchar *stock_id = l->data;
-
- widget = gtk_button_new_from_stock (stock_id);
- gtk_widget_show (widget);
-
- gtk_wrap_box_insert_child (GTK_WRAP_BOX (wrapbox), widget, -1,
- (items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
- (items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0));
- }
-}
-
-static void
-populate_items (GtkWrapBox *wrapbox)
-{
- GList *children, *l;
-
- /* Remove all children first */
- children = gtk_container_get_children (GTK_CONTAINER (wrapbox));
- for (l = children; l; l = l->next)
- {
- GtkWidget *child = l->data;
-
- gtk_container_remove (GTK_CONTAINER (wrapbox), child);
- }
- g_list_free (children);
-
- if (items_type == SIMPLE_ITEMS)
- populate_wrapbox_simple (wrapbox);
- else if (items_type == WRAPPY_ITEMS)
- populate_wrapbox_wrappy (wrapbox);
- else if (items_type == STOCK_ITEMS)
- populate_wrapbox_stock (wrapbox);
-}
-
-
-static void
-mode_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- GtkWrapAllocationMode mode = gtk_combo_box_get_active (box);
-
- gtk_wrap_box_set_allocation_mode (wrapbox, mode);
-}
-
-static void
-horizontal_spreading_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- GtkWrapBoxSpreading spreading = gtk_combo_box_get_active (box);
-
- gtk_wrap_box_set_horizontal_spreading (wrapbox, spreading);
-}
-
-static void
-vertical_spreading_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- GtkWrapBoxSpreading spreading = gtk_combo_box_get_active (box);
-
- gtk_wrap_box_set_vertical_spreading (wrapbox, spreading);
-}
-
-static void
-orientation_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- GtkOrientation orientation = gtk_combo_box_get_active (box);
-
- gtk_orientable_set_orientation (GTK_ORIENTABLE (wrapbox), orientation);
-}
-
-static void
-line_length_changed (GtkSpinButton *spin,
- GtkWrapBox *wrapbox)
-{
- gint length = gtk_spin_button_get_value_as_int (spin);
-
- gtk_wrap_box_set_minimum_line_children (wrapbox, length);
-}
-
-static void
-spacing_changed (GtkSpinButton *button,
- gpointer data)
-{
- GtkOrientation orientation = GPOINTER_TO_INT (data);
- gint state = gtk_spin_button_get_value_as_int (button);
-
- if (orientation == GTK_ORIENTATION_HORIZONTAL)
- gtk_wrap_box_set_horizontal_spacing (the_wrapbox, state);
- else
- gtk_wrap_box_set_vertical_spacing (the_wrapbox, state);
-}
-
-
-static void
-items_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- items_type = gtk_combo_box_get_active (box);
-
- populate_items (wrapbox);
-}
-
-static void
-text_orientation_changed (GtkComboBox *box,
- GtkWrapBox *wrapbox)
-{
- text_orientation = gtk_combo_box_get_active (box);
-
- populate_items (wrapbox);
-}
-
-static void
-child_option_toggled (GtkToggleButton *button,
- gboolean *state)
-{
- *state = gtk_toggle_button_get_active (button);
-
- populate_items (the_wrapbox);
-}
-
-static GtkWidget *
-create_window (void)
-{
- GtkWidget *window, *hbox, *vbox, *frame, *wrapbox_cntl, *items_cntl;
- GtkWidget *wrapbox, *widget, *expander, *swindow;
-
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- hbox = gtk_hbox_new (FALSE, 2);
- vbox = gtk_vbox_new (FALSE, 6);
-
- gtk_container_set_border_width (GTK_CONTAINER (window), 8);
-
- gtk_widget_show (vbox);
- gtk_widget_show (hbox);
- gtk_container_add (GTK_CONTAINER (window), hbox);
- gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
-
- frame = gtk_frame_new ("Wrap Box");
- gtk_widget_show (frame);
- gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
-
- swindow = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-
- gtk_widget_show (swindow);
- gtk_container_add (GTK_CONTAINER (frame), swindow);
-
- wrapbox = gtk_wrap_box_new (INITIAL_ALLOCATION_MODE, INITIAL_SPREADING,
- INITIAL_SPREADING, INITIAL_HSPACING, INITIAL_VSPACING);
- the_wrapbox = (GtkWrapBox *)wrapbox;
- gtk_wrap_box_set_minimum_line_children (GTK_WRAP_BOX (wrapbox), INITIAL_MINIMUM_LENGTH);
- gtk_widget_show (wrapbox);
- gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), wrapbox);
-
- /* Add Wrapbox test control frame */
- expander = gtk_expander_new ("Wrap Box controls");
- gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
- wrapbox_cntl = gtk_vbox_new (FALSE, 2);
- gtk_widget_show (wrapbox_cntl);
- gtk_widget_show (expander);
- gtk_container_add (GTK_CONTAINER (expander), wrapbox_cntl);
- gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
-
- /* Add Allocation mode control */
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Wrap Freely");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Align items");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Homogeneous");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_ALLOCATION_MODE);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the wrapbox allocation mode");
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (mode_changed), wrapbox);
-
- /* Add Spreading controls */
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Start");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread End");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Even");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Expand");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_SPREADING);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the horizontal spreading mode");
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (horizontal_spreading_changed), wrapbox);
-
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Start");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread End");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Even");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Spread Expand");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_SPREADING);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the vertical spreading mode");
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (vertical_spreading_changed), wrapbox);
-
- /* Add Orientation control */
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Horizontal");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Vertical");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the wrapbox orientation");
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (orientation_changed), wrapbox);
-
- /* Add minimum line length in items control */
- widget = gtk_spin_button_new_with_range (1, 10, 1);
- gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (line_length_changed), wrapbox);
- g_signal_connect (G_OBJECT (widget), "value-changed",
- G_CALLBACK (line_length_changed), wrapbox);
-
- /* Add horizontal/vertical spacing controls */
- hbox = gtk_hbox_new (FALSE, 2);
- gtk_widget_show (hbox);
-
- widget = gtk_label_new ("H Spacing");
- gtk_widget_show (widget);
- gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
-
- widget = gtk_spin_button_new_with_range (0, 30, 1);
- gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_HSPACING);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
- gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
- g_signal_connect (G_OBJECT (widget), "value-changed",
- G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
-
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 2);
- gtk_widget_show (hbox);
-
- widget = gtk_label_new ("V Spacing");
- gtk_widget_show (widget);
- gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
-
- widget = gtk_spin_button_new_with_range (0, 30, 1);
- gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_VSPACING);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
- gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
- g_signal_connect (G_OBJECT (widget), "value-changed",
- G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
-
- gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0);
-
-
- /* Add test items control frame */
- expander = gtk_expander_new ("Test item controls");
- gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
- items_cntl = gtk_vbox_new (FALSE, 2);
- gtk_widget_show (items_cntl);
- gtk_widget_show (expander);
- gtk_container_add (GTK_CONTAINER (expander), items_cntl);
- gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
-
- /* Add Items control */
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Simple");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Wrappy");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Stock");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the item set to use");
- gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (items_changed), wrapbox);
-
-
- /* Add Text Orientation control */
- widget = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Horizontal");
- gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Vertical");
- gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)");
- gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "changed",
- G_CALLBACK (text_orientation_changed), wrapbox);
-
-
- /* Add expand options */
- hbox = gtk_hbox_new (FALSE, 2);
- gtk_widget_show (hbox);
-
- widget = gtk_check_button_new_with_label ("X Expand");
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set whether the items expand horizontally");
- gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "toggled",
- G_CALLBACK (child_option_toggled), &items_xexpand);
-
-
- widget = gtk_check_button_new_with_label ("Y Expand");
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
- gtk_widget_show (widget);
-
- gtk_widget_set_tooltip_text (widget, "Set whether the items expand vertically");
- gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
-
- g_signal_connect (G_OBJECT (widget), "toggled",
- G_CALLBACK (child_option_toggled), &items_yexpand);
-
- gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0);
-
- populate_items (GTK_WRAP_BOX (wrapbox));
-
- /* This line was added only for the convenience of reproducing
- * a height-for-width inside GtkScrolledWindow bug (bug 629778).
- * -Tristan
- */
- gtk_window_set_default_size (GTK_WINDOW (window), 390, -1);
-
- return window;
-}
-
-
-
-int
-main (int argc, char *argv[])
-{
- GtkWidget *window;
-
- gtk_init (&argc, &argv);
-
- window = create_window ();
-
- g_signal_connect (window, "delete-event",
- G_CALLBACK (gtk_main_quit), window);
-
- gtk_widget_show (window);
-
- gtk_main ();
-
- return 0;
-}
projects / ~andy / gtk / commitdiff