GtkWidget

Name

GtkWidget -- 

Synopsis


#include <gtk/gtk.h>


struct      GtkWidget;
enum        GtkWidgetFlags;
#define     GTK_WIDGET_TYPE                 (wid)
#define     GTK_WIDGET_STATE                (wid)
#define     GTK_WIDGET_SAVED_STATE          (wid)
#define     GTK_WIDGET_FLAGS                (wid)
#define     GTK_WIDGET_TOPLEVEL             (wid)
#define     GTK_WIDGET_NO_WINDOW            (wid)
#define     GTK_WIDGET_REALIZED             (wid)
#define     GTK_WIDGET_MAPPED               (wid)
#define     GTK_WIDGET_VISIBLE              (wid)
#define     GTK_WIDGET_DRAWABLE             (wid)
#define     GTK_WIDGET_SENSITIVE            (wid)
#define     GTK_WIDGET_PARENT_SENSITIVE     (wid)
#define     GTK_WIDGET_IS_SENSITIVE         (wid)
#define     GTK_WIDGET_CAN_FOCUS            (wid)
#define     GTK_WIDGET_HAS_FOCUS            (wid)
#define     GTK_WIDGET_CAN_DEFAULT          (wid)
#define     GTK_WIDGET_RECEIVES_DEFAULT     (wid)
#define     GTK_WIDGET_HAS_DEFAULT          (wid)
#define     GTK_WIDGET_HAS_GRAB             (wid)
#define     GTK_WIDGET_RC_STYLE             (wid)
#define     GTK_WIDGET_COMPOSITE_CHILD      (wid)
#define     GTK_WIDGET_APP_PAINTABLE        (wid)
#define     GTK_WIDGET_DOUBLE_BUFFERED      (wid)
#define     GTK_WIDGET_SET_FLAGS            (wid,flag)
#define     GTK_WIDGET_UNSET_FLAGS          (wid,flag)
void        (*GtkCallback)                  (GtkWidget *widget,
                                             gpointer data);
struct      GtkRequisition;
struct      GtkAllocation;
struct      GtkSelectionData;
struct      GtkWidgetAuxInfo;
struct      GtkWidgetShapeInfo;
GtkWidget*  gtk_widget_new                  (GtkType type,
                                             const gchar *first_property_name,
                                             ...);
GtkWidget*  gtk_widget_ref                  (GtkWidget *widget);
void        gtk_widget_unref                (GtkWidget *widget);
void        gtk_widget_destroy              (GtkWidget *widget);
void        gtk_widget_destroyed            (GtkWidget *widget,
                                             GtkWidget **widget_pointer);
void        gtk_widget_set                  (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             ...);
void        gtk_widget_unparent             (GtkWidget *widget);
void        gtk_widget_show                 (GtkWidget *widget);
void        gtk_widget_show_now             (GtkWidget *widget);
void        gtk_widget_hide                 (GtkWidget *widget);
void        gtk_widget_show_all             (GtkWidget *widget);
void        gtk_widget_hide_all             (GtkWidget *widget);
void        gtk_widget_map                  (GtkWidget *widget);
void        gtk_widget_unmap                (GtkWidget *widget);
void        gtk_widget_realize              (GtkWidget *widget);
void        gtk_widget_unrealize            (GtkWidget *widget);
void        gtk_widget_queue_draw           (GtkWidget *widget);
void        gtk_widget_queue_resize         (GtkWidget *widget);
void        gtk_widget_draw                 (GtkWidget *widget,
                                             GdkRectangle *area);
void        gtk_widget_size_request         (GtkWidget *widget,
                                             GtkRequisition *requisition);
void        gtk_widget_get_child_requisition
                                            (GtkWidget *widget,
                                             GtkRequisition *requisition);
void        gtk_widget_size_allocate        (GtkWidget *widget,
                                             GtkAllocation *allocation);
void        gtk_widget_add_accelerator      (GtkWidget *widget,
                                             const gchar *accel_signal,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods,
                                             GtkAccelFlags accel_flags);
void        gtk_widget_remove_accelerator   (GtkWidget *widget,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods);
void        gtk_widget_remove_accelerators  (GtkWidget *widget,
                                             const gchar *accel_signal,
                                             gboolean visible_only);
guint       gtk_widget_accelerator_signal   (GtkWidget *widget,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods);
gboolean    gtk_widget_event                (GtkWidget *widget,
                                             GdkEvent *event);
gboolean    gtk_widget_activate             (GtkWidget *widget);
void        gtk_widget_reparent             (GtkWidget *widget,
                                             GtkWidget *new_parent);
gboolean    gtk_widget_intersect            (GtkWidget *widget,
                                             GdkRectangle *area,
                                             GdkRectangle *intersection);
gboolean    gtk_widget_is_focus             (GtkWidget *widget);
void        gtk_widget_grab_focus           (GtkWidget *widget);
void        gtk_widget_grab_default         (GtkWidget *widget);
void        gtk_widget_set_name             (GtkWidget *widget,
                                             const gchar *name);
G_CONST_RETURN gchar* gtk_widget_get_name   (GtkWidget *widget);
void        gtk_widget_set_state            (GtkWidget *widget,
                                             GtkStateType state);
void        gtk_widget_set_sensitive        (GtkWidget *widget,
                                             gboolean sensitive);
void        gtk_widget_set_parent           (GtkWidget *widget,
                                             GtkWidget *parent);
void        gtk_widget_set_parent_window    (GtkWidget *widget,
                                             GdkWindow *parent_window);
GdkWindow*  gtk_widget_get_parent_window    (GtkWidget *widget);
void        gtk_widget_set_uposition        (GtkWidget *widget,
                                             gint x,
                                             gint y);
void        gtk_widget_set_usize            (GtkWidget *widget,
                                             gint width,
                                             gint height);
void        gtk_widget_set_events           (GtkWidget *widget,
                                             gint events);
void        gtk_widget_add_events           (GtkWidget *widget,
                                             gint events);
void        gtk_widget_set_extension_events (GtkWidget *widget,
                                             GdkExtensionMode mode);
GdkExtensionMode gtk_widget_get_extension_events
                                            (GtkWidget *widget);
GtkWidget*  gtk_widget_get_toplevel         (GtkWidget *widget);
GtkWidget*  gtk_widget_get_ancestor         (GtkWidget *widget,
                                             GtkType widget_type);
GdkColormap* gtk_widget_get_colormap        (GtkWidget *widget);
void        gtk_widget_set_colormap         (GtkWidget *widget,
                                             GdkColormap *colormap);
GdkVisual*  gtk_widget_get_visual           (GtkWidget *widget);
gint        gtk_widget_get_events           (GtkWidget *widget);
void        gtk_widget_get_pointer          (GtkWidget *widget,
                                             gint *x,
                                             gint *y);
gboolean    gtk_widget_is_ancestor          (GtkWidget *widget,
                                             GtkWidget *ancestor);
gboolean    gtk_widget_hide_on_delete       (GtkWidget *widget);
void        gtk_widget_set_style            (GtkWidget *widget,
                                             GtkStyle *style);
void        gtk_widget_set_rc_style         (GtkWidget *widget);
void        gtk_widget_ensure_style         (GtkWidget *widget);
GtkStyle*   gtk_widget_get_style            (GtkWidget *widget);
void        gtk_widget_restore_default_style
                                            (GtkWidget *widget);
void        gtk_widget_reset_rc_styles      (GtkWidget *widget);
void        gtk_widget_push_style           (GtkStyle *style);
void        gtk_widget_push_colormap        (GdkColormap *cmap);
void        gtk_widget_pop_style            (void);
void        gtk_widget_pop_colormap         (void);
void        gtk_widget_set_default_style    (GtkStyle *style);
void        gtk_widget_set_default_colormap (GdkColormap *colormap);
GtkStyle*   gtk_widget_get_default_style    (void);
GdkColormap* gtk_widget_get_default_colormap
                                            (void);
GdkVisual*  gtk_widget_get_default_visual   (void);
void        gtk_widget_set_direction        (GtkWidget *widget,
                                             GtkTextDirection dir);
enum        GtkTextDirection;
GtkTextDirection gtk_widget_get_direction   (GtkWidget *widget);
void        gtk_widget_set_default_direction
                                            (GtkTextDirection dir);
GtkTextDirection gtk_widget_get_default_direction
                                            (void);
void        gtk_widget_shape_combine_mask   (GtkWidget *widget,
                                             GdkBitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);
void        gtk_widget_path                 (GtkWidget *widget,
                                             guint *path_length,
                                             gchar **path,
                                             gchar **path_reversed);
