Pileus Git - ~andy/gtk/blob - gtk/gtkwidget.h

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
  28 #error "Only <gtk/gtk.h> can be included directly."
  29 #endif
  30
  31 #ifndef __GTK_WIDGET_H__
  32 #define __GTK_WIDGET_H__
  33
  34 #include <gdk/gdk.h>
  35 #include <gtk/gtkaccelgroup.h>
  36 #include <gtk/gtkadjustment.h>
  37 #include <gtk/gtkstyle.h>
  38 #include <gtk/gtksettings.h>
  39 #include <atk/atk.h>
  40
  41 G_BEGIN_DECLS
  42
  43 /* Kinds of widget-specific help */
  44 typedef enum
  45 {
  46   GTK_WIDGET_HELP_TOOLTIP,
  47   GTK_WIDGET_HELP_WHATS_THIS
  48 } GtkWidgetHelpType;
  49
  50 /* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer.
  51  * Macros for testing whether `widget' or `klass' are of type GTK_TYPE_WIDGET.
  52  */
  53 #define GTK_TYPE_WIDGET                   (gtk_widget_get_type ())
  54 #define GTK_WIDGET(widget)                (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
  55 #define GTK_WIDGET_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
  56 #define GTK_IS_WIDGET(widget)             (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET))
  57 #define GTK_IS_WIDGET_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
  58 #define GTK_WIDGET_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
  59
  60 #define GTK_TYPE_REQUISITION              (gtk_requisition_get_type ())
  61
  62 /* forward declaration to avoid excessive includes (and concurrent includes)
  63  */
  64 typedef struct _GtkRequisition     GtkRequisition;
  65 typedef struct _GtkSelectionData   GtkSelectionData;
  66 typedef struct _GtkWidgetPrivate   GtkWidgetPrivate;
  67 typedef struct _GtkWidgetClass     GtkWidgetClass;
  68 typedef struct _GtkWidgetAuxInfo   GtkWidgetAuxInfo;
  69 typedef struct _GtkClipboard       GtkClipboard;
  70 typedef struct _GtkTooltip         GtkTooltip;
  71 typedef struct _GtkWindow          GtkWindow;
  72
  73
  74 /**
  75  * GtkAllocation:
  76  * @x: the X position of the widget's area relative to its parents allocation.
  77  * @y: the Y position of the widget's area relative to its parents allocation.
  78  * @width: the width of the widget's allocated area.
  79  * @height: the height of the widget's allocated area.
  80  *
  81  * A <structname>GtkAllocation</structname> of a widget represents region which has been allocated to the
  82  * widget by its parent. It is a subregion of its parents allocation. See
  83  * <xref linkend="size-allocation"/> for more information.
  84  */
  85 typedef         GdkRectangle       GtkAllocation;
  86
  87 /**
  88  * GtkCallback:
  89  * @widget: the widget to operate on
  90  * @data: user-supplied data
  91  *
  92  * The type of the callback functions used for e.g. iterating over
  93  * the children of a container, see gtk_container_foreach().
  94  */
  95 typedef void    (*GtkCallback)     (GtkWidget        *widget,
  96                                     gpointer          data);
  97
  98 /**
  99  * GtkRequisition:
 100  * @width: the widget's desired width
 101  * @height: the widget's desired height
 102  *
 103  * A <structname>GtkRequisition</structname> represents the desired size of a widget. See
 104  * <xref linkend="size-requisition"/> for more information.
 105  */
 106 struct _GtkRequisition
 107 {
 108   gint width;
 109   gint height;
 110 };
 111
 112 /* The widget is the base of the tree for displayable objects.
 113  *  (A displayable object is one which takes up some amount
 114  *  of screen real estate). It provides a common base and interface
 115  *  which actual widgets must adhere to.
 116  */
 117 struct _GtkWidget
 118 {
 119   GInitiallyUnowned parent_instance;
 120
 121   GtkWidgetPrivate *priv;
 122 };
 123
 124 /**
 125  * GtkWidgetClass:
 126  * @parent_class: The object class structure needs to be the first
 127  *   element in the widget class structure in order for the class mechanism
 128  *   to work correctly. This allows a GtkWidgetClass pointer to be cast to
 129  *   a GObjectClass pointer.
 130  * @activate_signal: The signal to emit when a widget of this class is
 131  *   activated, gtk_widget_activate() handles the emission.
 132  *   Implementation of this signal is optional.
 133  * @set_scroll_adjustments_signal: This signal is emitted  when a widget of
 134  *   this class is added to a scrolling aware parent,
 135  *   gtk_widget_set_scroll_adjustments() handles the emission.
 136  *   Implementation of this signal is optional.
 137  * @adjust_size_request: Convert an initial size request from a widget's
 138  *   #GtkSizeRequest virtual method implementations into a size request to
 139  *   be used by parent containers in laying out the widget.
 140  *   adjust_size_request adjusts <emphasis>from</emphasis> a child widget's
 141  *   original request <emphasis>to</emphasis> what a parent container should
 142  *   use for layout. The @for_size argument will be -1 if the request should
 143  *   not be for a particular size in the opposing orientation, i.e. if the
 144  *   request is not height-for-width or width-for-height. If @for_size is
 145  *   greater than -1, it is the proposed allocation in the opposing
 146  *   orientation that we need the request for. Implementations of
 147  *   adjust_size_request should chain up to the default implementation,
 148  *   which applies #GtkWidget's margin properties and imposes any values
 149  *   from gtk_widget_set_size_request(). Chaining up should be last,
 150  *   <emphasis>after</emphasis> your subclass adjusts the request, so
 151  *   #GtkWidget can apply constraints and add the margin properly.
 152  * @adjust_size_allocation: Convert an initial size allocation assigned
 153  *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
 154  *   size allocation to be used by the widget. adjust_size_allocation
 155  *   adjusts <emphasis>to</emphasis> a child widget's actual allocation
 156  *   <emphasis>from</emphasis> what a parent container computed for the
 157  *   child. The adjusted allocation must be entirely within the original
 158  *   allocation. In any custom implementation, chain up to the default
 159  *   #GtkWidget implementation of this method, which applies the margin
 160  *   and alignment properties of #GtkWidget. Chain up
 161  *   <emphasis>before</emphasis> performing your own adjustments so your
 162  *   own adjustments remove more allocation after the #GtkWidget base
 163  *   class has already removed margin and alignment.
 164  */
 165 struct _GtkWidgetClass
 166 {
 167   GInitiallyUnownedClass parent_class;
 168
 169   /*< public >*/
 170
 171   guint activate_signal;
 172
 173   guint set_scroll_adjustments_signal;
 174
 175   /*< private >*/
 176
 177   /* seldomly overidden */
 178   void (*dispatch_child_properties_changed) (GtkWidget   *widget,
 179                                              guint        n_pspecs,
 180                                              GParamSpec **pspecs);
 181
 182   /* basics */
 183   void (* destroy)             (GtkWidget        *widget);
 184   void (* show)                (GtkWidget        *widget);
 185   void (* show_all)            (GtkWidget        *widget);
 186   void (* hide)                (GtkWidget        *widget);
 187   void (* hide_all)            (GtkWidget        *widget);
 188   void (* map)                 (GtkWidget        *widget);
 189   void (* unmap)               (GtkWidget        *widget);
 190   void (* realize)             (GtkWidget        *widget);
 191   void (* unrealize)           (GtkWidget        *widget);
 192   void (* size_request)        (GtkWidget        *widget,
 193                                 GtkRequisition   *requisition);
 194   void (* size_allocate)       (GtkWidget        *widget,
 195                                 GtkAllocation    *allocation);
 196   void (* state_changed)       (GtkWidget        *widget,
 197                                 GtkStateType      previous_state);
 198   void (* parent_set)          (GtkWidget        *widget,
 199                                 GtkWidget        *previous_parent);
 200   void (* hierarchy_changed)   (GtkWidget        *widget,
 201                                 GtkWidget        *previous_toplevel);
 202   void (* style_set)           (GtkWidget        *widget,
 203                                 GtkStyle         *previous_style);
 204   void (* direction_changed)   (GtkWidget        *widget,
 205                                 GtkTextDirection  previous_direction);
 206   void (* grab_notify)         (GtkWidget        *widget,
 207                                 gboolean          was_grabbed);
 208   void (* child_notify)        (GtkWidget        *widget,
 209                                 GParamSpec       *pspec);
 210   gboolean (* draw)            (GtkWidget        *widget,
 211                                 cairo_t          *cr);
 212
 213   /* size requests */
 214   GtkSizeRequestMode (* get_request_mode)               (GtkWidget      *widget);
 215
 216   void               (* get_preferred_height)           (GtkWidget       *widget,
 217                                                          gint            *minimum_height,
 218                                                          gint            *natural_height);
 219   void               (* get_preferred_width_for_height) (GtkWidget       *widget,
 220                                                          gint             height,
 221                                                          gint            *minimum_width,
 222                                                          gint            *natural_width);
 223   void               (* get_preferred_width)            (GtkWidget       *widget,
 224                                                          gint            *minimum_width,
 225                                                          gint            *natural_width);
 226   void               (* get_preferred_height_for_width) (GtkWidget       *widget,
 227                                                          gint             width,
 228                                                          gint            *minimum_height,
 229                                                          gint            *natural_height);
 230
 231   /* Mnemonics */
 232   gboolean (* mnemonic_activate) (GtkWidget    *widget,
 233                                   gboolean      group_cycling);
 234
 235   /* explicit focus */
 236   void     (* grab_focus)      (GtkWidget        *widget);
 237   gboolean (* focus)           (GtkWidget        *widget,
 238                                 GtkDirectionType  direction);
 239
 240   /* events */
 241   gboolean (* event)                    (GtkWidget           *widget,
 242                                          GdkEvent            *event);
 243   gboolean (* button_press_event)       (GtkWidget           *widget,
 244                                          GdkEventButton      *event);
 245   gboolean (* button_release_event)     (GtkWidget           *widget,
 246                                          GdkEventButton      *event);
 247   gboolean (* scroll_event)             (GtkWidget           *widget,
 248                                          GdkEventScroll      *event);
 249   gboolean (* motion_notify_event)      (GtkWidget           *widget,
 250                                          GdkEventMotion      *event);
 251   gboolean (* delete_event)             (GtkWidget           *widget,
 252                                          GdkEventAny         *event);
 253   gboolean (* destroy_event)            (GtkWidget           *widget,
 254                                          GdkEventAny         *event);
 255   gboolean (* key_press_event)          (GtkWidget           *widget,
 256                                          GdkEventKey         *event);
 257   gboolean (* key_release_event)        (GtkWidget           *widget,
 258                                          GdkEventKey         *event);
 259   gboolean (* enter_notify_event)       (GtkWidget           *widget,
 260                                          GdkEventCrossing    *event);
 261   gboolean (* leave_notify_event)       (GtkWidget           *widget,
 262                                          GdkEventCrossing    *event);
 263   gboolean (* configure_event)          (GtkWidget           *widget,
 264                                          GdkEventConfigure   *event);
 265   gboolean (* focus_in_event)           (GtkWidget           *widget,
 266                                          GdkEventFocus       *event);
 267   gboolean (* focus_out_event)          (GtkWidget           *widget,
 268                                          GdkEventFocus       *event);
 269   gboolean (* map_event)                (GtkWidget           *widget,
 270                                          GdkEventAny         *event);
 271   gboolean (* unmap_event)              (GtkWidget           *widget,
 272                                          GdkEventAny         *event);
 273   gboolean (* property_notify_event)    (GtkWidget           *widget,
 274                                          GdkEventProperty    *event);
 275   gboolean (* selection_clear_event)    (GtkWidget           *widget,
 276                                          GdkEventSelection   *event);
 277   gboolean (* selection_request_event)  (GtkWidget           *widget,
 278                                          GdkEventSelection   *event);
 279   gboolean (* selection_notify_event)   (GtkWidget           *widget,
 280                                          GdkEventSelection   *event);
 281   gboolean (* proximity_in_event)       (GtkWidget           *widget,
 282                                          GdkEventProximity   *event);
 283   gboolean (* proximity_out_event)      (GtkWidget           *widget,
 284                                          GdkEventProximity   *event);
 285   gboolean (* visibility_notify_event)  (GtkWidget           *widget,
 286                                          GdkEventVisibility  *event);
 287   gboolean (* client_event)             (GtkWidget           *widget,
 288                                          GdkEventClient      *event);
 289   gboolean (* no_expose_event)          (GtkWidget           *widget,
 290                                          GdkEventAny         *event);
 291   gboolean (* window_state_event)       (GtkWidget           *widget,
 292                                          GdkEventWindowState *event);
 293
 294   /* selection */
 295   void (* selection_get)           (GtkWidget          *widget,
 296                                     GtkSelectionData   *selection_data,
 297                                     guint               info,
 298                                     guint               time_);
 299   void (* selection_received)      (GtkWidget          *widget,
 300                                     GtkSelectionData   *selection_data,
 301                                     guint               time_);
 302
 303   /* Source side drag signals */
 304   void (* drag_begin)              (GtkWidget          *widget,
 305                                     GdkDragContext     *context);
 306   void (* drag_end)                (GtkWidget          *widget,
 307                                     GdkDragContext     *context);
 308   void (* drag_data_get)           (GtkWidget          *widget,
 309                                     GdkDragContext     *context,
 310                                     GtkSelectionData   *selection_data,
 311                                     guint               info,
 312                                     guint               time_);
 313   void (* drag_data_delete)        (GtkWidget          *widget,
 314                                     GdkDragContext     *context);
 315
 316   /* Target side drag signals */
 317   void (* drag_leave)              (GtkWidget          *widget,
 318                                     GdkDragContext     *context,
 319                                     guint               time_);
 320   gboolean (* drag_motion)         (GtkWidget          *widget,
 321                                     GdkDragContext     *context,
 322                                     gint                x,
 323                                     gint                y,
 324                                     guint               time_);
 325   gboolean (* drag_drop)           (GtkWidget          *widget,
 326                                     GdkDragContext     *context,
 327                                     gint                x,
 328                                     gint                y,
 329                                     guint               time_);
 330   void (* drag_data_received)      (GtkWidget          *widget,
 331                                     GdkDragContext     *context,
 332                                     gint                x,
 333                                     gint                y,
 334                                     GtkSelectionData   *selection_data,
 335                                     guint               info,
 336                                     guint               time_);
 337
 338   /* Signals used only for keybindings */
 339   gboolean (* popup_menu)          (GtkWidget          *widget);
 340
 341   /* If a widget has multiple tooltips/whatsthis, it should show the
 342    * one for the current focus location, or if that doesn't make
 343    * sense, should cycle through them showing each tip alongside
 344    * whatever piece of the widget it applies to.
 345    */
 346   gboolean (* show_help)           (GtkWidget          *widget,
 347                                     GtkWidgetHelpType   help_type);
 348
 349   /* accessibility support
 350    */
 351   AtkObject*   (*get_accessible)     (GtkWidget *widget);
 352
 353   void         (*screen_changed)     (GtkWidget *widget,
 354                                       GdkScreen *previous_screen);
 355   gboolean     (*can_activate_accel) (GtkWidget *widget,
 356                                       guint      signal_id);
 357
 358   /* Sent when a grab is broken. */
 359   gboolean (*grab_broken_event) (GtkWidget           *widget,
 360                                  GdkEventGrabBroken  *event);
 361
 362   void         (* composited_changed) (GtkWidget *widget);
 363
 364   gboolean     (* query_tooltip)      (GtkWidget  *widget,
 365                                        gint        x,
 366                                        gint        y,
 367                                        gboolean    keyboard_tooltip,
 368                                        GtkTooltip *tooltip);
 369
 370   /*< public >*/
 371
 372   void         (* adjust_size_request)    (GtkWidget         *widget,
 373                                            GtkOrientation     orientation,
 374                                            gint               for_size,
 375                                            gint              *minimum_size,
 376                                            gint              *natural_size);
 377   void         (* adjust_size_allocation) (GtkWidget         *widget,
 378                                            GtkAllocation     *allocation);
 379
 380   /*< private >*/
 381
 382   /* Signals without a C default handler class slot:
 383    * gboolean   (*damage_event) (GtkWidget      *widget,
 384    *                             GdkEventExpose *event);
 385    */
 386
 387   /* Padding for future expansion */
 388   void (*_gtk_reserved1) (void);
 389   void (*_gtk_reserved2) (void);
 390   void (*_gtk_reserved3) (void);
 391   void (*_gtk_reserved4) (void);
 392   void (*_gtk_reserved5) (void);
 393   void (*_gtk_reserved6) (void);
 394   void (*_gtk_reserved7) (void);
 395   void (*_gtk_reserved8) (void);
 396 };
 397
 398 struct _GtkWidgetAuxInfo
 399 {
 400   gint width;
 401   gint height;
 402
 403   guint   halign : 4;
 404   guint   valign : 4;
 405
 406   GtkBorder margin;
 407 };
 408
 409 GType      gtk_widget_get_type            (void) G_GNUC_CONST;
 410 GtkWidget* gtk_widget_new                 (GType                type,
 411                                            const gchar         *first_property_name,
 412                                            ...);
 413 void       gtk_widget_destroy             (GtkWidget           *widget);
 414 void       gtk_widget_destroyed           (GtkWidget           *widget,
 415                                            GtkWidget          **widget_pointer);
 416 void       gtk_widget_unparent            (GtkWidget           *widget);
 417 void       gtk_widget_show                (GtkWidget           *widget);
 418 void       gtk_widget_show_now            (GtkWidget           *widget);
 419 void       gtk_widget_hide                (GtkWidget           *widget);
 420 void       gtk_widget_show_all            (GtkWidget           *widget);
 421 void       gtk_widget_hide_all            (GtkWidget           *widget);
 422 void       gtk_widget_set_no_show_all     (GtkWidget           *widget,
 423                                            gboolean             no_show_all);
 424 gboolean   gtk_widget_get_no_show_all     (GtkWidget           *widget);
 425 void       gtk_widget_map                 (GtkWidget           *widget);
 426 void       gtk_widget_unmap               (GtkWidget           *widget);
 427 void       gtk_widget_realize             (GtkWidget           *widget);
 428 void       gtk_widget_unrealize           (GtkWidget           *widget);
 429
 430 void       gtk_widget_draw                (GtkWidget           *widget,
 431                                            cairo_t             *cr);
 432 /* Queuing draws */
 433 void       gtk_widget_queue_draw          (GtkWidget           *widget);
 434 void       gtk_widget_queue_draw_area     (GtkWidget           *widget,
 435                                            gint                 x,
 436                                            gint                 y,
 437                                            gint                 width,
 438                                            gint                 height);
 439 void       gtk_widget_queue_resize        (GtkWidget           *widget);
 440 void       gtk_widget_queue_resize_no_redraw (GtkWidget *widget);
 441 #ifndef GTK_DISABLE_DEPRECATED
 442 void       gtk_widget_size_request        (GtkWidget           *widget,
 443                                            GtkRequisition      *requisition);
 444 #endif
 445 void       gtk_widget_size_allocate       (GtkWidget           *widget,
 446                                            GtkAllocation       *allocation);
 447
 448 GtkSizeRequestMode  gtk_widget_get_request_mode               (GtkWidget      *widget);
 449 void                gtk_widget_get_preferred_width            (GtkWidget      *widget,
 450                                                                gint           *minimum_width,
 451                                                                gint           *natural_width);
 452 void                gtk_widget_get_preferred_height_for_width (GtkWidget      *widget,
 453                                                                gint            width,
 454                                                                gint           *minimum_height,
 455                                                                gint           *natural_height);
 456 void                gtk_widget_get_preferred_height           (GtkWidget      *widget,
 457                                                                gint           *minimum_height,
 458                                                                gint           *natural_height);
 459 void                gtk_widget_get_preferred_width_for_height (GtkWidget      *widget,
 460                                                                gint            height,
 461                                                                gint           *minimum_width,
 462                                                                gint           *natural_width);
 463 void                gtk_widget_get_preferred_size             (GtkWidget      *widget,
 464                                                                GtkRequisition *minimum_size,
 465                                                                GtkRequisition *natural_size);
 466
 467 #ifndef GTK_DISABLE_DEPRECATED
 468 void       gtk_widget_get_child_requisition (GtkWidget         *widget,
 469                                              GtkRequisition    *requisition);
 470 #endif
 471 void       gtk_widget_add_accelerator     (GtkWidget           *widget,
 472                                            const gchar         *accel_signal,
 473                                            GtkAccelGroup       *accel_group,
 474                                            guint                accel_key,
 475                                            GdkModifierType      accel_mods,
 476                                            GtkAccelFlags        accel_flags);
 477 gboolean   gtk_widget_remove_accelerator  (GtkWidget           *widget,
 478                                            GtkAccelGroup       *accel_group,
 479                                            guint                accel_key,
 480                                            GdkModifierType      accel_mods);
 481 void       gtk_widget_set_accel_path      (GtkWidget           *widget,
 482                                            const gchar         *accel_path,
 483                                            GtkAccelGroup       *accel_group);
 484 const gchar* _gtk_widget_get_accel_path   (GtkWidget           *widget,
 485                                            gboolean            *locked);
 486 GList*     gtk_widget_list_accel_closures (GtkWidget           *widget);
 487 gboolean   gtk_widget_can_activate_accel  (GtkWidget           *widget,
 488                                            guint                signal_id);
 489 gboolean   gtk_widget_mnemonic_activate   (GtkWidget           *widget,
 490                                            gboolean             group_cycling);
 491 gboolean   gtk_widget_event               (GtkWidget           *widget,
 492                                            GdkEvent            *event);
 493 gint       gtk_widget_send_expose         (GtkWidget           *widget,
 494                                            GdkEvent            *event);
 495 gboolean   gtk_widget_send_focus_change   (GtkWidget           *widget,
 496                                            GdkEvent            *event);
 497
 498 gboolean   gtk_widget_activate               (GtkWidget        *widget);
 499 gboolean   gtk_widget_set_scroll_adjustments (GtkWidget        *widget,
 500                                               GtkAdjustment    *hadjustment,
 501                                               GtkAdjustment    *vadjustment);
 502
 503 void       gtk_widget_reparent            (GtkWidget           *widget,
 504                                            GtkWidget           *new_parent);
 505 gboolean   gtk_widget_intersect           (GtkWidget           *widget,
 506                                            const GdkRectangle  *area,
 507                                            GdkRectangle        *intersection);
 508 cairo_region_t *gtk_widget_region_intersect       (GtkWidget           *widget,
 509                                            const cairo_region_t     *region);
 510
 511 void    gtk_widget_freeze_child_notify    (GtkWidget           *widget);
 512 void    gtk_widget_child_notify           (GtkWidget           *widget,
 513                                            const gchar         *child_property);
 514 void    gtk_widget_thaw_child_notify      (GtkWidget           *widget);
 515
 516 void       gtk_widget_set_can_focus       (GtkWidget           *widget,
 517                                            gboolean             can_focus);
 518 gboolean   gtk_widget_get_can_focus       (GtkWidget           *widget);
 519 gboolean   gtk_widget_has_focus           (GtkWidget           *widget);
 520 gboolean   gtk_widget_is_focus            (GtkWidget           *widget);
 521 void       gtk_widget_grab_focus          (GtkWidget           *widget);
 522
 523 void       gtk_widget_set_can_default     (GtkWidget           *widget,
 524                                            gboolean             can_default);
 525 gboolean   gtk_widget_get_can_default     (GtkWidget           *widget);
 526 gboolean   gtk_widget_has_default         (GtkWidget           *widget);
 527 void       gtk_widget_grab_default        (GtkWidget           *widget);
 528
 529 void      gtk_widget_set_receives_default (GtkWidget           *widget,
 530                                            gboolean             receives_default);
 531 gboolean  gtk_widget_get_receives_default (GtkWidget           *widget);
 532
 533 gboolean   gtk_widget_has_grab            (GtkWidget           *widget);
 534
 535 gboolean   gtk_widget_device_is_shadowed  (GtkWidget           *widget,
 536                                            GdkDevice           *device);
 537
 538
 539 void                  gtk_widget_set_name               (GtkWidget    *widget,
 540                                                          const gchar  *name);
 541 G_CONST_RETURN gchar* gtk_widget_get_name               (GtkWidget    *widget);
 542
 543 void                  gtk_widget_set_state              (GtkWidget    *widget,
 544                                                          GtkStateType  state);
 545 GtkStateType          gtk_widget_get_state              (GtkWidget    *widget);
 546
 547 void                  gtk_widget_set_sensitive          (GtkWidget    *widget,
 548                                                          gboolean      sensitive);
 549 gboolean              gtk_widget_get_sensitive          (GtkWidget    *widget);
 550 gboolean              gtk_widget_is_sensitive           (GtkWidget    *widget);
 551
 552 void                  gtk_widget_set_visible            (GtkWidget    *widget,
 553                                                          gboolean      visible);
 554 gboolean              gtk_widget_get_visible            (GtkWidget    *widget);
 555
 556 void                  gtk_widget_set_has_window         (GtkWidget    *widget,
 557                                                          gboolean      has_window);
 558 gboolean              gtk_widget_get_has_window         (GtkWidget    *widget);
 559
 560 gboolean              gtk_widget_is_toplevel            (GtkWidget    *widget);
 561 gboolean              gtk_widget_is_drawable            (GtkWidget    *widget);
 562 void                  gtk_widget_set_realized           (GtkWidget    *widget,
 563                                                          gboolean      realized);
 564 gboolean              gtk_widget_get_realized           (GtkWidget    *widget);
 565 void                  gtk_widget_set_mapped             (GtkWidget    *widget,
 566                                                          gboolean      mapped);
 567 gboolean              gtk_widget_get_mapped             (GtkWidget    *widget);
 568
 569 void                  gtk_widget_set_app_paintable      (GtkWidget    *widget,
 570                                                          gboolean      app_paintable);
 571 gboolean              gtk_widget_get_app_paintable      (GtkWidget    *widget);
 572
 573 void                  gtk_widget_set_double_buffered    (GtkWidget    *widget,
 574                                                          gboolean      double_buffered);
 575 gboolean              gtk_widget_get_double_buffered    (GtkWidget    *widget);
 576
 577 void                  gtk_widget_set_redraw_on_allocate (GtkWidget    *widget,
 578                                                          gboolean      redraw_on_allocate);
 579
 580 void                  gtk_widget_set_parent             (GtkWidget    *widget,
 581                                                          GtkWidget    *parent);
 582 GtkWidget           * gtk_widget_get_parent             (GtkWidget    *widget);
 583
 584 void                  gtk_widget_set_parent_window      (GtkWidget    *widget,
 585                                                          GdkWindow    *parent_window);
 586 GdkWindow           * gtk_widget_get_parent_window      (GtkWidget    *widget);
 587
 588 void                  gtk_widget_set_child_visible      (GtkWidget    *widget,
 589                                                          gboolean      is_visible);
 590 gboolean              gtk_widget_get_child_visible      (GtkWidget    *widget);
 591
 592 void                  gtk_widget_set_window             (GtkWidget    *widget,
 593                                                          GdkWindow    *window);
 594 GdkWindow           * gtk_widget_get_window             (GtkWidget    *widget);
 595
 596 int                   gtk_widget_get_allocated_width    (GtkWidget     *widget);
 597 int                   gtk_widget_get_allocated_height   (GtkWidget     *widget);
 598
 599 void                  gtk_widget_get_allocation         (GtkWidget     *widget,
 600                                                          GtkAllocation *allocation);
 601 void                  gtk_widget_set_allocation         (GtkWidget     *widget,
 602                                                          const GtkAllocation *allocation);
 603
 604 void                  gtk_widget_get_requisition        (GtkWidget     *widget,
 605                                                          GtkRequisition *requisition);
 606
 607 gboolean   gtk_widget_child_focus         (GtkWidget           *widget,
 608                                            GtkDirectionType     direction);
 609 gboolean   gtk_widget_keynav_failed       (GtkWidget           *widget,
 610                                            GtkDirectionType     direction);
 611 void       gtk_widget_error_bell          (GtkWidget           *widget);
 612
 613 void       gtk_widget_set_size_request    (GtkWidget           *widget,
 614                                            gint                 width,
 615                                            gint                 height);
 616 void       gtk_widget_get_size_request    (GtkWidget           *widget,
 617                                            gint                *width,
 618                                            gint                *height);
 619 void       gtk_widget_set_events          (GtkWidget           *widget,
 620                                            gint                 events);
 621 void       gtk_widget_add_events          (GtkWidget           *widget,
 622                                            gint                 events);
 623 void       gtk_widget_set_device_events   (GtkWidget           *widget,
 624                                            GdkDevice           *device,
 625                                            GdkEventMask         events);
 626 void       gtk_widget_add_device_events   (GtkWidget           *widget,
 627                                            GdkDevice           *device,
 628                                            GdkEventMask         events);
 629 void       gtk_widget_set_extension_events (GtkWidget           *widget,
 630                                             GdkExtensionMode    mode);
 631
 632 GdkExtensionMode gtk_widget_get_extension_events (GtkWidget     *widget);
 633 GtkWidget*   gtk_widget_get_toplevel    (GtkWidget      *widget);
 634 GtkWidget*   gtk_widget_get_ancestor    (GtkWidget      *widget,
 635                                          GType           widget_type);
 636 GdkVisual*   gtk_widget_get_visual      (GtkWidget      *widget);
 637 void         gtk_widget_set_visual      (GtkWidget      *widget,
 638                                          GdkVisual      *visual);
 639
 640 GdkScreen *   gtk_widget_get_screen      (GtkWidget *widget);
 641 gboolean      gtk_widget_has_screen      (GtkWidget *widget);
 642 GdkDisplay *  gtk_widget_get_display     (GtkWidget *widget);
 643 GdkWindow *   gtk_widget_get_root_window (GtkWidget *widget);
 644 GtkSettings*  gtk_widget_get_settings    (GtkWidget *widget);
 645 GtkClipboard *gtk_widget_get_clipboard   (GtkWidget *widget,
 646                                           GdkAtom    selection);
 647
 648 /* Multidevice support */
 649 gboolean         gtk_widget_get_support_multidevice (GtkWidget      *widget);
 650 void             gtk_widget_set_support_multidevice (GtkWidget      *widget,
 651                                                      gboolean        support_multidevice);
 652
 653 /* Accessibility support */
 654 AtkObject*       gtk_widget_get_accessible               (GtkWidget          *widget);
 655
 656
 657 /* Margin and alignment */
 658 GtkAlign gtk_widget_get_halign        (GtkWidget *widget);
 659 void     gtk_widget_set_halign        (GtkWidget *widget,
 660                                        GtkAlign   align);
 661 GtkAlign gtk_widget_get_valign        (GtkWidget *widget);
 662 void     gtk_widget_set_valign        (GtkWidget *widget,
 663                                        GtkAlign   align);
 664 gint     gtk_widget_get_margin_left   (GtkWidget *widget);
 665 void     gtk_widget_set_margin_left   (GtkWidget *widget,
 666                                        gint       margin);
 667 gint     gtk_widget_get_margin_right  (GtkWidget *widget);
 668 void     gtk_widget_set_margin_right  (GtkWidget *widget,
 669                                        gint       margin);
 670 gint     gtk_widget_get_margin_top    (GtkWidget *widget);
 671 void     gtk_widget_set_margin_top    (GtkWidget *widget,
 672                                        gint       margin);
 673 gint     gtk_widget_get_margin_bottom (GtkWidget *widget);
 674 void     gtk_widget_set_margin_bottom (GtkWidget *widget,
 675                                        gint       margin);
 676
 677
 678 gint         gtk_widget_get_events      (GtkWidget      *widget);
 679 GdkEventMask gtk_widget_get_device_events (GtkWidget    *widget,
 680                                            GdkDevice    *device);
 681 void         gtk_widget_get_pointer     (GtkWidget      *widget,
 682                                          gint           *x,
 683                                          gint           *y);
 684
 685 gboolean     gtk_widget_is_ancestor     (GtkWidget      *widget,
 686                                          GtkWidget      *ancestor);
 687
 688 gboolean     gtk_widget_translate_coordinates (GtkWidget  *src_widget,
 689                                                GtkWidget  *dest_widget,
 690                                                gint        src_x,
 691                                                gint        src_y,
 692                                                gint       *dest_x,
 693                                                gint       *dest_y);
 694
 695 /* Hide widget and return TRUE.
 696  */
 697 gboolean     gtk_widget_hide_on_delete  (GtkWidget      *widget);
 698
 699 /* Widget styles.
 700  */
 701 void        gtk_widget_style_attach       (GtkWidget            *widget);
 702
 703 gboolean    gtk_widget_has_rc_style       (GtkWidget            *widget);
 704 void        gtk_widget_set_style          (GtkWidget            *widget,
 705                                            GtkStyle             *style);
 706 void        gtk_widget_ensure_style       (GtkWidget            *widget);
 707 GtkStyle *  gtk_widget_get_style          (GtkWidget            *widget);
 708
 709 void        gtk_widget_modify_style       (GtkWidget            *widget,
 710                                            GtkRcStyle           *style);
 711 GtkRcStyle *gtk_widget_get_modifier_style (GtkWidget            *widget);
 712 void        gtk_widget_modify_fg          (GtkWidget            *widget,
 713                                            GtkStateType          state,
 714                                            const GdkColor       *color);
 715 void        gtk_widget_modify_bg          (GtkWidget            *widget,
 716                                            GtkStateType          state,
 717                                            const GdkColor       *color);
 718 void        gtk_widget_modify_text        (GtkWidget            *widget,
 719                                            GtkStateType          state,
 720                                            const GdkColor       *color);
 721 void        gtk_widget_modify_base        (GtkWidget            *widget,
 722                                            GtkStateType          state,
 723                                            const GdkColor       *color);
 724 void        gtk_widget_modify_cursor      (GtkWidget            *widget,
 725                                            const GdkColor       *primary,
 726                                            const GdkColor       *secondary);
 727 void        gtk_widget_modify_font        (GtkWidget            *widget,
 728                                            PangoFontDescription *font_desc);
 729 void        gtk_widget_modify_symbolic_color (GtkWidget         *widget,
 730                                            const gchar          *name,
 731                                            const GdkColor       *color);
 732
 733 PangoContext *gtk_widget_create_pango_context (GtkWidget   *widget);
 734 PangoContext *gtk_widget_get_pango_context    (GtkWidget   *widget);
 735 PangoLayout  *gtk_widget_create_pango_layout  (GtkWidget   *widget,
 736                                                const gchar *text);
 737
 738 GdkPixbuf    *gtk_widget_render_icon          (GtkWidget   *widget,
 739                                                const gchar *stock_id,
 740                                                GtkIconSize  size,
 741                                                const gchar *detail);
 742
 743 /* handle composite names for GTK_COMPOSITE_CHILD widgets,
 744  * the returned name is newly allocated.
 745  */
 746 void   gtk_widget_set_composite_name    (GtkWidget      *widget,
 747                                          const gchar    *name);
 748 gchar* gtk_widget_get_composite_name    (GtkWidget      *widget);
 749
 750 /* Descend recursively and set rc-style on all widgets without user styles */
 751 void       gtk_widget_reset_rc_styles   (GtkWidget      *widget);
 752
 753 /* Push/pop pairs, to change default values upon a widget's creation.
 754  * This will override the values that got set by the
 755  * gtk_widget_set_default_* () functions.
 756  */
 757 void         gtk_widget_push_composite_child (void);
 758 void         gtk_widget_pop_composite_child  (void);
 759
 760 /* widget style properties
 761  */
 762 void gtk_widget_class_install_style_property        (GtkWidgetClass     *klass,
 763                                                      GParamSpec         *pspec);
 764 void gtk_widget_class_install_style_property_parser (GtkWidgetClass     *klass,
 765                                                      GParamSpec         *pspec,
 766                                                      GtkRcPropertyParser parser);
 767 GParamSpec*  gtk_widget_class_find_style_property   (GtkWidgetClass     *klass,
 768                                                      const gchar        *property_name);
 769 GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass     *klass,
 770                                                      guint              *n_properties);
 771 void gtk_widget_style_get_property (GtkWidget        *widget,
 772                                     const gchar    *property_name,
 773                                     GValue           *value);
 774 void gtk_widget_style_get_valist   (GtkWidget        *widget,
 775                                     const gchar    *first_property_name,
 776                                     va_list         var_args);
 777 void gtk_widget_style_get          (GtkWidget        *widget,
 778                                     const gchar    *first_property_name,
 779                                     ...) G_GNUC_NULL_TERMINATED;
 780
 781
 782 /* Set certain default values to be used at widget creation time.
 783  */
 784 GtkStyle*    gtk_widget_get_default_style    (void);
 785
 786 /* Functions for setting directionality for widgets
 787  */
 788
 789 void             gtk_widget_set_direction         (GtkWidget        *widget,
 790                                                    GtkTextDirection  dir);
 791 GtkTextDirection gtk_widget_get_direction         (GtkWidget        *widget);
 792
 793 void             gtk_widget_set_default_direction (GtkTextDirection  dir);
 794 GtkTextDirection gtk_widget_get_default_direction (void);
 795
 796 /* Compositing manager functionality */
 797 gboolean gtk_widget_is_composited (GtkWidget *widget);
 798
 799 /* Counterpart to gdk_window_shape_combine_region.
 800  */
 801 void         gtk_widget_shape_combine_region (GtkWidget *widget,
 802                                               cairo_region_t *region);
 803 void         gtk_widget_input_shape_combine_region (GtkWidget *widget,
 804                                                     cairo_region_t *region);
 805
 806 /* internal function */
 807 void         gtk_widget_reset_shapes       (GtkWidget *widget);
 808
 809 /* Compute a widget's path in the form "GtkWindow.MyLabel", and
 810  * return newly alocated strings.
 811  */
 812 void         gtk_widget_path               (GtkWidget *widget,
 813                                             guint     *path_length,
 814                                             gchar    **path,
 815                                             gchar    **path_reversed);
 816 void         gtk_widget_class_path         (GtkWidget *widget,
 817                                             guint     *path_length,
 818                                             gchar    **path,
 819                                             gchar    **path_reversed);
 820
 821 GList* gtk_widget_list_mnemonic_labels  (GtkWidget *widget);
 822 void   gtk_widget_add_mnemonic_label    (GtkWidget *widget,
 823                                          GtkWidget *label);
 824 void   gtk_widget_remove_mnemonic_label (GtkWidget *widget,
 825                                          GtkWidget *label);
 826
 827 void                  gtk_widget_set_tooltip_window    (GtkWidget   *widget,
 828                                                         GtkWindow   *custom_window);
 829 GtkWindow *gtk_widget_get_tooltip_window    (GtkWidget   *widget);
 830 void       gtk_widget_trigger_tooltip_query (GtkWidget   *widget);
 831 void       gtk_widget_set_tooltip_text      (GtkWidget   *widget,
 832                                              const gchar *text);
 833 gchar *    gtk_widget_get_tooltip_text      (GtkWidget   *widget);
 834 void       gtk_widget_set_tooltip_markup    (GtkWidget   *widget,
 835                                              const gchar *markup);
 836 gchar *    gtk_widget_get_tooltip_markup    (GtkWidget   *widget);
 837 void       gtk_widget_set_has_tooltip       (GtkWidget   *widget,
 838                                              gboolean     has_tooltip);
 839 gboolean   gtk_widget_get_has_tooltip       (GtkWidget   *widget);
 840
 841 gboolean   gtk_cairo_should_draw_window     (cairo_t     *cr,
 842                                              GdkWindow   *window);
 843 void       gtk_cairo_transform_to_window    (cairo_t     *cr,
 844                                              GtkWidget   *widget,
 845                                              GdkWindow   *window);
 846
 847 GType           gtk_requisition_get_type (void) G_GNUC_CONST;
 848 GtkRequisition *gtk_requisition_new      (void) G_GNUC_MALLOC;
 849 GtkRequisition *gtk_requisition_copy     (const GtkRequisition *requisition);
 850 void            gtk_requisition_free     (GtkRequisition       *requisition);
 851
 852 GdkEventExpose *  _gtk_cairo_get_event                    (cairo_t      *cr);
 853
 854 void              _gtk_widget_draw_internal               (GtkWidget    *widget,
 855                                                            cairo_t      *cr,
 856                                                            gboolean      clip_to_size);
 857 void              _gtk_widget_set_has_default             (GtkWidget    *widget,
 858                                                            gboolean      has_default);
 859 void              _gtk_widget_set_has_grab                (GtkWidget    *widget,
 860                                                            gboolean      has_grab);
 861 void              _gtk_widget_set_is_toplevel             (GtkWidget    *widget,
 862                                                            gboolean      is_toplevel);
 863
 864 void              _gtk_widget_grab_notify                 (GtkWidget    *widget,
 865                                                            gboolean     was_grabbed);
 866
 867 GtkWidgetAuxInfo *_gtk_widget_get_aux_info                (GtkWidget    *widget,
 868                                                            gboolean      create);
 869 void              _gtk_widget_propagate_hierarchy_changed (GtkWidget    *widget,
 870                                                            GtkWidget    *previous_toplevel);
 871 void              _gtk_widget_propagate_screen_changed    (GtkWidget    *widget,
 872                                                            GdkScreen    *previous_screen);
 873 void              _gtk_widget_propagate_composited_changed (GtkWidget    *widget);
 874
 875 void       _gtk_widget_set_device_window   (GtkWidget      *widget,
 876                                             GdkDevice      *device,
 877                                             GdkWindow      *pointer_window);
 878 GdkWindow *_gtk_widget_get_device_window   (GtkWidget      *widget,
 879                                             GdkDevice      *device);
 880 GList *    _gtk_widget_list_devices        (GtkWidget      *widget);
 881
 882 void       _gtk_widget_synthesize_crossing (GtkWidget      *from,
 883                                             GtkWidget      *to,
 884                                             GdkDevice      *device,
 885                                             GdkCrossingMode mode);
 886
 887 gpointer     _gtk_widget_peek_request_cache (GtkWidget *widget);
 888
 889 void         _gtk_widget_buildable_finish_accelerator (GtkWidget *widget,
 890                                                        GtkWidget *toplevel,
 891                                                        gpointer   user_data);
 892
 893 gboolean     gtk_widget_in_destruction (GtkWidget *widget);
 894
 895 G_END_DECLS
 896
 897 #endif /* __GTK_WIDGET_H__ */