src/gtk1/win_gtk.c

/* ///////////////////////////////////////////////////////////////////////////
// Name:        wx_gtk.h
// Purpose:
// Author:      Robert Roebling
// Created:     01/02/97
// Id:
// Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////// */

#include "wx/gtk/win_gtk.h"

#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);
static void gtk_myfixed_unmap         (GtkWidget        *widget);
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,
				     GtkCallback      callback,
				     gpointer         callback_data);


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,
	(GtkArgSetFunc) NULL,
        (GtkArgGetFunc) NULL,
      };

      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;

  parent_class = gtk_type_class (gtk_container_get_type ());

  widget_class->map = gtk_myfixed_map;
  widget_class->unmap = gtk_myfixed_unmap;
  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;
  container_class->foreach = gtk_myfixed_foreach;
}

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

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

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

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