void        gtk_widget_class_path           (GtkWidget *widget,
                                             guint *path_length,
                                             gchar **path,
                                             gchar **path_reversed);
gchar*      gtk_widget_get_composite_name   (GtkWidget *widget);
void        gtk_widget_lock_accelerators    (GtkWidget *widget);
void        gtk_widget_modify_style         (GtkWidget *widget,
                                             GtkRcStyle *style);
GtkRcStyle* gtk_widget_get_modifier_style   (GtkWidget *widget);
void        gtk_widget_modify_fg            (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);
void        gtk_widget_modify_bg            (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);
void        gtk_widget_modify_text          (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);
void        gtk_widget_modify_base          (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);
void        gtk_widget_modify_font          (GtkWidget *widget,
                                             PangoFontDescription *font_desc);
PangoContext* gtk_widget_create_pango_context
                                            (GtkWidget *widget);
PangoContext* gtk_widget_get_pango_context  (GtkWidget *widget);
PangoLayout* gtk_widget_create_pango_layout (GtkWidget *widget,
                                             const gchar *text);
GdkPixbuf*  gtk_widget_render_icon          (GtkWidget *widget,
                                             const gchar *stock_id,
                                             GtkIconSize size,
                                             const gchar *detail);
void        gtk_widget_pop_composite_child  (void);
void        gtk_widget_push_composite_child (void);
void        gtk_widget_queue_clear          (GtkWidget *widget);
void        gtk_widget_queue_clear_area     (GtkWidget *widget,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);
void        gtk_widget_queue_draw_area      (GtkWidget *widget,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);
void        gtk_widget_reset_shapes         (GtkWidget *widget);
void        gtk_widget_set_app_paintable    (GtkWidget *widget,
                                             gboolean app_paintable);
void        gtk_widget_set_double_buffered  (GtkWidget *widget,
                                             gboolean double_buffered);
void        gtk_widget_set_composite_name   (GtkWidget *widget,
                                             const gchar *name);
gboolean    gtk_widget_set_scroll_adjustments
                                            (GtkWidget *widget,
                                             GtkAdjustment *hadjustment,
                                             GtkAdjustment *vadjustment);
void        gtk_widget_unlock_accelerators  (GtkWidget *widget);
gboolean    gtk_widget_accelerators_locked  (GtkWidget *widget);
gboolean    gtk_widget_mnemonic_activate    (GtkWidget *widget,
                                             gboolean group_cycling);
void        gtk_widget_class_install_style_property
                                            (GtkWidgetClass *klass,
                                             GParamSpec *pspec);
void        gtk_widget_class_install_style_property_parser
                                            (GtkWidgetClass *klass,
                                             GParamSpec *pspec,
                                             GtkRcPropertyParser parser);
GdkRegion*  gtk_widget_region_intersect     (GtkWidget *widget,
                                             GdkRegion *region);
gint        gtk_widget_send_expose          (GtkWidget *widget,
                                             GdkEvent *event);
void        gtk_widget_style_get            (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             ...);
void        gtk_widget_style_get_property   (GtkWidget *widget,
                                             const gchar *property_name,
                                             GValue *value);
void        gtk_widget_style_get_valist     (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             va_list var_args);

GtkRequisition* gtk_requisition_copy        (const GtkRequisition *requisition);
void        gtk_requisition_free            (GtkRequisition *requisition);

Object Hierarchy


  GObject
   +----GtkObject
         +----GtkWidget

Args


  "name"                 gchararray           : Read / Write
  "parent"               GtkContainer         : Read / Write
  "x"                    gint                 : Read / Write
  "y"                    gint                 : Read / Write
  "width"                gint                 : Read / Write
  "height"               gint                 : Read / Write
  "visible"              gboolean             : Read / Write
  "sensitive"            gboolean             : Read / Write
  "app-paintable"        gboolean             : Read / Write
  "can-focus"            gboolean             : Read / Write
  "has-focus"            gboolean             : Read / Write
  "can-default"          gboolean             : Read / Write
  "has-default"          gboolean             : Read / Write
  "receives-default"     gboolean             : Read / Write
  "composite-child"      gboolean             : Read / Write
  "style"                GtkStyle             : Read / Write
  "events"               GdkEventMask         : Read / Write
  "extension-events"     GdkExtensionMode     : Read / Write

Signal Prototypes


"add-accelerator"
            void        user_function      (GtkWidget *widget,
                                            guint accel_signal_id,
                                            GtkAccelGroup *accel_group,
                                            guint accel_key,
                                            GdkModifierType accel_mods,
                                            GtkAccelFlags accel_flags,
                                            gpointer user_data);
"button-press-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventButton *event,
                                            gpointer user_data);
"button-release-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventButton *event,
                                            gpointer user_data);
"client-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventClient *event,
                                            gpointer user_data);
"configure-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventConfigure *event,
                                            gpointer user_data);
"delete-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"destroy-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"direction-changed"
            void        user_function      (GtkWidget *widget,
                                            GtkTextDirection arg1,
                                            gpointer user_data);
"drag-begin"
            void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);
"drag-data-delete"
            void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);
"drag-data-get"
            void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);
"drag-data-received"
            void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);
"drag-drop" gboolean    user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            guint time,
                                            gpointer user_data);
"drag-end"  void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);
"drag-leave"
            void        user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            guint time,
                                            gpointer user_data);
"drag-motion"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            guint time,
                                            gpointer user_data);
"enter-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventCrossing *event,
                                            gpointer user_data);
"event"     gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"expose-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventExpose *event,
                                            gpointer user_data);
"focus-in-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventFocus *event,
                                            gpointer user_data);
"focus-out-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventFocus *event,
                                            gpointer user_data);
"grab-focus"
            void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"hide"      void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"hierarchy-changed"
            void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"key-press-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventKey *event,
                                            gpointer user_data);
"key-release-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventKey *event,
                                            gpointer user_data);
"leave-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventCrossing *event,
                                            gpointer user_data);
"map"       void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"map-event" gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"mnemonic-activate"
            gboolean    user_function      (GtkWidget *widget,
                                            gboolean arg1,
                                            gpointer user_data);
"motion-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventMotion *event,
                                            gpointer user_data);
"no-expose-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventNoExpose *event,
                                            gpointer user_data);
"parent-set"
            void        user_function      (GtkWidget *widget,
                                            GtkObject *old_parent,
                                            gpointer user_data);
"popup-menu"
            void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"property-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventProperty *event,
                                            gpointer user_data);
"proximity-in-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventProximity *event,
                                            gpointer user_data);
"proximity-out-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventProximity *event,
                                            gpointer user_data);
"realize"   void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"remove-accelerator"
            void        user_function      (GtkWidget *widget,
                                            GtkAccelGroup *accel_group,
                                            guint accel_key,
                                            GdkModifierType accel_mods,
                                            gpointer user_data);
"scroll-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"selection-clear-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);
"selection-get"
            void        user_function      (GtkWidget *widget,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);
"selection-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);
"selection-received"
            void        user_function      (GtkWidget *widget,
                                            GtkSelectionData *data,
                                            guint time,
                                            gpointer user_data);
"selection-request-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);
"show"      void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"size-allocate"
            void        user_function      (GtkWidget *widget,
                                            GtkAllocation *allocation,
                                            gpointer user_data);
"size-request"
            void        user_function      (GtkWidget *widget,
                                            GtkRequisition *requisition,
                                            gpointer user_data);
"state-changed"
            void        user_function      (GtkWidget *widget,
                                            GtkStateType state,
                                            gpointer user_data);
"style-set" void        user_function      (GtkWidget *widget,
                                            GtkStyle *previous_style,
                                            gpointer user_data);
"unmap"     void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"unmap-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"unrealize" void        user_function      (GtkWidget *widget,
                                            gpointer user_data);
