<refentry id="GtkWidget">
<refmeta>
<refentrytitle>GtkWidget</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GTK Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>GtkWidget</refname><refpurpose></refpurpose>
</refnamediv>

<refsynopsisdiv><title>Synopsis</title>
<synopsis>

#include &lt;gtk/gtk.h&gt;


struct      <link linkend="GtkWidget-struct">GtkWidget</link>;
struct      <link linkend="GtkWidgetClass">GtkWidgetClass</link>;
enum        <link linkend="GtkWidgetFlags">GtkWidgetFlags</link>;
#define     <link linkend="GTK-WIDGET-TYPE-CAPS">GTK_WIDGET_TYPE</link>                 (wid)
#define     <link linkend="GTK-WIDGET-STATE-CAPS">GTK_WIDGET_STATE</link>                (wid)
#define     <link linkend="GTK-WIDGET-SAVED-STATE-CAPS">GTK_WIDGET_SAVED_STATE</link>          (wid)
#define     <link linkend="GTK-WIDGET-FLAGS-CAPS">GTK_WIDGET_FLAGS</link>                (wid)
#define     <link linkend="GTK-WIDGET-TOPLEVEL-CAPS">GTK_WIDGET_TOPLEVEL</link>             (wid)
#define     <link linkend="GTK-WIDGET-NO-WINDOW-CAPS">GTK_WIDGET_NO_WINDOW</link>            (wid)
#define     <link linkend="GTK-WIDGET-REALIZED-CAPS">GTK_WIDGET_REALIZED</link>             (wid)
#define     <link linkend="GTK-WIDGET-MAPPED-CAPS">GTK_WIDGET_MAPPED</link>               (wid)
#define     <link linkend="GTK-WIDGET-VISIBLE-CAPS">GTK_WIDGET_VISIBLE</link>              (wid)
#define     <link linkend="GTK-WIDGET-DRAWABLE-CAPS">GTK_WIDGET_DRAWABLE</link>             (wid)
#define     <link linkend="GTK-WIDGET-SENSITIVE-CAPS">GTK_WIDGET_SENSITIVE</link>            (wid)
#define     <link linkend="GTK-WIDGET-PARENT-SENSITIVE-CAPS">GTK_WIDGET_PARENT_SENSITIVE</link>     (wid)
#define     <link linkend="GTK-WIDGET-IS-SENSITIVE-CAPS">GTK_WIDGET_IS_SENSITIVE</link>         (wid)
#define     <link linkend="GTK-WIDGET-CAN-FOCUS-CAPS">GTK_WIDGET_CAN_FOCUS</link>            (wid)
#define     <link linkend="GTK-WIDGET-HAS-FOCUS-CAPS">GTK_WIDGET_HAS_FOCUS</link>            (wid)
#define     <link linkend="GTK-WIDGET-CAN-DEFAULT-CAPS">GTK_WIDGET_CAN_DEFAULT</link>          (wid)
#define     <link linkend="GTK-WIDGET-RECEIVES-DEFAULT-CAPS">GTK_WIDGET_RECEIVES_DEFAULT</link>     (wid)
#define     <link linkend="GTK-WIDGET-HAS-DEFAULT-CAPS">GTK_WIDGET_HAS_DEFAULT</link>          (wid)
#define     <link linkend="GTK-WIDGET-HAS-GRAB-CAPS">GTK_WIDGET_HAS_GRAB</link>             (wid)
#define     <link linkend="GTK-WIDGET-RC-STYLE-CAPS">GTK_WIDGET_RC_STYLE</link>             (wid)
#define     <link linkend="GTK-WIDGET-COMPOSITE-CHILD-CAPS">GTK_WIDGET_COMPOSITE_CHILD</link>      (wid)
#define     <link linkend="GTK-WIDGET-APP-PAINTABLE-CAPS">GTK_WIDGET_APP_PAINTABLE</link>        (wid)
#define     <link linkend="GTK-WIDGET-DOUBLE-BUFFERED-CAPS">GTK_WIDGET_DOUBLE_BUFFERED</link>      (wid)
#define     <link linkend="GTK-WIDGET-SET-FLAGS-CAPS">GTK_WIDGET_SET_FLAGS</link>            (wid,flag)
#define     <link linkend="GTK-WIDGET-UNSET-FLAGS-CAPS">GTK_WIDGET_UNSET_FLAGS</link>          (wid,flag)
void        (<link linkend="GtkCallback">*GtkCallback</link>)                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gpointer">gpointer</link> data);
struct      <link linkend="GtkRequisition">GtkRequisition</link>;
struct      <link linkend="GtkAllocation">GtkAllocation</link>;
struct      <link linkend="GtkSelectionData">GtkSelectionData</link>;
struct      <link linkend="GtkWidgetAuxInfo">GtkWidgetAuxInfo</link>;
struct      <link linkend="GtkWidgetShapeInfo">GtkWidgetShapeInfo</link>;
enum        <link linkend="GtkWidgetHelpType">GtkWidgetHelpType</link>;
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="gtk-widget-new">gtk_widget_new</link>                  (<link linkend="GtkType">GtkType</link> type,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="gtk-widget-ref">gtk_widget_ref</link>                  (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-unref">gtk_widget_unref</link>                (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-destroy">gtk_widget_destroy</link>              (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-destroyed">gtk_widget_destroyed</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> **widget_pointer);
void        <link linkend="gtk-widget-set">gtk_widget_set</link>                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);
void        <link linkend="gtk-widget-unparent">gtk_widget_unparent</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-show">gtk_widget_show</link>                 (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-show-now">gtk_widget_show_now</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-hide">gtk_widget_hide</link>                 (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-show-all">gtk_widget_show_all</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-hide-all">gtk_widget_hide_all</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-map">gtk_widget_map</link>                  (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-unmap">gtk_widget_unmap</link>                (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-realize">gtk_widget_realize</link>              (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-unrealize">gtk_widget_unrealize</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-queue-draw">gtk_widget_queue_draw</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-queue-resize">gtk_widget_queue_resize</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-draw">gtk_widget_draw</link>                 (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *area);
void        <link linkend="gtk-widget-size-request">gtk_widget_size_request</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRequisition">GtkRequisition</link> *requisition);
void        <link linkend="gtk-widget-get-child-requisition">gtk_widget_get_child_requisition</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRequisition">GtkRequisition</link> *requisition);
void        <link linkend="gtk-widget-size-allocate">gtk_widget_size_allocate</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAllocation">GtkAllocation</link> *allocation);
void        <link linkend="gtk-widget-add-accelerator">gtk_widget_add_accelerator</link>      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *accel_signal,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group,
                                             <link linkend="guint">guint</link> accel_key,
                                             <link linkend="GdkModifierType">GdkModifierType</link> accel_mods,
                                             <link linkend="GtkAccelFlags">GtkAccelFlags</link> accel_flags);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-remove-accelerator">gtk_widget_remove_accelerator</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group,
                                             <link linkend="guint">guint</link> accel_key,
                                             <link linkend="GdkModifierType">GdkModifierType</link> accel_mods);
void        <link linkend="gtk-widget-set-accel-path">gtk_widget_set_accel_path</link>       (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *accel_path,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group);
<link linkend="GList">GList</link>*      <link linkend="gtk-widget-list-accel-closures">gtk_widget_list_accel_closures</link>  (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-event">gtk_widget_event</link>                (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkEvent">GdkEvent</link> *event);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-activate">gtk_widget_activate</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-reparent">gtk_widget_reparent</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *new_parent);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-intersect">gtk_widget_intersect</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *area,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *intersection);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-is-focus">gtk_widget_is_focus</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-grab-focus">gtk_widget_grab_focus</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-grab-default">gtk_widget_grab_default</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-name">gtk_widget_set_name</link>             (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *name);
G_CONST_RETURN <link linkend="gchar">gchar</link>* <link linkend="gtk-widget-get-name">gtk_widget_get_name</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-state">gtk_widget_set_state</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state);
void        <link linkend="gtk-widget-set-sensitive">gtk_widget_set_sensitive</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> sensitive);
void        <link linkend="gtk-widget-set-parent">gtk_widget_set_parent</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *parent);
void        <link linkend="gtk-widget-set-parent-window">gtk_widget_set_parent_window</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkWindow">GdkWindow</link> *parent_window);
<link linkend="GdkWindow">GdkWindow</link>*  <link linkend="gtk-widget-get-parent-window">gtk_widget_get_parent_window</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-uposition">gtk_widget_set_uposition</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y);
void        <link linkend="gtk-widget-set-usize">gtk_widget_set_usize</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);
void        <link linkend="gtk-widget-set-events">gtk_widget_set_events</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> events);
void        <link linkend="gtk-widget-add-events">gtk_widget_add_events</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> events);
void        <link linkend="gtk-widget-set-extension-events">gtk_widget_set_extension_events</link> (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkExtensionMode">GdkExtensionMode</link> mode);
<link linkend="GdkExtensionMode">GdkExtensionMode</link> <link linkend="gtk-widget-get-extension-events">gtk_widget_get_extension_events</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="gtk-widget-get-toplevel">gtk_widget_get_toplevel</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="gtk-widget-get-ancestor">gtk_widget_get_ancestor</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkType">GtkType</link> widget_type);
<link linkend="GdkColormap">GdkColormap</link>* <link linkend="gtk-widget-get-colormap">gtk_widget_get_colormap</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-colormap">gtk_widget_set_colormap</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkColormap">GdkColormap</link> *colormap);
<link linkend="GdkVisual">GdkVisual</link>*  <link linkend="gtk-widget-get-visual">gtk_widget_get_visual</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="gint">gint</link>        <link linkend="gtk-widget-get-events">gtk_widget_get_events</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-get-pointer">gtk_widget_get_pointer</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> *x,
                                             <link linkend="gint">gint</link> *y);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-is-ancestor">gtk_widget_is_ancestor</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *ancestor);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-translate-coordinates">gtk_widget_translate_coordinates</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *src_widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *dest_widget,
                                             <link linkend="gint">gint</link> src_x,
                                             <link linkend="gint">gint</link> src_y,
                                             <link linkend="gint">gint</link> *dest_x,
                                             <link linkend="gint">gint</link> *dest_y);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-hide-on-delete">gtk_widget_hide_on_delete</link>       (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-style">gtk_widget_set_style</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStyle">GtkStyle</link> *style);
#define     <link linkend="gtk-widget-set-rc-style">gtk_widget_set_rc_style</link>         (widget)
void        <link linkend="gtk-widget-ensure-style">gtk_widget_ensure_style</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GtkStyle">GtkStyle</link>*   <link linkend="gtk-widget-get-style">gtk_widget_get_style</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget);
#define     <link linkend="gtk-widget-restore-default-style">gtk_widget_restore_default_style</link>(widget)
void        <link linkend="gtk-widget-reset-rc-styles">gtk_widget_reset_rc_styles</link>      (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-push-colormap">gtk_widget_push_colormap</link>        (<link linkend="GdkColormap">GdkColormap</link> *cmap);
void        <link linkend="gtk-widget-pop-colormap">gtk_widget_pop_colormap</link>         (void);
void        <link linkend="gtk-widget-set-default-colormap">gtk_widget_set_default_colormap</link> (<link linkend="GdkColormap">GdkColormap</link> *colormap);
<link linkend="GtkStyle">GtkStyle</link>*   <link linkend="gtk-widget-get-default-style">gtk_widget_get_default_style</link>    (void);
<link linkend="GdkColormap">GdkColormap</link>* <link linkend="gtk-widget-get-default-colormap">gtk_widget_get_default_colormap</link>
                                            (void);
<link linkend="GdkVisual">GdkVisual</link>*  <link linkend="gtk-widget-get-default-visual">gtk_widget_get_default_visual</link>   (void);
void        <link linkend="gtk-widget-set-direction">gtk_widget_set_direction</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkTextDirection">GtkTextDirection</link> dir);
enum        <link linkend="GtkTextDirection">GtkTextDirection</link>;
<link linkend="GtkTextDirection">GtkTextDirection</link> <link linkend="gtk-widget-get-direction">gtk_widget_get_direction</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-default-direction">gtk_widget_set_default_direction</link>
                                            (<link linkend="GtkTextDirection">GtkTextDirection</link> dir);
<link linkend="GtkTextDirection">GtkTextDirection</link> <link linkend="gtk-widget-get-default-direction">gtk_widget_get_default_direction</link>
                                            (void);
void        <link linkend="gtk-widget-shape-combine-mask">gtk_widget_shape_combine_mask</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkBitmap">GdkBitmap</link> *shape_mask,
                                             <link linkend="gint">gint</link> offset_x,
                                             <link linkend="gint">gint</link> offset_y);
void        <link linkend="gtk-widget-path">gtk_widget_path</link>                 (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="guint">guint</link> *path_length,
                                             <link linkend="gchar">gchar</link> **path,
                                             <link linkend="gchar">gchar</link> **path_reversed);
void        <link linkend="gtk-widget-class-path">gtk_widget_class_path</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="guint">guint</link> *path_length,
                                             <link linkend="gchar">gchar</link> **path,
                                             <link linkend="gchar">gchar</link> **path_reversed);
<link linkend="gchar">gchar</link>*      <link linkend="gtk-widget-get-composite-name">gtk_widget_get_composite_name</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRcStyle">GtkRcStyle</link> *style);
<link linkend="GtkRcStyle">GtkRcStyle</link>* <link linkend="gtk-widget-get-modifier-style">gtk_widget_get_modifier_style</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-modify-fg">gtk_widget_modify_fg</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);
void        <link linkend="gtk-widget-modify-bg">gtk_widget_modify_bg</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);
void        <link linkend="gtk-widget-modify-text">gtk_widget_modify_text</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);
void        <link linkend="gtk-widget-modify-base">gtk_widget_modify_base</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);
void        <link linkend="gtk-widget-modify-font">gtk_widget_modify_font</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="PangoFontDescription">PangoFontDescription</link> *font_desc);
<link linkend="PangoContext">PangoContext</link>* <link linkend="gtk-widget-create-pango-context">gtk_widget_create_pango_context</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="PangoContext">PangoContext</link>* <link linkend="gtk-widget-get-pango-context">gtk_widget_get_pango_context</link>  (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="PangoLayout">PangoLayout</link>* <link linkend="gtk-widget-create-pango-layout">gtk_widget_create_pango_layout</link> (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *text);
<link linkend="GdkPixbuf">GdkPixbuf</link>*  <link linkend="gtk-widget-render-icon">gtk_widget_render_icon</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *stock_id,
                                             <link linkend="GtkIconSize">GtkIconSize</link> size,
                                             const <link linkend="gchar">gchar</link> *detail);
void        <link linkend="gtk-widget-pop-composite-child">gtk_widget_pop_composite_child</link>  (void);
void        <link linkend="gtk-widget-push-composite-child">gtk_widget_push_composite_child</link> (void);
void        <link linkend="gtk-widget-queue-clear">gtk_widget_queue_clear</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-queue-clear-area">gtk_widget_queue_clear_area</link>     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);
void        <link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);
void        <link linkend="gtk-widget-reset-shapes">gtk_widget_reset_shapes</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-set-app-paintable">gtk_widget_set_app_paintable</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> app_paintable);
void        <link linkend="gtk-widget-set-double-buffered">gtk_widget_set_double_buffered</link>  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> double_buffered);
void        <link linkend="gtk-widget-set-redraw-on-allocate">gtk_widget_set_redraw_on_allocate</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> redraw_on_allocate);
void        <link linkend="gtk-widget-set-composite-name">gtk_widget_set_composite_name</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *name);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-set-scroll-adjustments">gtk_widget_set_scroll_adjustments</link>
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAdjustment">GtkAdjustment</link> *hadjustment,
                                             <link linkend="GtkAdjustment">GtkAdjustment</link> *vadjustment);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-mnemonic-activate">gtk_widget_mnemonic_activate</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> group_cycling);
void        <link linkend="gtk-widget-class-install-style-property">gtk_widget_class_install_style_property</link>
                                            (<link linkend="GtkWidgetClass">GtkWidgetClass</link> *klass,
                                             <link linkend="GParamSpec">GParamSpec</link> *pspec);
void        <link linkend="gtk-widget-class-install-style-property-parser">gtk_widget_class_install_style_property_parser</link>
                                            (<link linkend="GtkWidgetClass">GtkWidgetClass</link> *klass,
                                             <link linkend="GParamSpec">GParamSpec</link> *pspec,
                                             <link linkend="GtkRcPropertyParser">GtkRcPropertyParser</link> parser);
<link linkend="GdkRegion">GdkRegion</link>*  <link linkend="gtk-widget-region-intersect">gtk_widget_region_intersect</link>     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRegion">GdkRegion</link> *region);
<link linkend="gint">gint</link>        <link linkend="gtk-widget-send-expose">gtk_widget_send_expose</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkEvent">GdkEvent</link> *event);
void        <link linkend="gtk-widget-style-get">gtk_widget_style_get</link>            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);
void        <link linkend="gtk-widget-style-get-property">gtk_widget_style_get_property</link>   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *property_name,
                                             <link linkend="GValue">GValue</link> *value);
void        <link linkend="gtk-widget-style-get-valist">gtk_widget_style_get_valist</link>     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             va_list var_args);
<link linkend="AtkObject">AtkObject</link>*  <link linkend="gtk-widget-get-accessible">gtk_widget_get_accessible</link>       (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-child-focus">gtk_widget_child_focus</link>          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkDirectionType">GtkDirectionType</link> direction);
void        <link linkend="gtk-widget-child-notify">gtk_widget_child_notify</link>         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *child_property);
void        <link linkend="gtk-widget-freeze-child-notify">gtk_widget_freeze_child_notify</link>  (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="gboolean">gboolean</link>    <link linkend="gtk-widget-get-child-visible">gtk_widget_get_child_visible</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="gtk-widget-get-parent">gtk_widget_get_parent</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GtkSettings">GtkSettings</link>* <link linkend="gtk-widget-get-settings">gtk_widget_get_settings</link>        (<link linkend="GtkWidget">GtkWidget</link> *widget);
void        <link linkend="gtk-widget-get-size-request">gtk_widget_get_size_request</link>     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> *width,
                                             <link linkend="gint">gint</link> *height);
#define     <link linkend="gtk-widget-pop-visual">gtk_widget_pop_visual</link>           ()
#define     <link linkend="gtk-widget-push-visual">gtk_widget_push_visual</link>          (visual)
void        <link linkend="gtk-widget-set-child-visible">gtk_widget_set_child_visible</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> is_visible);
#define     <link linkend="gtk-widget-set-default-visual">gtk_widget_set_default_visual</link>   (visual)
void        <link linkend="gtk-widget-set-size-request">gtk_widget_set_size_request</link>     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);
#define     <link linkend="gtk-widget-set-visual">gtk_widget_set_visual</link>           (widget,visual)
void        <link linkend="gtk-widget-thaw-child-notify">gtk_widget_thaw_child_notify</link>    (<link linkend="GtkWidget">GtkWidget</link> *widget);

<link linkend="GtkRequisition">GtkRequisition</link>* <link linkend="gtk-requisition-copy">gtk_requisition_copy</link>        (const <link linkend="GtkRequisition">GtkRequisition</link> *requisition);
void        <link linkend="gtk-requisition-free">gtk_requisition_free</link>            (<link linkend="GtkRequisition">GtkRequisition</link> *requisition);


</synopsis>
</refsynopsisdiv>

<refsect1>
<title>Object Hierarchy</title>
<synopsis>

  <link linkend="GObject">GObject</link>
   +----<link linkend="GtkObject">GtkObject</link>
         +----GtkWidget
</synopsis>

</refsect1>

<refsect1>
<title>Properties</title>
<synopsis>

  &quot;<link linkend="GtkWidget--name">name</link>&quot;                 <link linkend="gchararray">gchararray</link>           : Read / Write
  &quot;<link linkend="GtkWidget--parent">parent</link>&quot;               <link linkend="GtkContainer">GtkContainer</link>         : Read / Write
  &quot;<link linkend="GtkWidget--width-request">width-request</link>&quot;        <link linkend="gint">gint</link>                 : Read / Write
  &quot;<link linkend="GtkWidget--height-request">height-request</link>&quot;       <link linkend="gint">gint</link>                 : Read / Write
  &quot;<link linkend="GtkWidget--visible">visible</link>&quot;              <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--sensitive">sensitive</link>&quot;            <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--app-paintable">app-paintable</link>&quot;        <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--can-focus">can-focus</link>&quot;            <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--has-focus">has-focus</link>&quot;            <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--can-default">can-default</link>&quot;          <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--has-default">has-default</link>&quot;          <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--receives-default">receives-default</link>&quot;     <link linkend="gboolean">gboolean</link>             : Read / Write
  &quot;<link linkend="GtkWidget--composite-child">composite-child</link>&quot;      <link linkend="gboolean">gboolean</link>             : Read
  &quot;<link linkend="GtkWidget--style">style</link>&quot;                <link linkend="GtkStyle">GtkStyle</link>             : Read / Write
  &quot;<link linkend="GtkWidget--events">events</link>&quot;               <link linkend="GdkEventMask">GdkEventMask</link>         : Read / Write
  &quot;<link linkend="GtkWidget--extension-events">extension-events</link>&quot;     <link linkend="GdkExtensionMode">GdkExtensionMode</link>     : Read / Write
</synopsis>
</refsect1>

<refsect1>
<title>Signal Prototypes</title>
<synopsis>

&quot;<link linkend="GtkWidget-accel-closures-changed">accel-closures-changed</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-button-press-event">button-press-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventButton">GdkEventButton</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-button-release-event">button-release-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventButton">GdkEventButton</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-child-notify">child-notify</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GParam">GParam</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-client-event">client-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventClient">GdkEventClient</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-configure-event">configure-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventConfigure">GdkEventConfigure</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-delete-event">delete-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-destroy-event">destroy-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-direction-changed">direction-changed</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkTextDirection">GtkTextDirection</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-begin">drag-begin</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-data-delete">drag-data-delete</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-data-get">drag-data-get</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-data-received">drag-data-received</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-drop">drag-drop</link>&quot; <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-end">drag-end</link>&quot;  void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-leave">drag-leave</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-drag-motion">drag-motion</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-enter-notify-event">enter-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventCrossing">GdkEventCrossing</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-event">event</link>&quot;     <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-event-after">event-after</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-expose-event">expose-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventExpose">GdkEventExpose</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-focus">focus</link>&quot;     <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkDirectionType">GtkDirectionType</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-focus-in-event">focus-in-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventFocus">GdkEventFocus</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-focus-out-event">focus-out-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventFocus">GdkEventFocus</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-grab-focus">grab-focus</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-grab-notify">grab-notify</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gboolean">gboolean</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-hide">hide</link>&quot;      void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-hierarchy-changed">hierarchy-changed</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-key-press-event">key-press-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventKey">GdkEventKey</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-key-release-event">key-release-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventKey">GdkEventKey</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-leave-notify-event">leave-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventCrossing">GdkEventCrossing</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-map">map</link>&quot;       void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-map-event">map-event</link>&quot; <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-mnemonic-activate">mnemonic-activate</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gboolean">gboolean</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-motion-notify-event">motion-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventMotion">GdkEventMotion</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-no-expose-event">no-expose-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventNoExpose">GdkEventNoExpose</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-parent-set">parent-set</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkObject">GtkObject</link> *old_parent,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-popup-menu">popup-menu</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-property-notify-event">property-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProperty">GdkEventProperty</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-proximity-in-event">proximity-in-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProximity">GdkEventProximity</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-proximity-out-event">proximity-out-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProximity">GdkEventProximity</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-realize">realize</link>&quot;   void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-scroll-event">scroll-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-selection-clear-event">selection-clear-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-selection-get">selection-get</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-selection-notify-event">selection-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-selection-received">selection-received</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-selection-request-event">selection-request-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-show">show</link>&quot;      void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-show-help">show-help</link>&quot; <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkWidgetHelpType">GtkWidgetHelpType</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-size-allocate">size-allocate</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkAllocation">GtkAllocation</link> *allocation,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-size-request">size-request</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkRequisition">GtkRequisition</link> *requisition,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-state-changed">state-changed</link>&quot;
            void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkStateType">GtkStateType</link> state,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-style-set">style-set</link>&quot; void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkStyle">GtkStyle</link> *previous_style,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-unmap">unmap</link>&quot;     void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-unmap-event">unmap-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-unrealize">unrealize</link>&quot; void        user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-visibility-notify-event">visibility-notify-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
&quot;<link linkend="GtkWidget-window-state-event">window-state-event</link>&quot;
            <link linkend="gboolean">gboolean</link>    user_function      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);
</synopsis>
</refsect1>


<refsect1>
<title>Description</title>
<para>

</para>
</refsect1>

<refsect1>
<title>Details</title>
<refsect2>
<title><anchor id="GtkWidget-struct">struct GtkWidget</title>
<programlisting>struct GtkWidget;</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkWidgetClass">struct GtkWidgetClass</title>
<programlisting>struct GtkWidgetClass;</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkWidgetFlags">enum GtkWidgetFlags</title>
<programlisting>typedef enum
{
  GTK_TOPLEVEL         = 1 &lt;&lt; 4,
  GTK_NO_WINDOW        = 1 &lt;&lt; 5,
  GTK_REALIZED         = 1 &lt;&lt; 6,
  GTK_MAPPED           = 1 &lt;&lt; 7,
  GTK_VISIBLE          = 1 &lt;&lt; 8,
  GTK_SENSITIVE        = 1 &lt;&lt; 9,
  GTK_PARENT_SENSITIVE = 1 &lt;&lt; 10,
  GTK_CAN_FOCUS        = 1 &lt;&lt; 11,
  GTK_HAS_FOCUS        = 1 &lt;&lt; 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 &lt;&lt; 13,

  /* the widget currently is receiving the default action and should be drawn
   * appropriately if possible
   */
  GTK_HAS_DEFAULT      = 1 &lt;&lt; 14,

  GTK_HAS_GRAB	       = 1 &lt;&lt; 15,
  GTK_RC_STYLE	       = 1 &lt;&lt; 16,
  GTK_COMPOSITE_CHILD  = 1 &lt;&lt; 17,
  GTK_NO_REPARENT      = 1 &lt;&lt; 18,
  GTK_APP_PAINTABLE    = 1 &lt;&lt; 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 &lt;&lt; 20,

  GTK_DOUBLE_BUFFERED  = 1 &lt;&lt; 21
} GtkWidgetFlags;
</programlisting>
<para>
Tells about certain properties of the widget.
</para><informaltable pgwide="1" frame="none" role="enum">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><literal>GTK_TOPLEVEL</literal></entry>
<entry>
        widgets without a real parent, as there are <link linkend="GtkWindow">GtkWindow</link><!-- -->s and
        <link linkend="GtkMenu">GtkMenu</link><!-- -->s have this flag set throughout their lifetime.
        Toplevel widgets always contain their own <link linkend="GdkWindow">GdkWindow</link>.
</entry>
</row>
<row>
<entry><literal>GTK_NO_WINDOW</literal></entry>
<entry>
        Indicative for a widget that does not provide its own <link linkend="GdkWindow">GdkWindow</link>. 
        Visible action (e.g. drawing) is performed on the parent's <link linkend="GdkWindow">GdkWindow</link>.
</entry>
</row>
<row>
<entry><literal>GTK_REALIZED</literal></entry>
<entry>
        Set by <link linkend="gtk-widget-realize">gtk_widget_realize</link>(), unset by <link linkend="gtk-widget-unrealize">gtk_widget_unrealize</link>().
        A realized widget has an associated <link linkend="GdkWindow">GdkWindow</link>.
</entry>
</row>
<row>
<entry><literal>GTK_MAPPED</literal></entry>
<entry>
        Set by <link linkend="gtk-widget-map">gtk_widget_map</link>(), unset by <link linkend="gtk-widget-unmap">gtk_widget_unmap</link>().
        Only realized widgets can be mapped. It means that <link linkend="gdk-window-show">gdk_window_show</link>() 
        has been called on the widgets window(s).
</entry>
</row>
<row>
<entry><literal>GTK_VISIBLE</literal></entry>
<entry>
        Set by <link linkend="gtk-widget-show">gtk_widget_show</link>(), unset by <link linkend="gtk-widget-hide">gtk_widget_hide</link>(). Implies that a 
        widget will be mapped as soon as its parent is mapped.
</entry>
</row>
<row>
<entry><literal>GTK_SENSITIVE</literal></entry>
<entry>
        Set and unset by <link linkend="gtk-widget-set-sensitive">gtk_widget_set_sensitive</link>().
        The sensitivity of a widget determines whether it will receive
        certain events (e.g. button or key presses). One premise for
        the widgets sensitivity is to have this flag set.
</entry>
</row>
<row>
<entry><literal>GTK_PARENT_SENSITIVE</literal></entry>
<entry>
        Set and unset by <link linkend="gtk-widget-set-sensitive">gtk_widget_set_sensitive</link>() operations on the
        parents of the widget.
        This is the second premise for the widgets sensitivity. Once
        it has <literal>GTK_SENSITIVE</literal> and <literal>GTK_PARENT_SENSITIVE</literal> set, its state is
        effectively sensitive. This is expressed (and can be examined) by
        the <link linkend="GTK-WIDGET-IS-SENSITIVE-CAPS">GTK_WIDGET_IS_SENSITIVE</link> macro.
</entry>
</row>
<row>
<entry><literal>GTK_CAN_FOCUS</literal></entry>
<entry>
        Determines whether a widget is able to handle focus grabs.
</entry>
</row>
<row>
<entry><literal>GTK_HAS_FOCUS</literal></entry>
<entry>
        Set by <link linkend="gtk-widget-grab-focus">gtk_widget_grab_focus</link>() for widgets that also
        have <literal>GTK_CAN_FOCUS</literal> set. The flag will be unset once another widget
        grabs the focus.
</entry>
</row>
<row>
<entry><literal>GTK_CAN_DEFAULT</literal></entry>
<entry>
        The widget is allowed to receive the default action via 
        <link linkend="gtk-widget-grab-default">gtk_widget_grab_default</link>().
</entry>
</row>
<row>
<entry><literal>GTK_HAS_DEFAULT</literal></entry>
<entry>
        The widget currently is receiving the default action.
</entry>
</row>
<row>
<entry><literal>GTK_HAS_GRAB</literal></entry>
<entry>
        Set by <link linkend="gtk-grab-add">gtk_grab_add</link>(), unset by <link linkend="gtk-grab-remove">gtk_grab_remove</link>(). 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.
</entry>
</row>
<row>
<entry><literal>GTK_RC_STYLE</literal></entry>
<entry>
        Indicates that the widgets 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.
</entry>
</row>
<row>
<entry><literal>GTK_COMPOSITE_CHILD</literal></entry>
<entry>
        Indicates that the widget is a composite child of its parent; see 
        <link linkend="gtk-widget-push-composite-child">gtk_widget_push_composite_child</link>(), <link linkend="gtk-widget-pop-composite-child">gtk_widget_pop_composite_child</link>().
