краткое описание

#include <gtk/gtk.h>

            gtkwidget;
            gtkwidgetclass;
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);
            gtkrequisition;
struct      gtkallocation;
            gtkselectiondata;
            gtkwidgetauxinfo;
            gtkwidgetshapeinfo;
enum        gtkwidgethelptype;

gtkwidget*  gtk_widget_new                  (gtype type,
                                             const gchar *first_property_name,
                                             ...);
gtkwidget*  gtk_widget_ref                  (gtkwidget *widget);
void        gtk_widget_unref                (gtkwidget *widget);
void        gtk_widget_destroy              (gtkwidget *widget);
void        gtk_widget_destroyed            (gtkwidget *widget,
                                             gtkwidget **widget_pointer);
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_queue_resize_no_redraw

                                            (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,
                                             gdkmodifiertype accel_mods,
                                             gtkaccelflags accel_flags);

gboolean    gtk_widget_remove_accelerator   (gtkwidget *widget,
                                             gtkaccelgroup *accel_group,
                                             guint accel_key,
                                             gdkmodifiertype accel_mods);
void        gtk_widget_set_accel_path       (gtkwidget *widget,
                                             const gchar *accel_path,
                                             gtkaccelgroup *accel_group);

glist*      gtk_widget_list_accel_closures  (gtkwidget *widget);
gboolean    gtk_widget_can_activate_accel   (gtkwidget *widget,
                                             guint signal_id);

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);
const 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,
                                             gtype 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_translate_coordinates
                                            (gtkwidget *src_widget,
                                             gtkwidget *dest_widget,
                                             gint src_x,
                                             gint src_y,
                                             gint *dest_x,
                                             gint *dest_y);

gboolean    gtk_widget_hide_on_delete       (gtkwidget *widget);
void        gtk_widget_set_style            (gtkwidget *widget,
                                             gtkstyle *style);
#define     gtk_widget_set_rc_style         (widget)
void        gtk_widget_ensure_style         (gtkwidget *widget);

gtkstyle*   gtk_widget_get_style            (gtkwidget *widget);
#define     gtk_widget_restore_default_style(widget)
void        gtk_widget_reset_rc_styles      (gtkwidget *widget);
void        gtk_widget_push_colormap        (gdkcolormap *cmap);
void        gtk_widget_pop_colormap         (void);
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_input_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_modify_style         (gtkwidget *widget,
                                             gtkrcstyle *style);

gtkrcstyle* gtk_widget_get_modifier_style   (gtkwidget *widget);
void        gtk_widget_modify_fg            (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);
void        gtk_widget_modify_bg            (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);
void        gtk_widget_modify_text          (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);
void        gtk_widget_modify_base          (gtkwidget *widget,
                                             gtkstatetype state,
                                             const 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_redraw_on_allocate

                                            (gtkwidget *widget,
                                             gboolean redraw_on_allocate);
void        gtk_widget_set_composite_name   (gtkwidget *widget,
                                             const gchar *name);

gboolean    gtk_widget_set_scroll_adjustments
                                            (gtkwidget *widget,
                                             gtkadjustment *hadjustment,
                                             gtkadjustment *vadjustment);
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);

gparamspec* gtk_widget_class_find_style_property
                                            (gtkwidgetclass *klass,
                                             const gchar *property_name);
gparamspec** gtk_widget_class_list_style_properties
                                            (gtkwidgetclass *klass,
                                             guint *n_properties);

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);

atkobject*  gtk_widget_get_accessible       (gtkwidget *widget);
gboolean    gtk_widget_child_focus          (gtkwidget *widget,
                                             gtkdirectiontype direction);
void        gtk_widget_child_notify         (gtkwidget *widget,
                                             const gchar *child_property);
void        gtk_widget_freeze_child_notify  (gtkwidget *widget);

gboolean    gtk_widget_get_child_visible    (gtkwidget *widget);
gtkwidget*  gtk_widget_get_parent           (gtkwidget *widget);
gtksettings* gtk_widget_get_settings        (gtkwidget *widget);

gtkclipboard* gtk_widget_get_clipboard      (gtkwidget *widget,
                                             gdkatom selection);
gdkdisplay* gtk_widget_get_display          (gtkwidget *widget);

gdkwindow*  gtk_widget_get_root_window      (gtkwidget *widget);
gdkscreen*  gtk_widget_get_screen           (gtkwidget *widget);
gboolean    gtk_widget_has_screen           (gtkwidget *widget);
void        gtk_widget_get_size_request     (gtkwidget *widget,
                                             gint *width,
                                             gint *height);
#define     gtk_widget_pop_visual           ()
#define     gtk_widget_push_visual          (visual)
void        gtk_widget_set_child_visible    (gtkwidget *widget,
                                             gboolean is_visible);
#define     gtk_widget_set_default_visual   (visual)
void        gtk_widget_set_size_request     (gtkwidget *widget,
                                             gint width,
                                             gint height);
#define     gtk_widget_set_visual           (widget,visual)
void        gtk_widget_thaw_child_notify    (gtkwidget *widget);
void        gtk_widget_set_no_show_all      (gtkwidget *widget,
                                             gboolean no_show_all);

gboolean    gtk_widget_get_no_show_all      (gtkwidget *widget);
glist*      gtk_widget_list_mnemonic_labels (gtkwidget *widget);
void        gtk_widget_add_mnemonic_label   (gtkwidget *widget,
                                             gtkwidget *label);
void        gtk_widget_remove_mnemonic_label

                                            (gtkwidget *widget,
                                             gtkwidget *label);
gtkaction*  gtk_widget_get_action           (gtkwidget *widget);
gboolean    gtk_widget_is_composited        (gtkwidget *widget);


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

иерархия объектов

  gobject
   +----ginitiallyunowned
         +----gtkobject
               +----gtkwidget
                     +----gtkcontainer

                     +----gtkmisc
                     +----gtkcalendar
                     +----gtkcellview
                     +----gtkdrawingarea
                     +----gtkentry

                     +----gtkruler
                     +----gtkrange
                     +----gtkseparator
                     +----gtkinvisible
                     +----gtkoldeditable

                     +----gtkpreview
                     +----gtkprogress

известные производные интерфейсы

gtkwidget требует gtkfilechooser и gtkcelleditable.

реализуемые интерфейсы

gtkwidget реализует atkimplementoriface.

свойства

  "app-paintable"        gboolean              : read / write
  "can-default"          gboolean              : read / write
  "can-focus"            gboolean              : read / write
  "composite-child"      gboolean              : read
  "events"               gdkeventmask          : read / write
  "extension-events"     gdkextensionmode      : read / write
  "has-default"          gboolean              : read / write
  "has-focus"            gboolean              : read / write
  "height-request"       gint                  : read / write
  "is-focus"             gboolean              : read / write
  "name"                 gchararray            : read / write
  "no-show-all"          gboolean              : read / write
  "parent"               gtkcontainer          : read / write
  "receives-default"     gboolean              : read / write
  "sensitive"            gboolean              : read / write
  "style"                gtkstyle              : read / write
  "visible"              gboolean              : read / write
  "width-request"        gint                  : read / write

свойства стиля

  "cursor-aspect-ratio"  gfloat                : read
  "cursor-color"         gdkcolor              : read
  "draw-border"          gtkborder             : read
  "focus-line-pattern"   gchararray            : read
  "focus-line-width"     gint                  : read
  "focus-padding"        gint                  : read
  "interior-focus"       gboolean              : read
  "link-color"           gdkcolor              : read
  "scroll-arrow-hlength" gint                  : read
  "scroll-arrow-vlength" gint                  : read
  "secondary-cursor-color" gdkcolor              : read
  "separator-height"     gint                  : read
  "separator-width"      gint                  : read
  "visited-link-color"   gdkcolor              : read
  "wide-separators"      gboolean              : read

сигналы

"accel-closures-changed"
            void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : 
"button-press-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventbutton *event,
                                            gpointer        user_data)      : run last
"button-release-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventbutton *event,
                                            gpointer        user_data)      : run last
"can-activate-accel"
            gboolean    user_function      (gtkwidget *widget,
                                            guint      signal_id,
                                            gpointer   user_data)      : run last
"child-notify"
            void        user_function      (gtkwidget  *widget,
                                            gparamspec *pspec,
                                            gpointer    user_data)      : run first / no recursion / has details / no hooks
"client-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventclient *event,
                                            gpointer        user_data)      : run last
"composited-changed"
            void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run last / action
"configure-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventconfigure *event,
                                            gpointer           user_data)      : run last
"delete-event"
            gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"destroy-event"
            gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"direction-changed"
            void        user_function      (gtkwidget       *widget,
                                            gtktextdirection arg1,
                                            gpointer         user_data)      : run first
"drag-begin"
            void        user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last
"drag-data-delete"
            void        user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last
"drag-data-get"
            void        user_function      (gtkwidget        *widget,
                                            gdkdragcontext   *drag_context,
                                            gtkselectiondata *data,
                                            guint             info,
                                            guint             time,
                                            gpointer          user_data)         : run last
"drag-data-received"
            void        user_function      (gtkwidget        *widget,
                                            gdkdragcontext   *drag_context,
                                            gint              x,
                                            gint              y,
                                            gtkselectiondata *data,
                                            guint             info,
                                            guint             time,
                                            gpointer          user_data)         : run last
"drag-drop" gboolean    user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gint            x,
                                            gint            y,
                                            guint           time,
                                            gpointer        user_data)         : run last
"drag-end"  void        user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last
"drag-leave"
            void        user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            guint           time,
                                            gpointer        user_data)         : run last
"drag-motion"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gint            x,
                                            gint            y,
                                            guint           time,
                                            gpointer        user_data)         : run last
"enter-notify-event"
            gboolean    user_function      (gtkwidget        *widget,
                                            gdkeventcrossing *event,
                                            gpointer          user_data)      : run last
"event"     gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"event-after"
            void        user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : 
"expose-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventexpose *event,
                                            gpointer        user_data)      : run last
"focus"     gboolean    user_function      (gtkwidget       *widget,
                                            gtkdirectiontype arg1,
                                            gpointer         user_data)      : run last
"focus-in-event"
            gboolean    user_function      (gtkwidget     *widget,
                                            gdkeventfocus *event,
                                            gpointer       user_data)      : run last
"focus-out-event"
            gboolean    user_function      (gtkwidget     *widget,
                                            gdkeventfocus *event,
                                            gpointer       user_data)      : run last
"grab-broken-event"
            gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"grab-focus"
            void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run last / action
"grab-notify"
            void        user_function      (gtkwidget *widget,
                                            gboolean   was_grabbed,
                                            gpointer   user_data)        : run first
"hide"      void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run first
"hierarchy-changed"
            void        user_function      (gtkwidget *widget,
                                            gtkwidget *widget2,
                                            gpointer   user_data)      : run last
"key-press-event"
            gboolean    user_function      (gtkwidget   *widget,
                                            gdkeventkey *event,
                                            gpointer     user_data)      : run last
"key-release-event"
            gboolean    user_function      (gtkwidget   *widget,
                                            gdkeventkey *event,
                                            gpointer     user_data)      : run last
"leave-notify-event"
            gboolean    user_function      (gtkwidget        *widget,
                                            gdkeventcrossing *event,
                                            gpointer          user_data)      : run last
"map"       void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run first
"map-event" gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"mnemonic-activate"
            gboolean    user_function      (gtkwidget *widget,
                                            gboolean   arg1,
                                            gpointer   user_data)      : run last
"motion-notify-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventmotion *event,
                                            gpointer        user_data)      : run last
"no-expose-event"
            gboolean    user_function      (gtkwidget        *widget,
                                            gdkeventnoexpose *event,
                                            gpointer          user_data)      : run last
"parent-set"
            void        user_function      (gtkwidget *widget,
                                            gtkobject *old_parent,
                                            gpointer   user_data)       : run first
"popup-menu"
            gboolean    user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run last / action
"property-notify-event"
            gboolean    user_function      (gtkwidget        *widget,
                                            gdkeventproperty *event,
                                            gpointer          user_data)      : run last
"proximity-in-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventproximity *event,
                                            gpointer           user_data)      : run last
"proximity-out-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventproximity *event,
                                            gpointer           user_data)      : run last
