#include <locale.h>
#include "gtkcontainer.h"
#include "gtkiconfactory.h"
+#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkrc.h"
#include "gtkselection.h"
+#include "gtksettings.h"
#include "gtksignal.h"
#include "gtkwidget.h"
#include "gtkwindow.h"
#include "gtkprivate.h"
#include "gdk/gdk.h"
#include "gdk/gdkprivate.h" /* Used in gtk_reset_shapes_recurse to avoid copy */
+#include "gobject/gvaluecollector.h"
+#include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
#define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w)
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,
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;
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);
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,
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:
*
* 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;
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;
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;
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,
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),
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] =
widget_signals[REMOVE_ACCELERATOR] =
gtk_accel_group_create_remove (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator));
+ widget_signals[ACTIVATE_MNEMONIC] =
+ g_signal_newc ("mnemonic_activate",
+ GTK_CLASS_TYPE (object_class),
+ GTK_RUN_LAST,
+ GTK_SIGNAL_OFFSET (GtkWidgetClass, mnemonic_activate),
+ _gtk_boolean_handled_accumulator, NULL,
+ gtk_marshal_BOOLEAN__BOOLEAN,
+ GTK_TYPE_BOOL, 1,
+ GTK_TYPE_BOOL);
widget_signals[GRAB_FOCUS] =
gtk_signal_new ("grab_focus",
GTK_RUN_LAST | GTK_RUN_ACTION,
gtk_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);
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);
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] =
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] =
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,
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,
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;
}
/*****************************************
- * gtk_widget_get_arg:
+ * gtk_widget_get_property:
*
* arguments:
*
*****************************************/
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;
}
}
/* 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.
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);
}
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));
}
}
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);
}
}
*
* Return value: %TRUE
**/
-gint
+gboolean
gtk_widget_hide_on_delete (GtkWidget *widget)
{
g_return_val_if_fail (widget != NULL, FALSE);
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,
}
}
-/**
- * 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
*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)
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;
}
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)
{
return handled;
}
-static gint
+static gboolean
gtk_widget_real_key_release_event (GtkWidget *widget,
GdkEventKey *event)
{
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
*
* 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;
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;
}
}
-/**
- * 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
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
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
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");
}
/**
if (GTK_WIDGET_RC_STYLE (widget))
gtk_widget_set_rc_style (widget);
+
+ g_object_notify (G_OBJECT (widget), "name");
}
/**
*
* 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);
if (GTK_WIDGET_DRAWABLE (widget))
gtk_widget_queue_clear (widget);
+
+ g_object_notify (G_OBJECT (widget), "app_paintable");
}
}
gtk_widget_propagate_state (widget, &data);
if (GTK_WIDGET_DRAWABLE (widget))
gtk_widget_queue_clear (widget);
+
+ g_object_notify (G_OBJECT (widget), "sensitive");
}
/**
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");
}
/*****************************************
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);
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);
}
{
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);
}
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);
}
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);
}
* 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
{
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);
}
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);
}
/**
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
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);
}
}
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
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)
{
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);
}
/**
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;
* 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;
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);
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);
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
* 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,
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);
}
/**
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));
}
/**
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)
{
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");
}
/**
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)
{
}
*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))
gdk_window_set_events (widget->window,
gdk_window_get_events (widget->window) | events);
}
+
+ g_object_notify (G_OBJECT (widget), "events");
}
/**
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");
}
/**
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;
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);
}
/**
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;
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;
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,
}
g_list_free (toplevels);
-
}
}
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);
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);
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);
}
}
-/*****************************************
- * 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;
}
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;
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
len = 0;
do
{
- gchar *string;
- gchar *d, *s;
+ const gchar *string;
+ const gchar *s;
+ gchar *d;
guint l;
string = gtk_widget_get_name (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));
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);
+}
+
projects / ~andy / gtk / blobdiff