src/gtk1/win_gtk.c

/* ///////////////////////////////////////////////////////////////////////////
// Name:        win_gtk.c
// Purpose:     native GTK+ widget for wxWindows
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////// */

#include "wx/gtk/win_gtk.h"
#include <gtk/gtkfeatures.h>

/*-------------------------------------------------------------------------
// conditional compilation
//------------------------------------------------------------------------- */

#if (GTK_MINOR_VERSION == 1)
#if (GTK_MICRO_VERSION >= 5)
#define NEW_GTK_CONSTRUCT_CODE
#endif
#endif

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

static void gtk_myfixed_class_init    (GtkMyFixedClass    *klass);
static void gtk_myfixed_init          (GtkMyFixed         *myfixed);
static void gtk_myfixed_map           (GtkWidget        *widget);
#ifndef NEW_GTK_CONSTRUCT_CODE
static void gtk_myfixed_unmap         (GtkWidget        *widget);
#endif
static void gtk_myfixed_realize       (GtkWidget        *widget);
static void gtk_myfixed_size_request  (GtkWidget        *widget,
				     GtkRequisition   *requisition);
static void gtk_myfixed_size_allocate (GtkWidget        *widget,
				     GtkAllocation    *allocation);
static void gtk_myfixed_paint         (GtkWidget        *widget,
				     GdkRectangle     *area);
static void gtk_myfixed_draw          (GtkWidget        *widget,
				     GdkRectangle     *area);
static gint gtk_myfixed_expose        (GtkWidget        *widget,
				     GdkEventExpose   *event);
static void gtk_myfixed_add           (GtkContainer     *container,
				     GtkWidget        *widget);
static void gtk_myfixed_remove        (GtkContainer     *container,
				     GtkWidget        *widget);
static void gtk_myfixed_foreach       (GtkContainer     *container,
#if (GTK_MINOR_VERSION == 1)
				     gboolean	      include_internals,
#endif
				     GtkCallback      callback,
				     gpointer         callback_data);
#ifdef NEW_GTK_CONSTRUCT_CODE
static GtkType gtk_myfixed_child_type (GtkContainer     *container);
#endif


static GtkContainerClass *parent_class = NULL;


guint
gtk_myfixed_get_type ()
{
  static guint myfixed_type = 0;

  if (!myfixed_type)
    {
      GtkTypeInfo myfixed_info =
      {
	"GtkMyFixed",
	sizeof (GtkMyFixed),
	sizeof (GtkMyFixedClass),
	(GtkClassInitFunc) gtk_myfixed_class_init,
	(GtkObjectInitFunc) gtk_myfixed_init,
#ifndef NEW_GTK_CONSTRUCT_CODE
        (GtkArgSetFunc) NULL,
        (GtkArgGetFunc) NULL,
#else
	/* reserved_1 */ NULL,
        /* reserved_2 */ NULL,
        (GtkClassInitFunc) NULL,
#endif
      };

      myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
    }

  return myfixed_type;
}

static void
gtk_myfixed_class_init (GtkMyFixedClass *klass)
{
  GtkObjectClass *object_class;
  GtkWidgetClass *widget_class;
  GtkContainerClass *container_class;

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

#ifndef NEW_GTK_CONSTRUCT_CODE
  parent_class = gtk_type_class (gtk_container_get_type ());
#else
  parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
#endif

  widget_class->map = gtk_myfixed_map;
#ifndef NEW_GTK_CONSTRUCT_CODE
  widget_class->unmap = gtk_myfixed_unmap;
#endif
  widget_class->realize = gtk_myfixed_realize;
  widget_class->size_request = gtk_myfixed_size_request;
  widget_class->size_allocate = gtk_myfixed_size_allocate;
  widget_class->draw = gtk_myfixed_draw;
  widget_class->expose_event = gtk_myfixed_expose;

  container_class->add = gtk_myfixed_add;
  container_class->remove = gtk_myfixed_remove;
#if (GTK_MINOR_VERSION == 1)
  container_class->forall = gtk_myfixed_foreach;
#else
  container_class->foreach = gtk_myfixed_foreach;
#endif

#ifdef NEW_GTK_CONSTRUCT_CODE
  container_class->child_type = gtk_myfixed_child_type;
#endif
}