"realize"   void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run first
"screen-changed"
            void        user_function      (gtkwidget *widget,
                                            gdkscreen *arg1,
                                            gpointer   user_data)      : run last
"scroll-event"
            gboolean    user_function      (gtkwidget      *widget,
                                            gdkeventscroll *event,
                                            gpointer        user_data)      : run last
"selection-clear-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventselection *event,
                                            gpointer           user_data)      : run last
"selection-get"
            void        user_function      (gtkwidget        *widget,
                                            gtkselectiondata *data,
                                            guint             info,
                                            guint             time,
                                            gpointer          user_data)      : run last
"selection-notify-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventselection *event,
                                            gpointer           user_data)      : run last
"selection-received"
            void        user_function      (gtkwidget        *widget,
                                            gtkselectiondata *data,
                                            guint             time,
                                            gpointer          user_data)      : run last
"selection-request-event"
            gboolean    user_function      (gtkwidget         *widget,
                                            gdkeventselection *event,
                                            gpointer           user_data)      : run last
"show"      void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run first
"show-help" gboolean    user_function      (gtkwidget        *widget,
                                            gtkwidgethelptype arg1,
                                            gpointer          user_data)      : run last / action
"size-allocate"
            void        user_function      (gtkwidget     *widget,
                                            gtkallocation *allocation,
                                            gpointer       user_data)       : run first
"size-request"
            void        user_function      (gtkwidget      *widget,
                                            gtkrequisition *requisition,
                                            gpointer        user_data)        : run first
"state-changed"
            void        user_function      (gtkwidget   *widget,
                                            gtkstatetype state,
                                            gpointer     user_data)      : run first
"style-set" void        user_function      (gtkwidget *widget,
                                            gtkstyle  *previous_style,
                                            gpointer   user_data)           : run first
"unmap"     void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run first
"unmap-event"
            gboolean    user_function      (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last
"unrealize" void        user_function      (gtkwidget *widget,
                                            gpointer   user_data)      : run last
"visibility-notify-event"
            gboolean    user_function      (gtkwidget          *widget,
                                            gdkeventvisibility *event,
                                            gpointer            user_data)      : run last
"window-state-event"
            gboolean    user_function      (gtkwidget           *widget,
                                            gdkeventwindowstate *event,
                                            gpointer             user_data)      : run last

описание

gtkwidget включает свойства стиля (style properties) – это основные свойства объекта которые сохраняются не в объекте, а в стиле объекта связанного с виджетом. свойства стиля устанавливаются в resource files. этот механизм используется для конфигурирования таких параметров как например тема расположения стрелок колеи полосы прокручивания, предоставление темы создаёт большую управляемость внешним видом приложения без необходимости писать движок темы на c.

для установки свойств стиля класса виджета используйте gtk_widget_class_install_style_property(), gtk_widget_class_find_style_property() или gtk_widget_class_list_style_properties() для получения информации о существующих стилях и gtk_widget_style_get_property(), gtk_widget_style_get() или gtk_widget_style_get_valist() для определения значения свойств стиля.

детали

gtkwidget

typedef struct {
  /* стиль для виджета. стиль содержит
   *  цвета виджета для каждого состояния
   *  вместе с графическим содержимым используемым для
   *  отрисовки и шрифт используемый в тексте.
   */
  gtkstyle *style;
  
  /* желательный размер виджета.
   */
  gtkrequisition requisition;
  
  /* распределённый размер для виджета.
   */
  gtkallocation allocation;
  
  /* окно виджета или его родительское окно если он
   *  не имеет окна. (что указывает установленный
   *  флажок gtk_no_window).
   */
  gdkwindow *window;
  
  /* родитель виджета.
   */
  gtkwidget *parent;
} gtkwidget;

gtkwidgetclass

typedef struct {
  /* структура объекта класса должна быть первым
   *  элементом в структуре класса виджета для правильной
   *  работы механизма классов. это позволяет указатель
   *  gtkwidgetclass привести к указателю gtkobjectclass
   */
  gtkobjectclass parent_class;

  
  guint activate_signal;

  guint set_scroll_adjustments_signal;
} gtkwidgetclass;

activate_signal сигнал издаётся когда виджет этого класса активизирован, gtk_widget_activate() обрабатывает эмиссию. реализация данного сигнала опциональна.

set_scroll_adjustment_signal сигнал издаётся когда виджет этого класса добавляется к прокрутке осведомлённого родителя, gtk_widget_set_scroll_adjustments() обрабатывает эмиссию. реализация этого сигнала опциональна.

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,

  /* виджету позволено получать значения по умолчанию через gtk_widget_grab_default
   * и резервировать пространство для отрисовки значения по умолчанию, если возможно.
   */
  gtk_can_default      = 1 << 13,

  /* виджет в текущий момент действует по умолчанию и должен быть соответственно отображён,
   * если возможно.
   */
  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,

  /* виджет при фокусировании действует по умолчанию и имеет
   * установку has_default, даже если другой виджет установлен по умолчанию
   */
  gtk_receives_default = 1 << 20,

  gtk_double_buffered  = 1 << 21,
  gtk_no_show_all      = 1 << 22
} gtkwidgetflags;

сообщает определённые свойства виджета.

gtk_widget_type()

#define gtk_widget_type(wid)              (gtk_object_type (wid))

определяет тип виджета.

gtk_widget_state()

#define gtk_widget_state(wid)             (gtk_widget (wid)->state)

возвращает текущеме состояние виджета, как gtkstatetype.

gtk_widget_saved_state()

#define gtk_widget_saved_state(wid)       (gtk_widget (wid)->saved_state)

возвращает сохранённое состояние виджета, как gtkstatetype.

сохранённое состояние виджета восстанавливается когда он снова становится чувствительным, после того как был сделан нечувствительным с помощью gtk_widget_set_state() или gtk_widget_set_sensitive().

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)

вычисляет true если виджет – это виджет верхнего уровня.

gtk_widget_no_window()

#define gtk_widget_no_window(wid)         ((gtk_widget_flags (wid) & gtk_no_window) != 0)

вычисляет true если виджет не имеет собственного gdkwindow.

gtk_widget_realized()

#define gtk_widget_realized(wid)          ((gtk_widget_flags (wid) & gtk_realized) != 0)

вычисляет true если виджет реализован.

gtk_widget_mapped()

#define gtk_widget_mapped(wid)            ((gtk_widget_flags (wid) & gtk_mapped) != 0)

вычисляет true если виджет отображён.

gtk_widget_visible()

#define gtk_widget_visible(wid)           ((gtk_widget_flags (wid) & gtk_visible) != 0)

вычисляет true если виджет видим.

gtk_widget_drawable()

#define gtk_widget_drawable(wid)          (gtk_widget_visible (wid) && gtk_widget_mapped (wid))

вычисляет true если виджет отображён и виден.

gtk_widget_sensitive()

#define gtk_widget_sensitive(wid)         ((gtk_widget_flags (wid) & gtk_sensitive) != 0)

вычисляет true если флажок gtk_sensitive установлен для виджета.

gtk_widget_parent_sensitive()

#define gtk_widget_parent_sensitive(wid)  ((gtk_widget_flags (wid) & gtk_parent_sensitive) != 0)

вычисляет true если для виджета установлен флажок gtk_parent_sensitive.

gtk_widget_is_sensitive()

#define     gtk_widget_is_sensitive(wid)

вычисляет true если виджет действительно чувствителен.

gtk_widget_can_focus()

#define gtk_widget_can_focus(wid)         ((gtk_widget_flags (wid) & gtk_can_focus) != 0)

вычисляет true если виджет может перехватывать фокус.

gtk_widget_has_focus()

#define gtk_widget_has_focus(wid)         ((gtk_widget_flags (wid) & gtk_has_focus) != 0)

вычисляет true если виджет находится в фокусе.

gtk_widget_can_default()

#define gtk_widget_can_default(wid)       ((gtk_widget_flags (wid) & gtk_can_default) != 0)

вычисляет true если виджет позволяет получать действие по умолчанию через gtk_widget_grab_default().

gtk_widget_receives_default()

#define gtk_widget_receives_default(wid)  ((gtk_widget_flags (wid) & gtk_receives_default) != 0)

вычисляет true если виджет находясь в фокусе получает действие по умолчанию, даже если по умолчанию установлен другой виджет.

gtk_widget_has_default()

#define gtk_widget_has_default(wid)       ((gtk_widget_flags (wid) & gtk_has_default) != 0)

вычисляет true если виджет в данный момент получает действие по умолчанию.

gtk_widget_has_grab()

#define gtk_widget_has_grab(wid)          ((gtk_widget_flags (wid) & gtk_has_grab) != 0)

вычисляет true если виджет находится в стеке grab_widgets, и привилегированный для получения событий кроме косметических значений.

gtk_widget_rc_style()

#define gtk_widget_rc_style(wid)          ((gtk_widget_flags (wid) & gtk_rc_style) != 0)

вычисляет true если стиль виджета определяется с помощью механизма rc файлов.

gtk_widget_composite_child()

#define gtk_widget_composite_child(wid)   ((gtk_widget_flags (wid) & gtk_composite_child) != 0)

вычисляет true если виджет является составной частью родителя.

gtk_widget_app_paintable()

#define gtk_widget_app_paintable(wid)     ((gtk_widget_flags (wid) & gtk_app_paintable) != 0)

вычисляет true если для виджета установлен флажок gtk_app_paintable.

gtk_widget_double_buffered()

#define gtk_widget_double_buffered(wid)   ((gtk_widget_flags (wid) & gtk_double_buffered) != 0)

вычисляет true если для виджета установлен флажок gtk_double_buffered.

gtk_widget_set_flags()

#define gtk_widget_set_flags(wid,flag)    g_stmt_start{ (gtk_widget_flags (wid) |= (flag)); }g_stmt_end

включает определённые флажки для виджета.

gtk_widget_unset_flags()

#define gtk_widget_unset_flags(wid,flag)  g_stmt_start{ (gtk_widget_flags (wid) &= ~(flag)); }g_stmt_end

отключает определённые флажки для виджета.

gtkcallback ()

void        (*gtkcallback)                  (gtkwidget *widget,
                                             gpointer data);

тип callback-функции используемой, например, для итерации дочерних виджетов контейнера, смотрите gtk_container_foreach().

gtkrequisition

typedef struct {
  gint width;
  gint height;
} gtkrequisition;

gtkrequisition представляет желаемый размер виджета. смотрите the section called “size requisition” для более подробной информации.

struct gtkallocation

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

gtkallocation представляет область которая распределяется для виджета его родителем. смотрите the section called “size allocation” для более подробной информации.

gtkselectiondata

typedef struct {
  gdkatom       selection;
  gdkatom       target;
  gdkatom       type;
  gint          format;
  guchar       *data;  
  gint          length;
  gdkdisplay   *display;
} gtkselectiondata;

gtkwidgetauxinfo

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

gtkwidgetshapeinfo

typedef struct {
  gint16     offset_x;
  gint16     offset_y;
  gdkbitmap *shape_mask;
} gtkwidgetshapeinfo;

enum gtkwidgethelptype

typedef enum
{
  gtk_widget_help_tooltip,
  gtk_widget_help_whats_this
} gtkwidgethelptype;

gtk_widget_new ()

gtkwidget*  gtk_widget_new                  (gtype type,
                                             const gchar *first_property_name,
                                             ...);

это удобная функция для создания виджета и настройки его свойств в один приём. например вы можете написать: gtk_widget_new (gtk_type_label, "label", "hello world", "xalign", 0.0, null) для создания ярлыка с левым выравниванием. равноценна для g_object_new(), но возвращает виджет, поэтому вы не должны преобразовывать объект самостоятельно.

gtk_widget_ref ()

gtkwidget*  gtk_widget_ref                  (gtkwidget *widget);

добавляет ссылку на виджет. это тоже самое что вызвать g_object_ref(), и существует главным образом для совместимости. может быть удобной для избежания преобразования виджета к gobject, это позволяет меньше печатать.

gtk_widget_unref ()

void        gtk_widget_unref                (gtkwidget *widget);

противоположна gtk_widget_ref(). эквивалентна для g_object_unref().

gtk_widget_destroy ()

void        gtk_widget_destroy              (gtkwidget *widget);

