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

   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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  20  * file for a list of people on the GTK+ Team.  See the ChangeLog
  21  * files for a list of changes.  These files are distributed with
  22  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <locale.h>
  30 #include <math.h>
  31
  32 #include <gobject/gvaluecollector.h>
  33 #include <gobject/gobjectnotifyqueue.c>
  34 #include <cairo-gobject.h>
  35
  36 #include "gtkcontainer.h"
  37 #include "gtkaccelmapprivate.h"
  38 #include "gtkclipboard.h"
  39 #include "gtkcssstylepropertyprivate.h"
  40 #include "gtkcssnumbervalueprivate.h"
  41 #include "gtkiconfactory.h"
  42 #include "gtkintl.h"
  43 #include "gtkmarshalers.h"
  44 #include "gtkselectionprivate.h"
  45 #include "gtksettingsprivate.h"
  46 #include "gtksizegroup-private.h"
  47 #include "gtksizerequestcacheprivate.h"
  48 #include "gtkwidget.h"
  49 #include "gtkwidgetprivate.h"
  50 #include "gtkwindowprivate.h"
  51 #include "gtkcontainerprivate.h"
  52 #include "gtkbindings.h"
  53 #include "gtkprivate.h"
  54 #include "gtkaccessible.h"
  55 #include "gtktooltip.h"
  56 #include "gtkinvisible.h"
  57 #include "gtkbuildable.h"
  58 #include "gtkbuilderprivate.h"
  59 #include "gtksizerequest.h"
  60 #include "gtkstylecontextprivate.h"
  61 #include "gtkcssprovider.h"
  62 #include "gtkmodifierstyle.h"
  63 #include "gtkversion.h"
  64 #include "gtkdebug.h"
  65 #include "gtkplug.h"
  66 #include "gtktypebuiltins.h"
  67 #include "a11y/gtkwidgetaccessible.h"
  68
  69 /**
  70  * SECTION:gtkwidget
  71  * @Short_description: Base class for all widgets
  72  * @Title: GtkWidget
  73  *
  74  * GtkWidget is the base class all widgets in GTK+ derive from. It manages the
  75  * widget lifecycle, states and style.
  76  *
  77  * <refsect2 id="geometry-management">
  78  * <title>Height-for-width Geometry Management</title>
  79  * <para>
  80  * GTK+ uses a height-for-width (and width-for-height) geometry management
  81  * system. Height-for-width means that a widget can change how much
  82  * vertical space it needs, depending on the amount of horizontal space
  83  * that it is given (and similar for width-for-height). The most common
  84  * example is a label that reflows to fill up the available width, wraps
  85  * to fewer lines, and therefore needs less height.
  86  *
  87  * Height-for-width geometry management is implemented in GTK+ by way
  88  * of five virtual methods:
  89  * <itemizedlist>
  90  *   <listitem>#GtkWidgetClass.get_request_mode()</listitem>
  91  *   <listitem>#GtkWidgetClass.get_preferred_width()</listitem>
  92  *   <listitem>#GtkWidgetClass.get_preferred_height()</listitem>
  93  *   <listitem>#GtkWidgetClass.get_preferred_height_for_width()</listitem>
  94  *   <listitem>#GtkWidgetClass.get_preferred_width_for_height()</listitem>
  95  * </itemizedlist>
  96  *
  97  * There are some important things to keep in mind when implementing
  98  * height-for-width and when using it in container implementations.
  99  *
 100  * The geometry management system will query a widget hierarchy in
 101  * only one orientation at a time. When widgets are initially queried
 102  * for their minimum sizes it is generally done in two initial passes
 103  * in the #GtkSizeRequestMode chosen by the toplevel.
 104  *
 105  * For example, when queried in the normal
 106  * %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
 107  * First, the default minimum and natural width for each widget
 108  * in the interface will be computed using gtk_widget_get_preferred_width().
 109  * Because the preferred widths for each container depend on the preferred
 110  * widths of their children, this information propagates up the hierarchy,
 111  * and finally a minimum and natural width is determined for the entire
 112  * toplevel. Next, the toplevel will use the minimum width to query for the
 113  * minimum height contextual to that width using
 114  * gtk_widget_get_preferred_height_for_width(), which will also be a highly
 115  * recursive operation. The minimum height for the minimum width is normally
 116  * used to set the minimum size constraint on the toplevel
 117  * (unless gtk_window_set_geometry_hints() is explicitly used instead).
 118  *
 119  * After the toplevel window has initially requested its size in both
 120  * dimensions it can go on to allocate itself a reasonable size (or a size
 121  * previously specified with gtk_window_set_default_size()). During the
 122  * recursive allocation process it's important to note that request cycles
 123  * will be recursively executed while container widgets allocate their children.
 124  * Each container widget, once allocated a size, will go on to first share the
 125  * space in one orientation among its children and then request each child's
 126  * height for its target allocated width or its width for allocated height,
 127  * depending. In this way a #GtkWidget will typically be requested its size
 128  * a number of times before actually being allocated a size. The size a
 129  * widget is finally allocated can of course differ from the size it has
 130  * requested. For this reason, #GtkWidget caches a  small number of results
 131  * to avoid re-querying for the same sizes in one allocation cycle.
 132  *
 133  * See <link linkend="container-geometry-management">GtkContainer's
 134  * geometry management section</link>
 135  * to learn more about how height-for-width allocations are performed
 136  * by container widgets.
 137  *
 138  * If a widget does move content around to intelligently use up the
 139  * allocated size then it must support the request in both
 140  * #GtkSizeRequestModes even if the widget in question only
 141  * trades sizes in a single orientation.
 142  *
 143  * For instance, a #GtkLabel that does height-for-width word wrapping
 144  * will not expect to have #GtkWidgetClass.get_preferred_height() called
 145  * because that call is specific to a width-for-height request. In this
 146  * case the label must return the height required for its own minimum
 147  * possible width. By following this rule any widget that handles
 148  * height-for-width or width-for-height requests will always be allocated
 149  * at least enough space to fit its own content.
 150  *
 151  * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
 152  * generally deals with width-for-height requests, for #GtkWidgetClass.get_preferred_height()
 153  * it will do:
 154  * <programlisting><![CDATA[
 155  * static void
 156  * foo_widget_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height)
 157  * {
 158  *    if (i_am_in_height_for_width_mode)
 159  *      {
 160  *        gint min_width;
 161  *
 162  *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
 163  *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width,
 164  *                                                                      min_height, nat_height);
 165  *      }
 166  *    else
 167  *      {
 168  *         ... some widgets do both. For instance, if a GtkLabel is rotated to 90 degrees
 169  *         it will return the minimum and natural height for the rotated label here.
 170  *      }
 171  * }
 172  * ]]></programlisting>
 173  *
 174  * And in #GtkWidgetClass.get_preferred_width_for_height() it will simply return
 175  * the minimum and natural width:
 176  *
 177  * <programlisting><![CDATA[
 178  * static void
 179  * foo_widget_get_preferred_width_for_height (GtkWidget *widget, gint for_height,
 180  *                                            gint *min_width, gint *nat_width)
 181  * {
 182  *    if (i_am_in_height_for_width_mode)
 183  *      {
 184  *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width);
 185  *      }
 186  *    else
 187  *      {
 188  *         ... again if a widget is sometimes operating in width-for-height mode
 189  *         (like a rotated GtkLabel) it can go ahead and do its real width for
 190  *         height calculation here.
 191  *      }
 192  * }
 193  * ]]></programlisting>
 194  *
 195  * Often a widget needs to get its own request during size request or
 196  * allocation. For example, when computing height it may need to also
 197  * compute width. Or when deciding how to use an allocation, the widget
 198  * may need to know its natural size. In these cases, the widget should
 199  * be careful to call its virtual methods directly, like this:
 200  * <example>
 201  *   <title>Widget calling its own size request method.</title>
 202  *   <programlisting>
 203  * GTK_WIDGET_GET_CLASS(widget)-&gt;get_preferred_width (widget),
 204  *                                  &min, &natural);
 205  *   </programlisting>
 206  * </example>
 207  *
 208  * It will not work to use the wrapper functions, such as
 209  * gtk_widget_get_preferred_width() inside your own size request
 210  * implementation. These return a request adjusted by #GtkSizeGroup
 211  * and by the #GtkWidgetClass.adjust_size_request() virtual method. If a
 212  * widget used the wrappers inside its virtual method implementations,
 213  * then the adjustments (such as widget margins) would be applied
 214  * twice. GTK+ therefore does not allow this and will warn if you try
 215  * to do it.
 216  *
 217  * Of course if you are getting the size request for
 218  * <emphasis>another</emphasis> widget, such as a child of a
 219  * container, you <emphasis>must</emphasis> use the wrapper APIs.
 220  * Otherwise, you would not properly consider widget margins,
 221  * #GtkSizeGroup, and so forth.
 222  * </para>
 223  * </refsect2>
 224  * <refsect2 id="style-properties">
 225  * <title>Style Properties</title>
 226  * <para>
 227  * <structname>GtkWidget</structname> introduces <firstterm>style
 228  * properties</firstterm> - these are basically object properties that are stored
 229  * not on the object, but in the style object associated to the widget. Style
 230  * properties are set in <link linkend="gtk-Resource-Files">resource files</link>.
 231  * This mechanism is used for configuring such things as the location of the
 232  * scrollbar arrows through the theme, giving theme authors more control over the
 233  * look of applications without the need to write a theme engine in C.
 234  * </para>
 235  * <para>
 236  * Use gtk_widget_class_install_style_property() to install style properties for
 237  * a widget class, gtk_widget_class_find_style_property() or
 238  * gtk_widget_class_list_style_properties() to get information about existing
 239  * style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or
 240  * gtk_widget_style_get_valist() to obtain the value of a style property.
 241  * </para>
 242  * </refsect2>
 243  * <refsect2 id="GtkWidget-BUILDER-UI">
 244  * <title>GtkWidget as GtkBuildable</title>
 245  * <para>
 246  * The GtkWidget implementation of the GtkBuildable interface supports a
 247  * custom &lt;accelerator&gt; element, which has attributes named key,
 248  * modifiers and signal and allows to specify accelerators.
 249  * </para>
 250  * <example>
 251  * <title>A UI definition fragment specifying an accelerator</title>
 252  * <programlisting><![CDATA[
 253  * <object class="GtkButton">
 254  *   <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
 255  * </object>
 256  * ]]></programlisting>
 257  * </example>
 258  * <para>
 259  * In addition to accelerators, <structname>GtkWidget</structname> also support a
 260  * custom &lt;accessible&gt; element, which supports actions and relations.
 261  * Properties on the accessible implementation of an object can be set by accessing the
 262  * internal child "accessible" of a <structname>GtkWidget</structname>.
 263  * </para>
 264  * <example>
 265  * <title>A UI definition fragment specifying an accessible</title>
 266  * <programlisting><![CDATA[
 267  * <object class="GtkButton" id="label1"/>
 268  *   <property name="label">I am a Label for a Button</property>
 269  * </object>
 270  * <object class="GtkButton" id="button1">
 271  *   <accessibility>
 272  *     <action action_name="click" translatable="yes">Click the button.</action>
 273  *     <relation target="label1" type="labelled-by"/>
 274  *   </accessibility>
 275  *   <child internal-child="accessible">
 276  *     <object class="AtkObject" id="a11y-button1">
 277  *       <property name="accessible-name">Clickable Button</property>
 278  *     </object>
 279  *   </child>
 280  * </object>
 281  * ]]></programlisting>
 282  * </example>
 283  * <para>
 284  * Finally, GtkWidget allows style information such as style classes to
 285  * be associated with widgets, using the custom &lt;style&gt; element:
 286  * <example>
 287  * <title>A UI definition fragment specifying an style class</title>
 288  * <programlisting><![CDATA[
 289  * <object class="GtkButton" id="button1">
 290  *   <style>
 291  *     <class name="my-special-button-class"/>
 292  *     <class name="dark-button"/>
 293  *   </style>
 294  * </object>
 295  * ]]></programlisting>
 296  * </example>
 297  * </para>
 298  * </refsect2>
 299  */
 300
 301 /* Add flags here that should not be propagated to children. By default,
 302  * all flags will be set on children (think prelight or active), but we
 303  * might want to not do this for some.
 304  */
 305 #define GTK_STATE_FLAGS_DONT_PROPAGATE (GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL)
 306 #define GTK_STATE_FLAGS_DO_PROPAGATE (~GTK_STATE_FLAGS_DONT_PROPAGATE)
 307
 308 #define WIDGET_CLASS(w)  GTK_WIDGET_GET_CLASS (w)
 309
 310 #define GTK_STATE_FLAGS_BITS 9
 311
 312 struct _GtkWidgetPrivate
 313 {
 314   /* The state of the widget. Needs to be able to hold all GtkStateFlags bits
 315    * (defined in "gtkenums.h").
 316    */
 317   guint state_flags : GTK_STATE_FLAGS_BITS;
 318
 319   guint direction             : 2;
 320
 321   guint in_destruction        : 1;
 322   guint toplevel              : 1;
 323   guint anchored              : 1;
 324   guint composite_child       : 1;
 325   guint no_window             : 1;
 326   guint realized              : 1;
 327   guint mapped                : 1;
 328   guint visible               : 1;
 329   guint sensitive             : 1;
 330   guint can_focus             : 1;
 331   guint has_focus             : 1;
 332   guint can_default           : 1;
 333   guint has_default           : 1;
 334   guint receives_default      : 1;
 335   guint has_grab              : 1;
 336   guint shadowed              : 1;
 337   guint style_update_pending  : 1;
 338   guint app_paintable         : 1;
 339   guint double_buffered       : 1;
 340   guint redraw_on_alloc       : 1;
 341   guint no_show_all           : 1;
 342   guint child_visible         : 1;
 343   guint multidevice           : 1;
 344   guint has_shape_mask        : 1;
 345   guint in_reparent           : 1;
 346
 347   /* Queue-resize related flags */
 348   guint alloc_needed          : 1;
 349
 350   /* Expand-related flags */
 351   guint need_compute_expand   : 1; /* Need to recompute computed_[hv]_expand */
 352   guint computed_hexpand      : 1; /* computed results (composite of child flags) */
 353   guint computed_vexpand      : 1;
 354   guint hexpand               : 1; /* application-forced expand */
 355   guint vexpand               : 1;
 356   guint hexpand_set           : 1; /* whether to use application-forced  */
 357   guint vexpand_set           : 1; /* instead of computing from children */
 358
 359   /* SizeGroup related flags */
 360   guint have_size_groups      : 1;
 361
 362   guint opacity_group         : 1;
 363   guint norender_children     : 1;
 364   guint norender              : 1; /* Don't expose windows, instead recurse via draw */
 365
 366   guint8 alpha;
 367   guint8 user_alpha;
 368
 369   /* The widget's name. If the widget does not have a name
 370    * (the name is NULL), then its name (as returned by
 371    * "gtk_widget_get_name") is its class's name.
 372    * Among other things, the widget name is used to determine
 373    * the style to use for a widget.
 374    */
 375   gchar *name;
 376
 377   /* The list of attached windows to this widget.
 378    * We keep a list in order to call reset_style to all of them,
 379    * recursively. */
 380   GList *attached_windows;
 381
 382   /* The style for the widget. The style contains the
 383    * colors the widget should be drawn in for each state
 384    * along with graphics contexts used to draw with and
 385    * the font to use for text.
 386    */
 387   GtkStyle *style;
 388   GtkStyleContext *context;
 389
 390   /* Widget's path for styling */
 391   GtkWidgetPath *path;
 392
 393   /* The widget's allocated size */
 394   GtkAllocation allocation;
 395
 396   /* The widget's requested sizes */
 397   SizeRequestCache requests;
 398
 399   /* actions attached to this or any parent widget */
 400   GActionMuxer *muxer;
 401
 402   /* The widget's window or its parent window if it does
 403    * not have a window. (Which will be indicated by the
 404    * GTK_NO_WINDOW flag being set).
 405    */
 406   GdkWindow *window;
 407   GList *registered_windows;
 408
 409   /* The widget's parent */
 410   GtkWidget *parent;
 411
 412   /* Animations and other things to update on clock ticks */
 413   GList *tick_callbacks;
 414
 415 #ifdef G_ENABLE_DEBUG
 416   /* Number of gtk_widget_push_verify_invariants () */
 417   guint verifying_invariants_count;
 418 #endif /* G_ENABLE_DEBUG */
 419 };
 420
 421 struct _GtkWidgetClassPrivate
 422 {
 423   GType accessible_type;
 424   AtkRole accessible_role;
 425 };
 426
 427 enum {
 428   DESTROY,
 429   SHOW,
 430   HIDE,
 431   MAP,
 432   UNMAP,
 433   REALIZE,
 434   UNREALIZE,
 435   SIZE_ALLOCATE,
 436   STATE_FLAGS_CHANGED,
 437   STATE_CHANGED,
 438   PARENT_SET,
 439   HIERARCHY_CHANGED,
 440   STYLE_SET,
 441   DIRECTION_CHANGED,
 442   GRAB_NOTIFY,
 443   CHILD_NOTIFY,
 444   DRAW,
 445   MNEMONIC_ACTIVATE,
 446   GRAB_FOCUS,
 447   FOCUS,
 448   MOVE_FOCUS,
 449   KEYNAV_FAILED,
 450   EVENT,
 451   EVENT_AFTER,
 452   BUTTON_PRESS_EVENT,
 453   BUTTON_RELEASE_EVENT,
 454   SCROLL_EVENT,
 455   MOTION_NOTIFY_EVENT,
 456   DELETE_EVENT,
 457   DESTROY_EVENT,
 458   KEY_PRESS_EVENT,
 459   KEY_RELEASE_EVENT,
 460   ENTER_NOTIFY_EVENT,
 461   LEAVE_NOTIFY_EVENT,
 462   CONFIGURE_EVENT,
 463   FOCUS_IN_EVENT,
 464   FOCUS_OUT_EVENT,
 465   MAP_EVENT,
 466   UNMAP_EVENT,
 467   PROPERTY_NOTIFY_EVENT,
 468   SELECTION_CLEAR_EVENT,
 469   SELECTION_REQUEST_EVENT,
 470   SELECTION_NOTIFY_EVENT,
 471   SELECTION_GET,
 472   SELECTION_RECEIVED,
 473   PROXIMITY_IN_EVENT,
 474   PROXIMITY_OUT_EVENT,
 475   VISIBILITY_NOTIFY_EVENT,
 476   WINDOW_STATE_EVENT,
 477   DAMAGE_EVENT,
 478   GRAB_BROKEN_EVENT,
 479   DRAG_BEGIN,
 480   DRAG_END,
 481   DRAG_DATA_DELETE,
 482   DRAG_LEAVE,
 483   DRAG_MOTION,
 484   DRAG_DROP,
 485   DRAG_DATA_GET,
 486   DRAG_DATA_RECEIVED,
 487   POPUP_MENU,
 488   SHOW_HELP,
 489   ACCEL_CLOSURES_CHANGED,
 490   SCREEN_CHANGED,
 491   CAN_ACTIVATE_ACCEL,
 492   COMPOSITED_CHANGED,
 493   QUERY_TOOLTIP,
 494   DRAG_FAILED,
 495   STYLE_UPDATED,
 496   TOUCH_EVENT,
 497   LAST_SIGNAL
 498 };
 499
 500 enum {
 501   PROP_0,
 502   PROP_NAME,
 503   PROP_PARENT,
 504   PROP_WIDTH_REQUEST,
 505   PROP_HEIGHT_REQUEST,
 506   PROP_VISIBLE,
 507   PROP_SENSITIVE,
 508   PROP_APP_PAINTABLE,
 509   PROP_CAN_FOCUS,
 510   PROP_HAS_FOCUS,
 511   PROP_IS_FOCUS,
 512   PROP_CAN_DEFAULT,
 513   PROP_HAS_DEFAULT,
 514   PROP_RECEIVES_DEFAULT,
 515   PROP_COMPOSITE_CHILD,
 516   PROP_STYLE,
 517   PROP_EVENTS,
 518   PROP_NO_SHOW_ALL,
 519   PROP_HAS_TOOLTIP,
 520   PROP_TOOLTIP_MARKUP,
 521   PROP_TOOLTIP_TEXT,
 522   PROP_WINDOW,
 523   PROP_OPACITY,
 524   PROP_DOUBLE_BUFFERED,
 525   PROP_HALIGN,
 526   PROP_VALIGN,
 527   PROP_MARGIN_LEFT,
 528   PROP_MARGIN_RIGHT,
 529   PROP_MARGIN_TOP,
 530   PROP_MARGIN_BOTTOM,
 531   PROP_MARGIN,
 532   PROP_HEXPAND,
 533   PROP_VEXPAND,
 534   PROP_HEXPAND_SET,
 535   PROP_VEXPAND_SET,
 536   PROP_EXPAND
 537 };
 538
 539 typedef struct  _GtkStateData    GtkStateData;
 540
 541 struct _GtkStateData
 542 {
 543   guint         flags_to_set;
 544   guint         flags_to_unset;
 545 };
 546
 547 /* --- prototypes --- */
 548 static void     gtk_widget_base_class_init      (gpointer            g_class);
 549 static void     gtk_widget_class_init           (GtkWidgetClass     *klass);
 550 static void     gtk_widget_base_class_finalize  (GtkWidgetClass     *klass);
 551 static void     gtk_widget_init                 (GtkWidget          *widget);
 552 static void     gtk_widget_set_property          (GObject           *object,
 553                                                   guint              prop_id,
 554                                                   const GValue      *value,
 555                                                   GParamSpec        *pspec);
 556 static void     gtk_widget_get_property          (GObject           *object,
 557                                                   guint              prop_id,
 558                                                   GValue            *value,
 559                                                   GParamSpec        *pspec);
 560 static void     gtk_widget_constructed           (GObject           *object);
 561 static void     gtk_widget_dispose               (GObject           *object);
 562 static void     gtk_widget_real_destroy          (GtkWidget         *object);
 563 static void     gtk_widget_finalize              (GObject           *object);
 564 static void     gtk_widget_real_show             (GtkWidget         *widget);
 565 static void     gtk_widget_real_hide             (GtkWidget         *widget);
 566 static void     gtk_widget_real_map              (GtkWidget         *widget);
 567 static void     gtk_widget_real_unmap            (GtkWidget         *widget);
 568 static void     gtk_widget_real_realize          (GtkWidget         *widget);
 569 static void     gtk_widget_real_unrealize        (GtkWidget         *widget);
 570 static void     gtk_widget_real_size_allocate    (GtkWidget         *widget,
 571                                                   GtkAllocation     *allocation);
 572 static void     gtk_widget_real_style_set        (GtkWidget         *widget,
 573                                                   GtkStyle          *previous_style);
 574 static void     gtk_widget_real_direction_changed(GtkWidget         *widget,
 575                                                   GtkTextDirection   previous_direction);
 576
 577 static void     gtk_widget_real_grab_focus       (GtkWidget         *focus_widget);
 578 static gboolean gtk_widget_real_query_tooltip    (GtkWidget         *widget,
 579                                                   gint               x,
 580                                                   gint               y,
 581                                                   gboolean           keyboard_tip,
 582                                                   GtkTooltip        *tooltip);
 583 static void     gtk_widget_real_style_updated    (GtkWidget         *widget);
 584 static gboolean gtk_widget_real_show_help        (GtkWidget         *widget,
 585                                                   GtkWidgetHelpType  help_type);
 586
 587 static void     gtk_widget_dispatch_child_properties_changed    (GtkWidget        *object,
 588                                                                  guint             n_pspecs,
 589                                                                  GParamSpec      **pspecs);
 590 static gboolean         gtk_widget_real_key_press_event         (GtkWidget        *widget,
 591                                                                  GdkEventKey      *event);
 592 static gboolean         gtk_widget_real_key_release_event       (GtkWidget        *widget,
 593                                                                  GdkEventKey      *event);
 594 static gboolean         gtk_widget_real_focus_in_event           (GtkWidget       *widget,
 595                                                                   GdkEventFocus   *event);
 596 static gboolean         gtk_widget_real_focus_out_event         (GtkWidget        *widget,
 597                                                                  GdkEventFocus    *event);
 598 static gboolean         gtk_widget_real_touch_event             (GtkWidget        *widget,
 599                                                                  GdkEventTouch    *event);
 600 static gboolean         gtk_widget_real_focus                   (GtkWidget        *widget,
 601                                                                  GtkDirectionType  direction);
 602 static void             gtk_widget_real_move_focus              (GtkWidget        *widget,
 603                                                                  GtkDirectionType  direction);
 604 static gboolean         gtk_widget_real_keynav_failed           (GtkWidget        *widget,
 605                                                                  GtkDirectionType  direction);
 606 #ifdef G_ENABLE_DEBUG
 607 static void             gtk_widget_verify_invariants            (GtkWidget        *widget);
 608 static void             gtk_widget_push_verify_invariants       (GtkWidget        *widget);
 609 static void             gtk_widget_pop_verify_invariants        (GtkWidget        *widget);
 610 #else
 611 #define                 gtk_widget_verify_invariants(widget)
 612 #define                 gtk_widget_push_verify_invariants(widget)
 613 #define                 gtk_widget_pop_verify_invariants(widget)
 614 #endif
 615 static PangoContext*    gtk_widget_peek_pango_context           (GtkWidget        *widget);
 616 static void             gtk_widget_update_pango_context         (GtkWidget        *widget);
 617 static void             gtk_widget_propagate_state              (GtkWidget        *widget,
 618                                                                  GtkStateData     *data);
 619 static void             gtk_widget_update_alpha                 (GtkWidget        *widget);
 620
 621 static gint             gtk_widget_event_internal               (GtkWidget        *widget,
 622                                                                  GdkEvent         *event);
 623 static gboolean         gtk_widget_real_mnemonic_activate       (GtkWidget        *widget,
 624                                                                  gboolean          group_cycling);
 625 static void             gtk_widget_real_get_width               (GtkWidget        *widget,
 626                                                                  gint             *minimum_size,
 627                                                                  gint             *natural_size);
 628 static void             gtk_widget_real_get_height              (GtkWidget        *widget,
 629                                                                  gint             *minimum_size,
 630                                                                  gint             *natural_size);
 631 static void             gtk_widget_real_get_height_for_width    (GtkWidget        *widget,
 632                                                                  gint              width,
 633                                                                  gint             *minimum_height,
 634                                                                  gint             *natural_height);
 635 static void             gtk_widget_real_get_width_for_height    (GtkWidget        *widget,
 636                                                                  gint              height,
 637                                                                  gint             *minimum_width,
 638                                                                  gint             *natural_width);
 639 static void             gtk_widget_real_state_flags_changed     (GtkWidget        *widget,
 640                                                                  GtkStateFlags     old_state);
 641 static const GtkWidgetAuxInfo* _gtk_widget_get_aux_info_or_defaults (GtkWidget *widget);
 642 static GtkWidgetAuxInfo* gtk_widget_get_aux_info                (GtkWidget        *widget,
 643                                                                  gboolean          create);
 644 static void             gtk_widget_aux_info_destroy             (GtkWidgetAuxInfo *aux_info);
 645 static AtkObject*       gtk_widget_real_get_accessible          (GtkWidget        *widget);
 646 static void             gtk_widget_accessible_interface_init    (AtkImplementorIface *iface);
 647 static AtkObject*       gtk_widget_ref_accessible               (AtkImplementor *implementor);
 648 static void             gtk_widget_invalidate_widget_windows    (GtkWidget        *widget,
 649                                                                  cairo_region_t        *region);
 650 static GdkScreen *      gtk_widget_get_screen_unchecked         (GtkWidget        *widget);
 651 static gboolean         gtk_widget_real_can_activate_accel      (GtkWidget *widget,
 652                                                                  guint      signal_id);
 653
 654 static void             gtk_widget_real_set_has_tooltip         (GtkWidget *widget,
 655                                                                  gboolean   has_tooltip,
 656                                                                  gboolean   force);
 657 static void             gtk_widget_buildable_interface_init     (GtkBuildableIface *iface);
 658 static void             gtk_widget_buildable_set_name           (GtkBuildable     *buildable,
 659                                                                  const gchar      *name);
 660 static const gchar *    gtk_widget_buildable_get_name           (GtkBuildable     *buildable);
 661 static GObject *        gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,
 662                                                                  GtkBuilder   *builder,
 663                                                                  const gchar  *childname);
 664 static void             gtk_widget_buildable_set_buildable_property (GtkBuildable     *buildable,
 665                                                                      GtkBuilder       *builder,
 666                                                                      const gchar      *name,
 667                                                                      const GValue     *value);
 668 static gboolean         gtk_widget_buildable_custom_tag_start   (GtkBuildable     *buildable,
 669                                                                  GtkBuilder       *builder,
 670                                                                  GObject          *child,
 671                                                                  const gchar      *tagname,
 672                                                                  GMarkupParser    *parser,
 673                                                                  gpointer         *data);
 674 static void             gtk_widget_buildable_custom_finished    (GtkBuildable     *buildable,
 675                                                                  GtkBuilder       *builder,
 676                                                                  GObject          *child,
 677                                                                  const gchar      *tagname,
 678                                                                  gpointer          data);
 679 static void             gtk_widget_buildable_parser_finished    (GtkBuildable     *buildable,
 680                                                                  GtkBuilder       *builder);
 681
 682 static GtkSizeRequestMode gtk_widget_real_get_request_mode      (GtkWidget         *widget);
 683 static void             gtk_widget_real_get_width               (GtkWidget         *widget,
 684                                                                  gint              *minimum_size,
 685                                                                  gint              *natural_size);
 686 static void             gtk_widget_real_get_height              (GtkWidget         *widget,
 687                                                                  gint              *minimum_size,
 688                                                                  gint              *natural_size);
 689
 690 static void             gtk_widget_queue_tooltip_query          (GtkWidget *widget);
 691
 692
 693 static void             gtk_widget_real_adjust_size_request     (GtkWidget         *widget,
 694                                                                  GtkOrientation     orientation,
 695                                                                  gint              *minimum_size,
 696                                                                  gint              *natural_size);
 697 static void             gtk_widget_real_adjust_size_allocation  (GtkWidget         *widget,
 698                                                                  GtkOrientation     orientation,
 699                                                                  gint              *minimum_size,
 700                                                                  gint              *natural_size,
 701                                                                  gint              *allocated_pos,
 702                                                                  gint              *allocated_size);
 703
 704 static void gtk_widget_set_usize_internal (GtkWidget          *widget,
 705                                            gint                width,
 706                                            gint                height,
 707                                            GtkQueueResizeFlags flags);
 708
 709 static void gtk_widget_add_events_internal (GtkWidget *widget,
 710                                             GdkDevice *device,
 711                                             gint       events);
 712 static void gtk_widget_set_device_enabled_internal (GtkWidget *widget,
 713                                                     GdkDevice *device,
 714                                                     gboolean   recurse,
 715                                                     gboolean   enabled);
 716
 717 static void gtk_widget_on_frame_clock_update (GdkFrameClock *frame_clock,
 718                                               GtkWidget     *widget);
 719
 720 static gboolean event_window_is_still_viewable (GdkEvent *event);
 721 static void gtk_cairo_set_event (cairo_t        *cr,
 722                                  GdkEventExpose *event);
 723 static void gtk_widget_propagate_alpha (GtkWidget *widget);
 724
 725 /* --- variables --- */
 726 static gpointer         gtk_widget_parent_class = NULL;
 727 static guint            widget_signals[LAST_SIGNAL] = { 0 };
 728 static guint            composite_child_stack = 0;
 729 static GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR;
 730 static GParamSpecPool  *style_property_spec_pool = NULL;
 731
 732 static GQuark           quark_property_parser = 0;
 733 static GQuark           quark_aux_info = 0;
 734 static GQuark           quark_accel_path = 0;
 735 static GQuark           quark_accel_closures = 0;
 736 static GQuark           quark_event_mask = 0;
 737 static GQuark           quark_device_event_mask = 0;
 738 static GQuark           quark_parent_window = 0;
 739 static GQuark           quark_pointer_window = 0;
 740 static GQuark           quark_shape_info = 0;
 741 static GQuark           quark_input_shape_info = 0;
 742 static GQuark           quark_pango_context = 0;
 743 static GQuark           quark_accessible_object = 0;
 744 static GQuark           quark_mnemonic_labels = 0;
 745 static GQuark           quark_tooltip_markup = 0;
 746 static GQuark           quark_has_tooltip = 0;
 747 static GQuark           quark_tooltip_window = 0;
 748 static GQuark           quark_visual = 0;
 749 static GQuark           quark_modifier_style = 0;
 750 static GQuark           quark_enabled_devices = 0;
 751 static GQuark           quark_size_groups = 0;
 752 GParamSpecPool         *_gtk_widget_child_property_pool = NULL;
 753 GObjectNotifyContext   *_gtk_widget_child_property_notify_context = NULL;
 754
 755 /* --- functions --- */
 756 GType
 757 gtk_widget_get_type (void)
 758 {
 759   static GType widget_type = 0;
 760
 761   if (G_UNLIKELY (widget_type == 0))
 762     {
 763       const GTypeInfo widget_info =
 764       {
 765         sizeof (GtkWidgetClass),
 766         gtk_widget_base_class_init,
 767         (GBaseFinalizeFunc) gtk_widget_base_class_finalize,
 768         (GClassInitFunc) gtk_widget_class_init,
 769         NULL,           /* class_finalize */
 770         NULL,           /* class_init */
 771         sizeof (GtkWidget),
 772         0,              /* n_preallocs */
 773         (GInstanceInitFunc) gtk_widget_init,
 774         NULL,           /* value_table */
 775       };
 776
 777       const GInterfaceInfo accessibility_info =
 778       {
 779         (GInterfaceInitFunc) gtk_widget_accessible_interface_init,
 780         (GInterfaceFinalizeFunc) NULL,
 781         NULL /* interface data */
 782       };
 783
 784       const GInterfaceInfo buildable_info =
 785       {
 786         (GInterfaceInitFunc) gtk_widget_buildable_interface_init,
 787         (GInterfaceFinalizeFunc) NULL,
 788         NULL /* interface data */
 789       };
 790
 791       widget_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkWidget",
 792                                             &widget_info, G_TYPE_FLAG_ABSTRACT);
 793
 794       g_type_add_class_private (widget_type, sizeof (GtkWidgetClassPrivate));
 795
 796       g_type_add_interface_static (widget_type, ATK_TYPE_IMPLEMENTOR,
 797                                    &accessibility_info) ;
 798       g_type_add_interface_static (widget_type, GTK_TYPE_BUILDABLE,
 799                                    &buildable_info) ;
 800     }
 801
 802   return widget_type;
 803 }
 804
 805 static void
 806 gtk_widget_base_class_init (gpointer g_class)
 807 {
 808   GtkWidgetClass *klass = g_class;
 809
 810   klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_WIDGET, GtkWidgetClassPrivate);
 811 }
 812
 813 static void
 814 child_property_notify_dispatcher (GObject     *object,
 815                                   guint        n_pspecs,
 816                                   GParamSpec **pspecs)
 817 {
 818   GTK_WIDGET_GET_CLASS (object)->dispatch_child_properties_changed (GTK_WIDGET (object), n_pspecs, pspecs);
 819 }
 820
 821 /* We guard against the draw signal callbacks modifying the state of the
 822  * cairo context by surounding it with save/restore.
 823  * Maybe we should also cairo_new_path() just to be sure?
 824  */
 825 static void
 826 gtk_widget_draw_marshaller (GClosure     *closure,
 827                             GValue       *return_value,
 828                             guint         n_param_values,
 829                             const GValue *param_values,
 830                             gpointer      invocation_hint,
 831                             gpointer      marshal_data)
 832 {
 833   GtkWidget *widget = g_value_get_object (&param_values[0]);
 834   GdkEventExpose *tmp_event;
 835   gboolean push_group;
 836   cairo_t *cr = g_value_get_boxed (&param_values[1]);
 837
 838   cairo_save (cr);
 839   tmp_event = _gtk_cairo_get_event (cr);
 840
 841   push_group =
 842     widget->priv->opacity_group ||
 843     (widget->priv->alpha != 255 &&
 844      (!gtk_widget_get_has_window (widget) || tmp_event == NULL));
 845
 846   if (push_group)
 847     {
 848       cairo_push_group (cr);
 849       gtk_cairo_set_event (cr, NULL);
 850     }
 851
 852   _gtk_marshal_BOOLEAN__BOXED (closure,
 853                                return_value,
 854                                n_param_values,
 855                                param_values,
 856                                invocation_hint,
 857                                marshal_data);
 858
 859
 860   if (push_group)
 861     {
 862       cairo_pop_group_to_source (cr);
 863       cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 864       cairo_paint_with_alpha (cr, widget->priv->alpha / 255.0);
 865     }
 866
 867   gtk_cairo_set_event (cr, tmp_event);
 868   cairo_restore (cr);
 869 }
 870
 871 static void
 872 gtk_widget_draw_marshallerv (GClosure     *closure,
 873                              GValue       *return_value,
 874                              gpointer      instance,
 875                              va_list       args,
 876                              gpointer      marshal_data,
 877                              int           n_params,
 878                              GType        *param_types)
 879 {
 880   GtkWidget *widget = GTK_WIDGET (instance);
 881   GdkEventExpose *tmp_event;
 882   gboolean push_group;
 883   cairo_t *cr;
 884   va_list args_copy;
 885
 886   G_VA_COPY (args_copy, args);
 887   cr = va_arg (args_copy, gpointer);
 888
 889   cairo_save (cr);
 890   tmp_event = _gtk_cairo_get_event (cr);
 891
 892   push_group =
 893     widget->priv->opacity_group ||
 894     (widget->priv->alpha != 255 &&
 895      (!gtk_widget_get_has_window (widget) || tmp_event == NULL));
 896
 897   if (push_group)
 898     {
 899       cairo_push_group (cr);
 900       gtk_cairo_set_event (cr, NULL);
 901     }
 902
 903   _gtk_marshal_BOOLEAN__BOXEDv (closure,
 904                                 return_value,
 905                                 instance,
 906                                 args,
 907                                 marshal_data,
 908                                 n_params,
 909                                 param_types);
 910
 911
 912   if (push_group)
 913     {
 914       cairo_pop_group_to_source (cr);
 915       cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 916       cairo_paint_with_alpha (cr, widget->priv->alpha / 255.0);
 917     }
 918
 919   gtk_cairo_set_event (cr, tmp_event);
 920   cairo_restore (cr);
 921
 922   va_end (args_copy);
 923 }
 924
 925 static void
 926 gtk_widget_class_init (GtkWidgetClass *klass)
 927 {
 928   static GObjectNotifyContext cpn_context = { 0, NULL, NULL };
 929   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 930   GtkBindingSet *binding_set;
 931
 932   gtk_widget_parent_class = g_type_class_peek_parent (klass);
 933
 934   quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");
 935   quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
 936   quark_accel_path = g_quark_from_static_string ("gtk-accel-path");
 937   quark_accel_closures = g_quark_from_static_string ("gtk-accel-closures");
 938   quark_event_mask = g_quark_from_static_string ("gtk-event-mask");
 939   quark_device_event_mask = g_quark_from_static_string ("gtk-device-event-mask");
 940   quark_parent_window = g_quark_from_static_string ("gtk-parent-window");
 941   quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
 942   quark_shape_info = g_quark_from_static_string ("gtk-shape-info");
 943   quark_input_shape_info = g_quark_from_static_string ("gtk-input-shape-info");
 944   quark_pango_context = g_quark_from_static_string ("gtk-pango-context");
 945   quark_accessible_object = g_quark_from_static_string ("gtk-accessible-object");
 946   quark_mnemonic_labels = g_quark_from_static_string ("gtk-mnemonic-labels");
 947   quark_tooltip_markup = g_quark_from_static_string ("gtk-tooltip-markup");
 948   quark_has_tooltip = g_quark_from_static_string ("gtk-has-tooltip");
 949   quark_tooltip_window = g_quark_from_static_string ("gtk-tooltip-window");
 950   quark_visual = g_quark_from_static_string ("gtk-widget-visual");
 951   quark_modifier_style = g_quark_from_static_string ("gtk-widget-modifier-style");
 952   quark_enabled_devices = g_quark_from_static_string ("gtk-widget-enabled-devices");
 953   quark_size_groups = g_quark_from_static_string ("gtk-widget-size-groups");
 954
 955   style_property_spec_pool = g_param_spec_pool_new (FALSE);
 956   _gtk_widget_child_property_pool = g_param_spec_pool_new (TRUE);
 957   cpn_context.quark_notify_queue = g_quark_from_static_string ("GtkWidget-child-property-notify-queue");
 958   cpn_context.dispatcher = child_property_notify_dispatcher;
 959   _gtk_widget_child_property_notify_context = &cpn_context;
 960
 961   gobject_class->constructed = gtk_widget_constructed;
 962   gobject_class->dispose = gtk_widget_dispose;
 963   gobject_class->finalize = gtk_widget_finalize;
 964   gobject_class->set_property = gtk_widget_set_property;
 965   gobject_class->get_property = gtk_widget_get_property;
 966
 967   klass->destroy = gtk_widget_real_destroy;
 968
 969   klass->activate_signal = 0;
 970   klass->dispatch_child_properties_changed = gtk_widget_dispatch_child_properties_changed;
 971   klass->show = gtk_widget_real_show;
 972   klass->show_all = gtk_widget_show;
 973   klass->hide = gtk_widget_real_hide;
 974   klass->map = gtk_widget_real_map;
 975   klass->unmap = gtk_widget_real_unmap;
 976   klass->realize = gtk_widget_real_realize;
 977   klass->unrealize = gtk_widget_real_unrealize;
 978   klass->size_allocate = gtk_widget_real_size_allocate;
 979   klass->get_request_mode = gtk_widget_real_get_request_mode;
 980   klass->get_preferred_width = gtk_widget_real_get_width;
 981   klass->get_preferred_height = gtk_widget_real_get_height;
 982   klass->get_preferred_width_for_height = gtk_widget_real_get_width_for_height;
 983   klass->get_preferred_height_for_width = gtk_widget_real_get_height_for_width;
 984   klass->state_changed = NULL;
 985   klass->state_flags_changed = gtk_widget_real_state_flags_changed;
 986   klass->parent_set = NULL;
 987   klass->hierarchy_changed = NULL;
 988   klass->style_set = gtk_widget_real_style_set;
 989   klass->direction_changed = gtk_widget_real_direction_changed;
 990   klass->grab_notify = NULL;
 991   klass->child_notify = NULL;
 992   klass->draw = NULL;
 993   klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
 994   klass->grab_focus = gtk_widget_real_grab_focus;
 995   klass->focus = gtk_widget_real_focus;
 996   klass->move_focus = gtk_widget_real_move_focus;
 997   klass->keynav_failed = gtk_widget_real_keynav_failed;
 998   klass->event = NULL;
 999   klass->button_press_event = NULL;
1000   klass->button_release_event = NULL;
1001   klass->motion_notify_event = NULL;
1002   klass->touch_event = gtk_widget_real_touch_event;
1003   klass->delete_event = NULL;
1004   klass->destroy_event = NULL;
1005   klass->key_press_event = gtk_widget_real_key_press_event;
1006   klass->key_release_event = gtk_widget_real_key_release_event;
1007   klass->enter_notify_event = NULL;
1008   klass->leave_notify_event = NULL;
1009   klass->configure_event = NULL;
1010   klass->focus_in_event = gtk_widget_real_focus_in_event;
1011   klass->focus_out_event = gtk_widget_real_focus_out_event;
1012   klass->map_event = NULL;
1013   klass->unmap_event = NULL;
1014   klass->window_state_event = NULL;
1015   klass->property_notify_event = _gtk_selection_property_notify;
1016   klass->selection_clear_event = _gtk_selection_clear;
1017   klass->selection_request_event = _gtk_selection_request;
1018   klass->selection_notify_event = _gtk_selection_notify;
1019   klass->selection_received = NULL;
1020   klass->proximity_in_event = NULL;
1021   klass->proximity_out_event = NULL;
1022   klass->drag_begin = NULL;
1023   klass->drag_end = NULL;
1024   klass->drag_data_delete = NULL;
1025   klass->drag_leave = NULL;
1026   klass->drag_motion = NULL;
1027   klass->drag_drop = NULL;
1028   klass->drag_data_received = NULL;
1029   klass->screen_changed = NULL;
1030   klass->can_activate_accel = gtk_widget_real_can_activate_accel;
1031   klass->grab_broken_event = NULL;
1032   klass->query_tooltip = gtk_widget_real_query_tooltip;
1033   klass->style_updated = gtk_widget_real_style_updated;
1034
1035   klass->show_help = gtk_widget_real_show_help;
1036
1037   /* Accessibility support */
1038   klass->priv->accessible_type = GTK_TYPE_ACCESSIBLE;
1039   klass->priv->accessible_role = ATK_ROLE_INVALID;
1040   klass->get_accessible = gtk_widget_real_get_accessible;
1041
1042   klass->adjust_size_request = gtk_widget_real_adjust_size_request;
1043   klass->adjust_size_allocation = gtk_widget_real_adjust_size_allocation;
1044
1045   g_object_class_install_property (gobject_class,
1046                                    PROP_NAME,
1047                                    g_param_spec_string ("name",
1048                                                         P_("Widget name"),
1049                                                         P_("The name of the widget"),
1050                                                         NULL,
1051                                                         GTK_PARAM_READWRITE));
1052   g_object_class_install_property (gobject_class,
1053                                    PROP_PARENT,
1054                                    g_param_spec_object ("parent",
1055                                                         P_("Parent widget"),
1056                                                         P_("The parent widget of this widget. Must be a Container widget"),
1057                                                         GTK_TYPE_CONTAINER,
1058                                                         GTK_PARAM_READWRITE));
1059
1060   g_object_class_install_property (gobject_class,
1061                                    PROP_WIDTH_REQUEST,
1062                                    g_param_spec_int ("width-request",
1063                                                      P_("Width request"),
1064                                                      P_("Override for width request of the widget, or -1 if natural request should be used"),
1065                                                      -1,
1066                                                      G_MAXINT,
1067                                                      -1,
1068                                                      GTK_PARAM_READWRITE));
1069   g_object_class_install_property (gobject_class,
1070                                    PROP_HEIGHT_REQUEST,
1071                                    g_param_spec_int ("height-request",
1072                                                      P_("Height request"),
1073                                                      P_("Override for height request of the widget, or -1 if natural request should be used"),
1074                                                      -1,
1075                                                      G_MAXINT,
1076                                                      -1,
1077                                                      GTK_PARAM_READWRITE));
1078   g_object_class_install_property (gobject_class,
1079                                    PROP_VISIBLE,
1080                                    g_param_spec_boolean ("visible",
1081                                                          P_("Visible"),
1082                                                          P_("Whether the widget is visible"),
1083                                                          FALSE,
1084                                                          GTK_PARAM_READWRITE));
1085   g_object_class_install_property (gobject_class,
1086                                    PROP_SENSITIVE,
1087                                    g_param_spec_boolean ("sensitive",
1088                                                          P_("Sensitive"),
1089                                                          P_("Whether the widget responds to input"),
1090                                                          TRUE,
1091                                                          GTK_PARAM_READWRITE));
1092   g_object_class_install_property (gobject_class,
1093                                    PROP_APP_PAINTABLE,
1094                                    g_param_spec_boolean ("app-paintable",
1095                                                          P_("Application paintable"),
1096                                                          P_("Whether the application will paint directly on the widget"),
1097                                                          FALSE,
1098                                                          GTK_PARAM_READWRITE));
1099   g_object_class_install_property (gobject_class,
1100                                    PROP_CAN_FOCUS,
1101                                    g_param_spec_boolean ("can-focus",
1102                                                          P_("Can focus"),
1103                                                          P_("Whether the widget can accept the input focus"),
1104                                                          FALSE,
1105                                                          GTK_PARAM_READWRITE));
1106   g_object_class_install_property (gobject_class,
1107                                    PROP_HAS_FOCUS,
1108                                    g_param_spec_boolean ("has-focus",
1109                                                          P_("Has focus"),
1110                                                          P_("Whether the widget has the input focus"),
1111                                                          FALSE,
1112                                                          GTK_PARAM_READWRITE));
1113   g_object_class_install_property (gobject_class,
1114                                    PROP_IS_FOCUS,
1115                                    g_param_spec_boolean ("is-focus",
1116                                                          P_("Is focus"),
1117                                                          P_("Whether the widget is the focus widget within the toplevel"),
1118                                                          FALSE,
1119                                                          GTK_PARAM_READWRITE));
1120   g_object_class_install_property (gobject_class,
1121                                    PROP_CAN_DEFAULT,
1122                                    g_param_spec_boolean ("can-default",
1123                                                          P_("Can default"),
1124                                                          P_("Whether the widget can be the default widget"),
1125                                                          FALSE,
1126                                                          GTK_PARAM_READWRITE));
1127   g_object_class_install_property (gobject_class,
1128                                    PROP_HAS_DEFAULT,
1129                                    g_param_spec_boolean ("has-default",
1130                                                          P_("Has default"),
1131                                                          P_("Whether the widget is the default widget"),
1132                                                          FALSE,
1133                                                          GTK_PARAM_READWRITE));
1134   g_object_class_install_property (gobject_class,
1135                                    PROP_RECEIVES_DEFAULT,
1136                                    g_param_spec_boolean ("receives-default",
1137                                                          P_("Receives default"),
1138                                                          P_("If TRUE, the widget will receive the default action when it is focused"),
1139                                                          FALSE,
1140                                                          GTK_PARAM_READWRITE));
1141   g_object_class_install_property (gobject_class,
1142                                    PROP_COMPOSITE_CHILD,
1143                                    g_param_spec_boolean ("composite-child",
1144                                                          P_("Composite child"),
1145                                                          P_("Whether the widget is part of a composite widget"),
1146                                                          FALSE,
1147                                                          GTK_PARAM_READABLE));
1148   g_object_class_install_property (gobject_class,
1149                                    PROP_STYLE,
1150                                    g_param_spec_object ("style",
1151                                                         P_("Style"),
1152                                                         P_("The style of the widget, which contains information about how it will look (colors etc)"),
1153                                                         GTK_TYPE_STYLE,
1154                                                         GTK_PARAM_READWRITE));
1155   g_object_class_install_property (gobject_class,
1156                                    PROP_EVENTS,
1157                                    g_param_spec_flags ("events",
1158                                                        P_("Events"),
1159                                                        P_("The event mask that decides what kind of GdkEvents this widget gets"),
1160                                                        GDK_TYPE_EVENT_MASK,
1161                                                        GDK_STRUCTURE_MASK,
1162                                                        GTK_PARAM_READWRITE));
1163   g_object_class_install_property (gobject_class,
1164                                    PROP_NO_SHOW_ALL,
1165                                    g_param_spec_boolean ("no-show-all",
1166                                                          P_("No show all"),
1167                                                          P_("Whether gtk_widget_show_all() should not affect this widget"),
1168                                                          FALSE,
1169                                                          GTK_PARAM_READWRITE));
1170
1171 /**
1172  * GtkWidget:has-tooltip:
1173  *
1174  * Enables or disables the emission of #GtkWidget::query-tooltip on @widget.
1175  * A value of %TRUE indicates that @widget can have a tooltip, in this case
1176  * the widget will be queried using #GtkWidget::query-tooltip to determine
1177  * whether it will provide a tooltip or not.
1178  *
1179  * Note that setting this property to %TRUE for the first time will change
1180  * the event masks of the GdkWindows of this widget to include leave-notify
1181  * and motion-notify events.  This cannot and will not be undone when the
1182  * property is set to %FALSE again.
1183  *
1184  * Since: 2.12
1185  */
1186   g_object_class_install_property (gobject_class,
1187                                    PROP_HAS_TOOLTIP,
1188                                    g_param_spec_boolean ("has-tooltip",
1189                                                          P_("Has tooltip"),
1190                                                          P_("Whether this widget has a tooltip"),
1191                                                          FALSE,
1192                                                          GTK_PARAM_READWRITE));
1193   /**
1194    * GtkWidget:tooltip-text:
1195    *
1196    * Sets the text of tooltip to be the given string.
1197    *
1198    * Also see gtk_tooltip_set_text().
1199    *
1200    * This is a convenience property which will take care of getting the
1201    * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
1202    * will automatically be set to %TRUE and there will be taken care of
1203    * #GtkWidget::query-tooltip in the default signal handler.
1204    *
1205    * Since: 2.12
1206    */
1207   g_object_class_install_property (gobject_class,
1208                                    PROP_TOOLTIP_TEXT,
1209                                    g_param_spec_string ("tooltip-text",
1210                                                         P_("Tooltip Text"),
1211                                                         P_("The contents of the tooltip for this widget"),
1212                                                         NULL,
1213                                                         GTK_PARAM_READWRITE));
1214   /**
1215    * GtkWidget:tooltip-markup:
1216    *
1217    * Sets the text of tooltip to be the given string, which is marked up
1218    * with the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
1219    * Also see gtk_tooltip_set_markup().
1220    *
1221    * This is a convenience property which will take care of getting the
1222    * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
1223    * will automatically be set to %TRUE and there will be taken care of
1224    * #GtkWidget::query-tooltip in the default signal handler.
1225    *
1226    * Since: 2.12
1227    */
1228   g_object_class_install_property (gobject_class,
1229                                    PROP_TOOLTIP_MARKUP,
1230                                    g_param_spec_string ("tooltip-markup",
1231                                                         P_("Tooltip markup"),
1232                                                         P_("The contents of the tooltip for this widget"),
1233                                                         NULL,
1234                                                         GTK_PARAM_READWRITE));
1235
1236   /**
1237    * GtkWidget:window:
1238    *
1239    * The widget's window if it is realized, %NULL otherwise.
1240    *
1241    * Since: 2.14
1242    */
1243   g_object_class_install_property (gobject_class,
1244                                    PROP_WINDOW,
1245                                    g_param_spec_object ("window",
1246                                                         P_("Window"),
1247                                                         P_("The widget's window if it is realized"),
1248                                                         GDK_TYPE_WINDOW,
1249                                                         GTK_PARAM_READABLE));
1250
1251   /**
1252    * GtkWidget:double-buffered:
1253    *
1254    * Whether the widget is double buffered.
1255    *
1256    * Since: 2.18
1257    */
1258   g_object_class_install_property (gobject_class,
1259                                    PROP_DOUBLE_BUFFERED,
1260                                    g_param_spec_boolean ("double-buffered",
1261                                                          P_("Double Buffered"),
1262                                                          P_("Whether the widget is double buffered"),
1263                                                          TRUE,
1264                                                          GTK_PARAM_READWRITE));
1265
1266   /**
1267    * GtkWidget:halign:
1268    *
1269    * How to distribute horizontal space if widget gets extra space, see #GtkAlign
1270    *
1271    * Since: 3.0
1272    */
1273   g_object_class_install_property (gobject_class,
1274                                    PROP_HALIGN,
1275                                    g_param_spec_enum ("halign",
1276                                                       P_("Horizontal Alignment"),
1277                                                       P_("How to position in extra horizontal space"),
1278                                                       GTK_TYPE_ALIGN,
1279                                                       GTK_ALIGN_FILL,
1280                                                       GTK_PARAM_READWRITE));
1281
1282   /**
1283    * GtkWidget:valign:
1284    *
1285    * How to distribute vertical space if widget gets extra space, see #GtkAlign
1286    *
1287    * Since: 3.0
1288    */
1289   g_object_class_install_property (gobject_class,
1290                                    PROP_VALIGN,
1291                                    g_param_spec_enum ("valign",
1292                                                       P_("Vertical Alignment"),
1293                                                       P_("How to position in extra vertical space"),
1294                                                       GTK_TYPE_ALIGN,
1295                                                       GTK_ALIGN_FILL,
1296                                                       GTK_PARAM_READWRITE));
1297
1298   /**
1299    * GtkWidget:margin-left:
1300    *
1301    * Margin on left side of widget.
1302    *
1303    * This property adds margin outside of the widget's normal size
1304    * request, the margin will be added in addition to the size from
1305    * gtk_widget_set_size_request() for example.
1306    *
1307    * Since: 3.0
1308    */
1309   g_object_class_install_property (gobject_class,
1310                                    PROP_MARGIN_LEFT,
1311                                    g_param_spec_int ("margin-left",
1312                                                      P_("Margin on Left"),
1313                                                      P_("Pixels of extra space on the left side"),
1314                                                      0,
1315                                                      G_MAXINT16,
1316                                                      0,
1317                                                      GTK_PARAM_READWRITE));
1318
1319   /**
1320    * GtkWidget:margin-right:
1321    *
1322    * Margin on right side of widget.
1323    *
1324    * This property adds margin outside of the widget's normal size
1325    * request, the margin will be added in addition to the size from
1326    * gtk_widget_set_size_request() for example.
1327    *
1328    * Since: 3.0
1329    */
1330   g_object_class_install_property (gobject_class,
1331                                    PROP_MARGIN_RIGHT,
1332                                    g_param_spec_int ("margin-right",
1333                                                      P_("Margin on Right"),
1334                                                      P_("Pixels of extra space on the right side"),
1335                                                      0,
1336                                                      G_MAXINT16,
1337                                                      0,
1338                                                      GTK_PARAM_READWRITE));
1339
1340   /**
1341    * GtkWidget:margin-top:
1342    *
1343    * Margin on top side of widget.
1344    *
1345    * This property adds margin outside of the widget's normal size
1346    * request, the margin will be added in addition to the size from
1347    * gtk_widget_set_size_request() for example.
1348    *
1349    * Since: 3.0
1350    */
1351   g_object_class_install_property (gobject_class,
1352                                    PROP_MARGIN_TOP,
1353                                    g_param_spec_int ("margin-top",
1354                                                      P_("Margin on Top"),
1355                                                      P_("Pixels of extra space on the top side"),
1356                                                      0,
1357                                                      G_MAXINT16,
1358                                                      0,
1359                                                      GTK_PARAM_READWRITE));
1360
1361   /**
1362    * GtkWidget:margin-bottom:
1363    *
1364    * Margin on bottom side of widget.
1365    *
1366    * This property adds margin outside of the widget's normal size
1367    * request, the margin will be added in addition to the size from
1368    * gtk_widget_set_size_request() for example.
1369    *
1370    * Since: 3.0
1371    */
1372   g_object_class_install_property (gobject_class,
1373                                    PROP_MARGIN_BOTTOM,
1374                                    g_param_spec_int ("margin-bottom",
1375                                                      P_("Margin on Bottom"),
1376                                                      P_("Pixels of extra space on the bottom side"),
1377                                                      0,
1378                                                      G_MAXINT16,
1379                                                      0,
1380                                                      GTK_PARAM_READWRITE));
1381
1382   /**
1383    * GtkWidget:margin:
1384    *
1385    * Sets all four sides' margin at once. If read, returns max
1386    * margin on any side.
1387    *
1388    * Since: 3.0
1389    */
1390   g_object_class_install_property (gobject_class,
1391                                    PROP_MARGIN,
1392                                    g_param_spec_int ("margin",
1393                                                      P_("All Margins"),
1394                                                      P_("Pixels of extra space on all four sides"),
1395                                                      0,
1396                                                      G_MAXINT16,
1397                                                      0,
1398                                                      GTK_PARAM_READWRITE));
1399
1400   /**
1401    * GtkWidget::destroy:
1402    * @object: the object which received the signal
1403    *
1404    * Signals that all holders of a reference to the widget should release
1405    * the reference that they hold. May result in finalization of the widget
1406    * if all references are released.
1407    */
1408   widget_signals[DESTROY] =
1409     g_signal_new (I_("destroy"),
1410                   G_TYPE_FROM_CLASS (gobject_class),
1411                   G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
1412                   G_STRUCT_OFFSET (GtkWidgetClass, destroy),
1413                   NULL, NULL,
1414                   _gtk_marshal_VOID__VOID,
1415                   G_TYPE_NONE, 0);
1416
1417   /**
1418    * GtkWidget:hexpand:
1419    *
1420    * Whether to expand horizontally. See gtk_widget_set_hexpand().
1421    *
1422    * Since: 3.0
1423    */
1424   g_object_class_install_property (gobject_class,
1425                                    PROP_HEXPAND,
1426                                    g_param_spec_boolean ("hexpand",
1427                                                          P_("Horizontal Expand"),
1428                                                          P_("Whether widget wants more horizontal space"),
1429                                                          FALSE,
1430                                                          GTK_PARAM_READWRITE));
1431
1432   /**
1433    * GtkWidget:hexpand-set:
1434    *
1435    * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
1436    *
1437    * Since: 3.0
1438    */
1439   g_object_class_install_property (gobject_class,
1440                                    PROP_HEXPAND_SET,
1441                                    g_param_spec_boolean ("hexpand-set",
1442                                                          P_("Horizontal Expand Set"),
1443                                                          P_("Whether to use the hexpand property"),
1444                                                          FALSE,
1445                                                          GTK_PARAM_READWRITE));
1446
1447   /**
1448    * GtkWidget:vexpand:
1449    *
1450    * Whether to expand vertically. See gtk_widget_set_vexpand().
1451    *
1452    * Since: 3.0
1453    */
1454   g_object_class_install_property (gobject_class,
1455                                    PROP_VEXPAND,
1456                                    g_param_spec_boolean ("vexpand",
1457                                                          P_("Vertical Expand"),
1458                                                          P_("Whether widget wants more vertical space"),
1459                                                          FALSE,
1460                                                          GTK_PARAM_READWRITE));
1461
1462   /**
1463    * GtkWidget:vexpand-set:
1464    *
1465    * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
1466    *
1467    * Since: 3.0
1468    */
1469   g_object_class_install_property (gobject_class,
1470                                    PROP_VEXPAND_SET,
1471                                    g_param_spec_boolean ("vexpand-set",
1472                                                          P_("Vertical Expand Set"),
1473                                                          P_("Whether to use the vexpand property"),
1474                                                          FALSE,
1475                                                          GTK_PARAM_READWRITE));
1476
1477   /**
1478    * GtkWidget:expand:
1479    *
1480    * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
1481    *
1482    * Since: 3.0
1483    */
1484   g_object_class_install_property (gobject_class,
1485                                    PROP_EXPAND,
1486                                    g_param_spec_boolean ("expand",
1487                                                          P_("Expand Both"),
1488                                                          P_("Whether widget wants to expand in both directions"),
1489                                                          FALSE,
1490                                                          GTK_PARAM_READWRITE));
1491
1492   /**
1493    * GtkWidget:opacity:
1494    *
1495    * The requested opacity of the widget. See gtk_widget_set_opacity() for
1496    * more details about window opacity.
1497    *
1498    * Before 3.8 this was only availible in GtkWindow
1499    *
1500    * Since: 3.8
1501    */
1502   g_object_class_install_property (gobject_class,
1503                                    PROP_OPACITY,
1504                                    g_param_spec_double ("opacity",
1505                                                         P_("Opacity for Widget"),
1506                                                         P_("The opacity of the widget, from 0 to 1"),
1507                                                         0.0,
1508                                                         1.0,
1509                                                         1.0,
1510                                                         GTK_PARAM_READWRITE));
1511   /**
1512    * GtkWidget::show:
1513    * @widget: the object which received the signal.
1514    */
1515   widget_signals[SHOW] =
1516     g_signal_new (I_("show"),
1517                   G_TYPE_FROM_CLASS (gobject_class),
1518                   G_SIGNAL_RUN_FIRST,
1519                   G_STRUCT_OFFSET (GtkWidgetClass, show),
1520                   NULL, NULL,
1521                   _gtk_marshal_VOID__VOID,
1522                   G_TYPE_NONE, 0);
1523
1524   /**
1525    * GtkWidget::hide:
1526    * @widget: the object which received the signal.
1527    */
1528   widget_signals[HIDE] =
1529     g_signal_new (I_("hide"),
1530                   G_TYPE_FROM_CLASS (gobject_class),
1531                   G_SIGNAL_RUN_FIRST,
1532                   G_STRUCT_OFFSET (GtkWidgetClass, hide),
1533                   NULL, NULL,
1534                   _gtk_marshal_VOID__VOID,
1535                   G_TYPE_NONE, 0);
1536
1537   /**
1538    * GtkWidget::map:
1539    * @widget: the object which received the signal.
1540    */
1541   widget_signals[MAP] =
1542     g_signal_new (I_("map"),
1543                   G_TYPE_FROM_CLASS (gobject_class),
1544                   G_SIGNAL_RUN_FIRST,
1545                   G_STRUCT_OFFSET (GtkWidgetClass, map),
1546                   NULL, NULL,
1547                   _gtk_marshal_VOID__VOID,
1548                   G_TYPE_NONE, 0);
1549
1550   /**
1551    * GtkWidget::unmap:
1552    * @widget: the object which received the signal.
1553    */
1554   widget_signals[UNMAP] =
1555     g_signal_new (I_("unmap"),
1556                   G_TYPE_FROM_CLASS (gobject_class),
1557                   G_SIGNAL_RUN_FIRST,
1558                   G_STRUCT_OFFSET (GtkWidgetClass, unmap),
1559                   NULL, NULL,
1560                   _gtk_marshal_VOID__VOID,
1561                   G_TYPE_NONE, 0);
1562
1563   /**
1564    * GtkWidget::realize:
1565    * @widget: the object which received the signal.
1566    */
1567   widget_signals[REALIZE] =
1568     g_signal_new (I_("realize"),
1569                   G_TYPE_FROM_CLASS (gobject_class),
1570                   G_SIGNAL_RUN_FIRST,
1571                   G_STRUCT_OFFSET (GtkWidgetClass, realize),
1572                   NULL, NULL,
1573                   _gtk_marshal_VOID__VOID,
1574                   G_TYPE_NONE, 0);
1575
1576   /**
1577    * GtkWidget::unrealize:
1578    * @widget: the object which received the signal.
1579    */
1580   widget_signals[UNREALIZE] =
1581     g_signal_new (I_("unrealize"),
1582                   G_TYPE_FROM_CLASS (gobject_class),
1583                   G_SIGNAL_RUN_LAST,
1584                   G_STRUCT_OFFSET (GtkWidgetClass, unrealize),
1585                   NULL, NULL,
1586                   _gtk_marshal_VOID__VOID,
1587                   G_TYPE_NONE, 0);
1588
1589   /**
1590    * GtkWidget::size-allocate:
1591    * @widget: the object which received the signal.
1592    * @allocation:
1593    */
1594   widget_signals[SIZE_ALLOCATE] =
1595     g_signal_new (I_("size-allocate"),
1596                   G_TYPE_FROM_CLASS (gobject_class),
1597                   G_SIGNAL_RUN_FIRST,
1598                   G_STRUCT_OFFSET (GtkWidgetClass, size_allocate),
1599                   NULL, NULL,
1600                   _gtk_marshal_VOID__BOXED,
1601                   G_TYPE_NONE, 1,
1602                   GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
1603
1604   /**
1605    * GtkWidget::state-changed:
1606    * @widget: the object which received the signal.
1607    * @state: the previous state
1608    *
1609    * The ::state-changed signal is emitted when the widget state changes.
1610    * See gtk_widget_get_state().
1611    *
1612    * Deprecated: 3.0. Use #GtkWidget::state-flags-changed instead.
1613    */
1614   widget_signals[STATE_CHANGED] =
1615     g_signal_new (I_("state-changed"),
1616                   G_TYPE_FROM_CLASS (gobject_class),
1617                   G_SIGNAL_RUN_FIRST,
1618                   G_STRUCT_OFFSET (GtkWidgetClass, state_changed),
1619                   NULL, NULL,
1620                   _gtk_marshal_VOID__ENUM,
1621                   G_TYPE_NONE, 1,
1622                   GTK_TYPE_STATE_TYPE);
1623
1624   /**
1625    * GtkWidget::state-flags-changed:
1626    * @widget: the object which received the signal.
1627    * @flags: The previous state flags.
1628    *
1629    * The ::state-flags-changed signal is emitted when the widget state
1630    * changes, see gtk_widget_get_state_flags().
1631    *
1632    * Since: 3.0
1633    */
1634   widget_signals[STATE_FLAGS_CHANGED] =
1635     g_signal_new (I_("state-flags-changed"),
1636                   G_TYPE_FROM_CLASS (gobject_class),
1637                   G_SIGNAL_RUN_FIRST,
1638                   G_STRUCT_OFFSET (GtkWidgetClass, state_flags_changed),
1639                   NULL, NULL,
1640                   _gtk_marshal_VOID__FLAGS,
1641                   G_TYPE_NONE, 1,
1642                   GTK_TYPE_STATE_FLAGS);
1643
1644   /**
1645    * GtkWidget::parent-set:
1646    * @widget: the object on which the signal is emitted
1647    * @old_parent: (allow-none): the previous parent, or %NULL if the widget
1648    *   just got its initial parent.
1649    *
1650    * The ::parent-set signal is emitted when a new parent
1651    * has been set on a widget.
1652    */
1653   widget_signals[PARENT_SET] =
1654     g_signal_new (I_("parent-set"),
1655                   G_TYPE_FROM_CLASS (gobject_class),
1656                   G_SIGNAL_RUN_FIRST,
1657                   G_STRUCT_OFFSET (GtkWidgetClass, parent_set),
1658                   NULL, NULL,
1659                   _gtk_marshal_VOID__OBJECT,
1660                   G_TYPE_NONE, 1,
1661                   GTK_TYPE_WIDGET);
1662
1663   /**
1664    * GtkWidget::hierarchy-changed:
1665    * @widget: the object on which the signal is emitted
1666    * @previous_toplevel: (allow-none): the previous toplevel ancestor, or %NULL
1667    *   if the widget was previously unanchored
1668    *
1669    * The ::hierarchy-changed signal is emitted when the
1670    * anchored state of a widget changes. A widget is
1671    * <firstterm>anchored</firstterm> when its toplevel
1672    * ancestor is a #GtkWindow. This signal is emitted when
1673    * a widget changes from un-anchored to anchored or vice-versa.
1674    */
1675   widget_signals[HIERARCHY_CHANGED] =
1676     g_signal_new (I_("hierarchy-changed"),
1677                   G_TYPE_FROM_CLASS (gobject_class),
1678                   G_SIGNAL_RUN_LAST,
1679                   G_STRUCT_OFFSET (GtkWidgetClass, hierarchy_changed),
1680                   NULL, NULL,
1681                   _gtk_marshal_VOID__OBJECT,
1682                   G_TYPE_NONE, 1,
1683                   GTK_TYPE_WIDGET);
1684
1685   /**
1686    * GtkWidget::style-set:
1687    * @widget: the object on which the signal is emitted
1688    * @previous_style: (allow-none): the previous style, or %NULL if the widget
1689    *   just got its initial style
1690    *
1691    * The ::style-set signal is emitted when a new style has been set
1692    * on a widget. Note that style-modifying functions like
1693    * gtk_widget_modify_base() also cause this signal to be emitted.
1694    *
1695    * Note that this signal is emitted for changes to the deprecated
1696    * #GtkStyle. To track changes to the #GtkStyleContext associated
1697    * with a widget, use the #GtkWidget::style-updated signal.
1698    *
1699    * Deprecated:3.0: Use the #GtkWidget::style-updated signal
1700    */
1701   widget_signals[STYLE_SET] =
1702     g_signal_new (I_("style-set"),
1703                   G_TYPE_FROM_CLASS (gobject_class),
1704                   G_SIGNAL_RUN_FIRST,
1705                   G_STRUCT_OFFSET (GtkWidgetClass, style_set),
1706                   NULL, NULL,
1707                   _gtk_marshal_VOID__OBJECT,
1708                   G_TYPE_NONE, 1,
1709                   GTK_TYPE_STYLE);
1710
1711   /**
1712    * GtkWidget::style-updated:
1713    * @widget: the object on which the signal is emitted
1714    *
1715    * The ::style-updated signal is emitted when the #GtkStyleContext
1716    * of a widget is changed. Note that style-modifying functions like
1717    * gtk_widget_override_color() also cause this signal to be emitted.
1718    *
1719    * Since: 3.0
1720    */
1721   widget_signals[STYLE_UPDATED] =
1722     g_signal_new (I_("style-updated"),
1723                   G_TYPE_FROM_CLASS (gobject_class),
1724                   G_SIGNAL_RUN_FIRST,
1725                   G_STRUCT_OFFSET (GtkWidgetClass, style_updated),
1726                   NULL, NULL,
1727                   g_cclosure_marshal_VOID__VOID,
1728                   G_TYPE_NONE, 0);
1729
1730   /**
1731    * GtkWidget::direction-changed:
1732    * @widget: the object on which the signal is emitted
1733    * @previous_direction: the previous text direction of @widget
1734    *
1735    * The ::direction-changed signal is emitted when the text direction
1736    * of a widget changes.
1737    */
1738   widget_signals[DIRECTION_CHANGED] =
1739     g_signal_new (I_("direction-changed"),
1740                   G_TYPE_FROM_CLASS (gobject_class),
1741                   G_SIGNAL_RUN_FIRST,
1742                   G_STRUCT_OFFSET (GtkWidgetClass, direction_changed),
1743                   NULL, NULL,
1744                   _gtk_marshal_VOID__ENUM,
1745                   G_TYPE_NONE, 1,
1746                   GTK_TYPE_TEXT_DIRECTION);
1747
1748   /**
1749    * GtkWidget::grab-notify:
1750    * @widget: the object which received the signal
1751    * @was_grabbed: %FALSE if the widget becomes shadowed, %TRUE
1752    *               if it becomes unshadowed
1753    *
1754    * The ::grab-notify signal is emitted when a widget becomes
1755    * shadowed by a GTK+ grab (not a pointer or keyboard grab) on
1756    * another widget, or when it becomes unshadowed due to a grab
1757    * being removed.
1758    *
1759    * A widget is shadowed by a gtk_grab_add() when the topmost
1760    * grab widget in the grab stack of its window group is not
1761    * its ancestor.
1762    */
1763   widget_signals[GRAB_NOTIFY] =
1764     g_signal_new (I_("grab-notify"),
1765                   G_TYPE_FROM_CLASS (gobject_class),
1766                   G_SIGNAL_RUN_FIRST,
1767                   G_STRUCT_OFFSET (GtkWidgetClass, grab_notify),
1768                   NULL, NULL,
1769                   _gtk_marshal_VOID__BOOLEAN,
1770                   G_TYPE_NONE, 1,
1771                   G_TYPE_BOOLEAN);
1772
1773   /**
1774    * GtkWidget::child-notify:
1775    * @widget: the object which received the signal
1776    * @child_property: the #GParamSpec of the changed child property
1777    *
1778    * The ::child-notify signal is emitted for each
1779    * <link linkend="child-properties">child property</link>  that has
1780    * changed on an object. The signal's detail holds the property name.
1781    */
1782   widget_signals[CHILD_NOTIFY] =
1783     g_signal_new (I_("child-notify"),
1784                    G_TYPE_FROM_CLASS (gobject_class),
1785                    G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,
1786                    G_STRUCT_OFFSET (GtkWidgetClass, child_notify),
1787                    NULL, NULL,
1788                    g_cclosure_marshal_VOID__PARAM,
1789                    G_TYPE_NONE, 1,
1790                    G_TYPE_PARAM);
1791
1792   /**
1793    * GtkWidget::draw:
1794    * @widget: the object which received the signal
1795    * @cr: the cairo context to draw to
1796    *
1797    * This signal is emitted when a widget is supposed to render itself.
1798    * The @widget's top left corner must be painted at the origin of
1799    * the passed in context and be sized to the values returned by
1800    * gtk_widget_get_allocated_width() and
1801    * gtk_widget_get_allocated_height().
1802    *
1803    * Signal handlers connected to this signal can modify the cairo
1804    * context passed as @cr in any way they like and don't need to
1805    * restore it. The signal emission takes care of calling cairo_save()
1806    * before and cairo_restore() after invoking the handler.
1807    *
1808    * Returns: %TRUE to stop other handlers from being invoked for the event.
1809    % %FALSE to propagate the event further.
1810    *
1811    * Since: 3.0
1812    */
1813   widget_signals[DRAW] =
1814     g_signal_new (I_("draw"),
1815                    G_TYPE_FROM_CLASS (gobject_class),
1816                    G_SIGNAL_RUN_LAST,
1817                    G_STRUCT_OFFSET (GtkWidgetClass, draw),
1818                    _gtk_boolean_handled_accumulator, NULL,
1819                    gtk_widget_draw_marshaller,
1820                    G_TYPE_BOOLEAN, 1,
1821                    CAIRO_GOBJECT_TYPE_CONTEXT);
1822   g_signal_set_va_marshaller (widget_signals[DRAW], G_TYPE_FROM_CLASS (klass),
1823                               gtk_widget_draw_marshallerv);
1824
1825   /**
1826    * GtkWidget::mnemonic-activate:
1827    * @widget: the object which received the signal.
1828    * @arg1:
1829    *
1830    * Returns: %TRUE to stop other handlers from being invoked for the event.
1831    * %FALSE to propagate the event further.
1832    */
1833   widget_signals[MNEMONIC_ACTIVATE] =
1834     g_signal_new (I_("mnemonic-activate"),
1835                   G_TYPE_FROM_CLASS (gobject_class),
1836                   G_SIGNAL_RUN_LAST,
1837                   G_STRUCT_OFFSET (GtkWidgetClass, mnemonic_activate),
1838                   _gtk_boolean_handled_accumulator, NULL,
1839                   _gtk_marshal_BOOLEAN__BOOLEAN,
1840                   G_TYPE_BOOLEAN, 1,
1841                   G_TYPE_BOOLEAN);
1842
1843   /**
1844    * GtkWidget::grab-focus:
1845    * @widget: the object which received the signal.
1846    */
1847   widget_signals[GRAB_FOCUS] =
1848     g_signal_new (I_("grab-focus"),
1849                   G_TYPE_FROM_CLASS (gobject_class),
1850                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1851                   G_STRUCT_OFFSET (GtkWidgetClass, grab_focus),
1852                   NULL, NULL,
1853                   _gtk_marshal_VOID__VOID,
1854                   G_TYPE_NONE, 0);
1855
1856   /**
1857    * GtkWidget::focus:
1858    * @widget: the object which received the signal.
1859    * @direction:
1860    *
1861    * Returns: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
1862    */
1863   widget_signals[FOCUS] =
1864     g_signal_new (I_("focus"),
1865                   G_TYPE_FROM_CLASS (klass),
1866                   G_SIGNAL_RUN_LAST,
1867                   G_STRUCT_OFFSET (GtkWidgetClass, focus),
1868                   _gtk_boolean_handled_accumulator, NULL,
1869                   _gtk_marshal_BOOLEAN__ENUM,
1870                   G_TYPE_BOOLEAN, 1,
1871                   GTK_TYPE_DIRECTION_TYPE);
1872
1873   /**
1874    * GtkWidget::move-focus:
1875    * @widget: the object which received the signal.
1876    * @direction:
1877    */
1878   widget_signals[MOVE_FOCUS] =
1879     g_signal_new (I_("move-focus"),
1880                   G_TYPE_FROM_CLASS (klass),
1881                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1882                   G_STRUCT_OFFSET (GtkWidgetClass, move_focus),
1883                   NULL, NULL,
1884                   _gtk_marshal_VOID__ENUM,
1885                   G_TYPE_NONE,
1886                   1,
1887                   GTK_TYPE_DIRECTION_TYPE);
1888
1889   /**
1890    * GtkWidget::keynav-failed:
1891    * @widget: the object which received the signal
1892    * @direction: the direction of movement
1893    *
1894    * Gets emitted if keyboard navigation fails.
1895    * See gtk_widget_keynav_failed() for details.
1896    *
1897    * Returns: %TRUE if stopping keyboard navigation is fine, %FALSE
1898    *          if the emitting widget should try to handle the keyboard
1899    *          navigation attempt in its parent container(s).
1900    *
1901    * Since: 2.12
1902    **/
1903   widget_signals[KEYNAV_FAILED] =
1904     g_signal_new (I_("keynav-failed"),
1905                   G_TYPE_FROM_CLASS (klass),
1906                   G_SIGNAL_RUN_LAST,
1907                   G_STRUCT_OFFSET (GtkWidgetClass, keynav_failed),
1908                   _gtk_boolean_handled_accumulator, NULL,
1909                   _gtk_marshal_BOOLEAN__ENUM,
1910                   G_TYPE_BOOLEAN, 1,
1911                   GTK_TYPE_DIRECTION_TYPE);
1912
1913   /**
1914    * GtkWidget::event:
1915    * @widget: the object which received the signal.
1916    * @event: the #GdkEvent which triggered this signal
1917    *
1918    * The GTK+ main loop will emit three signals for each GDK event delivered
1919    * to a widget: one generic ::event signal, another, more specific,
1920    * signal that matches the type of event delivered (e.g.
1921    * #GtkWidget::key-press-event) and finally a generic
1922    * #GtkWidget::event-after signal.
1923    *
1924    * Returns: %TRUE to stop other handlers from being invoked for the event
1925    * and to cancel the emission of the second specific ::event signal.
1926    *   %FALSE to propagate the event further and to allow the emission of
1927    *   the second signal. The ::event-after signal is emitted regardless of
1928    *   the return value.
1929    */
1930   widget_signals[EVENT] =
1931     g_signal_new (I_("event"),
1932                   G_TYPE_FROM_CLASS (klass),
1933                   G_SIGNAL_RUN_LAST,
1934                   G_STRUCT_OFFSET (GtkWidgetClass, event),
1935                   _gtk_boolean_handled_accumulator, NULL,
1936                   _gtk_marshal_BOOLEAN__BOXED,
1937                   G_TYPE_BOOLEAN, 1,
1938                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
1939   g_signal_set_va_marshaller (widget_signals[EVENT], G_TYPE_FROM_CLASS (klass),
1940                               _gtk_marshal_BOOLEAN__BOXEDv);
1941
1942   /**
1943    * GtkWidget::event-after:
1944    * @widget: the object which received the signal.
1945    * @event: the #GdkEvent which triggered this signal
1946    *
1947    * After the emission of the #GtkWidget::event signal and (optionally)
1948    * the second more specific signal, ::event-after will be emitted
1949    * regardless of the previous two signals handlers return values.
1950    *
1951    */
1952   widget_signals[EVENT_AFTER] =
1953     g_signal_new (I_("event-after"),
1954                   G_TYPE_FROM_CLASS (klass),
1955                   0,
1956                   0,
1957                   NULL, NULL,
1958                   _gtk_marshal_VOID__BOXED,
1959                   G_TYPE_NONE, 1,
1960                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
1961   g_signal_set_va_marshaller (widget_signals[EVENT_AFTER], G_TYPE_FROM_CLASS (klass),
1962                               _gtk_marshal_BOOLEAN__BOXEDv);
1963
1964   /**
1965    * GtkWidget::button-press-event:
1966    * @widget: the object which received the signal.
1967    * @event: (type Gdk.EventButton): the #GdkEventButton which triggered
1968    *   this signal.
1969    *
1970    * The ::button-press-event signal will be emitted when a button
1971    * (typically from a mouse) is pressed.
1972    *
1973    * To receive this signal, the #GdkWindow associated to the
1974    * widget needs to enable the #GDK_BUTTON_PRESS_MASK mask.
1975    *
1976    * This signal will be sent to the grab widget if there is one.
1977    *
1978    * Returns: %TRUE to stop other handlers from being invoked for the event.
1979    *   %FALSE to propagate the event further.
1980    */
1981   widget_signals[BUTTON_PRESS_EVENT] =
1982     g_signal_new (I_("button-press-event"),
1983                   G_TYPE_FROM_CLASS (klass),
1984                   G_SIGNAL_RUN_LAST,
1985                   G_STRUCT_OFFSET (GtkWidgetClass, button_press_event),
1986                   _gtk_boolean_handled_accumulator, NULL,
1987                   _gtk_marshal_BOOLEAN__BOXED,
1988                   G_TYPE_BOOLEAN, 1,
1989                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
1990   g_signal_set_va_marshaller (widget_signals[BUTTON_PRESS_EVENT], G_TYPE_FROM_CLASS (klass),
1991                               _gtk_marshal_BOOLEAN__BOXEDv);
1992
1993   /**
1994    * GtkWidget::button-release-event:
1995    * @widget: the object which received the signal.
1996    * @event: (type Gdk.EventButton): the #GdkEventButton which triggered
1997    *   this signal.
1998    *
1999    * The ::button-release-event signal will be emitted when a button
2000    * (typically from a mouse) is released.
2001    *
2002    * To receive this signal, the #GdkWindow associated to the
2003    * widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask.
2004    *
2005    * This signal will be sent to the grab widget if there is one.
2006    *
2007    * Returns: %TRUE to stop other handlers from being invoked for the event.
2008    *   %FALSE to propagate the event further.
2009    */
2010   widget_signals[BUTTON_RELEASE_EVENT] =
2011     g_signal_new (I_("button-release-event"),
2012                   G_TYPE_FROM_CLASS (klass),
2013                   G_SIGNAL_RUN_LAST,
2014                   G_STRUCT_OFFSET (GtkWidgetClass, button_release_event),
2015                   _gtk_boolean_handled_accumulator, NULL,
2016                   _gtk_marshal_BOOLEAN__BOXED,
2017                   G_TYPE_BOOLEAN, 1,
2018                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2019   g_signal_set_va_marshaller (widget_signals[BUTTON_RELEASE_EVENT], G_TYPE_FROM_CLASS (klass),
2020                               _gtk_marshal_BOOLEAN__BOXEDv);
2021
2022   widget_signals[TOUCH_EVENT] =
2023     g_signal_new (I_("touch-event"),
2024                   G_TYPE_FROM_CLASS (klass),
2025                   G_SIGNAL_RUN_LAST,
2026                   G_STRUCT_OFFSET (GtkWidgetClass, touch_event),
2027                   _gtk_boolean_handled_accumulator, NULL,
2028                   _gtk_marshal_BOOLEAN__BOXED,
2029                   G_TYPE_BOOLEAN, 1,
2030                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2031   g_signal_set_va_marshaller (widget_signals[TOUCH_EVENT], G_TYPE_FROM_CLASS (klass),
2032                               _gtk_marshal_BOOLEAN__BOXEDv);
2033
2034   /**
2035    * GtkWidget::scroll-event:
2036    * @widget: the object which received the signal.
2037    * @event: (type Gdk.EventScroll): the #GdkEventScroll which triggered
2038    *   this signal.
2039    *
2040    * The ::scroll-event signal is emitted when a button in the 4 to 7
2041    * range is pressed. Wheel mice are usually configured to generate
2042    * button press events for buttons 4 and 5 when the wheel is turned.
2043    *
2044    * To receive this signal, the #GdkWindow associated to the widget needs
2045    * to enable the #GDK_SCROLL_MASK mask.
2046    *
2047    * This signal will be sent to the grab widget if there is one.
2048    *
2049    * Returns: %TRUE to stop other handlers from being invoked for the event.
2050    *   %FALSE to propagate the event further.
2051    */
2052   widget_signals[SCROLL_EVENT] =
2053     g_signal_new (I_("scroll-event"),
2054                   G_TYPE_FROM_CLASS (klass),
2055                   G_SIGNAL_RUN_LAST,
2056                   G_STRUCT_OFFSET (GtkWidgetClass, scroll_event),
2057                   _gtk_boolean_handled_accumulator, NULL,
2058                   _gtk_marshal_BOOLEAN__BOXED,
2059                   G_TYPE_BOOLEAN, 1,
2060                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2061   g_signal_set_va_marshaller (widget_signals[SCROLL_EVENT], G_TYPE_FROM_CLASS (klass),
2062                               _gtk_marshal_BOOLEAN__BOXEDv);
2063
2064   /**
2065    * GtkWidget::motion-notify-event:
2066    * @widget: the object which received the signal.
2067    * @event: (type Gdk.EventMotion): the #GdkEventMotion which triggered
2068    *   this signal.
2069    *
2070    * The ::motion-notify-event signal is emitted when the pointer moves
2071    * over the widget's #GdkWindow.
2072    *
2073    * To receive this signal, the #GdkWindow associated to the widget
2074    * needs to enable the #GDK_POINTER_MOTION_MASK mask.
2075    *
2076    * This signal will be sent to the grab widget if there is one.
2077    *
2078    * Returns: %TRUE to stop other handlers from being invoked for the event.
2079    *   %FALSE to propagate the event further.
2080    */
2081   widget_signals[MOTION_NOTIFY_EVENT] =
2082     g_signal_new (I_("motion-notify-event"),
2083                   G_TYPE_FROM_CLASS (klass),
2084                   G_SIGNAL_RUN_LAST,
2085                   G_STRUCT_OFFSET (GtkWidgetClass, motion_notify_event),
2086                   _gtk_boolean_handled_accumulator, NULL,
2087                   _gtk_marshal_BOOLEAN__BOXED,
2088                   G_TYPE_BOOLEAN, 1,
2089                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2090   g_signal_set_va_marshaller (widget_signals[MOTION_NOTIFY_EVENT], G_TYPE_FROM_CLASS (klass),
2091                               _gtk_marshal_BOOLEAN__BOXEDv);
2092
2093   /**
2094    * GtkWidget::composited-changed:
2095    * @widget: the object on which the signal is emitted
2096    *
2097    * The ::composited-changed signal is emitted when the composited
2098    * status of @widget<!-- -->s screen changes.
2099    * See gdk_screen_is_composited().
2100    */
2101   widget_signals[COMPOSITED_CHANGED] =
2102     g_signal_new (I_("composited-changed"),
2103                   G_TYPE_FROM_CLASS (klass),
2104                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2105                   G_STRUCT_OFFSET (GtkWidgetClass, composited_changed),
2106                   NULL, NULL,
2107                   _gtk_marshal_VOID__VOID,
2108                   G_TYPE_NONE, 0);
2109
2110   /**
2111    * GtkWidget::delete-event:
2112    * @widget: the object which received the signal
2113    * @event: the event which triggered this signal
2114    *
2115    * The ::delete-event signal is emitted if a user requests that
2116    * a toplevel window is closed. The default handler for this signal
2117    * destroys the window. Connecting gtk_widget_hide_on_delete() to
2118    * this signal will cause the window to be hidden instead, so that
2119    * it can later be shown again without reconstructing it.
2120    *
2121    * Returns: %TRUE to stop other handlers from being invoked for the event.
2122    *   %FALSE to propagate the event further.
2123    */
2124   widget_signals[DELETE_EVENT] =
2125     g_signal_new (I_("delete-event"),
2126                   G_TYPE_FROM_CLASS (klass),
2127                   G_SIGNAL_RUN_LAST,
2128                   G_STRUCT_OFFSET (GtkWidgetClass, delete_event),
2129                   _gtk_boolean_handled_accumulator, NULL,
2130                   _gtk_marshal_BOOLEAN__BOXED,
2131                   G_TYPE_BOOLEAN, 1,
2132                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2133   g_signal_set_va_marshaller (widget_signals[DELETE_EVENT], G_TYPE_FROM_CLASS (klass),
2134                               _gtk_marshal_BOOLEAN__BOXEDv);
2135
2136   /**
2137    * GtkWidget::destroy-event:
2138    * @widget: the object which received the signal.
2139    * @event: the event which triggered this signal
2140    *
2141    * The ::destroy-event signal is emitted when a #GdkWindow is destroyed.
2142    * You rarely get this signal, because most widgets disconnect themselves
2143    * from their window before they destroy it, so no widget owns the
2144    * window at destroy time.
2145    *
2146    * To receive this signal, the #GdkWindow associated to the widget needs
2147    * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
2148    * automatically for all new windows.
2149    *
2150    * Returns: %TRUE to stop other handlers from being invoked for the event.
2151    *   %FALSE to propagate the event further.
2152    */
2153   widget_signals[DESTROY_EVENT] =
2154     g_signal_new (I_("destroy-event"),
2155                   G_TYPE_FROM_CLASS (klass),
2156                   G_SIGNAL_RUN_LAST,
2157                   G_STRUCT_OFFSET (GtkWidgetClass, destroy_event),
2158                   _gtk_boolean_handled_accumulator, NULL,
2159                   _gtk_marshal_BOOLEAN__BOXED,
2160                   G_TYPE_BOOLEAN, 1,
2161                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2162   g_signal_set_va_marshaller (widget_signals[DESTROY_EVENT], G_TYPE_FROM_CLASS (klass),
2163                               _gtk_marshal_BOOLEAN__BOXEDv);
2164
2165   /**
2166    * GtkWidget::key-press-event:
2167    * @widget: the object which received the signal
2168    * @event: (type Gdk.EventKey): the #GdkEventKey which triggered this signal.
2169    *
2170    * The ::key-press-event signal is emitted when a key is pressed. The signal
2171    * emission will reoccur at the key-repeat rate when the key is kept pressed.
2172    *
2173    * To receive this signal, the #GdkWindow associated to the widget needs
2174    * to enable the #GDK_KEY_PRESS_MASK mask.
2175    *
2176    * This signal will be sent to the grab widget if there is one.
2177    *
2178    * Returns: %TRUE to stop other handlers from being invoked for the event.
2179    *   %FALSE to propagate the event further.
2180    */
2181   widget_signals[KEY_PRESS_EVENT] =
2182     g_signal_new (I_("key-press-event"),
2183                   G_TYPE_FROM_CLASS (klass),
2184                   G_SIGNAL_RUN_LAST,
2185                   G_STRUCT_OFFSET (GtkWidgetClass, key_press_event),
2186                   _gtk_boolean_handled_accumulator, NULL,
2187                   _gtk_marshal_BOOLEAN__BOXED,
2188                   G_TYPE_BOOLEAN, 1,
2189                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2190   g_signal_set_va_marshaller (widget_signals[KEY_PRESS_EVENT], G_TYPE_FROM_CLASS (klass),
2191                               _gtk_marshal_BOOLEAN__BOXEDv);
2192
2193   /**
2194    * GtkWidget::key-release-event:
2195    * @widget: the object which received the signal
2196    * @event: (type Gdk.EventKey): the #GdkEventKey which triggered this signal.
2197    *
2198    * The ::key-release-event signal is emitted when a key is released.
2199    *
2200    * To receive this signal, the #GdkWindow associated to the widget needs
2201    * to enable the #GDK_KEY_RELEASE_MASK mask.
2202    *
2203    * This signal will be sent to the grab widget if there is one.
2204    *
2205    * Returns: %TRUE to stop other handlers from being invoked for the event.
2206    *   %FALSE to propagate the event further.
2207    */
2208   widget_signals[KEY_RELEASE_EVENT] =
2209     g_signal_new (I_("key-release-event"),
2210                   G_TYPE_FROM_CLASS (klass),
2211                   G_SIGNAL_RUN_LAST,
2212                   G_STRUCT_OFFSET (GtkWidgetClass, key_release_event),
2213                   _gtk_boolean_handled_accumulator, NULL,
2214                   _gtk_marshal_BOOLEAN__BOXED,
2215                   G_TYPE_BOOLEAN, 1,
2216                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2217   g_signal_set_va_marshaller (widget_signals[KEY_RELEASE_EVENT], G_TYPE_FROM_CLASS (klass),
2218                               _gtk_marshal_BOOLEAN__BOXEDv);
2219
2220   /**
2221    * GtkWidget::enter-notify-event:
2222    * @widget: the object which received the signal
2223    * @event: (type Gdk.EventCrossing): the #GdkEventCrossing which triggered
2224    *   this signal.
2225    *
2226    * The ::enter-notify-event will be emitted when the pointer enters
2227    * the @widget's window.
2228    *
2229    * To receive this signal, the #GdkWindow associated to the widget needs
2230    * to enable the #GDK_ENTER_NOTIFY_MASK mask.
2231    *
2232    * This signal will be sent to the grab widget if there is one.
2233    *
2234    * Returns: %TRUE to stop other handlers from being invoked for the event.
2235    *   %FALSE to propagate the event further.
2236    */
2237   widget_signals[ENTER_NOTIFY_EVENT] =
2238     g_signal_new (I_("enter-notify-event"),
2239                   G_TYPE_FROM_CLASS (klass),
2240                   G_SIGNAL_RUN_LAST,
2241                   G_STRUCT_OFFSET (GtkWidgetClass, enter_notify_event),
2242                   _gtk_boolean_handled_accumulator, NULL,
2243                   _gtk_marshal_BOOLEAN__BOXED,
2244                   G_TYPE_BOOLEAN, 1,
2245                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2246   g_signal_set_va_marshaller (widget_signals[ENTER_NOTIFY_EVENT], G_TYPE_FROM_CLASS (klass),
2247                               _gtk_marshal_BOOLEAN__BOXEDv);
2248
2249   /**
2250    * GtkWidget::leave-notify-event:
2251    * @widget: the object which received the signal
2252    * @event: (type Gdk.EventCrossing): the #GdkEventCrossing which triggered
2253    *   this signal.
2254    *
2255    * The ::leave-notify-event will be emitted when the pointer leaves
2256    * the @widget's window.
2257    *
2258    * To receive this signal, the #GdkWindow associated to the widget needs
2259    * to enable the #GDK_LEAVE_NOTIFY_MASK mask.
2260    *
2261    * This signal will be sent to the grab widget if there is one.
2262    *
2263    * Returns: %TRUE to stop other handlers from being invoked for the event.
2264    *   %FALSE to propagate the event further.
2265    */
2266   widget_signals[LEAVE_NOTIFY_EVENT] =
2267     g_signal_new (I_("leave-notify-event"),
2268                   G_TYPE_FROM_CLASS (klass),
2269                   G_SIGNAL_RUN_LAST,
2270                   G_STRUCT_OFFSET (GtkWidgetClass, leave_notify_event),
2271                   _gtk_boolean_handled_accumulator, NULL,
2272                   _gtk_marshal_BOOLEAN__BOXED,
2273                   G_TYPE_BOOLEAN, 1,
2274                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2275   g_signal_set_va_marshaller (widget_signals[LEAVE_NOTIFY_EVENT], G_TYPE_FROM_CLASS (klass),
2276                               _gtk_marshal_BOOLEAN__BOXEDv);
2277
2278   /**
2279    * GtkWidget::configure-event:
2280    * @widget: the object which received the signal
2281    * @event: (type Gdk.EventConfigure): the #GdkEventConfigure which triggered
2282    *   this signal.
2283    *
2284    * The ::configure-event signal will be emitted when the size, position or
2285    * stacking of the @widget's window has changed.
2286    *
2287    * To receive this signal, the #GdkWindow associated to the widget needs
2288    * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
2289    * automatically for all new windows.
2290    *
2291    * Returns: %TRUE to stop other handlers from being invoked for the event.
2292    *   %FALSE to propagate the event further.
2293    */
2294   widget_signals[CONFIGURE_EVENT] =
2295     g_signal_new (I_("configure-event"),
2296                   G_TYPE_FROM_CLASS (klass),
2297                   G_SIGNAL_RUN_LAST,
2298                   G_STRUCT_OFFSET (GtkWidgetClass, configure_event),
2299                   _gtk_boolean_handled_accumulator, NULL,
2300                   _gtk_marshal_BOOLEAN__BOXED,
2301                   G_TYPE_BOOLEAN, 1,
2302                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2303   g_signal_set_va_marshaller (widget_signals[CONFIGURE_EVENT], G_TYPE_FROM_CLASS (klass),
2304                               _gtk_marshal_BOOLEAN__BOXEDv);
2305
2306   /**
2307    * GtkWidget::focus-in-event:
2308    * @widget: the object which received the signal
2309    * @event: (type Gdk.EventFocus): the #GdkEventFocus which triggered
2310    *   this signal.
2311    *
2312    * The ::focus-in-event signal will be emitted when the keyboard focus
2313    * enters the @widget's window.
2314    *
2315    * To receive this signal, the #GdkWindow associated to the widget needs
2316    * to enable the #GDK_FOCUS_CHANGE_MASK mask.
2317    *
2318    * Returns: %TRUE to stop other handlers from being invoked for the event.
2319    *   %FALSE to propagate the event further.
2320    */
2321   widget_signals[FOCUS_IN_EVENT] =
2322     g_signal_new (I_("focus-in-event"),
2323                   G_TYPE_FROM_CLASS (klass),
2324                   G_SIGNAL_RUN_LAST,
2325                   G_STRUCT_OFFSET (GtkWidgetClass, focus_in_event),
2326                   _gtk_boolean_handled_accumulator, NULL,
2327                   _gtk_marshal_BOOLEAN__BOXED,
2328                   G_TYPE_BOOLEAN, 1,
2329                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2330   g_signal_set_va_marshaller (widget_signals[FOCUS_IN_EVENT], G_TYPE_FROM_CLASS (klass),
2331                               _gtk_marshal_BOOLEAN__BOXEDv);
2332
2333   /**
2334    * GtkWidget::focus-out-event:
2335    * @widget: the object which received the signal
2336    * @event: (type Gdk.EventFocus): the #GdkEventFocus which triggered this
2337    *   signal.
2338    *
2339    * The ::focus-out-event signal will be emitted when the keyboard focus
2340    * leaves the @widget's window.
2341    *
2342    * To receive this signal, the #GdkWindow associated to the widget needs
2343    * to enable the #GDK_FOCUS_CHANGE_MASK mask.
2344    *
2345    * Returns: %TRUE to stop other handlers from being invoked for the event.
2346    *   %FALSE to propagate the event further.
2347    */
2348   widget_signals[FOCUS_OUT_EVENT] =
2349     g_signal_new (I_("focus-out-event"),
2350                   G_TYPE_FROM_CLASS (klass),
2351                   G_SIGNAL_RUN_LAST,
2352                   G_STRUCT_OFFSET (GtkWidgetClass, focus_out_event),
2353                   _gtk_boolean_handled_accumulator, NULL,
2354                   _gtk_marshal_BOOLEAN__BOXED,
2355                   G_TYPE_BOOLEAN, 1,
2356                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2357   g_signal_set_va_marshaller (widget_signals[FOCUS_OUT_EVENT], G_TYPE_FROM_CLASS (klass),
2358                               _gtk_marshal_BOOLEAN__BOXEDv);
2359
2360   /**
2361    * GtkWidget::map-event:
2362    * @widget: the object which received the signal
2363    * @event: (type Gdk.EventAny): the #GdkEventAny which triggered this signal.
2364    *
2365    * The ::map-event signal will be emitted when the @widget's window is
2366    * mapped. A window is mapped when it becomes visible on the screen.
2367    *
2368    * To receive this signal, the #GdkWindow associated to the widget needs
2369    * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
2370    * automatically for all new windows.
2371    *
2372    * Returns: %TRUE to stop other handlers from being invoked for the event.
2373    *   %FALSE to propagate the event further.
2374    */
2375   widget_signals[MAP_EVENT] =
2376     g_signal_new (I_("map-event"),
2377                   G_TYPE_FROM_CLASS (klass),
2378                   G_SIGNAL_RUN_LAST,
2379                   G_STRUCT_OFFSET (GtkWidgetClass, map_event),
2380                   _gtk_boolean_handled_accumulator, NULL,
2381                   _gtk_marshal_BOOLEAN__BOXED,
2382                   G_TYPE_BOOLEAN, 1,
2383                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2384   g_signal_set_va_marshaller (widget_signals[MAP_EVENT], G_TYPE_FROM_CLASS (klass),
2385                               _gtk_marshal_BOOLEAN__BOXEDv);
2386
2387   /**
2388    * GtkWidget::unmap-event:
2389    * @widget: the object which received the signal
2390    * @event: (type Gdk.EventAny): the #GdkEventAny which triggered this signal
2391    *
2392    * The ::unmap-event signal will be emitted when the @widget's window is
2393    * unmapped. A window is unmapped when it becomes invisible on the screen.
2394    *
2395    * To receive this signal, the #GdkWindow associated to the widget needs
2396    * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
2397    * automatically for all new windows.
2398    *
2399    * Returns: %TRUE to stop other handlers from being invoked for the event.
2400    *   %FALSE to propagate the event further.
2401    */
2402   widget_signals[UNMAP_EVENT] =
2403     g_signal_new (I_("unmap-event"),
2404                   G_TYPE_FROM_CLASS (klass),
2405                   G_SIGNAL_RUN_LAST,
2406                   G_STRUCT_OFFSET (GtkWidgetClass, unmap_event),
2407                   _gtk_boolean_handled_accumulator, NULL,
2408                   _gtk_marshal_BOOLEAN__BOXED,
2409                   G_TYPE_BOOLEAN, 1,
2410                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2411   g_signal_set_va_marshaller (widget_signals[UNMAP_EVENT], G_TYPE_FROM_CLASS (klass),
2412                               _gtk_marshal_BOOLEAN__BOXEDv);
2413
2414   /**
2415    * GtkWidget::property-notify-event:
2416    * @widget: the object which received the signal
2417    * @event: (type Gdk.EventProperty): the #GdkEventProperty which triggered
2418    *   this signal.
2419    *
2420    * The ::property-notify-event signal will be emitted when a property on
2421    * the @widget's window has been changed or deleted.
2422    *
2423    * To receive this signal, the #GdkWindow associated to the widget needs
2424    * to enable the #GDK_PROPERTY_CHANGE_MASK mask.
2425    *
2426    * Returns: %TRUE to stop other handlers from being invoked for the event.
2427    *   %FALSE to propagate the event further.
2428    */
2429   widget_signals[PROPERTY_NOTIFY_EVENT] =
2430     g_signal_new (I_("property-notify-event"),
2431                   G_TYPE_FROM_CLASS (klass),
2432                   G_SIGNAL_RUN_LAST,
2433                   G_STRUCT_OFFSET (GtkWidgetClass, property_notify_event),
2434                   _gtk_boolean_handled_accumulator, NULL,
2435                   _gtk_marshal_BOOLEAN__BOXED,
2436                   G_TYPE_BOOLEAN, 1,
2437                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2438   g_signal_set_va_marshaller (widget_signals[PROPERTY_NOTIFY_EVENT], G_TYPE_FROM_CLASS (klass),
2439                               _gtk_marshal_BOOLEAN__BOXEDv);
2440
2441   /**
2442    * GtkWidget::selection-clear-event:
2443    * @widget: the object which received the signal
2444    * @event: (type Gdk.EventSelection): the #GdkEventSelection which triggered
2445    *   this signal.
2446    *
2447    * The ::selection-clear-event signal will be emitted when the
2448    * the @widget's window has lost ownership of a selection.
2449    *
2450    * Returns: %TRUE to stop other handlers from being invoked for the event.
2451    *   %FALSE to propagate the event further.
2452    */
2453   widget_signals[SELECTION_CLEAR_EVENT] =
2454     g_signal_new (I_("selection-clear-event"),
2455                   G_TYPE_FROM_CLASS (klass),
2456                   G_SIGNAL_RUN_LAST,
2457                   G_STRUCT_OFFSET (GtkWidgetClass, selection_clear_event),
2458                   _gtk_boolean_handled_accumulator, NULL,
2459                   _gtk_marshal_BOOLEAN__BOXED,
2460                   G_TYPE_BOOLEAN, 1,
2461                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2462   g_signal_set_va_marshaller (widget_signals[SELECTION_CLEAR_EVENT], G_TYPE_FROM_CLASS (klass),
2463                               _gtk_marshal_BOOLEAN__BOXEDv);
2464
2465   /**
2466    * GtkWidget::selection-request-event:
2467    * @widget: the object which received the signal
2468    * @event: (type Gdk.EventSelection): the #GdkEventSelection which triggered
2469    *   this signal.
2470    *
2471    * The ::selection-request-event signal will be emitted when
2472    * another client requests ownership of the selection owned by
2473    * the @widget's window.
2474    *
2475    * Returns: %TRUE to stop other handlers from being invoked for the event.
2476    *   %FALSE to propagate the event further.
2477    */
2478   widget_signals[SELECTION_REQUEST_EVENT] =
2479     g_signal_new (I_("selection-request-event"),
2480                   G_TYPE_FROM_CLASS (klass),
2481                   G_SIGNAL_RUN_LAST,
2482                   G_STRUCT_OFFSET (GtkWidgetClass, selection_request_event),
2483                   _gtk_boolean_handled_accumulator, NULL,
2484                   _gtk_marshal_BOOLEAN__BOXED,
2485                   G_TYPE_BOOLEAN, 1,
2486                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2487   g_signal_set_va_marshaller (widget_signals[SELECTION_REQUEST_EVENT], G_TYPE_FROM_CLASS (klass),
2488                               _gtk_marshal_BOOLEAN__BOXEDv);
2489
2490   /**
2491    * GtkWidget::selection-notify-event:
2492    * @widget: the object which received the signal.
2493    * @event: (type Gdk.EventSelection):
2494    *
2495    * Returns: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
2496    */
2497   widget_signals[SELECTION_NOTIFY_EVENT] =
2498     g_signal_new (I_("selection-notify-event"),
2499                   G_TYPE_FROM_CLASS (klass),
2500                   G_SIGNAL_RUN_LAST,
2501                   G_STRUCT_OFFSET (GtkWidgetClass, selection_notify_event),
2502                   _gtk_boolean_handled_accumulator, NULL,
2503                   _gtk_marshal_BOOLEAN__BOXED,
2504                   G_TYPE_BOOLEAN, 1,
2505                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2506   g_signal_set_va_marshaller (widget_signals[SELECTION_NOTIFY_EVENT], G_TYPE_FROM_CLASS (klass),
2507                               _gtk_marshal_BOOLEAN__BOXEDv);
2508
2509   /**
2510    * GtkWidget::selection-received:
2511    * @widget: the object which received the signal.
2512    * @data:
2513    * @time:
2514    */
2515   widget_signals[SELECTION_RECEIVED] =
2516     g_signal_new (I_("selection-received"),
2517                   G_TYPE_FROM_CLASS (klass),
2518                   G_SIGNAL_RUN_LAST,
2519                   G_STRUCT_OFFSET (GtkWidgetClass, selection_received),
2520                   NULL, NULL,
2521                   _gtk_marshal_VOID__BOXED_UINT,
2522                   G_TYPE_NONE, 2,
2523                   GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
2524                   G_TYPE_UINT);
2525
2526   /**
2527    * GtkWidget::selection-get:
2528    * @widget: the object which received the signal.
2529    * @data:
2530    * @info:
2531    * @time:
2532    */
2533   widget_signals[SELECTION_GET] =
2534     g_signal_new (I_("selection-get"),
2535                   G_TYPE_FROM_CLASS (klass),
2536                   G_SIGNAL_RUN_LAST,
2537                   G_STRUCT_OFFSET (GtkWidgetClass, selection_get),
2538                   NULL, NULL,
2539                   _gtk_marshal_VOID__BOXED_UINT_UINT,
2540                   G_TYPE_NONE, 3,
2541                   GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
2542                   G_TYPE_UINT,
2543                   G_TYPE_UINT);
2544
2545   /**
2546    * GtkWidget::proximity-in-event:
2547    * @widget: the object which received the signal
2548    * @event: (type Gdk.EventProximity): the #GdkEventProximity which triggered
2549    *   this signal.
2550    *
2551    * To receive this signal the #GdkWindow associated to the widget needs
2552    * to enable the #GDK_PROXIMITY_IN_MASK mask.
2553    *
2554    * This signal will be sent to the grab widget if there is one.
2555    *
2556    * Returns: %TRUE to stop other handlers from being invoked for the event.
2557    *   %FALSE to propagate the event further.
2558    */
2559   widget_signals[PROXIMITY_IN_EVENT] =
2560     g_signal_new (I_("proximity-in-event"),
2561                   G_TYPE_FROM_CLASS (klass),
2562                   G_SIGNAL_RUN_LAST,
2563                   G_STRUCT_OFFSET (GtkWidgetClass, proximity_in_event),
2564                   _gtk_boolean_handled_accumulator, NULL,
2565                   _gtk_marshal_BOOLEAN__BOXED,
2566                   G_TYPE_BOOLEAN, 1,
2567                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2568   g_signal_set_va_marshaller (widget_signals[PROXIMITY_IN_EVENT], G_TYPE_FROM_CLASS (klass),
2569                               _gtk_marshal_BOOLEAN__BOXEDv);
2570
2571   /**
2572    * GtkWidget::proximity-out-event:
2573    * @widget: the object which received the signal
2574    * @event: (type Gdk.EventProximity): the #GdkEventProximity which triggered
2575    *   this signal.
2576    *
2577    * To receive this signal the #GdkWindow associated to the widget needs
2578    * to enable the #GDK_PROXIMITY_OUT_MASK mask.
2579    *
2580    * This signal will be sent to the grab widget if there is one.
2581    *
2582    * Returns: %TRUE to stop other handlers from being invoked for the event.
2583    *   %FALSE to propagate the event further.
2584    */
2585   widget_signals[PROXIMITY_OUT_EVENT] =
2586     g_signal_new (I_("proximity-out-event"),
2587                   G_TYPE_FROM_CLASS (klass),
2588                   G_SIGNAL_RUN_LAST,
2589                   G_STRUCT_OFFSET (GtkWidgetClass, proximity_out_event),
2590                   _gtk_boolean_handled_accumulator, NULL,
2591                   _gtk_marshal_BOOLEAN__BOXED,
2592                   G_TYPE_BOOLEAN, 1,
2593                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2594   g_signal_set_va_marshaller (widget_signals[PROXIMITY_OUT_EVENT], G_TYPE_FROM_CLASS (klass),
2595                               _gtk_marshal_BOOLEAN__BOXEDv);
2596
2597   /**
2598    * GtkWidget::drag-leave:
2599    * @widget: the object which received the signal.
2600    * @context: the drag context
2601    * @time: the timestamp of the motion event
2602    *
2603    * The ::drag-leave signal is emitted on the drop site when the cursor
2604    * leaves the widget. A typical reason to connect to this signal is to
2605    * undo things done in #GtkWidget::drag-motion, e.g. undo highlighting
2606    * with gtk_drag_unhighlight()
2607    */
2608   widget_signals[DRAG_LEAVE] =
2609     g_signal_new (I_("drag-leave"),
2610                   G_TYPE_FROM_CLASS (klass),
2611                   G_SIGNAL_RUN_LAST,
2612                   G_STRUCT_OFFSET (GtkWidgetClass, drag_leave),
2613                   NULL, NULL,
2614                   _gtk_marshal_VOID__OBJECT_UINT,
2615                   G_TYPE_NONE, 2,
2616                   GDK_TYPE_DRAG_CONTEXT,
2617                   G_TYPE_UINT);
2618
2619   /**
2620    * GtkWidget::drag-begin:
2621    * @widget: the object which received the signal
2622    * @context: the drag context
2623    *
2624    * The ::drag-begin signal is emitted on the drag source when a drag is
2625    * started. A typical reason to connect to this signal is to set up a
2626    * custom drag icon with e.g. gtk_drag_source_set_icon_pixbuf().
2627    *
2628    * Note that some widgets set up a drag icon in the default handler of
2629    * this signal, so you may have to use g_signal_connect_after() to
2630    * override what the default handler did.
2631    */
2632   widget_signals[DRAG_BEGIN] =
2633     g_signal_new (I_("drag-begin"),
2634                   G_TYPE_FROM_CLASS (klass),
2635                   G_SIGNAL_RUN_LAST,
2636                   G_STRUCT_OFFSET (GtkWidgetClass, drag_begin),
2637                   NULL, NULL,
2638                   _gtk_marshal_VOID__OBJECT,
2639                   G_TYPE_NONE, 1,
2640                   GDK_TYPE_DRAG_CONTEXT);
2641
2642   /**
2643    * GtkWidget::drag-end:
2644    * @widget: the object which received the signal
2645    * @context: the drag context
2646    *
2647    * The ::drag-end signal is emitted on the drag source when a drag is
2648    * finished.  A typical reason to connect to this signal is to undo
2649    * things done in #GtkWidget::drag-begin.
2650    */
2651   widget_signals[DRAG_END] =
2652     g_signal_new (I_("drag-end"),
2653                   G_TYPE_FROM_CLASS (klass),
2654                   G_SIGNAL_RUN_LAST,
2655                   G_STRUCT_OFFSET (GtkWidgetClass, drag_end),
2656                   NULL, NULL,
2657                   _gtk_marshal_VOID__OBJECT,
2658                   G_TYPE_NONE, 1,
2659                   GDK_TYPE_DRAG_CONTEXT);
2660
2661   /**
2662    * GtkWidget::drag-data-delete:
2663    * @widget: the object which received the signal
2664    * @context: the drag context
2665    *
2666    * The ::drag-data-delete signal is emitted on the drag source when a drag
2667    * with the action %GDK_ACTION_MOVE is successfully completed. The signal
2668    * handler is responsible for deleting the data that has been dropped. What
2669    * "delete" means depends on the context of the drag operation.
2670    */
2671   widget_signals[DRAG_DATA_DELETE] =
2672     g_signal_new (I_("drag-data-delete"),
2673                   G_TYPE_FROM_CLASS (klass),
2674                   G_SIGNAL_RUN_LAST,
2675                   G_STRUCT_OFFSET (GtkWidgetClass, drag_data_delete),
2676                   NULL, NULL,
2677                   _gtk_marshal_VOID__OBJECT,
2678                   G_TYPE_NONE, 1,
2679                   GDK_TYPE_DRAG_CONTEXT);
2680
2681   /**
2682    * GtkWidget::drag-failed:
2683    * @widget: the object which received the signal
2684    * @context: the drag context
2685    * @result: the result of the drag operation
2686    *
2687    * The ::drag-failed signal is emitted on the drag source when a drag has
2688    * failed. The signal handler may hook custom code to handle a failed DND
2689    * operation based on the type of error, it returns %TRUE is the failure has
2690    * been already handled (not showing the default "drag operation failed"
2691    * animation), otherwise it returns %FALSE.
2692    *
2693    * Return value: %TRUE if the failed drag operation has been already handled.
2694    *
2695    * Since: 2.12
2696    */
2697   widget_signals[DRAG_FAILED] =
2698     g_signal_new (I_("drag-failed"),
2699                   G_TYPE_FROM_CLASS (klass),
2700                   G_SIGNAL_RUN_LAST,
2701                   G_STRUCT_OFFSET (GtkWidgetClass, drag_failed),
2702                   _gtk_boolean_handled_accumulator, NULL,
2703                   _gtk_marshal_BOOLEAN__OBJECT_ENUM,
2704                   G_TYPE_BOOLEAN, 2,
2705                   GDK_TYPE_DRAG_CONTEXT,
2706                   GTK_TYPE_DRAG_RESULT);
2707
2708   /**
2709    * GtkWidget::drag-motion:
2710    * @widget: the object which received the signal
2711    * @context: the drag context
2712    * @x: the x coordinate of the current cursor position
2713    * @y: the y coordinate of the current cursor position
2714    * @time: the timestamp of the motion event
2715    *
2716    * The ::drag-motion signal is emitted on the drop site when the user
2717    * moves the cursor over the widget during a drag. The signal handler
2718    * must determine whether the cursor position is in a drop zone or not.
2719    * If it is not in a drop zone, it returns %FALSE and no further processing
2720    * is necessary. Otherwise, the handler returns %TRUE. In this case, the
2721    * handler is responsible for providing the necessary information for
2722    * displaying feedback to the user, by calling gdk_drag_status().
2723    *
2724    * If the decision whether the drop will be accepted or rejected can't be
2725    * made based solely on the cursor position and the type of the data, the
2726    * handler may inspect the dragged data by calling gtk_drag_get_data() and
2727    * defer the gdk_drag_status() call to the #GtkWidget::drag-data-received
2728    * handler. Note that you cannot not pass #GTK_DEST_DEFAULT_DROP,
2729    * #GTK_DEST_DEFAULT_MOTION or #GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set()
2730    * when using the drag-motion signal that way.
2731    *
2732    * Also note that there is no drag-enter signal. The drag receiver has to
2733    * keep track of whether he has received any drag-motion signals since the
2734    * last #GtkWidget::drag-leave and if not, treat the drag-motion signal as
2735    * an "enter" signal. Upon an "enter", the handler will typically highlight
2736    * the drop site with gtk_drag_highlight().
2737    * |[
2738    * static void
2739    * drag_motion (GtkWidget      *widget,
2740    *              GdkDragContext *context,
2741    *              gint            x,
2742    *              gint            y,
2743    *              guint           time)
2744    * {
2745    *   GdkAtom target;
2746    *
2747    *   PrivateData *private_data = GET_PRIVATE_DATA (widget);
2748    *
2749    *   if (!private_data->drag_highlight)
2750    *    {
2751    *      private_data->drag_highlight = 1;
2752    *      gtk_drag_highlight (widget);
2753    *    }
2754    *
2755    *   target = gtk_drag_dest_find_target (widget, context, NULL);
2756    *   if (target == GDK_NONE)
2757    *     gdk_drag_status (context, 0, time);
2758    *   else
2759    *    {
2760    *      private_data->pending_status = gdk_drag_context_get_suggested_action (context);
2761    *      gtk_drag_get_data (widget, context, target, time);
2762    *    }
2763    *
2764    *   return TRUE;
2765    * }
2766    *
2767    * static void
2768    * drag_data_received (GtkWidget        *widget,
2769    *                     GdkDragContext   *context,
2770    *                     gint              x,
2771    *                     gint              y,
2772    *                     GtkSelectionData *selection_data,
2773    *                     guint             info,
2774    *                     guint             time)
2775    * {
2776    *   PrivateData *private_data = GET_PRIVATE_DATA (widget);
2777    *
2778    *   if (private_data->suggested_action)
2779    *    {
2780    *      private_data->suggested_action = 0;
2781    *
2782    *      /&ast; We are getting this data due to a request in drag_motion,
2783    *       * rather than due to a request in drag_drop, so we are just
2784    *       * supposed to call gdk_drag_status(), not actually paste in
2785    *       * the data.
2786    *       &ast;/
2787    *      str = gtk_selection_data_get_text (selection_data);
2788    *      if (!data_is_acceptable (str))
2789    *        gdk_drag_status (context, 0, time);
2790    *      else
2791    *        gdk_drag_status (context, private_data->suggested_action, time);
2792    *    }
2793    *   else
2794    *    {
2795    *      /&ast; accept the drop &ast;/
2796    *    }
2797    * }
2798    * ]|
2799    *
2800    * Returns: whether the cursor position is in a drop zone
2801    */
2802   widget_signals[DRAG_MOTION] =
2803     g_signal_new (I_("drag-motion"),
2804                   G_TYPE_FROM_CLASS (klass),
2805                   G_SIGNAL_RUN_LAST,
2806                   G_STRUCT_OFFSET (GtkWidgetClass, drag_motion),
2807                   _gtk_boolean_handled_accumulator, NULL,
2808                   _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT,
2809                   G_TYPE_BOOLEAN, 4,
2810                   GDK_TYPE_DRAG_CONTEXT,
2811                   G_TYPE_INT,
2812                   G_TYPE_INT,
2813                   G_TYPE_UINT);
2814
2815   /**
2816    * GtkWidget::drag-drop:
2817    * @widget: the object which received the signal
2818    * @context: the drag context
2819    * @x: the x coordinate of the current cursor position
2820    * @y: the y coordinate of the current cursor position
2821    * @time: the timestamp of the motion event
2822    *
2823    * The ::drag-drop signal is emitted on the drop site when the user drops
2824    * the data onto the widget. The signal handler must determine whether
2825    * the cursor position is in a drop zone or not. If it is not in a drop
2826    * zone, it returns %FALSE and no further processing is necessary.
2827    * Otherwise, the handler returns %TRUE. In this case, the handler must
2828    * ensure that gtk_drag_finish() is called to let the source know that
2829    * the drop is done. The call to gtk_drag_finish() can be done either
2830    * directly or in a #GtkWidget::drag-data-received handler which gets
2831    * triggered by calling gtk_drag_get_data() to receive the data for one
2832    * or more of the supported targets.
2833    *
2834    * Returns: whether the cursor position is in a drop zone
2835    */
2836   widget_signals[DRAG_DROP] =
2837     g_signal_new (I_("drag-drop"),
2838                   G_TYPE_FROM_CLASS (klass),
2839                   G_SIGNAL_RUN_LAST,
2840                   G_STRUCT_OFFSET (GtkWidgetClass, drag_drop),
2841                   _gtk_boolean_handled_accumulator, NULL,
2842                   _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT,
2843                   G_TYPE_BOOLEAN, 4,
2844                   GDK_TYPE_DRAG_CONTEXT,
2845                   G_TYPE_INT,
2846                   G_TYPE_INT,
2847                   G_TYPE_UINT);
2848
2849   /**
2850    * GtkWidget::drag-data-get:
2851    * @widget: the object which received the signal
2852    * @context: the drag context
2853    * @data: the #GtkSelectionData to be filled with the dragged data
2854    * @info: the info that has been registered with the target in the
2855    *        #GtkTargetList
2856    * @time: the timestamp at which the data was requested
2857    *
2858    * The ::drag-data-get signal is emitted on the drag source when the drop
2859    * site requests the data which is dragged. It is the responsibility of
2860    * the signal handler to fill @data with the data in the format which
2861    * is indicated by @info. See gtk_selection_data_set() and
2862    * gtk_selection_data_set_text().
2863    */
2864   widget_signals[DRAG_DATA_GET] =
2865     g_signal_new (I_("drag-data-get"),
2866                   G_TYPE_FROM_CLASS (klass),
2867                   G_SIGNAL_RUN_LAST,
2868                   G_STRUCT_OFFSET (GtkWidgetClass, drag_data_get),
2869                   NULL, NULL,
2870                   _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT,
2871                   G_TYPE_NONE, 4,
2872                   GDK_TYPE_DRAG_CONTEXT,
2873                   GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
2874                   G_TYPE_UINT,
2875                   G_TYPE_UINT);
2876
2877   /**
2878    * GtkWidget::drag-data-received:
2879    * @widget: the object which received the signal
2880    * @context: the drag context
2881    * @x: where the drop happened
2882    * @y: where the drop happened
2883    * @data: the received data
2884    * @info: the info that has been registered with the target in the
2885    *        #GtkTargetList
2886    * @time: the timestamp at which the data was received
2887    *
2888    * The ::drag-data-received signal is emitted on the drop site when the
2889    * dragged data has been received. If the data was received in order to
2890    * determine whether the drop will be accepted, the handler is expected
2891    * to call gdk_drag_status() and <emphasis>not</emphasis> finish the drag.
2892    * If the data was received in response to a #GtkWidget::drag-drop signal
2893    * (and this is the last target to be received), the handler for this
2894    * signal is expected to process the received data and then call
2895    * gtk_drag_finish(), setting the @success parameter depending on
2896    * whether the data was processed successfully.
2897    *
2898    * The handler may inspect the selected action with
2899    * gdk_drag_context_get_selected_action() before calling
2900    * gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as
2901    * shown in the following example:
2902    * |[
2903    * void
2904    * drag_data_received (GtkWidget          *widget,
2905    *                     GdkDragContext     *context,
2906    *                     gint                x,
2907    *                     gint                y,
2908    *                     GtkSelectionData   *data,
2909    *                     guint               info,
2910    *                     guint               time)
2911    * {
2912    *   if ((data->length >= 0) && (data->format == 8))
2913    *     {
2914    *       GdkDragAction action;
2915    *
2916    *       /&ast; handle data here &ast;/
2917    *
2918    *       action = gdk_drag_context_get_selected_action (context);
2919    *       if (action == GDK_ACTION_ASK)
2920    *         {
2921    *           GtkWidget *dialog;
2922    *           gint response;
2923    *
2924    *           dialog = gtk_message_dialog_new (NULL,
2925    *                                            GTK_DIALOG_MODAL |
2926    *                                            GTK_DIALOG_DESTROY_WITH_PARENT,
2927    *                                            GTK_MESSAGE_INFO,
2928    *                                            GTK_BUTTONS_YES_NO,
2929    *                                            "Move the data ?\n");
2930    *           response = gtk_dialog_run (GTK_DIALOG (dialog));
2931    *           gtk_widget_destroy (dialog);
2932    *
2933    *           if (response == GTK_RESPONSE_YES)
2934    *             action = GDK_ACTION_MOVE;
2935    *           else
2936    *             action = GDK_ACTION_COPY;
2937    *          }
2938    *
2939    *       gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
2940    *     }
2941    *   else
2942    *     gtk_drag_finish (context, FALSE, FALSE, time);
2943    *  }
2944    * ]|
2945    */
2946   widget_signals[DRAG_DATA_RECEIVED] =
2947     g_signal_new (I_("drag-data-received"),
2948                   G_TYPE_FROM_CLASS (klass),
2949                   G_SIGNAL_RUN_LAST,
2950                   G_STRUCT_OFFSET (GtkWidgetClass, drag_data_received),
2951                   NULL, NULL,
2952                   _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT,
2953                   G_TYPE_NONE, 6,
2954                   GDK_TYPE_DRAG_CONTEXT,
2955                   G_TYPE_INT,
2956                   G_TYPE_INT,
2957                   GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
2958                   G_TYPE_UINT,
2959                   G_TYPE_UINT);
2960
2961   /**
2962    * GtkWidget::visibility-notify-event:
2963    * @widget: the object which received the signal
2964    * @event: (type Gdk.EventVisibility): the #GdkEventVisibility which
2965    *   triggered this signal.
2966    *
2967    * The ::visibility-notify-event will be emitted when the @widget's window
2968    * is obscured or unobscured.
2969    *
2970    * To receive this signal the #GdkWindow associated to the widget needs
2971    * to enable the #GDK_VISIBILITY_NOTIFY_MASK mask.
2972    *
2973    * Returns: %TRUE to stop other handlers from being invoked for the event.
2974    *   %FALSE to propagate the event further.
2975    */
2976   widget_signals[VISIBILITY_NOTIFY_EVENT] =
2977     g_signal_new (I_("visibility-notify-event"),
2978                   G_TYPE_FROM_CLASS (klass),
2979                   G_SIGNAL_RUN_LAST,
2980                   G_STRUCT_OFFSET (GtkWidgetClass, visibility_notify_event),
2981                   _gtk_boolean_handled_accumulator, NULL,
2982                   _gtk_marshal_BOOLEAN__BOXED,
2983                   G_TYPE_BOOLEAN, 1,
2984                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
2985
2986   /**
2987    * GtkWidget::window-state-event:
2988    * @widget: the object which received the signal
2989    * @event: (type Gdk.EventWindowState): the #GdkEventWindowState which
2990    *   triggered this signal.
2991    *
2992    * The ::window-state-event will be emitted when the state of the
2993    * toplevel window associated to the @widget changes.
2994    *
2995    * To receive this signal the #GdkWindow associated to the widget
2996    * needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable
2997    * this mask automatically for all new windows.
2998    *
2999    * Returns: %TRUE to stop other handlers from being invoked for the
3000    *   event. %FALSE to propagate the event further.
3001    */
3002   widget_signals[WINDOW_STATE_EVENT] =
3003     g_signal_new (I_("window-state-event"),
3004                   G_TYPE_FROM_CLASS (klass),
3005                   G_SIGNAL_RUN_LAST,
3006                   G_STRUCT_OFFSET (GtkWidgetClass, window_state_event),
3007                   _gtk_boolean_handled_accumulator, NULL,
3008                   _gtk_marshal_BOOLEAN__BOXED,
3009                   G_TYPE_BOOLEAN, 1,
3010                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
3011   g_signal_set_va_marshaller (widget_signals[WINDOW_STATE_EVENT], G_TYPE_FROM_CLASS (klass),
3012                               _gtk_marshal_BOOLEAN__BOXEDv);
3013
3014   /**
3015    * GtkWidget::damage-event:
3016    * @widget: the object which received the signal
3017    * @event: (type Gdk.EventExpose): the #GdkEventExpose event
3018    *
3019    * Emitted when a redirected window belonging to @widget gets drawn into.
3020    * The region/area members of the event shows what area of the redirected
3021    * drawable was drawn into.
3022    *
3023    * Returns: %TRUE to stop other handlers from being invoked for the event.
3024    *   %FALSE to propagate the event further.
3025    *
3026    * Since: 2.14
3027    */
3028   widget_signals[DAMAGE_EVENT] =
3029     g_signal_new (I_("damage-event"),
3030                   G_TYPE_FROM_CLASS (klass),
3031                   G_SIGNAL_RUN_LAST,
3032                   G_STRUCT_OFFSET (GtkWidgetClass, damage_event),
3033                   _gtk_boolean_handled_accumulator, NULL,
3034                   _gtk_marshal_BOOLEAN__BOXED,
3035                   G_TYPE_BOOLEAN, 1,
3036                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
3037   g_signal_set_va_marshaller (widget_signals[DAMAGE_EVENT], G_TYPE_FROM_CLASS (klass),
3038                               _gtk_marshal_BOOLEAN__BOXEDv);
3039
3040 /**
3041    * GtkWidget::grab-broken-event:
3042    * @widget: the object which received the signal
3043    * @event: (type Gdk.EventGrabBroken): the #GdkEventGrabBroken event
3044    *
3045    * Emitted when a pointer or keyboard grab on a window belonging
3046    * to @widget gets broken.
3047    *
3048    * On X11, this happens when the grab window becomes unviewable
3049    * (i.e. it or one of its ancestors is unmapped), or if the same
3050    * application grabs the pointer or keyboard again.
3051    *
3052    * Returns: %TRUE to stop other handlers from being invoked for
3053    *   the event. %FALSE to propagate the event further.
3054    *
3055    * Since: 2.8
3056    */
3057   widget_signals[GRAB_BROKEN_EVENT] =
3058     g_signal_new (I_("grab-broken-event"),
3059                   G_TYPE_FROM_CLASS (klass),
3060                   G_SIGNAL_RUN_LAST,
3061                   G_STRUCT_OFFSET (GtkWidgetClass, grab_broken_event),
3062                   _gtk_boolean_handled_accumulator, NULL,
3063                   _gtk_marshal_BOOLEAN__BOXED,
3064                   G_TYPE_BOOLEAN, 1,
3065                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
3066   g_signal_set_va_marshaller (widget_signals[GRAB_BROKEN_EVENT], G_TYPE_FROM_CLASS (klass),
3067                               _gtk_marshal_BOOLEAN__BOXEDv);
3068
3069   /**
3070    * GtkWidget::query-tooltip:
3071    * @widget: the object which received the signal
3072    * @x: the x coordinate of the cursor position where the request has
3073    *     been emitted, relative to @widget's left side
3074    * @y: the y coordinate of the cursor position where the request has
3075    *     been emitted, relative to @widget's top
3076    * @keyboard_mode: %TRUE if the tooltip was trigged using the keyboard
3077    * @tooltip: a #GtkTooltip
3078    *
3079    * Emitted when #GtkWidget:has-tooltip is %TRUE and the #GtkSettings:gtk-tooltip-timeout
3080    * has expired with the cursor hovering "above" @widget; or emitted when @widget got
3081    * focus in keyboard mode.
3082    *
3083    * Using the given coordinates, the signal handler should determine
3084    * whether a tooltip should be shown for @widget. If this is the case
3085    * %TRUE should be returned, %FALSE otherwise.  Note that if
3086    * @keyboard_mode is %TRUE, the values of @x and @y are undefined and
3087    * should not be used.
3088    *
3089    * The signal handler is free to manipulate @tooltip with the therefore
3090    * destined function calls.
3091    *
3092    * Returns: %TRUE if @tooltip should be shown right now, %FALSE otherwise.
3093    *
3094    * Since: 2.12
3095    */
3096   widget_signals[QUERY_TOOLTIP] =
3097     g_signal_new (I_("query-tooltip"),
3098                   G_TYPE_FROM_CLASS (klass),
3099                   G_SIGNAL_RUN_LAST,
3100                   G_STRUCT_OFFSET (GtkWidgetClass, query_tooltip),
3101                   _gtk_boolean_handled_accumulator, NULL,
3102                   _gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT,
3103                   G_TYPE_BOOLEAN, 4,
3104                   G_TYPE_INT,
3105                   G_TYPE_INT,
3106                   G_TYPE_BOOLEAN,
3107                   GTK_TYPE_TOOLTIP);
3108
3109   /**
3110    * GtkWidget::popup-menu:
3111    * @widget: the object which received the signal
3112    *
3113    * This signal gets emitted whenever a widget should pop up a context
3114    * menu. This usually happens through the standard key binding mechanism;
3115    * by pressing a certain key while a widget is focused, the user can cause
3116    * the widget to pop up a menu.  For example, the #GtkEntry widget creates
3117    * a menu with clipboard commands. See <xref linkend="checklist-popup-menu"/>
3118    * for an example of how to use this signal.
3119    *
3120    * Returns: %TRUE if a menu was activated
3121    */
3122   widget_signals[POPUP_MENU] =
3123     g_signal_new (I_("popup-menu"),
3124                   G_TYPE_FROM_CLASS (klass),
3125                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
3126                   G_STRUCT_OFFSET (GtkWidgetClass, popup_menu),
3127                   _gtk_boolean_handled_accumulator, NULL,
3128                   _gtk_marshal_BOOLEAN__VOID,
3129                   G_TYPE_BOOLEAN, 0);
3130
3131   /**
3132    * GtkWidget::show-help:
3133    * @widget: the object which received the signal.
3134    * @help_type:
3135    *
3136    * Returns: %TRUE to stop other handlers from being invoked for the event.
3137    * %FALSE to propagate the event further.
3138    */
3139   widget_signals[SHOW_HELP] =
3140     g_signal_new (I_("show-help"),
3141                   G_TYPE_FROM_CLASS (klass),
3142                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
3143                   G_STRUCT_OFFSET (GtkWidgetClass, show_help),
3144                   _gtk_boolean_handled_accumulator, NULL,
3145                   _gtk_marshal_BOOLEAN__ENUM,
3146                   G_TYPE_BOOLEAN, 1,
3147                   GTK_TYPE_WIDGET_HELP_TYPE);
3148
3149   /**
3150    * GtkWidget::accel-closures-changed:
3151    * @widget: the object which received the signal.
3152    */
3153   widget_signals[ACCEL_CLOSURES_CHANGED] =
3154     g_signal_new (I_("accel-closures-changed"),
3155                   G_TYPE_FROM_CLASS (klass),
3156                   0,
3157                   0,
3158                   NULL, NULL,
3159                   _gtk_marshal_VOID__VOID,
3160                   G_TYPE_NONE, 0);
3161
3162   /**
3163    * GtkWidget::screen-changed:
3164    * @widget: the object on which the signal is emitted
3165    * @previous_screen: (allow-none): the previous screen, or %NULL if the
3166    *   widget was not associated with a screen before
3167    *
3168    * The ::screen-changed signal gets emitted when the
3169    * screen of a widget has changed.
3170    */
3171   widget_signals[SCREEN_CHANGED] =
3172     g_signal_new (I_("screen-changed"),
3173                   G_TYPE_FROM_CLASS (klass),
3174                   G_SIGNAL_RUN_LAST,
3175                   G_STRUCT_OFFSET (GtkWidgetClass, screen_changed),
3176                   NULL, NULL,
3177                   _gtk_marshal_VOID__OBJECT,
3178                   G_TYPE_NONE, 1,
3179                   GDK_TYPE_SCREEN);
3180
3181   /**
3182    * GtkWidget::can-activate-accel:
3183    * @widget: the object which received the signal
3184    * @signal_id: the ID of a signal installed on @widget
3185    *
3186    * Determines whether an accelerator that activates the signal
3187    * identified by @signal_id can currently be activated.
3188    * This signal is present to allow applications and derived
3189    * widgets to override the default #GtkWidget handling
3190    * for determining whether an accelerator can be activated.
3191    *
3192    * Returns: %TRUE if the signal can be activated.
3193    */
3194   widget_signals[CAN_ACTIVATE_ACCEL] =
3195      g_signal_new (I_("can-activate-accel"),
3196                   G_TYPE_FROM_CLASS (klass),
3197                   G_SIGNAL_RUN_LAST,
3198                   G_STRUCT_OFFSET (GtkWidgetClass, can_activate_accel),
3199                   _gtk_boolean_handled_accumulator, NULL,
3200                   _gtk_marshal_BOOLEAN__UINT,
3201                   G_TYPE_BOOLEAN, 1, G_TYPE_UINT);
3202
3203   binding_set = gtk_binding_set_by_class (klass);
3204   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F10, GDK_SHIFT_MASK,
3205                                 "popup-menu", 0);
3206   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Menu, 0,
3207                                 "popup-menu", 0);
3208
3209   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, GDK_CONTROL_MASK,
3210                                 "show-help", 1,
3211                                 GTK_TYPE_WIDGET_HELP_TYPE,
3212                                 GTK_WIDGET_HELP_TOOLTIP);
3213   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, GDK_CONTROL_MASK,
3214                                 "show-help", 1,
3215                                 GTK_TYPE_WIDGET_HELP_TYPE,
3216                                 GTK_WIDGET_HELP_TOOLTIP);
3217   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, GDK_SHIFT_MASK,
3218                                 "show-help", 1,
3219                                 GTK_TYPE_WIDGET_HELP_TYPE,
3220                                 GTK_WIDGET_HELP_WHATS_THIS);
3221   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, GDK_SHIFT_MASK,
3222                                 "show-help", 1,
3223                                 GTK_TYPE_WIDGET_HELP_TYPE,
3224                                 GTK_WIDGET_HELP_WHATS_THIS);
3225
3226   gtk_widget_class_install_style_property (klass,
3227                                            g_param_spec_boolean ("interior-focus",
3228                                                                  P_("Interior Focus"),
3229                                                                  P_("Whether to draw the focus indicator inside widgets"),
3230                                                                  TRUE,
3231                                                                  GTK_PARAM_READABLE));
3232
3233   gtk_widget_class_install_style_property (klass,
3234                                            g_param_spec_int ("focus-line-width",
3235                                                              P_("Focus linewidth"),
3236                                                              P_("Width, in pixels, of the focus indicator line"),
3237                                                              0, G_MAXINT, 1,
3238                                                              GTK_PARAM_READABLE));
3239
3240   gtk_widget_class_install_style_property (klass,
3241                                            g_param_spec_string ("focus-line-pattern",
3242                                                                 P_("Focus line dash pattern"),
3243                                                                 P_("Dash pattern used to draw the focus indicator"),
3244                                                                 "\1\1",
3245                                                                 GTK_PARAM_READABLE));
3246   gtk_widget_class_install_style_property (klass,
3247                                            g_param_spec_int ("focus-padding",
3248                                                              P_("Focus padding"),
3249                                                              P_("Width, in pixels, between focus indicator and the widget 'box'"),
3250                                                              0, G_MAXINT, 1,
3251                                                              GTK_PARAM_READABLE));
3252   gtk_widget_class_install_style_property (klass,
3253                                            g_param_spec_boxed ("cursor-color",
3254                                                                P_("Cursor color"),
3255                                                                P_("Color with which to draw insertion cursor"),
3256                                                                GDK_TYPE_COLOR,
3257                                                                GTK_PARAM_READABLE));
3258   gtk_widget_class_install_style_property (klass,
3259                                            g_param_spec_boxed ("secondary-cursor-color",
3260                                                                P_("Secondary cursor color"),
3261                                                                P_("Color with which to draw the secondary insertion cursor when editing mixed right-to-left and left-to-right text"),
3262                                                                GDK_TYPE_COLOR,
3263                                                                GTK_PARAM_READABLE));
3264   gtk_widget_class_install_style_property (klass,
3265                                            g_param_spec_float ("cursor-aspect-ratio",
3266                                                                P_("Cursor line aspect ratio"),
3267                                                                P_("Aspect ratio with which to draw insertion cursor"),
3268                                                                0.0, 1.0, 0.04,
3269                                                                GTK_PARAM_READABLE));
3270
3271   gtk_widget_class_install_style_property (klass,
3272                                            g_param_spec_boolean ("window-dragging",
3273                                                                  P_("Window dragging"),
3274                                                                  P_("Whether windows can be dragged by clicking on empty areas"),
3275                                                                  FALSE,
3276                                                                  GTK_PARAM_READABLE));
3277
3278   /**
3279    * GtkWidget:link-color:
3280    *
3281    * The "link-color" style property defines the color of unvisited links.
3282    *
3283    * Since: 2.10
3284    */
3285   gtk_widget_class_install_style_property (klass,
3286                                            g_param_spec_boxed ("link-color",
3287                                                                P_("Unvisited Link Color"),
3288                                                                P_("Color of unvisited links"),
3289                                                                GDK_TYPE_COLOR,
3290                                                                GTK_PARAM_READABLE));
3291
3292   /**
3293    * GtkWidget:visited-link-color:
3294    *
3295    * The "visited-link-color" style property defines the color of visited links.
3296    *
3297    * Since: 2.10
3298    */
3299   gtk_widget_class_install_style_property (klass,
3300                                            g_param_spec_boxed ("visited-link-color",
3301                                                                P_("Visited Link Color"),
3302                                                                P_("Color of visited links"),
3303                                                                GDK_TYPE_COLOR,
3304                                                                GTK_PARAM_READABLE));
3305
3306   /**
3307    * GtkWidget:wide-separators:
3308    *
3309    * The "wide-separators" style property defines whether separators have
3310    * configurable width and should be drawn using a box instead of a line.
3311    *
3312    * Since: 2.10
3313    */
3314   gtk_widget_class_install_style_property (klass,
3315                                            g_param_spec_boolean ("wide-separators",
3316                                                                  P_("Wide Separators"),
3317                                                                  P_("Whether separators have configurable width and should be drawn using a box instead of a line"),
3318                                                                  FALSE,
3319                                                                  GTK_PARAM_READABLE));
3320
3321   /**
3322    * GtkWidget:separator-width:
3323    *
3324    * The "separator-width" style property defines the width of separators.
3325    * This property only takes effect if #GtkWidget:wide-separators is %TRUE.
3326    *
3327    * Since: 2.10
3328    */
3329   gtk_widget_class_install_style_property (klass,
3330                                            g_param_spec_int ("separator-width",
3331                                                              P_("Separator Width"),
3332                                                              P_("The width of separators if wide-separators is TRUE"),
3333                                                              0, G_MAXINT, 0,
3334                                                              GTK_PARAM_READABLE));
3335
3336   /**
3337    * GtkWidget:separator-height:
3338    *
3339    * The "separator-height" style property defines the height of separators.
3340    * This property only takes effect if #GtkWidget:wide-separators is %TRUE.
3341    *
3342    * Since: 2.10
3343    */
3344   gtk_widget_class_install_style_property (klass,
3345                                            g_param_spec_int ("separator-height",
3346                                                              P_("Separator Height"),
3347                                                              P_("The height of separators if \"wide-separators\" is TRUE"),
3348                                                              0, G_MAXINT, 0,
3349                                                              GTK_PARAM_READABLE));
3350
3351   /**
3352    * GtkWidget:scroll-arrow-hlength:
3353    *
3354    * The "scroll-arrow-hlength" style property defines the length of
3355    * horizontal scroll arrows.
3356    *
3357    * Since: 2.10
3358    */
3359   gtk_widget_class_install_style_property (klass,
3360                                            g_param_spec_int ("scroll-arrow-hlength",
3361                                                              P_("Horizontal Scroll Arrow Length"),
3362                                                              P_("The length of horizontal scroll arrows"),
3363                                                              1, G_MAXINT, 16,
3364                                                              GTK_PARAM_READABLE));
3365
3366   /**
3367    * GtkWidget:scroll-arrow-vlength:
3368    *
3369    * The "scroll-arrow-vlength" style property defines the length of
3370    * vertical scroll arrows.
3371    *
3372    * Since: 2.10
3373    */
3374   gtk_widget_class_install_style_property (klass,
3375                                            g_param_spec_int ("scroll-arrow-vlength",
3376                                                              P_("Vertical Scroll Arrow Length"),
3377                                                              P_("The length of vertical scroll arrows"),
3378                                                              1, G_MAXINT, 16,
3379                                                              GTK_PARAM_READABLE));
3380
3381   gtk_widget_class_install_style_property (klass,
3382                                            g_param_spec_int ("text-handle-width",
3383                                                              P_("Width of text selection handles"),
3384                                                              P_("Width of text selection handles"),
3385                                                              1, G_MAXINT, 16,
3386                                                              GTK_PARAM_READABLE));
3387   gtk_widget_class_install_style_property (klass,
3388                                            g_param_spec_int ("text-handle-height",
3389                                                              P_("Height of text selection handles"),
3390                                                              P_("Height of text selection handles"),
3391                                                              1, G_MAXINT, 20,
3392                                                              GTK_PARAM_READABLE));
3393
3394   g_type_class_add_private (klass, sizeof (GtkWidgetPrivate));
3395
3396   gtk_widget_class_set_accessible_type (klass, GTK_TYPE_WIDGET_ACCESSIBLE);
3397 }
3398
3399 static void
3400 gtk_widget_base_class_finalize (GtkWidgetClass *klass)
3401 {
3402   GList *list, *node;
3403
3404   list = g_param_spec_pool_list_owned (style_property_spec_pool, G_OBJECT_CLASS_TYPE (klass));
3405   for (node = list; node; node = node->next)
3406     {
3407       GParamSpec *pspec = node->data;
3408
3409       g_param_spec_pool_remove (style_property_spec_pool, pspec);
3410       g_param_spec_unref (pspec);
3411     }
3412   g_list_free (list);
3413 }
3414
3415 static void
3416 gtk_widget_set_property (GObject         *object,
3417                          guint            prop_id,
3418                          const GValue    *value,
3419                          GParamSpec      *pspec)
3420 {
3421   GtkWidget *widget = GTK_WIDGET (object);
3422
3423   switch (prop_id)
3424     {
3425       gboolean tmp;
3426       gchar *tooltip_markup;
3427       const gchar *tooltip_text;
3428       GtkWindow *tooltip_window;
3429
3430     case PROP_NAME:
3431       gtk_widget_set_name (widget, g_value_get_string (value));
3432       break;
3433     case PROP_PARENT:
3434       gtk_container_add (GTK_CONTAINER (g_value_get_object (value)), widget);
3435       break;
3436     case PROP_WIDTH_REQUEST:
3437       gtk_widget_set_usize_internal (widget, g_value_get_int (value), -2, 0);
3438       break;
3439     case PROP_HEIGHT_REQUEST:
3440       gtk_widget_set_usize_internal (widget, -2, g_value_get_int (value), 0);
3441       break;
3442     case PROP_VISIBLE:
3443       gtk_widget_set_visible (widget, g_value_get_boolean (value));
3444       break;
3445     case PROP_SENSITIVE:
3446       gtk_widget_set_sensitive (widget, g_value_get_boolean (value));
3447       break;
3448     case PROP_APP_PAINTABLE:
3449       gtk_widget_set_app_paintable (widget, g_value_get_boolean (value));
3450       break;
3451     case PROP_CAN_FOCUS:
3452       gtk_widget_set_can_focus (widget, g_value_get_boolean (value));
3453       break;
3454     case PROP_HAS_FOCUS:
3455       if (g_value_get_boolean (value))
3456         gtk_widget_grab_focus (widget);
3457       break;
3458     case PROP_IS_FOCUS:
3459       if (g_value_get_boolean (value))
3460         gtk_widget_grab_focus (widget);
3461       break;
3462     case PROP_CAN_DEFAULT:
3463       gtk_widget_set_can_default (widget, g_value_get_boolean (value));
3464       break;
3465     case PROP_HAS_DEFAULT:
3466       if (g_value_get_boolean (value))
3467         gtk_widget_grab_default (widget);
3468       break;
3469     case PROP_RECEIVES_DEFAULT:
3470       gtk_widget_set_receives_default (widget, g_value_get_boolean (value));
3471       break;
3472     case PROP_STYLE:
3473       gtk_widget_set_style (widget, g_value_get_object (value));
3474       break;
3475     case PROP_EVENTS:
3476       if (!gtk_widget_get_realized (widget) && gtk_widget_get_has_window (widget))
3477         gtk_widget_set_events (widget, g_value_get_flags (value));
3478       break;
3479     case PROP_NO_SHOW_ALL:
3480       gtk_widget_set_no_show_all (widget, g_value_get_boolean (value));
3481       break;
3482     case PROP_HAS_TOOLTIP:
3483       gtk_widget_real_set_has_tooltip (widget,
3484                                        g_value_get_boolean (value), FALSE);
3485       break;
3486     case PROP_TOOLTIP_MARKUP:
3487       tooltip_window = g_object_get_qdata (object, quark_tooltip_window);
3488       tooltip_markup = g_value_dup_string (value);
3489
3490       /* Treat an empty string as a NULL string,
3491        * because an empty string would be useless for a tooltip:
3492        */
3493       if (tooltip_markup && (strlen (tooltip_markup) == 0))
3494         {
3495           g_free (tooltip_markup);
3496           tooltip_markup = NULL;
3497         }
3498
3499       g_object_set_qdata_full (object, quark_tooltip_markup,
3500                                tooltip_markup, g_free);
3501
3502       tmp = (tooltip_window != NULL || tooltip_markup != NULL);
3503       gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
3504       if (gtk_widget_get_visible (widget))
3505         gtk_widget_queue_tooltip_query (widget);
3506       break;
3507     case PROP_TOOLTIP_TEXT:
3508       tooltip_window = g_object_get_qdata (object, quark_tooltip_window);
3509
3510       tooltip_text = g_value_get_string (value);
3511
3512       /* Treat an empty string as a NULL string,
3513        * because an empty string would be useless for a tooltip:
3514        */
3515       if (tooltip_text && (strlen (tooltip_text) == 0))
3516         tooltip_text = NULL;
3517
3518       tooltip_markup = tooltip_text ? g_markup_escape_text (tooltip_text, -1) : NULL;
3519
3520       g_object_set_qdata_full (object, quark_tooltip_markup,
3521                                tooltip_markup, g_free);
3522
3523       tmp = (tooltip_window != NULL || tooltip_markup != NULL);
3524       gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
3525       if (gtk_widget_get_visible (widget))
3526         gtk_widget_queue_tooltip_query (widget);
3527       break;
3528     case PROP_DOUBLE_BUFFERED:
3529       gtk_widget_set_double_buffered (widget, g_value_get_boolean (value));
3530       break;
3531     case PROP_HALIGN:
3532       gtk_widget_set_halign (widget, g_value_get_enum (value));
3533       break;
3534     case PROP_VALIGN:
3535       gtk_widget_set_valign (widget, g_value_get_enum (value));
3536       break;
3537     case PROP_MARGIN_LEFT:
3538       gtk_widget_set_margin_left (widget, g_value_get_int (value));
3539       break;
3540     case PROP_MARGIN_RIGHT:
3541       gtk_widget_set_margin_right (widget, g_value_get_int (value));
3542       break;
3543     case PROP_MARGIN_TOP:
3544       gtk_widget_set_margin_top (widget, g_value_get_int (value));
3545       break;
3546     case PROP_MARGIN_BOTTOM:
3547       gtk_widget_set_margin_bottom (widget, g_value_get_int (value));
3548       break;
3549     case PROP_MARGIN:
3550       g_object_freeze_notify (G_OBJECT (widget));
3551       gtk_widget_set_margin_left (widget, g_value_get_int (value));
3552       gtk_widget_set_margin_right (widget, g_value_get_int (value));
3553       gtk_widget_set_margin_top (widget, g_value_get_int (value));
3554       gtk_widget_set_margin_bottom (widget, g_value_get_int (value));
3555       g_object_thaw_notify (G_OBJECT (widget));
3556       break;
3557     case PROP_HEXPAND:
3558       gtk_widget_set_hexpand (widget, g_value_get_boolean (value));
3559       break;
3560     case PROP_HEXPAND_SET:
3561       gtk_widget_set_hexpand_set (widget, g_value_get_boolean (value));
3562       break;
3563     case PROP_VEXPAND:
3564       gtk_widget_set_vexpand (widget, g_value_get_boolean (value));
3565       break;
3566     case PROP_VEXPAND_SET:
3567       gtk_widget_set_vexpand_set (widget, g_value_get_boolean (value));
3568       break;
3569     case PROP_EXPAND:
3570       g_object_freeze_notify (G_OBJECT (widget));
3571       gtk_widget_set_hexpand (widget, g_value_get_boolean (value));
3572       gtk_widget_set_vexpand (widget, g_value_get_boolean (value));
3573       g_object_thaw_notify (G_OBJECT (widget));
3574       break;
3575     case PROP_OPACITY:
3576       gtk_widget_set_opacity (widget, g_value_get_double (value));
3577       break;
3578     default:
3579       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
3580       break;
3581     }
3582 }
3583
3584 static void
3585 gtk_widget_get_property (GObject         *object,
3586                          guint            prop_id,
3587                          GValue          *value,
3588                          GParamSpec      *pspec)
3589 {
3590   GtkWidget *widget = GTK_WIDGET (object);
3591   GtkWidgetPrivate *priv = widget->priv;
3592
3593   switch (prop_id)
3594     {
3595       gpointer *eventp;
3596
3597     case PROP_NAME:
3598       if (priv->name)
3599         g_value_set_string (value, priv->name);
3600       else
3601         g_value_set_static_string (value, "");
3602       break;
3603     case PROP_PARENT:
3604       g_value_set_object (value, priv->parent);
3605       break;
3606     case PROP_WIDTH_REQUEST:
3607       {
3608         int w;
3609         gtk_widget_get_size_request (widget, &w, NULL);
3610         g_value_set_int (value, w);
3611       }
3612       break;
3613     case PROP_HEIGHT_REQUEST:
3614       {
3615         int h;
3616         gtk_widget_get_size_request (widget, NULL, &h);
3617         g_value_set_int (value, h);
3618       }
3619       break;
3620     case PROP_VISIBLE:
3621       g_value_set_boolean (value, (gtk_widget_get_visible (widget) != FALSE));
3622       break;
3623     case PROP_SENSITIVE:
3624       g_value_set_boolean (value, (gtk_widget_get_sensitive (widget) != FALSE));
3625       break;
3626     case PROP_APP_PAINTABLE:
3627       g_value_set_boolean (value, (gtk_widget_get_app_paintable (widget) != FALSE));
3628       break;
3629     case PROP_CAN_FOCUS:
3630       g_value_set_boolean (value, (gtk_widget_get_can_focus (widget) != FALSE));
3631       break;
3632     case PROP_HAS_FOCUS:
3633       g_value_set_boolean (value, (gtk_widget_has_focus (widget) != FALSE));
3634       break;
3635     case PROP_IS_FOCUS:
3636       g_value_set_boolean (value, (gtk_widget_is_focus (widget)));
3637       break;
3638     case PROP_CAN_DEFAULT:
3639       g_value_set_boolean (value, (gtk_widget_get_can_default (widget) != FALSE));
3640       break;
3641     case PROP_HAS_DEFAULT:
3642       g_value_set_boolean (value, (gtk_widget_has_default (widget) != FALSE));
3643       break;
3644     case PROP_RECEIVES_DEFAULT:
3645       g_value_set_boolean (value, (gtk_widget_get_receives_default (widget) != FALSE));
3646       break;
3647     case PROP_COMPOSITE_CHILD:
3648       g_value_set_boolean (value, widget->priv->composite_child);
3649       break;
3650     case PROP_STYLE:
3651       g_value_set_object (value, gtk_widget_get_style (widget));
3652       break;
3653     case PROP_EVENTS:
3654       eventp = g_object_get_qdata (G_OBJECT (widget), quark_event_mask);
3655       g_value_set_flags (value, GPOINTER_TO_INT (eventp));
3656       break;
3657     case PROP_NO_SHOW_ALL:
3658       g_value_set_boolean (value, gtk_widget_get_no_show_all (widget));
3659       break;
3660     case PROP_HAS_TOOLTIP:
3661       g_value_set_boolean (value, GPOINTER_TO_UINT (g_object_get_qdata (object, quark_has_tooltip)));
3662       break;
3663     case PROP_TOOLTIP_TEXT:
3664       {
3665         gchar *escaped = g_object_get_qdata (object, quark_tooltip_markup);
3666         gchar *text = NULL;
3667
3668         if (escaped && !pango_parse_markup (escaped, -1, 0, NULL, &text, NULL, NULL))
3669           g_assert (NULL == text); /* text should still be NULL in case of markup errors */
3670
3671         g_value_take_string (value, text);
3672       }
3673       break;
3674     case PROP_TOOLTIP_MARKUP:
3675       g_value_set_string (value, g_object_get_qdata (object, quark_tooltip_markup));
3676       break;
3677     case PROP_WINDOW:
3678       g_value_set_object (value, gtk_widget_get_window (widget));
3679       break;
3680     case PROP_DOUBLE_BUFFERED:
3681       g_value_set_boolean (value, gtk_widget_get_double_buffered (widget));
3682       break;
3683     case PROP_HALIGN:
3684       g_value_set_enum (value, gtk_widget_get_halign (widget));
3685       break;
3686     case PROP_VALIGN:
3687       g_value_set_enum (value, gtk_widget_get_valign (widget));
3688       break;
3689     case PROP_MARGIN_LEFT:
3690       g_value_set_int (value, gtk_widget_get_margin_left (widget));
3691       break;
3692     case PROP_MARGIN_RIGHT:
3693       g_value_set_int (value, gtk_widget_get_margin_right (widget));
3694       break;
3695     case PROP_MARGIN_TOP:
3696       g_value_set_int (value, gtk_widget_get_margin_top (widget));
3697       break;
3698     case PROP_MARGIN_BOTTOM:
3699       g_value_set_int (value, gtk_widget_get_margin_bottom (widget));
3700       break;
3701     case PROP_MARGIN:
3702       {
3703         GtkWidgetAuxInfo *aux_info = gtk_widget_get_aux_info (widget, FALSE);
3704         if (aux_info == NULL)
3705           {
3706             g_value_set_int (value, 0);
3707           }
3708         else
3709           {
3710             g_value_set_int (value, MAX (MAX (aux_info->margin.left,
3711                                               aux_info->margin.right),
3712                                          MAX (aux_info->margin.top,
3713                                               aux_info->margin.bottom)));
3714           }
3715       }
3716       break;
3717     case PROP_HEXPAND:
3718       g_value_set_boolean (value, gtk_widget_get_hexpand (widget));
3719       break;
3720     case PROP_HEXPAND_SET:
3721       g_value_set_boolean (value, gtk_widget_get_hexpand_set (widget));
3722       break;
3723     case PROP_VEXPAND:
3724       g_value_set_boolean (value, gtk_widget_get_vexpand (widget));
3725       break;
3726     case PROP_VEXPAND_SET:
3727       g_value_set_boolean (value, gtk_widget_get_vexpand_set (widget));
3728       break;
3729     case PROP_EXPAND:
3730       g_value_set_boolean (value,
3731                            gtk_widget_get_hexpand (widget) &&
3732                            gtk_widget_get_vexpand (widget));
3733       break;
3734     case PROP_OPACITY:
3735       g_value_set_double (value, gtk_widget_get_opacity (widget));
3736       break;
3737     default:
3738       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
3739       break;
3740     }
3741 }
3742
3743 static void
3744 gtk_widget_init (GtkWidget *widget)
3745 {
3746   GtkWidgetPrivate *priv;
3747
3748   widget->priv = G_TYPE_INSTANCE_GET_PRIVATE (widget,
3749                                               GTK_TYPE_WIDGET,
3750                                               GtkWidgetPrivate);
3751   priv = widget->priv;
3752
3753   priv->child_visible = TRUE;
3754   priv->name = NULL;
3755   priv->allocation.x = -1;
3756   priv->allocation.y = -1;
3757   priv->allocation.width = 1;
3758   priv->allocation.height = 1;
3759   priv->user_alpha = 255;
3760   priv->alpha = 255;
3761   priv->window = NULL;
3762   priv->parent = NULL;
3763
3764   priv->sensitive = TRUE;
3765   priv->composite_child = composite_child_stack != 0;
3766   priv->double_buffered = TRUE;
3767   priv->redraw_on_alloc = TRUE;
3768   priv->alloc_needed = TRUE;
3769
3770   switch (gtk_widget_get_direction (widget))
3771     {
3772     case GTK_TEXT_DIR_LTR:
3773       priv->state_flags = GTK_STATE_FLAG_DIR_LTR;
3774       break;
3775
3776     case GTK_TEXT_DIR_RTL:
3777       priv->state_flags = GTK_STATE_FLAG_DIR_RTL;
3778       break;
3779
3780     case GTK_TEXT_DIR_NONE:
3781     default:
3782       g_assert_not_reached ();
3783       break;
3784     }
3785
3786
3787   /* this will be set to TRUE if the widget gets a child or if the
3788    * expand flag is set on the widget, but until one of those happen
3789    * we know the expand is already properly FALSE.
3790    *
3791    * We really want to default FALSE here to avoid computing expand
3792    * all over the place while initially building a widget tree.
3793    */
3794   priv->need_compute_expand = FALSE;
3795
3796   _gtk_size_request_cache_init (&priv->requests);
3797
3798   priv->style = gtk_widget_get_default_style ();
3799   g_object_ref (priv->style);
3800 }
3801
3802
3803 static void
3804 gtk_widget_dispatch_child_properties_changed (GtkWidget   *widget,
3805                                               guint        n_pspecs,
3806                                               GParamSpec **pspecs)
3807 {
3808   GtkWidgetPrivate *priv = widget->priv;
3809   GtkWidget *container = priv->parent;
3810   guint i;
3811
3812   for (i = 0; widget->priv->parent == container && i < n_pspecs; i++)
3813     g_signal_emit (widget, widget_signals[CHILD_NOTIFY], g_quark_from_string (pspecs[i]->name), pspecs[i]);
3814 }
3815
3816 /**
3817  * gtk_widget_freeze_child_notify:
3818  * @widget: a #GtkWidget
3819  *
3820  * Stops emission of #GtkWidget::child-notify signals on @widget. The
3821  * signals are queued until gtk_widget_thaw_child_notify() is called
3822  * on @widget.
3823  *
3824  * This is the analogue of g_object_freeze_notify() for child properties.
3825  **/
3826 void
3827 gtk_widget_freeze_child_notify (GtkWidget *widget)
3828 {
3829   g_return_if_fail (GTK_IS_WIDGET (widget));
3830
3831   if (!G_OBJECT (widget)->ref_count)
3832     return;
3833
3834   g_object_ref (widget);
3835   g_object_notify_queue_freeze (G_OBJECT (widget), _gtk_widget_child_property_notify_context);
3836   g_object_unref (widget);
3837 }
3838
3839 /**
3840  * gtk_widget_child_notify:
3841  * @widget: a #GtkWidget
3842  * @child_property: the name of a child property installed on the
3843  *                  class of @widget<!-- -->'s parent
3844  *
3845  * Emits a #GtkWidget::child-notify signal for the
3846  * <link linkend="child-properties">child property</link> @child_property
3847  * on @widget.
3848  *
3849  * This is the analogue of g_object_notify() for child properties.
3850  *
3851  * Also see gtk_container_child_notify().
3852  */
3853 void
3854 gtk_widget_child_notify (GtkWidget    *widget,
3855                          const gchar  *child_property)
3856 {
3857   if (widget->priv->parent == NULL)
3858     return;
3859
3860   gtk_container_child_notify (GTK_CONTAINER (widget->priv->parent), widget, child_property);
3861 }
3862
3863 /**
3864  * gtk_widget_thaw_child_notify:
3865  * @widget: a #GtkWidget
3866  *
3867  * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
3868  * This causes all queued #GtkWidget::child-notify signals on @widget to be
3869  * emitted.
3870  */
3871 void
3872 gtk_widget_thaw_child_notify (GtkWidget *widget)
3873 {
3874   GObjectNotifyQueue *nqueue;
3875
3876   g_return_if_fail (GTK_IS_WIDGET (widget));
3877
3878   if (!G_OBJECT (widget)->ref_count)
3879     return;
3880
3881   g_object_ref (widget);
3882   nqueue = g_object_notify_queue_from_object (G_OBJECT (widget), _gtk_widget_child_property_notify_context);
3883   if (!nqueue || !nqueue->freeze_count)
3884     g_warning (G_STRLOC ": child-property-changed notification for %s(%p) is not frozen",
3885                G_OBJECT_TYPE_NAME (widget), widget);
3886   else
3887     g_object_notify_queue_thaw (G_OBJECT (widget), nqueue);
3888   g_object_unref (widget);
3889 }
3890
3891
3892 /**
3893  * gtk_widget_new:
3894  * @type: type ID of the widget to create
3895  * @first_property_name: name of first property to set
3896  * @...: value of first property, followed by more properties,
3897  *     %NULL-terminated
3898  *
3899  * This is a convenience function for creating a widget and setting
3900  * its properties in one go. For example you might write:
3901  * <literal>gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign",
3902  * 0.0, NULL)</literal> to create a left-aligned label. Equivalent to
3903  * g_object_new(), but returns a widget so you don't have to
3904  * cast the object yourself.
3905  *
3906  * Return value: a new #GtkWidget of type @widget_type
3907  **/
3908 GtkWidget*
3909 gtk_widget_new (GType        type,
3910                 const gchar *first_property_name,
3911                 ...)
3912 {
3913   GtkWidget *widget;
3914   va_list var_args;
3915
3916   g_return_val_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET), NULL);
3917
3918   va_start (var_args, first_property_name);
3919   widget = (GtkWidget *)g_object_new_valist (type, first_property_name, var_args);
3920   va_end (var_args);
3921
3922   return widget;
3923 }
3924
3925 static inline void
3926 gtk_widget_queue_draw_child (GtkWidget *widget)
3927 {
3928   GtkWidgetPrivate *priv = widget->priv;
3929   GtkWidget *parent;
3930
3931   parent = priv->parent;
3932   if (parent && gtk_widget_is_drawable (parent))
3933     gtk_widget_queue_draw_area (parent,
3934                                 priv->allocation.x,
3935                                 priv->allocation.y,
3936                                 priv->allocation.width,
3937                                 priv->allocation.height);
3938 }
3939
3940 /**
3941  * gtk_widget_unparent:
3942  * @widget: a #GtkWidget
3943  *
3944  * This function is only for use in widget implementations.
3945  * Should be called by implementations of the remove method
3946  * on #GtkContainer, to dissociate a child from the container.
3947  **/
3948 void
3949 gtk_widget_unparent (GtkWidget *widget)
3950 {
3951   GtkWidgetPrivate *priv;
3952   GObjectNotifyQueue *nqueue;
3953   GtkWidget *toplevel;
3954   GtkWidget *old_parent;
3955
3956   g_return_if_fail (GTK_IS_WIDGET (widget));
3957
3958   priv = widget->priv;
3959
3960   if (priv->parent == NULL)
3961     return;
3962
3963   /* keep this function in sync with gtk_menu_detach() */
3964
3965   gtk_widget_push_verify_invariants (widget);
3966
3967   g_object_freeze_notify (G_OBJECT (widget));
3968   nqueue = g_object_notify_queue_freeze (G_OBJECT (widget), _gtk_widget_child_property_notify_context);
3969
3970   toplevel = gtk_widget_get_toplevel (widget);
3971   if (gtk_widget_is_toplevel (toplevel))
3972     _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
3973
3974   if (gtk_container_get_focus_child (GTK_CONTAINER (priv->parent)) == widget)
3975     gtk_container_set_focus_child (GTK_CONTAINER (priv->parent), NULL);
3976
3977   gtk_widget_queue_draw_child (widget);
3978
3979   /* Reset the width and height here, to force reallocation if we
3980    * get added back to a new parent. This won't work if our new
3981    * allocation is smaller than 1x1 and we actually want a size of 1x1...
3982    * (would 0x0 be OK here?)
3983    */
3984   priv->allocation.width = 1;
3985   priv->allocation.height = 1;
3986
3987   if (gtk_widget_get_realized (widget))
3988     {
3989       if (priv->in_reparent)
3990         gtk_widget_unmap (widget);
3991       else
3992         gtk_widget_unrealize (widget);
3993     }
3994
3995   /* If we are unanchoring the child, we save around the toplevel
3996    * to emit hierarchy changed
3997    */
3998   if (priv->parent->priv->anchored)
3999     g_object_ref (toplevel);
4000   else
4001     toplevel = NULL;
4002
4003   /* Removing a widget from a container restores the child visible
4004    * flag to the default state, so it doesn't affect the child
4005    * in the next parent.
4006    */
4007   priv->child_visible = TRUE;
4008
4009   old_parent = priv->parent;
4010   priv->parent = NULL;
4011
4012   /* parent may no longer expand if the removed
4013    * child was expand=TRUE and could therefore
4014    * be forcing it to.
4015    */
4016   if (gtk_widget_get_visible (widget) &&
4017       (priv->need_compute_expand ||
4018        priv->computed_hexpand ||
4019        priv->computed_vexpand))
4020     {
4021       gtk_widget_queue_compute_expand (old_parent);
4022     }
4023
4024   /* Unset BACKDROP since we are no longer inside a toplevel window */
4025   gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_BACKDROP);
4026   if (priv->context)
4027     gtk_style_context_set_parent (priv->context, NULL);
4028
4029   _gtk_widget_update_parent_muxer (widget);
4030
4031   g_signal_emit (widget, widget_signals[PARENT_SET], 0, old_parent);
4032   if (toplevel)
4033     {
4034       _gtk_widget_propagate_hierarchy_changed (widget, toplevel);
4035       g_object_unref (toplevel);
4036     }
4037
4038   /* Now that the parent pointer is nullified and the hierarchy-changed
4039    * already passed, go ahead and unset the parent window, if we are unparenting
4040    * an embeded GtkWindow the window will become toplevel again and hierarchy-changed
4041    * will fire again for the new subhierarchy.
4042    */
4043   gtk_widget_set_parent_window (widget, NULL);
4044
4045   g_object_notify (G_OBJECT (widget), "parent");
4046   g_object_thaw_notify (G_OBJECT (widget));
4047   if (!priv->parent)
4048     g_object_notify_queue_clear (G_OBJECT (widget), nqueue);
4049   g_object_notify_queue_thaw (G_OBJECT (widget), nqueue);
4050
4051   gtk_widget_propagate_alpha (widget);
4052
4053   gtk_widget_pop_verify_invariants (widget);
4054   g_object_unref (widget);
4055 }
4056
4057 /**
4058  * gtk_widget_destroy:
4059  * @widget: a #GtkWidget
4060  *
4061  * Destroys a widget.
4062  *
4063  * When a widget is
4064  * destroyed, it will break any references it holds to other objects.
4065  * If the widget is inside a container, the widget will be removed
4066  * from the container. If the widget is a toplevel (derived from
4067  * #GtkWindow), it will be removed from the list of toplevels, and the
4068  * reference GTK+ holds to it will be removed. Removing a
4069  * widget from its container or the list of toplevels results in the
4070  * widget being finalized, unless you've added additional references
4071  * to the widget with g_object_ref().
4072  *
4073  * In most cases, only toplevel widgets (windows) require explicit
4074  * destruction, because when you destroy a toplevel its children will
4075  * be destroyed as well.
4076  **/
4077 void
4078 gtk_widget_destroy (GtkWidget *widget)
4079 {
4080   g_return_if_fail (GTK_IS_WIDGET (widget));
4081
4082   if (!widget->priv->in_destruction)
4083     g_object_run_dispose (G_OBJECT (widget));
4084 }
4085
4086 /**
4087  * gtk_widget_destroyed:
4088  * @widget: a #GtkWidget
4089  * @widget_pointer: (inout) (transfer none): address of a variable that contains @widget
4090  *
4091  * This function sets *@widget_pointer to %NULL if @widget_pointer !=
4092  * %NULL.  It's intended to be used as a callback connected to the
4093  * "destroy" signal of a widget. You connect gtk_widget_destroyed()
4094  * as a signal handler, and pass the address of your widget variable
4095  * as user data. Then when the widget is destroyed, the variable will
4096  * be set to %NULL. Useful for example to avoid multiple copies
4097  * of the same dialog.
4098  **/
4099 void
4100 gtk_widget_destroyed (GtkWidget      *widget,
4101                       GtkWidget      **widget_pointer)
4102 {
4103   /* Don't make any assumptions about the
4104    *  value of widget!
4105    *  Even check widget_pointer.
4106    */
4107   if (widget_pointer)
4108     *widget_pointer = NULL;
4109 }
4110
4111 /**
4112  * gtk_widget_show:
4113  * @widget: a #GtkWidget
4114  *
4115  * Flags a widget to be displayed. Any widget that isn't shown will
4116  * not appear on the screen. If you want to show all the widgets in a
4117  * container, it's easier to call gtk_widget_show_all() on the
4118  * container, instead of individually showing the widgets.
4119  *
4120  * Remember that you have to show the containers containing a widget,
4121  * in addition to the widget itself, before it will appear onscreen.
4122  *
4123  * When a toplevel container is shown, it is immediately realized and
4124  * mapped; other shown widgets are realized and mapped when their
4125  * toplevel container is realized and mapped.
4126  **/
4127 void
4128 gtk_widget_show (GtkWidget *widget)
4129 {
4130   g_return_if_fail (GTK_IS_WIDGET (widget));
4131
4132   if (!gtk_widget_get_visible (widget))
4133     {
4134       g_object_ref (widget);
4135       gtk_widget_push_verify_invariants (widget);
4136
4137       if (!gtk_widget_is_toplevel (widget))
4138         gtk_widget_queue_resize (widget);
4139
4140       /* see comment in set_parent() for why this should and can be
4141        * conditional
4142        */
4143       if (widget->priv->need_compute_expand ||
4144           widget->priv->computed_hexpand ||
4145           widget->priv->computed_vexpand)
4146         {
4147           if (widget->priv->parent != NULL)
4148             gtk_widget_queue_compute_expand (widget->priv->parent);
4149         }
4150
4151       g_signal_emit (widget, widget_signals[SHOW], 0);
4152       g_object_notify (G_OBJECT (widget), "visible");
4153
4154       gtk_widget_pop_verify_invariants (widget);
4155       g_object_unref (widget);
4156     }
4157 }
4158
4159 static void
4160 gtk_widget_real_show (GtkWidget *widget)
4161 {
4162   GtkWidgetPrivate *priv = widget->priv;
4163
4164   if (!gtk_widget_get_visible (widget))
4165     {
4166       priv->visible = TRUE;
4167
4168       if (priv->parent &&
4169           gtk_widget_get_mapped (priv->parent) &&
4170           gtk_widget_get_child_visible (widget) &&
4171           !gtk_widget_get_mapped (widget))
4172         gtk_widget_map (widget);
4173     }
4174 }
4175
4176 static void
4177 gtk_widget_show_map_callback (GtkWidget *widget, GdkEvent *event, gint *flag)
4178 {
4179   *flag = TRUE;
4180   g_signal_handlers_disconnect_by_func (widget,
4181                                         gtk_widget_show_map_callback,
4182                                         flag);
4183 }
4184
4185 /**
4186  * gtk_widget_show_now:
4187  * @widget: a #GtkWidget
4188  *
4189  * Shows a widget. If the widget is an unmapped toplevel widget
4190  * (i.e. a #GtkWindow that has not yet been shown), enter the main
4191  * loop and wait for the window to actually be mapped. Be careful;
4192  * because the main loop is running, anything can happen during
4193  * this function.
4194  **/
4195 void
4196 gtk_widget_show_now (GtkWidget *widget)
4197 {
4198   gint flag = FALSE;
4199
4200   g_return_if_fail (GTK_IS_WIDGET (widget));
4201
4202   /* make sure we will get event */
4203   if (!gtk_widget_get_mapped (widget) &&
4204       gtk_widget_is_toplevel (widget))
4205     {
4206       gtk_widget_show (widget);
4207
4208       g_signal_connect (widget, "map-event",
4209                         G_CALLBACK (gtk_widget_show_map_callback),
4210                         &flag);
4211
4212       while (!flag)
4213         gtk_main_iteration ();
4214     }
4215   else
4216     gtk_widget_show (widget);
4217 }
4218
4219 /**
4220  * gtk_widget_hide:
4221  * @widget: a #GtkWidget
4222  *
4223  * Reverses the effects of gtk_widget_show(), causing the widget to be
4224  * hidden (invisible to the user).
4225  **/
4226 void
4227 gtk_widget_hide (GtkWidget *widget)
4228 {
4229   g_return_if_fail (GTK_IS_WIDGET (widget));
4230
4231   if (gtk_widget_get_visible (widget))
4232     {
4233       GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
4234
4235       g_object_ref (widget);
4236       gtk_widget_push_verify_invariants (widget);
4237
4238       if (toplevel != widget && gtk_widget_is_toplevel (toplevel))
4239         _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
4240
4241       /* a parent may now be expand=FALSE since we're hidden. */
4242       if (widget->priv->need_compute_expand ||
4243           widget->priv->computed_hexpand ||
4244           widget->priv->computed_vexpand)
4245         {
4246           gtk_widget_queue_compute_expand (widget);
4247         }
4248
4249       g_signal_emit (widget, widget_signals[HIDE], 0);
4250       if (!gtk_widget_is_toplevel (widget))
4251         gtk_widget_queue_resize (widget);
4252       g_object_notify (G_OBJECT (widget), "visible");
4253
4254       gtk_widget_pop_verify_invariants (widget);
4255       g_object_unref (widget);
4256     }
4257 }
4258
4259 static void
4260 gtk_widget_real_hide (GtkWidget *widget)
4261 {
4262   if (gtk_widget_get_visible (widget))
4263     {
4264       widget->priv->visible = FALSE;
4265
4266       if (gtk_widget_get_mapped (widget))
4267         gtk_widget_unmap (widget);
4268     }
4269 }
4270
4271 /**
4272  * gtk_widget_hide_on_delete:
4273  * @widget: a #GtkWidget
4274  *
4275  * Utility function; intended to be connected to the #GtkWidget::delete-event
4276  * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
4277  * argument, then returns %TRUE. If connected to ::delete-event, the
4278  * result is that clicking the close button for a window (on the
4279  * window frame, top right corner usually) will hide but not destroy
4280  * the window. By default, GTK+ destroys windows when ::delete-event
4281  * is received.
4282  *
4283  * Return value: %TRUE
4284  **/
4285 gboolean
4286 gtk_widget_hide_on_delete (GtkWidget *widget)
4287 {
4288   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
4289
4290   gtk_widget_hide (widget);
4291
4292   return TRUE;
4293 }
4294
4295 /**
4296  * gtk_widget_show_all:
4297  * @widget: a #GtkWidget
4298  *
4299  * Recursively shows a widget, and any child widgets (if the widget is
4300  * a container).
4301  **/
4302 void
4303 gtk_widget_show_all (GtkWidget *widget)
4304 {
4305   GtkWidgetClass *class;
4306
4307   g_return_if_fail (GTK_IS_WIDGET (widget));
4308
4309   if (gtk_widget_get_no_show_all (widget))
4310     return;
4311
4312   class = GTK_WIDGET_GET_CLASS (widget);
4313
4314   if (class->show_all)
4315     class->show_all (widget);
4316 }
4317
4318 /**
4319  * gtk_widget_map:
4320  * @widget: a #GtkWidget
4321  *
4322  * This function is only for use in widget implementations. Causes
4323  * a widget to be mapped if it isn't already.
4324  **/
4325 void
4326 gtk_widget_map (GtkWidget *widget)
4327 {
4328   GtkWidgetPrivate *priv;
4329
4330   g_return_if_fail (GTK_IS_WIDGET (widget));
4331   g_return_if_fail (gtk_widget_get_visible (widget));
4332   g_return_if_fail (gtk_widget_get_child_visible (widget));
4333
4334   priv = widget->priv;
4335
4336   if (!gtk_widget_get_mapped (widget))
4337     {
4338       gtk_widget_push_verify_invariants (widget);
4339
4340       if (!gtk_widget_get_realized (widget))
4341         gtk_widget_realize (widget);
4342
4343       g_signal_emit (widget, widget_signals[MAP], 0);
4344
4345       if (!gtk_widget_get_has_window (widget))
4346         gdk_window_invalidate_rect (priv->window, &priv->allocation, FALSE);
4347
4348       if (widget->priv->context)
4349         _gtk_style_context_update_animating (widget->priv->context);
4350
4351       gtk_widget_pop_verify_invariants (widget);
4352     }
4353 }
4354
4355 /**
4356  * gtk_widget_unmap:
4357  * @widget: a #GtkWidget
4358  *
4359  * This function is only for use in widget implementations. Causes
4360  * a widget to be unmapped if it's currently mapped.
4361  **/
4362 void
4363 gtk_widget_unmap (GtkWidget *widget)
4364 {
4365   GtkWidgetPrivate *priv;
4366
4367   g_return_if_fail (GTK_IS_WIDGET (widget));
4368
4369   priv = widget->priv;
4370
4371   if (gtk_widget_get_mapped (widget))
4372     {
4373       gtk_widget_push_verify_invariants (widget);
4374
4375       if (!gtk_widget_get_has_window (widget))
4376         gdk_window_invalidate_rect (priv->window, &priv->allocation, FALSE);
4377       _gtk_tooltip_hide (widget);
4378
4379       if (widget->priv->context)
4380         _gtk_style_context_update_animating (widget->priv->context);
4381
4382       g_signal_emit (widget, widget_signals[UNMAP], 0);
4383
4384       gtk_widget_pop_verify_invariants (widget);
4385
4386       /* Unset pointer/window info */
4387       g_object_set_qdata (G_OBJECT (widget), quark_pointer_window, NULL);
4388     }
4389 }
4390
4391 static void
4392 _gtk_widget_enable_device_events (GtkWidget *widget)
4393 {
4394   GHashTable *device_events;
4395   GHashTableIter iter;
4396   gpointer key, value;
4397
4398   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
4399
4400   if (!device_events)
4401     return;
4402
4403   g_hash_table_iter_init (&iter, device_events);
4404
4405   while (g_hash_table_iter_next (&iter, &key, &value))
4406     {
4407       GdkDevice *device;
4408       GdkEventMask event_mask;
4409
4410       device = key;
4411       event_mask = GPOINTER_TO_UINT (value);
4412       gtk_widget_add_events_internal (widget, device, event_mask);
4413     }
4414 }
4415
4416 static GList *
4417 get_widget_windows (GtkWidget *widget)
4418 {
4419   GList *window_list, *last, *l, *children, *ret;
4420
4421   if (gtk_widget_get_has_window (widget))
4422     window_list = g_list_prepend (NULL, gtk_widget_get_window (widget));
4423   else
4424     window_list = gdk_window_peek_children (gtk_widget_get_window (widget));
4425
4426   last = g_list_last (window_list);
4427   ret = NULL;
4428
4429   for (l = window_list; l; l = l->next)
4430     {
4431       GtkWidget *window_widget = NULL;
4432
4433       gdk_window_get_user_data (l->data, (gpointer *) &window_widget);
4434
4435       if (widget != window_widget)
4436         continue;
4437
4438       ret = g_list_prepend (ret, l->data);
4439       children = gdk_window_peek_children (GDK_WINDOW (l->data));
4440
4441       if (children)
4442         {
4443           last = g_list_concat (last, children);
4444           last = g_list_last (last);
4445         }
4446     }
4447
4448   g_list_free (window_list);
4449
4450   return ret;
4451 }
4452
4453 static void
4454 device_enable_foreach (GtkWidget *widget,
4455                        gpointer   user_data)
4456 {
4457   GdkDevice *device = user_data;
4458   gtk_widget_set_device_enabled_internal (widget, device, TRUE, TRUE);
4459 }
4460
4461 static void
4462 device_disable_foreach (GtkWidget *widget,
4463                         gpointer   user_data)
4464 {
4465   GdkDevice *device = user_data;
4466   gtk_widget_set_device_enabled_internal (widget, device, TRUE, FALSE);
4467 }
4468
4469 static void
4470 gtk_widget_set_device_enabled_internal (GtkWidget *widget,
4471                                         GdkDevice *device,
4472                                         gboolean   recurse,
4473                                         gboolean   enabled)
4474 {
4475   GList *window_list, *l;
4476
4477   window_list = get_widget_windows (widget);
4478
4479   for (l = window_list; l; l = l->next)
4480     {
4481       GdkEventMask events = 0;
4482       GdkWindow *window;
4483
4484       window = l->data;
4485
4486       if (enabled)
4487         events = gdk_window_get_events (window);
4488
4489       gdk_window_set_device_events (window, device, events);
4490     }
4491
4492   if (recurse && GTK_IS_CONTAINER (widget))
4493     {
4494       if (enabled)
4495         gtk_container_forall (GTK_CONTAINER (widget), device_enable_foreach, device);
4496       else
4497         gtk_container_forall (GTK_CONTAINER (widget), device_disable_foreach, device);
4498     }
4499
4500   g_list_free (window_list);
4501 }
4502
4503 static void
4504 gtk_widget_update_devices_mask (GtkWidget *widget,
4505                                 gboolean   recurse)
4506 {
4507   GList *enabled_devices, *l;
4508
4509   enabled_devices = g_object_get_qdata (G_OBJECT (widget), quark_enabled_devices);
4510
4511   for (l = enabled_devices; l; l = l->next)
4512     gtk_widget_set_device_enabled_internal (widget, GDK_DEVICE (l->data), recurse, TRUE);
4513 }
4514
4515 typedef struct _GtkTickCallbackInfo GtkTickCallbackInfo;
4516
4517 struct _GtkTickCallbackInfo
4518 {
4519   guint refcount;
4520
4521   guint id;
4522   GtkTickCallback callback;
4523   gpointer user_data;
4524   GDestroyNotify notify;
4525
4526   guint destroyed : 1;
4527 };
4528
4529 static void
4530 ref_tick_callback_info (GtkTickCallbackInfo *info)
4531 {
4532   info->refcount++;
4533 }
4534
4535 static void
4536 unref_tick_callback_info (GtkWidget           *widget,
4537                           GtkTickCallbackInfo *info,
4538                           GList               *link)
4539 {
4540   GtkWidgetPrivate *priv = widget->priv;
4541
4542   info->refcount--;
4543   if (info->refcount == 0)
4544     {
4545       priv->tick_callbacks = g_list_delete_link (priv->tick_callbacks, link);
4546       if (info->notify)
4547         info->notify (info->user_data);
4548       g_slice_free (GtkTickCallbackInfo, info);
4549     }
4550
4551   if (priv->tick_callbacks == NULL && priv->realized)
4552     {
4553       GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
4554       g_signal_handlers_disconnect_by_func (frame_clock,
4555                                             (gpointer) gtk_widget_on_frame_clock_update,
4556                                             widget);
4557     }
4558 }
4559
4560 static void
4561 destroy_tick_callback_info (GtkWidget           *widget,
4562                             GtkTickCallbackInfo *info,
4563                             GList               *link)
4564 {
4565   if (!info->destroyed)
4566     {
4567       info->destroyed = TRUE;
4568       unref_tick_callback_info (widget, info, link);
4569     }
4570 }
4571
4572 static void
4573 gtk_widget_on_frame_clock_update (GdkFrameClock *frame_clock,
4574                                   GtkWidget     *widget)
4575 {
4576   GtkWidgetPrivate *priv = widget->priv;
4577   GList *l;
4578
4579   for (l = priv->tick_callbacks; l;)
4580     {
4581       GtkTickCallbackInfo *info = l->data;
4582       GList *next;
4583
4584       ref_tick_callback_info (info);
4585       if (!info->destroyed)
4586         {
4587           if (!info->callback (widget,
4588                                frame_clock,
4589                                info->user_data))
4590             {
4591               destroy_tick_callback_info (widget, info, l);
4592             }
4593         }
4594
4595       next = l->next;
4596       unref_tick_callback_info (widget, info, l);
4597       l = next;
4598     }
4599
4600   if (priv->tick_callbacks != NULL)
4601     gdk_frame_clock_request_phase (frame_clock,
4602                                    GDK_FRAME_CLOCK_PHASE_UPDATE);
4603 }
4604
4605 static guint tick_callback_id;
4606
4607 /**
4608  * gtk_widget_add_tick_callback:
4609  * @widget: a #GtkWidget
4610  * @callback: function to call for updating animations
4611  * @user_data: data to pass to @callback
4612  * @notify: function to call to free @user_data when the callback is removed.
4613  *
4614  * Queues a animation frame update and adds a callback to be called
4615  * before each frame. Until the tick callback is removed, it will be
4616  * called frequently (usually at the frame rate of the output device
4617  * or as quickly as the application an be repainted, whichever is
4618  * slower). For this reason, is most suitable for handling graphics
4619  * that change every frame or every few frames. The tick callback does
4620  * not automatically imply a relayout or repaint. If you want a
4621  * repaint or relayout, and aren't changing widget properties that
4622  * would trigger that (for example, changing the text of a #GtkLabel),
4623  * then you will have to call gtk_widget_queue_resize() or
4624  * gtk_widget_queue_draw_area() yourself.
4625  *
4626  * gtk_frame_clock_get_frame_time() should generally be used for timing
4627  * continuous animations and
4628  * gtk_frame_timings_get_predicted_presentation_time() if you are
4629  * trying to display isolated frames particular times.
4630  *
4631  * This is a more convenient alternative to connecting directly to the
4632  * ::update signal of GdkFrameClock, since you don't have to worry about
4633  * when a #GdkFrameClock is assigned to a widget.
4634  */
4635 guint
4636 gtk_widget_add_tick_callback (GtkWidget       *widget,
4637                               GtkTickCallback  callback,
4638                               gpointer         user_data,
4639                               GDestroyNotify   notify)
4640 {
4641   GtkWidgetPrivate *priv;
4642   GtkTickCallbackInfo *info;
4643
4644   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
4645
4646   priv = widget->priv;
4647
4648   if (priv->tick_callbacks == NULL && priv->realized)
4649     {
4650       GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
4651       g_signal_connect (frame_clock, "update",
4652                         G_CALLBACK (gtk_widget_on_frame_clock_update),
4653                         widget);
4654       gdk_frame_clock_request_phase (frame_clock,
4655                                      GDK_FRAME_CLOCK_PHASE_UPDATE);
4656     }
4657
4658   info = g_slice_new (GtkTickCallbackInfo);
4659
4660   info->refcount = 1;
4661   info->id = ++tick_callback_id;
4662   info->callback = callback;
4663   info->user_data = user_data;
4664   info->notify = notify;
4665
4666   priv->tick_callbacks = g_list_prepend (priv->tick_callbacks,
4667                                          info);
4668
4669   return info->id;
4670 }
4671
4672 void
4673 gtk_widget_remove_tick_callback (GtkWidget *widget,
4674                                  guint      id)
4675 {
4676   GtkWidgetPrivate *priv;
4677   GList *l;
4678
4679   g_return_if_fail (GTK_IS_WIDGET (widget));
4680
4681   priv = widget->priv;
4682
4683   for (l = priv->tick_callbacks; l; l = l->next)
4684     {
4685       GtkTickCallbackInfo *info = l->data;
4686       if (info->id == id)
4687         destroy_tick_callback_info (widget, info, l);
4688     }
4689 }
4690
4691 static void
4692 gtk_widget_connect_frame_clock (GtkWidget     *widget,
4693                                 GdkFrameClock *frame_clock)
4694 {
4695   GtkWidgetPrivate *priv = widget->priv;
4696
4697   if (priv->tick_callbacks != NULL)
4698     {
4699       g_signal_connect (frame_clock, "update",
4700                         G_CALLBACK (gtk_widget_on_frame_clock_update),
4701                         widget);
4702       gdk_frame_clock_request_phase (frame_clock,
4703                                      GDK_FRAME_CLOCK_PHASE_UPDATE);
4704     }
4705
4706   if (priv->context)
4707     gtk_style_context_set_frame_clock (priv->context, frame_clock);
4708 }
4709
4710 static void
4711 gtk_widget_disconnect_frame_clock (GtkWidget     *widget,
4712                                    GdkFrameClock *frame_clock)
4713 {
4714   GtkWidgetPrivate *priv = widget->priv;
4715
4716   if (priv->tick_callbacks)
4717     g_signal_handlers_disconnect_by_func (frame_clock,
4718                                           (gpointer) gtk_widget_on_frame_clock_update,
4719                                           widget);
4720
4721   if (priv->context)
4722     gtk_style_context_set_frame_clock (priv->context, NULL);
4723 }
4724
4725 /**
4726  * gtk_widget_realize:
4727  * @widget: a #GtkWidget
4728  *
4729  * Creates the GDK (windowing system) resources associated with a
4730  * widget.  For example, @widget->window will be created when a widget
4731  * is realized.  Normally realization happens implicitly; if you show
4732  * a widget and all its parent containers, then the widget will be
4733  * realized and mapped automatically.
4734  *
4735  * Realizing a widget requires all
4736  * the widget's parent widgets to be realized; calling
4737  * gtk_widget_realize() realizes the widget's parents in addition to
4738  * @widget itself. If a widget is not yet inside a toplevel window
4739  * when you realize it, bad things will happen.
4740  *
4741  * This function is primarily used in widget implementations, and
4742  * isn't very useful otherwise. Many times when you think you might
4743  * need it, a better approach is to connect to a signal that will be
4744  * called after the widget is realized automatically, such as
4745  * #GtkWidget::draw. Or simply g_signal_connect () to the
4746  * #GtkWidget::realize signal.
4747  **/
4748 void
4749 gtk_widget_realize (GtkWidget *widget)
4750 {
4751   GtkWidgetPrivate *priv;
4752   cairo_region_t *region;
4753
4754   g_return_if_fail (GTK_IS_WIDGET (widget));
4755   g_return_if_fail (widget->priv->anchored ||
4756                     GTK_IS_INVISIBLE (widget));
4757
4758   priv = widget->priv;
4759
4760   if (!gtk_widget_get_realized (widget))
4761     {
4762       gtk_widget_push_verify_invariants (widget);
4763
4764       /*
4765         if (GTK_IS_CONTAINER (widget) && gtk_widget_get_has_window (widget))
4766           g_message ("gtk_widget_realize(%s)", G_OBJECT_TYPE_NAME (widget));
4767       */
4768
4769       if (priv->parent == NULL &&
4770           !gtk_widget_is_toplevel (widget))
4771         g_warning ("Calling gtk_widget_realize() on a widget that isn't "
4772                    "inside a toplevel window is not going to work very well. "
4773                    "Widgets must be inside a toplevel container before realizing them.");
4774
4775       if (priv->parent && !gtk_widget_get_realized (priv->parent))
4776         gtk_widget_realize (priv->parent);
4777
4778       gtk_widget_ensure_style (widget);
4779
4780       if (priv->style_update_pending)
4781         g_signal_emit (widget, widget_signals[STYLE_UPDATED], 0);
4782
4783       g_signal_emit (widget, widget_signals[REALIZE], 0);
4784
4785       gtk_widget_real_set_has_tooltip (widget,
4786                                        GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget), quark_has_tooltip)),
4787                                        TRUE);
4788
4789       if (priv->has_shape_mask)
4790         {
4791           region = g_object_get_qdata (G_OBJECT (widget), quark_shape_info);
4792           gdk_window_shape_combine_region (priv->window, region, 0, 0);
4793         }
4794
4795       region = g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info);
4796       if (region)
4797         gdk_window_input_shape_combine_region (priv->window, region, 0, 0);
4798
4799       if (priv->multidevice)
4800         gdk_window_set_support_multidevice (priv->window, TRUE);
4801
4802       _gtk_widget_enable_device_events (widget);
4803       gtk_widget_update_devices_mask (widget, TRUE);
4804
4805       if (GTK_IS_CONTAINER (widget))
4806         _gtk_container_maybe_start_idle_sizer (GTK_CONTAINER (widget));
4807
4808       gtk_widget_connect_frame_clock (widget,
4809                                       gtk_widget_get_frame_clock (widget));
4810
4811       gtk_widget_pop_verify_invariants (widget);
4812     }
4813 }
4814
4815 /**
4816  * gtk_widget_unrealize:
4817  * @widget: a #GtkWidget
4818  *
4819  * This function is only useful in widget implementations.
4820  * Causes a widget to be unrealized (frees all GDK resources
4821  * associated with the widget, such as @widget->window).
4822  **/
4823 void
4824 gtk_widget_unrealize (GtkWidget *widget)
4825 {
4826   g_return_if_fail (GTK_IS_WIDGET (widget));
4827
4828   gtk_widget_push_verify_invariants (widget);
4829
4830   if (widget->priv->has_shape_mask)
4831     gtk_widget_shape_combine_region (widget, NULL);
4832
4833   if (g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info))
4834     gtk_widget_input_shape_combine_region (widget, NULL);
4835
4836   if (gtk_widget_get_realized (widget))
4837     {
4838       g_object_ref (widget);
4839
4840       if (widget->priv->mapped)
4841         gtk_widget_unmap (widget);
4842
4843       gtk_widget_disconnect_frame_clock (widget,
4844                                          gtk_widget_get_frame_clock (widget));
4845
4846       g_signal_emit (widget, widget_signals[UNREALIZE], 0);
4847       g_assert (!widget->priv->mapped);
4848       gtk_widget_set_realized (widget, FALSE);
4849
4850       g_object_unref (widget);
4851     }
4852
4853   gtk_widget_pop_verify_invariants (widget);
4854 }
4855
4856 /*****************************************
4857  * Draw queueing.
4858  *****************************************/
4859
4860 /**
4861  * gtk_widget_queue_draw_region:
4862  * @widget: a #GtkWidget
4863  * @region: region to draw
4864  *
4865  * Invalidates the rectangular area of @widget defined by @region by
4866  * calling gdk_window_invalidate_region() on the widget's window and
4867  * all its child windows. Once the main loop becomes idle (after the
4868  * current batch of events has been processed, roughly), the window
4869  * will receive expose events for the union of all regions that have
4870  * been invalidated.
4871  *
4872  * Normally you would only use this function in widget
4873  * implementations. You might also use it to schedule a redraw of a
4874  * #GtkDrawingArea or some portion thereof.
4875  *
4876  * Since: 3.0
4877  **/
4878 void
4879 gtk_widget_queue_draw_region (GtkWidget            *widget,
4880                               const cairo_region_t *region)
4881 {
4882   GtkWidgetPrivate *priv;
4883   GtkWidget *w;
4884
4885   g_return_if_fail (GTK_IS_WIDGET (widget));
4886
4887   priv = widget->priv;
4888
4889   if (!gtk_widget_get_realized (widget))
4890     return;
4891
4892   /* Just return if the widget or one of its ancestors isn't mapped */
4893   for (w = widget; w != NULL; w = w->priv->parent)
4894     if (!gtk_widget_get_mapped (w))
4895       return;
4896
4897   gdk_window_invalidate_region (priv->window, region, TRUE);
4898 }
4899
4900 /**
4901  * gtk_widget_queue_draw_area:
4902  * @widget: a #GtkWidget
4903  * @x: x coordinate of upper-left corner of rectangle to redraw
4904  * @y: y coordinate of upper-left corner of rectangle to redraw
4905  * @width: width of region to draw
4906  * @height: height of region to draw
4907  *
4908  * Convenience function that calls gtk_widget_queue_draw_region() on
4909  * the region created from the given coordinates.
4910  *
4911  * The region here is specified in widget coordinates.
4912  * Widget coordinates are a bit odd; for historical reasons, they are
4913  * defined as @widget->window coordinates for widgets that are not
4914  * #GTK_NO_WINDOW widgets, and are relative to @widget->allocation.x,
4915  * @widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
4916  */
4917 void
4918 gtk_widget_queue_draw_area (GtkWidget *widget,
4919                             gint       x,
4920                             gint       y,
4921                             gint       width,
4922                             gint       height)
4923 {
4924   GdkRectangle rect;
4925   cairo_region_t *region;
4926
4927   g_return_if_fail (GTK_IS_WIDGET (widget));
4928
4929   rect.x = x;
4930   rect.y = y;
4931   rect.width = width;
4932   rect.height = height;
4933
4934   region = cairo_region_create_rectangle (&rect);
4935   gtk_widget_queue_draw_region (widget, region);
4936   cairo_region_destroy (region);
4937 }
4938
4939 /**
4940  * gtk_widget_queue_draw:
4941  * @widget: a #GtkWidget
4942  *
4943  * Equivalent to calling gtk_widget_queue_draw_area() for the
4944  * entire area of a widget.
4945  **/
4946 void
4947 gtk_widget_queue_draw (GtkWidget *widget)
4948 {
4949   GdkRectangle rect;
4950
4951   g_return_if_fail (GTK_IS_WIDGET (widget));
4952
4953   gtk_widget_get_allocation (widget, &rect);
4954
4955   if (!gtk_widget_get_has_window (widget))
4956     gtk_widget_queue_draw_area (widget,
4957                                 rect.x, rect.y, rect.width, rect.height);
4958   else
4959     gtk_widget_queue_draw_area (widget,
4960                                 0, 0, rect.width, rect.height);
4961 }
4962
4963 /**
4964  * gtk_widget_queue_resize:
4965  * @widget: a #GtkWidget
4966  *
4967  * This function is only for use in widget implementations.
4968  * Flags a widget to have its size renegotiated; should
4969  * be called when a widget for some reason has a new size request.
4970  * For example, when you change the text in a #GtkLabel, #GtkLabel
4971  * queues a resize to ensure there's enough space for the new text.
4972  *
4973  * <note><para>You cannot call gtk_widget_queue_resize() on a widget
4974  * from inside its implementation of the GtkWidgetClass::size_allocate
4975  * virtual method. Calls to gtk_widget_queue_resize() from inside
4976  * GtkWidgetClass::size_allocate will be silently ignored.</para></note>
4977  **/
4978 void
4979 gtk_widget_queue_resize (GtkWidget *widget)
4980 {
4981   g_return_if_fail (GTK_IS_WIDGET (widget));
4982
4983   if (gtk_widget_get_realized (widget))
4984     gtk_widget_queue_draw (widget);
4985
4986   _gtk_size_group_queue_resize (widget, 0);
4987 }
4988
4989 /**
4990  * gtk_widget_queue_resize_no_redraw:
4991  * @widget: a #GtkWidget
4992  *
4993  * This function works like gtk_widget_queue_resize(),
4994  * except that the widget is not invalidated.
4995  *
4996  * Since: 2.4
4997  **/
4998 void
4999 gtk_widget_queue_resize_no_redraw (GtkWidget *widget)
5000 {
5001   g_return_if_fail (GTK_IS_WIDGET (widget));
5002
5003   _gtk_size_group_queue_resize (widget, 0);
5004 }
5005
5006 /**
5007  * gtk_widget_get_frame_clock:
5008  * @widget: a #GtkWidget
5009  *
5010  * Obtains the frame clock for a widget. The frame clock is a global
5011  * "ticker" that can be used to drive animations and repaints.  The
5012  * most common reason to get the frame clock is to call
5013  * gdk_frame_clock_get_frame_time(), in order to get a time to use for
5014  * animating. For example you might record the start of the animation
5015  * with an initial value from gdk_frame_clock_get_frame_time(), and
5016  * then update the animation by calling
5017  * gdk_frame_clock_get_frame_time() again during each repaint.
5018  *
5019  * gdk_frame_clock_request_phase() will result in a new frame on the
5020  * clock, but won't necessarily repaint any widgets. To repaint a
5021  * widget, you have to use gtk_widget_queue_draw() which invalidates
5022  * the widget (thus scheduling it to receive a draw on the next
5023  * frame). gtk_widget_queue_draw() will also end up requesting a frame
5024  * on the appropriate frame clock.
5025  *
5026  * A widget's frame clock will not change while the widget is
5027  * mapped. Reparenting a widget (which implies a temporary unmap) can
5028  * change the widget's frame clock.
5029  *
5030  * Unrealized widgets do not have a frame clock.
5031  *
5032  * Since: 3.0
5033  * Return value: (transfer none): a #GdkFrameClock (or #NULL if widget is unrealized)
5034  */
5035 GdkFrameClock*
5036 gtk_widget_get_frame_clock (GtkWidget *widget)
5037 {
5038   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
5039
5040   if (widget->priv->realized)
5041     {
5042       /* We use gtk_widget_get_toplevel() here to make it explicit that
5043        * the frame clock is a property of the toplevel that a widget
5044        * is anchored to; gdk_window_get_toplevel() will go up the
5045        * hierarchy anyways, but should squash any funny business with
5046        * reparenting windows and widgets.
5047        */
5048       GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
5049       GdkWindow *window = gtk_widget_get_window (toplevel);
5050       g_assert (window != NULL);
5051
5052       return gdk_window_get_frame_clock (window);
5053     }
5054   else
5055     {
5056       return NULL;
5057     }
5058 }
5059
5060 /**
5061  * gtk_widget_size_request:
5062  * @widget: a #GtkWidget
5063  * @requisition: (out): a #GtkRequisition to be filled in
5064  *
5065  * This function is typically used when implementing a #GtkContainer
5066  * subclass.  Obtains the preferred size of a widget. The container
5067  * uses this information to arrange its child widgets and decide what
5068  * size allocations to give them with gtk_widget_size_allocate().
5069  *
5070  * You can also call this function from an application, with some
5071  * caveats. Most notably, getting a size request requires the widget
5072  * to be associated with a screen, because font information may be
5073  * needed. Multihead-aware applications should keep this in mind.
5074  *
5075  * Also remember that the size request is not necessarily the size
5076  * a widget will actually be allocated.
5077  *
5078  * Deprecated: 3.0: Use gtk_widget_get_preferred_size() instead.
5079  **/
5080 void
5081 gtk_widget_size_request (GtkWidget      *widget,
5082                          GtkRequisition *requisition)
5083 {
5084   g_return_if_fail (GTK_IS_WIDGET (widget));
5085
5086   gtk_widget_get_preferred_size (widget, requisition, NULL);
5087 }
5088
5089 /**
5090  * gtk_widget_get_child_requisition:
5091  * @widget: a #GtkWidget
5092  * @requisition: (out): a #GtkRequisition to be filled in
5093  *
5094  * This function is only for use in widget implementations. Obtains
5095  * @widget->requisition, unless someone has forced a particular
5096  * geometry on the widget (e.g. with gtk_widget_set_size_request()),
5097  * in which case it returns that geometry instead of the widget's
5098  * requisition.
5099  *
5100  * This function differs from gtk_widget_size_request() in that
5101  * it retrieves the last size request value from @widget->requisition,
5102  * while gtk_widget_size_request() actually calls the "size_request" method
5103  * on @widget to compute the size request and fill in @widget->requisition,
5104  * and only then returns @widget->requisition.
5105  *
5106  * Because this function does not call the "size_request" method, it
5107  * can only be used when you know that @widget->requisition is
5108  * up-to-date, that is, gtk_widget_size_request() has been called
5109  * since the last time a resize was queued. In general, only container
5110  * implementations have this information; applications should use
5111  * gtk_widget_size_request().
5112  *
5113  *
5114  * Deprecated: 3.0: Use gtk_widget_get_preferred_size() instead.
5115  **/
5116 void
5117 gtk_widget_get_child_requisition (GtkWidget      *widget,
5118                                   GtkRequisition *requisition)
5119 {
5120   gtk_widget_get_preferred_size (widget, requisition, NULL);
5121 }
5122
5123 static gboolean
5124 invalidate_predicate (GdkWindow *window,
5125                       gpointer   data)
5126 {
5127   gpointer user_data;
5128
5129   gdk_window_get_user_data (window, &user_data);
5130
5131   return (user_data == data);
5132 }
5133
5134 /* Invalidate @region in widget->window and all children
5135  * of widget->window owned by widget. @region is in the
5136  * same coordinates as widget->allocation and will be
5137  * modified by this call.
5138  */
5139 static void
5140 gtk_widget_invalidate_widget_windows (GtkWidget *widget,
5141                                       cairo_region_t *region)
5142 {
5143   GtkWidgetPrivate *priv = widget->priv;
5144
5145   if (!gtk_widget_get_realized (widget))
5146     return;
5147
5148   if (gtk_widget_get_has_window (widget) && priv->parent)
5149     {
5150       int x, y;
5151
5152       gdk_window_get_position (priv->window, &x, &y);
5153       cairo_region_translate (region, -x, -y);
5154     }
5155
5156   gdk_window_invalidate_maybe_recurse (priv->window, region,
5157                                        invalidate_predicate, widget);
5158 }
5159
5160 /**
5161  * gtk_widget_size_allocate:
5162  * @widget: a #GtkWidget
5163  * @allocation: position and size to be allocated to @widget
5164  *
5165  * This function is only used by #GtkContainer subclasses, to assign a size
5166  * and position to their child widgets.
5167  *
5168  * In this function, the allocation may be adjusted. It will be forced
5169  * to a 1x1 minimum size, and the adjust_size_allocation virtual
5170  * method on the child will be used to adjust the allocation. Standard
5171  * adjustments include removing the widget's margins, and applying the
5172  * widget's #GtkWidget:halign and #GtkWidget:valign properties.
5173  **/
5174 void
5175 gtk_widget_size_allocate (GtkWidget     *widget,
5176                           GtkAllocation *allocation)
5177 {
5178   GtkWidgetPrivate *priv;
5179   GdkRectangle real_allocation;
5180   GdkRectangle old_allocation;
5181   GdkRectangle adjusted_allocation;
5182   gboolean alloc_needed;
5183   gboolean size_changed;
5184   gboolean position_changed;
5185   gint natural_width, natural_height, dummy;
5186   gint min_width, min_height;
5187
5188   priv = widget->priv;
5189
5190   g_return_if_fail (GTK_IS_WIDGET (widget));
5191
5192   if (!priv->visible && !gtk_widget_is_toplevel (widget))
5193     return;
5194
5195   gtk_widget_push_verify_invariants (widget);
5196
5197 #ifdef G_ENABLE_DEBUG
5198   if (gtk_get_debug_flags () & GTK_DEBUG_GEOMETRY)
5199     {
5200       gint depth;
5201       GtkWidget *parent;
5202       const gchar *name;
5203
5204       depth = 0;
5205       parent = widget;
5206       while (parent)
5207         {
5208           depth++;
5209           parent = gtk_widget_get_parent (parent);
5210         }
5211
5212       name = g_type_name (G_OBJECT_TYPE (G_OBJECT (widget)));
5213       g_print ("gtk_widget_size_allocate: %*s%s %d %d\n",
5214                2 * depth, " ", name,
5215                allocation->width, allocation->height);
5216     }
5217 #endif /* G_ENABLE_DEBUG */
5218
5219   alloc_needed = priv->alloc_needed;
5220   /* Preserve request/allocate ordering */
5221   priv->alloc_needed = FALSE;
5222
5223   old_allocation = priv->allocation;
5224   real_allocation = *allocation;
5225
5226   adjusted_allocation = real_allocation;
5227   if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
5228     {
5229       /* Go ahead and request the height for allocated width, note that the internals
5230        * of get_height_for_width will internally limit the for_size to natural size
5231        * when aligning implicitly.
5232        */
5233       gtk_widget_get_preferred_width (widget, &min_width, &natural_width);
5234       gtk_widget_get_preferred_height_for_width (widget, real_allocation.width, &min_height, &natural_height);
5235     }
5236   else
5237     {
5238       /* Go ahead and request the width for allocated height, note that the internals
5239        * of get_width_for_height will internally limit the for_size to natural size
5240        * when aligning implicitly.
5241        */
5242       gtk_widget_get_preferred_height (widget, &min_height, &natural_height);
5243       gtk_widget_get_preferred_width_for_height (widget, real_allocation.height, &min_width, &natural_width);
5244     }
5245
5246 #ifdef G_ENABLE_DEBUG
5247   if (gtk_get_debug_flags () & GTK_DEBUG_GEOMETRY)
5248     {
5249       if ((min_width > real_allocation.width || min_height > real_allocation.height) &&
5250           !GTK_IS_SCROLLABLE (widget))
5251         g_warning ("gtk_widget_size_allocate(): attempt to underallocate %s%s %s %p. "
5252                    "Allocation is %dx%d, but minimum required size is %dx%d.",
5253                    priv->parent ? G_OBJECT_TYPE_NAME (priv->parent) : "", priv->parent ? "'s child" : "toplevel",
5254                    G_OBJECT_TYPE_NAME (widget), widget,
5255                    real_allocation.width, real_allocation.height,
5256                    min_width, min_height);
5257     }
5258 #endif
5259   /* Now that we have the right natural height and width, go ahead and remove any margins from the
5260    * allocated sizes and possibly limit them to the natural sizes */
5261   GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
5262                                                          GTK_ORIENTATION_HORIZONTAL,
5263                                                          &dummy,
5264                                                          &natural_width,
5265                                                          &adjusted_allocation.x,
5266                                                          &adjusted_allocation.width);
5267   GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
5268                                                          GTK_ORIENTATION_VERTICAL,
5269                                                          &dummy,
5270                                                          &natural_height,
5271                                                          &adjusted_allocation.y,
5272                                                          &adjusted_allocation.height);
5273
5274   if (adjusted_allocation.x < real_allocation.x ||
5275       adjusted_allocation.y < real_allocation.y ||
5276       (adjusted_allocation.x + adjusted_allocation.width) >
5277       (real_allocation.x + real_allocation.width) ||
5278       (adjusted_allocation.y + adjusted_allocation.height >
5279        real_allocation.y + real_allocation.height))
5280     {
5281       g_warning ("%s %p attempted to adjust its size allocation from %d,%d %dx%d to %d,%d %dx%d. adjust_size_allocation must keep allocation inside original bounds",
5282                  G_OBJECT_TYPE_NAME (widget), widget,
5283                  real_allocation.x, real_allocation.y, real_allocation.width, real_allocation.height,
5284                  adjusted_allocation.x, adjusted_allocation.y, adjusted_allocation.width, adjusted_allocation.height);
5285       adjusted_allocation = real_allocation; /* veto it */
5286     }
5287   else
5288     {
5289       real_allocation = adjusted_allocation;
5290     }
5291
5292   if (real_allocation.width < 0 || real_allocation.height < 0)
5293     {
5294       g_warning ("gtk_widget_size_allocate(): attempt to allocate widget with width %d and height %d",
5295                  real_allocation.width,
5296                  real_allocation.height);
5297     }
5298
5299   real_allocation.width = MAX (real_allocation.width, 1);
5300   real_allocation.height = MAX (real_allocation.height, 1);
5301
5302   size_changed = (old_allocation.width != real_allocation.width ||
5303                   old_allocation.height != real_allocation.height);
5304   position_changed = (old_allocation.x != real_allocation.x ||
5305                       old_allocation.y != real_allocation.y);
5306
5307   if (!alloc_needed && !size_changed && !position_changed)
5308     goto out;
5309
5310   g_signal_emit (widget, widget_signals[SIZE_ALLOCATE], 0, &real_allocation);
5311
5312   /* Size allocation is god... after consulting god, no further requests or allocations are needed */
5313   priv->alloc_needed = FALSE;
5314
5315   if (gtk_widget_get_mapped (widget))
5316     {
5317       if (!gtk_widget_get_has_window (widget) && priv->redraw_on_alloc && position_changed)
5318         {
5319           /* Invalidate union(old_allaction,priv->allocation) in priv->window
5320            */
5321           cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->allocation);
5322           cairo_region_union_rectangle (invalidate, &old_allocation);
5323
5324           gdk_window_invalidate_region (priv->window, invalidate, FALSE);
5325           cairo_region_destroy (invalidate);
5326         }
5327
5328       if (size_changed)
5329         {
5330           if (priv->redraw_on_alloc)
5331             {
5332               /* Invalidate union(old_allaction,priv->allocation) in priv->window and descendents owned by widget
5333                */
5334               cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->allocation);
5335               cairo_region_union_rectangle (invalidate, &old_allocation);
5336
5337               gtk_widget_invalidate_widget_windows (widget, invalidate);
5338               cairo_region_destroy (invalidate);
5339             }
5340         }
5341     }
5342
5343   if ((size_changed || position_changed) && priv->parent &&
5344       gtk_widget_get_realized (priv->parent) && _gtk_container_get_reallocate_redraws (GTK_CONTAINER (priv->parent)))
5345     {
5346       cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->parent->priv->allocation);
5347       gtk_widget_invalidate_widget_windows (priv->parent, invalidate);
5348       cairo_region_destroy (invalidate);
5349     }
5350
5351 out:
5352   gtk_widget_pop_verify_invariants (widget);
5353 }
5354
5355 /**
5356  * gtk_widget_common_ancestor:
5357  * @widget_a: a #GtkWidget
5358  * @widget_b: a #GtkWidget
5359  *
5360  * Find the common ancestor of @widget_a and @widget_b that
5361  * is closest to the two widgets.
5362  *
5363  * Return value: the closest common ancestor of @widget_a and
5364  *   @widget_b or %NULL if @widget_a and @widget_b do not
5365  *   share a common ancestor.
5366  **/
5367 static GtkWidget *
5368 gtk_widget_common_ancestor (GtkWidget *widget_a,
5369                             GtkWidget *widget_b)
5370 {
5371   GtkWidget *parent_a;
5372   GtkWidget *parent_b;
5373   gint depth_a = 0;
5374   gint depth_b = 0;
5375
5376   parent_a = widget_a;
5377   while (parent_a->priv->parent)
5378     {
5379       parent_a = parent_a->priv->parent;
5380       depth_a++;
5381     }
5382
5383   parent_b = widget_b;
5384   while (parent_b->priv->parent)
5385     {
5386       parent_b = parent_b->priv->parent;
5387       depth_b++;
5388     }
5389
5390   if (parent_a != parent_b)
5391     return NULL;
5392
5393   while (depth_a > depth_b)
5394     {
5395       widget_a = widget_a->priv->parent;
5396       depth_a--;
5397     }
5398
5399   while (depth_b > depth_a)
5400     {
5401       widget_b = widget_b->priv->parent;
5402       depth_b--;
5403     }
5404
5405   while (widget_a != widget_b)
5406     {
5407       widget_a = widget_a->priv->parent;
5408       widget_b = widget_b->priv->parent;
5409     }
5410
5411   return widget_a;
5412 }
5413
5414 /**
5415  * gtk_widget_translate_coordinates:
5416  * @src_widget:  a #GtkWidget
5417  * @dest_widget: a #GtkWidget
5418  * @src_x: X position relative to @src_widget
5419  * @src_y: Y position relative to @src_widget
5420  * @dest_x: (out): location to store X position relative to @dest_widget
5421  * @dest_y: (out): location to store Y position relative to @dest_widget
5422  *
5423  * Translate coordinates relative to @src_widget's allocation to coordinates
5424  * relative to @dest_widget's allocations. In order to perform this
5425  * operation, both widgets must be realized, and must share a common
5426  * toplevel.
5427  *
5428  * Return value: %FALSE if either widget was not realized, or there
5429  *   was no common ancestor. In this case, nothing is stored in
5430  *   *@dest_x and *@dest_y. Otherwise %TRUE.
5431  **/
5432 gboolean
5433 gtk_widget_translate_coordinates (GtkWidget  *src_widget,
5434                                   GtkWidget  *dest_widget,
5435                                   gint        src_x,
5436                                   gint        src_y,
5437                                   gint       *dest_x,
5438                                   gint       *dest_y)
5439 {
5440   GtkWidgetPrivate *src_priv = src_widget->priv;
5441   GtkWidgetPrivate *dest_priv = dest_widget->priv;
5442   GtkWidget *ancestor;
5443   GdkWindow *window;
5444   GList *dest_list = NULL;
5445
5446   g_return_val_if_fail (GTK_IS_WIDGET (src_widget), FALSE);
5447   g_return_val_if_fail (GTK_IS_WIDGET (dest_widget), FALSE);
5448
5449   ancestor = gtk_widget_common_ancestor (src_widget, dest_widget);
5450   if (!ancestor || !gtk_widget_get_realized (src_widget) || !gtk_widget_get_realized (dest_widget))
5451     return FALSE;
5452
5453   /* Translate from allocation relative to window relative */
5454   if (gtk_widget_get_has_window (src_widget) && src_priv->parent)
5455     {
5456       gint wx, wy;
5457       gdk_window_get_position (src_priv->window, &wx, &wy);
5458
5459       src_x -= wx - src_priv->allocation.x;
5460       src_y -= wy - src_priv->allocation.y;
5461     }
5462   else
5463     {
5464       src_x += src_priv->allocation.x;
5465       src_y += src_priv->allocation.y;
5466     }
5467
5468   /* Translate to the common ancestor */
5469   window = src_priv->window;
5470   while (window != ancestor->priv->window)
5471     {
5472       gdouble dx, dy;
5473
5474       gdk_window_coords_to_parent (window, src_x, src_y, &dx, &dy);
5475
5476       src_x = dx;
5477       src_y = dy;
5478
5479       window = gdk_window_get_effective_parent (window);
5480
5481       if (!window)              /* Handle GtkHandleBox */
5482         return FALSE;
5483     }
5484
5485   /* And back */
5486   window = dest_priv->window;
5487   while (window != ancestor->priv->window)
5488     {
5489       dest_list = g_list_prepend (dest_list, window);
5490
5491       window = gdk_window_get_effective_parent (window);
5492
5493       if (!window)              /* Handle GtkHandleBox */
5494         {
5495           g_list_free (dest_list);
5496           return FALSE;
5497         }
5498     }
5499
5500   while (dest_list)
5501     {
5502       gdouble dx, dy;
5503
5504       gdk_window_coords_from_parent (dest_list->data, src_x, src_y, &dx, &dy);
5505
5506       src_x = dx;
5507       src_y = dy;
5508
5509       dest_list = g_list_remove (dest_list, dest_list->data);
5510     }
5511
5512   /* Translate from window relative to allocation relative */
5513   if (gtk_widget_get_has_window (dest_widget) && dest_priv->parent)
5514     {
5515       gint wx, wy;
5516       gdk_window_get_position (dest_priv->window, &wx, &wy);
5517
5518       src_x += wx - dest_priv->allocation.x;
5519       src_y += wy - dest_priv->allocation.y;
5520     }
5521   else
5522     {
5523       src_x -= dest_priv->allocation.x;
5524       src_y -= dest_priv->allocation.y;
5525     }
5526
5527   if (dest_x)
5528     *dest_x = src_x;
5529   if (dest_y)
5530     *dest_y = src_y;
5531
5532   return TRUE;
5533 }
5534
5535 static void
5536 gtk_widget_real_size_allocate (GtkWidget     *widget,
5537                                GtkAllocation *allocation)
5538 {
5539   GtkWidgetPrivate *priv = widget->priv;
5540
5541   priv->allocation = *allocation;
5542
5543   if (gtk_widget_get_realized (widget) &&
5544       gtk_widget_get_has_window (widget))
5545      {
5546         gdk_window_move_resize (priv->window,
5547                                 allocation->x, allocation->y,
5548                                 allocation->width, allocation->height);
5549      }
5550 }
5551
5552 /* translate initial/final into start/end */
5553 static GtkAlign
5554 effective_align (GtkAlign         align,
5555                  GtkTextDirection direction)
5556 {
5557   switch (align)
5558     {
5559     case GTK_ALIGN_START:
5560       return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
5561     case GTK_ALIGN_END:
5562       return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
5563     default:
5564       return align;
5565     }
5566 }
5567
5568 static void
5569 adjust_for_align (GtkAlign  align,
5570                   gint     *natural_size,
5571                   gint     *allocated_pos,
5572                   gint     *allocated_size)
5573 {
5574   switch (align)
5575     {
5576     case GTK_ALIGN_FILL:
5577       /* change nothing */
5578       break;
5579     case GTK_ALIGN_START:
5580       /* keep *allocated_pos where it is */
5581       *allocated_size = MIN (*allocated_size, *natural_size);
5582       break;
5583     case GTK_ALIGN_END:
5584       if (*allocated_size > *natural_size)
5585         {
5586           *allocated_pos += (*allocated_size - *natural_size);
5587           *allocated_size = *natural_size;
5588         }
5589       break;
5590     case GTK_ALIGN_CENTER:
5591       if (*allocated_size > *natural_size)
5592         {
5593           *allocated_pos += (*allocated_size - *natural_size) / 2;
5594           *allocated_size = MIN (*allocated_size, *natural_size);
5595         }
5596       break;
5597     }
5598 }
5599
5600 static void
5601 adjust_for_margin(gint               start_margin,
5602                   gint               end_margin,
5603                   gint              *minimum_size,
5604                   gint              *natural_size,
5605                   gint              *allocated_pos,
5606                   gint              *allocated_size)
5607 {
5608   *minimum_size -= (start_margin + end_margin);
5609   *natural_size -= (start_margin + end_margin);
5610   *allocated_pos += start_margin;
5611   *allocated_size -= (start_margin + end_margin);
5612 }
5613
5614 static void
5615 gtk_widget_real_adjust_size_allocation (GtkWidget         *widget,
5616                                         GtkOrientation     orientation,
5617                                         gint              *minimum_size,
5618                                         gint              *natural_size,
5619                                         gint              *allocated_pos,
5620                                         gint              *allocated_size)
5621 {
5622   const GtkWidgetAuxInfo *aux_info;
5623
5624   aux_info = _gtk_widget_get_aux_info_or_defaults (widget);
5625
5626   if (orientation == GTK_ORIENTATION_HORIZONTAL)
5627     {
5628       adjust_for_margin (aux_info->margin.left,
5629                          aux_info->margin.right,
5630                          minimum_size, natural_size,
5631                          allocated_pos, allocated_size);
5632       adjust_for_align (effective_align (aux_info->halign, gtk_widget_get_direction (widget)),
5633                         natural_size, allocated_pos, allocated_size);
5634     }
5635   else
5636     {
5637       adjust_for_margin (aux_info->margin.top,
5638                          aux_info->margin.bottom,
5639                          minimum_size, natural_size,
5640                          allocated_pos, allocated_size);
5641       adjust_for_align (effective_align (aux_info->valign, GTK_TEXT_DIR_NONE),
5642                         natural_size, allocated_pos, allocated_size);
5643     }
5644 }
5645
5646 static gboolean
5647 gtk_widget_real_can_activate_accel (GtkWidget *widget,
5648                                     guint      signal_id)
5649 {
5650   GtkWidgetPrivate *priv = widget->priv;
5651
5652   /* widgets must be onscreen for accels to take effect */
5653   return gtk_widget_is_sensitive (widget) &&
5654          gtk_widget_is_drawable (widget) &&
5655          gdk_window_is_viewable (priv->window);
5656 }
5657
5658 /**
5659  * gtk_widget_can_activate_accel:
5660  * @widget: a #GtkWidget
5661  * @signal_id: the ID of a signal installed on @widget
5662  *
5663  * Determines whether an accelerator that activates the signal
5664  * identified by @signal_id can currently be activated.
5665  * This is done by emitting the #GtkWidget::can-activate-accel
5666  * signal on @widget; if the signal isn't overridden by a
5667  * handler or in a derived widget, then the default check is
5668  * that the widget must be sensitive, and the widget and all
5669  * its ancestors mapped.
5670  *
5671  * Return value: %TRUE if the accelerator can be activated.
5672  *
5673  * Since: 2.4
5674  **/
5675 gboolean
5676 gtk_widget_can_activate_accel (GtkWidget *widget,
5677                                guint      signal_id)
5678 {
5679   gboolean can_activate = FALSE;
5680   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
5681   g_signal_emit (widget, widget_signals[CAN_ACTIVATE_ACCEL], 0, signal_id, &can_activate);
5682   return can_activate;
5683 }
5684
5685 typedef struct {
5686   GClosure   closure;
5687   guint      signal_id;
5688 } AccelClosure;
5689
5690 static void
5691 closure_accel_activate (GClosure     *closure,
5692                         GValue       *return_value,
5693                         guint         n_param_values,
5694                         const GValue *param_values,
5695                         gpointer      invocation_hint,
5696                         gpointer      marshal_data)
5697 {
5698   AccelClosure *aclosure = (AccelClosure*) closure;
5699   gboolean can_activate = gtk_widget_can_activate_accel (closure->data, aclosure->signal_id);
5700
5701   if (can_activate)
5702     g_signal_emit (closure->data, aclosure->signal_id, 0);
5703
5704   /* whether accelerator was handled */
5705   g_value_set_boolean (return_value, can_activate);
5706 }
5707
5708 static void
5709 closures_destroy (gpointer data)
5710 {
5711   GSList *slist, *closures = data;
5712
5713   for (slist = closures; slist; slist = slist->next)
5714     {
5715       g_closure_invalidate (slist->data);
5716       g_closure_unref (slist->data);
5717     }
5718   g_slist_free (closures);
5719 }
5720
5721 static GClosure*
5722 widget_new_accel_closure (GtkWidget *widget,
5723                           guint      signal_id)
5724 {
5725   AccelClosure *aclosure;
5726   GClosure *closure = NULL;
5727   GSList *slist, *closures;
5728
5729   closures = g_object_steal_qdata (G_OBJECT (widget), quark_accel_closures);
5730   for (slist = closures; slist; slist = slist->next)
5731     if (!gtk_accel_group_from_accel_closure (slist->data))
5732       {
5733         /* reuse this closure */
5734         closure = slist->data;
5735         break;
5736       }
5737   if (!closure)
5738     {
5739       closure = g_closure_new_object (sizeof (AccelClosure), G_OBJECT (widget));
5740       closures = g_slist_prepend (closures, g_closure_ref (closure));
5741       g_closure_sink (closure);
5742       g_closure_set_marshal (closure, closure_accel_activate);
5743     }
5744   g_object_set_qdata_full (G_OBJECT (widget), quark_accel_closures, closures, closures_destroy);
5745
5746   aclosure = (AccelClosure*) closure;
5747   g_assert (closure->data == widget);
5748   g_assert (closure->marshal == closure_accel_activate);
5749   aclosure->signal_id = signal_id;
5750
5751   return closure;
5752 }
5753
5754 /**
5755  * gtk_widget_add_accelerator:
5756  * @widget:       widget to install an accelerator on
5757  * @accel_signal: widget signal to emit on accelerator activation
5758  * @accel_group:  accel group for this widget, added to its toplevel
5759  * @accel_key:    GDK keyval of the accelerator
5760  * @accel_mods:   modifier key combination of the accelerator
5761  * @accel_flags:  flag accelerators, e.g. %GTK_ACCEL_VISIBLE
5762  *
5763  * Installs an accelerator for this @widget in @accel_group that causes
5764  * @accel_signal to be emitted if the accelerator is activated.
5765  * The @accel_group needs to be added to the widget's toplevel via
5766  * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
5767  * Accelerators added through this function are not user changeable during
5768  * runtime. If you want to support accelerators that can be changed by the
5769  * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
5770  * gtk_menu_item_set_accel_path() instead.
5771  */
5772 void
5773 gtk_widget_add_accelerator (GtkWidget      *widget,
5774                             const gchar    *accel_signal,
5775                             GtkAccelGroup  *accel_group,
5776                             guint           accel_key,
5777                             GdkModifierType accel_mods,
5778                             GtkAccelFlags   accel_flags)
5779 {
5780   GClosure *closure;
5781   GSignalQuery query;
5782
5783   g_return_if_fail (GTK_IS_WIDGET (widget));
5784   g_return_if_fail (accel_signal != NULL);
5785   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
5786
5787   g_signal_query (g_signal_lookup (accel_signal, G_OBJECT_TYPE (widget)), &query);
5788   if (!query.signal_id ||
5789       !(query.signal_flags & G_SIGNAL_ACTION) ||
5790       query.return_type != G_TYPE_NONE ||
5791       query.n_params)
5792     {
5793       /* hmm, should be elaborate enough */
5794       g_warning (G_STRLOC ": widget `%s' has no activatable signal \"%s\" without arguments",
5795                  G_OBJECT_TYPE_NAME (widget), accel_signal);
5796       return;
5797     }
5798
5799   closure = widget_new_accel_closure (widget, query.signal_id);
5800
5801   g_object_ref (widget);
5802
5803   /* install the accelerator. since we don't map this onto an accel_path,
5804    * the accelerator will automatically be locked.
5805    */
5806   gtk_accel_group_connect (accel_group,
5807                            accel_key,
5808                            accel_mods,
5809                            accel_flags | GTK_ACCEL_LOCKED,
5810                            closure);
5811
5812   g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5813
5814   g_object_unref (widget);
5815 }
5816
5817 /**
5818  * gtk_widget_remove_accelerator:
5819  * @widget:       widget to install an accelerator on
5820  * @accel_group:  accel group for this widget
5821  * @accel_key:    GDK keyval of the accelerator
5822  * @accel_mods:   modifier key combination of the accelerator
5823  *
5824  * Removes an accelerator from @widget, previously installed with
5825  * gtk_widget_add_accelerator().
5826  *
5827  * Returns: whether an accelerator was installed and could be removed
5828  */
5829 gboolean
5830 gtk_widget_remove_accelerator (GtkWidget      *widget,
5831                                GtkAccelGroup  *accel_group,
5832                                guint           accel_key,
5833                                GdkModifierType accel_mods)
5834 {
5835   GtkAccelGroupEntry *ag_entry;
5836   GList *slist, *clist;
5837   guint n;
5838
5839   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
5840   g_return_val_if_fail (GTK_IS_ACCEL_GROUP (accel_group), FALSE);
5841
5842   ag_entry = gtk_accel_group_query (accel_group, accel_key, accel_mods, &n);
5843   clist = gtk_widget_list_accel_closures (widget);
5844   for (slist = clist; slist; slist = slist->next)
5845     {
5846       guint i;
5847
5848       for (i = 0; i < n; i++)
5849         if (slist->data == (gpointer) ag_entry[i].closure)
5850           {
5851             gboolean is_removed = gtk_accel_group_disconnect (accel_group, slist->data);
5852
5853             g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5854
5855             g_list_free (clist);
5856
5857             return is_removed;
5858           }
5859     }
5860   g_list_free (clist);
5861
5862   g_warning (G_STRLOC ": no accelerator (%u,%u) installed in accel group (%p) for %s (%p)",
5863              accel_key, accel_mods, accel_group,
5864              G_OBJECT_TYPE_NAME (widget), widget);
5865
5866   return FALSE;
5867 }
5868
5869 /**
5870  * gtk_widget_list_accel_closures:
5871  * @widget:  widget to list accelerator closures for
5872  *
5873  * Lists the closures used by @widget for accelerator group connections
5874  * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
5875  * The closures can be used to monitor accelerator changes on @widget,
5876  * by connecting to the @GtkAccelGroup::accel-changed signal of the
5877  * #GtkAccelGroup of a closure which can be found out with
5878  * gtk_accel_group_from_accel_closure().
5879  *
5880  * Return value: (transfer container) (element-type GClosure):
5881  *     a newly allocated #GList of closures
5882  */
5883 GList*
5884 gtk_widget_list_accel_closures (GtkWidget *widget)
5885 {
5886   GSList *slist;
5887   GList *clist = NULL;
5888
5889   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
5890
5891   for (slist = g_object_get_qdata (G_OBJECT (widget), quark_accel_closures); slist; slist = slist->next)
5892     if (gtk_accel_group_from_accel_closure (slist->data))
5893       clist = g_list_prepend (clist, slist->data);
5894   return clist;
5895 }
5896
5897 typedef struct {
5898   GQuark         path_quark;
5899   GtkAccelGroup *accel_group;
5900   GClosure      *closure;
5901 } AccelPath;
5902
5903 static void
5904 destroy_accel_path (gpointer data)
5905 {
5906   AccelPath *apath = data;
5907
5908   gtk_accel_group_disconnect (apath->accel_group, apath->closure);
5909
5910   /* closures_destroy takes care of unrefing the closure */
5911   g_object_unref (apath->accel_group);
5912
5913   g_slice_free (AccelPath, apath);
5914 }
5915
5916
5917 /**
5918  * gtk_widget_set_accel_path:
5919  * @widget: a #GtkWidget
5920  * @accel_path: (allow-none): path used to look up the accelerator
5921  * @accel_group: (allow-none): a #GtkAccelGroup.
5922  *
5923  * Given an accelerator group, @accel_group, and an accelerator path,
5924  * @accel_path, sets up an accelerator in @accel_group so whenever the
5925  * key binding that is defined for @accel_path is pressed, @widget
5926  * will be activated.  This removes any accelerators (for any
5927  * accelerator group) installed by previous calls to
5928  * gtk_widget_set_accel_path(). Associating accelerators with
5929  * paths allows them to be modified by the user and the modifications
5930  * to be saved for future use. (See gtk_accel_map_save().)
5931  *
5932  * This function is a low level function that would most likely
5933  * be used by a menu creation system like #GtkUIManager. If you
5934  * use #GtkUIManager, setting up accelerator paths will be done
5935  * automatically.
5936  *
5937  * Even when you you aren't using #GtkUIManager, if you only want to
5938  * set up accelerators on menu items gtk_menu_item_set_accel_path()
5939  * provides a somewhat more convenient interface.
5940  *
5941  * Note that @accel_path string will be stored in a #GQuark. Therefore, if you
5942  * pass a static string, you can save some memory by interning it first with
5943  * g_intern_static_string().
5944  **/
5945 void
5946 gtk_widget_set_accel_path (GtkWidget     *widget,
5947                            const gchar   *accel_path,
5948                            GtkAccelGroup *accel_group)
5949 {
5950   AccelPath *apath;
5951
5952   g_return_if_fail (GTK_IS_WIDGET (widget));
5953   g_return_if_fail (GTK_WIDGET_GET_CLASS (widget)->activate_signal != 0);
5954
5955   if (accel_path)
5956     {
5957       g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
5958       g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
5959
5960       gtk_accel_map_add_entry (accel_path, 0, 0);
5961       apath = g_slice_new (AccelPath);
5962       apath->accel_group = g_object_ref (accel_group);
5963       apath->path_quark = g_quark_from_string (accel_path);
5964       apath->closure = widget_new_accel_closure (widget, GTK_WIDGET_GET_CLASS (widget)->activate_signal);
5965     }
5966   else
5967     apath = NULL;
5968
5969   /* also removes possible old settings */
5970   g_object_set_qdata_full (G_OBJECT (widget), quark_accel_path, apath, destroy_accel_path);
5971
5972   if (apath)
5973     gtk_accel_group_connect_by_path (apath->accel_group, g_quark_to_string (apath->path_quark), apath->closure);
5974
5975   g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5976 }
5977
5978 const gchar*
5979 _gtk_widget_get_accel_path (GtkWidget *widget,
5980                             gboolean  *locked)
5981 {
5982   AccelPath *apath;
5983
5984   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
5985
5986   apath = g_object_get_qdata (G_OBJECT (widget), quark_accel_path);
5987   if (locked)
5988     *locked = apath ? gtk_accel_group_get_is_locked (apath->accel_group) : TRUE;
5989   return apath ? g_quark_to_string (apath->path_quark) : NULL;
5990 }
5991
5992 /**
5993  * gtk_widget_mnemonic_activate:
5994  * @widget: a #GtkWidget
5995  * @group_cycling:  %TRUE if there are other widgets with the same mnemonic
5996  *
5997  * Emits the #GtkWidget::mnemonic-activate signal.
5998  *
5999  * The default handler for this signal activates the @widget if
6000  * @group_cycling is %FALSE, and just grabs the focus if @group_cycling
6001  * is %TRUE.
6002  *
6003  * Returns: %TRUE if the signal has been handled
6004  */
6005 gboolean
6006 gtk_widget_mnemonic_activate (GtkWidget *widget,
6007                               gboolean   group_cycling)
6008 {
6009   gboolean handled;
6010
6011   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6012
6013   group_cycling = group_cycling != FALSE;
6014   if (!gtk_widget_is_sensitive (widget))
6015     handled = TRUE;
6016   else
6017     g_signal_emit (widget,
6018                    widget_signals[MNEMONIC_ACTIVATE],
6019                    0,
6020                    group_cycling,
6021                    &handled);
6022   return handled;
6023 }
6024
6025 static gboolean
6026 gtk_widget_real_mnemonic_activate (GtkWidget *widget,
6027                                    gboolean   group_cycling)
6028 {
6029   if (!group_cycling && GTK_WIDGET_GET_CLASS (widget)->activate_signal)
6030     gtk_widget_activate (widget);
6031   else if (gtk_widget_get_can_focus (widget))
6032     gtk_widget_grab_focus (widget);
6033   else
6034     {
6035       g_warning ("widget `%s' isn't suitable for mnemonic activation",
6036                  G_OBJECT_TYPE_NAME (widget));
6037       gtk_widget_error_bell (widget);
6038     }
6039   return TRUE;
6040 }
6041
6042 static const cairo_user_data_key_t event_key;
6043
6044 GdkEventExpose *
6045 _gtk_cairo_get_event (cairo_t *cr)
6046 {
6047   g_return_val_if_fail (cr != NULL, NULL);
6048
6049   return cairo_get_user_data (cr, &event_key);
6050 }
6051
6052 static void
6053 gtk_cairo_set_event (cairo_t        *cr,
6054                      GdkEventExpose *event)
6055 {
6056   cairo_set_user_data (cr, &event_key, event, NULL);
6057 }
6058
6059 /**
6060  * gtk_cairo_should_draw_window:
6061  * @cr: a cairo context
6062  * @window: the window to check. @window may not be an input-only
6063  *          window.
6064  *
6065  * This function is supposed to be called in #GtkWidget::draw
6066  * implementations for widgets that support multiple windows.
6067  * @cr must be untransformed from invoking of the draw function.
6068  * This function will return %TRUE if the contents of the given
6069  * @window are supposed to be drawn and %FALSE otherwise. Note
6070  * that when the drawing was not initiated by the windowing
6071  * system this function will return %TRUE for all windows, so
6072  * you need to draw the bottommost window first. Also, do not
6073  * use "else if" statements to check which window should be drawn.
6074  *
6075  * Returns: %TRUE if @window should be drawn
6076  *
6077  * Since: 3.0
6078  **/
6079 gboolean
6080 gtk_cairo_should_draw_window (cairo_t *cr,
6081                               GdkWindow *window)
6082 {
6083   GdkEventExpose *event;
6084
6085   g_return_val_if_fail (cr != NULL, FALSE);
6086   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
6087
6088   event = _gtk_cairo_get_event (cr);
6089
6090   return event == NULL ||
6091          event->window == window;
6092 }
6093
6094 static gboolean
6095 gtk_widget_get_clip_draw (GtkWidget *widget)
6096 {
6097   /* labels are not clipped, because clipping them would cause
6098    * mnemonics to not appear on characters that go beyond the
6099    * baseline.
6100    * https://bugzilla.gnome.org/show_bug.cgi?id=648570
6101    */
6102   if (GTK_IS_LABEL (widget))
6103     return FALSE;
6104
6105   return TRUE;
6106 }
6107
6108 /* code shared by gtk_container_propagate_draw() and
6109  * gtk_widget_draw()
6110  */
6111 void
6112 _gtk_widget_draw_internal (GtkWidget *widget,
6113                            cairo_t   *cr,
6114                            gboolean   clip_to_size)
6115 {
6116   if (!gtk_widget_is_drawable (widget))
6117     return;
6118
6119   clip_to_size &= gtk_widget_get_clip_draw (widget);
6120
6121   if (clip_to_size)
6122     {
6123       cairo_rectangle (cr,
6124                        0, 0,
6125                        widget->priv->allocation.width,
6126                        widget->priv->allocation.height);
6127       cairo_clip (cr);
6128     }
6129
6130   if (gdk_cairo_get_clip_rectangle (cr, NULL))
6131     {
6132       gboolean result;
6133
6134       g_signal_emit (widget, widget_signals[DRAW],
6135                      0, cr,
6136                      &result);
6137
6138       if (cairo_status (cr) &&
6139           _gtk_cairo_get_event (cr))
6140         {
6141           /* We check the event so we only warn about internal GTK calls.
6142            * Errors might come from PDF streams having write failures and
6143            * we don't want to spam stderr in that case.
6144            * We do want to catch errors from
6145            */
6146           g_warning ("drawing failure for widget `%s': %s",
6147                      G_OBJECT_TYPE_NAME (widget),
6148                      cairo_status_to_string (cairo_status (cr)));
6149         }
6150     }
6151 }
6152
6153 /**
6154  * gtk_widget_draw:
6155  * @widget: the widget to draw. It must be drawable (see
6156  *   gtk_widget_is_drawable()) and a size must have been allocated.
6157  * @cr: a cairo context to draw to
6158  *
6159  * Draws @widget to @cr. The top left corner of the widget will be
6160  * drawn to the currently set origin point of @cr.
6161  *
6162  * You should pass a cairo context as @cr argument that is in an
6163  * original state. Otherwise the resulting drawing is undefined. For
6164  * example changing the operator using cairo_set_operator() or the
6165  * line width using cairo_set_line_width() might have unwanted side
6166  * effects.
6167  * You may however change the context's transform matrix - like with
6168  * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
6169  * region with cairo_clip() prior to calling this function. Also, it
6170  * is fine to modify the context with cairo_save() and
6171  * cairo_push_group() prior to calling this function.
6172  *
6173  * <note><para>Special purpose widgets may contain special code for
6174  * rendering to the screen and might appear differently on screen
6175  * and when rendered using gtk_widget_draw().</para></note>
6176  *
6177  * Since: 3.0
6178  **/
6179 void
6180 gtk_widget_draw (GtkWidget *widget,
6181                  cairo_t   *cr)
6182 {
6183   GdkEventExpose *tmp_event;
6184
6185   g_return_if_fail (GTK_IS_WIDGET (widget));
6186   g_return_if_fail (!widget->priv->alloc_needed);
6187   g_return_if_fail (cr != NULL);
6188
6189   cairo_save (cr);
6190   /* We have to reset the event here so that draw functions can call
6191    * gtk_widget_draw() on random other widgets and get the desired
6192    * effect: Drawing all contents, not just the current window.
6193    */
6194   tmp_event = _gtk_cairo_get_event (cr);
6195   gtk_cairo_set_event (cr, NULL);
6196
6197   _gtk_widget_draw_internal (widget, cr, TRUE);
6198
6199   gtk_cairo_set_event (cr, tmp_event);
6200   cairo_restore (cr);
6201 }
6202
6203 static gboolean
6204 gtk_widget_real_key_press_event (GtkWidget         *widget,
6205                                  GdkEventKey       *event)
6206 {
6207   return gtk_bindings_activate_event (G_OBJECT (widget), event);
6208 }
6209
6210 static gboolean
6211 gtk_widget_real_key_release_event (GtkWidget         *widget,
6212                                    GdkEventKey       *event)
6213 {
6214   return gtk_bindings_activate_event (G_OBJECT (widget), event);
6215 }
6216
6217 static gboolean
6218 gtk_widget_real_focus_in_event (GtkWidget     *widget,
6219                                 GdkEventFocus *event)
6220 {
6221   gtk_widget_queue_draw (widget);
6222
6223   return FALSE;
6224 }
6225
6226 static gboolean
6227 gtk_widget_real_focus_out_event (GtkWidget     *widget,
6228                                  GdkEventFocus *event)
6229 {
6230   gtk_widget_queue_draw (widget);
6231
6232   return FALSE;
6233 }
6234
6235 static gboolean
6236 gtk_widget_real_touch_event (GtkWidget     *widget,
6237                              GdkEventTouch *event)
6238 {
6239   GdkEvent *bevent;
6240   gboolean return_val;
6241   gint signum;
6242
6243   if (!event->emulating_pointer)
6244     return FALSE;
6245
6246   if (event->type == GDK_TOUCH_BEGIN ||
6247       event->type == GDK_TOUCH_END)
6248     {
6249       GdkEventType type;
6250
6251       if (event->type == GDK_TOUCH_BEGIN)
6252         {
6253           type = GDK_BUTTON_PRESS;
6254           signum = BUTTON_PRESS_EVENT;
6255         }
6256       else
6257         {
6258           type = GDK_BUTTON_RELEASE;
6259           signum = BUTTON_RELEASE_EVENT;
6260         }
6261       bevent = gdk_event_new (type);
6262       bevent->any.window = g_object_ref (event->window);
6263       bevent->any.send_event = FALSE;
6264       bevent->button.time = event->time;
6265       bevent->button.state = event->state;
6266       bevent->button.button = 1;
6267       bevent->button.x_root = event->x_root;
6268       bevent->button.y_root = event->y_root;
6269       bevent->button.x = event->x;
6270       bevent->button.y = event->y;
6271       bevent->button.device = event->device;
6272       bevent->button.axes = g_memdup (event->axes,
6273                                       sizeof (gdouble) * gdk_device_get_n_axes (event->device));
6274       gdk_event_set_source_device (bevent, gdk_event_get_source_device ((GdkEvent*)event));
6275     }
6276   else if (event->type == GDK_TOUCH_UPDATE)
6277     {
6278       signum = MOTION_NOTIFY_EVENT;
6279       bevent = gdk_event_new (GDK_MOTION_NOTIFY);
6280       bevent->any.window = g_object_ref (event->window);
6281       bevent->any.send_event = FALSE;
6282       bevent->motion.time = event->time;
6283       bevent->motion.state = event->state;
6284       bevent->motion.x_root = event->x_root;
6285       bevent->motion.y_root = event->y_root;
6286       bevent->motion.x = event->x;
6287       bevent->motion.y = event->y;
6288       bevent->motion.device = event->device;
6289       bevent->motion.is_hint = FALSE;
6290       bevent->motion.axes = g_memdup (event->axes,
6291                                       sizeof (gdouble) * gdk_device_get_n_axes (event->device));
6292       gdk_event_set_source_device (bevent, gdk_event_get_source_device ((GdkEvent*)event));
6293     }
6294   else
6295     return FALSE;
6296
6297   g_signal_emit (widget, widget_signals[signum], 0, bevent, &return_val);
6298
6299   gdk_event_free (bevent);
6300
6301   return return_val;
6302 }
6303
6304
6305 #define WIDGET_REALIZED_FOR_EVENT(widget, event) \
6306      (event->type == GDK_FOCUS_CHANGE || gtk_widget_get_realized(widget))
6307
6308 /**
6309  * gtk_widget_event:
6310  * @widget: a #GtkWidget
6311  * @event: a #GdkEvent
6312  *
6313  * Rarely-used function. This function is used to emit
6314  * the event signals on a widget (those signals should never
6315  * be emitted without using this function to do so).
6316  * If you want to synthesize an event though, don't use this function;
6317  * instead, use gtk_main_do_event() so the event will behave as if
6318  * it were in the event queue. Don't synthesize expose events; instead,
6319  * use gdk_window_invalidate_rect() to invalidate a region of the
6320  * window.
6321  *
6322  * Return value: return from the event signal emission (%TRUE if
6323  *               the event was handled)
6324  **/
6325 gboolean
6326 gtk_widget_event (GtkWidget *widget,
6327                   GdkEvent  *event)
6328 {
6329   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6330   g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
6331
6332   if (event->type == GDK_EXPOSE)
6333     {
6334       g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get "
6335                  "the same effect, call gdk_window_invalidate_rect/region(), "
6336                  "followed by gdk_window_process_updates().");
6337       return TRUE;
6338     }
6339
6340   return gtk_widget_event_internal (widget, event);
6341 }
6342
6343 void
6344 _gtk_widget_set_captured_event_handler (GtkWidget               *widget,
6345                                         GtkCapturedEventHandler  callback)
6346 {
6347   g_object_set_data (G_OBJECT (widget), "captured-event-handler", callback);
6348 }
6349
6350 gboolean
6351 _gtk_widget_captured_event (GtkWidget *widget,
6352                             GdkEvent  *event)
6353 {
6354   gboolean return_val = FALSE;
6355   GtkCapturedEventHandler handler;
6356
6357   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6358   g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
6359
6360   if (event->type == GDK_EXPOSE)
6361     {
6362       g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get "
6363                  "the same effect, call gdk_window_invalidate_rect/region(), "
6364                  "followed by gdk_window_process_updates().");
6365       return TRUE;
6366     }
6367
6368   if (!event_window_is_still_viewable (event))
6369     return TRUE;
6370
6371   handler = g_object_get_data (G_OBJECT (widget), "captured-event-handler");
6372   if (!handler)
6373     return FALSE;
6374
6375   g_object_ref (widget);
6376
6377   return_val = handler (widget, event);
6378   return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
6379
6380   /* The widget that was originally to receive the event
6381    * handles motion hints, but the capturing widget might
6382    * not, so ensure we get further motion events.
6383    */
6384   if (return_val &&
6385       event->type == GDK_MOTION_NOTIFY &&
6386       event->motion.is_hint &&
6387       (gdk_window_get_events (event->any.window) &
6388        GDK_POINTER_MOTION_HINT_MASK) != 0)
6389     gdk_event_request_motions (&event->motion);
6390
6391   g_object_unref (widget);
6392
6393   return return_val;
6394 }
6395
6396 /* Returns TRUE if a translation should be done */
6397 gboolean
6398 _gtk_widget_get_translation_to_window (GtkWidget      *widget,
6399                                        GdkWindow      *window,
6400                                        int            *x,
6401                                        int            *y)
6402 {
6403   GdkWindow *w, *widget_window;
6404
6405   if (!gtk_widget_get_has_window (widget))
6406     {
6407       *x = -widget->priv->allocation.x;
6408       *y = -widget->priv->allocation.y;
6409     }
6410   else
6411     {
6412       *x = 0;
6413       *y = 0;
6414     }
6415
6416   widget_window = gtk_widget_get_window (widget);
6417
6418   for (w = window; w && w != widget_window; w = gdk_window_get_parent (w))
6419     {
6420       int wx, wy;
6421       gdk_window_get_position (w, &wx, &wy);
6422       *x += wx;
6423       *y += wy;
6424     }
6425
6426   if (w == NULL)
6427     {
6428       *x = 0;
6429       *y = 0;
6430       return FALSE;
6431     }
6432
6433   return TRUE;
6434 }
6435
6436
6437 /**
6438  * gtk_cairo_transform_to_window:
6439  * @cr: the cairo context to transform
6440  * @widget: the widget the context is currently centered for
6441  * @window: the window to transform the context to
6442  *
6443  * Transforms the given cairo context @cr that from @widget-relative
6444  * coordinates to @window-relative coordinates.
6445  * If the @widget's window is not an ancestor of @window, no
6446  * modification will be applied.
6447  *
6448  * This is the inverse to the transformation GTK applies when
6449  * preparing an expose event to be emitted with the #GtkWidget::draw
6450  * signal. It is intended to help porting multiwindow widgets from
6451  * GTK+ 2 to the rendering architecture of GTK+ 3.
6452  *
6453  * Since: 3.0
6454  **/
6455 void
6456 gtk_cairo_transform_to_window (cairo_t   *cr,
6457                                GtkWidget *widget,
6458                                GdkWindow *window)
6459 {
6460   int x, y;
6461
6462   g_return_if_fail (cr != NULL);
6463   g_return_if_fail (GTK_IS_WIDGET (widget));
6464   g_return_if_fail (GDK_IS_WINDOW (window));
6465
6466   if (_gtk_widget_get_translation_to_window (widget, window, &x, &y))
6467     cairo_translate (cr, x, y);
6468 }
6469
6470 /**
6471  * gtk_widget_send_expose:
6472  * @widget: a #GtkWidget
6473  * @event: a expose #GdkEvent
6474  *
6475  * Very rarely-used function. This function is used to emit
6476  * an expose event on a widget. This function is not normally used
6477  * directly. The only time it is used is when propagating an expose
6478  * event to a child %NO_WINDOW widget, and that is normally done
6479  * using gtk_container_propagate_draw().
6480  *
6481  * If you want to force an area of a window to be redrawn,
6482  * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
6483  * To cause the redraw to be done immediately, follow that call
6484  * with a call to gdk_window_process_updates().
6485  *
6486  * Return value: return from the event signal emission (%TRUE if
6487  *               the event was handled)
6488  **/
6489 gint
6490 gtk_widget_send_expose (GtkWidget *widget,
6491                         GdkEvent  *event)
6492 {
6493   gboolean result = FALSE;
6494   cairo_t *cr;
6495   int x, y;
6496   gboolean do_clip;
6497
6498   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6499   g_return_val_if_fail (gtk_widget_get_realized (widget), TRUE);
6500   g_return_val_if_fail (event != NULL, TRUE);
6501   g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE);
6502
6503   cr = gdk_cairo_create (event->expose.window);
6504   gtk_cairo_set_event (cr, &event->expose);
6505
6506   gdk_cairo_region (cr, event->expose.region);
6507   cairo_clip (cr);
6508
6509   do_clip = _gtk_widget_get_translation_to_window (widget,
6510                                                    event->expose.window,
6511                                                    &x, &y);
6512   cairo_translate (cr, -x, -y);
6513
6514   _gtk_widget_draw_internal (widget, cr, do_clip);
6515
6516   /* unset here, so if someone keeps a reference to cr we
6517    * don't leak the window. */
6518   gtk_cairo_set_event (cr, NULL);
6519   cairo_destroy (cr);
6520
6521   return result;
6522 }
6523
6524 static gboolean
6525 event_window_is_still_viewable (GdkEvent *event)
6526 {
6527   /* Check that we think the event's window is viewable before
6528    * delivering the event, to prevent suprises. We do this here
6529    * at the last moment, since the event may have been queued
6530    * up behind other events, held over a recursive main loop, etc.
6531    */
6532   switch (event->type)
6533     {
6534     case GDK_EXPOSE:
6535     case GDK_MOTION_NOTIFY:
6536     case GDK_BUTTON_PRESS:
6537     case GDK_2BUTTON_PRESS:
6538     case GDK_3BUTTON_PRESS:
6539     case GDK_KEY_PRESS:
6540     case GDK_ENTER_NOTIFY:
6541     case GDK_PROXIMITY_IN:
6542     case GDK_SCROLL:
6543       return event->any.window && gdk_window_is_viewable (event->any.window);
6544
6545 #if 0
6546     /* The following events are the second half of paired events;
6547      * we always deliver them to deal with widgets that clean up
6548      * on the second half.
6549      */
6550     case GDK_BUTTON_RELEASE:
6551     case GDK_KEY_RELEASE:
6552     case GDK_LEAVE_NOTIFY:
6553     case GDK_PROXIMITY_OUT:
6554 #endif
6555
6556     default:
6557       /* Remaining events would make sense on an not-viewable window,
6558        * or don't have an associated window.
6559        */
6560       return TRUE;
6561     }
6562 }
6563
6564 static gint
6565 gtk_widget_event_internal (GtkWidget *widget,
6566                            GdkEvent  *event)
6567 {
6568   gboolean return_val = FALSE;
6569
6570   /* We check only once for is-still-visible; if someone
6571    * hides the window in on of the signals on the widget,
6572    * they are responsible for returning TRUE to terminate
6573    * handling.
6574    */
6575   if (!event_window_is_still_viewable (event))
6576     return TRUE;
6577
6578   g_object_ref (widget);
6579
6580   g_signal_emit (widget, widget_signals[EVENT], 0, event, &return_val);
6581   return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
6582   if (!return_val)
6583     {
6584       gint signal_num;
6585
6586       switch (event->type)
6587         {
6588         case GDK_EXPOSE:
6589         case GDK_NOTHING:
6590           signal_num = -1;
6591           break;
6592         case GDK_BUTTON_PRESS:
6593         case GDK_2BUTTON_PRESS:
6594         case GDK_3BUTTON_PRESS:
6595           signal_num = BUTTON_PRESS_EVENT;
6596           break;
6597         case GDK_TOUCH_BEGIN:
6598         case GDK_TOUCH_UPDATE:
6599         case GDK_TOUCH_END:
6600         case GDK_TOUCH_CANCEL:
6601           signal_num = TOUCH_EVENT;
6602           break;
6603         case GDK_SCROLL:
6604           signal_num = SCROLL_EVENT;
6605           break;
6606         case GDK_BUTTON_RELEASE:
6607           signal_num = BUTTON_RELEASE_EVENT;
6608           break;
6609         case GDK_MOTION_NOTIFY:
6610           signal_num = MOTION_NOTIFY_EVENT;
6611           break;
6612         case GDK_DELETE:
6613           signal_num = DELETE_EVENT;
6614           break;
6615         case GDK_DESTROY:
6616           signal_num = DESTROY_EVENT;
6617           _gtk_tooltip_hide (widget);
6618           break;
6619         case GDK_KEY_PRESS:
6620           signal_num = KEY_PRESS_EVENT;
6621           break;
6622         case GDK_KEY_RELEASE:
6623           signal_num = KEY_RELEASE_EVENT;
6624           break;
6625         case GDK_ENTER_NOTIFY:
6626           signal_num = ENTER_NOTIFY_EVENT;
6627           break;
6628         case GDK_LEAVE_NOTIFY:
6629           signal_num = LEAVE_NOTIFY_EVENT;
6630           break;
6631         case GDK_FOCUS_CHANGE:
6632           signal_num = event->focus_change.in ? FOCUS_IN_EVENT : FOCUS_OUT_EVENT;
6633           if (event->focus_change.in)
6634             _gtk_tooltip_focus_in (widget);
6635           else
6636             _gtk_tooltip_focus_out (widget);
6637           break;
6638         case GDK_CONFIGURE:
6639           signal_num = CONFIGURE_EVENT;
6640           break;
6641         case GDK_MAP:
6642           signal_num = MAP_EVENT;
6643           break;
6644         case GDK_UNMAP:
6645           signal_num = UNMAP_EVENT;
6646           break;
6647         case GDK_WINDOW_STATE:
6648           signal_num = WINDOW_STATE_EVENT;
6649           break;
6650         case GDK_PROPERTY_NOTIFY:
6651           signal_num = PROPERTY_NOTIFY_EVENT;
6652           break;
6653         case GDK_SELECTION_CLEAR:
6654           signal_num = SELECTION_CLEAR_EVENT;
6655           break;
6656         case GDK_SELECTION_REQUEST:
6657           signal_num = SELECTION_REQUEST_EVENT;
6658           break;
6659         case GDK_SELECTION_NOTIFY:
6660           signal_num = SELECTION_NOTIFY_EVENT;
6661           break;
6662         case GDK_PROXIMITY_IN:
6663           signal_num = PROXIMITY_IN_EVENT;
6664           break;
6665         case GDK_PROXIMITY_OUT:
6666           signal_num = PROXIMITY_OUT_EVENT;
6667           break;
6668         case GDK_VISIBILITY_NOTIFY:
6669           signal_num = VISIBILITY_NOTIFY_EVENT;
6670           break;
6671         case GDK_GRAB_BROKEN:
6672           signal_num = GRAB_BROKEN_EVENT;
6673           break;
6674         case GDK_DAMAGE:
6675           signal_num = DAMAGE_EVENT;
6676           break;
6677         default:
6678           g_warning ("gtk_widget_event(): unhandled event type: %d", event->type);
6679           signal_num = -1;
6680           break;
6681         }
6682       if (signal_num != -1)
6683         g_signal_emit (widget, widget_signals[signal_num], 0, event, &return_val);
6684     }
6685   if (WIDGET_REALIZED_FOR_EVENT (widget, event))
6686     g_signal_emit (widget, widget_signals[EVENT_AFTER], 0, event);
6687   else
6688     return_val = TRUE;
6689
6690   g_object_unref (widget);
6691
6692   return return_val;
6693 }
6694
6695 /**
6696  * gtk_widget_activate:
6697  * @widget: a #GtkWidget that's activatable
6698  *
6699  * For widgets that can be "activated" (buttons, menu items, etc.)
6700  * this function activates them. Activation is what happens when you
6701  * press Enter on a widget during key navigation. If @widget isn't
6702  * activatable, the function returns %FALSE.
6703  *
6704  * Return value: %TRUE if the widget was activatable
6705  **/
6706 gboolean
6707 gtk_widget_activate (GtkWidget *widget)
6708 {
6709   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6710
6711   if (WIDGET_CLASS (widget)->activate_signal)
6712     {
6713       /* FIXME: we should eventually check the signals signature here */
6714       g_signal_emit (widget, WIDGET_CLASS (widget)->activate_signal, 0);
6715
6716       return TRUE;
6717     }
6718   else
6719     return FALSE;
6720 }
6721
6722 static void
6723 gtk_widget_reparent_subwindows (GtkWidget *widget,
6724                                 GdkWindow *new_window)
6725 {
6726   GtkWidgetPrivate *priv = widget->priv;
6727
6728   if (!gtk_widget_get_has_window (widget))
6729     {
6730       GList *children = gdk_window_get_children (priv->window);
6731       GList *tmp_list;
6732
6733       for (tmp_list = children; tmp_list; tmp_list = tmp_list->next)
6734         {
6735           GdkWindow *window = tmp_list->data;
6736           gpointer child;
6737
6738           gdk_window_get_user_data (window, &child);
6739           while (child && child != widget)
6740             child = ((GtkWidget*) child)->priv->parent;
6741
6742           if (child)
6743             gdk_window_reparent (window, new_window, 0, 0);
6744         }
6745
6746       g_list_free (children);
6747     }
6748   else
6749    {
6750      GdkWindow *parent;
6751      GList *tmp_list, *children;
6752
6753      parent = gdk_window_get_parent (priv->window);
6754
6755      if (parent == NULL)
6756        gdk_window_reparent (priv->window, new_window, 0, 0);
6757      else
6758        {
6759          children = gdk_window_get_children (parent);
6760
6761          for (tmp_list = children; tmp_list; tmp_list = tmp_list->next)
6762            {
6763              GdkWindow *window = tmp_list->data;
6764              gpointer child;
6765
6766              gdk_window_get_user_data (window, &child);
6767
6768              if (child == widget)
6769                gdk_window_reparent (window, new_window, 0, 0);
6770            }
6771
6772          g_list_free (children);
6773        }
6774    }
6775 }
6776
6777 static void
6778 gtk_widget_reparent_fixup_child (GtkWidget *widget,
6779                                  gpointer   client_data)
6780 {
6781   GtkWidgetPrivate *priv = widget->priv;
6782
6783   g_assert (client_data != NULL);
6784
6785   if (!gtk_widget_get_has_window (widget))
6786     {
6787       if (priv->window)
6788         g_object_unref (priv->window);
6789       priv->window = (GdkWindow*) client_data;
6790       if (priv->window)
6791         g_object_ref (priv->window);
6792
6793       if (GTK_IS_CONTAINER (widget))
6794         gtk_container_forall (GTK_CONTAINER (widget),
6795                               gtk_widget_reparent_fixup_child,
6796                               client_data);
6797     }
6798 }
6799
6800 /**
6801  * gtk_widget_reparent:
6802  * @widget: a #GtkWidget
6803  * @new_parent: a #GtkContainer to move the widget into
6804  *
6805  * Moves a widget from one #GtkContainer to another, handling reference
6806  * count issues to avoid destroying the widget.
6807  **/
6808 void
6809 gtk_widget_reparent (GtkWidget *widget,
6810                      GtkWidget *new_parent)
6811 {
6812   GtkWidgetPrivate *priv;
6813
6814   g_return_if_fail (GTK_IS_WIDGET (widget));
6815   g_return_if_fail (GTK_IS_CONTAINER (new_parent));
6816   priv = widget->priv;
6817   g_return_if_fail (priv->parent != NULL);
6818
6819   if (priv->parent != new_parent)
6820     {
6821       /* First try to see if we can get away without unrealizing
6822        * the widget as we reparent it. if so we set a flag so
6823        * that gtk_widget_unparent doesn't unrealize widget
6824        */
6825       if (gtk_widget_get_realized (widget) && gtk_widget_get_realized (new_parent))
6826         priv->in_reparent = TRUE;
6827
6828       g_object_ref (widget);
6829       gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
6830       gtk_container_add (GTK_CONTAINER (new_parent), widget);
6831       g_object_unref (widget);
6832
6833       if (priv->in_reparent)
6834         {
6835           priv->in_reparent = FALSE;
6836
6837           gtk_widget_reparent_subwindows (widget, gtk_widget_get_parent_window (widget));
6838           gtk_widget_reparent_fixup_child (widget,
6839                                            gtk_widget_get_parent_window (widget));
6840         }
6841
6842       g_object_notify (G_OBJECT (widget), "parent");
6843     }
6844 }
6845
6846 /**
6847  * gtk_widget_intersect:
6848  * @widget: a #GtkWidget
6849  * @area: a rectangle
6850  * @intersection: rectangle to store intersection of @widget and @area
6851  *
6852  * Computes the intersection of a @widget's area and @area, storing
6853  * the intersection in @intersection, and returns %TRUE if there was
6854  * an intersection.  @intersection may be %NULL if you're only
6855  * interested in whether there was an intersection.
6856  *
6857  * Return value: %TRUE if there was an intersection
6858  **/
6859 gboolean
6860 gtk_widget_intersect (GtkWidget          *widget,
6861                       const GdkRectangle *area,
6862                       GdkRectangle       *intersection)
6863 {
6864   GtkWidgetPrivate *priv;
6865   GdkRectangle *dest;
6866   GdkRectangle tmp;
6867   gint return_val;
6868
6869   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6870   g_return_val_if_fail (area != NULL, FALSE);
6871
6872   priv = widget->priv;
6873
6874   if (intersection)
6875     dest = intersection;
6876   else
6877     dest = &tmp;
6878
6879   return_val = gdk_rectangle_intersect (&priv->allocation, area, dest);
6880
6881   if (return_val && intersection && gtk_widget_get_has_window (widget))
6882     {
6883       intersection->x -= priv->allocation.x;
6884       intersection->y -= priv->allocation.y;
6885     }
6886
6887   return return_val;
6888 }
6889
6890 /**
6891  * gtk_widget_region_intersect:
6892  * @widget: a #GtkWidget
6893  * @region: a #cairo_region_t, in the same coordinate system as
6894  *          @widget->allocation. That is, relative to @widget->window
6895  *          for %NO_WINDOW widgets; relative to the parent window
6896  *          of @widget->window for widgets with their own window.
6897  *
6898  * Computes the intersection of a @widget's area and @region, returning
6899  * the intersection. The result may be empty, use cairo_region_is_empty() to
6900  * check.
6901  *
6902  * Returns: A newly allocated region holding the intersection of @widget
6903  *     and @region. The coordinates of the return value are relative to
6904  *     @widget->window for %NO_WINDOW widgets, and relative to the parent
6905  *     window of @widget->window for widgets with their own window.
6906  */
6907 cairo_region_t *
6908 gtk_widget_region_intersect (GtkWidget       *widget,
6909                              const cairo_region_t *region)
6910 {
6911   GdkRectangle rect;
6912   cairo_region_t *dest;
6913
6914   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
6915   g_return_val_if_fail (region != NULL, NULL);
6916
6917   gtk_widget_get_allocation (widget, &rect);
6918
6919   dest = cairo_region_create_rectangle (&rect);
6920
6921   cairo_region_intersect (dest, region);
6922
6923   return dest;
6924 }
6925
6926 /**
6927  * _gtk_widget_grab_notify:
6928  * @widget: a #GtkWidget
6929  * @was_grabbed: whether a grab is now in effect
6930  *
6931  * Emits the #GtkWidget::grab-notify signal on @widget.
6932  *
6933  * Since: 2.6
6934  **/
6935 void
6936 _gtk_widget_grab_notify (GtkWidget *widget,
6937                          gboolean   was_grabbed)
6938 {
6939   g_signal_emit (widget, widget_signals[GRAB_NOTIFY], 0, was_grabbed);
6940 }
6941
6942 /**
6943  * gtk_widget_grab_focus:
6944  * @widget: a #GtkWidget
6945  *
6946  * Causes @widget to have the keyboard focus for the #GtkWindow it's
6947  * inside. @widget must be a focusable widget, such as a #GtkEntry;
6948  * something like #GtkFrame won't work.
6949  *
6950  * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
6951  * gtk_widget_set_can_focus() to modify that flag.
6952  *
6953  * The widget also needs to be realized and mapped. This is indicated by the
6954  * related signals. Grabbing the focus immediately after creating the widget
6955  * will likely fail and cause critical warnings.
6956  **/
6957 void
6958 gtk_widget_grab_focus (GtkWidget *widget)
6959 {
6960   g_return_if_fail (GTK_IS_WIDGET (widget));
6961
6962   if (!gtk_widget_is_sensitive (widget))
6963     return;
6964
6965   g_object_ref (widget);
6966   g_signal_emit (widget, widget_signals[GRAB_FOCUS], 0);
6967   g_object_notify (G_OBJECT (widget), "has-focus");
6968   g_object_unref (widget);
6969 }
6970
6971 static void
6972 reset_focus_recurse (GtkWidget *widget,
6973                      gpointer   data)
6974 {
6975   if (GTK_IS_CONTAINER (widget))
6976     {
6977       GtkContainer *container;
6978
6979       container = GTK_CONTAINER (widget);
6980       gtk_container_set_focus_child (container, NULL);
6981
6982       gtk_container_foreach (container,
6983                              reset_focus_recurse,
6984                              NULL);
6985     }
6986 }
6987
6988 static void
6989 gtk_widget_real_grab_focus (GtkWidget *focus_widget)
6990 {
6991   if (gtk_widget_get_can_focus (focus_widget))
6992     {
6993       GtkWidget *toplevel;
6994       GtkWidget *widget;
6995
6996       /* clear the current focus setting, break if the current widget
6997        * is the focus widget's parent, since containers above that will
6998        * be set by the next loop.
6999        */
7000       toplevel = gtk_widget_get_toplevel (focus_widget);
7001       if (gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
7002         {
7003           widget = gtk_window_get_focus (GTK_WINDOW (toplevel));
7004
7005           if (widget == focus_widget)
7006             {
7007               /* We call _gtk_window_internal_set_focus() here so that the
7008                * toplevel window can request the focus if necessary.
7009                * This is needed when the toplevel is a GtkPlug
7010                */
7011               if (!gtk_widget_has_focus (widget))
7012                 _gtk_window_internal_set_focus (GTK_WINDOW (toplevel), focus_widget);
7013
7014               return;
7015             }
7016
7017           if (widget)
7018             {
7019               GtkWidget *common_ancestor = gtk_widget_common_ancestor (widget, focus_widget);
7020
7021               if (widget != common_ancestor)
7022                 {
7023                   while (widget->priv->parent && widget->priv->parent != common_ancestor)
7024                     {
7025                       widget = widget->priv->parent;
7026                       gtk_container_set_focus_child (GTK_CONTAINER (widget), NULL);
7027                     }
7028                 }
7029             }
7030         }
7031       else if (toplevel != focus_widget)
7032         {
7033           /* gtk_widget_grab_focus() operates on a tree without window...
7034            * actually, this is very questionable behaviour.
7035            */
7036
7037           gtk_container_foreach (GTK_CONTAINER (toplevel),
7038                                  reset_focus_recurse,
7039                                  NULL);
7040         }
7041
7042       /* now propagate the new focus up the widget tree and finally
7043        * set it on the window
7044        */
7045       widget = focus_widget;
7046       while (widget->priv->parent)
7047         {
7048           gtk_container_set_focus_child (GTK_CONTAINER (widget->priv->parent), widget);
7049           widget = widget->priv->parent;
7050         }
7051       if (GTK_IS_WINDOW (widget))
7052         _gtk_window_internal_set_focus (GTK_WINDOW (widget), focus_widget);
7053     }
7054 }
7055
7056 static gboolean
7057 gtk_widget_real_query_tooltip (GtkWidget  *widget,
7058                                gint        x,
7059                                gint        y,
7060                                gboolean    keyboard_tip,
7061                                GtkTooltip *tooltip)
7062 {
7063   gchar *tooltip_markup;
7064   gboolean has_tooltip;
7065
7066   tooltip_markup = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_markup);
7067   has_tooltip = GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget), quark_has_tooltip));
7068
7069   if (has_tooltip && tooltip_markup)
7070     {
7071       gtk_tooltip_set_markup (tooltip, tooltip_markup);
7072       return TRUE;
7073     }
7074
7075   return FALSE;
7076 }
7077
7078 static void
7079 gtk_widget_real_state_flags_changed (GtkWidget     *widget,
7080                                      GtkStateFlags  old_state)
7081 {
7082   gtk_widget_update_pango_context (widget);
7083 }
7084
7085 static void
7086 gtk_widget_real_style_updated (GtkWidget *widget)
7087 {
7088   GtkWidgetPrivate *priv = widget->priv;
7089
7090   gtk_widget_update_pango_context (widget);
7091   gtk_widget_update_alpha (widget);
7092
7093   if (priv->style != NULL &&
7094       priv->style != gtk_widget_get_default_style ())
7095     {
7096       /* Trigger ::style-set for old
7097        * widgets not listening to this
7098        */
7099       g_signal_emit (widget,
7100                      widget_signals[STYLE_SET],
7101                      0,
7102                      widget->priv->style);
7103     }
7104
7105   if (widget->priv->context)
7106     {
7107       const GtkBitmask *changes = _gtk_style_context_get_changes (widget->priv->context);
7108
7109       if (gtk_widget_get_realized (widget) &&
7110           gtk_widget_get_has_window (widget) &&
7111           !gtk_widget_get_app_paintable (widget))
7112         gtk_style_context_set_background (widget->priv->context,
7113                                           widget->priv->window);
7114
7115       if (widget->priv->anchored)
7116         {
7117           if (changes && _gtk_css_style_property_changes_affect_size (changes))
7118             gtk_widget_queue_resize (widget);
7119           else
7120             gtk_widget_queue_draw (widget);
7121         }
7122     }
7123   else
7124     {
7125       if (widget->priv->anchored)
7126         gtk_widget_queue_resize (widget);
7127     }
7128 }
7129
7130 static gboolean
7131 gtk_widget_real_show_help (GtkWidget        *widget,
7132                            GtkWidgetHelpType help_type)
7133 {
7134   if (help_type == GTK_WIDGET_HELP_TOOLTIP)
7135     {
7136       _gtk_tooltip_toggle_keyboard_mode (widget);
7137
7138       return TRUE;
7139     }
7140   else
7141     return FALSE;
7142 }
7143
7144 static gboolean
7145 gtk_widget_real_focus (GtkWidget         *widget,
7146                        GtkDirectionType   direction)
7147 {
7148   if (!gtk_widget_get_can_focus (widget))
7149     return FALSE;
7150
7151   if (!gtk_widget_is_focus (widget))
7152     {
7153       gtk_widget_grab_focus (widget);
7154       return TRUE;
7155     }
7156   else
7157     return FALSE;
7158 }
7159
7160 static void
7161 gtk_widget_real_move_focus (GtkWidget         *widget,
7162                             GtkDirectionType   direction)
7163 {
7164   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
7165
7166   if (widget != toplevel && GTK_IS_WINDOW (toplevel))
7167     {
7168       g_signal_emit (toplevel, widget_signals[MOVE_FOCUS], 0,
7169                      direction);
7170     }
7171 }
7172
7173 static gboolean
7174 gtk_widget_real_keynav_failed (GtkWidget        *widget,
7175                                GtkDirectionType  direction)
7176 {
7177   gboolean cursor_only;
7178
7179   switch (direction)
7180     {
7181     case GTK_DIR_TAB_FORWARD:
7182     case GTK_DIR_TAB_BACKWARD:
7183       return FALSE;
7184
7185     case GTK_DIR_UP:
7186     case GTK_DIR_DOWN:
7187     case GTK_DIR_LEFT:
7188     case GTK_DIR_RIGHT:
7189       g_object_get (gtk_widget_get_settings (widget),
7190                     "gtk-keynav-cursor-only", &cursor_only,
7191                     NULL);
7192       if (cursor_only)
7193         return FALSE;
7194       break;
7195     }
7196
7197   gtk_widget_error_bell (widget);
7198
7199   return TRUE;
7200 }
7201
7202 /**
7203  * gtk_widget_set_can_focus:
7204  * @widget: a #GtkWidget
7205  * @can_focus: whether or not @widget can own the input focus.
7206  *
7207  * Specifies whether @widget can own the input focus. See
7208  * gtk_widget_grab_focus() for actually setting the input focus on a
7209  * widget.
7210  *
7211  * Since: 2.18
7212  **/
7213 void
7214 gtk_widget_set_can_focus (GtkWidget *widget,
7215                           gboolean   can_focus)
7216 {
7217   g_return_if_fail (GTK_IS_WIDGET (widget));
7218
7219   if (widget->priv->can_focus != can_focus)
7220     {
7221       widget->priv->can_focus = can_focus;
7222
7223       gtk_widget_queue_resize (widget);
7224       g_object_notify (G_OBJECT (widget), "can-focus");
7225     }
7226 }
7227
7228 /**
7229  * gtk_widget_get_can_focus:
7230  * @widget: a #GtkWidget
7231  *
7232  * Determines whether @widget can own the input focus. See
7233  * gtk_widget_set_can_focus().
7234  *
7235  * Return value: %TRUE if @widget can own the input focus, %FALSE otherwise
7236  *
7237  * Since: 2.18
7238  **/
7239 gboolean
7240 gtk_widget_get_can_focus (GtkWidget *widget)
7241 {
7242   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7243
7244   return widget->priv->can_focus;
7245 }
7246
7247 /**
7248  * gtk_widget_has_focus:
7249  * @widget: a #GtkWidget
7250  *
7251  * Determines if the widget has the global input focus. See
7252  * gtk_widget_is_focus() for the difference between having the global
7253  * input focus, and only having the focus within a toplevel.
7254  *
7255  * Return value: %TRUE if the widget has the global input focus.
7256  *
7257  * Since: 2.18
7258  **/
7259 gboolean
7260 gtk_widget_has_focus (GtkWidget *widget)
7261 {
7262   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7263
7264   return widget->priv->has_focus;
7265 }
7266
7267 /**
7268  * gtk_widget_has_visible_focus:
7269  * @widget: a #GtkWidget
7270  *
7271  * Determines if the widget should show a visible indication that
7272  * it has the global input focus. This is a convenience function for
7273  * use in ::draw handlers that takes into account whether focus
7274  * indication should currently be shown in the toplevel window of
7275  * @widget. See gtk_window_get_focus_visible() for more information
7276  * about focus indication.
7277  *
7278  * To find out if the widget has the global input focus, use
7279  * gtk_widget_has_focus().
7280  *
7281  * Return value: %TRUE if the widget should display a 'focus rectangle'
7282  *
7283  * Since: 3.2
7284  */
7285 gboolean
7286 gtk_widget_has_visible_focus (GtkWidget *widget)
7287 {
7288   gboolean draw_focus;
7289
7290   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7291
7292   if (widget->priv->has_focus)
7293     {
7294       GtkWidget *toplevel;
7295
7296       toplevel = gtk_widget_get_toplevel (widget);
7297
7298       if (GTK_IS_WINDOW (toplevel))
7299         draw_focus = gtk_window_get_focus_visible (GTK_WINDOW (toplevel));
7300       else
7301         draw_focus = TRUE;
7302     }
7303   else
7304     draw_focus = FALSE;
7305
7306   return draw_focus;
7307 }
7308
7309 /**
7310  * gtk_widget_is_focus:
7311  * @widget: a #GtkWidget
7312  *
7313  * Determines if the widget is the focus widget within its
7314  * toplevel. (This does not mean that the %HAS_FOCUS flag is
7315  * necessarily set; %HAS_FOCUS will only be set if the
7316  * toplevel widget additionally has the global input focus.)
7317  *
7318  * Return value: %TRUE if the widget is the focus widget.
7319  **/
7320 gboolean
7321 gtk_widget_is_focus (GtkWidget *widget)
7322 {
7323   GtkWidget *toplevel;
7324
7325   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7326
7327   toplevel = gtk_widget_get_toplevel (widget);
7328
7329   if (GTK_IS_WINDOW (toplevel))
7330     return widget == gtk_window_get_focus (GTK_WINDOW (toplevel));
7331   else
7332     return FALSE;
7333 }
7334
7335 /**
7336  * gtk_widget_set_can_default:
7337  * @widget: a #GtkWidget
7338  * @can_default: whether or not @widget can be a default widget.
7339  *
7340  * Specifies whether @widget can be a default widget. See
7341  * gtk_widget_grab_default() for details about the meaning of
7342  * "default".
7343  *
7344  * Since: 2.18
7345  **/
7346 void
7347 gtk_widget_set_can_default (GtkWidget *widget,
7348                             gboolean   can_default)
7349 {
7350   g_return_if_fail (GTK_IS_WIDGET (widget));
7351
7352   if (widget->priv->can_default != can_default)
7353     {
7354       widget->priv->can_default = can_default;
7355
7356       gtk_widget_queue_resize (widget);
7357       g_object_notify (G_OBJECT (widget), "can-default");
7358     }
7359 }
7360
7361 /**
7362  * gtk_widget_get_can_default:
7363  * @widget: a #GtkWidget
7364  *
7365  * Determines whether @widget can be a default widget. See
7366  * gtk_widget_set_can_default().
7367  *
7368  * Return value: %TRUE if @widget can be a default widget, %FALSE otherwise
7369  *
7370  * Since: 2.18
7371  **/
7372 gboolean
7373 gtk_widget_get_can_default (GtkWidget *widget)
7374 {
7375   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7376
7377   return widget->priv->can_default;
7378 }
7379
7380 /**
7381  * gtk_widget_has_default:
7382  * @widget: a #GtkWidget
7383  *
7384  * Determines whether @widget is the current default widget within its
7385  * toplevel. See gtk_widget_set_can_default().
7386  *
7387  * Return value: %TRUE if @widget is the current default widget within
7388  *     its toplevel, %FALSE otherwise
7389  *
7390  * Since: 2.18
7391  */
7392 gboolean
7393 gtk_widget_has_default (GtkWidget *widget)
7394 {
7395   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7396
7397   return widget->priv->has_default;
7398 }
7399
7400 void
7401 _gtk_widget_set_has_default (GtkWidget *widget,
7402                              gboolean   has_default)
7403 {
7404   GtkStyleContext *context;
7405
7406   widget->priv->has_default = has_default;
7407
7408   context = gtk_widget_get_style_context (widget);
7409
7410   if (has_default)
7411     gtk_style_context_add_class (context, GTK_STYLE_CLASS_DEFAULT);
7412   else
7413     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DEFAULT);
7414 }
7415
7416 /**
7417  * gtk_widget_grab_default:
7418  * @widget: a #GtkWidget
7419  *
7420  * Causes @widget to become the default widget. @widget must be able to be
7421  * a default widget; typically you would ensure this yourself
7422  * by calling gtk_widget_set_can_default() with a %TRUE value.
7423  * The default widget is activated when
7424  * the user presses Enter in a window. Default widgets must be
7425  * activatable, that is, gtk_widget_activate() should affect them. Note
7426  * that #GtkEntry widgets require the "activates-default" property
7427  * set to %TRUE before they activate the default widget when Enter
7428  * is pressed and the #GtkEntry is focused.
7429  **/
7430 void
7431 gtk_widget_grab_default (GtkWidget *widget)
7432 {
7433   GtkWidget *window;
7434
7435   g_return_if_fail (GTK_IS_WIDGET (widget));
7436   g_return_if_fail (gtk_widget_get_can_default (widget));
7437
7438   window = gtk_widget_get_toplevel (widget);
7439
7440   if (window && gtk_widget_is_toplevel (window))
7441     gtk_window_set_default (GTK_WINDOW (window), widget);
7442   else
7443     g_warning (G_STRLOC ": widget not within a GtkWindow");
7444 }
7445
7446 /**
7447  * gtk_widget_set_receives_default:
7448  * @widget: a #GtkWidget
7449  * @receives_default: whether or not @widget can be a default widget.
7450  *
7451  * Specifies whether @widget will be treated as the default widget
7452  * within its toplevel when it has the focus, even if another widget
7453  * is the default.
7454  *
7455  * See gtk_widget_grab_default() for details about the meaning of
7456  * "default".
7457  *
7458  * Since: 2.18
7459  **/
7460 void
7461 gtk_widget_set_receives_default (GtkWidget *widget,
7462                                  gboolean   receives_default)
7463 {
7464   g_return_if_fail (GTK_IS_WIDGET (widget));
7465
7466   if (widget->priv->receives_default != receives_default)
7467     {
7468       widget->priv->receives_default = receives_default;
7469
7470       g_object_notify (G_OBJECT (widget), "receives-default");
7471     }
7472 }
7473
7474 /**
7475  * gtk_widget_get_receives_default:
7476  * @widget: a #GtkWidget
7477  *
7478  * Determines whether @widget is alyways treated as default widget
7479  * withing its toplevel when it has the focus, even if another widget
7480  * is the default.
7481  *
7482  * See gtk_widget_set_receives_default().
7483  *
7484  * Return value: %TRUE if @widget acts as default widget when focussed,
7485  *               %FALSE otherwise
7486  *
7487  * Since: 2.18
7488  **/
7489 gboolean
7490 gtk_widget_get_receives_default (GtkWidget *widget)
7491 {
7492   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7493
7494   return widget->priv->receives_default;
7495 }
7496
7497 /**
7498  * gtk_widget_has_grab:
7499  * @widget: a #GtkWidget
7500  *
7501  * Determines whether the widget is currently grabbing events, so it
7502  * is the only widget receiving input events (keyboard and mouse).
7503  *
7504  * See also gtk_grab_add().
7505  *
7506  * Return value: %TRUE if the widget is in the grab_widgets stack
7507  *
7508  * Since: 2.18
7509  **/
7510 gboolean
7511 gtk_widget_has_grab (GtkWidget *widget)
7512 {
7513   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7514
7515   return widget->priv->has_grab;
7516 }
7517
7518 void
7519 _gtk_widget_set_has_grab (GtkWidget *widget,
7520                           gboolean   has_grab)
7521 {
7522   widget->priv->has_grab = has_grab;
7523 }
7524
7525 /**
7526  * gtk_widget_device_is_shadowed:
7527  * @widget: a #GtkWidget
7528  * @device: a #GdkDevice
7529  *
7530  * Returns %TRUE if @device has been shadowed by a GTK+
7531  * device grab on another widget, so it would stop sending
7532  * events to @widget. This may be used in the
7533  * #GtkWidget::grab-notify signal to check for specific
7534  * devices. See gtk_device_grab_add().
7535  *
7536  * Returns: %TRUE if there is an ongoing grab on @device
7537  *          by another #GtkWidget than @widget.
7538  *
7539  * Since: 3.0
7540  **/
7541 gboolean
7542 gtk_widget_device_is_shadowed (GtkWidget *widget,
7543                                GdkDevice *device)
7544 {
7545   GtkWindowGroup *group;
7546   GtkWidget *grab_widget, *toplevel;
7547
7548   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7549   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
7550
7551   if (!gtk_widget_get_realized (widget))
7552     return TRUE;
7553
7554   toplevel = gtk_widget_get_toplevel (widget);
7555
7556   if (GTK_IS_WINDOW (toplevel))
7557     group = gtk_window_get_group (GTK_WINDOW (toplevel));
7558   else
7559     group = gtk_window_get_group (NULL);
7560
7561   grab_widget = gtk_window_group_get_current_device_grab (group, device);
7562
7563   /* Widget not inside the hierarchy of grab_widget */
7564   if (grab_widget &&
7565       widget != grab_widget &&
7566       !gtk_widget_is_ancestor (widget, grab_widget))
7567     return TRUE;
7568
7569   grab_widget = gtk_window_group_get_current_grab (group);
7570   if (grab_widget && widget != grab_widget &&
7571       !gtk_widget_is_ancestor (widget, grab_widget))
7572     return TRUE;
7573
7574   return FALSE;
7575 }
7576
7577 /**
7578  * gtk_widget_set_name:
7579  * @widget: a #GtkWidget
7580  * @name: name for the widget
7581  *
7582  * Widgets can be named, which allows you to refer to them from a
7583  * CSS file. You can apply a style to widgets with a particular name
7584  * in the CSS file. See the documentation for the CSS syntax (on the
7585  * same page as the docs for #GtkStyleContext).
7586  *
7587  * Note that the CSS syntax has certain special characters to delimit
7588  * and represent elements in a selector (period, &num;, &gt;, &ast;...),
7589  * so using these will make your widget impossible to match by name.
7590  * Any combination of alphanumeric symbols, dashes and underscores will
7591  * suffice.
7592  **/
7593 void
7594 gtk_widget_set_name (GtkWidget   *widget,
7595                      const gchar *name)
7596 {
7597   GtkWidgetPrivate *priv;
7598   gchar *new_name;
7599
7600   g_return_if_fail (GTK_IS_WIDGET (widget));
7601
7602   priv = widget->priv;
7603
7604   new_name = g_strdup (name);
7605   g_free (priv->name);
7606   priv->name = new_name;
7607
7608   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_NAME);
7609
7610   g_object_notify (G_OBJECT (widget), "name");
7611 }
7612
7613 /**
7614  * gtk_widget_get_name:
7615  * @widget: a #GtkWidget
7616  *
7617  * Retrieves the name of a widget. See gtk_widget_set_name() for the
7618  * significance of widget names.
7619  *
7620  * Return value: name of the widget. This string is owned by GTK+ and
7621  * should not be modified or freed
7622  **/
7623 const gchar*
7624 gtk_widget_get_name (GtkWidget *widget)
7625 {
7626   GtkWidgetPrivate *priv;
7627
7628   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
7629
7630   priv = widget->priv;
7631
7632   if (priv->name)
7633     return priv->name;
7634   return G_OBJECT_TYPE_NAME (widget);
7635 }
7636
7637 static void
7638 gtk_widget_update_state_flags (GtkWidget     *widget,
7639                                GtkStateFlags  flags_to_set,
7640                                GtkStateFlags  flags_to_unset)
7641 {
7642   GtkWidgetPrivate *priv;
7643
7644   priv = widget->priv;
7645
7646   /* Handle insensitive first, since it is propagated
7647    * differently throughout the widget hierarchy.
7648    */
7649   if ((priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_unset & GTK_STATE_FLAG_INSENSITIVE))
7650     gtk_widget_set_sensitive (widget, TRUE);
7651   else if (!(priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_set & GTK_STATE_FLAG_INSENSITIVE))
7652     gtk_widget_set_sensitive (widget, FALSE);
7653
7654   flags_to_set &= ~(GTK_STATE_FLAG_INSENSITIVE);
7655   flags_to_unset &= ~(GTK_STATE_FLAG_INSENSITIVE);
7656
7657   if (flags_to_set != 0 || flags_to_unset != 0)
7658     {
7659       GtkStateData data;
7660
7661       data.flags_to_set = flags_to_set;
7662       data.flags_to_unset = flags_to_unset;
7663
7664       gtk_widget_propagate_state (widget, &data);
7665     }
7666 }
7667
7668 /**
7669  * gtk_widget_set_state_flags:
7670  * @widget: a #GtkWidget
7671  * @flags: State flags to turn on
7672  * @clear: Whether to clear state before turning on @flags
7673  *
7674  * This function is for use in widget implementations. Turns on flag
7675  * values in the current widget state (insensitive, prelighted, etc.).
7676  *
7677  * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
7678  * will be propagated down to all non-internal children if @widget is a
7679  * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
7680  * down to all #GtkContainer children by different means than turning on the
7681  * state flag down the hierarchy, both gtk_widget_get_state_flags() and
7682  * gtk_widget_is_sensitive() will make use of these.
7683  *
7684  * Since: 3.0
7685  **/
7686 void
7687 gtk_widget_set_state_flags (GtkWidget     *widget,
7688                             GtkStateFlags  flags,
7689                             gboolean       clear)
7690 {
7691   g_return_if_fail (GTK_IS_WIDGET (widget));
7692
7693   if ((!clear && (widget->priv->state_flags & flags) == flags) ||
7694       (clear && widget->priv->state_flags == flags))
7695     return;
7696
7697   if (clear)
7698     gtk_widget_update_state_flags (widget, flags, ~(flags ^ (GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL)));
7699   else
7700     gtk_widget_update_state_flags (widget, flags, 0);
7701 }
7702
7703 /**
7704  * gtk_widget_unset_state_flags:
7705  * @widget: a #GtkWidget
7706  * @flags: State flags to turn off
7707  *
7708  * This function is for use in widget implementations. Turns off flag
7709  * values for the current widget state (insensitive, prelighted, etc.).
7710  * See gtk_widget_set_state_flags().
7711  *
7712  * Since: 3.0
7713  **/
7714 void
7715 gtk_widget_unset_state_flags (GtkWidget     *widget,
7716                               GtkStateFlags  flags)
7717 {
7718   g_return_if_fail (GTK_IS_WIDGET (widget));
7719
7720   if ((widget->priv->state_flags & flags) == 0)
7721     return;
7722
7723   gtk_widget_update_state_flags (widget, 0, flags);
7724 }
7725
7726 /**
7727  * gtk_widget_get_state_flags:
7728  * @widget: a #GtkWidget
7729  *
7730  * Returns the widget state as a flag set. It is worth mentioning
7731  * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
7732  * returned, that is, also based on parent insensitivity, even if
7733  * @widget itself is sensitive.
7734  *
7735  * Returns: The state flags for widget
7736  *
7737  * Since: 3.0
7738  **/
7739 GtkStateFlags
7740 gtk_widget_get_state_flags (GtkWidget *widget)
7741 {
7742   GtkStateFlags flags;
7743
7744   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
7745
7746   flags = widget->priv->state_flags;
7747
7748   if (gtk_widget_has_focus (widget))
7749     flags |= GTK_STATE_FLAG_FOCUSED;
7750
7751   return flags;
7752 }
7753
7754 /**
7755  * gtk_widget_set_state:
7756  * @widget: a #GtkWidget
7757  * @state: new state for @widget
7758  *
7759  * This function is for use in widget implementations. Sets the state
7760  * of a widget (insensitive, prelighted, etc.) Usually you should set
7761  * the state using wrapper functions such as gtk_widget_set_sensitive().
7762  *
7763  * Deprecated: 3.0. Use gtk_widget_set_state_flags() instead.
7764  **/
7765 void
7766 gtk_widget_set_state (GtkWidget           *widget,
7767                       GtkStateType         state)
7768 {
7769   GtkStateFlags flags;
7770
7771   if (state == gtk_widget_get_state (widget))
7772     return;
7773
7774   switch (state)
7775     {
7776     case GTK_STATE_ACTIVE:
7777       flags = GTK_STATE_FLAG_ACTIVE;
7778       break;
7779     case GTK_STATE_PRELIGHT:
7780       flags = GTK_STATE_FLAG_PRELIGHT;
7781       break;
7782     case GTK_STATE_SELECTED:
7783       flags = GTK_STATE_FLAG_SELECTED;
7784       break;
7785     case GTK_STATE_INSENSITIVE:
7786       flags = GTK_STATE_FLAG_INSENSITIVE;
7787       break;
7788     case GTK_STATE_INCONSISTENT:
7789       flags = GTK_STATE_FLAG_INCONSISTENT;
7790       break;
7791     case GTK_STATE_FOCUSED:
7792       flags = GTK_STATE_FLAG_FOCUSED;
7793       break;
7794     case GTK_STATE_NORMAL:
7795     default:
7796       flags = 0;
7797       break;
7798     }
7799
7800   gtk_widget_update_state_flags (widget,
7801                                  flags,
7802                                  (GTK_STATE_FLAG_ACTIVE | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED
7803                                  | GTK_STATE_FLAG_INSENSITIVE | GTK_STATE_FLAG_INCONSISTENT | GTK_STATE_FLAG_FOCUSED) ^ flags);
7804 }
7805
7806 /**
7807  * gtk_widget_get_state:
7808  * @widget: a #GtkWidget
7809  *
7810  * Returns the widget's state. See gtk_widget_set_state().
7811  *
7812  * Returns: the state of @widget.
7813  *
7814  * Since: 2.18
7815  *
7816  * Deprecated: 3.0. Use gtk_widget_get_state_flags() instead.
7817  */
7818 GtkStateType
7819 gtk_widget_get_state (GtkWidget *widget)
7820 {
7821   GtkStateFlags flags;
7822
7823   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_STATE_NORMAL);
7824
7825   flags = gtk_widget_get_state_flags (widget);
7826
7827   if (flags & GTK_STATE_FLAG_INSENSITIVE)
7828     return GTK_STATE_INSENSITIVE;
7829   else if (flags & GTK_STATE_FLAG_ACTIVE)
7830     return GTK_STATE_ACTIVE;
7831   else if (flags & GTK_STATE_FLAG_SELECTED)
7832     return GTK_STATE_SELECTED;
7833   else if (flags & GTK_STATE_FLAG_PRELIGHT)
7834     return GTK_STATE_PRELIGHT;
7835   else
7836     return GTK_STATE_NORMAL;
7837 }
7838
7839 /**
7840  * gtk_widget_set_visible:
7841  * @widget: a #GtkWidget
7842  * @visible: whether the widget should be shown or not
7843  *
7844  * Sets the visibility state of @widget. Note that setting this to
7845  * %TRUE doesn't mean the widget is actually viewable, see
7846  * gtk_widget_get_visible().
7847  *
7848  * This function simply calls gtk_widget_show() or gtk_widget_hide()
7849  * but is nicer to use when the visibility of the widget depends on
7850  * some condition.
7851  *
7852  * Since: 2.18
7853  **/
7854 void
7855 gtk_widget_set_visible (GtkWidget *widget,
7856                         gboolean   visible)
7857 {
7858   g_return_if_fail (GTK_IS_WIDGET (widget));
7859
7860   if (visible != gtk_widget_get_visible (widget))
7861     {
7862       if (visible)
7863         gtk_widget_show (widget);
7864       else
7865         gtk_widget_hide (widget);
7866     }
7867 }
7868
7869 void
7870 _gtk_widget_set_visible_flag (GtkWidget *widget,
7871                               gboolean   visible)
7872 {
7873   GtkWidgetPrivate *priv = widget->priv;
7874
7875   priv->visible = visible;
7876
7877   if (!visible)
7878     {
7879       priv->allocation.x = -1;
7880       priv->allocation.y = -1;
7881       priv->allocation.width = 1;
7882       priv->allocation.height = 1;
7883     }
7884 }
7885
7886 /**
7887  * gtk_widget_get_visible:
7888  * @widget: a #GtkWidget
7889  *
7890  * Determines whether the widget is visible. If you want to
7891  * take into account whether the widget's parent is also marked as
7892  * visible, use gtk_widget_is_visible() instead.
7893  *
7894  * This function does not check if the widget is obscured in any way.
7895  *
7896  * See gtk_widget_set_visible().
7897  *
7898  * Return value: %TRUE if the widget is visible
7899  *
7900  * Since: 2.18
7901  **/
7902 gboolean
7903 gtk_widget_get_visible (GtkWidget *widget)
7904 {
7905   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7906
7907   return widget->priv->visible;
7908 }
7909
7910 /**
7911  * gtk_widget_is_visible:
7912  * @widget: a #GtkWidget
7913  *
7914  * Determines whether the widget and all its parents are marked as
7915  * visible.
7916  *
7917  * This function does not check if the widget is obscured in any way.
7918  *
7919  * See also gtk_widget_get_visible() and gtk_widget_set_visible()
7920  *
7921  * Return value: %TRUE if the widget and all its parents are visible
7922  *
7923  * Since: 3.8
7924  **/
7925 gboolean
7926 gtk_widget_is_visible (GtkWidget *widget)
7927 {
7928   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7929
7930   while (widget)
7931     {
7932       GtkWidgetPrivate *priv = widget->priv;
7933
7934       if (!priv->visible)
7935         return FALSE;
7936
7937       widget = priv->parent;
7938     }
7939
7940   return TRUE;
7941 }
7942
7943 /**
7944  * gtk_widget_set_has_window:
7945  * @widget: a #GtkWidget
7946  * @has_window: whether or not @widget has a window.
7947  *
7948  * Specifies whether @widget has a #GdkWindow of its own. Note that
7949  * all realized widgets have a non-%NULL "window" pointer
7950  * (gtk_widget_get_window() never returns a %NULL window when a widget
7951  * is realized), but for many of them it's actually the #GdkWindow of
7952  * one of its parent widgets. Widgets that do not create a %window for
7953  * themselves in #GtkWidget::realize must announce this by
7954  * calling this function with @has_window = %FALSE.
7955  *
7956  * This function should only be called by widget implementations,
7957  * and they should call it in their init() function.
7958  *
7959  * Since: 2.18
7960  **/
7961 void
7962 gtk_widget_set_has_window (GtkWidget *widget,
7963                            gboolean   has_window)
7964 {
7965   g_return_if_fail (GTK_IS_WIDGET (widget));
7966
7967   widget->priv->no_window = !has_window;
7968 }
7969
7970 /**
7971  * gtk_widget_get_has_window:
7972  * @widget: a #GtkWidget
7973  *
7974  * Determines whether @widget has a #GdkWindow of its own. See
7975  * gtk_widget_set_has_window().
7976  *
7977  * Return value: %TRUE if @widget has a window, %FALSE otherwise
7978  *
7979  * Since: 2.18
7980  **/
7981 gboolean
7982 gtk_widget_get_has_window (GtkWidget *widget)
7983 {
7984   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7985
7986   return ! widget->priv->no_window;
7987 }
7988
7989 /**
7990  * gtk_widget_is_toplevel:
7991  * @widget: a #GtkWidget
7992  *
7993  * Determines whether @widget is a toplevel widget.
7994  *
7995  * Currently only #GtkWindow and #GtkInvisible (and out-of-process
7996  * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
7997  * widget.
7998  *
7999  * Return value: %TRUE if @widget is a toplevel, %FALSE otherwise
8000  *
8001  * Since: 2.18
8002  **/
8003 gboolean
8004 gtk_widget_is_toplevel (GtkWidget *widget)
8005 {
8006   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8007
8008   return widget->priv->toplevel;
8009 }
8010
8011 void
8012 _gtk_widget_set_is_toplevel (GtkWidget *widget,
8013                              gboolean   is_toplevel)
8014 {
8015   widget->priv->toplevel = is_toplevel;
8016 }
8017
8018 /**
8019  * gtk_widget_is_drawable:
8020  * @widget: a #GtkWidget
8021  *
8022  * Determines whether @widget can be drawn to. A widget can be drawn
8023  * to if it is mapped and visible.
8024  *
8025  * Return value: %TRUE if @widget is drawable, %FALSE otherwise
8026  *
8027  * Since: 2.18
8028  **/
8029 gboolean
8030 gtk_widget_is_drawable (GtkWidget *widget)
8031 {
8032   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8033
8034   return (gtk_widget_get_visible (widget) &&
8035           gtk_widget_get_mapped (widget));
8036 }
8037
8038 /**
8039  * gtk_widget_get_realized:
8040  * @widget: a #GtkWidget
8041  *
8042  * Determines whether @widget is realized.
8043  *
8044  * Return value: %TRUE if @widget is realized, %FALSE otherwise
8045  *
8046  * Since: 2.20
8047  **/
8048 gboolean
8049 gtk_widget_get_realized (GtkWidget *widget)
8050 {
8051   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8052
8053   return widget->priv->realized;
8054 }
8055
8056 /**
8057  * gtk_widget_set_realized:
8058  * @widget: a #GtkWidget
8059  * @realized: %TRUE to mark the widget as realized
8060  *
8061  * Marks the widget as being realized.
8062  *
8063  * This function should only ever be called in a derived widget's
8064  * "realize" or "unrealize" implementation.
8065  *
8066  * Since: 2.20
8067  */
8068 void
8069 gtk_widget_set_realized (GtkWidget *widget,
8070                          gboolean   realized)
8071 {
8072   g_return_if_fail (GTK_IS_WIDGET (widget));
8073
8074   widget->priv->realized = realized;
8075 }
8076
8077 /**
8078  * gtk_widget_get_mapped:
8079  * @widget: a #GtkWidget
8080  *
8081  * Whether the widget is mapped.
8082  *
8083  * Return value: %TRUE if the widget is mapped, %FALSE otherwise.
8084  *
8085  * Since: 2.20
8086  */
8087 gboolean
8088 gtk_widget_get_mapped (GtkWidget *widget)
8089 {
8090   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8091
8092   return widget->priv->mapped;
8093 }
8094
8095 /**
8096  * gtk_widget_set_mapped:
8097  * @widget: a #GtkWidget
8098  * @mapped: %TRUE to mark the widget as mapped
8099  *
8100  * Marks the widget as being realized.
8101  *
8102  * This function should only ever be called in a derived widget's
8103  * "map" or "unmap" implementation.
8104  *
8105  * Since: 2.20
8106  */
8107 void
8108 gtk_widget_set_mapped (GtkWidget *widget,
8109                        gboolean   mapped)
8110 {
8111   g_return_if_fail (GTK_IS_WIDGET (widget));
8112
8113   widget->priv->mapped = mapped;
8114 }
8115
8116 /**
8117  * gtk_widget_set_app_paintable:
8118  * @widget: a #GtkWidget
8119  * @app_paintable: %TRUE if the application will paint on the widget
8120  *
8121  * Sets whether the application intends to draw on the widget in
8122  * an #GtkWidget::draw handler.
8123  *
8124  * This is a hint to the widget and does not affect the behavior of
8125  * the GTK+ core; many widgets ignore this flag entirely. For widgets
8126  * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
8127  * the effect is to suppress default themed drawing of the widget's
8128  * background. (Children of the widget will still be drawn.) The application
8129  * is then entirely responsible for drawing the widget background.
8130  *
8131  * Note that the background is still drawn when the widget is mapped.
8132  **/
8133 void
8134 gtk_widget_set_app_paintable (GtkWidget *widget,
8135                               gboolean   app_paintable)
8136 {
8137   g_return_if_fail (GTK_IS_WIDGET (widget));
8138
8139   app_paintable = (app_paintable != FALSE);
8140
8141   if (widget->priv->app_paintable != app_paintable)
8142     {
8143       widget->priv->app_paintable = app_paintable;
8144
8145       if (gtk_widget_is_drawable (widget))
8146         gtk_widget_queue_draw (widget);
8147
8148       g_object_notify (G_OBJECT (widget), "app-paintable");
8149     }
8150 }
8151
8152 /**
8153  * gtk_widget_get_app_paintable:
8154  * @widget: a #GtkWidget
8155  *
8156  * Determines whether the application intends to draw on the widget in
8157  * an #GtkWidget::draw handler.
8158  *
8159  * See gtk_widget_set_app_paintable()
8160  *
8161  * Return value: %TRUE if the widget is app paintable
8162  *
8163  * Since: 2.18
8164  **/
8165 gboolean
8166 gtk_widget_get_app_paintable (GtkWidget *widget)
8167 {
8168   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8169
8170   return widget->priv->app_paintable;
8171 }
8172
8173 /**
8174  * gtk_widget_set_double_buffered:
8175  * @widget: a #GtkWidget
8176  * @double_buffered: %TRUE to double-buffer a widget
8177  *
8178  * Widgets are double buffered by default; you can use this function
8179  * to turn off the buffering. "Double buffered" simply means that
8180  * gdk_window_begin_paint_region() and gdk_window_end_paint() are called
8181  * automatically around expose events sent to the
8182  * widget. gdk_window_begin_paint_region() diverts all drawing to a widget's
8183  * window to an offscreen buffer, and gdk_window_end_paint() draws the
8184  * buffer to the screen. The result is that users see the window
8185  * update in one smooth step, and don't see individual graphics
8186  * primitives being rendered.
8187  *
8188  * In very simple terms, double buffered widgets don't flicker,
8189  * so you would only use this function to turn off double buffering
8190  * if you had special needs and really knew what you were doing.
8191  *
8192  * Note: if you turn off double-buffering, you have to handle
8193  * expose events, since even the clearing to the background color or
8194  * pixmap will not happen automatically (as it is done in
8195  * gdk_window_begin_paint_region()).
8196  **/
8197 void
8198 gtk_widget_set_double_buffered (GtkWidget *widget,
8199                                 gboolean   double_buffered)
8200 {
8201   g_return_if_fail (GTK_IS_WIDGET (widget));
8202
8203   double_buffered = (double_buffered != FALSE);
8204
8205   if (widget->priv->double_buffered != double_buffered)
8206     {
8207       widget->priv->double_buffered = double_buffered;
8208
8209       g_object_notify (G_OBJECT (widget), "double-buffered");
8210     }
8211 }
8212
8213 /**
8214  * gtk_widget_get_double_buffered:
8215  * @widget: a #GtkWidget
8216  *
8217  * Determines whether the widget is double buffered.
8218  *
8219  * See gtk_widget_set_double_buffered()
8220  *
8221  * Return value: %TRUE if the widget is double buffered
8222  *
8223  * Since: 2.18
8224  **/
8225 gboolean
8226 gtk_widget_get_double_buffered (GtkWidget *widget)
8227 {
8228   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8229
8230   return widget->priv->double_buffered;
8231 }
8232
8233 /**
8234  * gtk_widget_set_redraw_on_allocate:
8235  * @widget: a #GtkWidget
8236  * @redraw_on_allocate: if %TRUE, the entire widget will be redrawn
8237  *   when it is allocated to a new size. Otherwise, only the
8238  *   new portion of the widget will be redrawn.
8239  *
8240  * Sets whether the entire widget is queued for drawing when its size
8241  * allocation changes. By default, this setting is %TRUE and
8242  * the entire widget is redrawn on every size change. If your widget
8243  * leaves the upper left unchanged when made bigger, turning this
8244  * setting off will improve performance.
8245
8246  * Note that for %NO_WINDOW widgets setting this flag to %FALSE turns
8247  * off all allocation on resizing: the widget will not even redraw if
8248  * its position changes; this is to allow containers that don't draw
8249  * anything to avoid excess invalidations. If you set this flag on a
8250  * %NO_WINDOW widget that <emphasis>does</emphasis> draw on @widget->window,
8251  * you are responsible for invalidating both the old and new allocation
8252  * of the widget when the widget is moved and responsible for invalidating
8253  * regions newly when the widget increases size.
8254  **/
8255 void
8256 gtk_widget_set_redraw_on_allocate (GtkWidget *widget,
8257                                    gboolean   redraw_on_allocate)
8258 {
8259   g_return_if_fail (GTK_IS_WIDGET (widget));
8260
8261   widget->priv->redraw_on_alloc = redraw_on_allocate;
8262 }
8263
8264 /**
8265  * gtk_widget_set_sensitive:
8266  * @widget: a #GtkWidget
8267  * @sensitive: %TRUE to make the widget sensitive
8268  *
8269  * Sets the sensitivity of a widget. A widget is sensitive if the user
8270  * can interact with it. Insensitive widgets are "grayed out" and the
8271  * user can't interact with them. Insensitive widgets are known as
8272  * "inactive", "disabled", or "ghosted" in some other toolkits.
8273  **/
8274 void
8275 gtk_widget_set_sensitive (GtkWidget *widget,
8276                           gboolean   sensitive)
8277 {
8278   GtkWidgetPrivate *priv;
8279
8280   g_return_if_fail (GTK_IS_WIDGET (widget));
8281
8282   priv = widget->priv;
8283
8284   sensitive = (sensitive != FALSE);
8285
8286   if (priv->sensitive == sensitive)
8287     return;
8288
8289   priv->sensitive = sensitive;
8290
8291   if (priv->parent == NULL
8292       || gtk_widget_is_sensitive (priv->parent))
8293     {
8294       GtkStateData data;
8295
8296       if (sensitive)
8297         {
8298           data.flags_to_set = 0;
8299           data.flags_to_unset = GTK_STATE_FLAG_INSENSITIVE;
8300         }
8301       else
8302         {
8303           data.flags_to_set = GTK_STATE_FLAG_INSENSITIVE;
8304           data.flags_to_unset = 0;
8305         }
8306
8307       gtk_widget_propagate_state (widget, &data);
8308
8309       gtk_widget_queue_resize (widget);
8310     }
8311
8312   g_object_notify (G_OBJECT (widget), "sensitive");
8313 }
8314
8315 /**
8316  * gtk_widget_get_sensitive:
8317  * @widget: a #GtkWidget
8318  *
8319  * Returns the widget's sensitivity (in the sense of returning
8320  * the value that has been set using gtk_widget_set_sensitive()).
8321  *
8322  * The effective sensitivity of a widget is however determined by both its
8323  * own and its parent widget's sensitivity. See gtk_widget_is_sensitive().
8324  *
8325  * Returns: %TRUE if the widget is sensitive
8326  *
8327  * Since: 2.18
8328  */
8329 gboolean
8330 gtk_widget_get_sensitive (GtkWidget *widget)
8331 {
8332   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8333
8334   return widget->priv->sensitive;
8335 }
8336
8337 /**
8338  * gtk_widget_is_sensitive:
8339  * @widget: a #GtkWidget
8340  *
8341  * Returns the widget's effective sensitivity, which means
8342  * it is sensitive itself and also its parent widget is sensitive
8343  *
8344  * Returns: %TRUE if the widget is effectively sensitive
8345  *
8346  * Since: 2.18
8347  */
8348 gboolean
8349 gtk_widget_is_sensitive (GtkWidget *widget)
8350 {
8351   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8352
8353   return !(widget->priv->state_flags & GTK_STATE_FLAG_INSENSITIVE);
8354 }
8355
8356 /**
8357  * gtk_widget_set_parent:
8358  * @widget: a #GtkWidget
8359  * @parent: parent container
8360  *
8361  * This function is useful only when implementing subclasses of
8362  * #GtkContainer.
8363  * Sets the container as the parent of @widget, and takes care of
8364  * some details such as updating the state and style of the child
8365  * to reflect its new location. The opposite function is
8366  * gtk_widget_unparent().
8367  **/
8368 void
8369 gtk_widget_set_parent (GtkWidget *widget,
8370                        GtkWidget *parent)
8371 {
8372   GtkStateFlags parent_flags;
8373   GtkWidgetPrivate *priv;
8374   GtkStateData data;
8375
8376   g_return_if_fail (GTK_IS_WIDGET (widget));
8377   g_return_if_fail (GTK_IS_WIDGET (parent));
8378   g_return_if_fail (widget != parent);
8379
8380   priv = widget->priv;
8381
8382   if (priv->parent != NULL)
8383     {
8384       g_warning ("Can't set a parent on widget which has a parent\n");
8385       return;
8386     }
8387   if (gtk_widget_is_toplevel (widget))
8388     {
8389       g_warning ("Can't set a parent on a toplevel widget\n");
8390       return;
8391     }
8392
8393   /* keep this function in sync with gtk_menu_attach_to_widget()
8394    */
8395
8396   g_object_ref_sink (widget);
8397
8398   gtk_widget_push_verify_invariants (widget);
8399
8400   priv->parent = parent;
8401
8402   parent_flags = gtk_widget_get_state_flags (parent);
8403
8404   /* Merge both old state and current parent state,
8405    * making sure to only propagate the right states */
8406   data.flags_to_set = parent_flags & GTK_STATE_FLAGS_DO_PROPAGATE;
8407   data.flags_to_unset = 0;
8408   gtk_widget_propagate_state (widget, &data);
8409
8410   if (priv->context)
8411     gtk_style_context_set_parent (priv->context,
8412                                   gtk_widget_get_style_context (parent));
8413
8414   _gtk_widget_update_parent_muxer (widget);
8415
8416   g_signal_emit (widget, widget_signals[PARENT_SET], 0, NULL);
8417   if (priv->parent->priv->anchored)
8418     _gtk_widget_propagate_hierarchy_changed (widget, NULL);
8419   g_object_notify (G_OBJECT (widget), "parent");
8420
8421   /* Enforce realized/mapped invariants
8422    */
8423   if (gtk_widget_get_realized (priv->parent))
8424     gtk_widget_realize (widget);
8425
8426   if (gtk_widget_get_visible (priv->parent) &&
8427       gtk_widget_get_visible (widget))
8428     {
8429       if (gtk_widget_get_child_visible (widget) &&
8430           gtk_widget_get_mapped (priv->parent))
8431         gtk_widget_map (widget);
8432
8433       gtk_widget_queue_resize (widget);
8434     }
8435
8436   /* child may cause parent's expand to change, if the child is
8437    * expanded. If child is not expanded, then it can't modify the
8438    * parent's expand. If the child becomes expanded later then it will
8439    * queue compute_expand then. This optimization plus defaulting
8440    * newly-constructed widgets to need_compute_expand=FALSE should
8441    * mean that initially building a widget tree doesn't have to keep
8442    * walking up setting need_compute_expand on parents over and over.
8443    *
8444    * We can't change a parent to need to expand unless we're visible.
8445    */
8446   if (gtk_widget_get_visible (widget) &&
8447       (priv->need_compute_expand ||
8448        priv->computed_hexpand ||
8449        priv->computed_vexpand))
8450     {
8451       gtk_widget_queue_compute_expand (parent);
8452     }
8453
8454   gtk_widget_propagate_alpha (widget);
8455
8456   gtk_widget_pop_verify_invariants (widget);
8457 }
8458
8459 /**
8460  * gtk_widget_get_parent:
8461  * @widget: a #GtkWidget
8462  *
8463  * Returns the parent container of @widget.
8464  *
8465  * Return value: (transfer none): the parent container of @widget, or %NULL
8466  **/
8467 GtkWidget *
8468 gtk_widget_get_parent (GtkWidget *widget)
8469 {
8470   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
8471
8472   return widget->priv->parent;
8473 }
8474
8475 static void
8476 modifier_style_changed (GtkModifierStyle *style,
8477                         GtkWidget        *widget)
8478 {
8479   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_ANY);
8480 }
8481
8482 static GtkModifierStyle *
8483 _gtk_widget_get_modifier_properties (GtkWidget *widget)
8484 {
8485   GtkModifierStyle *style;
8486
8487   style = g_object_get_qdata (G_OBJECT (widget), quark_modifier_style);
8488
8489   if (G_UNLIKELY (!style))
8490     {
8491       GtkStyleContext *context;
8492
8493       style = _gtk_modifier_style_new ();
8494       g_object_set_qdata_full (G_OBJECT (widget),
8495                                quark_modifier_style,
8496                                style,
8497                                (GDestroyNotify) g_object_unref);
8498
8499       g_signal_connect (style, "changed",
8500                         G_CALLBACK (modifier_style_changed), widget);
8501
8502       context = gtk_widget_get_style_context (widget);
8503
8504       gtk_style_context_add_provider (context,
8505                                       GTK_STYLE_PROVIDER (style),
8506                                       GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
8507     }
8508
8509   return style;
8510 }
8511
8512 /**
8513  * gtk_widget_override_color:
8514  * @widget: a #GtkWidget
8515  * @state: the state for which to set the color
8516  * @color: (allow-none): the color to assign, or %NULL to undo the effect
8517  *     of previous calls to gtk_widget_override_color()
8518  *
8519  * Sets the color to use for a widget.
8520  *
8521  * All other style values are left untouched.
8522  *
8523  * <note><para>
8524  * This API is mostly meant as a quick way for applications to
8525  * change a widget appearance. If you are developing a widgets
8526  * library and intend this change to be themeable, it is better
8527  * done by setting meaningful CSS classes and regions in your
8528  * widget/container implementation through gtk_style_context_add_class()
8529  * and gtk_style_context_add_region().
8530  * </para><para>
8531  * This way, your widget library can install a #GtkCssProvider
8532  * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
8533  * to provide a default styling for those widgets that need so, and
8534  * this theming may fully overridden by the user's theme.
8535  * </para></note>
8536  * <note><para>
8537  * Note that for complex widgets this may bring in undesired
8538  * results (such as uniform background color everywhere), in
8539  * these cases it is better to fully style such widgets through a
8540  * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
8541  * priority.
8542  * </para></note>
8543  *
8544  * Since: 3.0
8545  */
8546 void
8547 gtk_widget_override_color (GtkWidget     *widget,
8548                            GtkStateFlags  state,
8549                            const GdkRGBA *color)
8550 {
8551   GtkModifierStyle *style;
8552
8553   g_return_if_fail (GTK_IS_WIDGET (widget));
8554
8555   style = _gtk_widget_get_modifier_properties (widget);
8556   _gtk_modifier_style_set_color (style, state, color);
8557 }
8558
8559 /**
8560  * gtk_widget_override_background_color:
8561  * @widget: a #GtkWidget
8562  * @state: the state for which to set the background color
8563  * @color: (allow-none): the color to assign, or %NULL to undo the effect
8564  *     of previous calls to gtk_widget_override_background_color()
8565  *
8566  * Sets the background color to use for a widget.
8567  *
8568  * All other style values are left untouched.
8569  * See gtk_widget_override_color().
8570  *
8571  * Since: 3.0
8572  */
8573 void
8574 gtk_widget_override_background_color (GtkWidget     *widget,
8575                                       GtkStateFlags  state,
8576                                       const GdkRGBA *color)
8577 {
8578   GtkModifierStyle *style;
8579
8580   g_return_if_fail (GTK_IS_WIDGET (widget));
8581
8582   style = _gtk_widget_get_modifier_properties (widget);
8583   _gtk_modifier_style_set_background_color (style, state, color);
8584 }
8585
8586 /**
8587  * gtk_widget_override_font:
8588  * @widget: a #GtkWidget
8589  * @font_desc: (allow-none): the font descriptiong to use, or %NULL to undo
8590  *     the effect of previous calls to gtk_widget_override_font()
8591  *
8592  * Sets the font to use for a widget. All other style values are
8593  * left untouched. See gtk_widget_override_color().
8594  *
8595  * Since: 3.0
8596  */
8597 void
8598 gtk_widget_override_font (GtkWidget                  *widget,
8599                           const PangoFontDescription *font_desc)
8600 {
8601   GtkModifierStyle *style;
8602
8603   g_return_if_fail (GTK_IS_WIDGET (widget));
8604
8605   style = _gtk_widget_get_modifier_properties (widget);
8606   _gtk_modifier_style_set_font (style, font_desc);
8607 }
8608
8609 /**
8610  * gtk_widget_override_symbolic_color:
8611  * @widget: a #GtkWidget
8612  * @name: the name of the symbolic color to modify
8613  * @color: (allow-none): the color to assign (does not need
8614  *     to be allocated), or %NULL to undo the effect of previous
8615  *     calls to gtk_widget_override_symbolic_color()
8616  *
8617  * Sets a symbolic color for a widget.
8618  *
8619  * All other style values are left untouched.
8620  * See gtk_widget_override_color() for overriding the foreground
8621  * or background color.
8622  *
8623  * Since: 3.0
8624  */
8625 void
8626 gtk_widget_override_symbolic_color (GtkWidget     *widget,
8627                                     const gchar   *name,
8628                                     const GdkRGBA *color)
8629 {
8630   GtkModifierStyle *style;
8631
8632   g_return_if_fail (GTK_IS_WIDGET (widget));
8633
8634   style = _gtk_widget_get_modifier_properties (widget);
8635   _gtk_modifier_style_map_color (style, name, color);
8636 }
8637
8638 /**
8639  * gtk_widget_override_cursor:
8640  * @widget: a #GtkWidget
8641  * @cursor: (allow-none): the color to use for primary cursor (does not need to be
8642  *     allocated), or %NULL to undo the effect of previous calls to
8643  *     of gtk_widget_override_cursor().
8644  * @secondary_cursor: (allow-none): the color to use for secondary cursor (does not
8645  *     need to be allocated), or %NULL to undo the effect of previous
8646  *     calls to of gtk_widget_override_cursor().
8647  *
8648  * Sets the cursor color to use in a widget, overriding the
8649  * #GtkWidget:cursor-color and #GtkWidget:secondary-cursor-color
8650  * style properties. All other style values are left untouched.
8651  * See also gtk_widget_modify_style().
8652  *
8653  * Note that the underlying properties have the #GdkColor type,
8654  * so the alpha value in @primary and @secondary will be ignored.
8655  *
8656  * Since: 3.0
8657  */
8658 void
8659 gtk_widget_override_cursor (GtkWidget     *widget,
8660                             const GdkRGBA *cursor,
8661                             const GdkRGBA *secondary_cursor)
8662 {
8663   GtkModifierStyle *style;
8664
8665   g_return_if_fail (GTK_IS_WIDGET (widget));
8666
8667   style = _gtk_widget_get_modifier_properties (widget);
8668   _gtk_modifier_style_set_color_property (style,
8669                                           GTK_TYPE_WIDGET,
8670                                           "cursor-color", cursor);
8671   _gtk_modifier_style_set_color_property (style,
8672                                           GTK_TYPE_WIDGET,
8673                                           "secondary-cursor-color",
8674                                           secondary_cursor);
8675 }
8676
8677 static void
8678 gtk_widget_real_direction_changed (GtkWidget        *widget,
8679                                    GtkTextDirection  previous_direction)
8680 {
8681   gtk_widget_queue_resize (widget);
8682 }
8683
8684 static void
8685 gtk_widget_real_style_set (GtkWidget *widget,
8686                            GtkStyle  *previous_style)
8687 {
8688 }
8689
8690 typedef struct {
8691   GtkWidget *previous_toplevel;
8692   GdkScreen *previous_screen;
8693   GdkScreen *new_screen;
8694 } HierarchyChangedInfo;
8695
8696 static void
8697 do_screen_change (GtkWidget *widget,
8698                   GdkScreen *old_screen,
8699                   GdkScreen *new_screen)
8700 {
8701   if (old_screen != new_screen)
8702     {
8703       GtkWidgetPrivate *priv = widget->priv;
8704
8705       if (old_screen)
8706         {
8707           PangoContext *context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
8708           if (context)
8709             g_object_set_qdata (G_OBJECT (widget), quark_pango_context, NULL);
8710         }
8711
8712       _gtk_tooltip_hide (widget);
8713
8714       if (new_screen && priv->context)
8715         gtk_style_context_set_screen (priv->context, new_screen);
8716
8717       g_signal_emit (widget, widget_signals[SCREEN_CHANGED], 0, old_screen);
8718     }
8719 }
8720
8721 static void
8722 gtk_widget_propagate_hierarchy_changed_recurse (GtkWidget *widget,
8723                                                 gpointer   client_data)
8724 {
8725   GtkWidgetPrivate *priv = widget->priv;
8726   HierarchyChangedInfo *info = client_data;
8727   gboolean new_anchored = gtk_widget_is_toplevel (widget) ||
8728                  (priv->parent && priv->parent->priv->anchored);
8729
8730   if (priv->anchored != new_anchored)
8731     {
8732       g_object_ref (widget);
8733
8734       priv->anchored = new_anchored;
8735
8736       /* This can only happen with gtk_widget_reparent() */
8737       if (priv->realized)
8738         {
8739           if (new_anchored)
8740             gtk_widget_connect_frame_clock (widget,
8741                                             gtk_widget_get_frame_clock (widget));
8742           else
8743             gtk_widget_disconnect_frame_clock (widget,
8744                                                gtk_widget_get_frame_clock (info->previous_toplevel));
8745         }
8746
8747       g_signal_emit (widget, widget_signals[HIERARCHY_CHANGED], 0, info->previous_toplevel);
8748       do_screen_change (widget, info->previous_screen, info->new_screen);
8749
8750       if (GTK_IS_CONTAINER (widget))
8751         gtk_container_forall (GTK_CONTAINER (widget),
8752                               gtk_widget_propagate_hierarchy_changed_recurse,
8753                               client_data);
8754
8755       g_object_unref (widget);
8756     }
8757 }
8758
8759 /**
8760  * _gtk_widget_propagate_hierarchy_changed:
8761  * @widget: a #GtkWidget
8762  * @previous_toplevel: Previous toplevel
8763  *
8764  * Propagates changes in the anchored state to a widget and all
8765  * children, unsetting or setting the %ANCHORED flag, and
8766  * emitting #GtkWidget::hierarchy-changed.
8767  **/
8768 void
8769 _gtk_widget_propagate_hierarchy_changed (GtkWidget *widget,
8770                                          GtkWidget *previous_toplevel)
8771 {
8772   GtkWidgetPrivate *priv = widget->priv;
8773   HierarchyChangedInfo info;
8774
8775   info.previous_toplevel = previous_toplevel;
8776   info.previous_screen = previous_toplevel ? gtk_widget_get_screen (previous_toplevel) : NULL;
8777
8778   if (gtk_widget_is_toplevel (widget) ||
8779       (priv->parent && priv->parent->priv->anchored))
8780     info.new_screen = gtk_widget_get_screen (widget);
8781   else
8782     info.new_screen = NULL;
8783
8784   if (info.previous_screen)
8785     g_object_ref (info.previous_screen);
8786   if (previous_toplevel)
8787     g_object_ref (previous_toplevel);
8788
8789   gtk_widget_propagate_hierarchy_changed_recurse (widget, &info);
8790
8791   if (previous_toplevel)
8792     g_object_unref (previous_toplevel);
8793   if (info.previous_screen)
8794     g_object_unref (info.previous_screen);
8795 }
8796
8797 static void
8798 gtk_widget_propagate_screen_changed_recurse (GtkWidget *widget,
8799                                              gpointer   client_data)
8800 {
8801   HierarchyChangedInfo *info = client_data;
8802
8803   g_object_ref (widget);
8804
8805   do_screen_change (widget, info->previous_screen, info->new_screen);
8806
8807   if (GTK_IS_CONTAINER (widget))
8808     gtk_container_forall (GTK_CONTAINER (widget),
8809                           gtk_widget_propagate_screen_changed_recurse,
8810                           client_data);
8811
8812   g_object_unref (widget);
8813 }
8814
8815 /**
8816  * gtk_widget_is_composited:
8817  * @widget: a #GtkWidget
8818  *
8819  * Whether @widget can rely on having its alpha channel
8820  * drawn correctly. On X11 this function returns whether a
8821  * compositing manager is running for @widget's screen.
8822  *
8823  * Please note that the semantics of this call will change
8824  * in the future if used on a widget that has a composited
8825  * window in its hierarchy (as set by gdk_window_set_composited()).
8826  *
8827  * Return value: %TRUE if the widget can rely on its alpha
8828  * channel being drawn correctly.
8829  *
8830  * Since: 2.10
8831  */
8832 gboolean
8833 gtk_widget_is_composited (GtkWidget *widget)
8834 {
8835   GdkScreen *screen;
8836
8837   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8838
8839   screen = gtk_widget_get_screen (widget);
8840
8841   return gdk_screen_is_composited (screen);
8842 }
8843
8844 static void
8845 propagate_composited_changed (GtkWidget *widget,
8846                               gpointer dummy)
8847 {
8848   if (GTK_IS_CONTAINER (widget))
8849     {
8850       gtk_container_forall (GTK_CONTAINER (widget),
8851                             propagate_composited_changed,
8852                             NULL);
8853     }
8854
8855   g_signal_emit (widget, widget_signals[COMPOSITED_CHANGED], 0);
8856 }
8857
8858 void
8859 _gtk_widget_propagate_composited_changed (GtkWidget *widget)
8860 {
8861   propagate_composited_changed (widget, NULL);
8862 }
8863
8864 /**
8865  * _gtk_widget_propagate_screen_changed:
8866  * @widget: a #GtkWidget
8867  * @previous_screen: Previous screen
8868  *
8869  * Propagates changes in the screen for a widget to all
8870  * children, emitting #GtkWidget::screen-changed.
8871  **/
8872 void
8873 _gtk_widget_propagate_screen_changed (GtkWidget    *widget,
8874                                       GdkScreen    *previous_screen)
8875 {
8876   HierarchyChangedInfo info;
8877
8878   info.previous_screen = previous_screen;
8879   info.new_screen = gtk_widget_get_screen (widget);
8880
8881   if (previous_screen)
8882     g_object_ref (previous_screen);
8883
8884   gtk_widget_propagate_screen_changed_recurse (widget, &info);
8885
8886   if (previous_screen)
8887     g_object_unref (previous_screen);
8888 }
8889
8890 static void
8891 reset_style_recurse (GtkWidget *widget, gpointer data)
8892 {
8893   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_ANY);
8894
8895   if (GTK_IS_CONTAINER (widget))
8896     gtk_container_forall (GTK_CONTAINER (widget),
8897                           reset_style_recurse,
8898                           NULL);
8899 }
8900
8901 /**
8902  * gtk_widget_reset_style:
8903  * @widget: a #GtkWidget
8904  *
8905  * Updates the style context of @widget and all descendents
8906  * by updating its widget path. #GtkContainer<!-- -->s may want
8907  * to use this on a child when reordering it in a way that a different
8908  * style might apply to it. See also gtk_container_get_path_for_child().
8909  *
8910  * Since: 3.0
8911  */
8912 void
8913 gtk_widget_reset_style (GtkWidget *widget)
8914 {
8915   g_return_if_fail (GTK_IS_WIDGET (widget));
8916
8917   reset_style_recurse (widget, NULL);
8918
8919   g_list_foreach (widget->priv->attached_windows,
8920                   (GFunc) reset_style_recurse, NULL);
8921 }
8922
8923 #ifdef G_ENABLE_DEBUG
8924
8925 /* Verify invariants, see docs/widget_system.txt for notes on much of
8926  * this.  Invariants may be temporarily broken while we're in the
8927  * process of updating state, of course, so you can only
8928  * verify_invariants() after a given operation is complete.
8929  * Use push/pop_verify_invariants to help with that.
8930  */
8931 static void
8932 gtk_widget_verify_invariants (GtkWidget *widget)
8933 {
8934   GtkWidget *parent;
8935
8936   if (widget->priv->verifying_invariants_count > 0)
8937     return;
8938
8939   parent = widget->priv->parent;
8940
8941   if (widget->priv->mapped)
8942     {
8943       /* Mapped implies ... */
8944
8945       if (!widget->priv->realized)
8946         g_warning ("%s %p is mapped but not realized",
8947                    G_OBJECT_TYPE_NAME (widget), widget);
8948
8949       if (!widget->priv->visible)
8950         g_warning ("%s %p is mapped but not visible",
8951                    G_OBJECT_TYPE_NAME (widget), widget);
8952
8953       if (!widget->priv->toplevel)
8954         {
8955           if (!widget->priv->child_visible)
8956             g_warning ("%s %p is mapped but not child_visible",
8957                        G_OBJECT_TYPE_NAME (widget), widget);
8958         }
8959     }
8960   else
8961     {
8962       /* Not mapped implies... */
8963
8964 #if 0
8965   /* This check makes sense for normal toplevels, but for
8966    * something like a toplevel that is embedded within a clutter
8967    * state, mapping may depend on external factors.
8968    */
8969       if (widget->priv->toplevel)
8970         {
8971           if (widget->priv->visible)
8972             g_warning ("%s %p toplevel is visible but not mapped",
8973                        G_OBJECT_TYPE_NAME (widget), widget);
8974         }
8975 #endif
8976     }
8977
8978   /* Parent related checks aren't possible if parent has
8979    * verifying_invariants_count > 0 because parent needs to recurse
8980    * children first before the invariants will hold.
8981    */
8982   if (parent == NULL || parent->priv->verifying_invariants_count == 0)
8983     {
8984       if (parent &&
8985           parent->priv->realized)
8986         {
8987           /* Parent realized implies... */
8988
8989 #if 0
8990           /* This is in widget_system.txt but appears to fail
8991            * because there's no gtk_container_realize() that
8992            * realizes all children... instead we just lazily
8993            * wait for map to fix things up.
8994            */
8995           if (!widget->priv->realized)
8996             g_warning ("%s %p is realized but child %s %p is not realized",
8997                        G_OBJECT_TYPE_NAME (parent), parent,
8998                        G_OBJECT_TYPE_NAME (widget), widget);
8999 #endif
9000         }
9001       else if (!widget->priv->toplevel)
9002         {
9003           /* No parent or parent not realized on non-toplevel implies... */
9004
9005           if (widget->priv->realized && !widget->priv->in_reparent)
9006             g_warning ("%s %p is not realized but child %s %p is realized",
9007                        parent ? G_OBJECT_TYPE_NAME (parent) : "no parent", parent,
9008                        G_OBJECT_TYPE_NAME (widget), widget);
9009         }
9010
9011       if (parent &&
9012           parent->priv->mapped &&
9013           widget->priv->visible &&
9014           widget->priv->child_visible)
9015         {
9016           /* Parent mapped and we are visible implies... */
9017
9018           if (!widget->priv->mapped)
9019             g_warning ("%s %p is mapped but visible child %s %p is not mapped",
9020                        G_OBJECT_TYPE_NAME (parent), parent,
9021                        G_OBJECT_TYPE_NAME (widget), widget);
9022         }
9023       else if (!widget->priv->toplevel)
9024         {
9025           /* No parent or parent not mapped on non-toplevel implies... */
9026
9027           if (widget->priv->mapped && !widget->priv->in_reparent)
9028             g_warning ("%s %p is mapped but visible=%d child_visible=%d parent %s %p mapped=%d",
9029                        G_OBJECT_TYPE_NAME (widget), widget,
9030                        widget->priv->visible,
9031                        widget->priv->child_visible,
9032                        parent ? G_OBJECT_TYPE_NAME (parent) : "no parent", parent,
9033                        parent ? parent->priv->mapped : FALSE);
9034         }
9035     }
9036
9037   if (!widget->priv->realized)
9038     {
9039       /* Not realized implies... */
9040
9041 #if 0
9042       /* widget_system.txt says these hold, but they don't. */
9043       if (widget->priv->alloc_needed)
9044         g_warning ("%s %p alloc needed but not realized",
9045                    G_OBJECT_TYPE_NAME (widget), widget);
9046
9047       if (widget->priv->width_request_needed)
9048         g_warning ("%s %p width request needed but not realized",
9049                    G_OBJECT_TYPE_NAME (widget), widget);
9050
9051       if (widget->priv->height_request_needed)
9052         g_warning ("%s %p height request needed but not realized",
9053                    G_OBJECT_TYPE_NAME (widget), widget);
9054 #endif
9055     }
9056 }
9057
9058 /* The point of this push/pop is that invariants may not hold while
9059  * we're busy making changes. So we only check at the outermost call
9060  * on the call stack, after we finish updating everything.
9061  */
9062 static void
9063 gtk_widget_push_verify_invariants (GtkWidget *widget)
9064 {
9065   widget->priv->verifying_invariants_count += 1;
9066 }
9067
9068 static void
9069 gtk_widget_verify_child_invariants (GtkWidget *widget,
9070                                     gpointer   client_data)
9071 {
9072   /* We don't recurse further; this is a one-level check. */
9073   gtk_widget_verify_invariants (widget);
9074 }
9075
9076 static void
9077 gtk_widget_pop_verify_invariants (GtkWidget *widget)
9078 {
9079   g_assert (widget->priv->verifying_invariants_count > 0);
9080
9081   widget->priv->verifying_invariants_count -= 1;
9082
9083   if (widget->priv->verifying_invariants_count == 0)
9084     {
9085       gtk_widget_verify_invariants (widget);
9086
9087       if (GTK_IS_CONTAINER (widget))
9088         {
9089           /* Check one level of children, because our
9090            * push_verify_invariants() will have prevented some of the
9091            * checks. This does not recurse because if recursion is
9092            * needed, it will happen naturally as each child has a
9093            * push/pop on that child. For example if we're recursively
9094            * mapping children, we'll push/pop on each child as we map
9095            * it.
9096            */
9097           gtk_container_forall (GTK_CONTAINER (widget),
9098                                 gtk_widget_verify_child_invariants,
9099                                 NULL);
9100         }
9101     }
9102 }
9103 #endif /* G_ENABLE_DEBUG */
9104
9105 static PangoContext *
9106 gtk_widget_peek_pango_context (GtkWidget *widget)
9107 {
9108   return g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
9109 }
9110
9111 /**
9112  * gtk_widget_get_pango_context:
9113  * @widget: a #GtkWidget
9114  *
9115  * Gets a #PangoContext with the appropriate font map, font description,
9116  * and base direction for this widget. Unlike the context returned
9117  * by gtk_widget_create_pango_context(), this context is owned by
9118  * the widget (it can be used until the screen for the widget changes
9119  * or the widget is removed from its toplevel), and will be updated to
9120  * match any changes to the widget's attributes. This can be tracked
9121  * by using the #GtkWidget::screen-changed signal on the widget.
9122  *
9123  * Return value: (transfer none): the #PangoContext for the widget.
9124  **/
9125 PangoContext *
9126 gtk_widget_get_pango_context (GtkWidget *widget)
9127 {
9128   PangoContext *context;
9129
9130   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9131
9132   context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
9133   if (!context)
9134     {
9135       context = gtk_widget_create_pango_context (GTK_WIDGET (widget));
9136       g_object_set_qdata_full (G_OBJECT (widget),
9137                                quark_pango_context,
9138                                context,
9139                                g_object_unref);
9140     }
9141
9142   return context;
9143 }
9144
9145 static void
9146 update_pango_context (GtkWidget    *widget,
9147                       PangoContext *context)
9148 {
9149   PangoFontDescription *font_desc;
9150   GtkStyleContext *style_context;
9151
9152   style_context = gtk_widget_get_style_context (widget);
9153   gtk_style_context_get (style_context,
9154                          gtk_widget_get_state_flags (widget),
9155                          "font", &font_desc,
9156                          NULL);
9157
9158   pango_context_set_font_description (context, font_desc);
9159   pango_context_set_base_dir (context,
9160                               gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
9161                               PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
9162
9163   pango_font_description_free (font_desc);
9164 }
9165
9166 static void
9167 gtk_widget_update_pango_context (GtkWidget *widget)
9168 {
9169   PangoContext *context = gtk_widget_peek_pango_context (widget);
9170
9171   if (context)
9172     {
9173       GdkScreen *screen;
9174
9175       update_pango_context (widget, context);
9176
9177       screen = gtk_widget_get_screen_unchecked (widget);
9178       if (screen)
9179         {
9180           pango_cairo_context_set_resolution (context,
9181                                               gdk_screen_get_resolution (screen));
9182           pango_cairo_context_set_font_options (context,
9183                                                 gdk_screen_get_font_options (screen));
9184         }
9185     }
9186 }
9187
9188 /**
9189  * gtk_widget_create_pango_context:
9190  * @widget: a #GtkWidget
9191  *
9192  * Creates a new #PangoContext with the appropriate font map,
9193  * font description, and base direction for drawing text for
9194  * this widget. See also gtk_widget_get_pango_context().
9195  *
9196  * Return value: (transfer full): the new #PangoContext
9197  **/
9198 PangoContext *
9199 gtk_widget_create_pango_context (GtkWidget *widget)
9200 {
9201   GdkScreen *screen;
9202   PangoContext *context;
9203
9204   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9205
9206   screen = gtk_widget_get_screen_unchecked (widget);
9207   if (!screen)
9208     {
9209       GTK_NOTE (MULTIHEAD,
9210                 g_warning ("gtk_widget_create_pango_context ()) called without screen"));
9211
9212       screen = gdk_screen_get_default ();
9213     }
9214
9215   context = gdk_pango_context_get_for_screen (screen);
9216
9217   update_pango_context (widget, context);
9218   pango_context_set_language (context, gtk_get_default_language ());
9219
9220   return context;
9221 }
9222
9223 /**
9224  * gtk_widget_create_pango_layout:
9225  * @widget: a #GtkWidget
9226  * @text: text to set on the layout (can be %NULL)
9227  *
9228  * Creates a new #PangoLayout with the appropriate font map,
9229  * font description, and base direction for drawing text for
9230  * this widget.
9231  *
9232  * If you keep a #PangoLayout created in this way around, you need
9233  * to re-create it when the widget #PangoContext is replaced.
9234  * This can be tracked by using the #GtkWidget::screen-changed signal
9235  * on the widget.
9236  *
9237  * Return value: (transfer full): the new #PangoLayout
9238  **/
9239 PangoLayout *
9240 gtk_widget_create_pango_layout (GtkWidget   *widget,
9241                                 const gchar *text)
9242 {
9243   PangoLayout *layout;
9244   PangoContext *context;
9245
9246   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9247
9248   context = gtk_widget_get_pango_context (widget);
9249   layout = pango_layout_new (context);
9250
9251   if (text)
9252     pango_layout_set_text (layout, text, -1);
9253
9254   return layout;
9255 }
9256
9257 /**
9258  * gtk_widget_render_icon_pixbuf:
9259  * @widget: a #GtkWidget
9260  * @stock_id: a stock ID
9261  * @size: (type int): a stock size. A size of (GtkIconSize)-1 means
9262  *     render at the size of the source and don't scale (if there are
9263  *     multiple source sizes, GTK+ picks one of the available sizes).
9264  *
9265  * A convenience function that uses the theme engine and style
9266  * settings for @widget to look up @stock_id and render it to
9267  * a pixbuf. @stock_id should be a stock icon ID such as
9268  * #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size
9269  * such as #GTK_ICON_SIZE_MENU.
9270  *
9271  * The pixels in the returned #GdkPixbuf are shared with the rest of
9272  * the application and should not be modified. The pixbuf should be freed
9273  * after use with g_object_unref().
9274  *
9275  * Return value: (transfer full): a new pixbuf, or %NULL if the
9276  *     stock ID wasn't known
9277  *
9278  * Since: 3.0
9279  **/
9280 GdkPixbuf*
9281 gtk_widget_render_icon_pixbuf (GtkWidget   *widget,
9282                                const gchar *stock_id,
9283                                GtkIconSize  size)
9284 {
9285   GtkStyleContext *context;
9286   GtkIconSet *icon_set;
9287
9288   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9289   g_return_val_if_fail (stock_id != NULL, NULL);
9290   g_return_val_if_fail (size > GTK_ICON_SIZE_INVALID || size == -1, NULL);
9291
9292   context = gtk_widget_get_style_context (widget);
9293   icon_set = gtk_style_context_lookup_icon_set (context, stock_id);
9294
9295   if (icon_set == NULL)
9296     return NULL;
9297
9298   return gtk_icon_set_render_icon_pixbuf (icon_set, context, size);
9299 }
9300
9301 /**
9302  * gtk_widget_set_parent_window:
9303  * @widget: a #GtkWidget.
9304  * @parent_window: the new parent window.
9305  *
9306  * Sets a non default parent window for @widget.
9307  *
9308  * For GtkWindow classes, setting a @parent_window effects whether
9309  * the window is a toplevel window or can be embedded into other
9310  * widgets.
9311  *
9312  * <note><para>
9313  * For GtkWindow classes, this needs to be called before the
9314  * window is realized.
9315  * </para></note>
9316  *
9317  **/
9318 void
9319 gtk_widget_set_parent_window   (GtkWidget           *widget,
9320                                 GdkWindow           *parent_window)
9321 {
9322   GdkWindow *old_parent_window;
9323
9324   g_return_if_fail (GTK_IS_WIDGET (widget));
9325
9326   old_parent_window = g_object_get_qdata (G_OBJECT (widget),
9327                                           quark_parent_window);
9328
9329   if (parent_window != old_parent_window)
9330     {
9331       gboolean is_plug;
9332
9333       g_object_set_qdata (G_OBJECT (widget), quark_parent_window,
9334                           parent_window);
9335       if (old_parent_window)
9336         g_object_unref (old_parent_window);
9337       if (parent_window)
9338         g_object_ref (parent_window);
9339
9340       /* Unset toplevel flag when adding a parent window to a widget,
9341        * this is the primary entry point to allow toplevels to be
9342        * embeddable.
9343        */
9344 #ifdef GDK_WINDOWING_X11
9345       is_plug = GTK_IS_PLUG (widget);
9346 #else
9347       is_plug = FALSE;
9348 #endif
9349       if (GTK_IS_WINDOW (widget) && !is_plug)
9350         _gtk_window_set_is_toplevel (GTK_WINDOW (widget), parent_window == NULL);
9351     }
9352 }
9353
9354 /**
9355  * gtk_widget_get_parent_window:
9356  * @widget: a #GtkWidget.
9357  *
9358  * Gets @widget's parent window.
9359  *
9360  * Returns: (transfer none): the parent window of @widget.
9361  **/
9362 GdkWindow *
9363 gtk_widget_get_parent_window (GtkWidget *widget)
9364 {
9365   GtkWidgetPrivate *priv;
9366   GdkWindow *parent_window;
9367
9368   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9369
9370   priv = widget->priv;
9371
9372   parent_window = g_object_get_qdata (G_OBJECT (widget), quark_parent_window);
9373
9374   return (parent_window != NULL) ? parent_window :
9375          (priv->parent != NULL) ? priv->parent->priv->window : NULL;
9376 }
9377
9378
9379 /**
9380  * gtk_widget_set_child_visible:
9381  * @widget: a #GtkWidget
9382  * @is_visible: if %TRUE, @widget should be mapped along with its parent.
9383  *
9384  * Sets whether @widget should be mapped along with its when its parent
9385  * is mapped and @widget has been shown with gtk_widget_show().
9386  *
9387  * The child visibility can be set for widget before it is added to
9388  * a container with gtk_widget_set_parent(), to avoid mapping
9389  * children unnecessary before immediately unmapping them. However
9390  * it will be reset to its default state of %TRUE when the widget
9391  * is removed from a container.
9392  *
9393  * Note that changing the child visibility of a widget does not
9394  * queue a resize on the widget. Most of the time, the size of
9395  * a widget is computed from all visible children, whether or
9396  * not they are mapped. If this is not the case, the container
9397  * can queue a resize itself.
9398  *
9399  * This function is only useful for container implementations and
9400  * never should be called by an application.
9401  **/
9402 void
9403 gtk_widget_set_child_visible (GtkWidget *widget,
9404                               gboolean   is_visible)
9405 {
9406   GtkWidgetPrivate *priv;
9407
9408   g_return_if_fail (GTK_IS_WIDGET (widget));
9409   g_return_if_fail (!gtk_widget_is_toplevel (widget));
9410
9411   priv = widget->priv;
9412
9413   g_object_ref (widget);
9414   gtk_widget_verify_invariants (widget);
9415
9416   if (is_visible)
9417     priv->child_visible = TRUE;
9418   else
9419     {
9420       GtkWidget *toplevel;
9421
9422       priv->child_visible = FALSE;
9423
9424       toplevel = gtk_widget_get_toplevel (widget);
9425       if (toplevel != widget && gtk_widget_is_toplevel (toplevel))
9426         _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
9427     }
9428
9429   if (priv->parent && gtk_widget_get_realized (priv->parent))
9430     {
9431       if (gtk_widget_get_mapped (priv->parent) &&
9432           priv->child_visible &&
9433           gtk_widget_get_visible (widget))
9434         gtk_widget_map (widget);
9435       else
9436         gtk_widget_unmap (widget);
9437     }
9438
9439   gtk_widget_verify_invariants (widget);
9440   g_object_unref (widget);
9441 }
9442
9443 /**
9444  * gtk_widget_get_child_visible:
9445  * @widget: a #GtkWidget
9446  *
9447  * Gets the value set with gtk_widget_set_child_visible().
9448  * If you feel a need to use this function, your code probably
9449  * needs reorganization.
9450  *
9451  * This function is only useful for container implementations and
9452  * never should be called by an application.
9453  *
9454  * Return value: %TRUE if the widget is mapped with the parent.
9455  **/
9456 gboolean
9457 gtk_widget_get_child_visible (GtkWidget *widget)
9458 {
9459   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9460
9461   return widget->priv->child_visible;
9462 }
9463
9464 static GdkScreen *
9465 gtk_widget_get_screen_unchecked (GtkWidget *widget)
9466 {
9467   GtkWidget *toplevel;
9468
9469   toplevel = gtk_widget_get_toplevel (widget);
9470
9471   if (gtk_widget_is_toplevel (toplevel))
9472     {
9473       if (GTK_IS_WINDOW (toplevel))
9474         return gtk_window_get_screen (GTK_WINDOW (toplevel));
9475       else if (GTK_IS_INVISIBLE (toplevel))
9476         return gtk_invisible_get_screen (GTK_INVISIBLE (widget));
9477     }
9478
9479   return NULL;
9480 }
9481
9482 /**
9483  * gtk_widget_get_screen:
9484  * @widget: a #GtkWidget
9485  *
9486  * Get the #GdkScreen from the toplevel window associated with
9487  * this widget. This function can only be called after the widget
9488  * has been added to a widget hierarchy with a #GtkWindow
9489  * at the top.
9490  *
9491  * In general, you should only create screen specific
9492  * resources when a widget has been realized, and you should
9493  * free those resources when the widget is unrealized.
9494  *
9495  * Return value: (transfer none): the #GdkScreen for the toplevel for this widget.
9496  *
9497  * Since: 2.2
9498  **/
9499 GdkScreen*
9500 gtk_widget_get_screen (GtkWidget *widget)
9501 {
9502   GdkScreen *screen;
9503
9504   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9505
9506   screen = gtk_widget_get_screen_unchecked (widget);
9507
9508   if (screen)
9509     return screen;
9510   else
9511     {
9512 #if 0
9513       g_warning (G_STRLOC ": Can't get associated screen"
9514                  " for a widget unless it is inside a toplevel GtkWindow\n"
9515                  " widget type is %s associated top level type is %s",
9516                  g_type_name (G_OBJECT_TYPE(G_OBJECT (widget))),
9517                  g_type_name (G_OBJECT_TYPE(G_OBJECT (toplevel))));
9518 #endif
9519       return gdk_screen_get_default ();
9520     }
9521 }
9522
9523 /**
9524  * gtk_widget_has_screen:
9525  * @widget: a #GtkWidget
9526  *
9527  * Checks whether there is a #GdkScreen is associated with
9528  * this widget. All toplevel widgets have an associated
9529  * screen, and all widgets added into a hierarchy with a toplevel
9530  * window at the top.
9531  *
9532  * Return value: %TRUE if there is a #GdkScreen associcated
9533  *   with the widget.
9534  *
9535  * Since: 2.2
9536  **/
9537 gboolean
9538 gtk_widget_has_screen (GtkWidget *widget)
9539 {
9540   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9541
9542   return (gtk_widget_get_screen_unchecked (widget) != NULL);
9543 }
9544
9545 /**
9546  * gtk_widget_get_display:
9547  * @widget: a #GtkWidget
9548  *
9549  * Get the #GdkDisplay for the toplevel window associated with
9550  * this widget. This function can only be called after the widget
9551  * has been added to a widget hierarchy with a #GtkWindow at the top.
9552  *
9553  * In general, you should only create display specific
9554  * resources when a widget has been realized, and you should
9555  * free those resources when the widget is unrealized.
9556  *
9557  * Return value: (transfer none): the #GdkDisplay for the toplevel for this widget.
9558  *
9559  * Since: 2.2
9560  **/
9561 GdkDisplay*
9562 gtk_widget_get_display (GtkWidget *widget)
9563 {
9564   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9565
9566   return gdk_screen_get_display (gtk_widget_get_screen (widget));
9567 }
9568
9569 /**
9570  * gtk_widget_get_root_window:
9571  * @widget: a #GtkWidget
9572  *
9573  * Get the root window where this widget is located. This function can
9574  * only be called after the widget has been added to a widget
9575  * hierarchy with #GtkWindow at the top.
9576  *
9577  * The root window is useful for such purposes as creating a popup
9578  * #GdkWindow associated with the window. In general, you should only
9579  * create display specific resources when a widget has been realized,
9580  * and you should free those resources when the widget is unrealized.
9581  *
9582  * Return value: (transfer none): the #GdkWindow root window for the toplevel for this widget.
9583  *
9584  * Since: 2.2
9585  **/
9586 GdkWindow*
9587 gtk_widget_get_root_window (GtkWidget *widget)
9588 {
9589   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9590
9591   return gdk_screen_get_root_window (gtk_widget_get_screen (widget));
9592 }
9593
9594 /**
9595  * gtk_widget_child_focus:
9596  * @widget: a #GtkWidget
9597  * @direction: direction of focus movement
9598  *
9599  * This function is used by custom widget implementations; if you're
9600  * writing an app, you'd use gtk_widget_grab_focus() to move the focus
9601  * to a particular widget, and gtk_container_set_focus_chain() to
9602  * change the focus tab order. So you may want to investigate those
9603  * functions instead.
9604  *
9605  * gtk_widget_child_focus() is called by containers as the user moves
9606  * around the window using keyboard shortcuts. @direction indicates
9607  * what kind of motion is taking place (up, down, left, right, tab
9608  * forward, tab backward). gtk_widget_child_focus() emits the
9609  * #GtkWidget::focus signal; widgets override the default handler
9610  * for this signal in order to implement appropriate focus behavior.
9611  *
9612  * The default ::focus handler for a widget should return %TRUE if
9613  * moving in @direction left the focus on a focusable location inside
9614  * that widget, and %FALSE if moving in @direction moved the focus
9615  * outside the widget. If returning %TRUE, widgets normally
9616  * call gtk_widget_grab_focus() to place the focus accordingly;
9617  * if returning %FALSE, they don't modify the current focus location.
9618  *
9619  * Return value: %TRUE if focus ended up inside @widget
9620  **/
9621 gboolean
9622 gtk_widget_child_focus (GtkWidget       *widget,
9623                         GtkDirectionType direction)
9624 {
9625   gboolean return_val;
9626
9627   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9628
9629   if (!gtk_widget_get_visible (widget) ||
9630       !gtk_widget_is_sensitive (widget))
9631     return FALSE;
9632
9633   /* child widgets must set CAN_FOCUS, containers
9634    * don't have to though.
9635    */
9636   if (!GTK_IS_CONTAINER (widget) &&
9637       !gtk_widget_get_can_focus (widget))
9638     return FALSE;
9639
9640   g_signal_emit (widget,
9641                  widget_signals[FOCUS],
9642                  0,
9643                  direction, &return_val);
9644
9645   return return_val;
9646 }
9647
9648 /**
9649  * gtk_widget_keynav_failed:
9650  * @widget: a #GtkWidget
9651  * @direction: direction of focus movement
9652  *
9653  * This function should be called whenever keyboard navigation within
9654  * a single widget hits a boundary. The function emits the
9655  * #GtkWidget::keynav-failed signal on the widget and its return
9656  * value should be interpreted in a way similar to the return value of
9657  * gtk_widget_child_focus():
9658  *
9659  * When %TRUE is returned, stay in the widget, the failed keyboard
9660  * navigation is Ok and/or there is nowhere we can/should move the
9661  * focus to.
9662  *
9663  * When %FALSE is returned, the caller should continue with keyboard
9664  * navigation outside the widget, e.g. by calling
9665  * gtk_widget_child_focus() on the widget's toplevel.
9666  *
9667  * The default ::keynav-failed handler returns %TRUE for
9668  * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
9669  * values of #GtkDirectionType, it looks at the
9670  * #GtkSettings:gtk-keynav-cursor-only setting and returns %FALSE
9671  * if the setting is %TRUE. This way the entire user interface
9672  * becomes cursor-navigatable on input devices such as mobile phones
9673  * which only have cursor keys but no tab key.
9674  *
9675  * Whenever the default handler returns %TRUE, it also calls
9676  * gtk_widget_error_bell() to notify the user of the failed keyboard
9677  * navigation.
9678  *
9679  * A use case for providing an own implementation of ::keynav-failed
9680  * (either by connecting to it or by overriding it) would be a row of
9681  * #GtkEntry widgets where the user should be able to navigate the
9682  * entire row with the cursor keys, as e.g. known from user interfaces
9683  * that require entering license keys.
9684  *
9685  * Return value: %TRUE if stopping keyboard navigation is fine, %FALSE
9686  *               if the emitting widget should try to handle the keyboard
9687  *               navigation attempt in its parent container(s).
9688  *
9689  * Since: 2.12
9690  **/
9691 gboolean
9692 gtk_widget_keynav_failed (GtkWidget        *widget,
9693                           GtkDirectionType  direction)
9694 {
9695   gboolean return_val;
9696
9697   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9698
9699   g_signal_emit (widget, widget_signals[KEYNAV_FAILED], 0,
9700                  direction, &return_val);
9701
9702   return return_val;
9703 }
9704
9705 /**
9706  * gtk_widget_error_bell:
9707  * @widget: a #GtkWidget
9708  *
9709  * Notifies the user about an input-related error on this widget.
9710  * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
9711  * gdk_window_beep(), otherwise it does nothing.
9712  *
9713  * Note that the effect of gdk_window_beep() can be configured in many
9714  * ways, depending on the windowing backend and the desktop environment
9715  * or window manager that is used.
9716  *
9717  * Since: 2.12
9718  **/
9719 void
9720 gtk_widget_error_bell (GtkWidget *widget)
9721 {
9722   GtkWidgetPrivate *priv;
9723   GtkSettings* settings;
9724   gboolean beep;
9725
9726   g_return_if_fail (GTK_IS_WIDGET (widget));
9727
9728   priv = widget->priv;
9729
9730   settings = gtk_widget_get_settings (widget);
9731   if (!settings)
9732     return;
9733
9734   g_object_get (settings,
9735                 "gtk-error-bell", &beep,
9736                 NULL);
9737
9738   if (beep && priv->window)
9739     gdk_window_beep (priv->window);
9740 }
9741
9742 static void
9743 gtk_widget_set_usize_internal (GtkWidget          *widget,
9744                                gint                width,
9745                                gint                height,
9746                                GtkQueueResizeFlags flags)
9747 {
9748   GtkWidgetAuxInfo *aux_info;
9749   gboolean changed = FALSE;
9750
9751   g_object_freeze_notify (G_OBJECT (widget));
9752
9753   aux_info = gtk_widget_get_aux_info (widget, TRUE);
9754
9755   if (width > -2 && aux_info->width != width)
9756     {
9757       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9758         g_object_notify (G_OBJECT (widget), "width-request");
9759       aux_info->width = width;
9760       changed = TRUE;
9761     }
9762   if (height > -2 && aux_info->height != height)
9763     {
9764       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9765         g_object_notify (G_OBJECT (widget), "height-request");
9766       aux_info->height = height;
9767       changed = TRUE;
9768     }
9769
9770   if (gtk_widget_get_visible (widget) && changed)
9771     {
9772       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9773         gtk_widget_queue_resize (widget);
9774       else
9775         _gtk_size_group_queue_resize (widget, GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9776     }
9777
9778   g_object_thaw_notify (G_OBJECT (widget));
9779 }
9780
9781 /**
9782  * gtk_widget_set_size_request:
9783  * @widget: a #GtkWidget
9784  * @width: width @widget should request, or -1 to unset
9785  * @height: height @widget should request, or -1 to unset
9786  *
9787  * Sets the minimum size of a widget; that is, the widget's size
9788  * request will be at least @width by @height. You can use this
9789  * function to force a widget to be larger than it normally would be.
9790  *
9791  * In most cases, gtk_window_set_default_size() is a better choice for
9792  * toplevel windows than this function; setting the default size will
9793  * still allow users to shrink the window. Setting the size request
9794  * will force them to leave the window at least as large as the size
9795  * request. When dealing with window sizes,
9796  * gtk_window_set_geometry_hints() can be a useful function as well.
9797  *
9798  * Note the inherent danger of setting any fixed size - themes,
9799  * translations into other languages, different fonts, and user action
9800  * can all change the appropriate size for a given widget. So, it's
9801  * basically impossible to hardcode a size that will always be
9802  * correct.
9803  *
9804  * The size request of a widget is the smallest size a widget can
9805  * accept while still functioning well and drawing itself correctly.
9806  * However in some strange cases a widget may be allocated less than
9807  * its requested size, and in many cases a widget may be allocated more
9808  * space than it requested.
9809  *
9810  * If the size request in a given direction is -1 (unset), then
9811  * the "natural" size request of the widget will be used instead.
9812  *
9813  * The size request set here does not include any margin from the
9814  * #GtkWidget properties margin-left, margin-right, margin-top, and
9815  * margin-bottom, but it does include pretty much all other padding
9816  * or border properties set by any subclass of #GtkWidget.
9817  **/
9818 void
9819 gtk_widget_set_size_request (GtkWidget *widget,
9820                              gint       width,
9821                              gint       height)
9822 {
9823   g_return_if_fail (GTK_IS_WIDGET (widget));
9824   g_return_if_fail (width >= -1);
9825   g_return_if_fail (height >= -1);
9826
9827   if (width == 0)
9828     width = 1;
9829   if (height == 0)
9830     height = 1;
9831
9832   gtk_widget_set_usize_internal (widget, width, height, 0);
9833 }
9834
9835
9836 /**
9837  * gtk_widget_get_size_request:
9838  * @widget: a #GtkWidget
9839  * @width: (out) (allow-none): return location for width, or %NULL
9840  * @height: (out) (allow-none): return location for height, or %NULL
9841  *
9842  * Gets the size request that was explicitly set for the widget using
9843  * gtk_widget_set_size_request(). A value of -1 stored in @width or
9844  * @height indicates that that dimension has not been set explicitly
9845  * and the natural requisition of the widget will be used intead. See
9846  * gtk_widget_set_size_request(). To get the size a widget will
9847  * actually request, call gtk_widget_get_preferred_size() instead of
9848  * this function.
9849  **/
9850 void
9851 gtk_widget_get_size_request (GtkWidget *widget,
9852                              gint      *width,
9853                              gint      *height)
9854 {
9855   const GtkWidgetAuxInfo *aux_info;
9856
9857   g_return_if_fail (GTK_IS_WIDGET (widget));
9858
9859   aux_info = _gtk_widget_get_aux_info_or_defaults (widget);
9860
9861   if (width)
9862     *width = aux_info->width;
9863
9864   if (height)
9865     *height = aux_info->height;
9866 }
9867
9868 /**
9869  * _gtk_widget_override_size_request:
9870  * @widget: a #GtkWidget
9871  * @width: new forced minimum width
9872  * @height: new forced minimum height
9873  * @old_width: location to store previous forced minimum width
9874  * @old_height: location to store previous forced minumum height
9875  *
9876  * Temporarily establishes a forced minimum size for a widget; this
9877  * is used by GtkWindow when calculating the size to add to the
9878  * window's geometry widget. Cached sizes for the widget and its
9879  * parents are invalidated, so that subsequent calls to the size
9880  * negotiation machinery produce the overriden result, but the
9881  * widget is not queued for relayout or redraw. The old size must
9882  * be restored with _gtk_widget_restore_size_request() or things
9883  * will go screwy.
9884  */
9885 void
9886 _gtk_widget_override_size_request (GtkWidget *widget,
9887                                    int        width,
9888                                    int        height,
9889                                    int       *old_width,
9890                                    int       *old_height)
9891 {
9892   gtk_widget_get_size_request (widget, old_width, old_height);
9893   gtk_widget_set_usize_internal (widget, width, height,
9894                                  GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9895 }
9896
9897 /**
9898  * _gtk_widget_restore_size_request:
9899  * @widget: a #GtkWidget
9900  * @old_width: saved forced minimum size
9901  * @old_height: saved forced minimum size
9902  *
9903  * Undoes the operation of_gtk_widget_override_size_request().
9904  */
9905 void
9906 _gtk_widget_restore_size_request (GtkWidget *widget,
9907                                   int        old_width,
9908                                   int        old_height)
9909 {
9910   gtk_widget_set_usize_internal (widget, old_width, old_height,
9911                                  GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9912 }
9913
9914 /**
9915  * gtk_widget_set_events:
9916  * @widget: a #GtkWidget
9917  * @events: event mask
9918  *
9919  * Sets the event mask (see #GdkEventMask) for a widget. The event
9920  * mask determines which events a widget will receive. Keep in mind
9921  * that different widgets have different default event masks, and by
9922  * changing the event mask you may disrupt a widget's functionality,
9923  * so be careful. This function must be called while a widget is
9924  * unrealized. Consider gtk_widget_add_events() for widgets that are
9925  * already realized, or if you want to preserve the existing event
9926  * mask. This function can't be used with #GTK_NO_WINDOW widgets;
9927  * to get events on those widgets, place them inside a #GtkEventBox
9928  * and receive events on the event box.
9929  **/
9930 void
9931 gtk_widget_set_events (GtkWidget *widget,
9932                        gint       events)
9933 {
9934   g_return_if_fail (GTK_IS_WIDGET (widget));
9935   g_return_if_fail (!gtk_widget_get_realized (widget));
9936
9937   g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
9938                       GINT_TO_POINTER (events));
9939   g_object_notify (G_OBJECT (widget), "events");
9940 }
9941
9942 /**
9943  * gtk_widget_set_device_events:
9944  * @widget: a #GtkWidget
9945  * @device: a #GdkDevice
9946  * @events: event mask
9947  *
9948  * Sets the device event mask (see #GdkEventMask) for a widget. The event
9949  * mask determines which events a widget will receive from @device. Keep
9950  * in mind that different widgets have different default event masks, and by
9951  * changing the event mask you may disrupt a widget's functionality,
9952  * so be careful. This function must be called while a widget is
9953  * unrealized. Consider gtk_widget_add_device_events() for widgets that are
9954  * already realized, or if you want to preserve the existing event
9955  * mask. This function can't be used with #GTK_NO_WINDOW widgets;
9956  * to get events on those widgets, place them inside a #GtkEventBox
9957  * and receive events on the event box.
9958  *
9959  * Since: 3.0
9960  **/
9961 void
9962 gtk_widget_set_device_events (GtkWidget    *widget,
9963                               GdkDevice    *device,
9964                               GdkEventMask  events)
9965 {
9966   GHashTable *device_events;
9967
9968   g_return_if_fail (GTK_IS_WIDGET (widget));
9969   g_return_if_fail (GDK_IS_DEVICE (device));
9970   g_return_if_fail (!gtk_widget_get_realized (widget));
9971
9972   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
9973
9974   if (G_UNLIKELY (!device_events))
9975     {
9976       device_events = g_hash_table_new (NULL, NULL);
9977       g_object_set_qdata_full (G_OBJECT (widget), quark_device_event_mask, device_events,
9978                                (GDestroyNotify) g_hash_table_unref);
9979     }
9980
9981   g_hash_table_insert (device_events, device, GUINT_TO_POINTER (events));
9982 }
9983
9984 /**
9985  * gtk_widget_set_device_enabled:
9986  * @widget: a #GtkWidget
9987  * @device: a #GdkDevice
9988  * @enabled: whether to enable the device
9989  *
9990  * Enables or disables a #GdkDevice to interact with @widget
9991  * and all its children.
9992  *
9993  * It does so by descending through the #GdkWindow hierarchy
9994  * and enabling the same mask that is has for core events
9995  * (i.e. the one that gdk_window_get_events() returns).
9996  *
9997  * Since: 3.0
9998  */
9999 void
10000 gtk_widget_set_device_enabled (GtkWidget *widget,
10001                                GdkDevice *device,
10002                                gboolean   enabled)
10003 {
10004   GList *enabled_devices;
10005
10006   g_return_if_fail (GTK_IS_WIDGET (widget));
10007   g_return_if_fail (GDK_IS_DEVICE (device));
10008
10009   enabled_devices = g_object_get_qdata (G_OBJECT (widget), quark_enabled_devices);
10010   enabled_devices = g_list_append (enabled_devices, device);
10011
10012   g_object_set_qdata_full (G_OBJECT (widget), quark_enabled_devices,
10013                            enabled_devices, (GDestroyNotify) g_list_free);;
10014
10015   if (gtk_widget_get_realized (widget))
10016     gtk_widget_set_device_enabled_internal (widget, device, TRUE, enabled);
10017 }
10018
10019 /**
10020  * gtk_widget_get_device_enabled:
10021  * @widget: a #GtkWidget
10022  * @device: a #GdkDevice
10023  *
10024  * Returns whether @device can interact with @widget and its
10025  * children. See gtk_widget_set_device_enabled().
10026  *
10027  * Return value: %TRUE is @device is enabled for @widget
10028  *
10029  * Since: 3.0
10030  */
10031 gboolean
10032 gtk_widget_get_device_enabled (GtkWidget *widget,
10033                                GdkDevice *device)
10034 {
10035   GList *enabled_devices;
10036
10037   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10038   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
10039
10040   enabled_devices = g_object_get_qdata (G_OBJECT (widget), quark_enabled_devices);
10041
10042   return g_list_find (enabled_devices, device) != NULL;
10043 }
10044
10045 static void
10046 gtk_widget_add_events_internal_list (GtkWidget *widget,
10047                                      GdkDevice *device,
10048                                      gint       events,
10049                                      GList     *window_list)
10050 {
10051   GList *l;
10052
10053   for (l = window_list; l != NULL; l = l->next)
10054     {
10055       GdkWindow *window = l->data;
10056       gpointer user_data;
10057
10058       gdk_window_get_user_data (window, &user_data);
10059       if (user_data == widget)
10060         {
10061           GList *children;
10062
10063           if (device)
10064             gdk_window_set_device_events (window, device, gdk_window_get_events (window) | events);
10065           else
10066             gdk_window_set_events (window, gdk_window_get_events (window) | events);
10067
10068           children = gdk_window_get_children (window);
10069           gtk_widget_add_events_internal_list (widget, device, events, children);
10070           g_list_free (children);
10071         }
10072     }
10073 }
10074
10075 static void
10076 gtk_widget_add_events_internal (GtkWidget *widget,
10077                                 GdkDevice *device,
10078                                 gint       events)
10079 {
10080   GtkWidgetPrivate *priv = widget->priv;
10081   GList *window_list;
10082
10083   if (!gtk_widget_get_has_window (widget))
10084     window_list = gdk_window_get_children (priv->window);
10085   else
10086     window_list = g_list_prepend (NULL, priv->window);
10087
10088   gtk_widget_add_events_internal_list (widget, device, events, window_list);
10089
10090   g_list_free (window_list);
10091 }
10092
10093 /**
10094  * gtk_widget_add_events:
10095  * @widget: a #GtkWidget
10096  * @events: an event mask, see #GdkEventMask
10097  *
10098  * Adds the events in the bitfield @events to the event mask for
10099  * @widget. See gtk_widget_set_events() for details.
10100  **/
10101 void
10102 gtk_widget_add_events (GtkWidget *widget,
10103                        gint       events)
10104 {
10105   gint old_events;
10106
10107   g_return_if_fail (GTK_IS_WIDGET (widget));
10108
10109   old_events = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), quark_event_mask));
10110   g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
10111                       GINT_TO_POINTER (old_events | events));
10112
10113   if (gtk_widget_get_realized (widget))
10114     {
10115       gtk_widget_add_events_internal (widget, NULL, events);
10116       gtk_widget_update_devices_mask (widget, FALSE);
10117     }
10118
10119   g_object_notify (G_OBJECT (widget), "events");
10120 }
10121
10122 /**
10123  * gtk_widget_add_device_events:
10124  * @widget: a #GtkWidget
10125  * @device: a #GdkDevice
10126  * @events: an event mask, see #GdkEventMask
10127  *
10128  * Adds the device events in the bitfield @events to the event mask for
10129  * @widget. See gtk_widget_set_device_events() for details.
10130  *
10131  * Since: 3.0
10132  **/
10133 void
10134 gtk_widget_add_device_events (GtkWidget    *widget,
10135                               GdkDevice    *device,
10136                               GdkEventMask  events)
10137 {
10138   GdkEventMask old_events;
10139   GHashTable *device_events;
10140
10141   g_return_if_fail (GTK_IS_WIDGET (widget));
10142   g_return_if_fail (GDK_IS_DEVICE (device));
10143
10144   old_events = gtk_widget_get_device_events (widget, device);
10145
10146   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
10147
10148   if (G_UNLIKELY (!device_events))
10149     {
10150       device_events = g_hash_table_new (NULL, NULL);
10151       g_object_set_qdata_full (G_OBJECT (widget), quark_device_event_mask, device_events,
10152                                (GDestroyNotify) g_hash_table_unref);
10153     }
10154
10155   g_hash_table_insert (device_events, device,
10156                        GUINT_TO_POINTER (old_events | events));
10157
10158   if (gtk_widget_get_realized (widget))
10159     gtk_widget_add_events_internal (widget, device, events);
10160
10161   g_object_notify (G_OBJECT (widget), "events");
10162 }
10163
10164 /**
10165  * gtk_widget_get_toplevel:
10166  * @widget: a #GtkWidget
10167  *
10168  * This function returns the topmost widget in the container hierarchy
10169  * @widget is a part of. If @widget has no parent widgets, it will be
10170  * returned as the topmost widget. No reference will be added to the
10171  * returned widget; it should not be unreferenced.
10172  *
10173  * Note the difference in behavior vs. gtk_widget_get_ancestor();
10174  * <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</literal>
10175  * would return
10176  * %NULL if @widget wasn't inside a toplevel window, and if the
10177  * window was inside a #GtkWindow<!-- -->-derived widget which was in turn
10178  * inside the toplevel #GtkWindow. While the second case may
10179  * seem unlikely, it actually happens when a #GtkPlug is embedded
10180  * inside a #GtkSocket within the same application.
10181  *
10182  * To reliably find the toplevel #GtkWindow, use
10183  * gtk_widget_get_toplevel() and check if the %TOPLEVEL flags
10184  * is set on the result.
10185  * |[
10186  *  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
10187  *  if (gtk_widget_is_toplevel (toplevel))
10188  *    {
10189  *      /&ast; Perform action on toplevel. &ast;/
10190  *    }
10191  * ]|
10192  *
10193  * Return value: (transfer none): the topmost ancestor of @widget, or @widget itself
10194  *    if there's no ancestor.
10195  **/
10196 GtkWidget*
10197 gtk_widget_get_toplevel (GtkWidget *widget)
10198 {
10199   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10200
10201   while (widget->priv->parent)
10202     widget = widget->priv->parent;
10203
10204   return widget;
10205 }
10206
10207 /**
10208  * gtk_widget_get_ancestor:
10209  * @widget: a #GtkWidget
10210  * @widget_type: ancestor type
10211  *
10212  * Gets the first ancestor of @widget with type @widget_type. For example,
10213  * <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</literal> gets
10214  * the first #GtkBox that's an ancestor of @widget. No reference will be
10215  * added to the returned widget; it should not be unreferenced. See note
10216  * about checking for a toplevel #GtkWindow in the docs for
10217  * gtk_widget_get_toplevel().
10218  *
10219  * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
10220  * considers @widget to be an ancestor of itself.
10221  *
10222  * Return value: (transfer none): the ancestor widget, or %NULL if not found
10223  **/
10224 GtkWidget*
10225 gtk_widget_get_ancestor (GtkWidget *widget,
10226                          GType      widget_type)
10227 {
10228   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10229
10230   while (widget && !g_type_is_a (G_OBJECT_TYPE (widget), widget_type))
10231     widget = widget->priv->parent;
10232
10233   if (!(widget && g_type_is_a (G_OBJECT_TYPE (widget), widget_type)))
10234     return NULL;
10235
10236   return widget;
10237 }
10238
10239 /**
10240  * gtk_widget_set_visual:
10241  * @widget: a #GtkWidget
10242  * @visual: visual to be used or %NULL to unset a previous one
10243  *
10244  * Sets the visual that should be used for by widget and its children for
10245  * creating #GdkWindows. The visual must be on the same #GdkScreen as
10246  * returned by gtk_widget_get_screen(), so handling the
10247  * #GtkWidget::screen-changed signal is necessary.
10248  *
10249  * Setting a new @visual will not cause @widget to recreate its windows,
10250  * so you should call this function before @widget is realized.
10251  **/
10252 void
10253 gtk_widget_set_visual (GtkWidget *widget,
10254                        GdkVisual *visual)
10255 {
10256   g_return_if_fail (GTK_IS_WIDGET (widget));
10257   g_return_if_fail (visual == NULL || GDK_IS_VISUAL (visual));
10258   if (visual)
10259     {
10260       g_return_if_fail (gtk_widget_get_screen (widget) == gdk_visual_get_screen (visual));
10261     }
10262
10263   g_object_set_qdata_full (G_OBJECT (widget),
10264                            quark_visual,
10265                            g_object_ref (visual),
10266                            g_object_unref);
10267 }
10268
10269 /**
10270  * gtk_widget_get_visual:
10271  * @widget: a #GtkWidget
10272  *
10273  * Gets the visual that will be used to render @widget.
10274  *
10275  * Return value: (transfer none): the visual for @widget
10276  **/
10277 GdkVisual*
10278 gtk_widget_get_visual (GtkWidget *widget)
10279 {
10280   GtkWidget *w;
10281   GdkVisual *visual;
10282   GdkScreen *screen;
10283
10284   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10285
10286   if (gtk_widget_get_has_window (widget) &&
10287       widget->priv->window)
10288     return gdk_window_get_visual (widget->priv->window);
10289
10290   screen = gtk_widget_get_screen (widget);
10291
10292   for (w = widget; w != NULL; w = w->priv->parent)
10293     {
10294       visual = g_object_get_qdata (G_OBJECT (w), quark_visual);
10295       if (visual)
10296         {
10297           if (gdk_visual_get_screen (visual) == screen)
10298             return visual;
10299
10300           g_warning ("Ignoring visual set on widget `%s' that is not on the correct screen.",
10301                      gtk_widget_get_name (widget));
10302         }
10303     }
10304
10305   return gdk_screen_get_system_visual (screen);
10306 }
10307
10308 /**
10309  * gtk_widget_get_settings:
10310  * @widget: a #GtkWidget
10311  *
10312  * Gets the settings object holding the settings used for this widget.
10313  *
10314  * Note that this function can only be called when the #GtkWidget
10315  * is attached to a toplevel, since the settings object is specific
10316  * to a particular #GdkScreen.
10317  *
10318  * Return value: (transfer none): the relevant #GtkSettings object
10319  */
10320 GtkSettings*
10321 gtk_widget_get_settings (GtkWidget *widget)
10322 {
10323   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10324
10325   return gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
10326 }
10327
10328 /**
10329  * gtk_widget_get_events:
10330  * @widget: a #GtkWidget
10331  *
10332  * Returns the event mask for the widget (a bitfield containing flags
10333  * from the #GdkEventMask enumeration). These are the events that the widget
10334  * will receive.
10335  *
10336  * Return value: event mask for @widget
10337  **/
10338 gint
10339 gtk_widget_get_events (GtkWidget *widget)
10340 {
10341   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
10342
10343   return GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), quark_event_mask));
10344 }
10345
10346 /**
10347  * gtk_widget_get_device_events:
10348  * @widget: a #GtkWidget
10349  * @device: a #GdkDevice
10350  *
10351  * Returns the events mask for the widget corresponding to an specific device. These
10352  * are the events that the widget will receive when @device operates on it.
10353  *
10354  * Returns: device event mask for @widget
10355  *
10356  * Since: 3.0
10357  **/
10358 GdkEventMask
10359 gtk_widget_get_device_events (GtkWidget *widget,
10360                               GdkDevice *device)
10361 {
10362   GHashTable *device_events;
10363
10364   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
10365   g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
10366
10367   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
10368
10369   if (!device_events)
10370     return 0;
10371
10372   return GPOINTER_TO_UINT (g_hash_table_lookup (device_events, device));
10373 }
10374
10375 /**
10376  * gtk_widget_get_pointer:
10377  * @widget: a #GtkWidget
10378  * @x: (out) (allow-none): return location for the X coordinate, or %NULL
10379  * @y: (out) (allow-none): return location for the Y coordinate, or %NULL
10380  *
10381  * Obtains the location of the mouse pointer in widget coordinates.
10382  * Widget coordinates are a bit odd; for historical reasons, they are
10383  * defined as @widget->window coordinates for widgets that are not
10384  * #GTK_NO_WINDOW widgets, and are relative to @widget->allocation.x,
10385  * @widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
10386  *
10387  * Deprecated: 3.4: Use gdk_window_get_device_position() instead.
10388  **/
10389 void
10390 gtk_widget_get_pointer (GtkWidget *widget,
10391                         gint      *x,
10392                         gint      *y)
10393 {
10394   GtkWidgetPrivate *priv;
10395
10396   g_return_if_fail (GTK_IS_WIDGET (widget));
10397
10398   priv = widget->priv;
10399
10400   if (x)
10401     *x = -1;
10402   if (y)
10403     *y = -1;
10404
10405   if (gtk_widget_get_realized (widget))
10406     {
10407       gdk_window_get_device_position (priv->window,
10408                                       gdk_device_manager_get_client_pointer (
10409                                         gdk_display_get_device_manager (
10410                                           gtk_widget_get_display (widget))),
10411                                       x, y, NULL);
10412
10413       if (!gtk_widget_get_has_window (widget))
10414         {
10415           if (x)
10416             *x -= priv->allocation.x;
10417           if (y)
10418             *y -= priv->allocation.y;
10419         }
10420     }
10421 }
10422
10423 /**
10424  * gtk_widget_is_ancestor:
10425  * @widget: a #GtkWidget
10426  * @ancestor: another #GtkWidget
10427  *
10428  * Determines whether @widget is somewhere inside @ancestor, possibly with
10429  * intermediate containers.
10430  *
10431  * Return value: %TRUE if @ancestor contains @widget as a child,
10432  *    grandchild, great grandchild, etc.
10433  **/
10434 gboolean
10435 gtk_widget_is_ancestor (GtkWidget *widget,
10436                         GtkWidget *ancestor)
10437 {
10438   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10439   g_return_val_if_fail (ancestor != NULL, FALSE);
10440
10441   while (widget)
10442     {
10443       if (widget->priv->parent == ancestor)
10444         return TRUE;
10445       widget = widget->priv->parent;
10446     }
10447
10448   return FALSE;
10449 }
10450
10451 static GQuark quark_composite_name = 0;
10452
10453 /**
10454  * gtk_widget_set_composite_name:
10455  * @widget: a #GtkWidget.
10456  * @name: the name to set
10457  *
10458  * Sets a widgets composite name. The widget must be
10459  * a composite child of its parent; see gtk_widget_push_composite_child().
10460  **/
10461 void
10462 gtk_widget_set_composite_name (GtkWidget   *widget,
10463                                const gchar *name)
10464 {
10465   g_return_if_fail (GTK_IS_WIDGET (widget));
10466   g_return_if_fail (widget->priv->composite_child);
10467   g_return_if_fail (name != NULL);
10468
10469   if (!quark_composite_name)
10470     quark_composite_name = g_quark_from_static_string ("gtk-composite-name");
10471
10472   g_object_set_qdata_full (G_OBJECT (widget),
10473                            quark_composite_name,
10474                            g_strdup (name),
10475                            g_free);
10476 }
10477
10478 /**
10479  * gtk_widget_get_composite_name:
10480  * @widget: a #GtkWidget
10481  *
10482  * Obtains the composite name of a widget.
10483  *
10484  * Returns: the composite name of @widget, or %NULL if @widget is not
10485  *   a composite child. The string should be freed when it is no
10486  *   longer needed.
10487  **/
10488 gchar*
10489 gtk_widget_get_composite_name (GtkWidget *widget)
10490 {
10491   GtkWidgetPrivate *priv;
10492
10493   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10494
10495   priv = widget->priv;
10496
10497   if (widget->priv->composite_child && priv->parent)
10498     return _gtk_container_child_composite_name (GTK_CONTAINER (priv->parent),
10499                                                widget);
10500   else
10501     return NULL;
10502 }
10503
10504 /**
10505  * gtk_widget_push_composite_child:
10506  *
10507  * Makes all newly-created widgets as composite children until
10508  * the corresponding gtk_widget_pop_composite_child() call.
10509  *
10510  * A composite child is a child that's an implementation detail of the
10511  * container it's inside and should not be visible to people using the
10512  * container. Composite children aren't treated differently by GTK (but
10513  * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI
10514  * builders might want to treat them in a different way.
10515  *
10516  * Here is a simple example:
10517  * |[
10518  *   gtk_widget_push_composite_child ();
10519  *   scrolled_window->hscrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
10520  *   gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
10521  *   gtk_widget_pop_composite_child ();
10522  *   gtk_widget_set_parent (scrolled_window->hscrollbar,
10523  *                          GTK_WIDGET (scrolled_window));
10524  *   g_object_ref (scrolled_window->hscrollbar);
10525  * ]|
10526  **/
10527 void
10528 gtk_widget_push_composite_child (void)
10529 {
10530   composite_child_stack++;
10531 }
10532
10533 /**
10534  * gtk_widget_pop_composite_child:
10535  *
10536  * Cancels the effect of a previous call to gtk_widget_push_composite_child().
10537  **/
10538 void
10539 gtk_widget_pop_composite_child (void)
10540 {
10541   if (composite_child_stack)
10542     composite_child_stack--;
10543 }
10544
10545 static void
10546 gtk_widget_emit_direction_changed (GtkWidget        *widget,
10547                                    GtkTextDirection  old_dir)
10548 {
10549   GtkTextDirection direction;
10550   GtkStateFlags state;
10551
10552   gtk_widget_update_pango_context (widget);
10553
10554   direction = gtk_widget_get_direction (widget);
10555   state = widget->priv->state_flags;
10556   state &= GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL;
10557
10558   switch (direction)
10559     {
10560     case GTK_TEXT_DIR_LTR:
10561       state |= GTK_STATE_FLAG_DIR_LTR;
10562       break;
10563
10564     case GTK_TEXT_DIR_RTL:
10565       state |= GTK_STATE_FLAG_DIR_RTL;
10566       break;
10567
10568     case GTK_TEXT_DIR_NONE:
10569     default:
10570       g_assert_not_reached ();
10571       break;
10572     }
10573
10574   gtk_widget_set_state_flags (widget, state, TRUE);
10575
10576   g_signal_emit (widget, widget_signals[DIRECTION_CHANGED], 0, old_dir);
10577 }
10578
10579 /**
10580  * gtk_widget_set_direction:
10581  * @widget: a #GtkWidget
10582  * @dir:    the new direction
10583  *
10584  * Sets the reading direction on a particular widget. This direction
10585  * controls the primary direction for widgets containing text,
10586  * and also the direction in which the children of a container are
10587  * packed. The ability to set the direction is present in order
10588  * so that correct localization into languages with right-to-left
10589  * reading directions can be done. Generally, applications will
10590  * let the default reading direction present, except for containers
10591  * where the containers are arranged in an order that is explicitely
10592  * visual rather than logical (such as buttons for text justification).
10593  *
10594  * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
10595  * set by gtk_widget_set_default_direction() will be used.
10596  **/
10597 void
10598 gtk_widget_set_direction (GtkWidget        *widget,
10599                           GtkTextDirection  dir)
10600 {
10601   GtkTextDirection old_dir;
10602
10603   g_return_if_fail (GTK_IS_WIDGET (widget));
10604   g_return_if_fail (dir >= GTK_TEXT_DIR_NONE && dir <= GTK_TEXT_DIR_RTL);
10605
10606   old_dir = gtk_widget_get_direction (widget);
10607
10608   widget->priv->direction = dir;
10609
10610   if (old_dir != gtk_widget_get_direction (widget))
10611     gtk_widget_emit_direction_changed (widget, old_dir);
10612 }
10613
10614 /**
10615  * gtk_widget_get_direction:
10616  * @widget: a #GtkWidget
10617  *
10618  * Gets the reading direction for a particular widget. See
10619  * gtk_widget_set_direction().
10620  *
10621  * Return value: the reading direction for the widget.
10622  **/
10623 GtkTextDirection
10624 gtk_widget_get_direction (GtkWidget *widget)
10625 {
10626   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_TEXT_DIR_LTR);
10627
10628   if (widget->priv->direction == GTK_TEXT_DIR_NONE)
10629     return gtk_default_direction;
10630   else
10631     return widget->priv->direction;
10632 }
10633
10634 static void
10635 gtk_widget_set_default_direction_recurse (GtkWidget *widget, gpointer data)
10636 {
10637   GtkTextDirection old_dir = GPOINTER_TO_UINT (data);
10638
10639   g_object_ref (widget);
10640
10641   if (widget->priv->direction == GTK_TEXT_DIR_NONE)
10642     gtk_widget_emit_direction_changed (widget, old_dir);
10643
10644   if (GTK_IS_CONTAINER (widget))
10645     gtk_container_forall (GTK_CONTAINER (widget),
10646                           gtk_widget_set_default_direction_recurse,
10647                           data);
10648
10649   g_object_unref (widget);
10650 }
10651
10652 /**
10653  * gtk_widget_set_default_direction:
10654  * @dir: the new default direction. This cannot be
10655  *        %GTK_TEXT_DIR_NONE.
10656  *
10657  * Sets the default reading direction for widgets where the
10658  * direction has not been explicitly set by gtk_widget_set_direction().
10659  **/
10660 void
10661 gtk_widget_set_default_direction (GtkTextDirection dir)
10662 {
10663   g_return_if_fail (dir == GTK_TEXT_DIR_RTL || dir == GTK_TEXT_DIR_LTR);
10664
10665   if (dir != gtk_default_direction)
10666     {
10667       GList *toplevels, *tmp_list;
10668       GtkTextDirection old_dir = gtk_default_direction;
10669
10670       gtk_default_direction = dir;
10671
10672       tmp_list = toplevels = gtk_window_list_toplevels ();
10673       g_list_foreach (toplevels, (GFunc)g_object_ref, NULL);
10674
10675       while (tmp_list)
10676         {
10677           gtk_widget_set_default_direction_recurse (tmp_list->data,
10678                                                     GUINT_TO_POINTER (old_dir));
10679           g_object_unref (tmp_list->data);
10680           tmp_list = tmp_list->next;
10681         }
10682
10683       g_list_free (toplevels);
10684     }
10685 }
10686
10687 /**
10688  * gtk_widget_get_default_direction:
10689  *
10690  * Obtains the current default reading direction. See
10691  * gtk_widget_set_default_direction().
10692  *
10693  * Return value: the current default direction.
10694  **/
10695 GtkTextDirection
10696 gtk_widget_get_default_direction (void)
10697 {
10698   return gtk_default_direction;
10699 }
10700
10701 static void
10702 gtk_widget_constructed (GObject *object)
10703 {
10704   GtkWidget *widget = GTK_WIDGET (object);
10705   GtkWidgetPrivate *priv = widget->priv;
10706
10707   /* As strange as it may seem, this may happen on object construction.
10708    * init() implementations of parent types may eventually call this function,
10709    * each with its corresponding GType, which could leave a child
10710    * implementation with a wrong widget type in the widget path
10711    */
10712   if (priv->path &&
10713       G_OBJECT_TYPE (widget) != gtk_widget_path_get_object_type (priv->path))
10714     {
10715       gtk_widget_path_free (priv->path);
10716       priv->path = NULL;
10717     }
10718
10719   G_OBJECT_CLASS (gtk_widget_parent_class)->constructed (object);
10720 }
10721
10722 static void
10723 gtk_widget_dispose (GObject *object)
10724 {
10725   GtkWidget *widget = GTK_WIDGET (object);
10726   GtkWidgetPrivate *priv = widget->priv;
10727
10728   if (priv->parent)
10729     gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
10730   else if (gtk_widget_get_visible (widget))
10731     gtk_widget_hide (widget);
10732
10733   priv->visible = FALSE;
10734   if (gtk_widget_get_realized (widget))
10735     gtk_widget_unrealize (widget);
10736
10737   if (!priv->in_destruction)
10738     {
10739       priv->in_destruction = TRUE;
10740       g_signal_emit (object, widget_signals[DESTROY], 0);
10741       priv->in_destruction = FALSE;
10742     }
10743
10744   g_clear_object (&priv->muxer);
10745
10746   G_OBJECT_CLASS (gtk_widget_parent_class)->dispose (object);
10747 }
10748
10749 static void
10750 gtk_widget_real_destroy (GtkWidget *object)
10751 {
10752   /* gtk_object_destroy() will already hold a refcount on object */
10753   GtkWidget *widget = GTK_WIDGET (object);
10754   GtkWidgetPrivate *priv = widget->priv;
10755   GList *l;
10756
10757   if (GTK_WIDGET_GET_CLASS (widget)->priv->accessible_type != GTK_TYPE_ACCESSIBLE)
10758     {
10759       GtkAccessible *accessible = g_object_steal_qdata (G_OBJECT (widget), quark_accessible_object);
10760
10761       if (accessible)
10762         {
10763           gtk_accessible_set_widget (accessible, NULL);
10764           g_object_unref (accessible);
10765         }
10766     }
10767
10768   /* wipe accelerator closures (keep order) */
10769   g_object_set_qdata (G_OBJECT (widget), quark_accel_path, NULL);
10770   g_object_set_qdata (G_OBJECT (widget), quark_accel_closures, NULL);
10771
10772   /* Callers of add_mnemonic_label() should disconnect on ::destroy */
10773   g_object_set_qdata (G_OBJECT (widget), quark_mnemonic_labels, NULL);
10774
10775   gtk_grab_remove (widget);
10776
10777   for (l = priv->tick_callbacks; l;)
10778     {
10779       GList *next = l->next;
10780       destroy_tick_callback_info (widget, l->data, l);
10781       l = next;
10782     }
10783
10784   if (priv->style)
10785     g_object_unref (priv->style);
10786   priv->style = gtk_widget_get_default_style ();
10787   g_object_ref (priv->style);
10788 }
10789
10790 static void
10791 gtk_widget_finalize (GObject *object)
10792 {
10793   GtkWidget *widget = GTK_WIDGET (object);
10794   GtkWidgetPrivate *priv = widget->priv;
10795   GtkWidgetAuxInfo *aux_info;
10796   GtkAccessible *accessible;
10797
10798   gtk_grab_remove (widget);
10799
10800   g_object_unref (priv->style);
10801   priv->style = NULL;
10802
10803   g_free (priv->name);
10804
10805   aux_info = gtk_widget_get_aux_info (widget, FALSE);
10806   if (aux_info)
10807     gtk_widget_aux_info_destroy (aux_info);
10808
10809   accessible = g_object_get_qdata (G_OBJECT (widget), quark_accessible_object);
10810   if (accessible)
10811     g_object_unref (accessible);
10812
10813   if (priv->path)
10814     gtk_widget_path_free (priv->path);
10815
10816   if (priv->context)
10817     {
10818       _gtk_style_context_set_widget (priv->context, NULL);
10819       g_object_unref (priv->context);
10820     }
10821
10822   _gtk_size_request_cache_free (&priv->requests);
10823
10824   if (g_object_is_floating (object))
10825     g_warning ("A floating object was finalized. This means that someone\n"
10826                "called g_object_unref() on an object that had only a floating\n"
10827                "reference; the initial floating reference is not owned by anyone\n"
10828                "and must be removed with g_object_ref_sink().");
10829
10830   G_OBJECT_CLASS (gtk_widget_parent_class)->finalize (object);
10831 }
10832
10833 /*****************************************
10834  * gtk_widget_real_map:
10835  *
10836  *   arguments:
10837  *
10838  *   results:
10839  *****************************************/
10840
10841 static void
10842 gtk_widget_real_map (GtkWidget *widget)
10843 {
10844   GtkWidgetPrivate *priv = widget->priv;
10845
10846   g_assert (gtk_widget_get_realized (widget));
10847
10848   if (!gtk_widget_get_mapped (widget))
10849     {
10850       gtk_widget_set_mapped (widget, TRUE);
10851
10852       if (gtk_widget_get_has_window (widget))
10853         gdk_window_show (priv->window);
10854     }
10855 }
10856
10857 /*****************************************
10858  * gtk_widget_real_unmap:
10859  *
10860  *   arguments:
10861  *
10862  *   results:
10863  *****************************************/
10864
10865 static void
10866 gtk_widget_real_unmap (GtkWidget *widget)
10867 {
10868   GtkWidgetPrivate *priv = widget->priv;
10869
10870   if (gtk_widget_get_mapped (widget))
10871     {
10872       gtk_widget_set_mapped (widget, FALSE);
10873
10874       if (gtk_widget_get_has_window (widget))
10875         gdk_window_hide (priv->window);
10876     }
10877 }
10878
10879 /*****************************************
10880  * gtk_widget_real_realize:
10881  *
10882  *   arguments:
10883  *
10884  *   results:
10885  *****************************************/
10886
10887 static void
10888 gtk_widget_real_realize (GtkWidget *widget)
10889 {
10890   GtkWidgetPrivate *priv = widget->priv;
10891
10892   g_assert (!gtk_widget_get_has_window (widget));
10893
10894   gtk_widget_set_realized (widget, TRUE);
10895   if (priv->parent)
10896     {
10897       priv->window = gtk_widget_get_parent_window (widget);
10898       g_object_ref (priv->window);
10899     }
10900 }
10901
10902 /*****************************************
10903  * gtk_widget_real_unrealize:
10904  *
10905  *   arguments:
10906  *
10907  *   results:
10908  *****************************************/
10909
10910 static void
10911 gtk_widget_real_unrealize (GtkWidget *widget)
10912 {
10913   GtkWidgetPrivate *priv = widget->priv;
10914
10915   g_assert (!widget->priv->mapped);
10916
10917   /* printf ("unrealizing %s\n", g_type_name (G_TYPE_FROM_INSTANCE (widget)));
10918    */
10919
10920    /* We must do unrealize child widget BEFORE container widget.
10921     * gdk_window_destroy() destroys specified xwindow and its sub-xwindows.
10922     * So, unrealizing container widget bofore its children causes the problem
10923     * (for example, gdk_ic_destroy () with destroyed window causes crash. )
10924     */
10925
10926   if (GTK_IS_CONTAINER (widget))
10927     gtk_container_forall (GTK_CONTAINER (widget),
10928                           (GtkCallback) gtk_widget_unrealize,
10929                           NULL);
10930
10931   if (gtk_widget_get_has_window (widget))
10932     {
10933       gtk_widget_unregister_window (widget, priv->window);
10934       gdk_window_destroy (priv->window);
10935       priv->window = NULL;
10936     }
10937   else
10938     {
10939       g_object_unref (priv->window);
10940       priv->window = NULL;
10941     }
10942
10943   gtk_selection_remove_all (widget);
10944
10945   gtk_widget_set_realized (widget, FALSE);
10946 }
10947
10948 static void
10949 gtk_widget_real_adjust_size_request (GtkWidget         *widget,
10950                                      GtkOrientation     orientation,
10951                                      gint              *minimum_size,
10952                                      gint              *natural_size)
10953 {
10954   const GtkWidgetAuxInfo *aux_info;
10955
10956   aux_info =_gtk_widget_get_aux_info_or_defaults (widget);
10957
10958   if (orientation == GTK_ORIENTATION_HORIZONTAL &&
10959       aux_info->width > 0)
10960     {
10961       *minimum_size = MAX (*minimum_size, aux_info->width);
10962     }
10963   else if (orientation == GTK_ORIENTATION_VERTICAL &&
10964            aux_info->height > 0)
10965     {
10966       *minimum_size = MAX (*minimum_size, aux_info->height);
10967     }
10968
10969   /* Fix it if set_size_request made natural size smaller than min size.
10970    * This would also silently fix broken widgets, but we warn about them
10971    * in gtksizerequest.c when calling their size request vfuncs.
10972    */
10973   *natural_size = MAX (*natural_size, *minimum_size);
10974
10975   if (orientation == GTK_ORIENTATION_HORIZONTAL)
10976     {
10977       *minimum_size += (aux_info->margin.left + aux_info->margin.right);
10978       *natural_size += (aux_info->margin.left + aux_info->margin.right);
10979     }
10980   else
10981     {
10982       *minimum_size += (aux_info->margin.top + aux_info->margin.bottom);
10983       *natural_size += (aux_info->margin.top + aux_info->margin.bottom);
10984     }
10985 }
10986
10987 /**
10988  * _gtk_widget_peek_request_cache:
10989  *
10990  * Returns the address of the widget's request cache (strictly for
10991  * internal use in gtksizerequest.c)
10992  *
10993  * Return value: the address of @widget's size request cache.
10994  **/
10995 gpointer
10996 _gtk_widget_peek_request_cache (GtkWidget *widget)
10997 {
10998   /* Don't bother slowing things down with the return_if_fail guards here */
10999   return &widget->priv->requests;
11000 }
11001
11002 /*
11003  * _gtk_widget_set_device_window:
11004  * @widget: a #GtkWidget
11005  * @device: a #GdkDevice
11006  * @window: the new device window
11007  *
11008  * Sets pointer window for @widget and @device.
11009  * Does not ref @window.
11010  */
11011 void
11012 _gtk_widget_set_device_window (GtkWidget *widget,
11013                                GdkDevice *device,
11014                                GdkWindow *window)
11015 {
11016   GHashTable *device_window;
11017
11018   g_return_if_fail (GTK_IS_WIDGET (widget));
11019   g_return_if_fail (GDK_IS_DEVICE (device));
11020   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
11021
11022   if (!gtk_widget_get_mapped (widget))
11023     return;
11024
11025   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11026
11027   if (!device_window && window)
11028     {
11029       device_window = g_hash_table_new (NULL, NULL);
11030       g_object_set_qdata_full (G_OBJECT (widget),
11031                                quark_pointer_window,
11032                                device_window,
11033                                (GDestroyNotify) g_hash_table_destroy);
11034     }
11035
11036   if (window)
11037     g_hash_table_insert (device_window, device, window);
11038   else if (device_window)
11039     {
11040       g_hash_table_remove (device_window, device);
11041
11042       if (g_hash_table_size (device_window) == 0)
11043         g_object_set_qdata (G_OBJECT (widget), quark_pointer_window, NULL);
11044     }
11045 }
11046
11047 /*
11048  * _gtk_widget_get_device_window:
11049  * @widget: a #GtkWidget
11050  * @device: a #GdkDevice
11051  *
11052  * Return value: the device window set on @widget, or %NULL
11053  */
11054 GdkWindow *
11055 _gtk_widget_get_device_window (GtkWidget *widget,
11056                                GdkDevice *device)
11057 {
11058   GHashTable *device_window;
11059
11060   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11061   g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
11062
11063   if (!gtk_widget_get_mapped (widget))
11064     return NULL;
11065
11066   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11067
11068   if (!device_window)
11069     return NULL;
11070
11071   return g_hash_table_lookup (device_window, device);
11072 }
11073
11074 /*
11075  * _gtk_widget_list_devices:
11076  * @widget: a #GtkWidget
11077  *
11078  * Returns the list of #GdkDevices that is currently on top
11079  * of any window belonging to @widget.
11080  * Free the list with g_list_free(), the elements are owned
11081  * by GTK+ and must not be freed.
11082  */
11083 GList *
11084 _gtk_widget_list_devices (GtkWidget *widget)
11085 {
11086   GHashTableIter iter;
11087   GHashTable *device_window;
11088   GList *devices = NULL;
11089   gpointer key, value;
11090
11091   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11092
11093   if (!gtk_widget_get_mapped (widget))
11094     return NULL;
11095
11096   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11097
11098   if (G_UNLIKELY (!device_window))
11099     return NULL;
11100
11101   g_hash_table_iter_init (&iter, device_window);
11102
11103   while (g_hash_table_iter_next (&iter, &key, &value))
11104     devices = g_list_prepend (devices, key);
11105
11106   return devices;
11107 }
11108
11109 static void
11110 synth_crossing (GtkWidget       *widget,
11111                 GdkEventType     type,
11112                 GdkWindow       *window,
11113                 GdkDevice       *device,
11114                 GdkCrossingMode  mode,
11115                 GdkNotifyType    detail)
11116 {
11117   GdkEvent *event;
11118
11119   event = gdk_event_new (type);
11120
11121   event->crossing.window = g_object_ref (window);
11122   event->crossing.send_event = TRUE;
11123   event->crossing.subwindow = g_object_ref (window);
11124   event->crossing.time = GDK_CURRENT_TIME;
11125   event->crossing.x = event->crossing.y = 0;
11126   event->crossing.x_root = event->crossing.y_root = 0;
11127   event->crossing.mode = mode;
11128   event->crossing.detail = detail;
11129   event->crossing.focus = FALSE;
11130   event->crossing.state = 0;
11131   gdk_event_set_device (event, device);
11132
11133   if (!widget)
11134     widget = gtk_get_event_widget (event);
11135
11136   if (widget)
11137     gtk_widget_event_internal (widget, event);
11138
11139   gdk_event_free (event);
11140 }
11141
11142 /*
11143  * _gtk_widget_synthesize_crossing:
11144  * @from: the #GtkWidget the virtual pointer is leaving.
11145  * @to: the #GtkWidget the virtual pointer is moving to.
11146  * @mode: the #GdkCrossingMode to place on the synthesized events.
11147  *
11148  * Generate crossing event(s) on widget state (sensitivity) or GTK+ grab change.
11149  *
11150  * The real pointer window is the window that most recently received an enter notify
11151  * event.  Windows that don't select for crossing events can't become the real
11152  * poiner window.  The real pointer widget that owns the real pointer window.  The
11153  * effective pointer window is the same as the real pointer window unless the real
11154  * pointer widget is either insensitive or there is a grab on a widget that is not
11155  * an ancestor of the real pointer widget (in which case the effective pointer
11156  * window should be the root window).
11157  *
11158  * When the effective pointer window is the same as the real poiner window, we
11159  * receive crossing events from the windowing system.  When the effective pointer
11160  * window changes to become different from the real pointer window we synthesize
11161  * crossing events, attempting to follow X protocol rules:
11162  *
11163  * When the root window becomes the effective pointer window:
11164  *   - leave notify on real pointer window, detail Ancestor
11165  *   - leave notify on all of its ancestors, detail Virtual
11166  *   - enter notify on root window, detail Inferior
11167  *
11168  * When the root window ceases to be the effective pointer window:
11169  *   - leave notify on root window, detail Inferior
11170  *   - enter notify on all ancestors of real pointer window, detail Virtual
11171  *   - enter notify on real pointer window, detail Ancestor
11172  */
11173 void
11174 _gtk_widget_synthesize_crossing (GtkWidget       *from,
11175                                  GtkWidget       *to,
11176                                  GdkDevice       *device,
11177                                  GdkCrossingMode  mode)
11178 {
11179   GdkWindow *from_window = NULL, *to_window = NULL;
11180
11181   g_return_if_fail (from != NULL || to != NULL);
11182
11183   if (from != NULL)
11184     {
11185       from_window = _gtk_widget_get_device_window (from, device);
11186
11187       if (!from_window)
11188         from_window = from->priv->window;
11189     }
11190
11191   if (to != NULL)
11192     {
11193       to_window = _gtk_widget_get_device_window (to, device);
11194
11195       if (!to_window)
11196         to_window = to->priv->window;
11197     }
11198
11199   if (from_window == NULL && to_window == NULL)
11200     ;
11201   else if (from_window != NULL && to_window == NULL)
11202     {
11203       GList *from_ancestors = NULL, *list;
11204       GdkWindow *from_ancestor = from_window;
11205
11206       while (from_ancestor != NULL)
11207         {
11208           from_ancestor = gdk_window_get_effective_parent (from_ancestor);
11209           if (from_ancestor == NULL)
11210             break;
11211           from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
11212         }
11213
11214       synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11215                       device, mode, GDK_NOTIFY_ANCESTOR);
11216       for (list = g_list_last (from_ancestors); list; list = list->prev)
11217         {
11218           synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11219                           device, mode, GDK_NOTIFY_VIRTUAL);
11220         }
11221
11222       /* XXX: enter/inferior on root window? */
11223
11224       g_list_free (from_ancestors);
11225     }
11226   else if (from_window == NULL && to_window != NULL)
11227     {
11228       GList *to_ancestors = NULL, *list;
11229       GdkWindow *to_ancestor = to_window;
11230
11231       while (to_ancestor != NULL)
11232         {
11233           to_ancestor = gdk_window_get_effective_parent (to_ancestor);
11234           if (to_ancestor == NULL)
11235             break;
11236           to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
11237         }
11238
11239       /* XXX: leave/inferior on root window? */
11240
11241       for (list = to_ancestors; list; list = list->next)
11242         {
11243           synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11244                           device, mode, GDK_NOTIFY_VIRTUAL);
11245         }
11246       synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11247                       device, mode, GDK_NOTIFY_ANCESTOR);
11248
11249       g_list_free (to_ancestors);
11250     }
11251   else if (from_window == to_window)
11252     ;
11253   else
11254     {
11255       GList *from_ancestors = NULL, *to_ancestors = NULL, *list;
11256       GdkWindow *from_ancestor = from_window, *to_ancestor = to_window;
11257
11258       while (from_ancestor != NULL || to_ancestor != NULL)
11259         {
11260           if (from_ancestor != NULL)
11261             {
11262               from_ancestor = gdk_window_get_effective_parent (from_ancestor);
11263               if (from_ancestor == to_window)
11264                 break;
11265               if (from_ancestor)
11266                 from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
11267             }
11268           if (to_ancestor != NULL)
11269             {
11270               to_ancestor = gdk_window_get_effective_parent (to_ancestor);
11271               if (to_ancestor == from_window)
11272                 break;
11273               if (to_ancestor)
11274                 to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
11275             }
11276         }
11277       if (to_ancestor == from_window)
11278         {
11279           if (mode != GDK_CROSSING_GTK_UNGRAB)
11280             synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11281                             device, mode, GDK_NOTIFY_INFERIOR);
11282           for (list = to_ancestors; list; list = list->next)
11283             synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11284                             device, mode, GDK_NOTIFY_VIRTUAL);
11285           synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11286                           device, mode, GDK_NOTIFY_ANCESTOR);
11287         }
11288       else if (from_ancestor == to_window)
11289         {
11290           synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11291                           device, mode, GDK_NOTIFY_ANCESTOR);
11292           for (list = g_list_last (from_ancestors); list; list = list->prev)
11293             {
11294               synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11295                               device, mode, GDK_NOTIFY_VIRTUAL);
11296             }
11297           if (mode != GDK_CROSSING_GTK_GRAB)
11298             synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11299                             device, mode, GDK_NOTIFY_INFERIOR);
11300         }
11301       else
11302         {
11303           while (from_ancestors != NULL && to_ancestors != NULL
11304                  && from_ancestors->data == to_ancestors->data)
11305             {
11306               from_ancestors = g_list_delete_link (from_ancestors,
11307                                                    from_ancestors);
11308               to_ancestors = g_list_delete_link (to_ancestors, to_ancestors);
11309             }
11310
11311           synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11312                           device, mode, GDK_NOTIFY_NONLINEAR);
11313
11314           for (list = g_list_last (from_ancestors); list; list = list->prev)
11315             {
11316               synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11317                               device, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
11318             }
11319           for (list = to_ancestors; list; list = list->next)
11320             {
11321               synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11322                               device, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
11323             }
11324           synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11325                           device, mode, GDK_NOTIFY_NONLINEAR);
11326         }
11327       g_list_free (from_ancestors);
11328       g_list_free (to_ancestors);
11329     }
11330 }
11331
11332 static void
11333 gtk_widget_propagate_state (GtkWidget    *widget,
11334                             GtkStateData *data)
11335 {
11336   GtkWidgetPrivate *priv = widget->priv;
11337   GtkStateFlags new_flags, old_flags = priv->state_flags;
11338   GtkStateType old_state;
11339
11340   old_state = gtk_widget_get_state (widget);
11341
11342   priv->state_flags |= data->flags_to_set;
11343   priv->state_flags &= ~(data->flags_to_unset);
11344
11345   /* make insensitivity unoverridable */
11346   if (!priv->sensitive)
11347     priv->state_flags |= GTK_STATE_FLAG_INSENSITIVE;
11348
11349   if (gtk_widget_is_focus (widget) && !gtk_widget_is_sensitive (widget))
11350     {
11351       GtkWidget *window;
11352
11353       window = gtk_widget_get_toplevel (widget);
11354
11355       if (window && gtk_widget_is_toplevel (window))
11356         gtk_window_set_focus (GTK_WINDOW (window), NULL);
11357     }
11358
11359   new_flags = priv->state_flags;
11360
11361   if (old_flags != new_flags)
11362     {
11363       g_object_ref (widget);
11364
11365       if (!gtk_widget_is_sensitive (widget) && gtk_widget_has_grab (widget))
11366         gtk_grab_remove (widget);
11367
11368       gtk_style_context_set_state (gtk_widget_get_style_context (widget), new_flags);
11369
11370       g_signal_emit (widget, widget_signals[STATE_CHANGED], 0, old_state);
11371       g_signal_emit (widget, widget_signals[STATE_FLAGS_CHANGED], 0, old_flags);
11372
11373       if (!priv->shadowed &&
11374           (new_flags & GTK_STATE_FLAG_INSENSITIVE) != (old_flags & GTK_STATE_FLAG_INSENSITIVE))
11375         {
11376           GList *event_windows = NULL;
11377           GList *devices, *d;
11378
11379           devices = _gtk_widget_list_devices (widget);
11380
11381           for (d = devices; d; d = d->next)
11382             {
11383               GdkWindow *window;
11384               GdkDevice *device;
11385
11386               device = d->data;
11387               window = _gtk_widget_get_device_window (widget, device);
11388
11389               /* Do not propagate more than once to the
11390                * same window if non-multidevice aware.
11391                */
11392               if (!gdk_window_get_support_multidevice (window) &&
11393                   g_list_find (event_windows, window))
11394                 continue;
11395
11396               if (!gtk_widget_is_sensitive (widget))
11397                 _gtk_widget_synthesize_crossing (widget, NULL, d->data,
11398                                                  GDK_CROSSING_STATE_CHANGED);
11399               else
11400                 _gtk_widget_synthesize_crossing (NULL, widget, d->data,
11401                                                  GDK_CROSSING_STATE_CHANGED);
11402
11403               event_windows = g_list_prepend (event_windows, window);
11404             }
11405
11406           g_list_free (event_windows);
11407           g_list_free (devices);
11408         }
11409
11410       if (GTK_IS_CONTAINER (widget))
11411         {
11412           GtkStateData child_data;
11413
11414           /* Make sure to only propate the right states further */
11415           child_data.flags_to_set = data->flags_to_set & GTK_STATE_FLAGS_DO_PROPAGATE;
11416           child_data.flags_to_unset = data->flags_to_unset & GTK_STATE_FLAGS_DO_PROPAGATE;
11417
11418           gtk_container_forall (GTK_CONTAINER (widget),
11419                                 (GtkCallback) gtk_widget_propagate_state,
11420                                 &child_data);
11421         }
11422
11423       g_object_unref (widget);
11424     }
11425 }
11426
11427 static const GtkWidgetAuxInfo default_aux_info = {
11428   -1, -1,
11429   GTK_ALIGN_FILL,
11430   GTK_ALIGN_FILL,
11431   { 0, 0, 0, 0 }
11432 };
11433
11434 /*
11435  * gtk_widget_get_aux_info:
11436  * @widget: a #GtkWidget
11437  * @create: if %TRUE, create the structure if it doesn't exist
11438  *
11439  * Get the #GtkWidgetAuxInfo structure for the widget.
11440  *
11441  * Return value: the #GtkAuxInfo structure for the widget, or
11442  *    %NULL if @create is %FALSE and one doesn't already exist.
11443  */
11444 static GtkWidgetAuxInfo *
11445 gtk_widget_get_aux_info (GtkWidget *widget,
11446                          gboolean   create)
11447 {
11448   GtkWidgetAuxInfo *aux_info;
11449
11450   aux_info = g_object_get_qdata (G_OBJECT (widget), quark_aux_info);
11451   if (!aux_info && create)
11452     {
11453       aux_info = g_slice_new0 (GtkWidgetAuxInfo);
11454
11455       *aux_info = default_aux_info;
11456
11457       g_object_set_qdata (G_OBJECT (widget), quark_aux_info, aux_info);
11458     }
11459
11460   return aux_info;
11461 }
11462
11463 static const GtkWidgetAuxInfo*
11464 _gtk_widget_get_aux_info_or_defaults (GtkWidget *widget)
11465 {
11466   GtkWidgetAuxInfo *aux_info;
11467
11468   aux_info = gtk_widget_get_aux_info (widget, FALSE);
11469   if (aux_info == NULL)
11470     {
11471       return &default_aux_info;
11472     }
11473   else
11474     {
11475       return aux_info;
11476     }
11477 }
11478
11479 /*****************************************
11480  * gtk_widget_aux_info_destroy:
11481  *
11482  *   arguments:
11483  *
11484  *   results:
11485  *****************************************/
11486
11487 static void
11488 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
11489 {
11490   g_slice_free (GtkWidgetAuxInfo, aux_info);
11491 }
11492
11493 /**
11494  * gtk_widget_shape_combine_region:
11495  * @widget: a #GtkWidget
11496  * @region: (allow-none): shape to be added, or %NULL to remove an existing shape
11497  *
11498  * Sets a shape for this widget's GDK window. This allows for
11499  * transparent windows etc., see gdk_window_shape_combine_region()
11500  * for more information.
11501  *
11502  * Since: 3.0
11503  **/
11504 void
11505 gtk_widget_shape_combine_region (GtkWidget *widget,
11506                                  cairo_region_t *region)
11507 {
11508   GtkWidgetPrivate *priv;
11509
11510   g_return_if_fail (GTK_IS_WIDGET (widget));
11511   /*  set_shape doesn't work on widgets without gdk window */
11512   g_return_if_fail (gtk_widget_get_has_window (widget));
11513
11514   priv = widget->priv;
11515
11516   if (region == NULL)
11517     {
11518       priv->has_shape_mask = FALSE;
11519
11520       if (priv->window)
11521         gdk_window_shape_combine_region (priv->window, NULL, 0, 0);
11522
11523       g_object_set_qdata (G_OBJECT (widget), quark_shape_info, NULL);
11524     }
11525   else
11526     {
11527       priv->has_shape_mask = TRUE;
11528
11529       g_object_set_qdata_full (G_OBJECT (widget), quark_shape_info,
11530                                cairo_region_copy (region),
11531                                (GDestroyNotify) cairo_region_destroy);
11532
11533       /* set shape if widget has a gdk window already.
11534        * otherwise the shape is scheduled to be set by gtk_widget_realize().
11535        */
11536       if (priv->window)
11537         gdk_window_shape_combine_region (priv->window, region, 0, 0);
11538     }
11539 }
11540
11541 /**
11542  * gtk_widget_input_shape_combine_region:
11543  * @widget: a #GtkWidget
11544  * @region: (allow-none): shape to be added, or %NULL to remove an existing shape
11545  *
11546  * Sets an input shape for this widget's GDK window. This allows for
11547  * windows which react to mouse click in a nonrectangular region, see
11548  * gdk_window_input_shape_combine_region() for more information.
11549  *
11550  * Since: 3.0
11551  **/
11552 void
11553 gtk_widget_input_shape_combine_region (GtkWidget *widget,
11554                                        cairo_region_t *region)
11555 {
11556   GtkWidgetPrivate *priv;
11557
11558   g_return_if_fail (GTK_IS_WIDGET (widget));
11559   /*  set_shape doesn't work on widgets without gdk window */
11560   g_return_if_fail (gtk_widget_get_has_window (widget));
11561
11562   priv = widget->priv;
11563
11564   if (region == NULL)
11565     {
11566       if (priv->window)
11567         gdk_window_input_shape_combine_region (priv->window, NULL, 0, 0);
11568
11569       g_object_set_qdata (G_OBJECT (widget), quark_input_shape_info, NULL);
11570     }
11571   else
11572     {
11573       g_object_set_qdata_full (G_OBJECT (widget), quark_input_shape_info,
11574                                cairo_region_copy (region),
11575                                (GDestroyNotify) cairo_region_destroy);
11576
11577       /* set shape if widget has a gdk window already.
11578        * otherwise the shape is scheduled to be set by gtk_widget_realize().
11579        */
11580       if (priv->window)
11581         gdk_window_input_shape_combine_region (priv->window, region, 0, 0);
11582     }
11583 }
11584
11585
11586 /* style properties
11587  */
11588
11589 /**
11590  * gtk_widget_class_install_style_property_parser: (skip)
11591  * @klass: a #GtkWidgetClass
11592  * @pspec: the #GParamSpec for the style property
11593  * @parser: the parser for the style property
11594  *
11595  * Installs a style property on a widget class.
11596  **/
11597 void
11598 gtk_widget_class_install_style_property_parser (GtkWidgetClass     *klass,
11599                                                 GParamSpec         *pspec,
11600                                                 GtkRcPropertyParser parser)
11601 {
11602   g_return_if_fail (GTK_IS_WIDGET_CLASS (klass));
11603   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
11604   g_return_if_fail (pspec->flags & G_PARAM_READABLE);
11605   g_return_if_fail (!(pspec->flags & (G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT)));
11606
11607   if (g_param_spec_pool_lookup (style_property_spec_pool, pspec->name, G_OBJECT_CLASS_TYPE (klass), FALSE))
11608     {
11609       g_warning (G_STRLOC ": class `%s' already contains a style property named `%s'",
11610                  G_OBJECT_CLASS_NAME (klass),
11611                  pspec->name);
11612       return;
11613     }
11614
11615   g_param_spec_ref_sink (pspec);
11616   g_param_spec_set_qdata (pspec, quark_property_parser, (gpointer) parser);
11617   g_param_spec_pool_insert (style_property_spec_pool, pspec, G_OBJECT_CLASS_TYPE (klass));
11618 }
11619
11620 /**
11621  * gtk_widget_class_install_style_property:
11622  * @klass: a #GtkWidgetClass
11623  * @pspec: the #GParamSpec for the property
11624  *
11625  * Installs a style property on a widget class. The parser for the
11626  * style property is determined by the value type of @pspec.
11627  **/
11628 void
11629 gtk_widget_class_install_style_property (GtkWidgetClass *klass,
11630                                          GParamSpec     *pspec)
11631 {
11632   GtkRcPropertyParser parser;
11633
11634   g_return_if_fail (GTK_IS_WIDGET_CLASS (klass));
11635   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
11636
11637   parser = _gtk_rc_property_parser_from_type (G_PARAM_SPEC_VALUE_TYPE (pspec));
11638
11639   gtk_widget_class_install_style_property_parser (klass, pspec, parser);
11640 }
11641
11642 /**
11643  * gtk_widget_class_find_style_property:
11644  * @klass: a #GtkWidgetClass
11645  * @property_name: the name of the style property to find
11646  *
11647  * Finds a style property of a widget class by name.
11648  *
11649  * Returns: (transfer none): the #GParamSpec of the style property or
11650  *   %NULL if @class has no style property with that name.
11651  *
11652  * Since: 2.2
11653  */
11654 GParamSpec*
11655 gtk_widget_class_find_style_property (GtkWidgetClass *klass,
11656                                       const gchar    *property_name)
11657 {
11658   g_return_val_if_fail (property_name != NULL, NULL);
11659
11660   return g_param_spec_pool_lookup (style_property_spec_pool,
11661                                    property_name,
11662                                    G_OBJECT_CLASS_TYPE (klass),
11663                                    TRUE);
11664 }
11665
11666 /**
11667  * gtk_widget_class_list_style_properties:
11668  * @klass: a #GtkWidgetClass
11669  * @n_properties: location to return the number of style properties found
11670  *
11671  * Returns all style properties of a widget class.
11672  *
11673  * Returns: (array length=n_properties) (transfer container): a
11674  *     newly allocated array of #GParamSpec*. The array must be
11675  *     freed with g_free().
11676  *
11677  * Since: 2.2
11678  */
11679 GParamSpec**
11680 gtk_widget_class_list_style_properties (GtkWidgetClass *klass,
11681                                         guint          *n_properties)
11682 {
11683   GParamSpec **pspecs;
11684   guint n;
11685
11686   pspecs = g_param_spec_pool_list (style_property_spec_pool,
11687                                    G_OBJECT_CLASS_TYPE (klass),
11688                                    &n);
11689   if (n_properties)
11690     *n_properties = n;
11691
11692   return pspecs;
11693 }
11694
11695 /**
11696  * gtk_widget_style_get_property:
11697  * @widget: a #GtkWidget
11698  * @property_name: the name of a style property
11699  * @value: location to return the property value
11700  *
11701  * Gets the value of a style property of @widget.
11702  */
11703 void
11704 gtk_widget_style_get_property (GtkWidget   *widget,
11705                                const gchar *property_name,
11706                                GValue      *value)
11707 {
11708   GParamSpec *pspec;
11709
11710   g_return_if_fail (GTK_IS_WIDGET (widget));
11711   g_return_if_fail (property_name != NULL);
11712   g_return_if_fail (G_IS_VALUE (value));
11713
11714   g_object_ref (widget);
11715   pspec = g_param_spec_pool_lookup (style_property_spec_pool,
11716                                     property_name,
11717                                     G_OBJECT_TYPE (widget),
11718                                     TRUE);
11719   if (!pspec)
11720     g_warning ("%s: widget class `%s' has no property named `%s'",
11721                G_STRLOC,
11722                G_OBJECT_TYPE_NAME (widget),
11723                property_name);
11724   else
11725     {
11726       GtkStyleContext *context;
11727       const GValue *peek_value;
11728       GtkStateFlags state;
11729
11730       context = gtk_widget_get_style_context (widget);
11731       state = gtk_widget_get_state_flags (widget);
11732
11733       peek_value = _gtk_style_context_peek_style_property (context,
11734                                                            G_OBJECT_TYPE (widget),
11735                                                            state, pspec);
11736
11737       /* auto-conversion of the caller's value type
11738        */
11739       if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
11740         g_value_copy (peek_value, value);
11741       else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
11742         g_value_transform (peek_value, value);
11743       else
11744         g_warning ("can't retrieve style property `%s' of type `%s' as value of type `%s'",
11745                    pspec->name,
11746                    g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
11747                    G_VALUE_TYPE_NAME (value));
11748     }
11749   g_object_unref (widget);
11750 }
11751
11752 /**
11753  * gtk_widget_style_get_valist:
11754  * @widget: a #GtkWidget
11755  * @first_property_name: the name of the first property to get
11756  * @var_args: a <type>va_list</type> of pairs of property names and
11757  *     locations to return the property values, starting with the location
11758  *     for @first_property_name.
11759  *
11760  * Non-vararg variant of gtk_widget_style_get(). Used primarily by language
11761  * bindings.
11762  */
11763 void
11764 gtk_widget_style_get_valist (GtkWidget   *widget,
11765                              const gchar *first_property_name,
11766                              va_list      var_args)
11767 {
11768   GtkStyleContext *context;
11769   GtkStateFlags state;
11770   const gchar *name;
11771
11772   g_return_if_fail (GTK_IS_WIDGET (widget));
11773
11774   g_object_ref (widget);
11775   context = gtk_widget_get_style_context (widget);
11776   state = gtk_widget_get_state_flags (widget);
11777
11778   name = first_property_name;
11779   while (name)
11780     {
11781       const GValue *peek_value;
11782       GParamSpec *pspec;
11783       gchar *error;
11784
11785       pspec = g_param_spec_pool_lookup (style_property_spec_pool,
11786                                         name,
11787                                         G_OBJECT_TYPE (widget),
11788                                         TRUE);
11789       if (!pspec)
11790         {
11791           g_warning ("%s: widget class `%s' has no property named `%s'",
11792                      G_STRLOC,
11793                      G_OBJECT_TYPE_NAME (widget),
11794                      name);
11795           break;
11796         }
11797       /* style pspecs are always readable so we can spare that check here */
11798
11799       peek_value = _gtk_style_context_peek_style_property (context,
11800                                                            G_OBJECT_TYPE (widget),
11801                                                            state, pspec);
11802
11803       G_VALUE_LCOPY (peek_value, var_args, 0, &error);
11804       if (error)
11805         {
11806           g_warning ("%s: %s", G_STRLOC, error);
11807           g_free (error);
11808           break;
11809         }
11810
11811       name = va_arg (var_args, gchar*);
11812     }
11813
11814   g_object_unref (widget);
11815 }
11816
11817 /**
11818  * gtk_widget_style_get:
11819  * @widget: a #GtkWidget
11820  * @first_property_name: the name of the first property to get
11821  * @...: pairs of property names and locations to return the
11822  *     property values, starting with the location for
11823  *     @first_property_name, terminated by %NULL.
11824  *
11825  * Gets the values of a multiple style properties of @widget.
11826  */
11827 void
11828 gtk_widget_style_get (GtkWidget   *widget,
11829                       const gchar *first_property_name,
11830                       ...)
11831 {
11832   va_list var_args;
11833
11834   g_return_if_fail (GTK_IS_WIDGET (widget));
11835
11836   va_start (var_args, first_property_name);
11837   gtk_widget_style_get_valist (widget, first_property_name, var_args);
11838   va_end (var_args);
11839 }
11840
11841 /**
11842  * gtk_requisition_new:
11843  *
11844  * Allocates a new #GtkRequisition structure and initializes its elements to zero.
11845  *
11846  * Returns: a new empty #GtkRequisition. The newly allocated #GtkRequisition should
11847  *   be freed with gtk_requisition_free().
11848  *
11849  * Since: 3.0
11850  */
11851 GtkRequisition *
11852 gtk_requisition_new (void)
11853 {
11854   return g_slice_new0 (GtkRequisition);
11855 }
11856
11857 /**
11858  * gtk_requisition_copy:
11859  * @requisition: a #GtkRequisition
11860  *
11861  * Copies a #GtkRequisition.
11862  *
11863  * Returns: a copy of @requisition
11864  **/
11865 GtkRequisition *
11866 gtk_requisition_copy (const GtkRequisition *requisition)
11867 {
11868   return g_slice_dup (GtkRequisition, requisition);
11869 }
11870
11871 /**
11872  * gtk_requisition_free:
11873  * @requisition: a #GtkRequisition
11874  *
11875  * Frees a #GtkRequisition.
11876  **/
11877 void
11878 gtk_requisition_free (GtkRequisition *requisition)
11879 {
11880   g_slice_free (GtkRequisition, requisition);
11881 }
11882
11883 G_DEFINE_BOXED_TYPE (GtkRequisition, gtk_requisition,
11884                      gtk_requisition_copy,
11885                      gtk_requisition_free)
11886
11887 /**
11888  * gtk_widget_class_set_accessible_type:
11889  * @widget_class: class to set the accessible type for
11890  * @type: The object type that implements the accessible for @widget_class
11891  *
11892  * Sets the type to be used for creating accessibles for widgets of
11893  * @widget_class. The given @type must be a subtype of the type used for
11894  * accessibles of the parent class.
11895  *
11896  * This function should only be called from class init functions of widgets.
11897  *
11898  * Since: 3.2
11899  **/
11900 void
11901 gtk_widget_class_set_accessible_type (GtkWidgetClass *widget_class,
11902                                       GType           type)
11903 {
11904   GtkWidgetClassPrivate *priv;
11905
11906   g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
11907   g_return_if_fail (g_type_is_a (type, widget_class->priv->accessible_type));
11908
11909   priv = widget_class->priv;
11910
11911   priv->accessible_type = type;
11912   /* reset this - honoring the type's role is better. */
11913   priv->accessible_role = ATK_ROLE_INVALID;
11914 }
11915
11916 /**
11917  * gtk_widget_class_set_accessible_role:
11918  * @widget_class: class to set the accessible role for
11919  * @role: The role to use for accessibles created for @widget_class
11920  *
11921  * Sets the default #AtkRole to be set on accessibles created for
11922  * widgets of @widget_class. Accessibles may decide to not honor this
11923  * setting if their role reporting is more refined. Calls to
11924  * gtk_widget_class_set_accessible_type() will reset this value.
11925  *
11926  * In cases where you want more fine-grained control over the role of
11927  * accessibles created for @widget_class, you should provide your own
11928  * accessible type and use gtk_widget_class_set_accessible_type()
11929  * instead.
11930  *
11931  * If @role is #ATK_ROLE_INVALID, the default role will not be changed
11932  * and the accessible's default role will be used instead.
11933  *
11934  * This function should only be called from class init functions of widgets.
11935  *
11936  * Since: 3.2
11937  **/
11938 void
11939 gtk_widget_class_set_accessible_role (GtkWidgetClass *widget_class,
11940                                       AtkRole         role)
11941 {
11942   GtkWidgetClassPrivate *priv;
11943
11944   g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
11945
11946   priv = widget_class->priv;
11947
11948   priv->accessible_role = role;
11949 }
11950
11951 /**
11952  * _gtk_widget_peek_accessible:
11953  * @widget: a #GtkWidget
11954  *
11955  * Gets the accessible for @widget, if it has been created yet.
11956  * Otherwise, this function returns %NULL. If the @widget's implementation
11957  * does not use the default way to create accessibles, %NULL will always be
11958  * returned.
11959  *
11960  * Returns: the accessible for @widget or %NULL if none has been
11961  *     created yet.
11962  **/
11963 AtkObject *
11964 _gtk_widget_peek_accessible (GtkWidget *widget)
11965 {
11966   return g_object_get_qdata (G_OBJECT (widget),
11967                              quark_accessible_object);
11968 }
11969
11970 /**
11971  * gtk_widget_get_accessible:
11972  * @widget: a #GtkWidget
11973  *
11974  * Returns the accessible object that describes the widget to an
11975  * assistive technology.
11976  *
11977  * If accessibility support is not available, this #AtkObject
11978  * instance may be a no-op. Likewise, if no class-specific #AtkObject
11979  * implementation is available for the widget instance in question,
11980  * it will inherit an #AtkObject implementation from the first ancestor
11981  * class for which such an implementation is defined.
11982  *
11983  * The documentation of the
11984  * <ulink url="http://developer.gnome.org/atk/stable/">ATK</ulink>
11985  * library contains more information about accessible objects and their uses.
11986  *
11987  * Returns: (transfer none): the #AtkObject associated with @widget
11988  */
11989 AtkObject*
11990 gtk_widget_get_accessible (GtkWidget *widget)
11991 {
11992   GtkWidgetClass *klass;
11993
11994   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11995
11996   klass = GTK_WIDGET_GET_CLASS (widget);
11997
11998   g_return_val_if_fail (klass->get_accessible != NULL, NULL);
11999
12000   return klass->get_accessible (widget);
12001 }
12002
12003 static AtkObject*
12004 gtk_widget_real_get_accessible (GtkWidget *widget)
12005 {
12006   AtkObject* accessible;
12007
12008   accessible = g_object_get_qdata (G_OBJECT (widget),
12009                                    quark_accessible_object);
12010   if (!accessible)
12011   {
12012     GtkWidgetClass *widget_class;
12013     GtkWidgetClassPrivate *priv;
12014     AtkObjectFactory *factory;
12015     AtkRegistry *default_registry;
12016
12017     widget_class = GTK_WIDGET_GET_CLASS (widget);
12018     priv = widget_class->priv;
12019
12020     if (priv->accessible_type == GTK_TYPE_ACCESSIBLE)
12021       {
12022         default_registry = atk_get_default_registry ();
12023         factory = atk_registry_get_factory (default_registry,
12024                                             G_TYPE_FROM_INSTANCE (widget));
12025         accessible =
12026           atk_object_factory_create_accessible (factory,
12027                                                 G_OBJECT (widget));
12028
12029         if (priv->accessible_role != ATK_ROLE_INVALID)
12030           atk_object_set_role (accessible, priv->accessible_role);
12031
12032         g_object_set_qdata (G_OBJECT (widget),
12033                             quark_accessible_object,
12034                             accessible);
12035       }
12036     else
12037       {
12038         accessible = g_object_new (priv->accessible_type,
12039                                    "widget", widget,
12040                                    NULL);
12041         if (priv->accessible_role != ATK_ROLE_INVALID)
12042           atk_object_set_role (accessible, priv->accessible_role);
12043
12044         g_object_set_qdata (G_OBJECT (widget),
12045                             quark_accessible_object,
12046                             accessible);
12047
12048         atk_object_initialize (accessible, widget);
12049
12050         /* Set the role again, since we don't want a role set
12051          * in some parent initialize() function to override
12052          * our own.
12053          */
12054         if (priv->accessible_role != ATK_ROLE_INVALID)
12055           atk_object_set_role (accessible, priv->accessible_role);
12056       }
12057   }
12058   return accessible;
12059 }
12060
12061 /*
12062  * Initialize a AtkImplementorIface instance's virtual pointers as
12063  * appropriate to this implementor's class (GtkWidget).
12064  */
12065 static void
12066 gtk_widget_accessible_interface_init (AtkImplementorIface *iface)
12067 {
12068   iface->ref_accessible = gtk_widget_ref_accessible;
12069 }
12070
12071 static AtkObject*
12072 gtk_widget_ref_accessible (AtkImplementor *implementor)
12073 {
12074   AtkObject *accessible;
12075
12076   accessible = gtk_widget_get_accessible (GTK_WIDGET (implementor));
12077   if (accessible)
12078     g_object_ref (accessible);
12079   return accessible;
12080 }
12081
12082 /*
12083  * Expand flag management
12084  */
12085
12086 static void
12087 gtk_widget_update_computed_expand (GtkWidget *widget)
12088 {
12089   GtkWidgetPrivate *priv;
12090
12091   priv = widget->priv;
12092
12093   if (priv->need_compute_expand)
12094     {
12095       gboolean h, v;
12096
12097       if (priv->hexpand_set)
12098         h = priv->hexpand;
12099       else
12100         h = FALSE;
12101
12102       if (priv->vexpand_set)
12103         v = priv->vexpand;
12104       else
12105         v = FALSE;
12106
12107       /* we don't need to use compute_expand if both expands are
12108        * forced by the app
12109        */
12110       if (!(priv->hexpand_set && priv->vexpand_set))
12111         {
12112           if (GTK_WIDGET_GET_CLASS (widget)->compute_expand != NULL)
12113             {
12114               gboolean ignored;
12115
12116               GTK_WIDGET_GET_CLASS (widget)->compute_expand (widget,
12117                                                              priv->hexpand_set ? &ignored : &h,
12118                                                              priv->vexpand_set ? &ignored : &v);
12119             }
12120         }
12121
12122       priv->need_compute_expand = FALSE;
12123       priv->computed_hexpand = h != FALSE;
12124       priv->computed_vexpand = v != FALSE;
12125     }
12126 }
12127
12128 /**
12129  * gtk_widget_queue_compute_expand:
12130  * @widget: a #GtkWidget
12131  *
12132  * Mark @widget as needing to recompute its expand flags. Call
12133  * this function when setting legacy expand child properties
12134  * on the child of a container.
12135  *
12136  * See gtk_widget_compute_expand().
12137  */
12138 void
12139 gtk_widget_queue_compute_expand (GtkWidget *widget)
12140 {
12141   GtkWidget *parent;
12142   gboolean changed_anything;
12143
12144   if (widget->priv->need_compute_expand)
12145     return;
12146
12147   changed_anything = FALSE;
12148   parent = widget;
12149   while (parent != NULL)
12150     {
12151       if (!parent->priv->need_compute_expand)
12152         {
12153           parent->priv->need_compute_expand = TRUE;
12154           changed_anything = TRUE;
12155         }
12156
12157       /* Note: if we had an invariant that "if a child needs to
12158        * compute expand, its parents also do" then we could stop going
12159        * up when we got to a parent that already needed to
12160        * compute. However, in general we compute expand lazily (as
12161        * soon as we see something in a subtree that is expand, we know
12162        * we're expanding) and so this invariant does not hold and we
12163        * have to always walk all the way up in case some ancestor
12164        * is not currently need_compute_expand.
12165        */
12166
12167       parent = parent->priv->parent;
12168     }
12169
12170   /* recomputing expand always requires
12171    * a relayout as well
12172    */
12173   if (changed_anything)
12174     gtk_widget_queue_resize (widget);
12175 }
12176
12177 /**
12178  * gtk_widget_compute_expand:
12179  * @widget: the widget
12180  * @orientation: expand direction
12181  *
12182  * Computes whether a container should give this widget extra space
12183  * when possible. Containers should check this, rather than
12184  * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
12185  *
12186  * This function already checks whether the widget is visible, so
12187  * visibility does not need to be checked separately. Non-visible
12188  * widgets are not expanded.
12189  *
12190  * The computed expand value uses either the expand setting explicitly
12191  * set on the widget itself, or, if none has been explicitly set,
12192  * the widget may expand if some of its children do.
12193  *
12194  * Return value: whether widget tree rooted here should be expanded
12195  */
12196 gboolean
12197 gtk_widget_compute_expand (GtkWidget     *widget,
12198                            GtkOrientation orientation)
12199 {
12200   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12201
12202   /* We never make a widget expand if not even showing. */
12203   if (!gtk_widget_get_visible (widget))
12204     return FALSE;
12205
12206   gtk_widget_update_computed_expand (widget);
12207
12208   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12209     {
12210       return widget->priv->computed_hexpand;
12211     }
12212   else
12213     {
12214       return widget->priv->computed_vexpand;
12215     }
12216 }
12217
12218 static void
12219 gtk_widget_set_expand (GtkWidget     *widget,
12220                        GtkOrientation orientation,
12221                        gboolean       expand)
12222 {
12223   const char *expand_prop;
12224   const char *expand_set_prop;
12225   gboolean was_both;
12226   GtkWidgetPrivate *priv;
12227
12228   g_return_if_fail (GTK_IS_WIDGET (widget));
12229
12230   priv = widget->priv;
12231
12232   expand = expand != FALSE;
12233
12234   was_both = priv->hexpand && priv->vexpand;
12235
12236   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12237     {
12238       if (priv->hexpand_set &&
12239           priv->hexpand == expand)
12240         return;
12241
12242       priv->hexpand_set = TRUE;
12243       priv->hexpand = expand;
12244
12245       expand_prop = "hexpand";
12246       expand_set_prop = "hexpand-set";
12247     }
12248   else
12249     {
12250       if (priv->vexpand_set &&
12251           priv->vexpand == expand)
12252         return;
12253
12254       priv->vexpand_set = TRUE;
12255       priv->vexpand = expand;
12256
12257       expand_prop = "vexpand";
12258       expand_set_prop = "vexpand-set";
12259     }
12260
12261   gtk_widget_queue_compute_expand (widget);
12262
12263   g_object_freeze_notify (G_OBJECT (widget));
12264   g_object_notify (G_OBJECT (widget), expand_prop);
12265   g_object_notify (G_OBJECT (widget), expand_set_prop);
12266   if (was_both != (priv->hexpand && priv->vexpand))
12267     g_object_notify (G_OBJECT (widget), "expand");
12268   g_object_thaw_notify (G_OBJECT (widget));
12269 }
12270
12271 static void
12272 gtk_widget_set_expand_set (GtkWidget      *widget,
12273                            GtkOrientation  orientation,
12274                            gboolean        set)
12275 {
12276   GtkWidgetPrivate *priv;
12277   const char *prop;
12278
12279   priv = widget->priv;
12280
12281   set = set != FALSE;
12282
12283   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12284     {
12285       if (set == priv->hexpand_set)
12286         return;
12287
12288       priv->hexpand_set = set;
12289       prop = "hexpand-set";
12290     }
12291   else
12292     {
12293       if (set == priv->vexpand_set)
12294         return;
12295
12296       priv->vexpand_set = set;
12297       prop = "vexpand-set";
12298     }
12299
12300   gtk_widget_queue_compute_expand (widget);
12301
12302   g_object_notify (G_OBJECT (widget), prop);
12303 }
12304
12305 /**
12306  * gtk_widget_get_hexpand:
12307  * @widget: the widget
12308  *
12309  * Gets whether the widget would like any available extra horizontal
12310  * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
12311  * generally receive the extra space. For example, a list or
12312  * scrollable area or document in your window would often be set to
12313  * expand.
12314  *
12315  * Containers should use gtk_widget_compute_expand() rather than
12316  * this function, to see whether a widget, or any of its children,
12317  * has the expand flag set. If any child of a widget wants to
12318  * expand, the parent may ask to expand also.
12319  *
12320  * This function only looks at the widget's own hexpand flag, rather
12321  * than computing whether the entire widget tree rooted at this widget
12322  * wants to expand.
12323  *
12324  * Return value: whether hexpand flag is set
12325  */
12326 gboolean
12327 gtk_widget_get_hexpand (GtkWidget *widget)
12328 {
12329   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12330
12331   return widget->priv->hexpand;
12332 }
12333
12334 /**
12335  * gtk_widget_set_hexpand:
12336  * @widget: the widget
12337  * @expand: whether to expand
12338  *
12339  * Sets whether the widget would like any available extra horizontal
12340  * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
12341  * generally receive the extra space. For example, a list or
12342  * scrollable area or document in your window would often be set to
12343  * expand.
12344  *
12345  * Call this function to set the expand flag if you would like your
12346  * widget to become larger horizontally when the window has extra
12347  * room.
12348  *
12349  * By default, widgets automatically expand if any of their children
12350  * want to expand. (To see if a widget will automatically expand given
12351  * its current children and state, call gtk_widget_compute_expand(). A
12352  * container can decide how the expandability of children affects the
12353  * expansion of the container by overriding the compute_expand virtual
12354  * method on #GtkWidget.).
12355  *
12356  * Setting hexpand explicitly with this function will override the
12357  * automatic expand behavior.
12358  *
12359  * This function forces the widget to expand or not to expand,
12360  * regardless of children.  The override occurs because
12361  * gtk_widget_set_hexpand() sets the hexpand-set property (see
12362  * gtk_widget_set_hexpand_set()) which causes the widget's hexpand
12363  * value to be used, rather than looking at children and widget state.
12364  */
12365 void
12366 gtk_widget_set_hexpand (GtkWidget      *widget,
12367                         gboolean        expand)
12368 {
12369   g_return_if_fail (GTK_IS_WIDGET (widget));
12370
12371   gtk_widget_set_expand (widget, GTK_ORIENTATION_HORIZONTAL, expand);
12372 }
12373
12374 /**
12375  * gtk_widget_get_hexpand_set:
12376  * @widget: the widget
12377  *
12378  * Gets whether gtk_widget_set_hexpand() has been used to
12379  * explicitly set the expand flag on this widget.
12380  *
12381  * If hexpand is set, then it overrides any computed
12382  * expand value based on child widgets. If hexpand is not
12383  * set, then the expand value depends on whether any
12384  * children of the widget would like to expand.
12385  *
12386  * There are few reasons to use this function, but it's here
12387  * for completeness and consistency.
12388  *
12389  * Return value: whether hexpand has been explicitly set
12390  */
12391 gboolean
12392 gtk_widget_get_hexpand_set (GtkWidget      *widget)
12393 {
12394   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12395
12396   return widget->priv->hexpand_set;
12397 }
12398
12399 /**
12400  * gtk_widget_set_hexpand_set:
12401  * @widget: the widget
12402  * @set: value for hexpand-set property
12403  *
12404  * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
12405  * be used.
12406  *
12407  * The hexpand-set property will be set automatically when you call
12408  * gtk_widget_set_hexpand() to set hexpand, so the most likely
12409  * reason to use this function would be to unset an explicit expand
12410  * flag.
12411  *
12412  * If hexpand is set, then it overrides any computed
12413  * expand value based on child widgets. If hexpand is not
12414  * set, then the expand value depends on whether any
12415  * children of the widget would like to expand.
12416  *
12417  * There are few reasons to use this function, but it's here
12418  * for completeness and consistency.
12419  */
12420 void
12421 gtk_widget_set_hexpand_set (GtkWidget      *widget,
12422                             gboolean        set)
12423 {
12424   g_return_if_fail (GTK_IS_WIDGET (widget));
12425
12426   gtk_widget_set_expand_set (widget, GTK_ORIENTATION_HORIZONTAL, set);
12427 }
12428
12429
12430 /**
12431  * gtk_widget_get_vexpand:
12432  * @widget: the widget
12433  *
12434  * Gets whether the widget would like any available extra vertical
12435  * space.
12436  *
12437  * See gtk_widget_get_hexpand() for more detail.
12438  *
12439  * Return value: whether vexpand flag is set
12440  */
12441 gboolean
12442 gtk_widget_get_vexpand (GtkWidget *widget)
12443 {
12444   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12445
12446   return widget->priv->vexpand;
12447 }
12448
12449 /**
12450  * gtk_widget_set_vexpand:
12451  * @widget: the widget
12452  * @expand: whether to expand
12453  *
12454  * Sets whether the widget would like any available extra vertical
12455  * space.
12456  *
12457  * See gtk_widget_set_hexpand() for more detail.
12458  */
12459 void
12460 gtk_widget_set_vexpand (GtkWidget      *widget,
12461                         gboolean        expand)
12462 {
12463   g_return_if_fail (GTK_IS_WIDGET (widget));
12464
12465   gtk_widget_set_expand (widget, GTK_ORIENTATION_VERTICAL, expand);
12466 }
12467
12468 /**
12469  * gtk_widget_get_vexpand_set:
12470  * @widget: the widget
12471  *
12472  * Gets whether gtk_widget_set_vexpand() has been used to
12473  * explicitly set the expand flag on this widget.
12474  *
12475  * See gtk_widget_get_hexpand_set() for more detail.
12476  *
12477  * Return value: whether vexpand has been explicitly set
12478  */
12479 gboolean
12480 gtk_widget_get_vexpand_set (GtkWidget      *widget)
12481 {
12482   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12483
12484   return widget->priv->vexpand_set;
12485 }
12486
12487 /**
12488  * gtk_widget_set_vexpand_set:
12489  * @widget: the widget
12490  * @set: value for vexpand-set property
12491  *
12492  * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
12493  * be used.
12494  *
12495  * See gtk_widget_set_hexpand_set() for more detail.
12496  */
12497 void
12498 gtk_widget_set_vexpand_set (GtkWidget      *widget,
12499                             gboolean        set)
12500 {
12501   g_return_if_fail (GTK_IS_WIDGET (widget));
12502
12503   gtk_widget_set_expand_set (widget, GTK_ORIENTATION_VERTICAL, set);
12504 }
12505
12506 /*
12507  * GtkBuildable implementation
12508  */
12509 static GQuark            quark_builder_has_default = 0;
12510 static GQuark            quark_builder_has_focus = 0;
12511 static GQuark            quark_builder_atk_relations = 0;
12512 static GQuark            quark_builder_set_name = 0;
12513
12514 static void
12515 gtk_widget_buildable_interface_init (GtkBuildableIface *iface)
12516 {
12517   quark_builder_has_default = g_quark_from_static_string ("gtk-builder-has-default");
12518   quark_builder_has_focus = g_quark_from_static_string ("gtk-builder-has-focus");
12519   quark_builder_atk_relations = g_quark_from_static_string ("gtk-builder-atk-relations");
12520   quark_builder_set_name = g_quark_from_static_string ("gtk-builder-set-name");
12521
12522   iface->set_name = gtk_widget_buildable_set_name;
12523   iface->get_name = gtk_widget_buildable_get_name;
12524   iface->get_internal_child = gtk_widget_buildable_get_internal_child;
12525   iface->set_buildable_property = gtk_widget_buildable_set_buildable_property;
12526   iface->parser_finished = gtk_widget_buildable_parser_finished;
12527   iface->custom_tag_start = gtk_widget_buildable_custom_tag_start;
12528   iface->custom_finished = gtk_widget_buildable_custom_finished;
12529 }
12530
12531 static void
12532 gtk_widget_buildable_set_name (GtkBuildable *buildable,
12533                                const gchar  *name)
12534 {
12535   g_object_set_qdata_full (G_OBJECT (buildable), quark_builder_set_name,
12536                            g_strdup (name), g_free);
12537 }
12538
12539 static const gchar *
12540 gtk_widget_buildable_get_name (GtkBuildable *buildable)
12541 {
12542   return g_object_get_qdata (G_OBJECT (buildable), quark_builder_set_name);
12543 }
12544
12545 static GObject *
12546 gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,
12547                                          GtkBuilder   *builder,
12548                                          const gchar  *childname)
12549 {
12550   if (strcmp (childname, "accessible") == 0)
12551     return G_OBJECT (gtk_widget_get_accessible (GTK_WIDGET (buildable)));
12552
12553   return NULL;
12554 }
12555
12556 static void
12557 gtk_widget_buildable_set_buildable_property (GtkBuildable *buildable,
12558                                              GtkBuilder   *builder,
12559                                              const gchar  *name,
12560                                              const GValue *value)
12561 {
12562   if (strcmp (name, "has-default") == 0 && g_value_get_boolean (value))
12563       g_object_set_qdata (G_OBJECT (buildable), quark_builder_has_default,
12564                           GINT_TO_POINTER (TRUE));
12565   else if (strcmp (name, "has-focus") == 0 && g_value_get_boolean (value))
12566       g_object_set_qdata (G_OBJECT (buildable), quark_builder_has_focus,
12567                           GINT_TO_POINTER (TRUE));
12568   else
12569     g_object_set_property (G_OBJECT (buildable), name, value);
12570 }
12571
12572 typedef struct
12573 {
12574   gchar *action_name;
12575   GString *description;
12576   gchar *context;
12577   gboolean translatable;
12578 } AtkActionData;
12579
12580 typedef struct
12581 {
12582   gchar *target;
12583   gchar *type;
12584 } AtkRelationData;
12585
12586 static void
12587 free_action (AtkActionData *data, gpointer user_data)
12588 {
12589   g_free (data->action_name);
12590   g_string_free (data->description, TRUE);
12591   g_free (data->context);
12592   g_slice_free (AtkActionData, data);
12593 }
12594
12595 static void
12596 free_relation (AtkRelationData *data, gpointer user_data)
12597 {
12598   g_free (data->target);
12599   g_free (data->type);
12600   g_slice_free (AtkRelationData, data);
12601 }
12602
12603 static void
12604 gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
12605                                       GtkBuilder   *builder)
12606 {
12607   GSList *atk_relations;
12608
12609   if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_default))
12610     gtk_widget_grab_default (GTK_WIDGET (buildable));
12611   if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_focus))
12612     gtk_widget_grab_focus (GTK_WIDGET (buildable));
12613
12614   atk_relations = g_object_get_qdata (G_OBJECT (buildable),
12615                                       quark_builder_atk_relations);
12616   if (atk_relations)
12617     {
12618       AtkObject *accessible;
12619       AtkRelationSet *relation_set;
12620       GSList *l;
12621       GObject *target;
12622       AtkRelationType relation_type;
12623       AtkObject *target_accessible;
12624
12625       accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
12626       relation_set = atk_object_ref_relation_set (accessible);
12627
12628       for (l = atk_relations; l; l = l->next)
12629         {
12630           AtkRelationData *relation = (AtkRelationData*)l->data;
12631
12632           target = gtk_builder_get_object (builder, relation->target);
12633           if (!target)
12634             {
12635               g_warning ("Target object %s in <relation> does not exist",
12636                          relation->target);
12637               continue;
12638             }
12639           target_accessible = gtk_widget_get_accessible (GTK_WIDGET (target));
12640           g_assert (target_accessible != NULL);
12641
12642           relation_type = atk_relation_type_for_name (relation->type);
12643           if (relation_type == ATK_RELATION_NULL)
12644             {
12645               g_warning ("<relation> type %s not found",
12646                          relation->type);
12647               continue;
12648             }
12649           atk_relation_set_add_relation_by_type (relation_set, relation_type,
12650                                                  target_accessible);
12651         }
12652       g_object_unref (relation_set);
12653
12654       g_slist_free_full (atk_relations, (GDestroyNotify) free_relation);
12655       g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
12656                           NULL);
12657     }
12658 }
12659
12660 typedef struct
12661 {
12662   GSList *actions;
12663   GSList *relations;
12664 } AccessibilitySubParserData;
12665
12666 static void
12667 accessibility_start_element (GMarkupParseContext  *context,
12668                              const gchar          *element_name,
12669                              const gchar         **names,
12670                              const gchar         **values,
12671                              gpointer              user_data,
12672                              GError              **error)
12673 {
12674   AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
12675   guint i;
12676   gint line_number, char_number;
12677
12678   if (strcmp (element_name, "relation") == 0)
12679     {
12680       gchar *target = NULL;
12681       gchar *type = NULL;
12682       AtkRelationData *relation;
12683
12684       for (i = 0; names[i]; i++)
12685         {
12686           if (strcmp (names[i], "target") == 0)
12687             target = g_strdup (values[i]);
12688           else if (strcmp (names[i], "type") == 0)
12689             type = g_strdup (values[i]);
12690           else
12691             {
12692               g_markup_parse_context_get_position (context,
12693                                                    &line_number,
12694                                                    &char_number);
12695               g_set_error (error,
12696                            GTK_BUILDER_ERROR,
12697                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
12698                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
12699                            "<input>",
12700                            line_number, char_number, names[i], "relation");
12701               g_free (target);
12702               g_free (type);
12703               return;
12704             }
12705         }
12706
12707       if (!target || !type)
12708         {
12709           g_markup_parse_context_get_position (context,
12710                                                &line_number,
12711                                                &char_number);
12712           g_set_error (error,
12713                        GTK_BUILDER_ERROR,
12714                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
12715                        "%s:%d:%d <%s> requires attribute \"%s\"",
12716                        "<input>",
12717                        line_number, char_number, "relation",
12718                        type ? "target" : "type");
12719           g_free (target);
12720           g_free (type);
12721           return;
12722         }
12723
12724       relation = g_slice_new (AtkRelationData);
12725       relation->target = target;
12726       relation->type = type;
12727
12728       data->relations = g_slist_prepend (data->relations, relation);
12729     }
12730   else if (strcmp (element_name, "action") == 0)
12731     {
12732       const gchar *action_name = NULL;
12733       const gchar *description = NULL;
12734       const gchar *msg_context = NULL;
12735       gboolean translatable = FALSE;
12736       AtkActionData *action;
12737
12738       for (i = 0; names[i]; i++)
12739         {
12740           if (strcmp (names[i], "action_name") == 0)
12741             action_name = values[i];
12742           else if (strcmp (names[i], "description") == 0)
12743             description = values[i];
12744           else if (strcmp (names[i], "translatable") == 0)
12745             {
12746               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
12747                 return;
12748             }
12749           else if (strcmp (names[i], "comments") == 0)
12750             {
12751               /* do nothing, comments are for translators */
12752             }
12753           else if (strcmp (names[i], "context") == 0)
12754             msg_context = values[i];
12755           else
12756             {
12757               g_markup_parse_context_get_position (context,
12758                                                    &line_number,
12759                                                    &char_number);
12760               g_set_error (error,
12761                            GTK_BUILDER_ERROR,
12762                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
12763                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
12764                            "<input>",
12765                            line_number, char_number, names[i], "action");
12766               return;
12767             }
12768         }
12769
12770       if (!action_name)
12771         {
12772           g_markup_parse_context_get_position (context,
12773                                                &line_number,
12774                                                &char_number);
12775           g_set_error (error,
12776                        GTK_BUILDER_ERROR,
12777                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
12778                        "%s:%d:%d <%s> requires attribute \"%s\"",
12779                        "<input>",
12780                        line_number, char_number, "action",
12781                        "action_name");
12782           return;
12783         }
12784
12785       action = g_slice_new (AtkActionData);
12786       action->action_name = g_strdup (action_name);
12787       action->description = g_string_new (description);
12788       action->context = g_strdup (msg_context);
12789       action->translatable = translatable;
12790
12791       data->actions = g_slist_prepend (data->actions, action);
12792     }
12793   else if (strcmp (element_name, "accessibility") == 0)
12794     ;
12795   else
12796     g_warning ("Unsupported tag for GtkWidget: %s\n", element_name);
12797 }
12798
12799 static void
12800 accessibility_text (GMarkupParseContext  *context,
12801                     const gchar          *text,
12802                     gsize                 text_len,
12803                     gpointer              user_data,
12804                     GError              **error)
12805 {
12806   AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
12807
12808   if (strcmp (g_markup_parse_context_get_element (context), "action") == 0)
12809     {
12810       AtkActionData *action = data->actions->data;
12811
12812       g_string_append_len (action->description, text, text_len);
12813     }
12814 }
12815
12816 static const GMarkupParser accessibility_parser =
12817   {
12818     accessibility_start_element,
12819     NULL,
12820     accessibility_text,
12821   };
12822
12823 typedef struct
12824 {
12825   GObject *object;
12826   guint    key;
12827   guint    modifiers;
12828   gchar   *signal;
12829 } AccelGroupParserData;
12830
12831 static void
12832 accel_group_start_element (GMarkupParseContext  *context,
12833                            const gchar          *element_name,
12834                            const gchar         **names,
12835                            const gchar         **values,
12836                            gpointer              user_data,
12837                            GError              **error)
12838 {
12839   gint i;
12840   guint key = 0;
12841   guint modifiers = 0;
12842   gchar *signal = NULL;
12843   AccelGroupParserData *parser_data = (AccelGroupParserData*)user_data;
12844
12845   for (i = 0; names[i]; i++)
12846     {
12847       if (strcmp (names[i], "key") == 0)
12848         key = gdk_keyval_from_name (values[i]);
12849       else if (strcmp (names[i], "modifiers") == 0)
12850         {
12851           if (!_gtk_builder_flags_from_string (GDK_TYPE_MODIFIER_TYPE,
12852                                                values[i],
12853                                                &modifiers,
12854                                                error))
12855               return;
12856         }
12857       else if (strcmp (names[i], "signal") == 0)
12858         signal = g_strdup (values[i]);
12859     }
12860
12861   if (key == 0 || signal == NULL)
12862     {
12863       g_warning ("<accelerator> requires key and signal attributes");
12864       return;
12865     }
12866   parser_data->key = key;
12867   parser_data->modifiers = modifiers;
12868   parser_data->signal = signal;
12869 }
12870
12871 static const GMarkupParser accel_group_parser =
12872   {
12873     accel_group_start_element,
12874   };
12875
12876 typedef struct
12877 {
12878   GSList *classes;
12879 } StyleParserData;
12880
12881 static void
12882 style_start_element (GMarkupParseContext  *context,
12883                      const gchar          *element_name,
12884                      const gchar         **names,
12885                      const gchar         **values,
12886                      gpointer              user_data,
12887                      GError              **error)
12888 {
12889   StyleParserData *style_data = (StyleParserData *)user_data;
12890   gchar *class_name;
12891
12892   if (strcmp (element_name, "class") == 0)
12893     {
12894       if (g_markup_collect_attributes (element_name,
12895                                        names,
12896                                        values,
12897                                        error,
12898                                        G_MARKUP_COLLECT_STRDUP, "name", &class_name,
12899                                        G_MARKUP_COLLECT_INVALID))
12900         {
12901           style_data->classes = g_slist_append (style_data->classes, class_name);
12902         }
12903     }
12904   else if (strcmp (element_name, "style") == 0)
12905     ;
12906   else
12907     g_warning ("Unsupported tag for GtkWidget: %s\n", element_name);
12908 }
12909
12910 static const GMarkupParser style_parser =
12911   {
12912     style_start_element,
12913   };
12914
12915 static gboolean
12916 gtk_widget_buildable_custom_tag_start (GtkBuildable     *buildable,
12917                                        GtkBuilder       *builder,
12918                                        GObject          *child,
12919                                        const gchar      *tagname,
12920                                        GMarkupParser    *parser,
12921                                        gpointer         *data)
12922 {
12923   g_assert (buildable);
12924
12925   if (strcmp (tagname, "accelerator") == 0)
12926     {
12927       AccelGroupParserData *parser_data;
12928
12929       parser_data = g_slice_new0 (AccelGroupParserData);
12930       parser_data->object = g_object_ref (buildable);
12931       *parser = accel_group_parser;
12932       *data = parser_data;
12933       return TRUE;
12934     }
12935   if (strcmp (tagname, "accessibility") == 0)
12936     {
12937       AccessibilitySubParserData *parser_data;
12938
12939       parser_data = g_slice_new0 (AccessibilitySubParserData);
12940       *parser = accessibility_parser;
12941       *data = parser_data;
12942       return TRUE;
12943     }
12944   if (strcmp (tagname, "style") == 0)
12945     {
12946       StyleParserData *parser_data;
12947
12948       parser_data = g_slice_new0 (StyleParserData);
12949       *parser = style_parser;
12950       *data = parser_data;
12951       return TRUE;
12952     }
12953
12954   return FALSE;
12955 }
12956
12957 void
12958 _gtk_widget_buildable_finish_accelerator (GtkWidget *widget,
12959                                           GtkWidget *toplevel,
12960                                           gpointer   user_data)
12961 {
12962   AccelGroupParserData *accel_data;
12963   GSList *accel_groups;
12964   GtkAccelGroup *accel_group;
12965
12966   g_return_if_fail (GTK_IS_WIDGET (widget));
12967   g_return_if_fail (GTK_IS_WIDGET (toplevel));
12968   g_return_if_fail (user_data != NULL);
12969
12970   accel_data = (AccelGroupParserData*)user_data;
12971   accel_groups = gtk_accel_groups_from_object (G_OBJECT (toplevel));
12972   if (g_slist_length (accel_groups) == 0)
12973     {
12974       accel_group = gtk_accel_group_new ();
12975       gtk_window_add_accel_group (GTK_WINDOW (toplevel), accel_group);
12976     }
12977   else
12978     {
12979       g_assert (g_slist_length (accel_groups) == 1);
12980       accel_group = g_slist_nth_data (accel_groups, 0);
12981     }
12982
12983   gtk_widget_add_accelerator (GTK_WIDGET (accel_data->object),
12984                               accel_data->signal,
12985                               accel_group,
12986                               accel_data->key,
12987                               accel_data->modifiers,
12988                               GTK_ACCEL_VISIBLE);
12989
12990   g_object_unref (accel_data->object);
12991   g_free (accel_data->signal);
12992   g_slice_free (AccelGroupParserData, accel_data);
12993 }
12994
12995 static void
12996 gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
12997                                       GtkBuilder   *builder,
12998                                       GObject      *child,
12999                                       const gchar  *tagname,
13000                                       gpointer      user_data)
13001 {
13002   if (strcmp (tagname, "accelerator") == 0)
13003     {
13004       AccelGroupParserData *accel_data;
13005       GtkWidget *toplevel;
13006
13007       accel_data = (AccelGroupParserData*)user_data;
13008       g_assert (accel_data->object);
13009
13010       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (accel_data->object));
13011
13012       _gtk_widget_buildable_finish_accelerator (GTK_WIDGET (buildable), toplevel, user_data);
13013     }
13014   else if (strcmp (tagname, "accessibility") == 0)
13015     {
13016       AccessibilitySubParserData *a11y_data;
13017
13018       a11y_data = (AccessibilitySubParserData*)user_data;
13019
13020       if (a11y_data->actions)
13021         {
13022           AtkObject *accessible;
13023           AtkAction *action;
13024           gint i, n_actions;
13025           GSList *l;
13026
13027           accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
13028
13029           if (ATK_IS_ACTION (accessible))
13030             {
13031               action = ATK_ACTION (accessible);
13032               n_actions = atk_action_get_n_actions (action);
13033
13034               for (l = a11y_data->actions; l; l = l->next)
13035                 {
13036                   AtkActionData *action_data = (AtkActionData*)l->data;
13037
13038                   for (i = 0; i < n_actions; i++)
13039                     if (strcmp (atk_action_get_name (action, i),
13040                                 action_data->action_name) == 0)
13041                       break;
13042
13043                   if (i < n_actions)
13044                     {
13045                       gchar *description;
13046
13047                       if (action_data->translatable && action_data->description->len)
13048                         description = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
13049                                                                      action_data->context,
13050                                                                      action_data->description->str);
13051                       else
13052                         description = action_data->description->str;
13053
13054                       atk_action_set_description (action, i, description);
13055                     }
13056                 }
13057             }
13058           else
13059             g_warning ("accessibility action on a widget that does not implement AtkAction");
13060
13061           g_slist_free_full (a11y_data->actions, (GDestroyNotify) free_action);
13062         }
13063
13064       if (a11y_data->relations)
13065         g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
13066                             a11y_data->relations);
13067
13068       g_slice_free (AccessibilitySubParserData, a11y_data);
13069     }
13070   else if (strcmp (tagname, "style") == 0)
13071     {
13072       StyleParserData *style_data = (StyleParserData *)user_data;
13073       GtkStyleContext *context;
13074       GSList *l;
13075
13076       context = gtk_widget_get_style_context (GTK_WIDGET (buildable));
13077
13078       for (l = style_data->classes; l; l = l->next)
13079         gtk_style_context_add_class (context, (const gchar *)l->data);
13080
13081       gtk_widget_reset_style (GTK_WIDGET (buildable));
13082
13083       g_slist_free_full (style_data->classes, g_free);
13084       g_slice_free (StyleParserData, style_data);
13085     }
13086 }
13087
13088 static GtkSizeRequestMode
13089 gtk_widget_real_get_request_mode (GtkWidget *widget)
13090 {
13091   /* By default widgets dont trade size at all. */
13092   return GTK_SIZE_REQUEST_CONSTANT_SIZE;
13093 }
13094
13095 static void
13096 gtk_widget_real_get_width (GtkWidget *widget,
13097                            gint      *minimum_size,
13098                            gint      *natural_size)
13099 {
13100   if (minimum_size)
13101     *minimum_size = 0;
13102
13103   if (natural_size)
13104     *natural_size = 0;
13105 }
13106
13107 static void
13108 gtk_widget_real_get_height (GtkWidget *widget,
13109                             gint      *minimum_size,
13110                             gint      *natural_size)
13111 {
13112   if (minimum_size)
13113     *minimum_size = 0;
13114
13115   if (natural_size)
13116     *natural_size = 0;
13117 }
13118
13119 static void
13120 gtk_widget_real_get_height_for_width (GtkWidget *widget,
13121                                       gint       width,
13122                                       gint      *minimum_height,
13123                                       gint      *natural_height)
13124 {
13125   GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
13126 }
13127
13128 static void
13129 gtk_widget_real_get_width_for_height (GtkWidget *widget,
13130                                       gint       height,
13131                                       gint      *minimum_width,
13132                                       gint      *natural_width)
13133 {
13134   GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
13135 }
13136
13137 /**
13138  * gtk_widget_get_halign:
13139  * @widget: a #GtkWidget
13140  *
13141  * Gets the value of the #GtkWidget:halign property.
13142  *
13143  * Returns: the horizontal alignment of @widget
13144  */
13145 GtkAlign
13146 gtk_widget_get_halign (GtkWidget *widget)
13147 {
13148   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
13149   return _gtk_widget_get_aux_info_or_defaults (widget)->halign;
13150 }
13151
13152 /**
13153  * gtk_widget_set_halign:
13154  * @widget: a #GtkWidget
13155  * @align: the horizontal alignment
13156  *
13157  * Sets the horizontal alignment of @widget.
13158  * See the #GtkWidget:halign property.
13159  */
13160 void
13161 gtk_widget_set_halign (GtkWidget *widget,
13162                        GtkAlign   align)
13163 {
13164   GtkWidgetAuxInfo *aux_info;
13165
13166   g_return_if_fail (GTK_IS_WIDGET (widget));
13167
13168   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13169
13170   if (aux_info->halign == align)
13171     return;
13172
13173   aux_info->halign = align;
13174   gtk_widget_queue_resize (widget);
13175   g_object_notify (G_OBJECT (widget), "halign");
13176 }
13177
13178 /**
13179  * gtk_widget_get_valign:
13180  * @widget: a #GtkWidget
13181  *
13182  * Gets the value of the #GtkWidget:valign property.
13183  *
13184  * Returns: the vertical alignment of @widget
13185  */
13186 GtkAlign
13187 gtk_widget_get_valign (GtkWidget *widget)
13188 {
13189   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
13190   return _gtk_widget_get_aux_info_or_defaults (widget)->valign;
13191 }
13192
13193 /**
13194  * gtk_widget_set_valign:
13195  * @widget: a #GtkWidget
13196  * @align: the vertical alignment
13197  *
13198  * Sets the vertical alignment of @widget.
13199  * See the #GtkWidget:valign property.
13200  */
13201 void
13202 gtk_widget_set_valign (GtkWidget *widget,
13203                        GtkAlign   align)
13204 {
13205   GtkWidgetAuxInfo *aux_info;
13206
13207   g_return_if_fail (GTK_IS_WIDGET (widget));
13208
13209   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13210
13211   if (aux_info->valign == align)
13212     return;
13213
13214   aux_info->valign = align;
13215   gtk_widget_queue_resize (widget);
13216   g_object_notify (G_OBJECT (widget), "valign");
13217 }
13218
13219 /**
13220  * gtk_widget_get_margin_left:
13221  * @widget: a #GtkWidget
13222  *
13223  * Gets the value of the #GtkWidget:margin-left property.
13224  *
13225  * Returns: The left margin of @widget
13226  *
13227  * Since: 3.0
13228  */
13229 gint
13230 gtk_widget_get_margin_left (GtkWidget *widget)
13231 {
13232   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13233
13234   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.left;
13235 }
13236
13237 /**
13238  * gtk_widget_set_margin_left:
13239  * @widget: a #GtkWidget
13240  * @margin: the left margin
13241  *
13242  * Sets the left margin of @widget.
13243  * See the #GtkWidget:margin-left property.
13244  *
13245  * Since: 3.0
13246  */
13247 void
13248 gtk_widget_set_margin_left (GtkWidget *widget,
13249                             gint       margin)
13250 {
13251   GtkWidgetAuxInfo *aux_info;
13252
13253   g_return_if_fail (GTK_IS_WIDGET (widget));
13254   g_return_if_fail (margin <= G_MAXINT16);
13255
13256   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13257
13258   if (aux_info->margin.left == margin)
13259     return;
13260
13261   aux_info->margin.left = margin;
13262   gtk_widget_queue_resize (widget);
13263   g_object_notify (G_OBJECT (widget), "margin-left");
13264 }
13265
13266 /**
13267  * gtk_widget_get_margin_right:
13268  * @widget: a #GtkWidget
13269  *
13270  * Gets the value of the #GtkWidget:margin-right property.
13271  *
13272  * Returns: The right margin of @widget
13273  *
13274  * Since: 3.0
13275  */
13276 gint
13277 gtk_widget_get_margin_right (GtkWidget *widget)
13278 {
13279   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13280
13281   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.right;
13282 }
13283
13284 /**
13285  * gtk_widget_set_margin_right:
13286  * @widget: a #GtkWidget
13287  * @margin: the right margin
13288  *
13289  * Sets the right margin of @widget.
13290  * See the #GtkWidget:margin-right property.
13291  *
13292  * Since: 3.0
13293  */
13294 void
13295 gtk_widget_set_margin_right (GtkWidget *widget,
13296                              gint       margin)
13297 {
13298   GtkWidgetAuxInfo *aux_info;
13299
13300   g_return_if_fail (GTK_IS_WIDGET (widget));
13301   g_return_if_fail (margin <= G_MAXINT16);
13302
13303   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13304
13305   if (aux_info->margin.right == margin)
13306     return;
13307
13308   aux_info->margin.right = margin;
13309   gtk_widget_queue_resize (widget);
13310   g_object_notify (G_OBJECT (widget), "margin-right");
13311 }
13312
13313 /**
13314  * gtk_widget_get_margin_top:
13315  * @widget: a #GtkWidget
13316  *
13317  * Gets the value of the #GtkWidget:margin-top property.
13318  *
13319  * Returns: The top margin of @widget
13320  *
13321  * Since: 3.0
13322  */
13323 gint
13324 gtk_widget_get_margin_top (GtkWidget *widget)
13325 {
13326   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13327
13328   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.top;
13329 }
13330
13331 /**
13332  * gtk_widget_set_margin_top:
13333  * @widget: a #GtkWidget
13334  * @margin: the top margin
13335  *
13336  * Sets the top margin of @widget.
13337  * See the #GtkWidget:margin-top property.
13338  *
13339  * Since: 3.0
13340  */
13341 void
13342 gtk_widget_set_margin_top (GtkWidget *widget,
13343                            gint       margin)
13344 {
13345   GtkWidgetAuxInfo *aux_info;
13346
13347   g_return_if_fail (GTK_IS_WIDGET (widget));
13348   g_return_if_fail (margin <= G_MAXINT16);
13349
13350   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13351
13352   if (aux_info->margin.top == margin)
13353     return;
13354
13355   aux_info->margin.top = margin;
13356   gtk_widget_queue_resize (widget);
13357   g_object_notify (G_OBJECT (widget), "margin-top");
13358 }
13359
13360 /**
13361  * gtk_widget_get_margin_bottom:
13362  * @widget: a #GtkWidget
13363  *
13364  * Gets the value of the #GtkWidget:margin-bottom property.
13365  *
13366  * Returns: The bottom margin of @widget
13367  *
13368  * Since: 3.0
13369  */
13370 gint
13371 gtk_widget_get_margin_bottom (GtkWidget *widget)
13372 {
13373   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13374
13375   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.bottom;
13376 }
13377
13378 /**
13379  * gtk_widget_set_margin_bottom:
13380  * @widget: a #GtkWidget
13381  * @margin: the bottom margin
13382  *
13383  * Sets the bottom margin of @widget.
13384  * See the #GtkWidget:margin-bottom property.
13385  *
13386  * Since: 3.0
13387  */
13388 void
13389 gtk_widget_set_margin_bottom (GtkWidget *widget,
13390                               gint       margin)
13391 {
13392   GtkWidgetAuxInfo *aux_info;
13393
13394   g_return_if_fail (GTK_IS_WIDGET (widget));
13395   g_return_if_fail (margin <= G_MAXINT16);
13396
13397   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13398
13399   if (aux_info->margin.bottom == margin)
13400     return;
13401
13402   aux_info->margin.bottom = margin;
13403   gtk_widget_queue_resize (widget);
13404   g_object_notify (G_OBJECT (widget), "margin-bottom");
13405 }
13406
13407 /**
13408  * gtk_widget_get_clipboard:
13409  * @widget: a #GtkWidget
13410  * @selection: a #GdkAtom which identifies the clipboard
13411  *             to use. %GDK_SELECTION_CLIPBOARD gives the
13412  *             default clipboard. Another common value
13413  *             is %GDK_SELECTION_PRIMARY, which gives
13414  *             the primary X selection.
13415  *
13416  * Returns the clipboard object for the given selection to
13417  * be used with @widget. @widget must have a #GdkDisplay
13418  * associated with it, so must be attached to a toplevel
13419  * window.
13420  *
13421  * Return value: (transfer none): the appropriate clipboard object. If no
13422  *             clipboard already exists, a new one will
13423  *             be created. Once a clipboard object has
13424  *             been created, it is persistent for all time.
13425  *
13426  * Since: 2.2
13427  **/
13428 GtkClipboard *
13429 gtk_widget_get_clipboard (GtkWidget *widget, GdkAtom selection)
13430 {
13431   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13432   g_return_val_if_fail (gtk_widget_has_screen (widget), NULL);
13433
13434   return gtk_clipboard_get_for_display (gtk_widget_get_display (widget),
13435                                         selection);
13436 }
13437
13438 /**
13439  * gtk_widget_list_mnemonic_labels:
13440  * @widget: a #GtkWidget
13441  *
13442  * Returns a newly allocated list of the widgets, normally labels, for
13443  * which this widget is the target of a mnemonic (see for example,
13444  * gtk_label_set_mnemonic_widget()).
13445
13446  * The widgets in the list are not individually referenced. If you
13447  * want to iterate through the list and perform actions involving
13448  * callbacks that might destroy the widgets, you
13449  * <emphasis>must</emphasis> call <literal>g_list_foreach (result,
13450  * (GFunc)g_object_ref, NULL)</literal> first, and then unref all the
13451  * widgets afterwards.
13452
13453  * Return value: (element-type GtkWidget) (transfer container): the list of
13454  *  mnemonic labels; free this list
13455  *  with g_list_free() when you are done with it.
13456  *
13457  * Since: 2.4
13458  **/
13459 GList *
13460 gtk_widget_list_mnemonic_labels (GtkWidget *widget)
13461 {
13462   GList *list = NULL;
13463   GSList *l;
13464
13465   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13466
13467   for (l = g_object_get_qdata (G_OBJECT (widget), quark_mnemonic_labels); l; l = l->next)
13468     list = g_list_prepend (list, l->data);
13469
13470   return list;
13471 }
13472
13473 /**
13474  * gtk_widget_add_mnemonic_label:
13475  * @widget: a #GtkWidget
13476  * @label: a #GtkWidget that acts as a mnemonic label for @widget
13477  *
13478  * Adds a widget to the list of mnemonic labels for
13479  * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
13480  * list of mnemonic labels for the widget is cleared when the
13481  * widget is destroyed, so the caller must make sure to update
13482  * its internal state at this point as well, by using a connection
13483  * to the #GtkWidget::destroy signal or a weak notifier.
13484  *
13485  * Since: 2.4
13486  **/
13487 void
13488 gtk_widget_add_mnemonic_label (GtkWidget *widget,
13489                                GtkWidget *label)
13490 {
13491   GSList *old_list, *new_list;
13492
13493   g_return_if_fail (GTK_IS_WIDGET (widget));
13494   g_return_if_fail (GTK_IS_WIDGET (label));
13495
13496   old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
13497   new_list = g_slist_prepend (old_list, label);
13498
13499   g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
13500                            new_list, (GDestroyNotify) g_slist_free);
13501 }
13502
13503 /**
13504  * gtk_widget_remove_mnemonic_label:
13505  * @widget: a #GtkWidget
13506  * @label: a #GtkWidget that was previously set as a mnemnic label for
13507  *         @widget with gtk_widget_add_mnemonic_label().
13508  *
13509  * Removes a widget from the list of mnemonic labels for
13510  * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
13511  * must have previously been added to the list with
13512  * gtk_widget_add_mnemonic_label().
13513  *
13514  * Since: 2.4
13515  **/
13516 void
13517 gtk_widget_remove_mnemonic_label (GtkWidget *widget,
13518                                   GtkWidget *label)
13519 {
13520   GSList *old_list, *new_list;
13521
13522   g_return_if_fail (GTK_IS_WIDGET (widget));
13523   g_return_if_fail (GTK_IS_WIDGET (label));
13524
13525   old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
13526   new_list = g_slist_remove (old_list, label);
13527
13528   if (new_list)
13529     g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
13530                              new_list, (GDestroyNotify) g_slist_free);
13531 }
13532
13533 /**
13534  * gtk_widget_get_no_show_all:
13535  * @widget: a #GtkWidget
13536  *
13537  * Returns the current value of the #GtkWidget:no-show-all property,
13538  * which determines whether calls to gtk_widget_show_all()
13539  * will affect this widget.
13540  *
13541  * Return value: the current value of the "no-show-all" property.
13542  *
13543  * Since: 2.4
13544  **/
13545 gboolean
13546 gtk_widget_get_no_show_all (GtkWidget *widget)
13547 {
13548   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
13549
13550   return widget->priv->no_show_all;
13551 }
13552
13553 /**
13554  * gtk_widget_set_no_show_all:
13555  * @widget: a #GtkWidget
13556  * @no_show_all: the new value for the "no-show-all" property
13557  *
13558  * Sets the #GtkWidget:no-show-all property, which determines whether
13559  * calls to gtk_widget_show_all() will affect this widget.
13560  *
13561  * This is mostly for use in constructing widget hierarchies with externally
13562  * controlled visibility, see #GtkUIManager.
13563  *
13564  * Since: 2.4
13565  **/
13566 void
13567 gtk_widget_set_no_show_all (GtkWidget *widget,
13568                             gboolean   no_show_all)
13569 {
13570   g_return_if_fail (GTK_IS_WIDGET (widget));
13571
13572   no_show_all = (no_show_all != FALSE);
13573
13574   if (widget->priv->no_show_all != no_show_all)
13575     {
13576       widget->priv->no_show_all = no_show_all;
13577
13578       g_object_notify (G_OBJECT (widget), "no-show-all");
13579     }
13580 }
13581
13582
13583 static void
13584 gtk_widget_real_set_has_tooltip (GtkWidget *widget,
13585                                  gboolean   has_tooltip,
13586                                  gboolean   force)
13587 {
13588   GtkWidgetPrivate *priv = widget->priv;
13589   gboolean priv_has_tooltip;
13590
13591   priv_has_tooltip = GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget),
13592                                        quark_has_tooltip));
13593
13594   if (priv_has_tooltip != has_tooltip || force)
13595     {
13596       priv_has_tooltip = has_tooltip;
13597
13598       if (priv_has_tooltip)
13599         {
13600           if (gtk_widget_get_realized (widget) && !gtk_widget_get_has_window (widget))
13601             gdk_window_set_events (priv->window,
13602                                    gdk_window_get_events (priv->window) |
13603                                    GDK_LEAVE_NOTIFY_MASK |
13604                                    GDK_POINTER_MOTION_MASK |
13605                                    GDK_POINTER_MOTION_HINT_MASK);
13606
13607           if (gtk_widget_get_has_window (widget))
13608               gtk_widget_add_events (widget,
13609                                      GDK_LEAVE_NOTIFY_MASK |
13610                                      GDK_POINTER_MOTION_MASK |
13611                                      GDK_POINTER_MOTION_HINT_MASK);
13612         }
13613
13614       g_object_set_qdata (G_OBJECT (widget), quark_has_tooltip,
13615                           GUINT_TO_POINTER (priv_has_tooltip));
13616     }
13617 }
13618
13619 /**
13620  * gtk_widget_set_tooltip_window:
13621  * @widget: a #GtkWidget
13622  * @custom_window: (allow-none): a #GtkWindow, or %NULL
13623  *
13624  * Replaces the default, usually yellow, window used for displaying
13625  * tooltips with @custom_window. GTK+ will take care of showing and
13626  * hiding @custom_window at the right moment, to behave likewise as
13627  * the default tooltip window. If @custom_window is %NULL, the default
13628  * tooltip window will be used.
13629  *
13630  * If the custom window should have the default theming it needs to
13631  * have the name "gtk-tooltip", see gtk_widget_set_name().
13632  *
13633  * Since: 2.12
13634  */
13635 void
13636 gtk_widget_set_tooltip_window (GtkWidget *widget,
13637                                GtkWindow *custom_window)
13638 {
13639   gboolean has_tooltip;
13640   gchar *tooltip_markup;
13641
13642   g_return_if_fail (GTK_IS_WIDGET (widget));
13643   g_return_if_fail (custom_window == NULL || GTK_IS_WINDOW (custom_window));
13644
13645   tooltip_markup = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_markup);
13646
13647   if (custom_window)
13648     g_object_ref (custom_window);
13649
13650   g_object_set_qdata_full (G_OBJECT (widget), quark_tooltip_window,
13651                            custom_window, g_object_unref);
13652
13653   has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
13654   gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
13655
13656   if (has_tooltip && gtk_widget_get_visible (widget))
13657     gtk_widget_queue_tooltip_query (widget);
13658 }
13659
13660 /**
13661  * gtk_widget_get_tooltip_window:
13662  * @widget: a #GtkWidget
13663  *
13664  * Returns the #GtkWindow of the current tooltip. This can be the
13665  * GtkWindow created by default, or the custom tooltip window set
13666  * using gtk_widget_set_tooltip_window().
13667  *
13668  * Return value: (transfer none): The #GtkWindow of the current tooltip.
13669  *
13670  * Since: 2.12
13671  */
13672 GtkWindow *
13673 gtk_widget_get_tooltip_window (GtkWidget *widget)
13674 {
13675   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13676
13677   return g_object_get_qdata (G_OBJECT (widget), quark_tooltip_window);
13678 }
13679
13680 /**
13681  * gtk_widget_trigger_tooltip_query:
13682  * @widget: a #GtkWidget
13683  *
13684  * Triggers a tooltip query on the display where the toplevel of @widget
13685  * is located. See gtk_tooltip_trigger_tooltip_query() for more
13686  * information.
13687  *
13688  * Since: 2.12
13689  */
13690 void
13691 gtk_widget_trigger_tooltip_query (GtkWidget *widget)
13692 {
13693   gtk_tooltip_trigger_tooltip_query (gtk_widget_get_display (widget));
13694 }
13695
13696 static guint tooltip_query_id;
13697 static GSList *tooltip_query_displays;
13698
13699 static gboolean
13700 tooltip_query_idle (gpointer data)
13701 {
13702   g_slist_foreach (tooltip_query_displays, (GFunc)gtk_tooltip_trigger_tooltip_query, NULL);
13703   g_slist_foreach (tooltip_query_displays, (GFunc)g_object_unref, NULL);
13704   g_slist_free (tooltip_query_displays);
13705
13706   tooltip_query_displays = NULL;
13707   tooltip_query_id = 0;
13708
13709   return FALSE;
13710 }
13711
13712 static void
13713 gtk_widget_queue_tooltip_query (GtkWidget *widget)
13714 {
13715   GdkDisplay *display;
13716
13717   display = gtk_widget_get_display (widget);
13718
13719   if (!g_slist_find (tooltip_query_displays, display))
13720     tooltip_query_displays = g_slist_prepend (tooltip_query_displays, g_object_ref (display));
13721
13722   if (tooltip_query_id == 0)
13723     tooltip_query_id = gdk_threads_add_idle (tooltip_query_idle, NULL);
13724 }
13725
13726 /**
13727  * gtk_widget_set_tooltip_text:
13728  * @widget: a #GtkWidget
13729  * @text: (allow-none): the contents of the tooltip for @widget
13730  *
13731  * Sets @text as the contents of the tooltip. This function will take
13732  * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
13733  * handler for the #GtkWidget::query-tooltip signal.
13734  *
13735  * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
13736  *
13737  * Since: 2.12
13738  */
13739 void
13740 gtk_widget_set_tooltip_text (GtkWidget   *widget,
13741                              const gchar *text)
13742 {
13743   g_return_if_fail (GTK_IS_WIDGET (widget));
13744
13745   g_object_set (G_OBJECT (widget), "tooltip-text", text, NULL);
13746 }
13747
13748 /**
13749  * gtk_widget_get_tooltip_text:
13750  * @widget: a #GtkWidget
13751  *
13752  * Gets the contents of the tooltip for @widget.
13753  *
13754  * Return value: the tooltip text, or %NULL. You should free the
13755  *   returned string with g_free() when done.
13756  *
13757  * Since: 2.12
13758  */
13759 gchar *
13760 gtk_widget_get_tooltip_text (GtkWidget *widget)
13761 {
13762   gchar *text = NULL;
13763
13764   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13765
13766   g_object_get (G_OBJECT (widget), "tooltip-text", &text, NULL);
13767
13768   return text;
13769 }
13770
13771 /**
13772  * gtk_widget_set_tooltip_markup:
13773  * @widget: a #GtkWidget
13774  * @markup: (allow-none): the contents of the tooltip for @widget, or %NULL
13775  *
13776  * Sets @markup as the contents of the tooltip, which is marked up with
13777  *  the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
13778  *
13779  * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
13780  * and of the default handler for the #GtkWidget::query-tooltip signal.
13781  *
13782  * See also the #GtkWidget:tooltip-markup property and
13783  * gtk_tooltip_set_markup().
13784  *
13785  * Since: 2.12
13786  */
13787 void
13788 gtk_widget_set_tooltip_markup (GtkWidget   *widget,
13789                                const gchar *markup)
13790 {
13791   g_return_if_fail (GTK_IS_WIDGET (widget));
13792
13793   g_object_set (G_OBJECT (widget), "tooltip-markup", markup, NULL);
13794 }
13795
13796 /**
13797  * gtk_widget_get_tooltip_markup:
13798  * @widget: a #GtkWidget
13799  *
13800  * Gets the contents of the tooltip for @widget.
13801  *
13802  * Return value: the tooltip text, or %NULL. You should free the
13803  *   returned string with g_free() when done.
13804  *
13805  * Since: 2.12
13806  */
13807 gchar *
13808 gtk_widget_get_tooltip_markup (GtkWidget *widget)
13809 {
13810   gchar *text = NULL;
13811
13812   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13813
13814   g_object_get (G_OBJECT (widget), "tooltip-markup", &text, NULL);
13815
13816   return text;
13817 }
13818
13819 /**
13820  * gtk_widget_set_has_tooltip:
13821  * @widget: a #GtkWidget
13822  * @has_tooltip: whether or not @widget has a tooltip.
13823  *
13824  * Sets the has-tooltip property on @widget to @has_tooltip.  See
13825  * #GtkWidget:has-tooltip for more information.
13826  *
13827  * Since: 2.12
13828  */
13829 void
13830 gtk_widget_set_has_tooltip (GtkWidget *widget,
13831                             gboolean   has_tooltip)
13832 {
13833   g_return_if_fail (GTK_IS_WIDGET (widget));
13834
13835   g_object_set (G_OBJECT (widget), "has-tooltip", has_tooltip, NULL);
13836 }
13837
13838 /**
13839  * gtk_widget_get_has_tooltip:
13840  * @widget: a #GtkWidget
13841  *
13842  * Returns the current value of the has-tooltip property.  See
13843  * #GtkWidget:has-tooltip for more information.
13844  *
13845  * Return value: current value of has-tooltip on @widget.
13846  *
13847  * Since: 2.12
13848  */
13849 gboolean
13850 gtk_widget_get_has_tooltip (GtkWidget *widget)
13851 {
13852   gboolean has_tooltip = FALSE;
13853
13854   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
13855
13856   g_object_get (G_OBJECT (widget), "has-tooltip", &has_tooltip, NULL);
13857
13858   return has_tooltip;
13859 }
13860
13861 /**
13862  * gtk_widget_get_allocation:
13863  * @widget: a #GtkWidget
13864  * @allocation: (out): a pointer to a #GtkAllocation to copy to
13865  *
13866  * Retrieves the widget's allocation.
13867  *
13868  * Note, when implementing a #GtkContainer: a widget's allocation will
13869  * be its "adjusted" allocation, that is, the widget's parent
13870  * container typically calls gtk_widget_size_allocate() with an
13871  * allocation, and that allocation is then adjusted (to handle margin
13872  * and alignment for example) before assignment to the widget.
13873  * gtk_widget_get_allocation() returns the adjusted allocation that
13874  * was actually assigned to the widget. The adjusted allocation is
13875  * guaranteed to be completely contained within the
13876  * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
13877  * is guaranteed that its children stay inside the assigned bounds,
13878  * but not that they have exactly the bounds the container assigned.
13879  * There is no way to get the original allocation assigned by
13880  * gtk_widget_size_allocate(), since it isn't stored; if a container
13881  * implementation needs that information it will have to track it itself.
13882  *
13883  * Since: 2.18
13884  */
13885 void
13886 gtk_widget_get_allocation (GtkWidget     *widget,
13887                            GtkAllocation *allocation)
13888 {
13889   GtkWidgetPrivate *priv;
13890
13891   g_return_if_fail (GTK_IS_WIDGET (widget));
13892   g_return_if_fail (allocation != NULL);
13893
13894   priv = widget->priv;
13895
13896   *allocation = priv->allocation;
13897 }
13898
13899 /**
13900  * gtk_widget_set_allocation:
13901  * @widget: a #GtkWidget
13902  * @allocation: a pointer to a #GtkAllocation to copy from
13903  *
13904  * Sets the widget's allocation.  This should not be used
13905  * directly, but from within a widget's size_allocate method.
13906  *
13907  * The allocation set should be the "adjusted" or actual
13908  * allocation. If you're implementing a #GtkContainer, you want to use
13909  * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
13910  * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
13911  * allocation inside gtk_widget_size_allocate() to create an adjusted
13912  * allocation.
13913  *
13914  * Since: 2.18
13915  */
13916 void
13917 gtk_widget_set_allocation (GtkWidget           *widget,
13918                            const GtkAllocation *allocation)
13919 {
13920   GtkWidgetPrivate *priv;
13921
13922   g_return_if_fail (GTK_IS_WIDGET (widget));
13923   g_return_if_fail (gtk_widget_get_visible (widget) || gtk_widget_is_toplevel (widget));
13924   g_return_if_fail (allocation != NULL);
13925
13926   priv = widget->priv;
13927
13928   priv->allocation = *allocation;
13929 }
13930
13931 /**
13932  * gtk_widget_get_allocated_width:
13933  * @widget: the widget to query
13934  *
13935  * Returns the width that has currently been allocated to @widget.
13936  * This function is intended to be used when implementing handlers
13937  * for the #GtkWidget::draw function.
13938  *
13939  * Returns: the width of the @widget
13940  **/
13941 int
13942 gtk_widget_get_allocated_width (GtkWidget *widget)
13943 {
13944   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13945
13946   return widget->priv->allocation.width;
13947 }
13948
13949 /**
13950  * gtk_widget_get_allocated_height:
13951  * @widget: the widget to query
13952  *
13953  * Returns the height that has currently been allocated to @widget.
13954  * This function is intended to be used when implementing handlers
13955  * for the #GtkWidget::draw function.
13956  *
13957  * Returns: the height of the @widget
13958  **/
13959 int
13960 gtk_widget_get_allocated_height (GtkWidget *widget)
13961 {
13962   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13963
13964   return widget->priv->allocation.height;
13965 }
13966
13967 /**
13968  * gtk_widget_get_requisition:
13969  * @widget: a #GtkWidget
13970  * @requisition: (out): a pointer to a #GtkRequisition to copy to
13971  *
13972  * Retrieves the widget's requisition.
13973  *
13974  * This function should only be used by widget implementations in
13975  * order to figure whether the widget's requisition has actually
13976  * changed after some internal state change (so that they can call
13977  * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
13978  *
13979  * Normally, gtk_widget_size_request() should be used.
13980  *
13981  * Since: 2.20
13982  *
13983  * Deprecated: 3.0: The #GtkRequisition cache on the widget was
13984  * removed, If you need to cache sizes across requests and allocations,
13985  * add an explicit cache to the widget in question instead.
13986  */
13987 void
13988 gtk_widget_get_requisition (GtkWidget      *widget,
13989                             GtkRequisition *requisition)
13990 {
13991   g_return_if_fail (GTK_IS_WIDGET (widget));
13992   g_return_if_fail (requisition != NULL);
13993
13994   gtk_widget_get_preferred_size (widget, requisition, NULL);
13995 }
13996
13997 /**
13998  * gtk_widget_set_window:
13999  * @widget: a #GtkWidget
14000  * @window: (transfer full): a #GdkWindow
14001  *
14002  * Sets a widget's window. This function should only be used in a
14003  * widget's #GtkWidget::realize implementation. The %window passed is
14004  * usually either new window created with gdk_window_new(), or the
14005  * window of its parent widget as returned by
14006  * gtk_widget_get_parent_window().
14007  *
14008  * Widgets must indicate whether they will create their own #GdkWindow
14009  * by calling gtk_widget_set_has_window(). This is usually done in the
14010  * widget's init() function.
14011  *
14012  * <note><para>This function does not add any reference to @window.</para></note>
14013  *
14014  * Since: 2.18
14015  */
14016 void
14017 gtk_widget_set_window (GtkWidget *widget,
14018                        GdkWindow *window)
14019 {
14020   GtkWidgetPrivate *priv;
14021
14022   g_return_if_fail (GTK_IS_WIDGET (widget));
14023   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
14024
14025   priv = widget->priv;
14026
14027   if (priv->window != window)
14028     {
14029       priv->window = window;
14030
14031       if (gtk_widget_get_has_window (widget) && window != NULL && !gdk_window_has_native (window))
14032         gdk_window_set_opacity (window,
14033                                 priv->norender ? 0 : priv->alpha / 255.0);
14034
14035       g_object_notify (G_OBJECT (widget), "window");
14036     }
14037 }
14038
14039 /**
14040  * gtk_widget_register_window:
14041  * @widget: a #GtkWidget
14042  * @window: a #GdkWindow
14043  *
14044  * Registers a #GdkWindow with the widget and sets it up so that
14045  * the widget recieves events for it. Call gtk_widget_unregister_window()
14046  * when destroying the window.
14047  *
14048  * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
14049  * this up. This is now deprecated and you should use gtk_widget_register_window()
14050  * instead. Old code will keep working as is, although some new features like
14051  * transparency might not work perfectly.
14052  *
14053  * Since: 3.8
14054  */
14055 void
14056 gtk_widget_register_window (GtkWidget    *widget,
14057                             GdkWindow    *window)
14058 {
14059   GtkWidgetPrivate *priv;
14060   gpointer user_data;
14061
14062   g_return_if_fail (GTK_IS_WIDGET (widget));
14063   g_return_if_fail (GDK_IS_WINDOW (window));
14064
14065   gdk_window_get_user_data (window, &user_data);
14066   g_assert (user_data == NULL);
14067
14068   priv = widget->priv;
14069
14070   gdk_window_set_user_data (window, widget);
14071   priv->registered_windows = g_list_prepend (priv->registered_windows, window);
14072
14073   if (!gtk_widget_get_has_window (widget) && !gdk_window_has_native (window))
14074     gdk_window_set_opacity (window,
14075                             priv->norender_children ? 0.0 : 1.0);
14076 }
14077
14078 /**
14079  * gtk_widget_unregister_window:
14080  * @widget: a #GtkWidget
14081  * @window: a #GdkWindow
14082  *
14083  * Unregisters a #GdkWindow from the widget that was previously set up with
14084  * gtk_widget_register_window(). You need to call this when the window is
14085  * no longer used by the widget, such as when you destroy it.
14086  *
14087  * Since: 3.8
14088  */
14089 void
14090 gtk_widget_unregister_window (GtkWidget    *widget,
14091                               GdkWindow    *window)
14092 {
14093   GtkWidgetPrivate *priv;
14094   gpointer user_data;
14095
14096   g_return_if_fail (GTK_IS_WIDGET (widget));
14097   g_return_if_fail (GDK_IS_WINDOW (window));
14098
14099   priv = widget->priv;
14100
14101   gdk_window_get_user_data (window, &user_data);
14102   g_assert (user_data == widget);
14103   gdk_window_set_user_data (window, NULL);
14104   priv->registered_windows = g_list_remove (priv->registered_windows, window);
14105 }
14106
14107 /**
14108  * gtk_widget_get_window:
14109  * @widget: a #GtkWidget
14110  *
14111  * Returns the widget's window if it is realized, %NULL otherwise
14112  *
14113  * Return value: (transfer none): @widget's window.
14114  *
14115  * Since: 2.14
14116  */
14117 GdkWindow*
14118 gtk_widget_get_window (GtkWidget *widget)
14119 {
14120   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14121
14122   return widget->priv->window;
14123 }
14124
14125 /**
14126  * gtk_widget_get_support_multidevice:
14127  * @widget: a #GtkWidget
14128  *
14129  * Returns %TRUE if @widget is multiple pointer aware. See
14130  * gtk_widget_set_support_multidevice() for more information.
14131  *
14132  * Returns: %TRUE if @widget is multidevice aware.
14133  **/
14134 gboolean
14135 gtk_widget_get_support_multidevice (GtkWidget *widget)
14136 {
14137   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14138
14139   return widget->priv->multidevice;
14140 }
14141
14142 /**
14143  * gtk_widget_set_support_multidevice:
14144  * @widget: a #GtkWidget
14145  * @support_multidevice: %TRUE to support input from multiple devices.
14146  *
14147  * Enables or disables multiple pointer awareness. If this setting is %TRUE,
14148  * @widget will start receiving multiple, per device enter/leave events. Note
14149  * that if custom #GdkWindow<!-- -->s are created in #GtkWidget::realize,
14150  * gdk_window_set_support_multidevice() will have to be called manually on them.
14151  *
14152  * Since: 3.0
14153  **/
14154 void
14155 gtk_widget_set_support_multidevice (GtkWidget *widget,
14156                                     gboolean   support_multidevice)
14157 {
14158   GtkWidgetPrivate *priv;
14159
14160   g_return_if_fail (GTK_IS_WIDGET (widget));
14161
14162   priv = widget->priv;
14163   priv->multidevice = (support_multidevice == TRUE);
14164
14165   if (gtk_widget_get_realized (widget))
14166     gdk_window_set_support_multidevice (priv->window, support_multidevice);
14167 }
14168
14169 /* There are multiple alpha related sources. First of all the user can specify alpha
14170  * in gtk_widget_set_opacity, secondly we can get it from the css opacity. These two
14171  * are multiplied together to form the total alpha. Secondly, the user can specify
14172  * an opacity group for a widget, which means we must essentially handle it as having alpha.
14173  *
14174  * We handle opacity in two ways. For a windowed widget, with opacity set but no opacity
14175  * group we directly set the opacity of widget->window. This will cause gdk to properly
14176  * redirect drawing inside the window to a buffer and do OVER paint_with_alpha.
14177  *
14178  * However, if the widget is not windowed, or the user specified an opacity group for the
14179  * widget we do the opacity handling in the ::draw marshaller for the widget. A naive
14180  * implementation of this would break for windowed widgets or descendant widgets with
14181  * windows, as these would not be handled by the ::draw signal. To handle this we set
14182  * all such gdkwindows as fully transparent and then override gtk_cairo_should_draw_window()
14183  * to make the draw signal propagate to *all* child widgets/windows.
14184  *
14185  * Note: We don't make all child windows fully transparent, we stop at the first one
14186  * in each branch when propagating down the hierarchy.
14187  */
14188
14189
14190 /* This is called when priv->alpha or priv->opacity_group group changes, and should
14191  * update priv->norender and GdkWindow opacity for this widget and any children that
14192  * needs changing. It is also called whenver the parent changes, the parents
14193  * norender_children state changes, or the has_window state of the widget changes.
14194  */
14195 static void
14196 gtk_widget_propagate_alpha (GtkWidget *widget)
14197 {
14198   GtkWidgetPrivate *priv = widget->priv;
14199   GtkWidget *parent;
14200   gboolean norender, norender_children;
14201   GList *l;
14202
14203   parent = priv->parent;
14204
14205   norender =
14206     /* If this widget has an opacity group, never render it */
14207     priv->opacity_group ||
14208     /* If the parent has norender_children, propagate that here */
14209     (parent != NULL && parent->priv->norender_children);
14210
14211   /* Windowed widget children should norender if: */
14212   norender_children =
14213     /* The widget is no_window (otherwise its enought to mark it norender/alpha), and */
14214     !gtk_widget_get_has_window (widget) &&
14215      ( /* norender is set, or */
14216       norender ||
14217       /* widget has an alpha */
14218       priv->alpha != 255
14219        );
14220
14221   if (gtk_widget_get_has_window (widget))
14222     {
14223       if (priv->window != NULL && !gdk_window_has_native (priv->window))
14224         gdk_window_set_opacity (priv->window,
14225                                 norender ? 0 : priv->alpha / 255.0);
14226     }
14227   else /* !has_window */
14228     {
14229       for (l = priv->registered_windows; l != NULL; l = l->next)
14230         {
14231           GdkWindow *w = l->data;
14232           if (!gdk_window_has_native (w))
14233             gdk_window_set_opacity (w, norender_children ? 0.0 : 1.0);
14234         }
14235     }
14236
14237   priv->norender = norender;
14238   if (priv->norender_children != norender_children)
14239     {
14240       priv->norender_children = norender_children;
14241
14242       if (GTK_IS_CONTAINER (widget))
14243         gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback)gtk_widget_propagate_alpha, NULL);
14244     }
14245
14246   if (gtk_widget_get_realized (widget))
14247     gtk_widget_queue_draw (widget);
14248 }
14249
14250 static void
14251 gtk_widget_update_alpha (GtkWidget *widget)
14252 {
14253   GtkWidgetPrivate *priv;
14254   double opacity;
14255   guint8 alpha;
14256
14257   priv = widget->priv;
14258
14259   alpha = priv->user_alpha;
14260
14261   if (priv->context)
14262     {
14263       opacity =
14264         _gtk_css_number_value_get (_gtk_style_context_peek_property (priv->context,
14265                                                                      GTK_CSS_PROPERTY_OPACITY),
14266                                    100);
14267       opacity = CLAMP (opacity, 0.0, 1.0);
14268       alpha = round (priv->user_alpha * opacity);
14269     }
14270
14271   if (alpha == priv->alpha)
14272     return;
14273
14274   priv->alpha = alpha;
14275
14276   gtk_widget_propagate_alpha (widget);
14277
14278 }
14279
14280 static void
14281 gtk_widget_set_has_opacity_group  (GtkWidget *widget,
14282                                    gboolean has_opacity_group)
14283 {
14284   GtkWidgetPrivate *priv;
14285
14286   g_return_if_fail (GTK_IS_WIDGET (widget));
14287
14288   priv = widget->priv;
14289
14290   has_opacity_group = !!has_opacity_group;
14291
14292   if (priv->opacity_group == has_opacity_group)
14293     return;
14294
14295   priv->opacity_group = has_opacity_group;
14296
14297   gtk_widget_propagate_alpha (widget);
14298 }
14299
14300 /**
14301  * gtk_widget_set_opacity:
14302  * @widget: a #GtkWidget
14303  * @opacity: desired opacity, between 0 and 1
14304  *
14305  * Request the @widget to be rendered partially transparent,
14306  * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
14307  * are clamped to the [0,1] range.).
14308  * This works on both toplevel widget, and child widgets, although there
14309  * are some limitations:
14310  *
14311  * For toplevel widgets this depends on the capabilities of the windowing
14312  * system. On X11 this has any effect only on X screens with a compositing manager
14313  * running. See gtk_widget_is_composited(). On Windows it should work
14314  * always, although setting a window's opacity after the window has been
14315  * shown causes it to flicker once on Windows.
14316  *
14317  * For child widgets it doesn't work if any affected widget has a native window, or
14318  * disables double buffering.
14319  *
14320  * Since: 3.8
14321  **/
14322 void
14323 gtk_widget_set_opacity  (GtkWidget *widget,
14324                          gdouble    opacity)
14325 {
14326   GtkWidgetPrivate *priv;
14327   guint8 alpha;
14328
14329   g_return_if_fail (GTK_IS_WIDGET (widget));
14330
14331   priv = widget->priv;
14332
14333   opacity = CLAMP (opacity, 0.0, 1.0);
14334
14335   alpha = round (opacity * 255);
14336
14337   /* As a kind of hack for internal use we treat an alpha very
14338      close to 1.0 (rounds to 255) but not 1.0 as specifying that
14339      we want the opacity group behaviour wrt draw handling, but
14340      not actually an alpha value. See bug #687842 for discussions. */
14341   gtk_widget_set_has_opacity_group (widget,
14342                                     alpha == 255 && opacity != 1.0);
14343
14344   if (alpha == priv->user_alpha)
14345     return;
14346
14347   priv->user_alpha = alpha;
14348
14349   gtk_widget_update_alpha (widget);
14350
14351 }
14352
14353 /**
14354  * gtk_widget_get_opacity:
14355  * @widget: a #GtkWidget
14356  *
14357  * Fetches the requested opacity for this widget. See
14358  * gtk_widget_set_opacity().
14359  *
14360  * Return value: the requested opacity for this widget.
14361  *
14362  * Since: 3.8
14363  **/
14364 gdouble
14365 gtk_widget_get_opacity (GtkWidget *widget)
14366 {
14367   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0.0);
14368
14369   return widget->priv->alpha / 255.0;
14370 }
14371
14372 static void
14373 _gtk_widget_set_has_focus (GtkWidget *widget,
14374                            gboolean   has_focus)
14375 {
14376   widget->priv->has_focus = has_focus;
14377
14378   if (has_focus)
14379     gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_FOCUSED, FALSE);
14380   else
14381     gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_FOCUSED);
14382 }
14383
14384 /**
14385  * gtk_widget_send_focus_change:
14386  * @widget: a #GtkWidget
14387  * @event: a #GdkEvent of type GDK_FOCUS_CHANGE
14388  *
14389  * Sends the focus change @event to @widget
14390  *
14391  * This function is not meant to be used by applications. The only time it
14392  * should be used is when it is necessary for a #GtkWidget to assign focus
14393  * to a widget that is semantically owned by the first widget even though
14394  * it's not a direct child - for instance, a search entry in a floating
14395  * window similar to the quick search in #GtkTreeView.
14396  *
14397  * An example of its usage is:
14398  *
14399  * |[
14400  *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
14401  *
14402  *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
14403  *   fevent->focus_change.in = TRUE;
14404  *   fevent->focus_change.window = gtk_widget_get_window (widget);
14405  *   if (fevent->focus_change.window != NULL)
14406  *     g_object_ref (fevent->focus_change.window);
14407  *
14408  *   gtk_widget_send_focus_change (widget, fevent);
14409  *
14410  *   gdk_event_free (event);
14411  * ]|
14412  *
14413  * Return value: the return value from the event signal emission: %TRUE
14414  *   if the event was handled, and %FALSE otherwise
14415  *
14416  * Since: 2.20
14417  */
14418 gboolean
14419 gtk_widget_send_focus_change (GtkWidget *widget,
14420                               GdkEvent  *event)
14421 {
14422   gboolean res;
14423
14424   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14425   g_return_val_if_fail (event != NULL && event->type == GDK_FOCUS_CHANGE, FALSE);
14426
14427   g_object_ref (widget);
14428
14429   _gtk_widget_set_has_focus (widget, event->focus_change.in);
14430
14431   res = gtk_widget_event (widget, event);
14432
14433   g_object_notify (G_OBJECT (widget), "has-focus");
14434
14435   g_object_unref (widget);
14436
14437   return res;
14438 }
14439
14440 /**
14441  * gtk_widget_in_destruction:
14442  * @widget: a #GtkWidget
14443  *
14444  * Returns whether the widget is currently being destroyed.
14445  * This information can sometimes be used to avoid doing
14446  * unnecessary work.
14447  *
14448  * Returns: %TRUE if @widget is being destroyed
14449  */
14450 gboolean
14451 gtk_widget_in_destruction (GtkWidget *widget)
14452 {
14453   return widget->priv->in_destruction;
14454 }
14455
14456 gboolean
14457 _gtk_widget_get_in_reparent (GtkWidget *widget)
14458 {
14459   return widget->priv->in_reparent;
14460 }
14461
14462 void
14463 _gtk_widget_set_in_reparent (GtkWidget *widget,
14464                              gboolean   in_reparent)
14465 {
14466   widget->priv->in_reparent = in_reparent;
14467 }
14468
14469 gboolean
14470 _gtk_widget_get_anchored (GtkWidget *widget)
14471 {
14472   return widget->priv->anchored;
14473 }
14474
14475 void
14476 _gtk_widget_set_anchored (GtkWidget *widget,
14477                           gboolean   anchored)
14478 {
14479   widget->priv->anchored = anchored;
14480 }
14481
14482 gboolean
14483 _gtk_widget_get_shadowed (GtkWidget *widget)
14484 {
14485   return widget->priv->shadowed;
14486 }
14487
14488 void
14489 _gtk_widget_set_shadowed (GtkWidget *widget,
14490                           gboolean   shadowed)
14491 {
14492   widget->priv->shadowed = shadowed;
14493 }
14494
14495 gboolean
14496 _gtk_widget_get_alloc_needed (GtkWidget *widget)
14497 {
14498   return widget->priv->alloc_needed;
14499 }
14500
14501 void
14502 _gtk_widget_set_alloc_needed (GtkWidget *widget,
14503                               gboolean   alloc_needed)
14504 {
14505   widget->priv->alloc_needed = alloc_needed;
14506 }
14507
14508 void
14509 _gtk_widget_add_sizegroup (GtkWidget    *widget,
14510                            gpointer      group)
14511 {
14512   GSList *groups;
14513
14514   groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14515   groups = g_slist_prepend (groups, group);
14516   g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
14517
14518   widget->priv->have_size_groups = TRUE;
14519 }
14520
14521 void
14522 _gtk_widget_remove_sizegroup (GtkWidget    *widget,
14523                               gpointer      group)
14524 {
14525   GSList *groups;
14526
14527   groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14528   groups = g_slist_remove (groups, group);
14529   g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
14530
14531   widget->priv->have_size_groups = groups != NULL;
14532 }
14533
14534 GSList *
14535 _gtk_widget_get_sizegroups (GtkWidget    *widget)
14536 {
14537   if (widget->priv->have_size_groups)
14538     return g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14539
14540   return NULL;
14541 }
14542
14543 void
14544 _gtk_widget_add_attached_window (GtkWidget    *widget,
14545                                  GtkWindow    *window)
14546 {
14547   widget->priv->attached_windows = g_list_prepend (widget->priv->attached_windows, window);
14548 }
14549
14550 void
14551 _gtk_widget_remove_attached_window (GtkWidget    *widget,
14552                                     GtkWindow    *window)
14553 {
14554   widget->priv->attached_windows = g_list_remove (widget->priv->attached_windows, window);
14555 }
14556
14557 /**
14558  * gtk_widget_path_append_for_widget:
14559  * @path: a widget path
14560  * @widget: the widget to append to the widget path
14561  *
14562  * Appends the data from @widget to the widget hierarchy represented
14563  * by @path. This function is a shortcut for adding information from
14564  * @widget to the given @path. This includes setting the name or
14565  * adding the style classes from @widget.
14566  *
14567  * Returns: the position where the data was inserted
14568  *
14569  * Since: 3.2
14570  */
14571 gint
14572 gtk_widget_path_append_for_widget (GtkWidgetPath *path,
14573                                    GtkWidget     *widget)
14574 {
14575   gint pos;
14576
14577   g_return_val_if_fail (path != NULL, 0);
14578   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
14579
14580   pos = gtk_widget_path_append_type (path, G_OBJECT_TYPE (widget));
14581
14582   if (widget->priv->name)
14583     gtk_widget_path_iter_set_name (path, pos, widget->priv->name);
14584
14585   if (widget->priv->context)
14586     {
14587       GList *classes, *l;
14588
14589       /* Also add any persistent classes in
14590        * the style context the widget path
14591        */
14592       classes = gtk_style_context_list_classes (widget->priv->context);
14593
14594       for (l = classes; l; l = l->next)
14595         gtk_widget_path_iter_add_class (path, pos, l->data);
14596
14597       g_list_free (classes);
14598     }
14599
14600   return pos;
14601 }
14602
14603 GtkWidgetPath *
14604 _gtk_widget_create_path (GtkWidget *widget)
14605 {
14606   GtkWidget *parent;
14607
14608   parent = widget->priv->parent;
14609
14610   if (parent)
14611     return gtk_container_get_path_for_child (GTK_CONTAINER (parent), widget);
14612   else
14613     {
14614       /* Widget is either toplevel or unparented, treat both
14615        * as toplevels style wise, since there are situations
14616        * where style properties might be retrieved on that
14617        * situation.
14618        */
14619       GtkWidget *attach_widget = NULL;
14620       GtkWidgetPath *result;
14621
14622       if (GTK_IS_WINDOW (widget))
14623         attach_widget = gtk_window_get_attached_to (GTK_WINDOW (widget));
14624
14625       if (attach_widget != NULL)
14626         result = gtk_widget_path_copy (gtk_widget_get_path (attach_widget));
14627       else
14628         result = gtk_widget_path_new ();
14629
14630       gtk_widget_path_append_for_widget (result, widget);
14631
14632       return result;
14633     }
14634 }
14635
14636 /**
14637  * gtk_widget_get_path:
14638  * @widget: a #GtkWidget
14639  *
14640  * Returns the #GtkWidgetPath representing @widget, if the widget
14641  * is not connected to a toplevel widget, a partial path will be
14642  * created.
14643  *
14644  * Returns: (transfer none): The #GtkWidgetPath representing @widget
14645  **/
14646 GtkWidgetPath *
14647 gtk_widget_get_path (GtkWidget *widget)
14648 {
14649   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14650
14651   if (!widget->priv->path)
14652     widget->priv->path = _gtk_widget_create_path (widget);
14653
14654   return widget->priv->path;
14655 }
14656
14657 void
14658 _gtk_widget_style_context_invalidated (GtkWidget *widget)
14659 {
14660   if (widget->priv->path)
14661     {
14662       gtk_widget_path_free (widget->priv->path);
14663       widget->priv->path = NULL;
14664     }
14665
14666   if (gtk_widget_get_realized (widget))
14667     g_signal_emit (widget, widget_signals[STYLE_UPDATED], 0);
14668   else
14669     {
14670       /* Compress all style updates so it
14671        * is only emitted once pre-realize.
14672        */
14673       widget->priv->style_update_pending = TRUE;
14674     }
14675 }
14676
14677 /**
14678  * gtk_widget_get_style_context:
14679  * @widget: a #GtkWidget
14680  *
14681  * Returns the style context associated to @widget.
14682  *
14683  * Returns: (transfer none): a #GtkStyleContext. This memory is owned by @widget and
14684  *          must not be freed.
14685  **/
14686 GtkStyleContext *
14687 gtk_widget_get_style_context (GtkWidget *widget)
14688 {
14689   GtkWidgetPrivate *priv;
14690
14691   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14692
14693   priv = widget->priv;
14694
14695   if (G_UNLIKELY (priv->context == NULL))
14696     {
14697       GdkScreen *screen;
14698       GdkFrameClock *frame_clock;
14699
14700       priv->context = gtk_style_context_new ();
14701
14702       gtk_style_context_set_state (priv->context, priv->state_flags);
14703
14704       screen = gtk_widget_get_screen (widget);
14705       if (screen)
14706         gtk_style_context_set_screen (priv->context, screen);
14707
14708       frame_clock = gtk_widget_get_frame_clock (widget);
14709       if (frame_clock)
14710         gtk_style_context_set_frame_clock (priv->context, frame_clock);
14711
14712       if (priv->parent)
14713         gtk_style_context_set_parent (priv->context,
14714                                       gtk_widget_get_style_context (priv->parent));
14715
14716       _gtk_style_context_set_widget (priv->context, widget);
14717     }
14718
14719   return widget->priv->context;
14720 }
14721
14722 void
14723 _gtk_widget_invalidate_style_context (GtkWidget    *widget,
14724                                       GtkCssChange  change)
14725 {
14726   GtkWidgetPrivate *priv;
14727
14728   priv = widget->priv;
14729
14730   if (priv->context == NULL)
14731     return;
14732
14733   _gtk_style_context_queue_invalidate (priv->context, change);
14734 }
14735
14736 /**
14737  * gtk_widget_get_modifier_mask:
14738  * @widget: a #GtkWidget
14739  * @intent: the use case for the modifier mask
14740  *
14741  * Returns the modifier mask the @widget's windowing system backend
14742  * uses for a particular purpose.
14743  *
14744  * See gdk_keymap_get_modifier_mask().
14745  *
14746  * Returns: the modifier mask used for @intent.
14747  *
14748  * Since: 3.4
14749  **/
14750 GdkModifierType
14751 gtk_widget_get_modifier_mask (GtkWidget         *widget,
14752                               GdkModifierIntent  intent)
14753 {
14754   GdkDisplay *display;
14755
14756   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
14757
14758   display = gtk_widget_get_display (widget);
14759
14760   return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
14761                                        intent);
14762 }
14763
14764 GtkStyle *
14765 _gtk_widget_get_style (GtkWidget *widget)
14766 {
14767   return widget->priv->style;
14768 }
14769
14770 void
14771 _gtk_widget_set_style (GtkWidget *widget,
14772                        GtkStyle  *style)
14773 {
14774   widget->priv->style = style;
14775 }
14776
14777 void
14778 _gtk_widget_update_parent_muxer (GtkWidget *widget)
14779 {
14780   GtkWidget *parent;
14781   GActionMuxer *parent_muxer;
14782
14783   if (widget->priv->muxer == NULL)
14784     return;
14785
14786   if (GTK_IS_MENU (widget))
14787     parent = gtk_menu_get_attach_widget (GTK_MENU (widget));
14788   else
14789     parent = gtk_widget_get_parent (widget);
14790
14791   parent_muxer = parent ? _gtk_widget_get_action_muxer (parent) : NULL;
14792
14793   g_action_muxer_set_parent (widget->priv->muxer, parent_muxer);
14794 }
14795
14796 GActionMuxer *
14797 _gtk_widget_get_action_muxer (GtkWidget *widget)
14798 {
14799   if (widget->priv->muxer == NULL)
14800     {
14801       widget->priv->muxer = g_action_muxer_new ();
14802       _gtk_widget_update_parent_muxer (widget);
14803     }
14804
14805   return widget->priv->muxer;
14806 }
14807
14808 /**
14809  * gtk_widget_insert_action_group:
14810  * @widget: a #GtkWidget
14811  * @name: the prefix for actions in @group
14812  * @group: a #GActionGroup
14813  *
14814  * Inserts @group into @widget. Children of @widget that implement
14815  * #GtkActionable can then be associated with actions in @group by
14816  * setting their 'action-name' to
14817  * @prefix.<replaceable>action-name</replaceable>.
14818  *
14819  * Since: 3.6
14820  */
14821 void
14822 gtk_widget_insert_action_group (GtkWidget    *widget,
14823                                 const gchar  *name,
14824                                 GActionGroup *group)
14825 {
14826   GActionMuxer *muxer;
14827
14828   g_return_if_fail (GTK_IS_WIDGET (widget));
14829   g_return_if_fail (name != NULL);
14830
14831   muxer = _gtk_widget_get_action_muxer (widget);
14832
14833   if (group)
14834     g_action_muxer_insert (muxer, name, group);
14835   else
14836     g_action_muxer_remove (muxer, name);
14837 }