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

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