уничтожает виджет. эквивалент для gtk_object_destroy(), за исключением того что вы не должны преобразовывать виджет к gtkobject. когда виджет разрушен, уничтожаются все ссылки содержащиеся в других объектах. если виджет находится в контейнере, он будет удалён из контейнера. если виджет верхнего уровня (происходит из gtkwindow), он будет удалён из списка верхнего уровня и будут удалены ссылки на него которые содержит gtk+. удаление виджета из его родительского контейнера ил из списка верхнего уровня является завершающей стадией (finalized), если вы не добавите ссылки на виджет с помощью g_object_ref().

в большинстве случаев, только виджеты верхнего уровня (окна) требуют явного уничтожения, потому что при их уничтожении также уничтожаются дочерние виджеты.

gtk_widget_destroyed ()

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

эта функция устанавливает *widget_pointer в значение null если widget_pointer != null. она предназначена для использования в качестве callback-функции подключённой к сигналу "destroy" виджета. вы подключаете gtk_widget_destroyed() как обработчик сигнала, и помещаете вашу переменную виджета как пользовательские данные. после уничтожения виджета переменная устанавливается в null. полезна например, для избежания многократного копирования одного и того же диалога.

gtk_widget_set ()

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

внимание

gtk_widget_set устарела и не должна использоваться во вновь создаваемом коде.

тоже что и g_object_set() - нет причин использовать её вместо g_object_set().

gtk_widget_unparent ()

void        gtk_widget_unparent             (gtkwidget *widget);

эта функция используется только для реализации виджетов. должна вызываться для реализации метода удаления из контейнера gtkcontainer, отсоединяя дочерний виджет от контейнера.

gtk_widget_show ()

void        gtk_widget_show                 (gtkwidget *widget);

отмечает виджет для отображения. любой не отображённый виджет не будет появляться на экране. если вам нужно отобразить все виджеты в контейнере, лучше вызвать gtk_widget_show_all() для контейнера, вместо индивидуального отображения виджетов.

помните, что вы должны отобразить контейнер содержащий виджет, в дополнение к непосредственно отображению самого виджета, после этого он появится на экране.

когда контейнер верхнего уровня отображён, он реализован; другие виджеты являются отображёнными и реализованными когда их контейнер реализован и отображён.

gtk_widget_show_now ()

void        gtk_widget_show_now             (gtkwidget *widget);

показывает виджет. если виджет является не отображенным виджетом верхнего уровня (то есть gtkwindow который не показан), входит в основной цикл в ожидании фактического отображения окна. будьте внимательны; поскольку выполняется основной цикл, может что нибудь произойти во время выполнения этой функции.

gtk_widget_hide ()

void        gtk_widget_hide                 (gtkwidget *widget);

обратный эффект от gtk_widget_show(), скрывает виджет (невидим для пользователя).

gtk_widget_show_all ()

void        gtk_widget_show_all             (gtkwidget *widget);

рекурсивно отображает все виджеты и любые дочерние виджеты (если виджет является контейнером).

gtk_widget_hide_all ()

void        gtk_widget_hide_all             (gtkwidget *widget);

рекурсивно скрывает все виджеты и любые дочерние виджеты.

gtk_widget_map ()

void        gtk_widget_map                  (gtkwidget *widget);

эта функция используется только для реализации виджета. отображает виджет если он ещё не отображён.

gtk_widget_unmap ()

void        gtk_widget_unmap                (gtkwidget *widget);

эта функция используется только для реализации виджета. отменяет текущеме отображение.

gtk_widget_realize ()

void        gtk_widget_realize              (gtkwidget *widget);

создаёт gdk (оконную систему) ресурсы, связанные с виджетом. например, widget->window будет создан когда виджет реализован. обычно реализация происходит не явно; если вы покажите виджет все его родительские контейнеры, то виджет будет реализован и отображён автоматически.

реализация виджета требует чтобы все родители виджета тоже были реализованы; вызов gtk_widget_realize() реализует родителей виджета в дополнение к непосредственно реализации widget. если виджет не в окне верхнего уровня когда вы его реализуете, может произойти ошибка.

эта функция в первую очередь используется при реализации виджета, и не очень полезна в других ситуациях. в большинстве случаев когда вы думаете что нуждаетесь в этой функции, лучшим решением будет подключение сигнала который будет издаваться после реализации автоматически, такой как "expose_event". или просто g_signal_connect_after() для сигнала "realize".

gtk_widget_unrealize ()

void        gtk_widget_unrealize            (gtkwidget *widget);

эта функция полезна только при реализации виджета. делает виджет не реализованным (освобождает все ресурсы gdk связанные с виджетом, такие как widget->window).

gtk_widget_queue_draw ()

void        gtk_widget_queue_draw           (gtkwidget *widget);

равноценна вызову gtk_widget_queue_draw_area() для всей области виджета.

gtk_widget_queue_resize ()

void        gtk_widget_queue_resize         (gtkwidget *widget);

эта функция используется только для реализации виджета. отмечает виджет для пересмотра размера; должна вызываться когда виджет по каким то причинам запрашивает новый размер. например, когда вы изменяете текст в gtklabel, gtklabel запрашивает изменение размера чтобы соответствовать новому тексту.

gtk_widget_queue_resize_no_redraw ()

void        gtk_widget_queue_resize_no_redraw
                                            (gtkwidget *widget);

эта функция работает также как gtk_widget_queue_resize(), за исключением того, что виджет не аннулируется.

начиная с версии 2.4

gtk_widget_draw ()

void        gtk_widget_draw                 (gtkwidget *widget,
                                             gdkrectangle *area);

внимание

gtk_widget_draw устарела и не должна использоваться во вновь создаваемом коде.

в gtk+ 1.2, эта функция немедленно бы нарисовала участок area виджета, вызывая виртуальный метод рисования виджета. в gtk+ 2.0, метод рисования исключён, а вместо него gtk_widget_draw() просто аннулирует участок виджета, затем немедленно обновляет аннулированный участок. обычно вам не нужно обновлять участок немедленно по причинам производительности, таким образом в основном gtk_widget_queue_draw_area() лучший выбор, если вам нужно отобразить участок виджета.

gtk_widget_size_request ()

void        gtk_widget_size_request         (gtkwidget *widget,
                                             gtkrequisition *requisition);

эта функция обычно используется при реализации подкласса gtkcontainer. определяет привилегированный размер виджета. контейнер использует эту информацию для упорядочения дочерних виджетов и решить какой размер распределить для них с помощью gtk_widget_size_allocate().

вы также можете вызвать эту функцию из приложения, с некоторыми оговорками. наиболее важная, получение запроса размера требует, чтобы виджет был связан с экраном, потому что может быть необходима информация о шрифте. многооконные (multihead-aware) приложения должны хранить это в памяти.

помните, запрашиваемый размер не всегда является фактическим размером виджета.

смотрите также gtk_widget_get_child_requisition().

gtk_widget_get_child_requisition ()

void        gtk_widget_get_child_requisition
                                            (gtkwidget *widget,
                                             gtkrequisition *requisition);

эта функция используется только для реализации виджета. определяет widget->requisition, если кто нибудь не установил специфическую геометрию для виджета (например с помощью gtk_widget_set_usize()), в этом случае возвращается эта геометрия вместо запрашиваемой виджетом.

эта функция отличается от gtk_widget_size_request() в том, что определяет последний запрашиваемый размер из widget->requisition, в то время как gtk_widget_size_request() фактически вызывает "size_request" метод на widget для вычисления вычисления запрашиваемого размера и заполнения в widget->requisition, и только после этого возвращает widget->requisition.

поскольку эта функция не вызывает "size_request" метод, она может использоваться только когда вы знаете что widget->requisition обновлен, то есть, gtk_widget_size_request() вызывался с момента последнего изменения размера. в основном, только контейнеры используют эту информацию; приложения должны использовать gtk_widget_size_request().

gtk_widget_size_allocate ()

void        gtk_widget_size_allocate        (gtkwidget *widget,
                                             gtkallocation *allocation);

эта функция используется только подклассами gtkcontainer, для привязки размера и позиции их дочерних виджетов.

gtk_widget_add_accelerator ()

void        gtk_widget_add_accelerator      (gtkwidget *widget,
                                             const gchar *accel_signal,
                                             gtkaccelgroup *accel_group,
                                             guint accel_key,
                                             gdkmodifiertype accel_mods,
                                             gtkaccelflags accel_flags);

устанавливает акселератор для widget в accel_group, который издаёт сигнал accel_signal если активизирован. accel_group должен быть добавлен в виджет верхнего уровня с помощью gtk_window_add_accel_group(), а сигнал должен быть типа g_run_action. акселераторы добавленные с помощью этой функции не могут изменяться пользователем в течении выполнения. если вам нужна поддержка акселераторов которые могут изменяться пользователем, используйте gtk_accel_map_add_entry() и gtk_widget_set_accel_path() или gtk_menu_item_set_accel_path().

gtk_widget_remove_accelerator ()

gboolean    gtk_widget_remove_accelerator   (gtkwidget *widget,
                                             gtkaccelgroup *accel_group,
                                             guint accel_key,
                                             gdkmodifiertype accel_mods);

удаляет акселератор для widget, предварительно установленный с помощью gtk_widget_add_accelerator().

gtk_widget_set_accel_path ()

void        gtk_widget_set_accel_path       (gtkwidget *widget,
                                             const gchar *accel_path,
                                             gtkaccelgroup *accel_group);

учитывая группу акселератора, accel_group, и путь акселератора, accel_path, устанавливает акселератор в accel_group, чтобы всякий раз при нажатии клавишной привязки которая определена для accel_path, widget активировался. это удаляет любые акселераторы (для любой группы акселераторов) предварительно установленные с помощью gtk_widget_set_accel_path(). ассоциирует акселераторы с путями, позволяя пользователю изменять их и сохранять для использования в будущем. (смотрите gtk_accel_map_save().)

это функция нижнего уровня, которая наиболее вероятно использовалась бы системой создания меню, такой как gtkitemfactory. если вы используете gtkitemfactory, установка путей акселератора будет выполнена автоматически.

даже когда вы не используете gtkitemfactory, а просто хотите установить акселераторы для пунктов меню, gtk_menu_item_set_accel_path() обеспечивает наиболее удобный интерфейс.

gtk_widget_list_accel_closures ()

glist*      gtk_widget_list_accel_closures  (gtkwidget *widget);

перечисляет закрытые выражения используемые widget для групп акселераторов подключённых с помощью gtk_accel_group_connect_by_path() или gtk_accel_group_connect(). закрытые выражения могут использоваться для контроля изменений акселератора для widget, подключая сигнал ::accel_changed закрытого выражения gtkaccelgroup, которое может быть найдено с помощью gtk_accel_group_from_accel_closure().

gtk_widget_can_activate_accel ()

gboolean    gtk_widget_can_activate_accel   (gtkwidget *widget,
                                             guint signal_id);

определяет может ли в данный момент активизироваться акселератор, который подключен к сигналу идентифицируемому signal_id. это издаёт сигнал gtkwidget::can-activate-accel для widget; если сигнал не отменён обработчиком или предком виджета, то по умолчанию проверяется может ли виджет быть чувствительным и отображены ли все его предки.

начиная с версии 2.4

gtk_widget_event ()

gboolean    gtk_widget_event                (gtkwidget *widget,
                                             gdkevent *event);

редко используемая функция. эта функция используется для издания сигналов событий для виджета (которые не могут издаваться без использования этой функции). если вам нужно синтезировать событие не используя эту функцию; вместо неё, используйте gtk_main_do_event(), таким образом событие будет вести себя как будто оно было в очереди событий. не синтезируйте события экспозиции; вместо этого используйте gdk_window_invalidate_rect() для аннулирования участка окна.

gtk_widget_activate ()

gboolean    gtk_widget_activate             (gtkwidget *widget);

активизирует виджеты которые могут быть "activated" (кнопки, пункты меню, и т.д..). активизация происходит когда вы нажимаете enter на виджете во время клавиатурного управления. если widget не может быть активизирован, функция вернёт false.

gtk_widget_reparent ()

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

перемещает виджет из одного gtkcontainer в другой, обрабатывает ссылки для избежания разрушения виджета.

gtk_widget_intersect ()

