[gtk+] GtkBox: Add baseline alignment for horizontal boxes
- From: Alexander Larsson <alexl src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+] GtkBox: Add baseline alignment for horizontal boxes
- Date: Tue, 23 Apr 2013 03:56:58 +0000 (UTC)
commit 9a42942afbe9f535e44413c5bfe49a44577cf238
Author: Alexander Larsson <alexl redhat com>
Date: Tue Mar 5 15:20:20 2013 +0100
GtkBox: Add baseline alignment for horizontal boxes
Report a baseline based height and baseline whenever there
are children with ALIGN_BASELINE.
Assign baseline to childen in size_allocate. Either the one inherited
from the parent if set, or otherwise calculate one based on any
ALIGN_BASELINE children.
gtk/gtkbox.c | 382 +++++++++++++++++++++++++++++++++++++++++++++++++--------
gtk/gtkbox.h | 5 +
gtk/gtkenums.h | 22 ++++
3 files changed, 359 insertions(+), 50 deletions(-)
---
diff --git a/gtk/gtkbox.c b/gtk/gtkbox.c
index 5c8e6e3..c1e916a 100644
--- a/gtk/gtkbox.c
+++ b/gtk/gtkbox.c
@@ -94,7 +94,8 @@ enum {
PROP_0,
PROP_ORIENTATION,
PROP_SPACING,
- PROP_HOMOGENEOUS
+ PROP_HOMOGENEOUS,
+ PROP_BASELINE_POSITION
};
enum {
@@ -116,6 +117,7 @@ struct _GtkBoxPrivate
guint default_expand : 1;
guint homogeneous : 1;
guint spacing_set : 1;
+ guint baseline_pos : 2;
};
typedef struct _GtkBoxChild GtkBoxChild;
@@ -200,6 +202,12 @@ static void gtk_box_get_preferred_height_for_width (GtkWidget
gint width,
gint *minimum_height,
gint *natural_height);
+static void gtk_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height,
+ gint *minimum_baseline,
+ gint *natural_baseline);
G_DEFINE_TYPE_WITH_CODE (GtkBox, gtk_box, GTK_TYPE_CONTAINER,
@@ -220,6 +228,7 @@ gtk_box_class_init (GtkBoxClass *class)
widget_class->get_preferred_width = gtk_box_get_preferred_width;
widget_class->get_preferred_height = gtk_box_get_preferred_height;
widget_class->get_preferred_height_for_width = gtk_box_get_preferred_height_for_width;
+ widget_class->get_preferred_height_and_baseline_for_width =
gtk_box_get_preferred_height_and_baseline_for_width;
widget_class->get_preferred_width_for_height = gtk_box_get_preferred_width_for_height;
widget_class->compute_expand = gtk_box_compute_expand;
widget_class->direction_changed = gtk_box_direction_changed;
@@ -255,6 +264,15 @@ gtk_box_class_init (GtkBoxClass *class)
FALSE,
GTK_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_BASELINE_POSITION,
+ g_param_spec_enum ("baseline-position",
+ P_("Baseline position"),
+ P_("The position of the baseline aligned widgets if
extra space is availible"),
+ GTK_TYPE_BASELINE_POSITION,
+ GTK_BASELINE_POSITION_CENTER,
+ GTK_PARAM_READWRITE));
+
/**
* GtkBox:expand:
*
@@ -340,6 +358,7 @@ gtk_box_init (GtkBox *box)
private->homogeneous = FALSE;
private->spacing = 0;
private->spacing_set = FALSE;
+ private->baseline_pos = GTK_BASELINE_POSITION_CENTER;
}
static void
@@ -361,6 +380,9 @@ gtk_box_set_property (GObject *object,
case PROP_SPACING:
gtk_box_set_spacing (box, g_value_get_int (value));
break;
+ case PROP_BASELINE_POSITION:
+ gtk_box_set_baseline_position (box, g_value_get_enum (value));
+ break;
case PROP_HOMOGENEOUS:
gtk_box_set_homogeneous (box, g_value_get_boolean (value));
break;
@@ -387,6 +409,9 @@ gtk_box_get_property (GObject *object,
case PROP_SPACING:
g_value_set_int (value, private->spacing);
break;
+ case PROP_BASELINE_POSITION:
+ g_value_set_enum (value, private->baseline_pos);
+ break;
case PROP_HOMOGENEOUS:
g_value_set_boolean (value, private->homogeneous);
break;
@@ -435,6 +460,11 @@ gtk_box_size_allocate (GtkWidget *widget,
GtkTextDirection direction;
GtkAllocation child_allocation;
GtkRequestedSize *sizes;
+ gint child_minimum_baseline, child_natural_baseline;
+ gint minimum_above, natural_above;
+ gint minimum_below, natural_below;
+ gboolean have_baseline;
+ gint baseline;
GtkPackType packing;
@@ -461,6 +491,10 @@ gtk_box_size_allocate (GtkWidget *widget,
else
size = allocation->height - (nvis_children - 1) * private->spacing;
+ have_baseline = FALSE;
+ minimum_above = natural_above = 0;
+ minimum_below = natural_below = 0;
+
/* Retrieve desired size for visible children. */
for (i = 0, children = private->children; children; children = children->next)
{
@@ -475,11 +509,11 @@ gtk_box_size_allocate (GtkWidget *widget,
&sizes[i].minimum_size,
&sizes[i].natural_size);
else
- gtk_widget_get_preferred_height_for_width (child->widget,
- allocation->width,
- &sizes[i].minimum_size,
- &sizes[i].natural_size);
-
+ gtk_widget_get_preferred_height_and_baseline_for_width (child->widget,
+ allocation->width,
+ &sizes[i].minimum_size,
+ &sizes[i].natural_size,
+ NULL, NULL);
/* Assert the api is working properly */
if (sizes[i].minimum_size < 0)
@@ -537,28 +571,9 @@ gtk_box_size_allocate (GtkWidget *widget,
extra = 0;
}
- /* Allocate child positions. */
+ /* Allocate child sizes. */
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
{
- if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- child_allocation.y = allocation->y;
- child_allocation.height = MAX (1, allocation->height);
- if (packing == GTK_PACK_START)
- x = allocation->x;
- else
- x = allocation->x + allocation->width;
- }
- else
- {
- child_allocation.x = allocation->x;
- child_allocation.width = MAX (1, allocation->width);
- if (packing == GTK_PACK_START)
- y = allocation->y;
- else
- y = allocation->y + allocation->height;
- }
-
for (i = 0, children = private->children;
children;
children = children->next)
@@ -605,6 +620,105 @@ gtk_box_size_allocate (GtkWidget *widget,
}
}
+ sizes[i].natural_size = child_size;
+
+ if (private->orientation == GTK_ORIENTATION_HORIZONTAL &&
+ gtk_widget_get_valign_with_baseline (child->widget) == GTK_ALIGN_BASELINE)
+ {
+ int child_allocation_width;
+ int child_minimum_height, child_natural_height;
+
+ if (child->fill)
+ child_allocation_width = MAX (1, child_size - child->padding * 2);
+ else
+ child_allocation_width = sizes[i].minimum_size;
+
+ child_minimum_baseline = -1;
+ child_natural_baseline = -1;
+ gtk_widget_get_preferred_height_and_baseline_for_width (child->widget,
+ child_allocation_width,
+ &child_minimum_height,
&child_natural_height,
+ &child_minimum_baseline,
&child_natural_baseline);
+
+ if (child_minimum_baseline >= 0)
+ {
+ have_baseline = TRUE;
+ minimum_below = MAX (minimum_below, child_minimum_height - child_minimum_baseline);
+ natural_below = MAX (natural_below, child_natural_height - child_natural_baseline);
+ minimum_above = MAX (minimum_above, child_minimum_baseline);
+ natural_above = MAX (natural_above, child_natural_baseline);
+ }
+ }
+
+ i++;
+ }
+ }
+
+ baseline = gtk_widget_get_allocated_baseline (widget);
+ if (baseline == -1 && have_baseline)
+ {
+ gint height = MAX (1, allocation->height);
+
+ /* TODO: This is purely based on the minimum baseline, when things fit we should
+ use the natural one? */
+
+ switch (private->baseline_pos)
+ {
+ case GTK_BASELINE_POSITION_TOP:
+ baseline = minimum_above;
+ break;
+ case GTK_BASELINE_POSITION_CENTER:
+ baseline = minimum_above + (height - (minimum_above + minimum_below)) / 2;
+ break;
+ case GTK_BASELINE_POSITION_BOTTOM:
+ baseline = height - minimum_below;
+ break;
+ }
+ }
+
+ /* Allocate child positions. */
+ for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
+ {
+ if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
+ {
+ child_allocation.y = allocation->y;
+ child_allocation.height = MAX (1, allocation->height);
+ if (packing == GTK_PACK_START)
+ x = allocation->x;
+ else
+ x = allocation->x + allocation->width;
+ }
+ else
+ {
+ child_allocation.x = allocation->x;
+ child_allocation.width = MAX (1, allocation->width);
+ if (packing == GTK_PACK_START)
+ y = allocation->y;
+ else
+ y = allocation->y + allocation->height;
+ }
+
+ for (i = 0, children = private->children;
+ children;
+ children = children->next)
+ {
+ child = children->data;
+
+ /* If widget is not visible, skip it. */
+ if (!gtk_widget_get_visible (child->widget))
+ continue;
+
+ /* If widget is packed differently skip it, but still increment i,
+ * since widget is visible and will be handled in next loop iteration.
+ */
+ if (child->pack != packing)
+ {
+ i++;
+ continue;
+ }
+
+ child_size = sizes[i].natural_size;
+
/* Assign the child's position. */
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
{
@@ -658,7 +772,7 @@ gtk_box_size_allocate (GtkWidget *widget,
child_allocation.y -= child_size;
}
}
- gtk_widget_size_allocate (child->widget, &child_allocation);
+ gtk_widget_size_allocate_with_baseline (child->widget, &child_allocation, baseline);
i++;
}
@@ -1015,18 +1129,28 @@ static void
gtk_box_get_size (GtkWidget *widget,
GtkOrientation orientation,
gint *minimum_size,
- gint *natural_size)
+ gint *natural_size,
+ gint *minimum_baseline,
+ gint *natural_baseline)
{
GtkBox *box;
GtkBoxPrivate *private;
GList *children;
gint nvis_children;
gint minimum, natural;
+ gint minimum_above, natural_above;
+ gint minimum_below, natural_below;
+ gboolean have_baseline;
+ gint min_baseline, nat_baseline;
box = GTK_BOX (widget);
private = box->priv;
+ have_baseline = FALSE;
minimum = natural = 0;
+ minimum_above = natural_above = 0;
+ minimum_below = natural_below = 0;
+ min_baseline = nat_baseline = -1;
nvis_children = 0;
@@ -1037,13 +1161,15 @@ gtk_box_get_size (GtkWidget *widget,
if (gtk_widget_get_visible (child->widget))
{
gint child_minimum, child_natural;
+ gint child_minimum_baseline = -1, child_natural_baseline = -1;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_widget_get_preferred_width (child->widget,
&child_minimum, &child_natural);
else
- gtk_widget_get_preferred_height (child->widget,
- &child_minimum, &child_natural);
+ gtk_widget_get_preferred_height_and_baseline_for_width (child->widget, -1,
+ &child_minimum, &child_natural,
+ &child_minimum_baseline,
&child_natural_baseline);
if (private->orientation == orientation)
{
@@ -1065,9 +1191,20 @@ gtk_box_get_size (GtkWidget *widget,
}
else
{
- /* The biggest mins and naturals in the opposing orientation */
- minimum = MAX (minimum, child_minimum);
- natural = MAX (natural, child_natural);
+ if (child_minimum_baseline >= 0)
+ {
+ have_baseline = TRUE;
+ minimum_below = MAX (minimum_below, child_minimum - child_minimum_baseline);
+ natural_below = MAX (natural_below, child_natural - child_natural_baseline);
+ minimum_above = MAX (minimum_above, child_minimum_baseline);
+ natural_above = MAX (natural_above, child_natural_baseline);
+ }
+ else
+ {
+ /* The biggest mins and naturals in the opposing orientation */
+ minimum = MAX (minimum, child_minimum);
+ natural = MAX (natural, child_natural);
+ }
}
nvis_children += 1;
@@ -1085,11 +1222,39 @@ gtk_box_get_size (GtkWidget *widget,
natural += (nvis_children - 1) * private->spacing;
}
+ minimum = MAX (minimum, minimum_below + minimum_above);
+ natural = MAX (natural, natural_below + natural_above);
+
+ if (have_baseline)
+ {
+ switch (private->baseline_pos)
+ {
+ case GTK_BASELINE_POSITION_TOP:
+ min_baseline = minimum_above;
+ nat_baseline = natural_above;
+ break;
+ case GTK_BASELINE_POSITION_CENTER:
+ min_baseline = minimum_above + (minimum - (minimum_above + minimum_below)) / 2;
+ nat_baseline = natural_above + (natural - (natural_above + natural_below)) / 2;
+ break;
+ case GTK_BASELINE_POSITION_BOTTOM:
+ min_baseline = minimum - minimum_below;
+ nat_baseline = natural - natural_below;
+ break;
+ }
+ }
+
if (minimum_size)
*minimum_size = minimum;
if (natural_size)
*natural_size = natural;
+
+ if (minimum_baseline)
+ *minimum_baseline = min_baseline;
+
+ if (natural_baseline)
+ *natural_baseline = nat_baseline;
}
static void
@@ -1097,7 +1262,7 @@ gtk_box_get_preferred_width (GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
- gtk_box_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
+ gtk_box_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size, NULL, NULL);
}
static void
@@ -1105,14 +1270,16 @@ gtk_box_get_preferred_height (GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
- gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
+ gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size, NULL, NULL);
}
static void
gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
gint avail_size,
gint *minimum_size,
- gint *natural_size)
+ gint *natural_size,
+ gint *minimum_baseline,
+ gint *natural_baseline)
{
GtkBoxPrivate *private = box->priv;
GtkBoxChild *child;
@@ -1120,11 +1287,16 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
gint nvis_children;
gint nexpand_children;
gint computed_minimum = 0, computed_natural = 0;
+ gint computed_minimum_above = 0, computed_natural_above = 0;
+ gint computed_minimum_below = 0, computed_natural_below = 0;
+ gint computed_minimum_baseline = -1, computed_natural_baseline = -1;
GtkRequestedSize *sizes;
GtkPackType packing;
gint size, extra, i;
gint child_size, child_minimum, child_natural;
+ gint child_minimum_baseline, child_natural_baseline;
gint n_extra_widgets = 0;
+ gboolean have_baseline;
count_expand_children (box, &nvis_children, &nexpand_children);
@@ -1199,6 +1371,7 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
extra = 0;
}
+ have_baseline = FALSE;
/* Allocate child positions. */
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
{
@@ -1260,26 +1433,64 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
}
+ child_minimum_baseline = child_natural_baseline = -1;
/* Assign the child's position. */
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
- gtk_widget_get_preferred_height_for_width (child->widget,
- child_size, &child_minimum, &child_natural);
+ gtk_widget_get_preferred_height_and_baseline_for_width (child->widget, child_size,
+ &child_minimum, &child_natural,
+ &child_minimum_baseline,
&child_natural_baseline);
else /* (private->orientation == GTK_ORIENTATION_VERTICAL) */
gtk_widget_get_preferred_width_for_height (child->widget,
child_size, &child_minimum, &child_natural);
-
- computed_minimum = MAX (computed_minimum, child_minimum);
- computed_natural = MAX (computed_natural, child_natural);
+ if (child_minimum_baseline >= 0)
+ {
+ have_baseline = TRUE;
+ computed_minimum_below = MAX (computed_minimum_below, child_minimum -
child_minimum_baseline);
+ computed_natural_below = MAX (computed_natural_below, child_natural -
child_natural_baseline);
+ computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
+ computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+ }
+ else
+ {
+ computed_minimum = MAX (computed_minimum, child_minimum);
+ computed_natural = MAX (computed_natural, child_natural);
+ }
}
i += 1;
}
}
+ if (have_baseline)
+ {
+ computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above);
+ computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
+ switch (private->baseline_pos)
+ {
+ case GTK_BASELINE_POSITION_TOP:
+ computed_minimum_baseline = computed_minimum_above;
+ computed_natural_baseline = computed_natural_above;
+ break;
+ case GTK_BASELINE_POSITION_CENTER:
+ computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum -
(computed_minimum_above + computed_minimum_below)) / 2, 0);
+ computed_natural_baseline = computed_natural_above + MAX((computed_natural -
(computed_natural_above + computed_natural_below)) / 2, 0);
+ break;
+ case GTK_BASELINE_POSITION_BOTTOM:
+ computed_minimum_baseline = computed_minimum - computed_minimum_below;
+ computed_natural_baseline = computed_natural - computed_natural_below;
+ break;
+ }
+ }
+
+ if (minimum_baseline)
+ *minimum_baseline = computed_minimum_baseline;
+ if (natural_baseline)
+ *natural_baseline = computed_natural_baseline;
+
if (minimum_size)
*minimum_size = computed_minimum;
if (natural_size)
- *natural_size = computed_natural;
+ *natural_size = MAX (computed_natural, computed_natural_below + computed_natural_above);
}
static void
@@ -1355,24 +1566,46 @@ gtk_box_get_preferred_width_for_height (GtkWidget *widget,
GtkBoxPrivate *private = box->priv;
if (private->orientation == GTK_ORIENTATION_VERTICAL)
- gtk_box_compute_size_for_opposing_orientation (box, height, minimum_width, natural_width);
+ gtk_box_compute_size_for_opposing_orientation (box, height, minimum_width, natural_width, NULL, NULL);
else
gtk_box_compute_size_for_orientation (box, height, minimum_width, natural_width);
}
static void
-gtk_box_get_preferred_height_for_width (GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+gtk_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height,
+ gint *minimum_baseline,
+ gint *natural_baseline)
{
GtkBox *box = GTK_BOX (widget);
GtkBoxPrivate *private = box->priv;
- if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
- gtk_box_compute_size_for_opposing_orientation (box, width, minimum_height, natural_height);
+ if (width < 0)
+ gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_height, natural_height, minimum_baseline,
natural_baseline);
else
- gtk_box_compute_size_for_orientation (box, width, minimum_height, natural_height);
+ {
+ if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
+ gtk_box_compute_size_for_opposing_orientation (box, width, minimum_height, natural_height,
minimum_baseline, natural_baseline);
+ else
+ {
+ if (minimum_baseline)
+ *minimum_baseline = -1;
+ if (natural_baseline)
+ *natural_baseline = -1;
+ gtk_box_compute_size_for_orientation (box, width, minimum_height, natural_height);
+ }
+ }
+}
+
+static void
+gtk_box_get_preferred_height_for_width (GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ gtk_box_get_preferred_height_and_baseline_for_width (widget, width, minimum_height, natural_height, NULL,
NULL);
}
/**
@@ -1550,6 +1783,55 @@ gtk_box_get_spacing (GtkBox *box)
return box->priv->spacing;
}
+/**
+ * gtk_box_set_baseline_position:
+ * @box: a #GtkBox
+ * @position: a #GtkBaselinePosition
+ *
+ * Sets the baseline position of a box. This affects
+ * only horizontal boxes with at least one baseline aligned
+ * child. If there is more vertical space availible than requested,
+ * and the baseline is not allocated by the parent then
+ * @position is used to allocate the baseline wrt the
+ * extra space available.
+ */
+void
+gtk_box_set_baseline_position (GtkBox *box,
+ GtkBaselinePosition position)
+{
+ GtkBoxPrivate *private;
+
+ g_return_if_fail (GTK_IS_BOX (box));
+
+ private = box->priv;
+
+ if (position != private->baseline_pos)
+ {
+ private->baseline_pos = position;
+
+ g_object_notify (G_OBJECT (box), "baseline-position");
+
+ gtk_widget_queue_resize (GTK_WIDGET (box));
+ }
+}
+
+/**
+ * gtk_box_get_baseline_position:
+ * @box: a #GtkBox
+ *
+ * Gets the value set by gtk_box_set_baseline_position().
+ *
+ * Return value: the baseline position
+ **/
+GtkBaselinePosition
+gtk_box_get_baseline_position (GtkBox *box)
+{
+ g_return_val_if_fail (GTK_IS_BOX (box), GTK_BASELINE_POSITION_CENTER);
+
+ return box->priv->baseline_pos;
+}
+
+
void
_gtk_box_set_spacing_set (GtkBox *box,
gboolean spacing_set)
diff --git a/gtk/gtkbox.h b/gtk/gtkbox.h
index d51ccf0..e93c97f 100644
--- a/gtk/gtkbox.h
+++ b/gtk/gtkbox.h
@@ -89,6 +89,11 @@ gboolean gtk_box_get_homogeneous (GtkBox *box);
void gtk_box_set_spacing (GtkBox *box,
gint spacing);
gint gtk_box_get_spacing (GtkBox *box);
+GDK_AVAILABLE_IN_3_10
+void gtk_box_set_baseline_position (GtkBox *box,
+ GtkBaselinePosition position);
+GDK_AVAILABLE_IN_3_10
+GtkBaselinePosition gtk_box_get_baseline_position (GtkBox *box);
void gtk_box_reorder_child (GtkBox *box,
GtkWidget *child,
diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h
index 9df69a8..82f5a0a 100644
--- a/gtk/gtkenums.h
+++ b/gtk/gtkenums.h
@@ -132,6 +132,28 @@ typedef enum
} GtkAttachOptions;
/**
+ * GtkBaselinePosition:
+ * @GTK_BASELINE_POSITION_TOP: Align the baseline at the top
+ * @GTK_BASELINE_POSITION_CENTER: Center the baseline
+ * @GTK_BASELINE_POSITION_BOTTOM: Align the baseline at the bottom
+ *
+ * Whenever a container has some form of natural row it may align
+ * children in that row along a common typographical baseline. If
+ * the amount of verical space in the row is taller than the total
+ * requested height of the baseline-aligned children then it can use a
+ * #GtkBaselinePosition to select where to put the baseline inside the
+ * extra availible space.
+ *
+ * Since: 3.10
+ */
+typedef enum
+{
+ GTK_BASELINE_POSITION_TOP,
+ GTK_BASELINE_POSITION_CENTER,
+ GTK_BASELINE_POSITION_BOTTOM
+} GtkBaselinePosition;
+
+/**
* GtkButtonBoxStyle:
* @GTK_BUTTONBOX_DEFAULT_STYLE: Default packing.
* @GTK_BUTTONBOX_SPREAD: Buttons are evenly spread across the box.
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
