src/gtk/win_gtk.c

/* ///////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/win_gtk.c
// Purpose:     Native GTK+ widget for wxWidgets, based on GtkLayout and
//              GtkFixed. It makes use of the gravity window property and
//              therefore does not work with GTK 1.0.
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWidgets licence
/////////////////////////////////////////////////////////////////////////// */

#ifdef VMS
#define XCheckIfEvent XCHECKIFEVENT
#endif

#include "wx/platform.h"
#include "wx/gtk/win_gtk.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef struct _GtkPizzaAdjData  GtkPizzaAdjData;

struct _GtkPizzaAdjData
{
    gint dx;
    gint dy;
};

static void gtk_pizza_class_init    (GtkPizzaClass    *klass);
static void gtk_pizza_init          (GtkPizza         *pizza);

static void gtk_pizza_realize       (GtkWidget        *widget);
static void gtk_pizza_unrealize     (GtkWidget        *widget);

static void gtk_pizza_map           (GtkWidget        *widget);

static void gtk_pizza_size_request  (GtkWidget        *widget,
                                     GtkRequisition   *requisition);
static void gtk_pizza_size_allocate (GtkWidget        *widget,
                                     GtkAllocation    *allocation);
static gint gtk_pizza_expose        (GtkWidget        *widget,
                                     GdkEventExpose   *event);
static void gtk_pizza_style_set     (GtkWidget *widget,
                                     GtkStyle  *previous_style);
static void gtk_pizza_add           (GtkContainer     *container,
                                     GtkWidget        *widget);
static void gtk_pizza_remove        (GtkContainer     *container,
                                     GtkWidget        *widget);
static void gtk_pizza_forall        (GtkContainer     *container,
                                     gboolean          include_internals,
                                     GtkCallback       callback,
                                     gpointer          callback_data);

static void     gtk_pizza_allocate_child     (GtkPizza      *pizza,
                                              GtkPizzaChild *child);
static void     gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
                                                      gpointer   cb_data);

static GtkType gtk_pizza_child_type (GtkContainer     *container);

static void  gtk_pizza_scroll_set_adjustments (GtkPizza      *pizza,
                                               GtkAdjustment *hadj,
                                               GtkAdjustment *vadj);

static GtkWidgetClass* pizza_parent_class;

GtkType
gtk_pizza_get_type ()
{
    static GtkType pizza_type = 0;

    if (!pizza_type)
    {
        static const GTypeInfo pizza_info =
        {
            sizeof (GtkPizzaClass),
            NULL,           /* base_init */
            NULL,           /* base_finalize */
            (GClassInitFunc) gtk_pizza_class_init,
            NULL,           /* class_finalize */
            NULL,           /* class_data */
            sizeof (GtkPizza),
            16,             /* n_preallocs */
            (GInstanceInitFunc) gtk_pizza_init,
            NULL
        };
        pizza_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkPizza", &pizza_info, (GTypeFlags)0);
    }

    return pizza_type;
}

/* Marshaller needed for set_scroll_adjustments signal,
   generated with GLib-2.4.6 glib-genmarshal */
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
static void
g_cclosure_user_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
                                             GValue       *return_value,
                                             guint         n_param_values,
                                             const GValue *param_values,
                                             gpointer      invocation_hint,
                                             gpointer      marshal_data)
{
  typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
                                                    gpointer     arg_1,
                                                    gpointer     arg_2,
                                                    gpointer     data2);
  register GMarshalFunc_VOID__OBJECT_OBJECT callback;
  register GCClosure *cc = (GCClosure*) closure;
  register gpointer data1, data2;

  g_return_if_fail (n_param_values == 3);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }
  callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);

  callback (data1,
            g_marshal_value_peek_object (param_values + 1),
            g_marshal_value_peek_object (param_values + 2),
            data2);
}

static void
gtk_pizza_class_init (GtkPizzaClass *klass)
{
    GtkObjectClass *object_class;
    GtkWidgetClass *widget_class;
    GtkContainerClass *container_class;

    object_class = (GtkObjectClass*) klass;
    widget_class = (GtkWidgetClass*) klass;
    container_class = (GtkContainerClass*) klass;
    pizza_parent_class = gtk_type_class (GTK_TYPE_CONTAINER);

    widget_class->map = gtk_pizza_map;
    widget_class->realize = gtk_pizza_realize;
    widget_class->unrealize = gtk_pizza_unrealize;
    widget_class->size_request = gtk_pizza_size_request;
    widget_class->size_allocate = gtk_pizza_size_allocate;
    widget_class->expose_event = gtk_pizza_expose;
    widget_class->style_set = gtk_pizza_style_set;

    container_class->add = gtk_pizza_add;
    container_class->remove = gtk_pizza_remove;
    container_class->forall = gtk_pizza_forall;

    container_class->child_type = gtk_pizza_child_type;

    klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;

    widget_class->set_scroll_adjustments_signal =
        g_signal_new(
            "set_scroll_adjustments",
            G_TYPE_FROM_CLASS(object_class),
            G_SIGNAL_RUN_LAST,
            G_STRUCT_OFFSET(GtkPizzaClass, set_scroll_adjustments),
            NULL,
            NULL,
            g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
            G_TYPE_NONE,
            2,
            GTK_TYPE_ADJUSTMENT,
            GTK_TYPE_ADJUSTMENT);
}

static GtkType
gtk_pizza_child_type (GtkContainer     *container)
{
    return GTK_TYPE_WIDGET;
}

static void
gtk_pizza_init (GtkPizza *pizza)
{
    GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);

    pizza->shadow_type = GTK_MYSHADOW_NONE;

    pizza->children = NULL;

    pizza->bin_window = NULL;

    pizza->m_xoffset = 0;
    pizza->m_yoffset = 0;

    pizza->m_width = -1;
}