gboolean    gtk_widget_intersect            (gtkwidget *widget,
                                             gdkrectangle *area,
                                             gdkrectangle *intersection);

вычисляет пересечение области widget's и area, сохраняя пересечение в intersection, и возвращая true если пересечение было. intersection может быть null если вы только интересуетесь было ли пересечение.

gtk_widget_is_focus ()

gboolean    gtk_widget_is_focus             (gtkwidget *widget);

определяет является ли сфокусированный виджет в пределах его верхнего уровня. (это не значит что флажок has_focus обязательно установлен; has_focus устанавливается только если виджет верхнего уровня имеет общий фокус ввода.)

gtk_widget_grab_focus ()

void        gtk_widget_grab_focus           (gtkwidget *widget);

заставляет widget получить клавиатурный фокус внутри gtkwindow. widget должен быть фокусируемым, таким как gtkentry; для таких как gtkframe не будет работать. (более точно, он должен иметь установленный флажок gtk_can_focus.)

gtk_widget_grab_default ()

void        gtk_widget_grab_default         (gtkwidget *widget);

заставляет widget быть виджетом по умолчанию. widget должен иметь установленный флажок gtk_can_default; обычно вы устанавливаете этот флажок самостоятельно вызывая gtk_widget_set_flags (widget, gtk_can_default). виджет по умолчанию активизируется когда пользователь нажимает enter в сфокусированном окне. виджет по умолчанию должен быть активизируемым, то есть, gtk_widget_activate() должна быть для него выполнена.

gtk_widget_set_name ()

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

виджет может быть именован, что позволит вам обращаться к нему через gtkrc файл. вы можете применить стиль для виджетов с помощью специальных имён в gtkrc файле. смотрите документацию для gtkrc файлов (там же где документация для gtkrcstyle).

помните, имена виджетов разделяются точками в путях (смотрите gtk_widget_path()), поэтому имена включающие точки могут вызвать ошибку.

gtk_widget_get_name ()

const gchar* gtk_widget_get_name            (gtkwidget *widget);

определяет имя виджета. смотрите gtk_widget_set_name().

gtk_widget_set_state ()

void        gtk_widget_set_state            (gtkwidget *widget,
                                             gtkstatetype state);

эта функция только для реализации виджетов. устанавливает состояние виджета (нечувствительный, подсвеченный, и т.д..) обычно состояние устанавливается используя функцию оболочку, такую как gtk_widget_set_sensitive().

gtk_widget_set_sensitive ()

void        gtk_widget_set_sensitive        (gtkwidget *widget,
                                             gboolean sensitive);

устанавливает чувствительность виджета. виджет чувствителен если пользователь может взаимодействовать с ним. нечувствительные виджеты являются "недоступными (grayed out)" и пользователь не может с ними взаимодействовать. нечувствительные виджеты известны как "inactive", "disabled", или "ghosted" в некоторых других инструментариях.

gtk_widget_set_parent ()

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

эта функция полезна только когда реализуется подкласс gtkcontainer. устанавливает контейнер как родительский для widget, и заботится о некоторых деталях, таких как обновление состояния и стиль дочернего виджета, отражая его новое расположение. противоположна функции gtk_widget_unparent().

gtk_widget_set_parent_window ()

void        gtk_widget_set_parent_window    (gtkwidget *widget,
                                             gdkwindow *parent_window);

устанавливает родительское окно для widget.

gtk_widget_get_parent_window ()

gdkwindow*  gtk_widget_get_parent_window    (gtkwidget *widget);

определяет родительское окно для widget's.

gtk_widget_set_uposition ()

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

внимание

gtk_widget_set_uposition устарела и не должна использоваться во вновь создаваемом коде.

устанавливает позицию виджета. дополнительное "u" в названии происходит из "user position" подсказки определенной x window system, и существует для обратной совместимости. эта функция не работает если виджет внутри контейнера; она полезна только для gtkwindow.

не используйте эту функцию для центрирования диалога относительно основного окна; большинство менеджеров окон сделают это за вас, если вы вызовите gtk_window_set_transient_for(), невозможно заставить работать центрирование правильно во всех случаях прикладного кода. но если вы настаиваете, используйте gtk_window_set_position() для установки gtk_win_pos_center_on_parent, не выполняйте центровку вручную.

помните, хотя x и y могут быть индивидуально отменены, позиция не соблюдается если оба и x и y не установлены.

gtk_widget_set_usize ()

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

внимание

gtk_widget_set_usize устарела и не должна использоваться во вновь создаваемом коде.

устанавливает минимальный размер виджета; то есть запрашиваемый размер виджета будет width и height. вы можете использовать эту функцию чтобы заставить виджет стать меньше или больше чем он есть. странное имя "usize" датируется ранними версиями gtk+, и происходит из терминологии x window system. в большинстве случаев, gtk_window_set_default_size() лучше для окон верхнего уровня чем эта функция; установка размера по умолчанию все же позволит пользователю уменьшать окно. установка usize заставит их сохранять размер окна не больше чем usize. имея дело с размером окна, gtk_window_set_geometry_hints() также может быть полезна.

помните, внутренне опасно устанавливать любой фиксированный размер - темы, перевод на другие языки, разные шрифты и пользовательские действия могут изменить соответственные размеры виджета. поэтому не возможно подобрать размер который будет всегда правильным.

deprecated: вместо неё используйте gtk_widget_set_size_request().

gtk_widget_set_events ()

void        gtk_widget_set_events           (gtkwidget *widget,
                                             gint events);

устанавливает маску события (смотрите gdkeventmask) для виджета. маска события определяет какие события будет получать виджет. имейте ввиду, что разные виджеты имеют разные маски событий по умолчанию, и изменяя маску события вы можете нарушить функциональность виджета, поэтому будьте внимательны. эта функция вызывается до реализации виджета. рассмотрите gtk_widget_add_events() для виджетов которые уже реализованы, или если вам нужно сохранить существующую маску. эта функция может использоваться с виджетами gtk_no_window; для получения событий такими виджетами, поместите их в gtkeventbox а получаемое событие в контейнер событий.

gtk_widget_add_events ()

void        gtk_widget_add_events           (gtkwidget *widget,
                                             gint events);

добавляет событие к битовому полю events маски события для widget. смотрите gtk_widget_set_events().

gtk_widget_set_extension_events ()

void        gtk_widget_set_extension_events (gtkwidget *widget,
                                             gdkextensionmode mode);

устанавливает дополнительную маску события в mode. смотрите gdkextensionmode и gdk_input_set_extension_events().

gtk_widget_get_extension_events ()

gdkextensionmode gtk_widget_get_extension_events
                                            (gtkwidget *widget);

определяет дополнительное событие виджета для получения; смотрите gdk_input_set_extension_events().

gtk_widget_get_toplevel ()

gtkwidget*  gtk_widget_get_toplevel         (gtkwidget *widget);

эта функция возвращает самый верхний виджет в контейнерной иерархии widget. если widget не имеет родительского виджета, он будет возвращён как виджет верхнего уровня. на возвращаемый виджет не добавляется ссылок; он не должен освобождаться.

помните о различных поведениях gtk_widget_get_ancestor(); gtk_widget_get_ancestor (widget, gtk_type_window) вернёт null если widget был в окне верхнего уровня, и если окно было внутри gtkwindow-наследника виджета который был в свою очередь внутри gtkwindow верхнего уровня. в то время как второй случай может показаться мало вероятным, он происходит когда gtkplug встроен в gtksocket внутри некоторого приложения.

для надёжного определения gtkwindow верхнего уровня, используйте gtk_widget_get_toplevel() и контролируйте установлен ли флаг toplevel в результате.

 gtkwidget *toplevel = gtk_widget_get_toplevel (widget);
 if (gtk_widget_toplevel (toplevel))
   {
     [ perform action on toplevel. ]
   }

gtk_widget_get_ancestor ()

gtkwidget*  gtk_widget_get_ancestor         (gtkwidget *widget,
                                             gtype widget_type);

определяет первого предка виджета widget с типом widget_type. например, gtk_widget_get_ancestor (widget, gtk_type_box) получает первый gtkbox который является предком widget. к возвращаемому виджету не добавляется ссылок; он не должен освобождаться. смотрите примечания о проверки верхнего уровня gtkwindow в документации для gtk_widget_get_toplevel().

помните, в отличии от gtk_widget_is_ancestor(), gtk_widget_get_ancestor() предполагает что widget является предком самого себя.

gtk_widget_get_colormap ()

gdkcolormap* gtk_widget_get_colormap        (gtkwidget *widget);

определяет цветовую гамму для представления виджета widget. на цветовую гамму не добавляются ссылки; их не нужно отменять.

gtk_widget_set_colormap ()

void        gtk_widget_set_colormap         (gtkwidget *widget,
                                             gdkcolormap *colormap);

устанавливает цветовую гамму для виджета в определённое значение. виджет не должен быть реализованным. это в основном должно использоваться только init() функцией (то есть из конструктора для виджета).

gtk_widget_get_visual ()

gdkvisual*  gtk_widget_get_visual           (gtkwidget *widget);

определяет визуализацию которая используется для отображения виджета widget.

gtk_widget_get_events ()

gint        gtk_widget_get_events           (gtkwidget *widget);

возвращает маску событий для виджета (битовое поле содержит флажки из перечисления gdkeventmask). они являются событиями которые получает виджет.

gtk_widget_get_pointer ()

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

определяет расположение указателя мыши в координатах виджета. координаты виджета немного избыточны; для обратной совместимости, они определяются как widget->window координаты для виджетов которые не являются виджетами gtk_no_window, и соответственно widget->allocation.x, widget->allocation.y для виджетов которые являются виджетами gtk_no_window.

gtk_widget_is_ancestor ()

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

определяет находится ли widget внутри какого нибудь ancestor, возможно с промежуточными контейнерами.

gtk_widget_translate_coordinates ()

gboolean    gtk_widget_translate_coordinates
                                            (gtkwidget *src_widget,
                                             gtkwidget *dest_widget,
                                             gint src_x,
                                             gint src_y,
                                             gint *dest_x,
                                             gint *dest_y);

преобразует соответствующие координаты расположения src_widget's в соответствующие координаты расположения dest_widget's. для выполнения этой операции оба виджета должны быть реализованы и должны иметь общий верхний уровень.

gtk_widget_hide_on_delete ()

gboolean    gtk_widget_hide_on_delete       (gtkwidget *widget);

сервисная функция; предназначена для подключения сигнала "delete_event" к gtkwindow. функция вызывает gtk_widget_hide() в своём аргументе, затем возвращает true, если подключение к "delete_event", результат нажатия кнопки close на окне (обычно в верхнем правом углу) оно скрывается, но не разрушается. по умолчанию, gtk+ разрушает окна когда получает "delete_event".

gtk_widget_set_style ()

void        gtk_widget_set_style            (gtkwidget *widget,
                                             gtkstyle *style);

устанавливает gtkstyle для виджета (widget->style). в основном вам не нужно использовать эту функцию; это ужасно взаимодействует с темами, поскольку темы заменяют gtkstyle. вместо неё используйте gtk_widget_modify_style().

gtk_widget_set_rc_style()

#define gtk_widget_set_rc_style(widget)          (gtk_widget_set_style (widget, null))

внимание

gtk_widget_set_rc_style устарела и не должна использоваться во вновь создаваемом коде.

равноценна для gtk_widget_set_style (widget, null).

gtk_widget_ensure_style ()

void        gtk_widget_ensure_style         (gtkwidget *widget);

убеждается что widget имеет стиль (widget->style). не очень полезная функция; в большинстве случаев, если вам нужен стиль, виджет реализован, а реализованный виджет гарантировано имеет стиль.

gtk_widget_get_style ()

gtkstyle*   gtk_widget_get_style            (gtkwidget *widget);

возвращает стиль widget->style.

gtk_widget_restore_default_style()

#define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, null))

внимание

gtk_widget_restore_default_style устарела и не должна использоваться во вновь создаваемом коде.

равноценна для gtk_widget_set_style (widget, null).

gtk_widget_reset_rc_styles ()

void        gtk_widget_reset_rc_styles      (gtkwidget *widget);

отменяет стиль виджета widget и всех его потомков, поэтому когда они определяться снова, они получат правильные значения для текущих загруженных настроек rc файла.