#ifdef NEW_GTK_CONSTRUCT_CODE
static GtkType
gtk_myfixed_child_type (GtkContainer     *container)
{
  return GTK_TYPE_WIDGET;
}
#endif

static void
gtk_myfixed_init (GtkMyFixed *myfixed)
{
  GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);

#ifndef NEW_GTK_CONSTRUCT_CODE
  GTK_WIDGET_SET_FLAGS (myfixed, GTK_BASIC);
#endif

  myfixed->children = NULL;
}

GtkWidget*
gtk_myfixed_new ()
{
  GtkMyFixed *myfixed;

  myfixed = gtk_type_new (gtk_myfixed_get_type ());

  return GTK_WIDGET (myfixed);
}

void
gtk_myfixed_put (GtkMyFixed       *myfixed,
               GtkWidget      *widget,
               gint16         x,
               gint16         y)
{
  GtkMyFixedChild *child_info;

  g_return_if_fail (myfixed != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (myfixed));
  g_return_if_fail (widget != NULL);

  child_info = g_new (GtkMyFixedChild, 1);
  child_info->widget = widget;
  child_info->x = x;
  child_info->y = y;

  gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));

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

  if (GTK_WIDGET_REALIZED (myfixed) && !GTK_WIDGET_REALIZED (widget))
    gtk_widget_realize (widget);

  if (GTK_WIDGET_MAPPED (myfixed) && !GTK_WIDGET_MAPPED (widget))
    gtk_widget_map (widget);

  if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
    gtk_widget_queue_resize (GTK_WIDGET (myfixed));
}

void
gtk_myfixed_move (GtkMyFixed       *myfixed,
                GtkWidget      *widget,
                gint16         x,
                gint16         y)
{
  GtkMyFixedChild *child;
  GList *children;

  g_return_if_fail (myfixed != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (myfixed));
  g_return_if_fail (widget != NULL);

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

      if (child->widget == widget)
        {
	  if ((child->x == x) && (child->y == y)) return;

          child->x = x;
          child->y = y;

          if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
            gtk_widget_queue_resize (GTK_WIDGET (myfixed));

          break;
        }
    }
}

static void
gtk_myfixed_map (GtkWidget *widget)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GList *children;

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

  GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
  myfixed = GTK_MYFIXED (widget);

  gdk_window_show (widget->window);

  children = myfixed->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);
    }
}

#ifndef NEW_GTK_CONSTRUCT_CODE
static void
gtk_myfixed_unmap (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (widget));

  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
}
#endif

static void
gtk_myfixed_realize (GtkWidget *widget)
{
  GtkMyFixed *myfixed;
  GdkWindowAttr attributes;
  gint attributes_mask;

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

  myfixed = GTK_MYFIXED (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 = 32000;
  attributes.height = 32000;
  attributes.wclass = GDK_INPUT_OUTPUT;
  attributes.visual = gtk_widget_get_visual (widget);
  attributes.colormap = gtk_widget_get_colormap (widget);
  attributes.event_mask = gtk_widget_get_events (widget);
  attributes.event_mask |=
  GDK_EXPOSURE_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;

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

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

static void
gtk_myfixed_size_request (GtkWidget      *widget,
			GtkRequisition *requisition)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GList *children;

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

  myfixed = GTK_MYFIXED (widget);

  requisition->width = 0;
  requisition->height = 0;

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

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

static void
gtk_myfixed_size_allocate (GtkWidget     *widget,
			 GtkAllocation *allocation)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GtkAllocation child_allocation;
  GList *children;
  guint16 border_width;

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

  myfixed = GTK_MYFIXED (widget);

  widget->allocation = *allocation;
  if (GTK_WIDGET_REALIZED (widget))
    gdk_window_move_resize (widget->window, allocation->x, allocation->y, 32000, 32000 );

  border_width = GTK_CONTAINER (myfixed)->border_width;

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

      if (GTK_WIDGET_VISIBLE (child->widget))
	{
	  child_allocation.x = child->x + border_width;
	  child_allocation.y = child->y + border_width;
	  child_allocation.width = child->widget->requisition.width;
	  child_allocation.height = child->widget->requisition.height;
	  gtk_widget_size_allocate (child->widget, &child_allocation);
	}
    }
}

