gtkwidget.c

/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 */

#include <stdarg.h>
#include <string.h>
#include <locale.h>
#include "gtkcontainer.h"
#include "gtkiconfactory.h"
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkrc.h"
#include "gtkselection.h"
#include "gtksettings.h"
#include "gtksizegroup.h"
#include "gtksignal.h"
#include "gtkwidget.h"
#include "gtkwindow.h"
#include "gtkbindings.h"
#include "gtkprivate.h"
#include "gdk/gdk.h"
#include "gdk/gdkprivate.h" /* Used in gtk_reset_shapes_recurse to avoid copy */
#include "gobject/gvaluecollector.h"
#include "gdk/gdkkeysyms.h"
#include "gtkintl.h"
#include "gtkaccessible.h"

#define WIDGET_CLASS(w)	 GTK_WIDGET_GET_CLASS (w)
#define	INIT_PATH_SIZE	(512)


enum {
  SHOW,
  HIDE,
  MAP,
  UNMAP,
  REALIZE,
  UNREALIZE,
  SIZE_REQUEST,
  SIZE_ALLOCATE,
  STATE_CHANGED,
  PARENT_SET,
  HIERARCHY_CHANGED,
  STYLE_SET,
  DIRECTION_CHANGED,
  ADD_ACCELERATOR,
  REMOVE_ACCELERATOR,
  ACTIVATE_MNEMONIC,
  GRAB_FOCUS,
  FOCUS,
  EVENT,
  BUTTON_PRESS_EVENT,
  BUTTON_RELEASE_EVENT,
  SCROLL_EVENT,
  MOTION_NOTIFY_EVENT,
  DELETE_EVENT,
  DESTROY_EVENT,
  EXPOSE_EVENT,
  KEY_PRESS_EVENT,
  KEY_RELEASE_EVENT,
  ENTER_NOTIFY_EVENT,
  LEAVE_NOTIFY_EVENT,
  CONFIGURE_EVENT,
  FOCUS_IN_EVENT,
  FOCUS_OUT_EVENT,
  MAP_EVENT,
  UNMAP_EVENT,
  PROPERTY_NOTIFY_EVENT,
  SELECTION_CLEAR_EVENT,
  SELECTION_REQUEST_EVENT,
  SELECTION_NOTIFY_EVENT,
  SELECTION_GET,
  SELECTION_RECEIVED,
  PROXIMITY_IN_EVENT,
  PROXIMITY_OUT_EVENT,
  DRAG_BEGIN,
  DRAG_END,
  DRAG_DATA_DELETE,
  DRAG_LEAVE,
  DRAG_MOTION,
  DRAG_DROP,
  DRAG_DATA_GET,
  DRAG_DATA_RECEIVED,
  CLIENT_EVENT,
  NO_EXPOSE_EVENT,
  VISIBILITY_NOTIFY_EVENT,
  WINDOW_STATE_EVENT,
  POPUP_MENU,
  LAST_SIGNAL
};

enum {
  PROP_0,
  PROP_NAME,
  PROP_PARENT,
  PROP_X,
  PROP_Y,
  PROP_WIDTH,
  PROP_HEIGHT,
  PROP_VISIBLE,
  PROP_SENSITIVE,
  PROP_APP_PAINTABLE,
  PROP_CAN_FOCUS,
  PROP_HAS_FOCUS,
  PROP_CAN_DEFAULT,
  PROP_HAS_DEFAULT,
  PROP_RECEIVES_DEFAULT,
  PROP_COMPOSITE_CHILD,
  PROP_STYLE,
  PROP_EVENTS,
  PROP_EXTENSION_EVENTS
};

typedef	struct	_GtkStateData	 GtkStateData;

struct _GtkStateData
{
  GtkStateType  state;
  guint		state_restoration : 1;
  guint         parent_sensitive : 1;
  guint		use_forall : 1;
};

static void gtk_widget_class_init		 (GtkWidgetClass    *klass);
static void gtk_widget_init			 (GtkWidget	    *widget);
static void gtk_widget_set_property		 (GObject           *object,
						  guint              prop_id,
						  const GValue      *value,
						  GParamSpec        *pspec);
