[wxWidgets.git] / 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>

#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);
  
#if (GTK_MINOR_VERSION == 1)
  gtk_container_set_resize_mode( GTK_CONTAINER(myfixed), GTK_RESIZE_PARENT );
#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);
    }
}

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