GtkWidget*
gtk_pizza_new ()
{
    GtkPizza *pizza;

    pizza = g_object_new (gtk_pizza_get_type (), NULL);

    return GTK_WIDGET (pizza);
}

gint       gtk_pizza_get_xoffset     (GtkPizza          *pizza)
{
    g_return_val_if_fail ( (pizza != NULL), -1 );
    g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );

    return pizza->m_xoffset;
}

gint       gtk_pizza_get_yoffset     (GtkPizza          *pizza)
{
    g_return_val_if_fail ( (pizza != NULL), -1 );
    g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );

    return pizza->m_yoffset;
}

void       gtk_pizza_set_xoffset     (GtkPizza          *pizza, gint xoffset)
{
    g_return_if_fail (pizza != NULL);
    g_return_if_fail (GTK_IS_PIZZA (pizza));

    pizza->m_xoffset = xoffset;
    // do something
}

void       gtk_pizza_set_yoffset     (GtkPizza          *pizza, gint yoffset)
{
    g_return_if_fail (pizza != NULL);
    g_return_if_fail (GTK_IS_PIZZA (pizza));

    pizza->m_xoffset = yoffset;
    // do something
}

gint       gtk_pizza_get_rtl_offset  (GtkPizza          *pizza)
{
    gint width;

    g_return_val_if_fail ( (pizza != NULL), 0 );
    g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), 0 );

    if (!pizza->bin_window) return 0;

    gdk_window_get_geometry( pizza->bin_window, NULL, NULL, &width, NULL, NULL );

    return width;
}


static void
gtk_pizza_scroll_set_adjustments (GtkPizza     *pizza,
                                    GtkAdjustment  *hadj,
                                    GtkAdjustment  *vadj)
{
   /* We handle scrolling in the wxScrolledWindow, not here. */
}

void
gtk_pizza_set_shadow_type (GtkPizza        *pizza,
                           GtkMyShadowType  type)
{
    g_return_if_fail (pizza != NULL);
    g_return_if_fail (GTK_IS_PIZZA (pizza));

    if (pizza->shadow_type != type)
    {
        pizza->shadow_type = type;

        if (GTK_WIDGET_VISIBLE (pizza))
        {
            gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
            gtk_widget_queue_draw (GTK_WIDGET (pizza));
        }
    }
}

void
gtk_pizza_put (GtkPizza   *pizza,
               GtkWidget  *widget,
               gint        x,
               gint        y,
               gint        width,
               gint        height)
{
    GtkPizzaChild *child_info;

    g_return_if_fail (pizza != NULL);
    g_return_if_fail (GTK_IS_PIZZA (pizza));
    g_return_if_fail (widget != NULL);

    if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
    {
        // reverse horizontal placement
        x = pizza->m_width - x - width;
    }

    child_info = g_new (GtkPizzaChild, 1);

    child_info->widget = widget;
    child_info->x = x;
    child_info->y = y;
    child_info->width = width;
    child_info->height = height;

    if (GTK_IS_PIZZA(widget))
        GTK_PIZZA(widget)->m_width = width;

    pizza->children = g_list_append (pizza->children, child_info);

    if (GTK_WIDGET_REALIZED (pizza))
      gtk_widget_set_parent_window (widget, pizza->bin_window);

    gtk_widget_set_parent (widget, GTK_WIDGET (pizza));

    gtk_widget_set_size_request (widget, width, height);
}

void
gtk_pizza_set_size (GtkPizza   *pizza,
                    GtkWidget  *widget,
                    gint        x,
                    gint        y,
                    gint        width,
                    gint        height)
{
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (pizza != NULL);
    g_return_if_fail (GTK_IS_PIZZA (pizza));
    g_return_if_fail (widget != NULL);

#ifndef WX_WARN_ILLEGAL_SETSIZE
    /* this really shouldn't happen -- but it does, a lot, right now and we
       can't pass negative values to gtk_widget_set_size_request() without getting
       a warning printed out, so filter them out here */
    if ( width < 0 )
        width = 0;
    if ( height < 0 )
        height = 0;
#endif

    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

        if (child->widget == widget)
        {
            gint new_x = x;
            if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
            {
                // reverse horizontal placement
                new_x = pizza->m_width - new_x - width;
            }

            if ((child->x == new_x) &&
                (child->y == y) &&
                (child->width == width) &&
                (child->height == height)) return;

            child->x = new_x;
            child->y = y;
            child->width = width;
            child->height = height;

            if (GTK_IS_PIZZA(widget))
                GTK_PIZZA(widget)->m_width = width;

            gtk_widget_set_size_request (widget, width, height);

            return;
        }
    }
}

static void
gtk_pizza_map (GtkWidget *widget)
{
    GtkPizza *pizza;
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_PIZZA (widget));

    GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
    pizza = GTK_PIZZA (widget);

    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

        if ( GTK_WIDGET_VISIBLE (child->widget) &&
            !GTK_WIDGET_MAPPED (child->widget) )
        {
            gtk_widget_map (child->widget);
        }
    }

    gdk_window_show (widget->window);
    gdk_window_show (pizza->bin_window);
}

static void
gtk_pizza_realize (GtkWidget *widget)
{
    GtkPizza *pizza;
    GdkWindowAttr attributes;
    gint attributes_mask;
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_PIZZA (widget));

    pizza = GTK_PIZZA (widget);
    GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

    attributes.window_type = GDK_WINDOW_CHILD;

    attributes.x = widget->allocation.x;
    attributes.y = widget->allocation.y;
    attributes.width = widget->allocation.width;
    attributes.height = widget->allocation.height;