эта функция бесполезна для приложений.

gtk_widget_push_colormap ()

void        gtk_widget_push_colormap        (gdkcolormap *cmap);

помещает cmap в общий стек цветовых гамм; самая верхняя цветовая гамма в стеке будет использоваться для отображения всех виджетов. удаляется cmap с помощью gtk_widget_pop_colormap(). существует мало причин использовать эту функцию.

gtk_widget_pop_colormap ()

void        gtk_widget_pop_colormap         (void);

удаляет цветовую гамму помещённую с помощью gtk_widget_push_colormap().

gtk_widget_set_default_colormap ()

void        gtk_widget_set_default_colormap (gdkcolormap *colormap);

устанавливает цветовую гамму по умолчанию при создании виджетов. gtk_widget_push_colormap() влияет только на несколько виджетов а не на все сразу.

gtk_widget_get_default_style ()

gtkstyle*   gtk_widget_get_default_style    (void);

возвращает стиль используемый всеми инициализированными виджетами.

gtk_widget_get_default_colormap ()

gdkcolormap* gtk_widget_get_default_colormap
                                            (void);

определяет цветовую гамму используемую по умолчанию при создании виджетов.

gtk_widget_get_default_visual ()

gdkvisual*  gtk_widget_get_default_visual   (void);

определяет визуализацию цветовой гаммы по умолчанию. не очень полезна; используется перед осуществлением gdk_colormap_get_visual().

gtk_widget_set_direction ()

void        gtk_widget_set_direction        (gtkwidget *widget,
                                             gtktextdirection dir);

устанавливает направление интерпретации определенного виджета. контролирует первичное направление для виджета содержащего текст, а также направление в котором упакованы дочерние виджеты в контейнере. позволяет устанавливать направление представляющее возможность правильно отображать языковую локализацию с право на лево. обычно, приложения используют направление интерпретации по умолчанию, за исключением контейнеров выравненных в порядке явной визуализации, а не логической (такие как кнопки для для выравнивания текста).

если направление установлено в gtk_text_dir_none, то будет использоваться значение установленное с помощью gtk_widget_set_default_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);

определяет направление интерпретации определённого виджета. смотрите gtk_widget_set_direction().

gtk_widget_set_default_direction ()

void        gtk_widget_set_default_direction
                                            (gtktextdirection dir);

устанавливает направление интерпретации для виджетов, если оно не было установлено явно с помощью gtk_widget_set_direction().

gtk_widget_get_default_direction ()

gtktextdirection gtk_widget_get_default_direction
                                            (void);

определяет текущеме направление интерпретации по умолчанию. смотрите gtk_widget_set_default_direction().

gtk_widget_shape_combine_mask ()

void        gtk_widget_shape_combine_mask   (gtkwidget *widget,
                                             gdkbitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);

устанавливает очертания для этого виджета gdk окна. это позволяет делать прозрачные окна и т.д., смотрите gdk_window_shape_combine_mask() для более подробной информации.

gtk_widget_input_shape_combine_mask ()

void        gtk_widget_input_shape_combine_mask
                                            (gtkwidget *widget,
                                             gdkbitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);

устанавливает очертание ввода для виджета gdk окна. позволяет окнам реагировать на нажатие мышки вне прямоугольной области, смотрите gdk_window_input_shape_combine_mask() для более подробной информации.

начиная с версии 2.10

gtk_widget_path ()

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

определяет полный путь для widget. путь это имя виджета и всех родительских контейнеров в иерархии, разделённые точками. имя виджета определяется с помощью gtk_widget_get_name(). пути используются для применения стилей к виджетам в gtkrc файлах конфигурации. по умолчанию именем виджета является его тип (например "gtkbutton") или может устанавливаться в определённое приложением значение с помощью gtk_widget_set_name(). установив имя виджета вы позволяете пользователю или автору темы применять стили к определённому виджету в gtkrc файле. path_reversed_p заполняется путём в обратном порядке, то есть начиная с имени виджета widget's вместо имени изначального родителя widget's.

gtk_widget_class_path ()

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

также как gtk_widget_path(), но всегда использует имя типа виджета, никогда не использует выбранное имя установленное с помощью gtk_widget_set_name().

gtk_widget_get_composite_name ()

gchar*      gtk_widget_get_composite_name   (gtkwidget *widget);

определяет составное имя виджета.

gtk_widget_modify_style ()

void        gtk_widget_modify_style         (gtkwidget *widget,
                                             gtkrcstyle *style);

изменят стиль виджета. изменения сделанные с помощью этой функции имеют приоритет перед стилем установленным через rc файл, однако, они будут отменены если стиль явно установить используя gtk_widget_set_style(). структура gtkrcstyle спроектирована так, что каждое поле может быть установлено или сброшено, поэтому возможно изменение некоторых значений стиля в то время как другие остаются без изменений.

помните, изменения сделанные с помощью этой функции не совмещаются с предыдущими вызовами gtk_widget_modify_style() или с такими функциями как gtk_widget_modify_fg(). если вы хотите сохранить предыдущие значения, вы должны сначала вызвать gtk_widget_get_modifier_style(), вложив ваши изменения в возвращаемый стиль, затем вызвать gtk_widget_modify_style() с этим стилем. с другой стороны, если вы сначала вызовите gtk_widget_modify_style(), то последующие вызовы таких функций как gtk_widget_modify_fg() будут совмещать эффект с начальными изменениями.

gtk_widget_get_modifier_style ()

gtkrcstyle* gtk_widget_get_modifier_style   (gtkwidget *widget);

возвращает текущие модификатор стиля виджета. (которые установлены с помощью gtk_widget_modify_style().) если нет предварительно установленного стиля, создаётся новый gtkrcstyle с неустановленными значениями и устанавливается как модификатор стиля виджета. если вы делаете изменения в этом rc стиле, вы должны вызвать gtk_widget_modify_style(), помещая возвращаемый rc стиль, убедившись что ваши изменения вступили в силу.

предостережение: помещение стиля назад в gtk_widget_modify_style() обычно заканчивается его уничтожением, потому что gtk_widget_modify_style() копирует помещаемый в неё стиль и устанавливает копию как новый изменённый стиль, таким образом отменяются все ссылки на старую модификацию стиля. добавьте ссылку на модификатор стиля, если вам нужно чтобы он существовал.

gtk_widget_modify_fg ()

void        gtk_widget_modify_fg            (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);

устанавливает цвет символов (переднего плана) виджета в специфическом состоянии. все остальные значения стиля остаются нетронутыми. смотрите также gtk_widget_modify_style().

gtk_widget_modify_bg ()

void        gtk_widget_modify_bg            (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);

устанавливает цвет фона для виджета в специфическом состоянии. остальные значения стиля остаются не тронутыми. смотрите также gtk_widget_modify_style().

помните, виджеты без окон "no window" (для которых установлен флажок gtk_no_window) отображаются в окнах их родительских контейнеров и поэтому не могут отображать фон самостоятельно. например как gtklabel. для установки фона таких виджетов, вы должны установить цвет фона для его родителя; если вам нужно установить фон прямоугольной области вокруг ярлыка, попробуйте разместить ярлык в gtkeventbox виджете и установить фон для него.

gtk_widget_modify_text ()

void        gtk_widget_modify_text          (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);

устанавливает цвет текста виджета в специфическом состоянии. остальные значения стиля остаются нетронутыми. цвет текста – это цвет символов используемый вместе с основным цветом (смотрите gtk_widget_modify_base()) для таких виджетов как gtkentry и gtktextview. смотрите также gtk_widget_modify_style().

gtk_widget_modify_base ()

void        gtk_widget_modify_base          (gtkwidget *widget,
                                             gtkstatetype state,
                                             const gdkcolor *color);

устанавливает основной цвет для виджета в специфическом состоянии. остальные значения стиля остаются нетронутыми. основной цвет это фон используемый вместе с цветом текста (смотрите gtk_widget_modify_text()) для таких виджетов как gtkentry и gtktextview. смотрите также gtk_widget_modify_style().

помните, виджеты без окон "no window" (для которых установлен флажок gtk_no_window) отображаются в окнах их родительских контейнеров и поэтому не могут отображать фон самостоятельно. например как gtklabel. для установки фона таких виджетов, вы должны установить цвет фона для его родителя; если вам нужно установить фон прямоугольной области вокруг ярлыка, попробуйте разместить ярлык в gtkeventbox виджете и установить фон для него.

gtk_widget_modify_font ()

void        gtk_widget_modify_font          (gtkwidget *widget,
                                             pangofontdescription *font_desc);

устанавливает шрифт используемый в виджете. остальные значения стиля остаются нетронутыми. смотрите также gtk_widget_modify_style().

gtk_widget_create_pango_context ()

pangocontext* gtk_widget_create_pango_context
                                            (gtkwidget *widget);

создаёт новый pangocontext с соответствующей картой шрифта, описанием шрифта и основного направления отображения текста в виджете. смотрите также gtk_widget_get_pango_context().

gtk_widget_get_pango_context ()

pangocontext* gtk_widget_get_pango_context  (gtkwidget *widget);

определяет pangocontext с соответствующей картой шрифта, описанием шрифта и основного направления текста в виджете. в отличие от контекста возвращаемого из gtk_widget_create_pango_context(), этот контекст принадлежит виджету (он может использоваться в течении отображения для изменения виджета или удаления виджета из его верхнего уровня) и обновляется для соответствия любым изменениям атрибутов виджета.

если вы создаёте и сохраняете pangolayout используя этот контекст, вы должны иметь дело с изменениями для контекста вызывая pango_layout_context_changed() для макета в ответ на сигналы виджета ::style-set и ::direction-changed.

gtk_widget_create_pango_layout ()

pangolayout* gtk_widget_create_pango_layout (gtkwidget *widget,
                                             const gchar *text);

создаёт новый pangolayout с соответствующей картой шрифта, описанием шрифта и основным направлением отображения текста в виджете.

если вы сохраняете pangolayout созданный этим способом, чтобы зарегистрировать макет изменений основного направления или шрифта этого виджета, вы должны вызвать pango_layout_context_changed() в ответ на сигналы виджета ::style-set и ::direction-changed.

gtk_widget_render_icon ()

gdkpixbuf*  gtk_widget_render_icon          (gtkwidget *widget,
                                             const gchar *stock_id,
                                             gtkiconsize size,
                                             const gchar *detail);

удобная функция которая использует механизм тем и настройки rc файла для widget, чтобы определить stock_id и предоставить его для изображения (pixbuf). stock_id должен быть id готового значка, такой как gtk_stock_open или gtk_stock_ok. size должен быть таким размером как gtk_icon_size_menu. detail должен быть строкой которая идентифицирует виджет или код выполняющий представление, так чтобы движки тем могли быть специально выбраны для представления этим виджетом или кодом.

пикселы в возвращаемом gdkpixbuf являются общими с приложением и не должны освобождаться. изображение должно освобождаться после использования, с помощью g_object_unref().

gtk_widget_pop_composite_child ()

void        gtk_widget_pop_composite_child  (void);

прекращает действие предыдущего вызова gtk_widget_push_composite_child().

gtk_widget_push_composite_child ()

void        gtk_widget_push_composite_child (void);

делает все вновь созданные виджеты как составные дочерние, перед передачей вызову gtk_widget_pop_composite_child().

составные виджеты – это дочерние виджеты которые реализуют детали контейнера в котором они находятся и не должны быть видимы людям использующим контейнер. составные дочерние виджеты обрабатываются gtk не по другому (смотрите gtk_container_foreach() против gtk_container_forall()), но например разработчики gui могут захотеть обработать их другим способом.

вот простой пример:

  gtk_widget_push_composite_child ();
  scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
  gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
  gtk_widget_pop_composite_child ();
  gtk_widget_set_parent (scrolled_window->hscrollbar, 
                         gtk_widget (scrolled_window));
  g_object_ref (scrolled_window->hscrollbar);

gtk_widget_queue_clear ()

void        gtk_widget_queue_clear          (gtkwidget *widget);

внимание

gtk_widget_queue_clear устарела и не должна использоваться во вновь создаваемом коде.

эта функция тоже самое, что и gtk_widget_queue_draw().

deprecated: вместо неё используйте gtk_widget_queue_draw().

gtk_widget_queue_clear_area ()

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

