* 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/.
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
#ifndef __GTK_WIDGET_H__
#define __GTK_WIDGET_H__
#include <gtk/gtkobject.h>
#include <gtk/gtkadjustment.h>
#include <gtk/gtkstyle.h>
-#include <atk/atkobject.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+#include <gtk/gtksettings.h>
+#include <atk/atk.h>
+G_BEGIN_DECLS
-/* The flags that are used by GtkWidget on top of the
- * flags field of GtkObject.
+/**
+ * GtkWidgetFlags:
+ * @GTK_TOPLEVEL: widgets without a real parent, as there are #GtkWindow<!-- -->s and
+ * #GtkMenu<!-- -->s have this flag set throughout their lifetime.
+ * Toplevel widgets always contain their own #GdkWindow.
+ * @GTK_NO_WINDOW: Indicative for a widget that does not provide its own #GdkWindow.
+ * Visible action (e.g. drawing) is performed on the parent's #GdkWindow.
+ * @GTK_REALIZED: Set by gtk_widget_realize(), unset by gtk_widget_unrealize().
+ * A realized widget has an associated #GdkWindow.
+ * @GTK_MAPPED: Set by gtk_widget_map(), unset by gtk_widget_unmap().
+ * Only realized widgets can be mapped. It means that gdk_window_show()
+ * has been called on the widgets window(s).
+ * @GTK_VISIBLE: Set by gtk_widget_show(), unset by gtk_widget_hide(). Implies that a
+ * widget will be mapped as soon as its parent is mapped.
+ * @GTK_SENSITIVE: Set and unset by gtk_widget_set_sensitive().
+ * The sensitivity of a widget determines whether it will receive
+ * certain events (e.g. button or key presses). One premise for
+ * the widget's sensitivity is to have this flag set.
+ * @GTK_PARENT_SENSITIVE: Set and unset by gtk_widget_set_sensitive() operations on the
+ * parents of the widget.
+ * This is the second premise for the widget's sensitivity. Once
+ * it has %GTK_SENSITIVE and %GTK_PARENT_SENSITIVE set, its state is
+ * effectively sensitive. This is expressed (and can be examined) by
+ * the #GTK_WIDGET_IS_SENSITIVE macro.
+ * @GTK_CAN_FOCUS: Determines whether a widget is able to handle focus grabs.
+ * @GTK_HAS_FOCUS: Set by gtk_widget_grab_focus() for widgets that also
+ * have %GTK_CAN_FOCUS set. The flag will be unset once another widget
+ * grabs the focus.
+ * @GTK_CAN_DEFAULT: The widget is allowed to receive the default action via
+ * gtk_widget_grab_default() and will reserve space to draw the default if possible
+ * @GTK_HAS_DEFAULT: The widget currently is receiving the default action and
+ * should be drawn appropriately if possible
+ * @GTK_HAS_GRAB: Set by gtk_grab_add(), unset by gtk_grab_remove(). It means that the
+ * widget is in the grab_widgets stack, and will be the preferred one for
+ * receiving events other than ones of cosmetic value.
+ * @GTK_RC_STYLE: Indicates that the widget's style has been looked up through the rc
+ * mechanism. It does not imply that the widget actually had a style
+ * defined through the rc mechanism.
+ * @GTK_COMPOSITE_CHILD: Indicates that the widget is a composite child of its parent; see
+ * gtk_widget_push_composite_child(), gtk_widget_pop_composite_child().
+ * @GTK_NO_REPARENT: Unused since before GTK+ 1.2, will be removed in a future version.
+ * @GTK_APP_PAINTABLE: Set and unset by gtk_widget_set_app_paintable().
+ * Must be set on widgets whose window the application directly draws on,
+ * in order to keep GTK+ from overwriting the drawn stuff. See
+ * <xref linkend="app-paintable-widgets"/> for a detailed
+ * description of this flag.
+ * @GTK_RECEIVES_DEFAULT: The widget when focused will receive the default action and have
+ * %GTK_HAS_DEFAULT set even if there is a different widget set as default.
+ * @GTK_DOUBLE_BUFFERED: Set and unset by gtk_widget_set_double_buffered().
+ * Indicates that exposes done on the widget should be
+ * double-buffered. See <xref linkend="double-buffering"/> for a
+ * detailed discussion of how double-buffering works in GTK+ and
+ * why you may want to disable it for special cases.
+ * @GTK_NO_SHOW_ALL:
+ *
+ * Tells about certain properties of the widget.
*/
typedef enum
{
GTK_PARENT_SENSITIVE = 1 << 10,
GTK_CAN_FOCUS = 1 << 11,
GTK_HAS_FOCUS = 1 << 12,
-
- /* widget is allowed to receive the default via gtk_widget_grab_default
- * and will reserve space to draw the default if possible
- */
GTK_CAN_DEFAULT = 1 << 13,
-
- /* the widget currently is receiving the default action and should be drawn
- * appropriately if possible
- */
GTK_HAS_DEFAULT = 1 << 14,
-
GTK_HAS_GRAB = 1 << 15,
GTK_RC_STYLE = 1 << 16,
GTK_COMPOSITE_CHILD = 1 << 17,
GTK_NO_REPARENT = 1 << 18,
GTK_APP_PAINTABLE = 1 << 19,
-
- /* the widget when focused will receive the default action and have
- * HAS_DEFAULT set even if there is a different widget set as default
- */
GTK_RECEIVES_DEFAULT = 1 << 20,
-
- GTK_DOUBLE_BUFFERED = 1 << 21
+ GTK_DOUBLE_BUFFERED = 1 << 21,
+ GTK_NO_SHOW_ALL = 1 << 22
} GtkWidgetFlags;
+/* Kinds of widget-specific help */
+typedef enum
+{
+ GTK_WIDGET_HELP_TOOLTIP,
+ GTK_WIDGET_HELP_WHATS_THIS
+} GtkWidgetHelpType;
+
/* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer.
* Macros for testing whether `widget' or `klass' are of type GTK_TYPE_WIDGET.
*/
#define GTK_TYPE_WIDGET (gtk_widget_get_type ())
-#define GTK_WIDGET(widget) (GTK_CHECK_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
-#define GTK_WIDGET_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
-#define GTK_IS_WIDGET(widget) (GTK_CHECK_TYPE ((widget), GTK_TYPE_WIDGET))
-#define GTK_IS_WIDGET_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
-#define GTK_WIDGET_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
+#define GTK_WIDGET(widget) (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
+#define GTK_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
+#define GTK_IS_WIDGET(widget) (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET))
+#define GTK_IS_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
+#define GTK_WIDGET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
/* Macros for extracting various fields from GtkWidget and GtkWidgetClass.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+/**
+ * GTK_WIDGET_TYPE:
+ * @wid: a #GtkWidget.
+ *
+ * Gets the type of a widget.
+ *
+ * Deprecated: 2.20: Use G_OBJECT_TYPE() instead.
+ */
#define GTK_WIDGET_TYPE(wid) (GTK_OBJECT_TYPE (wid))
+#endif
+
+/**
+ * GTK_WIDGET_STATE:
+ * @wid: a #GtkWidget.
+ *
+ * Returns the current state of the widget, as a #GtkStateType.
+ *
+ * Deprecated: 2.20: Use gtk_widget_get_state() instead.
+ */
#define GTK_WIDGET_STATE(wid) (GTK_WIDGET (wid)->state)
+/* FIXME: Deprecating GTK_WIDGET_STATE requires fixing GTK internals. */
+
+#ifndef GTK_DISABLE_DEPRECATED
+/**
+ * GTK_WIDGET_SAVED_STATE:
+ * @wid: a #GtkWidget.
+ *
+ * Returns the saved state of the widget, as a #GtkStateType.
+ *
+ * The saved state will be restored when a widget gets sensitive
+ * again, after it has been made insensitive with gtk_widget_set_state()
+ * or gtk_widget_set_sensitive().
+ *
+ * Deprecated: 2.20: Do not used it.
+ */
#define GTK_WIDGET_SAVED_STATE(wid) (GTK_WIDGET (wid)->saved_state)
+#endif
+
/* Macros for extracting the widget flags from GtkWidget.
*/
+/**
+ * GTK_WIDGET_FLAGS:
+ * @wid: a #GtkWidget.
+ *
+ * Returns the widget flags from @wid.
+ *
+ * Deprecated: 2.20: Do not use it.
+ */
#define GTK_WIDGET_FLAGS(wid) (GTK_OBJECT_FLAGS (wid))
+/* FIXME: Deprecating GTK_WIDGET_FLAGS requires fixing GTK internals. */
+
+#ifndef GTK_DISABLE_DEPRECATED
+/**
+ * GTK_WIDGET_TOPLEVEL:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is a toplevel widget.
+ *
+ * Deprecated: 2.20: Use gtk_widget_is_toplevel() instead.
+ */
#define GTK_WIDGET_TOPLEVEL(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_TOPLEVEL) != 0)
+#endif
+
+/**
+ * GTK_WIDGET_NO_WINDOW:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget doesn't have an own #GdkWindow.
+ *
+ * Deprecated: 2.20: Use gtk_widget_get_has_window() instead.
+ */
#define GTK_WIDGET_NO_WINDOW(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_NO_WINDOW) != 0)
+/* FIXME: Deprecating GTK_WIDGET_NO_WINDOW requires fixing GTK internals. */
+
+/**
+ * GTK_WIDGET_REALIZED:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is realized.
+ */
#define GTK_WIDGET_REALIZED(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_REALIZED) != 0)
+
+/**
+ * GTK_WIDGET_MAPPED:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is mapped.
+ */
#define GTK_WIDGET_MAPPED(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0)
+
+/**
+ * GTK_WIDGET_VISIBLE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is visible.
+ */
#define GTK_WIDGET_VISIBLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0)
+
+/**
+ * GTK_WIDGET_DRAWABLE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is mapped and visible.
+ */
#define GTK_WIDGET_DRAWABLE(wid) (GTK_WIDGET_VISIBLE (wid) && GTK_WIDGET_MAPPED (wid))
+
+/**
+ * GTK_WIDGET_SENSITIVE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the #GTK_SENSITIVE flag has be set on the widget.
+ */
#define GTK_WIDGET_SENSITIVE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_SENSITIVE) != 0)
+
+/**
+ * GTK_WIDGET_PARENT_SENSITIVE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the #GTK_PARENT_SENSITIVE flag has be set on the widget.
+ */
#define GTK_WIDGET_PARENT_SENSITIVE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_PARENT_SENSITIVE) != 0)
+
+/**
+ * GTK_WIDGET_IS_SENSITIVE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is effectively sensitive.
+ */
#define GTK_WIDGET_IS_SENSITIVE(wid) (GTK_WIDGET_SENSITIVE (wid) && \
GTK_WIDGET_PARENT_SENSITIVE (wid))
+/**
+ * GTK_WIDGET_CAN_FOCUS:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is able to handle focus grabs.
+ */
#define GTK_WIDGET_CAN_FOCUS(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_FOCUS) != 0)
+
+/**
+ * GTK_WIDGET_HAS_FOCUS:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget has grabbed the focus and no other
+ * widget has done so more recently.
+ */
#define GTK_WIDGET_HAS_FOCUS(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_FOCUS) != 0)
+
+/**
+ * GTK_WIDGET_CAN_DEFAULT:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is allowed to receive the default action
+ * via gtk_widget_grab_default().
+ */
#define GTK_WIDGET_CAN_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_DEFAULT) != 0)
+
+/**
+ * GTK_WIDGET_HAS_DEFAULT:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget currently is receiving the default action.
+ */
#define GTK_WIDGET_HAS_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_DEFAULT) != 0)
+
+/**
+ * GTK_WIDGET_HAS_GRAB:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is in the grab_widgets stack, and will be
+ * the preferred one for receiving events other than ones of cosmetic value.
+ */
#define GTK_WIDGET_HAS_GRAB(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0)
+
+/**
+ * GTK_WIDGET_RC_STYLE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget's style has been looked up through the rc
+ * mechanism.
+ */
#define GTK_WIDGET_RC_STYLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0)
+#ifndef GTK_DISABLE_DEPRECATED
+/**
+ * GTK_WIDGET_COMPOSITE_CHILD:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget is a composite child of its parent.
+ *
+ * Deprecated: 2.20: Use the "composite-child" property instead.
+ */
#define GTK_WIDGET_COMPOSITE_CHILD(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0)
+#endif
+
+/**
+ * GTK_WIDGET_APP_PAINTABLE:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the #GTK_APP_PAINTABLE flag has been set on the widget.
+ */
#define GTK_WIDGET_APP_PAINTABLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_APP_PAINTABLE) != 0)
+
+/**
+ * GTK_WIDGET_RECEIVES_DEFAULT:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the widget when focused will receive the default action
+ * even if there is a different widget set as default.
+ */
#define GTK_WIDGET_RECEIVES_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_RECEIVES_DEFAULT) != 0)
+
+/**
+ * GTK_WIDGET_DOUBLE_BUFFERED:
+ * @wid: a #GtkWidget.
+ *
+ * Evaluates to %TRUE if the #GTK_DOUBLE_BUFFERED flag has been set on the widget.
+ */
#define GTK_WIDGET_DOUBLE_BUFFERED(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_DOUBLE_BUFFERED) != 0)
-
+
+
/* Macros for setting and clearing widget flags.
*/
+/**
+ * GTK_WIDGET_SET_FLAGS:
+ * @wid: a #GtkWidget.
+ * @flag: the flags to set.
+ *
+ * Turns on certain widget flags.
+ */
#define GTK_WIDGET_SET_FLAGS(wid,flag) G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END
+
+/**
+ * GTK_WIDGET_UNSET_FLAGS:
+ * @wid: a #GtkWidget.
+ * @flag: the flags to unset.
+ *
+ * Turns off certain widget flags.
+ */
#define GTK_WIDGET_UNSET_FLAGS(wid,flag) G_STMT_START{ (GTK_WIDGET_FLAGS (wid) &= ~(flag)); }G_STMT_END
+#define GTK_TYPE_REQUISITION (gtk_requisition_get_type ())
/* forward declaration to avoid excessive includes (and concurrent includes)
*/
typedef struct _GtkRequisition GtkRequisition;
-typedef struct _GdkRectangle GtkAllocation;
typedef struct _GtkSelectionData GtkSelectionData;
typedef struct _GtkWidgetClass GtkWidgetClass;
typedef struct _GtkWidgetAuxInfo GtkWidgetAuxInfo;
typedef struct _GtkWidgetShapeInfo GtkWidgetShapeInfo;
-typedef void (*GtkCallback) (GtkWidget *widget,
- gpointer data);
+typedef struct _GtkClipboard GtkClipboard;
+typedef struct _GtkTooltip GtkTooltip;
+typedef struct _GtkWindow GtkWindow;
+
+/**
+ * GtkAllocation:
+ * @x: the X position of the widget's area relative to its parents allocation.
+ * @y: the Y position of the widget's area relative to its parents allocation.
+ * @width: the width of the widget's allocated area.
+ * @height: the height of the widget's allocated area.
+ *
+ * A <structname>GtkAllocation</structname> of a widget represents region which has been allocated to the
+ * widget by its parent. It is a subregion of its parents allocation. See
+ * <xref linkend="size-allocation"/> for more information.
+ */
+typedef GdkRectangle GtkAllocation;
+
+/**
+ * GtkCallback:
+ * @widget: the widget to operate on
+ * @data: user-supplied data
+ *
+ * The type of the callback functions used for e.g. iterating over
+ * the children of a container, see gtk_container_foreach().
+ */
+typedef void (*GtkCallback) (GtkWidget *widget,
+ gpointer data);
-/* A requisition is a desired amount of space which a
- * widget may request.
+/**
+ * GtkRequisition:
+ * @width: the widget's desired width
+ * @height: the widget's desired height
+ *
+ * A <structname>GtkRequisition</structname> represents the desired size of a widget. See
+ * <xref linkend="size-requisition"/> for more information.
*/
struct _GtkRequisition
{
* state and saved_state go. we therefore don't waste any new
* space on this.
*/
- guint16 private_flags;
+ guint16 GSEAL (private_flags);
/* The state of the widget. There are actually only
* 5 widget states (defined in "gtkenums.h").
*/
- guint8 state;
+ guint8 GSEAL (state);
- /* The saved state of the widget. When a widgets state
+ /* The saved state of the widget. When a widget's state
* is changed to GTK_STATE_INSENSITIVE via
* "gtk_widget_set_state" or "gtk_widget_set_sensitive"
* the old state is kept around in this field. The state
* will be restored once the widget gets sensitive again.
*/
- guint8 saved_state;
+ guint8 GSEAL (saved_state);
- /* The widgets name. If the widget does not have a name
+ /* The widget's name. If the widget does not have a name
* (the name is NULL), then its name (as returned by
- * "gtk_widget_get_name") is its classes name.
+ * "gtk_widget_get_name") is its class's name.
* Among other things, the widget name is used to determine
* the style to use for a widget.
*/
- gchar *name;
+ gchar *GSEAL (name);
+ /*< public >*/
+
/* The style for the widget. The style contains the
* colors the widget should be drawn in for each state
* along with graphics contexts used to draw with and
* the font to use for text.
*/
- GtkStyle *style;
+ GtkStyle *GSEAL (style);
- /* The widgets desired size.
+ /* The widget's desired size.
*/
- GtkRequisition requisition;
+ GtkRequisition GSEAL (requisition);
- /* The widgets allocated size.
+ /* The widget's allocated size.
*/
- GtkAllocation allocation;
+ GtkAllocation GSEAL (allocation);
- /* The widgets window or its parent window if it does
+ /* The widget's window or its parent window if it does
* not have a window. (Which will be indicated by the
* GTK_NO_WINDOW flag being set).
*/
- GdkWindow *window;
+ GdkWindow *GSEAL (window);
- /* The widgets parent.
+ /* The widget's parent.
*/
- GtkWidget *parent;
+ GtkWidget *GSEAL (parent);
};
+/**
+ * GtkWidgetClass:
+ * @parent_class:
+ * @activate_signal:
+ * @set_scroll_adjustments_signal:
+ *
+ * <structfield>activate_signal</structfield>
+ * The signal to emit when a widget of this class is activated,
+ * gtk_widget_activate() handles the emission. Implementation of this
+ * signal is optional.
+ *
+ *
+ * <structfield>set_scroll_adjustment_signal</structfield>
+ * This signal is emitted when a widget of this class is added
+ * to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
+ * handles the emission.
+ * Implementation of this signal is optional.
+ */
struct _GtkWidgetClass
{
/* The object class structure needs to be the first
* pointer.
*/
GtkObjectClass parent_class;
+
+ /*< public >*/
- /* The signal to emit when a widget of this class is activated,
- * gtk_widget_activate() handles the emission.
- * Implementation of this signal is optional.
- */
guint activate_signal;
- /* This signal is emitted when a widget of this class is added
- * to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
- * handles the emission.
- * Implementation of this signal is optional.
- */
guint set_scroll_adjustments_signal;
+ /*< private >*/
+
+ /* seldomly overidden */
+ void (*dispatch_child_properties_changed) (GtkWidget *widget,
+ guint n_pspecs,
+ GParamSpec **pspecs);
+
/* basics */
void (* show) (GtkWidget *widget);
void (* show_all) (GtkWidget *widget);
GtkStateType previous_state);
void (* parent_set) (GtkWidget *widget,
GtkWidget *previous_parent);
- void (* hierarchy_changed) (GtkWidget *widget);
+ void (* hierarchy_changed) (GtkWidget *widget,
+ GtkWidget *previous_toplevel);
void (* style_set) (GtkWidget *widget,
GtkStyle *previous_style);
void (* direction_changed) (GtkWidget *widget,
GtkTextDirection previous_direction);
+ void (* grab_notify) (GtkWidget *widget,
+ gboolean was_grabbed);
+ void (* child_notify) (GtkWidget *widget,
+ GParamSpec *pspec);
- /* accelerators */
- void (* add_accelerator) (GtkWidget *widget,
- guint accel_signal_id,
- GtkAccelGroup *accel_group,
- guint accel_key,
- GdkModifierType accel_mods,
- GtkAccelFlags accel_flags);
- void (* remove_accelerator) (GtkWidget *widget,
- GtkAccelGroup *accel_group,
- guint accel_key,
- GdkModifierType accel_mods);
-
/* Mnemonics */
gboolean (* mnemonic_activate) (GtkWidget *widget,
gboolean group_cycling);
/* explicit focus */
- void (* grab_focus) (GtkWidget *widget);
+ void (* grab_focus) (GtkWidget *widget);
gboolean (* focus) (GtkWidget *widget,
GtkDirectionType direction);
void (* selection_get) (GtkWidget *widget,
GtkSelectionData *selection_data,
guint info,
- guint time);
+ guint time_);
void (* selection_received) (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint time);
+ guint time_);
/* Source side drag signals */
void (* drag_begin) (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
- guint time);
+ guint time_);
void (* drag_data_delete) (GtkWidget *widget,
GdkDragContext *context);
/* Target side drag signals */
void (* drag_leave) (GtkWidget *widget,
GdkDragContext *context,
- guint time);
+ guint time_);
gboolean (* drag_motion) (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
- guint time);
+ guint time_);
gboolean (* drag_drop) (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
- guint time);
+ guint time_);
void (* drag_data_received) (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
- guint time);
+ guint time_);
/* Signals used only for keybindings */
- void (* popup_menu) (GtkWidget *widget);
-
+ gboolean (* popup_menu) (GtkWidget *widget);
+
+ /* If a widget has multiple tooltips/whatsthis, it should show the
+ * one for the current focus location, or if that doesn't make
+ * sense, should cycle through them showing each tip alongside
+ * whatever piece of the widget it applies to.
+ */
+ gboolean (* show_help) (GtkWidget *widget,
+ GtkWidgetHelpType help_type);
/* accessibility support
*/
- AtkObject* (* get_accessible) (GtkWidget *widget);
+ AtkObject* (*get_accessible) (GtkWidget *widget);
+
+ void (*screen_changed) (GtkWidget *widget,
+ GdkScreen *previous_screen);
+ gboolean (*can_activate_accel) (GtkWidget *widget,
+ guint signal_id);
+
+ /* Sent when a grab is broken. */
+ gboolean (*grab_broken_event) (GtkWidget *widget,
+ GdkEventGrabBroken *event);
+
+ void (* composited_changed) (GtkWidget *widget);
+
+ gboolean (* query_tooltip) (GtkWidget *widget,
+ gint x,
+ gint y,
+ gboolean keyboard_tooltip,
+ GtkTooltip *tooltip);
+ /* Signals without a C default handler class slot:
+ * gboolean (*damage_event) (GtkWidget *widget,
+ * GdkEventExpose *event);
+ */
/* Padding for future expansion */
- GtkFunction pad1;
- GtkFunction pad2;
- GtkFunction pad3;
- GtkFunction pad4;
+ void (*_gtk_reserved5) (void);
+ void (*_gtk_reserved6) (void);
+ void (*_gtk_reserved7) (void);
};
struct _GtkWidgetAuxInfo
GdkBitmap *shape_mask;
};
-GtkType gtk_widget_get_type (void) G_GNUC_CONST;
-GtkWidget* gtk_widget_new (GtkType type,
+GType gtk_widget_get_type (void) G_GNUC_CONST;
+GtkWidget* gtk_widget_new (GType type,
const gchar *first_property_name,
...);
-GtkWidget* gtk_widget_ref (GtkWidget *widget);
-void gtk_widget_unref (GtkWidget *widget);
void gtk_widget_destroy (GtkWidget *widget);
void gtk_widget_destroyed (GtkWidget *widget,
GtkWidget **widget_pointer);
#ifndef GTK_DISABLE_DEPRECATED
+GtkWidget* gtk_widget_ref (GtkWidget *widget);
+void gtk_widget_unref (GtkWidget *widget);
void gtk_widget_set (GtkWidget *widget,
const gchar *first_property_name,
- ...);
+ ...) G_GNUC_NULL_TERMINATED;
#endif /* GTK_DISABLE_DEPRECATED */
void gtk_widget_unparent (GtkWidget *widget);
void gtk_widget_show (GtkWidget *widget);
void gtk_widget_hide (GtkWidget *widget);
void gtk_widget_show_all (GtkWidget *widget);
void gtk_widget_hide_all (GtkWidget *widget);
+void gtk_widget_set_no_show_all (GtkWidget *widget,
+ gboolean no_show_all);
+gboolean gtk_widget_get_no_show_all (GtkWidget *widget);
void gtk_widget_map (GtkWidget *widget);
void gtk_widget_unmap (GtkWidget *widget);
void gtk_widget_realize (GtkWidget *widget);
void gtk_widget_queue_resize (GtkWidget *widget);
+void gtk_widget_queue_resize_no_redraw (GtkWidget *widget);
#ifndef GTK_DISABLE_DEPRECATED
void gtk_widget_draw (GtkWidget *widget,
- GdkRectangle *area);
+ const GdkRectangle *area);
#endif /* GTK_DISABLE_DEPRECATED */
void gtk_widget_size_request (GtkWidget *widget,
GtkRequisition *requisition);
const gchar *accel_signal,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
-void gtk_widget_remove_accelerator (GtkWidget *widget,
+gboolean gtk_widget_remove_accelerator (GtkWidget *widget,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
-void gtk_widget_remove_accelerators (GtkWidget *widget,
- const gchar *accel_signal,
- gboolean visible_only);
-guint gtk_widget_accelerator_signal (GtkWidget *widget,
- GtkAccelGroup *accel_group,
- guint accel_key,
- guint accel_mods);
-void gtk_widget_lock_accelerators (GtkWidget *widget);
-void gtk_widget_unlock_accelerators (GtkWidget *widget);
-gboolean gtk_widget_accelerators_locked (GtkWidget *widget);
+ GdkModifierType accel_mods);
+void gtk_widget_set_accel_path (GtkWidget *widget,
+ const gchar *accel_path,
+ GtkAccelGroup *accel_group);
+const gchar* _gtk_widget_get_accel_path (GtkWidget *widget,
+ gboolean *locked);
+GList* gtk_widget_list_accel_closures (GtkWidget *widget);
+gboolean gtk_widget_can_activate_accel (GtkWidget *widget,
+ guint signal_id);
gboolean gtk_widget_mnemonic_activate (GtkWidget *widget,
gboolean group_cycling);
gboolean gtk_widget_event (GtkWidget *widget,
void gtk_widget_reparent (GtkWidget *widget,
GtkWidget *new_parent);
gboolean gtk_widget_intersect (GtkWidget *widget,
- GdkRectangle *area,
+ const GdkRectangle *area,
GdkRectangle *intersection);
GdkRegion *gtk_widget_region_intersect (GtkWidget *widget,
- GdkRegion *region);
+ const GdkRegion *region);
+
+void gtk_widget_freeze_child_notify (GtkWidget *widget);
+void gtk_widget_child_notify (GtkWidget *widget,
+ const gchar *child_property);
+void gtk_widget_thaw_child_notify (GtkWidget *widget);
+void gtk_widget_set_can_focus (GtkWidget *widget,
+ gboolean can_focus);
+gboolean gtk_widget_get_can_focus (GtkWidget *widget);
+gboolean gtk_widget_has_focus (GtkWidget *widget);
gboolean gtk_widget_is_focus (GtkWidget *widget);
-void gtk_widget_grab_focus (GtkWidget *widget);
-void gtk_widget_grab_default (GtkWidget *widget);
-
-void gtk_widget_set_name (GtkWidget *widget,
- const gchar *name);
-G_CONST_RETURN gchar* gtk_widget_get_name (GtkWidget *widget);
-void gtk_widget_set_state (GtkWidget *widget,
- GtkStateType state);
-void gtk_widget_set_sensitive (GtkWidget *widget,
- gboolean sensitive);
-void gtk_widget_set_app_paintable (GtkWidget *widget,
- gboolean app_paintable);
-void gtk_widget_set_double_buffered (GtkWidget *widget,
- gboolean double_buffered);
-void gtk_widget_set_parent (GtkWidget *widget,
- GtkWidget *parent);
-void gtk_widget_set_parent_window (GtkWidget *widget,
- GdkWindow *parent_window);
-GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget);
+void gtk_widget_grab_focus (GtkWidget *widget);
+
+void gtk_widget_set_can_default (GtkWidget *widget,
+ gboolean can_default);
+gboolean gtk_widget_get_can_default (GtkWidget *widget);
+gboolean gtk_widget_has_default (GtkWidget *widget);
+void gtk_widget_grab_default (GtkWidget *widget);
+
+void gtk_widget_set_receives_default (GtkWidget *widget,
+ gboolean receives_default);
+gboolean gtk_widget_get_receives_default (GtkWidget *widget);
+
+gboolean gtk_widget_has_grab (GtkWidget *widget);
+
+void gtk_widget_set_name (GtkWidget *widget,
+ const gchar *name);
+G_CONST_RETURN gchar* gtk_widget_get_name (GtkWidget *widget);
+
+void gtk_widget_set_state (GtkWidget *widget,
+ GtkStateType state);
+GtkStateType gtk_widget_get_state (GtkWidget *widget);
+
+void gtk_widget_set_sensitive (GtkWidget *widget,
+ gboolean sensitive);
+gboolean gtk_widget_get_sensitive (GtkWidget *widget);
+gboolean gtk_widget_is_sensitive (GtkWidget *widget);
+
+void gtk_widget_set_visible (GtkWidget *widget,
+ gboolean visible);
+gboolean gtk_widget_get_visible (GtkWidget *widget);
+
+void gtk_widget_set_has_window (GtkWidget *widget,
+ gboolean has_window);
+gboolean gtk_widget_get_has_window (GtkWidget *widget);
+
+gboolean gtk_widget_is_toplevel (GtkWidget *widget);
+gboolean gtk_widget_is_drawable (GtkWidget *widget);
+
+void gtk_widget_set_app_paintable (GtkWidget *widget,
+ gboolean app_paintable);
+gboolean gtk_widget_get_app_paintable (GtkWidget *widget);
+
+void gtk_widget_set_double_buffered (GtkWidget *widget,
+ gboolean double_buffered);
+gboolean gtk_widget_get_double_buffered (GtkWidget *widget);
+
+void gtk_widget_set_redraw_on_allocate (GtkWidget *widget,
+ gboolean redraw_on_allocate);
+
+void gtk_widget_set_parent (GtkWidget *widget,
+ GtkWidget *parent);
+GtkWidget * gtk_widget_get_parent (GtkWidget *widget);
+
+void gtk_widget_set_parent_window (GtkWidget *widget,
+ GdkWindow *parent_window);
+GdkWindow * gtk_widget_get_parent_window (GtkWidget *widget);
+
+void gtk_widget_set_child_visible (GtkWidget *widget,
+ gboolean is_visible);
+gboolean gtk_widget_get_child_visible (GtkWidget *widget);
+
+void gtk_widget_set_window (GtkWidget *widget,
+ GdkWindow *window);
+GdkWindow * gtk_widget_get_window (GtkWidget *widget);
+
+void gtk_widget_get_allocation (GtkWidget *widget,
+ GtkAllocation *allocation);
+void gtk_widget_set_allocation (GtkWidget *widget,
+ const GtkAllocation *allocation);
+
gboolean gtk_widget_child_focus (GtkWidget *widget,
GtkDirectionType direction);
+gboolean gtk_widget_keynav_failed (GtkWidget *widget,
+ GtkDirectionType direction);
+void gtk_widget_error_bell (GtkWidget *widget);
+
+void gtk_widget_set_size_request (GtkWidget *widget,
+ gint width,
+ gint height);
+void gtk_widget_get_size_request (GtkWidget *widget,
+ gint *width,
+ gint *height);
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_widget_set_uposition (GtkWidget *widget,
gint x,
gint y);
void gtk_widget_set_usize (GtkWidget *widget,
gint width,
gint height);
+#endif
+
void gtk_widget_set_events (GtkWidget *widget,
gint events);
void gtk_widget_add_events (GtkWidget *widget,
GdkExtensionMode gtk_widget_get_extension_events (GtkWidget *widget);
GtkWidget* gtk_widget_get_toplevel (GtkWidget *widget);
GtkWidget* gtk_widget_get_ancestor (GtkWidget *widget,
- GtkType widget_type);
+ GType widget_type);
GdkColormap* gtk_widget_get_colormap (GtkWidget *widget);
GdkVisual* gtk_widget_get_visual (GtkWidget *widget);
+GdkScreen * gtk_widget_get_screen (GtkWidget *widget);
+gboolean gtk_widget_has_screen (GtkWidget *widget);
+GdkDisplay * gtk_widget_get_display (GtkWidget *widget);
+GdkWindow * gtk_widget_get_root_window (GtkWidget *widget);
+GtkSettings* gtk_widget_get_settings (GtkWidget *widget);
+GtkClipboard *gtk_widget_get_clipboard (GtkWidget *widget,
+ GdkAtom selection);
+GdkPixmap * gtk_widget_get_snapshot (GtkWidget *widget,
+ GdkRectangle *clip_rect);
+
+#ifndef GTK_DISABLE_DEPRECATED
+
+/**
+ * gtk_widget_set_visual:
+ * @widget: a #GtkWidget
+ * @visual: a visual
+ *
+ * This function is deprecated; it does nothing.
+ */
+#define gtk_widget_set_visual(widget,visual) ((void) 0)
+
+/**
+ * gtk_widget_push_visual:
+ * @visual: a visual
+ *
+ * This function is deprecated; it does nothing.
+ */
+#define gtk_widget_push_visual(visual) ((void) 0)
+
+/**
+ * gtk_widget_pop_visual:
+ *
+ * This function is deprecated; it does nothing.
+ */
+#define gtk_widget_pop_visual() ((void) 0)
+
+/**
+ * gtk_widget_set_default_visual:
+ * @visual: a visual
+ *
+ * This function is deprecated; it does nothing.
+ */
+#define gtk_widget_set_default_visual(visual) ((void) 0)
+
+#endif /* GTK_DISABLE_DEPRECATED */
/* Accessibility support */
AtkObject* gtk_widget_get_accessible (GtkWidget *widget);
gboolean gtk_widget_is_ancestor (GtkWidget *widget,
GtkWidget *ancestor);
+gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget,
+ GtkWidget *dest_widget,
+ gint src_x,
+ gint src_y,
+ gint *dest_x,
+ gint *dest_y);
+
/* Hide widget and return TRUE.
*/
gboolean gtk_widget_hide_on_delete (GtkWidget *widget);
*/
void gtk_widget_set_style (GtkWidget *widget,
GtkStyle *style);
-void gtk_widget_set_rc_style (GtkWidget *widget);
void gtk_widget_ensure_style (GtkWidget *widget);
GtkStyle* gtk_widget_get_style (GtkWidget *widget);
-void gtk_widget_restore_default_style (GtkWidget *widget);
void gtk_widget_modify_style (GtkWidget *widget,
GtkRcStyle *style);
GtkRcStyle *gtk_widget_get_modifier_style (GtkWidget *widget);
void gtk_widget_modify_fg (GtkWidget *widget,
GtkStateType state,
- GdkColor *color);
+ const GdkColor *color);
void gtk_widget_modify_bg (GtkWidget *widget,
GtkStateType state,
- GdkColor *color);
+ const GdkColor *color);
void gtk_widget_modify_text (GtkWidget *widget,
GtkStateType state,
- GdkColor *color);
+ const GdkColor *color);
void gtk_widget_modify_base (GtkWidget *widget,
GtkStateType state,
- GdkColor *color);
+ const GdkColor *color);
+void gtk_widget_modify_cursor (GtkWidget *widget,
+ const GdkColor *primary,
+ const GdkColor *secondary);
void gtk_widget_modify_font (GtkWidget *widget,
PangoFontDescription *font_desc);
+#ifndef GTK_DISABLE_DEPRECATED
+
+/**
+ * gtk_widget_set_rc_style:
+ * @widget: a #GtkWidget.
+ *
+ * Equivalent to <literal>gtk_widget_set_style (widget, NULL)</literal>.
+ *
+ * Deprecated: Use gtk_widget_set_style() with a %NULL @style argument instead.
+ */
+#define gtk_widget_set_rc_style(widget) (gtk_widget_set_style (widget, NULL))
+
+/**
+ * gtk_widget_restore_default_style:
+ * @widget: a #GtkWidget.
+ *
+ * Equivalent to <literal>gtk_widget_set_style (widget, NULL)</literal>.
+ *
+ * Deprecated: Use gtk_widget_set_style() with a %NULL @style argument instead.
+ */
+#define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
+#endif
+
PangoContext *gtk_widget_create_pango_context (GtkWidget *widget);
PangoContext *gtk_widget_get_pango_context (GtkWidget *widget);
PangoLayout *gtk_widget_create_pango_layout (GtkWidget *widget,
* This will override the values that got set by the
* gtk_widget_set_default_* () functions.
*/
-void gtk_widget_push_style (GtkStyle *style);
void gtk_widget_push_colormap (GdkColormap *cmap);
void gtk_widget_push_composite_child (void);
void gtk_widget_pop_composite_child (void);
-void gtk_widget_pop_style (void);
void gtk_widget_pop_colormap (void);
/* widget style properties
void gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass,
GParamSpec *pspec,
GtkRcPropertyParser parser);
+GParamSpec* gtk_widget_class_find_style_property (GtkWidgetClass *klass,
+ const gchar *property_name);
+GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass *klass,
+ guint *n_properties);
void gtk_widget_style_get_property (GtkWidget *widget,
const gchar *property_name,
GValue *value);
va_list var_args);
void gtk_widget_style_get (GtkWidget *widget,
const gchar *first_property_name,
- ...);
+ ...) G_GNUC_NULL_TERMINATED;
/* Set certain default values to be used at widget creation time.
*/
-void gtk_widget_set_default_style (GtkStyle *style);
void gtk_widget_set_default_colormap (GdkColormap *colormap);
GtkStyle* gtk_widget_get_default_style (void);
+#ifndef GDK_MULTIHEAD_SAFE
GdkColormap* gtk_widget_get_default_colormap (void);
GdkVisual* gtk_widget_get_default_visual (void);
+#endif
/* Functions for setting directionality for widgets
*/
void gtk_widget_set_default_direction (GtkTextDirection dir);
GtkTextDirection gtk_widget_get_default_direction (void);
+/* Compositing manager functionality */
+gboolean gtk_widget_is_composited (GtkWidget *widget);
+
/* Counterpart to gdk_window_shape_combine_mask.
*/
void gtk_widget_shape_combine_mask (GtkWidget *widget,
GdkBitmap *shape_mask,
gint offset_x,
gint offset_y);
+void gtk_widget_input_shape_combine_mask (GtkWidget *widget,
+ GdkBitmap *shape_mask,
+ gint offset_x,
+ gint offset_y);
/* internal function */
void gtk_widget_reset_shapes (GtkWidget *widget);
gchar **path,
gchar **path_reversed);
-GtkRequisition *gtk_requisition_copy (const GtkRequisition *requisition);
-void gtk_requisition_free (GtkRequisition *requisition);
+GList* gtk_widget_list_mnemonic_labels (GtkWidget *widget);
+void gtk_widget_add_mnemonic_label (GtkWidget *widget,
+ GtkWidget *label);
+void gtk_widget_remove_mnemonic_label (GtkWidget *widget,
+ GtkWidget *label);
+
+void gtk_widget_set_tooltip_window (GtkWidget *widget,
+ GtkWindow *custom_window);
+GtkWindow *gtk_widget_get_tooltip_window (GtkWidget *widget);
+void gtk_widget_trigger_tooltip_query (GtkWidget *widget);
+void gtk_widget_set_tooltip_text (GtkWidget *widget,
+ const gchar *text);
+gchar * gtk_widget_get_tooltip_text (GtkWidget *widget);
+void gtk_widget_set_tooltip_markup (GtkWidget *widget,
+ const gchar *markup);
+gchar * gtk_widget_get_tooltip_markup (GtkWidget *widget);
+void gtk_widget_set_has_tooltip (GtkWidget *widget,
+ gboolean has_tooltip);
+gboolean gtk_widget_get_has_tooltip (GtkWidget *widget);
+
+GType gtk_requisition_get_type (void) G_GNUC_CONST;
+GtkRequisition *gtk_requisition_copy (const GtkRequisition *requisition);
+void gtk_requisition_free (GtkRequisition *requisition);
#if defined (GTK_TRACE_OBJECTS) && defined (__GNUC__)
-# define gtk_widget_ref gtk_object_ref
-# define gtk_widget_unref gtk_object_unref
+# define gtk_widget_ref g_object_ref
+# define gtk_widget_unref g_object_unref
#endif /* GTK_TRACE_OBJECTS && __GNUC__ */
-GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget,
- gboolean create);
+void _gtk_widget_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed);
+
+GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget,
+ gboolean create);
+void _gtk_widget_propagate_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *previous_toplevel);
+void _gtk_widget_propagate_screen_changed (GtkWidget *widget,
+ GdkScreen *previous_screen);
+void _gtk_widget_propagate_composited_changed (GtkWidget *widget);
+
+void _gtk_widget_set_pointer_window (GtkWidget *widget,
+ GdkWindow *pointer_window);
+GdkWindow *_gtk_widget_get_pointer_window (GtkWidget *widget);
+gboolean _gtk_widget_is_pointer_widget (GtkWidget *widget);
+void _gtk_widget_synthesize_crossing (GtkWidget *from,
+ GtkWidget *to,
+ GdkCrossingMode mode);
+
+GdkColormap* _gtk_widget_peek_colormap (void);
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+void _gtk_widget_buildable_finish_accelerator (GtkWidget *widget,
+ GtkWidget *toplevel,
+ gpointer user_data);
+G_END_DECLS
#endif /* __GTK_WIDGET_H__ */
projects / ~andy / gtk / blobdiff