[wxWidgets.git] / src / gtk / 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 ());
  
  myfixed->scroll_offset_x = 0;
  myfixed->scroll_offset_y = 0;
  
  return GTK_WIDGET (myfixed);
}

void       
gtk_myfixed_set_offset (GtkMyFixed     *myfixed,
                        gint16         x,
			gint16         y)
{
  GtkWidget *widget;
 
  g_return_if_fail (myfixed != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (myfixed));
  
  myfixed->scroll_offset_x = x;
  myfixed->scroll_offset_y = y;
  
  widget = GTK_WIDGET( myfixed );
  
  if (GTK_WIDGET_REALIZED( GTK_WIDGET(myfixed) ))
    gdk_window_move_resize (widget->window,
			    widget->allocation.x + x, 
			    widget->allocation.y + y,
                            32000, 
			    32000);
}

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 - myfixed->scroll_offset_x;
  child_info->y = y - myfixed->scroll_offset_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 - myfixed->scroll_offset_x;
          child->y = y - myfixed->scroll_offset_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 + myfixed->scroll_offset_x;
  attributes.y = widget->allocation.y + myfixed->scroll_offset_x;
  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 + myfixed->scroll_offset_x, 
			    allocation->y + myfixed->scroll_offset_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
c801d85f KB	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	myfixed->scroll_offset_x = 0;
111	myfixed->scroll_offset_y = 0;
112
113	return GTK_WIDGET (myfixed);
114	}
115
116	void
117	gtk_myfixed_set_offset (GtkMyFixed *myfixed,
118	gint16 x,
119	gint16 y)
120	{
121	GtkWidget *widget;
122
123	g_return_if_fail (myfixed != NULL);
124	g_return_if_fail (GTK_IS_MYFIXED (myfixed));
125
126	myfixed->scroll_offset_x = x;
127	myfixed->scroll_offset_y = y;
128
129	widget = GTK_WIDGET( myfixed );
130
131	if (GTK_WIDGET_REALIZED( GTK_WIDGET(myfixed) ))
132	gdk_window_move_resize (widget->window,
133	widget->allocation.x + x,
134	widget->allocation.y + y,
135	32000,
136	32000);
137	}
138
139	void
140	gtk_myfixed_put (GtkMyFixed *myfixed,
141	GtkWidget *widget,
142	gint16 x,
143	gint16 y)
144	{
145	GtkMyFixedChild *child_info;
146
147	g_return_if_fail (myfixed != NULL);
148	g_return_if_fail (GTK_IS_MYFIXED (myfixed));
149	g_return_if_fail (widget != NULL);
150
151	child_info = g_new (GtkMyFixedChild, 1);
152	child_info->widget = widget;
d4c99d6f RR	153	child_info->x = x - myfixed->scroll_offset_x;
	154	child_info->y = y - myfixed->scroll_offset_y;
	155
c801d85f KB	156	gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
	157
	158	myfixed->children = g_list_append (myfixed->children, child_info);
	159
	160	if (GTK_WIDGET_REALIZED (myfixed) && !GTK_WIDGET_REALIZED (widget))
	161	gtk_widget_realize (widget);
	162
	163	if (GTK_WIDGET_MAPPED (myfixed) && !GTK_WIDGET_MAPPED (widget))
	164	gtk_widget_map (widget);
	165
	166	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
	167	gtk_widget_queue_resize (GTK_WIDGET (myfixed));
	168	}
	169
	170	void
	171	gtk_myfixed_move (GtkMyFixed *myfixed,
	172	GtkWidget *widget,
	173	gint16 x,
	174	gint16 y)
	175	{
	176	GtkMyFixedChild *child;
	177	GList *children;
	178
	179	g_return_if_fail (myfixed != NULL);
	180	g_return_if_fail (GTK_IS_MYFIXED (myfixed));
	181	g_return_if_fail (widget != NULL);
	182
	183	children = myfixed->children;
	184	while (children)
	185	{
	186	child = children->data;
	187	children = children->next;
	188
	189	if (child->widget == widget)
	190	{
d4c99d6f RR	191	child->x = x - myfixed->scroll_offset_x;
d4c99d6f RR	192	child->y = y - myfixed->scroll_offset_y;
c801d85f KB	193
	194	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
	195	gtk_widget_queue_resize (GTK_WIDGET (myfixed));
	196
	197	break;
	198	}
	199	}
	200	}
	201
	202	static void
	203	gtk_myfixed_map (GtkWidget *widget)
	204	{
	205	GtkMyFixed *myfixed;
	206	GtkMyFixedChild *child;
	207	GList *children;
	208
	209	g_return_if_fail (widget != NULL);
	210	g_return_if_fail (GTK_IS_MYFIXED (widget));
	211
	212	GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
	213	myfixed = GTK_MYFIXED (widget);
	214
	215	gdk_window_show (widget->window);
	216
	217	children = myfixed->children;
	218	while (children)
	219	{
	220	child = children->data;
	221	children = children->next;
	222
	223	if (GTK_WIDGET_VISIBLE (child->widget) &&
	224	!GTK_WIDGET_MAPPED (child->widget))
	225	gtk_widget_map (child->widget);
	226	}
	227	}
	228
	229	static void
	230	gtk_myfixed_unmap (GtkWidget *widget)
	231	{
	232	g_return_if_fail (widget != NULL);
	233	g_return_if_fail (GTK_IS_MYFIXED (widget));
	234
	235	GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
	236	}
	237
	238	static void
	239	gtk_myfixed_realize (GtkWidget *widget)
	240	{
d4c99d6f	241	GtkMyFixed *myfixed;
c801d85f KB	242	GdkWindowAttr attributes;
	243	gint attributes_mask;
	244
	245	g_return_if_fail (widget != NULL);
	246	g_return_if_fail (GTK_IS_MYFIXED (widget));
	247
d4c99d6f RR	248	myfixed = GTK_MYFIXED (widget);
d4c99d6f RR	249
c801d85f KB	250	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
	251
	252	attributes.window_type = GDK_WINDOW_CHILD;
d4c99d6f RR	253	attributes.x = widget->allocation.x + myfixed->scroll_offset_x;
d4c99d6f RR	254	attributes.y = widget->allocation.y + myfixed->scroll_offset_x;
c801d85f KB	255	attributes.width = 32000;
	256	attributes.height = 32000;
	257	attributes.wclass = GDK_INPUT_OUTPUT;
	258	attributes.visual = gtk_widget_get_visual (widget);
	259	attributes.colormap = gtk_widget_get_colormap (widget);
	260	attributes.event_mask = gtk_widget_get_events (widget);
	261	attributes.event_mask \|=
	262	GDK_EXPOSURE_MASK \|
	263	GDK_POINTER_MOTION_MASK \|
	264	GDK_BUTTON_MOTION_MASK \|
	265	GDK_BUTTON1_MOTION_MASK \|
	266	GDK_BUTTON2_MOTION_MASK \|
	267	GDK_BUTTON3_MOTION_MASK \|
	268	GDK_BUTTON_PRESS_MASK \|
	269	GDK_BUTTON_RELEASE_MASK \|
	270	GDK_KEY_PRESS_MASK \|
	271	GDK_KEY_RELEASE_MASK \|
	272	GDK_ENTER_NOTIFY_MASK \|
	273	GDK_LEAVE_NOTIFY_MASK \|
	274	GDK_FOCUS_CHANGE_MASK;
	275
	276	attributes_mask = GDK_WA_X \| GDK_WA_Y \| GDK_WA_VISUAL \| GDK_WA_COLORMAP;
	277
	278	widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes,
	279	attributes_mask);
	280	gdk_window_set_user_data (widget->window, widget);
	281
	282	widget->style = gtk_style_attach (widget->style, widget->window);
	283	gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
	284	}
	285
	286	static void
	287	gtk_myfixed_size_request (GtkWidget *widget,
	288	GtkRequisition *requisition)
	289	{
	290	GtkMyFixed *myfixed;
	291	GtkMyFixedChild *child;
	292	GList *children;
	293
	294	g_return_if_fail (widget != NULL);
	295	g_return_if_fail (GTK_IS_MYFIXED (widget));
	296	g_return_if_fail (requisition != NULL);
	297
	298	myfixed = GTK_MYFIXED (widget);
	299
	300	requisition->width = 0;
	301	requisition->height = 0;
	302
	303	children = myfixed->children;
	304	while (children)
	305	{
	306	child = children->data;
	307	children = children->next;
	308
	309	if (GTK_WIDGET_VISIBLE (child->widget))
	310	{
	311	gtk_widget_size_request (child->widget, &child->widget->requisition);
	312	}
	313	}
	314	}
	315
	316	static void
	317	gtk_myfixed_size_allocate (GtkWidget *widget,
	318	GtkAllocation *allocation)
