X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkwidget.c;h=e5a2738a810d35f4db902edf0d1d38181d6c4ff9;hb=c626cd4233c03dc5a1ec81a2b272e59bed285c85;hp=e9fee7463dd49c3b9f190452a1b717216d3a9eb0;hpb=2c5d938ff81480846539d9659dd92ca90cfb9e40;p=~andy%2Fgtk diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index e9fee7463..e5a2738a8 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -29,9 +29,11 @@ #include #include "gtkcontainer.h" #include "gtkiconfactory.h" +#include "gtkintl.h" #include "gtkmain.h" #include "gtkrc.h" #include "gtkselection.h" +#include "gtksettings.h" #include "gtksignal.h" #include "gtkwidget.h" #include "gtkwindow.h" @@ -39,6 +41,9 @@ #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" #define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w) @@ -52,16 +57,16 @@ enum { UNMAP, REALIZE, UNREALIZE, - DRAW_FOCUS, - DRAW_DEFAULT, SIZE_REQUEST, SIZE_ALLOCATE, STATE_CHANGED, PARENT_SET, + HIERARCHY_CHANGED, STYLE_SET, DIRECTION_CHANGED, ADD_ACCELERATOR, REMOVE_ACCELERATOR, + ACTIVATE_MNEMONIC, GRAB_FOCUS, EVENT, BUTTON_PRESS_EVENT, @@ -99,30 +104,31 @@ enum { CLIENT_EVENT, NO_EXPOSE_EVENT, VISIBILITY_NOTIFY_EVENT, - DEBUG_MSG, + WINDOW_STATE_EVENT, + POPUP_MENU, LAST_SIGNAL }; enum { - ARG_0, - ARG_NAME, - ARG_PARENT, - ARG_X, - ARG_Y, - ARG_WIDTH, - ARG_HEIGHT, - ARG_VISIBLE, - ARG_SENSITIVE, - ARG_APP_PAINTABLE, - ARG_CAN_FOCUS, - ARG_HAS_FOCUS, - ARG_CAN_DEFAULT, - ARG_HAS_DEFAULT, - ARG_RECEIVES_DEFAULT, - ARG_COMPOSITE_CHILD, - ARG_STYLE, - ARG_EVENTS, - ARG_EXTENSION_EVENTS + 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; @@ -137,12 +143,14 @@ struct _GtkStateData static void gtk_widget_class_init (GtkWidgetClass *klass); static void gtk_widget_init (GtkWidget *widget); -static void gtk_widget_set_arg (GtkObject *object, - GtkArg *arg, - guint arg_id); -static void gtk_widget_get_arg (GtkObject *object, - GtkArg *arg, - guint arg_id); +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); @@ -156,10 +164,15 @@ static void gtk_widget_real_size_request (GtkWidget *widget, GtkRequisition *requisition); static void gtk_widget_real_size_allocate (GtkWidget *widget, GtkAllocation *allocation); -static gint gtk_widget_real_key_press_event (GtkWidget *widget, - GdkEventKey *event); -static gint gtk_widget_real_key_release_event (GtkWidget *widget, - GdkEventKey *event); +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, @@ -179,41 +192,41 @@ static void gtk_widget_set_style_internal (GtkWidget *widget, 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 GtkWidgetAuxInfo* gtk_widget_aux_info_new (void); -static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info); - -static gpointer parent_class = NULL; -static guint widget_signals[LAST_SIGNAL] = { 0 }; - -static GMemChunk *aux_info_mem_chunk = NULL; +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 GdkColormap *default_colormap = NULL; -static GtkStyle *gtk_default_style = NULL; +static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info); -static GSList *colormap_stack = NULL; -static GSList *style_stack = NULL; -static guint composite_child_stack = 0; +static void gtk_widget_do_uposition (GtkWidget *widget); + +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 const gchar *aux_info_key = "gtk-aux-info"; -static guint aux_info_key_id = 0; -static const gchar *event_key = "gtk-event-mask"; -static guint event_key_id = 0; -static const gchar *extension_event_key = "gtk-extension-event-mode"; -static guint extension_event_key_id = 0; -static const gchar *parent_window_key = "gtk-parent-window"; -static guint parent_window_key_id = 0; -static const gchar *saved_default_style_key = "gtk-saved-default-style"; -static guint saved_default_style_key_id = 0; -static const gchar *shape_info_key = "gtk-shape-info"; -static const gchar *colormap_key = "gtk-colormap"; -static const gchar *pango_context_key = "gtk-pango-context"; -static guint pango_context_key_id = 0; +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 const gchar *rc_style_key = "gtk-rc-style"; -static guint rc_style_key_id = 0; - -static GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR; /***************************************** * gtk_widget_get_type: @@ -255,27 +268,20 @@ gtk_widget_get_type (void) * * results: *****************************************/ -#include "stdio.h" -static void -gtk_widget_debug_msg (GtkWidget *widget, - const gchar *string) -{ - fprintf (stderr, "Gtk-DEBUG: %s\n", string); -} - 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->set_arg = gtk_widget_set_arg; - object_class->get_arg = gtk_widget_get_arg; object_class->destroy = gtk_widget_real_destroy; klass->activate_signal = 0; @@ -288,15 +294,16 @@ gtk_widget_class_init (GtkWidgetClass *klass) klass->unmap = gtk_widget_real_unmap; klass->realize = gtk_widget_real_realize; klass->unrealize = gtk_widget_real_unrealize; - klass->draw_focus = NULL; 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->event = NULL; klass->button_press_event = NULL; @@ -310,10 +317,11 @@ gtk_widget_class_init (GtkWidgetClass *klass) klass->enter_notify_event = NULL; klass->leave_notify_event = NULL; klass->configure_event = NULL; - klass->focus_in_event = NULL; - klass->focus_out_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; @@ -331,27 +339,175 @@ gtk_widget_class_init (GtkWidgetClass *klass) klass->no_expose_event = NULL; - klass->debug_msg = gtk_widget_debug_msg; - - gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME); - gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT); - gtk_object_add_arg_type ("GtkWidget::x", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_X); - gtk_object_add_arg_type ("GtkWidget::y", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_Y); - gtk_object_add_arg_type ("GtkWidget::width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WIDTH); - gtk_object_add_arg_type ("GtkWidget::height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_HEIGHT); - gtk_object_add_arg_type ("GtkWidget::visible", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBLE); - gtk_object_add_arg_type ("GtkWidget::sensitive", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SENSITIVE); - gtk_object_add_arg_type ("GtkWidget::app_paintable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_APP_PAINTABLE); - gtk_object_add_arg_type ("GtkWidget::can_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_FOCUS); - gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_FOCUS); - gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_DEFAULT); - gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_DEFAULT); - gtk_object_add_arg_type ("GtkWidget::receives_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_RECEIVES_DEFAULT); - gtk_object_add_arg_type ("GtkWidget::composite_child", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_COMPOSITE_CHILD); - gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, GTK_ARG_READWRITE, ARG_STYLE); - gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EVENTS); - gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EXTENSION_EVENTS); - + 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"); + + 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, @@ -394,29 +550,16 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize), gtk_marshal_VOID__VOID, GTK_TYPE_NONE, 0); - widget_signals[DRAW_FOCUS] = - gtk_signal_new ("draw_focus", - GTK_RUN_FIRST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus), - gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); - widget_signals[DRAW_DEFAULT] = - gtk_signal_new ("draw_default", - GTK_RUN_FIRST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default), - gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); widget_signals[SIZE_REQUEST] = - gtk_signal_new ("size_request", - GTK_RUN_FIRST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request), - gtk_marshal_VOID__POINTER, - GTK_TYPE_NONE, 1, - GTK_TYPE_POINTER); - widget_signals[SIZE_ALLOCATE] = + 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), @@ -437,15 +580,22 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set), - gtk_marshal_VOID__POINTER, + 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__POINTER, + gtk_marshal_VOID__OBJECT, GTK_TYPE_NONE, 1, GTK_TYPE_STYLE); widget_signals[DIRECTION_CHANGED] = @@ -462,6 +612,15 @@ gtk_widget_class_init (GtkWidgetClass *klass) 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, @@ -470,179 +629,200 @@ gtk_widget_class_init (GtkWidgetClass *klass) gtk_marshal_VOID__VOID, GTK_TYPE_NONE, 0); widget_signals[EVENT] = - gtk_signal_new ("event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("button_press_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("button_release_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("scroll_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, scroll_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("motion_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("delete_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("destroy_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("expose_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("key_press_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("key_release_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("enter_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("leave_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("configure_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("focus_in_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("focus_out_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("map_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("unmap_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("property_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("selection_clear_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("selection_request_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("selection_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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__POINTER_UINT, + gtk_marshal_VOID__BOXED_UINT, GTK_TYPE_NONE, 2, GTK_TYPE_SELECTION_DATA, GTK_TYPE_UINT); @@ -651,33 +831,35 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_LAST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_get), - gtk_marshal_VOID__POINTER_UINT_UINT, + 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] = - gtk_signal_new ("proximity_in_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("proximity_out_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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__POINTER_UINT, + gtk_marshal_VOID__OBJECT_UINT, GTK_TYPE_NONE, 2, GDK_TYPE_DRAG_CONTEXT, GTK_TYPE_UINT); @@ -686,7 +868,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_LAST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin), - gtk_marshal_VOID__POINTER, + gtk_marshal_VOID__OBJECT, GTK_TYPE_NONE, 1, GDK_TYPE_DRAG_CONTEXT); widget_signals[DRAG_END] = @@ -694,7 +876,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_LAST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end), - gtk_marshal_VOID__POINTER, + gtk_marshal_VOID__OBJECT, GTK_TYPE_NONE, 1, GDK_TYPE_DRAG_CONTEXT); widget_signals[DRAG_DATA_DELETE] = @@ -702,37 +884,39 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_LAST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete), - gtk_marshal_VOID__POINTER, + gtk_marshal_VOID__OBJECT, GTK_TYPE_NONE, 1, GDK_TYPE_DRAG_CONTEXT); widget_signals[DRAG_MOTION] = - gtk_signal_new ("drag_motion", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_motion), - gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT, - GTK_TYPE_BOOL, 4, - GDK_TYPE_DRAG_CONTEXT, - GTK_TYPE_INT, - GTK_TYPE_INT, - GTK_TYPE_UINT); + 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] = - gtk_signal_new ("drag_drop", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_drop), - gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT, - GTK_TYPE_BOOL, 4, - GDK_TYPE_DRAG_CONTEXT, - GTK_TYPE_INT, - GTK_TYPE_INT, - GTK_TYPE_UINT); + 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__POINTER_POINTER_UINT_UINT, + gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT, GTK_TYPE_NONE, 4, GDK_TYPE_DRAG_CONTEXT, GTK_TYPE_SELECTION_DATA, @@ -743,7 +927,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_RUN_LAST, GTK_CLASS_TYPE (object_class), GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_received), - gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT, + gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT, GTK_TYPE_NONE, 6, GDK_TYPE_DRAG_CONTEXT, GTK_TYPE_INT, @@ -752,129 +936,173 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_TYPE_UINT, GTK_TYPE_UINT); widget_signals[VISIBILITY_NOTIFY_EVENT] = - gtk_signal_new ("visibility_notify_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, visibility_notify_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("client_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_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] = - gtk_signal_new ("no_expose_event", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event), - gtk_marshal_BOOLEAN__POINTER, - GTK_TYPE_BOOL, 1, - GTK_TYPE_GDK_EVENT); - widget_signals[DEBUG_MSG] = - gtk_signal_new ("debug_msg", + 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, debug_msg), - gtk_marshal_VOID__POINTER, - GTK_TYPE_NONE, 1, - GTK_TYPE_STRING); + 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_arg (GtkObject *object, - GtkArg *arg, - guint arg_id) +gtk_widget_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { GtkWidget *widget; + GtkWidgetAuxInfo *aux_info; widget = GTK_WIDGET (object); - switch (arg_id) + switch (prop_id) { guint32 saved_flags; - case ARG_NAME: - gtk_widget_set_name (widget, GTK_VALUE_STRING (*arg)); + case PROP_NAME: + gtk_widget_set_name (widget, g_value_get_string (value)); break; - case ARG_PARENT: - gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget); + case PROP_PARENT: + gtk_container_add (GTK_CONTAINER (g_value_get_object (value)), widget); break; - case ARG_X: - gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2); + 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 ARG_Y: - gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg)); + 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 ARG_WIDTH: - gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -2); + case PROP_WIDTH: + gtk_widget_set_usize (widget, g_value_get_int (value), -2); break; - case ARG_HEIGHT: - gtk_widget_set_usize (widget, -2, GTK_VALUE_INT (*arg)); + case PROP_HEIGHT: + gtk_widget_set_usize (widget, -2, g_value_get_int (value)); break; - case ARG_VISIBLE: - if (GTK_VALUE_BOOL(*arg)) + case PROP_VISIBLE: + if (g_value_get_boolean (value)) gtk_widget_show (widget); else gtk_widget_hide (widget); break; - case ARG_SENSITIVE: - gtk_widget_set_sensitive (widget, GTK_VALUE_BOOL (*arg)); + case PROP_SENSITIVE: + gtk_widget_set_sensitive (widget, g_value_get_boolean (value)); break; - case ARG_APP_PAINTABLE: - gtk_widget_set_app_paintable (widget, GTK_VALUE_BOOL (*arg)); + case PROP_APP_PAINTABLE: + gtk_widget_set_app_paintable (widget, g_value_get_boolean (value)); break; - case ARG_CAN_FOCUS: + case PROP_CAN_FOCUS: saved_flags = GTK_WIDGET_FLAGS (widget); - if (GTK_VALUE_BOOL (*arg)) + 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 ARG_HAS_FOCUS: - if (GTK_VALUE_BOOL (*arg)) + case PROP_HAS_FOCUS: + if (g_value_get_boolean (value)) gtk_widget_grab_focus (widget); break; - case ARG_CAN_DEFAULT: + case PROP_CAN_DEFAULT: saved_flags = GTK_WIDGET_FLAGS (widget); - if (GTK_VALUE_BOOL (*arg)) + 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 ARG_HAS_DEFAULT: - if (GTK_VALUE_BOOL (*arg)) + case PROP_HAS_DEFAULT: + if (g_value_get_boolean (value)) gtk_widget_grab_default (widget); break; - case ARG_RECEIVES_DEFAULT: - if (GTK_VALUE_BOOL (*arg)) + 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 ARG_COMPOSITE_CHILD: - if (GTK_VALUE_BOOL(*arg)) + 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; - case ARG_STYLE: - gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg)); + case PROP_STYLE: + gtk_widget_set_style (widget, g_value_get_object (value)); break; - case ARG_EVENTS: + case PROP_EVENTS: if (!GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_NO_WINDOW (widget)) - gtk_widget_set_events (widget, GTK_VALUE_FLAGS (*arg)); + gtk_widget_set_events (widget, g_value_get_flags (value)); break; - case ARG_EXTENSION_EVENTS: - gtk_widget_set_extension_events (widget, GTK_VALUE_FLAGS (*arg)); + case PROP_EXTENSION_EVENTS: + gtk_widget_set_extension_events (widget, g_value_get_enum (value)); break; default: break; @@ -882,7 +1110,7 @@ gtk_widget_set_arg (GtkObject *object, } /***************************************** - * gtk_widget_get_arg: + * gtk_widget_get_property: * * arguments: * @@ -890,103 +1118,104 @@ gtk_widget_set_arg (GtkObject *object, *****************************************/ static void -gtk_widget_get_arg (GtkObject *object, - GtkArg *arg, - guint arg_id) +gtk_widget_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { GtkWidget *widget; widget = GTK_WIDGET (object); - switch (arg_id) + switch (prop_id) { GtkWidgetAuxInfo *aux_info; gint *eventp; GdkExtensionMode *modep; - case ARG_NAME: + case PROP_NAME: if (widget->name) - GTK_VALUE_STRING (*arg) = g_strdup (widget->name); + g_value_set_string (value, widget->name); else - GTK_VALUE_STRING (*arg) = g_strdup (""); + g_value_set_string (value, ""); break; - case ARG_PARENT: - GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent; + case PROP_PARENT: + g_value_set_object (value, G_OBJECT (widget->parent)); break; - case ARG_X: - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); - if (!aux_info) - GTK_VALUE_INT (*arg) = -1; + case PROP_X: + aux_info =_gtk_widget_get_aux_info (widget, FALSE); + if (!aux_info || !aux_info->x_set) + g_value_set_int (value, -1); else - GTK_VALUE_INT (*arg) = aux_info->x; + g_value_set_int (value, aux_info->x); break; - case ARG_Y: - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); - if (!aux_info) - GTK_VALUE_INT (*arg) = -1; + case PROP_Y: + aux_info =_gtk_widget_get_aux_info (widget, FALSE); + if (!aux_info || !aux_info->y_set) + g_value_set_int (value, -1); else - GTK_VALUE_INT (*arg) = aux_info->y; + g_value_set_int (value, aux_info->y); break; - case ARG_WIDTH: - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); + case PROP_WIDTH: + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (!aux_info) - GTK_VALUE_INT (*arg) = -1; + g_value_set_int (value, -1); else - GTK_VALUE_INT (*arg) = aux_info->width; + g_value_set_int (value, aux_info->width); break; - case ARG_HEIGHT: - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); + case PROP_HEIGHT: + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (!aux_info) - GTK_VALUE_INT (*arg) = -1; + g_value_set_int (value, -1); else - GTK_VALUE_INT (*arg) = aux_info->height; + g_value_set_int (value, aux_info->height); break; - case ARG_VISIBLE: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_VISIBLE (widget) != FALSE); + case PROP_VISIBLE: + g_value_set_boolean (value, (GTK_WIDGET_VISIBLE (widget) != FALSE)); break; - case ARG_SENSITIVE: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_SENSITIVE (widget) != FALSE); + case PROP_SENSITIVE: + g_value_set_boolean (value, (GTK_WIDGET_SENSITIVE (widget) != FALSE)); break; - case ARG_APP_PAINTABLE: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_APP_PAINTABLE (widget) != FALSE); + case PROP_APP_PAINTABLE: + g_value_set_boolean (value, (GTK_WIDGET_APP_PAINTABLE (widget) != FALSE)); break; - case ARG_CAN_FOCUS: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_FOCUS (widget) != FALSE); + case PROP_CAN_FOCUS: + g_value_set_boolean (value, (GTK_WIDGET_CAN_FOCUS (widget) != FALSE)); break; - case ARG_HAS_FOCUS: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_FOCUS (widget) != FALSE); + case PROP_HAS_FOCUS: + g_value_set_boolean (value, (GTK_WIDGET_HAS_FOCUS (widget) != FALSE)); break; - case ARG_CAN_DEFAULT: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_DEFAULT (widget) != FALSE); + case PROP_CAN_DEFAULT: + g_value_set_boolean (value, (GTK_WIDGET_CAN_DEFAULT (widget) != FALSE)); break; - case ARG_HAS_DEFAULT: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE); + case PROP_HAS_DEFAULT: + g_value_set_boolean (value, (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE)); break; - case ARG_RECEIVES_DEFAULT: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_RECEIVES_DEFAULT (widget) != FALSE); + case PROP_RECEIVES_DEFAULT: + g_value_set_boolean (value, (GTK_WIDGET_RECEIVES_DEFAULT (widget) != FALSE)); break; - case ARG_COMPOSITE_CHILD: - GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE); + case PROP_COMPOSITE_CHILD: + g_value_set_boolean (value, (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE)); break; - case ARG_STYLE: - GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget); + case PROP_STYLE: + g_value_set_object (value, G_OBJECT (gtk_widget_get_style (widget))); break; - case ARG_EVENTS: - eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id); + case PROP_EVENTS: + eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask); if (!eventp) - GTK_VALUE_FLAGS (*arg) = 0; + g_value_set_int (value, 0); else - GTK_VALUE_FLAGS (*arg) = *eventp; + g_value_set_int (value, *eventp); break; - case ARG_EXTENSION_EVENTS: - modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id); + case PROP_EXTENSION_EVENTS: + modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode); if (!modep) - GTK_VALUE_FLAGS (*arg) = 0; + g_value_set_flags (value, 0); else - GTK_VALUE_FLAGS (*arg) = *modep; + g_value_set_flags (value, (GdkExtensionMode) *modep); break; default: - arg->type = GTK_TYPE_INVALID; + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } @@ -1124,6 +1353,8 @@ gtk_widget_unparent (GtkWidget *widget) /* keep this function in sync with gtk_menu_detach() */ + g_object_freeze_notify (G_OBJECT (widget)); + /* unset focused and default children properly, this code * should eventually move into some gtk_window_unparent_branch() or * similar function. @@ -1235,7 +1466,9 @@ gtk_widget_unparent (GtkWidget *widget) widget->parent = NULL; gtk_widget_set_parent_window (widget, NULL); gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], old_parent); - + gtk_widget_propagate_hierarchy_changed (widget, NULL); + g_object_notify (G_OBJECT (widget), "parent"); + g_object_thaw_notify (G_OBJECT (widget)); gtk_widget_unref (widget); } @@ -1319,9 +1552,12 @@ gtk_widget_show (GtkWidget *widget) if (!GTK_WIDGET_VISIBLE (widget)) { + g_object_ref (G_OBJECT (widget)); if (!GTK_WIDGET_TOPLEVEL (widget)) gtk_widget_queue_resize (widget); gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]); + g_object_notify (G_OBJECT (widget), "visible"); + g_object_unref (G_OBJECT (widget)); } } @@ -1403,6 +1639,7 @@ gtk_widget_hide (GtkWidget *widget) gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]); if (!GTK_WIDGET_TOPLEVEL (widget) && !GTK_OBJECT_DESTROYED (widget)) gtk_widget_queue_resize (widget); + g_object_notify (G_OBJECT (widget), "visible"); gtk_widget_unref (widget); } } @@ -1435,7 +1672,7 @@ gtk_widget_real_hide (GtkWidget *widget) * * Return value: %TRUE **/ -gint +gboolean gtk_widget_hide_on_delete (GtkWidget *widget) { g_return_val_if_fail (widget != NULL, FALSE); @@ -1591,8 +1828,7 @@ gtk_widget_realize (GtkWidget *widget) if (GTK_WIDGET_HAS_SHAPE_MASK (widget)) { - shape_info = gtk_object_get_data (GTK_OBJECT (widget), - shape_info_key); + shape_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_shape_info); gdk_window_shape_combine_mask (widget->window, shape_info->shape_mask, shape_info->offset_x, @@ -1870,45 +2106,6 @@ gtk_widget_draw (GtkWidget *widget, } } -/** - * gtk_widget_draw_focus: - * @widget: a #GtkWidget - * - * This function is only for use in widget implementations. Invokes the - * "draw_focus" virtual method/signal on @widget, causing the focus - * rectangle to be drawn or undrawn according to the focus state of - * the widget. Normally called from widget implementations in the - * "focus_in_event" and "focus_out_event" handlers. - * - **/ -void -gtk_widget_draw_focus (GtkWidget *widget) -{ - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_FOCUS]); -} - -/** - * gtk_widget_draw_default: - * @widget: a #GtkWidget - * - * This function is only for use in widget implementations. Invokes the - * "draw_default" virtual method/signal on a widget, causing it to - * draw the default rectangle (indicating that the widget is - * the default widget, i.e. the one that's activated by pressing - * the enter key, generally). - **/ -void -gtk_widget_draw_default (GtkWidget *widget) -{ - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_DEFAULT]); -} - /** * gtk_widget_size_request: * @widget: a #GtkWidget @@ -1963,7 +2160,7 @@ gtk_widget_get_child_requisition (GtkWidget *widget, *requisition = widget->requisition; - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (aux_info) { if (aux_info->width > 0) @@ -1994,13 +2191,13 @@ gtk_widget_size_allocate (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); real_allocation = *allocation; - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (aux_info) { - if (aux_info->x != -1) + if (aux_info->x_set) real_allocation.x = aux_info->x; - if (aux_info->y != -1) + if (aux_info->y_set) real_allocation.y = aux_info->y; } @@ -2216,7 +2413,43 @@ gtk_widget_accelerator_signal (GtkWidget *widget, return 0; } -static gint +gboolean +gtk_widget_mnemonic_activate (GtkWidget *widget, + gboolean group_cycling) +{ + gboolean handled; + + g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); + + group_cycling = group_cycling != FALSE; + if (!GTK_WIDGET_IS_SENSITIVE (widget)) + handled = TRUE; + else + gtk_signal_emit (GTK_OBJECT (widget), + widget_signals[ACTIVATE_MNEMONIC], + group_cycling, + &handled); + return handled; +} + +static gboolean +gtk_widget_real_mnemonic_activate (GtkWidget *widget, + gboolean group_cycling) +{ + if (!group_cycling && GTK_WIDGET_GET_CLASS (widget)->activate_signal) + gtk_widget_activate (widget); + else if (GTK_WIDGET_CAN_FOCUS (widget)) + gtk_widget_grab_focus (widget); + else + { + g_warning ("widget `%s' isn't suitable for mnemonic activation", + G_OBJECT_TYPE_NAME (widget)); + gdk_beep (); + } + return TRUE; +} + +static gboolean gtk_widget_real_key_press_event (GtkWidget *widget, GdkEventKey *event) { @@ -2234,7 +2467,7 @@ gtk_widget_real_key_press_event (GtkWidget *widget, return handled; } -static gint +static gboolean gtk_widget_real_key_release_event (GtkWidget *widget, GdkEventKey *event) { @@ -2252,6 +2485,26 @@ gtk_widget_real_key_release_event (GtkWidget *widget, return handled; } +static gboolean +gtk_widget_real_focus_in_event (GtkWidget *widget, + GdkEventFocus *event) +{ + GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS); + gtk_widget_queue_draw (widget); + + return FALSE; +} + +static gboolean +gtk_widget_real_focus_out_event (GtkWidget *widget, + GdkEventFocus *event) +{ + GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); + gtk_widget_queue_draw (widget); + + return FALSE; +} + /** * gtk_widget_event: * @widget: a #GtkWidget @@ -2268,15 +2521,64 @@ gtk_widget_real_key_release_event (GtkWidget *widget, * * Return value: return from the event signal emission (%TRUE if the event was handled) **/ -gint +gboolean gtk_widget_event (GtkWidget *widget, GdkEvent *event) { - gboolean return_val; - gint signal_num; + g_return_val_if_fail (widget != NULL, TRUE); + g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE); + if (event->type == GDK_EXPOSE) + { + g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get " + "the same effect, call gdk_window_invalidate_rect/region(), " + "followed by gdk_window_process_updates()."); + return TRUE; + } + + return gtk_widget_event_internal (widget, event); +} + + +/** + * gtk_widget_send_expose: + * @widget: a #GtkWidget + * @event: a expose #GdkEvent + * + * Very rarely-used function. This function is used to emit + * an expose event signals on a widget. This function is not + * normally used directly. The only time it is used is when + * propagating an expose event to a child NO_WINDOW widget, and + * that is normally done using gtk_container_propagate_expose. + * + * If you want to force an area of a window to be redrawn, + * use gdk_window_invalidate_rect() or gdk_window_invalidate_region(). + * To cause the redraw to be done immediately, follow that call + * with a call to gdk_window_procss_updates(). + * + * Return value: return from the event signal emission (%TRUE if the event was handled) + **/ +gint +gtk_widget_send_expose (GtkWidget *widget, + GdkEvent *event) +{ g_return_val_if_fail (widget != NULL, TRUE); g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE); + g_return_val_if_fail (event != NULL, TRUE); + g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE); + + if (event->type != GDK_EXPOSE) + return TRUE; + + return gtk_widget_event_internal (widget, event); +} + +static gint +gtk_widget_event_internal (GtkWidget *widget, + GdkEvent *event) +{ + gboolean return_val; + gint signal_num; gtk_widget_ref (widget); return_val = FALSE; @@ -2337,6 +2639,9 @@ gtk_widget_event (GtkWidget *widget, case GDK_UNMAP: signal_num = UNMAP_EVENT; break; + case GDK_WINDOW_STATE: + signal_num = WINDOW_STATE_EVENT; + break; case GDK_PROPERTY_NOTIFY: signal_num = PROPERTY_NOTIFY_EVENT; break; @@ -2531,34 +2836,6 @@ gtk_widget_reparent (GtkWidget *widget, } } -/** - * gtk_widget_popup: - * @widget: - * @x: - * @y: - * - * DEPRECATED. Completely useless function as far as we know. - * Probably does something bad. - * - **/ -void -gtk_widget_popup (GtkWidget *widget, - gint x, - gint y) -{ - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - if (!GTK_WIDGET_VISIBLE (widget)) - { - if (!GTK_WIDGET_REALIZED (widget)) - gtk_widget_realize (widget); - if (!GTK_WIDGET_NO_WINDOW (widget)) - gdk_window_move (widget->window, x, y); - gtk_widget_show (widget); - } -} - /** * gtk_widget_intersect: * @widget: a #GtkWidget @@ -2601,6 +2878,40 @@ gtk_widget_intersect (GtkWidget *widget, return return_val; } +/** + * gtk_widget_region_intersect: + * @widget: a #GtkWidget + * @region: a #GdkRegion, in the same coordinate system as + * widget->allocation. That is, relative to widget->window + * for NO_WINDOW widgets; relative to the parent window + * of widget->window for widgets with their own window. + * @returns: A newly allocated region holding the intersection of @widget + * and @region. The coordinates of the return value are + * relative to widget->window for NO_WINDOW widgets, and + * relative to the parent window of widget->window for + * widgets with their own window. + * + * Computes the intersection of a @widget's area and @region, returning + * the intersection. The result may be empty, use #gdk_region_empty to + * check. + **/ +GdkRegion * +gtk_widget_region_intersect (GtkWidget *widget, + GdkRegion *region) +{ + GdkRegion *dest; + + g_return_val_if_fail (widget != NULL, NULL); + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); + g_return_val_if_fail (region != NULL, NULL); + + dest = gdk_region_rectangle (&widget->allocation); + + gdk_region_intersect (dest, region); + + return dest; +} + /** * gtk_widget_grab_focus: * @widget: a #GtkWidget @@ -2617,7 +2928,10 @@ gtk_widget_grab_focus (GtkWidget *widget) g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); + g_object_ref (G_OBJECT (widget)); gtk_signal_emit (GTK_OBJECT (widget), widget_signals[GRAB_FOCUS]); + g_object_notify (G_OBJECT (widget), "has_focus"); + g_object_unref (G_OBJECT (widget)); } static void @@ -2758,9 +3072,12 @@ gtk_widget_grab_default (GtkWidget *widget) window = window->parent; if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type)) - gtk_window_set_default (GTK_WINDOW (window), widget); + { + gtk_window_set_default (GTK_WINDOW (window), widget); + g_object_notify (G_OBJECT (widget), "has_default"); + } else - g_warning("gtk_widget_grab_default() called on a widget not within a GtkWindow"); + g_warning (G_STRLOC ": widget not within a GtkWindow"); } /** @@ -2787,6 +3104,8 @@ gtk_widget_set_name (GtkWidget *widget, if (GTK_WIDGET_RC_STYLE (widget)) gtk_widget_set_rc_style (widget); + + g_object_notify (G_OBJECT (widget), "name"); } /** @@ -2799,7 +3118,7 @@ gtk_widget_set_name (GtkWidget *widget, * * Return value: name of the widget **/ -gchar* +G_CONST_RETURN gchar* gtk_widget_get_name (GtkWidget *widget) { g_return_val_if_fail (widget != NULL, NULL); @@ -2869,6 +3188,8 @@ gtk_widget_set_app_paintable (GtkWidget *widget, if (GTK_WIDGET_DRAWABLE (widget)) gtk_widget_queue_clear (widget); + + g_object_notify (G_OBJECT (widget), "app_paintable"); } } @@ -2951,6 +3272,8 @@ gtk_widget_set_sensitive (GtkWidget *widget, gtk_widget_propagate_state (widget, &data); if (GTK_WIDGET_DRAWABLE (widget)) gtk_widget_queue_clear (widget); + + g_object_notify (G_OBJECT (widget), "sensitive"); } /** @@ -2999,6 +3322,8 @@ gtk_widget_set_parent (GtkWidget *widget, gtk_widget_set_style_recurse (widget, NULL); gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], NULL); + gtk_widget_propagate_hierarchy_changed (widget, NULL); + g_object_notify (G_OBJECT (widget), "parent"); } /***************************************** @@ -3033,13 +3358,11 @@ gtk_widget_set_style (GtkWidget *widget, GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE); GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE); - default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); if (!default_style) { gtk_style_ref (widget->style); - if (!saved_default_style_key_id) - saved_default_style_key_id = g_quark_from_static_string (saved_default_style_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id, widget->style); + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_saved_default_style, widget->style); } gtk_widget_set_style_internal (widget, style, initial_emission); @@ -3087,16 +3410,14 @@ gtk_widget_set_rc_style (GtkWidget *widget) GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE); GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE); - saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); new_style = gtk_rc_get_style (widget); if (new_style) { if (!saved_style) { gtk_style_ref (widget->style); - if (!saved_default_style_key_id) - saved_default_style_key_id = g_quark_from_static_string (saved_default_style_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id, widget->style); + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_saved_default_style, widget->style); } gtk_widget_set_style_internal (widget, new_style, initial_emission); } @@ -3106,7 +3427,7 @@ gtk_widget_set_rc_style (GtkWidget *widget) { g_assert (initial_emission == FALSE); /* FIXME: remove this line */ - gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); gtk_widget_set_style_internal (widget, saved_style, initial_emission); gtk_style_unref (saved_style); } @@ -3128,10 +3449,10 @@ gtk_widget_restore_default_style (GtkWidget *widget) GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE); - default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); if (default_style) { - gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); gtk_widget_set_style_internal (widget, default_style, FALSE); gtk_style_unref (default_style); } @@ -3185,18 +3506,18 @@ gtk_widget_modify_style (GtkWidget *widget, g_return_if_fail (GTK_IS_RC_STYLE (style)); - if (!rc_style_key_id) - rc_style_key_id = g_quark_from_static_string (rc_style_key); - old_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), - rc_style_key_id); + quark_rc_style); - if (style != old_style) - gtk_object_set_data_by_id_full (GTK_OBJECT (widget), - rc_style_key_id, - gtk_rc_style_copy (style), - (GtkDestroyNotify)gtk_rc_style_unref); + gtk_object_set_data_by_id_full (GTK_OBJECT (widget), + quark_rc_style, + gtk_rc_style_copy (style), + (GtkDestroyNotify)gtk_rc_style_unref); + /* note that "style" may be invalid here if it was the old + * modifier style and the only reference was our own. + */ + if (GTK_WIDGET_RC_STYLE (widget)) gtk_widget_set_rc_style (widget); } @@ -3211,6 +3532,12 @@ gtk_widget_modify_style (GtkWidget *widget, * modifier style for the widget. If you make changes to this rc * style, you must call gtk_widget_modify_style(), passing in the * returned rc style, to make sure that your changes take effect. + * + * Caution: passing the style back to gtk_widget_modify_style() will + * normally end up destroying it, because gtk_widget_modify_style() copies + * the passed-in style and sets the copy as the new modifier style, + * thus dropping any reference to the old modifier style. Add a reference + * to the modifier style if you want to keep it alive. * * Return value: the modifier style for the widget. This rc style is * owned by the widget. If you want to keep a pointer to value this @@ -3221,17 +3548,14 @@ gtk_widget_get_modifier_style (GtkWidget *widget) { GtkRcStyle *rc_style; - if (!rc_style_key_id) - rc_style_key_id = g_quark_from_static_string (rc_style_key); - rc_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), - rc_style_key_id); + quark_rc_style); if (!rc_style) { rc_style = gtk_rc_style_new(); gtk_object_set_data_by_id_full (GTK_OBJECT (widget), - rc_style_key_id, + quark_rc_style, rc_style, (GtkDestroyNotify)gtk_rc_style_unref); } @@ -3267,8 +3591,7 @@ gtk_widget_modify_color_component (GtkWidget *widget, rc_style->color_flags[state] |= component; - if (GTK_WIDGET_RC_STYLE (widget)) - gtk_widget_set_rc_style (widget); + gtk_widget_modify_style (widget, rc_style); } /** @@ -3386,9 +3709,8 @@ gtk_widget_modify_font (GtkWidget *widget, pango_font_description_free (rc_style->font_desc); rc_style->font_desc = pango_font_description_copy (font_desc); - - if (GTK_WIDGET_RC_STYLE (widget)) - gtk_widget_set_rc_style (widget); + + gtk_widget_modify_style (widget, rc_style); } static void @@ -3416,6 +3738,9 @@ gtk_widget_set_style_internal (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (style != NULL); + g_object_ref (G_OBJECT (widget)); + g_object_freeze_notify (G_OBJECT (widget)); + if (widget->style != style || initial_emission) { PangoContext *context = gtk_widget_peek_pango_context (widget); @@ -3460,11 +3785,12 @@ gtk_widget_set_style_internal (GtkWidget *widget, } } else if (initial_emission) - { - gtk_signal_emit (GTK_OBJECT (widget), - widget_signals[STYLE_SET], - NULL); - } + gtk_signal_emit (GTK_OBJECT (widget), + widget_signals[STYLE_SET], + NULL); + g_object_notify (G_OBJECT (widget), "style"); + g_object_thaw_notify (G_OBJECT (widget)); + g_object_unref (G_OBJECT (widget)); } static void @@ -3480,6 +3806,34 @@ gtk_widget_set_style_recurse (GtkWidget *widget, NULL); } +static void +gtk_widget_propagate_hierarchy_changed (GtkWidget *widget, + gpointer client_data) +{ + gboolean new_anchored; + + new_anchored = widget->parent && GTK_WIDGET_ANCHORED (widget->parent); + + if (GTK_WIDGET_ANCHORED (widget) != new_anchored) + { + gtk_widget_ref (widget); + + if (new_anchored) + GTK_PRIVATE_SET_FLAG (widget, GTK_ANCHORED); + else + GTK_PRIVATE_UNSET_FLAG (widget, GTK_ANCHORED); + + g_signal_emit (GTK_OBJECT (widget), widget_signals[HIERARCHY_CHANGED], 0); + + if (GTK_IS_CONTAINER (widget)) + gtk_container_forall (GTK_CONTAINER (widget), + gtk_widget_propagate_hierarchy_changed, + NULL); + + gtk_widget_unref (widget); + } +} + void gtk_widget_reset_rc_styles (GtkWidget *widget) { @@ -3549,10 +3903,7 @@ gtk_widget_pop_style (void) static PangoContext * gtk_widget_peek_pango_context (GtkWidget *widget) { - if (!pango_context_key_id) - pango_context_key_id = g_quark_from_static_string (pango_context_key); - - return gtk_object_get_data_by_id (GTK_OBJECT (widget), pango_context_key_id); + return gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_pango_context); } /** @@ -3579,15 +3930,12 @@ gtk_widget_get_pango_context (GtkWidget *widget) g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); - if (!pango_context_key_id) - pango_context_key_id = g_quark_from_static_string (pango_context_key); - - context = gtk_object_get_data_by_id (GTK_OBJECT (widget), pango_context_key_id); + context = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_pango_context); if (!context) { context = gtk_widget_create_pango_context (GTK_WIDGET (widget)); - gtk_object_set_data_by_id_full (GTK_OBJECT (widget), pango_context_key_id, context, - (GDestroyNotify)g_object_unref); + gtk_object_set_data_by_id_full (GTK_OBJECT (widget), quark_pango_context, context, + (GDestroyNotify) g_object_unref); } return context; @@ -3675,12 +4023,12 @@ gtk_widget_create_pango_layout (GtkWidget *widget, * identifies the widget or code doing the rendering, so that * theme engines can special-case rendering for that widget or code. * - * Return value: a new pixbuf, or NULL if the stock ID wasn't known + * Return value: a new pixbuf, or %NULL if the stock ID wasn't known **/ GdkPixbuf* gtk_widget_render_icon (GtkWidget *widget, const gchar *stock_id, - const gchar *size, + GtkIconSize size, const gchar *detail) { GtkIconSet *icon_set; @@ -3688,7 +4036,7 @@ gtk_widget_render_icon (GtkWidget *widget, g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); g_return_val_if_fail (stock_id != NULL, NULL); - g_return_val_if_fail (size != NULL, NULL); + g_return_val_if_fail (size > GTK_ICON_SIZE_INVALID, NULL); gtk_widget_ensure_style (widget); @@ -3729,13 +4077,11 @@ gtk_widget_set_parent_window (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); old_parent_window = gtk_object_get_data_by_id (GTK_OBJECT (widget), - parent_window_key_id); + quark_parent_window); if (parent_window != old_parent_window) { - if (!parent_window_key_id) - parent_window_key_id = g_quark_from_static_string (parent_window_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), parent_window_key_id, + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_parent_window, parent_window); if (old_parent_window) gdk_window_unref (old_parent_window); @@ -3765,16 +4111,38 @@ gtk_widget_get_parent_window (GtkWidget *widget) g_return_val_if_fail (widget->parent != NULL, NULL); parent_window = gtk_object_get_data_by_id (GTK_OBJECT (widget), - parent_window_key_id); + quark_parent_window); return (parent_window != NULL) ? parent_window : widget->parent->window; } +/* Update the position from aux_info. Used from gtk_widget_set_uposition + * and gtk_widget_set_property(). + */ +static void +gtk_widget_do_uposition (GtkWidget *widget) +{ + GtkWidgetAuxInfo *aux_info =_gtk_widget_get_aux_info (widget, FALSE); + + if (GTK_IS_WINDOW (widget) && aux_info->x_set && aux_info->y_set) + _gtk_window_reposition (GTK_WINDOW (widget), aux_info->x, aux_info->y); + + if (GTK_WIDGET_VISIBLE (widget) && widget->parent) + gtk_widget_size_allocate (widget, &widget->allocation); + + g_object_freeze_notify (G_OBJECT (widget)); + if (aux_info->x_set) + g_object_notify (G_OBJECT (widget), "x"); + if (aux_info->y_set) + g_object_notify (G_OBJECT (widget), "y"); + g_object_thaw_notify (G_OBJECT (widget)); +} + /** * gtk_widget_set_uposition: * @widget: a #GtkWidget - * @x: x position - * @y: y position + * @x: x position; -1 to unset x; -2 to leave x unchanged + * @y: y position; -1 to unset y; -2 to leave y unchanged * * * Sets the position of a widget. The funny "u" in the name comes from @@ -3786,7 +4154,12 @@ gtk_widget_get_parent_window (GtkWidget *widget) * window; most window managers will do the centering on your behalf * if you call gtk_window_set_transient_for(), and it's really not * possible to get the centering to work correctly in all cases from - * application code. + * application code. But if you insist, use gtk_window_set_position() + * to set #GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering + * manually. + * + * Note that although x and y can be individually unset, the position + * is not honoured unless both x and y are set. **/ void gtk_widget_set_uposition (GtkWidget *widget, @@ -3798,27 +4171,31 @@ gtk_widget_set_uposition (GtkWidget *widget, g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); - if (!aux_info) + aux_info =_gtk_widget_get_aux_info (widget, TRUE); + + if (x > -2) { - if (!aux_info_key_id) - aux_info_key_id = g_quark_from_static_string (aux_info_key); - aux_info = gtk_widget_aux_info_new (); - gtk_object_set_data_by_id (GTK_OBJECT (widget), aux_info_key_id, aux_info); + if (x == -1) + aux_info->x_set = FALSE; + else + { + aux_info->x_set = TRUE; + aux_info->x = x; + } } - /* keep this in sync with gtk_window_compute_reposition() */ - - if (x > -2) - aux_info->x = x; if (y > -2) - aux_info->y = y; - - if (GTK_IS_WINDOW (widget) && (aux_info->x != -1) && (aux_info->y != -1)) - gtk_window_reposition (GTK_WINDOW (widget), x, y); - - if (GTK_WIDGET_VISIBLE (widget) && widget->parent) - gtk_widget_size_allocate (widget, &widget->allocation); + { + if (y == -1) + aux_info->y_set = FALSE; + else + { + aux_info->y_set = TRUE; + aux_info->y = y; + } + } + + gtk_widget_do_uposition (widget); } /** @@ -3856,22 +4233,25 @@ gtk_widget_set_usize (GtkWidget *widget, g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); - if (!aux_info) - { - if (!aux_info_key_id) - aux_info_key_id = g_quark_from_static_string (aux_info_key); - aux_info = gtk_widget_aux_info_new (); - gtk_object_set_data_by_id (GTK_OBJECT (widget), aux_info_key_id, aux_info); - } + g_object_freeze_notify (G_OBJECT (widget)); + + aux_info =_gtk_widget_get_aux_info (widget, TRUE); if (width > -2) - aux_info->width = width; + { + g_object_notify (G_OBJECT (widget), "width"); + aux_info->width = width; + } if (height > -2) - aux_info->height = height; + { + g_object_notify (G_OBJECT (widget), "height"); + aux_info->height = height; + } if (GTK_WIDGET_VISIBLE (widget)) gtk_widget_queue_resize (widget); + + g_object_thaw_notify (G_OBJECT (widget)); } /** @@ -3902,7 +4282,7 @@ gtk_widget_set_events (GtkWidget *widget, g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget)); g_return_if_fail (!GTK_WIDGET_REALIZED (widget)); - eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id); + eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask); if (events) { @@ -3910,15 +4290,15 @@ gtk_widget_set_events (GtkWidget *widget, eventp = g_new (gint, 1); *eventp = events; - if (!event_key_id) - event_key_id = g_quark_from_static_string (event_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), event_key_id, eventp); + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_event_mask, eventp); } else if (eventp) { g_free (eventp); - gtk_object_remove_data_by_id (GTK_OBJECT (widget), event_key_id); + gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_event_mask); } + + g_object_notify (G_OBJECT (widget), "events"); } /** @@ -3940,7 +4320,7 @@ gtk_widget_add_events (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget)); - eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id); + eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask); if (events) { @@ -3951,14 +4331,12 @@ gtk_widget_add_events (GtkWidget *widget, } *eventp |= events; - if (!event_key_id) - event_key_id = g_quark_from_static_string (event_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), event_key_id, eventp); + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_event_mask, eventp); } else if (eventp) { g_free (eventp); - gtk_object_remove_data_by_id (GTK_OBJECT (widget), event_key_id); + gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_event_mask); } if (GTK_WIDGET_REALIZED (widget)) @@ -3966,6 +4344,8 @@ gtk_widget_add_events (GtkWidget *widget, gdk_window_set_events (widget->window, gdk_window_get_events (widget->window) | events); } + + g_object_notify (G_OBJECT (widget), "events"); } /** @@ -3986,15 +4366,14 @@ gtk_widget_set_extension_events (GtkWidget *widget, g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); - modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id); + modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode); if (!modep) modep = g_new (GdkExtensionMode, 1); *modep = mode; - if (!extension_event_key_id) - extension_event_key_id = g_quark_from_static_string (extension_event_key); - gtk_object_set_data_by_id (GTK_OBJECT (widget), extension_event_key_id, modep); + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode, modep); + g_object_notify (G_OBJECT (widget), "extension_events"); } /** @@ -4077,7 +4456,7 @@ gtk_widget_get_colormap (GtkWidget *widget) return colormap; } - colormap = gtk_object_get_data (GTK_OBJECT (widget), colormap_key); + colormap = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_colormap); if (colormap) return colormap; @@ -4122,10 +4501,10 @@ gtk_widget_set_colormap (GtkWidget *widget, g_object_ref (G_OBJECT (colormap)); - gtk_object_set_data_full (GTK_OBJECT (widget), - colormap_key, - colormap, - (GtkDestroyNotify) g_object_unref); + g_object_set_qdata_full (G_OBJECT (widget), + quark_colormap, + colormap, + (GtkDestroyNotify) g_object_unref); } /** @@ -4146,7 +4525,7 @@ gtk_widget_get_events (GtkWidget *widget) g_return_val_if_fail (widget != NULL, 0); g_return_val_if_fail (GTK_IS_WIDGET (widget), 0); - events = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id); + events = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask); if (events) return *events; @@ -4170,7 +4549,7 @@ gtk_widget_get_extension_events (GtkWidget *widget) g_return_val_if_fail (widget != NULL, 0); g_return_val_if_fail (GTK_IS_WIDGET (widget), 0); - mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id); + mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode); if (mode) return *mode; @@ -4499,6 +4878,8 @@ gtk_widget_set_default_direction (GtkTextDirection dir) gtk_default_direction = dir; tmp_list = toplevels = gtk_window_list_toplevels (); + g_list_foreach (toplevels, (GFunc)g_object_ref, NULL); + while (tmp_list) { gtk_widget_set_default_direction_recurse (tmp_list->data, @@ -4508,7 +4889,6 @@ gtk_widget_set_default_direction (GtkTextDirection dir) } g_list_free (toplevels); - } } @@ -4552,11 +4932,11 @@ gtk_widget_real_destroy (GtkObject *object) gtk_grab_remove (widget); gtk_selection_remove_all (widget); - saved_style = gtk_object_get_data_by_id (object, saved_default_style_key_id); + saved_style = gtk_object_get_data_by_id (object, quark_saved_default_style); if (saved_style) { gtk_style_unref (saved_style); - gtk_object_remove_data_by_id (object, saved_default_style_key_id); + gtk_object_remove_data_by_id (object, quark_saved_default_style); } gtk_style_unref (widget->style); @@ -4578,11 +4958,11 @@ gtk_widget_finalize (GObject *object) gtk_grab_remove (widget); gtk_selection_remove_all (widget); - saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); if (saved_style) { gtk_style_unref (saved_style); - gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id); + gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); } gtk_style_unref (widget->style); @@ -4591,15 +4971,15 @@ gtk_widget_finalize (GObject *object) if (widget->name) g_free (widget->name); - aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id); + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (aux_info) gtk_widget_aux_info_destroy (aux_info); - events = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id); + events = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask); if (events) g_free (events); - mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id); + mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode); if (mode) g_free (mode); @@ -4827,30 +5207,39 @@ gtk_widget_propagate_state (GtkWidget *widget, } } -/***************************************** - * gtk_widget_aux_info_new: - * - * arguments: - * - * results: - *****************************************/ - -static GtkWidgetAuxInfo* -gtk_widget_aux_info_new (void) +/** + * _gtk_widget_get_aux_info: + * @widget: a #GtkWidget + * @create: if %TRUE, create the structure if it doesn't exist + * + * Get the #GtkWidgetAuxInfo structure for the widget. + * + * Return value: the #GtkAuxInfo structure for the widget, or + * %NULL if @create is %FALSE and one doesn't already exist. + **/ +GtkWidgetAuxInfo* +_gtk_widget_get_aux_info (GtkWidget *widget, + gboolean create) { GtkWidgetAuxInfo *aux_info; - if (!aux_info_mem_chunk) - aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk", - sizeof (GtkWidgetAuxInfo), - 1024, G_ALLOC_AND_FREE); - - aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk); - - aux_info->x = -1; - aux_info->y = -1; - aux_info->width = 0; - aux_info->height = 0; + aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info); + if (!aux_info && create) + { + if (!aux_info_mem_chunk) + aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk", + sizeof (GtkWidgetAuxInfo), + 1024, G_ALLOC_AND_FREE); + aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk); + + aux_info->width = -1; + aux_info->height = -1; + aux_info->x = 0; + aux_info->y = 0; + aux_info->x_set = FALSE; + aux_info->y_set = FALSE; + gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info); + } return aux_info; } @@ -4908,15 +5297,15 @@ gtk_widget_shape_combine_mask (GtkWidget *widget, if (widget->window) gdk_window_shape_combine_mask (widget->window, NULL, 0, 0); - gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key); + g_object_set_qdata (G_OBJECT (widget), quark_shape_info, NULL); } else { GTK_PRIVATE_SET_FLAG (widget, GTK_HAS_SHAPE_MASK); shape_info = g_new (GtkWidgetShapeInfo, 1); - gtk_object_set_data_full (GTK_OBJECT (widget), shape_info_key, shape_info, - (GDestroyNotify)gtk_widget_shape_info_destroy); + g_object_set_qdata_full (G_OBJECT (widget), quark_shape_info, shape_info, + (GDestroyNotify) gtk_widget_shape_info_destroy); shape_info->shape_mask = gdk_drawable_ref (shape_mask); shape_info->offset_x = offset_x; @@ -4992,6 +5381,157 @@ gtk_widget_unref (GtkWidget *widget) g_object_unref ((GObject*) widget); } + +/* style properties + */ + +void +gtk_widget_class_install_style_property_parser (GtkWidgetClass *class, + GParamSpec *pspec, + GtkRcPropertyParser parser) +{ + g_return_if_fail (GTK_IS_WIDGET_CLASS (class)); + g_return_if_fail (G_IS_PARAM_SPEC (pspec)); + g_return_if_fail (pspec->flags & G_PARAM_READABLE); + g_return_if_fail (!(pspec->flags & (G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT))); + + if (g_param_spec_pool_lookup (style_property_spec_pool, pspec->name, G_OBJECT_CLASS_TYPE (class), FALSE)) + { + g_warning (G_STRLOC ": class `%s' already contains a style property named `%s'", + G_OBJECT_CLASS_NAME (class), + pspec->name); + return; + } + + g_param_spec_ref (pspec); + g_param_spec_sink (pspec); + g_param_spec_set_qdata (pspec, quark_property_parser, parser); + g_param_spec_pool_insert (style_property_spec_pool, pspec, G_OBJECT_CLASS_TYPE (class)); +} + +void +gtk_widget_class_install_style_property (GtkWidgetClass *class, + GParamSpec *pspec) +{ + GtkRcPropertyParser parser; + + g_return_if_fail (GTK_IS_WIDGET_CLASS (class)); + g_return_if_fail (G_IS_PARAM_SPEC (pspec)); + + parser = _gtk_rc_property_parser_from_type (G_PARAM_SPEC_VALUE_TYPE (pspec)); + + gtk_widget_class_install_style_property_parser (class, pspec, parser); +} + +void +gtk_widget_style_get_property (GtkWidget *widget, + const gchar *property_name, + GValue *value) +{ + GParamSpec *pspec; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (property_name != NULL); + g_return_if_fail (G_IS_VALUE (value)); + + g_object_ref (widget); + pspec = g_param_spec_pool_lookup (style_property_spec_pool, + property_name, + G_OBJECT_TYPE (widget), + TRUE); + if (!pspec) + g_warning ("%s: widget class `%s' has no property named `%s'", + G_STRLOC, + G_OBJECT_TYPE_NAME (widget), + property_name); + else + { + const GValue *peek_value; + + peek_value = _gtk_style_peek_property_value (widget->style, + G_OBJECT_TYPE (widget), + pspec, + g_param_spec_get_qdata (pspec, quark_property_parser)); + + /* auto-conversion of the caller's value type + */ + if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec)) + g_value_copy (peek_value, value); + else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value))) + g_value_transform (peek_value, value); + else + g_warning ("can't retrive style property `%s' of type `%s' as value of type `%s'", + pspec->name, + g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), + G_VALUE_TYPE_NAME (value)); + } + g_object_unref (widget); +} + +void +gtk_widget_style_get_valist (GtkWidget *widget, + const gchar *first_property_name, + va_list var_args) +{ + const gchar *name; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + + g_object_ref (widget); + + name = first_property_name; + while (name) + { + const GValue *peek_value; + GParamSpec *pspec; + gchar *error; + + pspec = g_param_spec_pool_lookup (style_property_spec_pool, + name, + G_OBJECT_TYPE (widget), + TRUE); + if (!pspec) + { + g_warning ("%s: widget class `%s' has no property named `%s'", + G_STRLOC, + G_OBJECT_TYPE_NAME (widget), + name); + break; + } + /* style pspecs are always readable so we can spare that check here */ + + peek_value = _gtk_style_peek_property_value (widget->style, + G_OBJECT_TYPE (widget), + pspec, + g_param_spec_get_qdata (pspec, quark_property_parser)); + G_VALUE_LCOPY (peek_value, var_args, 0, &error); + if (error) + { + g_warning ("%s: %s", G_STRLOC, error); + g_free (error); + break; + } + + name = va_arg (var_args, gchar*); + } + + g_object_unref (widget); +} + +void +gtk_widget_style_get (GtkWidget *widget, + const gchar *first_property_name, + ...) +{ + va_list var_args; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + + va_start (var_args, first_property_name); + gtk_widget_style_get_valist (widget, first_property_name, var_args); + va_end (var_args); +} + /** * gtk_widget_path: * @widget: a #GtkWidget @@ -5029,8 +5569,9 @@ gtk_widget_path (GtkWidget *widget, len = 0; do { - gchar *string; - gchar *d, *s; + const gchar *string; + const gchar *s; + gchar *d; guint l; string = gtk_widget_get_name (widget); @@ -5093,8 +5634,9 @@ gtk_widget_class_path (GtkWidget *widget, len = 0; do { - gchar *string; - gchar *d, *s; + const gchar *string; + const gchar *s; + gchar *d; guint l; string = gtk_type_name (GTK_WIDGET_TYPE (widget)); @@ -5129,3 +5671,16 @@ gtk_widget_class_path (GtkWidget *widget, g_strreverse (*path_p); } } + +GtkRequisition * +gtk_requisition_copy (const GtkRequisition *requisition) +{ + return (GtkRequisition *)g_memdup (requisition, sizeof (GtkRequisition)); +} + +void +gtk_requisition_free (GtkRequisition *requisition) +{ + g_free (requisition); +} +