"visibility-notify-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);
"window-state-event"
            gboolean    user_function      (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

Description

Details

struct GtkWidget

struct GtkWidget;


enum GtkWidgetFlags

typedef enum
{
  GTK_TOPLEVEL         = 1 << 4,
  GTK_NO_WINDOW        = 1 << 5,
  GTK_REALIZED         = 1 << 6,
  GTK_MAPPED           = 1 << 7,
  GTK_VISIBLE          = 1 << 8,
  GTK_SENSITIVE        = 1 << 9,
  GTK_PARENT_SENSITIVE = 1 << 10,
  GTK_CAN_FOCUS        = 1 << 11,
  GTK_HAS_FOCUS        = 1 << 12,

  /* widget is allowed to receive the default via gtk_widget_grab_default
   * and will reserve space to draw the default if possible
   */
  GTK_CAN_DEFAULT      = 1 << 13,

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

  GTK_HAS_GRAB	       = 1 << 15,
  GTK_RC_STYLE	       = 1 << 16,
  GTK_COMPOSITE_CHILD  = 1 << 17,
  GTK_NO_REPARENT      = 1 << 18,
  GTK_APP_PAINTABLE    = 1 << 19,

  /* the widget when focused will receive the default action and have
   * HAS_DEFAULT set even if there is a different widget set as default
   */
  GTK_RECEIVES_DEFAULT = 1 << 20,

  GTK_DOUBLE_BUFFERED  = 1 << 21
} GtkWidgetFlags;


GTK_WIDGET_TYPE()

#define GTK_WIDGET_TYPE(wid)		  (GTK_OBJECT_TYPE (wid))

wid : 


GTK_WIDGET_STATE()

#define GTK_WIDGET_STATE(wid)		  (GTK_WIDGET (wid)->state)

wid : 


GTK_WIDGET_SAVED_STATE()

#define GTK_WIDGET_SAVED_STATE(wid)	  (GTK_WIDGET (wid)->saved_state)

wid : 


GTK_WIDGET_FLAGS()

#define GTK_WIDGET_FLAGS(wid)		  (GTK_OBJECT_FLAGS (wid))

wid : 


GTK_WIDGET_TOPLEVEL()

#define GTK_WIDGET_TOPLEVEL(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_TOPLEVEL) != 0)

wid : 


GTK_WIDGET_NO_WINDOW()

#define GTK_WIDGET_NO_WINDOW(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_NO_WINDOW) != 0)

wid : 


GTK_WIDGET_REALIZED()

#define GTK_WIDGET_REALIZED(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_REALIZED) != 0)

wid : 


GTK_WIDGET_MAPPED()

#define GTK_WIDGET_MAPPED(wid)		  ((GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0)

wid : 


GTK_WIDGET_VISIBLE()

#define GTK_WIDGET_VISIBLE(wid)		  ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0)

wid : 


GTK_WIDGET_DRAWABLE()

#define GTK_WIDGET_DRAWABLE(wid)	  (GTK_WIDGET_VISIBLE (wid) && GTK_WIDGET_MAPPED (wid))

wid : 


GTK_WIDGET_SENSITIVE()

#define GTK_WIDGET_SENSITIVE(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_SENSITIVE) != 0)

wid : 


GTK_WIDGET_PARENT_SENSITIVE()

#define GTK_WIDGET_PARENT_SENSITIVE(wid)  ((GTK_WIDGET_FLAGS (wid) & GTK_PARENT_SENSITIVE) != 0)

wid : 


GTK_WIDGET_IS_SENSITIVE()

#define     GTK_WIDGET_IS_SENSITIVE(wid)

wid : 


GTK_WIDGET_CAN_FOCUS()

#define GTK_WIDGET_CAN_FOCUS(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_FOCUS) != 0)

wid : 


GTK_WIDGET_HAS_FOCUS()

#define GTK_WIDGET_HAS_FOCUS(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_FOCUS) != 0)

wid : 


GTK_WIDGET_CAN_DEFAULT()

#define GTK_WIDGET_CAN_DEFAULT(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_DEFAULT) != 0)

wid : 


GTK_WIDGET_RECEIVES_DEFAULT()

#define GTK_WIDGET_RECEIVES_DEFAULT(wid)  ((GTK_WIDGET_FLAGS (wid) & GTK_RECEIVES_DEFAULT) != 0)

wid : 


GTK_WIDGET_HAS_DEFAULT()

#define GTK_WIDGET_HAS_DEFAULT(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_DEFAULT) != 0)

wid : 


GTK_WIDGET_HAS_GRAB()

#define GTK_WIDGET_HAS_GRAB(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0)

wid : 


GTK_WIDGET_RC_STYLE()

#define GTK_WIDGET_RC_STYLE(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0)

wid : 


GTK_WIDGET_COMPOSITE_CHILD()

#define GTK_WIDGET_COMPOSITE_CHILD(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0)

wid : 


GTK_WIDGET_APP_PAINTABLE()

#define GTK_WIDGET_APP_PAINTABLE(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_APP_PAINTABLE) != 0)

wid : 


GTK_WIDGET_DOUBLE_BUFFERED()

#define GTK_WIDGET_DOUBLE_BUFFERED(wid)	  ((GTK_WIDGET_FLAGS (wid) & GTK_DOUBLE_BUFFERED) != 0)

wid : 


GTK_WIDGET_SET_FLAGS()

#define GTK_WIDGET_SET_FLAGS(wid,flag)	  G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END

wid : 
flag : 


GTK_WIDGET_UNSET_FLAGS()

#define GTK_WIDGET_UNSET_FLAGS(wid,flag)  G_STMT_START{ (GTK_WIDGET_FLAGS (wid) &= ~(flag)); }G_STMT_END

wid : 
flag : 


GtkCallback ()

void        (*GtkCallback)                  (GtkWidget *widget,
                                             gpointer data);

widget : 
data : 


struct GtkRequisition

struct GtkRequisition
{
  gint width;
  gint height;
};


struct GtkAllocation

struct GtkAllocation
{
  gint x;
  gint y;
  gint width;
  gint height;
};


struct GtkSelectionData

struct GtkSelectionData
{
  GdkAtom selection;
  GdkAtom target;
  GdkAtom type;
  gint	  format;
  guchar *data;  
  gint	  length;
};


struct GtkWidgetAuxInfo

struct GtkWidgetAuxInfo
{
  gint x;
  gint y;
  gint width;
  gint height;
  guint x_set : 1;
  guint y_set : 1;
};


struct GtkWidgetShapeInfo

struct GtkWidgetShapeInfo
{
  gint16     offset_x;
  gint16     offset_y;
  GdkBitmap *shape_mask;
};


gtk_widget_new ()

GtkWidget*  gtk_widget_new                  (GtkType type,
                                             const gchar *first_property_name,
                                             ...);

This is a convenience function for creating a widget and setting its properties in one go. For example you might write: gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign", 0.0, NULL) to create a left-aligned label. Equivalent to gtk_object_new(), but returns a widget so you don't have to cast the object yourself.

type : type ID of the widget to create
first_property_name : name of first property to set
... : value of first property, followed by more properties, NULL-terminated
Returns : a new GtkWidget of type widget_type


gtk_widget_ref ()

GtkWidget*  gtk_widget_ref                  (GtkWidget *widget);

Adds a reference to a widget. This function is exactly the same as calling g_object_ref(), and exists mostly for historical reasons. It can still be convenient to avoid casting a widget to a GObject, it saves a small amount of typing.

widget : a GtkWidget
Returns : the widget that was referenced


gtk_widget_unref ()

void        gtk_widget_unref                (GtkWidget *widget);

Inverse of gtk_widget_ref(). Equivalent to g_object_unref().

widget : a GtkWidget


gtk_widget_destroy ()

void        gtk_widget_destroy              (GtkWidget *widget);

Destroys a widget. Equivalent to gtk_object_destroy(), except that you don't have to cast the widget to GtkObject. When a widget is destroyed, it will break any references it holds to other objects. If the widget is inside a container, the widget will be removed from the container. If the widget is a toplevel (derived from GtkWindow), it will be removed from the list of toplevels, and the reference GTK+ holds to it will be removed. Removing a widget from its container or the list of toplevels results in the widget being finalized, unless you've added additional references to the widget with gtk_object_ref().

In most cases, only toplevel widgets (windows) require explicit destruction, because when you destroy a toplevel its children will be destroyed as well.

widget : a GtkWidget


gtk_widget_destroyed ()

void        gtk_widget_destroyed            (GtkWidget *widget,
                                             GtkWidget **widget_pointer);

This function sets *widget_pointer to NULL if widget_pointer != NULL. It's intended to be used as a callback connected to the "destroy" signal of a widget. You connect gtk_widget_destroyed() as a signal handler, and pass the address of your widget variable as user data. Then when the widget is destroyed, the variable will be set to NULL. Useful for example to avoid multiple copies of the same dialog.

widget : a GtkWidget
widget_pointer : address of a variable that contains widget


gtk_widget_set ()

void        gtk_widget_set                  (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             ...);

Like gtk_object_set() - there's no reason to use this instead of gtk_object_set().

widget : a GtkWidget
first_property_name : name of first property to set
... : value of first property, followed by more properties, NULL-terminated


gtk_widget_unparent ()

void        gtk_widget_unparent             (GtkWidget *widget);

This function is only for use in widget implementations. Should be called by implementations of the remove method on GtkContainer, to dissociate a child from the container.

widget : a GtkWidget


gtk_widget_show ()

void        gtk_widget_show                 (GtkWidget *widget);

Flags a widget to be displayed. Any widget that isn't shown will not appear on the screen. If you want to show all the widgets in a container, it's easier to call gtk_widget_show_all() on the container, instead of individually showing the widgets.

Remember that you have to show the containers containing a widget, in addition to the widget itself, before it will appear onscreen.

When a toplevel container is shown, it is immediately realized and mapped; other shown widgets are realized and mapped when their toplevel container is realized and mapped.

widget : a GtkWidget


gtk_widget_show_now ()

void        gtk_widget_show_now             (GtkWidget *widget);

Shows a widget. If the widget is an unmapped toplevel widget (i.e. a GtkWindow that has not yet been shown), enter the main loop and wait for the window to actually be mapped. Be careful; because the main loop is running, anything can happen during this function.

widget : a GtkWidget


gtk_widget_hide ()

void        gtk_widget_hide                 (GtkWidget *widget);

Reverses the effects of gtk_widget_show(), causing the widget to be hidden (invisible to the user).

widget : a GtkWidget


gtk_widget_show_all ()

void        gtk_widget_show_all             (GtkWidget *widget);

Recursively shows a widget, and any child widgets (if the widget is a container).

widget : a GtkWidget


gtk_widget_hide_all ()

void        gtk_widget_hide_all             (GtkWidget *widget);

Recursively hides a widget and any child widgets.

widget : a GtkWidget


gtk_widget_map ()

void        gtk_widget_map                  (GtkWidget *widget);

This function is only for use in widget implementations. Causes a widget to be mapped if it isn't already.

widget : a GtkWidget


gtk_widget_unmap ()

void        gtk_widget_unmap                (GtkWidget *widget);

This function is only for use in widget implementations. Causes a widget to be unmapped if it's currently mapped.

widget : a GtkWidget


gtk_widget_realize ()

void        gtk_widget_realize              (GtkWidget *widget);

Creates the GDK (windowing system) resources associated with a widget. For example, widget->window will be created when a widget is realized. Normally realization happens implicitly; if you show a widget and all its parent containers, then the widget will be realized and mapped automatically.

Realizing a widget requires all the widget's parent widgets to be realized; calling gtk_widget_realize() realizes the widget's parents in addition to widget itself. If a widget is not yet inside a toplevel window when you realize it, bad things will happen.

This function is primarily used in widget implementations, and isn't very useful otherwise. Many times when you think you might need it, a better approach is to connect to a signal that will be called after the widget is realized automatically, such as "expose_event". Or simply gtk_signal_connect_after() to the "realize" signal.

widget : a GtkWidget


gtk_widget_unrealize ()

void        gtk_widget_unrealize            (GtkWidget *widget);

This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget, such as widget->window).

