* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <stdarg.h>
#include <string.h>
#include <locale.h>
PROP_NO_SHOW_ALL,
PROP_HAS_TOOLTIP,
PROP_TOOLTIP_MARKUP,
- PROP_TOOLTIP_TEXT
+ PROP_TOOLTIP_TEXT,
+ PROP_WINDOW,
+ PROP_DOUBLE_BUFFERED
};
typedef struct _GtkStateData GtkStateData;
GtkRequisition *requisition);
static void gtk_widget_real_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-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_style_set (GtkWidget *widget,
+ GtkStyle *previous_style);
+static void gtk_widget_real_direction_changed(GtkWidget *widget,
+ GtkTextDirection previous_direction);
static void gtk_widget_real_grab_focus (GtkWidget *focus_widget);
static gboolean gtk_widget_real_query_tooltip (GtkWidget *widget,
static void gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
GtkBuilder *builder);
+static void gtk_widget_queue_tooltip_query (GtkWidget *widget);
static void gtk_widget_set_usize_internal (GtkWidget *widget,
gint width,
static GQuark quark_event_mask = 0;
static GQuark quark_extension_event_mode = 0;
static GQuark quark_parent_window = 0;
+static GQuark quark_pointer_window = 0;
static GQuark quark_shape_info = 0;
static GQuark quark_input_shape_info = 0;
static GQuark quark_colormap = 0;
quark_event_mask = g_quark_from_static_string ("gtk-event-mask");
quark_extension_event_mode = g_quark_from_static_string ("gtk-extension-event-mode");
quark_parent_window = g_quark_from_static_string ("gtk-parent-window");
+ quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
quark_shape_info = g_quark_from_static_string ("gtk-shape-info");
quark_input_shape_info = g_quark_from_static_string ("gtk-input-shape-info");
quark_colormap = g_quark_from_static_string ("gtk-colormap");
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->style_set = gtk_widget_real_style_set;
+ klass->direction_changed = gtk_widget_real_direction_changed;
klass->grab_notify = NULL;
klass->child_notify = NULL;
klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
NULL,
GTK_PARAM_READWRITE));
+ /**
+ * GtkWidget:window:
+ *
+ * The widget's window if it is realized, %NULL otherwise.
+ *
+ * Since: 2.14
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_WINDOW,
+ g_param_spec_object ("window",
+ P_("Window"),
+ P_("The widget's window if it is realized"),
+ GDK_TYPE_WINDOW,
+ GTK_PARAM_READABLE));
+
+ /**
+ * GtkWidget:double-buffered
+ *
+ * Whether or not the widget is double buffered.
+ *
+ * Since: 2.18
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_DOUBLE_BUFFERED,
+ g_param_spec_boolean ("double-buffered",
+ P_("Double Buffered"),
+ P_("Whether or not the widget is double buffered"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
widget_signals[SHOW] =
g_signal_new (I_("show"),
G_TYPE_FROM_CLASS (gobject_class),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[SIZE_REQUEST] =
- g_signal_new (I_("size_request"),
+ g_signal_new (I_("size-request"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, size_request),
G_TYPE_NONE, 1,
GTK_TYPE_REQUISITION | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SIZE_ALLOCATE] =
- g_signal_new (I_("size_allocate"),
+ g_signal_new (I_("size-allocate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, size_allocate),
GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[STATE_CHANGED] =
- g_signal_new (I_("state_changed"),
+ g_signal_new (I_("state-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, state_changed),
* has been set on a widget.
*/
widget_signals[PARENT_SET] =
- g_signal_new (I_("parent_set"),
+ g_signal_new (I_("parent-set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, parent_set),
* a widget changes from un-anchored to anchored or vice-versa.
*/
widget_signals[HIERARCHY_CHANGED] =
- g_signal_new (I_("hierarchy_changed"),
+ g_signal_new (I_("hierarchy-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, hierarchy_changed),
* gtk_widget_modify_base() also cause this signal to be emitted.
*/
widget_signals[STYLE_SET] =
- g_signal_new (I_("style_set"),
+ g_signal_new (I_("style-set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, style_set),
* of a widget changes.
*/
widget_signals[DIRECTION_CHANGED] =
- g_signal_new (I_("direction_changed"),
+ g_signal_new (I_("direction-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, direction_changed),
* its ancestor.
*/
widget_signals[GRAB_NOTIFY] =
- g_signal_new (I_("grab_notify"),
+ g_signal_new (I_("grab-notify"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, grab_notify),
* changed on an object. The signal's detail holds the property name.
*/
widget_signals[CHILD_NOTIFY] =
- g_signal_new (I_("child_notify"),
+ g_signal_new (I_("child-notify"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (GtkWidgetClass, child_notify),
G_TYPE_NONE, 1,
G_TYPE_PARAM);
widget_signals[MNEMONIC_ACTIVATE] =
- g_signal_new (I_("mnemonic_activate"),
+ g_signal_new (I_("mnemonic-activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, mnemonic_activate),
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
widget_signals[GRAB_FOCUS] =
- g_signal_new (I_("grab_focus"),
+ g_signal_new (I_("grab-focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, grab_focus),
G_TYPE_BOOLEAN, 1,
GTK_TYPE_DIRECTION_TYPE);
widget_signals[MOVE_FOCUS] =
- _gtk_binding_signal_new (I_("move_focus"),
- G_TYPE_FROM_CLASS (object_class),
- G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_CALLBACK (gtk_widget_real_move_focus),
- NULL, NULL,
- _gtk_marshal_VOID__ENUM,
- G_TYPE_NONE,
- 1,
- GTK_TYPE_DIRECTION_TYPE);
+ g_signal_new_class_handler (I_("move-focus"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_CALLBACK (gtk_widget_real_move_focus),
+ NULL, NULL,
+ _gtk_marshal_VOID__ENUM,
+ G_TYPE_NONE,
+ 1,
+ GTK_TYPE_DIRECTION_TYPE);
/**
* GtkWidget::event:
* @widget: the object which received the signal.
*
*/
widget_signals[EVENT_AFTER] =
- g_signal_new (I_("event_after"),
+ g_signal_new (I_("event-after"),
G_TYPE_FROM_CLASS (gobject_class),
0,
0,
* %FALSE to propagate the event further.
*/
widget_signals[BUTTON_PRESS_EVENT] =
- g_signal_new (I_("button_press_event"),
+ g_signal_new (I_("button-press-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, button_press_event),
* %FALSE to propagate the event further.
*/
widget_signals[BUTTON_RELEASE_EVENT] =
- g_signal_new (I_("button_release_event"),
+ g_signal_new (I_("button-release-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, button_release_event),
* %FALSE to propagate the event further.
*/
widget_signals[SCROLL_EVENT] =
- g_signal_new (I_("scroll_event"),
+ g_signal_new (I_("scroll-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, scroll_event),
* %FALSE to propagate the event further.
*/
widget_signals[MOTION_NOTIFY_EVENT] =
- g_signal_new (I_("motion_notify_event"),
+ g_signal_new (I_("motion-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, motion_notify_event),
* See gdk_screen_is_composited().
*/
widget_signals[COMPOSITED_CHANGED] =
- g_signal_new (I_("composited_changed"),
+ g_signal_new (I_("composited-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, composited_changed),
* Since: 2.12
**/
widget_signals[KEYNAV_FAILED] =
- _gtk_binding_signal_new (I_("keynav-failed"),
- G_TYPE_FROM_CLASS (gobject_class),
- G_SIGNAL_RUN_LAST,
- G_CALLBACK (gtk_widget_real_keynav_failed),
- _gtk_boolean_handled_accumulator, NULL,
- _gtk_marshal_BOOLEAN__ENUM,
- G_TYPE_BOOLEAN, 1,
- GTK_TYPE_DIRECTION_TYPE);
+ g_signal_new_class_handler (I_("keynav-failed"),
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_CALLBACK (gtk_widget_real_keynav_failed),
+ _gtk_boolean_handled_accumulator, NULL,
+ _gtk_marshal_BOOLEAN__ENUM,
+ G_TYPE_BOOLEAN, 1,
+ GTK_TYPE_DIRECTION_TYPE);
/**
* GtkWidget::delete-event:
* %FALSE to propagate the event further.
*/
widget_signals[DELETE_EVENT] =
- g_signal_new (I_("delete_event"),
+ g_signal_new (I_("delete-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, delete_event),
* %FALSE to propagate the event further.
*/
widget_signals[DESTROY_EVENT] =
- g_signal_new (I_("destroy_event"),
+ g_signal_new (I_("destroy-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, destroy_event),
* %FALSE to propagate the event further.
*/
widget_signals[EXPOSE_EVENT] =
- g_signal_new (I_("expose_event"),
+ g_signal_new (I_("expose-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, expose_event),
* %FALSE to propagate the event further.
*/
widget_signals[KEY_PRESS_EVENT] =
- g_signal_new (I_("key_press_event"),
+ g_signal_new (I_("key-press-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, key_press_event),
* %FALSE to propagate the event further.
*/
widget_signals[KEY_RELEASE_EVENT] =
- g_signal_new (I_("key_release_event"),
+ g_signal_new (I_("key-release-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, key_release_event),
* %FALSE to propagate the event further.
*/
widget_signals[ENTER_NOTIFY_EVENT] =
- g_signal_new (I_("enter_notify_event"),
+ g_signal_new (I_("enter-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, enter_notify_event),
* %FALSE to propagate the event further.
*/
widget_signals[LEAVE_NOTIFY_EVENT] =
- g_signal_new (I_("leave_notify_event"),
+ g_signal_new (I_("leave-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, leave_notify_event),
* %FALSE to propagate the event further.
*/
widget_signals[CONFIGURE_EVENT] =
- g_signal_new (I_("configure_event"),
+ g_signal_new (I_("configure-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, configure_event),
* %FALSE to propagate the event further.
*/
widget_signals[FOCUS_IN_EVENT] =
- g_signal_new (I_("focus_in_event"),
+ g_signal_new (I_("focus-in-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus_in_event),
* %FALSE to propagate the event further.
*/
widget_signals[FOCUS_OUT_EVENT] =
- g_signal_new (I_("focus_out_event"),
+ g_signal_new (I_("focus-out-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus_out_event),
* %FALSE to propagate the event further.
*/
widget_signals[MAP_EVENT] =
- g_signal_new (I_("map_event"),
+ g_signal_new (I_("map-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, map_event),
* %FALSE to propagate the event further.
*/
widget_signals[UNMAP_EVENT] =
- g_signal_new (I_("unmap_event"),
+ g_signal_new (I_("unmap-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, unmap_event),
* %FALSE to propagate the event further.
*/
widget_signals[PROPERTY_NOTIFY_EVENT] =
- g_signal_new (I_("property_notify_event"),
+ g_signal_new (I_("property-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, property_notify_event),
* %FALSE to propagate the event further.
*/
widget_signals[SELECTION_CLEAR_EVENT] =
- g_signal_new (I_("selection_clear_event"),
+ g_signal_new (I_("selection-clear-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_clear_event),
* %FALSE to propagate the event further.
*/
widget_signals[SELECTION_REQUEST_EVENT] =
- g_signal_new (I_("selection_request_event"),
+ g_signal_new (I_("selection-request-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_request_event),
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_NOTIFY_EVENT] =
- g_signal_new (I_("selection_notify_event"),
+ g_signal_new (I_("selection-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_notify_event),
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_RECEIVED] =
- g_signal_new (I_("selection_received"),
+ g_signal_new (I_("selection-received"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_received),
G_TYPE_UINT);
widget_signals[SELECTION_GET] =
- g_signal_new (I_("selection_get"),
+ g_signal_new (I_("selection-get"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_get),
* %FALSE to propagate the event further.
*/
widget_signals[PROXIMITY_IN_EVENT] =
- g_signal_new (I_("proximity_in_event"),
+ g_signal_new (I_("proximity-in-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, proximity_in_event),
* %FALSE to propagate the event further.
*/
widget_signals[PROXIMITY_OUT_EVENT] =
- g_signal_new (I_("proximity_out_event"),
+ g_signal_new (I_("proximity-out-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, proximity_out_event),
* with gtk_drag_unhighlight()
*/
widget_signals[DRAG_LEAVE] =
- g_signal_new (I_("drag_leave"),
+ g_signal_new (I_("drag-leave"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_leave),
* The ::drag-begin signal is emitted on the drag source when a drag is
* started. A typical reason to connect to this signal is to set up a
* custom drag icon with gtk_drag_source_set_icon().
+ *
+ * Note that some widgets set up a drag icon in the default handler of
+ * this signal, so you may have to use g_signal_connect_after() to
+ * override what the default handler did.
*/
widget_signals[DRAG_BEGIN] =
- g_signal_new (I_("drag_begin"),
+ g_signal_new (I_("drag-begin"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_begin),
* things done in #GtkWidget::drag-begin.
*/
widget_signals[DRAG_END] =
- g_signal_new (I_("drag_end"),
+ g_signal_new (I_("drag-end"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_end),
* "delete" means depends on the context of the drag operation.
*/
widget_signals[DRAG_DATA_DELETE] =
- g_signal_new (I_("drag_data_delete"),
+ g_signal_new (I_("drag-data-delete"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_delete),
* Since: 2.12
*/
widget_signals[DRAG_FAILED] =
- g_signal_new (I_("drag_failed"),
+ g_signal_new (I_("drag-failed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
0, _gtk_boolean_handled_accumulator, NULL,
* ]|
*/
widget_signals[DRAG_MOTION] =
- g_signal_new (I_("drag_motion"),
+ g_signal_new (I_("drag-motion"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_motion),
* or more of the supported targets.
*/
widget_signals[DRAG_DROP] =
- g_signal_new (I_("drag_drop"),
+ g_signal_new (I_("drag-drop"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_drop),
* gtk_selection_data_set_text().
*/
widget_signals[DRAG_DATA_GET] =
- g_signal_new (I_("drag_data_get"),
+ g_signal_new (I_("drag-data-get"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_get),
* ]|
*/
widget_signals[DRAG_DATA_RECEIVED] =
- g_signal_new (I_("drag_data_received"),
+ g_signal_new (I_("drag-data-received"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_received),
* %FALSE to propagate the event further.
*/
widget_signals[VISIBILITY_NOTIFY_EVENT] =
- g_signal_new (I_("visibility_notify_event"),
+ g_signal_new (I_("visibility-notify-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, visibility_notify_event),
* the event. %FALSE to propagate the event further.
*/
widget_signals[CLIENT_EVENT] =
- g_signal_new (I_("client_event"),
+ g_signal_new (I_("client-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, client_event),
* %FALSE to propagate the event further.
*/
widget_signals[NO_EXPOSE_EVENT] =
- g_signal_new (I_("no_expose_event"),
+ g_signal_new (I_("no-expose-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, no_expose_event),
* event. %FALSE to propagate the event further.
*/
widget_signals[WINDOW_STATE_EVENT] =
- g_signal_new (I_("window_state_event"),
+ g_signal_new (I_("window-state-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, window_state_event),
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*
- * Since: 2.16
+ * Since: 2.14
*/
widget_signals[DAMAGE_EVENT] =
- g_signal_new ("damage_event",
+ g_signal_new (I_("damage-event"),
G_TYPE_FROM_CLASS (gobject_class),
- G_SIGNAL_RUN_LAST, 0,
+ G_SIGNAL_RUN_LAST,
+ 0,
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
* Since: 2.8
*/
widget_signals[GRAB_BROKEN] =
- g_signal_new (I_("grab_broken_event"),
+ g_signal_new (I_("grab-broken-event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, grab_broken_event),
* @keyboard_mode: %TRUE if the tooltip was trigged using the keyboard
* @tooltip: a #GtkTooltip
*
- * Emitted when the #GtkSettings:gtk-tooltip-timeout has expired with
- * the cursor hovering "above" @widget; or emitted when @widget got
+ * Emitted when #GtkWidget:has-tooltip is %TRUE and the #GtkSettings:gtk-tooltip-timeout
+ * has expired with the cursor hovering "above" @widget; or emitted when @widget got
* focus in keyboard mode.
*
* Using the given coordinates, the signal handler should determine
* Returns: %TRUE if a menu was activated
*/
widget_signals[POPUP_MENU] =
- g_signal_new (I_("popup_menu"),
+ g_signal_new (I_("popup-menu"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, popup_menu),
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
widget_signals[SHOW_HELP] =
- g_signal_new (I_("show_help"),
+ g_signal_new (I_("show-help"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, show_help),
G_TYPE_BOOLEAN, 1,
GTK_TYPE_WIDGET_HELP_TYPE);
widget_signals[ACCEL_CLOSURES_CHANGED] =
- g_signal_new (I_("accel_closures_changed"),
+ g_signal_new (I_("accel-closures-changed"),
G_TYPE_FROM_CLASS (gobject_class),
0,
0,
NULL, NULL,
- _gtk_marshal_NONE__NONE,
+ _gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* screen of a widget has changed.
*/
widget_signals[SCREEN_CHANGED] =
- g_signal_new (I_("screen_changed"),
+ g_signal_new (I_("screen-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, screen_changed),
* Returns: %TRUE if the signal can be activated.
*/
widget_signals[CAN_ACTIVATE_ACCEL] =
- g_signal_new (I_("can_activate_accel"),
+ g_signal_new (I_("can-activate-accel"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, can_activate_accel),
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set, GDK_F10, GDK_SHIFT_MASK,
- "popup_menu", 0);
+ "popup-menu", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Menu, 0,
- "popup_menu", 0);
+ "popup-menu", 0);
gtk_binding_entry_add_signal (binding_set, GDK_F1, GDK_CONTROL_MASK,
- "show_help", 1,
+ "show-help", 1,
GTK_TYPE_WIDGET_HELP_TYPE,
GTK_WIDGET_HELP_TOOLTIP);
gtk_binding_entry_add_signal (binding_set, GDK_KP_F1, GDK_CONTROL_MASK,
- "show_help", 1,
+ "show-help", 1,
GTK_TYPE_WIDGET_HELP_TYPE,
GTK_WIDGET_HELP_TOOLTIP);
gtk_binding_entry_add_signal (binding_set, GDK_F1, GDK_SHIFT_MASK,
- "show_help", 1,
+ "show-help", 1,
GTK_TYPE_WIDGET_HELP_TYPE,
GTK_WIDGET_HELP_WHATS_THIS);
gtk_binding_entry_add_signal (binding_set, GDK_KP_F1, GDK_SHIFT_MASK,
- "show_help", 1,
+ "show-help", 1,
GTK_TYPE_WIDGET_HELP_TYPE,
GTK_WIDGET_HELP_WHATS_THIS);
tooltip_window = g_object_get_qdata (object, quark_tooltip_window);
tooltip_markup = g_value_dup_string (value);
+ /* Treat an empty string as a NULL string,
+ * because an empty string would be useless for a tooltip:
+ */
+ if (tooltip_markup && (strlen (tooltip_markup) == 0))
+ {
+ g_free (tooltip_markup);
+ tooltip_markup = NULL;
+ }
+
g_object_set_qdata_full (object, quark_tooltip_markup,
tooltip_markup, g_free);
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
+ if (GTK_WIDGET_VISIBLE (widget))
+ gtk_widget_queue_tooltip_query (widget);
break;
case PROP_TOOLTIP_TEXT:
tooltip_window = g_object_get_qdata (object, quark_tooltip_window);
+
tooltip_text = g_value_get_string (value);
+
+ /* Treat an empty string as a NULL string,
+ * because an empty string would be useless for a tooltip:
+ */
+ if (tooltip_text && (strlen (tooltip_text) == 0))
+ tooltip_text = NULL;
+
tooltip_markup = tooltip_text ? g_markup_escape_text (tooltip_text, -1) : NULL;
g_object_set_qdata_full (object, quark_tooltip_markup,
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
+ if (GTK_WIDGET_VISIBLE (widget))
+ gtk_widget_queue_tooltip_query (widget);
+ break;
+ case PROP_DOUBLE_BUFFERED:
+ gtk_widget_set_double_buffered (widget, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
g_value_set_static_string (value, "");
break;
case PROP_PARENT:
- if (widget->parent)
- g_value_set_object (value, widget->parent);
- else
- g_value_set_object (value, NULL);
+ g_value_set_object (value, widget->parent);
break;
case PROP_WIDTH_REQUEST:
{
case PROP_TOOLTIP_MARKUP:
g_value_set_string (value, g_object_get_qdata (object, quark_tooltip_markup));
break;
+ case PROP_WINDOW:
+ g_value_set_object (value, gtk_widget_get_window (widget));
+ break;
+ case PROP_DOUBLE_BUFFERED:
+ g_value_set_boolean (value, gtk_widget_get_double_buffered (widget));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
*
* Precursor of g_object_set().
*
- * Deprecated: Use g_object_set() instead.
+ * Deprecated: 2.0: Use g_object_set() instead.
**/
void
gtk_widget_set (GtkWidget *widget,
{
gtk_widget_show (widget);
- g_signal_connect (widget, "map_event",
+ g_signal_connect (widget, "map-event",
G_CALLBACK (gtk_widget_show_map_callback),
&flag);
*rect = widget->allocation;
- gtk_widget_style_get (widget,
+ gtk_widget_style_get (widget,
"draw-border", &draw_border,
NULL);
if (draw_border)
{
- rect->x -= draw_border->top;
- rect->y -= draw_border->left;
+ rect->x -= draw_border->left;
+ rect->y -= draw_border->top;
rect->width += draw_border->left + draw_border->right;
rect->height += draw_border->top + draw_border->bottom;
* gtk_widget_queue_draw_area() would not. Now both functions ensure
* the background will be redrawn.
*
- * Deprecated: Use gtk_widget_queue_draw_area() instead.
+ * Deprecated: 2.2: Use gtk_widget_queue_draw_area() instead.
**/
void
gtk_widget_queue_clear_area (GtkWidget *widget,
*
* This function does the same as gtk_widget_queue_draw().
*
- * Deprecated: Use gtk_widget_queue_draw() instead.
+ * Deprecated: 2.2: Use gtk_widget_queue_draw() instead.
**/
void
gtk_widget_queue_clear (GtkWidget *widget)
* Even when you you aren't using #GtkUIManager, if you only want to
* set up accelerators on menu items gtk_menu_item_set_accel_path()
* provides a somewhat more convenient interface.
+ *
+ * Note that @accel_path string will be stored in a #GQuark. Therefore, if you
+ * pass a static string, you can save some memory by interning it first with
+ * g_intern_static_string().
**/
void
gtk_widget_set_accel_path (GtkWidget *widget,
return apath ? g_quark_to_string (apath->path_quark) : NULL;
}
+/**
+ * gtk_widget_mnemonic_activate:
+ * @widget: a #GtkWidget
+ * @group_cycling: %TRUE if there are other widgets with the same mnemonic
+ *
+ * Emits the #GtkWidget::mnemonic-activate signal.
+ *
+ * The default handler for this signal activates the @widget if
+ * @group_cycling is %FALSE, and just grabs the focus if @group_cycling
+ * is %TRUE.
+ *
+ * Returns: %TRUE if the signal has been handled
+ */
gboolean
gtk_widget_mnemonic_activate (GtkWidget *widget,
gboolean group_cycling)
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment)
{
+ guint signal_id;
+ GSignalQuery query;
+
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
if (hadjustment)
g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), FALSE);
if (vadjustment)
g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), FALSE);
- if (WIDGET_CLASS (widget)->set_scroll_adjustments_signal)
+ signal_id = WIDGET_CLASS (widget)->set_scroll_adjustments_signal;
+ if (!signal_id)
+ return FALSE;
+
+ g_signal_query (signal_id, &query);
+ if (!query.signal_id ||
+ !g_type_is_a (query.itype, GTK_TYPE_WIDGET) ||
+ query.return_type != G_TYPE_NONE ||
+ query.n_params != 2 ||
+ query.param_types[0] != GTK_TYPE_ADJUSTMENT ||
+ query.param_types[1] != GTK_TYPE_ADJUSTMENT)
{
- /* FIXME: we should eventually check the signals signature here */
- g_signal_emit (widget,
- WIDGET_CLASS (widget)->set_scroll_adjustments_signal, 0,
- hadjustment, vadjustment);
- return TRUE;
+ g_warning (G_STRLOC ": signal \"%s::%s\" has wrong signature",
+ G_OBJECT_TYPE_NAME (widget), query.signal_name);
+ return FALSE;
}
- else
- return FALSE;
+
+ g_signal_emit (widget, signal_id, 0, hadjustment, vadjustment);
+ return TRUE;
}
static void
*
* 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.)
+ * something like #GtkFrame won't work.
+ *
+ * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+ * gtk_widget_set_can_focus() to modify that flag.
**/
void
gtk_widget_grab_focus (GtkWidget *widget)
* be set by the next loop.
*/
toplevel = gtk_widget_get_toplevel (focus_widget);
- if (GTK_WIDGET_TOPLEVEL (toplevel))
+ if (GTK_WIDGET_TOPLEVEL (toplevel) && GTK_IS_WINDOW (toplevel))
{
widget = GTK_WINDOW (toplevel)->focus_widget;
return TRUE;
}
+/**
+ * gtk_widget_set_can_focus:
+ * @widget: a #GtkWidget
+ * @can_focus: whether or not @widget can own the input focus.
+ *
+ * Specifies whether @widget can own the input focus. See
+ * gtk_widget_grab_focus() for actually setting the input focus on a
+ * widget.
+ *
+ * Since: 2.18
+ **/
+void
+gtk_widget_set_can_focus (GtkWidget *widget,
+ gboolean can_focus)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (can_focus != GTK_WIDGET_CAN_FOCUS (widget))
+ {
+ if (can_focus)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
+
+ gtk_widget_queue_resize (widget);
+ g_object_notify (G_OBJECT (widget), "can-focus");
+ }
+}
+
+/**
+ * gtk_widget_get_can_focus:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget can own the input focus. See
+ * gtk_widget_set_can_focus().
+ *
+ * Return value: %TRUE if @widget can own the input focus, %FALSE otherwise
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_can_focus (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_CAN_FOCUS (widget);
+}
+
+/**
+ * gtk_widget_has_focus:
+ * @widget: a #GtkWidget
+ *
+ * Determines if the widget has the global input focus. See
+ * gtk_widget_is_focus() for the difference between having the global
+ * input focus, and only having the focus within a toplevel.
+ *
+ * Return value: %TRUE if the widget has the global input focus.
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_has_focus (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_HAS_FOCUS (widget);
+}
+
/**
* gtk_widget_is_focus:
* @widget: a #GtkWidget
return FALSE;
}
+/**
+ * gtk_widget_set_can_default:
+ * @widget: a #GtkWidget
+ * @can_default: whether or not @widget can be a default widget.
+ *
+ * Specifies whether @widget can be a default widget. See
+ * gtk_widget_grab_default() for details about the meaning of
+ * "default".
+ *
+ * Since: 2.18
+ **/
+void
+gtk_widget_set_can_default (GtkWidget *widget,
+ gboolean can_default)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (can_default != GTK_WIDGET_CAN_DEFAULT (widget))
+ {
+ if (can_default)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
+
+ gtk_widget_queue_resize (widget);
+ g_object_notify (G_OBJECT (widget), "can-default");
+ }
+}
+
+/**
+ * gtk_widget_get_can_default:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget can be a default widget. See
+ * gtk_widget_set_can_default().
+ *
+ * Return value: %TRUE if @widget can be a default widget, %FALSE otherwise
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_can_default (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_CAN_DEFAULT (widget);
+}
+
+/**
+ * gtk_widget_has_default:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget is the current default widget within its
+ * toplevel. See gtk_widget_set_can_default().
+ *
+ * Return value: %TRUE if @widget is the current default widget within
+ * its toplevel, %FALSE otherwise
+ *
+ * Since: 2.18
+ */
+gboolean
+gtk_widget_has_default (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_HAS_DEFAULT (widget);
+}
+
/**
* 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 <literal>GTK_WIDGET_SET_FLAGS (@widget,
- * GTK_CAN_DEFAULT)</literal>. The default widget is activated when
+ * yourself by calling <literal>gtk_widget_set_can_default (@widget,
+ * %TRUE)</literal>. 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.
**/
g_warning (G_STRLOC ": widget not within a GtkWindow");
}
+/**
+ * gtk_widget_has_grab:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether the widget is currently grabbing events, so it
+ * is the only widget receiving input events (keyboard and mouse).
+ *
+ * See also gtk_grab_add().
+ *
+ * Return value: %TRUE if the widget is in the grab_widgets stack
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_has_grab (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (GTK_WIDGET_FLAGS (widget) & GTK_HAS_GRAB) != 0;
+}
+
/**
* gtk_widget_set_name:
* @widget: a #GtkWidget
}
}
+/**
+ * gtk_widget_get_state:
+ * @widget: a #GtkWidget
+ *
+ * Returns the widget's state. See gtk_widget_set_state().
+ *
+ * Returns: the state of @widget.
+ *
+ * Since: 2.18
+ */
+GtkStateType
+gtk_widget_get_state (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_STATE_NORMAL);
+
+ return widget->state;
+}
+
+/**
+ * gtk_widget_set_visible:
+ * @widget: a #GtkWidget
+ * @visible: whether the widget should be shown or not
+ *
+ * Sets the visibility state of @widget. Note that setting this to
+ * %TRUE doesn't mean the widget is actually viewable, see
+ * gtk_widget_get_visible().
+ *
+ * This function simply calls gtk_widget_show() or gtk_widget_hide()
+ * but is nicer to use when the visibility of the widget depends on
+ * some condition.
+ *
+ * Since: 2.18
+ **/
+void
+gtk_widget_set_visible (GtkWidget *widget,
+ gboolean visible)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (visible != GTK_WIDGET_VISIBLE (widget))
+ {
+ if (visible)
+ gtk_widget_show (widget);
+ else
+ gtk_widget_hide (widget);
+ }
+}
+
+/**
+ * gtk_widget_get_visible:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether the widget is visible. Note that this doesn't
+ * take into account whether the widget's parent is also visible
+ * or the widget is obscured in any way.
+ *
+ * See gtk_widget_set_visible().
+ *
+ * Return value: %TRUE if the widget is visible
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_visible (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0;
+}
+
+/**
+ * gtk_widget_set_has_window:
+ * @widget: a #GtkWidget
+ * @has_window: whether or not @widget has a window.
+ *
+ * Specifies whether @widget has a #GdkWindow of its own. Note that
+ * all realized widgets have a non-%NULL "window" pointer
+ * (gtk_widget_get_window() never returns a %NULL window when a widget
+ * is realized), but for many of them it's actually the #GdkWindow of
+ * one of its parent widgets. Widgets that create a %window for
+ * themselves in GtkWidget::realize() however must announce this by
+ * calling this function with @has_window = %TRUE.
+ *
+ * This function should only be called by widget implementations,
+ * and they should call it in their init() function.
+ *
+ * Since: 2.18
+ **/
+void
+gtk_widget_set_has_window (GtkWidget *widget,
+ gboolean has_window)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (has_window)
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_NO_WINDOW);
+ else
+ GTK_WIDGET_SET_FLAGS (widget, GTK_NO_WINDOW);
+}
+
+/**
+ * gtk_widget_get_has_window:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget has a #GdkWindow of its own. See
+ * gtk_widget_set_has_window().
+ *
+ * Return value: %TRUE if @widget has a window, %FALSE otherwise
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_has_window (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return !GTK_WIDGET_NO_WINDOW (widget);
+}
+
+/**
+ * gtk_widget_is_toplevel:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget is a toplevel widget. Currently only
+ * #GtkWindow and #GtkInvisible are toplevel widgets. Toplevel
+ * widgets have no parent widget.
+ *
+ * Return value: %TRUE if @widget is a toplevel, %FALSE otherwise
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_is_toplevel (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (GTK_WIDGET_FLAGS (widget) & GTK_TOPLEVEL) != 0;
+}
+
+/**
+ * gtk_widget_is_drawable:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether @widget can be drawn to. A widget can be drawn
+ * to if it is mapped and visible.
+ *
+ * Return value: %TRUE if @widget is drawable, %FALSE otherwise
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_is_drawable (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return ((GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0 &&
+ (GTK_WIDGET_FLAGS (widget) & GTK_MAPPED) != 0);
+}
/**
* gtk_widget_set_app_paintable:
}
}
+/**
+ * gtk_widget_get_app_paintable:
+ * @widget: a #GtkWidget
+ *
+ * Determines whether the application intends to draw on the widget in
+ * an #GtkWidget::expose-event handler.
+ *
+ * See gtk_widget_set_app_paintable()
+ *
+ * Return value: %TRUE if the widget is app paintable
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_app_paintable (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (GTK_WIDGET_FLAGS (widget) & GTK_APP_PAINTABLE) != 0;
+}
+
/**
* gtk_widget_set_double_buffered:
* @widget: a #GtkWidget
{
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);
+ if (double_buffered != GTK_WIDGET_DOUBLE_BUFFERED (widget))
+ {
+ if (double_buffered)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+
+ g_object_notify (G_OBJECT (widget), "double-buffered");
+ }
}
/**
- * gtk_widget_set_redraw_on_allocate:
+ * gtk_widget_get_double_buffered:
* @widget: a #GtkWidget
- * @redraw_on_allocate: if %TRUE, the entire widget will be redrawn
- * when it is allocated to a new size. Otherwise, only the
- * new portion of the widget will be redrawn.
*
- * Sets whether the entire widget is queued for drawing when its size
- * allocation changes. By default, this setting is %TRUE and
- * the entire widget is redrawn on every size change. If your widget
- * leaves the upper left unchanged when made bigger, turning this
+ * Determines whether the widget is double buffered.
+ *
+ * See gtk_widget_set_double_buffered()
+ *
+ * Return value: %TRUE if the widget is double buffered
+ *
+ * Since: 2.18
+ **/
+gboolean
+gtk_widget_get_double_buffered (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (GTK_WIDGET_FLAGS (widget) & GTK_DOUBLE_BUFFERED) != 0;
+}
+
+/**
+ * gtk_widget_set_redraw_on_allocate:
+ * @widget: a #GtkWidget
+ * @redraw_on_allocate: if %TRUE, the entire widget will be redrawn
+ * when it is allocated to a new size. Otherwise, only the
+ * new portion of the widget will be redrawn.
+ *
+ * Sets whether the entire widget is queued for drawing when its size
+ * allocation changes. By default, this setting is %TRUE and
+ * the entire widget is redrawn on every size change. If your widget
+ * leaves the upper left unchanged when made bigger, turning this
* setting off will improve performance.
* Note that for %NO_WINDOW widgets setting this flag to %FALSE turns
g_object_notify (G_OBJECT (widget), "sensitive");
}
+/**
+ * gtk_widget_get_sensitive:
+ * @widget: a #GtkWidget
+ *
+ * Returns the widget's sensitivity (in the sense of returning
+ * the value that has been set using gtk_widget_set_sensitive()).
+ *
+ * The effective sensitivity of a widget is however determined by both its
+ * own and its parent widget's sensitivity. See gtk_widget_is_sensitive().
+ *
+ * Returns: %TRUE if the widget is sensitive
+ *
+ * Since: 2.18
+ */
+gboolean
+gtk_widget_get_sensitive (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_SENSITIVE (widget);
+}
+
+/**
+ * gtk_widget_is_sensitive:
+ * @widget: a #GtkWidget
+ *
+ * Returns the widget's effective sensitivity, which means
+ * it is sensitive itself and also its parent widget is sensntive
+ *
+ * Returns: %TRUE if the widget is effectively sensitive
+ *
+ * Since: 2.18
+ */
+gboolean
+gtk_widget_is_sensitive (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return GTK_WIDGET_IS_SENSITIVE (widget);
+}
+
/**
* gtk_widget_set_parent:
* @widget: a #GtkWidget
g_object_set_qdata_full (G_OBJECT (widget),
quark_rc_style,
gtk_rc_style_copy (style),
- (GDestroyNotify) gtk_rc_style_unref);
+ (GDestroyNotify) g_object_unref);
/* note that "style" may be invalid here if it was the old
* modifier style and the only reference was our own.
g_object_set_qdata_full (G_OBJECT (widget),
quark_rc_style,
rc_style,
- (GDestroyNotify) gtk_rc_style_unref);
+ (GDestroyNotify) g_object_unref);
}
return rc_style;
}
static void
-gtk_widget_direction_changed (GtkWidget *widget,
- GtkTextDirection previous_direction)
+gtk_widget_real_direction_changed (GtkWidget *widget,
+ GtkTextDirection previous_direction)
{
gtk_widget_queue_resize (widget);
}
static void
-gtk_widget_style_set (GtkWidget *widget,
- GtkStyle *previous_style)
+gtk_widget_real_style_set (GtkWidget *widget,
+ GtkStyle *previous_style)
{
if (GTK_WIDGET_REALIZED (widget) &&
!GTK_WIDGET_NO_WINDOW (widget))
*
* Please note that the semantics of this call will change
* in the future if used on a widget that has a composited
- * window in its heirarchy (as set by
- * gdk_window_set_composited()).
+ * window in its hierarchy (as set by gdk_window_set_composited()).
*
* Return value: %TRUE if the widget can rely on its alpha
* channel being drawn correctly.
}
}
+/**
+ * gtk_widget_get_parent_window:
+ * @widget: a #GtkWidget.
+ * @returns: the parent window of @widget.
+ *
+ * Gets @widget's parent window.
+ **/
+GdkWindow *
+gtk_widget_get_parent_window (GtkWidget *widget)
+{
+ GdkWindow *parent_window;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ parent_window = g_object_get_qdata (G_OBJECT (widget), quark_parent_window);
+
+ return (parent_window != NULL) ? parent_window :
+ (widget->parent != NULL) ? widget->parent->window : NULL;
+}
+
/**
* gtk_widget_set_child_visible:
*
* Checks whether there is a #GdkScreen is associated with
* this widget. All toplevel widgets have an associated
- * screen, and all widgets added into a heirarchy with a toplevel
+ * screen, and all widgets added into a hierarchy with a toplevel
* window at the top.
*
* Return value: %TRUE if there is a #GdkScreen associcated
*
* Get the root window where this widget is located. This function can
* only be called after the widget has been added to a widget
- * heirarchy with #GtkWindow at the top.
+ * hierarchy with #GtkWindow at the top.
*
* The root window is useful for such purposes as creating a popup
* #GdkWindow associated with the window. In general, you should only
return gdk_screen_get_root_window (gtk_widget_get_screen (widget));
}
-/**
- * gtk_widget_get_parent_window:
- * @widget: a #GtkWidget.
- * @returns: the parent window of @widget.
- *
- * Gets @widget's parent window.
- **/
-GdkWindow *
-gtk_widget_get_parent_window (GtkWidget *widget)
-{
- GdkWindow *parent_window;
-
- g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
-
- parent_window = g_object_get_qdata (G_OBJECT (widget), quark_parent_window);
-
- return (parent_window != NULL) ? parent_window :
- (widget->parent != NULL) ? widget->parent->window : NULL;
-}
-
/**
* gtk_widget_child_focus:
* @widget: a #GtkWidget
void
gtk_widget_error_bell (GtkWidget *widget)
{
+ GtkSettings* settings;
gboolean beep;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_object_get (gtk_widget_get_settings (widget),
+ settings = gtk_widget_get_settings (widget);
+ if (!settings)
+ return;
+
+ g_object_get (settings,
"gtk-error-bell", &beep,
NULL);
* basically impossible to hardcode a size that will always be
* correct.
*
- * Deprecated: Use gtk_widget_set_size_request() instead.
+ * Deprecated: 2.2: Use gtk_widget_set_size_request() instead.
**/
void
gtk_widget_set_usize (GtkWidget *widget,
/**
* gtk_widget_get_composite_name:
* @widget: a #GtkWidget
- * @returns: the composite name of @widget, or %NULL if @widget is not
- * a composite child. The string should not be freed when it is no
- * longer needed.
*
* Obtains the composite name of a widget.
+ *
+ * Returns: the composite name of @widget, or %NULL if @widget is not
+ * a composite child. The string should be freed when it is no
+ * longer needed.
**/
gchar*
gtk_widget_get_composite_name (GtkWidget *widget)
return NULL;
}
+/*
+ * _gtk_widget_set_pointer_window:
+ * @widget: a #GtkWidget.
+ * @pointer_window: the new pointer window.
+ *
+ * Sets pointer window for @widget. Does not ref @pointer_window.
+ * Actually stores it on the #GdkScreen, but you don't need to know that.
+ */
+void
+_gtk_widget_set_pointer_window (GtkWidget *widget,
+ GdkWindow *pointer_window)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (GTK_WIDGET_REALIZED (widget))
+ {
+ GdkScreen *screen = gdk_drawable_get_screen (widget->window);
+
+ g_object_set_qdata (G_OBJECT (screen), quark_pointer_window,
+ pointer_window);
+ }
+}
+
+/*
+ * _gtk_widget_get_pointer_window:
+ * @widget: a #GtkWidget.
+ *
+ * Return value: the pointer window set on the #GdkScreen @widget is attached
+ * to, or %NULL.
+ */
+GdkWindow *
+_gtk_widget_get_pointer_window (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ if (GTK_WIDGET_REALIZED (widget))
+ {
+ GdkScreen *screen = gdk_drawable_get_screen (widget->window);
+
+ return g_object_get_qdata (G_OBJECT (screen), quark_pointer_window);
+ }
+
+ return NULL;
+}
+
+static void
+synth_crossing (GtkWidget *widget,
+ GdkEventType type,
+ GdkWindow *window,
+ GdkCrossingMode mode,
+ GdkNotifyType detail)
+{
+ GdkEvent *event;
+
+ event = gdk_event_new (type);
+
+ event->crossing.window = g_object_ref (window);
+ event->crossing.send_event = TRUE;
+ event->crossing.subwindow = g_object_ref (window);
+ event->crossing.time = GDK_CURRENT_TIME;
+ event->crossing.x = event->crossing.y = 0;
+ event->crossing.x_root = event->crossing.y_root = 0;
+ event->crossing.mode = mode;
+ event->crossing.detail = detail;
+ event->crossing.focus = FALSE;
+ event->crossing.state = 0;
+
+ if (!widget)
+ widget = gtk_get_event_widget (event);
+
+ if (widget)
+ gtk_widget_event_internal (widget, event);
+
+ gdk_event_free (event);
+}
+
+/*
+ * _gtk_widget_is_pointer_widget:
+ * @widget: a #GtkWidget
+ *
+ * Returns %TRUE if the pointer window belongs to @widget.
+ */
+gboolean
+_gtk_widget_is_pointer_widget (GtkWidget *widget)
+{
+ if (GTK_WIDGET_HAS_POINTER (widget))
+ {
+ GdkWindow *win;
+ GtkWidget *wid;
+
+ win = _gtk_widget_get_pointer_window (widget);
+ if (win)
+ {
+ gdk_window_get_user_data (win, (gpointer *)&wid);
+ if (wid == widget)
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/*
+ * _gtk_widget_synthesize_crossing:
+ * @from: the #GtkWidget the virtual pointer is leaving.
+ * @to: the #GtkWidget the virtual pointer is moving to.
+ * @mode: the #GdkCrossingMode to place on the synthesized events.
+ *
+ * Generate crossing event(s) on widget state (sensitivity) or GTK+ grab change.
+ *
+ * The real pointer window is the window that most recently received an enter notify
+ * event. Windows that don't select for crossing events can't become the real
+ * poiner window. The real pointer widget that owns the real pointer window. The
+ * effective pointer window is the same as the real pointer window unless the real
+ * pointer widget is either insensitive or there is a grab on a widget that is not
+ * an ancestor of the real pointer widget (in which case the effective pointer
+ * window should be the root window).
+ *
+ * When the effective pointer window is the same as the real poiner window, we
+ * receive crossing events from the windowing system. When the effective pointer
+ * window changes to become different from the real pointer window we synthesize
+ * crossing events, attempting to follow X protocol rules:
+ *
+ * When the root window becomes the effective pointer window:
+ * - leave notify on real pointer window, detail Ancestor
+ * - leave notify on all of its ancestors, detail Virtual
+ * - enter notify on root window, detail Inferior
+ *
+ * When the root window ceases to be the effective pointer window:
+ * - leave notify on root window, detail Inferior
+ * - enter notify on all ancestors of real pointer window, detail Virtual
+ * - enter notify on real pointer window, detail Ancestor
+ */
+void
+_gtk_widget_synthesize_crossing (GtkWidget *from,
+ GtkWidget *to,
+ GdkCrossingMode mode)
+{
+ GdkWindow *from_window = NULL, *to_window = NULL;
+
+ g_return_if_fail (from != NULL || to != NULL);
+
+ if (from != NULL)
+ from_window = GTK_WIDGET_HAS_POINTER (from)
+ ? _gtk_widget_get_pointer_window (from) : from->window;
+ if (to != NULL)
+ to_window = GTK_WIDGET_HAS_POINTER (to)
+ ? _gtk_widget_get_pointer_window (to) : to->window;
+
+ if (from_window == NULL && to_window == NULL)
+ ;
+ else if (from_window != NULL && to_window == NULL)
+ {
+ GList *from_ancestors = NULL, *list;
+ GdkWindow *from_ancestor = from_window;
+
+ while (from_ancestor != NULL)
+ {
+ from_ancestor = gdk_window_get_parent (from_ancestor);
+ if (from_ancestor == NULL)
+ break;
+ from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
+ }
+
+ synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
+ mode, GDK_NOTIFY_ANCESTOR);
+ for (list = g_list_last (from_ancestors); list; list = list->prev)
+ {
+ synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_VIRTUAL);
+ }
+
+ /* XXX: enter/inferior on root window? */
+
+ g_list_free (from_ancestors);
+ }
+ else if (from_window == NULL && to_window != NULL)
+ {
+ GList *to_ancestors = NULL, *list;
+ GdkWindow *to_ancestor = to_window;
+
+ while (to_ancestor != NULL)
+ {
+ to_ancestor = gdk_window_get_parent (to_ancestor);
+ if (to_ancestor == NULL)
+ break;
+ to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
+ }
+
+ /* XXX: leave/inferior on root window? */
+
+ for (list = to_ancestors; list; list = list->next)
+ {
+ synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_VIRTUAL);
+ }
+ synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
+ mode, GDK_NOTIFY_ANCESTOR);
+
+ g_list_free (to_ancestors);
+ }
+ else if (from_window == to_window)
+ ;
+ else
+ {
+ GList *from_ancestors = NULL, *to_ancestors = NULL, *list;
+ GdkWindow *from_ancestor = from_window, *to_ancestor = to_window;
+
+ while (from_ancestor != NULL || to_ancestor != NULL)
+ {
+ if (from_ancestor != NULL)
+ {
+ from_ancestor = gdk_window_get_parent (from_ancestor);
+ if (from_ancestor == to_window)
+ break;
+ if (from_ancestor)
+ from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
+ }
+ if (to_ancestor != NULL)
+ {
+ to_ancestor = gdk_window_get_parent (to_ancestor);
+ if (to_ancestor == from_window)
+ break;
+ if (to_ancestor)
+ to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
+ }
+ }
+ if (to_ancestor == from_window)
+ {
+ if (mode != GDK_CROSSING_GTK_UNGRAB)
+ synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
+ mode, GDK_NOTIFY_INFERIOR);
+ for (list = to_ancestors; list; list = list->next)
+ synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_VIRTUAL);
+ synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
+ mode, GDK_NOTIFY_ANCESTOR);
+ }
+ else if (from_ancestor == to_window)
+ {
+ synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
+ mode, GDK_NOTIFY_ANCESTOR);
+ for (list = g_list_last (from_ancestors); list; list = list->prev)
+ {
+ synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_VIRTUAL);
+ }
+ if (mode != GDK_CROSSING_GTK_GRAB)
+ synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
+ mode, GDK_NOTIFY_INFERIOR);
+ }
+ else
+ {
+ while (from_ancestors != NULL && to_ancestors != NULL
+ && from_ancestors->data == to_ancestors->data)
+ {
+ from_ancestors = g_list_delete_link (from_ancestors,
+ from_ancestors);
+ to_ancestors = g_list_delete_link (to_ancestors, to_ancestors);
+ }
+
+ synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
+ mode, GDK_NOTIFY_NONLINEAR);
+
+ for (list = g_list_last (from_ancestors); list; list = list->prev)
+ {
+ synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
+ }
+ for (list = to_ancestors; list; list = list->next)
+ {
+ synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
+ mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
+ }
+ synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
+ mode, GDK_NOTIFY_NONLINEAR);
+ }
+ g_list_free (from_ancestors);
+ g_list_free (to_ancestors);
+ }
+}
+
static void
gtk_widget_propagate_state (GtkWidget *widget,
GtkStateData *data)
g_signal_emit (widget, widget_signals[STATE_CHANGED], 0, old_state);
+ if (GTK_WIDGET_HAS_POINTER (widget) && !GTK_WIDGET_SHADOWED (widget))
+ {
+ if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ _gtk_widget_synthesize_crossing (widget, NULL,
+ GDK_CROSSING_STATE_CHANGED);
+ else if (old_state == GTK_STATE_INSENSITIVE)
+ _gtk_widget_synthesize_crossing (NULL, widget,
+ GDK_CROSSING_STATE_CHANGED);
+ }
+
if (GTK_IS_CONTAINER (widget))
{
data->parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget) != FALSE);
}
}
-/**
+/*
* _gtk_widget_get_aux_info:
* @widget: a #GtkWidget
* @create: if %TRUE, create the structure if it doesn't exist
*
* 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)
*
* Return value: the widget that was referenced
*
- * Deprecated:2.12: Use g_object_ref() instead.
+ * Deprecated: 2.12: Use g_object_ref() instead.
**/
GtkWidget*
gtk_widget_ref (GtkWidget *widget)
*
* Inverse of gtk_widget_ref(). Equivalent to g_object_unref().
*
- * Deprecated:2.12: Use g_object_unref() instead.
+ * Deprecated: 2.12: Use g_object_unref() instead.
**/
void
gtk_widget_unref (GtkWidget *widget)
g_object_unref ((GObject*) widget);
}
+static void
+expose_window (GdkWindow *window)
+{
+ GdkEvent event;
+ GList *l, *children;
+ gpointer user_data;
+ gboolean is_double_buffered;
+
+ gdk_window_get_user_data (window, &user_data);
+
+ if (user_data)
+ is_double_buffered = GTK_WIDGET_DOUBLE_BUFFERED (GTK_WIDGET (user_data));
+ else
+ is_double_buffered = FALSE;
+
+ event.expose.type = GDK_EXPOSE;
+ event.expose.window = g_object_ref (window);
+ event.expose.send_event = FALSE;
+ event.expose.count = 0;
+ event.expose.area.x = 0;
+ event.expose.area.y = 0;
+ gdk_drawable_get_size (GDK_DRAWABLE (window),
+ &event.expose.area.width,
+ &event.expose.area.height);
+ event.expose.region = gdk_region_rectangle (&event.expose.area);
+
+ /* If this is not double buffered, force a double buffer so that
+ redirection works. */
+ if (!is_double_buffered)
+ gdk_window_begin_paint_region (window, event.expose.region);
+
+ gtk_main_do_event (&event);
+
+ if (!is_double_buffered)
+ gdk_window_end_paint (window);
+
+ children = gdk_window_peek_children (window);
+ for (l = children; l != NULL; l = l->next)
+ {
+ GdkWindow *child = l->data;
+
+ /* Don't expose input-only windows */
+ if (gdk_drawable_get_depth (GDK_DRAWABLE (child)) != 0)
+ expose_window (l->data);
+ }
+
+ g_object_unref (window);
+}
+
/**
* gtk_widget_get_snapshot:
* @widget: a #GtkWidget
GdkPixmap *pixmap;
GList *windows = NULL, *list;
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ if (!GTK_WIDGET_VISIBLE (widget))
+ return NULL;
+
/* the widget (and parent_window) must be realized to be drawable */
if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
gtk_widget_realize (widget->parent);
{
GdkWindow *subwin = list->data;
int wx, wy;
+ if (gdk_drawable_get_depth (GDK_DRAWABLE (subwin)) == 0)
+ continue; /* Input only window */
gdk_window_get_position (subwin, &wx, &wy);
gdk_window_redirect_to_drawable (subwin, pixmap, MAX (0, x - wx), MAX (0, y - wy),
MAX (0, wx - x), MAX (0, wy - y), width, height);
- gdk_window_invalidate_rect (subwin, NULL, TRUE);
+
+ expose_window (subwin);
}
if (!windows) /* NO_WINDOW || toplevel => parent_window == NULL || parent_window == widget->window */
{
gdk_window_redirect_to_drawable (widget->window, pixmap, x, y, 0, 0, width, height);
- gdk_window_invalidate_rect (widget->window, NULL, TRUE);
+ expose_window (widget->window);
}
- gtk_widget_queue_draw (widget);
- if (parent_window)
- gdk_window_process_updates (parent_window, TRUE);
- for (list = windows; list; list = list->next)
- gdk_window_process_updates (list->data, TRUE);
- gdk_window_process_updates (widget->window, TRUE);
for (list = windows; list; list = list->next)
gdk_window_remove_redirection (list->data);
if (!windows) /* NO_WINDOW || toplevel */
g_object_set_property (G_OBJECT (buildable), name, value);
}
-typedef struct {
+typedef struct
+{
gchar *action_name;
- gchar *description;
+ GString *description;
+ gchar *context;
+ gboolean translatable;
} AtkActionData;
-
-typedef struct {
+
+typedef struct
+{
gchar *target;
gchar *type;
} AtkRelationData;
free_action (AtkActionData *data, gpointer user_data)
{
g_free (data->action_name);
- g_free (data->description);
+ g_string_free (data->description, TRUE);
+ g_free (data->context);
g_slice_free (AtkActionData, data);
}
GtkBuilder *builder)
{
GSList *atk_relations;
-
+
if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_default))
gtk_widget_grab_default (GTK_WIDGET (buildable));
if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_focus))
GObject *target;
AtkRelationType relation_type;
AtkObject *target_accessible;
-
+
accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
relation_set = atk_object_ref_relation_set (accessible);
for (l = atk_relations; l; l = l->next)
{
AtkRelationData *relation = (AtkRelationData*)l->data;
-
+
target = gtk_builder_get_object (builder, relation->target);
if (!target)
{
}
target_accessible = gtk_widget_get_accessible (GTK_WIDGET (target));
g_assert (target_accessible != NULL);
-
+
relation_type = atk_relation_type_for_name (relation->type);
if (relation_type == ATK_RELATION_NULL)
{
g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
NULL);
}
-
}
-typedef struct {
+typedef struct
+{
GSList *actions;
GSList *relations;
} AccessibilitySubParserData;
static void
-accessibility_start_element (GMarkupParseContext *context,
- const gchar *element_name,
- const gchar **names,
- const gchar **values,
- gpointer user_data,
- GError **error)
+accessibility_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **names,
+ const gchar **values,
+ gpointer user_data,
+ GError **error)
{
AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
guint i;
gchar *target = NULL;
gchar *type = NULL;
AtkRelationData *relation;
-
+
for (i = 0; names[i]; i++)
{
if (strcmp (names[i], "target") == 0)
relation = g_slice_new (AtkRelationData);
relation->target = target;
relation->type = type;
-
+
data->relations = g_slist_prepend (data->relations, relation);
}
else if (strcmp (element_name, "action") == 0)
{
- gchar *action_name = NULL;
- gchar *description = NULL;
+ const gchar *action_name = NULL;
+ const gchar *description = NULL;
+ const gchar *msg_context = NULL;
+ gboolean translatable = FALSE;
AtkActionData *action;
-
+
for (i = 0; names[i]; i++)
{
if (strcmp (names[i], "action_name") == 0)
- action_name = g_strdup (values[i]);
+ action_name = values[i];
else if (strcmp (names[i], "description") == 0)
- description = g_strdup (values[i]);
+ description = values[i];
+ else if (strcmp (names[i], "translatable") == 0)
+ {
+ if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
+ return;
+ }
+ else if (strcmp (names[i], "comments") == 0)
+ {
+ /* do nothing, comments are for translators */
+ }
+ else if (strcmp (names[i], "context") == 0)
+ msg_context = values[i];
else
{
g_markup_parse_context_get_position (context,
"%s:%d:%d '%s' is not a valid attribute of <%s>",
"<input>",
line_number, char_number, names[i], "action");
- g_free (action_name);
- g_free (description);
return;
}
}
- if (!action_name || !description)
+ if (!action_name)
{
g_markup_parse_context_get_position (context,
&line_number,
"%s:%d:%d <%s> requires attribute \"%s\"",
"<input>",
line_number, char_number, "action",
- description ? "action_name" : "description");
- g_free (action_name);
- g_free (description);
+ "action_name");
return;
}
action = g_slice_new (AtkActionData);
- action->action_name = action_name;
- action->description = description;
-
+ action->action_name = g_strdup (action_name);
+ action->description = g_string_new (description);
+ action->context = g_strdup (msg_context);
+ action->translatable = translatable;
+
data->actions = g_slist_prepend (data->actions, action);
}
else if (strcmp (element_name, "accessibility") == 0)
g_warning ("Unsupported tag for GtkWidget: %s\n", element_name);
}
+static void
+accessibility_text (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error)
+{
+ AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
+
+ if (strcmp (g_markup_parse_context_get_element (context), "action") == 0)
+ {
+ AtkActionData *action = data->actions->data;
+
+ g_string_append_len (action->description, text, text_len);
+ }
+}
+
static const GMarkupParser accessibility_parser =
{
accessibility_start_element,
+ NULL,
+ accessibility_text,
};
-typedef struct {
+typedef struct
+{
GObject *object;
guint key;
guint modifiers;
} AccelGroupParserData;
static void
-accel_group_start_element (GMarkupParseContext *context,
- const gchar *element_name,
- const gchar **names,
- const gchar **values,
- gpointer user_data,
- GError **error)
+accel_group_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **names,
+ const gchar **values,
+ gpointer user_data,
+ GError **error)
{
gint i;
guint key = 0;
return FALSE;
}
+void
+_gtk_widget_buildable_finish_accelerator (GtkWidget *widget,
+ GtkWidget *toplevel,
+ gpointer user_data)
+{
+ AccelGroupParserData *accel_data;
+ GSList *accel_groups;
+ GtkAccelGroup *accel_group;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (GTK_IS_WIDGET (toplevel));
+ g_return_if_fail (user_data != NULL);
+
+ accel_data = (AccelGroupParserData*)user_data;
+ accel_groups = gtk_accel_groups_from_object (G_OBJECT (toplevel));
+ if (g_slist_length (accel_groups) == 0)
+ {
+ accel_group = gtk_accel_group_new ();
+ gtk_window_add_accel_group (GTK_WINDOW (toplevel), accel_group);
+ }
+ else
+ {
+ g_assert (g_slist_length (accel_groups) == 1);
+ accel_group = g_slist_nth_data (accel_groups, 0);
+ }
+
+ gtk_widget_add_accelerator (GTK_WIDGET (accel_data->object),
+ accel_data->signal,
+ accel_group,
+ accel_data->key,
+ accel_data->modifiers,
+ GTK_ACCEL_VISIBLE);
+
+ g_object_unref (accel_data->object);
+ g_free (accel_data->signal);
+ g_slice_free (AccelGroupParserData, accel_data);
+}
+
static void
gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
GtkBuilder *builder,
AccelGroupParserData *accel_data;
AccessibilitySubParserData *a11y_data;
GtkWidget *toplevel;
- GSList *accel_groups;
- GtkAccelGroup *accel_group;
if (strcmp (tagname, "accelerator") == 0)
{
g_assert (accel_data->object);
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (accel_data->object));
- accel_groups = gtk_accel_groups_from_object (G_OBJECT (toplevel));
- if (g_slist_length (accel_groups) == 0)
- {
- accel_group = gtk_accel_group_new ();
- gtk_window_add_accel_group (GTK_WINDOW (toplevel), accel_group);
- }
- else
- {
- g_assert (g_slist_length (accel_groups) == 1);
- accel_group = g_slist_nth_data (accel_groups, 0);
- }
- gtk_widget_add_accelerator (GTK_WIDGET (accel_data->object),
- accel_data->signal,
- accel_group,
- accel_data->key,
- accel_data->modifiers,
- GTK_ACCEL_VISIBLE);
- g_object_unref (accel_data->object);
- g_free (accel_data->signal);
- g_slice_free (AccelGroupParserData, accel_data);
+
+ _gtk_widget_buildable_finish_accelerator (GTK_WIDGET (buildable), toplevel, user_data);
}
else if (strcmp (tagname, "accessibility") == 0)
{
AtkAction *action;
gint i, n_actions;
GSList *l;
-
+
accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
-
+
action = ATK_ACTION (accessible);
- n_actions = atk_action_get_n_actions (action);
-
+ n_actions = atk_action_get_n_actions (action);
+
for (l = a11y_data->actions; l; l = l->next)
{
AtkActionData *action_data = (AtkActionData*)l->data;
-
+
for (i = 0; i < n_actions; i++)
if (strcmp (atk_action_get_name (action, i),
action_data->action_name) == 0)
break;
if (i < n_actions)
- atk_action_set_description (action, i,
- action_data->description);
+ {
+ gchar *description;
+
+ if (action_data->translatable && action_data->description->len)
+ description = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
+ action_data->context,
+ action_data->description->str);
+ else
+ description = action_data->description->str;
+
+ atk_action_set_description (action, i, description);
+ }
}
-
+
g_slist_foreach (a11y_data->actions, (GFunc)free_action, NULL);
g_slist_free (a11y_data->actions);
}
if (a11y_data->relations)
g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
a11y_data->relations);
-
+
g_slice_free (AccessibilitySubParserData, a11y_data);
-
}
}
gtk_widget_set_tooltip_window (GtkWidget *widget,
GtkWindow *custom_window)
{
- gboolean tmp;
+ gboolean has_tooltip;
gchar *tooltip_markup;
- GtkWindow *tooltip_window;
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (custom_window)
- g_return_if_fail (GTK_IS_WINDOW (custom_window));
+ g_return_if_fail (custom_window == NULL || GTK_IS_WINDOW (custom_window));
- tooltip_window = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_window);
tooltip_markup = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_markup);
if (custom_window)
g_object_ref (custom_window);
- tooltip_window = custom_window;
g_object_set_qdata_full (G_OBJECT (widget), quark_tooltip_window,
- tooltip_window, g_object_unref);
+ custom_window, g_object_unref);
- tmp = (tooltip_window != NULL || tooltip_markup != NULL);
- gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
+ has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
+ gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
- if (tmp)
- gtk_widget_trigger_tooltip_query (widget);
+ if (has_tooltip && GTK_WIDGET_VISIBLE (widget))
+ gtk_widget_queue_tooltip_query (widget);
}
/**
gtk_tooltip_trigger_tooltip_query (gtk_widget_get_display (widget));
}
+static guint tooltip_query_id;
+static GSList *tooltip_query_displays;
+
+static gboolean
+tooltip_query_idle (gpointer data)
+{
+ g_slist_foreach (tooltip_query_displays, (GFunc)gtk_tooltip_trigger_tooltip_query, NULL);
+ g_slist_foreach (tooltip_query_displays, (GFunc)g_object_unref, NULL);
+ g_slist_free (tooltip_query_displays);
+
+ tooltip_query_displays = NULL;
+ tooltip_query_id = 0;
+
+ return FALSE;
+}
+
+static void
+gtk_widget_queue_tooltip_query (GtkWidget *widget)
+{
+ GdkDisplay *display;
+
+ display = gtk_widget_get_display (widget);
+
+ if (!g_slist_find (tooltip_query_displays, display))
+ tooltip_query_displays = g_slist_prepend (tooltip_query_displays, g_object_ref (display));
+
+ if (tooltip_query_id == 0)
+ tooltip_query_id = gdk_threads_add_idle (tooltip_query_idle, NULL);
+}
+
/**
* gtk_widget_set_tooltip_text:
* @widget: a #GtkWidget
return has_tooltip;
}
+/**
+ * gtk_widget_get_allocation:
+ * @widget: a #GtkWidget
+ * @allocation: a pointer to a #GtkAllocation to copy to
+ *
+ * Retrieves the widget's allocation.
+ *
+ * Since: 2.18
+ */
+void
+gtk_widget_get_allocation (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (allocation != NULL);
+
+ *allocation = widget->allocation;
+}
+
+/**
+ * gtk_widget_set_allocation:
+ * @widget: a #GtkWidget
+ * @allocation: a pointer to a #GtkAllocation to copy from
+ *
+ * Sets the widget's allocation. This should not be used
+ * directly, but from within a widget's size_allocate method.
+ *
+ * Since: 2.18
+ */
+void
+gtk_widget_set_allocation (GtkWidget *widget,
+ const GtkAllocation *allocation)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (allocation != NULL);
+
+ widget->allocation = *allocation;
+}
+
+/**
+ * gtk_widget_set_window:
+ * @widget: a #GtkWidget
+ * @window: a #GdkWindow
+ *
+ * Sets a widget's window. This function should only be used in a
+ * widget's GtkWidget::realize() implementation. The %window passed is
+ * usually either new window created with gdk_window_new(), or the
+ * window of its parent widget as returned by
+ * gtk_widget_get_parent_window().
+ *
+ * Widgets must indicate whether they will create their own #GdkWindow
+ * by calling gtk_widget_set_has_window(). This is usually done in the
+ * widget's init() function.
+ *
+ * Since: 2.18
+ */
+void
+gtk_widget_set_window (GtkWidget *widget,
+ GdkWindow *window)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
+
+ if (widget->window != window)
+ {
+ widget->window = window;
+ g_object_notify (G_OBJECT (widget), "window");
+ }
+}
+
+/**
+ * gtk_widget_get_window:
+ * @widget: a #GtkWidget
+ *
+ * Returns the widget's window if it is realized, %NULL otherwise
+ *
+ * Return value: @widget's window.
+ *
+ * Since: 2.14
+ */
+GdkWindow*
+gtk_widget_get_window (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ return widget->window;
+}
+
#define __GTK_WIDGET_C__
#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff