/* 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 "config.h"

#include <stdarg.h>

#include <string.h>

#include <locale.h>

#include "gtkcontainer.h"

#include "gtkaccelmap.h"

#include "gtkclipboard.h"

#include "gtkiconfactory.h"

#include "gtkintl.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkrc.h"

#include "gtkselection.h"

#include "gtksettings.h"

#include "gtksizegroup.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 <gobject/gobjectnotifyqueue.c>

#include "gdk/gdkkeysyms.h"

#include "gtkaccessible.h"

#include "gtktooltip.h"

#include "gtkinvisible.h"

#include "gtkbuildable.h"

#include "gtkbuilderprivate.h"

#include "gtkalias.h"

#ifdef MAEMO_CHANGES

#include <x11/gdkx.h>

#include <stdlib.h>

#include "gtkmenu.h"

#include "gtkmenuitem.h"

#include "gtkicontheme.h"

#include "gtkdnd.h"

#endif /* MAEMO_CHANGES */

#define WIDGET_CLASS(w)	 GTK_WIDGET_GET_CLASS (w)

#define	INIT_PATH_SIZE	(512)

#ifdef MAEMO_CHANGES

#define TAP_AND_HOLD_TIMER_COUNTER 6

#define TAP_AND_HOLD_TIMER_INTERVAL 100

/* #define TAP_AND_HOLD_ANIMATION 1 */

#endif /* MAEMO_CHANGES */

enum {

  SHOW,

  HIDE,

  MAP,

  UNMAP,

  REALIZE,

  UNREALIZE,

  SIZE_REQUEST,

  SIZE_ALLOCATE,

  STATE_CHANGED,

  PARENT_SET,

  HIERARCHY_CHANGED,

  STYLE_SET,

  DIRECTION_CHANGED,

  GRAB_NOTIFY,

  CHILD_NOTIFY,

  MNEMONIC_ACTIVATE,

  GRAB_FOCUS,

  FOCUS,

  MOVE_FOCUS,

  EVENT,

  EVENT_AFTER,

  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,

  SHOW_HELP,

  ACCEL_CLOSURES_CHANGED,

  SCREEN_CHANGED,

  CAN_ACTIVATE_ACCEL,

  GRAB_BROKEN,

  COMPOSITED_CHANGED,

  QUERY_TOOLTIP,

  KEYNAV_FAILED,

  DRAG_FAILED,

  DAMAGE_EVENT,

#ifdef MAEMO_CHANGES

  INSENSITIVE_PRESS,

  TAP_AND_HOLD,

  TAP_AND_HOLD_SETUP,

  TAP_AND_HOLD_QUERY,

#endif /* MAEMO_CHANGES */

  LAST_SIGNAL

};

enum {

  PROP_0,

  PROP_NAME,

  PROP_PARENT,

  PROP_WIDTH_REQUEST,

  PROP_HEIGHT_REQUEST,

  PROP_VISIBLE,

  PROP_SENSITIVE,

  PROP_APP_PAINTABLE,

  PROP_CAN_FOCUS,

  PROP_HAS_FOCUS,

  PROP_IS_FOCUS,

  PROP_CAN_DEFAULT,

  PROP_HAS_DEFAULT,

  PROP_RECEIVES_DEFAULT,

  PROP_COMPOSITE_CHILD,

  PROP_STYLE,

  PROP_EVENTS,

  PROP_EXTENSION_EVENTS,

  PROP_NO_SHOW_ALL,

  PROP_HAS_TOOLTIP,

  PROP_TOOLTIP_MARKUP,

  PROP_TOOLTIP_TEXT,

  PROP_WINDOW

#ifdef MAEMO_CHANGES

  , PROP_TAP_AND_HOLD

#endif /* MAEMO_CHANGES */

};

typedef	struct	_GtkStateData	 GtkStateData;

struct _GtkStateData

{

  GtkStateType  state;

  guint		state_restoration : 1;

  guint         parent_sensitive : 1;

  guint		use_forall : 1;

};

/* --- prototypes --- */

static void	gtk_widget_class_init		(GtkWidgetClass     *klass);