widget : a GtkWidget


gtk_widget_queue_draw ()

void        gtk_widget_queue_draw           (GtkWidget *widget);

Equivalent to calling gtk_widget_queue_draw_area() for the entire area of a widget.

widget : a GtkWidget


gtk_widget_queue_resize ()

void        gtk_widget_queue_resize         (GtkWidget *widget);

This function is only for use in widget implementations. Flags a widget to have its size renegotiated; should be called when a widget for some reason has a new size request. For example, when you change the text in a GtkLabel, GtkLabel queues a resize to ensure there's enough space for the new text.

widget : a GtkWidget


gtk_widget_draw ()

void        gtk_widget_draw                 (GtkWidget *widget,
                                             GdkRectangle *area);

Warning

gtk_widget_draw is deprecated and should not be used in newly-written code.

DEPRECATED. In GTK+ 1.2, this function would immediately render the region area of a widget, by invoking the virtual draw method of a widget. In GTK+ 2.0, the draw method is gone, and instead gtk_widget_draw() simply invalidates the specified region of the widget, then updates the invalid region of the widget immediately. Usually you don't want to update the region immediately for performance reasons, so in general gtk_widget_queue_draw_area() is a better choice if you want to draw a region of a widget.

widget : a GtkWidget
area : area to draw


gtk_widget_size_request ()

void        gtk_widget_size_request         (GtkWidget *widget,
                                             GtkRequisition *requisition);

This function is only used when implementing a GtkContainer subclass. Obtains the preferred size of a widget. The container uses this information to arrange its child widgets and decide what size allocations to give them with gtk_widget_size_allocate().

widget : a GtkWidget
requisition : a GtkRequisition to be filled in


gtk_widget_get_child_requisition ()

void        gtk_widget_get_child_requisition
                                            (GtkWidget *widget,
                                             GtkRequisition *requisition);

This function is only for use in widget implementations. Obtains widget->requisition, unless someone has forced a particular geometry on the widget (e.g. with gtk_widget_set_usize()), in which case it returns that geometry instead of the widget's requisition.

widget : a GtkWidget
requisition : a GtkRequisition to be filled in


gtk_widget_size_allocate ()

void        gtk_widget_size_allocate        (GtkWidget *widget,
                                             GtkAllocation *allocation);

This function is only used by GtkContainer subclasses, to assign a size and position to their child widgets.

widget : a GtkWidget
allocation : position and size to be allocated to widget


gtk_widget_add_accelerator ()

void        gtk_widget_add_accelerator      (GtkWidget *widget,
                                             const gchar *accel_signal,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods,
                                             GtkAccelFlags accel_flags);

widget : 
accel_signal : 
accel_group : 
accel_key : 
accel_mods : 
accel_flags : 


gtk_widget_remove_accelerator ()

void        gtk_widget_remove_accelerator   (GtkWidget *widget,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods);

widget : 
accel_group : 
accel_key : 
accel_mods : 


gtk_widget_remove_accelerators ()

void        gtk_widget_remove_accelerators  (GtkWidget *widget,
                                             const gchar *accel_signal,
                                             gboolean visible_only);

widget : 
accel_signal : 
visible_only : 


gtk_widget_accelerator_signal ()

guint       gtk_widget_accelerator_signal   (GtkWidget *widget,
                                             GtkAccelGroup *accel_group,
                                             guint accel_key,
                                             guint accel_mods);

widget : 
accel_group : 
accel_key : 
accel_mods : 
Returns : 


gtk_widget_event ()

gboolean    gtk_widget_event                (GtkWidget *widget,
                                             GdkEvent *event);

Rarely-used function. This function is used to emit the event signals on a widget (those signals should never be emitted without using this function to do so). If you want to synthesize an event though, don't use this function; instead, use gtk_main_do_event() so the event will behave as if it were in the event queue. Don't synthesize expose events; instead, use gdk_window_invalidate_rect() to invalidate a region of the window.

widget : a GtkWidget
event : a GdkEvent
Returns : return from the event signal emission (TRUE if the event was handled)


gtk_widget_activate ()

gboolean    gtk_widget_activate             (GtkWidget *widget);

For widgets that can be "activated" (buttons, menu items, etc.) this function activates them. Activation is what happens when you press Enter on a widget during key navigation; clicking a button, selecting a menu item, etc. If widget isn't activatable, the function returns FALSE.

widget : a GtkWidget that's activatable
Returns : TRUE if the widget was activatable


gtk_widget_reparent ()

void        gtk_widget_reparent             (GtkWidget *widget,
                                             GtkWidget *new_parent);

Moves a widget from one GtkContainer to another, handling reference count issues to avoid destroying the widget.

widget : a GtkWidget
new_parent : a GtkContainer to move the widget into


gtk_widget_intersect ()

gboolean    gtk_widget_intersect            (GtkWidget *widget,
                                             GdkRectangle *area,
                                             GdkRectangle *intersection);

Computes the intersection of a widget's area and area, storing the intersection in intersection, and returns TRUE if there was an intersection. intersection may be NULL if you're only interested in whether there was an intersection.

widget : a GtkWidget
area : a rectangle
intersection : rectangle to store intersection of widget and area
Returns : TRUE if there was an intersection


gtk_widget_is_focus ()

gboolean    gtk_widget_is_focus             (GtkWidget *widget);

Determines if the widget is the focus widget within its toplevel. (This does not mean that the HAS_FOCUS flag is necessarily set; HAS_FOCUS will only be set if the toplevel widget additionally has the global input focus.)