static void
gtk_myfixed_paint (GtkWidget    *widget,
		 GdkRectangle *area)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (widget));
  g_return_if_fail (area != NULL);

  if (GTK_WIDGET_DRAWABLE (widget))
      gdk_window_clear_area (widget->window,
			     area->x, area->y,
			     area->width, area->height);
}

static void
gtk_myfixed_draw (GtkWidget    *widget,
		GdkRectangle *area)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GdkRectangle child_area;
  GList *children;

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

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      myfixed = GTK_MYFIXED (widget);
      gtk_myfixed_paint (widget, area);

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

	  if (gtk_widget_intersect (child->widget, area, &child_area))
	    gtk_widget_draw (child->widget, &child_area);
	}
    }
}

static gint
gtk_myfixed_expose (GtkWidget      *widget,
		  GdkEventExpose *event)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GdkEventExpose child_event;
  GList *children;

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

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      myfixed = GTK_MYFIXED (widget);

      child_event = *event;

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

	  if (GTK_WIDGET_NO_WINDOW (child->widget) &&
	      gtk_widget_intersect (child->widget, &event->area,
				    &child_event.area))
	    gtk_widget_event (child->widget, (GdkEvent*) &child_event);
	}
    }

  return FALSE;
}

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

  gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0);
}

static void
gtk_myfixed_remove (GtkContainer *container,
		  GtkWidget    *widget)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GList *children;

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

  myfixed = GTK_MYFIXED (container);

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

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

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

	  if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
	    gtk_widget_queue_resize (GTK_WIDGET (container));

	  break;
	}

      children = children->next;
    }
}

static void
gtk_myfixed_foreach (GtkContainer *container,
#if (GTK_MINOR_VERSION == 1)
		   gboolean	 include_internals,
#endif
		   GtkCallback   callback,
		   gpointer      callback_data)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GList *children;

  g_return_if_fail (container != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (container));
  g_return_if_fail (callback != NULL);

  myfixed = GTK_MYFIXED (container);

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

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


