[wxWidgets.git] / src / gtk / 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/gtksignal.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);
#if (GTK_MINOR_VERSION == 0)
static void gtk_myfixed_unmap         (GtkWidget        *widget);
#endif
static void gtk_myfixed_realize       (GtkWidget        *widget);
static void gtk_myfixed_size_request  (GtkWidget        *widget,
				     GtkRequisition   *requisition);
static void gtk_myfixed_size_allocate (GtkWidget        *widget,
				     GtkAllocation    *allocation);
static void gtk_myfixed_paint         (GtkWidget        *widget,
				     GdkRectangle     *area);
static void gtk_myfixed_draw          (GtkWidget        *widget,
				     GdkRectangle     *area);
static gint gtk_myfixed_expose        (GtkWidget        *widget,
				     GdkEventExpose   *event);
static void gtk_myfixed_add           (GtkContainer     *container,
				     GtkWidget        *widget);
static void gtk_myfixed_remove        (GtkContainer     *container,
				     GtkWidget        *widget);
static void gtk_myfixed_foreach       (GtkContainer     *container,
#if (GTK_MINOR_VERSION > 0)
				     gboolean	      include_internals,
#endif
				     GtkCallback      callback,
				     gpointer         callback_data);
#if (GTK_MINOR_VERSION > 0)
static GtkType gtk_myfixed_child_type (GtkContainer     *container);
#endif

#if (GTK_MINOR_VERSION > 0)
static void  gtk_myfixed_scroll_set_adjustments    (GtkMyFixed   *myfixed,
					       GtkAdjustment *hadj,
					       GtkAdjustment *vadj);
#endif


static GtkContainerClass *parent_class = NULL;

guint
gtk_myfixed_get_type ()
{
  static guint myfixed_type = 0;

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

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

  return myfixed_type;
}

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

  object_class = (GtkObjectClass*) klass;
  widget_class = (GtkWidgetClass*) klass;
  container_class = (GtkContainerClass*) klass;
  
#if (GTK_MINOR_VERSION > 0)
  parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
#else
  parent_class = gtk_type_class (gtk_container_get_type ());
#endif

  widget_class->map = gtk_myfixed_map;
#if (GTK_MINOR_VERSION == 0)
  widget_class->unmap = gtk_myfixed_unmap;
#endif
  widget_class->realize = gtk_myfixed_realize;
  widget_class->size_request = gtk_myfixed_size_request;
  widget_class->size_allocate = gtk_myfixed_size_allocate;
  widget_class->draw = gtk_myfixed_draw;
  widget_class->expose_event = gtk_myfixed_expose;

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

#if (GTK_MINOR_VERSION > 0)
  container_class->child_type = gtk_myfixed_child_type;
#endif

#if (GTK_MINOR_VERSION > 0)
  klass->set_scroll_adjustments = gtk_myfixed_scroll_set_adjustments;

  widget_class->set_scroll_adjustments_signal =
    gtk_signal_new ("set_scroll_adjustments",
		    GTK_RUN_LAST,
		    object_class->type,
		    GTK_SIGNAL_OFFSET (GtkMyFixedClass, set_scroll_adjustments),
		    gtk_marshal_NONE__POINTER_POINTER,
		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
#endif
}

#if (GTK_MINOR_VERSION > 0)
static GtkType
gtk_myfixed_child_type (GtkContainer     *container)
{
  return GTK_TYPE_WIDGET;
}
#endif

static void
gtk_myfixed_init (GtkMyFixed *myfixed)
{
  GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
  
#if (GTK_MINOR_VERSION == 0)
  GTK_WIDGET_SET_FLAGS (myfixed, GTK_BASIC);
#endif

#if (GTK_MINOR_VERSION > 0)
  myfixed->shadow_type = GTK_SHADOW_NONE;
#endif

  myfixed->children = NULL;
}

GtkWidget*
gtk_myfixed_new ()
{
  GtkMyFixed *myfixed;

  myfixed = gtk_type_new (gtk_myfixed_get_type ());
  
  return GTK_WIDGET (myfixed);
}