#ifndef __WXUNIVERSAL__
    if (pizza->shadow_type == GTK_MYSHADOW_NONE)
    {
        /* no border, no changes to sizes */
    }
    else if (pizza->shadow_type == GTK_MYSHADOW_THIN)
    {
        /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
        attributes.x += 1;
        attributes.y += 1;
        attributes.width -= 2;
        attributes.height -= 2;
    }
    else
    {
        /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
        /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
        attributes.x += 2;
        attributes.y += 2;
        attributes.width -= 4;
        attributes.height -= 4;
    }
#endif /* __WXUNIVERSAL__ */

    /* minimal size */
    if (attributes.width < 2) attributes.width = 2;
    if (attributes.height < 2) attributes.height = 2;

    attributes.wclass = GDK_INPUT_OUTPUT;
    attributes.visual = gtk_widget_get_visual (widget);
    attributes.colormap = gtk_widget_get_colormap (widget);
    attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

    widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
                                     &attributes, attributes_mask);
    gdk_window_set_user_data (widget->window, widget);

    attributes.x = 0;
    attributes.y = 0;

    attributes.event_mask = gtk_widget_get_events (widget);
    attributes.event_mask |= GDK_EXPOSURE_MASK              |
                             GDK_SCROLL_MASK                |
                             GDK_POINTER_MOTION_MASK        |
                             GDK_POINTER_MOTION_HINT_MASK   |
                             GDK_BUTTON_MOTION_MASK         |
                             GDK_BUTTON1_MOTION_MASK        |
                             GDK_BUTTON2_MOTION_MASK        |
                             GDK_BUTTON3_MOTION_MASK        |
                             GDK_BUTTON_PRESS_MASK          |
                             GDK_BUTTON_RELEASE_MASK        |
                             GDK_KEY_PRESS_MASK             |
                             GDK_KEY_RELEASE_MASK           |
                             GDK_ENTER_NOTIFY_MASK          |
                             GDK_LEAVE_NOTIFY_MASK          |
                             GDK_FOCUS_CHANGE_MASK;

    pizza->bin_window = gdk_window_new(widget->window,
                                          &attributes, attributes_mask);
    gdk_window_set_user_data (pizza->bin_window, widget);

    widget->style = gtk_style_attach (widget->style, widget->window);
    gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
    gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );

/*
    gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
    gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
*/

    /* cannot be done before realisation */
    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

        gtk_widget_set_parent_window (child->widget, pizza->bin_window);
    }
}

static void
gtk_pizza_unrealize (GtkWidget *widget)
{
    GtkPizza *pizza;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_PIZZA (widget));

    pizza = GTK_PIZZA (widget);

    gdk_window_set_user_data (pizza->bin_window, NULL);
    gdk_window_destroy (pizza->bin_window);
    pizza->bin_window = NULL;

    if (pizza_parent_class->unrealize)
        pizza_parent_class->unrealize(widget);
}

static void
gtk_pizza_size_request (GtkWidget      *widget,
                        GtkRequisition *requisition)
{
    GtkPizza *pizza;
    GtkPizzaChild *child;
    GList *children;
    GtkRequisition child_requisition;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_PIZZA (widget));
    g_return_if_fail (requisition != NULL);

    pizza = GTK_PIZZA (widget);

    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

        if (GTK_WIDGET_VISIBLE (child->widget))
        {
            gtk_widget_size_request (child->widget, &child_requisition);
        }
    }

    /* request very little, I'm not sure if requesting nothing
       will always have positive effects on stability... */
    requisition->width = 2;
    requisition->height = 2;
}

static void
gtk_pizza_size_allocate (GtkWidget     *widget,
                         GtkAllocation *allocation)
{
    GtkPizza *pizza;
    gint border;
    gint x,y,w,h;
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_PIZZA(widget));
    g_return_if_fail (allocation != NULL);

    pizza = GTK_PIZZA (widget);

    widget->allocation = *allocation;

    if (pizza->shadow_type == GTK_MYSHADOW_NONE)
        border = 0;
    else
    if (pizza->shadow_type == GTK_MYSHADOW_THIN)
        border = 1;
    else
        border = 2;

    x = allocation->x + border;
    y = allocation->y + border;
    w = allocation->width - border*2;
    h = allocation->height - border*2;
    if (w < 0)
        w = 0;
    if (h < 0)
        h = 0;

    if (GTK_WIDGET_REALIZED (widget))
    {
        gdk_window_move_resize( widget->window, x, y, w, h );
        gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
    }

    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

        gtk_pizza_allocate_child (pizza, child);
    }
}

static gint
gtk_pizza_expose (GtkWidget      *widget,
                  GdkEventExpose *event)
{
    GtkPizza *pizza;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    pizza = (GtkPizza*)widget;

    if (event->window != pizza->bin_window)
        return FALSE;

    pizza_parent_class->expose_event(widget, event);

    return FALSE;
}

static void
gtk_pizza_style_set(GtkWidget *widget, GtkStyle  *previous_style)
{
    if (GTK_WIDGET_REALIZED(widget))
    {
        gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
        gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
    }

    pizza_parent_class->style_set(widget, previous_style);
}

static void
gtk_pizza_add (GtkContainer *container,
               GtkWidget    *widget)
{
    g_return_if_fail (container != NULL);
    g_return_if_fail (GTK_IS_PIZZA (container));
    g_return_if_fail (widget != NULL);

    gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
}

static void
gtk_pizza_remove (GtkContainer *container,
                  GtkWidget    *widget)
{
    GtkPizza *pizza;
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (container != NULL);
    g_return_if_fail (GTK_IS_PIZZA (container));
    g_return_if_fail (widget != NULL);

    pizza = GTK_PIZZA (container);

    children = pizza->children;
    while (children)
    {
        child = children->data;

        if (child->widget == widget)
        {
            gtk_widget_unparent (widget);

            /* security checks */
            g_return_if_fail (GTK_IS_WIDGET (widget));

            pizza->children = g_list_remove_link (pizza->children, children);
            g_list_free (children);
            g_free (child);

            /* security checks */
            g_return_if_fail (GTK_IS_WIDGET (widget));

            break;
        }

        children = children->next;
    }
}

