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/private/win_gtk.h"

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

typedef struct _GtkPizzaChild GtkPizzaChild;
typedef struct _GtkPizzaClass GtkPizzaClass;

struct _GtkPizzaClass
{
  GtkContainerClass parent_class;

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

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

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

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

void
gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
{
    GList *tmp_list;

    pizza->m_xoffset += dx;
    pizza->m_yoffset += dy;

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

    for (tmp_list = pizza->children; tmp_list; tmp_list = tmp_list->next)
    {
        GtkPizzaChild *child = tmp_list->data;
        gtk_widget_queue_resize(child->widget);
    }
}

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