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 _GtkPizzaChild GtkPizzaChild;
typedef struct _GtkPizzaClass GtkPizzaClass;
typedef struct _GtkPizzaAdjData  GtkPizzaAdjData;

struct _GtkPizzaClass
{
  GtkContainerClass parent_class;

  void  (*set_scroll_adjustments)   (GtkPizza     *pizza,
                                     GtkAdjustment  *hadjustment,
                                     GtkAdjustment  *vadjustment);
};

struct _GtkPizzaChild
{
    GtkWidget *widget;
    gint x;
    gint y;
};

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 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)
    {
        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->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_SET_FLAGS (pizza, GTK_CAN_FOCUS);
    GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);

    pizza->children = NULL;

    pizza->bin_window = NULL;

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

GtkWidget*
gtk_pizza_new ()
{
    GtkPizza *pizza;

    pizza = g_object_new (gtk_pizza_get_type (), NULL);

    pizza->m_noscroll = FALSE;

    return GTK_WIDGET (pizza);
}

GtkWidget*
gtk_pizza_new_no_scroll ()
{
    GtkPizza *pizza;

    pizza = g_object_new (gtk_pizza_get_type (), NULL);

    pizza->m_noscroll = TRUE;

    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 border;

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

    if (!pizza->bin_window) return 0;

    border = pizza->container.border_width;

    return GTK_WIDGET(pizza)->allocation.width - border*2;
}


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

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);

    child_info = g_new (GtkPizzaChild, 1);

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

    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 );
    if (GTK_WIDGET_REALIZED (pizza))
        gtk_pizza_allocate_child (pizza, child_info);
}

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)
        {
            if (child->x != x || child->y != y)
            {
                child->x = x;
                child->y = y;
                gtk_widget_queue_resize(widget);
            }

            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;
    int border;
    int w, h;

    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;

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

    border = pizza->container.border_width;
    w = attributes.width  - 2 * border;
    h = attributes.height - 2 * border;
    if (w < 2) w = 2;
    if (h < 2) h = 2;

    if (!pizza->m_noscroll)
    {
        attributes.x += border;
        attributes.y += border;
        attributes.width  = w;
        attributes.height = h;
    }

    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;
    if (pizza->m_noscroll)
    {
        attributes.x = border;
        attributes.y = border;
        attributes.width  = w;
        attributes.height = h;
    }

    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;
    gboolean only_resize;

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

    pizza = GTK_PIZZA (widget);

    only_resize = ((widget->allocation.x == allocation->x) &&
                   (widget->allocation.y == allocation->y));
    widget->allocation = *allocation;

    if (GTK_WIDGET_REALIZED(widget))
    {
        border = pizza->container.border_width;

        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 (pizza->m_noscroll)
        {
            if (only_resize)
                gdk_window_resize( widget->window, allocation->width, allocation->height );
            else
                gdk_window_move_resize( widget->window, allocation->x, allocation->y,
                                                        allocation->width, allocation->height );

            gdk_window_move_resize( pizza->bin_window, border, border, w, h );
        }
        else
        {
            if (only_resize)
                gdk_window_resize( widget->window, w, h );
            else
                gdk_window_move_resize( widget->window, x, y, w, h );

            gdk_window_resize( pizza->bin_window, w, h );
        }
    }

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

        gtk_pizza_allocate_child (pizza, child);
    }
}

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;

    if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
    {
        /* reverse horizontal placement */
        gint offset,border;

        offset = GTK_WIDGET(pizza)->allocation.width;
        border = pizza->container.border_width;
        offset -= border*2;

        allocation.x = offset - child->x - allocation.width + pizza->m_xoffset;
    }

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