[wxWidgets.git] / 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"
#include <gtk/gtkfeatures.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,
#if (GTK_MINOR_VERSION == 1)
				     gboolean	      include_internals,
#endif
				     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;
#if (GTK_MINOR_VERSION == 1)
  container_class->forall = gtk_myfixed_foreach;
#else
  container_class->foreach = gtk_myfixed_foreach;
#endif
}

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