*
*/
+/*
+ * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+
#include "gtkpacker.h"
+enum {
+ ARG_0,
+ ARG_SPACING,
+ ARG_D_BORDER_WIDTH,
+ ARG_D_PAD_X,
+ ARG_D_PAD_Y,
+ ARG_D_IPAD_X,
+ ARG_D_IPAD_Y
+};
+
+enum {
+ CHILD_ARG_0,
+ CHILD_ARG_SIDE,
+ CHILD_ARG_ANCHOR,
+ CHILD_ARG_EXPAND,
+ CHILD_ARG_FILL_X,
+ CHILD_ARG_FILL_Y,
+ CHILD_ARG_USE_DEFAULT,
+ CHILD_ARG_BORDER_WIDTH,
+ CHILD_ARG_PAD_X,
+ CHILD_ARG_PAD_Y,
+ CHILD_ARG_I_PAD_X,
+ CHILD_ARG_I_PAD_Y,
+ CHILD_ARG_POSITION
+};
+
static void gtk_packer_class_init (GtkPackerClass *klass);
static void gtk_packer_init (GtkPacker *packer);
static void gtk_packer_map (GtkWidget *widget);
GtkWidget *child);
static void gtk_packer_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_packer_foreach (GtkContainer *container,
+static void gtk_packer_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
+static void gtk_packer_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
static GtkType gtk_packer_child_type (GtkContainer *container);
-
+
static GtkPackerClass *parent_class;
if (!packer_type)
{
- GtkTypeInfo packer_info =
+ static const GtkTypeInfo packer_info =
{
"GtkPacker",
sizeof (GtkPacker),
sizeof (GtkPackerClass),
(GtkClassInitFunc) gtk_packer_class_init,
(GtkObjectInitFunc) gtk_packer_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL
+ /* reserved_1 */ NULL,
+ /* reserved_2 */ NULL,
+ (GtkClassInitFunc) NULL,
};
- packer_type = gtk_type_unique (gtk_container_get_type (), &packer_info);
+ packer_type = gtk_type_unique (GTK_TYPE_CONTAINER, &packer_info);
}
return packer_type;
static void
gtk_packer_class_init (GtkPackerClass *klass)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
+ object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
+ gtk_object_add_arg_type ("GtkPacker::spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_SPACING);
+ gtk_object_add_arg_type ("GtkPacker::default_border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_BORDER_WIDTH);
+ gtk_object_add_arg_type ("GtkPacker::default_pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_X);
+ gtk_object_add_arg_type ("GtkPacker::default_pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_Y);
+ gtk_object_add_arg_type ("GtkPacker::default_ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_X);
+ gtk_object_add_arg_type ("GtkPacker::default_ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_Y);
+
+ gtk_container_add_child_arg_type ("GtkPacker::side", GTK_TYPE_SIDE_TYPE, GTK_ARG_READWRITE, CHILD_ARG_SIDE);
+ gtk_container_add_child_arg_type ("GtkPacker::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, CHILD_ARG_ANCHOR);
+ gtk_container_add_child_arg_type ("GtkPacker::expand", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_EXPAND);
+ gtk_container_add_child_arg_type ("GtkPacker::fill_x", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_X);
+ gtk_container_add_child_arg_type ("GtkPacker::fill_y", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::use_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_USE_DEFAULT);
+ gtk_container_add_child_arg_type ("GtkPacker::border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BORDER_WIDTH);
+ gtk_container_add_child_arg_type ("GtkPacker::pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_X);
+ gtk_container_add_child_arg_type ("GtkPacker::pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_X);
+ gtk_container_add_child_arg_type ("GtkPacker::ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::position", GTK_TYPE_LONG, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
+
+ object_class->set_arg = gtk_packer_set_arg;
+ object_class->get_arg = gtk_packer_get_arg;
+
widget_class->map = gtk_packer_map;
widget_class->unmap = gtk_packer_unmap;
widget_class->draw = gtk_packer_draw;
container_class->add = gtk_packer_container_add;
container_class->remove = gtk_packer_remove;
- container_class->foreach = gtk_packer_foreach;
+ container_class->forall = gtk_packer_forall;
container_class->child_type = gtk_packer_child_type;
+ container_class->get_child_arg = gtk_packer_get_child_arg;
+ container_class->set_child_arg = gtk_packer_set_child_arg;
+}
+
+static void
+gtk_packer_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+
+ packer = GTK_PACKER (object);
+
+ switch (arg_id)
+ {
+ case ARG_SPACING:
+ gtk_packer_set_spacing (packer, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_BORDER_WIDTH:
+ gtk_packer_set_default_border_width (packer, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_PAD_X:
+ gtk_packer_set_default_pad (packer,
+ GTK_VALUE_UINT (*arg),
+ packer->default_pad_y);
+ break;
+ case ARG_D_PAD_Y:
+ gtk_packer_set_default_pad (packer,
+ packer->default_pad_x,
+ GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_IPAD_X:
+ gtk_packer_set_default_ipad (packer,
+ GTK_VALUE_UINT (*arg),
+ packer->default_i_pad_y);
+ break;
+ case ARG_D_IPAD_Y:
+ gtk_packer_set_default_ipad (packer,
+ packer->default_i_pad_x,
+ GTK_VALUE_UINT (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_packer_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+
+ packer = GTK_PACKER (object);
+
+ switch (arg_id)
+ {
+ case ARG_SPACING:
+ GTK_VALUE_UINT (*arg) = packer->spacing;
+ break;
+ case ARG_D_BORDER_WIDTH:
+ GTK_VALUE_UINT (*arg) = packer->default_border_width;
+ break;
+ case ARG_D_PAD_X:
+ GTK_VALUE_UINT (*arg) = packer->default_pad_x;
+ break;
+ case ARG_D_PAD_Y:
+ GTK_VALUE_UINT (*arg) = packer->default_pad_y;
+ break;
+ case ARG_D_IPAD_X:
+ GTK_VALUE_UINT (*arg) = packer->default_i_pad_x;
+ break;
+ case ARG_D_IPAD_Y:
+ GTK_VALUE_UINT (*arg) = packer->default_i_pad_y;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
}
static GtkType
return GTK_TYPE_WIDGET;
}
+static void
+gtk_packer_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+ GtkPackerChild *child_info = NULL;
+
+ packer = GTK_PACKER (container);
+
+ if (arg_id != CHILD_ARG_POSITION)
+ {
+ GList *list;
+
+ list = packer->children;
+ while (list)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+ if (!list)
+ return;
+ }
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_SIDE:
+ child_info->side = GTK_VALUE_ENUM (*arg);
+ break;
+ case CHILD_ARG_ANCHOR:
+ child_info->anchor = GTK_VALUE_ENUM (*arg);
+ break;
+ case CHILD_ARG_EXPAND:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_PACK_EXPAND;
+ else
+ child_info->options &= ~GTK_PACK_EXPAND;
+ break;
+ case CHILD_ARG_FILL_X:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_FILL_X;
+ else
+ child_info->options &= ~GTK_FILL_X;
+ break;
+ case CHILD_ARG_FILL_Y:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_FILL_Y;
+ else
+ child_info->options &= ~GTK_FILL_Y;
+ break;
+ case CHILD_ARG_USE_DEFAULT:
+ child_info->use_default = (GTK_VALUE_BOOL (*arg) != 0);
+ break;
+ case CHILD_ARG_BORDER_WIDTH:
+ if (!child_info->use_default)
+ child_info->border_width = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_PAD_X:
+ if (!child_info->use_default)
+ child_info->pad_x = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_PAD_Y:
+ if (!child_info->use_default)
+ child_info->pad_y = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_I_PAD_X:
+ if (!child_info->use_default)
+ child_info->i_pad_x = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_I_PAD_Y:
+ if (!child_info->use_default)
+ child_info->i_pad_y = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_POSITION:
+ gtk_packer_reorder_child (packer,
+ child,
+ GTK_VALUE_LONG (*arg));
+ break;
+ default:
+ break;
+ }
+
+ if (arg_id != CHILD_ARG_POSITION &&
+ GTK_WIDGET_VISIBLE (packer) &&
+ GTK_WIDGET_VISIBLE (child))
+ gtk_widget_queue_resize (child);
+}
+
+static void
+gtk_packer_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+ GtkPackerChild *child_info = NULL;
+ GList * list;
+
+ packer = GTK_PACKER (container);
+
+ if (arg_id != CHILD_ARG_POSITION)
+ {
+ list = packer->children;
+ while (list)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+ if (!list)
+ {
+ arg->type = GTK_TYPE_INVALID;
+ return;
+ }
+ }
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_SIDE:
+ GTK_VALUE_ENUM (*arg) = child_info->side;
+ break;
+ case CHILD_ARG_ANCHOR:
+ GTK_VALUE_ENUM (*arg) = child_info->anchor;
+ break;
+ case CHILD_ARG_EXPAND:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_PACK_EXPAND) != 0;
+ break;
+ case CHILD_ARG_FILL_X:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_X) != 0;
+ break;
+ case CHILD_ARG_FILL_Y:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_Y) != 0;
+ break;
+ case CHILD_ARG_USE_DEFAULT:
+ GTK_VALUE_BOOL (*arg) = child_info->use_default;
+ break;
+ case CHILD_ARG_BORDER_WIDTH:
+ GTK_VALUE_UINT (*arg) = child_info->border_width;
+ break;
+ case CHILD_ARG_PAD_X:
+ GTK_VALUE_UINT (*arg) = child_info->pad_x;
+ break;
+ case CHILD_ARG_PAD_Y:
+ GTK_VALUE_UINT (*arg) = child_info->pad_y;
+ break;
+ case CHILD_ARG_I_PAD_X:
+ GTK_VALUE_UINT (*arg) = child_info->i_pad_x;
+ break;
+ case CHILD_ARG_I_PAD_Y:
+ GTK_VALUE_UINT (*arg) = child_info->i_pad_y;
+ break;
+ case CHILD_ARG_POSITION:
+ GTK_VALUE_LONG (*arg) = 0;
+ for (list = packer->children; list; list = list->next)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+ GTK_VALUE_LONG (*arg)++;
+ }
+ if (!list)
+ GTK_VALUE_LONG (*arg) = -1;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_packer_init (GtkPacker *packer)
{
- GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW);
packer->children = NULL;
packer->spacing = 0;
if (spacing != packer->spacing)
{
packer->spacing = spacing;
- gtk_widget_queue_resize(GTK_WIDGET(packer));
+ gtk_widget_queue_resize (GTK_WIDGET (packer));
}
-};
+}
GtkWidget*
gtk_packer_new (void)
{
- return GTK_WIDGET (gtk_type_new (gtk_packer_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_PACKER));
}
static void
child->pad_y = packer->default_pad_y;
child->i_pad_x = packer->default_i_pad_x;
child->i_pad_y = packer->default_i_pad_y;
- gtk_widget_queue_resize(GTK_WIDGET(packer));
+ gtk_widget_queue_resize (GTK_WIDGET (child->widget));
}
list = g_list_next(list);
}
}
}
void
-gtk_packer_set_default_pad(GtkPacker *packer,
- guint pad_x,
- guint pad_y)
+gtk_packer_set_default_pad (GtkPacker *packer,
+ guint pad_x,
+ guint pad_y)
{
g_return_if_fail (packer != NULL);
g_return_if_fail (GTK_IS_PACKER (packer));
}
void
-gtk_packer_set_default_ipad(GtkPacker *packer,
- guint i_pad_x,
- guint i_pad_y)
+gtk_packer_set_default_ipad (GtkPacker *packer,
+ guint i_pad_x,
+ guint i_pad_y)
{
g_return_if_fail (packer != NULL);
g_return_if_fail (GTK_IS_PACKER (packer));
gtk_widget_set_parent (child, GTK_WIDGET (packer));
- if (GTK_WIDGET_VISIBLE (GTK_WIDGET (packer)))
+ if (GTK_WIDGET_REALIZED (child->parent))
+ gtk_widget_realize (child);
+
+ if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child))
{
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (packer)) &&
- !GTK_WIDGET_REALIZED (child))
- gtk_widget_realize (child);
-
- if (GTK_WIDGET_MAPPED (GTK_WIDGET (packer)) &&
- !GTK_WIDGET_MAPPED (child))
- gtk_widget_map (child);
- }
+ if (GTK_WIDGET_MAPPED (child->parent))
+ gtk_widget_map (child);
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
- gtk_widget_queue_resize (child);
-
+ gtk_widget_queue_resize (child);
+ }
}
void
gtk_widget_set_parent (child, GTK_WIDGET (packer));
- if (GTK_WIDGET_VISIBLE (GTK_WIDGET (packer)))
+ if (GTK_WIDGET_REALIZED (child->parent))
+ gtk_widget_realize (child);
+
+ if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child))
{
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (packer)) &&
- !GTK_WIDGET_REALIZED (child))
- gtk_widget_realize (child);
-
- if (GTK_WIDGET_MAPPED (GTK_WIDGET (packer)) &&
- !GTK_WIDGET_MAPPED (child))
- gtk_widget_map (child);
+ if (GTK_WIDGET_MAPPED (child->parent))
+ gtk_widget_map (child);
+
+ gtk_widget_queue_resize (child);
}
-
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
- gtk_widget_queue_resize (child);
-
}
void
-gtk_packer_configure (GtkPacker *packer,
- GtkWidget *child,
- GtkSideType side,
- GtkAnchorType anchor,
- GtkPackerOptions options,
- guint border_width,
- guint pad_x,
- guint pad_y,
- guint i_pad_x,
- guint i_pad_y)
+gtk_packer_set_child_packing (GtkPacker *packer,
+ GtkWidget *child,
+ GtkSideType side,
+ GtkAnchorType anchor,
+ GtkPackerOptions options,
+ guint border_width,
+ guint pad_x,
+ guint pad_y,
+ guint i_pad_x,
+ guint i_pad_y)
{
GList *list;
GtkPackerChild *pchild;
list = g_list_next(list);
}
- g_warning ("gtk_packer_configure(): couldn't find child `%s' amongst the packer's children", gtk_type_name (GTK_OBJECT_TYPE (child)));
+ g_warning ("couldn't find child `%s' amongst the packer's children", gtk_type_name (GTK_OBJECT_TYPE (child)));
+}
+
+void
+gtk_packer_reorder_child (GtkPacker *packer,
+ GtkWidget *child,
+ gint position)
+{
+ GList *list;
+
+ g_return_if_fail (packer != NULL);
+ g_return_if_fail (GTK_IS_PACKER (packer));
+ g_return_if_fail (child != NULL);
+
+ list = packer->children;
+ while (list)
+ {
+ GtkPackerChild *child_info;
+
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+
+ if (list && packer->children->next)
+ {
+ GList *tmp_list;
+
+ if (list->next)
+ list->next->prev = list->prev;
+ if (list->prev)
+ list->prev->next = list->next;
+ else
+ packer->children = list->next;
+
+ tmp_list = packer->children;
+ while (position && tmp_list->next)
+ {
+ position--;
+ tmp_list = tmp_list->next;
+ }
+
+ if (position)
+ {
+ tmp_list->next = list;
+ list->prev = tmp_list;
+ list->next = NULL;
+ }
+ else
+ {
+ if (tmp_list->prev)
+ tmp_list->prev->next = list;
+ else
+ packer->children = list;
+ list->prev = tmp_list->prev;
+ tmp_list->prev = list;
+ list->next = tmp_list;
+ }
+ if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
+ gtk_widget_queue_resize (child);
+ }
}
static void
-gtk_packer_remove (GtkContainer *container, GtkWidget *widget)
+gtk_packer_remove (GtkContainer *container,
+ GtkWidget *widget)
{
GtkPacker *packer;
GtkPackerChild *child;
}
static void
-gtk_packer_draw (GtkWidget *widget, GdkRectangle *area)
+gtk_packer_draw (GtkWidget *widget,
+ GdkRectangle *area)
{
GtkPacker *packer;
GtkPackerChild *child;
}
static gint
-gtk_packer_expose (GtkWidget *widget, GdkEventExpose *event)
+gtk_packer_expose (GtkWidget *widget,
+ GdkEventExpose *event)
{
GtkPacker *packer;
GtkPackerChild *child;
}
static void
-gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
+gtk_packer_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
{
GtkPacker *packer;
+ GtkContainer *container;
GtkPackerChild *child;
GList *children;
gint nvis_vert_children;
g_return_if_fail (requisition != NULL);
packer = GTK_PACKER (widget);
+ container = GTK_CONTAINER (widget);
+
requisition->width = 0;
requisition->height = 0;
nvis_vert_children = 0;
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (child->widget, &child_requisition);
- if((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
+ if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
maxWidth = MAX (maxWidth,
- (child->widget->requisition.width +
+ (child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x +
width));
- height += (child->widget->requisition.height +
+ height += (child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y);
}
else
{
maxHeight = MAX (maxHeight,
- (child->widget->requisition.height +
+ (child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y +
height));
- width += (child->widget->requisition.width +
+ width += (child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x);
}
children = g_list_next(children);
}
- requisition->width = MAX (maxWidth, width);
- requisition->height = MAX (maxHeight, height);
+
+ requisition->width = MAX (maxWidth, width) + 2 * container->border_width;
+ requisition->height = MAX (maxHeight, height) + 2 * container->border_width;
}
static gint
-YExpansion (GList *children, gint cavityHeight)
+YExpansion (GList *children,
+ gint cavityHeight)
{
GList *list;
GtkPackerChild *child;
list = children;
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
widget = child->widget;
- childHeight = (widget->requisition.height +
+ gtk_widget_get_child_requisition (widget, &child_requisition);
+
+ childHeight = (child_requisition.height +
2 * child->border_width +
child->i_pad_y +
child->pad_y);
}
static gint
-XExpansion (GList *children, gint cavityWidth)
+XExpansion (GList *children,
+ gint cavityWidth)
{
GList *list;
GtkPackerChild *child;
list = children;
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
widget = child->widget;
- childWidth = (widget->requisition.width +
+ gtk_widget_get_child_requisition (widget, &child_requisition);
+
+ childWidth = (child_requisition.width +
2 * child->border_width +
child->i_pad_x +
child->pad_x);
if (curExpand < minExpand)
minExpand = curExpand;
return (minExpand < 0) ? 0 : minExpand;
-};
+}
static void
-gtk_packer_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+gtk_packer_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
{
GtkPacker *packer;
+ GtkContainer *container;
GtkAllocation child_allocation;
GList *list;
GtkPackerChild *child;
g_return_if_fail (GTK_IS_PACKER (widget));
g_return_if_fail (allocation != NULL);
+ packer = GTK_PACKER (widget);
+ container = GTK_CONTAINER (widget);
+
x = y = 0;
widget->allocation = *allocation;
- packer = GTK_PACKER(widget);
- cavityX = widget->allocation.x;
- cavityY = widget->allocation.y;
- cavityWidth = widget->allocation.width;
- cavityHeight = widget->allocation.height;
- list = g_list_first(packer->children);
+ cavityX = widget->allocation.x + container->border_width;
+ cavityY = widget->allocation.y + container->border_width;
+ cavityWidth = widget->allocation.width - 2 * container->border_width;
+ cavityHeight = widget->allocation.height - 2 * container->border_width;
+
+ list = g_list_first (packer->children);
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
frameWidth = cavityWidth;
- frameHeight = (child->widget->requisition.height +
+ frameHeight = (child_requisition.height +
2 * child->border_width +
child->pad_y +
child->i_pad_y);
else
{
frameHeight = cavityHeight;
- frameWidth = (child->widget->requisition.width +
+ frameWidth = (child_requisition.width +
2 * child->border_width +
child->pad_x +
child->i_pad_x);
borderX = child->pad_x + 2 * child->border_width;
borderY = child->pad_y + 2 * child->border_width;
- width = (child->widget->requisition.width +
+ width = (child_requisition.width +
2 * child->border_width +
child->i_pad_x);
if ((child->options & GTK_FILL_X) || (width > (frameWidth - borderX)))
width = frameWidth - borderX;
- height = (child->widget->requisition.height +
+ height = (child_requisition.height +
2 * child->border_width +
child->i_pad_y);
if ((child->options & GTK_FILL_Y) || (height > (frameHeight - borderY)))
}
static void
-gtk_packer_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_packer_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkPacker *packer;
GtkPackerChild *child;
packer = GTK_PACKER (container);
- children = g_list_first(packer->children);
+ children = g_list_first (packer->children);
while (children != NULL)
{
child = children->data;
projects / ~andy / gtk / blobdiff