внимание

gtk_widget_queue_clear_area устарела и не должна использоваться во вновь создаваемом коде.

эта функция ничем не отличается от gtk_widget_queue_draw_area(), хотя раньше такое было. теперь она просто вызывает gtk_widget_queue_draw_area(). первоначально gtk_widget_queue_clear_area() заставляла перерисовывать фон для gtk_no_window виджетов, а gtk_widget_queue_draw_area() не делала этого. теперь обе функции гарантируют перерисовку фона.

устарела: вместо неё используйте gtk_widget_queue_draw_area().

gtk_widget_queue_draw_area ()

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

аннулирует прямоугольную область виджета widget определённую x, y, width и height вызывая gdk_window_invalidate_rect() для окна виджета и для всех его дочерних окон. когда основной цикл бездействует (например после обработки текущемго пакета событий), окно получает событие экспозиции для объединения всех частей которые были аннулированы.

обычно эта функция используется при реализации виджета. вы также можете использовать её, или непосредственно gdk_window_invalidate_rect(), для перерисовки gtkdrawingarea или некоторой её части.

часто вы можете просто вызвать gdk_window_invalidate_rect() или gdk_window_invalidate_region() вместо этой функции. эти функции аннулируют только одно окно, вместо виджета со всеми дочерними окнами.

преимущество добавления аннулированного участка вместо простого перерисовывания заключается в эффективности; использование аннулированного участка гарантирует перерисовку только один раз.

gtk_widget_reset_shapes ()

void        gtk_widget_reset_shapes         (gtkwidget *widget);

рекурсивно сбрасывает форму виджета и его потомков.

gtk_widget_set_app_paintable ()

void        gtk_widget_set_app_paintable    (gtkwidget *widget,
                                             gboolean app_paintable);

устанавливает подразумевает ли приложение отображение виджета при обработке ::expose-event.

это подсказка для виджета и не затрагивает поведение ядра gtk+; большинство виджетов полностью игнорируют этот флажок. для виджетов которые обращают внимание на флажок, таких как gtkeventbox и gtkwindow, эффектом будет подавление тематического отображения по умолчанию фона виджета. (дочерние виджеты все же будут отображаться.) приложение полностью отвечает за отображение фона виджета.

помните, фон отображается в течении отображения виджета. если это не устраивает (например потому, что вы хотите создать прозрачное окно используя rgba визуализацию), вы можете поработать над этим выполнив:

 gtk_widget_realize (window);
 gdk_window_set_back_pixmap (window->window, null, false);
 gtk_widget_show (window);

gtk_widget_set_double_buffered ()

void        gtk_widget_set_double_buffered  (gtkwidget *widget,
                                             gboolean double_buffered);

по умолчанию виджет дважды буферизуются (double buffered); вы можете использовать эту функцию для отключения буферизации. "double buffered" просто означает что gdk_window_begin_paint_region() и gdk_window_end_paint() вызываются автоматически при получении события экспозиции виджета. gdk_window_begin_paint() сбрасывает все отрисованное в буфер, а gdk_window_end_paint() отображает буфер на экран. в результате пользователи видят обновление окна в один приём и не видят прорисовку отдельных графических примитивов.

проще говоря, виджет двойной буферизации не мерцает, поэтому вы должны использовать эту функцию только если уверены в том что делаете.

помните: если вы выключите двойную буферизацию, вы должны обрабатывать экспонирующие события, так как даже очистка фона или изображения не произойдут автоматически (как это происходит при выполнении gdk_window_begin_paint()).

gtk_widget_set_redraw_on_allocate ()

void        gtk_widget_set_redraw_on_allocate
                                            (gtkwidget *widget,
                                             gboolean redraw_on_allocate);

устанавливает перерисовывается ли виджет полностью когда его распределённый размер изменяется. по умолчанию установлено true и весь виджет перерисовывается при каждом изменении его размера.

помните, для виджета без окна no_window установка этого флажка в false отключит все распределяемое изменение размера: виджет не будет перерисовываться даже если его позиция изменится; это позволяет контейнерам ничего не отрисовывать избегая лишних аннулированний. если вы установите этот флаг для виджета без окна no_window который отображается widget->window, вы отвечаете за аннулирование и старого и нового распределения виджета, когда виджет перемещается и отвечаете за аннулирование участка когда виджет увеличивает размер.

gtk_widget_set_composite_name ()

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

устанавливает составное имя виджета. виджет должен быть составным дочерним виджетом своего родителя; смотрите gtk_widget_push_composite_child().

gtk_widget_set_scroll_adjustments ()

gboolean    gtk_widget_set_scroll_adjustments
                                            (gtkwidget *widget,
                                             gtkadjustment *hadjustment,
                                             gtkadjustment *vadjustment);

для виджетов поддерживающих прокручивание, устанавливает регуляторы прокрутки и возвращает true. для виджетов которые не поддерживают прокручивание, ничего не делает и возвращает false. виджеты не поддерживающие прокручивание можно поместить в gtkviewport, который поддерживает прокручивание.

gtk_widget_mnemonic_activate ()

gboolean    gtk_widget_mnemonic_activate    (gtkwidget *widget,
                                             gboolean group_cycling);

gtk_widget_class_install_style_property ()

void        gtk_widget_class_install_style_property
                                            (gtkwidgetclass *klass,
                                             gparamspec *pspec);

устанавливает свойство стиля для класса виджета. анализатор свойства стиля определяется значением типа pspec.

gtk_widget_class_install_style_property_parser ()

void        gtk_widget_class_install_style_property_parser
                                            (gtkwidgetclass *klass,
                                             gparamspec *pspec,
                                             gtkrcpropertyparser parser);

устанавливает свойство стиля класса виджета.

gtk_widget_class_find_style_property ()

gparamspec* gtk_widget_class_find_style_property
                                            (gtkwidgetclass *klass,
                                             const gchar *property_name);

находит свойство стиля класса виджета по имени.

начиная с версии 2.2

gtk_widget_class_list_style_properties ()

gparamspec** gtk_widget_class_list_style_properties
                                            (gtkwidgetclass *klass,
                                             guint *n_properties);

возвращает все свойства стиля класса виджета.

начиная с версии 2.2

gtk_widget_region_intersect ()

gdkregion*  gtk_widget_region_intersect     (gtkwidget *widget,
                                             gdkregion *region);

рассчитывает пересечение области виджета widget's и region, возвращая пересечение. результат может быть пустым, используйте gdk_region_empty() для проверки.

gtk_widget_send_expose ()

gint        gtk_widget_send_expose          (gtkwidget *widget,
                                             gdkevent *event);

очень редко используемая функция. используется для создания сигналов экспонирующего события для виджета. обычно не используется не посредственно. единственная ситуация использования заключается в распространении экспонирующего события на дочерние виджеты no_window, обычно выполняется с помощью gtk_container_propagate_expose().

если вам нужно заставить область окна перерисоваться, используйте gdk_window_invalidate_rect() или gdk_window_invalidate_region(). чтобы выполнить перерисовку немедленно, следом за этим вызовом вызовите gdk_window_process_updates().

gtk_widget_style_get ()

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

определяет значения множества свойств стиля widget.

gtk_widget_style_get_property ()

void        gtk_widget_style_get_property   (gtkwidget *widget,
                                             const gchar *property_name,
                                             gvalue *value);

определяет значение свойства стиля widget.

gtk_widget_style_get_valist ()

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

вариант gtk_widget_style_get() без массива аргументов. в первую очередь используется языковыми привязками.

gtk_widget_get_accessible ()

atkobject*  gtk_widget_get_accessible       (gtkwidget *widget);

возвращает объект доступа который описывает виджет вспомогательной технологии.

если нет загруженной библиотеки доступа (то есть библиотека atk реализации не загружена через gtk_modules или через другую библиотеку приложения, такую как libgnome), то в этом случае atkobject может быть пустой командой. аналогично, если нет определённого класса atkobject реализации доступности для образца виджета в запросе, он унаследует atkobject реализацию из первого предка класса для которого такая реализация определена.

документация по библиотеке atk содержит больше информации об объектах доступности и их использовании.

gtk_widget_child_focus ()

gboolean    gtk_widget_child_focus          (gtkwidget *widget,
                                             gtkdirectiontype direction);

эта функция используется при выборочной реализации виджета; если вы пишите приложение, вы могли бы использовать gtk_widget_grab_focus() для перемещения фокуса в определённый виджет, а gtk_container_set_focus_chain() для изменения фокуса методом табуляции (нажатием клавиши tab). поэтому вы можете изучить эти функции вместо этой.

gtk_widget_child_focus() вызывается контейнером при пользовательских перемещениях в пределах окна используя горячие клавиши клавиатуры. direction указывает направление движения (вверх(up), вниз(down), влево(left), в право(right), tab вперёд, tab назад). gtk_widget_child_focus() вызывает сигнал "focus" на gtkwidget; виджеты отменяю обработчик по умолчанию для этого сигнала, чтобы реализовать соответствующее поведение фокуса.

обработчик "focus" по умолчанию для виджета, должен возвращать true если движение в direction оставило фокус в том же виджете, а false если движение в direction переместило фокус за пределы виджета. если возвращено true, виджеты обычно вызывают gtk_widget_grab_focus() для соответственного размещения фокуса; если возвращено false, они не меняют текущемго расположения фокуса.

эта функция заменяет gtk_container_focus() из gtk+ 1.2. в которой необходимо было проверять что дочерний виджет был видим, чувствителен и сфокусирован перед вызовом gtk_container_focus(). gtk_widget_child_focus() возвращает false если виджет в текущий момент не в фокусе, поэтому отпала необходимость в вышеперечисленных проверках.

gtk_widget_child_notify ()

void        gtk_widget_child_notify         (gtkwidget *widget,
                                             const gchar *child_property);

издаёт сигнал "child-notify" для child property child_property на widget.

это аналог g_object_notify() для дочерних свойств.

gtk_widget_freeze_child_notify ()

void        gtk_widget_freeze_child_notify  (gtkwidget *widget);

останавливает распространение сигнала "child-notify" на widget. сигнал находится в очереди пока вызывается gtk_widget_thaw_child_notify() для widget.

это аналог g_object_freeze_notify() для дочернего свойства.

gtk_widget_get_child_visible ()

gboolean    gtk_widget_get_child_visible    (gtkwidget *widget);

определяет значение установленное с помощью gtk_widget_set_child_visible(). если вы чувствуете потребность в этой функции, ваш код вероятно нужно реорганизовать.

эта функция полезна только для реализации контейнеров и никогда не должна вызываться приложением.

gtk_widget_get_parent ()

gtkwidget*  gtk_widget_get_parent           (gtkwidget *widget);

возвращает родительский контейнер для widget.

gtk_widget_get_settings ()

gtksettings* gtk_widget_get_settings        (gtkwidget *widget);

определяет объект настроек содержащий настройки (общие настройки свойств, информацию rc файла и т.д.) используемые для этого виджета.

помните, эта функция вызывается только когда gtkwidget прикреплён к верхнему уровню, так как объект настройки определяется для определённого gdkscreen.

gtk_widget_get_clipboard ()

gtkclipboard* gtk_widget_get_clipboard      (gtkwidget *widget,
                                             gdkatom selection);

возвращает объект буфера обмена для выделения полученного с использованием widget. widget должен иметь gdkdisplay связанный с ним, то есть должен быть прикреплён к окну верхнего уровня.

начиная с версии 2.2

gtk_widget_get_display ()

gdkdisplay* gtk_widget_get_display          (gtkwidget *widget);

определяет gdkdisplay для окна верхнего уровня связанного с этим виджетом. эта функция может быть вызвана только после добавления виджета к верхней иерархии виджетов gtkwindow.

в основном, вы должны создавать только ресурсы определяющие отображение виджета при реализации и должны освобождать эти ресурсы когда реализация виджета аннулирована (unrealized).

начиная с версии 2.2

gtk_widget_get_root_window ()

gdkwindow*  gtk_widget_get_root_window      (gtkwidget *widget);

определяет основное окно в котором распределён данный виджет. эта функция может быть вызвана только после добавления виджета к верхней иерархии виджетов gtkwindow.