#if (GTK_MINOR_VERSION > 0)
void  gtk_myfixed_scroll_set_adjustments (GtkMyFixed     *myfixed,
					       GtkAdjustment *hadj,
					       GtkAdjustment *vadj)
{
   /* OK, this is embarassing, but this function has to be here */
}

void 
gtk_myfixed_set_shadow_type (GtkMyFixed   *myfixed,
			      GtkShadowType  type)
{
  g_return_if_fail (myfixed != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (myfixed));

  if ((GtkShadowType) myfixed->shadow_type != type)
    {
      myfixed->shadow_type = type;

      if (GTK_WIDGET_VISIBLE (myfixed))
	{
	  gtk_widget_size_allocate (GTK_WIDGET (myfixed), &(GTK_WIDGET (myfixed)->allocation));
	  gtk_widget_queue_draw (GTK_WIDGET (myfixed));
	}
    }
}
#endif

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

#if (GTK_MINOR_VERSION == 0)
static void
gtk_myfixed_unmap (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (widget));

  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
}
#endif

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

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

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

  attributes.window_type = GDK_WINDOW_CHILD;
  
#if (GTK_MINOR_VERSION > 0)
  attributes.x = widget->allocation.x;
  attributes.y = widget->allocation.y;
  attributes.width = widget->allocation.width;
  attributes.height = widget->allocation.height;

  if (myfixed->shadow_type != GTK_SHADOW_NONE)
  {
      attributes.x += 2;
      attributes.y += 2;
      attributes.width -= 4;
      attributes.height -= 4;
  }
    
  if (attributes.width < 2) attributes.width = 2;
  if (attributes.height < 2) attributes.height = 2;
#else
  attributes.x = widget->allocation.x;
  attributes.y = widget->allocation.y;
  attributes.width = 32000;
  attributes.height = 32000;
#endif
  attributes.wclass = GDK_INPUT_OUTPUT;
  attributes.visual = gtk_widget_get_visual (widget);
  attributes.colormap = gtk_widget_get_colormap (widget);
  attributes.event_mask = gtk_widget_get_events (widget);
  attributes.event_mask |= 
  GDK_EXPOSURE_MASK	|
  GDK_POINTER_MOTION_MASK	|
  GDK_POINTER_MOTION_HINT_MASK  |
  GDK_BUTTON_MOTION_MASK	|
  GDK_BUTTON1_MOTION_MASK	|
  GDK_BUTTON2_MOTION_MASK	|
  GDK_BUTTON3_MOTION_MASK	|
  GDK_BUTTON_PRESS_MASK		|
  GDK_BUTTON_RELEASE_MASK	|
  GDK_KEY_PRESS_MASK		|
  GDK_KEY_RELEASE_MASK		|
  GDK_ENTER_NOTIFY_MASK		|
  GDK_LEAVE_NOTIFY_MASK		|
  GDK_FOCUS_CHANGE_MASK;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, 
				   attributes_mask);
  gdk_window_set_user_data (widget->window, widget);
    
  widget->style = gtk_style_attach (widget->style, widget->window);
  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}

static void
gtk_myfixed_size_request (GtkWidget      *widget,
			GtkRequisition *requisition)
{
  GtkMyFixed *myfixed;
  GtkMyFixedChild *child;
  GList *children;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_MYFIXED (widget));
  g_return_if_fail (requisition != NULL);

  myfixed = GTK_MYFIXED (widget);
  
  requisition->width = 0;
  requisition->height = 0;

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

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

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

  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_MINOR_VERSION > 0)
  if (myfixed->shadow_type == GTK_SHADOW_NONE)
    border = 0;
  else
    border = 2;
#else
  border = 0;
#endif

  if (GTK_WIDGET_REALIZED (widget))
  {
    gdk_window_move_resize( widget->window, 
                            allocation->x+border, allocation->y+border, 
#if (GTK_MINOR_VERSION > 0)
			    allocation->width-border*2, allocation->height-border*2
#else
			    32000, 32000
#endif
                           );
  }

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