static void gtk_widget_get_property		 (GObject           *object,
						  guint              prop_id,
						  GValue            *value,
						  GParamSpec        *pspec);
static void gtk_widget_shutdown			 (GObject	    *object);
static void gtk_widget_real_destroy		 (GtkObject	    *object);
static void gtk_widget_finalize			 (GObject	    *object);
static void gtk_widget_real_show		 (GtkWidget	    *widget);
static void gtk_widget_real_hide		 (GtkWidget	    *widget);
static void gtk_widget_real_map			 (GtkWidget	    *widget);
static void gtk_widget_real_unmap		 (GtkWidget	    *widget);
static void gtk_widget_real_realize		 (GtkWidget	    *widget);
static void gtk_widget_real_unrealize		 (GtkWidget	    *widget);
static void gtk_widget_real_size_request	 (GtkWidget	    *widget,
						  GtkRequisition    *requisition);
static void gtk_widget_real_size_allocate	 (GtkWidget	    *widget,
						  GtkAllocation	    *allocation);
static gboolean gtk_widget_real_key_press_event   (GtkWidget     *widget,
						   GdkEventKey   *event);
static gboolean gtk_widget_real_key_release_event (GtkWidget     *widget,
						   GdkEventKey   *event);
static gboolean gtk_widget_real_focus_in_event    (GtkWidget     *widget,
						   GdkEventFocus *event);
static gboolean gtk_widget_real_focus_out_event   (GtkWidget     *widget,
						   GdkEventFocus *event);

static void gtk_widget_style_set		 (GtkWidget	    *widget,
						  GtkStyle          *previous_style);
static void gtk_widget_direction_changed	 (GtkWidget	    *widget,
						  GtkTextDirection   previous_direction);
static void gtk_widget_real_grab_focus           (GtkWidget         *focus_widget);
static gboolean gtk_widget_real_focus            (GtkWidget         *widget,
                                                  GtkDirectionType   direction);

static GdkColormap*  gtk_widget_peek_colormap      (void);
static GtkStyle*     gtk_widget_peek_style         (void);
static PangoContext *gtk_widget_peek_pango_context (GtkWidget *widget);

static void gtk_widget_reparent_container_child  (GtkWidget     *widget,
						  gpointer       client_data);
static void gtk_widget_propagate_state		 (GtkWidget	*widget,
						  GtkStateData 	*data);
static void gtk_widget_set_style_internal	 (GtkWidget	*widget,
						  GtkStyle	*style,
						  gboolean	 initial_emission);
static void gtk_widget_set_style_recurse	 (GtkWidget	*widget,
						  gpointer	 client_data);
static gint gtk_widget_event_internal            (GtkWidget     *widget,
						  GdkEvent      *event);

static void gtk_widget_propagate_hierarchy_changed (GtkWidget *widget,
						    gpointer   client_data);
static gboolean gtk_widget_real_mnemonic_activate  (GtkWidget *widget,
						    gboolean   group_cycling);

static void		 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);

static void  gtk_widget_do_uposition (GtkWidget *widget);

static AtkObject*        gtk_widget_real_get_accessible   (GtkWidget *widget);
static void              gtk_widget_accessible_interface_init (AtkImplementorIface *iface);
static AtkObject *       gtk_widget_ref_accessible (AtkImplementor *implementor);

static gpointer         parent_class = NULL;
static guint            widget_signals[LAST_SIGNAL] = { 0 };

static GMemChunk       *aux_info_mem_chunk = NULL;
static GdkColormap     *default_colormap = NULL;
static GtkStyle        *gtk_default_style = NULL;
static GSList          *colormap_stack = NULL;
static GSList          *style_stack = NULL;
static guint            composite_child_stack = 0;
static GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR;
static GParamSpecPool  *style_property_spec_pool = NULL;

static GQuark quark_property_parser = 0;
static GQuark quark_aux_info = 0;
static GQuark quark_event_mask = 0;
static GQuark quark_extension_event_mode = 0;
static GQuark quark_parent_window = 0;
static GQuark quark_saved_default_style = 0;
static GQuark quark_shape_info = 0;
static GQuark quark_colormap = 0;
static GQuark quark_pango_context = 0;
static GQuark quark_rc_style = 0;
static GQuark quark_accessible_object = 0;