static void
gtk_pizza_forall (GtkContainer *container,
                  gboolean      include_internals,
                  GtkCallback   callback,
                  gpointer      callback_data)
{
    GtkPizza *pizza;
    GtkPizzaChild *child;
    GList *children;

    g_return_if_fail (container != NULL);
    g_return_if_fail (GTK_IS_PIZZA (container));
    g_return_if_fail (callback != (GtkCallback)NULL);

    pizza = GTK_PIZZA (container);

    children = pizza->children;
    while (children)
    {
        child = children->data;
        children = children->next;

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

static void
gtk_pizza_allocate_child (GtkPizza      *pizza,
                          GtkPizzaChild *child)
{
    GtkAllocation allocation;
    GtkRequisition requisition;

    allocation.x = child->x - pizza->m_xoffset;
    allocation.y = child->y - pizza->m_yoffset;
    gtk_widget_get_child_requisition (child->widget, &requisition);
    allocation.width = requisition.width;
    allocation.height = requisition.height;

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

static void
gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
                                       gpointer   cb_data)
{
    GtkPizzaAdjData *data = cb_data;

    widget->allocation.x += data->dx;
    widget->allocation.y += data->dy;

    if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
    {
        gtk_container_forall (GTK_CONTAINER (widget),
                          gtk_pizza_adjust_allocations_recurse,
                          cb_data);
    }
}

static void
gtk_pizza_adjust_allocations (GtkPizza *pizza,
                               gint       dx,
                               gint       dy)
{
    GList *tmp_list;
    GtkPizzaAdjData data;

    data.dx = dx;
    data.dy = dy;

    tmp_list = pizza->children;
    while (tmp_list)
    {
        GtkPizzaChild *child = tmp_list->data;
        tmp_list = tmp_list->next;

        child->widget->allocation.x += dx;
        child->widget->allocation.y += dy;

        if (GTK_WIDGET_NO_WINDOW (child->widget) &&
            GTK_IS_CONTAINER (child->widget))
        {
            gtk_container_forall (GTK_CONTAINER (child->widget),
                                  gtk_pizza_adjust_allocations_recurse,
                                  &data);
        }
    }
}

void
gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
{
    pizza->m_xoffset += dx;
    pizza->m_yoffset += dy;

    gtk_pizza_adjust_allocations (pizza, -dx, -dy);

    if (pizza->bin_window)
        gdk_window_scroll( pizza->bin_window, -dx, -dy );
}

#ifdef __cplusplus
}
#endif /* __cplusplus */
Commit	Line	Data
	1	/* ///////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/win_gtk.c
	3	// Purpose: Native GTK+ widget for wxWidgets, based on GtkLayout and
	4	// GtkFixed. It makes use of the gravity window property and
	5	// therefore does not work with GTK 1.0.
	6	// Author: Robert Roebling
	7	// Id: $Id$
	8	// Copyright: (c) 1998 Robert Roebling
	9	// Licence: wxWidgets licence
	10	/////////////////////////////////////////////////////////////////////////// */
	11
	12	#ifdef VMS
	13	#define XCheckIfEvent XCHECKIFEVENT
	14	#endif
	15
	16	#include "wx/platform.h"
	17	#include "wx/gtk/win_gtk.h"
	18
	19	#ifdef __cplusplus
	20	extern "C" {
	21	#endif /* __cplusplus */
	22
	23	typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
	24
	25	struct _GtkPizzaAdjData
	26	{
	27	gint dx;
	28	gint dy;
	29	};
	30
	31	static void gtk_pizza_class_init (GtkPizzaClass *klass);
	32	static void gtk_pizza_init (GtkPizza *pizza);
	33
	34	static void gtk_pizza_realize (GtkWidget *widget);
	35	static void gtk_pizza_unrealize (GtkWidget *widget);
	36
	37	static void gtk_pizza_map (GtkWidget *widget);
	38
	39	static void gtk_pizza_size_request (GtkWidget *widget,
	40	GtkRequisition *requisition);
	41	static void gtk_pizza_size_allocate (GtkWidget *widget,
	42	GtkAllocation *allocation);
	43	static gint gtk_pizza_expose (GtkWidget *widget,
	44	GdkEventExpose *event);
	45	static void gtk_pizza_style_set (GtkWidget *widget,
	46	GtkStyle *previous_style);
	47	static void gtk_pizza_add (GtkContainer *container,
	48	GtkWidget *widget);
	49	static void gtk_pizza_remove (GtkContainer *container,
	50	GtkWidget *widget);
	51	static void gtk_pizza_forall (GtkContainer *container,
	52	gboolean include_internals,
	53	GtkCallback callback,
	54	gpointer callback_data);
	55
	56	static void gtk_pizza_allocate_child (GtkPizza *pizza,
	57	GtkPizzaChild *child);
	58	static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
	59	gpointer cb_data);
	60
	61	static GtkType gtk_pizza_child_type (GtkContainer *container);
	62
	63	static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
	64	GtkAdjustment *hadj,
	65	GtkAdjustment *vadj);
	66
	67	static GtkWidgetClass* pizza_parent_class;
	68
	69	GtkType
	70	gtk_pizza_get_type ()
	71	{
	72	static GtkType pizza_type = 0;
	73
	74	if (!pizza_type)
	75	{
	76	static const GTypeInfo pizza_info =
	77	{
	78	sizeof (GtkPizzaClass),
	79	NULL, /* base_init */
	80	NULL, /* base_finalize */
	81	(GClassInitFunc) gtk_pizza_class_init,
	82	NULL, /* class_finalize */
	83	NULL, /* class_data */
	84	sizeof (GtkPizza),
	85	16, /* n_preallocs */
	86	(GInstanceInitFunc) gtk_pizza_init,
	87	NULL
	88	};
	89	pizza_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkPizza", &pizza_info, (GTypeFlags)0);
	90	}
	91
	92	return pizza_type;
	93	}
	94
	95	/* Marshaller needed for set_scroll_adjustments signal,
	96	generated with GLib-2.4.6 glib-genmarshal */
	97	#define g_marshal_value_peek_object(v) g_value_get_object (v)
	98	static void
	99	g_cclosure_user_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
	100	GValue *return_value,
	101	guint n_param_values,
	102	const GValue *param_values,
	103	gpointer invocation_hint,
	104	gpointer marshal_data)
	105	{
	106	typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
	107	gpointer arg_1,
	108	gpointer arg_2,
	109	gpointer data2);
	110	register GMarshalFunc_VOID__OBJECT_OBJECT callback;
	111	register GCClosure cc = (GCClosure) closure;
	112	register gpointer data1, data2;
	113
	114	g_return_if_fail (n_param_values == 3);
	115
	116	if (G_CCLOSURE_SWAP_DATA (closure))
	117	{
	118	data1 = closure->data;
	119	data2 = g_value_peek_pointer (param_values + 0);
	120	}
	121	else
	122	{
	123	data1 = g_value_peek_pointer (param_values + 0);
	124	data2 = closure->data;
	125	}
	126	callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
	127
	128	callback (data1,
	129	g_marshal_value_peek_object (param_values + 1),
	130	g_marshal_value_peek_object (param_values + 2),
	131	data2);
	132	}
	133
	134	static void
	135	gtk_pizza_class_init (GtkPizzaClass *klass)
	136	{
	137	GtkObjectClass *object_class;
	138	GtkWidgetClass *widget_class;
	139	GtkContainerClass *container_class;
	140
	141	object_class = (GtkObjectClass*) klass;
	142	widget_class = (GtkWidgetClass*) klass;
	143	container_class = (GtkContainerClass*) klass;
	144	pizza_parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
	145
	146	widget_class->map = gtk_pizza_map;
	147	widget_class->realize = gtk_pizza_realize;
	148	widget_class->unrealize = gtk_pizza_unrealize;
	149	widget_class->size_request = gtk_pizza_size_request;
	150	widget_class->size_allocate = gtk_pizza_size_allocate;
	151	widget_class->expose_event = gtk_pizza_expose;
	152	widget_class->style_set = gtk_pizza_style_set;
	153
	154	container_class->add = gtk_pizza_add;
	155	container_class->remove = gtk_pizza_remove;
	156	container_class->forall = gtk_pizza_forall;
	157
	158	container_class->child_type = gtk_pizza_child_type;
	159
	160	klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
	161
	162	widget_class->set_scroll_adjustments_signal =
	163	g_signal_new(
	164	"set_scroll_adjustments",
	165	G_TYPE_FROM_CLASS(object_class),
	166	G_SIGNAL_RUN_LAST,
	167	G_STRUCT_OFFSET(GtkPizzaClass, set_scroll_adjustments),
	168	NULL,
	169	NULL,
	170	g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
	171	G_TYPE_NONE,
	172	2,
	173	GTK_TYPE_ADJUSTMENT,
	174	GTK_TYPE_ADJUSTMENT);
	175	}
	176
	177	static GtkType
	178	gtk_pizza_child_type (GtkContainer *container)
	179	{
	180	return GTK_TYPE_WIDGET;
	181	}
	182
	183	static void
	184	gtk_pizza_init (GtkPizza *pizza)
	185	{
	186	GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
	187
	188	pizza->shadow_type = GTK_MYSHADOW_NONE;
	189
	190	pizza->children = NULL;
	191
	192	pizza->bin_window = NULL;
	193
	194	pizza->m_xoffset = 0;
	195	pizza->m_yoffset = 0;
	196
	197	pizza->m_width = -1;
	198	}
	199
	200	GtkWidget*
	201	gtk_pizza_new ()
	202	{
	203	GtkPizza *pizza;
	204
	205	pizza = g_object_new (gtk_pizza_get_type (), NULL);
	206
	207	return GTK_WIDGET (pizza);
	208	}
	209
	210	gint gtk_pizza_get_xoffset (GtkPizza *pizza)
	211	{
	212	g_return_val_if_fail ( (pizza != NULL), -1 );
	213	g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
	214
	215	return pizza->m_xoffset;
	216	}
	217
	218	gint gtk_pizza_get_yoffset (GtkPizza *pizza)
	219	{
	220	g_return_val_if_fail ( (pizza != NULL), -1 );
	221	g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
	222
	223	return pizza->m_yoffset;
	224	}
	225
	226	void gtk_pizza_set_xoffset (GtkPizza *pizza, gint xoffset)
	227	{
	228	g_return_if_fail (pizza != NULL);
	229	g_return_if_fail (GTK_IS_PIZZA (pizza));
	230
	231	pizza->m_xoffset = xoffset;
	232	// do something
	233	}
	234
	235	void gtk_pizza_set_yoffset (GtkPizza *pizza, gint yoffset)
	236	{
	237	g_return_if_fail (pizza != NULL);
	238	g_return_if_fail (GTK_IS_PIZZA (pizza));
	239
	240	pizza->m_xoffset = yoffset;
	241	// do something
	242	}
	243
	244	gint gtk_pizza_get_rtl_offset (GtkPizza *pizza)
	245	{
	246	gint width;
	247
	248	g_return_val_if_fail ( (pizza != NULL), 0 );
	249	g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), 0 );
	250
	251	if (!pizza->bin_window) return 0;
	252
	253	gdk_window_get_geometry( pizza->bin_window, NULL, NULL, &width, NULL, NULL );
	254
	255	return width;
	256	}
	257
	258
	259	static void
	260	gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
	261	GtkAdjustment *hadj,
	262	GtkAdjustment *vadj)
	263	{
	264	/* We handle scrolling in the wxScrolledWindow, not here. */
	265	}
	266
	267	void
	268	gtk_pizza_set_shadow_type (GtkPizza *pizza,
	269	GtkMyShadowType type)
	270	{
	271	g_return_if_fail (pizza != NULL);
	272	g_return_if_fail (GTK_IS_PIZZA (pizza));
	273
	274	if (pizza->shadow_type != type)
	275	{
	276	pizza->shadow_type = type;
	277
	278	if (GTK_WIDGET_VISIBLE (pizza))
	279	{
	280	gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
	281	gtk_widget_queue_draw (GTK_WIDGET (pizza));
	282	}
	283	}
	284	}
	285
	286	void
	287	gtk_pizza_put (GtkPizza *pizza,
	288	GtkWidget *widget,
	289	gint x,
	290	gint y,
	291	gint width,
	292	gint height)
	293	{
	294	GtkPizzaChild *child_info;
	295
	296	g_return_if_fail (pizza != NULL);
	297	g_return_if_fail (GTK_IS_PIZZA (pizza));
	298	g_return_if_fail (widget != NULL);
	299
	300	if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
	301	{
	302	// reverse horizontal placement
	303	x = pizza->m_width - x - width;
	304	}
	305
	306	child_info = g_new (GtkPizzaChild, 1);
	307
	308	child_info->widget = widget;
	309	child_info->x = x;
	310	child_info->y = y;
	311	child_info->width = width;
	312	child_info->height = height;
	313
	314	if (GTK_IS_PIZZA(widget))
	315	GTK_PIZZA(widget)->m_width = width;
	316
	317	pizza->children = g_list_append (pizza->children, child_info);
	318
	319	if (GTK_WIDGET_REALIZED (pizza))
	320	gtk_widget_set_parent_window (widget, pizza->bin_window);
	321
	322	gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
	323
	324	gtk_widget_set_size_request (widget, width, height);
	325	}
	326
	327	void
	328	gtk_pizza_set_size (GtkPizza *pizza,
	329	GtkWidget *widget,
	330	gint x,
	331	gint y,
	332	gint width,
	333	gint height)
	334	{
	335	GtkPizzaChild *child;
	336	GList *children;
	337
	338	g_return_if_fail (pizza != NULL);
	339	g_return_if_fail (GTK_IS_PIZZA (pizza));
	340	g_return_if_fail (widget != NULL);
	341
	342	#ifndef WX_WARN_ILLEGAL_SETSIZE
	343	/* this really shouldn't happen -- but it does, a lot, right now and we
	344	can't pass negative values to gtk_widget_set_size_request() without getting
	345	a warning printed out, so filter them out here */
	346	if ( width < 0 )
	347	width = 0;
	348	if ( height < 0 )
	349	height = 0;
	350	#endif
	351
	352	children = pizza->children;
	353	while (children)
	354	{
	355	child = children->data;
	356	children = children->next;
	357
	358	if (child->widget == widget)
	359	{
	360	gint new_x = x;
	361	if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
	362	{
	363	// reverse horizontal placement
	364	new_x = pizza->m_width - new_x - width;
	365	}
	366
	367	if ((child->x == new_x) &&
	368	(child->y == y) &&
	369	(child->width == width) &&
	370	(child->height == height)) return;
	371
	372	child->x = new_x;
	373	child->y = y;
	374	child->width = width;
	375	child->height = height;
	376
	377	if (GTK_IS_PIZZA(widget))
	378	GTK_PIZZA(widget)->m_width = width;
	379
	380	gtk_widget_set_size_request (widget, width, height);
	381
	382	return;
	383	}
	384	}
	385	}
	386
	387	static void
	388	gtk_pizza_map (GtkWidget *widget)
	389	{
	390	GtkPizza *pizza;
	391	GtkPizzaChild *child;
	392	GList *children;
	393
	394	g_return_if_fail (widget != NULL);
	395	g_return_if_fail (GTK_IS_PIZZA (widget));
	396
	397	GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
	398	pizza = GTK_PIZZA (widget);
	399
	400	children = pizza->children;
	401	while (children)
	402	{
	403	child = children->data;
	404	children = children->next;
	405
	406	if ( GTK_WIDGET_VISIBLE (child->widget) &&
	407	!GTK_WIDGET_MAPPED (child->widget) )
	408	{
	409	gtk_widget_map (child->widget);
	410	}
	411	}
	412
	413	gdk_window_show (widget->window);
	414	gdk_window_show (pizza->bin_window);
	415	}
	416
	417	static void
	418	gtk_pizza_realize (GtkWidget *widget)
	419	{
	420	GtkPizza *pizza;
	421	GdkWindowAttr attributes;
	422	gint attributes_mask;
	423	GtkPizzaChild *child;
	424	GList *children;
	425
	426	g_return_if_fail (widget != NULL);
	427	g_return_if_fail (GTK_IS_PIZZA (widget));
	428
	429	pizza = GTK_PIZZA (widget);
	430	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
	431
	432	attributes.window_type = GDK_WINDOW_CHILD;
	433
	434	attributes.x = widget->allocation.x;
	435	attributes.y = widget->allocation.y;
	436	attributes.width = widget->allocation.width;
	437	attributes.height = widget->allocation.height;
	438
	439	#ifndef __WXUNIVERSAL__
	440	if (pizza->shadow_type == GTK_MYSHADOW_NONE)
	441	{
	442	/* no border, no changes to sizes */
	443	}
	444	else if (pizza->shadow_type == GTK_MYSHADOW_THIN)
	445	{
	446	/* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
	447	attributes.x += 1;
	448	attributes.y += 1;
	449	attributes.width -= 2;
	450	attributes.height -= 2;
	451	}
	452	else
	453	{
	454	/* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
	455	/* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
	456	attributes.x += 2;
	457	attributes.y += 2;
	458	attributes.width -= 4;
	459	attributes.height -= 4;
	460	}
	461	#endif /* __WXUNIVERSAL__ */
	462
	463	/* minimal size */
	464	if (attributes.width < 2) attributes.width = 2;
	465	if (attributes.height < 2) attributes.height = 2;
	466
	467	attributes.wclass = GDK_INPUT_OUTPUT;
	468	attributes.visual = gtk_widget_get_visual (widget);
	469	attributes.colormap = gtk_widget_get_colormap (widget);
	470	attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
	471	attributes_mask = GDK_WA_X \| GDK_WA_Y \| GDK_WA_VISUAL \| GDK_WA_COLORMAP;
	472
	473	widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
	474	&attributes, attributes_mask);
	475	gdk_window_set_user_data (widget->window, widget);
	476
	477	attributes.x = 0;
	478	attributes.y = 0;
	479
	480	attributes.event_mask = gtk_widget_get_events (widget);
	481	attributes.event_mask \|= GDK_EXPOSURE_MASK \|
	482	GDK_SCROLL_MASK \|
	483	GDK_POINTER_MOTION_MASK \|
	484	GDK_POINTER_MOTION_HINT_MASK \|
	485	GDK_BUTTON_MOTION_MASK \|
	486	GDK_BUTTON1_MOTION_MASK \|
	487	GDK_BUTTON2_MOTION_MASK \|
	488	GDK_BUTTON3_MOTION_MASK \|
	489	GDK_BUTTON_PRESS_MASK \|
	490	GDK_BUTTON_RELEASE_MASK \|
	491	GDK_KEY_PRESS_MASK \|
	492	GDK_KEY_RELEASE_MASK \|
	493	GDK_ENTER_NOTIFY_MASK \|
	494	GDK_LEAVE_NOTIFY_MASK \|
	495	GDK_FOCUS_CHANGE_MASK;
	496
	497	pizza->bin_window = gdk_window_new(widget->window,
	498	&attributes, attributes_mask);
	499	gdk_window_set_user_data (pizza->bin_window, widget);
	500
	501	widget->style = gtk_style_attach (widget->style, widget->window);
	502	gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
	503	gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
	504
	505	/*
	506	gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
	507	gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
	508	*/
	509
	510	/* cannot be done before realisation */
	511	children = pizza->children;
	512	while (children)
	513	{
	514	child = children->data;
	515	children = children->next;
	516
	517	gtk_widget_set_parent_window (child->widget, pizza->bin_window);
	518	}
	519	}
	520
	521	static void
	522	gtk_pizza_unrealize (GtkWidget *widget)
	523	{
	524	GtkPizza *pizza;
	525
	526	g_return_if_fail (widget != NULL);
	527	g_return_if_fail (GTK_IS_PIZZA (widget));
	528
	529	pizza = GTK_PIZZA (widget);
	530
	531	gdk_window_set_user_data (pizza->bin_window, NULL);
	532	gdk_window_destroy (pizza->bin_window);
	533	pizza->bin_window = NULL;
	534
	535	if (pizza_parent_class->unrealize)
	536	pizza_parent_class->unrealize(widget);
	537	}
	538
	539	static void
	540	gtk_pizza_size_request (GtkWidget *widget,
	541	GtkRequisition *requisition)
	542	{
	543	GtkPizza *pizza;
	544	GtkPizzaChild *child;
	545	GList *children;
	546	GtkRequisition child_requisition;
	547
	548	g_return_if_fail (widget != NULL);
	549	g_return_if_fail (GTK_IS_PIZZA (widget));
	550	g_return_if_fail (requisition != NULL);
	551
	552	pizza = GTK_PIZZA (widget);
	553
	554	children = pizza->children;
	555	while (children)
	556	{
	557	child = children->data;
	558	children = children->next;
	559
	560	if (GTK_WIDGET_VISIBLE (child->widget))
	561	{
	562	gtk_widget_size_request (child->widget, &child_requisition);
	563	}
	564	}
	565
	566	/* request very little, I'm not sure if requesting nothing
	567	will always have positive effects on stability... */
	568	requisition->width = 2;
	569	requisition->height = 2;
	570	}
	571
	572	static void
	573	gtk_pizza_size_allocate (GtkWidget *widget,
	574	GtkAllocation *allocation)
	575	{
	576	GtkPizza *pizza;
	577	gint border;
	578	gint x,y,w,h;
	579	GtkPizzaChild *child;
	580	GList *children;
	581
	582	g_return_if_fail (widget != NULL);
	583	g_return_if_fail (GTK_IS_PIZZA(widget));
	584	g_return_if_fail (allocation != NULL);
	585
	586	pizza = GTK_PIZZA (widget);
	587
	588	widget->allocation = *allocation;
	589
	590	if (pizza->shadow_type == GTK_MYSHADOW_NONE)
	591	border = 0;
	592	else
	593	if (pizza->shadow_type == GTK_MYSHADOW_THIN)
	594	border = 1;
	595	else
	596	border = 2;
	597
	598	x = allocation->x + border;
	599	y = allocation->y + border;
	600	w = allocation->width - border*2;
	601	h = allocation->height - border*2;
	602	if (w < 0)
	603	w = 0;
	604	if (h < 0)
	605	h = 0;
	606
	607	if (GTK_WIDGET_REALIZED (widget))
	608	{
	609	gdk_window_move_resize( widget->window, x, y, w, h );
	610	gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
	611	}
	612
	613	children = pizza->children;
	614	while (children)
	615	{
	616	child = children->data;
	617	children = children->next;
	618
	619	gtk_pizza_allocate_child (pizza, child);
	620	}
	621	}
	622
	623	static gint
	624	gtk_pizza_expose (GtkWidget *widget,
	625	GdkEventExpose *event)
	626	{
	627	GtkPizza *pizza;
	628
	629	g_return_val_if_fail (widget != NULL, FALSE);
	630	g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
	631	g_return_val_if_fail (event != NULL, FALSE);
	632
	633	pizza = (GtkPizza*)widget;
	634
	635	if (event->window != pizza->bin_window)
	636	return FALSE;
	637
	638	pizza_parent_class->expose_event(widget, event);
	639
	640	return FALSE;
	641	}
	642
	643	static void
	644	gtk_pizza_style_set(GtkWidget widget, GtkStyle previous_style)
	645	{
	646	if (GTK_WIDGET_REALIZED(widget))
	647	{
	648	gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
	649	gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
	650	}
	651
	652	pizza_parent_class->style_set(widget, previous_style);
	653	}
	654
	655	static void
	656	gtk_pizza_add (GtkContainer *container,
	657	GtkWidget *widget)
	658	{
	659	g_return_if_fail (container != NULL);
	660	g_return_if_fail (GTK_IS_PIZZA (container));
	661	g_return_if_fail (widget != NULL);
	662
	663	gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
	664	}
	665
	666	static void
	667	gtk_pizza_remove (GtkContainer *container,
	668	GtkWidget *widget)
	669	{
	670	GtkPizza *pizza;
	671	GtkPizzaChild *child;
	672	GList *children;
	673
	674	g_return_if_fail (container != NULL);
	675	g_return_if_fail (GTK_IS_PIZZA (container));
	676	g_return_if_fail (widget != NULL);
	677
	678	pizza = GTK_PIZZA (container);
	679
	680	children = pizza->children;
	681	while (children)
	682	{
	683	child = children->data;
	684
	685	if (child->widget == widget)
	686	{
	687	gtk_widget_unparent (widget);
	688
	689	/* security checks */
	690	g_return_if_fail (GTK_IS_WIDGET (widget));
	691
	692	pizza->children = g_list_remove_link (pizza->children, children);
	693	g_list_free (children);
	694	g_free (child);
	695
	696	/* security checks */
	697	g_return_if_fail (GTK_IS_WIDGET (widget));
	698
	699	break;
	700	}
	701
	702	children = children->next;
	703	}
	704	}
	705
	706	static void
	707	gtk_pizza_forall (GtkContainer *container,
	708	gboolean include_internals,
	709	GtkCallback callback,
	710	gpointer callback_data)
	711	{
	712	GtkPizza *pizza;
	713	GtkPizzaChild *child;
	714	GList *children;
	715
	716	g_return_if_fail (container != NULL);
	717	g_return_if_fail (GTK_IS_PIZZA (container));
	718	g_return_if_fail (callback != (GtkCallback)NULL);
	719
	720	pizza = GTK_PIZZA (container);
	721
	722	children = pizza->children;
	723	while (children)
	724	{
	725	child = children->data;
	726	children = children->next;
	727
	728	(* callback) (child->widget, callback_data);
	729	}
	730	}
	731
	732	static void
	733	gtk_pizza_allocate_child (GtkPizza *pizza,
	734	GtkPizzaChild *child)
	735	{
	736	GtkAllocation allocation;
	737	GtkRequisition requisition;
	738
	739	allocation.x = child->x - pizza->m_xoffset;
	740	allocation.y = child->y - pizza->m_yoffset;
	741	gtk_widget_get_child_requisition (child->widget, &requisition);
	742	allocation.width = requisition.width;
	743	allocation.height = requisition.height;
	744
	745	gtk_widget_size_allocate (child->widget, &allocation);
	746	}
	747
	748	static void
	749	gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
	750	gpointer cb_data)
	751	{
	752	GtkPizzaAdjData *data = cb_data;
	753
	754	widget->allocation.x += data->dx;
	755	widget->allocation.y += data->dy;
	756
	757	if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
	758	{
	759	gtk_container_forall (GTK_CONTAINER (widget),
	760	gtk_pizza_adjust_allocations_recurse,
	761	cb_data);
	762	}
	763	}
	764
	765	static void
	766	gtk_pizza_adjust_allocations (GtkPizza *pizza,
	767	gint dx,
	768	gint dy)
	769	{
	770	GList *tmp_list;
	771	GtkPizzaAdjData data;
	772
	773	data.dx = dx;
	774	data.dy = dy;
	775
	776	tmp_list = pizza->children;
	777	while (tmp_list)
	778	{
	779	GtkPizzaChild *child = tmp_list->data;
	780	tmp_list = tmp_list->next;
	781
	782	child->widget->allocation.x += dx;
	783	child->widget->allocation.y += dy;
	784
	785	if (GTK_WIDGET_NO_WINDOW (child->widget) &&
	786	GTK_IS_CONTAINER (child->widget))
	787	{
	788	gtk_container_forall (GTK_CONTAINER (child->widget),
	789	gtk_pizza_adjust_allocations_recurse,
	790	&data);
	791	}
	792	}
	793	}
	794
	795	void
	796	gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
	797	{
	798	pizza->m_xoffset += dx;
	799	pizza->m_yoffset += dy;
	800
	801	gtk_pizza_adjust_allocations (pizza, -dx, -dy);
	802
	803	if (pizza->bin_window)
	804	gdk_window_scroll( pizza->bin_window, -dx, -dy );
	805	}
	806
	807	#ifdef __cplusplus
	808	}
	809	#endif /* __cplusplus */