* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
- * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
#include <string.h>
#include <locale.h>
#include "gtkcontainer.h"
+#include "gtkiconfactory.h"
+#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkrc.h"
#include "gtkselection.h"
+#include "gtksettings.h"
#include "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,
- 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);
static void gtk_widget_real_unmap (GtkWidget *widget);
static void gtk_widget_real_realize (GtkWidget *widget);
static void gtk_widget_real_unrealize (GtkWidget *widget);
-static void gtk_widget_real_draw (GtkWidget *widget,
- GdkRectangle *area);
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,
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 GSList *colormap_stack = NULL;
-static GSList *style_stack = NULL;
-static guint composite_child_stack = 0;
+static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
-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 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 *rc_style_key = "gtk-rc-style";
-static guint rc_style_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 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 = gtk_widget_real_draw;
- 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_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
- gtk_marshal_NONE__NONE,
+ gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[HIDE] =
gtk_signal_new ("hide",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
- gtk_marshal_NONE__NONE,
+ gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[MAP] =
gtk_signal_new ("map",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
- gtk_marshal_NONE__NONE,
+ gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[UNMAP] =
gtk_signal_new ("unmap",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
- gtk_marshal_NONE__NONE,
+ gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[REALIZE] =
gtk_signal_new ("realize",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
- gtk_marshal_NONE__NONE,
+ gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[UNREALIZE] =
gtk_signal_new ("unrealize",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
- gtk_marshal_NONE__NONE,
- GTK_TYPE_NONE, 0);
- widget_signals[DRAW] =
- gtk_signal_new ("draw",
- GTK_RUN_FIRST,
- GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
- gtk_marshal_NONE__POINTER,
- GTK_TYPE_NONE, 1,
- GTK_TYPE_POINTER);
- 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_NONE__NONE,
- 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_NONE__NONE,
+ 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_NONE__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_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
- gtk_marshal_NONE__POINTER,
+ gtk_marshal_VOID__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
widget_signals[STATE_CHANGED] =
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
- gtk_marshal_NONE__UINT,
+ gtk_marshal_VOID__ENUM,
GTK_TYPE_NONE, 1,
GTK_TYPE_STATE_TYPE);
widget_signals[PARENT_SET] =
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
- gtk_marshal_NONE__OBJECT,
+ 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_NONE__POINTER,
+ gtk_marshal_VOID__OBJECT,
GTK_TYPE_NONE, 1,
GTK_TYPE_STYLE);
widget_signals[DIRECTION_CHANGED] =
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, direction_changed),
- gtk_marshal_NONE__UINT,
+ gtk_marshal_VOID__ENUM,
GTK_TYPE_NONE, 1,
GTK_TYPE_TEXT_DIRECTION);
widget_signals[ADD_ACCELERATOR] =
widget_signals[REMOVE_ACCELERATOR] =
gtk_accel_group_create_remove (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator));
+ widget_signals[ACTIVATE_MNEMONIC] =
+ g_signal_newc ("mnemonic_activate",
+ GTK_CLASS_TYPE (object_class),
+ GTK_RUN_LAST,
+ GTK_SIGNAL_OFFSET (GtkWidgetClass, mnemonic_activate),
+ _gtk_boolean_handled_accumulator, NULL,
+ gtk_marshal_BOOLEAN__BOOLEAN,
+ GTK_TYPE_BOOL, 1,
+ GTK_TYPE_BOOL);
widget_signals[GRAB_FOCUS] =
gtk_signal_new ("grab_focus",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, grab_focus),
- gtk_marshal_NONE__NONE,
+ 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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_BOOL__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_NONE__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_NONE__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_BOOL__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_BOOL__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_NONE__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_NONE__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_NONE__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_NONE__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_BOOL__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_BOOL__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_NONE__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_NONE__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_BOOL__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_BOOL__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_BOOL__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_NONE__STRING,
- 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_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
+ 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."),
+ FALSE,
+ 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;
}
}
gtk_widget_set_colormap (widget, colormap);
}
-/*****************************************
- * gtk_widget_new:
- *
- * arguments:
- *
- * results:
- *****************************************/
+/**
+ * gtk_widget_new:
+ * @type: type ID of the widget to create
+ * @first_property_name: name of first property to set
+ * @Varargs: value of first property, followed by more properties, NULL-terminated
+ *
+ * This is a convenience function for creating a widget and setting
+ * its properties in one go. For example you might write:
+ * gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign",
+ * 0.0, NULL) to create a left-aligned label. Equivalent to
+ * gtk_object_new(), but returns a widget so you don't have to
+ * cast the object yourself.
+ *
+ * Return value: a new #GtkWidget of type @widget_type
+ **/
GtkWidget*
-gtk_widget_new (GtkType widget_type,
- const gchar *first_arg_name,
+gtk_widget_new (GtkType type,
+ const gchar *first_property_name,
...)
{
- GtkObject *object;
+ GtkWidget *widget;
va_list var_args;
- GSList *arg_list = NULL;
- GSList *info_list = NULL;
- gchar *error;
-
- g_return_val_if_fail (gtk_type_is_a (widget_type, GTK_TYPE_WIDGET), NULL);
-
- object = gtk_type_new (widget_type);
-
- va_start (var_args, first_arg_name);
- error = gtk_object_args_collect (GTK_OBJECT_TYPE (object),
- &arg_list,
- &info_list,
- first_arg_name,
- var_args);
- va_end (var_args);
-
- if (error)
- {
- g_warning ("gtk_widget_new(): %s", error);
- g_free (error);
- }
- else
- {
- GSList *slist_arg;
- GSList *slist_info;
-
- slist_arg = arg_list;
- slist_info = info_list;
- while (slist_arg)
- {
- gtk_object_arg_set (object, slist_arg->data, slist_info->data);
- slist_arg = slist_arg->next;
- slist_info = slist_info->next;
- }
- gtk_args_collect_cleanup (arg_list, info_list);
- }
- if (!GTK_OBJECT_CONSTRUCTED (object))
- gtk_object_default_construct (object);
-
- return GTK_WIDGET (object);
-}
-
-/*****************************************
- * gtk_widget_newv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-GtkWidget*
-gtk_widget_newv (GtkType type,
- guint nargs,
- GtkArg *args)
-{
g_return_val_if_fail (gtk_type_is_a (type, GTK_TYPE_WIDGET), NULL);
- return GTK_WIDGET (gtk_object_newv (type, nargs, args));
-}
-
-/*****************************************
- * gtk_widget_get:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_get (GtkWidget *widget,
- GtkArg *arg)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (arg != NULL);
-
- gtk_object_getv (GTK_OBJECT (widget), 1, arg);
-}
-
-/*****************************************
- * gtk_widget_getv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_getv (GtkWidget *widget,
- guint nargs,
- GtkArg *args)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
+ va_start (var_args, first_property_name);
+ widget = g_object_new_valist (type, first_property_name, var_args);
+ va_end (var_args);
- gtk_object_getv (GTK_OBJECT (widget), nargs, args);
+ return widget;
}
-/*****************************************
+/**
* gtk_widget_set:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @first_property_name: name of first property to set
+ * @Varargs: value of first property, followed by more properties, NULL-terminated
+ *
+ * Like gtk_object_set() - there's no reason to use this instead of
+ * gtk_object_set().
+ **/
void
gtk_widget_set (GtkWidget *widget,
- const gchar *first_arg_name,
+ const gchar *first_property_name,
...)
{
- GtkObject *object;
va_list var_args;
- GSList *arg_list = NULL;
- GSList *info_list = NULL;
- gchar *error;
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- object = GTK_OBJECT (widget);
-
- va_start (var_args, first_arg_name);
- error = gtk_object_args_collect (GTK_OBJECT_TYPE (object),
- &arg_list,
- &info_list,
- first_arg_name,
- var_args);
+ va_start (var_args, first_property_name);
+ g_object_set_valist (G_OBJECT (widget), first_property_name, var_args);
va_end (var_args);
-
- if (error)
- {
- g_warning ("gtk_widget_set(): %s", error);
- g_free (error);
- }
- else
- {
- GSList *slist_arg;
- GSList *slist_info;
-
- slist_arg = arg_list;
- slist_info = info_list;
- while (slist_arg)
- {
- gtk_object_arg_set (object, slist_arg->data, slist_info->data);
- slist_arg = slist_arg->next;
- slist_info = slist_info->next;
- }
- gtk_args_collect_cleanup (arg_list, info_list);
- }
-}
-
-/*****************************************
- * gtk_widget_setv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_setv (GtkWidget *widget,
- guint nargs,
- GtkArg *args)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- gtk_object_setv (GTK_OBJECT (widget), nargs, args);
}
static inline void
widget->allocation.height);
}
+/**
+ * gtk_widget_unparent:
+ * @widget: a #GtkWidget
+ *
+ * This function is only for use in widget implementations.
+ * Should be called by implementations of the remove method
+ * on #GtkContainer, to dissociate a child from the container.
+ **/
void
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.
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);
}
-/*****************************************
+/**
* gtk_widget_destroy:
+ * @widget: a #GtkWidget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Destroys a widget. Equivalent to gtk_object_destroy(), except that
+ * you don't have to cast the widget to #GtkObject. When a widget is
+ * destroyed, it will break any references it holds to other objects.
+ * If the widget is inside a container, the widget will be removed
+ * from the container. If the widget is a toplevel (derived from
+ * #GtkWindow), it will be removed from the list of toplevels, and the
+ * reference GTK+ holds to it will be removed. Removing a
+ * widget from its container or the list of toplevels results in the
+ * widget being finalized, unless you've added additional references
+ * to the widget with gtk_object_ref().
+ *
+ * In most cases, only toplevel widgets (windows) require explicit
+ * destruction, because when you destroy a toplevel its children will
+ * be destroyed as well.
+ *
+ **/
void
gtk_widget_destroy (GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GTK_OBJECT_CONSTRUCTED (widget));
gtk_object_destroy ((GtkObject*) widget);
}
-/*****************************************
+/**
* gtk_widget_destroyed:
- * Utility function: sets widget_pointer
- * to NULL when widget is destroyed.
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @widget_pointer: address of a variable that contains @widget
+ *
+ * This function sets *@widget_pointer to NULL if @widget_pointer !=
+ * NULL. It's intended to be used as a callback connected to the
+ * "destroy" signal of a widget. You connect gtk_widget_destroyed()
+ * as a signal handler, and pass the address of your widget variable
+ * as user data. Then when the widget is destroyed, the variable will
+ * be set to NULL. Useful for example to avoid multiple copies
+ * of the same dialog.
+ *
+ **/
void
gtk_widget_destroyed (GtkWidget *widget,
GtkWidget **widget_pointer)
*widget_pointer = NULL;
}
-/*****************************************
+/**
* gtk_widget_show:
+ * @widget: a #GtkWidget
+ *
+ * Flags a widget to be displayed. Any widget that isn't shown will
+ * not appear on the screen. If you want to show all the widgets in a
+ * container, it's easier to call gtk_widget_show_all() on the
+ * container, instead of individually showing the widgets.
*
- * arguments:
+ * Remember that you have to show the containers containing a widget,
+ * in addition to the widget itself, before it will appear onscreen.
*
- * results:
- *****************************************/
-
+ * When a toplevel container is shown, it is immediately realized and
+ * mapped; other shown widgets are realized and mapped when their
+ * toplevel container is realized and mapped.
+ *
+ **/
void
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));
}
}
}
}
-/*************************************************************
- * gtk_widget_show_now:
- * Show a widget, and if it is an unmapped toplevel widget
- * wait for the map_event before returning
- *
- * Warning: This routine will call the main loop recursively.
- *
- * arguments:
- *
- * results:
- *************************************************************/
-
static void
gtk_widget_show_map_callback (GtkWidget *widget, GdkEvent *event, gint *flag)
{
gtk_signal_disconnect_by_data (GTK_OBJECT (widget), flag);
}
+/**
+ * gtk_widget_show_now:
+ * @widget: a #GtkWidget
+ *
+ * Shows a widget. If the widget is an unmapped toplevel widget
+ * (i.e. a #GtkWindow that has not yet been shown), enter the main
+ * loop and wait for the window to actually be mapped. Be careful;
+ * because the main loop is running, anything can happen during
+ * this function.
+ **/
void
gtk_widget_show_now (GtkWidget *widget)
{
gtk_widget_show (widget);
}
-/*****************************************
+/**
* gtk_widget_hide:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Reverses the effects of gtk_widget_show(), causing the widget to be
+ * hidden (invisible to the user).
+ **/
void
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);
}
}
}
}
-gint
+/**
+ * gtk_widget_hide_on_delete:
+ * @widget: a #GtkWidget
+ *
+ * Utility function; intended to be connected to the "delete_event"
+ * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+ * argument, then returns %TRUE. If connected to "delete_event",
+ * the result is that clicking the window manager close button for
+ * will hide but not destroy the window. By default, GTK+ destroys
+ * windows when "delete_event" is received.
+ *
+ * Return value: %TRUE
+ **/
+gboolean
gtk_widget_hide_on_delete (GtkWidget *widget)
{
g_return_val_if_fail (widget != NULL, FALSE);
return TRUE;
}
+/**
+ * gtk_widget_show_all:
+ * @widget: a #GtkWidget
+ *
+ * Recursively shows a widget, and any child widgets (if the widget is
+ * a container).
+ **/
void
gtk_widget_show_all (GtkWidget *widget)
{
class->show_all (widget);
}
+/**
+ * gtk_widget_hide_all:
+ * @widget: a #GtkWidget
+ *
+ * Recursively hides a widget and any child widgets.
+ **/
void
gtk_widget_hide_all (GtkWidget *widget)
{
class->hide_all (widget);
}
-/*****************************************
+/**
* gtk_widget_map:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * This function is only for use in widget implementations. Causes
+ * a widget to be mapped if it isn't already.
+ *
+ **/
void
gtk_widget_map (GtkWidget *widget)
{
}
}
-/*****************************************
+/**
* gtk_widget_unmap:
+ * @widget: a #GtkWidget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * This function is only for use in widget implementations. Causes
+ * a widget to be unmapped if it's currently mapped.
+ *
+ **/
void
gtk_widget_unmap (GtkWidget *widget)
{
}
}
-/*****************************************
+/**
* gtk_widget_realize:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Creates the GDK (windowing system) resources associated with a
+ * widget. For example, widget->window will be created when a widget
+ * is realized. Normally realization happens implicitly; if you show
+ * a widget and all its parent containers, then the widget will be
+ * realized and mapped automatically.
+ *
+ * Realizing a widget requires all
+ * the widget's parent widgets to be realized; calling
+ * gtk_widget_realize() realizes the widget's parents in addition to
+ * @widget itself. If a widget is not yet inside a toplevel window
+ * when you realize it, bad things will happen.
+ *
+ * This function is primarily used in widget implementations, and
+ * isn't very useful otherwise. Many times when you think you might
+ * need it, a better approach is to connect to a signal that will be
+ * called after the widget is realized automatically, such as
+ * "expose_event". Or simply gtk_signal_connect_after() to the
+ * "realize" signal.
+ *
+ **/
void
gtk_widget_realize (GtkWidget *widget)
{
if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
g_message ("gtk_widget_realize(%s)", gtk_type_name (GTK_WIDGET_TYPE (widget)));
*/
+
+ if (widget->parent == NULL &&
+ !GTK_WIDGET_TOPLEVEL (widget))
+ g_warning ("Calling gtk_widget_realize() on a widget that isn't "
+ "inside a toplevel window is not going to work very well. "
+ "Widgets must be inside a toplevel container before realizing them.");
if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
gtk_widget_realize (widget->parent);
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_unrealize:
+ * @widget: a #GtkWidget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * This function is only useful in widget implementations.
+ * Causes a widget to be unrealized (frees all GDK resources
+ * associated with the widget, such as widget->window).
+ *
+ **/
void
gtk_widget_unrealize (GtkWidget *widget)
{
* Draw queueing.
*****************************************/
+/**
+ * gtk_widget_queue_draw_area:
+ * @widget: a #GtkWidget
+ * @x: x coordinate of upper-left corner of rectangle to redraw
+ * @y: y coordinate of upper-left corner of rectangle to redraw
+ * @width: width of region to draw
+ * @height: height of region to draw
+ *
+ * Invalidates the rectangular area of @widget defined by @x, @y,
+ * @width and @height by calling gdk_window_invalidate_rect() on the
+ * widget's window and all its child windows. Once the main loop
+ * becomes idle (after the current batch of events has been processed,
+ * roughly), the window will receive expose events for the union of
+ * all regions that have been invalidated.
+ *
+ * Normally you would only use this function in widget
+ * implementations. You might also use it, or
+ * gdk_window_invalidate_rect() directly, to schedule a redraw of a
+ * #GtkDrawingArea or some portion thereof.
+ *
+ * Frequently you can just call gdk_window_invalidate_rect() or
+ * gdk_window_invalidate_region() instead of this function. Those
+ * functions will invalidate only a single window, instead of the
+ * widget and all its children.
+ *
+ * The advantage of adding to the invalidated region compared to
+ * simply drawing immediately is efficiency; using an invalid region
+ * ensures that you only have to redraw one time.
+ *
+ **/
void
gtk_widget_queue_draw_area (GtkWidget *widget,
gint x,
gtk_widget_queue_clear_area (widget, x, y, width, height);
}
+/**
+ * gtk_widget_queue_draw:
+ * @widget: a #GtkWidget
+ *
+ * Equivalent to calling gtk_widget_queue_draw_area() for the
+ * entire area of a widget.
+ *
+ **/
void
gtk_widget_queue_draw (GtkWidget *widget)
{
/* Invalidates the given area (allocation-relative-coordinates)
* in all of the widget's windows
*/
+/**
+ * gtk_widget_queue_clear_area:
+ * @widget: a #GtkWidget
+ * @x: x coordinate of upper-left corner of rectangle to redraw
+ * @y: y coordinate of upper-left corner of rectangle to redraw
+ * @width: width of region to draw
+ * @height: height of region to draw
+ *
+ * DEPRECATED. This function is no longer different from
+ * gtk_widget_queue_draw_area(), though it once was. Now it just calls
+ * gtk_widget_queue_draw_area(). Originally
+ * gtk_widget_queue_clear_area() would force a redraw of the
+ * background for GTK_NO_WINDOW widgets, and
+ * gtk_widget_queue_draw_area() would not. Now both functions ensure
+ * the background will be redrawn.
+ *
+ **/
void
gtk_widget_queue_clear_area (GtkWidget *widget,
gint x,
gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
}
+/**
+ * gtk_widget_queue_clear:
+ * @widget: a #GtkWidget
+ *
+ * DEPRECATED. Use gtk_widget_queue_draw() instead.
+ **/
void
gtk_widget_queue_clear (GtkWidget *widget)
{
}
}
+/**
+ * gtk_widget_queue_resize:
+ * @widget: a #GtkWidget
+ *
+ * This function is only for use in widget implementations.
+ * Flags a widget to have its size renegotiated; should
+ * be called when a widget for some reason has a new size request.
+ * For example, when you change the text in a #GtkLabel, #GtkLabel
+ * queues a resize to ensure there's enough space for the new text.
+ *
+ **/
void
gtk_widget_queue_resize (GtkWidget *widget)
{
if (widget->parent)
gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
- else if (GTK_WIDGET_TOPLEVEL (widget))
+ else if (GTK_WIDGET_TOPLEVEL (widget) && GTK_IS_CONTAINER (widget))
gtk_container_queue_resize (GTK_CONTAINER (widget));
}
-/*****************************************
+/**
* gtk_widget_draw:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @area: area to draw
+ *
+ * DEPRECATED. In GTK+ 1.2, this function would immediately render the
+ * region @area of a widget, by invoking the virtual draw method of a
+ * widget. In GTK+ 2.0, the draw method is gone, and instead
+ * gtk_widget_draw() simply invalidates the specified region of the
+ * widget, then updates the invalid region of the widget immediately.
+ * Usually you don't want to update the region immediately for
+ * performance reasons, so in general gtk_widget_queue_draw_area() is
+ * a better choice if you want to draw a region of a widget.
+ *
+ **/
void
gtk_widget_draw (GtkWidget *widget,
GdkRectangle *area)
{
- GdkRectangle temp_area;
-
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (GTK_WIDGET_DRAWABLE (widget))
{
- if (!area)
- {
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- temp_area.x = widget->allocation.x;
- temp_area.y = widget->allocation.y;
- }
- else
- {
- temp_area.x = 0;
- temp_area.y = 0;
- }
-
- temp_area.width = widget->allocation.width;
- temp_area.height = widget->allocation.height;
- area = &temp_area;
- }
-
- if (!GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_DOUBLE_BUFFERED (widget))
- {
- GdkRectangle tmp_area = *area;
- gint x, y;
-
- if (!GTK_WIDGET_TOPLEVEL (widget))
- {
- gdk_window_get_position (widget->window, &x, &y);
- tmp_area.x -= x - widget->allocation.x;
- tmp_area.y -= y - widget->allocation.y;
- }
-
- gdk_window_begin_paint_rect (widget->window, &tmp_area);
- }
-
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
+ if (area)
+ gtk_widget_queue_draw_area (widget,
+ area->x, area->y,
+ area->width, area->height);
+ else
+ gtk_widget_queue_draw (widget);
- if (!GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_DOUBLE_BUFFERED (widget))
- gdk_window_end_paint (widget->window);
+ gdk_window_process_updates (widget->window, TRUE);
}
}
-/*****************************************
- * gtk_widget_draw_focus:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @requisition: a #GtkRequisition to be filled in
+ *
+ * This function is only used when implementing a #GtkContainer subclass.
+ * Obtains the preferred size of a widget. The container uses this
+ * information to arrange its child widgets and decide what size allocations
+ * to give them with gtk_widget_size_allocate().
+ **/
void
gtk_widget_size_request (GtkWidget *widget,
GtkRequisition *requisition)
gtk_widget_unref (widget);
}
-/*****************************************
- * gtk_widget_get_requesition:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+/**
+ * gtk_widget_get_child_requisition:
+ * @widget: a #GtkWidget
+ * @requisition: a #GtkRequisition to be filled in
+ *
+ * This function is only for use in widget implementations. Obtains
+ * @widget->requisition, unless someone has forced a particular
+ * geometry on the widget (e.g. with gtk_widget_set_usize()), in which
+ * case it returns that geometry instead of the widget's requisition.
+ **/
void
gtk_widget_get_child_requisition (GtkWidget *widget,
GtkRequisition *requisition)
*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)
}
}
-/*****************************************
+/**
* gtk_widget_size_allocate:
+ * @widget: a #GtkWidget
+ * @allocation: position and size to be allocated to @widget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * This function is only used by #GtkContainer subclasses, to assign a size
+ * and position to their child widgets.
+ *
+ **/
void
gtk_widget_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
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;
}
-/*****************************************
- * gtk_widget_event:
- *
- * arguments:
- *
- * results:
- *****************************************/
+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);
-gint
+ 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
+ * @event: a #GdkEvent
+ *
+ * Rarely-used function. This function is used to emit
+ * the event signals on a widget (those signals should never
+ * be emitted without using this function to do so).
+ * If you want to synthesize an event though, don't use this function;
+ * instead, use gtk_main_do_event() so the event will behave as if
+ * it were in the event queue. Don't synthesize expose events; instead,
+ * use gdk_window_invalidate_rect() to invalidate a region of the
+ * window.
+ *
+ * Return value: return from the event signal emission (%TRUE if the event was handled)
+ **/
+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);
- gtk_widget_ref (widget);
- return_val = FALSE;
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
- &return_val);
- if (return_val || GTK_OBJECT_DESTROYED (widget))
- goto out;
-
- switch (event->type)
+ if (event->type == GDK_EXPOSE)
{
- case GDK_NOTHING:
- signal_num = -1;
- break;
+ 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;
+ gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
+ &return_val);
+ if (return_val || GTK_OBJECT_DESTROYED (widget))
+ goto out;
+
+ switch (event->type)
+ {
+ case GDK_NOTHING:
+ signal_num = -1;
+ break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
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;
return return_val;
}
-/*****************************************
+/**
* gtk_widget_activate:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget that's activatable
+ *
+ * For widgets that can be "activated" (buttons, menu items, etc.)
+ * this function activates them. Activation is what happens when you
+ * press Enter on a widget during key navigation; clicking a button,
+ * selecting a menu item, etc. If @widget isn't activatable,
+ * the function returns %FALSE.
+ *
+ * Return value: %TRUE if the widget was activatable
+ **/
gboolean
gtk_widget_activate (GtkWidget *widget)
{
return FALSE;
}
+/**
+ * gtk_widget_set_scroll_adjustments:
+ * @widget: a #GtkWidget
+ * @hadjustment: an adjustment for horizontal scrolling, or %NULL
+ * @vadjustment: an adjustment for vertical scrolling, or %NULL
+ *
+ * For widgets that support scrolling, sets the scroll adjustments and
+ * returns %TRUE. For widgets that don't support scrolling, does
+ * nothing and returns %FALSE. Widgets that don't support scrolling
+ * can be scrolled by placing them in a #GtkViewport, which does
+ * support scrolling.
+ *
+ * Return value: %TRUE if the widget supports scrolling
+ **/
gboolean
gtk_widget_set_scroll_adjustments (GtkWidget *widget,
GtkAdjustment *hadjustment,
(GdkWindow*) client_data, 0, 0);
}
-/*****************************************
+/**
* gtk_widget_reparent:
+ * @widget: a #GtkWidget
+ * @new_parent: a #GtkContainer to move the widget into
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Moves a widget from one #GtkContainer to another, handling reference
+ * count issues to avoid destroying the widget.
+ *
+ **/
void
gtk_widget_reparent (GtkWidget *widget,
GtkWidget *new_parent)
}
}
-/*****************************************
- * gtk_widget_popup:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-gint
+ * @widget: a #GtkWidget
+ * @area: a rectangle
+ * @intersection: rectangle to store intersection of @widget and @area
+ *
+ * Computes the intersection of a @widget's area and @area, storing
+ * the intersection in @intersection, and returns %TRUE if there was
+ * an intersection. @intersection may be %NULL if you're only
+ * interested in whether there was an intersection.
+ *
+ * Return value: %TRUE if there was an intersection
+ **/
+gboolean
gtk_widget_intersect (GtkWidget *widget,
GdkRectangle *area,
GdkRectangle *intersection)
return return_val;
}
-/*****************************************
- * gtk_widget_grab_focus:
- *
- * arguments:
- *
- * results:
- *****************************************/
+/**
+ * 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
+ *
+ * Causes @widget to have the keyboard focus for the #GtkWindow it's
+ * inside. @widget must be a focusable widget, such as a #GtkEntry;
+ * something like #GtkFrame won't work. (More precisely, it must have the
+ * #GTK_CAN_FOCUS flag set.)
+ *
+ **/
void
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
}
}
-/*****************************************
+/**
+ * gtk_widget_is_focus:
+ * @widget: a #GtkWidget
+ *
+ * Determines if the widget is the focus widget within its
+ * toplevel. (This does not mean that the HAS_FOCUS flag is
+ * necessarily set; HAS_FOCUS will only be set if the
+ * toplevel widget additionally has the global input focus.)
+ *
+ * Return value: %TRUE if the widget is the focus widget.
+ **/
+gboolean
+gtk_widget_is_focus (GtkWidget *widget)
+{
+ GtkWidget *toplevel;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ toplevel = gtk_widget_get_toplevel (widget);
+
+ if (GTK_IS_WINDOW (toplevel))
+ return widget == GTK_WINDOW (toplevel)->focus_widget;
+ else
+ return FALSE;
+}
+
+/**
* gtk_widget_grab_default:
+ * @widget: a #GtkWidget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Causes @widget to become the default widget. @widget must have the
+ * #GTK_CAN_DEFAULT flag set; typically you have to set this flag
+ * yourself by calling GTK_WIDGET_SET_FLAGS (@widget,
+ * GTK_CAN_DEFAULT). The default widget is activated when the user
+ * presses Enter in a window. Default widgets must be activatable,
+ * that is, gtk_widget_activate() should affect them.
+ *
+ **/
void
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");
}
-/*****************************************
+/**
* gtk_widget_set_name:
+ * @widget: a #GtkWidget
+ * @name: name for the widget
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Widgets can be named, which allows you to refer to them from a
+ * gtkrc file. You can apply a style to widgets with a particular name
+ * in the gtkrc file. See the documentation for gtkrc files (on the
+ * same page as the docs for #GtkRcStyle).
+ *
+ **/
void
gtk_widget_set_name (GtkWidget *widget,
const gchar *name)
if (GTK_WIDGET_RC_STYLE (widget))
gtk_widget_set_rc_style (widget);
+
+ g_object_notify (G_OBJECT (widget), "name");
}
-/*****************************************
+/**
* gtk_widget_get_name:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-gchar*
+ * @widget: a #GtkWidget
+ *
+ * Retrieves the name of a widget. The return value should not be
+ * freed. See gtk_widget_set_name() for the significance of widget
+ * names.
+ *
+ * Return value: name of the widget
+ **/
+G_CONST_RETURN gchar*
gtk_widget_get_name (GtkWidget *widget)
{
g_return_val_if_fail (widget != NULL, NULL);
return gtk_type_name (GTK_WIDGET_TYPE (widget));
}
-/*****************************************
+/**
* gtk_widget_set_state:
+ * @widget: a #GtkWidget
+ * @state: new state for @widget
*
- * arguments:
- * widget
- * state
- *
- * results:
- *****************************************/
-
+ * This function is for use in widget implementations. Sets the state
+ * of a widget (insensitive, prelighted, etc.) Usually you should set
+ * the state using wrapper functions such as gtk_widget_set_sensitive().
+ *
+ **/
void
gtk_widget_set_state (GtkWidget *widget,
GtkStateType state)
if (GTK_WIDGET_DRAWABLE (widget))
gtk_widget_queue_clear (widget);
+
+ g_object_notify (G_OBJECT (widget), "app_paintable");
}
}
+/**
+ * gtk_widget_set_double_buffered:
+ * @widget: a #GtkWidget
+ * @double_buffered: %TRUE to double-buffer a widget
+ *
+ * Widgets are double buffered by default; you can use this function
+ * to turn off the buffering. "Double buffered" simply means that
+ * gdk_window_begin_paint() and gdk_window_end_paint() are called
+ * automatically around expose events sent to the
+ * widget. gdk_window_begin_paint() diverts all drawing to a widget's
+ * window to an offscreen buffer, and gdk_window_end_paint() draws the
+ * buffer to the screen. The result is that users see the window
+ * update in one smooth step, and don't see individual graphics
+ * primitives being rendered.
+ *
+ * In very simple terms, double buffered widgets don't flicker,
+ * so you would only use this function to turn off double buffering
+ * if you had special needs and really knew what you were doing.
+ *
+ **/
void
gtk_widget_set_double_buffered (GtkWidget *widget,
gboolean double_buffered)
GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
}
-/*****************************************
+/**
* gtk_widget_set_sensitive:
+ * @widget: a @widget
+ * @sensitive: %TRUE to make the widget sensitive
*
- * arguments:
- * widget
- * boolean value for sensitivity
- *
- * results:
- *****************************************/
-
+ * Sets the sensitivity of a widget. A widget is sensitive if the user
+ * can interact with it. Insensitive widgets are "grayed out" and the
+ * user can't interact with them. Insensitive widgets are known as
+ * "inactive" in some other toolkits.
+ *
+ **/
void
gtk_widget_set_sensitive (GtkWidget *widget,
gboolean sensitive)
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_parent:
+ * @widget: a #GtkWidget
+ * @parent: parent container
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * This function is useful only when implementing subclasses of #GtkContainer.
+ * Sets the container as the parent of @widget, and takes care of
+ * some details such as updating the state and style of the child
+ * to reflect its new location. The opposite function is
+ * gtk_widget_unparent().
+ *
+ **/
void
gtk_widget_set_parent (GtkWidget *widget,
GtkWidget *parent)
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");
}
/*****************************************
* Widget styles
* see docs/styles.txt
*****************************************/
+
+/**
+ * gtk_widget_set_style:
+ * @widget: a #GtkWidget
+ * @style: a #GtkStyle
+ *
+ * Sets the #GtkStyle for a widget (widget->style). You probably don't
+ * want to use this function; it interacts badly with themes, because
+ * themes work by replacing the #GtkStyle. Instead, use
+ * gtk_widget_modify_style().
+ *
+ **/
void
gtk_widget_set_style (GtkWidget *widget,
GtkStyle *style)
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_widget_ensure_style:
+ * @widget: a #GtkWidget
+ *
+ * Ensures that @widget has a style (widget->style). Not a very useful
+ * function; most of the time, if you want the style, the widget is
+ * realized, and realized widgets are guaranteed to have a style
+ * already.
+ *
+ **/
void
gtk_widget_ensure_style (GtkWidget *widget)
{
gtk_widget_set_rc_style (widget);
}
+/**
+ * gtk_widget_set_rc_style:
+ * @widget: a #GtkWidget
+ *
+ *
+ **/
void
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);
}
{
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);
}
}
+/**
+ * gtk_widget_get_style:
+ * @widget: a #GtkWidget
+ *
+ * Simply an accessor function that returns widget->style.
+ *
+ * Return value: the widget's #GtkStyle
+ **/
GtkStyle*
gtk_widget_get_style (GtkWidget *widget)
{
return widget->style;
}
+/**
+ * gtk_widget_modify_style:
+ * @widget: a #GtkWidget
+ * @style: the #GtkRcStyle holding the style modifications
+ *
+ * Modify style values on the widget. Modifications made using this
+ * technique take precendence over style values set via an RC file,
+ * however, they will be overriden if a style is explicitely set on
+ * the widget using gtk_widget_set_style(). The #GtkRcStyle structure
+ * is designed so each field can either be set or unset, so it is
+ * possible, using this function, to modify some style values and
+ * leave the others unchanged.
+ *
+ * Note that modifications made with this function are not cumulative
+ * with previous calls to gtk_widget_modify_style() or with such
+ * functions as gtk_widget_modify_fg(). If you wish to retain
+ * previous values, you must first call gtk_widget_get_modifier_style(),
+ * make your modifications to the returned style, then call
+ * gtk_widget_modify_style() with that style. On the other hand,
+ * if you first call gtk_widget_modify_style(), subsequent calls
+ * to such functions gtk_widget_modify_fg() will be have a cumulative
+ * effect with the inital modifications.
+ **/
void
gtk_widget_modify_style (GtkWidget *widget,
GtkRcStyle *style)
{
GtkRcStyle *old_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);
+ g_return_if_fail (GTK_IS_RC_STYLE (style));
+
+ old_style = gtk_object_get_data_by_id (GTK_OBJECT (widget),
+ quark_rc_style);
if (style != old_style)
+ gtk_object_set_data_by_id_full (GTK_OBJECT (widget),
+ quark_rc_style,
+ gtk_rc_style_copy (style),
+ (GtkDestroyNotify)gtk_rc_style_unref);
+
+ if (GTK_WIDGET_RC_STYLE (widget))
+ gtk_widget_set_rc_style (widget);
+}
+
+/**
+ * gtk_widget_get_modifier_style:
+ * @widget: a #GtkWidget
+ *
+ * Return the current modifier style for the widget. (As set by
+ * gtk_widget_modify_style().) If no style has previously set, a new
+ * #GtkRcStyle will be created with all values unset, and set as the
+ * 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.
+ *
+ * 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
+ * around, you must add a refcount using gtk_rc_style_ref().
+ **/
+GtkRcStyle *
+gtk_widget_get_modifier_style (GtkWidget *widget)
+{
+ GtkRcStyle *rc_style;
+
+ rc_style = gtk_object_get_data_by_id (GTK_OBJECT (widget),
+ quark_rc_style);
+
+ if (!rc_style)
{
- gtk_rc_style_ref (style);
-
+ rc_style = gtk_rc_style_new();
gtk_object_set_data_by_id_full (GTK_OBJECT (widget),
- rc_style_key_id,
- style,
+ quark_rc_style,
+ rc_style,
(GtkDestroyNotify)gtk_rc_style_unref);
}
+ return rc_style;
+}
+
+static void
+gtk_widget_modify_color_component (GtkWidget *widget,
+ GtkRcFlags component,
+ GtkStateType state,
+ GdkColor *color)
+{
+ GtkRcStyle *rc_style = gtk_widget_get_modifier_style (widget);
+
+ switch (component)
+ {
+ case GTK_RC_FG:
+ rc_style->fg[state] = *color;
+ break;
+ case GTK_RC_BG:
+ rc_style->bg[state] = *color;
+ break;
+ case GTK_RC_TEXT:
+ rc_style->text[state] = *color;
+ break;
+ case GTK_RC_BASE:
+ rc_style->base[state] = *color;
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ rc_style->color_flags[state] |= component;
+
+ if (GTK_WIDGET_RC_STYLE (widget))
+ gtk_widget_set_rc_style (widget);
+}
+
+/**
+ * gtk_widget_modify_fg:
+ * @widget: a #GtkWidget
+ * @state: the state for which to set the foreground color.
+ * @color: the color to assign (does not need to be allocated)
+ *
+ * Set the foreground color for a widget in a particular state. All
+ * other style values are left untouched. See also
+ * gtk_widget_modify_style().
+ **/
+void
+gtk_widget_modify_fg (GtkWidget *widget,
+ GtkStateType state,
+ GdkColor *color)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (state >= GTK_STATE_NORMAL && state <= GTK_STATE_INSENSITIVE);
+ g_return_if_fail (color != NULL);
+
+ gtk_widget_modify_color_component (widget, GTK_RC_FG, state, color);
+}
+
+/**
+ * gtk_widget_modify_bg:
+ * @widget: a #GtkWidget
+ * @state: the state for which to set the foreground color.
+ * @color: the color to assign (does not need to be allocated)
+ *
+ * Set the background color for a widget in a particular state. All
+ * other style values are left untouched. See also
+ * gtk_widget_modify_style().
+ **/
+void
+gtk_widget_modify_bg (GtkWidget *widget,
+ GtkStateType state,
+ GdkColor *color)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (state >= GTK_STATE_NORMAL && state <= GTK_STATE_INSENSITIVE);
+ g_return_if_fail (color != NULL);
+
+ gtk_widget_modify_color_component (widget, GTK_RC_BG, state, color);
+}
+
+/**
+ * gtk_widget_modify_base:
+ * @widget: a #GtkWidget
+ * @state: the state for which to set the foreground color.
+ * @color: the color to assign (does not need to be allocated)
+ *
+ * Set the text color for a widget in a particular state. All other
+ * style values are left untouched. The text color is the foreground
+ * color used along with the base color (see gtk_widget_modify_base)
+ * for widgets such as #GtkEntry and #GtkTextView. See also
+ * gtk_widget_modify_style().
+ **/
+void
+gtk_widget_modify_text (GtkWidget *widget,
+ GtkStateType state,
+ GdkColor *color)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (state >= GTK_STATE_NORMAL && state <= GTK_STATE_INSENSITIVE);
+ g_return_if_fail (color != NULL);
+
+ gtk_widget_modify_color_component (widget, GTK_RC_TEXT, state, color);
+}
+
+/**
+ * gtk_widget_modify_base:
+ * @widget: a #GtkWidget
+ * @state: the state for which to set the foreground color.
+ * @color: the color to assign (does not need to be allocated)
+ *
+ * Set the text color for a widget in a particular state.
+ * All other style values are left untouched. The base color
+ * is the background color used along with the text color
+ * (see gtk_widget_modify_text) for widgets such as #GtkEntry
+ * and #GtkTextView. See also gtk_widget_modify_style().
+ **/
+void
+gtk_widget_modify_base (GtkWidget *widget,
+ GtkStateType state,
+ GdkColor *color)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (state >= GTK_STATE_NORMAL && state <= GTK_STATE_INSENSITIVE);
+ g_return_if_fail (color != NULL);
+
+ gtk_widget_modify_color_component (widget, GTK_RC_BASE, state, color);
+}
+
+/**
+ * gtk_widget_modify_font:
+ * @widget: a #GtkWidget
+ * @font_desc: the font description to use
+ *
+ * Set the font to use for a widget. All other style values are left
+ * untouched. See also gtk_widget_modify_style().
+ **/
+void
+gtk_widget_modify_font (GtkWidget *widget,
+ PangoFontDescription *font_desc)
+{
+ GtkRcStyle *rc_style;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (font_desc != NULL);
+
+ rc_style = gtk_widget_get_modifier_style (widget);
+
+ if (rc_style->font_desc)
+ 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);
}
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);
if (context)
- pango_context_set_font_description (context, widget->style->font_desc);
+ pango_context_set_font_description (context, style->font_desc);
}
if (widget->style != style)
}
}
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;
return layout;
}
+/**
+ * gtk_widget_render_icon:
+ * @widget: a #GtkWidget
+ * @stock_id: a stock ID
+ * @size: a stock size
+ * @detail: render detail to pass to theme engine
+ *
+ * A convenience function that uses the theme engine and RC file
+ * settings for @widget to look up @stock_id and render it to
+ * a pixbuf. @stock_id should be a stock icon ID such as
+ * #GTK_STOCK_OPEN or #GTK_STOCK_BUTTON_OK. @size should be a size
+ * such as #GTK_ICON_SIZE_MENU. @detail should be a string that
+ * 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
+ **/
+GdkPixbuf*
+gtk_widget_render_icon (GtkWidget *widget,
+ const gchar *stock_id,
+ GtkIconSize size,
+ const gchar *detail)
+{
+ GtkIconSet *icon_set;
+ GdkPixbuf *retval;
+
+ 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 > GTK_ICON_SIZE_INVALID, NULL);
+
+ gtk_widget_ensure_style (widget);
+
+ icon_set = gtk_style_lookup_icon_set (widget->style, stock_id);
+
+ if (icon_set == NULL)
+ return NULL;
+
+ retval = gtk_icon_set_render_icon (icon_set,
+ widget->style,
+ gtk_widget_get_direction (widget),
+ GTK_WIDGET_STATE (widget),
+ size,
+ widget,
+ detail);
+
+ return retval;
+}
+
/*************************************************************
* gtk_widget_set_parent_window:
* Set a non default parent window for 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; -1 to unset x; -2 to leave x unchanged
+ * @y: y position; -1 to unset y; -2 to leave y unchanged
+ *
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Sets the position of a widget. The funny "u" in the name comes from
+ * the "user position" hint specified by the X window system, and
+ * exists for legacy reasons. This function doesn't work if a widget
+ * is inside a container; it's only really useful on #GtkWindow.
+ *
+ * Don't use this function to center dialogs over the main application
+ * 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. 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,
gint x,
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);
}
-/*****************************************
+/**
* gtk_widget_set_usize:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @width: minimum width, or -1 to unset
+ * @height: minimum height, or -1 to unset
+ *
+ * Sets the minimum size of a widget; that is, the widget's size
+ * request will be @width by @height. You can use this function to
+ * force a widget to be either larger or smaller than it is. The
+ * strange "usize" name dates from the early days of GTK+, and derives
+ * from X Window System terminology. In many cases,
+ * gtk_window_set_default_size() is a better choice for toplevel
+ * windows than this function; setting the default size will still
+ * allow users to shrink the window. Setting the usize will force them
+ * to leave the window at least as large as the usize. When dealing
+ * with window sizes, gtk_window_set_geometry_hints() can be a useful
+ * function as well.
+ *
+ * Note the inherent danger of setting any fixed size - themes,
+ * translations into other languages, different fonts, and user action
+ * can all change the appropriate size for a given widget. So, it's
+ * basically impossible to hardcode a size that will always be
+ * correct.
+ *
+ **/
void
gtk_widget_set_usize (GtkWidget *widget,
gint width,
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));
}
-/*****************************************
+/**
* gtk_widget_set_events:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @events: event mask
+ *
+ * Sets the event mask (see #GdkEventMask) for a widget. The event
+ * mask determines which events a widget will receive. Keep in mind
+ * that different widgets have different default event masks, and by
+ * changing the event mask you may disrupt a widget's functionality,
+ * so be careful. This function must be called while a widget is
+ * unrealized. Consider gtk_widget_add_events() for widgets that are
+ * already realized, or if you want to preserve the existing event
+ * mask. This function can't be used with #GTK_NO_WINDOW widgets;
+ * to get events on those widgets, place them inside a #GtkEventBox
+ * and receive events on the event box.
+ *
+ **/
void
gtk_widget_set_events (GtkWidget *widget,
gint events)
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");
}
-/*****************************************
+/**
* gtk_widget_add_events:
+ * @widget: a #GtkWidget
+ * @events: an event mask, see #GdkEventMask
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Adds the events in the bitfield @events to the event mask for
+ * @widget. See gtk_widget_set_events() for details.
+ *
+ **/
void
gtk_widget_add_events (GtkWidget *widget,
gint 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");
}
-/*****************************************
+/**
* gtk_widget_set_extension_events:
+ * @widget: a #GtkWidget
+ * @mode: bitfield of extension events to receive
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Sets the extension events mask to @mode. See #GdkExtensionMode
+ * and gdk_input_set_extension_events().
+ *
+ **/
void
gtk_widget_set_extension_events (GtkWidget *widget,
GdkExtensionMode mode)
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");
}
-/*****************************************
+/**
* gtk_widget_get_toplevel:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * This function returns the topmost widget in the container hierarchy
+ * @widget is a part of. If @widget has no parent widgets, it will be
+ * returned as the topmost widget. No reference will be added to the
+ * returned widget; it should not be unreferenced.
+ *
+ * Note the difference in behavior vs. gtk_widget_get_ancestor();
+ * gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would return
+ * %NULL if @widget wasn't inside a toplevel window.
+ *
+ * Return value: the topmost ancestor of @widget, or @widget itself if there's no ancestor
+ **/
GtkWidget*
gtk_widget_get_toplevel (GtkWidget *widget)
{
widget = widget->parent;
return widget;
-}
-
-/*****************************************
- * gtk_widget_get_ancestor:
- *
- * arguments:
- *
- * results:
- *****************************************/
+}
+/**
+ * gtk_widget_get_ancestor:
+ * @widget: a #GtkWidget
+ * @widget_type: ancestor type
+ *
+ * Gets the first ancestor of @widget with type @widget_type. For example,
+ * gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the first #GtkBox that's
+ * an ancestor of @widget. No reference will be added to the returned widget;
+ * it should not be unreferenced.
+ *
+ * Return value: the ancestor widget, or %NULL if not found
+ **/
GtkWidget*
gtk_widget_get_ancestor (GtkWidget *widget,
GtkType widget_type)
return widget;
}
-/*****************************************
+/**
* gtk_widget_get_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Gets the colormap that will be used to render @widget. No reference will
+ * be added to the returned colormap; it should not be unreferenced.
+ *
+ * Return value: the colormap used by @widget
+ **/
GdkColormap*
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;
return gtk_widget_get_default_colormap ();
}
-/*****************************************
+/**
* gtk_widget_get_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Gets the visual that will be used to render @widget.
+ *
+ * Return value: the visual for @widget
+ **/
GdkVisual*
gtk_widget_get_visual (GtkWidget *widget)
{
return gdk_colormap_get_visual (gtk_widget_get_colormap (widget));
}
-/*****************************************
- * gtk_widget_set_colormap:
- * Set the colormap for the widget to the given
- * value. Widget must not have been previously
- * realized. This probably should only be used
- * from an init() function.
- * arguments:
- * widget:
- * colormap:
- * results:
- *****************************************/
+/**
+ * gtk_widget_set_colormap:
+ * @widget: a #GtkWidget
+ * @colormap: a colormap
+ *
+ * Set the colormap for the widget to the given value. Widget must not
+ * have been previously realized. This probably should only be used
+ * from an init() function (i.e. from the constructor for the widget).
+ *
+ **/
void
-gtk_widget_set_colormap (GtkWidget *widget, GdkColormap *colormap)
+gtk_widget_set_colormap (GtkWidget *widget,
+ GdkColormap *colormap)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
- g_return_if_fail (colormap != NULL);
+ g_return_if_fail (GDK_IS_COLORMAP (colormap));
- /* FIXME: reference count the colormap.
- */
+ g_object_ref (G_OBJECT (colormap));
- gtk_object_set_data (GTK_OBJECT (widget),
- colormap_key,
- colormap);
+ g_object_set_qdata_full (G_OBJECT (widget),
+ quark_colormap,
+ colormap,
+ (GtkDestroyNotify) g_object_unref);
}
-/*****************************************
+/**
* gtk_widget_get_events:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Returns the event mask for the widget (a bitfield containing flags
+ * from the #GdkEventMask enumeration). These are the events that the widget
+ * will receive.
+ *
+ * Return value: event mask for @widget
+ **/
gint
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;
return 0;
}
-/*****************************************
+/**
* gtk_widget_get_extension_events:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Retrieves the extension events the widget will receive; see
+ * gdk_input_set_extension_events().
+ *
+ * Return value: extension events for @widget
+ **/
GdkExtensionMode
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;
return 0;
}
-/*****************************************
+/**
* gtk_widget_get_pointer:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @x: return location for the X coordinate, or %NULL
+ * @y: return location for the Y coordinate, or %NULL
+ *
+ * Obtains the location of the mouse pointer in widget coordinates.
+ * Widget coordinates are a bit odd; for historical reasons, they are
+ * defined as widget->window coordinates for widgets that are not
+ * #GTK_NO_WINDOW widgets, and are relative to widget->allocation.x,
+ * widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
+ *
+ **/
void
gtk_widget_get_pointer (GtkWidget *widget,
gint *x,
}
}
-/*****************************************
+/**
* gtk_widget_is_ancestor:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-gint
+ * @widget: a #GtkWidget
+ * @ancestor: another #GtkWidget
+ *
+ * Determines whether @widget is somewhere inside @ancestor, possibly with
+ * intermediate containers.
+ *
+ * Return value: %TRUE if @ancestor contains @widget as a child, grandchild, great grandchild, etc.
+ **/
+gboolean
gtk_widget_is_ancestor (GtkWidget *widget,
GtkWidget *ancestor)
{
composite_child_stack--;
}
-/*****************************************
+/**
* gtk_widget_push_colormap:
+ * @cmap: a #GdkColormap
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Pushes @cmap onto a global stack of colormaps; the topmost
+ * colormap on the stack will be used to create all widgets.
+ * Remove @cmap with gtk_widget_pop_colormap(). There's little
+ * reason to use this function.
+ *
+ **/
void
gtk_widget_push_colormap (GdkColormap *cmap)
{
colormap_stack = g_slist_prepend (colormap_stack, cmap);
}
-/*****************************************
+/**
* gtk_widget_pop_colormap:
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Removes a colormap pushed with gtk_widget_push_colormap().
+ *
+ **/
void
gtk_widget_pop_colormap (void)
{
}
}
-/*****************************************
+/**
* gtk_widget_set_default_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @colormap: a #GdkColormap
+ *
+ * Sets the default colormap to use when creating widgets.
+ * gtk_widget_push_colormap() is a better function to use if
+ * you only want to affect a few widgets, rather than all widgets.
+ *
+ **/
void
gtk_widget_set_default_colormap (GdkColormap *colormap)
{
}
}
-/*****************************************
+/**
* gtk_widget_get_default_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ *
+ * Obtains the default colormap used to create widgets.
+ *
+ * Return value: default widget colormap
+ **/
GdkColormap*
gtk_widget_get_default_colormap (void)
{
if (!default_colormap)
- default_colormap = gdk_colormap_get_system ();
+ gtk_widget_set_default_colormap (gdk_colormap_get_system ());
return default_colormap;
}
-/*****************************************
+/**
* gtk_widget_get_default_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ *
+ * Obtains the visual of the default colormap. Not really useful;
+ * used to be useful before gdk_colormap_get_visual() existed.
+ *
+ * Return value: visual of the default colormap
+ **/
GdkVisual*
gtk_widget_get_default_visual (void)
{
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_UNSET_FLAGS (widget, GTK_REALIZED);
}
-static void
-gtk_widget_real_draw (GtkWidget *widget,
- GdkRectangle *area)
-{
- GdkEventExpose event;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (area != NULL);
-
- if (GTK_WIDGET_DRAWABLE (widget))
- {
- event.type = GDK_EXPOSE;
- event.send_event = TRUE;
- event.window = widget->window;
- event.area = *area;
- event.count = 0;
-
- gdk_window_ref (event.window);
- gtk_widget_event (widget, (GdkEvent*) &event);
- gdk_window_unref (event.window);
- }
-}
-
static void
gtk_widget_real_size_request (GtkWidget *widget,
GtkRequisition *requisition)
}
}
-/*****************************************
- * 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;
gtk_reset_shapes_recurse (widget, widget->window);
}
+/**
+ * gtk_widget_ref:
+ * @widget: a #GtkWidget
+ *
+ * Adds a reference to a widget. This function is exactly the same
+ * as calling g_object_ref(), and exists mostly for historical
+ * reasons. It can still be convenient to avoid casting a widget
+ * to a #GObject, it saves a small amount of typing.
+ *
+ * Return value: the widget that was referenced
+ **/
GtkWidget*
gtk_widget_ref (GtkWidget *widget)
{
return (GtkWidget*) g_object_ref ((GObject*) widget);
}
+/**
+ * gtk_widget_unref:
+ * @widget: a #GtkWidget
+ *
+ * Inverse of gtk_widget_ref(). Equivalent to g_object_unref().
+ *
+ **/
void
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, G_VALUE_NOCOPY_CONTENTS, &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
+ * @path_length: location to store length of the path
+ * @path: location to store allocated path string
+ * @path_reversed: location to store allocated reverse path string
+ *
+ * Obtains the full path to @widget. The path is simply the name of a
+ * widget and all its parents in the container hierarchy, separated by
+ * periods. The name of a widget comes from
+ * gtk_widget_get_name(). Paths are used to apply styles to a widget
+ * in gtkrc configuration files. Widget names are the type of the
+ * widget by default (e.g. "GtkButton") or can be set to an
+ * application-specific value with gtk_widget_set_name(). By setting
+ * the name of a widget, you allow users or theme authors to apply
+ * styles to that specific widget in their gtkrc
+ * file. @path_reversed_p fills in the path in reverse order,
+ * i.e. starting with @widget's name instead of starting with the name
+ * of @widget's outermost ancestor.
+ *
+ **/
void
gtk_widget_path (GtkWidget *widget,
guint *path_length_p,
len = 0;
do
{
- gchar *string;
- gchar *d, *s;
+ const gchar *string;
+ const gchar *s;
+ gchar *d;
guint l;
string = gtk_widget_get_name (widget);
}
}
+/**
+ * gtk_widget_class_path:
+ * @widget: a #GtkWidget
+ * @path_length: location to store the length of the class path
+ * @path: location to store the class path as an allocated string
+ * @path_reversed: location to store the reverse class path as an allocated string
+ *
+ * Same as gtk_widget_path(), but always uses the name of a widget's type,
+ * never uses a custom name set with gtk_widget_set_name().
+ *
+ **/
void
gtk_widget_class_path (GtkWidget *widget,
guint *path_length_p,
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