* 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-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
#include <stdarg.h>
#include <string.h>
+#include <locale.h>
#include "gtkcontainer.h"
+#include "gtkiconfactory.h"
+#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkrc.h"
#include "gtkselection.h"
+#include "gtksettings.h"
#include "gtksignal.h"
#include "gtkwidget.h"
#include "gtkwindow.h"
#include "gtkbindings.h"
#include "gtkprivate.h"
#include "gdk/gdk.h"
-#include "gdk/gdkx.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_CLASS (GTK_OBJECT (w)->klass)
+#define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w)
#define INIT_PATH_SIZE (512)
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,
BUTTON_RELEASE_EVENT,
+ SCROLL_EVENT,
MOTION_NOTIFY_EVENT,
DELETE_EVENT,
DESTROY_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_CAN_FOCUS,
- ARG_HAS_FOCUS,
- ARG_CAN_DEFAULT,
- ARG_HAS_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_shutdown (GtkObject *object);
+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 (GtkObject *object);
+static void gtk_widget_finalize (GObject *object);
static void gtk_widget_real_show (GtkWidget *widget);
static void gtk_widget_real_hide (GtkWidget *widget);
static void gtk_widget_real_map (GtkWidget *widget);
static void gtk_widget_real_unmap (GtkWidget *widget);
static void gtk_widget_real_realize (GtkWidget *widget);
static void gtk_widget_real_unrealize (GtkWidget *widget);
-static void gtk_widget_real_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,
+ GtkTextDirection previous_direction);
static void gtk_widget_real_grab_focus (GtkWidget *focus_widget);
-static void gtk_widget_redraw_queue_remove (GtkWidget *widget);
-
-
-static GdkColormap* gtk_widget_peek_colormap (void);
-static GdkVisual* gtk_widget_peek_visual (void);
-static GtkStyle* gtk_widget_peek_style (void);
+static GdkColormap* gtk_widget_peek_colormap (void);
+static GtkStyle* gtk_widget_peek_style (void);
+static PangoContext *gtk_widget_peek_pango_context (GtkWidget *widget);
static void gtk_widget_reparent_container_child (GtkWidget *widget,
gpointer client_data);
gboolean initial_emission);
static void gtk_widget_set_style_recurse (GtkWidget *widget,
gpointer client_data);
+static gint gtk_widget_event_internal (GtkWidget *widget,
+ GdkEvent *event);
+
+static void gtk_widget_propagate_hierarchy_changed (GtkWidget *widget,
+ gpointer client_data);
+static gboolean gtk_widget_real_mnemonic_activate (GtkWidget *widget,
+ gboolean group_cycling);
-static GtkWidgetAuxInfo* gtk_widget_aux_info_new (void);
static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
-static GtkObjectClass *parent_class = NULL;
-static guint widget_signals[LAST_SIGNAL] = { 0 };
-
-static GMemChunk *aux_info_mem_chunk = NULL;
-
-static GdkColormap *default_colormap = NULL;
-static GdkVisual *default_visual = NULL;
-static GtkStyle *gtk_default_style = NULL;
-
-static GSList *colormap_stack = NULL;
-static GSList *visual_stack = NULL;
-static GSList *style_stack = NULL;
-static guint composite_child_stack = 0;
-static GSList *gtk_widget_redraw_queue = NULL;
-
-static const gchar *aux_info_key = "gtk-aux-info";
-static guint aux_info_key_id = 0;
-static const gchar *event_key = "gtk-event-mask";
-static guint event_key_id = 0;
-static const gchar *extension_event_key = "gtk-extension-event-mode";
-static guint extension_event_key_id = 0;
-static const gchar *parent_window_key = "gtk-parent-window";
-static guint parent_window_key_id = 0;
-static const gchar *saved_default_style_key = "gtk-saved-default-style";
-static guint saved_default_style_key_id = 0;
-static const gchar *shape_info_key = "gtk-shape-info";
-static const gchar *colormap_key = "gtk-colormap";
-static const gchar *visual_key = "gtk-visual";
-
-static const gchar *rc_style_key = "gtk-rc-style";
-static guint rc_style_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 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;
+
/*****************************************
* gtk_widget_get_type:
(GtkClassInitFunc) NULL,
};
- widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
+ widget_type = gtk_type_unique (GTK_TYPE_OBJECT, &widget_info);
}
return widget_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)
{
- GtkObjectClass *object_class;
-
- object_class = (GtkObjectClass*) klass;
-
- parent_class = gtk_type_class (gtk_object_get_type ());
-
- 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::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::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);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
+ GtkBindingSet *binding_set;
+
+ parent_class = gtk_type_class (GTK_TYPE_OBJECT);
+
+ gobject_class->shutdown = gtk_widget_shutdown;
+ gobject_class->finalize = gtk_widget_finalize;
+ gobject_class->set_property = gtk_widget_set_property;
+ gobject_class->get_property = gtk_widget_get_property;
+
+ object_class->destroy = gtk_widget_real_destroy;
+ klass->activate_signal = 0;
+ klass->set_scroll_adjustments_signal = 0;
+ klass->show = gtk_widget_real_show;
+ klass->show_all = gtk_widget_show;
+ klass->hide = gtk_widget_real_hide;
+ klass->hide_all = gtk_widget_hide;
+ klass->map = gtk_widget_real_map;
+ klass->unmap = gtk_widget_real_unmap;
+ klass->realize = gtk_widget_real_realize;
+ klass->unrealize = gtk_widget_real_unrealize;
+ klass->size_request = gtk_widget_real_size_request;
+ klass->size_allocate = gtk_widget_real_size_allocate;
+ klass->state_changed = NULL;
+ klass->parent_set = NULL;
+ klass->hierarchy_changed = NULL;
+ klass->style_set = gtk_widget_style_set;
+ klass->direction_changed = gtk_widget_direction_changed;
+ klass->add_accelerator = (void*) gtk_accel_group_handle_add;
+ klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
+ klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
+ klass->grab_focus = gtk_widget_real_grab_focus;
+ klass->event = NULL;
+ klass->button_press_event = NULL;
+ klass->button_release_event = NULL;
+ klass->motion_notify_event = NULL;
+ klass->delete_event = NULL;
+ klass->destroy_event = NULL;
+ klass->expose_event = NULL;
+ klass->key_press_event = gtk_widget_real_key_press_event;
+ klass->key_release_event = gtk_widget_real_key_release_event;
+ klass->enter_notify_event = NULL;
+ klass->leave_notify_event = NULL;
+ klass->configure_event = NULL;
+ klass->focus_in_event = gtk_widget_real_focus_in_event;
+ klass->focus_out_event = gtk_widget_real_focus_out_event;
+ klass->map_event = NULL;
+ klass->unmap_event = NULL;
+ klass->window_state_event = NULL;
+ klass->property_notify_event = gtk_selection_property_notify;
+ klass->selection_clear_event = gtk_selection_clear;
+ klass->selection_request_event = gtk_selection_request;
+ klass->selection_notify_event = gtk_selection_notify;
+ klass->selection_received = NULL;
+ klass->proximity_in_event = NULL;
+ klass->proximity_out_event = NULL;
+ klass->drag_begin = NULL;
+ klass->drag_end = NULL;
+ klass->drag_data_delete = NULL;
+ klass->drag_leave = NULL;
+ klass->drag_motion = NULL;
+ klass->drag_drop = NULL;
+ klass->drag_data_received = NULL;
+
+ klass->no_expose_event = NULL;
+
+ quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");
+ quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
+ quark_event_mask = g_quark_from_static_string ("gtk-event-mask");
+ quark_extension_event_mode = g_quark_from_static_string ("gtk-extension-event-mode");
+ quark_parent_window = g_quark_from_static_string ("gtk-parent-window");
+ quark_saved_default_style = g_quark_from_static_string ("gtk-saved-default-style");
+ quark_shape_info = g_quark_from_static_string ("gtk-shape-info");
+ quark_colormap = g_quark_from_static_string ("gtk-colormap");
+ quark_pango_context = g_quark_from_static_string ("gtk-pango-context");
+ quark_rc_style = g_quark_from_static_string ("gtk-rc-style");
+
+ 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,
- object_class->type,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
+ 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_signal_new ("state_changed",
GTK_RUN_FIRST,
- object_class->type,
+ 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_signal_new ("parent_set",
GTK_RUN_FIRST,
- object_class->type,
+ 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,
- object_class->type,
+ 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_signal_new ("direction_changed",
+ GTK_RUN_FIRST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkWidgetClass, direction_changed),
+ gtk_marshal_VOID__ENUM,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_TEXT_DIRECTION);
widget_signals[ADD_ACCELERATOR] =
- gtk_accel_group_create_add (object_class->type, GTK_RUN_LAST,
+ gtk_accel_group_create_add (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
widget_signals[REMOVE_ACCELERATOR] =
- gtk_accel_group_create_remove (object_class->type, GTK_RUN_LAST,
+ 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,
- object_class->type,
+ 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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] =
+ 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
+ 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);
widget_signals[SELECTION_GET] =
gtk_signal_new ("selection_get",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_get),
- gtk_marshal_NONE__POINTER_UINT_UINT,
- GTK_TYPE_NONE, 2,
+ 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
+ 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,
- GTK_TYPE_GDK_DRAG_CONTEXT,
+ GDK_TYPE_DRAG_CONTEXT,
GTK_TYPE_UINT);
widget_signals[DRAG_BEGIN] =
gtk_signal_new ("drag_begin",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin),
- gtk_marshal_NONE__POINTER,
+ gtk_marshal_VOID__OBJECT,
GTK_TYPE_NONE, 1,
- GTK_TYPE_GDK_DRAG_CONTEXT);
+ GDK_TYPE_DRAG_CONTEXT);
widget_signals[DRAG_END] =
gtk_signal_new ("drag_end",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end),
- gtk_marshal_NONE__POINTER,
+ gtk_marshal_VOID__OBJECT,
GTK_TYPE_NONE, 1,
- GTK_TYPE_GDK_DRAG_CONTEXT);
+ GDK_TYPE_DRAG_CONTEXT);
widget_signals[DRAG_DATA_DELETE] =
gtk_signal_new ("drag_data_delete",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete),
- gtk_marshal_NONE__POINTER,
+ gtk_marshal_VOID__OBJECT,
GTK_TYPE_NONE, 1,
- GTK_TYPE_GDK_DRAG_CONTEXT);
+ GDK_TYPE_DRAG_CONTEXT);
widget_signals[DRAG_MOTION] =
- gtk_signal_new ("drag_motion",
- GTK_RUN_LAST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_motion),
- gtk_marshal_BOOL__POINTER_INT_INT_UINT,
- GTK_TYPE_BOOL, 4,
- GTK_TYPE_GDK_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,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_drop),
- gtk_marshal_BOOL__POINTER_INT_INT_UINT,
- GTK_TYPE_BOOL, 4,
- GTK_TYPE_GDK_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,
- object_class->type,
+ 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,
- GTK_TYPE_GDK_DRAG_CONTEXT,
+ GDK_TYPE_DRAG_CONTEXT,
GTK_TYPE_SELECTION_DATA,
GTK_TYPE_UINT,
GTK_TYPE_UINT);
widget_signals[DRAG_DATA_RECEIVED] =
gtk_signal_new ("drag_data_received",
GTK_RUN_LAST,
- object_class->type,
+ 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,
- GTK_TYPE_GDK_DRAG_CONTEXT,
+ GDK_TYPE_DRAG_CONTEXT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_SELECTION_DATA,
GTK_TYPE_UINT,
GTK_TYPE_UINT);
widget_signals[VISIBILITY_NOTIFY_EVENT] =
- gtk_signal_new ("visibility_notify_event",
- GTK_RUN_LAST,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- 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,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkWidgetClass, debug_msg),
- gtk_marshal_NONE__STRING,
- GTK_TYPE_NONE, 1,
- GTK_TYPE_STRING);
-
- gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
-
- object_class->set_arg = gtk_widget_set_arg;
- object_class->get_arg = gtk_widget_get_arg;
- object_class->shutdown = gtk_widget_shutdown;
- object_class->destroy = gtk_widget_real_destroy;
- object_class->finalize = gtk_widget_finalize;
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkWidgetClass, popup_menu),
+ gtk_marshal_NONE__NONE,
+ GTK_TYPE_NONE, 0);
- klass->activate_signal = 0;
- klass->set_scroll_adjustments_signal = 0;
- klass->show = gtk_widget_real_show;
- klass->show_all = gtk_widget_show;
- klass->hide = gtk_widget_real_hide;
- klass->hide_all = gtk_widget_hide;
- klass->map = gtk_widget_real_map;
- klass->unmap = gtk_widget_real_unmap;
- klass->realize = gtk_widget_real_realize;
- klass->unrealize = gtk_widget_real_unrealize;
- klass->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->style_set = gtk_widget_style_set;
- klass->add_accelerator = (void*) gtk_accel_group_handle_add;
- klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
- klass->grab_focus = gtk_widget_real_grab_focus;
- klass->event = NULL;
- klass->button_press_event = NULL;
- klass->button_release_event = NULL;
- klass->motion_notify_event = NULL;
- klass->delete_event = NULL;
- klass->destroy_event = NULL;
- klass->expose_event = NULL;
- klass->key_press_event = gtk_widget_real_key_press_event;
- klass->key_release_event = gtk_widget_real_key_release_event;
- klass->enter_notify_event = NULL;
- klass->leave_notify_event = NULL;
- klass->configure_event = NULL;
- klass->focus_in_event = NULL;
- klass->focus_out_event = NULL;
- klass->map_event = NULL;
- klass->unmap_event = NULL;
- klass->property_notify_event = gtk_selection_property_notify;
- klass->selection_clear_event = gtk_selection_clear;
- klass->selection_request_event = gtk_selection_request;
- klass->selection_notify_event = gtk_selection_notify;
- klass->selection_received = NULL;
- klass->proximity_in_event = NULL;
- klass->proximity_out_event = NULL;
- klass->drag_begin = NULL;
- klass->drag_end = NULL;
- klass->drag_data_delete = NULL;
- klass->drag_leave = NULL;
- klass->drag_motion = NULL;
- klass->drag_drop = NULL;
- klass->drag_data_received = NULL;
+ binding_set = gtk_binding_set_by_class (klass);
- klass->no_expose_event = NULL;
+ gtk_binding_entry_add_signal (binding_set, GDK_F10, GDK_SHIFT_MASK,
+ "popup_menu", 0);
- klass->debug_msg = gtk_widget_debug_msg;
+ 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_CAN_FOCUS:
+ case PROP_APP_PAINTABLE:
+ gtk_widget_set_app_paintable (widget, g_value_get_boolean (value));
+ break;
+ case PROP_CAN_FOCUS:
saved_flags = GTK_WIDGET_FLAGS (widget);
- if (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_COMPOSITE_CHILD:
- 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 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 PROP_VISIBLE:
+ g_value_set_boolean (value, (GTK_WIDGET_VISIBLE (widget) != FALSE));
break;
- case ARG_VISIBLE:
- GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_VISIBLE (widget) != FALSE);
+ case PROP_SENSITIVE:
+ g_value_set_boolean (value, (GTK_WIDGET_SENSITIVE (widget) != FALSE));
break;
- case ARG_SENSITIVE:
- GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_SENSITIVE (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_COMPOSITE_CHILD:
- GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE);
+ case PROP_RECEIVES_DEFAULT:
+ g_value_set_boolean (value, (GTK_WIDGET_RECEIVES_DEFAULT (widget) != FALSE));
break;
- case ARG_STYLE:
- GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
+ case PROP_COMPOSITE_CHILD:
+ g_value_set_boolean (value, (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE));
break;
- case ARG_EVENTS:
- eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id);
+ case PROP_STYLE:
+ g_value_set_object (value, G_OBJECT (gtk_widget_get_style (widget)));
+ break;
+ 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_init (GtkWidget *widget)
{
GdkColormap *colormap;
- GdkVisual *visual;
GTK_PRIVATE_FLAGS (widget) = 0;
widget->state = GTK_STATE_NORMAL;
GTK_WIDGET_SET_FLAGS (widget,
GTK_SENSITIVE |
GTK_PARENT_SENSITIVE |
- (composite_child_stack ? GTK_COMPOSITE_CHILD : 0));
+ (composite_child_stack ? GTK_COMPOSITE_CHILD : 0) |
+ GTK_DOUBLE_BUFFERED);
widget->style = gtk_widget_peek_style ();
gtk_style_ref (widget->style);
colormap = gtk_widget_peek_colormap ();
- visual = gtk_widget_peek_visual ();
- /* XXX - should we ref the colormap and visual, too? */
-
if (colormap != gtk_widget_get_default_colormap ())
- {
- /* gdk_colormap_ref (colormap); */
- gtk_object_set_data (GTK_OBJECT (widget), colormap_key, colormap);
- }
-
- if (visual != gtk_widget_get_default_visual ())
- {
- /* gdk_visual_ref (visual); */
- gtk_object_set_data (GTK_OBJECT (widget), visual_key, visual);
- }
+ 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);
+ g_return_val_if_fail (gtk_type_is_a (type, GTK_TYPE_WIDGET), NULL);
- 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);
+ widget = g_object_new_valist (type, first_property_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);
+ return widget;
}
-/*****************************************
- * gtk_widget_newv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-GtkWidget*
-gtk_widget_newv (GtkType type,
- guint nargs,
- GtkArg *args)
+/**
+ * gtk_widget_set:
+ * @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_property_name,
+ ...)
{
- g_return_val_if_fail (gtk_type_is_a (type, GTK_TYPE_WIDGET), NULL);
-
- return GTK_WIDGET (gtk_object_newv (type, nargs, args));
-}
+ va_list var_args;
-/*****************************************
- * gtk_widget_get:
- *
- * arguments:
- *
- * results:
- *****************************************/
+ g_return_if_fail (GTK_IS_WIDGET (widget));
-void
-gtk_widget_get (GtkWidget *widget,
- GtkArg *arg)
+ va_start (var_args, first_property_name);
+ g_object_set_valist (G_OBJECT (widget), first_property_name, var_args);
+ va_end (var_args);
+}
+
+static inline void
+gtk_widget_queue_clear_child (GtkWidget *widget)
{
- 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);
+ GtkWidget *parent;
+
+ parent = widget->parent;
+ if (parent && GTK_WIDGET_DRAWABLE (parent))
+ gtk_widget_queue_clear_area (parent,
+ widget->allocation.x,
+ widget->allocation.y,
+ widget->allocation.width,
+ widget->allocation.height);
}
-/*****************************************
- * 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));
-
- gtk_object_getv (GTK_OBJECT (widget), nargs, args);
-}
-
-/*****************************************
- * gtk_widget_set:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_set (GtkWidget *widget,
- const gchar *first_arg_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_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);
-}
-
-/*****************************************
+/**
* gtk_widget_unparent:
- * do any cleanup necessary necessary
- * for setting parent = NULL.
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @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.
gtk_window_set_default (GTK_WINDOW (toplevel), NULL);
}
- if (GTK_WIDGET_REDRAW_PENDING (widget))
- gtk_widget_redraw_queue_remove (widget);
-
if (GTK_IS_RESIZE_CONTAINER (widget))
gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
if (prev)
prev->next = slist;
else
- {
- /* it is really messy to have this signal disconnection
- * in gtkwidget.c, the resize_widgets invariants should
- * all be taken care off by gtkcontainer.c exclusively.
- */
- if (!slist)
- gtk_signal_disconnect_by_func (GTK_OBJECT (toplevel),
- GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
- NULL);
- GTK_CONTAINER (toplevel)->resize_widgets = slist;
- }
+ GTK_CONTAINER (toplevel)->resize_widgets = slist;
g_slist_free_1 (last);
}
toplevel = toplevel->parent;
}
- if (widget->window &&
- GTK_WIDGET_NO_WINDOW (widget) &&
- GTK_WIDGET_DRAWABLE (widget))
- gtk_widget_queue_clear (widget);
+
+ gtk_widget_queue_clear_child (widget);
/* Reset the width and height here, to force reallocation if we
* get added back to a new parent. This won't work if our new
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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * 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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @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.
+ *
+ * Remember that you have to show the containers containing a widget,
+ * in addition to the widget itself, before it will appear onscreen.
+ *
+ * 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)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (!GTK_WIDGET_VISIBLE (widget))
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
+ {
+ 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));
+ }
}
+static void
+gtk_widget_real_show (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (!GTK_WIDGET_VISIBLE (widget))
+ {
+ GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
-/*************************************************************
- * 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:
- *************************************************************/
+ if (widget->parent &&
+ GTK_WIDGET_MAPPED (widget->parent) &&
+ !GTK_WIDGET_MAPPED (widget))
+ gtk_widget_map (widget);
+ }
+}
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)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (GTK_WIDGET_VISIBLE (widget))
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
+ {
+ gtk_widget_ref (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
+static void
+gtk_widget_real_hide (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (GTK_WIDGET_VISIBLE (widget))
+ {
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
+
+ if (GTK_WIDGET_MAPPED (widget))
+ gtk_widget_unmap (widget);
+ }
+}
+
+/**
+ * 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)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+ class = GTK_WIDGET_GET_CLASS (widget);
if (class->show_all)
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)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+ class = GTK_WIDGET_GET_CLASS (widget);
if (class->hide_all)
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)
{
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (GTK_WIDGET_VISIBLE (widget) == TRUE);
if (!GTK_WIDGET_MAPPED (widget))
{
if (!GTK_WIDGET_REALIZED (widget))
gtk_widget_realize (widget);
-
+
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);
+
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ gtk_widget_queue_draw (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)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (GTK_WIDGET_MAPPED (widget))
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
+ {
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ gtk_widget_queue_clear_child (widget);
+ gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
+ }
}
-/*****************************************
+/**
* 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)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_REDRAW_PENDING (widget))
- gtk_widget_redraw_queue_remove (widget);
-
if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
gtk_widget_shape_combine_mask (widget, NULL, -1, -1);
if (GTK_WIDGET_REALIZED (widget))
{
+ gtk_widget_ref (widget);
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
+ gtk_widget_unref (widget);
}
}
/*****************************************
- * gtk_widget_queue_draw:
- *
- * arguments:
- *
- * results:
+ * Draw queueing.
*****************************************/
-typedef struct _GtkDrawData GtkDrawData;
-struct _GtkDrawData {
- GdkRectangle rect;
- GdkWindow *window;
-};
-
-static GMemChunk *draw_data_mem_chunk = NULL;
-static GSList *draw_data_free_list = NULL;
-static const gchar *draw_data_key = "gtk-draw-data";
-static GQuark draw_data_key_id = 0;
-
-static gint gtk_widget_idle_draw (gpointer data);
-
-static void
-gtk_widget_queue_draw_data (GtkWidget *widget,
- gint x,
- gint y,
- gint width,
- gint height,
- GdkWindow *window)
-{
- GSList *node;
- GtkDrawData *data;
-
- g_return_if_fail (widget != NULL);
-
- if ((width != 0) && (height != 0) && GTK_WIDGET_DRAWABLE (widget))
- {
- if (!draw_data_key_id)
- draw_data_key_id = g_quark_from_static_string (draw_data_key);
-
- if (draw_data_free_list)
- {
- node = draw_data_free_list;
- data = node->data;
- draw_data_free_list = draw_data_free_list->next;
- }
- else
- {
- if (!draw_data_mem_chunk)
- draw_data_mem_chunk = g_mem_chunk_create (GtkDrawData, 64,
- G_ALLOC_ONLY);
- data = g_chunk_new (GtkDrawData, draw_data_mem_chunk);
- node = g_slist_alloc();
- node->data = data;
- }
-
- data->rect.x = x;
- data->rect.y = y;
-
- if ((width < 0) || (height < 0))
- {
- data->rect.width = 0;
- data->rect.height = 0;
- }
- else
- {
- data->rect.width = width;
- data->rect.height = height;
- }
- data->window = window;
-
- if ((width < 0) || (height < 0))
- {
- GSList *draw_data_list =
- gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
- if (draw_data_list)
- draw_data_free_list = g_slist_concat (draw_data_list,
- draw_data_free_list);
- node->next = NULL;
- }
- else
- node->next = gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
-
- if (!GTK_WIDGET_REDRAW_PENDING (widget))
- {
- GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_PENDING);
- if (gtk_widget_redraw_queue == NULL)
- gtk_idle_add_priority (GTK_PRIORITY_INTERNAL,
- gtk_widget_idle_draw,
- NULL);
- gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
- }
-
- gtk_object_set_data_by_id (GTK_OBJECT (widget), draw_data_key_id, node);
- }
-}
-
+/**
+ * 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,
gint y,
gint width,
- gint height)
+ gint height)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_widget_queue_draw_data (widget, x, y, width, height, NULL);
+ 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)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_widget_queue_draw_data (widget, 0, 0, -1, -1, NULL);
+ gtk_widget_queue_clear (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,
gint width,
gint height)
{
- GtkWidget *parent;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- /* Find the correct widget */
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- parent = widget;
- while (parent && GTK_WIDGET_NO_WINDOW (parent))
- parent = parent->parent;
-
- if (parent)
- gtk_widget_queue_draw_data (parent, x, y, width, height, widget->window);
- }
- else
- {
- gint wx, wy, wwidth, wheight;
- /* Translate widget relative to window-relative */
-
- gdk_window_get_position (widget->window, &wx, &wy);
- x -= wx - widget->allocation.x;
- y -= wy - widget->allocation.y;
-
- gdk_window_get_size (widget->window, &wwidth, &wheight);
-
- if (x < 0)
- {
- width += x; x = 0;
- }
- if (y < 0)
- {
- height += y; y = 0;
- }
- if (x + width > wwidth)
- width = wwidth - x;
- if (y + height > wheight)
- height = wheight - y;
-
- gtk_widget_queue_draw_data (widget, x, y, width, height, NULL);
- }
-}
-
-static void
-gtk_widget_redraw_queue_remove (GtkWidget *widget)
-{
- GSList *draw_data_list;
- GSList *tmp_list;
-
- g_return_if_fail (GTK_WIDGET_REDRAW_PENDING (widget));
-
- gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
-
- draw_data_list = gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
- tmp_list = g_slist_last (draw_data_list);
- if (tmp_list)
- {
- tmp_list->next = draw_data_free_list;
- draw_data_free_list = draw_data_list;
- }
-
- gtk_object_set_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id,
- NULL);
+ GdkRectangle invalid_rect;
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
-}
-
-void
-gtk_widget_queue_clear (GtkWidget *widget)
-{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_NO_WINDOW (widget))
- gtk_widget_queue_clear_area (widget, widget->allocation.x,
- widget->allocation.y,
- widget->allocation.width,
- widget->allocation.height);
- else
- gtk_widget_queue_clear_area (widget, 0, 0,
- widget->allocation.width,
- widget->allocation.height);
-}
-
-static gint
-gtk_widget_draw_data_combine (GtkDrawData *parent, GtkDrawData *child)
-{
- gint parent_x2, parent_y2;
- gint child_x2, child_y2;
-
- /* Check for intersection */
-
- parent_x2 = parent->rect.x + parent->rect.width;
- child_x2 = child->rect.x + child->rect.width;
- parent_y2 = parent->rect.y + parent->rect.height;
- child_y2 = child->rect.y + child->rect.height;
-
- if ((child->rect.x > parent_x2) || (parent->rect.x > child_x2) ||
- (child->rect.y > parent_y2) || (parent->rect.y > child_y2))
- return FALSE;
- else
- {
- parent->rect.x = MIN (parent->rect.x, child->rect.x);
- parent->rect.y = MIN (parent->rect.y, child->rect.y);
- parent->rect.width = MAX (parent_x2, child_x2) - parent->rect.x;
- parent->rect.height = MAX (parent_y2, child_y2) - parent->rect.y;
- }
-
- return TRUE;
-}
-
-/* Take a rectangle with respect to window, and translate it
- * to coordinates relative to widget's allocation, clipping through
- * intermediate windows. Returns whether translation failed. If the
- * translation failed, we have something like a handlebox, where
- * the child widget's GdkWindow is not a child of the parents GdkWindow.
- */
-static gboolean
-gtk_widget_clip_rect (GtkWidget *widget,
- GdkWindow *window,
- GdkRectangle *rect,
- gint *x_offset,
- gint *y_offset)
-{
- gint x,y, width, height;
-
- while (window && (window != widget->window))
- {
- gdk_window_get_position (window, &x, &y);
- rect->x += x;
- if (x_offset)
- *x_offset += x;
- rect->y += y;
- if (y_offset)
- *y_offset += y;
-
- window = gdk_window_get_parent (window);
- if (!window)
- return FALSE;
-
- gdk_window_get_size (window, &width, &height);
-
- if (rect->x < 0)
- {
- rect->width += rect->x;
- rect->x = 0;
- }
- if (rect->y < 0)
- {
- rect->height += rect->y;
- rect->y = 0;
- }
- if (rect->x + rect->width > width)
- rect->width = width - rect->x;
- if (rect->y + rect->height > height)
- rect->height = height - rect->y;
- }
+ if (!(widget->window && gdk_window_is_viewable (widget->window)))
+ return;
- if (!window)
- return FALSE;
+ /* Find the correct widget */
if (!GTK_WIDGET_NO_WINDOW (widget))
{
- if (gdk_window_get_toplevel (window) != window)
+ if (widget->parent)
{
- gdk_window_get_position (window, &x, &y);
- rect->x += x - widget->allocation.x;
- if (x_offset)
- *x_offset += x - widget->allocation.x;
- rect->y += y - widget->allocation.y;
- if (y_offset)
- *y_offset += y - widget->allocation.y;
- }
- }
-
- return TRUE;
-}
+ /* Translate widget relative to window-relative */
-static gint
-gtk_widget_idle_draw (gpointer data)
-{
- GSList *widget_list;
- GSList *draw_data_list;
- GtkWidget *widget;
-
- GTK_THREADS_ENTER;
-
- /* Translate all draw requests to be allocation-relative */
- widget_list = gtk_widget_redraw_queue;
- while (widget_list)
- {
- widget = widget_list->data;
- draw_data_list = gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
-
- while (draw_data_list)
- {
- gboolean full_allocation = FALSE;
- GtkDrawData *data = draw_data_list->data;
+ gint wx, wy, wwidth, wheight;
+
+ gdk_window_get_position (widget->window, &wx, &wy);
+ x -= wx - widget->allocation.x;
+ y -= wy - widget->allocation.y;
+
+ gdk_window_get_size (widget->window, &wwidth, &wheight);
- if (data->window)
- {
- /* If the translation fails, we have a handlebox,
- * so redraw the whole widget. Could be done better?
- */
- full_allocation = !gtk_widget_clip_rect (widget,
- data->window,
- &data->rect,
- NULL, NULL);
- data->window = NULL;
- }
- else
+ if (x + width <= 0 || y + height <= 0 ||
+ x >= wwidth || y >= wheight)
+ return;
+
+ if (x < 0)
{
- if ((data->rect.width == 0) && (data->rect.height == 0))
- {
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- data->rect.x = widget->allocation.x;
- data->rect.y = widget->allocation.y;
- }
- else
- {
- data->rect.x = 0;
- data->rect.y = 0;
- }
- data->rect.width = widget->allocation.width;
- data->rect.height = widget->allocation.height;
- }
+ width += x; x = 0;
}
-
- draw_data_list = draw_data_list->next;
- }
-
- widget_list = widget_list->next;
- }
-
- /* Coalesce redraws
- */
- widget_list = gtk_widget_redraw_queue;
- while (widget_list)
- {
- GSList *prev_node = NULL;
- widget = widget_list->data;
- draw_data_list = gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
-
- while (draw_data_list)
- {
- gint x_offset, y_offset;
- GtkDrawData *data = draw_data_list->data;
- GSList *parent_list = draw_data_list->next;
- GtkWidget *parent;
- GdkWindow *window;
-
- x_offset = 0;
- y_offset = 0;
-
- parent = widget;
- while (parent)
+ if (y < 0)
{
- while (parent_list)
- {
- if (gtk_widget_draw_data_combine (parent_list->data, data))
- {
- GSList *tmp;
- if (prev_node)
- prev_node->next = draw_data_list->next;
- else
- gtk_object_set_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id,
- draw_data_list->next);
-
- tmp = draw_data_list->next;
- draw_data_list->next = draw_data_free_list;
- draw_data_free_list = draw_data_list;
- draw_data_list = tmp;
-
- goto next_rect;
- }
-
- parent_list = parent_list->next;
- }
-
- window = parent->window;
-
- if (parent->parent && parent->parent->window != window)
- {
- if (!GTK_WIDGET_NO_WINDOW (parent))
- {
- gint x, y;
- gdk_window_get_position (window, &x, &y);
- data->rect.x -= x - parent->allocation.x;
- x_offset -= x - parent->allocation.x;
- data->rect.y -= y - parent->allocation.y;
- y_offset -= y - parent->allocation.y;
- }
- /* If we can't translate the rectangle, stop trying to
- * merge. (This occurs for a handlebox)
- */
- if (!gtk_widget_clip_rect (parent->parent, window, &data->rect,
- &x_offset, &y_offset))
- parent = NULL;
- }
-
- if (parent)
- parent = parent->parent;
-
- if (parent && GTK_WIDGET_REDRAW_PENDING (parent))
- parent_list = gtk_object_get_data_by_id (GTK_OBJECT (parent),
- draw_data_key_id);
- else
- parent_list = NULL;
+ height += y; y = 0;
}
-
- /* OK, this rectangle stays around. But take advantage
- * of the work we've done to clip it to the visible area -
- * rect.width/height have already been appropriately
- * decreased
- */
- data->rect.x -= x_offset;
- data->rect.y -= y_offset;
-
-
- prev_node = draw_data_list;
-
- draw_data_list = draw_data_list->next;
- next_rect:
- continue;
+ if (x + width > wwidth)
+ width = wwidth - x;
+ if (y + height > wheight)
+ height = wheight - y;
}
- widget_list = widget_list->next;
}
- /* Process the draws */
+ invalid_rect.x = x;
+ invalid_rect.y = y;
+ invalid_rect.width = width;
+ invalid_rect.height = height;
- widget_list = gtk_widget_redraw_queue;
-
- while (widget_list)
- {
- widget = widget_list->data;
- draw_data_list = gtk_object_get_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id);
- gtk_object_set_data_by_id (GTK_OBJECT (widget),
- draw_data_key_id,
- NULL);
-
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
+ gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
+}
- while (draw_data_list)
- {
- GtkDrawData *data = draw_data_list->data;
- gtk_widget_draw (widget, &data->rect);
-
- if (draw_data_list->next)
- draw_data_list = draw_data_list->next;
- else
- {
- draw_data_list->next = draw_data_free_list;
- draw_data_free_list = draw_data_list;
- break;
- }
- }
+/**
+ * gtk_widget_queue_clear:
+ * @widget: a #GtkWidget
+ *
+ * DEPRECATED. Use gtk_widget_queue_draw() instead.
+ **/
+void
+gtk_widget_queue_clear (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
- widget_list = widget_list->next;
+ if (widget->allocation.width || widget->allocation.height)
+ {
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ gtk_widget_queue_clear_area (widget, widget->allocation.x,
+ widget->allocation.y,
+ widget->allocation.width,
+ widget->allocation.height);
+ else
+ gtk_widget_queue_clear_area (widget, 0, 0,
+ widget->allocation.width,
+ widget->allocation.height);
}
-
- g_slist_free (gtk_widget_redraw_queue);
- gtk_widget_redraw_queue = NULL;
-
- GTK_THREADS_LEAVE;
-
- return FALSE;
}
+/**
+ * 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 (GTK_IS_RESIZE_CONTAINER (widget))
gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
+ gtk_widget_queue_clear (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 (area)
+ gtk_widget_queue_draw_area (widget,
+ area->x, area->y,
+ area->width, area->height);
+ else
+ gtk_widget_queue_draw (widget);
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
+ gdk_window_process_updates (widget->window, TRUE);
}
}
-/*****************************************
- * gtk_widget_draw_focus:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+/**
+ * gtk_widget_size_request:
+ * @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_draw_focus (GtkWidget *widget)
+gtk_widget_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
{
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:
- *****************************************/
+#ifdef G_ENABLE_DEBUG
+ if (requisition == &widget->requisition)
+ g_warning ("gtk_widget_size_request() called on child widget with request equal\n to widget->requisition. gtk_widget_set_usize() may not work properly.");
+#endif /* G_ENABLE_DEBUG */
-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_ref (widget);
+ gtk_widget_ensure_style (widget);
+ gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
+ &widget->requisition);
-/*****************************************
- * gtk_widget_size_request:
- *
- * arguments:
- *
- * results:
- *****************************************/
+ if (requisition)
+ gtk_widget_get_child_requisition (widget, requisition);
+
+ gtk_widget_unref (widget);
+}
+/**
+ * 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_size_request (GtkWidget *widget,
- GtkRequisition *requisition)
+gtk_widget_get_child_requisition (GtkWidget *widget,
+ GtkRequisition *requisition)
{
GtkWidgetAuxInfo *aux_info;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_widget_ref (widget);
- gtk_widget_ensure_style (widget);
- gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
- requisition);
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
+ *requisition = widget->requisition;
+
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
{
if (aux_info->width > 0)
if (aux_info->height > 0)
requisition->height = aux_info->height;
}
- gtk_widget_unref (widget);
}
-/*****************************************
+/**
* 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)
{
GtkWidgetAuxInfo *aux_info;
GtkAllocation real_allocation;
+ gboolean needs_draw = FALSE;
g_return_if_fail (widget != NULL);
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;
}
+
+ real_allocation.width = MAX (real_allocation.width, 1);
+ real_allocation.height = MAX (real_allocation.height, 1);
+
+ if (real_allocation.width < 0 || real_allocation.height < 0)
+ {
+ g_warning ("gtk_widget_size_allocate(): attempt to allocate widget with width %d and height %d",
+ real_allocation.width,
+ real_allocation.height);
+ real_allocation.width = 1;
+ real_allocation.height = 1;
+ }
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ {
+ if (widget->allocation.x != real_allocation.x ||
+ widget->allocation.y != real_allocation.y ||
+ widget->allocation.width != real_allocation.width ||
+ widget->allocation.height != real_allocation.height)
+ {
+ gtk_widget_queue_clear_child (widget);
+ needs_draw = TRUE;
+ }
+ }
+ else if (widget->allocation.width != real_allocation.width ||
+ widget->allocation.height != real_allocation.height)
+ {
+ needs_draw = TRUE;
+ }
+
+ if (GTK_IS_RESIZE_CONTAINER (widget))
+ gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
+
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
+
+ if (needs_draw)
+ {
+ gtk_widget_queue_draw (widget);
+ if (widget->parent && GTK_CONTAINER (widget->parent)->reallocate_redraws)
+ gtk_widget_queue_draw (widget->parent);
+ }
+}
+
+static void
+gtk_widget_real_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ widget->allocation = *allocation;
+
+ if (GTK_WIDGET_REALIZED (widget) &&
+ !GTK_WIDGET_NO_WINDOW (widget))
+ {
+ gdk_window_move_resize (widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
+ }
}
static void
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (gtk_signal_handler_pending_by_func (GTK_OBJECT (widget),
- widget_signals[ADD_ACCELERATOR],
- TRUE,
- GTK_SIGNAL_FUNC (gtk_widget_stop_add_accelerator),
- NULL) == 0)
+
+ if (!gtk_widget_accelerators_locked (widget))
{
gtk_signal_connect (GTK_OBJECT (widget),
"add_accelerator",
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (gtk_signal_handler_pending_by_func (GTK_OBJECT (widget),
- widget_signals[ADD_ACCELERATOR],
- TRUE,
- GTK_SIGNAL_FUNC (gtk_widget_stop_add_accelerator),
- NULL) > 0)
+
+ if (gtk_widget_accelerators_locked (widget))
{
gtk_signal_disconnect_by_func (GTK_OBJECT (widget),
GTK_SIGNAL_FUNC (gtk_widget_stop_add_accelerator),
}
}
-void
-gtk_widget_thaw_accelerators (GtkWidget *widget)
-{
- g_message ("gtk_widget_thaw_accelerators() is deprecated");
-
- gtk_widget_unlock_accelerators (widget);
-}
-
-void
-gtk_widget_freeze_accelerators (GtkWidget *widget)
+gboolean
+gtk_widget_accelerators_locked (GtkWidget *widget)
{
- g_message ("gtk_widget_freeze_accelerators() is deprecated");
-
- gtk_widget_lock_accelerators (widget);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return gtk_signal_handler_pending_by_func (GTK_OBJECT (widget),
+ widget_signals[ADD_ACCELERATOR],
+ TRUE,
+ GTK_SIGNAL_FUNC (gtk_widget_stop_add_accelerator),
+ NULL) > 0;
}
void
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)
{
- gint return_val;
- gint signal_num;
+ g_return_val_if_fail (widget != NULL, TRUE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
+
+ if (event->type == GDK_EXPOSE)
+ {
+ g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get "
+ "the same effect, call gdk_window_invalidate_rect/region(), "
+ "followed by gdk_window_process_updates().");
+ return TRUE;
+ }
+
+ return gtk_widget_event_internal (widget, event);
+}
+
+/**
+ * gtk_widget_send_expose:
+ * @widget: a #GtkWidget
+ * @event: a expose #GdkEvent
+ *
+ * Very rarely-used function. This function is used to emit
+ * an expose event signals on a widget. This function is not
+ * normally used directly. The only time it is used is when
+ * propagating an expose event to a child NO_WINDOW widget, and
+ * that is normally done using gtk_container_propagate_expose.
+ *
+ * If you want to force an area of a window to be redrawn,
+ * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+ * To cause the redraw to be done immediately, follow that call
+ * with a call to gdk_window_procss_updates().
+ *
+ * Return value: return from the event signal emission (%TRUE if the event was handled)
+ **/
+gint
+gtk_widget_send_expose (GtkWidget *widget,
+ GdkEvent *event)
+{
g_return_val_if_fail (widget != NULL, TRUE);
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
+ g_return_val_if_fail (event != NULL, TRUE);
+ g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE);
+
+ if (event->type != GDK_EXPOSE)
+ return TRUE;
+
+ return gtk_widget_event_internal (widget, event);
+}
+
+static gint
+gtk_widget_event_internal (GtkWidget *widget,
+ GdkEvent *event)
+{
+ gboolean return_val;
+ gint signal_num;
gtk_widget_ref (widget);
return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
&return_val);
if (return_val || GTK_OBJECT_DESTROYED (widget))
- {
- gtk_widget_unref (widget);
- return TRUE;
- }
+ goto out;
switch (event->type)
{
case GDK_3BUTTON_PRESS:
signal_num = BUTTON_PRESS_EVENT;
break;
+ case GDK_SCROLL:
+ signal_num = SCROLL_EVENT;
+ break;
case GDK_BUTTON_RELEASE:
signal_num = BUTTON_RELEASE_EVENT;
break;
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;
signal_num = CLIENT_EVENT;
break;
case GDK_EXPOSE:
- /* there is no sense in providing a widget with bogus expose events.
- * Widgets that are going to be resized don't need to be
- * exposed, since they will be redrawn anyways.
- */
- if (!event->any.window ||
- GTK_WIDGET_RESIZE_NEEDED (widget) ||
- (widget->parent && GTK_WIDGET_RESIZE_NEEDED (widget->parent)))
- {
- gtk_widget_unref (widget);
- return TRUE;
- }
+ if (!event->any.window) /* Why is this necessary */
+ goto out;
+
signal_num = EXPOSE_EVENT;
break;
case GDK_VISIBILITY_NOTIFY:
break;
default:
g_warning ("could not determine signal number for event: %d", event->type);
- gtk_widget_unref (widget);
- return TRUE;
+ goto out;
}
if (signal_num != -1)
return_val |= GTK_OBJECT_DESTROYED (widget);
+ out:
gtk_widget_unref (widget);
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)
g_return_if_fail (widget->parent != NULL);
if (widget->parent != new_parent)
- {
- /* First try to see if we can get away without unrealizing
- * the widget as we reparent it. if so we set a flag so
- * that gtk_widget_unparent doesn't unrealize widget
- */
- if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
- GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
-
- gtk_widget_ref (widget);
- gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
- gtk_container_add (GTK_CONTAINER (new_parent), widget);
- gtk_widget_unref (widget);
-
- if (GTK_WIDGET_IN_REPARENT (widget))
- {
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_IN_REPARENT);
-
- /* OK, now fix up the widget's window. (And that for any
- * children, if the widget is NO_WINDOW and a container)
- */
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget),
- gtk_widget_reparent_container_child,
- gtk_widget_get_parent_window (widget));
- else
- {
- GdkWindow *parent_window;
-
- parent_window = gtk_widget_get_parent_window (widget);
- if (parent_window != widget->window)
- {
- if (widget->window)
- gdk_window_unref (widget->window);
- widget->window = parent_window;
- if (widget->window)
- gdk_window_ref (widget->window);
- }
- }
- }
- else
- gdk_window_reparent (widget->window, gtk_widget_get_parent_window (widget), 0, 0);
- }
- }
-}
-
-/*****************************************
- * 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);
+ {
+ /* First try to see if we can get away without unrealizing
+ * the widget as we reparent it. if so we set a flag so
+ * that gtk_widget_unparent doesn't unrealize widget
+ */
+ if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
+ GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
+
+ gtk_widget_ref (widget);
+ gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
+ gtk_container_add (GTK_CONTAINER (new_parent), widget);
+ gtk_widget_unref (widget);
+
+ if (GTK_WIDGET_IN_REPARENT (widget))
+ {
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_IN_REPARENT);
+
+ gtk_widget_reparent_container_child (widget,
+ gtk_widget_get_parent_window (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)
else
dest = &tmp;
- return_val = gdk_rectangle_intersect ((GdkRectangle*) &widget->allocation, area, dest);
+ return_val = gdk_rectangle_intersect (&widget->allocation, area, dest);
if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
{
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
widget = GTK_WINDOW (toplevel)->focus_widget;
if (widget == focus_widget)
- return;
+ {
+ /* We call gtk_window_set_focus() here so that the
+ * toplevel window can request the focus if necessary.
+ * This is needed when the toplevel is a GtkPlug
+ */
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_window_set_focus (GTK_WINDOW (toplevel), focus_widget);
+
+ return;
+ }
if (widget)
{
}
}
-/*****************************************
- * gtk_widget_grab_default:
- *
- * arguments:
- *
- * results:
- *****************************************/
+/**
+ * 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
+ *
+ * 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)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
- window_type = gtk_window_get_type ();
+ window_type = GTK_TYPE_WINDOW;
window = widget->parent;
while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
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 (G_STRLOC ": widget not within a GtkWindow");
}
-/*****************************************
+/**
* gtk_widget_set_name:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @name: name for the widget
+ *
+ * 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)
g_free (widget->name);
widget->name = g_strdup (name);
- if (!GTK_WIDGET_USER_STYLE (widget))
+ 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:
- *
- * arguments:
- * widget
- * state
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @state: new state for @widget
+ *
+ * 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)
}
}
-/*****************************************
- * gtk_widget_set_sensitive:
- *
- * arguments:
- * widget
- * boolean value for sensitivity
- *
- * results:
- *****************************************/
+void
+gtk_widget_set_app_paintable (GtkWidget *widget,
+ gboolean app_paintable)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ app_paintable = (app_paintable != FALSE);
+
+ if (GTK_WIDGET_APP_PAINTABLE (widget) != app_paintable)
+ {
+ if (app_paintable)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_APP_PAINTABLE);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_APP_PAINTABLE);
+
+ 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)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (double_buffered)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+}
+/**
+ * gtk_widget_set_sensitive:
+ * @widget: a @widget
+ * @sensitive: %TRUE to make the widget sensitive
+ *
+ * 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,
- gint sensitive)
+ gboolean sensitive)
{
GtkStateData data;
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:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @parent: parent container
+ *
+ * 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),
- rc_style_key_id,
- style,
+ 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)
+ {
+ rc_style = gtk_rc_style_new();
+ gtk_object_set_data_by_id_full (GTK_OBJECT (widget),
+ 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);
+}
+
+static void
+gtk_widget_direction_changed (GtkWidget *widget,
+ GtkTextDirection previous_direction)
+{
+ gtk_widget_queue_resize (widget);
}
static void
{
if (GTK_WIDGET_REALIZED (widget) &&
!GTK_WIDGET_NO_WINDOW (widget))
- {
- gtk_style_set_background (widget->style, widget->window, widget->state);
- if (GTK_WIDGET_DRAWABLE (widget))
- gdk_window_clear (widget->window);
- }
+ gtk_style_set_background (widget->style, widget->window, widget->state);
}
static void
g_return_if_fail (widget != NULL);
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, style->font_desc);
+ }
if (widget->style != style)
{
GtkRequisition old_requisition;
old_requisition = widget->requisition;
- gtk_widget_size_request (widget, &widget->requisition);
+ gtk_widget_size_request (widget, NULL);
if ((old_requisition.width != widget->requisition.width) ||
(old_requisition.height != widget->requisition.height))
}
}
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)
{
{
GSList *tmp;
- if (style_stack)
- {
- tmp = style_stack;
- style_stack = style_stack->next;
- gtk_style_unref ((GtkStyle*) tmp->data);
- g_slist_free_1 (tmp);
- }
+ if (style_stack)
+ {
+ tmp = style_stack;
+ style_stack = style_stack->next;
+ gtk_style_unref ((GtkStyle*) tmp->data);
+ g_slist_free_1 (tmp);
+ }
+}
+
+static PangoContext *
+gtk_widget_peek_pango_context (GtkWidget *widget)
+{
+ return gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_pango_context);
+}
+
+/**
+ * gtk_widget_get_pango_context:
+ * @widget: a #GtkWidget
+ *
+ * Get a #PangoContext with the appropriate colormap, font description
+ * and base direction for this widget. Unlike the context returned
+ * by gtk_widget_create_pango_context(), this context is owned by
+ * the widget (it can be used as long as widget exists), and will
+ * be updated to match any changes to the widget's attributes.
+ *
+ * If you create and keep a #PangoLayout using this context, you must
+ * deal with changes to the context by calling pango_layout_context_changed()
+ * on the layout in response to the ::style_set and ::direction_set signals
+ * for the widget.
+ *
+ * Return value: the #PangoContext for the widget.
+ **/
+PangoContext *
+gtk_widget_get_pango_context (GtkWidget *widget)
+{
+ PangoContext *context;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ 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), quark_pango_context, context,
+ (GDestroyNotify) g_object_unref);
+ }
+
+ return context;
+}
+
+/**
+ * gtk_widget_create_pango_context:
+ * @widget: a #PangoWidget
+ *
+ * Create a new pango context with the appropriate colormap,
+ * font description, and base direction for drawing text for
+ * this widget. See also gtk_widget_get_pango_context()
+ *
+ * Return value: the new #PangoContext
+ **/
+PangoContext *
+gtk_widget_create_pango_context (GtkWidget *widget)
+{
+ PangoContext *context;
+ char *lang;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ context = gdk_pango_context_get ();
+
+ gdk_pango_context_set_colormap (context, gtk_widget_get_colormap (widget));
+ pango_context_set_base_dir (context,
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
+ PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
+ pango_context_set_font_description (context, widget->style->font_desc);
+
+ lang = gtk_get_default_language ();
+ pango_context_set_lang (context, lang);
+ g_free (lang);
+
+ return context;
+}
+
+/**
+ * gtk_widget_create_pango_layout:
+ * @widget: a #PangoWidget
+ * @text: text to set on the layout (can be %NULL)
+ *
+ * Create a new #PangoLayout with the appropriate colormap,
+ * font description, and base direction for drawing text for
+ * this widget.
+ *
+ * If you keep a #PangoLayout created in this way around, in order
+ * notify the layout of changes to the base direction or font of this
+ * widget, you must call pango_layout_context_changed() in response to
+ * the ::style_set and ::direction_set signals for the widget.
+ *
+ * Return value: the new #PangoLayout
+ **/
+PangoLayout *
+gtk_widget_create_pango_layout (GtkWidget *widget,
+ const gchar *text)
+{
+ PangoLayout *layout;
+ PangoContext *context;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ context = gtk_widget_get_pango_context (widget);
+ layout = pango_layout_new (context);
+
+ if (text)
+ pango_layout_set_text (layout, text, -1);
+
+ 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;
}
/*************************************************************
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;
}
-/*****************************************
- * gtk_widget_set_uposition:
- *
- * arguments:
- *
- * results:
- *****************************************/
+/* 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
+ *
+ *
+ * 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)
- {
- 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);
- }
+ aux_info =_gtk_widget_get_aux_info (widget, TRUE);
if (x > -2)
- aux_info->x = x;
+ {
+ if (x == -1)
+ aux_info->x_set = FALSE;
+ else
+ {
+ aux_info->x_set = TRUE;
+ aux_info->x = x;
+ }
+ }
+
if (y > -2)
- aux_info->y = y;
-
- if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
- (aux_info->x != -1) && (aux_info->y != -1))
{
- gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
- gdk_window_move (widget->window, aux_info->x, aux_info->y);
+ if (y == -1)
+ aux_info->y_set = FALSE;
+ else
+ {
+ aux_info->y_set = TRUE;
+ aux_info->y = y;
+ }
}
-
- if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
- gtk_widget_size_allocate (widget, &widget->allocation);
+
+ 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)
{
return widget;
}
-/*****************************************
+/**
* gtk_widget_get_ancestor:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @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)
{
- GdkVisual *visual;
-
- g_return_val_if_fail (widget != NULL, NULL);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
-
- if (widget->window)
- {
- visual = gdk_window_get_visual (widget->window);
- /* If window was destroyed previously, we'll get NULL here */
- if (visual)
- return visual;
- }
-
- visual = gtk_object_get_data (GTK_OBJECT (widget), visual_key);
- if (visual)
- return visual;
- return gtk_widget_get_default_visual ();
+ return gdk_colormap_get_visual (gtk_widget_get_colormap (widget));
}
-/*****************************************
- * gtk_widget_get_events:
- *
- * arguments:
+
+/**
+ * gtk_widget_set_colormap:
+ * @widget: a #GtkWidget
+ * @colormap: a colormap
*
- * results:
- *****************************************/
+ * 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)
+{
+ 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 (GDK_IS_COLORMAP (colormap));
+
+ g_object_ref (G_OBJECT (colormap));
+
+ g_object_set_qdata_full (G_OBJECT (widget),
+ quark_colormap,
+ colormap,
+ (GtkDestroyNotify) g_object_unref);
+}
+/**
+ * gtk_widget_get_events:
+ * @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)
{
static GQuark quark_composite_name = 0;
void
-gtk_widget_set_composite_name (GtkWidget *widget,
- gchar *name)
+gtk_widget_set_composite_name (GtkWidget *widget,
+ const gchar *name)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
composite_child_stack--;
}
-/*****************************************
+/**
* gtk_widget_push_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @cmap: a #GdkColormap
+ *
+ * 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_push_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_push_visual (GdkVisual *visual)
-{
- g_return_if_fail (visual != NULL);
-
- visual_stack = g_slist_prepend (visual_stack, visual);
-}
-
-/*****************************************
+/**
* gtk_widget_pop_colormap:
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Removes a colormap pushed with gtk_widget_push_colormap().
+ *
+ **/
void
gtk_widget_pop_colormap (void)
{
}
}
-/*****************************************
- * gtk_widget_pop_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_widget_pop_visual (void)
-{
- GSList *tmp;
-
- if (visual_stack)
- {
- tmp = visual_stack;
- visual_stack = visual_stack->next;
- g_slist_free_1 (tmp);
- }
-}
-
-/*****************************************
+/**
* 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_set_default_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
+/**
+ * gtk_widget_get_default_colormap:
+ *
+ * Obtains the default colormap used to create widgets.
+ *
+ * Return value: default widget colormap
+ **/
+GdkColormap*
+gtk_widget_get_default_colormap (void)
+{
+ if (!default_colormap)
+ gtk_widget_set_default_colormap (gdk_colormap_get_system ());
+
+ return default_colormap;
+}
+
+/**
+ * gtk_widget_get_default_visual:
+ *
+ * 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)
+{
+ return gdk_colormap_get_visual (gtk_widget_get_default_colormap ());
+}
+
+static void
+gtk_widget_emit_direction_changed (GtkWidget *widget,
+ GtkTextDirection old_dir)
+{
+ PangoContext *context = gtk_widget_peek_pango_context (widget);
+
+ if (context)
+ pango_context_set_base_dir (context,
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
+ PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
+
+ gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DIRECTION_CHANGED], old_dir);
+}
+
+/**
+ * gtk_widget_set_direction:
+ * @widget: a #GtkWidget
+ * @dir: the new direction
+ *
+ * Set the reading direction on a particular widget. This direction
+ * controls the primary direction for widgets containing text,
+ * and also the direction in which the children of a container are
+ * packed. The ability to set the direction is present in order
+ * so that correct localization into languages with right-to-left
+ * reading directions can be done. Generally, applications will
+ * let the default reading direction present, except for containers
+ * where the containers are arranged in an order that is explicitely
+ * visual rather than logical (such as buttons for text justificiation).
+ *
+ * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+ * set by gtk_widget_set_default_direction() will be used.
+ **/
+void
+gtk_widget_set_direction (GtkWidget *widget,
+ GtkTextDirection dir)
+{
+ GtkTextDirection old_dir;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (dir >= GTK_TEXT_DIR_NONE && dir <= GTK_TEXT_DIR_RTL);
+
+ old_dir = gtk_widget_get_direction (widget);
+
+ if (dir == GTK_TEXT_DIR_NONE)
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_DIRECTION_SET);
+ else
+ {
+ GTK_PRIVATE_SET_FLAG (widget, GTK_DIRECTION_SET);
+ if (dir == GTK_TEXT_DIR_LTR)
+ GTK_PRIVATE_SET_FLAG (widget, GTK_DIRECTION_LTR);
+ else
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_DIRECTION_LTR);
+ }
+
+ if (old_dir != gtk_widget_get_direction (widget))
+ gtk_widget_emit_direction_changed (widget, old_dir);
+}
+
+/**
+ * gtk_widget_get_direction:
+ * @widget: a #GtkWidget
+ *
+ * Get the reading direction for a particular widget. See
+ * gtk_widget_set_direction().
+ *
+ * Return value: the reading direction for the widget.
+ **/
+GtkTextDirection
+gtk_widget_get_direction (GtkWidget *widget)
+{
+ g_return_val_if_fail (widget != NULL, GTK_TEXT_DIR_LTR);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_TEXT_DIR_LTR);
+
+ if (GTK_WIDGET_DIRECTION_SET (widget))
+ return GTK_WIDGET_DIRECTION_LTR (widget) ? GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+ else
+ return gtk_default_direction;
+}
+
+static void
+gtk_widget_set_default_direction_recurse (GtkWidget *widget, gpointer data)
+{
+ GtkTextDirection old_dir = GPOINTER_TO_UINT (data);
+
+ g_object_ref (G_OBJECT (widget));
+
+ if (!GTK_WIDGET_DIRECTION_SET (widget))
+ gtk_widget_emit_direction_changed (widget, old_dir);
+
+ if (GTK_IS_CONTAINER (widget))
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_widget_set_default_direction_recurse,
+ data);
+
+ g_object_unref (G_OBJECT (widget));
+}
+/**
+ * gtk_widget_set_default_direction:
+ * @dir: the new default direction. This cannot be
+ * %GTK_TEXT_DIR_NONE.
+ *
+ * Set the default reading direction for widgets where the
+ * direction has not been explicitly set by gtk_widget_set_direction().
+ **/
void
-gtk_widget_set_default_visual (GdkVisual *visual)
+gtk_widget_set_default_direction (GtkTextDirection dir)
{
- default_visual = visual;
-}
+ g_return_if_fail (dir == GTK_TEXT_DIR_RTL || dir == GTK_TEXT_DIR_LTR);
-/*****************************************
- * gtk_widget_get_default_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
+ if (dir != gtk_default_direction)
+ {
+ GList *toplevels, *tmp_list;
+ GtkTextDirection old_dir = gtk_default_direction;
+
+ gtk_default_direction = dir;
-GdkColormap*
-gtk_widget_get_default_colormap (void)
-{
- if (!default_colormap)
- default_colormap = gdk_colormap_get_system ();
-
- return default_colormap;
-}
+ 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,
+ GUINT_TO_POINTER (old_dir));
+ g_object_unref (tmp_list->data);
+ tmp_list = tmp_list->next;
+ }
-/*****************************************
- * gtk_widget_get_default_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
+ g_list_free (toplevels);
+ }
+}
-GdkVisual*
-gtk_widget_get_default_visual (void)
+/**
+ * gtk_widget_get_default_direction:
+ *
+ * Return value: the current default direction. See
+ * gtk_widget_set_direction().
+ **/
+GtkTextDirection
+gtk_widget_get_default_direction (void)
{
- if (!default_visual)
- default_visual = gdk_visual_get_system ();
-
- return default_visual;
+ return gtk_default_direction;
}
static void
-gtk_widget_shutdown (GtkObject *object)
+gtk_widget_shutdown (GObject *object)
{
- GtkWidget *widget;
-
- /* gtk_object_destroy() will already hold a refcount on object
- */
- widget = GTK_WIDGET (object);
+ GtkWidget *widget = GTK_WIDGET (object);
if (widget->parent)
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
if (GTK_WIDGET_REALIZED (widget))
gtk_widget_unrealize (widget);
- parent_class->shutdown (object);
+ G_OBJECT_CLASS (parent_class)->shutdown (object);
}
static void
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);
- widget->style = NULL;
+ widget->style = gtk_widget_peek_style ();
+ gtk_style_ref (widget->style);
- parent_class->destroy (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
-gtk_widget_finalize (GtkObject *object)
+gtk_widget_finalize (GObject *object)
{
- GtkWidget *widget;
+ GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetAuxInfo *aux_info;
gint *events;
GdkExtensionMode *mode;
+ GtkStyle *saved_style;
- widget = GTK_WIDGET (object);
-
+ gtk_grab_remove (widget);
+ gtk_selection_remove_all (widget);
+
+ 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), quark_saved_default_style);
+ }
+
+ gtk_style_unref (widget->style);
+ widget->style = NULL;
+
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);
- parent_class->finalize (object);
-}
-
-/*****************************************
- * gtk_widget_real_show:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static void
-gtk_widget_real_show (GtkWidget *widget)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (!GTK_WIDGET_VISIBLE (widget))
- {
- GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
-
- if (widget->parent)
- {
- gtk_widget_queue_resize (widget->parent);
-
- if (GTK_WIDGET_MAPPED (widget->parent))
- gtk_widget_map (widget);
- }
- }
-}
-
-/*****************************************
- * gtk_widget_real_hide:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static void
-gtk_widget_real_hide (GtkWidget *widget)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (GTK_WIDGET_VISIBLE (widget))
- {
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
-
- if (GTK_WIDGET_MAPPED (widget))
- gtk_widget_unmap (widget);
-
- if (widget->parent)
- gtk_widget_queue_resize (widget->parent);
- }
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
/*****************************************
static void
gtk_widget_real_map (GtkWidget *widget)
{
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (GTK_WIDGET_REALIZED (widget) == TRUE);
- if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
+ if (!GTK_WIDGET_MAPPED (widget))
{
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (!GTK_WIDGET_NO_WINDOW (widget))
gdk_window_show (widget->window);
- else
- gtk_widget_queue_draw (widget);
}
}
if (GTK_WIDGET_MAPPED (widget))
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- gtk_widget_queue_clear (widget);
- else
+
+ if (!GTK_WIDGET_NO_WINDOW (widget))
gdk_window_hide (widget->window);
}
}
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- /* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT(widget)->klass->type));
+ /* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT (widget)->klass->type));
*/
/* We must do unrealize child widget BEFORE container widget.
- * gdk_window_destroy() destroys specified xwindow and it's sub-xwindows.
- * So, unrealizing container widget bofore it's children causes the problem
+ * gdk_window_destroy() destroys specified xwindow and its sub-xwindows.
+ * So, unrealizing container widget bofore its children causes the problem
* (for example, gdk_ic_destroy () with destroyed window causes crash. )
*/
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- (GtkCallback) gtk_widget_unrealize,
- NULL);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_unrealize,
+ NULL);
gtk_style_detach (widget->style);
if (!GTK_WIDGET_NO_WINDOW (widget))
GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED);
}
-/*****************************************
- * gtk_widget_real_draw:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-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)
requisition->height = widget->requisition.height;
}
-static void
-gtk_widget_real_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
-{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (GTK_WIDGET_NO_WINDOW (widget) &&
- GTK_WIDGET_MAPPED (widget) &&
- ((widget->allocation.x != allocation->x) ||
- (widget->allocation.y != allocation->y) ||
- (widget->allocation.width != allocation->width) ||
- (widget->allocation.height != allocation->height)) &&
- (widget->allocation.width != 0) &&
- (widget->allocation.height != 0))
- gtk_widget_queue_clear (widget);
-
- widget->allocation = *allocation;
-
- if (GTK_WIDGET_REALIZED (widget) &&
- !GTK_WIDGET_NO_WINDOW (widget))
- {
- gdk_window_move_resize (widget->window,
- allocation->x, allocation->y,
- allocation->width, allocation->height);
- }
-}
-
/*****************************************
* gtk_widget_peek_colormap:
*
return gtk_widget_get_default_colormap ();
}
-/*****************************************
- * gtk_widget_peek_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static GdkVisual*
-gtk_widget_peek_visual (void)
-{
- if (visual_stack)
- return (GdkVisual*) visual_stack->data;
- return gtk_widget_get_default_visual ();
-}
-
static void
gtk_widget_propagate_state (GtkWidget *widget,
GtkStateData *data)
{
GtkWidget *window;
- window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
+ window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (window)
gtk_window_set_focus (GTK_WINDOW (window), NULL);
}
}
}
-/*****************************************
- * 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;
}
g_mem_chunk_free (aux_info_mem_chunk, aux_info);
}
+static void
+gtk_widget_shape_info_destroy (GtkWidgetShapeInfo *info)
+{
+ gdk_drawable_unref (info->shape_mask);
+ g_free (info);
+}
+
/*****************************************
* gtk_widget_shape_combine_mask:
* set a shape for this widgets' gdk window, this allows for
if (widget->window)
gdk_window_shape_combine_mask (widget->window, NULL, 0, 0);
- shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
- gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key);
- g_free (shape_info);
+ g_object_set_qdata (G_OBJECT (widget), quark_shape_info, NULL);
}
else
{
GTK_PRIVATE_SET_FLAG (widget, GTK_HAS_SHAPE_MASK);
- shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
- if (!shape_info)
- {
- shape_info = g_new (GtkWidgetShapeInfo, 1);
- gtk_object_set_data (GTK_OBJECT (widget), shape_info_key, shape_info);
- }
- shape_info->shape_mask = shape_mask;
+ shape_info = g_new (GtkWidgetShapeInfo, 1);
+ 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;
shape_info->offset_y = offset_y;
gtk_reset_shapes_recurse (GtkWidget *widget,
GdkWindow *window)
{
- GdkWindowPrivate *private;
gpointer data;
GList *list;
- private = (GdkWindowPrivate*) window;
-
- if (private->destroyed)
- return;
gdk_window_get_user_data (window, &data);
if (data != widget)
return;
gdk_window_shape_combine_mask (window, NULL, 0, 0);
- for (list = private->children; list; list = list->next)
+ for (list = gdk_window_peek_children (window); list; list = list->next)
gtk_reset_shapes_recurse (widget, list->data);
}
gtk_reset_shapes_recurse (widget, widget->window);
}
-void
+/**
+ * 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)
{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- gtk_object_ref ((GtkObject*) 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_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_object_unref ((GtkObject*) 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