widget : a GtkWidget
Returns : TRUE if the widget is the focus widget.


gtk_widget_grab_focus ()

void        gtk_widget_grab_focus           (GtkWidget *widget);

Causes widget to have the keyboard focus for the GtkWindow it's inside. widget must be a focusable widget, such as a GtkEntry; something like GtkFrame won't work. (More precisely, it must have the GTK_CAN_FOCUS flag set.)

widget : a GtkWidget


gtk_widget_grab_default ()

void        gtk_widget_grab_default         (GtkWidget *widget);

Causes widget to become the default widget. widget must have the GTK_CAN_DEFAULT flag set; typically you have to set this flag yourself by calling GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT). The default widget is activated when the user presses Enter in a window. Default widgets must be activatable, that is, gtk_widget_activate() should affect them.

widget : a GtkWidget


gtk_widget_set_name ()

void        gtk_widget_set_name             (GtkWidget *widget,
                                             const gchar *name);

Widgets can be named, which allows you to refer to them from a gtkrc file. You can apply a style to widgets with a particular name in the gtkrc file. See the documentation for gtkrc files (on the same page as the docs for GtkRcStyle).

widget : a GtkWidget
name : name for the widget


gtk_widget_get_name ()

G_CONST_RETURN gchar* gtk_widget_get_name   (GtkWidget *widget);

Retrieves the name of a widget. The return value should not be freed. See gtk_widget_set_name() for the significance of widget names.

widget : a GtkWidget
Returns : name of the widget


gtk_widget_set_state ()

void        gtk_widget_set_state            (GtkWidget *widget,
                                             GtkStateType state);

This function is for use in widget implementations. Sets the state of a widget (insensitive, prelighted, etc.) Usually you should set the state using wrapper functions such as gtk_widget_set_sensitive().

widget : a GtkWidget
state : new state for widget


gtk_widget_set_sensitive ()

void        gtk_widget_set_sensitive        (GtkWidget *widget,
                                             gboolean sensitive);

Sets the sensitivity of a widget. A widget is sensitive if the user can interact with it. Insensitive widgets are "grayed out" and the user can't interact with them. Insensitive widgets are known as "inactive" in some other toolkits.

widget : a widget
sensitive : TRUE to make the widget sensitive


gtk_widget_set_parent ()

void        gtk_widget_set_parent           (GtkWidget *widget,
                                             GtkWidget *parent);

This function is useful only when implementing subclasses of GtkContainer. Sets the container as the parent of widget, and takes care of some details such as updating the state and style of the child to reflect its new location. The opposite function is gtk_widget_unparent().

widget : a GtkWidget
parent : parent container


gtk_widget_set_parent_window ()

void        gtk_widget_set_parent_window    (GtkWidget *widget,
                                             GdkWindow *parent_window);

widget : 
parent_window : 


gtk_widget_get_parent_window ()

GdkWindow*  gtk_widget_get_parent_window    (GtkWidget *widget);

widget : 
Returns : 


gtk_widget_set_uposition ()

void        gtk_widget_set_uposition        (GtkWidget *widget,
                                             gint x,
                                             gint y);

Sets the position of a widget. The funny "u" in the name comes from the "user position" hint specified by the X window system, and exists for legacy reasons. This function doesn't work if a widget is inside a container; it's only really useful on GtkWindow.

Don't use this function to center dialogs over the main application window; most window managers will do the centering on your behalf if you call gtk_window_set_transient_for(), and it's really not possible to get the centering to work correctly in all cases from application code. But if you insist, use gtk_window_set_position() to set GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering manually.

Note that although x and y can be individually unset, the position is not honoured unless both x and y are set.

widget : a GtkWidget
x : x position; -1 to unset x; -2 to leave x unchanged
y : y position; -1 to unset y; -2 to leave y unchanged


gtk_widget_set_usize ()

void        gtk_widget_set_usize            (GtkWidget *widget,
                                             gint width,
                                             gint height);

Sets the minimum size of a widget; that is, the widget's size request will be width by height. You can use this function to force a widget to be either larger or smaller than it is. The strange "usize" name dates from the early days of GTK+, and derives from X Window System terminology. In many cases, gtk_window_set_default_size() is a better choice for toplevel windows than this function; setting the default size will still allow users to shrink the window. Setting the usize will force them to leave the window at least as large as the usize. When dealing with window sizes, gtk_window_set_geometry_hints() can be a useful function as well.

Note the inherent danger of setting any fixed size - themes, translations into other languages, different fonts, and user action can all change the appropriate size for a given widget. So, it's basically impossible to hardcode a size that will always be correct.

widget : a GtkWidget
width : minimum width, or -1 to unset
height : minimum height, or -1 to unset


gtk_widget_set_events ()

void        gtk_widget_set_events           (GtkWidget *widget,
                                             gint events);

Sets the event mask (see GdkEventMask) for a widget. The event mask determines which events a widget will receive. Keep in mind that different widgets have different default event masks, and by changing the event mask you may disrupt a widget's functionality, so be careful. This function must be called while a widget is unrealized. Consider gtk_widget_add_events() for widgets that are already realized, or if you want to preserve the existing event mask. This function can't be used with GTK_NO_WINDOW widgets; to get events on those widgets, place them inside a GtkEventBox and receive events on the event box.

widget : a GtkWidget
events : event mask


gtk_widget_add_events ()

void        gtk_widget_add_events           (GtkWidget *widget,
                                             gint events);

Adds the events in the bitfield events to the event mask for widget. See gtk_widget_set_events() for details.

widget : a GtkWidget
events : an event mask, see GdkEventMask


gtk_widget_set_extension_events ()

void        gtk_widget_set_extension_events (GtkWidget *widget,
                                             GdkExtensionMode mode);

Sets the extension events mask to mode. See GdkExtensionMode and gdk_input_set_extension_events().

widget : a GtkWidget
mode : bitfield of extension events to receive


gtk_widget_get_extension_events ()

GdkExtensionMode gtk_widget_get_extension_events
                                            (GtkWidget *widget);

Retrieves the extension events the widget will receive; see gdk_input_set_extension_events().

widget : a GtkWidget
Returns : extension events for widget


gtk_widget_get_toplevel ()

GtkWidget*  gtk_widget_get_toplevel         (GtkWidget *widget);

This function returns the topmost widget in the container hierarchy widget is a part of. If widget has no parent widgets, it will be returned as the topmost widget. No reference will be added to the returned widget; it should not be unreferenced.

Note the difference in behavior vs. gtk_widget_get_ancestor(); gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would return NULL if widget wasn't inside a toplevel window.

widget : a GtkWidget
Returns : the topmost ancestor of widget, or widget itself if there's no ancestor


gtk_widget_get_ancestor ()

GtkWidget*  gtk_widget_get_ancestor         (GtkWidget *widget,
                                             GtkType widget_type);

Gets the first ancestor of widget with type widget_type. For example, gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the first GtkBox that's an ancestor of widget. No reference will be added to the returned widget; it should not be unreferenced.

widget : a GtkWidget
widget_type : ancestor type
Returns : the ancestor widget, or NULL if not found


gtk_widget_get_colormap ()

GdkColormap* gtk_widget_get_colormap        (GtkWidget *widget);

Gets the colormap that will be used to render widget. No reference will be added to the returned colormap; it should not be unreferenced.

widget : a GtkWidget
Returns : the colormap used by widget


gtk_widget_set_colormap ()

void        gtk_widget_set_colormap         (GtkWidget *widget,
                                             GdkColormap *colormap);

Set the colormap for the widget to the given value. Widget must not have been previously realized. This probably should only be used from an init() function (i.e. from the constructor for the widget).

widget : a GtkWidget
colormap : a colormap


gtk_widget_get_visual ()

GdkVisual*  gtk_widget_get_visual           (GtkWidget *widget);

Gets the visual that will be used to render widget.

widget : a GtkWidget
Returns : the visual for widget


gtk_widget_get_events ()

gint        gtk_widget_get_events           (GtkWidget *widget);

Returns the event mask for the widget (a bitfield containing flags from the GdkEventMask enumeration). These are the events that the widget will receive.

widget : a GtkWidget
Returns : event mask for widget


gtk_widget_get_pointer ()

void        gtk_widget_get_pointer          (GtkWidget *widget,
                                             gint *x,
                                             gint *y);

Obtains the location of the mouse pointer in widget coordinates. Widget coordinates are a bit odd; for historical reasons, they are defined as widget->window coordinates for widgets that are not GTK_NO_WINDOW widgets, and are relative to widget->allocation.x, widget->allocation.y for widgets that are GTK_NO_WINDOW widgets.