static void	gtk_widget_base_class_finalize	(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_dispose		 (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 void	gtk_widget_real_style_set        (GtkWidget         *widget,

                                                  GtkStyle          *previous_style);

static void	gtk_widget_real_direction_changed(GtkWidget         *widget,

                                                  GtkTextDirection   previous_direction);

static void	gtk_widget_real_grab_focus	 (GtkWidget         *focus_widget);

static gboolean gtk_widget_real_query_tooltip    (GtkWidget         *widget,

						  gint               x,

						  gint               y,

						  gboolean           keyboard_tip,

						  GtkTooltip        *tooltip);

static gboolean gtk_widget_real_show_help        (GtkWidget         *widget,

                                                  GtkWidgetHelpType  help_type);

static void	gtk_widget_dispatch_child_properties_changed	(GtkWidget        *object,

								 guint             n_pspecs,

								 GParamSpec      **pspecs);

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 gboolean		gtk_widget_real_focus			(GtkWidget        *widget,

								 GtkDirectionType  direction);

static void             gtk_widget_real_move_focus              (GtkWidget        *widget,

                                                                 GtkDirectionType  direction);

static gboolean		gtk_widget_real_keynav_failed		(GtkWidget        *widget,

								 GtkDirectionType  direction);

static PangoContext*	gtk_widget_peek_pango_context		(GtkWidget	  *widget);

static void     	gtk_widget_update_pango_context		(GtkWidget	  *widget);

static void		gtk_widget_propagate_state		(GtkWidget	  *widget,

								 GtkStateData 	  *data);

static void             gtk_widget_reset_rc_style               (GtkWidget        *widget);

static void		gtk_widget_set_style_internal		(GtkWidget	  *widget,

								 GtkStyle	  *style,

								 gboolean	   initial_emission);

static gint		gtk_widget_event_internal		(GtkWidget	  *widget,

								 GdkEvent	  *event);

static gboolean		gtk_widget_real_mnemonic_activate	(GtkWidget	  *widget,

								 gboolean	   group_cycling);

static void		gtk_widget_aux_info_destroy		(GtkWidgetAuxInfo *aux_info);

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 void             gtk_widget_invalidate_widget_windows    (GtkWidget        *widget,

								 GdkRegion        *region);

static GdkScreen *      gtk_widget_get_screen_unchecked         (GtkWidget        *widget);

static void		gtk_widget_queue_shallow_draw		(GtkWidget        *widget);

static gboolean         gtk_widget_real_can_activate_accel      (GtkWidget *widget,

                                                                 guint      signal_id);

static void             gtk_widget_real_set_has_tooltip         (GtkWidget *widget,

								 gboolean   has_tooltip,

								 gboolean   force);

static void             gtk_widget_buildable_interface_init     (GtkBuildableIface *iface);

static void             gtk_widget_buildable_set_name           (GtkBuildable     *buildable,

                                                                 const gchar      *name);

static const gchar *    gtk_widget_buildable_get_name           (GtkBuildable     *buildable);

static GObject *        gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,

								 GtkBuilder   *builder,

								 const gchar  *childname);

static void             gtk_widget_buildable_set_buildable_property (GtkBuildable     *buildable,

								     GtkBuilder       *builder,

								     const gchar      *name,

								     const GValue     *value);

static gboolean         gtk_widget_buildable_custom_tag_start   (GtkBuildable     *buildable,

                                                                 GtkBuilder       *builder,

                                                                 GObject          *child,

                                                                 const gchar      *tagname,

                                                                 GMarkupParser    *parser,

                                                                 gpointer         *data);

static void             gtk_widget_buildable_custom_finished    (GtkBuildable     *buildable,

                                                                 GtkBuilder       *builder,

                                                                 GObject          *child,

                                                                 const gchar      *tagname,

                                                                 gpointer          data);

static void             gtk_widget_buildable_parser_finished    (GtkBuildable     *buildable,

                                                                 GtkBuilder       *builder);

static void gtk_widget_set_usize_internal (GtkWidget *widget,

					   gint       width,

					   gint       height);

static void gtk_widget_get_draw_rectangle (GtkWidget    *widget,

					   GdkRectangle *rect);

#ifdef MAEMO_CHANGES

typedef struct

{

  GtkWidget *menu;

  guint timer_id;

  GtkMenuPositionFunc func;

  gint x, y;

  gint timer_counter;

  gint signals_connected : 1;

  guint interval;

  GdkWindow *tah_on_window;

#ifdef TAP_AND_HOLD_ANIMATION

  GdkPixbufAnimation *anim;

  GdkPixbufAnimationIter *iter;

#endif

} TahData;

/* --- Tap And Hold --- */

static gboolean gtk_widget_tap_and_hold_timeout           (GtkWidget                *widget);

static gboolean gtk_widget_tap_and_hold_button_press      (GtkWidget                *widget,

                                                           GdkEvent                 *event,

                                                           TahData                  *td);

static gboolean gtk_widget_tap_and_hold_event_stop        (GtkWidget                *widget,

                                                           gpointer                  unused,

                                                           TahData                  *td);

static void     gtk_widget_real_tap_and_hold_setup        (GtkWidget                *widget,

                                                           GtkWidget                *menu,

                                                           GtkCallback               func,

                                                           GtkWidgetTapAndHoldFlags  flags );

static void     gtk_widget_real_tap_and_hold              (GtkWidget                *widget);

static gboolean gtk_widget_tap_and_hold_query             (GtkWidget                *widget,

                                                           GdkEvent                 *event);

static gboolean gtk_widget_real_tap_and_hold_query        (GtkWidget                *widget,

                                                           GdkEvent                 *event);

static gboolean gtk_widget_tap_and_hold_query_accumulator (GSignalInvocationHint    *ihint,

                                                           GValue                   *return_accu,

                                                           const GValue             *handler_return,

                                                           gpointer                  dummy);

#endif /* MAEMO_CHANGES */

/* --- variables --- */

static gpointer         gtk_widget_parent_class = NULL;

static guint            widget_signals[LAST_SIGNAL] = { 0 };

static GtkStyle        *gtk_default_style = NULL;

static GSList          *colormap_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_accel_path = 0;

static GQuark		quark_accel_closures = 0;

static GQuark		quark_event_mask = 0;

static GQuark		quark_extension_event_mode = 0;

static GQuark		quark_parent_window = 0;

static GQuark		quark_pointer_window = 0;

static GQuark		quark_shape_info = 0;

static GQuark		quark_input_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;

static GQuark		quark_mnemonic_labels = 0;

static GQuark		quark_tooltip_markup = 0;

static GQuark		quark_has_tooltip = 0;

static GQuark		quark_tooltip_window = 0;

GParamSpecPool         *_gtk_widget_child_property_pool = NULL;

GObjectNotifyContext   *_gtk_widget_child_property_notify_context = NULL;

/* --- functions --- */

GType

gtk_widget_get_type (void)

{

  static GType widget_type = 0;

  if (G_UNLIKELY (widget_type == 0))

    {

      const GTypeInfo widget_info =

      {

	sizeof (GtkWidgetClass),

	NULL,		/* base_init */

	(GBaseFinalizeFunc) gtk_widget_base_class_finalize,

	(GClassInitFunc) gtk_widget_class_init,

	NULL,		/* class_finalize */

	NULL,		/* class_init */

	sizeof (GtkWidget),

	0,		/* n_preallocs */

	(GInstanceInitFunc) gtk_widget_init,

	NULL,		/* value_table */

      };

      const GInterfaceInfo accessibility_info =

      {

	(GInterfaceInitFunc) gtk_widget_accessible_interface_init,

	(GInterfaceFinalizeFunc) NULL,

	NULL /* interface data */

      };

      const GInterfaceInfo buildable_info =

      {

	(GInterfaceInitFunc) gtk_widget_buildable_interface_init,

	(GInterfaceFinalizeFunc) NULL,

	NULL /* interface data */

      };

      widget_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkWidget",

                                           &widget_info, G_TYPE_FLAG_ABSTRACT);

      g_type_add_interface_static (widget_type, ATK_TYPE_IMPLEMENTOR,

                                   &accessibility_info) ;

      g_type_add_interface_static (widget_type, GTK_TYPE_BUILDABLE,

                                   &buildable_info) ;

    }

  return widget_type;

}

