AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Remove padding from GtkWrapBox

Browse Source 
GtkWidget margins make this unnecessary in new containers.
This commit is contained in:
Matthias Clasen 2010-09-13 18:21:21 -04:00
parent 8204fe6036
commit 0e484a83d1
4 changed files with 234 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gtk/gtk.symbols
View File

@ -4494,7 +4494,7 @@ gtk_wrap_box_get_natural_line_children
gtk_wrap_box_get_spreading
gtk_wrap_box_get_type G_GNUC_CONST
gtk_wrap_box_get_vertical_spacing
gtk_wrap_box_insert_child_with_padding
gtk_wrap_box_insert_child
gtk_wrap_box_new
gtk_wrap_box_packing_get_type
gtk_wrap_box_reorder_child

502
gtk/gtkwrapbox.c
View File

@ -55,9 +55,7 @@ enum {
enum
{
CHILD_PROP_0,
CHILD_PROP_PACKING,
CHILD_PROP_HORIZONTAL_PADDING,
CHILD_PROP_VERTICAL_PADDING
CHILD_PROP_PACKING
};
struct _GtkWrapBoxPrivate
@ -79,8 +77,6 @@ struct _GtkWrapBoxChild
{
GtkWidget *widget;
guint16 hpadding;
guint16 vpadding;
GtkWrapBoxPacking packing;
};
@ -280,40 +276,7 @@ gtk_wrap_box_class_init (GtkWrapBoxClass *class)
("packing",
P_("Packing"),
P_("The packing options to use for this child"),
GTK_TYPE_WRAP_BOX_PACKING, 0,
GTK_PARAM_READWRITE));
/**
* GtkWrapBox:horizontal-padding:
*
* Extra space to put between the child and its left and right neighbors, in pixels.
*
*/
gtk_container_class_install_child_property (container_class,
CHILD_PROP_HORIZONTAL_PADDING,
g_param_spec_uint
("horizontal-padding",
P_("Horizontal padding"),
P_("Extra space to put between the child and "
"its left and right neighbors, in pixels"),
0, 65535, 0,
GTK_PARAM_READWRITE));
/**
* GtkWrapBox:vertical-padding:
*
* Extra space to put between the child and its upper and lower neighbors, in pixels.
*
*/
gtk_container_class_install_child_property (container_class,
CHILD_PROP_VERTICAL_PADDING,
g_param_spec_uint
("vertical-padding",
P_("Vertical padding"),
P_("Extra space to put between the child and "
"its upper and lower neighbors, in pixels"),
0, 65535, 0,
GTK_TYPE_WRAP_BOX_PACKING, 0,
GTK_PARAM_READWRITE));
g_type_class_add_private (class, sizeof (GtkWrapBoxPrivate));
@ -492,21 +455,12 @@ get_average_item_size (GtkWrapBox *box,
continue;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
&child_min, &child_nat);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
&child_min, &child_nat);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
max_min_size = MAX (max_min_size, child_min);
max_nat_size = MAX (max_nat_size, child_nat);
}
@ -542,21 +496,13 @@ get_largest_size_for_opposing_orientation (GtkWrapBox *box,
continue;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child->widget),
item_size - child->hpadding * 2,
&child_min, &child_nat);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
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->vpadding * 2,
&child_min, &child_nat);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
@ -608,21 +554,13 @@ get_largest_size_for_line_in_opposing_orientation (GtkWrapBox *box,
}
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child->widget),
this_item_size - child->hpadding * 2,
&child_min, &child_nat);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
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->vpadding * 2,
&child_min, &child_nat);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
@ -682,17 +620,11 @@ get_largest_size_for_free_line_in_opposing_orientation (GtkWrapBox *box,
continue;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
NULL, &child_size);
child_size += child->hpadding * 2;
}
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);
child_size += child->vpadding * 2;
}
gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
NULL, &child_size);
if (i > 0)
child_size += spacing;
@ -721,21 +653,13 @@ get_largest_size_for_free_line_in_opposing_orientation (GtkWrapBox *box,
requested.data = child;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
&requested.minimum_size,
&requested.natural_size);
size -= child->hpadding * 2;
}
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);
size -= child->vpadding * 2;
}
gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
&requested.minimum_size,
&requested.natural_size);
if (i > 0)
size -= spacing;
@ -798,21 +722,13 @@ get_largest_size_for_free_line_in_opposing_orientation (GtkWrapBox *box,
}
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);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
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);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
@ -852,17 +768,17 @@ allocate_child (GtkWrapBox *box,
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
child_allocation.x = widget_allocation.x + item_offset + child->hpadding;
child_allocation.y = widget_allocation.y + line_offset + child->vpadding;
child_allocation.width = item_size - child->hpadding * 2;
child_allocation.height = line_size - child->vpadding * 2;
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->hpadding;
child_allocation.y = widget_allocation.y + item_offset + child->vpadding;
child_allocation.width = line_size - child->hpadding * 2;
child_allocation.height = item_size - child->vpadding * 2;
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;
}
request_mode = gtk_size_request_get_request_mode (GTK_SIZE_REQUEST (child->widget));
@ -912,11 +828,11 @@ allocate_child (GtkWrapBox *box,
/* 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)
GtkOrientation orientation,
gint line_length,
gint item_spacing,
gint n_children,
GtkRequestedSize *item_sizes)
{
GtkWrapBoxPrivate *priv = box->priv;
GList *list;
@ -935,26 +851,17 @@ gather_aligned_item_requests (GtkWrapBox *box,
continue;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
&child_min, &child_nat);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
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 (priv->spreading == GTK_WRAP_BOX_SPREAD_END && i >= n_children - extra_items)
position += line_length - 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);
@ -971,11 +878,11 @@ gather_aligned_item_requests (GtkWrapBox *box,
static GtkRequestedSize *
fit_aligned_item_requests (GtkWrapBox *box,
GtkOrientation orientation,
gint avail_size,
gint item_spacing,
gint *line_length, /* in-out */
gint n_children)
GtkOrientation orientation,
gint avail_size,
gint item_spacing,
gint *line_length, /* in-out */
gint n_children)
{
GtkRequestedSize *sizes, *try_sizes;
gint natural_line_size, try_line_size, try_length;
@ -992,23 +899,23 @@ fit_aligned_item_requests (GtkWrapBox *box,
{
try_sizes = g_new0 (GtkRequestedSize, try_length);
try_line_size = gather_aligned_item_requests (box, orientation, try_length, item_spacing,
n_children, try_sizes);
n_children, try_sizes);
if (try_line_size < avail_size)
{
natural_line_size = try_line_size;
*line_length = try_length;
{
natural_line_size = try_line_size;
*line_length = try_length;
g_free (sizes);
sizes = try_sizes;
}
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;
}
{
/* oops, this one failed; stick to the last size that fit and then return */
g_free (try_sizes);
break;
}
}
return sizes;
@ -1084,19 +991,19 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
* 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);
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 (priv->spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
item_size = MIN (item_size, nat_item_size);
/* 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 (priv->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);
@ -1105,39 +1012,39 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
line_size = (avail_other_size - (n_lines - 1) * line_spacing) / n_lines;
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;
/* 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;
}
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);
/* 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);
/* 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;
/* 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 */
/* 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.
*/
/* 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++)
{
@ -1169,21 +1076,21 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
/* Calculate expand space per item (used diferently depending on spreading mode) */
if (priv->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);
}
{
extra_per_item = extra_pixels / MAX (line_length -1, 1);
extra_extra = extra_pixels % MAX (line_length -1, 1);
}
else if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
{
extra_per_item = extra_pixels / line_length;
extra_extra = extra_pixels % line_length;
}
{
extra_per_item = extra_pixels / line_length;
extra_extra = extra_pixels % line_length;
}
line_offset = item_offset = border_width;
/* prepend extra space to item_offset for SPREAD_END */
if (priv->spreading == GTK_WRAP_BOX_SPREAD_END)
item_offset += extra_pixels;
item_offset += extra_pixels;
for (i = 0, line_count = 0, list = priv->children; list; list = list->next)
{
@ -1207,35 +1114,35 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
line_count++;
item_offset = border_width;
item_offset = border_width;
if (priv->spreading == GTK_WRAP_BOX_SPREAD_END)
{
item_offset += extra_pixels;
if (priv->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 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;
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;
}
}
}
}
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 */
@ -1247,20 +1154,20 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
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 (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
this_item_size = item_size;
else /* aligned mode */
this_item_size = item_sizes[position].minimum_size;
if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
{
this_item_size += extra_per_item;
if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
{
this_item_size += extra_per_item;
/* We could be smarter here and distribute the extra pixels more
* evenly across the children */
if (position < extra_extra)
this_item_size++;
}
/* We could be smarter here and distribute the extra pixels more
* evenly across the children */
if (position < extra_extra)
this_item_size++;
}
/* Get the allocation size for this line */
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
@ -1272,15 +1179,15 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
allocate_child (box, child, item_offset, line_offset, this_item_size, this_line_size);
item_offset += this_item_size;
item_offset += item_spacing;
item_offset += item_spacing;
/* deal with extra spacing here */
/* deal with extra spacing here */
if (priv->spreading == GTK_WRAP_BOX_SPREAD_EVEN)
{
item_offset += extra_per_item;
if (position < extra_extra)
item_offset++;
if (position < extra_extra)
item_offset++;
}
i++;
@ -1367,9 +1274,6 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
GtkWrapBoxChild *child = line_sizes[i].data;
gint item_size = line_sizes[i].minimum_size;
item_size += (priv->orientation == GTK_ORIENTATION_HORIZONTAL) ?
child->hpadding * 2 : child->vpadding * 2;
/* Do the actual allocation */
allocate_child (box, child, item_offset, line_offset, item_size, line_size);
@ -1404,9 +1308,9 @@ gtk_wrap_box_size_allocate (GtkWidget *widget,
*****************************************************/
static void
gtk_wrap_box_add (GtkContainer *container,
GtkWidget *widget)
GtkWidget *widget)
{
gtk_wrap_box_insert_child_with_padding (GTK_WRAP_BOX (container), widget, -1, 0, 0, 0);
gtk_wrap_box_insert_child (GTK_WRAP_BOX (container), widget, -1, 0);
}
static gint
@ -1490,12 +1394,6 @@ gtk_wrap_box_set_child_property (GtkContainer *container,
case CHILD_PROP_PACKING:
child->packing = g_value_get_flags (value);
break;
case CHILD_PROP_HORIZONTAL_PADDING:
child->hpadding = g_value_get_uint (value);
break;
case CHILD_PROP_VERTICAL_PADDING:
child->vpadding = g_value_get_uint (value);
break;
default:
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
break;
@ -1529,12 +1427,6 @@ gtk_wrap_box_get_child_property (GtkContainer *container,
case CHILD_PROP_PACKING:
g_value_set_flags (value, child->packing);
break;
case CHILD_PROP_HORIZONTAL_PADDING:
g_value_set_uint (value, child->hpadding);
break;
case CHILD_PROP_VERTICAL_PADDING:
g_value_set_uint (value, child->vpadding);
break;
default:
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
break;
@ -1603,21 +1495,11 @@ get_largest_line_length (GtkWrapBox *box,
continue;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
&child_min, &child_nat);
child_min += child->hpadding * 2;
child_nat += child->hpadding * 2;
}
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);
child_min += child->vpadding * 2;
child_nat += child->vpadding * 2;
}
gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
&child_min, &child_nat);
if (i > 0)
{
@ -1883,21 +1765,21 @@ gtk_wrap_box_get_height_for_width (GtkSizeRequest *widget,
GList *list = priv->children;
gint min_line_height, nat_line_height, i;
gboolean first_line = TRUE;
GtkRequestedSize *item_sizes;
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);
/* 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;
/* 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);
extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
while (list != NULL)
{
@ -1923,7 +1805,7 @@ gtk_wrap_box_get_height_for_width (GtkSizeRequest *widget,
}
}
g_free (item_sizes);
g_free (item_sizes);
}
}
else /* GTK_WRAP_ALLOCATE_FREE */
@ -2072,20 +1954,20 @@ gtk_wrap_box_get_width_for_height (GtkSizeRequest *widget,
GList *list = priv->children;
gint min_line_width, nat_line_width, i;
gboolean first_line = TRUE;
GtkRequestedSize *item_sizes;
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);
/* 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;
/* 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);
extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
while (list != NULL)
{
@ -2110,7 +1992,7 @@ gtk_wrap_box_get_width_for_height (GtkSizeRequest *widget,
nat_width += nat_line_width;
}
}
g_free (item_sizes);
g_free (item_sizes);
}
}
else /* GTK_WRAP_ALLOCATE_FREE */
@ -2454,24 +2336,20 @@ gtk_wrap_box_get_natural_line_children (GtkWrapBox *box)
/**
* gtk_wrap_box_insert_child_with_padding:
* 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.
* @horizontal_padding: horizontal padding for this child
* @vertical_padding: vertical padding for this child
* @packing: The #GtkWrapBoxPacking options to use.
*
* Adds a child to an #GtkWrapBox with its packing options set
*
*/
void
gtk_wrap_box_insert_child_with_padding (GtkWrapBox *box,
GtkWidget *widget,
gint index,
guint horizontal_padding,
guint vertical_padding,
GtkWrapBoxPacking packing)
gtk_wrap_box_insert_child (GtkWrapBox *box,
GtkWidget *widget,
gint index,
GtkWrapBoxPacking packing)
{
GtkWrapBoxPrivate *priv;
GtkWrapBoxChild *child;
@ -2488,8 +2366,6 @@ gtk_wrap_box_insert_child_with_padding (GtkWrapBox *box,
child = g_slice_new0 (GtkWrapBoxChild);
child->widget = widget;
child->hpadding = horizontal_padding;
child->vpadding = vertical_padding;
child->packing = packing;
priv->children = g_list_insert (priv->children, child, index);

6
gtk/gtkwrapbox.h
View File

@ -82,12 +82,10 @@ void gtk_wrap_box_set_natural_line_children (GtkWrapBox
guint n_children);
guint gtk_wrap_box_get_natural_line_children (GtkWrapBox *layout);
void gtk_wrap_box_insert_child_with_padding (GtkWrapBox *layout,
void gtk_wrap_box_insert_child (GtkWrapBox *layout,
GtkWidget *widget,
gint index,
guint horizontal_padding,
guint vertical_padding,
GtkWrapBoxPacking packing);
GtkWrapBoxPacking packing);
void gtk_wrap_box_reorder_child (GtkWrapBox *layout,
GtkWidget *widget,

141
tests/testwrapbox.c
View File

@ -41,8 +41,6 @@ static gboolean items_xexpand = TRUE;
static gboolean items_yexpand = TRUE;
static gboolean items_xfill = TRUE;
static gboolean items_yfill = TRUE;
static gint items_xpad = 0;
static gint items_ypad = 0;
static void
@ -63,14 +61,13 @@ populate_wrapbox_simple (GtkWrapBox *wrapbox)
gtk_container_add (GTK_CONTAINER (frame), widget);
if (text_orientation == GTK_ORIENTATION_VERTICAL)
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_wrap_box_insert_child_with_padding (GTK_WRAP_BOX (wrapbox), frame, -1,
items_xpad, items_ypad,
(items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
(items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
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) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
g_free (text);
}
@ -99,7 +96,7 @@ populate_wrapbox_wrappy (GtkWrapBox *wrapbox)
gtk_widget_show (frame);
if (text_orientation == GTK_ORIENTATION_VERTICAL)
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_container_add (GTK_CONTAINER (frame), widget);
@ -107,12 +104,11 @@ populate_wrapbox_wrappy (GtkWrapBox *wrapbox)
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_with_padding (GTK_WRAP_BOX (wrapbox), frame, -1,
items_xpad, items_ypad,
(items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
(items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
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) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
}
}
@ -135,12 +131,11 @@ populate_wrapbox_stock (GtkWrapBox *wrapbox)
widget = gtk_button_new_from_stock (stock_id);
gtk_widget_show (widget);
gtk_wrap_box_insert_child_with_padding (GTK_WRAP_BOX (wrapbox), widget, -1,
items_xpad, items_ypad,
(items_xexpand ? GTK_WRAP_BOX_H_EXPAND : 0) |
(items_yexpand ? GTK_WRAP_BOX_V_EXPAND : 0) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
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) |
(items_xfill ? GTK_WRAP_BOX_H_FILL : 0) |
(items_yfill ? GTK_WRAP_BOX_V_FILL : 0));
}
}
@ -170,7 +165,7 @@ populate_items (GtkWrapBox *wrapbox)
static void
mode_changed (GtkComboBox *box,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
GtkWrapAllocationMode mode = gtk_combo_box_get_active (box);
@ -179,7 +174,7 @@ mode_changed (GtkComboBox *box,
static void
spreading_changed (GtkComboBox *box,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
GtkWrapBoxSpreading spreading = gtk_combo_box_get_active (box);
@ -188,7 +183,7 @@ spreading_changed (GtkComboBox *box,
static void
orientation_changed (GtkComboBox *box,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
GtkOrientation orientation = gtk_combo_box_get_active (box);
@ -197,7 +192,7 @@ orientation_changed (GtkComboBox *box,
static void
line_length_changed (GtkSpinButton *spin,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
gint length = gtk_spin_button_get_value_as_int (spin);
@ -206,7 +201,7 @@ line_length_changed (GtkSpinButton *spin,
static void
spacing_changed (GtkSpinButton *button,
gpointer data)
gpointer data)
{
GtkOrientation orientation = GPOINTER_TO_INT (data);
gint state = gtk_spin_button_get_value_as_int (button);
@ -220,7 +215,7 @@ spacing_changed (GtkSpinButton *button,
static void
items_changed (GtkComboBox *box,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
items_type = gtk_combo_box_get_active (box);
@ -229,7 +224,7 @@ items_changed (GtkComboBox *box,
static void
text_orientation_changed (GtkComboBox *box,
GtkWrapBox *wrapbox)
GtkWrapBox *wrapbox)
{
text_orientation = gtk_combo_box_get_active (box);
@ -238,22 +233,13 @@ text_orientation_changed (GtkComboBox *box,
static void
child_option_toggled (GtkToggleButton *button,
gboolean *state)
gboolean *state)
{
*state = gtk_toggle_button_get_active (button);
populate_items (the_wrapbox);
}
static void
child_padding_changed (GtkSpinButton *button,
gint *state)
{
*state = gtk_spin_button_get_value_as_int (button);
populate_items (the_wrapbox);
}
static GtkWidget *
create_window (void)
{
@ -277,13 +263,13 @@ create_window (void)
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
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_HSPACING, INITIAL_VSPACING);
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);
@ -310,7 +296,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (mode_changed), wrapbox);
G_CALLBACK (mode_changed), wrapbox);
/* Add Spreading control */
widget = gtk_combo_box_new_text ();
@ -325,7 +311,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spreading_changed), wrapbox);
G_CALLBACK (spreading_changed), wrapbox);
/* Add Orientation control */
widget = gtk_combo_box_new_text ();
@ -338,7 +324,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (wrapbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), wrapbox);
G_CALLBACK (orientation_changed), wrapbox);
/* Add minimum line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
@ -349,9 +335,9 @@ create_window (void)
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_CALLBACK (line_length_changed), wrapbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (line_length_changed), wrapbox);
G_CALLBACK (line_length_changed), wrapbox);
/* Add horizontal/vertical spacing controls */
hbox = gtk_hbox_new (FALSE, 2);
@ -369,9 +355,9 @@ create_window (void)
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_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));
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0);
@ -390,9 +376,9 @@ create_window (void)
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_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));
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
gtk_box_pack_start (GTK_BOX (wrapbox_cntl), hbox, FALSE, FALSE, 0);
@ -418,7 +404,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (items_changed), wrapbox);
G_CALLBACK (items_changed), wrapbox);
/* Add Text Orientation control */
@ -432,7 +418,7 @@ create_window (void)
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);
G_CALLBACK (text_orientation_changed), wrapbox);
/* Add expand/fill options */
@ -447,7 +433,7 @@ create_window (void)
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);
G_CALLBACK (child_option_toggled), &items_xexpand);
widget = gtk_check_button_new_with_label ("X Fill");
@ -458,7 +444,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (child_option_toggled), &items_xfill);
G_CALLBACK (child_option_toggled), &items_xfill);
gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0);
@ -474,7 +460,7 @@ create_window (void)
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);
G_CALLBACK (child_option_toggled), &items_yexpand);
widget = gtk_check_button_new_with_label ("Y Fill");
@ -485,50 +471,7 @@ create_window (void)
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (child_option_toggled), &items_yfill);
gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0);
/* Add x/y padding options */
hbox = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("X Padding");
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_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal padding values for children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (child_padding_changed), &items_xpad);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (child_padding_changed), &items_xpad);
gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("Y Padding");
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_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical padding values for children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (child_padding_changed), &items_ypad);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (child_padding_changed), &items_ypad);
G_CALLBACK (child_option_toggled), &items_yfill);
gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0);