widget : a GtkWidget
x : return location for the X coordinate, or NULL
y : return location for the Y coordinate, or NULL


gtk_widget_is_ancestor ()

gboolean    gtk_widget_is_ancestor          (GtkWidget *widget,
                                             GtkWidget *ancestor);

Determines whether widget is somewhere inside ancestor, possibly with intermediate containers.

widget : a GtkWidget
ancestor : another GtkWidget
Returns : TRUE if ancestor contains widget as a child, grandchild, great grandchild, etc.


gtk_widget_hide_on_delete ()

gboolean    gtk_widget_hide_on_delete       (GtkWidget *widget);

Utility function; intended to be connected to the "delete_event" signal on a GtkWindow. The function calls gtk_widget_hide() on its argument, then returns TRUE. If connected to "delete_event", the result is that clicking the window manager close button for will hide but not destroy the window. By default, GTK+ destroys windows when "delete_event" is received.

widget : a GtkWidget
Returns : TRUE


gtk_widget_set_style ()

void        gtk_widget_set_style            (GtkWidget *widget,
                                             GtkStyle *style);

Sets the GtkStyle for a widget (widget->style). You probably don't want to use this function; it interacts badly with themes, because themes work by replacing the GtkStyle. Instead, use gtk_widget_modify_style().

widget : a GtkWidget
style : a GtkStyle


gtk_widget_set_rc_style ()

void        gtk_widget_set_rc_style         (GtkWidget *widget);

widget : a GtkWidget


gtk_widget_ensure_style ()

void        gtk_widget_ensure_style         (GtkWidget *widget);

Ensures that widget has a style (widget->style). Not a very useful function; most of the time, if you want the style, the widget is realized, and realized widgets are guaranteed to have a style already.

widget : a GtkWidget


gtk_widget_get_style ()

GtkStyle*   gtk_widget_get_style            (GtkWidget *widget);

Simply an accessor function that returns widget->style.

widget : a GtkWidget
Returns : the widget's GtkStyle


gtk_widget_restore_default_style ()

void        gtk_widget_restore_default_style
                                            (GtkWidget *widget);

widget : 


gtk_widget_reset_rc_styles ()

void        gtk_widget_reset_rc_styles      (GtkWidget *widget);

widget : 


gtk_widget_push_style ()

void        gtk_widget_push_style           (GtkStyle *style);

style : 


gtk_widget_push_colormap ()

void        gtk_widget_push_colormap        (GdkColormap *cmap);

Pushes cmap onto a global stack of colormaps; the topmost colormap on the stack will be used to create all widgets. Remove cmap with gtk_widget_pop_colormap(). There's little reason to use this function.

cmap : a GdkColormap


gtk_widget_pop_style ()

void        gtk_widget_pop_style            (void);


gtk_widget_pop_colormap ()

void        gtk_widget_pop_colormap         (void);

Removes a colormap pushed with gtk_widget_push_colormap().


gtk_widget_set_default_style ()

void        gtk_widget_set_default_style    (GtkStyle *style);

style : 


gtk_widget_set_default_colormap ()

void        gtk_widget_set_default_colormap (GdkColormap *colormap);

Sets the default colormap to use when creating widgets. gtk_widget_push_colormap() is a better function to use if you only want to affect a few widgets, rather than all widgets.

colormap : a GdkColormap


gtk_widget_get_default_style ()

GtkStyle*   gtk_widget_get_default_style    (void);

Returns : 


gtk_widget_get_default_colormap ()

GdkColormap* gtk_widget_get_default_colormap
                                            (void);

Obtains the default colormap used to create widgets.

Returns : default widget colormap


gtk_widget_get_default_visual ()

GdkVisual*  gtk_widget_get_default_visual   (void);

Obtains the visual of the default colormap. Not really useful; used to be useful before gdk_colormap_get_visual() existed.

Returns : visual of the default colormap


gtk_widget_set_direction ()

void        gtk_widget_set_direction        (GtkWidget *widget,
                                             GtkTextDirection dir);

Set the reading direction on a particular widget. This direction controls the primary direction for widgets containing text, and also the direction in which the children of a container are packed. The ability to set the direction is present in order so that correct localization into languages with right-to-left reading directions can be done. Generally, applications will let the default reading direction present, except for containers where the containers are arranged in an order that is explicitely visual rather than logical (such as buttons for text justificiation).

If the direction is set to GTK_TEXT_DIR_NONE, then the value set by gtk_widget_set_default_direction() will be used.

widget : a GtkWidget
dir : the new direction


enum GtkTextDirection

typedef enum
{
  GTK_TEXT_DIR_NONE,
  GTK_TEXT_DIR_LTR,
  GTK_TEXT_DIR_RTL
} GtkTextDirection;


gtk_widget_get_direction ()

GtkTextDirection gtk_widget_get_direction   (GtkWidget *widget);

Get the reading direction for a particular widget. See gtk_widget_set_direction().

widget : a GtkWidget
Returns : the reading direction for the widget.


gtk_widget_set_default_direction ()

void        gtk_widget_set_default_direction
                                            (GtkTextDirection dir);

Set the default reading direction for widgets where the direction has not been explicitly set by gtk_widget_set_direction().

dir : the new default direction. This cannot be GTK_TEXT_DIR_NONE.


gtk_widget_get_default_direction ()

GtkTextDirection gtk_widget_get_default_direction
                                            (void);

Returns : the current default direction. See gtk_widget_set_direction().


gtk_widget_shape_combine_mask ()

void        gtk_widget_shape_combine_mask   (GtkWidget *widget,
                                             GdkBitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);

widget : 
shape_mask : 
offset_x : 
offset_y : 


gtk_widget_path ()

void        gtk_widget_path                 (GtkWidget *widget,
                                             guint *path_length,
                                             gchar **path,
                                             gchar **path_reversed);

Obtains the full path to widget. The path is simply the name of a widget and all its parents in the container hierarchy, separated by periods. The name of a widget comes from gtk_widget_get_name(). Paths are used to apply styles to a widget in gtkrc configuration files. Widget names are the type of the widget by default (e.g. "GtkButton") or can be set to an application-specific value with gtk_widget_set_name(). By setting the name of a widget, you allow users or theme authors to apply styles to that specific widget in their gtkrc file. path_reversed_p fills in the path in reverse order, i.e. starting with widget's name instead of starting with the name of widget's outermost ancestor.

widget : a GtkWidget
path_length : location to store length of the path
path : location to store allocated path string
path_reversed : location to store allocated reverse path string


gtk_widget_class_path ()

void        gtk_widget_class_path           (GtkWidget *widget,
                                             guint *path_length,
                                             gchar **path,
                                             gchar **path_reversed);

Same as gtk_widget_path(), but always uses the name of a widget's type, never uses a custom name set with gtk_widget_set_name().

widget : a GtkWidget
path_length : location to store the length of the class path
path : location to store the class path as an allocated string
path_reversed : location to store the reverse class path as an allocated string


gtk_widget_get_composite_name ()

gchar*      gtk_widget_get_composite_name   (GtkWidget *widget);

widget : 
Returns : 


gtk_widget_lock_accelerators ()

void        gtk_widget_lock_accelerators    (GtkWidget *widget);

widget : 


gtk_widget_modify_style ()

void        gtk_widget_modify_style         (GtkWidget *widget,
                                             GtkRcStyle *style);

Modify style values on the widget. Modifications made using this technique take precendence over style values set via an RC file, however, they will be overriden if a style is explicitely set on the widget using gtk_widget_set_style(). The GtkRcStyle structure is designed so each field can either be set or unset, so it is possible, using this function, to modify some style values and leave the others unchanged.

Note that modifications made with this function are not cumulative with previous calls to gtk_widget_modify_style() or with such functions as gtk_widget_modify_fg(). If you wish to retain previous values, you must first call gtk_widget_get_modifier_style(), make your modifications to the returned style, then call gtk_widget_modify_style() with that style. On the other hand, if you first call gtk_widget_modify_style(), subsequent calls to such functions gtk_widget_modify_fg() will be have a cumulative effect with the inital modifications.

widget : a GtkWidget
style : the GtkRcStyle holding the style modifications


gtk_widget_get_modifier_style ()

GtkRcStyle* gtk_widget_get_modifier_style   (GtkWidget *widget);

Return the current modifier style for the widget. (As set by gtk_widget_modify_style().) If no style has previously set, a new GtkRcStyle will be created with all values unset, and set as the modifier style for the widget. If you make changes to this rc style, you must call gtk_widget_modify_style(), passing in the returned rc style, to make sure that your changes take effect.