319	{
320	GtkMyFixed *myfixed;
321	GtkMyFixedChild *child;
322	GtkAllocation child_allocation;
323	GList *children;
324	guint16 border_width;
325
326	g_return_if_fail (widget != NULL);
327	g_return_if_fail (GTK_IS_MYFIXED(widget));
328	g_return_if_fail (allocation != NULL);
329
330	myfixed = GTK_MYFIXED (widget);
331
332	widget->allocation = *allocation;
333	if (GTK_WIDGET_REALIZED (widget))
334	gdk_window_move_resize (widget->window,
335	allocation->x + myfixed->scroll_offset_x,
336	allocation->y + myfixed->scroll_offset_y,
337	32000,
338	32000
339	);
340
341	border_width = GTK_CONTAINER (myfixed)->border_width;
342
343	children = myfixed->children;
344	while (children)
345	{
346	child = children->data;
347	children = children->next;
348
349	if (GTK_WIDGET_VISIBLE (child->widget))
350	{
351	child_allocation.x = child->x + border_width;
352	child_allocation.y = child->y + border_width;
353	child_allocation.width = child->widget->requisition.width;
354	child_allocation.height = child->widget->requisition.height;
355	gtk_widget_size_allocate (child->widget, &child_allocation);
356	}
357	}
358	}
359
360	static void
361	gtk_myfixed_paint (GtkWidget *widget,
362	GdkRectangle *area)
363	{
364	g_return_if_fail (widget != NULL);
365	g_return_if_fail (GTK_IS_MYFIXED (widget));
366	g_return_if_fail (area != NULL);
367
368	if (GTK_WIDGET_DRAWABLE (widget))
369	gdk_window_clear_area (widget->window,
370	area->x, area->y,
371	area->width, area->height);
372	}
373
374	static void
375	gtk_myfixed_draw (GtkWidget *widget,
376	GdkRectangle *area)
377	{
378	GtkMyFixed *myfixed;
379	GtkMyFixedChild *child;
380	GdkRectangle child_area;
381	GList *children;
382
383	g_return_if_fail (widget != NULL);
384	g_return_if_fail (GTK_IS_MYFIXED (widget));
385
386	if (GTK_WIDGET_DRAWABLE (widget))
387	{
388	myfixed = GTK_MYFIXED (widget);
389	gtk_myfixed_paint (widget, area);
390
391	children = myfixed->children;
392	while (children)
393	{
394	child = children->data;
395	children = children->next;
396
397	if (gtk_widget_intersect (child->widget, area, &child_area))
398	gtk_widget_draw (child->widget, &child_area);
399	}
400	}
401	}
402
403	static gint
404	gtk_myfixed_expose (GtkWidget *widget,
405	GdkEventExpose *event)
406	{
407	GtkMyFixed *myfixed;
408	GtkMyFixedChild *child;
409	GdkEventExpose child_event;
410	GList *children;
411
412	g_return_val_if_fail (widget != NULL, FALSE);
413	g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
414	g_return_val_if_fail (event != NULL, FALSE);
415
416	if (GTK_WIDGET_DRAWABLE (widget))
417	{
418	myfixed = GTK_MYFIXED (widget);
419
420	child_event = *event;
421
422	children = myfixed->children;
423	while (children)
424	{
425	child = children->data;
426	children = children->next;
427
428	if (GTK_WIDGET_NO_WINDOW (child->widget) &&
429	gtk_widget_intersect (child->widget, &event->area,
430	&child_event.area))
431	gtk_widget_event (child->widget, (GdkEvent*) &child_event);
432	}
433	}
434
435	return FALSE;
436	}
437
438	static void
439	gtk_myfixed_add (GtkContainer *container,
440	GtkWidget *widget)
441	{
442	g_return_if_fail (container != NULL);
443	g_return_if_fail (GTK_IS_MYFIXED (container));
444	g_return_if_fail (widget != NULL);
445
446	gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0);
447	}
448
449	static void
450	gtk_myfixed_remove (GtkContainer *container,
451	GtkWidget *widget)
452	{
453	GtkMyFixed *myfixed;
454	GtkMyFixedChild *child;
455	GList *children;
456
457	g_return_if_fail (container != NULL);
458	g_return_if_fail (GTK_IS_MYFIXED (container));
459	g_return_if_fail (widget != NULL);
460
461	myfixed = GTK_MYFIXED (container);
462
463	children = myfixed->children;
464	while (children)
465	{
466	child = children->data;
467
468	if (child->widget == widget)
469	{
470	gtk_widget_unparent (widget);
471
472	myfixed->children = g_list_remove_link (myfixed->children, children);
473	g_list_free (children);
474	g_free (child);
475
476	if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
477	gtk_widget_queue_resize (GTK_WIDGET (container));
478
479	break;
480	}
481
482	children = children->next;
483	}
484	}
485
486	static void
487	gtk_myfixed_foreach (GtkContainer *container,
488	GtkCallback callback,
489	gpointer callback_data)
490	{
491	GtkMyFixed *myfixed;
492	GtkMyFixedChild *child;
493	GList *children;
494
495	g_return_if_fail (container != NULL);
496	g_return_if_fail (GTK_IS_MYFIXED (container));
497	g_return_if_fail (callback != NULL);
498
499	myfixed = GTK_MYFIXED (container);
500
501	children = myfixed->children;
502	while (children)
503	{
504	child = children->data;
505	children = children->next;
506
507	(* callback) (child->widget, callback_data);
508	}
509	}
510
511
512	#ifdef __cplusplus
513	}
514	#endif /* __cplusplus */
515