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

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

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

        GtkAllocation alloc = child->widget->allocation;
        alloc.x -= dx;
        alloc.y -= dy;
        gtk_widget_size_allocate( child->widget, &alloc );
    }
}

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