#ifdef __cplusplus
}
#endif /* __cplusplus */
Commit	Line	Data
	1	/* ///////////////////////////////////////////////////////////////////////////
	2	// Name: win_gtk.c
	3	// Purpose: native GTK+ widget for wxWindows
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////// */
	9
	10	#include "wx/gtk/win_gtk.h"
	11	#include <gtk/gtkfeatures.h>
	12
	13	/*-------------------------------------------------------------------------
	14	// conditional compilation
	15	//------------------------------------------------------------------------- */
	16
	17	#if (GTK_MINOR_VERSION == 1)
	18	#if (GTK_MICRO_VERSION >= 5)
	19	#define NEW_GTK_CONSTRUCT_CODE
	20	#endif
	21	#endif
	22
	23	#ifdef __cplusplus
	24	extern "C" {
	25	#endif /* __cplusplus */
	26
	27	static void gtk_myfixed_class_init (GtkMyFixedClass *klass);
	28	static void gtk_myfixed_init (GtkMyFixed *myfixed);
	29	static void gtk_myfixed_map (GtkWidget *widget);
	30	#ifndef NEW_GTK_CONSTRUCT_CODE
	31	static void gtk_myfixed_unmap (GtkWidget *widget);
	32	#endif
	33	static void gtk_myfixed_realize (GtkWidget *widget);
	34	static void gtk_myfixed_size_request (GtkWidget *widget,
	35	GtkRequisition *requisition);
	36	static void gtk_myfixed_size_allocate (GtkWidget *widget,
	37	GtkAllocation *allocation);
	38	static void gtk_myfixed_paint (GtkWidget *widget,
	39	GdkRectangle *area);
	40	static void gtk_myfixed_draw (GtkWidget *widget,
	41	GdkRectangle *area);
	42	static gint gtk_myfixed_expose (GtkWidget *widget,
	43	GdkEventExpose *event);
	44	static void gtk_myfixed_add (GtkContainer *container,
	45	GtkWidget *widget);
	46	static void gtk_myfixed_remove (GtkContainer *container,
	47	GtkWidget *widget);
	48	static void gtk_myfixed_foreach (GtkContainer *container,
	49	#if (GTK_MINOR_VERSION == 1)
	50	gboolean include_internals,
	51	#endif
	52	GtkCallback callback,
	53	gpointer callback_data);
	54	#ifdef NEW_GTK_CONSTRUCT_CODE
	55	static GtkType gtk_myfixed_child_type (GtkContainer *container);
	56	#endif
	57
	58
	59	static GtkContainerClass *parent_class = NULL;
	60
	61
	62	guint
	63	gtk_myfixed_get_type ()
	64	{
	65	static guint myfixed_type = 0;
	66
	67	if (!myfixed_type)
	68	{
	69	GtkTypeInfo myfixed_info =
	70	{
	71	"GtkMyFixed",
	72	sizeof (GtkMyFixed),
	73	sizeof (GtkMyFixedClass),
	74	(GtkClassInitFunc) gtk_myfixed_class_init,
	75	(GtkObjectInitFunc) gtk_myfixed_init,
	76	#ifndef NEW_GTK_CONSTRUCT_CODE
	77	(GtkArgSetFunc) NULL,
	78	(GtkArgGetFunc) NULL,
	79	#else
	80	/* reserved_1 */ NULL,
	81	/* reserved_2 */ NULL,
	82	(GtkClassInitFunc) NULL,
	83	#endif
	84	};
	85
	86	myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
	87	}
	88
	89	return myfixed_type;
	90	}
	91
	92	static void
	93	gtk_myfixed_class_init (GtkMyFixedClass *klass)
	94	{
	95	GtkObjectClass *object_class;
	96	GtkWidgetClass *widget_class;
	97	GtkContainerClass *container_class;
	98
	99	object_class = (GtkObjectClass*) klass;
	100	widget_class = (GtkWidgetClass*) klass;
	101	container_class = (GtkContainerClass*) klass;
	102
	103	#ifndef NEW_GTK_CONSTRUCT_CODE
	104	parent_class = gtk_type_class (gtk_container_get_type ());
	105	#else
	106	parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
	107	#endif
	108
	109	widget_class->map = gtk_myfixed_map;
	110	#ifndef NEW_GTK_CONSTRUCT_CODE
	111	widget_class->unmap = gtk_myfixed_unmap;
	112	#endif
	113	widget_class->realize = gtk_myfixed_realize;
	114	widget_class->size_request = gtk_myfixed_size_request;
	115	widget_class->size_allocate = gtk_myfixed_size_allocate;
	116	widget_class->draw = gtk_myfixed_draw;
	117	widget_class->expose_event = gtk_myfixed_expose;
	118
	119	container_class->add = gtk_myfixed_add;
	120	container_class->remove = gtk_myfixed_remove;
	121	#if (GTK_MINOR_VERSION == 1)
	122	container_class->forall = gtk_myfixed_foreach;
	123	#else
	124	container_class->foreach = gtk_myfixed_foreach;
	125	#endif
	126
	127	#ifdef NEW_GTK_CONSTRUCT_CODE
	128	container_class->child_type = gtk_myfixed_child_type;
	129	#endif
	130	}
	131
	132	#ifdef NEW_GTK_CONSTRUCT_CODE
	133	static GtkType
	134	gtk_myfixed_child_type (GtkContainer *container)
	135	{
	136	return GTK_TYPE_WIDGET;
	137	}
	138	#endif
	139
	140	static void
	141	gtk_myfixed_init (GtkMyFixed *myfixed)
	142	{
	143	GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
	144
	145	#ifndef NEW_GTK_CONSTRUCT_CODE
	146	GTK_WIDGET_SET_FLAGS (myfixed, GTK_BASIC);
	147	#endif
	148
	149	myfixed->children = NULL;
	150	}
	151
	152	GtkWidget*
	153	gtk_myfixed_new ()
	154	{
	155	GtkMyFixed *myfixed;
	156
	157	myfixed = gtk_type_new (gtk_myfixed_get_type ());
	158
	159	return GTK_WIDGET (myfixed);
	160	}
	161
	162	void
	163	gtk_myfixed_put (GtkMyFixed *myfixed,
	164	GtkWidget *widget,
	165	gint16 x,
	166	gint16 y)
	167	{
	168	GtkMyFixedChild *child_info;
	169
	170	g_return_if_fail (myfixed != NULL);
	171	g_return_if_fail (GTK_IS_MYFIXED (myfixed));
	172	g_return_if_fail (widget != NULL);
	173
	174	child_info = g_new (GtkMyFixedChild, 1);
	175	child_info->widget = widget;
	176	child_info->x = x;
	177	child_info->y = y;
	178
	179	gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
	180
	181	myfixed->children = g_list_append (myfixed->children, child_info);
	182
	183	if (GTK_WIDGET_REALIZED (myfixed) && !GTK_WIDGET_REALIZED (widget))
	184	gtk_widget_realize (widget);
	185
	186	if (GTK_WIDGET_MAPPED (myfixed) && !GTK_WIDGET_MAPPED (widget))
	187	gtk_widget_map (widget);
	188
	189	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
	190	gtk_widget_queue_resize (GTK_WIDGET (myfixed));
	191	}
	192
	193	void
	194	gtk_myfixed_move (GtkMyFixed *myfixed,
	195	GtkWidget *widget,
	196	gint16 x,
	197	gint16 y)
	198	{
	199	GtkMyFixedChild *child;
	200	GList *children;
	201
	202	g_return_if_fail (myfixed != NULL);
	203	g_return_if_fail (GTK_IS_MYFIXED (myfixed));
	204	g_return_if_fail (widget != NULL);
	205
	206	children = myfixed->children;
	207	while (children)
	208	{
	209	child = children->data;
	210	children = children->next;
	211
	212	if (child->widget == widget)
	213	{
	214	if ((child->x == x) && (child->y == y)) return;
	215
	216	child->x = x;
	217	child->y = y;
	218
	219	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
	220	gtk_widget_queue_resize (GTK_WIDGET (myfixed));
	221
	222	break;
	223	}
	224	}
	225	}
	226
	227	static void
	228	gtk_myfixed_map (GtkWidget *widget)
	229	{
	230	GtkMyFixed *myfixed;
	231	GtkMyFixedChild *child;
	232	GList *children;
	233
	234	g_return_if_fail (widget != NULL);
	235	g_return_if_fail (GTK_IS_MYFIXED (widget));
	236
	237	GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
	238	myfixed = GTK_MYFIXED (widget);
	239
	240	gdk_window_show (widget->window);
	241
	242	children = myfixed->children;
	243	while (children)
	244	{
	245	child = children->data;
	246	children = children->next;
	247
	248	if (GTK_WIDGET_VISIBLE (child->widget) &&
	249	!GTK_WIDGET_MAPPED (child->widget))
	250	gtk_widget_map (child->widget);
	251	}
	252	}
	253
	254	#ifndef NEW_GTK_CONSTRUCT_CODE
	255	static void
	256	gtk_myfixed_unmap (GtkWidget *widget)
	257	{
	258	g_return_if_fail (widget != NULL);
	259	g_return_if_fail (GTK_IS_MYFIXED (widget));
	260
	261	GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
	262	}
	263	#endif
	264
	265	static void
	266	gtk_myfixed_realize (GtkWidget *widget)
	267	{
	268	GtkMyFixed *myfixed;
	269	GdkWindowAttr attributes;
	270	gint attributes_mask;
	271
	272	g_return_if_fail (widget != NULL);
	273	g_return_if_fail (GTK_IS_MYFIXED (widget));
	274
	275	myfixed = GTK_MYFIXED (widget);
	276
	277	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
	278
	279	attributes.window_type = GDK_WINDOW_CHILD;
	280	attributes.x = widget->allocation.x;
	281	attributes.y = widget->allocation.y;
	282	attributes.width = 32000;
	283	attributes.height = 32000;
	284	attributes.wclass = GDK_INPUT_OUTPUT;
	285	attributes.visual = gtk_widget_get_visual (widget);
	286	attributes.colormap = gtk_widget_get_colormap (widget);
	287	attributes.event_mask = gtk_widget_get_events (widget);
	288	attributes.event_mask \|=
	289	GDK_EXPOSURE_MASK \|
	290	GDK_POINTER_MOTION_MASK \|
	291	GDK_POINTER_MOTION_HINT_MASK \|
	292	GDK_BUTTON_MOTION_MASK \|
	293	GDK_BUTTON1_MOTION_MASK \|
	294	GDK_BUTTON2_MOTION_MASK \|
	295	GDK_BUTTON3_MOTION_MASK \|
	296	GDK_BUTTON_PRESS_MASK \|
	297	GDK_BUTTON_RELEASE_MASK \|
	298	GDK_KEY_PRESS_MASK \|
	299	GDK_KEY_RELEASE_MASK \|
	300	GDK_ENTER_NOTIFY_MASK \|
	301	GDK_LEAVE_NOTIFY_MASK \|
	302	GDK_FOCUS_CHANGE_MASK;
	303
	304	attributes_mask = GDK_WA_X \| GDK_WA_Y \| GDK_WA_VISUAL \| GDK_WA_COLORMAP;
	305
	306	widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes,
	307	attributes_mask);
	308	gdk_window_set_user_data (widget->window, widget);
	309
	310	widget->style = gtk_style_attach (widget->style, widget->window);
	311	gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
	312	}
	313
	314	static void
	315	gtk_myfixed_size_request (GtkWidget *widget,
	316	GtkRequisition *requisition)
	317	{
	318	GtkMyFixed *myfixed;
	319	GtkMyFixedChild *child;
	320	GList *children;
	321
	322	g_return_if_fail (widget != NULL);
	323	g_return_if_fail (GTK_IS_MYFIXED (widget));
	324	g_return_if_fail (requisition != NULL);
	325
	326	myfixed = GTK_MYFIXED (widget);
	327
	328	requisition->width = 0;
	329	requisition->height = 0;
	330
	331	children = myfixed->children;
	332	while (children)
	333	{
	334	child = children->data;
	335	children = children->next;
	336
	337	if (GTK_WIDGET_VISIBLE (child->widget))
	338	{
	339	gtk_widget_size_request (child->widget, &child->widget->requisition);
	340	}
	341	}
	342	}
	343
	344	static void
	345	gtk_myfixed_size_allocate (GtkWidget *widget,
	346	GtkAllocation *allocation)
	347	{
	348	GtkMyFixed *myfixed;
	349	GtkMyFixedChild *child;
	350	GtkAllocation child_allocation;
	351	GList *children;
	352	guint16 border_width;
	353
	354	g_return_if_fail (widget != NULL);
	355	g_return_if_fail (GTK_IS_MYFIXED(widget));
	356	g_return_if_fail (allocation != NULL);
	357
	358	myfixed = GTK_MYFIXED (widget);
	359
	360	widget->allocation = *allocation;
	361	if (GTK_WIDGET_REALIZED (widget))
	362	gdk_window_move_resize (widget->window, allocation->x, allocation->y, 32000, 32000 );
	363
	364	border_width = GTK_CONTAINER (myfixed)->border_width;
	365
	366	children = myfixed->children;
	367	while (children)
	368	{
	369	child = children->data;
	370	children = children->next;
	371
	372	if (GTK_WIDGET_VISIBLE (child->widget))
	373	{
	374	child_allocation.x = child->x + border_width;
	375	child_allocation.y = child->y + border_width;
	376	child_allocation.width = child->widget->requisition.width;
	377	child_allocation.height = child->widget->requisition.height;
	378	gtk_widget_size_allocate (child->widget, &child_allocation);
	379	}
	380	}
	381	}
	382
	383	static void
	384	gtk_myfixed_paint (GtkWidget *widget,
	385	GdkRectangle *area)
	386	{
	387	g_return_if_fail (widget != NULL);
	388	g_return_if_fail (GTK_IS_MYFIXED (widget));
	389	g_return_if_fail (area != NULL);
	390
	391	if (GTK_WIDGET_DRAWABLE (widget))
	392	gdk_window_clear_area (widget->window,
	393	area->x, area->y,
	394	area->width, area->height);
	395	}
	396
	397	static void
	398	gtk_myfixed_draw (GtkWidget *widget,
	399	GdkRectangle *area)
	400	{
	401	GtkMyFixed *myfixed;
	402	GtkMyFixedChild *child;
	403	GdkRectangle child_area;
	404	GList *children;
	405
	406	g_return_if_fail (widget != NULL);
	407	g_return_if_fail (GTK_IS_MYFIXED (widget));
	408
	409	if (GTK_WIDGET_DRAWABLE (widget))
	410	{
	411	myfixed = GTK_MYFIXED (widget);
	412	gtk_myfixed_paint (widget, area);
	413
	414	children = myfixed->children;
	415	while (children)
	416	{
	417	child = children->data;
	418	children = children->next;
	419
	420	if (gtk_widget_intersect (child->widget, area, &child_area))
	421	gtk_widget_draw (child->widget, &child_area);
	422	}
	423	}
	424	}
	425
	426	static gint
	427	gtk_myfixed_expose (GtkWidget *widget,
	428	GdkEventExpose *event)
	429	{
	430	GtkMyFixed *myfixed;
	431	GtkMyFixedChild *child;
	432	GdkEventExpose child_event;
	433	GList *children;
	434
	435	g_return_val_if_fail (widget != NULL, FALSE);
	436	g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
	437	g_return_val_if_fail (event != NULL, FALSE);
	438
	439	if (GTK_WIDGET_DRAWABLE (widget))
	440	{
	441	myfixed = GTK_MYFIXED (widget);
	442
	443	child_event = *event;
	444
	445	children = myfixed->children;
	446	while (children)
	447	{
	448	child = children->data;
	449	children = children->next;
	450
	451	if (GTK_WIDGET_NO_WINDOW (child->widget) &&
	452	gtk_widget_intersect (child->widget, &event->area,
	453	&child_event.area))
	454	gtk_widget_event (child->widget, (GdkEvent*) &child_event);
	455	}
	456	}
	457
	458	return FALSE;
	459	}
	460
	461	static void
	462	gtk_myfixed_add (GtkContainer *container,
	463	GtkWidget *widget)
	464	{
	465	g_return_if_fail (container != NULL);
	466	g_return_if_fail (GTK_IS_MYFIXED (container));
	467	g_return_if_fail (widget != NULL);
	468
	469	gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0);
	470	}
	471
	472	static void
	473	gtk_myfixed_remove (GtkContainer *container,
	474	GtkWidget *widget)
	475	{
	476	GtkMyFixed *myfixed;
	477	GtkMyFixedChild *child;
	478	GList *children;
	479
	480	g_return_if_fail (container != NULL);
	481	g_return_if_fail (GTK_IS_MYFIXED (container));
	482	g_return_if_fail (widget != NULL);
	483
	484	myfixed = GTK_MYFIXED (container);
	485
	486	children = myfixed->children;
	487	while (children)
	488	{
	489	child = children->data;
	490
	491	if (child->widget == widget)
	492	{
	493	gtk_widget_unparent (widget);
	494
	495	myfixed->children = g_list_remove_link (myfixed->children, children);
	496	g_list_free (children);
	497	g_free (child);
	498
	499	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
	500	gtk_widget_queue_resize (GTK_WIDGET (container));
	501
	502	break;
	503	}
	504
	505	children = children->next;
	506	}
	507	}
	508
	509	static void
	510	gtk_myfixed_foreach (GtkContainer *container,
	511	#if (GTK_MINOR_VERSION == 1)
	512	gboolean include_internals,
	513	#endif
	514	GtkCallback callback,
	515	gpointer callback_data)
	516	{
	517	GtkMyFixed *myfixed;
	518	GtkMyFixedChild *child;
	519	GList *children;
	520
	521	g_return_if_fail (container != NULL);
	522	g_return_if_fail (GTK_IS_MYFIXED (container));
	523	g_return_if_fail (callback != NULL);
	524
	525	myfixed = GTK_MYFIXED (container);
	526
	527	children = myfixed->children;
	528	while (children)
	529	{
	530	child = children->data;
	531	children = children->next;
	532
	533	(* callback) (child->widget, callback_data);
	534	}
	535	}
	536
	537
	538	#ifdef __cplusplus
	539	}
	540	#endif /* __cplusplus */
	541