static void

child_property_notify_dispatcher (GObject     *object,

				  guint        n_pspecs,

				  GParamSpec **pspecs)

{

  GTK_WIDGET_GET_CLASS (object)->dispatch_child_properties_changed (GTK_WIDGET (object), n_pspecs, pspecs);

}

#ifdef MAEMO_CHANGES

static void

maemo_widget_constructed (GObject *object)

{

  static GQuark quark_maemo_widget_customizer = 0;

  if (!quark_maemo_widget_customizer)

    quark_maemo_widget_customizer = g_quark_from_static_string ("maemo_widget_customizer");

  void (*hook) (GtkWidget*) = g_type_get_qdata (G_OBJECT_TYPE (object), quark_maemo_widget_customizer);

  if (hook)

    hook (GTK_WIDGET (object));

}

#endif /* MAEMO_CHANGES */

static void

gtk_widget_class_init (GtkWidgetClass *klass)

{

  static GObjectNotifyContext cpn_context = { 0, NULL, NULL };

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);

  GtkBindingSet *binding_set;

  gtk_widget_parent_class = g_type_class_peek_parent (klass);

  quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");

  quark_aux_info = g_quark_from_static_string ("gtk-aux-info");

  quark_accel_path = g_quark_from_static_string ("gtk-accel-path");

  quark_accel_closures = g_quark_from_static_string ("gtk-accel-closures");

  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_pointer_window = g_quark_from_static_string ("gtk-pointer-window");

  quark_shape_info = g_quark_from_static_string ("gtk-shape-info");

  quark_input_shape_info = g_quark_from_static_string ("gtk-input-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");

  quark_mnemonic_labels = g_quark_from_static_string ("gtk-mnemonic-labels");

  quark_tooltip_markup = g_quark_from_static_string ("gtk-tooltip-markup");

  quark_has_tooltip = g_quark_from_static_string ("gtk-has-tooltip");

  quark_tooltip_window = g_quark_from_static_string ("gtk-tooltip-window");

  style_property_spec_pool = g_param_spec_pool_new (FALSE);

  _gtk_widget_child_property_pool = g_param_spec_pool_new (TRUE);

  cpn_context.quark_notify_queue = g_quark_from_static_string ("GtkWidget-child-property-notify-queue");

  cpn_context.dispatcher = child_property_notify_dispatcher;

  _gtk_widget_child_property_notify_context = &cpn_context;