widget : a GtkWidget
Returns : the modifier style for the widget. This rc style is owned by the widget. If you want to keep a pointer to value this around, you must add a refcount using gtk_rc_style_ref().


gtk_widget_modify_fg ()

void        gtk_widget_modify_fg            (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);

Set the foreground color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style().

widget : a GtkWidget
state : the state for which to set the foreground color.
color : the color to assign (does not need to be allocated)


gtk_widget_modify_bg ()

void        gtk_widget_modify_bg            (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);

Set the background color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style().

widget : a GtkWidget
state : the state for which to set the foreground color.
color : the color to assign (does not need to be allocated)


gtk_widget_modify_text ()

void        gtk_widget_modify_text          (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);

widget : 
state : 
color : 


gtk_widget_modify_base ()

void        gtk_widget_modify_base          (GtkWidget *widget,
                                             GtkStateType state,
                                             GdkColor *color);

Set the text color for a widget in a particular state. All other style values are left untouched. The base color is the background color used along with the text color (see gtk_widget_modify_text) for widgets such as GtkEntry and GtkTextView. See also gtk_widget_modify_style().

widget : a GtkWidget
state : the state for which to set the foreground color.
color : the color to assign (does not need to be allocated)


gtk_widget_modify_font ()

void        gtk_widget_modify_font          (GtkWidget *widget,
                                             PangoFontDescription *font_desc);

Set the font to use for a widget. All other style values are left untouched. See also gtk_widget_modify_style().

widget : a GtkWidget
font_desc : the font description to use


gtk_widget_create_pango_context ()

PangoContext* gtk_widget_create_pango_context
                                            (GtkWidget *widget);

Create a new pango context with the appropriate colormap, font description, and base direction for drawing text for this widget. See also gtk_widget_get_pango_context()

widget : a PangoWidget
Returns : the new PangoContext


gtk_widget_get_pango_context ()

PangoContext* gtk_widget_get_pango_context  (GtkWidget *widget);

Get a PangoContext with the appropriate colormap, font description and base direction for this widget. Unlike the context returned by gtk_widget_create_pango_context(), this context is owned by the widget (it can be used as long as widget exists), and will be updated to match any changes to the widget's attributes.

If you create and keep a PangoLayout using this context, you must deal with changes to the context by calling pango_layout_context_changed() on the layout in response to the ::style_set and ::direction_set signals for the widget.

widget : a GtkWidget
Returns : the PangoContext for the widget.


gtk_widget_create_pango_layout ()

PangoLayout* gtk_widget_create_pango_layout (GtkWidget *widget,
                                             const gchar *text);

Create a new PangoLayout with the appropriate colormap, font description, and base direction for drawing text for this widget.

If you keep a PangoLayout created in this way around, in order notify the layout of changes to the base direction or font of this widget, you must call pango_layout_context_changed() in response to the ::style_set and ::direction_set signals for the widget.

widget : a PangoWidget
text : text to set on the layout (can be NULL)
Returns : the new PangoLayout


gtk_widget_render_icon ()

GdkPixbuf*  gtk_widget_render_icon          (GtkWidget *widget,
                                             const gchar *stock_id,
                                             GtkIconSize size,
                                             const gchar *detail);

A convenience function that uses the theme engine and RC file settings for widget to look up stock_id and render it to a pixbuf. stock_id should be a stock icon ID such as GTK_STOCK_OPEN or GTK_STOCK_BUTTON_OK. size should be a size such as GTK_ICON_SIZE_MENU. detail should be a string that identifies the widget or code doing the rendering, so that theme engines can special-case rendering for that widget or code.

widget : a GtkWidget
stock_id : a stock ID
size : a stock size
detail : render detail to pass to theme engine
Returns : a new pixbuf, or NULL if the stock ID wasn't known


gtk_widget_pop_composite_child ()

void        gtk_widget_pop_composite_child  (void);


gtk_widget_push_composite_child ()

void        gtk_widget_push_composite_child (void);


gtk_widget_queue_clear ()

void        gtk_widget_queue_clear          (GtkWidget *widget);

Warning

gtk_widget_queue_clear is deprecated and should not be used in newly-written code.

DEPRECATED. Use gtk_widget_queue_draw() instead.

widget : a GtkWidget


gtk_widget_queue_clear_area ()

