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