#ifdef MAEMO_CHANGES

  gobject_class->constructed = maemo_widget_constructed;

#endif /* MAEMO_CHANGES */

  gobject_class->dispose = gtk_widget_dispose;

  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->dispatch_child_properties_changed = gtk_widget_dispatch_child_properties_changed;

  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_real_style_set;

  klass->direction_changed = gtk_widget_real_direction_changed;

  klass->grab_notify = NULL;

  klass->child_notify = NULL;

  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;

  klass->screen_changed = NULL;

  klass->can_activate_accel = gtk_widget_real_can_activate_accel;

  klass->grab_broken_event = NULL;

  klass->query_tooltip = gtk_widget_real_query_tooltip;

  klass->show_help = gtk_widget_real_show_help;

  /* Accessibility support */

  klass->get_accessible = gtk_widget_real_get_accessible;

  klass->no_expose_event = NULL;

  g_object_class_install_property (gobject_class,

				   PROP_NAME,

				   g_param_spec_string ("name",

 							P_("Widget name"),

							P_("The name of the widget"),

							NULL,

							GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_PARENT,

				   g_param_spec_object ("parent",

							P_("Parent widget"), 

							P_("The parent widget of this widget. Must be a Container widget"),

							GTK_TYPE_CONTAINER,

							GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_WIDTH_REQUEST,

				   g_param_spec_int ("width-request",

 						     P_("Width request"),

 						     P_("Override for width request of the widget, or -1 if natural request should be used"),

 						     -1,

 						     G_MAXINT,

 						     -1,

 						     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_HEIGHT_REQUEST,

				   g_param_spec_int ("height-request",

 						     P_("Height request"),

 						     P_("Override for height request of the widget, or -1 if natural request should be used"),

 						     -1,

 						     G_MAXINT,

 						     -1,

 						     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_VISIBLE,

				   g_param_spec_boolean ("visible",

 							 P_("Visible"),

 							 P_("Whether the widget is visible"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_SENSITIVE,

				   g_param_spec_boolean ("sensitive",

 							 P_("Sensitive"),

 							 P_("Whether the widget responds to input"),

 							 TRUE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_APP_PAINTABLE,

				   g_param_spec_boolean ("app-paintable",

 							 P_("Application paintable"),

 							 P_("Whether the application will paint directly on the widget"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_CAN_FOCUS,

				   g_param_spec_boolean ("can-focus",

 							 P_("Can focus"),

 							 P_("Whether the widget can accept the input focus"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_HAS_FOCUS,

				   g_param_spec_boolean ("has-focus",

 							 P_("Has focus"),

 							 P_("Whether the widget has the input focus"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_IS_FOCUS,

				   g_param_spec_boolean ("is-focus",

 							 P_("Is focus"),

 							 P_("Whether the widget is the focus widget within the toplevel"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_CAN_DEFAULT,

				   g_param_spec_boolean ("can-default",

 							 P_("Can default"),

 							 P_("Whether the widget can be the default widget"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_HAS_DEFAULT,

				   g_param_spec_boolean ("has-default",

 							 P_("Has default"),

 							 P_("Whether the widget is the default widget"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_RECEIVES_DEFAULT,

				   g_param_spec_boolean ("receives-default",

 							 P_("Receives default"),

 							 P_("If TRUE, the widget will receive the default action when it is focused"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_COMPOSITE_CHILD,

				   g_param_spec_boolean ("composite-child",

 							 P_("Composite child"),

 							 P_("Whether the widget is part of a composite widget"),

 							 FALSE,

 							 GTK_PARAM_READABLE));

  g_object_class_install_property (gobject_class,

				   PROP_STYLE,

				   g_param_spec_object ("style",

 							P_("Style"),

 							P_("The style of the widget, which contains information about how it will look (colors etc)"),

 							GTK_TYPE_STYLE,

 							GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_EVENTS,

				   g_param_spec_flags ("events",

 						       P_("Events"),

 						       P_("The event mask that decides what kind of GdkEvents this widget gets"),

 						       GDK_TYPE_EVENT_MASK,

 						       GDK_STRUCTURE_MASK,

 						       GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_EXTENSION_EVENTS,

				   g_param_spec_enum ("extension-events",

 						      P_("Extension events"),

 						      P_("The mask that decides what kind of extension events this widget gets"),

 						      GDK_TYPE_EXTENSION_MODE,

 						      GDK_EXTENSION_EVENTS_NONE,

 						      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

				   PROP_NO_SHOW_ALL,

				   g_param_spec_boolean ("no-show-all",

 							 P_("No show all"),

 							 P_("Whether gtk_widget_show_all() should not affect this widget"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

/**

 * GtkWidget:has-tooltip:

 *

 * Enables or disables the emission of #GtkWidget::query-tooltip on @widget.  

 * A value of %TRUE indicates that @widget can have a tooltip, in this case

 * the widget will be queried using #GtkWidget::query-tooltip to determine

 * whether it will provide a tooltip or not.

 *

 * Note that setting this property to %TRUE for the first time will change

 * the event masks of the GdkWindows of this widget to include leave-notify

 * and motion-notify events.  This cannot and will not be undone when the

 * property is set to %FALSE again.

 *

 * Since: 2.12

 */

  g_object_class_install_property (gobject_class,

				   PROP_HAS_TOOLTIP,

				   g_param_spec_boolean ("has-tooltip",

 							 P_("Has tooltip"),

 							 P_("Whether this widget has a tooltip"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  /**

   * GtkWidget:tooltip-text:

   *

   * Sets the text of tooltip to be the given string.

   *

   * Also see gtk_tooltip_set_text().

   *

   * This is a convenience property which will take care of getting the

   * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip

   * will automatically be set to %TRUE and there will be taken care of

   * #GtkWidget::query-tooltip in the default signal handler.

   *

   * Since: 2.12

   */

  g_object_class_install_property (gobject_class,

                                   PROP_TOOLTIP_TEXT,

                                   g_param_spec_string ("tooltip-text",

                                                        P_("Tooltip Text"),

                                                        P_("The contents of the tooltip for this widget"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkWidget:tooltip-markup:

   *

   * Sets the text of tooltip to be the given string, which is marked up

   * with the <link linkend="PangoMarkupFormat">Pango text markup language</link>.

   * Also see gtk_tooltip_set_markup().

   *

   * This is a convenience property which will take care of getting the

   * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip

   * will automatically be set to %TRUE and there will be taken care of

   * #GtkWidget::query-tooltip in the default signal handler.

   *

   * Since: 2.12

   */

  g_object_class_install_property (gobject_class,

				   PROP_TOOLTIP_MARKUP,

				   g_param_spec_string ("tooltip-markup",

 							P_("Tooltip markup"),

							P_("The contents of the tooltip for this widget"),

							NULL,

							GTK_PARAM_READWRITE));

  /**

   * GtkWidget:window:

   *

   * The widget's window if it is realized, %NULL otherwise.

   *

   * Since: 2.14

   */

  g_object_class_install_property (gobject_class,

				   PROP_WINDOW,

				   g_param_spec_object ("window",

 							P_("Window"),

							P_("The widget's window if it is realized"),

							GDK_TYPE_WINDOW,

							GTK_PARAM_READABLE));

#ifdef MAEMO_CHANGES

  /**

   * GtkWidget:tap-and-hold-state:

   *

   * Sets the state (#GtkStateType) to be used to the tap and hold

   * functionality. The default is GTK_STATE_NORMAL.

   *

   * Deprecated: Functionality for setting and getting this propery is not

   * implemented.

   *

   * Since: maemo 1.0

   * Stability: Unstable

   */

  g_object_class_install_property (gobject_class,

                                   PROP_TAP_AND_HOLD,

                                   g_param_spec_int ("tap-and-hold-state",

                                                     P_("Tap and hold State type"),

                                                     P_("Sets the state to be used to the tap and hold functionality. The default is GTK_STATE_NORMAL"),

                                                     0,

                                                     4, /*4 == Last state in GTK+-2.0*/

                                                     GTK_STATE_NORMAL,

                                                     G_PARAM_READWRITE));

#endif /* MAEMO_CHANGES */

  widget_signals[SHOW] =

    g_signal_new (I_("show"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, show),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[HIDE] =

    g_signal_new (I_("hide"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, hide),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[MAP] =

    g_signal_new (I_("map"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, map),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[UNMAP] =

    g_signal_new (I_("unmap"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, unmap),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[REALIZE] =

    g_signal_new (I_("realize"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, realize),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[UNREALIZE] =

    g_signal_new (I_("unrealize"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkWidgetClass, unrealize),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[SIZE_REQUEST] =

    g_signal_new (I_("size-request"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, size_request),

		  NULL, NULL,

		  _gtk_marshal_VOID__BOXED,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_REQUISITION | G_SIGNAL_TYPE_STATIC_SCOPE);

  widget_signals[SIZE_ALLOCATE] = 

    g_signal_new (I_("size-allocate"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, size_allocate),

		  NULL, NULL,

		  _gtk_marshal_VOID__BOXED,

		  G_TYPE_NONE, 1,

		  GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);

  widget_signals[STATE_CHANGED] =

    g_signal_new (I_("state-changed"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, state_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__ENUM,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_STATE_TYPE);

  /**

   * GtkWidget::parent-set:

   * @widget: the object on which the signal is emitted

   * @old_parent: the previous parent, or %NULL if the widget 

   *   just got its initial parent.

   *

   * The ::parent-set signal is emitted when a new parent 

   * has been set on a widget. 

   */

  widget_signals[PARENT_SET] =

    g_signal_new (I_("parent-set"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, parent_set),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_WIDGET);

  /**

   * GtkWidget::hierarchy-changed:

   * @widget: the object on which the signal is emitted

   * @previous_toplevel: the previous toplevel ancestor, or %NULL

   *   if the widget was previously unanchored

   *

   * The ::hierarchy-changed signal is emitted when the

   * anchored state of a widget changes. A widget is

   * <firstterm>anchored</firstterm> when its toplevel

   * ancestor is a #GtkWindow. This signal is emitted when

   * a widget changes from un-anchored to anchored or vice-versa.

   */

  widget_signals[HIERARCHY_CHANGED] =

    g_signal_new (I_("hierarchy-changed"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkWidgetClass, hierarchy_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_WIDGET);

  /**

   * GtkWidget::style-set:

   * @widget: the object on which the signal is emitted

   * @previous_style: the previous style, or %NULL if the widget 

   *   just got its initial style 

   *

   * The ::style-set signal is emitted when a new style has been set 

   * on a widget. Note that style-modifying functions like 

   * gtk_widget_modify_base() also cause this signal to be emitted.

   */

  widget_signals[STYLE_SET] =

    g_signal_new (I_("style-set"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, style_set),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_STYLE);

/**

 * GtkWidget::direction-changed:

 * @widget: the object on which the signal is emitted

 * @previous_direction: the previous text direction of @widget

 *

 * The ::direction-changed signal is emitted when the text direction

 * of a widget changes.

 */

  widget_signals[DIRECTION_CHANGED] =

    g_signal_new (I_("direction-changed"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkWidgetClass, direction_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__ENUM,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_TEXT_DIRECTION);

  /**

   * GtkWidget::grab-notify:

   * @widget: the object which received the signal

   * @was_grabbed: %FALSE if the widget becomes shadowed, %TRUE

   *               if it becomes unshadowed

   *

   * The ::grab-notify signal is emitted when a widget becomes

   * shadowed by a GTK+ grab (not a pointer or keyboard grab) on 

   * another widget, or when it becomes unshadowed due to a grab 

   * being removed.

   * 

   * A widget is shadowed by a gtk_grab_add() when the topmost 

   * grab widget in the grab stack of its window group is not 

   * its ancestor.

   */

  widget_signals[GRAB_NOTIFY] =

    g_signal_new (I_("grab-notify"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_FIRST,

                  G_STRUCT_OFFSET (GtkWidgetClass, grab_notify),

		  NULL, NULL,

		  _gtk_marshal_VOID__BOOLEAN,

		  G_TYPE_NONE, 1,

		  G_TYPE_BOOLEAN);

/**

 * GtkWidget::child-notify:

 * @widget: the object which received the signal

 * @pspec: the #GParamSpec of the changed child property

 *

 * The ::child-notify signal is emitted for each 

 * <link linkend="child-properties">child property</link>  that has

 * changed on an object. The signal's detail holds the property name. 

 */

  widget_signals[CHILD_NOTIFY] =

    g_signal_new (I_("child-notify"),

		   G_TYPE_FROM_CLASS (gobject_class),

		   G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,

		   G_STRUCT_OFFSET (GtkWidgetClass, child_notify),

		   NULL, NULL,

		   g_cclosure_marshal_VOID__PARAM,

		   G_TYPE_NONE, 1,

		   G_TYPE_PARAM);

  widget_signals[MNEMONIC_ACTIVATE] =

    g_signal_new (I_("mnemonic-activate"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkWidgetClass, mnemonic_activate),

		  _gtk_boolean_handled_accumulator, NULL,

		  _gtk_marshal_BOOLEAN__BOOLEAN,

		  G_TYPE_BOOLEAN, 1,

		  G_TYPE_BOOLEAN);

  widget_signals[GRAB_FOCUS] =

    g_signal_new (I_("grab-focus"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GtkWidgetClass, grab_focus),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_signals[FOCUS] =

    g_signal_new (I_("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[MOVE_FOCUS] =

    g_signal_new_class_handler (I_("move-focus"),

                                G_TYPE_FROM_CLASS (object_class),

                                G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

                                G_CALLBACK (gtk_widget_real_move_focus),

                                NULL, NULL,

                                _gtk_marshal_VOID__ENUM,

                                G_TYPE_NONE,

                                1,

                                GTK_TYPE_DIRECTION_TYPE);

  /**

   * GtkWidget::event:

   * @widget: the object which received the signal.

   * @event: the #GdkEvent which triggered this signal

   *

   * The GTK+ main loop will emit three signals for each GDK event delivered

   * to a widget: one generic ::event signal, another, more specific,

   * signal that matches the type of event delivered (e.g. 

   * #GtkWidget::key-press-event) and finally a generic 

   * #GtkWidget::event-after signal.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event 

   * and to cancel the emission of the second specific ::event signal.

   *   %FALSE to propagate the event further and to allow the emission of 

   *   the second signal. The ::event-after signal is emitted regardless of

   *   the return value.

   */

  widget_signals[EVENT] =

    g_signal_new (I_("event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::event-after:

   * @widget: the object which received the signal.

   * @event: the #GdkEvent which triggered this signal

   *

   * After the emission of the #GtkWidget::event signal and (optionally) 

   * the second more specific signal, ::event-after will be emitted 

   * regardless of the previous two signals handlers return values.

   *

   */

  widget_signals[EVENT_AFTER] =

    g_signal_new (I_("event-after"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  0,

		  0,

		  NULL, NULL,

		  _gtk_marshal_VOID__BOXED,

		  G_TYPE_NONE, 1,

		  GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::button-press-event:

   * @widget: the object which received the signal.

   * @event: the #GdkEventButton which triggered this signal

   *

   * The ::button-press-event signal will be emitted when a button

   * (typically from a mouse) is pressed.

   *

   * To receive this signal, the #GdkWindow associated to the 

   * widget needs to enable the #GDK_BUTTON_PRESS_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[BUTTON_PRESS_EVENT] =

    g_signal_new (I_("button-press-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::button-release-event:

   * @widget: the object which received the signal.

   * @event: the #GdkEventButton which triggered this signal

   *

   * The ::button-release-event signal will be emitted when a button

   * (typically from a mouse) is released.

   *

   * To receive this signal, the #GdkWindow associated to the 

   * widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[BUTTON_RELEASE_EVENT] =

    g_signal_new (I_("button-release-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::scroll-event:

   * @widget: the object which received the signal.

   * @event: the #GdkEventScroll which triggered this signal

   *

   * The ::scroll-event signal is emitted when a button in the 4 to 7

   * range is pressed. Wheel mice are usually configured to generate 

   * button press events for buttons 4 and 5 when the wheel is turned.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_BUTTON_PRESS_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[SCROLL_EVENT] =

    g_signal_new (I_("scroll-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::motion-notify-event:

   * @widget: the object which received the signal.

   * @event: the #GdkEventMotion which triggered this signal

   *

   * The ::motion-notify-event signal is emitted when the pointer moves 

   * over the widget's #GdkWindow.

   *

   * To receive this signal, the #GdkWindow associated to the widget 

   * needs to enable the #GDK_POINTER_MOTION_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[MOTION_NOTIFY_EVENT] =

    g_signal_new (I_("motion-notify-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::composited-changed:

   * @widget: the object on which the signal is emitted

   *

   * The ::composited-changed signal is emitted when the composited

   * status of @widget<!-- -->s screen changes. 

   * See gdk_screen_is_composited().

   */

  widget_signals[COMPOSITED_CHANGED] =

    g_signal_new (I_("composited-changed"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GtkWidgetClass, composited_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkWidget::keynav-failed:

   * @widget: the object which received the signal

   * @direction: the direction of movement

   *

   * Gets emitted if keyboard navigation fails. 

   * See gtk_widget_keynav_failed() for details.

   *

   * Returns: %TRUE if stopping keyboard navigation is fine, %FALSE

   *          if the emitting widget should try to handle the keyboard

   *          navigation attempt in its parent container(s).

   *

   * Since: 2.12

   **/

  widget_signals[KEYNAV_FAILED] =

    g_signal_new_class_handler (I_("keynav-failed"),

                                G_TYPE_FROM_CLASS (gobject_class),

                                G_SIGNAL_RUN_LAST,

                                G_CALLBACK (gtk_widget_real_keynav_failed),

                                _gtk_boolean_handled_accumulator, NULL,

                                _gtk_marshal_BOOLEAN__ENUM,

                                G_TYPE_BOOLEAN, 1,

                                GTK_TYPE_DIRECTION_TYPE);

  /**

   * GtkWidget::delete-event:

   * @widget: the object which received the signal

   * @event: the event which triggered this signal

   *

   * The ::delete-event signal is emitted if a user requests that

   * a toplevel window is closed. The default handler for this signal

   * destroys the window. Connecting gtk_widget_hide_on_delete() to

   * this signal will cause the window to be hidden instead, so that

   * it can later be shown again without reconstructing it.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[DELETE_EVENT] =

    g_signal_new (I_("delete-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::destroy-event:

   * @widget: the object which received the signal.

   * @event: the event which triggered this signal

   *

   * The ::destroy-event signal is emitted when a #GdkWindow is destroyed.

   * You rarely get this signal, because most widgets disconnect themselves 

   * from their window before they destroy it, so no widget owns the 

   * window at destroy time.

   * 

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask

   * automatically for all new windows.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[DESTROY_EVENT] =

    g_signal_new (I_("destroy-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::expose-event:

   * @widget: the object which received the signal.

   * @event: the #GdkEventExpose which triggered this signal

   *

   * The ::expose-event signal is emitted when an area of a previously

   * obscured #GdkWindow is made visible and needs to be redrawn.

   * #GTK_NO_WINDOW widgets will get a synthesized event from their parent 

   * widget.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_EXPOSURE_MASK mask.

   * 

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[EXPOSE_EVENT] =

    g_signal_new (I_("expose-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::key-press-event:

   * @widget: the object which received the signal

   * @event: the #GdkEventKey which triggered this signal

   *

   * The ::key-press-event signal is emitted when a key is pressed.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_KEY_PRESS_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[KEY_PRESS_EVENT] =

    g_signal_new (I_("key-press-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::key-release-event:

   * @widget: the object which received the signal

   * @event: the #GdkEventKey which triggered this signal

   *

   * The ::key-release-event signal is emitted when a key is pressed.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_KEY_RELEASE_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[KEY_RELEASE_EVENT] =

    g_signal_new (I_("key-release-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::enter-notify-event:

   * @widget: the object which received the signal

   * @event: the #GdkEventCrossing which triggered this signal

   *

   * The ::enter-notify-event will be emitted when the pointer enters

   * the @widget's window.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_ENTER_NOTIFY_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[ENTER_NOTIFY_EVENT] =

    g_signal_new (I_("enter-notify-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::leave-notify-event:

   * @widget: the object which received the signal

   * @event: the #GdkEventCrossing which triggered this signal

   *

   * The ::leave-notify-event will be emitted when the pointer leaves

   * the @widget's window.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_LEAVE_NOTIFY_MASK mask.

   *

   * This signal will be sent to the grab widget if there is one.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[LEAVE_NOTIFY_EVENT] =

    g_signal_new (I_("leave-notify-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::configure-event

   * @widget: the object which received the signal

   * @event: the #GdkEventConfigure which triggered this signal

   *

   * The ::configure-event signal will be emitted when the size, position or

   * stacking of the @widget's window has changed.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask

   * automatically for all new windows.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[CONFIGURE_EVENT] =

    g_signal_new (I_("configure-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::focus-in-event

   * @widget: the object which received the signal

   * @event: the #GdkEventFocus which triggered this signal

   *

   * The ::focus-in-event signal will be emitted when the keyboard focus

   * enters the @widget's window.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_FOCUS_CHANGE_MASK mask.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[FOCUS_IN_EVENT] =

    g_signal_new (I_("focus-in-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::focus-out-event

   * @widget: the object which received the signal

   * @event: the #GdkEventFocus which triggered this signal

   *

   * The ::focus-out-event signal will be emitted when the keyboard focus

   * leaves the @widget's window.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_FOCUS_CHANGE_MASK mask.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[FOCUS_OUT_EVENT] =

    g_signal_new (I_("focus-out-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::map-event

   * @widget: the object which received the signal

   * @event: the #GdkEventAny which triggered this signal

   *

   * The ::map-event signal will be emitted when the @widget's window is

   * mapped. A window is mapped when it becomes visible on the screen.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask

   * automatically for all new windows.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[MAP_EVENT] =

    g_signal_new (I_("map-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::unmap-event

   * @widget: the object which received the signal

   * @event: the #GdkEventAny which triggered this signal

   *

   * The ::unmap-event signal will be emitted when the @widget's window is

   * unmapped. A window is unmapped when it becomes invisible on the screen.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask

   * automatically for all new windows.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[UNMAP_EVENT] =

    g_signal_new (I_("unmap-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::property-notify-event

   * @widget: the object which received the signal

   * @event: the #GdkEventProperty which triggered this signal

   *

   * The ::property-notify-event signal will be emitted when a property on

   * the @widget's window has been changed or deleted.

   *

   * To receive this signal, the #GdkWindow associated to the widget needs

   * to enable the #GDK_PROPERTY_CHANGE_MASK mask.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[PROPERTY_NOTIFY_EVENT] =

    g_signal_new (I_("property-notify-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::selection-clear-event

   * @widget: the object which received the signal

   * @event: the #GdkEventSelection which triggered this signal

   *

   * The ::selection-clear-event signal will be emitted when the

   * the @widget's window has lost ownership of a selection.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[SELECTION_CLEAR_EVENT] =

    g_signal_new (I_("selection-clear-event"),

		  G_TYPE_FROM_CLASS (gobject_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 | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GtkWidget::selection-request-event

   * @widget: the object which received the signal

   * @event: the #GdkEventSelection which triggered this signal

   *

   * The ::selection-request-event signal will be emitted when

   * another client requests ownership of the selection owned by

   * the @widget's window.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the event. 

   *   %FALSE to propagate the event further.

   */

  widget_signals[SELECTION_REQUEST_EVENT] =

    g_signal_new (I_("selection-request-event"),