void        gtk_widget_queue_clear_area     (GtkWidget *widget,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

Warning

gtk_widget_queue_clear_area is deprecated and should not be used in newly-written code.

DEPRECATED. This function is no longer different from gtk_widget_queue_draw_area(), though it once was. Now it just calls gtk_widget_queue_draw_area(). Originally gtk_widget_queue_clear_area() would force a redraw of the background for GTK_NO_WINDOW widgets, and gtk_widget_queue_draw_area() would not. Now both functions ensure the background will be redrawn.

widget : a GtkWidget
x : x coordinate of upper-left corner of rectangle to redraw
y : y coordinate of upper-left corner of rectangle to redraw
width : width of region to draw
height : height of region to draw


gtk_widget_queue_draw_area ()

void        gtk_widget_queue_draw_area      (GtkWidget *widget,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

Invalidates the rectangular area of widget defined by x, y, width and height by calling gdk_window_invalidate_rect() on the widget's window and all its child windows. Once the main loop becomes idle (after the current batch of events has been processed, roughly), the window will receive expose events for the union of all regions that have been invalidated.

Normally you would only use this function in widget implementations. You might also use it, or gdk_window_invalidate_rect() directly, to schedule a redraw of a GtkDrawingArea or some portion thereof.

Frequently you can just call gdk_window_invalidate_rect() or gdk_window_invalidate_region() instead of this function. Those functions will invalidate only a single window, instead of the widget and all its children.

The advantage of adding to the invalidated region compared to simply drawing immediately is efficiency; using an invalid region ensures that you only have to redraw one time.

widget : a GtkWidget
x : x coordinate of upper-left corner of rectangle to redraw
y : y coordinate of upper-left corner of rectangle to redraw
width : width of region to draw
height : height of region to draw


gtk_widget_reset_shapes ()

void        gtk_widget_reset_shapes         (GtkWidget *widget);

widget : 


gtk_widget_set_app_paintable ()

void        gtk_widget_set_app_paintable    (GtkWidget *widget,
                                             gboolean app_paintable);

widget : 
app_paintable : 


gtk_widget_set_double_buffered ()

void        gtk_widget_set_double_buffered  (GtkWidget *widget,
                                             gboolean double_buffered);

Widgets are double buffered by default; you can use this function to turn off the buffering. "Double buffered" simply means that gdk_window_begin_paint() and gdk_window_end_paint() are called automatically around expose events sent to the widget. gdk_window_begin_paint() diverts all drawing to a widget's window to an offscreen buffer, and gdk_window_end_paint() draws the buffer to the screen. The result is that users see the window update in one smooth step, and don't see individual graphics primitives being rendered.

In very simple terms, double buffered widgets don't flicker, so you would only use this function to turn off double buffering if you had special needs and really knew what you were doing.

widget : a GtkWidget
double_buffered : TRUE to double-buffer a widget


gtk_widget_set_composite_name ()

void        gtk_widget_set_composite_name   (GtkWidget *widget,
                                             const gchar *name);

widget : 
name : 


gtk_widget_set_scroll_adjustments ()

gboolean    gtk_widget_set_scroll_adjustments
                                            (GtkWidget *widget,
                                             GtkAdjustment *hadjustment,
                                             GtkAdjustment *vadjustment);

For widgets that support scrolling, sets the scroll adjustments and returns TRUE. For widgets that don't support scrolling, does nothing and returns FALSE. Widgets that don't support scrolling can be scrolled by placing them in a GtkViewport, which does support scrolling.

widget : a GtkWidget
hadjustment : an adjustment for horizontal scrolling, or NULL
vadjustment : an adjustment for vertical scrolling, or NULL
Returns : TRUE if the widget supports scrolling


gtk_widget_unlock_accelerators ()

void        gtk_widget_unlock_accelerators  (GtkWidget *widget);

widget : 


gtk_widget_accelerators_locked ()

gboolean    gtk_widget_accelerators_locked  (GtkWidget *widget);

widget : 
Returns : 


gtk_widget_mnemonic_activate ()

gboolean    gtk_widget_mnemonic_activate    (GtkWidget *widget,
                                             gboolean group_cycling);

widget : 
group_cycling : 
Returns : 


gtk_widget_class_install_style_property ()

void        gtk_widget_class_install_style_property
                                            (GtkWidgetClass *klass,
                                             GParamSpec *pspec);

klass : 
pspec : 


gtk_widget_class_install_style_property_parser ()

void        gtk_widget_class_install_style_property_parser
                                            (GtkWidgetClass *klass,
                                             GParamSpec *pspec,
                                             GtkRcPropertyParser parser);

klass : 
pspec : 
parser : 


gtk_widget_region_intersect ()

GdkRegion*  gtk_widget_region_intersect     (GtkWidget *widget,
                                             GdkRegion *region);

Computes the intersection of a widget's area and region, returning the intersection. The result may be empty, use gdk_region_empty to check.

widget : a GtkWidget
region : a GdkRegion, in the same coordinate system as widget->allocation. That is, relative to widget->window for NO_WINDOW widgets; relative to the parent window of widget->window for widgets with their own window.
Returns : A newly allocated region holding the intersection of widget and region. The coordinates of the return value are relative to widget->window for NO_WINDOW widgets, and relative to the parent window of widget->window for widgets with their own window.


gtk_widget_send_expose ()

gint        gtk_widget_send_expose          (GtkWidget *widget,
                                             GdkEvent *event);

Very rarely-used function. This function is used to emit an expose event signals on a widget. This function is not normally used directly. The only time it is used is when propagating an expose event to a child NO_WINDOW widget, and that is normally done using gtk_container_propagate_expose.

If you want to force an area of a window to be redrawn, use gdk_window_invalidate_rect() or gdk_window_invalidate_region(). To cause the redraw to be done immediately, follow that call with a call to gdk_window_procss_updates().

widget : a GtkWidget
event : a expose GdkEvent
Returns : return from the event signal emission (TRUE if the event was handled)


gtk_widget_style_get ()

void        gtk_widget_style_get            (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             ...);

widget : 
first_property_name : 
... : 


gtk_widget_style_get_property ()

void        gtk_widget_style_get_property   (GtkWidget *widget,
                                             const gchar *property_name,
                                             GValue *value);

widget : 
property_name : 
value : 


gtk_widget_style_get_valist ()

void        gtk_widget_style_get_valist     (GtkWidget *widget,
                                             const gchar *first_property_name,
                                             va_list var_args);

widget : 
first_property_name : 
var_args : 


gtk_requisition_copy ()

GtkRequisition* gtk_requisition_copy        (const GtkRequisition *requisition);

requisition : 
Returns : 


gtk_requisition_free ()

void        gtk_requisition_free            (GtkRequisition *requisition);

requisition : 

Args

"name" (gchararray : Read / Write)

"parent" (GtkContainer : Read / Write)

"x" (gint : Read / Write)

"y" (gint : Read / Write)

"width" (gint : Read / Write)

"height" (gint : Read / Write)

"visible" (gboolean : Read / Write)

"sensitive" (gboolean : Read / Write)

"app-paintable" (gboolean : Read / Write)

"can-focus" (gboolean : Read / Write)

"has-focus" (gboolean : Read / Write)

"can-default" (gboolean : Read / Write)

"has-default" (gboolean : Read / Write)

"receives-default" (gboolean : Read / Write)

"composite-child" (gboolean : Read / Write)

"style" (GtkStyle : Read / Write)

"events" (GdkEventMask : Read / Write)

"extension-events" (GdkExtensionMode : Read / Write)

Signals

The "add-accelerator" signal

void        user_function                  (GtkWidget *widget,
                                            guint accel_signal_id,
                                            GtkAccelGroup *accel_group,
                                            guint accel_key,
                                            GdkModifierType accel_mods,
                                            GtkAccelFlags accel_flags,
                                            gpointer user_data);

widget :the object which received the signal.
accel_signal_id : 
accel_group : 
accel_key : 
accel_mods : 
accel_flags : 
user_data :user data set when the signal handler was connected.


The "button-press-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventButton *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "button-release-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventButton *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "client-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventClient *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "configure-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventConfigure *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "delete-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "destroy-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "direction-changed" signal

void        user_function                  (GtkWidget *widget,
                                            GtkTextDirection arg1,
                                            gpointer user_data);

widget :the object which received the signal.
arg1 : 
user_data :user data set when the signal handler was connected.


The "drag-begin" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
user_data :user data set when the signal handler was connected.


The "drag-data-delete" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
user_data :user data set when the signal handler was connected.


The "drag-data-get" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
data : 
info : 
time : 
user_data :user data set when the signal handler was connected.


The "drag-data-received" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
x : 
y : 
data : 
info : 
time : 
user_data :user data set when the signal handler was connected.


The "drag-drop" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
x : 
y : 
time : 
user_data :user data set when the signal handler was connected.
Returns : 


The "drag-end" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
user_data :user data set when the signal handler was connected.


The "drag-leave" signal

void        user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
time : 
user_data :user data set when the signal handler was connected.


The "drag-motion" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkDragContext *drag_context,
                                            gint x,
                                            gint y,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
drag_context : 
x : 
y : 
time : 
user_data :user data set when the signal handler was connected.
Returns : 


The "enter-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventCrossing *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "expose-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventExpose *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "focus-in-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventFocus *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "focus-out-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventFocus *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "grab-focus" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "hide" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "hierarchy-changed" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

Emitted when there is a chance in the hierarchy to which a widget belong. More precisely, a widget is anchored when its toplevel ancestor is a GtkWindow. This signal is emitted when a widget changes from un-anchored to anchored or vice-versa.

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "key-press-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventKey *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "key-release-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventKey *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "leave-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventCrossing *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "map" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "map-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "mnemonic-activate" signal

gboolean    user_function                  (GtkWidget *widget,
                                            gboolean arg1,
                                            gpointer user_data);

widget :the object which received the signal.
arg1 : 
user_data :user data set when the signal handler was connected.
Returns : 


The "motion-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventMotion *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "no-expose-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventNoExpose *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "parent-set" signal

void        user_function                  (GtkWidget *widget,
                                            GtkObject *old_parent,
                                            gpointer user_data);

widget :the object which received the signal.
old_parent : 
user_data :user data set when the signal handler was connected.


The "popup-menu" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "property-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventProperty *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "proximity-in-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventProximity *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "proximity-out-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventProximity *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "realize" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "remove-accelerator" signal

void        user_function                  (GtkWidget *widget,
                                            GtkAccelGroup *accel_group,
                                            guint accel_key,
                                            GdkModifierType accel_mods,
                                            gpointer user_data);

widget :the object which received the signal.
accel_group : 
accel_key : 
accel_mods : 
user_data :user data set when the signal handler was connected.


The "scroll-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "selection-clear-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "selection-get" signal

void        user_function                  (GtkWidget *widget,
                                            GtkSelectionData *data,
                                            guint info,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
data : 
info : 
time : 
user_data :user data set when the signal handler was connected.


The "selection-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "selection-received" signal

void        user_function                  (GtkWidget *widget,
                                            GtkSelectionData *data,
                                            guint time,
                                            gpointer user_data);

widget :the object which received the signal.
data : 
time : 
user_data :user data set when the signal handler was connected.


The "selection-request-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEventSelection *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "show" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "size-allocate" signal

void        user_function                  (GtkWidget *widget,
                                            GtkAllocation *allocation,
                                            gpointer user_data);

widget :the object which received the signal.
allocation : 
user_data :user data set when the signal handler was connected.


The "size-request" signal

void        user_function                  (GtkWidget *widget,
                                            GtkRequisition *requisition,
                                            gpointer user_data);

widget :the object which received the signal.
requisition : 
user_data :user data set when the signal handler was connected.


The "state-changed" signal

void        user_function                  (GtkWidget *widget,
                                            GtkStateType state,
                                            gpointer user_data);

widget :the object which received the signal.
state : 
user_data :user data set when the signal handler was connected.


The "style-set" signal

void        user_function                  (GtkWidget *widget,
                                            GtkStyle *previous_style,
                                            gpointer user_data);

widget :the object which received the signal.
previous_style : 
user_data :user data set when the signal handler was connected.


The "unmap" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "unmap-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "unrealize" signal

void        user_function                  (GtkWidget *widget,
                                            gpointer user_data);

widget :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "visibility-notify-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns : 


The "window-state-event" signal

gboolean    user_function                  (GtkWidget *widget,
                                            GdkEvent *event,
                                            gpointer user_data);

widget :the object which received the signal.
event : 
user_data :user data set when the signal handler was connected.
Returns :