основное окно полезно для таких целей как создание всплывающего gdkwindow связанного с окном. в основном, вы должны создавать только ресурсы определяющие отображение виджета при реализации и должны освобождать эти ресурсы когда реализация виджета аннулирована (unrealized).

начиная с версии 2.2

gtk_widget_get_screen ()

gdkscreen*  gtk_widget_get_screen           (gtkwidget *widget);

определяет gdkscreen из окна верхнего уровня связанного с этим виджетом. эта функция может быть вызвана только после добавления виджета к верхней иерархии виджетов gtkwindow.

в основном, вы должны создавать только ресурсы определяющие отображение виджета при реализации и должны освобождать эти ресурсы когда реализация виджета аннулирована (unrealized).

начиная с версии 2.2

gtk_widget_has_screen ()

gboolean    gtk_widget_has_screen           (gtkwidget *widget);

проверяет есть ли gdkscreen связанный с этим виджетом. все виджеты верхнего уровня имеют связанный с ними дисплей и все виджеты добавляются в иерархию окна верхнего уровня.

начиная с версии 2.2

gtk_widget_get_size_request ()

void        gtk_widget_get_size_request     (gtkwidget *widget,
                                             gint *width,
                                             gint *height);

определяет запрашиваемый размер который явно установлен для виджета с помощью gtk_widget_set_size_request(). значение -1 сохраняемое в width или height указывает что размер не был явно установлен и вместо него будет использована обычная реквизиция виджета. смотрите gtk_widget_set_size_request(). для определения размера фактически используемого виджетом, вызовите gtk_widget_size_request() вместо этой функции.

gtk_widget_pop_visual()

#define gtk_widget_pop_visual()               ((void) 0)

внимание

gtk_widget_pop_visual устарела и не должна использоваться во вновь создаваемом коде.

эта функция устарела: она ничего не делает..

gtk_widget_push_visual()

#define gtk_widget_push_visual(visual)        ((void) 0)

внимание

gtk_widget_push_visual устарела и не должна использоваться во вновь создаваемом коде.

эта функция устарела: она ничего не делает..

gtk_widget_set_child_visible ()

void        gtk_widget_set_child_visible    (gtkwidget *widget,
                                             gboolean is_visible);

устанавливает должен ли widget отображаться вместе со своим родителем и должен ли widget показываться с помощью gtk_widget_show().

дочерняя видимость может быть установлена для виджета перед добавлением его в контейнер с помощью gtk_widget_set_parent(), избегая отображения дочерних виджетов раньше необходимого. однако это значение сбрасывается в состояние по умолчанию true, когда виджет удаляется из контейнера.

помните, изменение дочерней видимости виджета не влияет на структуру изменения размера виджета. большинство времени, размер виджета рассчитывается из всех видимых дочерних виджетов, отображены они или нет. если дело обстоит не так, контейнер может обработать изменение размера самостоятельно.

эта функция полезна только для реализации контейнеров и никогда не должна вызываться приложениями.

gtk_widget_set_default_visual()

#define gtk_widget_set_default_visual(visual) ((void) 0)

внимание

gtk_widget_set_default_visual устарела и не должна использоваться во вновь создаваемом коде.

эта функция устарела: она ничего не делает.

gtk_widget_set_size_request ()

void        gtk_widget_set_size_request     (gtkwidget *widget,
                                             gint width,
                                             gint height);

устанавливает минимальный размер виджета; то есть, запрашиваемый размер виджета будет width и height. вы можете использовать эту функцию чтобы заставить виджет иметь больший или меньший размер чем обычно.

в большинстве случаев, gtk_window_set_default_size() лучше чем эта функция для окна верхнего уровня; установка размера по умолчанию позволит пользователям сокращать окно. установка запрашиваемого размера заставит окно быть по крайней мере того же размера как запрашиваемый. имея дело с размерами окна, функция gtk_window_set_geometry_hints() также может быть полезной.

помните о внутренней опасности установки фиксированных размеров – темы, перевод на другие языки, разные шрифты и действия пользователя могут соответственно изменить размер данного виджета. так как не возможно подобрать жесткий размер который будет всегда корректен.

запрашиваемый размер виджета – это наименьший размер который виджет может принять при правильном отображении и функционировании. однако в некоторых не обычных случаях виджет может быть распределён в меньший чем запрашиваемый размер, а в большинстве случаев может распределяться больше пространства чем запрошено.

если запрос размера в данном направлении -1 (не установлен), то используется размер "natural".

фактически виджеты не могут быть меньше чем 1 на 1, но вы можете поместить 0,0 в эту функцию, что значит "наименьший из возможных."

gtk_widget_set_visual()

#define gtk_widget_set_visual(widget,visual)  ((void) 0)

внимание

gtk_widget_set_visual устарела и не должна использоваться во вновь создаваемом коде.

эта функция устарела: она ничего не делает.

gtk_widget_thaw_child_notify ()

void        gtk_widget_thaw_child_notify    (gtkwidget *widget);

отменяет эффект предыдущего вызова gtk_widget_freeze_child_notify(). в этом случае все сигналы "child-notify" в очереди для widget будут изданы.

gtk_widget_set_no_show_all ()

void        gtk_widget_set_no_show_all      (gtkwidget *widget,
                                             gboolean no_show_all);

устанавливает свойство "no_show_all", которое определяет влияют ли вызовы gtk_widget_show_all() и gtk_widget_hide_all() на этот виджет.

это главным образом полезно для построения иерархии виджета с внешним управлением видимости, смотрите gtkuimanager.

начиная с версии 2.4

gtk_widget_get_no_show_all ()

gboolean    gtk_widget_get_no_show_all      (gtkwidget *widget);

возвращает текущеме значение свойства "no_show_all", которое определяет влияют ли вызовы gtk_widget_show_all() и gtk_widget_hide_all() на виджет.

начиная с версии 2.4

gtk_widget_list_mnemonic_labels ()

glist*      gtk_widget_list_mnemonic_labels (gtkwidget *widget);

возвращает список виджетов, обычно ярлыков, для которых этот виджет мнемоник (смотрите например, gtk_label_set_mnemonic_widget()).

на виджеты в списке нет отдельных ссылок. если вы хотите выполнить итерацию через список и выполнить действия вызывающие callback-функции разрушающие виджеты, вы сначала должны вызвать g_list_foreach (result, (gfunc)g_object_ref, null), а затем затем снять все ссылки с виджетов после использования.

начиная с версии 2.4

gtk_widget_add_mnemonic_label ()

void        gtk_widget_add_mnemonic_label   (gtkwidget *widget,
                                             gtkwidget *label);

добавляет виджет в список мнемонических ярлыков для этого виджета. (смотрите gtk_widget_list_mnemonic_labels()). помните, список мнемонических ярлыков очищается когда разрушается виджет, поэтому вызывающая программа должна убедиться в обновлении внутреннего состояния, используя подключение сигнала ::destroy или уведомление.

начиная с версии 2.4

gtk_widget_remove_mnemonic_label ()

void        gtk_widget_remove_mnemonic_label
                                            (gtkwidget *widget,
                                             gtkwidget *label);

удаляет виджет из списка мнемонических ярлыков для данного виджета. (смотрите gtk_widget_list_mnemonic_labels()). виджет должен быть предварительно добавлен в список с помощью gtk_widget_add_mnemonic_label().

начиная с версии 2.4

gtk_widget_get_action ()

gtkaction*  gtk_widget_get_action           (gtkwidget *widget);

возвращает gtkaction для widget. смотрите также gtk_action_get_proxies().

начиная с версии 2.10

gtk_widget_is_composited ()

gboolean    gtk_widget_is_composited        (gtkwidget *widget);

может ли widget положиться на правильное отображение альфа канала. в x11 эта функция возвращает выполняется ли композитное управление (compositing manager) для отображения widget's.

начиная с версии 2.10

gtk_requisition_copy ()

gtkrequisition* gtk_requisition_copy        (const gtkrequisition *requisition);

копирует gtkrequisition.

gtk_requisition_free ()

void        gtk_requisition_free            (gtkrequisition *requisition);

освобождает gtkrequisition.

детали свойств

свойство "app-paintable"

  "app-paintable"        gboolean              : read / write

будет ли приложение непосредственно рисовать на виджете.

значение по умолчанию: false

свойство "can-default"

  "can-default"          gboolean              : read / write

может ли виджет быть виджетом по умолчанию.

значение по умолчанию: false

свойство "can-focus"

  "can-focus"            gboolean              : read / write

может ли виджет фокусироваться для ввода.

значение по умолчанию: false

свойство "composite-child"

  "composite-child"      gboolean              : read

является ли виджет частью сложного виджета.

значение по умолчанию: false

свойство "events"

  "events"               gdkeventmask          : read / write

маска событий которая решает какие gdkevents получает виджет.

значение по умолчанию: gdk_structure_mask

свойство "extension-events"

  "extension-events"     gdkextensionmode      : read / write

маска которая решает какие дополнительные события получает виджет.

значение по умолчанию: gdk_extension_events_none

свойство "has-default"

  "has-default"          gboolean              : read / write

является ли виджет виджетом по умолчанию.

значение по умолчанию: false

свойство "has-focus"

  "has-focus"            gboolean              : read / write

имеет ли виджет фокус ввода.

значение по умолчанию: false

свойство "height-request"

  "height-request"       gint                  : read / write

переписывает запрос высоты виджета, или -1 ели должна использоваться натуральная реквизиция.

допустимые значения: >= -1

значение по умолчанию: -1

свойство "is-focus"

  "is-focus"             gboolean              : read / write

является ли виджет сфокусированным внутри верхнего уровня.

значение по умолчанию: false

свойство "name"

  "name"                 gchararray            : read / write

имя виджета.

значение по умолчанию: null

свойство "no-show-all"

  "no-show-all"          gboolean              : read / write

имеет ли влияние gtk_widget_show_all() на виджет.

значение по умолчанию: false

свойство "parent"

  "parent"               gtkcontainer          : read / write

родительский виджет виджета. должен быть контейнерным виджетом.

свойство "receives-default"

  "receives-default"     gboolean              : read / write

если true, виджет получает действие по умолчанию при фокусировании.

значение по умолчанию: false

свойство "sensitive"

  "sensitive"            gboolean              : read / write

реагирует ли виджет на ввод.

значение по умолчанию: true

свойство "style"

  "style"                gtkstyle              : read / write

стиль виджета, который содержит информацию о внешнем виде (цвет и т.д.).

свойство "visible"

  "visible"              gboolean              : read / write

видим ли виджет.

значение по умолчанию: false

свойство "width-request"

  "width-request"        gint                  : read / write

перезаписывает запрашиваемую ширину виджета, или -1 если должна использоваться натуральная реквизиция.

допустимые значения: >= -1

значение по умолчанию: -1

детали свойств стиля

свойство стиля "cursor-aspect-ratio"

  "cursor-aspect-ratio"  gfloat                : read

соотношение сторон для отображения курсора вставки.

допустимые значения: [0,1]

значение по умолчанию: 0.04

свойство стиля "cursor-color"

  "cursor-color"         gdkcolor              : read

цвет для отображения курсора вставки.

свойство стиля "draw-border"

  "draw-border"          gtkborder             : read

свойство "draw-border" определяет размер внешней области для отображения виджета.

начиная с версии 2.8

свойство стиля "focus-line-pattern"

  "focus-line-pattern"   gchararray            : read

шаблон линии для отображения индикатора фокуса.

значение по умолчанию: "\001\001"

свойство стиля "focus-line-width"

  "focus-line-width"     gint                  : read

ширина, в пикселах, индикаторной линии фокуса.

допустимые значения: >= 0

значение по умолчанию: 1

свойство стиля "focus-padding"

  "focus-padding"        gint                  : read

ширина, в пикселах, между индикатором фокуса и контейнером виджета.

допустимые значения: >= 0

значение по умолчанию: 1

свойство стиля "interior-focus"

  "interior-focus"       gboolean              : read

отображается ли индикатор фокуса внутри виджета.

значение по умолчанию: true

свойство стиля "link-color"

  "link-color"           gdkcolor              : read

свойство "link-color" определяет цвет не посещенной ссылки.

начиная с версии 2.10

свойство стиля "scroll-arrow-hlength"

  "scroll-arrow-hlength" gint                  : read

свойство "scroll-arrow-hlength" определяет длину горизонтальных кнопок прокручивания.