/*****************************************
 * gtk_widget_get_type:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

GtkType
gtk_widget_get_type (void)
{
  static GtkType widget_type = 0;
  
  if (!widget_type)
    {
      static const GtkTypeInfo widget_info =
      {
	"GtkWidget",
	sizeof (GtkWidget),
	sizeof (GtkWidgetClass),
	(GtkClassInitFunc) gtk_widget_class_init,
	(GtkObjectInitFunc) gtk_widget_init,
        /* reserved_1 */ NULL,
	/* reserved_2 */ NULL,
	(GtkClassInitFunc) NULL,
      };
      
      static const GInterfaceInfo accessibility_info =
      {
        (GInterfaceInitFunc) gtk_widget_accessible_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL /* interface data */
      };

 
      widget_type = gtk_type_unique (GTK_TYPE_OBJECT, &widget_info);

      g_type_add_interface_static (widget_type, ATK_TYPE_IMPLEMENTOR,
                                   &accessibility_info) ;

    }
  
  return widget_type;
}

/*****************************************
 * gtk_widget_class_init:
 *
 *   arguments:
 *
 *   results:
 *****************************************/
static void
gtk_widget_class_init (GtkWidgetClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
  GtkBindingSet *binding_set;
  
  parent_class = gtk_type_class (GTK_TYPE_OBJECT);

  gobject_class->shutdown = gtk_widget_shutdown;
  gobject_class->finalize = gtk_widget_finalize;
  gobject_class->set_property = gtk_widget_set_property;
  gobject_class->get_property = gtk_widget_get_property;

  object_class->destroy = gtk_widget_real_destroy;
  
  klass->activate_signal = 0;
  klass->set_scroll_adjustments_signal = 0;
  klass->show = gtk_widget_real_show;
  klass->show_all = gtk_widget_show;
  klass->hide = gtk_widget_real_hide;
  klass->hide_all = gtk_widget_hide;
  klass->map = gtk_widget_real_map;
  klass->unmap = gtk_widget_real_unmap;
  klass->realize = gtk_widget_real_realize;
  klass->unrealize = gtk_widget_real_unrealize;
  klass->size_request = gtk_widget_real_size_request;
  klass->size_allocate = gtk_widget_real_size_allocate;
  klass->state_changed = NULL;
  klass->parent_set = NULL;
  klass->hierarchy_changed = NULL;
  klass->style_set = gtk_widget_style_set;
  klass->direction_changed = gtk_widget_direction_changed;
  klass->add_accelerator = (void*) gtk_accel_group_handle_add;
  klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
  klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
  klass->grab_focus = gtk_widget_real_grab_focus;
  klass->focus = gtk_widget_real_focus;
  klass->event = NULL;
  klass->button_press_event = NULL;
  klass->button_release_event = NULL;
  klass->motion_notify_event = NULL;
  klass->delete_event = NULL;
  klass->destroy_event = NULL;
  klass->expose_event = NULL;
  klass->key_press_event = gtk_widget_real_key_press_event;
  klass->key_release_event = gtk_widget_real_key_release_event;
  klass->enter_notify_event = NULL;
  klass->leave_notify_event = NULL;
  klass->configure_event = NULL;
  klass->focus_in_event = gtk_widget_real_focus_in_event;
  klass->focus_out_event = gtk_widget_real_focus_out_event;
  klass->map_event = NULL;
  klass->unmap_event = NULL;
  klass->window_state_event = NULL;
  klass->property_notify_event = gtk_selection_property_notify;
  klass->selection_clear_event = gtk_selection_clear;
  klass->selection_request_event = gtk_selection_request;
  klass->selection_notify_event = gtk_selection_notify;
  klass->selection_received = NULL;
  klass->proximity_in_event = NULL;
  klass->proximity_out_event = NULL;
  klass->drag_begin = NULL;
  klass->drag_end = NULL;
  klass->drag_data_delete = NULL;
  klass->drag_leave = NULL;
  klass->drag_motion = NULL;
  klass->drag_drop = NULL;
  klass->drag_data_received = NULL;

  /* Accessibility support */
  klass->get_accessible = gtk_widget_real_get_accessible;

  klass->no_expose_event = NULL;

  quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");
  quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
  quark_event_mask = g_quark_from_static_string ("gtk-event-mask");
  quark_extension_event_mode = g_quark_from_static_string ("gtk-extension-event-mode");
  quark_parent_window = g_quark_from_static_string ("gtk-parent-window");
  quark_saved_default_style = g_quark_from_static_string ("gtk-saved-default-style");
  quark_shape_info = g_quark_from_static_string ("gtk-shape-info");
  quark_colormap = g_quark_from_static_string ("gtk-colormap");
  quark_pango_context = g_quark_from_static_string ("gtk-pango-context");
  quark_rc_style = g_quark_from_static_string ("gtk-rc-style");
  quark_accessible_object = g_quark_from_static_string ("gtk-accessible-object");

  style_property_spec_pool = g_param_spec_pool_new (FALSE);

  g_object_class_install_property (gobject_class,
				   PROP_NAME,
				   g_param_spec_string ("name",
 							_("Widget name"),
							_("The name of the widget"),
							NULL,
							G_PARAM_READWRITE));
  
  g_object_class_install_property (gobject_class,
				   PROP_PARENT,
				   g_param_spec_object ("parent",
							_("Parent widget"),
							_("The parent widget of this widget. Must be a Container widget."),
							GTK_TYPE_CONTAINER,
							G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_X,
				   g_param_spec_int ("x",
 						     _("x coordinate"),
 						     _("The x coordinate of the top-left corner of the widget, or -1 if not set"),
 						     -G_MAXINT,
 						     G_MAXINT,
 						     -1,
 						     G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_Y,
				   g_param_spec_int ("y",
 						     _("y coordinate"),
 						     _("The y coordinate of the top-left corner of the widget, or -1 if not set"),
 						     -G_MAXINT,
 						     G_MAXINT,
 						     -1,
 						     G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_WIDTH,
				   g_param_spec_int ("width",
 						     _("Width"),
 						     _("The width of the widget, or -1 if unset."),
 						     -1,
 						     G_MAXINT,
 						     -1,
 						     G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_HEIGHT,
				   g_param_spec_int ("height",
 						     _("Height"),
 						     _("The height of the widget, or -1 if unset."),
 						     -1,
 						     G_MAXINT,
 						     -1,
 						     G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_VISIBLE,
				   g_param_spec_boolean ("visible",
 							 _("Visible"),
 							 _("Whether the widget is visible"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_SENSITIVE,
				   g_param_spec_boolean ("sensitive",
 							 _("Sensitive"),
 							 _("Whether the widget responds to input"),
 							 TRUE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_APP_PAINTABLE,
				   g_param_spec_boolean ("app_paintable",
 							 _("Application paintable"),
 							 _("Whether the application will paint directly on the widget"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_CAN_FOCUS,
				   g_param_spec_boolean ("can_focus",
 							 _("Can focus"),
 							 _("Whether the widget can accept the input focus"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_HAS_FOCUS,
				   g_param_spec_boolean ("has_focus",
 							 _("Has focus"),
 							 _("Whether the widget has the input focus"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_CAN_DEFAULT,
				   g_param_spec_boolean ("can_default",
 							 _("Can default"),
 							 _("Whether the widget can be the default widget"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_HAS_DEFAULT,
				   g_param_spec_boolean ("has_default",
 							 _("Has default"),
 							 _("Whether the widget is the default widget"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_RECEIVES_DEFAULT,
				   g_param_spec_boolean ("receives_default",
 							 _("Receives default"),
 							 _("If TRUE, the widget will receive the default action when it is focused."),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_COMPOSITE_CHILD,
				   g_param_spec_boolean ("composite_child",
 							 _("Composite child"),
 							 _("Whether the widget is composed of other widgets"),
 							 FALSE,
 							 G_PARAM_READWRITE));
 
 
  g_object_class_install_property (gobject_class,
				   PROP_STYLE,
				   g_param_spec_object ("style",
 							_("Style"),
 							_("The style of the widget, which contains information about how it will look (colors etc)."),
 							GTK_TYPE_STYLE,
 							G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_EVENTS,
				   g_param_spec_flags ("events",
 						       _("Events"),
 						       _("The event mask that decides what kind of GdkEvents this widget gets."),
 						       GDK_TYPE_EVENT_MASK,
 						       GDK_STRUCTURE_MASK,
 						       G_PARAM_READWRITE));
 
  g_object_class_install_property (gobject_class,
				   PROP_EXTENSION_EVENTS,
				   g_param_spec_enum ("extension_events",
 						      _("Extension events"),
 						      _("The mask that decides what kind of extension events this widget gets."),
 						      GDK_TYPE_EXTENSION_MODE,
 						      GDK_EXTENSION_EVENTS_NONE,
 						      G_PARAM_READWRITE));


  widget_signals[SHOW] =
    gtk_signal_new ("show",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[HIDE] =
    gtk_signal_new ("hide",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[MAP] =
    gtk_signal_new ("map",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[UNMAP] =
    gtk_signal_new ("unmap",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[REALIZE] =
    gtk_signal_new ("realize",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[UNREALIZE] =
    gtk_signal_new ("unrealize",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[SIZE_REQUEST] =
    g_signal_newc ("size_request",
		   G_OBJECT_CLASS_TYPE (object_class),
		   G_SIGNAL_RUN_FIRST,
		   G_STRUCT_OFFSET (GtkWidgetClass, size_request),
		   NULL, NULL,
		   gtk_marshal_VOID__BOXED,
		   GTK_TYPE_NONE, 1,
		   GTK_TYPE_REQUISITION | G_SIGNAL_TYPE_STATIC_SCOPE);
  widget_signals[SIZE_ALLOCATE] = 
    gtk_signal_new ("size_allocate",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
		    gtk_marshal_VOID__BOXED,
		    GTK_TYPE_NONE, 1,
		    GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
  widget_signals[STATE_CHANGED] =
    gtk_signal_new ("state_changed",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
		    gtk_marshal_VOID__ENUM,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_STATE_TYPE);
  widget_signals[PARENT_SET] =
    gtk_signal_new ("parent_set",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
		    gtk_marshal_VOID__OBJECT,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_OBJECT);
  widget_signals[HIERARCHY_CHANGED] =
    gtk_signal_new ("hierarchy_changed",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, hierarchy_changed),
		    gtk_marshal_NONE__NONE,
		    GTK_TYPE_NONE, 0);
  widget_signals[STYLE_SET] =
    gtk_signal_new ("style_set",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
		    gtk_marshal_VOID__OBJECT,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_STYLE);
  widget_signals[DIRECTION_CHANGED] =
    gtk_signal_new ("direction_changed",
		    GTK_RUN_FIRST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, direction_changed),
		    gtk_marshal_VOID__ENUM,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_TEXT_DIRECTION);
  widget_signals[ADD_ACCELERATOR] =
    gtk_accel_group_create_add (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
				GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
  widget_signals[REMOVE_ACCELERATOR] =
    gtk_accel_group_create_remove (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
				   GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator));
  widget_signals[ACTIVATE_MNEMONIC] =
    g_signal_newc ("mnemonic_activate",
		   GTK_CLASS_TYPE (object_class),
		   GTK_RUN_LAST,
		   GTK_SIGNAL_OFFSET (GtkWidgetClass, mnemonic_activate),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOOLEAN,
		   GTK_TYPE_BOOL, 1,
		   GTK_TYPE_BOOL);
  widget_signals[GRAB_FOCUS] =
    gtk_signal_new ("grab_focus",
		    GTK_RUN_LAST | GTK_RUN_ACTION,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, grab_focus),
		    gtk_marshal_VOID__VOID,
		    GTK_TYPE_NONE, 0);
  widget_signals[FOCUS] =
    g_signal_newc ("focus",
                   G_TYPE_FROM_CLASS (object_class),
                   G_SIGNAL_RUN_LAST,
                   G_STRUCT_OFFSET (GtkWidgetClass, focus),
                   _gtk_boolean_handled_accumulator, NULL,
                   gtk_marshal_BOOLEAN__ENUM,
                   G_TYPE_BOOLEAN, 1,
                   GTK_TYPE_DIRECTION_TYPE);
  widget_signals[EVENT] =
    g_signal_newc ("event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[BUTTON_PRESS_EVENT] =
    g_signal_newc ("button_press_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, button_press_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[BUTTON_RELEASE_EVENT] =
    g_signal_newc ("button_release_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, button_release_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[SCROLL_EVENT] =
    g_signal_newc ("scroll_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, scroll_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[MOTION_NOTIFY_EVENT] =
    g_signal_newc ("motion_notify_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, motion_notify_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[DELETE_EVENT] =
    g_signal_newc ("delete_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, delete_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[DESTROY_EVENT] =
    g_signal_newc ("destroy_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, destroy_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[EXPOSE_EVENT] =
    g_signal_newc ("expose_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, expose_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[KEY_PRESS_EVENT] =
    g_signal_newc ("key_press_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, key_press_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[KEY_RELEASE_EVENT] =
    g_signal_newc ("key_release_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, key_release_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[ENTER_NOTIFY_EVENT] =
    g_signal_newc ("enter_notify_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, enter_notify_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[LEAVE_NOTIFY_EVENT] =
    g_signal_newc ("leave_notify_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, leave_notify_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[CONFIGURE_EVENT] =
    g_signal_newc ("configure_event",
		   G_TYPE_FROM_CLASS(object_class),
		   G_SIGNAL_RUN_LAST,
		   G_STRUCT_OFFSET(GtkWidgetClass, configure_event),
		   _gtk_boolean_handled_accumulator, NULL,
		   gtk_marshal_BOOLEAN__BOXED,
		   G_TYPE_BOOLEAN, 1,
		   GDK_TYPE_EVENT);
  widget_signals[FOCUS_IN_EVENT] =
    g_signal_newc ("focus_in_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, focus_in_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[FOCUS_OUT_EVENT] =
    g_signal_newc ("focus_out_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, focus_out_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[MAP_EVENT] =
    g_signal_newc ("map_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, map_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[UNMAP_EVENT] =
    g_signal_newc ("unmap_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, unmap_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[PROPERTY_NOTIFY_EVENT] =
    g_signal_newc ("property_notify_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, property_notify_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[SELECTION_CLEAR_EVENT] =
    g_signal_newc ("selection_clear_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, selection_clear_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[SELECTION_REQUEST_EVENT] =
    g_signal_newc ("selection_request_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, selection_request_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[SELECTION_NOTIFY_EVENT] =
    g_signal_newc ("selection_notify_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, selection_notify_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[SELECTION_RECEIVED] =
    gtk_signal_new ("selection_received",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
		    gtk_marshal_VOID__BOXED_UINT,
		    GTK_TYPE_NONE, 2,
		    GTK_TYPE_SELECTION_DATA,
		    GTK_TYPE_UINT);
  widget_signals[SELECTION_GET] =
    gtk_signal_new ("selection_get",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_get),
		    gtk_marshal_VOID__BOXED_UINT_UINT,
		    GTK_TYPE_NONE, 3,
		    GTK_TYPE_SELECTION_DATA,
		    GTK_TYPE_UINT,
		    GTK_TYPE_UINT);
  widget_signals[PROXIMITY_IN_EVENT] =
    g_signal_newc ("proximity_in_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, proximity_in_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[PROXIMITY_OUT_EVENT] =
    g_signal_newc ("proximity_out_event",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, proximity_out_event),
                  _gtk_boolean_handled_accumulator, NULL,
                  gtk_marshal_BOOLEAN__BOXED,
                  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[DRAG_LEAVE] =
    gtk_signal_new ("drag_leave",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_leave),
		    gtk_marshal_VOID__OBJECT_UINT,
		    GTK_TYPE_NONE, 2,
		    GDK_TYPE_DRAG_CONTEXT,
		    GTK_TYPE_UINT);
  widget_signals[DRAG_BEGIN] =
    gtk_signal_new ("drag_begin",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin),
		    gtk_marshal_VOID__OBJECT,
		    GTK_TYPE_NONE, 1,
		    GDK_TYPE_DRAG_CONTEXT);
  widget_signals[DRAG_END] =
    gtk_signal_new ("drag_end",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end),
		    gtk_marshal_VOID__OBJECT,
		    GTK_TYPE_NONE, 1,
		    GDK_TYPE_DRAG_CONTEXT);
  widget_signals[DRAG_DATA_DELETE] =
    gtk_signal_new ("drag_data_delete",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete),
		    gtk_marshal_VOID__OBJECT,
		    GTK_TYPE_NONE, 1,
		    GDK_TYPE_DRAG_CONTEXT);
  widget_signals[DRAG_MOTION] =
    g_signal_newc ("drag_motion",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, drag_motion),
                  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT,
		  G_TYPE_BOOLEAN, 4,
		  GDK_TYPE_DRAG_CONTEXT,
		  G_TYPE_INT,
		  G_TYPE_INT,
		  G_TYPE_UINT);
  widget_signals[DRAG_DROP] =
    g_signal_newc ("drag_drop",
                  G_TYPE_FROM_CLASS(object_class),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET(GtkWidgetClass, drag_drop),
                  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT,
		  G_TYPE_BOOLEAN, 4,
		  GDK_TYPE_DRAG_CONTEXT,
		  G_TYPE_INT,
		  G_TYPE_INT,
		  G_TYPE_UINT);
  widget_signals[DRAG_DATA_GET] =
    gtk_signal_new ("drag_data_get",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_get),
		    gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT,
		    GTK_TYPE_NONE, 4,
		    GDK_TYPE_DRAG_CONTEXT,
		    GTK_TYPE_SELECTION_DATA,
		    GTK_TYPE_UINT,
		    GTK_TYPE_UINT);
  widget_signals[DRAG_DATA_RECEIVED] =
    gtk_signal_new ("drag_data_received",
		    GTK_RUN_LAST,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_received),
		    gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT,
		    GTK_TYPE_NONE, 6,
		    GDK_TYPE_DRAG_CONTEXT,
		    GTK_TYPE_INT,
		    GTK_TYPE_INT,
		    GTK_TYPE_SELECTION_DATA,
		    GTK_TYPE_UINT,
		    GTK_TYPE_UINT);
  widget_signals[VISIBILITY_NOTIFY_EVENT] =
    g_signal_newc ("visibility_notify_event",
		  G_TYPE_FROM_CLASS(object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET(GtkWidgetClass, visibility_notify_event),
                  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__BOXED,
		  G_TYPE_BOOLEAN, 1,
                  GDK_TYPE_EVENT);
  widget_signals[CLIENT_EVENT] =
    g_signal_newc ("client_event",
		  G_TYPE_FROM_CLASS(object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET(GtkWidgetClass, client_event),
		  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__BOXED,
		  G_TYPE_BOOLEAN, 1,
		  GDK_TYPE_EVENT);
  widget_signals[NO_EXPOSE_EVENT] =
    g_signal_newc ("no_expose_event",
		  G_TYPE_FROM_CLASS(object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET(GtkWidgetClass, no_expose_event),
		  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__BOXED,
		  G_TYPE_BOOLEAN, 1,
		  GDK_TYPE_EVENT);
  widget_signals[WINDOW_STATE_EVENT] =
    g_signal_newc ("window_state_event",
		  G_TYPE_FROM_CLASS(object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET(GtkWidgetClass, window_state_event),
		  _gtk_boolean_handled_accumulator, NULL,
		  gtk_marshal_BOOLEAN__BOXED,
		  G_TYPE_BOOLEAN, 1,
		  GDK_TYPE_EVENT);
  widget_signals[POPUP_MENU] =
    gtk_signal_new ("popup_menu",
		    GTK_RUN_LAST | GTK_RUN_ACTION,
		    GTK_CLASS_TYPE (object_class),
		    GTK_SIGNAL_OFFSET (GtkWidgetClass, popup_menu),
                    gtk_marshal_NONE__NONE,
		    GTK_TYPE_NONE, 0);
  
  binding_set = gtk_binding_set_by_class (klass);

  gtk_binding_entry_add_signal (binding_set, GDK_F10, GDK_SHIFT_MASK,
                                "popup_menu", 0);

  gtk_binding_entry_add_signal (binding_set, GDK_Menu, 0,
                                "popup_menu", 0);  

  gtk_widget_class_install_style_property (klass,
					   g_param_spec_boolean ("interior_focus",
								 _("Interior Focus"),
								 _("Whether to draw the focus indicator inside widgets."),
								 TRUE,
								 G_PARAM_READABLE));
}

static void
gtk_widget_set_property (GObject         *object,
			 guint            prop_id,
			 const GValue    *value,
			 GParamSpec      *pspec)
{
  GtkWidget *widget;
  GtkWidgetAuxInfo *aux_info;

  widget = GTK_WIDGET (object);

  switch (prop_id)
    {
      guint32 saved_flags;
      
    case PROP_NAME:
      gtk_widget_set_name (widget, g_value_get_string (value));
      break;
    case PROP_PARENT:
      gtk_container_add (GTK_CONTAINER (g_value_get_object (value)), widget);
      break;
    case PROP_X:
      aux_info = _gtk_widget_get_aux_info (widget, TRUE);
      if (g_value_get_int (value) == -1)
	aux_info->x_set = FALSE;
      else
	{
	  aux_info->x_set = TRUE;
	  aux_info->x = g_value_get_int (value);
	}
      gtk_widget_do_uposition (widget);
      break;
    case PROP_Y:
      aux_info = _gtk_widget_get_aux_info (widget, TRUE);
      if (g_value_get_int (value) == -1)
	aux_info->y_set = FALSE;
      else
	{
	  aux_info->y_set = TRUE;
	  aux_info->y = g_value_get_int (value);
	}
      gtk_widget_do_uposition (widget);
      break;
    case PROP_WIDTH:
      gtk_widget_set_usize (widget, g_value_get_int (value), -2);
      break;
    case PROP_HEIGHT:
      gtk_widget_set_usize (widget, -2, g_value_get_int (value));
      break;
    case PROP_VISIBLE:
      if (g_value_get_boolean (value))
	gtk_widget_show (widget);
      else
	gtk_widget_hide (widget);
      break;
    case PROP_SENSITIVE:
      gtk_widget_set_sensitive (widget, g_value_get_boolean (value));
      break;
    case PROP_APP_PAINTABLE:
      gtk_widget_set_app_paintable (widget, g_value_get_boolean (value));
      break;
    case PROP_CAN_FOCUS:
      saved_flags = GTK_WIDGET_FLAGS (widget);
      if (g_value_get_boolean (value))
	GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
      else
	GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
      if (saved_flags != GTK_WIDGET_FLAGS (widget))
	gtk_widget_queue_resize (widget);
      break;
    case PROP_HAS_FOCUS:
      if (g_value_get_boolean (value))
	gtk_widget_grab_focus (widget);
      break;
    case PROP_CAN_DEFAULT:
      saved_flags = GTK_WIDGET_FLAGS (widget);
      if (g_value_get_boolean (value))
	GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
      else
	GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
      if (saved_flags != GTK_WIDGET_FLAGS (widget))
	gtk_widget_queue_resize (widget);
      break;
    case PROP_HAS_DEFAULT:
      if (g_value_get_boolean (value))
	gtk_widget_grab_default (widget);
      break;
    case PROP_RECEIVES_DEFAULT:
      if (g_value_get_boolean (value))
	GTK_WIDGET_SET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
      else
	GTK_WIDGET_UNSET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
      break;
    case PROP_COMPOSITE_CHILD:
      if (g_value_get_boolean (value))
	GTK_WIDGET_SET_FLAGS (widget, GTK_COMPOSITE_CHILD);
      else
	GTK_WIDGET_UNSET_FLAGS (widget, GTK_COMPOSITE_CHILD);
      break;