</entry>
</row>
<row>
<entry><literal>GTK_NO_REPARENT</literal></entry>
<entry>
	Unused since before GTK+ 1.2, will be removed in a future version.
</entry>
</row>
<row>
<entry><literal>GTK_APP_PAINTABLE</literal></entry>
<entry>
        Set and unset by <link linkend="gtk-widget-set-app-paintable">gtk_widget_set_app_paintable</link>().
        Must be set on widgets whose window the application directly draws on, 
	in order to keep GTK+ from overwriting the drawn stuff.
</entry>
</row>
<row>
<entry><literal>GTK_RECEIVES_DEFAULT</literal></entry>
<entry>
        The widget when focused will receive the default action and have 
        <literal>GTK_HAS_DEFAULT</literal> set even if there is a different widget set as default.
</entry>
</row>
<row>
<entry><literal>GTK_DOUBLE_BUFFERED</literal></entry>
<entry>
        Set and unset by <link linkend="gtk-widget-set-double-buffered">gtk_widget_set_double_buffered</link>().
        Indicates that exposes done on the widget should be double-buffered.

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-TYPE-CAPS">GTK_WIDGET_TYPE()</title>
<programlisting>#define GTK_WIDGET_TYPE(wid)		  (GTK_OBJECT_TYPE (wid))
</programlisting>
<para>
Gets the type of a widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-STATE-CAPS">GTK_WIDGET_STATE()</title>
<programlisting>#define GTK_WIDGET_STATE(wid)		  (GTK_WIDGET (wid)-&gt;state)
</programlisting>
<para>
Returns the current state of the widget, as a <link linkend="GtkStateType">GtkStateType</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-SAVED-STATE-CAPS">GTK_WIDGET_SAVED_STATE()</title>
<programlisting>#define GTK_WIDGET_SAVED_STATE(wid)	  (GTK_WIDGET (wid)-&gt;saved_state)
</programlisting>
<para>
Returns the saved state of the widget, as a <link linkend="GtkStateType">GtkStateType</link>.
</para>
<para>
The saved state will be restored when a widget gets sensitive
again, after it has been made insensitive with <link linkend="gtk-widget-set-state">gtk_widget_set_state</link>()
or <link linkend="gtk-widget-set-sensitive">gtk_widget_set_sensitive</link>().
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-FLAGS-CAPS">GTK_WIDGET_FLAGS()</title>
<programlisting>#define GTK_WIDGET_FLAGS(wid)		  (GTK_OBJECT_FLAGS (wid))
</programlisting>
<para>
Returns the widget flags from <parameter>wid</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-TOPLEVEL-CAPS">GTK_WIDGET_TOPLEVEL()</title>
<programlisting>#define GTK_WIDGET_TOPLEVEL(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_TOPLEVEL) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is a toplevel widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-NO-WINDOW-CAPS">GTK_WIDGET_NO_WINDOW()</title>
<programlisting>#define GTK_WIDGET_NO_WINDOW(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_NO_WINDOW) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget doesn't have an own <link linkend="GdkWindow">GdkWindow</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-REALIZED-CAPS">GTK_WIDGET_REALIZED()</title>
<programlisting>#define GTK_WIDGET_REALIZED(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_REALIZED) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is realized.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-MAPPED-CAPS">GTK_WIDGET_MAPPED()</title>
<programlisting>#define GTK_WIDGET_MAPPED(wid)		  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_MAPPED) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is mapped.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-VISIBLE-CAPS">GTK_WIDGET_VISIBLE()</title>
<programlisting>#define GTK_WIDGET_VISIBLE(wid)		  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_VISIBLE) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is visible.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-DRAWABLE-CAPS">GTK_WIDGET_DRAWABLE()</title>
<programlisting>#define GTK_WIDGET_DRAWABLE(wid)	  (GTK_WIDGET_VISIBLE (wid) &amp;&amp; GTK_WIDGET_MAPPED (wid))
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is mapped and visible.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-SENSITIVE-CAPS">GTK_WIDGET_SENSITIVE()</title>
<programlisting>#define GTK_WIDGET_SENSITIVE(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_SENSITIVE) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the <link linkend="GTK-SENSITIVE-CAPS">GTK_SENSITIVE</link> flag has be set on the widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-PARENT-SENSITIVE-CAPS">GTK_WIDGET_PARENT_SENSITIVE()</title>
<programlisting>#define GTK_WIDGET_PARENT_SENSITIVE(wid)  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_PARENT_SENSITIVE) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the <link linkend="GTK-PARENT-SENSITIVE-CAPS">GTK_PARENT_SENSITIVE</link> flag has be set on the widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-IS-SENSITIVE-CAPS">GTK_WIDGET_IS_SENSITIVE()</title>
<programlisting>#define     GTK_WIDGET_IS_SENSITIVE(wid)</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is effectively sensitive.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-CAN-FOCUS-CAPS">GTK_WIDGET_CAN_FOCUS()</title>
<programlisting>#define GTK_WIDGET_CAN_FOCUS(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_CAN_FOCUS) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is able to handle focus grabs.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-HAS-FOCUS-CAPS">GTK_WIDGET_HAS_FOCUS()</title>
<programlisting>#define GTK_WIDGET_HAS_FOCUS(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_HAS_FOCUS) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget has grabbed the focus and no other
widget has done so more recently.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-CAN-DEFAULT-CAPS">GTK_WIDGET_CAN_DEFAULT()</title>
<programlisting>#define GTK_WIDGET_CAN_DEFAULT(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_CAN_DEFAULT) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is allowed to receive the default action 
via <link linkend="gtk-widget-grab-default">gtk_widget_grab_default</link>(). 
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-RECEIVES-DEFAULT-CAPS">GTK_WIDGET_RECEIVES_DEFAULT()</title>
<programlisting>#define GTK_WIDGET_RECEIVES_DEFAULT(wid)  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_RECEIVES_DEFAULT) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget when focused will receive the default action 
even if there is a different widget set as default.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-HAS-DEFAULT-CAPS">GTK_WIDGET_HAS_DEFAULT()</title>
<programlisting>#define GTK_WIDGET_HAS_DEFAULT(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_HAS_DEFAULT) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget currently is receiving the default action.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-HAS-GRAB-CAPS">GTK_WIDGET_HAS_GRAB()</title>
<programlisting>#define GTK_WIDGET_HAS_GRAB(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_HAS_GRAB) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is in the grab_widgets stack, and will be 
the preferred one for receiving events other than ones of cosmetic value.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-RC-STYLE-CAPS">GTK_WIDGET_RC_STYLE()</title>
<programlisting>#define GTK_WIDGET_RC_STYLE(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_RC_STYLE) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widgets style has been looked up through the rc
mechanism.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-COMPOSITE-CHILD-CAPS">GTK_WIDGET_COMPOSITE_CHILD()</title>
<programlisting>#define GTK_WIDGET_COMPOSITE_CHILD(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_COMPOSITE_CHILD) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the widget is a composite child of its parent.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-APP-PAINTABLE-CAPS">GTK_WIDGET_APP_PAINTABLE()</title>
<programlisting>#define GTK_WIDGET_APP_PAINTABLE(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_APP_PAINTABLE) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the <link linkend="GTK-APP-PAINTABLE-CAPS">GTK_APP_PAINTABLE</link> flag has been set on the widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-DOUBLE-BUFFERED-CAPS">GTK_WIDGET_DOUBLE_BUFFERED()</title>
<programlisting>#define GTK_WIDGET_DOUBLE_BUFFERED(wid)	  ((GTK_WIDGET_FLAGS (wid) &amp; GTK_DOUBLE_BUFFERED) != 0)
</programlisting>
<para>
Evaluates to <literal>TRUE</literal> if the <link linkend="GTK-DOUBLE-BUFFERED-CAPS">GTK_DOUBLE_BUFFERED</link> flag has been set on the widget.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-SET-FLAGS-CAPS">GTK_WIDGET_SET_FLAGS()</title>
<programlisting>#define GTK_WIDGET_SET_FLAGS(wid,flag)	  G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END
</programlisting>
<para>
Turns on certain widget flags.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>flag</parameter>&nbsp;:</entry>
<entry>the flags to set.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GTK-WIDGET-UNSET-FLAGS-CAPS">GTK_WIDGET_UNSET_FLAGS()</title>
<programlisting>#define GTK_WIDGET_UNSET_FLAGS(wid,flag)  G_STMT_START{ (GTK_WIDGET_FLAGS (wid) &amp;= ~(flag)); }G_STMT_END
</programlisting>
<para>
Turns off certain widget flags.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>wid</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>flag</parameter>&nbsp;:</entry>
<entry>the flags to unset.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GtkCallback">GtkCallback ()</title>
<programlisting>void        (*GtkCallback)                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gpointer">gpointer</link> data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GtkRequisition">struct GtkRequisition</title>
<programlisting>struct GtkRequisition
{
  gint width;
  gint height;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkAllocation">struct GtkAllocation</title>
<programlisting>struct GtkAllocation
{
  gint x;
  gint y;
  gint width;
  gint height;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkSelectionData">struct GtkSelectionData</title>
<programlisting>struct GtkSelectionData
{
  GdkAtom selection;
  GdkAtom target;
  GdkAtom type;
  gint	  format;
  guchar *data;  
  gint	  length;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkWidgetAuxInfo">struct GtkWidgetAuxInfo</title>
<programlisting>struct GtkWidgetAuxInfo
{
  gint x;
  gint y;
  gint width;
  gint height;
  guint x_set : 1;
  guint y_set : 1;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkWidgetShapeInfo">struct GtkWidgetShapeInfo</title>
<programlisting>struct GtkWidgetShapeInfo
{
  gint16     offset_x;
  gint16     offset_y;
  GdkBitmap *shape_mask;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GtkWidgetHelpType">enum GtkWidgetHelpType</title>
<programlisting>typedef enum
{
  GTK_WIDGET_HELP_TOOLTIP,
  GTK_WIDGET_HELP_WHATS_THIS
} GtkWidgetHelpType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-new">gtk_widget_new ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  gtk_widget_new                  (<link linkend="GtkType">GtkType</link> type,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);</programlisting>
<para>
This is a convenience function for creating a widget and setting
its properties in one go. For example you might write:
<literal>gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign",
0.0, NULL)</literal> to create a left-aligned label. Equivalent to
<link linkend="gtk-object-new">gtk_object_new</link>(), but returns a widget so you don't have to
cast the object yourself.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>type</parameter>&nbsp;:</entry>
<entry> type ID of the widget to create
</entry></row>
<row><entry align="right"><parameter>first_property_name</parameter>&nbsp;:</entry>
<entry> name of first property to set
</entry></row>
<row><entry align="right"><parameter>...</parameter>&nbsp;:</entry>
<entry> value of first property, followed by more properties, <literal>NULL</literal>-terminated
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> a new <link linkend="GtkWidget">GtkWidget</link> of type <parameter>widget_type</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-ref">gtk_widget_ref ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  gtk_widget_ref                  (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Adds a reference to a widget. This function is exactly the same
as calling <link linkend="g-object-ref">g_object_ref</link>(), and exists mostly for historical
reasons. It can still be convenient to avoid casting a widget
to a <link linkend="GObject">GObject</link>, it saves a small amount of typing.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the widget that was referenced
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-unref">gtk_widget_unref ()</title>
<programlisting>void        gtk_widget_unref                (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Inverse of <link linkend="gtk-widget-ref">gtk_widget_ref</link>(). Equivalent to <link linkend="g-object-unref">g_object_unref</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-destroy">gtk_widget_destroy ()</title>
<programlisting>void        gtk_widget_destroy              (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Destroys a widget. Equivalent to <link linkend="gtk-object-destroy">gtk_object_destroy</link>(), except that
you don't have to cast the widget to <link linkend="GtkObject">GtkObject</link>. When a widget is
destroyed, it will break any references it holds to other objects.
If the widget is inside a container, the widget will be removed
from the container. If the widget is a toplevel (derived from
<link linkend="GtkWindow">GtkWindow</link>), it will be removed from the list of toplevels, and the
reference GTK+ holds to it will be removed. Removing a
widget from its container or the list of toplevels results in the
widget being finalized, unless you've added additional references
to the widget with <link linkend="gtk-object-ref">gtk_object_ref</link>().
</para>
<para>
In most cases, only toplevel widgets (windows) require explicit
destruction, because when you destroy a toplevel its children will
be destroyed as well.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-destroyed">gtk_widget_destroyed ()</title>
<programlisting>void        gtk_widget_destroyed            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> **widget_pointer);</programlisting>
<para>
This function sets *<parameter>widget_pointer</parameter> to <literal>NULL</literal> if <parameter>widget_pointer</parameter> !=
<literal>NULL</literal>.  It's intended to be used as a callback connected to the
"destroy" signal of a widget. You connect <link linkend="gtk-widget-destroyed">gtk_widget_destroyed</link>()
as a signal handler, and pass the address of your widget variable
as user data. Then when the widget is destroyed, the variable will
be set to <literal>NULL</literal>. Useful for example to avoid multiple copies
of the same dialog.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>widget_pointer</parameter>&nbsp;:</entry>
<entry> address of a variable that contains <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set">gtk_widget_set ()</title>
<programlisting>void        gtk_widget_set                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);</programlisting>
<warning>
<para>
<literal>gtk_widget_set</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
Like <link linkend="gtk-object-set">gtk_object_set</link>() - there's no reason to use this instead of
<link linkend="gtk-object-set">gtk_object_set</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>first_property_name</parameter>&nbsp;:</entry>
<entry> name of first property to set
</entry></row>
<row><entry align="right"><parameter>...</parameter>&nbsp;:</entry>
<entry> value of first property, followed by more properties, <literal>NULL</literal>-terminated
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-unparent">gtk_widget_unparent ()</title>
<programlisting>void        gtk_widget_unparent             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is only for use in widget implementations.
Should be called by implementations of the remove method
on <link linkend="GtkContainer">GtkContainer</link>, to dissociate a child from the container.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-show">gtk_widget_show ()</title>
<programlisting>void        gtk_widget_show                 (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Flags a widget to be displayed. Any widget that isn't shown will
not appear on the screen. If you want to show all the widgets in a
container, it's easier to call <link linkend="gtk-widget-show-all">gtk_widget_show_all</link>() on the
container, instead of individually showing the widgets.
</para>
<para>
Remember that you have to show the containers containing a widget,
in addition to the widget itself, before it will appear onscreen.
</para>
<para>
When a toplevel container is shown, it is immediately realized and
mapped; other shown widgets are realized and mapped when their
toplevel container is realized and mapped.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-show-now">gtk_widget_show_now ()</title>
<programlisting>void        gtk_widget_show_now             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Shows a widget. If the widget is an unmapped toplevel widget
(i.e. a <link linkend="GtkWindow">GtkWindow</link> that has not yet been shown), enter the main
loop and wait for the window to actually be mapped. Be careful;
because the main loop is running, anything can happen during
this function.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-hide">gtk_widget_hide ()</title>
<programlisting>void        gtk_widget_hide                 (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Reverses the effects of <link linkend="gtk-widget-show">gtk_widget_show</link>(), causing the widget to be
hidden (invisible to the user).</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-show-all">gtk_widget_show_all ()</title>
<programlisting>void        gtk_widget_show_all             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Recursively shows a widget, and any child widgets (if the widget is
a container).</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-hide-all">gtk_widget_hide_all ()</title>
<programlisting>void        gtk_widget_hide_all             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Recursively hides a widget and any child widgets.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-map">gtk_widget_map ()</title>
<programlisting>void        gtk_widget_map                  (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is only for use in widget implementations. Causes
a widget to be mapped if it isn't already.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-unmap">gtk_widget_unmap ()</title>
<programlisting>void        gtk_widget_unmap                (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is only for use in widget implementations. Causes
a widget to be unmapped if it's currently mapped.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-realize">gtk_widget_realize ()</title>
<programlisting>void        gtk_widget_realize              (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Creates the GDK (windowing system) resources associated with a
widget.  For example, <parameter>widget</parameter>->window will be created when a widget
is realized.  Normally realization happens implicitly; if you show
a widget and all its parent containers, then the widget will be
realized and mapped automatically.
</para>
<para>
Realizing a widget requires all
the widget's parent widgets to be realized; calling
<link linkend="gtk-widget-realize">gtk_widget_realize</link>() realizes the widget's parents in addition to
<parameter>widget</parameter> itself. If a widget is not yet inside a toplevel window
when you realize it, bad things will happen.
</para>
<para>
This function is primarily used in widget implementations, and
isn't very useful otherwise. Many times when you think you might
need it, a better approach is to connect to a signal that will be
called after the widget is realized automatically, such as
"expose_event". Or simply <link linkend="gtk-signal-connect-after">gtk_signal_connect_after</link>() to the
"realize" signal.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-unrealize">gtk_widget_unrealize ()</title>
<programlisting>void        gtk_widget_unrealize            (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is only useful in widget implementations.
Causes a widget to be unrealized (frees all GDK resources
associated with the widget, such as <parameter>widget</parameter>->window).</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-queue-draw">gtk_widget_queue_draw ()</title>
<programlisting>void        gtk_widget_queue_draw           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Equivalent to calling <link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>() for the
entire area of a widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-queue-resize">gtk_widget_queue_resize ()</title>
<programlisting>void        gtk_widget_queue_resize         (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is only for use in widget implementations.
Flags a widget to have its size renegotiated; should
be called when a widget for some reason has a new size request.
For example, when you change the text in a <link linkend="GtkLabel">GtkLabel</link>, <link linkend="GtkLabel">GtkLabel</link>
queues a resize to ensure there's enough space for the new text.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-draw">gtk_widget_draw ()</title>
<programlisting>void        gtk_widget_draw                 (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *area);</programlisting>
<warning>
<para>
<literal>gtk_widget_draw</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
DEPRECATED. In GTK+ 1.2, this function would immediately render the
region <parameter>area</parameter> of a widget, by invoking the virtual draw method of a
widget. In GTK+ 2.0, the draw method is gone, and instead
<link linkend="gtk-widget-draw">gtk_widget_draw</link>() simply invalidates the specified region of the
widget, then updates the invalid region of the widget immediately.
Usually you don't want to update the region immediately for
performance reasons, so in general <link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>() is
a better choice if you want to draw a region of a widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>area</parameter>&nbsp;:</entry>
<entry> area to draw
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-size-request">gtk_widget_size_request ()</title>
<programlisting>void        gtk_widget_size_request         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRequisition">GtkRequisition</link> *requisition);</programlisting>
<para>
This function is typically used when implementing a <link linkend="GtkContainer">GtkContainer</link>
subclass.  Obtains the preferred size of a widget. The container
uses this information to arrange its child widgets and decide what
size allocations to give them with <link linkend="gtk-widget-size-allocate">gtk_widget_size_allocate</link>().
</para>
<para>
You can also call this function from an application, with some
caveats. Most notably, getting a size request requires the widget
to be associated with a screen, because font information may be
needed. Multihead-aware applications should keep this in mind.
</para>
<para>
Also remember that the size request is not necessarily the size
a widget will actually be allocated.
</para>
<para>
See also <link linkend="gtk-widget-get-child-requisition">gtk_widget_get_child_requisition</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>requisition</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkRequisition">GtkRequisition</link> to be filled in
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-child-requisition">gtk_widget_get_child_requisition ()</title>
<programlisting>void        gtk_widget_get_child_requisition
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRequisition">GtkRequisition</link> *requisition);</programlisting>
<para>
This function is only for use in widget implementations. Obtains
<parameter>widget</parameter>->requisition, unless someone has forced a particular
geometry on the widget (e.g. with <link linkend="gtk-widget-set-usize">gtk_widget_set_usize</link>()), in which
case it returns that geometry instead of the widget's requisition.
</para>
<para>
This function differs from <link linkend="gtk-widget-size-request">gtk_widget_size_request</link>() in that
it retrieves the last size request value from <parameter>widget</parameter>->requisition,
while <link linkend="gtk-widget-size-request">gtk_widget_size_request</link>() actually calls the "size_request" method
on <parameter>widget</parameter> to compute the size request and fill in <parameter>widget</parameter>->requisition,
and only then returns <parameter>widget</parameter>->requisition.
</para>
<para>
Because this function does not call the "size_request" method, it
can only be used when you know that <parameter>widget</parameter>->requisition is
up-to-date, that is, <link linkend="gtk-widget-size-request">gtk_widget_size_request</link>() has been called
since the last time a resize was queued. In general, only container
implementations have this information; applications should use
<link linkend="gtk-widget-size-request">gtk_widget_size_request</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>requisition</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkRequisition">GtkRequisition</link> to be filled in
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-size-allocate">gtk_widget_size_allocate ()</title>
<programlisting>void        gtk_widget_size_allocate        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAllocation">GtkAllocation</link> *allocation);</programlisting>
<para>
This function is only used by <link linkend="GtkContainer">GtkContainer</link> subclasses, to assign a size
and position to their child widgets.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>allocation</parameter>&nbsp;:</entry>
<entry> position and size to be allocated to <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-add-accelerator">gtk_widget_add_accelerator ()</title>
<programlisting>void        gtk_widget_add_accelerator      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *accel_signal,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group,
                                             <link linkend="guint">guint</link> accel_key,
                                             <link linkend="GdkModifierType">GdkModifierType</link> accel_mods,
                                             <link linkend="GtkAccelFlags">GtkAccelFlags</link> accel_flags);</programlisting>
<para>
Installs an accelerator for this <parameter>widget</parameter> in <parameter>accel_group</parameter> that causes
<parameter>accel_signal</parameter> to be emitted if the accelerator is activated.
The <parameter>accel_group</parameter> needs to be added to the widget's toplevel via
<link linkend="gtk-window-add-accel-group">gtk_window_add_accel_group</link>(), and the signal must be of type <literal>G_RUN_ACTION</literal>.
Accelerators added through this function are not user changeable during
runtime. If you want to support accelerators that can be changed by the
user, use <link linkend="gtk-accel-map-add-entry">gtk_accel_map_add_entry</link>() and <link linkend="gtk-widget-set-accel-path">gtk_widget_set_accel_path</link>() or
<link linkend="gtk-menu-item-set-accel-path">gtk_menu_item_set_accel_path</link>() instead.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>       widget to install an accelerator on
</entry></row>
<row><entry align="right"><parameter>accel_signal</parameter>&nbsp;:</entry>
<entry> widget signal to emit on accelerator activation
</entry></row>
<row><entry align="right"><parameter>accel_group</parameter>&nbsp;:</entry>
<entry>  accel group for this widget, added to its toplevel
</entry></row>
<row><entry align="right"><parameter>accel_key</parameter>&nbsp;:</entry>
<entry>    GDK keyval of the accelerator
</entry></row>
<row><entry align="right"><parameter>accel_mods</parameter>&nbsp;:</entry>
<entry>   modifier key combination of the accelerator
</entry></row>
<row><entry align="right"><parameter>accel_flags</parameter>&nbsp;:</entry>
<entry>  flag accelerators, e.g. <literal>GTK_ACCEL_VISIBLE</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-remove-accelerator">gtk_widget_remove_accelerator ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_remove_accelerator   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group,
                                             <link linkend="guint">guint</link> accel_key,
                                             <link linkend="GdkModifierType">GdkModifierType</link> accel_mods);</programlisting>
<para>
Removes an accelerator from <parameter>widget</parameter>, previously installed with
<link linkend="gtk-widget-add-accelerator">gtk_widget_add_accelerator</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>       widget to install an accelerator on
</entry></row>
<row><entry align="right"><parameter>accel_group</parameter>&nbsp;:</entry>
<entry>  accel group for this widget
</entry></row>
<row><entry align="right"><parameter>accel_key</parameter>&nbsp;:</entry>
<entry>    GDK keyval of the accelerator
</entry></row>
<row><entry align="right"><parameter>accel_mods</parameter>&nbsp;:</entry>
<entry>   modifier key combination of the accelerator
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      whether an accelerator was installed and could be removed
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-accel-path">gtk_widget_set_accel_path ()</title>
<programlisting>void        gtk_widget_set_accel_path       (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *accel_path,
                                             <link linkend="GtkAccelGroup">GtkAccelGroup</link> *accel_group);</programlisting>
<para>
Given an accelerator group, <parameter>accel_group</parameter>, and an accelerator path,
<parameter>accel_path</parameter>, sets up an accelerator in <parameter>accel_group</parameter> so whenever the
key binding that is defined for <parameter>accel_path</parameter> is pressed, <parameter>widget</parameter>
will be activated.  This removes any accelerators (for any
accelerator group) installed by previous calls to
<link linkend="gtk-widget-set-accel-path">gtk_widget_set_accel_path</link>(). Associating accelerators with
paths allows them to be modified by the user and the modifications
to be saved for future use. (See <link linkend="gtk-accel-map-save">gtk_accel_map_save</link>().)
</para>
<para>
This function is a low level function that would most likely
be used by a menu creation system like <link linkend="GtkItemFactory">GtkItemFactory</link>. If you
use <link linkend="GtkItemFactory">GtkItemFactory</link>, setting up accelerator paths will be done
automatically.
</para>
<para>
Even when you you aren't using <link linkend="GtkItemFactory">GtkItemFactory</link>, if you only want to
set up accelerators on menu items <link linkend="gtk-menu-item-set-accel-path">gtk_menu_item_set_accel_path</link>()
provides a somewhat more convenient interface.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>accel_path</parameter>&nbsp;:</entry>
<entry> path used to look up the the accelerator
</entry></row>
<row><entry align="right"><parameter>accel_group</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkAccelGroup">GtkAccelGroup</link>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-list-accel-closures">gtk_widget_list_accel_closures ()</title>
<programlisting><link linkend="GList">GList</link>*      gtk_widget_list_accel_closures  (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Lists the closures used by <parameter>widget</parameter> for accelerator group connections
with <link linkend="gtk-accel-group-connect-by-path">gtk_accel_group_connect_by_path</link>() or <link linkend="gtk-accel-group-connect">gtk_accel_group_connect</link>().
The closures can be used to monitor accelerator changes on <parameter>widget</parameter>,
by connecting to the ::accel_changed signal of the <link linkend="GtkAccelGroup">GtkAccelGroup</link> of a 
closure which can be found out with <link linkend="gtk-accel-group-from-accel-closure">gtk_accel_group_from_accel_closure</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>  widget to list accelerator closures for
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> a newly allocated <link linkend="GList">GList</link> of closures
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-event">gtk_widget_event ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_event                (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkEvent">GdkEvent</link> *event);</programlisting>
<para>
Rarely-used function. This function is used to emit
the event signals on a widget (those signals should never
be emitted without using this function to do so).
If you want to synthesize an event though, don't use this function;
instead, use <link linkend="gtk-main-do-event">gtk_main_do_event</link>() so the event will behave as if
it were in the event queue. Don't synthesize expose events; instead,
use <link linkend="gdk-window-invalidate-rect">gdk_window_invalidate_rect</link>() to invalidate a region of the
window.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry> a <link linkend="GdkEvent">GdkEvent</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> return from the event signal emission (<literal>TRUE</literal> if the event was handled)
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-activate">gtk_widget_activate ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_activate             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
For widgets that can be "activated" (buttons, menu items, etc.)
this function activates them. Activation is what happens when you
press Enter on a widget during key navigation; clicking a button,
selecting a menu item, etc. If <parameter>widget</parameter> isn't activatable,
the function returns <literal>FALSE</literal>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link> that's activatable
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if the widget was activatable
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-reparent">gtk_widget_reparent ()</title>
<programlisting>void        gtk_widget_reparent             (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *new_parent);</programlisting>
<para>
Moves a widget from one <link linkend="GtkContainer">GtkContainer</link> to another, handling reference
count issues to avoid destroying the widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>new_parent</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkContainer">GtkContainer</link> to move the widget into
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-intersect">gtk_widget_intersect ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_intersect            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *area,
                                             <link linkend="GdkRectangle">GdkRectangle</link> *intersection);</programlisting>
<para>
Computes the intersection of a <parameter>widget</parameter>'s area and <parameter>area</parameter>, storing
the intersection in <parameter>intersection</parameter>, and returns <literal>TRUE</literal> if there was
an intersection.  <parameter>intersection</parameter> may be <literal>NULL</literal> if you're only
interested in whether there was an intersection.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>area</parameter>&nbsp;:</entry>
<entry> a rectangle
</entry></row>
<row><entry align="right"><parameter>intersection</parameter>&nbsp;:</entry>
<entry> rectangle to store intersection of <parameter>widget</parameter> and <parameter>area</parameter>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if there was an intersection
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-is-focus">gtk_widget_is_focus ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_is_focus             (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Determines if the widget is the focus widget within its
toplevel. (This does not mean that the <literal>HAS_FOCUS</literal> flag is
necessarily set; <literal>HAS_FOCUS</literal> will only be set if the
toplevel widget additionally has the global input focus.)</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if the widget is the focus widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-grab-focus">gtk_widget_grab_focus ()</title>
<programlisting>void        gtk_widget_grab_focus           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Causes <parameter>widget</parameter> to have the keyboard focus for the <link linkend="GtkWindow">GtkWindow</link> it's
inside. <parameter>widget</parameter> must be a focusable widget, such as a <link linkend="GtkEntry">GtkEntry</link>;
something like <link linkend="GtkFrame">GtkFrame</link> won't work. (More precisely, it must have the
<literal>GTK_CAN_FOCUS</literal> flag set.)</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-grab-default">gtk_widget_grab_default ()</title>
<programlisting>void        gtk_widget_grab_default         (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Causes <parameter>widget</parameter> to become the default widget. <parameter>widget</parameter> must have the
<literal>GTK_CAN_DEFAULT</literal> flag set; typically you have to set this flag
yourself by calling <literal>GTK_WIDGET_SET_FLAGS (<parameter>widget</parameter>,
GTK_CAN_DEFAULT)</literal>.  The default widget is activated when the user
presses Enter in a window.  Default widgets must be activatable,
that is, <link linkend="gtk-widget-activate">gtk_widget_activate</link>() should affect them.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-name">gtk_widget_set_name ()</title>
<programlisting>void        gtk_widget_set_name             (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *name);</programlisting>
<para>
Widgets can be named, which allows you to refer to them from a
gtkrc file. You can apply a style to widgets with a particular name
in the gtkrc file. See the documentation for gtkrc files (on the
same page as the docs for <link linkend="GtkRcStyle">GtkRcStyle</link>).</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry> name for the widget
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-name">gtk_widget_get_name ()</title>
<programlisting>G_CONST_RETURN <link linkend="gchar">gchar</link>* gtk_widget_get_name   (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Retrieves the name of a widget. The return value should not be
freed. See <link linkend="gtk-widget-set-name">gtk_widget_set_name</link>() for the significance of widget
names.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> name of the widget
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-state">gtk_widget_set_state ()</title>
<programlisting>void        gtk_widget_set_state            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state);</programlisting>
<para>
This function is for use in widget implementations. Sets the state
of a widget (insensitive, prelighted, etc.) Usually you should set
the state using wrapper functions such as <link linkend="gtk-widget-set-sensitive">gtk_widget_set_sensitive</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry> new state for <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-sensitive">gtk_widget_set_sensitive ()</title>
<programlisting>void        gtk_widget_set_sensitive        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> sensitive);</programlisting>
<para>
Sets the sensitivity of a widget. A widget is sensitive if the user
can interact with it. Insensitive widgets are "grayed out" and the
user can't interact with them. Insensitive widgets are known as
"inactive", "disabled", or "ghosted" in some other toolkits.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>sensitive</parameter>&nbsp;:</entry>
<entry> <literal>TRUE</literal> to make the widget sensitive
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-parent">gtk_widget_set_parent ()</title>
<programlisting>void        gtk_widget_set_parent           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *parent);</programlisting>
<para>
This function is useful only when implementing subclasses of <link linkend="GtkContainer">GtkContainer</link>.
Sets the container as the parent of <parameter>widget</parameter>, and takes care of
some details such as updating the state and style of the child
to reflect its new location. The opposite function is
<link linkend="gtk-widget-unparent">gtk_widget_unparent</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>parent</parameter>&nbsp;:</entry>
<entry> parent container
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-parent-window">gtk_widget_set_parent_window ()</title>
<programlisting>void        gtk_widget_set_parent_window    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkWindow">GdkWindow</link> *parent_window);</programlisting>
<para>
Sets a non default parent window for <parameter>widget</parameter>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>parent_window</parameter>&nbsp;:</entry>
<entry> the new parent window.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-parent-window">gtk_widget_get_parent_window ()</title>
<programlisting><link linkend="GdkWindow">GdkWindow</link>*  gtk_widget_get_parent_window    (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets <parameter>widget</parameter>'s parent window.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the parent window of <parameter>widget</parameter>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-uposition">gtk_widget_set_uposition ()</title>
<programlisting>void        gtk_widget_set_uposition        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y);</programlisting>
<warning>
<para>
<literal>gtk_widget_set_uposition</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
Sets the position of a widget. The funny "u" in the name comes from
the "user position" hint specified by the X Window System, and
exists for legacy reasons. This function doesn't work if a widget
is inside a container; it's only really useful on <link linkend="GtkWindow">GtkWindow</link>.
</para>
<para>
Don't use this function to center dialogs over the main application
window; most window managers will do the centering on your behalf
if you call <link linkend="gtk-window-set-transient-for">gtk_window_set_transient_for</link>(), and it's really not
possible to get the centering to work correctly in all cases from
application code. But if you insist, use <link linkend="gtk-window-set-position">gtk_window_set_position</link>()
to set <link linkend="GTK-WIN-POS-CENTER-ON-PARENT-CAPS">GTK_WIN_POS_CENTER_ON_PARENT</link>, don't do the centering
manually.
</para>
<para>
Note that although <parameter>x</parameter> and <parameter>y</parameter> can be individually unset, the position
is not honoured unless both <parameter>x</parameter> and <parameter>y</parameter> are set.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry> x position; -1 to unset x; -2 to leave x unchanged
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry> y position; -1 to unset y; -2 to leave y unchanged
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-usize">gtk_widget_set_usize ()</title>
<programlisting>void        gtk_widget_set_usize            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);</programlisting>
<warning>
<para>
<literal>gtk_widget_set_usize</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
This function is deprecated; use <link linkend="gtk-widget-set-size-request">gtk_widget_set_size_request</link>()
instead.
</para>
<para>
Sets the minimum size of a widget; that is, the widget's size
request will be <parameter>width</parameter> by <parameter>height</parameter>. You can use this function to
force a widget to be either larger or smaller than it is. The
strange "usize" name dates from the early days of GTK+, and derives
from X Window System terminology. In many cases,
<link linkend="gtk-window-set-default-size">gtk_window_set_default_size</link>() is a better choice for toplevel
windows than this function; setting the default size will still
allow users to shrink the window. Setting the usize will force them
to leave the window at least as large as the usize. When dealing
with window sizes, <link linkend="gtk-window-set-geometry-hints">gtk_window_set_geometry_hints</link>() can be a useful
function as well.
</para>
<para>
Note the inherent danger of setting any fixed size - themes,
translations into other languages, different fonts, and user action
can all change the appropriate size for a given widget. So, it's
basically impossible to hardcode a size that will always be
correct.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>width</parameter>&nbsp;:</entry>
<entry> minimum width, or -1 to unset
</entry></row>
<row><entry align="right"><parameter>height</parameter>&nbsp;:</entry>
<entry> minimum height, or -1 to unset
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-events">gtk_widget_set_events ()</title>
<programlisting>void        gtk_widget_set_events           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> events);</programlisting>
<para>
Sets the event mask (see <link linkend="GdkEventMask">GdkEventMask</link>) for a widget. The event
mask determines which events a widget will receive. Keep in mind
that different widgets have different default event masks, and by
changing the event mask you may disrupt a widget's functionality,
so be careful. This function must be called while a widget is
unrealized. Consider <link linkend="gtk-widget-add-events">gtk_widget_add_events</link>() for widgets that are
already realized, or if you want to preserve the existing event
mask. This function can't be used with <link linkend="GTK-NO-WINDOW-CAPS">GTK_NO_WINDOW</link> widgets;
to get events on those widgets, place them inside a <link linkend="GtkEventBox">GtkEventBox</link>
and receive events on the event box.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>events</parameter>&nbsp;:</entry>
<entry> event mask
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-add-events">gtk_widget_add_events ()</title>
<programlisting>void        gtk_widget_add_events           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> events);</programlisting>
<para>
Adds the events in the bitfield <parameter>events</parameter> to the event mask for
<parameter>widget</parameter>. See <link linkend="gtk-widget-set-events">gtk_widget_set_events</link>() for details.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>events</parameter>&nbsp;:</entry>
<entry> an event mask, see <link linkend="GdkEventMask">GdkEventMask</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-extension-events">gtk_widget_set_extension_events ()</title>
<programlisting>void        gtk_widget_set_extension_events (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkExtensionMode">GdkExtensionMode</link> mode);</programlisting>
<para>
Sets the extension events mask to <parameter>mode</parameter>. See <link linkend="GdkExtensionMode">GdkExtensionMode</link>
and <link linkend="gdk-input-set-extension-events">gdk_input_set_extension_events</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>mode</parameter>&nbsp;:</entry>
<entry> bitfield of extension events to receive
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-extension-events">gtk_widget_get_extension_events ()</title>
<programlisting><link linkend="GdkExtensionMode">GdkExtensionMode</link> gtk_widget_get_extension_events
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Retrieves the extension events the widget will receive; see
<link linkend="gdk-input-set-extension-events">gdk_input_set_extension_events</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> extension events for <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-toplevel">gtk_widget_get_toplevel ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  gtk_widget_get_toplevel         (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function returns the topmost widget in the container hierarchy
<parameter>widget</parameter> is a part of. If <parameter>widget</parameter> has no parent widgets, it will be
returned as the topmost widget. No reference will be added to the
returned widget; it should not be unreferenced.
</para>
<para>
Note the difference in behavior vs. <link linkend="gtk-widget-get-ancestor">gtk_widget_get_ancestor</link>();
<literal>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</literal> 
would return
<literal>NULL</literal> if <parameter>widget</parameter> wasn't inside a toplevel window, and if the
window was inside a <link linkend="GtkWindow-derived">GtkWindow-derived</link> widget which was in turn
inside the toplevel <link linkend="GtkWindow">GtkWindow</link>. While the second case may
seem unlikely, it actually happens when a <link linkend="GtkPlug">GtkPlug</link> is embedded
inside a <link linkend="GtkSocket">GtkSocket</link> within the same application.
</para>
<para>
To reliably find the toplevel <link linkend="GtkWindow">GtkWindow</link>, use
<link linkend="gtk-widget-get-toplevel">gtk_widget_get_toplevel</link>() and check if the <literal>TOPLEVEL</literal> flags
is set on the result.
 <informalexample><programlisting>
 <!>GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 <!>if (GTK_WIDGET_TOPLEVEL (toplevel))
 <!> {
 <!>   [ Perform action on toplevel. ]
 <!> }
 </programlisting></informalexample></para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the topmost ancestor of <parameter>widget</parameter>, or <parameter>widget</parameter> itself if there's no ancestor.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-ancestor">gtk_widget_get_ancestor ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  gtk_widget_get_ancestor         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkType">GtkType</link> widget_type);</programlisting>
<para>
Gets the first ancestor of <parameter>widget</parameter> with type <parameter>widget_type</parameter>. For example,
<literal>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</literal> gets the 
first <link linkend="GtkBox">GtkBox</link> that's
an ancestor of <parameter>widget</parameter>. No reference will be added to the returned widget;
it should not be unreferenced. See note about checking for a toplevel
<link linkend="GtkWindow">GtkWindow</link> in the docs for <link linkend="gtk-widget-get-toplevel">gtk_widget_get_toplevel</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>widget_type</parameter>&nbsp;:</entry>
<entry> ancestor type
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the ancestor widget, or <literal>NULL</literal> if not found
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-colormap">gtk_widget_get_colormap ()</title>
<programlisting><link linkend="GdkColormap">GdkColormap</link>* gtk_widget_get_colormap        (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets the colormap that will be used to render <parameter>widget</parameter>. No reference will
be added to the returned colormap; it should not be unreferenced.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the colormap used by <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-colormap">gtk_widget_set_colormap ()</title>
<programlisting>void        gtk_widget_set_colormap         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkColormap">GdkColormap</link> *colormap);</programlisting>
<para>
Sets the colormap for the widget to the given value. Widget must not
have been previously realized. This probably should only be used
from an <function><link linkend="init">init</link>()</function> function (i.e. from the constructor 
for the widget).</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>colormap</parameter>&nbsp;:</entry>
<entry> a colormap
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-visual">gtk_widget_get_visual ()</title>
<programlisting><link linkend="GdkVisual">GdkVisual</link>*  gtk_widget_get_visual           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets the visual that will be used to render <parameter>widget</parameter>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the visual for <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-events">gtk_widget_get_events ()</title>
<programlisting><link linkend="gint">gint</link>        gtk_widget_get_events           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Returns the event mask for the widget (a bitfield containing flags
from the <link linkend="GdkEventMask">GdkEventMask</link> enumeration). These are the events that the widget
will receive.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> event mask for <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-pointer">gtk_widget_get_pointer ()</title>
<programlisting>void        gtk_widget_get_pointer          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> *x,
                                             <link linkend="gint">gint</link> *y);</programlisting>
<para>
Obtains the location of the mouse pointer in widget coordinates.
Widget coordinates are a bit odd; for historical reasons, they are
defined as <parameter>widget</parameter>->window coordinates for widgets that are not
<link linkend="GTK-NO-WINDOW-CAPS">GTK_NO_WINDOW</link> widgets, and are relative to <parameter>widget</parameter>->allocation.x,
<parameter>widget</parameter>->allocation.y for widgets that are <link linkend="GTK-NO-WINDOW-CAPS">GTK_NO_WINDOW</link> widgets.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry> return location for the X coordinate, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry> return location for the Y coordinate, or <literal>NULL</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-is-ancestor">gtk_widget_is_ancestor ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_is_ancestor          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *ancestor);</programlisting>
<para>
Determines whether <parameter>widget</parameter> is somewhere inside <parameter>ancestor</parameter>, possibly with
intermediate containers.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>ancestor</parameter>&nbsp;:</entry>
<entry> another <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if <parameter>ancestor</parameter> contains <parameter>widget</parameter> as a child, grandchild, great grandchild, etc.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-translate-coordinates">gtk_widget_translate_coordinates ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_translate_coordinates
                                            (<link linkend="GtkWidget">GtkWidget</link> *src_widget,
                                             <link linkend="GtkWidget">GtkWidget</link> *dest_widget,
                                             <link linkend="gint">gint</link> src_x,
                                             <link linkend="gint">gint</link> src_y,
                                             <link linkend="gint">gint</link> *dest_x,
                                             <link linkend="gint">gint</link> *dest_y);</programlisting>
<para>
Translate coordinates relative to <parameter>src_widget</parameter>'s allocation to coordinates
relative to <parameter>dest_widget</parameter>'s allocations. In order to perform this
operation, both widgets must be realized, and must share a common
toplevel.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>src_widget</parameter>&nbsp;:</entry>
<entry>  a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>dest_widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>src_x</parameter>&nbsp;:</entry>
<entry> X position relative to <parameter>src_widget</parameter>
</entry></row>
<row><entry align="right"><parameter>src_y</parameter>&nbsp;:</entry>
<entry> Y position relative to <parameter>src_widget</parameter>
</entry></row>
<row><entry align="right"><parameter>dest_x</parameter>&nbsp;:</entry>
<entry> location to store X position relative to <parameter>dest_widget</parameter>
</entry></row>
<row><entry align="right"><parameter>dest_y</parameter>&nbsp;:</entry>
<entry> location to store Y position relative to <parameter>dest_widget</parameter>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>FALSE</literal> if either widget was not realized, or there
  was no common ancestor. In this case, nothing is stored in
  *<parameter>dest_x</parameter> and *<parameter>dest_y</parameter>. Otherwise <literal>TRUE</literal>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-hide-on-delete">gtk_widget_hide_on_delete ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_hide_on_delete       (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Utility function; intended to be connected to the "delete_event"
signal on a <link linkend="GtkWindow">GtkWindow</link>. The function calls <link linkend="gtk-widget-hide">gtk_widget_hide</link>() on its
argument, then returns <literal>TRUE</literal>. If connected to "delete_event", the
result is that clicking the close button for a window (on the
window frame, top right corner usually) will hide but not destroy
the window. By default, GTK+ destroys windows when "delete_event"
is received.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-style">gtk_widget_set_style ()</title>
<programlisting>void        gtk_widget_set_style            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStyle">GtkStyle</link> *style);</programlisting>
<para>
Sets the <link linkend="GtkStyle">GtkStyle</link> for a widget (<parameter>widget</parameter>->style). You probably don't
want to use this function; it interacts badly with themes, because
themes work by replacing the <link linkend="GtkStyle">GtkStyle</link>. Instead, use
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>style</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkStyle">GtkStyle</link>, or <literal>NULL</literal> to remove the effect of a previous
        <link linkend="gtk-widget-set-style">gtk_widget_set_style</link>() and go back to the default style
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-rc-style">gtk_widget_set_rc_style()</title>
<programlisting>#define gtk_widget_set_rc_style(widget)          (gtk_widget_set_style (widget, NULL))
</programlisting>
<warning>
<para>
<literal>gtk_widget_set_rc_style</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
Equivalent to <literal>gtk_widget_set_style (widget, NULL)</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-ensure-style">gtk_widget_ensure_style ()</title>
<programlisting>void        gtk_widget_ensure_style         (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Ensures that <parameter>widget</parameter> has a style (<parameter>widget</parameter>->style). Not a very useful
function; most of the time, if you want the style, the widget is
realized, and realized widgets are guaranteed to have a style
already.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-style">gtk_widget_get_style ()</title>
<programlisting><link linkend="GtkStyle">GtkStyle</link>*   gtk_widget_get_style            (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Simply an accessor function that returns <parameter>widget</parameter>->style.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the widget's <link linkend="GtkStyle">GtkStyle</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-restore-default-style">gtk_widget_restore_default_style()</title>
<programlisting>#define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
</programlisting>
<warning>
<para>
<literal>gtk_widget_restore_default_style</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
Equivalent to <literal>gtk_widget_set_style (widget, NULL)</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-reset-rc-styles">gtk_widget_reset_rc_styles ()</title>
<programlisting>void        gtk_widget_reset_rc_styles      (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Reset the styles of <parameter>widget</parameter> and all descendents, so when 
they are looked up again, they get the correct values 
for the currently loaded RC file settings. 
</para>
<para>
This function is not useful for applications.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>a <link linkend="GtkWidget">GtkWidget</link>.


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-push-colormap">gtk_widget_push_colormap ()</title>
<programlisting>void        gtk_widget_push_colormap        (<link linkend="GdkColormap">GdkColormap</link> *cmap);</programlisting>
<para>
Pushes <parameter>cmap</parameter> onto a global stack of colormaps; the topmost
colormap on the stack will be used to create all widgets.
Remove <parameter>cmap</parameter> with <link linkend="gtk-widget-pop-colormap">gtk_widget_pop_colormap</link>(). There's little
reason to use this function.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>cmap</parameter>&nbsp;:</entry>
<entry> a <link linkend="GdkColormap">GdkColormap</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-pop-colormap">gtk_widget_pop_colormap ()</title>
<programlisting>void        gtk_widget_pop_colormap         (void);</programlisting>
<para>
Removes a colormap pushed with <link linkend="gtk-widget-push-colormap">gtk_widget_push_colormap</link>().</para>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-default-colormap">gtk_widget_set_default_colormap ()</title>
<programlisting>void        gtk_widget_set_default_colormap (<link linkend="GdkColormap">GdkColormap</link> *colormap);</programlisting>
<para>
Sets the default colormap to use when creating widgets.
<link linkend="gtk-widget-push-colormap">gtk_widget_push_colormap</link>() is a better function to use if
you only want to affect a few widgets, rather than all widgets.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>colormap</parameter>&nbsp;:</entry>
<entry> a <link linkend="GdkColormap">GdkColormap</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-default-style">gtk_widget_get_default_style ()</title>
<programlisting><link linkend="GtkStyle">GtkStyle</link>*   gtk_widget_get_default_style    (void);</programlisting>
<para>
Returns the default style used by all widgets initially.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the default style. This <link linkend="GtkStyle">GtkStyle</link> object is owned by GTK+ and
should not be modified or freed.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-default-colormap">gtk_widget_get_default_colormap ()</title>
<programlisting><link linkend="GdkColormap">GdkColormap</link>* gtk_widget_get_default_colormap
                                            (void);</programlisting>
<para>
Obtains the default colormap used to create widgets.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> default widget colormap
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-default-visual">gtk_widget_get_default_visual ()</title>
<programlisting><link linkend="GdkVisual">GdkVisual</link>*  gtk_widget_get_default_visual   (void);</programlisting>
<para>
Obtains the visual of the default colormap. Not really useful;
used to be useful before <link linkend="gdk-colormap-get-visual">gdk_colormap_get_visual</link>() existed.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> visual of the default colormap
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-direction">gtk_widget_set_direction ()</title>
<programlisting>void        gtk_widget_set_direction        (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkTextDirection">GtkTextDirection</link> dir);</programlisting>
<para>
Sets the reading direction on a particular widget. This direction
controls the primary direction for widgets containing text,
and also the direction in which the children of a container are
packed. The ability to set the direction is present in order
so that correct localization into languages with right-to-left
reading directions can be done. Generally, applications will
let the default reading direction present, except for containers
where the containers are arranged in an order that is explicitely
visual rather than logical (such as buttons for text justification).
</para>
<para>
If the direction is set to <literal>GTK_TEXT_DIR_NONE</literal>, then the value
set by <link linkend="gtk-widget-set-default-direction">gtk_widget_set_default_direction</link>() will be used.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>dir</parameter>&nbsp;:</entry>
<entry>    the new direction
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GtkTextDirection">enum GtkTextDirection</title>
<programlisting>typedef enum
{
  GTK_TEXT_DIR_NONE,
  GTK_TEXT_DIR_LTR,
  GTK_TEXT_DIR_RTL
} GtkTextDirection;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-direction">gtk_widget_get_direction ()</title>
<programlisting><link linkend="GtkTextDirection">GtkTextDirection</link> gtk_widget_get_direction   (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets the reading direction for a particular widget. See
<link linkend="gtk-widget-set-direction">gtk_widget_set_direction</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the reading direction for the widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-default-direction">gtk_widget_set_default_direction ()</title>
<programlisting>void        gtk_widget_set_default_direction
                                            (<link linkend="GtkTextDirection">GtkTextDirection</link> dir);</programlisting>
<para>
Sets the default reading direction for widgets where the
direction has not been explicitly set by <link linkend="gtk-widget-set-direction">gtk_widget_set_direction</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>dir</parameter>&nbsp;:</entry>
<entry> the new default direction. This cannot be
       <literal>GTK_TEXT_DIR_NONE</literal>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-default-direction">gtk_widget_get_default_direction ()</title>
<programlisting><link linkend="GtkTextDirection">GtkTextDirection</link> gtk_widget_get_default_direction
                                            (void);</programlisting>
<para>
Obtains the current default reading direction. See
<link linkend="gtk-widget-set-default-direction">gtk_widget_set_default_direction</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the current default direction. 
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-shape-combine-mask">gtk_widget_shape_combine_mask ()</title>
<programlisting>void        gtk_widget_shape_combine_mask   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkBitmap">GdkBitmap</link> *shape_mask,
                                             <link linkend="gint">gint</link> offset_x,
                                             <link linkend="gint">gint</link> offset_y);</programlisting>
<para>
Sets a shape for this widget's GDK window. This allows for
transparent windows etc., see <link linkend="gdk-window-shape-combine-mask">gdk_window_shape_combine_mask</link>()
for more information.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>shape_mask</parameter>&nbsp;:</entry>
<entry> shape to be added, or <literal>NULL</literal> to remove an existing shape. 
</entry></row>
<row><entry align="right"><parameter>offset_x</parameter>&nbsp;:</entry>
<entry> X position of shape mask with respect to <parameter>window</parameter>.
</entry></row>
<row><entry align="right"><parameter>offset_y</parameter>&nbsp;:</entry>
<entry> Y position of shape mask with respect to <parameter>window</parameter>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-path">gtk_widget_path ()</title>
<programlisting>void        gtk_widget_path                 (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="guint">guint</link> *path_length,
                                             <link linkend="gchar">gchar</link> **path,
                                             <link linkend="gchar">gchar</link> **path_reversed);</programlisting>
<para>
Obtains the full path to <parameter>widget</parameter>. The path is simply the name of a
widget and all its parents in the container hierarchy, separated by
periods. The name of a widget comes from
<link linkend="gtk-widget-get-name">gtk_widget_get_name</link>(). Paths are used to apply styles to a widget
in gtkrc configuration files.  Widget names are the type of the
widget by default (e.g. "GtkButton") or can be set to an
application-specific value with <link linkend="gtk-widget-set-name">gtk_widget_set_name</link>().  By setting
the name of a widget, you allow users or theme authors to apply
styles to that specific widget in their gtkrc
file. <parameter>path_reversed_p</parameter> fills in the path in reverse order,
i.e. starting with <parameter>widget</parameter>'s name instead of starting with the name
of <parameter>widget</parameter>'s outermost ancestor.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>path_length</parameter>&nbsp;:</entry>
<entry> location to store length of the path, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>path</parameter>&nbsp;:</entry>
<entry> location to store allocated path string, or <literal>NULL</literal> 
</entry></row>
<row><entry align="right"><parameter>path_reversed</parameter>&nbsp;:</entry>
<entry> location to store allocated reverse path string, or <literal>NULL</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-class-path">gtk_widget_class_path ()</title>
<programlisting>void        gtk_widget_class_path           (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="guint">guint</link> *path_length,
                                             <link linkend="gchar">gchar</link> **path,
                                             <link linkend="gchar">gchar</link> **path_reversed);</programlisting>
<para>
Same as <link linkend="gtk-widget-path">gtk_widget_path</link>(), but always uses the name of a widget's type,
never uses a custom name set with <link linkend="gtk-widget-set-name">gtk_widget_set_name</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>path_length</parameter>&nbsp;:</entry>
<entry> location to store the length of the class path, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>path</parameter>&nbsp;:</entry>
<entry> location to store the class path as an allocated string, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>path_reversed</parameter>&nbsp;:</entry>
<entry> location to store the reverse class path as an allocated string, or <literal>NULL</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-composite-name">gtk_widget_get_composite_name ()</title>
<programlisting><link linkend="gchar">gchar</link>*      gtk_widget_get_composite_name   (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Obtains the composite name of a widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the composite name of <parameter>widget</parameter>, or <literal>NULL</literal> if <parameter>widget</parameter> is not
  a composite child. The string should not be freed when it is no 
  longer needed.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-style">gtk_widget_modify_style ()</title>
<programlisting>void        gtk_widget_modify_style         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkRcStyle">GtkRcStyle</link> *style);</programlisting>
<para>
Modifies style values on the widget. Modifications made using this
technique take precedence over style values set via an RC file,
however, they will be overriden if a style is explicitely set on
the widget using <link linkend="gtk-widget-set-style">gtk_widget_set_style</link>(). The <link linkend="GtkRcStyle">GtkRcStyle</link> structure
is designed so each field can either be set or unset, so it is
possible, using this function, to modify some style values and
leave the others unchanged.
</para>
<para>
Note that modifications made with this function are not cumulative
with previous calls to <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>() or with such
functions as <link linkend="gtk-widget-modify-fg">gtk_widget_modify_fg</link>(). If you wish to retain
previous values, you must first call <link linkend="gtk-widget-get-modifier-style">gtk_widget_get_modifier_style</link>(),
make your modifications to the returned style, then call
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>() with that style. On the other hand,
if you first call <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>(), subsequent calls
to such functions <link linkend="gtk-widget-modify-fg">gtk_widget_modify_fg</link>() will have a cumulative
effect with the initial modifications.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>style</parameter>&nbsp;:</entry>
<entry> the <link linkend="GtkRcStyle">GtkRcStyle</link> holding the style modifications
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-modifier-style">gtk_widget_get_modifier_style ()</title>
<programlisting><link linkend="GtkRcStyle">GtkRcStyle</link>* gtk_widget_get_modifier_style   (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Returns the current modifier style for the widget. (As set by
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().) If no style has previously set, a new
<link linkend="GtkRcStyle">GtkRcStyle</link> will be created with all values unset, and set as the
modifier style for the widget. If you make changes to this rc
style, you must call <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>(), passing in the
returned rc style, to make sure that your changes take effect.
</para>
<para>
Caution: passing the style back to <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>() will
normally end up destroying it, because <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>() copies
the passed-in style and sets the copy as the new modifier style,
thus dropping any reference to the old modifier style. Add a reference
to the modifier style if you want to keep it alive.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the modifier style for the widget. This rc style is
  owned by the widget. If you want to keep a pointer to value this
  around, you must add a refcount using <link linkend="gtk-rc-style-ref">gtk_rc_style_ref</link>().
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-fg">gtk_widget_modify_fg ()</title>
<programlisting>void        gtk_widget_modify_fg            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);</programlisting>
<para>
Sets the foreground color for a widget in a particular state.  All
other style values are left untouched. See also
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry> the state for which to set the foreground color.
</entry></row>
<row><entry align="right"><parameter>color</parameter>&nbsp;:</entry>
<entry> the color to assign (does not need to be allocated).
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-bg">gtk_widget_modify_bg ()</title>
<programlisting>void        gtk_widget_modify_bg            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);</programlisting>
<para>
Sets the background color for a widget in a particular state.  All
other style values are left untouched. See also
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry> the state for which to set the background color.
</entry></row>
<row><entry align="right"><parameter>color</parameter>&nbsp;:</entry>
<entry> the color to assign (does not need to be allocated).
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-text">gtk_widget_modify_text ()</title>
<programlisting>void        gtk_widget_modify_text          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);</programlisting>
<para>
Sets the text color for a widget in a particular state.  All other
style values are left untouched. The text color is the foreground
color used along with the base color (see <link linkend="gtk-widget-modify-base">gtk_widget_modify_base</link>())
for widgets such as <link linkend="GtkEntry">GtkEntry</link> and <link linkend="GtkTextView">GtkTextView</link>. See also
<link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry> the state for which to set the text color.
</entry></row>
<row><entry align="right"><parameter>color</parameter>&nbsp;:</entry>
<entry> the color to assign (does not need to be allocated).
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-base">gtk_widget_modify_base ()</title>
<programlisting>void        gtk_widget_modify_base          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkStateType">GtkStateType</link> state,
                                             <link linkend="GdkColor">GdkColor</link> *color);</programlisting>
<para>
Sets the base color for a widget in a particular state.
All other style values are left untouched. The base color
is the background color used along with the text color
(see <link linkend="gtk-widget-modify-text">gtk_widget_modify_text</link>()) for widgets such as <link linkend="GtkEntry">GtkEntry</link>
and <link linkend="GtkTextView">GtkTextView</link>. See also <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry> the state for which to set the base color.
</entry></row>
<row><entry align="right"><parameter>color</parameter>&nbsp;:</entry>
<entry> the color to assign (does not need to be allocated).
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-modify-font">gtk_widget_modify_font ()</title>
<programlisting>void        gtk_widget_modify_font          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="PangoFontDescription">PangoFontDescription</link> *font_desc);</programlisting>
<para>
Sets the font to use for a widget.  All other style values are left
untouched. See also <link linkend="gtk-widget-modify-style">gtk_widget_modify_style</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>font_desc</parameter>&nbsp;:</entry>
<entry> the font description to use
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-create-pango-context">gtk_widget_create_pango_context ()</title>
<programlisting><link linkend="PangoContext">PangoContext</link>* gtk_widget_create_pango_context
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Creates a new <link linkend="PangoContext">PangoContext</link> with the appropriate colormap,
font description, and base direction for drawing text for
this widget. See also <link linkend="gtk-widget-get-pango-context">gtk_widget_get_pango_context</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the new <link linkend="PangoContext">PangoContext</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-pango-context">gtk_widget_get_pango_context ()</title>
<programlisting><link linkend="PangoContext">PangoContext</link>* gtk_widget_get_pango_context  (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets a <link linkend="PangoContext">PangoContext</link> with the appropriate colormap, font description
and base direction for this widget. Unlike the context returned
by <link linkend="gtk-widget-create-pango-context">gtk_widget_create_pango_context</link>(), this context is owned by
the widget (it can be used as long as widget exists), and will
be updated to match any changes to the widget's attributes.
</para>
<para>
If you create and keep a <link linkend="PangoLayout">PangoLayout</link> using this context, you must
deal with changes to the context by calling <link linkend="pango-layout-context-changed">pango_layout_context_changed</link>()
on the layout in response to the ::style_set and ::direction_set signals
for the widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the <link linkend="PangoContext">PangoContext</link> for the widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-create-pango-layout">gtk_widget_create_pango_layout ()</title>
<programlisting><link linkend="PangoLayout">PangoLayout</link>* gtk_widget_create_pango_layout (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *text);</programlisting>
<para>
Creates a new <link linkend="PangoLayout">PangoLayout</link> with the appropriate colormap,
font description, and base direction for drawing text for
this widget.
</para>
<para>
If you keep a <link linkend="PangoLayout">PangoLayout</link> created in this way around, in order
notify the layout of changes to the base direction or font of this
widget, you must call <link linkend="pango-layout-context-changed">pango_layout_context_changed</link>() in response to
the ::style_set and ::direction_set signals for the widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>text</parameter>&nbsp;:</entry>
<entry>   text to set on the layout (can be <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the new <link linkend="PangoLayout">PangoLayout</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-render-icon">gtk_widget_render_icon ()</title>
<programlisting><link linkend="GdkPixbuf">GdkPixbuf</link>*  gtk_widget_render_icon          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *stock_id,
                                             <link linkend="GtkIconSize">GtkIconSize</link> size,
                                             const <link linkend="gchar">gchar</link> *detail);</programlisting>
<para>
A convenience function that uses the theme engine and RC file
settings for <parameter>widget</parameter> to look up <parameter>stock_id</parameter> and render it to
a pixbuf. <parameter>stock_id</parameter> should be a stock icon ID such as
<link linkend="GTK-STOCK-OPEN-CAPS">GTK_STOCK_OPEN</link> or <link linkend="GTK-STOCK-OK-CAPS">GTK_STOCK_OK</link>. <parameter>size</parameter> should be a size
such as <link linkend="GTK-ICON-SIZE-MENU-CAPS">GTK_ICON_SIZE_MENU</link>. <parameter>detail</parameter> should be a string that
identifies the widget or code doing the rendering, so that
theme engines can special-case rendering for that widget or code.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>stock_id</parameter>&nbsp;:</entry>
<entry> a stock ID
</entry></row>
<row><entry align="right"><parameter>size</parameter>&nbsp;:</entry>
<entry> a stock size
</entry></row>
<row><entry align="right"><parameter>detail</parameter>&nbsp;:</entry>
<entry> render detail to pass to theme engine
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> a new pixbuf, or <literal>NULL</literal> if the stock ID wasn't known
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-pop-composite-child">gtk_widget_pop_composite_child ()</title>
<programlisting>void        gtk_widget_pop_composite_child  (void);</programlisting>
<para>
Cancels the effect of a previous call to <link linkend="gtk-widget-push-composite-child">gtk_widget_push_composite_child</link>().</para>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-push-composite-child">gtk_widget_push_composite_child ()</title>
<programlisting>void        gtk_widget_push_composite_child (void);</programlisting>
<para>
Makes all newly-created widgets as composite children until
the corresponding <link linkend="gtk-widget-pop-composite-child">gtk_widget_pop_composite_child</link>() call.
</para>
<para>
A composite child is a child that's an implementation detail of the
container it's inside and should not be visible to people using the
container. Composite children aren't treated differently by GTK (but
see <link linkend="gtk-container-foreach">gtk_container_foreach</link>() vs. <link linkend="gtk-container-forall">gtk_container_forall</link>()), but e.g. GUI 
builders might want to treat them in a different way.
</para>
<para>
Here is a simple example:
<informalexample><programlisting>
<!>  gtk_widget_push_composite_child (<!>);
<!>  scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
<!>  gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
<!>  gtk_widget_pop_composite_child (<!>);
<!>  gtk_widget_set_parent (scrolled_window->hscrollbar, 
<!>                         GTK_WIDGET (scrolled_window));
<!>  gtk_widget_ref (scrolled_window->hscrollbar);
</programlisting></informalexample></para>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-queue-clear">gtk_widget_queue_clear ()</title>
<programlisting>void        gtk_widget_queue_clear          (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<warning>
<para>
<literal>gtk_widget_queue_clear</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
DEPRECATED. Use <link linkend="gtk-widget-queue-draw">gtk_widget_queue_draw</link>() instead.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-queue-clear-area">gtk_widget_queue_clear_area ()</title>
<programlisting>void        gtk_widget_queue_clear_area     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);</programlisting>
<warning>
<para>
<literal>gtk_widget_queue_clear_area</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
DEPRECATED. This function is no longer different from
<link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>(), though it once was. Now it just calls
<link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>(). Originally
<link linkend="gtk-widget-queue-clear-area">gtk_widget_queue_clear_area</link>() would force a redraw of the
background for <literal>GTK_NO_WINDOW</literal> widgets, and
<link linkend="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area</link>() would not. Now both functions ensure
the background will be redrawn.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry> x coordinate of upper-left corner of rectangle to redraw
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry> y coordinate of upper-left corner of rectangle to redraw
</entry></row>
<row><entry align="right"><parameter>width</parameter>&nbsp;:</entry>
<entry> width of region to draw
</entry></row>
<row><entry align="right"><parameter>height</parameter>&nbsp;:</entry>
<entry> height of region to draw
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-queue-draw-area">gtk_widget_queue_draw_area ()</title>
<programlisting>void        gtk_widget_queue_draw_area      (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> x,
                                             <link linkend="gint">gint</link> y,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);</programlisting>
<para>
Invalidates the rectangular area of <parameter>widget</parameter> defined by <parameter>x</parameter>, <parameter>y</parameter>,
<parameter>width</parameter> and <parameter>height</parameter> by calling <link linkend="gdk-window-invalidate-rect">gdk_window_invalidate_rect</link>() on the
widget's window and all its child windows.  Once the main loop
becomes idle (after the current batch of events has been processed,
roughly), the window will receive expose events for the union of
all regions that have been invalidated.
</para>
<para>
Normally you would only use this function in widget
implementations. You might also use it, or
<link linkend="gdk-window-invalidate-rect">gdk_window_invalidate_rect</link>() directly, to schedule a redraw of a
<link linkend="GtkDrawingArea">GtkDrawingArea</link> or some portion thereof.
</para>
<para>
Frequently you can just call <link linkend="gdk-window-invalidate-rect">gdk_window_invalidate_rect</link>() or
<link linkend="gdk-window-invalidate-region">gdk_window_invalidate_region</link>() instead of this function. Those
functions will invalidate only a single window, instead of the
widget and all its children.
</para>
<para>
The advantage of adding to the invalidated region compared to
simply drawing immediately is efficiency; using an invalid region
ensures that you only have to redraw one time.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry> x coordinate of upper-left corner of rectangle to redraw
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry> y coordinate of upper-left corner of rectangle to redraw
</entry></row>
<row><entry align="right"><parameter>width</parameter>&nbsp;:</entry>
<entry> width of region to draw
</entry></row>
<row><entry align="right"><parameter>height</parameter>&nbsp;:</entry>
<entry> height of region to draw
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-reset-shapes">gtk_widget_reset_shapes ()</title>
<programlisting>void        gtk_widget_reset_shapes         (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Recursively resets the shape on this widget and its descendants.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-app-paintable">gtk_widget_set_app_paintable ()</title>
<programlisting>void        gtk_widget_set_app_paintable    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> app_paintable);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>app_paintable</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-double-buffered">gtk_widget_set_double_buffered ()</title>
<programlisting>void        gtk_widget_set_double_buffered  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> double_buffered);</programlisting>
<para>
Widgets are double buffered by default; you can use this function
to turn off the buffering. "Double buffered" simply means that
<link linkend="gdk-window-begin-paint-region">gdk_window_begin_paint_region</link>() and <link linkend="gdk-window-end-paint">gdk_window_end_paint</link>() are called
automatically around expose events sent to the
widget. <link linkend="gdk-window-begin-paint">gdk_window_begin_paint</link>() diverts all drawing to a widget's
window to an offscreen buffer, and <link linkend="gdk-window-end-paint">gdk_window_end_paint</link>() draws the
buffer to the screen. The result is that users see the window
update in one smooth step, and don't see individual graphics
primitives being rendered.
</para>
<para>
In very simple terms, double buffered widgets don't flicker,
so you would only use this function to turn off double buffering
if you had special needs and really knew what you were doing.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>double_buffered</parameter>&nbsp;:</entry>
<entry> <literal>TRUE</literal> to double-buffer a widget
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-redraw-on-allocate">gtk_widget_set_redraw_on_allocate ()</title>
<programlisting>void        gtk_widget_set_redraw_on_allocate
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> redraw_on_allocate);</programlisting>
<para>
Sets whether a when a widgets size allocation changes, the entire
widget is queued for drawing. By default, this setting is <literal>TRUE</literal> and
the entire widget is redrawn on every size change. If your widget
leaves the upper left are unchanged when made bigger, turning this
setting on will improve performance.
</para>
<para>
Note that for <literal>NO_WINDOW</literal> widgets setting this flag to <literal>FALSE</literal> turns
off all allocation on resizing: the widget will not even redraw if
its position changes; this is to allow containers that don't draw
anything to avoid excess invalidations. If you set this flag on a
<literal>NO_WINDOW</literal> widget that <emphasis>does</emphasis> draw on <parameter>widget</parameter>->window, 
you are responsible for invalidating both the old and new allocation 
of the widget when the widget is moved and responsible for invalidating
regions newly when the widget increases size.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>redraw_on_allocate</parameter>&nbsp;:</entry>
<entry> if <literal>TRUE</literal>, 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.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-composite-name">gtk_widget_set_composite_name ()</title>
<programlisting>void        gtk_widget_set_composite_name   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *name);</programlisting>
<para>
Sets a widgets composite name. The widget must be
a composite child of its parent; see <link linkend="gtk-widget-push-composite-child">gtk_widget_push_composite_child</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>.
</entry></row>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry> the name to set.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-scroll-adjustments">gtk_widget_set_scroll_adjustments ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_set_scroll_adjustments
                                            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkAdjustment">GtkAdjustment</link> *hadjustment,
                                             <link linkend="GtkAdjustment">GtkAdjustment</link> *vadjustment);</programlisting>
<para>
For widgets that support scrolling, sets the scroll adjustments and
returns <literal>TRUE</literal>.  For widgets that don't support scrolling, does
nothing and returns <literal>FALSE</literal>. Widgets that don't support scrolling
can be scrolled by placing them in a <link linkend="GtkViewport">GtkViewport</link>, which does
support scrolling.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>hadjustment</parameter>&nbsp;:</entry>
<entry> an adjustment for horizontal scrolling, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>vadjustment</parameter>&nbsp;:</entry>
<entry> an adjustment for vertical scrolling, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if the widget supports scrolling
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-mnemonic-activate">gtk_widget_mnemonic_activate ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_mnemonic_activate    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> group_cycling);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>group_cycling</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-class-install-style-property">gtk_widget_class_install_style_property ()</title>
<programlisting>void        gtk_widget_class_install_style_property
                                            (<link linkend="GtkWidgetClass">GtkWidgetClass</link> *klass,
                                             <link linkend="GParamSpec">GParamSpec</link> *pspec);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>klass</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-class-install-style-property-parser">gtk_widget_class_install_style_property_parser ()</title>
<programlisting>void        gtk_widget_class_install_style_property_parser
                                            (<link linkend="GtkWidgetClass">GtkWidgetClass</link> *klass,
                                             <link linkend="GParamSpec">GParamSpec</link> *pspec,
                                             <link linkend="GtkRcPropertyParser">GtkRcPropertyParser</link> parser);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>klass</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>parser</parameter>&nbsp;:</entry>
<entry>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-region-intersect">gtk_widget_region_intersect ()</title>
<programlisting><link linkend="GdkRegion">GdkRegion</link>*  gtk_widget_region_intersect     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkRegion">GdkRegion</link> *region);</programlisting>
<para>
Computes the intersection of a <parameter>widget</parameter>'s area and <parameter>region</parameter>, returning
the intersection. The result may be empty, use <link linkend="gdk-region-empty">gdk_region_empty</link>() to
check.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>region</parameter>&nbsp;:</entry>
<entry> a <link linkend="GdkRegion">GdkRegion</link>, in the same coordinate system as 
         <parameter>widget</parameter>->allocation. That is, relative to <parameter>widget</parameter>->window
         for <literal>NO_WINDOW</literal> widgets; relative to the parent window
         of <parameter>widget</parameter>->window for widgets with their own window.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> A newly allocated region holding the intersection of <parameter>widget</parameter>
          and <parameter>region</parameter>. The coordinates of the return value are
          relative to <parameter>widget</parameter>->window for <literal>NO_WINDOW</literal> widgets, and
          relative to the parent window of <parameter>widget</parameter>->window for
          widgets with their own window.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-send-expose">gtk_widget_send_expose ()</title>
<programlisting><link linkend="gint">gint</link>        gtk_widget_send_expose          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GdkEvent">GdkEvent</link> *event);</programlisting>
<para>
Very rarely-used function. This function is used to emit
an expose event signals on a widget. This function is not
normally used directly. The only time it is used is when
propagating an expose event to a child <literal>NO_WINDOW</literal> widget, and
that is normally done using <link linkend="gtk-container-propagate-expose">gtk_container_propagate_expose</link>().
</para>
<para>
If you want to force an area of a window to be redrawn, 
use <link linkend="gdk-window-invalidate-rect">gdk_window_invalidate_rect</link>() or <link linkend="gdk-window-invalidate-region">gdk_window_invalidate_region</link>().
To cause the redraw to be done immediately, follow that call
with a call to <link linkend="gdk-window-process-updates">gdk_window_process_updates</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry> a expose <link linkend="GdkEvent">GdkEvent</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> return from the event signal emission (<literal>TRUE</literal> if the event was handled)
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-style-get">gtk_widget_style_get ()</title>
<programlisting>void        gtk_widget_style_get            (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             ...);</programlisting>
<para>
Gets the values of a multiple style properties of <parameter>widget</parameter>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>first_property_name</parameter>&nbsp;:</entry>
<entry> the name of the first property to get
</entry></row>
<row><entry align="right"><parameter>...</parameter>&nbsp;:</entry>
<entry> pairs of property names and locations to 
  return the property values, starting with the location for 
  <parameter>first_property_name</parameter>, terminated by <literal>NULL</literal>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-style-get-property">gtk_widget_style_get_property ()</title>
<programlisting>void        gtk_widget_style_get_property   (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *property_name,
                                             <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Gets the value of a style property of <parameter>widget</parameter>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>property_name</parameter>&nbsp;:</entry>
<entry> the name of a style property
</entry></row>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry> location to return the property value 
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-style-get-valist">gtk_widget_style_get_valist ()</title>
<programlisting>void        gtk_widget_style_get_valist     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *first_property_name,
                                             va_list var_args);</programlisting>
<para>
Non-vararg variant of <link linkend="gtk-widget-style-get">gtk_widget_style_get</link>(). Used primarily by language 
bindings.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>first_property_name</parameter>&nbsp;:</entry>
<entry> the name of the first property to get
</entry></row>
<row><entry align="right"><parameter>var_args</parameter>&nbsp;:</entry>
<entry> a <type>va_list</type> of pairs of property names and
    locations to return the property values, starting with the location
    for <parameter>first_property_name</parameter>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-accessible">gtk_widget_get_accessible ()</title>
<programlisting><link linkend="AtkObject">AtkObject</link>*  gtk_widget_get_accessible       (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-child-focus">gtk_widget_child_focus ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_child_focus          (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="GtkDirectionType">GtkDirectionType</link> direction);</programlisting>
<para>
This function is used by custom widget implementations; if you're
writing an app, you'd use <link linkend="gtk-widget-grab-focus">gtk_widget_grab_focus</link>() to move the focus
to a particular widget, and <link linkend="gtk-container-set-focus-chain">gtk_container_set_focus_chain</link>() to
change the focus tab order. So you may want to investigate those
functions instead.
</para>
<para>
<link linkend="gtk-widget-child-focus">gtk_widget_child_focus</link>() is called by containers as the user moves
around the window using keyboard shortcuts. <parameter>direction</parameter> indicates
what kind of motion is taking place (up, down, left, right, tab
forward, tab backward).  <link linkend="gtk-widget-child-focus">gtk_widget_child_focus</link>() invokes the
"focus" signal on <link linkend="GtkWidget">GtkWidget</link>; widgets override the default handler
for this signal in order to implement appropriate focus behavior.
</para>
<para>
The "focus" default handler for a widget should return <literal>TRUE</literal> if
moving in <parameter>direction</parameter> left the focus on a focusable location inside
that widget, and <literal>FALSE</literal> if moving in <parameter>direction</parameter> moved the focus
outside the widget. If returning <literal>TRUE</literal>, widgets normally
call <link linkend="gtk-widget-grab-focus">gtk_widget_grab_focus</link>() to place the focus accordingly;
if returning <literal>FALSE</literal>, they don't modify the current focus location.
</para>
<para>
This function replaces <link linkend="gtk-container-focus">gtk_container_focus</link>() from GTK+ 1.2.  It was
necessary to check that the child was visible, sensitive, and
focusable before calling
<link linkend="gtk-container-focus">gtk_container_focus</link>(). <link linkend="gtk-widget-child-focus">gtk_widget_child_focus</link>() returns <literal>FALSE</literal> if
the widget is not currently in a focusable state, so there's no
need for those checks.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>direction</parameter>&nbsp;:</entry>
<entry> direction of focus movement
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if focus ended up inside <parameter>widget</parameter>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-child-notify">gtk_widget_child_notify ()</title>
<programlisting>void        gtk_widget_child_notify         (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             const <link linkend="gchar">gchar</link> *child_property);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>child_property</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-freeze-child-notify">gtk_widget_freeze_child_notify ()</title>
<programlisting>void        gtk_widget_freeze_child_notify  (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-child-visible">gtk_widget_get_child_visible ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    gtk_widget_get_child_visible    (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets the value set with <link linkend="gtk-widget-set-child-visible">gtk_widget_set_child_visible</link>().
If you feel a need to use this function, your code probably
needs reorganization. 
</para>
<para>
This function is only useful for container implementations and
never should be called by an application.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> <literal>TRUE</literal> if the widget is mapped with the parent.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-parent">gtk_widget_get_parent ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  gtk_widget_get_parent           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Returns the parent container of <parameter>widget</parameter>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the parent container of <parameter>widget</parameter>, or <literal>NULL</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-settings">gtk_widget_get_settings ()</title>
<programlisting><link linkend="GtkSettings">GtkSettings</link>* gtk_widget_get_settings        (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Gets the settings object holding the settings (global property
settings, RC file information, etc) used for this widget.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the relevant <link linkend="GtkSettings">GtkSettings</link> object
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-get-size-request">gtk_widget_get_size_request ()</title>
<programlisting>void        gtk_widget_get_size_request     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> *width,
                                             <link linkend="gint">gint</link> *height);</programlisting>
<para>
Gets the size request that was explicitly set for the widget using
<link linkend="gtk-widget-set-size-request">gtk_widget_set_size_request</link>().  A value of -1 stored in <parameter>width</parameter> or
<parameter>height</parameter> indicates that that dimension has not been set explicitly
and the natural requisition of the widget will be used intead. See
<link linkend="gtk-widget-set-size-request">gtk_widget_set_size_request</link>(). To get the size a widget will
actually use, call <link linkend="gtk-widget-size-request">gtk_widget_size_request</link>() instead of
this function.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>width</parameter>&nbsp;:</entry>
<entry> return location for width, or <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>height</parameter>&nbsp;:</entry>
<entry> return location for height, or <literal>NULL</literal>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-pop-visual">gtk_widget_pop_visual()</title>
<programlisting>#define gtk_widget_pop_visual()               ((void) 0)
</programlisting>
<warning>
<para>
<literal>gtk_widget_pop_visual</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
This function is deprecated; it does nothing.
</para></refsect2>
<refsect2>
<title><anchor id="gtk-widget-push-visual">gtk_widget_push_visual()</title>
<programlisting>#define gtk_widget_push_visual(visual)        ((void) 0)
</programlisting>
<warning>
<para>
<literal>gtk_widget_push_visual</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
This function is deprecated; it does nothing.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>visual</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-child-visible">gtk_widget_set_child_visible ()</title>
<programlisting>void        gtk_widget_set_child_visible    (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gboolean">gboolean</link> is_visible);</programlisting>
<para>
Sets whether <parameter>widget</parameter> should be mapped along with its when its parent
is mapped and <parameter>widget</parameter> has been shown with <link linkend="gtk-widget-show">gtk_widget_show</link>(). 
</para>
<para>
The child visibility can be set for widget before it is added to
a container with <link linkend="gtk-widget-set-parent">gtk_widget_set_parent</link>(), to avoid mapping
children unnecessary before immediately unmapping them. However
it will be reset to its default state of <literal>TRUE</literal> when the widget
is removed from a container.
</para>
<para>
Note that changing the child visibility of a widget does not
queue a resize on the widget. Most of the time, the size of
a widget is computed from all visible children, whether or
not they are mapped. If this is not the case, the container
can queue a resize itself.
</para>
<para>
This function is only useful for container implementations and
never should be called by an application.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>is_visible</parameter>&nbsp;:</entry>
<entry> if <literal>TRUE</literal>, <parameter>widget</parameter> should be mapped along with its parent.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-default-visual">gtk_widget_set_default_visual()</title>
<programlisting>#define gtk_widget_set_default_visual(visual) ((void) 0)
</programlisting>
<warning>
<para>
<literal>gtk_widget_set_default_visual</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
This function is deprecated; it does nothing.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>visual</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-size-request">gtk_widget_set_size_request ()</title>
<programlisting>void        gtk_widget_set_size_request     (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                             <link linkend="gint">gint</link> width,
                                             <link linkend="gint">gint</link> height);</programlisting>
<para>
Sets the minimum size of a widget; that is, the widget's size
request will be <parameter>width</parameter> by <parameter>height</parameter>. You can use this function to
force a widget to be either larger or smaller than it normally
would be.
</para>
<para>
In most cases, <link linkend="gtk-window-set-default-size">gtk_window_set_default_size</link>() is a better choice for
toplevel windows than this function; setting the default size will
still allow users to shrink the window. Setting the size request
will force them to leave the window at least as large as the size
request. When dealing with window sizes,
<link linkend="gtk-window-set-geometry-hints">gtk_window_set_geometry_hints</link>() can be a useful function as well.
</para>
<para>
Note the inherent danger of setting any fixed size - themes,
translations into other languages, different fonts, and user action
can all change the appropriate size for a given widget. So, it's
basically impossible to hardcode a size that will always be
correct.
</para>
<para>
The size request of a widget is the smallest size a widget can
accept while still functioning well and drawing itself correctly.
However in some strange cases a widget may be allocated less than
its requested size, and in many cases a widget may be allocated more
space than it requested.
</para>
<para>
If the size request in a given direction is -1 (unset), then
the "natural" size request of the widget will be used instead.
</para>
<para>
Widgets can't actually be allocated a size less than 1 by 1, but
you can pass 0,0 to this function to mean "as small as possible."</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
<row><entry align="right"><parameter>width</parameter>&nbsp;:</entry>
<entry> width <parameter>widget</parameter> should request, or -1 to unset
</entry></row>
<row><entry align="right"><parameter>height</parameter>&nbsp;:</entry>
<entry> height <parameter>widget</parameter> should request, or -1 to unset
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-set-visual">gtk_widget_set_visual()</title>
<programlisting>#define gtk_widget_set_visual(widget,visual)  ((void) 0)
</programlisting>
<warning>
<para>
<literal>gtk_widget_set_visual</literal> is deprecated and should not be used in newly-written code.
</para>
</warning>
<para>
This function is deprecated; it does nothing.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>visual</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-widget-thaw-child-notify">gtk_widget_thaw_child_notify ()</title>
<programlisting>void        gtk_widget_thaw_child_notify    (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Reverts the effect of a previous call to <link linkend="gtk-widget-freeze-child-notify">gtk_widget_freeze_child_notify</link>().</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkWidget">GtkWidget</link>
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-requisition-copy">gtk_requisition_copy ()</title>
<programlisting><link linkend="GtkRequisition">GtkRequisition</link>* gtk_requisition_copy        (const <link linkend="GtkRequisition">GtkRequisition</link> *requisition);</programlisting>
<para>
Copies a <link linkend="GtkRequisition">GtkRequisition</link>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>requisition</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkRequisition">GtkRequisition</link>.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> a copy of <parameter>requisition</parameter>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="gtk-requisition-free">gtk_requisition_free ()</title>
<programlisting>void        gtk_requisition_free            (<link linkend="GtkRequisition">GtkRequisition</link> *requisition);</programlisting>
<para>
Frees a <link linkend="GtkRequisition">GtkRequisition</link>.</para>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>requisition</parameter>&nbsp;:</entry>
<entry> a <link linkend="GtkRequisition">GtkRequisition</link>.
</entry></row>
</tbody></tgroup></informaltable></refsect2>

</refsect1>
<refsect1>
<title>Properties</title>
<variablelist>
<varlistentry><term><anchor id="GtkWidget--name">&quot;<literal>name</literal>&quot; (<link linkend="gchararray">gchararray</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--parent">&quot;<literal>parent</literal>&quot; (<link linkend="GtkContainer">GtkContainer</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--width-request">&quot;<literal>width-request</literal>&quot; (<link linkend="gint">gint</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--height-request">&quot;<literal>height-request</literal>&quot; (<link linkend="gint">gint</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--visible">&quot;<literal>visible</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--sensitive">&quot;<literal>sensitive</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--app-paintable">&quot;<literal>app-paintable</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--can-focus">&quot;<literal>can-focus</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--has-focus">&quot;<literal>has-focus</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--can-default">&quot;<literal>can-default</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--has-default">&quot;<literal>has-default</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--receives-default">&quot;<literal>receives-default</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--composite-child">&quot;<literal>composite-child</literal>&quot; (<link linkend="gboolean">gboolean</link> : Read)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--style">&quot;<literal>style</literal>&quot; (<link linkend="GtkStyle">GtkStyle</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--events">&quot;<literal>events</literal>&quot; (<link linkend="GdkEventMask">GdkEventMask</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>
<varlistentry><term><anchor id="GtkWidget--extension-events">&quot;<literal>extension-events</literal>&quot; (<link linkend="GdkExtensionMode">GdkExtensionMode</link> : Read / Write)</term>
<listitem>
<para>

</para></listitem></varlistentry>

</variablelist>
</refsect1>

<refsect1>
<title>Signals</title>
<refsect2><title><anchor id="GtkWidget-accel-closures-changed">The &quot;accel-closures-changed&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-button-press-event">The &quot;button-press-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventButton">GdkEventButton</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-button-release-event">The &quot;button-release-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventButton">GdkEventButton</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-child-notify">The &quot;child-notify&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GParam">GParam</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-client-event">The &quot;client-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventClient">GdkEventClient</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-configure-event">The &quot;configure-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventConfigure">GdkEventConfigure</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-delete-event">The &quot;delete-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-destroy-event">The &quot;destroy-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-direction-changed">The &quot;direction-changed&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkTextDirection">GtkTextDirection</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-begin">The &quot;drag-begin&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-data-delete">The &quot;drag-data-delete&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-data-get">The &quot;drag-data-get&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>info</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-data-received">The &quot;drag-data-received&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>info</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-drop">The &quot;drag-drop&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-end">The &quot;drag-end&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-leave">The &quot;drag-leave&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-drag-motion">The &quot;drag-motion&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkDragContext">GdkDragContext</link> *drag_context,
                                            <link linkend="gint">gint</link> x,
                                            <link linkend="gint">gint</link> y,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>drag_context</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>x</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>y</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-enter-notify-event">The &quot;enter-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventCrossing">GdkEventCrossing</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-event">The &quot;event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-event-after">The &quot;event-after&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-expose-event">The &quot;expose-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventExpose">GdkEventExpose</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-focus">The &quot;focus&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkDirectionType">GtkDirectionType</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-focus-in-event">The &quot;focus-in-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventFocus">GdkEventFocus</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-focus-out-event">The &quot;focus-out-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventFocus">GdkEventFocus</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-grab-focus">The &quot;grab-focus&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-grab-notify">The &quot;grab-notify&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gboolean">gboolean</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-hide">The &quot;hide&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-hierarchy-changed">The &quot;hierarchy-changed&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>
Emitted when there is a chance in the hierarchy to
which a widget belong. More precisely, a widget is
<firstterm>anchored</firstterm> when its toplevel
ancestor is a <link linkend="GtkWindow">GtkWindow</link>. This signal is emitted when 
a widget changes from un-anchored to anchored or vice-versa.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-key-press-event">The &quot;key-press-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventKey">GdkEventKey</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-key-release-event">The &quot;key-release-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventKey">GdkEventKey</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-leave-notify-event">The &quot;leave-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventCrossing">GdkEventCrossing</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-map">The &quot;map&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-map-event">The &quot;map-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-mnemonic-activate">The &quot;mnemonic-activate&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gboolean">gboolean</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-motion-notify-event">The &quot;motion-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventMotion">GdkEventMotion</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-no-expose-event">The &quot;no-expose-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventNoExpose">GdkEventNoExpose</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-parent-set">The &quot;parent-set&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkObject">GtkObject</link> *old_parent,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>old_parent</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-popup-menu">The &quot;popup-menu&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-property-notify-event">The &quot;property-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProperty">GdkEventProperty</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-proximity-in-event">The &quot;proximity-in-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProximity">GdkEventProximity</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-proximity-out-event">The &quot;proximity-out-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventProximity">GdkEventProximity</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-realize">The &quot;realize&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-scroll-event">The &quot;scroll-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-selection-clear-event">The &quot;selection-clear-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-selection-get">The &quot;selection-get&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> info,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>info</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-selection-notify-event">The &quot;selection-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-selection-received">The &quot;selection-received&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkSelectionData">GtkSelectionData</link> *data,
                                            <link linkend="guint">guint</link> time,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>time</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-selection-request-event">The &quot;selection-request-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEventSelection">GdkEventSelection</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-show">The &quot;show&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-show-help">The &quot;show-help&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkWidgetHelpType">GtkWidgetHelpType</link> arg1,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>arg1</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-size-allocate">The &quot;size-allocate&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkAllocation">GtkAllocation</link> *allocation,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>allocation</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-size-request">The &quot;size-request&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkRequisition">GtkRequisition</link> *requisition,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>requisition</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-state-changed">The &quot;state-changed&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkStateType">GtkStateType</link> state,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>state</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-style-set">The &quot;style-set&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GtkStyle">GtkStyle</link> *previous_style,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>previous_style</parameter>&nbsp;:</entry>
<entry>

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-unmap">The &quot;unmap&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-unmap-event">The &quot;unmap-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-unrealize">The &quot;unrealize&quot; signal</title>
<programlisting>void        user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.

</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-visibility-notify-event">The &quot;visibility-notify-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2><refsect2><title><anchor id="GtkWidget-window-state-event">The &quot;window-state-event&quot; signal</title>
<programlisting><link linkend="gboolean">gboolean</link>    user_function                  (<link linkend="GtkWidget">GtkWidget</link> *widget,
                                            <link linkend="GdkEvent">GdkEvent</link> *event,
                                            <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry>the object which received the signal.
</entry></row>
<row><entry align="right"><parameter>event</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry>user data set when the signal handler was connected.</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>

</entry></row>
</tbody></tgroup></informaltable></refsect2>
</refsect1>



</refentry>