допустимые значения: >= 1

значение по умолчанию: 16

начиная с версии 2.10

свойство стиля "scroll-arrow-vlength"

  "scroll-arrow-vlength" gint                  : read

свойство "scroll-arrow-vlength" определяет длину вертикальных стрелок прокручивания.

допустимые значения: >= 1

значение по умолчанию: 16

начиная с версии 2.10

свойство стиля "secondary-cursor-color"

  "secondary-cursor-color" gdkcolor              : read

цвет для отображения вторичного выделения курсором когда редактируется смешанный right-to-left и left-to-right текст.

свойство стиля "separator-height"

  "separator-height"     gint                  : read

свойство "separator-height" определяет высоту разделителей. это свойство имеет значение только если "wide-separators" равно true.

допустимые значения: >= 0

значение по умолчанию: 0

начиная с версии 2.10

свойство стиля "separator-width"

  "separator-width"      gint                  : read

свойство "separator-width" определяет ширину разделителя. это свойство имеет значение только если "wide-separators" равно true.

допустимые значения: >= 0

значение по умолчанию: 0

начиная с версии 2.10

свойство стиля "visited-link-color"

  "visited-link-color"   gdkcolor              : read

свойство "visited-link-color" определяет цвет посещённой ссылки.

начиная с версии 2.10

свойство стиля "wide-separators"

  "wide-separators"      gboolean              : read

свойство "wide-separators" определяет могут ли конфигурироваться разделители и должны ли отображаться используя контейнер вместо линии.

значение по умолчанию: false

начиная с версии 2.10

детали сигналов

сигнал "accel-closures-changed"

void        user_function                  (gtkwidget *widget,
                                            gpointer   user_data)      : 

сигнал "button-press-event"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkeventbutton *event,
                                            gpointer        user_data)      : run last

сигнал "button-release-event"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkeventbutton *event,
                                            gpointer        user_data)      : run last

сигнал "can-activate-accel"

gboolean    user_function                  (gtkwidget *widget,
                                            guint      signal_id,
                                            gpointer   user_data)      : run last

определяет может ли акселератор, активизирующий сигнал идентифицируемый signal_id, быть активирован в данный момент. этот сигнал позволяет приложениям и производным виджетам отменять обработчик по умолчанию для gtkwidget для определения может ли акселератор быть активизирован.

сигнал "child-notify"

void        user_function                  (gtkwidget  *widget,
                                            gparamspec *pspec,
                                            gpointer    user_data)      : run first / no recursion / has details / no hooks

сигнал ::child-notify издаётся для каждого изменения дочернего свойства объекта. деталь сигнала содержит имя свойства.

сигнал "client-event"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkeventclient *event,
                                            gpointer        user_data)      : run last

сигнал "composited-changed"

void        user_function                  (gtkwidget *widget,
                                            gpointer   user_data)      : run last / action

сигнал "configure-event"

gboolean    user_function                  (gtkwidget         *widget,
                                            gdkeventconfigure *event,
                                            gpointer           user_data)      : run last

сигнал "delete-event"

gboolean    user_function                  (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last

сигнал ::delete-event издаётся когда пользователь закрывает окно верхнего уровня. обработчик по умолчанию для этого сигнала уничтожает окно. подключение gtk_widget_hide_on_delete() для сигнала заставит окно скрываться а не закрываться, поэтому его можно будет позже показать снова.

сигнал "destroy-event"

gboolean    user_function                  (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last

сигнал ::destroy-event издаётся когда gdkwindow уничтожен. вы редко получаете этот сигнал, потому что большинство виджетов самостоятельно отключаются от их окна перед их разрушением, таким образом нет виджетов владеющих окном в момент уничтожения.

сигнал "direction-changed"

void        user_function                  (gtkwidget       *widget,
                                            gtktextdirection arg1,
                                            gpointer         user_data)      : run first

сигнал "drag-begin"

void        user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last

сигнал ::drag-begin издаётся на источнике перетаскивания когда начинается процесс перетаскивания. обычная причина подключения этого сигнала заключается в том, чтобы установить выбранный значок перетаскивания с помощью gtk_drag_source_set_icon().

сигнал "drag-data-delete"

void        user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last

сигнал ::drag-data-delete издаётся на источнике перетаскивания когда действие перетаскивания gdk_action_move полностью выполнено. обработчик сигнала отвечает за удаление перемещенных данных после завершения операции. что означает "удаление", зависит от содержимого операции перетаскивания.

сигнал "drag-data-get"

void        user_function                  (gtkwidget        *widget,
                                            gdkdragcontext   *drag_context,
                                            gtkselectiondata *data,
                                            guint             info,
                                            guint             time,
                                            gpointer          user_data)         : run last

сигнал ::drag-data-get издаётся на источнике перетаскивания когда адресат перетаскивания запрашивает данные перетаскивания. это обязывает обработчик сигнала заполнить data данными в формате который указан info. смотрите gtk_selection_data_set() и gtk_selection_data_set_text().

сигнал "drag-data-received"

void        user_function                  (gtkwidget        *widget,
                                            gdkdragcontext   *drag_context,
                                            gint              x,
                                            gint              y,
                                            gtkselectiondata *data,
                                            guint             info,
                                            guint             time,
                                            gpointer          user_data)         : run last

сигнал ::drag-data-received издаётся на адресате перетаскивания когда были получены перетаскиваемые данные. если данные были получены для определения будет ли принято перетаскивание, обработчик вызовет gdk_drag_status() и не закончит перетаскивание. если данные были получены в ответ на сигнал ::drag-drop signal (и это последний адрес для получения), обработчик для этого сигнала после обработки данных вызовет gtk_drag_finish(), установив параметр success в зависимости от того были ли данные обработаны полностью.

обработчик может изучить и изменить drag_context->action перед вызовом gtk_drag_finish(), например осуществляя gdk_action_ask как показано в следующем примере:

void  
drag_data_received (gtkwidget          *widget,
                    gdkdragcontext     *drag_context,
                    gint                x,
                    gint                y,
                    gtkselectiondata   *data,
                    guint               info,
                    guint               time)
{
  if ((data->length >= 0) && (data->format == 8))
    {
      if (drag_context->action == gdk_action_ask) 
        {
          gtkwidget *dialog;
          gint response;
          
          dialog = gtk_message_dialog_new (null,
                                           gtk_dialog_modal | 
                                           gtk_dialog_destroy_with_parent,
                                           gtk_message_info,
                                           gtk_buttons_yes_no,
                                           "move the data ?\n");
          response = gtk_dialog_run (gtk_dialog (dialog));
          gtk_widget_destroy (dialog);
            
          if (response == gtk_response_yes)
            drag_context->action = gdk_action_move;
          else
            drag_context->action = gdk_action_copy;
         }
         
      gtk_drag_finish (drag_context, true, false, time);
      return;
    }
      
   gtk_drag_finish (drag_context, false, false, time);
 }

сигнал "drag-drop"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gint            x,
                                            gint            y,
                                            guint           time,
                                            gpointer        user_data)         : run last

сигнал ::drag-drop издаётся на адресате перетаскивания когда пользователь перетащил данные на виджет. обработчик сигнала должен определять находится ли курсор в зоне адресата перетаскивания или нет. если он не в зоне адресата перетаскивания, возвращается false и никакой дальнейшей обработки не происходит. иначе, обработчик возвращает true. в этом случае, обработчик должен убедиться что gtk_drag_finish() вызвана, для того чтобы источник знал что перетаскивание выполнено. вызов gtk_drag_finish() может выполняться или непосредственно, или в обработчике ::drag-data-received который вызывается gtk_drag_get_data() для получения данных для одного или более поддерживаемых адресатов.

сигнал "drag-end"

void        user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gpointer        user_data)         : run last

сигнал ::drag-end издаётся на источнике перетаскивания когда перетаскивание завершено. обычно сигнал подключается для отмены действий выполненных в ::drag-begin.

сигнал "drag-leave"

void        user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            guint           time,
                                            gpointer        user_data)         : run last

сигнал ::drag-leave издаётся на адресате перетаскивания когда курсор покидает виджет. обычное применение этого сигнала – отмена действия ::drag-motion, например отмена подсвечивания с помощью gtk_drag_unhighlight()

сигнал "drag-motion"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkdragcontext *drag_context,
                                            gint            x,
                                            gint            y,
                                            guint           time,
                                            gpointer        user_data)         : run last

сигнал ::drag-motion издаётся на адресате перетаскивания когда пользователь перемещает курсор над виджетом в течении перетаскивания. обработчик сигнала должен определять находится ли курсор в зоне адресата перетаскивания или нет. если он не в зоне адресата перетаскивания, возвращается false и дальнейшая обработка прекращается. иначе, возвращается true. в этом случае, обработчик отвечает за обеспечение необходимой информации для отображения пользователю, вызывая gdk_drag_status(). если решение о принятии или отклонении перетаскиваемого не может быть принято исключительно на основе позиции курсора и типа данных, обработчик может изучить перетаскиваемые данные вызвав gtk_drag_get_data() и отложить вызов gdk_drag_status() обработчика ::drag-data-received.

помните, что есть не ::drag-enter сигнал. адресат перетаскивания должен следить получал ли он какие нибудь сигналы ::drag-motion с момента последнего ::drag-leave и если нет, обработать сигнал ::drag-motion как сигнал "входа(enter)". после "входа(enter)", обработчик обычно подсвечивает адресат перетаскивания с помощью gtk_drag_highlight().

 
static void
drag_motion (gtkwidget *widget,
          gdkdragcontext *context,
             gint x,
             gint y,
             guint time)
{
  gdkatom target;
 
  privatedata *private_data = get_private_data (widget);
 
  if (!private_data->drag_highlight) 
   {
     private_data->drag_highlight = 1;
     gtk_drag_highlight (widget);
   }
 
  target = gtk_drag_dest_find_target (widget, context, null);
  if (target == gdk_none)
    gdk_drag_status (context, 0, time);
  else 
   {
     private_data->pending_status = context->suggested_action;
     gtk_drag_get_data (widget, context, target, time);
   }
 
  return true;
}
  
static void
drag_data_received (gtkwidget        *widget,
                    gdkdragcontext   *context,
                    gint              x,
                    gint              y,
                    gtkselectiondata *selection_data,
                    guint             info,
                    guint             time)
{
  privatedata *private_data = get_private_data (widget);
  
  if (private_data->suggested_action) 
   {
     private_data->suggested_action = 0;
     
    /* мы получаем эти данные из запроса в drag_motion,
     * а не из запроса в drag_drop, поэтому мы просто
     * предположили вызов gdk_drag_status(), фактически 
     * не помещая данные.
     */
     str = gtk_selection_data_get_text (selection_data);
     if (!data_is_acceptable (str)) 
       gdk_drag_status (context, 0, time);
     else
       gdk_drag_status (context, private_data->suggested_action, time);
   }
  else
   {
     /* принимаем перетаскивание */
   }
}

сигнал "enter-notify-event"

gboolean    user_function                  (gtkwidget        *widget,
                                            gdkeventcrossing *event,
                                            gpointer          user_data)      : run last

сигнал "event"

gboolean    user_function                  (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last

сигнал "event-after"

void        user_function                  (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : 

сигнал "expose-event"

gboolean    user_function                  (gtkwidget      *widget,
                                            gdkeventexpose *event,
                                            gpointer        user_data)      : run last

сигнал "focus"

gboolean    user_function                  (gtkwidget       *widget,
                                            gtkdirectiontype arg1,
                                            gpointer         user_data)      : run last

сигнал "focus-in-event"

gboolean    user_function                  (gtkwidget     *widget,
                                            gdkeventfocus *event,
                                            gpointer       user_data)      : run last

сигнал "focus-out-event"

gboolean    user_function                  (gtkwidget     *widget,
                                            gdkeventfocus *event,
                                            gpointer       user_data)      : run last

сигнал "grab-broken-event"

gboolean    user_function                  (gtkwidget *widget,
                                            gdkevent  *event,
                                            gpointer   user_data)      : run last

издаётся когда захват фокуса указателя или клавиатуры на окне widget прерван.

в x11, это происходит когда захваченное окно становится не доступно (то есть оно или один из его предков не отображаются), или если некоторое приложение снова перехватило фокус указателя или клавиатуры.