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   for (l = priv->tick_callbacks; l;)
4581     {
4582       GtkTickCallbackInfo *info = l->data;
4583       GList *next;
4584
4585       ref_tick_callback_info (info);
4586       if (!info->destroyed)
4587         {
4588           if (info->callback (widget,
4589                               frame_clock,
4590                               info->user_data) == G_SOURCE_REMOVE)
4591             {
4592               destroy_tick_callback_info (widget, info, l);
4593             }
4594         }
4595
4596       next = l->next;
4597       unref_tick_callback_info (widget, info, l);
4598       l = next;
4599     }
4600 }
4601
4602 static guint tick_callback_id;
4603
4604 /**
4605  * gtk_widget_add_tick_callback:
4606  * @widget: a #GtkWidget
4607  * @callback: function to call for updating animations
4608  * @user_data: data to pass to @callback
4609  * @notify: function to call to free @user_data when the callback is removed.
4610  *
4611  * Queues a animation frame update and adds a callback to be called
4612  * before each frame. Until the tick callback is removed, it will be
4613  * called frequently (usually at the frame rate of the output device
4614  * or as quickly as the application an be repainted, whichever is
4615  * slower). For this reason, is most suitable for handling graphics
4616  * that change every frame or every few frames. The tick callback does
4617  * not automatically imply a relayout or repaint. If you want a
4618  * repaint or relayout, and aren't changing widget properties that
4619  * would trigger that (for example, changing the text of a #GtkLabel),
4620  * then you will have to call gtk_widget_queue_resize() or
4621  * gtk_widget_queue_draw_area() yourself.
4622  *
4623  * gdk_frame_clock_get_frame_time() should generally be used for timing
4624  * continuous animations and
4625  * gdk_frame_timings_get_predicted_presentation_time() if you are
4626  * trying to display isolated frames particular times.
4627  *
4628  * This is a more convenient alternative to connecting directly to the
4629  * ::update signal of GdkFrameClock, since you don't have to worry about
4630  * when a #GdkFrameClock is assigned to a widget.
4631  */
4632 guint
4633 gtk_widget_add_tick_callback (GtkWidget       *widget,
4634                               GtkTickCallback  callback,
4635                               gpointer         user_data,
4636                               GDestroyNotify   notify)
4637 {
4638   GtkWidgetPrivate *priv;
4639   GtkTickCallbackInfo *info;
4640
4641   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
4642
4643   priv = widget->priv;
4644
4645   if (priv->tick_callbacks == NULL && priv->realized)
4646     {
4647       GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
4648       g_signal_connect (frame_clock, "update",
4649                         G_CALLBACK (gtk_widget_on_frame_clock_update),
4650                         widget);
4651       gdk_frame_clock_begin_updating (frame_clock);
4652     }
4653
4654   info = g_slice_new0 (GtkTickCallbackInfo);
4655
4656   info->refcount = 1;
4657   info->id = ++tick_callback_id;
4658   info->callback = callback;
4659   info->user_data = user_data;
4660   info->notify = notify;
4661
4662   priv->tick_callbacks = g_list_prepend (priv->tick_callbacks,
4663                                          info);
4664
4665   return info->id;
4666 }
4667
4668 void
4669 gtk_widget_remove_tick_callback (GtkWidget *widget,
4670                                  guint      id)
4671 {
4672   GtkWidgetPrivate *priv;
4673   GList *l;
4674
4675   g_return_if_fail (GTK_IS_WIDGET (widget));
4676
4677   priv = widget->priv;
4678
4679   for (l = priv->tick_callbacks; l; l = l->next)
4680     {
4681       GtkTickCallbackInfo *info = l->data;
4682       if (info->id == id)
4683         destroy_tick_callback_info (widget, info, l);
4684     }
4685 }
4686
4687 static void
4688 gtk_widget_connect_frame_clock (GtkWidget     *widget,
4689                                 GdkFrameClock *frame_clock)
4690 {
4691   GtkWidgetPrivate *priv = widget->priv;
4692
4693   if (GTK_IS_CONTAINER (widget))
4694     _gtk_container_maybe_start_idle_sizer (GTK_CONTAINER (widget));
4695
4696   if (priv->tick_callbacks != NULL)
4697     {
4698       g_signal_connect (frame_clock, "update",
4699                         G_CALLBACK (gtk_widget_on_frame_clock_update),
4700                         widget);
4701       gdk_frame_clock_begin_updating (frame_clock);
4702     }
4703
4704   if (priv->context)
4705     gtk_style_context_set_frame_clock (priv->context, frame_clock);
4706 }
4707
4708 static void
4709 gtk_widget_disconnect_frame_clock (GtkWidget     *widget,
4710                                    GdkFrameClock *frame_clock)
4711 {
4712   GtkWidgetPrivate *priv = widget->priv;
4713
4714   if (GTK_IS_CONTAINER (widget))
4715     _gtk_container_stop_idle_sizer (GTK_CONTAINER (widget));
4716
4717   if (priv->tick_callbacks)
4718     {
4719       g_signal_handlers_disconnect_by_func (frame_clock,
4720                                             (gpointer) gtk_widget_on_frame_clock_update,
4721                                             widget);
4722       gdk_frame_clock_end_updating (frame_clock);
4723     }
4724
4725   if (priv->context)
4726     gtk_style_context_set_frame_clock (priv->context, NULL);
4727 }
4728
4729 /**
4730  * gtk_widget_realize:
4731  * @widget: a #GtkWidget
4732  *
4733  * Creates the GDK (windowing system) resources associated with a
4734  * widget.  For example, @widget->window will be created when a widget
4735  * is realized.  Normally realization happens implicitly; if you show
4736  * a widget and all its parent containers, then the widget will be
4737  * realized and mapped automatically.
4738  *
4739  * Realizing a widget requires all
4740  * the widget's parent widgets to be realized; calling
4741  * gtk_widget_realize() realizes the widget's parents in addition to
4742  * @widget itself. If a widget is not yet inside a toplevel window
4743  * when you realize it, bad things will happen.
4744  *
4745  * This function is primarily used in widget implementations, and
4746  * isn't very useful otherwise. Many times when you think you might
4747  * need it, a better approach is to connect to a signal that will be
4748  * called after the widget is realized automatically, such as
4749  * #GtkWidget::draw. Or simply g_signal_connect () to the
4750  * #GtkWidget::realize signal.
4751  **/
4752 void
4753 gtk_widget_realize (GtkWidget *widget)
4754 {
4755   GtkWidgetPrivate *priv;
4756   cairo_region_t *region;
4757
4758   g_return_if_fail (GTK_IS_WIDGET (widget));
4759   g_return_if_fail (widget->priv->anchored ||
4760                     GTK_IS_INVISIBLE (widget));
4761
4762   priv = widget->priv;
4763
4764   if (!gtk_widget_get_realized (widget))
4765     {
4766       gtk_widget_push_verify_invariants (widget);
4767
4768       /*
4769         if (GTK_IS_CONTAINER (widget) && gtk_widget_get_has_window (widget))
4770           g_message ("gtk_widget_realize(%s)", G_OBJECT_TYPE_NAME (widget));
4771       */
4772
4773       if (priv->parent == NULL &&
4774           !gtk_widget_is_toplevel (widget))
4775         g_warning ("Calling gtk_widget_realize() on a widget that isn't "
4776                    "inside a toplevel window is not going to work very well. "
4777                    "Widgets must be inside a toplevel container before realizing them.");
4778
4779       if (priv->parent && !gtk_widget_get_realized (priv->parent))
4780         gtk_widget_realize (priv->parent);
4781
4782       gtk_widget_ensure_style (widget);
4783
4784       if (priv->style_update_pending)
4785         g_signal_emit (widget, widget_signals[STYLE_UPDATED], 0);
4786
4787       g_signal_emit (widget, widget_signals[REALIZE], 0);
4788
4789       gtk_widget_real_set_has_tooltip (widget,
4790                                        GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget), quark_has_tooltip)),
4791                                        TRUE);
4792
4793       if (priv->has_shape_mask)
4794         {
4795           region = g_object_get_qdata (G_OBJECT (widget), quark_shape_info);
4796           gdk_window_shape_combine_region (priv->window, region, 0, 0);
4797         }
4798
4799       region = g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info);
4800       if (region)
4801         gdk_window_input_shape_combine_region (priv->window, region, 0, 0);
4802
4803       if (priv->multidevice)
4804         gdk_window_set_support_multidevice (priv->window, TRUE);
4805
4806       _gtk_widget_enable_device_events (widget);
4807       gtk_widget_update_devices_mask (widget, TRUE);
4808
4809       gtk_widget_connect_frame_clock (widget,
4810                                       gtk_widget_get_frame_clock (widget));
4811
4812       gtk_widget_pop_verify_invariants (widget);
4813     }
4814 }
4815
4816 /**
4817  * gtk_widget_unrealize:
4818  * @widget: a #GtkWidget
4819  *
4820  * This function is only useful in widget implementations.
4821  * Causes a widget to be unrealized (frees all GDK resources
4822  * associated with the widget, such as @widget->window).
4823  **/
4824 void
4825 gtk_widget_unrealize (GtkWidget *widget)
4826 {
4827   g_return_if_fail (GTK_IS_WIDGET (widget));
4828
4829   gtk_widget_push_verify_invariants (widget);
4830
4831   if (widget->priv->has_shape_mask)
4832     gtk_widget_shape_combine_region (widget, NULL);
4833
4834   if (g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info))
4835     gtk_widget_input_shape_combine_region (widget, NULL);
4836
4837   if (gtk_widget_get_realized (widget))
4838     {
4839       g_object_ref (widget);
4840
4841       if (widget->priv->mapped)
4842         gtk_widget_unmap (widget);
4843
4844       gtk_widget_disconnect_frame_clock (widget,
4845                                          gtk_widget_get_frame_clock (widget));
4846
4847       g_signal_emit (widget, widget_signals[UNREALIZE], 0);
4848       g_assert (!widget->priv->mapped);
4849       gtk_widget_set_realized (widget, FALSE);
4850
4851       g_object_unref (widget);
4852     }
4853
4854   gtk_widget_pop_verify_invariants (widget);
4855 }
4856
4857 /*****************************************
4858  * Draw queueing.
4859  *****************************************/
4860
4861 /**
4862  * gtk_widget_queue_draw_region:
4863  * @widget: a #GtkWidget
4864  * @region: region to draw
4865  *
4866  * Invalidates the rectangular area of @widget defined by @region by
4867  * calling gdk_window_invalidate_region() on the widget's window and
4868  * all its child windows. Once the main loop becomes idle (after the
4869  * current batch of events has been processed, roughly), the window
4870  * will receive expose events for the union of all regions that have
4871  * been invalidated.
4872  *
4873  * Normally you would only use this function in widget
4874  * implementations. You might also use it to schedule a redraw of a
4875  * #GtkDrawingArea or some portion thereof.
4876  *
4877  * Since: 3.0
4878  **/
4879 void
4880 gtk_widget_queue_draw_region (GtkWidget            *widget,
4881                               const cairo_region_t *region)
4882 {
4883   GtkWidgetPrivate *priv;
4884   GtkWidget *w;
4885
4886   g_return_if_fail (GTK_IS_WIDGET (widget));
4887
4888   priv = widget->priv;
4889
4890   if (!gtk_widget_get_realized (widget))
4891     return;
4892
4893   /* Just return if the widget or one of its ancestors isn't mapped */
4894   for (w = widget; w != NULL; w = w->priv->parent)
4895     if (!gtk_widget_get_mapped (w))
4896       return;
4897
4898   gdk_window_invalidate_region (priv->window, region, TRUE);
4899 }
4900
4901 /**
4902  * gtk_widget_queue_draw_area:
4903  * @widget: a #GtkWidget
4904  * @x: x coordinate of upper-left corner of rectangle to redraw
4905  * @y: y coordinate of upper-left corner of rectangle to redraw
4906  * @width: width of region to draw
4907  * @height: height of region to draw
4908  *
4909  * Convenience function that calls gtk_widget_queue_draw_region() on
4910  * the region created from the given coordinates.
4911  *
4912  * The region here is specified in widget coordinates.
4913  * Widget coordinates are a bit odd; for historical reasons, they are
4914  * defined as @widget->window coordinates for widgets that are not
4915  * #GTK_NO_WINDOW widgets, and are relative to @widget->allocation.x,
4916  * @widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
4917  */
4918 void
4919 gtk_widget_queue_draw_area (GtkWidget *widget,
4920                             gint       x,
4921                             gint       y,
4922                             gint       width,
4923                             gint       height)
4924 {
4925   GdkRectangle rect;
4926   cairo_region_t *region;
4927
4928   g_return_if_fail (GTK_IS_WIDGET (widget));
4929
4930   rect.x = x;
4931   rect.y = y;
4932   rect.width = width;
4933   rect.height = height;
4934
4935   region = cairo_region_create_rectangle (&rect);
4936   gtk_widget_queue_draw_region (widget, region);
4937   cairo_region_destroy (region);
4938 }
4939
4940 /**
4941  * gtk_widget_queue_draw:
4942  * @widget: a #GtkWidget
4943  *
4944  * Equivalent to calling gtk_widget_queue_draw_area() for the
4945  * entire area of a widget.
4946  **/
4947 void
4948 gtk_widget_queue_draw (GtkWidget *widget)
4949 {
4950   GdkRectangle rect;
4951
4952   g_return_if_fail (GTK_IS_WIDGET (widget));
4953
4954   gtk_widget_get_allocation (widget, &rect);
4955
4956   if (!gtk_widget_get_has_window (widget))
4957     gtk_widget_queue_draw_area (widget,
4958                                 rect.x, rect.y, rect.width, rect.height);
4959   else
4960     gtk_widget_queue_draw_area (widget,
4961                                 0, 0, rect.width, rect.height);
4962 }
4963
4964 /**
4965  * gtk_widget_queue_resize:
4966  * @widget: a #GtkWidget
4967  *
4968  * This function is only for use in widget implementations.
4969  * Flags a widget to have its size renegotiated; should
4970  * be called when a widget for some reason has a new size request.
4971  * For example, when you change the text in a #GtkLabel, #GtkLabel
4972  * queues a resize to ensure there's enough space for the new text.
4973  *
4974  * <note><para>You cannot call gtk_widget_queue_resize() on a widget
4975  * from inside its implementation of the GtkWidgetClass::size_allocate
4976  * virtual method. Calls to gtk_widget_queue_resize() from inside
4977  * GtkWidgetClass::size_allocate will be silently ignored.</para></note>
4978  **/
4979 void
4980 gtk_widget_queue_resize (GtkWidget *widget)
4981 {
4982   g_return_if_fail (GTK_IS_WIDGET (widget));
4983
4984   if (gtk_widget_get_realized (widget))
4985     gtk_widget_queue_draw (widget);
4986
4987   _gtk_size_group_queue_resize (widget, 0);
4988 }
4989
4990 /**
4991  * gtk_widget_queue_resize_no_redraw:
4992  * @widget: a #GtkWidget
4993  *
4994  * This function works like gtk_widget_queue_resize(),
4995  * except that the widget is not invalidated.
4996  *
4997  * Since: 2.4
4998  **/
4999 void
5000 gtk_widget_queue_resize_no_redraw (GtkWidget *widget)
5001 {
5002   g_return_if_fail (GTK_IS_WIDGET (widget));
5003
5004   _gtk_size_group_queue_resize (widget, 0);
5005 }
5006
5007 /**
5008  * gtk_widget_get_frame_clock:
5009  * @widget: a #GtkWidget
5010  *
5011  * Obtains the frame clock for a widget. The frame clock is a global
5012  * "ticker" that can be used to drive animations and repaints.  The
5013  * most common reason to get the frame clock is to call
5014  * gdk_frame_clock_get_frame_time(), in order to get a time to use for
5015  * animating. For example you might record the start of the animation
5016  * with an initial value from gdk_frame_clock_get_frame_time(), and
5017  * then update the animation by calling
5018  * gdk_frame_clock_get_frame_time() again during each repaint.
5019  *
5020  * gdk_frame_clock_request_phase() will result in a new frame on the
5021  * clock, but won't necessarily repaint any widgets. To repaint a
5022  * widget, you have to use gtk_widget_queue_draw() which invalidates
5023  * the widget (thus scheduling it to receive a draw on the next
5024  * frame). gtk_widget_queue_draw() will also end up requesting a frame
5025  * on the appropriate frame clock.
5026  *
5027  * A widget's frame clock will not change while the widget is
5028  * mapped. Reparenting a widget (which implies a temporary unmap) can
5029  * change the widget's frame clock.
5030  *
5031  * Unrealized widgets do not have a frame clock.
5032  *
5033  * Since: 3.0
5034  * Return value: (transfer none): a #GdkFrameClock (or #NULL if widget is unrealized)
5035  */
5036 GdkFrameClock*
5037 gtk_widget_get_frame_clock (GtkWidget *widget)
5038 {
5039   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
5040
5041   if (widget->priv->realized)
5042     {
5043       /* We use gtk_widget_get_toplevel() here to make it explicit that
5044        * the frame clock is a property of the toplevel that a widget
5045        * is anchored to; gdk_window_get_toplevel() will go up the
5046        * hierarchy anyways, but should squash any funny business with
5047        * reparenting windows and widgets.
5048        */
5049       GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
5050       GdkWindow *window = gtk_widget_get_window (toplevel);
5051       g_assert (window != NULL);
5052
5053       return gdk_window_get_frame_clock (window);
5054     }
5055   else
5056     {
5057       return NULL;
5058     }
5059 }
5060
5061 /**
5062  * gtk_widget_size_request:
5063  * @widget: a #GtkWidget
5064  * @requisition: (out): a #GtkRequisition to be filled in
5065  *
5066  * This function is typically used when implementing a #GtkContainer
5067  * subclass.  Obtains the preferred size of a widget. The container
5068  * uses this information to arrange its child widgets and decide what
5069  * size allocations to give them with gtk_widget_size_allocate().
5070  *
5071  * You can also call this function from an application, with some
5072  * caveats. Most notably, getting a size request requires the widget
5073  * to be associated with a screen, because font information may be
5074  * needed. Multihead-aware applications should keep this in mind.
5075  *
5076  * Also remember that the size request is not necessarily the size
5077  * a widget will actually be allocated.
5078  *
5079  * Deprecated: 3.0: Use gtk_widget_get_preferred_size() instead.
5080  **/
5081 void
5082 gtk_widget_size_request (GtkWidget      *widget,
5083                          GtkRequisition *requisition)
5084 {
5085   g_return_if_fail (GTK_IS_WIDGET (widget));
5086
5087   gtk_widget_get_preferred_size (widget, requisition, NULL);
5088 }
5089
5090 /**
5091  * gtk_widget_get_child_requisition:
5092  * @widget: a #GtkWidget
5093  * @requisition: (out): a #GtkRequisition to be filled in
5094  *
5095  * This function is only for use in widget implementations. Obtains
5096  * @widget->requisition, unless someone has forced a particular
5097  * geometry on the widget (e.g. with gtk_widget_set_size_request()),
5098  * in which case it returns that geometry instead of the widget's
5099  * requisition.
5100  *
5101  * This function differs from gtk_widget_size_request() in that
5102  * it retrieves the last size request value from @widget->requisition,
5103  * while gtk_widget_size_request() actually calls the "size_request" method
5104  * on @widget to compute the size request and fill in @widget->requisition,
5105  * and only then returns @widget->requisition.
5106  *
5107  * Because this function does not call the "size_request" method, it
5108  * can only be used when you know that @widget->requisition is
5109  * up-to-date, that is, gtk_widget_size_request() has been called
5110  * since the last time a resize was queued. In general, only container
5111  * implementations have this information; applications should use
5112  * gtk_widget_size_request().
5113  *
5114  *
5115  * Deprecated: 3.0: Use gtk_widget_get_preferred_size() instead.
5116  **/
5117 void
5118 gtk_widget_get_child_requisition (GtkWidget      *widget,
5119                                   GtkRequisition *requisition)
5120 {
5121   gtk_widget_get_preferred_size (widget, requisition, NULL);
5122 }
5123
5124 static gboolean
5125 invalidate_predicate (GdkWindow *window,
5126                       gpointer   data)
5127 {
5128   gpointer user_data;
5129
5130   gdk_window_get_user_data (window, &user_data);
5131
5132   return (user_data == data);
5133 }
5134
5135 /* Invalidate @region in widget->window and all children
5136  * of widget->window owned by widget. @region is in the
5137  * same coordinates as widget->allocation and will be
5138  * modified by this call.
5139  */
5140 static void
5141 gtk_widget_invalidate_widget_windows (GtkWidget *widget,
5142                                       cairo_region_t *region)
5143 {
5144   GtkWidgetPrivate *priv = widget->priv;
5145
5146   if (!gtk_widget_get_realized (widget))
5147     return;
5148
5149   if (gtk_widget_get_has_window (widget) && priv->parent)
5150     {
5151       int x, y;
5152
5153       gdk_window_get_position (priv->window, &x, &y);
5154       cairo_region_translate (region, -x, -y);
5155     }
5156
5157   gdk_window_invalidate_maybe_recurse (priv->window, region,
5158                                        invalidate_predicate, widget);
5159 }
5160
5161 /**
5162  * gtk_widget_size_allocate:
5163  * @widget: a #GtkWidget
5164  * @allocation: position and size to be allocated to @widget
5165  *
5166  * This function is only used by #GtkContainer subclasses, to assign a size
5167  * and position to their child widgets.
5168  *
5169  * In this function, the allocation may be adjusted. It will be forced
5170  * to a 1x1 minimum size, and the adjust_size_allocation virtual
5171  * method on the child will be used to adjust the allocation. Standard
5172  * adjustments include removing the widget's margins, and applying the
5173  * widget's #GtkWidget:halign and #GtkWidget:valign properties.
5174  **/
5175 void
5176 gtk_widget_size_allocate (GtkWidget     *widget,
5177                           GtkAllocation *allocation)
5178 {
5179   GtkWidgetPrivate *priv;
5180   GdkRectangle real_allocation;
5181   GdkRectangle old_allocation;
5182   GdkRectangle adjusted_allocation;
5183   gboolean alloc_needed;
5184   gboolean size_changed;
5185   gboolean position_changed;
5186   gint natural_width, natural_height, dummy;
5187   gint min_width, min_height;
5188
5189   priv = widget->priv;
5190
5191   g_return_if_fail (GTK_IS_WIDGET (widget));
5192
5193   if (!priv->visible && !gtk_widget_is_toplevel (widget))
5194     return;
5195
5196   gtk_widget_push_verify_invariants (widget);
5197
5198 #ifdef G_ENABLE_DEBUG
5199   if (gtk_get_debug_flags () & GTK_DEBUG_GEOMETRY)
5200     {
5201       gint depth;
5202       GtkWidget *parent;
5203       const gchar *name;
5204
5205       depth = 0;
5206       parent = widget;
5207       while (parent)
5208         {
5209           depth++;
5210           parent = gtk_widget_get_parent (parent);
5211         }
5212
5213       name = g_type_name (G_OBJECT_TYPE (G_OBJECT (widget)));
5214       g_print ("gtk_widget_size_allocate: %*s%s %d %d\n",
5215                2 * depth, " ", name,
5216                allocation->width, allocation->height);
5217     }
5218 #endif /* G_ENABLE_DEBUG */
5219
5220   alloc_needed = priv->alloc_needed;
5221   /* Preserve request/allocate ordering */
5222   priv->alloc_needed = FALSE;
5223
5224   old_allocation = priv->allocation;
5225   real_allocation = *allocation;
5226
5227   adjusted_allocation = real_allocation;
5228   if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
5229     {
5230       /* Go ahead and request the height for allocated width, note that the internals
5231        * of get_height_for_width will internally limit the for_size to natural size
5232        * when aligning implicitly.
5233        */
5234       gtk_widget_get_preferred_width (widget, &min_width, &natural_width);
5235       gtk_widget_get_preferred_height_for_width (widget, real_allocation.width, &min_height, &natural_height);
5236     }
5237   else
5238     {
5239       /* Go ahead and request the width for allocated height, note that the internals
5240        * of get_width_for_height will internally limit the for_size to natural size
5241        * when aligning implicitly.
5242        */
5243       gtk_widget_get_preferred_height (widget, &min_height, &natural_height);
5244       gtk_widget_get_preferred_width_for_height (widget, real_allocation.height, &min_width, &natural_width);
5245     }
5246
5247 #ifdef G_ENABLE_DEBUG
5248   if (gtk_get_debug_flags () & GTK_DEBUG_GEOMETRY)
5249     {
5250       if ((min_width > real_allocation.width || min_height > real_allocation.height) &&
5251           !GTK_IS_SCROLLABLE (widget))
5252         g_warning ("gtk_widget_size_allocate(): attempt to underallocate %s%s %s %p. "
5253                    "Allocation is %dx%d, but minimum required size is %dx%d.",
5254                    priv->parent ? G_OBJECT_TYPE_NAME (priv->parent) : "", priv->parent ? "'s child" : "toplevel",
5255                    G_OBJECT_TYPE_NAME (widget), widget,
5256                    real_allocation.width, real_allocation.height,
5257                    min_width, min_height);
5258     }
5259 #endif
5260   /* Now that we have the right natural height and width, go ahead and remove any margins from the
5261    * allocated sizes and possibly limit them to the natural sizes */
5262   GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
5263                                                          GTK_ORIENTATION_HORIZONTAL,
5264                                                          &dummy,
5265                                                          &natural_width,
5266                                                          &adjusted_allocation.x,
5267                                                          &adjusted_allocation.width);
5268   GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
5269                                                          GTK_ORIENTATION_VERTICAL,
5270                                                          &dummy,
5271                                                          &natural_height,
5272                                                          &adjusted_allocation.y,
5273                                                          &adjusted_allocation.height);
5274
5275   if (adjusted_allocation.x < real_allocation.x ||
5276       adjusted_allocation.y < real_allocation.y ||
5277       (adjusted_allocation.x + adjusted_allocation.width) >
5278       (real_allocation.x + real_allocation.width) ||
5279       (adjusted_allocation.y + adjusted_allocation.height >
5280        real_allocation.y + real_allocation.height))
5281     {
5282       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",
5283                  G_OBJECT_TYPE_NAME (widget), widget,
5284                  real_allocation.x, real_allocation.y, real_allocation.width, real_allocation.height,
5285                  adjusted_allocation.x, adjusted_allocation.y, adjusted_allocation.width, adjusted_allocation.height);
5286       adjusted_allocation = real_allocation; /* veto it */
5287     }
5288   else
5289     {
5290       real_allocation = adjusted_allocation;
5291     }
5292
5293   if (real_allocation.width < 0 || real_allocation.height < 0)
5294     {
5295       g_warning ("gtk_widget_size_allocate(): attempt to allocate widget with width %d and height %d",
5296                  real_allocation.width,
5297                  real_allocation.height);
5298     }
5299
5300   real_allocation.width = MAX (real_allocation.width, 1);
5301   real_allocation.height = MAX (real_allocation.height, 1);
5302
5303   size_changed = (old_allocation.width != real_allocation.width ||
5304                   old_allocation.height != real_allocation.height);
5305   position_changed = (old_allocation.x != real_allocation.x ||
5306                       old_allocation.y != real_allocation.y);
5307
5308   if (!alloc_needed && !size_changed && !position_changed)
5309     goto out;
5310
5311   g_signal_emit (widget, widget_signals[SIZE_ALLOCATE], 0, &real_allocation);
5312
5313   /* Size allocation is god... after consulting god, no further requests or allocations are needed */
5314   priv->alloc_needed = FALSE;
5315
5316   if (gtk_widget_get_mapped (widget))
5317     {
5318       if (!gtk_widget_get_has_window (widget) && priv->redraw_on_alloc && position_changed)
5319         {
5320           /* Invalidate union(old_allaction,priv->allocation) in priv->window
5321            */
5322           cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->allocation);
5323           cairo_region_union_rectangle (invalidate, &old_allocation);
5324
5325           gdk_window_invalidate_region (priv->window, invalidate, FALSE);
5326           cairo_region_destroy (invalidate);
5327         }
5328
5329       if (size_changed)
5330         {
5331           if (priv->redraw_on_alloc)
5332             {
5333               /* Invalidate union(old_allaction,priv->allocation) in priv->window and descendents owned by widget
5334                */
5335               cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->allocation);
5336               cairo_region_union_rectangle (invalidate, &old_allocation);
5337
5338               gtk_widget_invalidate_widget_windows (widget, invalidate);
5339               cairo_region_destroy (invalidate);
5340             }
5341         }
5342     }
5343
5344   if ((size_changed || position_changed) && priv->parent &&
5345       gtk_widget_get_realized (priv->parent) && _gtk_container_get_reallocate_redraws (GTK_CONTAINER (priv->parent)))
5346     {
5347       cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->parent->priv->allocation);
5348       gtk_widget_invalidate_widget_windows (priv->parent, invalidate);
5349       cairo_region_destroy (invalidate);
5350     }
5351
5352 out:
5353   gtk_widget_pop_verify_invariants (widget);
5354 }
5355
5356 /**
5357  * gtk_widget_common_ancestor:
5358  * @widget_a: a #GtkWidget
5359  * @widget_b: a #GtkWidget
5360  *
5361  * Find the common ancestor of @widget_a and @widget_b that
5362  * is closest to the two widgets.
5363  *
5364  * Return value: the closest common ancestor of @widget_a and
5365  *   @widget_b or %NULL if @widget_a and @widget_b do not
5366  *   share a common ancestor.
5367  **/
5368 static GtkWidget *
5369 gtk_widget_common_ancestor (GtkWidget *widget_a,
5370                             GtkWidget *widget_b)
5371 {
5372   GtkWidget *parent_a;
5373   GtkWidget *parent_b;
5374   gint depth_a = 0;
5375   gint depth_b = 0;
5376
5377   parent_a = widget_a;
5378   while (parent_a->priv->parent)
5379     {
5380       parent_a = parent_a->priv->parent;
5381       depth_a++;
5382     }
5383
5384   parent_b = widget_b;
5385   while (parent_b->priv->parent)
5386     {
5387       parent_b = parent_b->priv->parent;
5388       depth_b++;
5389     }
5390
5391   if (parent_a != parent_b)
5392     return NULL;
5393
5394   while (depth_a > depth_b)
5395     {
5396       widget_a = widget_a->priv->parent;
5397       depth_a--;
5398     }
5399
5400   while (depth_b > depth_a)
5401     {
5402       widget_b = widget_b->priv->parent;
5403       depth_b--;
5404     }
5405
5406   while (widget_a != widget_b)
5407     {
5408       widget_a = widget_a->priv->parent;
5409       widget_b = widget_b->priv->parent;
5410     }
5411
5412   return widget_a;
5413 }
5414
5415 /**
5416  * gtk_widget_translate_coordinates:
5417  * @src_widget:  a #GtkWidget
5418  * @dest_widget: a #GtkWidget
5419  * @src_x: X position relative to @src_widget
5420  * @src_y: Y position relative to @src_widget
5421  * @dest_x: (out): location to store X position relative to @dest_widget
5422  * @dest_y: (out): location to store Y position relative to @dest_widget
5423  *
5424  * Translate coordinates relative to @src_widget's allocation to coordinates
5425  * relative to @dest_widget's allocations. In order to perform this
5426  * operation, both widgets must be realized, and must share a common
5427  * toplevel.
5428  *
5429  * Return value: %FALSE if either widget was not realized, or there
5430  *   was no common ancestor. In this case, nothing is stored in
5431  *   *@dest_x and *@dest_y. Otherwise %TRUE.
5432  **/
5433 gboolean
5434 gtk_widget_translate_coordinates (GtkWidget  *src_widget,
5435                                   GtkWidget  *dest_widget,
5436                                   gint        src_x,
5437                                   gint        src_y,
5438                                   gint       *dest_x,
5439                                   gint       *dest_y)
5440 {
5441   GtkWidgetPrivate *src_priv = src_widget->priv;
5442   GtkWidgetPrivate *dest_priv = dest_widget->priv;
5443   GtkWidget *ancestor;
5444   GdkWindow *window;
5445   GList *dest_list = NULL;
5446
5447   g_return_val_if_fail (GTK_IS_WIDGET (src_widget), FALSE);
5448   g_return_val_if_fail (GTK_IS_WIDGET (dest_widget), FALSE);
5449
5450   ancestor = gtk_widget_common_ancestor (src_widget, dest_widget);
5451   if (!ancestor || !gtk_widget_get_realized (src_widget) || !gtk_widget_get_realized (dest_widget))
5452     return FALSE;
5453
5454   /* Translate from allocation relative to window relative */
5455   if (gtk_widget_get_has_window (src_widget) && src_priv->parent)
5456     {
5457       gint wx, wy;
5458       gdk_window_get_position (src_priv->window, &wx, &wy);
5459
5460       src_x -= wx - src_priv->allocation.x;
5461       src_y -= wy - src_priv->allocation.y;
5462     }
5463   else
5464     {
5465       src_x += src_priv->allocation.x;
5466       src_y += src_priv->allocation.y;
5467     }
5468
5469   /* Translate to the common ancestor */
5470   window = src_priv->window;
5471   while (window != ancestor->priv->window)
5472     {
5473       gdouble dx, dy;
5474
5475       gdk_window_coords_to_parent (window, src_x, src_y, &dx, &dy);
5476
5477       src_x = dx;
5478       src_y = dy;
5479
5480       window = gdk_window_get_effective_parent (window);
5481
5482       if (!window)              /* Handle GtkHandleBox */
5483         return FALSE;
5484     }
5485
5486   /* And back */
5487   window = dest_priv->window;
5488   while (window != ancestor->priv->window)
5489     {
5490       dest_list = g_list_prepend (dest_list, window);
5491
5492       window = gdk_window_get_effective_parent (window);
5493
5494       if (!window)              /* Handle GtkHandleBox */
5495         {
5496           g_list_free (dest_list);
5497           return FALSE;
5498         }
5499     }
5500
5501   while (dest_list)
5502     {
5503       gdouble dx, dy;
5504
5505       gdk_window_coords_from_parent (dest_list->data, src_x, src_y, &dx, &dy);
5506
5507       src_x = dx;
5508       src_y = dy;
5509
5510       dest_list = g_list_remove (dest_list, dest_list->data);
5511     }
5512
5513   /* Translate from window relative to allocation relative */
5514   if (gtk_widget_get_has_window (dest_widget) && dest_priv->parent)
5515     {
5516       gint wx, wy;
5517       gdk_window_get_position (dest_priv->window, &wx, &wy);
5518
5519       src_x += wx - dest_priv->allocation.x;
5520       src_y += wy - dest_priv->allocation.y;
5521     }
5522   else
5523     {
5524       src_x -= dest_priv->allocation.x;
5525       src_y -= dest_priv->allocation.y;
5526     }
5527
5528   if (dest_x)
5529     *dest_x = src_x;
5530   if (dest_y)
5531     *dest_y = src_y;
5532
5533   return TRUE;
5534 }
5535
5536 static void
5537 gtk_widget_real_size_allocate (GtkWidget     *widget,
5538                                GtkAllocation *allocation)
5539 {
5540   GtkWidgetPrivate *priv = widget->priv;
5541
5542   priv->allocation = *allocation;
5543
5544   if (gtk_widget_get_realized (widget) &&
5545       gtk_widget_get_has_window (widget))
5546      {
5547         gdk_window_move_resize (priv->window,
5548                                 allocation->x, allocation->y,
5549                                 allocation->width, allocation->height);
5550      }
5551 }
5552
5553 /* translate initial/final into start/end */
5554 static GtkAlign
5555 effective_align (GtkAlign         align,
5556                  GtkTextDirection direction)
5557 {
5558   switch (align)
5559     {
5560     case GTK_ALIGN_START:
5561       return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
5562     case GTK_ALIGN_END:
5563       return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
5564     default:
5565       return align;
5566     }
5567 }
5568
5569 static void
5570 adjust_for_align (GtkAlign  align,
5571                   gint     *natural_size,
5572                   gint     *allocated_pos,
5573                   gint     *allocated_size)
5574 {
5575   switch (align)
5576     {
5577     case GTK_ALIGN_FILL:
5578       /* change nothing */
5579       break;
5580     case GTK_ALIGN_START:
5581       /* keep *allocated_pos where it is */
5582       *allocated_size = MIN (*allocated_size, *natural_size);
5583       break;
5584     case GTK_ALIGN_END:
5585       if (*allocated_size > *natural_size)
5586         {
5587           *allocated_pos += (*allocated_size - *natural_size);
5588           *allocated_size = *natural_size;
5589         }
5590       break;
5591     case GTK_ALIGN_CENTER:
5592       if (*allocated_size > *natural_size)
5593         {
5594           *allocated_pos += (*allocated_size - *natural_size) / 2;
5595           *allocated_size = MIN (*allocated_size, *natural_size);
5596         }
5597       break;
5598     }
5599 }
5600
5601 static void
5602 adjust_for_margin(gint               start_margin,
5603                   gint               end_margin,
5604                   gint              *minimum_size,
5605                   gint              *natural_size,
5606                   gint              *allocated_pos,
5607                   gint              *allocated_size)
5608 {
5609   *minimum_size -= (start_margin + end_margin);
5610   *natural_size -= (start_margin + end_margin);
5611   *allocated_pos += start_margin;
5612   *allocated_size -= (start_margin + end_margin);
5613 }
5614
5615 static void
5616 gtk_widget_real_adjust_size_allocation (GtkWidget         *widget,
5617                                         GtkOrientation     orientation,
5618                                         gint              *minimum_size,
5619                                         gint              *natural_size,
5620                                         gint              *allocated_pos,
5621                                         gint              *allocated_size)
5622 {
5623   const GtkWidgetAuxInfo *aux_info;
5624
5625   aux_info = _gtk_widget_get_aux_info_or_defaults (widget);
5626
5627   if (orientation == GTK_ORIENTATION_HORIZONTAL)
5628     {
5629       adjust_for_margin (aux_info->margin.left,
5630                          aux_info->margin.right,
5631                          minimum_size, natural_size,
5632                          allocated_pos, allocated_size);
5633       adjust_for_align (effective_align (aux_info->halign, gtk_widget_get_direction (widget)),
5634                         natural_size, allocated_pos, allocated_size);
5635     }
5636   else
5637     {
5638       adjust_for_margin (aux_info->margin.top,
5639                          aux_info->margin.bottom,
5640                          minimum_size, natural_size,
5641                          allocated_pos, allocated_size);
5642       adjust_for_align (effective_align (aux_info->valign, GTK_TEXT_DIR_NONE),
5643                         natural_size, allocated_pos, allocated_size);
5644     }
5645 }
5646
5647 static gboolean
5648 gtk_widget_real_can_activate_accel (GtkWidget *widget,
5649                                     guint      signal_id)
5650 {
5651   GtkWidgetPrivate *priv = widget->priv;
5652
5653   /* widgets must be onscreen for accels to take effect */
5654   return gtk_widget_is_sensitive (widget) &&
5655          gtk_widget_is_drawable (widget) &&
5656          gdk_window_is_viewable (priv->window);
5657 }
5658
5659 /**
5660  * gtk_widget_can_activate_accel:
5661  * @widget: a #GtkWidget
5662  * @signal_id: the ID of a signal installed on @widget
5663  *
5664  * Determines whether an accelerator that activates the signal
5665  * identified by @signal_id can currently be activated.
5666  * This is done by emitting the #GtkWidget::can-activate-accel
5667  * signal on @widget; if the signal isn't overridden by a
5668  * handler or in a derived widget, then the default check is
5669  * that the widget must be sensitive, and the widget and all
5670  * its ancestors mapped.
5671  *
5672  * Return value: %TRUE if the accelerator can be activated.
5673  *
5674  * Since: 2.4
5675  **/
5676 gboolean
5677 gtk_widget_can_activate_accel (GtkWidget *widget,
5678                                guint      signal_id)
5679 {
5680   gboolean can_activate = FALSE;
5681   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
5682   g_signal_emit (widget, widget_signals[CAN_ACTIVATE_ACCEL], 0, signal_id, &can_activate);
5683   return can_activate;
5684 }
5685
5686 typedef struct {
5687   GClosure   closure;
5688   guint      signal_id;
5689 } AccelClosure;
5690
5691 static void
5692 closure_accel_activate (GClosure     *closure,
5693                         GValue       *return_value,
5694                         guint         n_param_values,
5695                         const GValue *param_values,
5696                         gpointer      invocation_hint,
5697                         gpointer      marshal_data)
5698 {
5699   AccelClosure *aclosure = (AccelClosure*) closure;
5700   gboolean can_activate = gtk_widget_can_activate_accel (closure->data, aclosure->signal_id);
5701
5702   if (can_activate)
5703     g_signal_emit (closure->data, aclosure->signal_id, 0);
5704
5705   /* whether accelerator was handled */
5706   g_value_set_boolean (return_value, can_activate);
5707 }
5708
5709 static void
5710 closures_destroy (gpointer data)
5711 {
5712   GSList *slist, *closures = data;
5713
5714   for (slist = closures; slist; slist = slist->next)
5715     {
5716       g_closure_invalidate (slist->data);
5717       g_closure_unref (slist->data);
5718     }
5719   g_slist_free (closures);
5720 }
5721
5722 static GClosure*
5723 widget_new_accel_closure (GtkWidget *widget,
5724                           guint      signal_id)
5725 {
5726   AccelClosure *aclosure;
5727   GClosure *closure = NULL;
5728   GSList *slist, *closures;
5729
5730   closures = g_object_steal_qdata (G_OBJECT (widget), quark_accel_closures);
5731   for (slist = closures; slist; slist = slist->next)
5732     if (!gtk_accel_group_from_accel_closure (slist->data))
5733       {
5734         /* reuse this closure */
5735         closure = slist->data;
5736         break;
5737       }
5738   if (!closure)
5739     {
5740       closure = g_closure_new_object (sizeof (AccelClosure), G_OBJECT (widget));
5741       closures = g_slist_prepend (closures, g_closure_ref (closure));
5742       g_closure_sink (closure);
5743       g_closure_set_marshal (closure, closure_accel_activate);
5744     }
5745   g_object_set_qdata_full (G_OBJECT (widget), quark_accel_closures, closures, closures_destroy);
5746
5747   aclosure = (AccelClosure*) closure;
5748   g_assert (closure->data == widget);
5749   g_assert (closure->marshal == closure_accel_activate);
5750   aclosure->signal_id = signal_id;
5751
5752   return closure;
5753 }
5754
5755 /**
5756  * gtk_widget_add_accelerator:
5757  * @widget:       widget to install an accelerator on
5758  * @accel_signal: widget signal to emit on accelerator activation
5759  * @accel_group:  accel group for this widget, added to its toplevel
5760  * @accel_key:    GDK keyval of the accelerator
5761  * @accel_mods:   modifier key combination of the accelerator
5762  * @accel_flags:  flag accelerators, e.g. %GTK_ACCEL_VISIBLE
5763  *
5764  * Installs an accelerator for this @widget in @accel_group that causes
5765  * @accel_signal to be emitted if the accelerator is activated.
5766  * The @accel_group needs to be added to the widget's toplevel via
5767  * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
5768  * Accelerators added through this function are not user changeable during
5769  * runtime. If you want to support accelerators that can be changed by the
5770  * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
5771  * gtk_menu_item_set_accel_path() instead.
5772  */
5773 void
5774 gtk_widget_add_accelerator (GtkWidget      *widget,
5775                             const gchar    *accel_signal,
5776                             GtkAccelGroup  *accel_group,
5777                             guint           accel_key,
5778                             GdkModifierType accel_mods,
5779                             GtkAccelFlags   accel_flags)
5780 {
5781   GClosure *closure;
5782   GSignalQuery query;
5783
5784   g_return_if_fail (GTK_IS_WIDGET (widget));
5785   g_return_if_fail (accel_signal != NULL);
5786   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
5787
5788   g_signal_query (g_signal_lookup (accel_signal, G_OBJECT_TYPE (widget)), &query);
5789   if (!query.signal_id ||
5790       !(query.signal_flags & G_SIGNAL_ACTION) ||
5791       query.return_type != G_TYPE_NONE ||
5792       query.n_params)
5793     {
5794       /* hmm, should be elaborate enough */
5795       g_warning (G_STRLOC ": widget `%s' has no activatable signal \"%s\" without arguments",
5796                  G_OBJECT_TYPE_NAME (widget), accel_signal);
5797       return;
5798     }
5799
5800   closure = widget_new_accel_closure (widget, query.signal_id);
5801
5802   g_object_ref (widget);
5803
5804   /* install the accelerator. since we don't map this onto an accel_path,
5805    * the accelerator will automatically be locked.
5806    */
5807   gtk_accel_group_connect (accel_group,
5808                            accel_key,
5809                            accel_mods,
5810                            accel_flags | GTK_ACCEL_LOCKED,
5811                            closure);
5812
5813   g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5814
5815   g_object_unref (widget);
5816 }
5817
5818 /**
5819  * gtk_widget_remove_accelerator:
5820  * @widget:       widget to install an accelerator on
5821  * @accel_group:  accel group for this widget
5822  * @accel_key:    GDK keyval of the accelerator
5823  * @accel_mods:   modifier key combination of the accelerator
5824  *
5825  * Removes an accelerator from @widget, previously installed with
5826  * gtk_widget_add_accelerator().
5827  *
5828  * Returns: whether an accelerator was installed and could be removed
5829  */
5830 gboolean
5831 gtk_widget_remove_accelerator (GtkWidget      *widget,
5832                                GtkAccelGroup  *accel_group,
5833                                guint           accel_key,
5834                                GdkModifierType accel_mods)
5835 {
5836   GtkAccelGroupEntry *ag_entry;
5837   GList *slist, *clist;
5838   guint n;
5839
5840   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
5841   g_return_val_if_fail (GTK_IS_ACCEL_GROUP (accel_group), FALSE);
5842
5843   ag_entry = gtk_accel_group_query (accel_group, accel_key, accel_mods, &n);
5844   clist = gtk_widget_list_accel_closures (widget);
5845   for (slist = clist; slist; slist = slist->next)
5846     {
5847       guint i;
5848
5849       for (i = 0; i < n; i++)
5850         if (slist->data == (gpointer) ag_entry[i].closure)
5851           {
5852             gboolean is_removed = gtk_accel_group_disconnect (accel_group, slist->data);
5853
5854             g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5855
5856             g_list_free (clist);
5857
5858             return is_removed;
5859           }
5860     }
5861   g_list_free (clist);
5862
5863   g_warning (G_STRLOC ": no accelerator (%u,%u) installed in accel group (%p) for %s (%p)",
5864              accel_key, accel_mods, accel_group,
5865              G_OBJECT_TYPE_NAME (widget), widget);
5866
5867   return FALSE;
5868 }
5869
5870 /**
5871  * gtk_widget_list_accel_closures:
5872  * @widget:  widget to list accelerator closures for
5873  *
5874  * Lists the closures used by @widget for accelerator group connections
5875  * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
5876  * The closures can be used to monitor accelerator changes on @widget,
5877  * by connecting to the @GtkAccelGroup::accel-changed signal of the
5878  * #GtkAccelGroup of a closure which can be found out with
5879  * gtk_accel_group_from_accel_closure().
5880  *
5881  * Return value: (transfer container) (element-type GClosure):
5882  *     a newly allocated #GList of closures
5883  */
5884 GList*
5885 gtk_widget_list_accel_closures (GtkWidget *widget)
5886 {
5887   GSList *slist;
5888   GList *clist = NULL;
5889
5890   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
5891
5892   for (slist = g_object_get_qdata (G_OBJECT (widget), quark_accel_closures); slist; slist = slist->next)
5893     if (gtk_accel_group_from_accel_closure (slist->data))
5894       clist = g_list_prepend (clist, slist->data);
5895   return clist;
5896 }
5897
5898 typedef struct {
5899   GQuark         path_quark;
5900   GtkAccelGroup *accel_group;
5901   GClosure      *closure;
5902 } AccelPath;
5903
5904 static void
5905 destroy_accel_path (gpointer data)
5906 {
5907   AccelPath *apath = data;
5908
5909   gtk_accel_group_disconnect (apath->accel_group, apath->closure);
5910
5911   /* closures_destroy takes care of unrefing the closure */
5912   g_object_unref (apath->accel_group);
5913
5914   g_slice_free (AccelPath, apath);
5915 }
5916
5917
5918 /**
5919  * gtk_widget_set_accel_path:
5920  * @widget: a #GtkWidget
5921  * @accel_path: (allow-none): path used to look up the accelerator
5922  * @accel_group: (allow-none): a #GtkAccelGroup.
5923  *
5924  * Given an accelerator group, @accel_group, and an accelerator path,
5925  * @accel_path, sets up an accelerator in @accel_group so whenever the
5926  * key binding that is defined for @accel_path is pressed, @widget
5927  * will be activated.  This removes any accelerators (for any
5928  * accelerator group) installed by previous calls to
5929  * gtk_widget_set_accel_path(). Associating accelerators with
5930  * paths allows them to be modified by the user and the modifications
5931  * to be saved for future use. (See gtk_accel_map_save().)
5932  *
5933  * This function is a low level function that would most likely
5934  * be used by a menu creation system like #GtkUIManager. If you
5935  * use #GtkUIManager, setting up accelerator paths will be done
5936  * automatically.
5937  *
5938  * Even when you you aren't using #GtkUIManager, if you only want to
5939  * set up accelerators on menu items gtk_menu_item_set_accel_path()
5940  * provides a somewhat more convenient interface.
5941  *
5942  * Note that @accel_path string will be stored in a #GQuark. Therefore, if you
5943  * pass a static string, you can save some memory by interning it first with
5944  * g_intern_static_string().
5945  **/
5946 void
5947 gtk_widget_set_accel_path (GtkWidget     *widget,
5948                            const gchar   *accel_path,
5949                            GtkAccelGroup *accel_group)
5950 {
5951   AccelPath *apath;
5952
5953   g_return_if_fail (GTK_IS_WIDGET (widget));
5954   g_return_if_fail (GTK_WIDGET_GET_CLASS (widget)->activate_signal != 0);
5955
5956   if (accel_path)
5957     {
5958       g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
5959       g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
5960
5961       gtk_accel_map_add_entry (accel_path, 0, 0);
5962       apath = g_slice_new (AccelPath);
5963       apath->accel_group = g_object_ref (accel_group);
5964       apath->path_quark = g_quark_from_string (accel_path);
5965       apath->closure = widget_new_accel_closure (widget, GTK_WIDGET_GET_CLASS (widget)->activate_signal);
5966     }
5967   else
5968     apath = NULL;
5969
5970   /* also removes possible old settings */
5971   g_object_set_qdata_full (G_OBJECT (widget), quark_accel_path, apath, destroy_accel_path);
5972
5973   if (apath)
5974     gtk_accel_group_connect_by_path (apath->accel_group, g_quark_to_string (apath->path_quark), apath->closure);
5975
5976   g_signal_emit (widget, widget_signals[ACCEL_CLOSURES_CHANGED], 0);
5977 }
5978
5979 const gchar*
5980 _gtk_widget_get_accel_path (GtkWidget *widget,
5981                             gboolean  *locked)
5982 {
5983   AccelPath *apath;
5984
5985   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
5986
5987   apath = g_object_get_qdata (G_OBJECT (widget), quark_accel_path);
5988   if (locked)
5989     *locked = apath ? gtk_accel_group_get_is_locked (apath->accel_group) : TRUE;
5990   return apath ? g_quark_to_string (apath->path_quark) : NULL;
5991 }
5992
5993 /**
5994  * gtk_widget_mnemonic_activate:
5995  * @widget: a #GtkWidget
5996  * @group_cycling:  %TRUE if there are other widgets with the same mnemonic
5997  *
5998  * Emits the #GtkWidget::mnemonic-activate signal.
5999  *
6000  * The default handler for this signal activates the @widget if
6001  * @group_cycling is %FALSE, and just grabs the focus if @group_cycling
6002  * is %TRUE.
6003  *
6004  * Returns: %TRUE if the signal has been handled
6005  */
6006 gboolean
6007 gtk_widget_mnemonic_activate (GtkWidget *widget,
6008                               gboolean   group_cycling)
6009 {
6010   gboolean handled;
6011
6012   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6013
6014   group_cycling = group_cycling != FALSE;
6015   if (!gtk_widget_is_sensitive (widget))
6016     handled = TRUE;
6017   else
6018     g_signal_emit (widget,
6019                    widget_signals[MNEMONIC_ACTIVATE],
6020                    0,
6021                    group_cycling,
6022                    &handled);
6023   return handled;
6024 }
6025
6026 static gboolean
6027 gtk_widget_real_mnemonic_activate (GtkWidget *widget,
6028                                    gboolean   group_cycling)
6029 {
6030   if (!group_cycling && GTK_WIDGET_GET_CLASS (widget)->activate_signal)
6031     gtk_widget_activate (widget);
6032   else if (gtk_widget_get_can_focus (widget))
6033     gtk_widget_grab_focus (widget);
6034   else
6035     {
6036       g_warning ("widget `%s' isn't suitable for mnemonic activation",
6037                  G_OBJECT_TYPE_NAME (widget));
6038       gtk_widget_error_bell (widget);
6039     }
6040   return TRUE;
6041 }
6042
6043 static const cairo_user_data_key_t event_key;
6044
6045 GdkEventExpose *
6046 _gtk_cairo_get_event (cairo_t *cr)
6047 {
6048   g_return_val_if_fail (cr != NULL, NULL);
6049
6050   return cairo_get_user_data (cr, &event_key);
6051 }
6052
6053 static void
6054 gtk_cairo_set_event (cairo_t        *cr,
6055                      GdkEventExpose *event)
6056 {
6057   cairo_set_user_data (cr, &event_key, event, NULL);
6058 }
6059
6060 /**
6061  * gtk_cairo_should_draw_window:
6062  * @cr: a cairo context
6063  * @window: the window to check. @window may not be an input-only
6064  *          window.
6065  *
6066  * This function is supposed to be called in #GtkWidget::draw
6067  * implementations for widgets that support multiple windows.
6068  * @cr must be untransformed from invoking of the draw function.
6069  * This function will return %TRUE if the contents of the given
6070  * @window are supposed to be drawn and %FALSE otherwise. Note
6071  * that when the drawing was not initiated by the windowing
6072  * system this function will return %TRUE for all windows, so
6073  * you need to draw the bottommost window first. Also, do not
6074  * use "else if" statements to check which window should be drawn.
6075  *
6076  * Returns: %TRUE if @window should be drawn
6077  *
6078  * Since: 3.0
6079  **/
6080 gboolean
6081 gtk_cairo_should_draw_window (cairo_t *cr,
6082                               GdkWindow *window)
6083 {
6084   GdkEventExpose *event;
6085
6086   g_return_val_if_fail (cr != NULL, FALSE);
6087   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
6088
6089   event = _gtk_cairo_get_event (cr);
6090
6091   return event == NULL ||
6092          event->window == window;
6093 }
6094
6095 static gboolean
6096 gtk_widget_get_clip_draw (GtkWidget *widget)
6097 {
6098   /* labels are not clipped, because clipping them would cause
6099    * mnemonics to not appear on characters that go beyond the
6100    * baseline.
6101    * https://bugzilla.gnome.org/show_bug.cgi?id=648570
6102    */
6103   if (GTK_IS_LABEL (widget))
6104     return FALSE;
6105
6106   return TRUE;
6107 }
6108
6109 /* code shared by gtk_container_propagate_draw() and
6110  * gtk_widget_draw()
6111  */
6112 void
6113 _gtk_widget_draw_internal (GtkWidget *widget,
6114                            cairo_t   *cr,
6115                            gboolean   clip_to_size)
6116 {
6117   if (!gtk_widget_is_drawable (widget))
6118     return;
6119
6120   clip_to_size &= gtk_widget_get_clip_draw (widget);
6121
6122   if (clip_to_size)
6123     {
6124       cairo_rectangle (cr,
6125                        0, 0,
6126                        widget->priv->allocation.width,
6127                        widget->priv->allocation.height);
6128       cairo_clip (cr);
6129     }
6130
6131   if (gdk_cairo_get_clip_rectangle (cr, NULL))
6132     {
6133       gboolean result;
6134
6135       g_signal_emit (widget, widget_signals[DRAW],
6136                      0, cr,
6137                      &result);
6138
6139       if (cairo_status (cr) &&
6140           _gtk_cairo_get_event (cr))
6141         {
6142           /* We check the event so we only warn about internal GTK calls.
6143            * Errors might come from PDF streams having write failures and
6144            * we don't want to spam stderr in that case.
6145            * We do want to catch errors from
6146            */
6147           g_warning ("drawing failure for widget `%s': %s",
6148                      G_OBJECT_TYPE_NAME (widget),
6149                      cairo_status_to_string (cairo_status (cr)));
6150         }
6151     }
6152 }
6153
6154 /**
6155  * gtk_widget_draw:
6156  * @widget: the widget to draw. It must be drawable (see
6157  *   gtk_widget_is_drawable()) and a size must have been allocated.
6158  * @cr: a cairo context to draw to
6159  *
6160  * Draws @widget to @cr. The top left corner of the widget will be
6161  * drawn to the currently set origin point of @cr.
6162  *
6163  * You should pass a cairo context as @cr argument that is in an
6164  * original state. Otherwise the resulting drawing is undefined. For
6165  * example changing the operator using cairo_set_operator() or the
6166  * line width using cairo_set_line_width() might have unwanted side
6167  * effects.
6168  * You may however change the context's transform matrix - like with
6169  * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
6170  * region with cairo_clip() prior to calling this function. Also, it
6171  * is fine to modify the context with cairo_save() and
6172  * cairo_push_group() prior to calling this function.
6173  *
6174  * <note><para>Special purpose widgets may contain special code for
6175  * rendering to the screen and might appear differently on screen
6176  * and when rendered using gtk_widget_draw().</para></note>
6177  *
6178  * Since: 3.0
6179  **/
6180 void
6181 gtk_widget_draw (GtkWidget *widget,
6182                  cairo_t   *cr)
6183 {
6184   GdkEventExpose *tmp_event;
6185
6186   g_return_if_fail (GTK_IS_WIDGET (widget));
6187   g_return_if_fail (!widget->priv->alloc_needed);
6188   g_return_if_fail (cr != NULL);
6189
6190   cairo_save (cr);
6191   /* We have to reset the event here so that draw functions can call
6192    * gtk_widget_draw() on random other widgets and get the desired
6193    * effect: Drawing all contents, not just the current window.
6194    */
6195   tmp_event = _gtk_cairo_get_event (cr);
6196   gtk_cairo_set_event (cr, NULL);
6197
6198   _gtk_widget_draw_internal (widget, cr, TRUE);
6199
6200   gtk_cairo_set_event (cr, tmp_event);
6201   cairo_restore (cr);
6202 }
6203
6204 static gboolean
6205 gtk_widget_real_key_press_event (GtkWidget         *widget,
6206                                  GdkEventKey       *event)
6207 {
6208   return gtk_bindings_activate_event (G_OBJECT (widget), event);
6209 }
6210
6211 static gboolean
6212 gtk_widget_real_key_release_event (GtkWidget         *widget,
6213                                    GdkEventKey       *event)
6214 {
6215   return gtk_bindings_activate_event (G_OBJECT (widget), event);
6216 }
6217
6218 static gboolean
6219 gtk_widget_real_focus_in_event (GtkWidget     *widget,
6220                                 GdkEventFocus *event)
6221 {
6222   gtk_widget_queue_draw (widget);
6223
6224   return FALSE;
6225 }
6226
6227 static gboolean
6228 gtk_widget_real_focus_out_event (GtkWidget     *widget,
6229                                  GdkEventFocus *event)
6230 {
6231   gtk_widget_queue_draw (widget);
6232
6233   return FALSE;
6234 }
6235
6236 static gboolean
6237 gtk_widget_real_touch_event (GtkWidget     *widget,
6238                              GdkEventTouch *event)
6239 {
6240   GdkEvent *bevent;
6241   gboolean return_val;
6242   gint signum;
6243
6244   if (!event->emulating_pointer)
6245     return FALSE;
6246
6247   if (event->type == GDK_TOUCH_BEGIN ||
6248       event->type == GDK_TOUCH_END)
6249     {
6250       GdkEventType type;
6251
6252       if (event->type == GDK_TOUCH_BEGIN)
6253         {
6254           type = GDK_BUTTON_PRESS;
6255           signum = BUTTON_PRESS_EVENT;
6256         }
6257       else
6258         {
6259           type = GDK_BUTTON_RELEASE;
6260           signum = BUTTON_RELEASE_EVENT;
6261         }
6262       bevent = gdk_event_new (type);
6263       bevent->any.window = g_object_ref (event->window);
6264       bevent->any.send_event = FALSE;
6265       bevent->button.time = event->time;
6266       bevent->button.state = event->state;
6267       bevent->button.button = 1;
6268       bevent->button.x_root = event->x_root;
6269       bevent->button.y_root = event->y_root;
6270       bevent->button.x = event->x;
6271       bevent->button.y = event->y;
6272       bevent->button.device = event->device;
6273       bevent->button.axes = g_memdup (event->axes,
6274                                       sizeof (gdouble) * gdk_device_get_n_axes (event->device));
6275       gdk_event_set_source_device (bevent, gdk_event_get_source_device ((GdkEvent*)event));
6276     }
6277   else if (event->type == GDK_TOUCH_UPDATE)
6278     {
6279       signum = MOTION_NOTIFY_EVENT;
6280       bevent = gdk_event_new (GDK_MOTION_NOTIFY);
6281       bevent->any.window = g_object_ref (event->window);
6282       bevent->any.send_event = FALSE;
6283       bevent->motion.time = event->time;
6284       bevent->motion.state = event->state;
6285       bevent->motion.x_root = event->x_root;
6286       bevent->motion.y_root = event->y_root;
6287       bevent->motion.x = event->x;
6288       bevent->motion.y = event->y;
6289       bevent->motion.device = event->device;
6290       bevent->motion.is_hint = FALSE;
6291       bevent->motion.axes = g_memdup (event->axes,
6292                                       sizeof (gdouble) * gdk_device_get_n_axes (event->device));
6293       gdk_event_set_source_device (bevent, gdk_event_get_source_device ((GdkEvent*)event));
6294     }
6295   else
6296     return FALSE;
6297
6298   g_signal_emit (widget, widget_signals[signum], 0, bevent, &return_val);
6299
6300   gdk_event_free (bevent);
6301
6302   return return_val;
6303 }
6304
6305
6306 #define WIDGET_REALIZED_FOR_EVENT(widget, event) \
6307      (event->type == GDK_FOCUS_CHANGE || gtk_widget_get_realized(widget))
6308
6309 /**
6310  * gtk_widget_event:
6311  * @widget: a #GtkWidget
6312  * @event: a #GdkEvent
6313  *
6314  * Rarely-used function. This function is used to emit
6315  * the event signals on a widget (those signals should never
6316  * be emitted without using this function to do so).
6317  * If you want to synthesize an event though, don't use this function;
6318  * instead, use gtk_main_do_event() so the event will behave as if
6319  * it were in the event queue. Don't synthesize expose events; instead,
6320  * use gdk_window_invalidate_rect() to invalidate a region of the
6321  * window.
6322  *
6323  * Return value: return from the event signal emission (%TRUE if
6324  *               the event was handled)
6325  **/
6326 gboolean
6327 gtk_widget_event (GtkWidget *widget,
6328                   GdkEvent  *event)
6329 {
6330   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6331   g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
6332
6333   if (event->type == GDK_EXPOSE)
6334     {
6335       g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get "
6336                  "the same effect, call gdk_window_invalidate_rect/region(), "
6337                  "followed by gdk_window_process_updates().");
6338       return TRUE;
6339     }
6340
6341   return gtk_widget_event_internal (widget, event);
6342 }
6343
6344 void
6345 _gtk_widget_set_captured_event_handler (GtkWidget               *widget,
6346                                         GtkCapturedEventHandler  callback)
6347 {
6348   g_object_set_data (G_OBJECT (widget), "captured-event-handler", callback);
6349 }
6350
6351 gboolean
6352 _gtk_widget_captured_event (GtkWidget *widget,
6353                             GdkEvent  *event)
6354 {
6355   gboolean return_val = FALSE;
6356   GtkCapturedEventHandler handler;
6357
6358   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6359   g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
6360
6361   if (event->type == GDK_EXPOSE)
6362     {
6363       g_warning ("Events of type GDK_EXPOSE cannot be synthesized. To get "
6364                  "the same effect, call gdk_window_invalidate_rect/region(), "
6365                  "followed by gdk_window_process_updates().");
6366       return TRUE;
6367     }
6368
6369   if (!event_window_is_still_viewable (event))
6370     return TRUE;
6371
6372   handler = g_object_get_data (G_OBJECT (widget), "captured-event-handler");
6373   if (!handler)
6374     return FALSE;
6375
6376   g_object_ref (widget);
6377
6378   return_val = handler (widget, event);
6379   return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
6380
6381   /* The widget that was originally to receive the event
6382    * handles motion hints, but the capturing widget might
6383    * not, so ensure we get further motion events.
6384    */
6385   if (return_val &&
6386       event->type == GDK_MOTION_NOTIFY &&
6387       event->motion.is_hint &&
6388       (gdk_window_get_events (event->any.window) &
6389        GDK_POINTER_MOTION_HINT_MASK) != 0)
6390     gdk_event_request_motions (&event->motion);
6391
6392   g_object_unref (widget);
6393
6394   return return_val;
6395 }
6396
6397 /* Returns TRUE if a translation should be done */
6398 gboolean
6399 _gtk_widget_get_translation_to_window (GtkWidget      *widget,
6400                                        GdkWindow      *window,
6401                                        int            *x,
6402                                        int            *y)
6403 {
6404   GdkWindow *w, *widget_window;
6405
6406   if (!gtk_widget_get_has_window (widget))
6407     {
6408       *x = -widget->priv->allocation.x;
6409       *y = -widget->priv->allocation.y;
6410     }
6411   else
6412     {
6413       *x = 0;
6414       *y = 0;
6415     }
6416
6417   widget_window = gtk_widget_get_window (widget);
6418
6419   for (w = window; w && w != widget_window; w = gdk_window_get_parent (w))
6420     {
6421       int wx, wy;
6422       gdk_window_get_position (w, &wx, &wy);
6423       *x += wx;
6424       *y += wy;
6425     }
6426
6427   if (w == NULL)
6428     {
6429       *x = 0;
6430       *y = 0;
6431       return FALSE;
6432     }
6433
6434   return TRUE;
6435 }
6436
6437
6438 /**
6439  * gtk_cairo_transform_to_window:
6440  * @cr: the cairo context to transform
6441  * @widget: the widget the context is currently centered for
6442  * @window: the window to transform the context to
6443  *
6444  * Transforms the given cairo context @cr that from @widget-relative
6445  * coordinates to @window-relative coordinates.
6446  * If the @widget's window is not an ancestor of @window, no
6447  * modification will be applied.
6448  *
6449  * This is the inverse to the transformation GTK applies when
6450  * preparing an expose event to be emitted with the #GtkWidget::draw
6451  * signal. It is intended to help porting multiwindow widgets from
6452  * GTK+ 2 to the rendering architecture of GTK+ 3.
6453  *
6454  * Since: 3.0
6455  **/
6456 void
6457 gtk_cairo_transform_to_window (cairo_t   *cr,
6458                                GtkWidget *widget,
6459                                GdkWindow *window)
6460 {
6461   int x, y;
6462
6463   g_return_if_fail (cr != NULL);
6464   g_return_if_fail (GTK_IS_WIDGET (widget));
6465   g_return_if_fail (GDK_IS_WINDOW (window));
6466
6467   if (_gtk_widget_get_translation_to_window (widget, window, &x, &y))
6468     cairo_translate (cr, x, y);
6469 }
6470
6471 /**
6472  * gtk_widget_send_expose:
6473  * @widget: a #GtkWidget
6474  * @event: a expose #GdkEvent
6475  *
6476  * Very rarely-used function. This function is used to emit
6477  * an expose event on a widget. This function is not normally used
6478  * directly. The only time it is used is when propagating an expose
6479  * event to a child %NO_WINDOW widget, and that is normally done
6480  * using gtk_container_propagate_draw().
6481  *
6482  * If you want to force an area of a window to be redrawn,
6483  * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
6484  * To cause the redraw to be done immediately, follow that call
6485  * with a call to gdk_window_process_updates().
6486  *
6487  * Return value: return from the event signal emission (%TRUE if
6488  *               the event was handled)
6489  **/
6490 gint
6491 gtk_widget_send_expose (GtkWidget *widget,
6492                         GdkEvent  *event)
6493 {
6494   gboolean result = FALSE;
6495   cairo_t *cr;
6496   int x, y;
6497   gboolean do_clip;
6498
6499   g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
6500   g_return_val_if_fail (gtk_widget_get_realized (widget), TRUE);
6501   g_return_val_if_fail (event != NULL, TRUE);
6502   g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE);
6503
6504   cr = gdk_cairo_create (event->expose.window);
6505   gtk_cairo_set_event (cr, &event->expose);
6506
6507   gdk_cairo_region (cr, event->expose.region);
6508   cairo_clip (cr);
6509
6510   do_clip = _gtk_widget_get_translation_to_window (widget,
6511                                                    event->expose.window,
6512                                                    &x, &y);
6513   cairo_translate (cr, -x, -y);
6514
6515   _gtk_widget_draw_internal (widget, cr, do_clip);
6516
6517   /* unset here, so if someone keeps a reference to cr we
6518    * don't leak the window. */
6519   gtk_cairo_set_event (cr, NULL);
6520   cairo_destroy (cr);
6521
6522   return result;
6523 }
6524
6525 static gboolean
6526 event_window_is_still_viewable (GdkEvent *event)
6527 {
6528   /* Check that we think the event's window is viewable before
6529    * delivering the event, to prevent suprises. We do this here
6530    * at the last moment, since the event may have been queued
6531    * up behind other events, held over a recursive main loop, etc.
6532    */
6533   switch (event->type)
6534     {
6535     case GDK_EXPOSE:
6536     case GDK_MOTION_NOTIFY:
6537     case GDK_BUTTON_PRESS:
6538     case GDK_2BUTTON_PRESS:
6539     case GDK_3BUTTON_PRESS:
6540     case GDK_KEY_PRESS:
6541     case GDK_ENTER_NOTIFY:
6542     case GDK_PROXIMITY_IN:
6543     case GDK_SCROLL:
6544       return event->any.window && gdk_window_is_viewable (event->any.window);
6545
6546 #if 0
6547     /* The following events are the second half of paired events;
6548      * we always deliver them to deal with widgets that clean up
6549      * on the second half.
6550      */
6551     case GDK_BUTTON_RELEASE:
6552     case GDK_KEY_RELEASE:
6553     case GDK_LEAVE_NOTIFY:
6554     case GDK_PROXIMITY_OUT:
6555 #endif
6556
6557     default:
6558       /* Remaining events would make sense on an not-viewable window,
6559        * or don't have an associated window.
6560        */
6561       return TRUE;
6562     }
6563 }
6564
6565 static gint
6566 gtk_widget_event_internal (GtkWidget *widget,
6567                            GdkEvent  *event)
6568 {
6569   gboolean return_val = FALSE;
6570
6571   /* We check only once for is-still-visible; if someone
6572    * hides the window in on of the signals on the widget,
6573    * they are responsible for returning TRUE to terminate
6574    * handling.
6575    */
6576   if (!event_window_is_still_viewable (event))
6577     return TRUE;
6578
6579   g_object_ref (widget);
6580
6581   g_signal_emit (widget, widget_signals[EVENT], 0, event, &return_val);
6582   return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
6583   if (!return_val)
6584     {
6585       gint signal_num;
6586
6587       switch (event->type)
6588         {
6589         case GDK_EXPOSE:
6590         case GDK_NOTHING:
6591           signal_num = -1;
6592           break;
6593         case GDK_BUTTON_PRESS:
6594         case GDK_2BUTTON_PRESS:
6595         case GDK_3BUTTON_PRESS:
6596           signal_num = BUTTON_PRESS_EVENT;
6597           break;
6598         case GDK_TOUCH_BEGIN:
6599         case GDK_TOUCH_UPDATE:
6600         case GDK_TOUCH_END:
6601         case GDK_TOUCH_CANCEL:
6602           signal_num = TOUCH_EVENT;
6603           break;
6604         case GDK_SCROLL:
6605           signal_num = SCROLL_EVENT;
6606           break;
6607         case GDK_BUTTON_RELEASE:
6608           signal_num = BUTTON_RELEASE_EVENT;
6609           break;
6610         case GDK_MOTION_NOTIFY:
6611           signal_num = MOTION_NOTIFY_EVENT;
6612           break;
6613         case GDK_DELETE:
6614           signal_num = DELETE_EVENT;
6615           break;
6616         case GDK_DESTROY:
6617           signal_num = DESTROY_EVENT;
6618           _gtk_tooltip_hide (widget);
6619           break;
6620         case GDK_KEY_PRESS:
6621           signal_num = KEY_PRESS_EVENT;
6622           break;
6623         case GDK_KEY_RELEASE:
6624           signal_num = KEY_RELEASE_EVENT;
6625           break;
6626         case GDK_ENTER_NOTIFY:
6627           signal_num = ENTER_NOTIFY_EVENT;
6628           break;
6629         case GDK_LEAVE_NOTIFY:
6630           signal_num = LEAVE_NOTIFY_EVENT;
6631           break;
6632         case GDK_FOCUS_CHANGE:
6633           signal_num = event->focus_change.in ? FOCUS_IN_EVENT : FOCUS_OUT_EVENT;
6634           if (event->focus_change.in)
6635             _gtk_tooltip_focus_in (widget);
6636           else
6637             _gtk_tooltip_focus_out (widget);
6638           break;
6639         case GDK_CONFIGURE:
6640           signal_num = CONFIGURE_EVENT;
6641           break;
6642         case GDK_MAP:
6643           signal_num = MAP_EVENT;
6644           break;
6645         case GDK_UNMAP:
6646           signal_num = UNMAP_EVENT;
6647           break;
6648         case GDK_WINDOW_STATE:
6649           signal_num = WINDOW_STATE_EVENT;
6650           break;
6651         case GDK_PROPERTY_NOTIFY:
6652           signal_num = PROPERTY_NOTIFY_EVENT;
6653           break;
6654         case GDK_SELECTION_CLEAR:
6655           signal_num = SELECTION_CLEAR_EVENT;
6656           break;
6657         case GDK_SELECTION_REQUEST:
6658           signal_num = SELECTION_REQUEST_EVENT;
6659           break;
6660         case GDK_SELECTION_NOTIFY:
6661           signal_num = SELECTION_NOTIFY_EVENT;
6662           break;
6663         case GDK_PROXIMITY_IN:
6664           signal_num = PROXIMITY_IN_EVENT;
6665           break;
6666         case GDK_PROXIMITY_OUT:
6667           signal_num = PROXIMITY_OUT_EVENT;
6668           break;
6669         case GDK_VISIBILITY_NOTIFY:
6670           signal_num = VISIBILITY_NOTIFY_EVENT;
6671           break;
6672         case GDK_GRAB_BROKEN:
6673           signal_num = GRAB_BROKEN_EVENT;
6674           break;
6675         case GDK_DAMAGE:
6676           signal_num = DAMAGE_EVENT;
6677           break;
6678         default:
6679           g_warning ("gtk_widget_event(): unhandled event type: %d", event->type);
6680           signal_num = -1;
6681           break;
6682         }
6683       if (signal_num != -1)
6684         g_signal_emit (widget, widget_signals[signal_num], 0, event, &return_val);
6685     }
6686   if (WIDGET_REALIZED_FOR_EVENT (widget, event))
6687     g_signal_emit (widget, widget_signals[EVENT_AFTER], 0, event);
6688   else
6689     return_val = TRUE;
6690
6691   g_object_unref (widget);
6692
6693   return return_val;
6694 }
6695
6696 /**
6697  * gtk_widget_activate:
6698  * @widget: a #GtkWidget that's activatable
6699  *
6700  * For widgets that can be "activated" (buttons, menu items, etc.)
6701  * this function activates them. Activation is what happens when you
6702  * press Enter on a widget during key navigation. If @widget isn't
6703  * activatable, the function returns %FALSE.
6704  *
6705  * Return value: %TRUE if the widget was activatable
6706  **/
6707 gboolean
6708 gtk_widget_activate (GtkWidget *widget)
6709 {
6710   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6711
6712   if (WIDGET_CLASS (widget)->activate_signal)
6713     {
6714       /* FIXME: we should eventually check the signals signature here */
6715       g_signal_emit (widget, WIDGET_CLASS (widget)->activate_signal, 0);
6716
6717       return TRUE;
6718     }
6719   else
6720     return FALSE;
6721 }
6722
6723 static void
6724 gtk_widget_reparent_subwindows (GtkWidget *widget,
6725                                 GdkWindow *new_window)
6726 {
6727   GtkWidgetPrivate *priv = widget->priv;
6728
6729   if (!gtk_widget_get_has_window (widget))
6730     {
6731       GList *children = gdk_window_get_children (priv->window);
6732       GList *tmp_list;
6733
6734       for (tmp_list = children; tmp_list; tmp_list = tmp_list->next)
6735         {
6736           GdkWindow *window = tmp_list->data;
6737           gpointer child;
6738
6739           gdk_window_get_user_data (window, &child);
6740           while (child && child != widget)
6741             child = ((GtkWidget*) child)->priv->parent;
6742
6743           if (child)
6744             gdk_window_reparent (window, new_window, 0, 0);
6745         }
6746
6747       g_list_free (children);
6748     }
6749   else
6750    {
6751      GdkWindow *parent;
6752      GList *tmp_list, *children;
6753
6754      parent = gdk_window_get_parent (priv->window);
6755
6756      if (parent == NULL)
6757        gdk_window_reparent (priv->window, new_window, 0, 0);
6758      else
6759        {
6760          children = gdk_window_get_children (parent);
6761
6762          for (tmp_list = children; tmp_list; tmp_list = tmp_list->next)
6763            {
6764              GdkWindow *window = tmp_list->data;
6765              gpointer child;
6766
6767              gdk_window_get_user_data (window, &child);
6768
6769              if (child == widget)
6770                gdk_window_reparent (window, new_window, 0, 0);
6771            }
6772
6773          g_list_free (children);
6774        }
6775    }
6776 }
6777
6778 static void
6779 gtk_widget_reparent_fixup_child (GtkWidget *widget,
6780                                  gpointer   client_data)
6781 {
6782   GtkWidgetPrivate *priv = widget->priv;
6783
6784   g_assert (client_data != NULL);
6785
6786   if (!gtk_widget_get_has_window (widget))
6787     {
6788       if (priv->window)
6789         g_object_unref (priv->window);
6790       priv->window = (GdkWindow*) client_data;
6791       if (priv->window)
6792         g_object_ref (priv->window);
6793
6794       if (GTK_IS_CONTAINER (widget))
6795         gtk_container_forall (GTK_CONTAINER (widget),
6796                               gtk_widget_reparent_fixup_child,
6797                               client_data);
6798     }
6799 }
6800
6801 /**
6802  * gtk_widget_reparent:
6803  * @widget: a #GtkWidget
6804  * @new_parent: a #GtkContainer to move the widget into
6805  *
6806  * Moves a widget from one #GtkContainer to another, handling reference
6807  * count issues to avoid destroying the widget.
6808  **/
6809 void
6810 gtk_widget_reparent (GtkWidget *widget,
6811                      GtkWidget *new_parent)
6812 {
6813   GtkWidgetPrivate *priv;
6814
6815   g_return_if_fail (GTK_IS_WIDGET (widget));
6816   g_return_if_fail (GTK_IS_CONTAINER (new_parent));
6817   priv = widget->priv;
6818   g_return_if_fail (priv->parent != NULL);
6819
6820   if (priv->parent != new_parent)
6821     {
6822       /* First try to see if we can get away without unrealizing
6823        * the widget as we reparent it. if so we set a flag so
6824        * that gtk_widget_unparent doesn't unrealize widget
6825        */
6826       if (gtk_widget_get_realized (widget) && gtk_widget_get_realized (new_parent))
6827         priv->in_reparent = TRUE;
6828
6829       g_object_ref (widget);
6830       gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
6831       gtk_container_add (GTK_CONTAINER (new_parent), widget);
6832       g_object_unref (widget);
6833
6834       if (priv->in_reparent)
6835         {
6836           priv->in_reparent = FALSE;
6837
6838           gtk_widget_reparent_subwindows (widget, gtk_widget_get_parent_window (widget));
6839           gtk_widget_reparent_fixup_child (widget,
6840                                            gtk_widget_get_parent_window (widget));
6841         }
6842
6843       g_object_notify (G_OBJECT (widget), "parent");
6844     }
6845 }
6846
6847 /**
6848  * gtk_widget_intersect:
6849  * @widget: a #GtkWidget
6850  * @area: a rectangle
6851  * @intersection: rectangle to store intersection of @widget and @area
6852  *
6853  * Computes the intersection of a @widget's area and @area, storing
6854  * the intersection in @intersection, and returns %TRUE if there was
6855  * an intersection.  @intersection may be %NULL if you're only
6856  * interested in whether there was an intersection.
6857  *
6858  * Return value: %TRUE if there was an intersection
6859  **/
6860 gboolean
6861 gtk_widget_intersect (GtkWidget          *widget,
6862                       const GdkRectangle *area,
6863                       GdkRectangle       *intersection)
6864 {
6865   GtkWidgetPrivate *priv;
6866   GdkRectangle *dest;
6867   GdkRectangle tmp;
6868   gint return_val;
6869
6870   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
6871   g_return_val_if_fail (area != NULL, FALSE);
6872
6873   priv = widget->priv;
6874
6875   if (intersection)
6876     dest = intersection;
6877   else
6878     dest = &tmp;
6879
6880   return_val = gdk_rectangle_intersect (&priv->allocation, area, dest);
6881
6882   if (return_val && intersection && gtk_widget_get_has_window (widget))
6883     {
6884       intersection->x -= priv->allocation.x;
6885       intersection->y -= priv->allocation.y;
6886     }
6887
6888   return return_val;
6889 }
6890
6891 /**
6892  * gtk_widget_region_intersect:
6893  * @widget: a #GtkWidget
6894  * @region: a #cairo_region_t, in the same coordinate system as
6895  *          @widget->allocation. That is, relative to @widget->window
6896  *          for %NO_WINDOW widgets; relative to the parent window
6897  *          of @widget->window for widgets with their own window.
6898  *
6899  * Computes the intersection of a @widget's area and @region, returning
6900  * the intersection. The result may be empty, use cairo_region_is_empty() to
6901  * check.
6902  *
6903  * Returns: A newly allocated region holding the intersection of @widget
6904  *     and @region. The coordinates of the return value are relative to
6905  *     @widget->window for %NO_WINDOW widgets, and relative to the parent
6906  *     window of @widget->window for widgets with their own window.
6907  */
6908 cairo_region_t *
6909 gtk_widget_region_intersect (GtkWidget       *widget,
6910                              const cairo_region_t *region)
6911 {
6912   GdkRectangle rect;
6913   cairo_region_t *dest;
6914
6915   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
6916   g_return_val_if_fail (region != NULL, NULL);
6917
6918   gtk_widget_get_allocation (widget, &rect);
6919
6920   dest = cairo_region_create_rectangle (&rect);
6921
6922   cairo_region_intersect (dest, region);
6923
6924   return dest;
6925 }
6926
6927 /**
6928  * _gtk_widget_grab_notify:
6929  * @widget: a #GtkWidget
6930  * @was_grabbed: whether a grab is now in effect
6931  *
6932  * Emits the #GtkWidget::grab-notify signal on @widget.
6933  *
6934  * Since: 2.6
6935  **/
6936 void
6937 _gtk_widget_grab_notify (GtkWidget *widget,
6938                          gboolean   was_grabbed)
6939 {
6940   g_signal_emit (widget, widget_signals[GRAB_NOTIFY], 0, was_grabbed);
6941 }
6942
6943 /**
6944  * gtk_widget_grab_focus:
6945  * @widget: a #GtkWidget
6946  *
6947  * Causes @widget to have the keyboard focus for the #GtkWindow it's
6948  * inside. @widget must be a focusable widget, such as a #GtkEntry;
6949  * something like #GtkFrame won't work.
6950  *
6951  * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
6952  * gtk_widget_set_can_focus() to modify that flag.
6953  *
6954  * The widget also needs to be realized and mapped. This is indicated by the
6955  * related signals. Grabbing the focus immediately after creating the widget
6956  * will likely fail and cause critical warnings.
6957  **/
6958 void
6959 gtk_widget_grab_focus (GtkWidget *widget)
6960 {
6961   g_return_if_fail (GTK_IS_WIDGET (widget));
6962
6963   if (!gtk_widget_is_sensitive (widget))
6964     return;
6965
6966   g_object_ref (widget);
6967   g_signal_emit (widget, widget_signals[GRAB_FOCUS], 0);
6968   g_object_notify (G_OBJECT (widget), "has-focus");
6969   g_object_unref (widget);
6970 }
6971
6972 static void
6973 reset_focus_recurse (GtkWidget *widget,
6974                      gpointer   data)
6975 {
6976   if (GTK_IS_CONTAINER (widget))
6977     {
6978       GtkContainer *container;
6979
6980       container = GTK_CONTAINER (widget);
6981       gtk_container_set_focus_child (container, NULL);
6982
6983       gtk_container_foreach (container,
6984                              reset_focus_recurse,
6985                              NULL);
6986     }
6987 }
6988
6989 static void
6990 gtk_widget_real_grab_focus (GtkWidget *focus_widget)
6991 {
6992   if (gtk_widget_get_can_focus (focus_widget))
6993     {
6994       GtkWidget *toplevel;
6995       GtkWidget *widget;
6996
6997       /* clear the current focus setting, break if the current widget
6998        * is the focus widget's parent, since containers above that will
6999        * be set by the next loop.
7000        */
7001       toplevel = gtk_widget_get_toplevel (focus_widget);
7002       if (gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
7003         {
7004           widget = gtk_window_get_focus (GTK_WINDOW (toplevel));
7005
7006           if (widget == focus_widget)
7007             {
7008               /* We call _gtk_window_internal_set_focus() here so that the
7009                * toplevel window can request the focus if necessary.
7010                * This is needed when the toplevel is a GtkPlug
7011                */
7012               if (!gtk_widget_has_focus (widget))
7013                 _gtk_window_internal_set_focus (GTK_WINDOW (toplevel), focus_widget);
7014
7015               return;
7016             }
7017
7018           if (widget)
7019             {
7020               GtkWidget *common_ancestor = gtk_widget_common_ancestor (widget, focus_widget);
7021
7022               if (widget != common_ancestor)
7023                 {
7024                   while (widget->priv->parent && widget->priv->parent != common_ancestor)
7025                     {
7026                       widget = widget->priv->parent;
7027                       gtk_container_set_focus_child (GTK_CONTAINER (widget), NULL);
7028                     }
7029                 }
7030             }
7031         }
7032       else if (toplevel != focus_widget)
7033         {
7034           /* gtk_widget_grab_focus() operates on a tree without window...
7035            * actually, this is very questionable behaviour.
7036            */
7037
7038           gtk_container_foreach (GTK_CONTAINER (toplevel),
7039                                  reset_focus_recurse,
7040                                  NULL);
7041         }
7042
7043       /* now propagate the new focus up the widget tree and finally
7044        * set it on the window
7045        */
7046       widget = focus_widget;
7047       while (widget->priv->parent)
7048         {
7049           gtk_container_set_focus_child (GTK_CONTAINER (widget->priv->parent), widget);
7050           widget = widget->priv->parent;
7051         }
7052       if (GTK_IS_WINDOW (widget))
7053         _gtk_window_internal_set_focus (GTK_WINDOW (widget), focus_widget);
7054     }
7055 }
7056
7057 static gboolean
7058 gtk_widget_real_query_tooltip (GtkWidget  *widget,
7059                                gint        x,
7060                                gint        y,
7061                                gboolean    keyboard_tip,
7062                                GtkTooltip *tooltip)
7063 {
7064   gchar *tooltip_markup;
7065   gboolean has_tooltip;
7066
7067   tooltip_markup = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_markup);
7068   has_tooltip = GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget), quark_has_tooltip));
7069
7070   if (has_tooltip && tooltip_markup)
7071     {
7072       gtk_tooltip_set_markup (tooltip, tooltip_markup);
7073       return TRUE;
7074     }
7075
7076   return FALSE;
7077 }
7078
7079 static void
7080 gtk_widget_real_state_flags_changed (GtkWidget     *widget,
7081                                      GtkStateFlags  old_state)
7082 {
7083   gtk_widget_update_pango_context (widget);
7084 }
7085
7086 static void
7087 gtk_widget_real_style_updated (GtkWidget *widget)
7088 {
7089   GtkWidgetPrivate *priv = widget->priv;
7090
7091   gtk_widget_update_pango_context (widget);
7092   gtk_widget_update_alpha (widget);
7093
7094   if (priv->style != NULL &&
7095       priv->style != gtk_widget_get_default_style ())
7096     {
7097       /* Trigger ::style-set for old
7098        * widgets not listening to this
7099        */
7100       g_signal_emit (widget,
7101                      widget_signals[STYLE_SET],
7102                      0,
7103                      widget->priv->style);
7104     }
7105
7106   if (widget->priv->context)
7107     {
7108       const GtkBitmask *changes = _gtk_style_context_get_changes (widget->priv->context);
7109
7110       if (gtk_widget_get_realized (widget) &&
7111           gtk_widget_get_has_window (widget) &&
7112           !gtk_widget_get_app_paintable (widget))
7113         gtk_style_context_set_background (widget->priv->context,
7114                                           widget->priv->window);
7115
7116       if (widget->priv->anchored)
7117         {
7118           if (changes && _gtk_css_style_property_changes_affect_size (changes))
7119             gtk_widget_queue_resize (widget);
7120           else
7121             gtk_widget_queue_draw (widget);
7122         }
7123     }
7124   else
7125     {
7126       if (widget->priv->anchored)
7127         gtk_widget_queue_resize (widget);
7128     }
7129 }
7130
7131 static gboolean
7132 gtk_widget_real_show_help (GtkWidget        *widget,
7133                            GtkWidgetHelpType help_type)
7134 {
7135   if (help_type == GTK_WIDGET_HELP_TOOLTIP)
7136     {
7137       _gtk_tooltip_toggle_keyboard_mode (widget);
7138
7139       return TRUE;
7140     }
7141   else
7142     return FALSE;
7143 }
7144
7145 static gboolean
7146 gtk_widget_real_focus (GtkWidget         *widget,
7147                        GtkDirectionType   direction)
7148 {
7149   if (!gtk_widget_get_can_focus (widget))
7150     return FALSE;
7151
7152   if (!gtk_widget_is_focus (widget))
7153     {
7154       gtk_widget_grab_focus (widget);
7155       return TRUE;
7156     }
7157   else
7158     return FALSE;
7159 }
7160
7161 static void
7162 gtk_widget_real_move_focus (GtkWidget         *widget,
7163                             GtkDirectionType   direction)
7164 {
7165   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
7166
7167   if (widget != toplevel && GTK_IS_WINDOW (toplevel))
7168     {
7169       g_signal_emit (toplevel, widget_signals[MOVE_FOCUS], 0,
7170                      direction);
7171     }
7172 }
7173
7174 static gboolean
7175 gtk_widget_real_keynav_failed (GtkWidget        *widget,
7176                                GtkDirectionType  direction)
7177 {
7178   gboolean cursor_only;
7179
7180   switch (direction)
7181     {
7182     case GTK_DIR_TAB_FORWARD:
7183     case GTK_DIR_TAB_BACKWARD:
7184       return FALSE;
7185
7186     case GTK_DIR_UP:
7187     case GTK_DIR_DOWN:
7188     case GTK_DIR_LEFT:
7189     case GTK_DIR_RIGHT:
7190       g_object_get (gtk_widget_get_settings (widget),
7191                     "gtk-keynav-cursor-only", &cursor_only,
7192                     NULL);
7193       if (cursor_only)
7194         return FALSE;
7195       break;
7196     }
7197
7198   gtk_widget_error_bell (widget);
7199
7200   return TRUE;
7201 }
7202
7203 /**
7204  * gtk_widget_set_can_focus:
7205  * @widget: a #GtkWidget
7206  * @can_focus: whether or not @widget can own the input focus.
7207  *
7208  * Specifies whether @widget can own the input focus. See
7209  * gtk_widget_grab_focus() for actually setting the input focus on a
7210  * widget.
7211  *
7212  * Since: 2.18
7213  **/
7214 void
7215 gtk_widget_set_can_focus (GtkWidget *widget,
7216                           gboolean   can_focus)
7217 {
7218   g_return_if_fail (GTK_IS_WIDGET (widget));
7219
7220   if (widget->priv->can_focus != can_focus)
7221     {
7222       widget->priv->can_focus = can_focus;
7223
7224       gtk_widget_queue_resize (widget);
7225       g_object_notify (G_OBJECT (widget), "can-focus");
7226     }
7227 }
7228
7229 /**
7230  * gtk_widget_get_can_focus:
7231  * @widget: a #GtkWidget
7232  *
7233  * Determines whether @widget can own the input focus. See
7234  * gtk_widget_set_can_focus().
7235  *
7236  * Return value: %TRUE if @widget can own the input focus, %FALSE otherwise
7237  *
7238  * Since: 2.18
7239  **/
7240 gboolean
7241 gtk_widget_get_can_focus (GtkWidget *widget)
7242 {
7243   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7244
7245   return widget->priv->can_focus;
7246 }
7247
7248 /**
7249  * gtk_widget_has_focus:
7250  * @widget: a #GtkWidget
7251  *
7252  * Determines if the widget has the global input focus. See
7253  * gtk_widget_is_focus() for the difference between having the global
7254  * input focus, and only having the focus within a toplevel.
7255  *
7256  * Return value: %TRUE if the widget has the global input focus.
7257  *
7258  * Since: 2.18
7259  **/
7260 gboolean
7261 gtk_widget_has_focus (GtkWidget *widget)
7262 {
7263   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7264
7265   return widget->priv->has_focus;
7266 }
7267
7268 /**
7269  * gtk_widget_has_visible_focus:
7270  * @widget: a #GtkWidget
7271  *
7272  * Determines if the widget should show a visible indication that
7273  * it has the global input focus. This is a convenience function for
7274  * use in ::draw handlers that takes into account whether focus
7275  * indication should currently be shown in the toplevel window of
7276  * @widget. See gtk_window_get_focus_visible() for more information
7277  * about focus indication.
7278  *
7279  * To find out if the widget has the global input focus, use
7280  * gtk_widget_has_focus().
7281  *
7282  * Return value: %TRUE if the widget should display a 'focus rectangle'
7283  *
7284  * Since: 3.2
7285  */
7286 gboolean
7287 gtk_widget_has_visible_focus (GtkWidget *widget)
7288 {
7289   gboolean draw_focus;
7290
7291   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7292
7293   if (widget->priv->has_focus)
7294     {
7295       GtkWidget *toplevel;
7296
7297       toplevel = gtk_widget_get_toplevel (widget);
7298
7299       if (GTK_IS_WINDOW (toplevel))
7300         draw_focus = gtk_window_get_focus_visible (GTK_WINDOW (toplevel));
7301       else
7302         draw_focus = TRUE;
7303     }
7304   else
7305     draw_focus = FALSE;
7306
7307   return draw_focus;
7308 }
7309
7310 /**
7311  * gtk_widget_is_focus:
7312  * @widget: a #GtkWidget
7313  *
7314  * Determines if the widget is the focus widget within its
7315  * toplevel. (This does not mean that the %HAS_FOCUS flag is
7316  * necessarily set; %HAS_FOCUS will only be set if the
7317  * toplevel widget additionally has the global input focus.)
7318  *
7319  * Return value: %TRUE if the widget is the focus widget.
7320  **/
7321 gboolean
7322 gtk_widget_is_focus (GtkWidget *widget)
7323 {
7324   GtkWidget *toplevel;
7325
7326   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7327
7328   toplevel = gtk_widget_get_toplevel (widget);
7329
7330   if (GTK_IS_WINDOW (toplevel))
7331     return widget == gtk_window_get_focus (GTK_WINDOW (toplevel));
7332   else
7333     return FALSE;
7334 }
7335
7336 /**
7337  * gtk_widget_set_can_default:
7338  * @widget: a #GtkWidget
7339  * @can_default: whether or not @widget can be a default widget.
7340  *
7341  * Specifies whether @widget can be a default widget. See
7342  * gtk_widget_grab_default() for details about the meaning of
7343  * "default".
7344  *
7345  * Since: 2.18
7346  **/
7347 void
7348 gtk_widget_set_can_default (GtkWidget *widget,
7349                             gboolean   can_default)
7350 {
7351   g_return_if_fail (GTK_IS_WIDGET (widget));
7352
7353   if (widget->priv->can_default != can_default)
7354     {
7355       widget->priv->can_default = can_default;
7356
7357       gtk_widget_queue_resize (widget);
7358       g_object_notify (G_OBJECT (widget), "can-default");
7359     }
7360 }
7361
7362 /**
7363  * gtk_widget_get_can_default:
7364  * @widget: a #GtkWidget
7365  *
7366  * Determines whether @widget can be a default widget. See
7367  * gtk_widget_set_can_default().
7368  *
7369  * Return value: %TRUE if @widget can be a default widget, %FALSE otherwise
7370  *
7371  * Since: 2.18
7372  **/
7373 gboolean
7374 gtk_widget_get_can_default (GtkWidget *widget)
7375 {
7376   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7377
7378   return widget->priv->can_default;
7379 }
7380
7381 /**
7382  * gtk_widget_has_default:
7383  * @widget: a #GtkWidget
7384  *
7385  * Determines whether @widget is the current default widget within its
7386  * toplevel. See gtk_widget_set_can_default().
7387  *
7388  * Return value: %TRUE if @widget is the current default widget within
7389  *     its toplevel, %FALSE otherwise
7390  *
7391  * Since: 2.18
7392  */
7393 gboolean
7394 gtk_widget_has_default (GtkWidget *widget)
7395 {
7396   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7397
7398   return widget->priv->has_default;
7399 }
7400
7401 void
7402 _gtk_widget_set_has_default (GtkWidget *widget,
7403                              gboolean   has_default)
7404 {
7405   GtkStyleContext *context;
7406
7407   widget->priv->has_default = has_default;
7408
7409   context = gtk_widget_get_style_context (widget);
7410
7411   if (has_default)
7412     gtk_style_context_add_class (context, GTK_STYLE_CLASS_DEFAULT);
7413   else
7414     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DEFAULT);
7415 }
7416
7417 /**
7418  * gtk_widget_grab_default:
7419  * @widget: a #GtkWidget
7420  *
7421  * Causes @widget to become the default widget. @widget must be able to be
7422  * a default widget; typically you would ensure this yourself
7423  * by calling gtk_widget_set_can_default() with a %TRUE value.
7424  * The default widget is activated when
7425  * the user presses Enter in a window. Default widgets must be
7426  * activatable, that is, gtk_widget_activate() should affect them. Note
7427  * that #GtkEntry widgets require the "activates-default" property
7428  * set to %TRUE before they activate the default widget when Enter
7429  * is pressed and the #GtkEntry is focused.
7430  **/
7431 void
7432 gtk_widget_grab_default (GtkWidget *widget)
7433 {
7434   GtkWidget *window;
7435
7436   g_return_if_fail (GTK_IS_WIDGET (widget));
7437   g_return_if_fail (gtk_widget_get_can_default (widget));
7438
7439   window = gtk_widget_get_toplevel (widget);
7440
7441   if (window && gtk_widget_is_toplevel (window))
7442     gtk_window_set_default (GTK_WINDOW (window), widget);
7443   else
7444     g_warning (G_STRLOC ": widget not within a GtkWindow");
7445 }
7446
7447 /**
7448  * gtk_widget_set_receives_default:
7449  * @widget: a #GtkWidget
7450  * @receives_default: whether or not @widget can be a default widget.
7451  *
7452  * Specifies whether @widget will be treated as the default widget
7453  * within its toplevel when it has the focus, even if another widget
7454  * is the default.
7455  *
7456  * See gtk_widget_grab_default() for details about the meaning of
7457  * "default".
7458  *
7459  * Since: 2.18
7460  **/
7461 void
7462 gtk_widget_set_receives_default (GtkWidget *widget,
7463                                  gboolean   receives_default)
7464 {
7465   g_return_if_fail (GTK_IS_WIDGET (widget));
7466
7467   if (widget->priv->receives_default != receives_default)
7468     {
7469       widget->priv->receives_default = receives_default;
7470
7471       g_object_notify (G_OBJECT (widget), "receives-default");
7472     }
7473 }
7474
7475 /**
7476  * gtk_widget_get_receives_default:
7477  * @widget: a #GtkWidget
7478  *
7479  * Determines whether @widget is alyways treated as default widget
7480  * withing its toplevel when it has the focus, even if another widget
7481  * is the default.
7482  *
7483  * See gtk_widget_set_receives_default().
7484  *
7485  * Return value: %TRUE if @widget acts as default widget when focussed,
7486  *               %FALSE otherwise
7487  *
7488  * Since: 2.18
7489  **/
7490 gboolean
7491 gtk_widget_get_receives_default (GtkWidget *widget)
7492 {
7493   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7494
7495   return widget->priv->receives_default;
7496 }
7497
7498 /**
7499  * gtk_widget_has_grab:
7500  * @widget: a #GtkWidget
7501  *
7502  * Determines whether the widget is currently grabbing events, so it
7503  * is the only widget receiving input events (keyboard and mouse).
7504  *
7505  * See also gtk_grab_add().
7506  *
7507  * Return value: %TRUE if the widget is in the grab_widgets stack
7508  *
7509  * Since: 2.18
7510  **/
7511 gboolean
7512 gtk_widget_has_grab (GtkWidget *widget)
7513 {
7514   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7515
7516   return widget->priv->has_grab;
7517 }
7518
7519 void
7520 _gtk_widget_set_has_grab (GtkWidget *widget,
7521                           gboolean   has_grab)
7522 {
7523   widget->priv->has_grab = has_grab;
7524 }
7525
7526 /**
7527  * gtk_widget_device_is_shadowed:
7528  * @widget: a #GtkWidget
7529  * @device: a #GdkDevice
7530  *
7531  * Returns %TRUE if @device has been shadowed by a GTK+
7532  * device grab on another widget, so it would stop sending
7533  * events to @widget. This may be used in the
7534  * #GtkWidget::grab-notify signal to check for specific
7535  * devices. See gtk_device_grab_add().
7536  *
7537  * Returns: %TRUE if there is an ongoing grab on @device
7538  *          by another #GtkWidget than @widget.
7539  *
7540  * Since: 3.0
7541  **/
7542 gboolean
7543 gtk_widget_device_is_shadowed (GtkWidget *widget,
7544                                GdkDevice *device)
7545 {
7546   GtkWindowGroup *group;
7547   GtkWidget *grab_widget, *toplevel;
7548
7549   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7550   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
7551
7552   if (!gtk_widget_get_realized (widget))
7553     return TRUE;
7554
7555   toplevel = gtk_widget_get_toplevel (widget);
7556
7557   if (GTK_IS_WINDOW (toplevel))
7558     group = gtk_window_get_group (GTK_WINDOW (toplevel));
7559   else
7560     group = gtk_window_get_group (NULL);
7561
7562   grab_widget = gtk_window_group_get_current_device_grab (group, device);
7563
7564   /* Widget not inside the hierarchy of grab_widget */
7565   if (grab_widget &&
7566       widget != grab_widget &&
7567       !gtk_widget_is_ancestor (widget, grab_widget))
7568     return TRUE;
7569
7570   grab_widget = gtk_window_group_get_current_grab (group);
7571   if (grab_widget && widget != grab_widget &&
7572       !gtk_widget_is_ancestor (widget, grab_widget))
7573     return TRUE;
7574
7575   return FALSE;
7576 }
7577
7578 /**
7579  * gtk_widget_set_name:
7580  * @widget: a #GtkWidget
7581  * @name: name for the widget
7582  *
7583  * Widgets can be named, which allows you to refer to them from a
7584  * CSS file. You can apply a style to widgets with a particular name
7585  * in the CSS file. See the documentation for the CSS syntax (on the
7586  * same page as the docs for #GtkStyleContext).
7587  *
7588  * Note that the CSS syntax has certain special characters to delimit
7589  * and represent elements in a selector (period, &num;, &gt;, &ast;...),
7590  * so using these will make your widget impossible to match by name.
7591  * Any combination of alphanumeric symbols, dashes and underscores will
7592  * suffice.
7593  **/
7594 void
7595 gtk_widget_set_name (GtkWidget   *widget,
7596                      const gchar *name)
7597 {
7598   GtkWidgetPrivate *priv;
7599   gchar *new_name;
7600
7601   g_return_if_fail (GTK_IS_WIDGET (widget));
7602
7603   priv = widget->priv;
7604
7605   new_name = g_strdup (name);
7606   g_free (priv->name);
7607   priv->name = new_name;
7608
7609   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_NAME);
7610
7611   g_object_notify (G_OBJECT (widget), "name");
7612 }
7613
7614 /**
7615  * gtk_widget_get_name:
7616  * @widget: a #GtkWidget
7617  *
7618  * Retrieves the name of a widget. See gtk_widget_set_name() for the
7619  * significance of widget names.
7620  *
7621  * Return value: name of the widget. This string is owned by GTK+ and
7622  * should not be modified or freed
7623  **/
7624 const gchar*
7625 gtk_widget_get_name (GtkWidget *widget)
7626 {
7627   GtkWidgetPrivate *priv;
7628
7629   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
7630
7631   priv = widget->priv;
7632
7633   if (priv->name)
7634     return priv->name;
7635   return G_OBJECT_TYPE_NAME (widget);
7636 }
7637
7638 static void
7639 gtk_widget_update_state_flags (GtkWidget     *widget,
7640                                GtkStateFlags  flags_to_set,
7641                                GtkStateFlags  flags_to_unset)
7642 {
7643   GtkWidgetPrivate *priv;
7644
7645   priv = widget->priv;
7646
7647   /* Handle insensitive first, since it is propagated
7648    * differently throughout the widget hierarchy.
7649    */
7650   if ((priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_unset & GTK_STATE_FLAG_INSENSITIVE))
7651     gtk_widget_set_sensitive (widget, TRUE);
7652   else if (!(priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_set & GTK_STATE_FLAG_INSENSITIVE))
7653     gtk_widget_set_sensitive (widget, FALSE);
7654
7655   flags_to_set &= ~(GTK_STATE_FLAG_INSENSITIVE);
7656   flags_to_unset &= ~(GTK_STATE_FLAG_INSENSITIVE);
7657
7658   if (flags_to_set != 0 || flags_to_unset != 0)
7659     {
7660       GtkStateData data;
7661
7662       data.flags_to_set = flags_to_set;
7663       data.flags_to_unset = flags_to_unset;
7664
7665       gtk_widget_propagate_state (widget, &data);
7666     }
7667 }
7668
7669 /**
7670  * gtk_widget_set_state_flags:
7671  * @widget: a #GtkWidget
7672  * @flags: State flags to turn on
7673  * @clear: Whether to clear state before turning on @flags
7674  *
7675  * This function is for use in widget implementations. Turns on flag
7676  * values in the current widget state (insensitive, prelighted, etc.).
7677  *
7678  * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
7679  * will be propagated down to all non-internal children if @widget is a
7680  * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
7681  * down to all #GtkContainer children by different means than turning on the
7682  * state flag down the hierarchy, both gtk_widget_get_state_flags() and
7683  * gtk_widget_is_sensitive() will make use of these.
7684  *
7685  * Since: 3.0
7686  **/
7687 void
7688 gtk_widget_set_state_flags (GtkWidget     *widget,
7689                             GtkStateFlags  flags,
7690                             gboolean       clear)
7691 {
7692   g_return_if_fail (GTK_IS_WIDGET (widget));
7693
7694   if ((!clear && (widget->priv->state_flags & flags) == flags) ||
7695       (clear && widget->priv->state_flags == flags))
7696     return;
7697
7698   if (clear)
7699     gtk_widget_update_state_flags (widget, flags, ~(flags ^ (GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL)));
7700   else
7701     gtk_widget_update_state_flags (widget, flags, 0);
7702 }
7703
7704 /**
7705  * gtk_widget_unset_state_flags:
7706  * @widget: a #GtkWidget
7707  * @flags: State flags to turn off
7708  *
7709  * This function is for use in widget implementations. Turns off flag
7710  * values for the current widget state (insensitive, prelighted, etc.).
7711  * See gtk_widget_set_state_flags().
7712  *
7713  * Since: 3.0
7714  **/
7715 void
7716 gtk_widget_unset_state_flags (GtkWidget     *widget,
7717                               GtkStateFlags  flags)
7718 {
7719   g_return_if_fail (GTK_IS_WIDGET (widget));
7720
7721   if ((widget->priv->state_flags & flags) == 0)
7722     return;
7723
7724   gtk_widget_update_state_flags (widget, 0, flags);
7725 }
7726
7727 /**
7728  * gtk_widget_get_state_flags:
7729  * @widget: a #GtkWidget
7730  *
7731  * Returns the widget state as a flag set. It is worth mentioning
7732  * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
7733  * returned, that is, also based on parent insensitivity, even if
7734  * @widget itself is sensitive.
7735  *
7736  * Returns: The state flags for widget
7737  *
7738  * Since: 3.0
7739  **/
7740 GtkStateFlags
7741 gtk_widget_get_state_flags (GtkWidget *widget)
7742 {
7743   GtkStateFlags flags;
7744
7745   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
7746
7747   flags = widget->priv->state_flags;
7748
7749   if (gtk_widget_has_focus (widget))
7750     flags |= GTK_STATE_FLAG_FOCUSED;
7751
7752   return flags;
7753 }
7754
7755 /**
7756  * gtk_widget_set_state:
7757  * @widget: a #GtkWidget
7758  * @state: new state for @widget
7759  *
7760  * This function is for use in widget implementations. Sets the state
7761  * of a widget (insensitive, prelighted, etc.) Usually you should set
7762  * the state using wrapper functions such as gtk_widget_set_sensitive().
7763  *
7764  * Deprecated: 3.0. Use gtk_widget_set_state_flags() instead.
7765  **/
7766 void
7767 gtk_widget_set_state (GtkWidget           *widget,
7768                       GtkStateType         state)
7769 {
7770   GtkStateFlags flags;
7771
7772   if (state == gtk_widget_get_state (widget))
7773     return;
7774
7775   switch (state)
7776     {
7777     case GTK_STATE_ACTIVE:
7778       flags = GTK_STATE_FLAG_ACTIVE;
7779       break;
7780     case GTK_STATE_PRELIGHT:
7781       flags = GTK_STATE_FLAG_PRELIGHT;
7782       break;
7783     case GTK_STATE_SELECTED:
7784       flags = GTK_STATE_FLAG_SELECTED;
7785       break;
7786     case GTK_STATE_INSENSITIVE:
7787       flags = GTK_STATE_FLAG_INSENSITIVE;
7788       break;
7789     case GTK_STATE_INCONSISTENT:
7790       flags = GTK_STATE_FLAG_INCONSISTENT;
7791       break;
7792     case GTK_STATE_FOCUSED:
7793       flags = GTK_STATE_FLAG_FOCUSED;
7794       break;
7795     case GTK_STATE_NORMAL:
7796     default:
7797       flags = 0;
7798       break;
7799     }
7800
7801   gtk_widget_update_state_flags (widget,
7802                                  flags,
7803                                  (GTK_STATE_FLAG_ACTIVE | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED
7804                                  | GTK_STATE_FLAG_INSENSITIVE | GTK_STATE_FLAG_INCONSISTENT | GTK_STATE_FLAG_FOCUSED) ^ flags);
7805 }
7806
7807 /**
7808  * gtk_widget_get_state:
7809  * @widget: a #GtkWidget
7810  *
7811  * Returns the widget's state. See gtk_widget_set_state().
7812  *
7813  * Returns: the state of @widget.
7814  *
7815  * Since: 2.18
7816  *
7817  * Deprecated: 3.0. Use gtk_widget_get_state_flags() instead.
7818  */
7819 GtkStateType
7820 gtk_widget_get_state (GtkWidget *widget)
7821 {
7822   GtkStateFlags flags;
7823
7824   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_STATE_NORMAL);
7825
7826   flags = gtk_widget_get_state_flags (widget);
7827
7828   if (flags & GTK_STATE_FLAG_INSENSITIVE)
7829     return GTK_STATE_INSENSITIVE;
7830   else if (flags & GTK_STATE_FLAG_ACTIVE)
7831     return GTK_STATE_ACTIVE;
7832   else if (flags & GTK_STATE_FLAG_SELECTED)
7833     return GTK_STATE_SELECTED;
7834   else if (flags & GTK_STATE_FLAG_PRELIGHT)
7835     return GTK_STATE_PRELIGHT;
7836   else
7837     return GTK_STATE_NORMAL;
7838 }
7839
7840 /**
7841  * gtk_widget_set_visible:
7842  * @widget: a #GtkWidget
7843  * @visible: whether the widget should be shown or not
7844  *
7845  * Sets the visibility state of @widget. Note that setting this to
7846  * %TRUE doesn't mean the widget is actually viewable, see
7847  * gtk_widget_get_visible().
7848  *
7849  * This function simply calls gtk_widget_show() or gtk_widget_hide()
7850  * but is nicer to use when the visibility of the widget depends on
7851  * some condition.
7852  *
7853  * Since: 2.18
7854  **/
7855 void
7856 gtk_widget_set_visible (GtkWidget *widget,
7857                         gboolean   visible)
7858 {
7859   g_return_if_fail (GTK_IS_WIDGET (widget));
7860
7861   if (visible != gtk_widget_get_visible (widget))
7862     {
7863       if (visible)
7864         gtk_widget_show (widget);
7865       else
7866         gtk_widget_hide (widget);
7867     }
7868 }
7869
7870 void
7871 _gtk_widget_set_visible_flag (GtkWidget *widget,
7872                               gboolean   visible)
7873 {
7874   GtkWidgetPrivate *priv = widget->priv;
7875
7876   priv->visible = visible;
7877
7878   if (!visible)
7879     {
7880       priv->allocation.x = -1;
7881       priv->allocation.y = -1;
7882       priv->allocation.width = 1;
7883       priv->allocation.height = 1;
7884     }
7885 }
7886
7887 /**
7888  * gtk_widget_get_visible:
7889  * @widget: a #GtkWidget
7890  *
7891  * Determines whether the widget is visible. If you want to
7892  * take into account whether the widget's parent is also marked as
7893  * visible, use gtk_widget_is_visible() instead.
7894  *
7895  * This function does not check if the widget is obscured in any way.
7896  *
7897  * See gtk_widget_set_visible().
7898  *
7899  * Return value: %TRUE if the widget is visible
7900  *
7901  * Since: 2.18
7902  **/
7903 gboolean
7904 gtk_widget_get_visible (GtkWidget *widget)
7905 {
7906   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7907
7908   return widget->priv->visible;
7909 }
7910
7911 /**
7912  * gtk_widget_is_visible:
7913  * @widget: a #GtkWidget
7914  *
7915  * Determines whether the widget and all its parents are marked as
7916  * visible.
7917  *
7918  * This function does not check if the widget is obscured in any way.
7919  *
7920  * See also gtk_widget_get_visible() and gtk_widget_set_visible()
7921  *
7922  * Return value: %TRUE if the widget and all its parents are visible
7923  *
7924  * Since: 3.8
7925  **/
7926 gboolean
7927 gtk_widget_is_visible (GtkWidget *widget)
7928 {
7929   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7930
7931   while (widget)
7932     {
7933       GtkWidgetPrivate *priv = widget->priv;
7934
7935       if (!priv->visible)
7936         return FALSE;
7937
7938       widget = priv->parent;
7939     }
7940
7941   return TRUE;
7942 }
7943
7944 /**
7945  * gtk_widget_set_has_window:
7946  * @widget: a #GtkWidget
7947  * @has_window: whether or not @widget has a window.
7948  *
7949  * Specifies whether @widget has a #GdkWindow of its own. Note that
7950  * all realized widgets have a non-%NULL "window" pointer
7951  * (gtk_widget_get_window() never returns a %NULL window when a widget
7952  * is realized), but for many of them it's actually the #GdkWindow of
7953  * one of its parent widgets. Widgets that do not create a %window for
7954  * themselves in #GtkWidget::realize must announce this by
7955  * calling this function with @has_window = %FALSE.
7956  *
7957  * This function should only be called by widget implementations,
7958  * and they should call it in their init() function.
7959  *
7960  * Since: 2.18
7961  **/
7962 void
7963 gtk_widget_set_has_window (GtkWidget *widget,
7964                            gboolean   has_window)
7965 {
7966   g_return_if_fail (GTK_IS_WIDGET (widget));
7967
7968   widget->priv->no_window = !has_window;
7969 }
7970
7971 /**
7972  * gtk_widget_get_has_window:
7973  * @widget: a #GtkWidget
7974  *
7975  * Determines whether @widget has a #GdkWindow of its own. See
7976  * gtk_widget_set_has_window().
7977  *
7978  * Return value: %TRUE if @widget has a window, %FALSE otherwise
7979  *
7980  * Since: 2.18
7981  **/
7982 gboolean
7983 gtk_widget_get_has_window (GtkWidget *widget)
7984 {
7985   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
7986
7987   return ! widget->priv->no_window;
7988 }
7989
7990 /**
7991  * gtk_widget_is_toplevel:
7992  * @widget: a #GtkWidget
7993  *
7994  * Determines whether @widget is a toplevel widget.
7995  *
7996  * Currently only #GtkWindow and #GtkInvisible (and out-of-process
7997  * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
7998  * widget.
7999  *
8000  * Return value: %TRUE if @widget is a toplevel, %FALSE otherwise
8001  *
8002  * Since: 2.18
8003  **/
8004 gboolean
8005 gtk_widget_is_toplevel (GtkWidget *widget)
8006 {
8007   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8008
8009   return widget->priv->toplevel;
8010 }
8011
8012 void
8013 _gtk_widget_set_is_toplevel (GtkWidget *widget,
8014                              gboolean   is_toplevel)
8015 {
8016   widget->priv->toplevel = is_toplevel;
8017 }
8018
8019 /**
8020  * gtk_widget_is_drawable:
8021  * @widget: a #GtkWidget
8022  *
8023  * Determines whether @widget can be drawn to. A widget can be drawn
8024  * to if it is mapped and visible.
8025  *
8026  * Return value: %TRUE if @widget is drawable, %FALSE otherwise
8027  *
8028  * Since: 2.18
8029  **/
8030 gboolean
8031 gtk_widget_is_drawable (GtkWidget *widget)
8032 {
8033   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8034
8035   return (gtk_widget_get_visible (widget) &&
8036           gtk_widget_get_mapped (widget));
8037 }
8038
8039 /**
8040  * gtk_widget_get_realized:
8041  * @widget: a #GtkWidget
8042  *
8043  * Determines whether @widget is realized.
8044  *
8045  * Return value: %TRUE if @widget is realized, %FALSE otherwise
8046  *
8047  * Since: 2.20
8048  **/
8049 gboolean
8050 gtk_widget_get_realized (GtkWidget *widget)
8051 {
8052   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8053
8054   return widget->priv->realized;
8055 }
8056
8057 /**
8058  * gtk_widget_set_realized:
8059  * @widget: a #GtkWidget
8060  * @realized: %TRUE to mark the widget as realized
8061  *
8062  * Marks the widget as being realized.
8063  *
8064  * This function should only ever be called in a derived widget's
8065  * "realize" or "unrealize" implementation.
8066  *
8067  * Since: 2.20
8068  */
8069 void
8070 gtk_widget_set_realized (GtkWidget *widget,
8071                          gboolean   realized)
8072 {
8073   g_return_if_fail (GTK_IS_WIDGET (widget));
8074
8075   widget->priv->realized = realized;
8076 }
8077
8078 /**
8079  * gtk_widget_get_mapped:
8080  * @widget: a #GtkWidget
8081  *
8082  * Whether the widget is mapped.
8083  *
8084  * Return value: %TRUE if the widget is mapped, %FALSE otherwise.
8085  *
8086  * Since: 2.20
8087  */
8088 gboolean
8089 gtk_widget_get_mapped (GtkWidget *widget)
8090 {
8091   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8092
8093   return widget->priv->mapped;
8094 }
8095
8096 /**
8097  * gtk_widget_set_mapped:
8098  * @widget: a #GtkWidget
8099  * @mapped: %TRUE to mark the widget as mapped
8100  *
8101  * Marks the widget as being realized.
8102  *
8103  * This function should only ever be called in a derived widget's
8104  * "map" or "unmap" implementation.
8105  *
8106  * Since: 2.20
8107  */
8108 void
8109 gtk_widget_set_mapped (GtkWidget *widget,
8110                        gboolean   mapped)
8111 {
8112   g_return_if_fail (GTK_IS_WIDGET (widget));
8113
8114   widget->priv->mapped = mapped;
8115 }
8116
8117 /**
8118  * gtk_widget_set_app_paintable:
8119  * @widget: a #GtkWidget
8120  * @app_paintable: %TRUE if the application will paint on the widget
8121  *
8122  * Sets whether the application intends to draw on the widget in
8123  * an #GtkWidget::draw handler.
8124  *
8125  * This is a hint to the widget and does not affect the behavior of
8126  * the GTK+ core; many widgets ignore this flag entirely. For widgets
8127  * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
8128  * the effect is to suppress default themed drawing of the widget's
8129  * background. (Children of the widget will still be drawn.) The application
8130  * is then entirely responsible for drawing the widget background.
8131  *
8132  * Note that the background is still drawn when the widget is mapped.
8133  **/
8134 void
8135 gtk_widget_set_app_paintable (GtkWidget *widget,
8136                               gboolean   app_paintable)
8137 {
8138   g_return_if_fail (GTK_IS_WIDGET (widget));
8139
8140   app_paintable = (app_paintable != FALSE);
8141
8142   if (widget->priv->app_paintable != app_paintable)
8143     {
8144       widget->priv->app_paintable = app_paintable;
8145
8146       if (gtk_widget_is_drawable (widget))
8147         gtk_widget_queue_draw (widget);
8148
8149       g_object_notify (G_OBJECT (widget), "app-paintable");
8150     }
8151 }
8152
8153 /**
8154  * gtk_widget_get_app_paintable:
8155  * @widget: a #GtkWidget
8156  *
8157  * Determines whether the application intends to draw on the widget in
8158  * an #GtkWidget::draw handler.
8159  *
8160  * See gtk_widget_set_app_paintable()
8161  *
8162  * Return value: %TRUE if the widget is app paintable
8163  *
8164  * Since: 2.18
8165  **/
8166 gboolean
8167 gtk_widget_get_app_paintable (GtkWidget *widget)
8168 {
8169   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8170
8171   return widget->priv->app_paintable;
8172 }
8173
8174 /**
8175  * gtk_widget_set_double_buffered:
8176  * @widget: a #GtkWidget
8177  * @double_buffered: %TRUE to double-buffer a widget
8178  *
8179  * Widgets are double buffered by default; you can use this function
8180  * to turn off the buffering. "Double buffered" simply means that
8181  * gdk_window_begin_paint_region() and gdk_window_end_paint() are called
8182  * automatically around expose events sent to the
8183  * widget. gdk_window_begin_paint_region() diverts all drawing to a widget's
8184  * window to an offscreen buffer, and gdk_window_end_paint() draws the
8185  * buffer to the screen. The result is that users see the window
8186  * update in one smooth step, and don't see individual graphics
8187  * primitives being rendered.
8188  *
8189  * In very simple terms, double buffered widgets don't flicker,
8190  * so you would only use this function to turn off double buffering
8191  * if you had special needs and really knew what you were doing.
8192  *
8193  * Note: if you turn off double-buffering, you have to handle
8194  * expose events, since even the clearing to the background color or
8195  * pixmap will not happen automatically (as it is done in
8196  * gdk_window_begin_paint_region()).
8197  **/
8198 void
8199 gtk_widget_set_double_buffered (GtkWidget *widget,
8200                                 gboolean   double_buffered)
8201 {
8202   g_return_if_fail (GTK_IS_WIDGET (widget));
8203
8204   double_buffered = (double_buffered != FALSE);
8205
8206   if (widget->priv->double_buffered != double_buffered)
8207     {
8208       widget->priv->double_buffered = double_buffered;
8209
8210       g_object_notify (G_OBJECT (widget), "double-buffered");
8211     }
8212 }
8213
8214 /**
8215  * gtk_widget_get_double_buffered:
8216  * @widget: a #GtkWidget
8217  *
8218  * Determines whether the widget is double buffered.
8219  *
8220  * See gtk_widget_set_double_buffered()
8221  *
8222  * Return value: %TRUE if the widget is double buffered
8223  *
8224  * Since: 2.18
8225  **/
8226 gboolean
8227 gtk_widget_get_double_buffered (GtkWidget *widget)
8228 {
8229   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8230
8231   return widget->priv->double_buffered;
8232 }
8233
8234 /**
8235  * gtk_widget_set_redraw_on_allocate:
8236  * @widget: a #GtkWidget
8237  * @redraw_on_allocate: if %TRUE, the entire widget will be redrawn
8238  *   when it is allocated to a new size. Otherwise, only the
8239  *   new portion of the widget will be redrawn.
8240  *
8241  * Sets whether the entire widget is queued for drawing when its size
8242  * allocation changes. By default, this setting is %TRUE and
8243  * the entire widget is redrawn on every size change. If your widget
8244  * leaves the upper left unchanged when made bigger, turning this
8245  * setting off will improve performance.
8246
8247  * Note that for %NO_WINDOW widgets setting this flag to %FALSE turns
8248  * off all allocation on resizing: the widget will not even redraw if
8249  * its position changes; this is to allow containers that don't draw
8250  * anything to avoid excess invalidations. If you set this flag on a
8251  * %NO_WINDOW widget that <emphasis>does</emphasis> draw on @widget->window,
8252  * you are responsible for invalidating both the old and new allocation
8253  * of the widget when the widget is moved and responsible for invalidating
8254  * regions newly when the widget increases size.
8255  **/
8256 void
8257 gtk_widget_set_redraw_on_allocate (GtkWidget *widget,
8258                                    gboolean   redraw_on_allocate)
8259 {
8260   g_return_if_fail (GTK_IS_WIDGET (widget));
8261
8262   widget->priv->redraw_on_alloc = redraw_on_allocate;
8263 }
8264
8265 /**
8266  * gtk_widget_set_sensitive:
8267  * @widget: a #GtkWidget
8268  * @sensitive: %TRUE to make the widget sensitive
8269  *
8270  * Sets the sensitivity of a widget. A widget is sensitive if the user
8271  * can interact with it. Insensitive widgets are "grayed out" and the
8272  * user can't interact with them. Insensitive widgets are known as
8273  * "inactive", "disabled", or "ghosted" in some other toolkits.
8274  **/
8275 void
8276 gtk_widget_set_sensitive (GtkWidget *widget,
8277                           gboolean   sensitive)
8278 {
8279   GtkWidgetPrivate *priv;
8280
8281   g_return_if_fail (GTK_IS_WIDGET (widget));
8282
8283   priv = widget->priv;
8284
8285   sensitive = (sensitive != FALSE);
8286
8287   if (priv->sensitive == sensitive)
8288     return;
8289
8290   priv->sensitive = sensitive;
8291
8292   if (priv->parent == NULL
8293       || gtk_widget_is_sensitive (priv->parent))
8294     {
8295       GtkStateData data;
8296
8297       if (sensitive)
8298         {
8299           data.flags_to_set = 0;
8300           data.flags_to_unset = GTK_STATE_FLAG_INSENSITIVE;
8301         }
8302       else
8303         {
8304           data.flags_to_set = GTK_STATE_FLAG_INSENSITIVE;
8305           data.flags_to_unset = 0;
8306         }
8307
8308       gtk_widget_propagate_state (widget, &data);
8309
8310       gtk_widget_queue_resize (widget);
8311     }
8312
8313   g_object_notify (G_OBJECT (widget), "sensitive");
8314 }
8315
8316 /**
8317  * gtk_widget_get_sensitive:
8318  * @widget: a #GtkWidget
8319  *
8320  * Returns the widget's sensitivity (in the sense of returning
8321  * the value that has been set using gtk_widget_set_sensitive()).
8322  *
8323  * The effective sensitivity of a widget is however determined by both its
8324  * own and its parent widget's sensitivity. See gtk_widget_is_sensitive().
8325  *
8326  * Returns: %TRUE if the widget is sensitive
8327  *
8328  * Since: 2.18
8329  */
8330 gboolean
8331 gtk_widget_get_sensitive (GtkWidget *widget)
8332 {
8333   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8334
8335   return widget->priv->sensitive;
8336 }
8337
8338 /**
8339  * gtk_widget_is_sensitive:
8340  * @widget: a #GtkWidget
8341  *
8342  * Returns the widget's effective sensitivity, which means
8343  * it is sensitive itself and also its parent widget is sensitive
8344  *
8345  * Returns: %TRUE if the widget is effectively sensitive
8346  *
8347  * Since: 2.18
8348  */
8349 gboolean
8350 gtk_widget_is_sensitive (GtkWidget *widget)
8351 {
8352   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8353
8354   return !(widget->priv->state_flags & GTK_STATE_FLAG_INSENSITIVE);
8355 }
8356
8357 /**
8358  * gtk_widget_set_parent:
8359  * @widget: a #GtkWidget
8360  * @parent: parent container
8361  *
8362  * This function is useful only when implementing subclasses of
8363  * #GtkContainer.
8364  * Sets the container as the parent of @widget, and takes care of
8365  * some details such as updating the state and style of the child
8366  * to reflect its new location. The opposite function is
8367  * gtk_widget_unparent().
8368  **/
8369 void
8370 gtk_widget_set_parent (GtkWidget *widget,
8371                        GtkWidget *parent)
8372 {
8373   GtkStateFlags parent_flags;
8374   GtkWidgetPrivate *priv;
8375   GtkStateData data;
8376
8377   g_return_if_fail (GTK_IS_WIDGET (widget));
8378   g_return_if_fail (GTK_IS_WIDGET (parent));
8379   g_return_if_fail (widget != parent);
8380
8381   priv = widget->priv;
8382
8383   if (priv->parent != NULL)
8384     {
8385       g_warning ("Can't set a parent on widget which has a parent\n");
8386       return;
8387     }
8388   if (gtk_widget_is_toplevel (widget))
8389     {
8390       g_warning ("Can't set a parent on a toplevel widget\n");
8391       return;
8392     }
8393
8394   /* keep this function in sync with gtk_menu_attach_to_widget()
8395    */
8396
8397   g_object_ref_sink (widget);
8398
8399   gtk_widget_push_verify_invariants (widget);
8400
8401   priv->parent = parent;
8402
8403   parent_flags = gtk_widget_get_state_flags (parent);
8404
8405   /* Merge both old state and current parent state,
8406    * making sure to only propagate the right states */
8407   data.flags_to_set = parent_flags & GTK_STATE_FLAGS_DO_PROPAGATE;
8408   data.flags_to_unset = 0;
8409   gtk_widget_propagate_state (widget, &data);
8410
8411   if (priv->context)
8412     gtk_style_context_set_parent (priv->context,
8413                                   gtk_widget_get_style_context (parent));
8414
8415   _gtk_widget_update_parent_muxer (widget);
8416
8417   g_signal_emit (widget, widget_signals[PARENT_SET], 0, NULL);
8418   if (priv->parent->priv->anchored)
8419     _gtk_widget_propagate_hierarchy_changed (widget, NULL);
8420   g_object_notify (G_OBJECT (widget), "parent");
8421
8422   /* Enforce realized/mapped invariants
8423    */
8424   if (gtk_widget_get_realized (priv->parent))
8425     gtk_widget_realize (widget);
8426
8427   if (gtk_widget_get_visible (priv->parent) &&
8428       gtk_widget_get_visible (widget))
8429     {
8430       if (gtk_widget_get_child_visible (widget) &&
8431           gtk_widget_get_mapped (priv->parent))
8432         gtk_widget_map (widget);
8433
8434       gtk_widget_queue_resize (widget);
8435     }
8436
8437   /* child may cause parent's expand to change, if the child is
8438    * expanded. If child is not expanded, then it can't modify the
8439    * parent's expand. If the child becomes expanded later then it will
8440    * queue compute_expand then. This optimization plus defaulting
8441    * newly-constructed widgets to need_compute_expand=FALSE should
8442    * mean that initially building a widget tree doesn't have to keep
8443    * walking up setting need_compute_expand on parents over and over.
8444    *
8445    * We can't change a parent to need to expand unless we're visible.
8446    */
8447   if (gtk_widget_get_visible (widget) &&
8448       (priv->need_compute_expand ||
8449        priv->computed_hexpand ||
8450        priv->computed_vexpand))
8451     {
8452       gtk_widget_queue_compute_expand (parent);
8453     }
8454
8455   gtk_widget_propagate_alpha (widget);
8456
8457   gtk_widget_pop_verify_invariants (widget);
8458 }
8459
8460 /**
8461  * gtk_widget_get_parent:
8462  * @widget: a #GtkWidget
8463  *
8464  * Returns the parent container of @widget.
8465  *
8466  * Return value: (transfer none): the parent container of @widget, or %NULL
8467  **/
8468 GtkWidget *
8469 gtk_widget_get_parent (GtkWidget *widget)
8470 {
8471   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
8472
8473   return widget->priv->parent;
8474 }
8475
8476 static void
8477 modifier_style_changed (GtkModifierStyle *style,
8478                         GtkWidget        *widget)
8479 {
8480   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_ANY);
8481 }
8482
8483 static GtkModifierStyle *
8484 _gtk_widget_get_modifier_properties (GtkWidget *widget)
8485 {
8486   GtkModifierStyle *style;
8487
8488   style = g_object_get_qdata (G_OBJECT (widget), quark_modifier_style);
8489
8490   if (G_UNLIKELY (!style))
8491     {
8492       GtkStyleContext *context;
8493
8494       style = _gtk_modifier_style_new ();
8495       g_object_set_qdata_full (G_OBJECT (widget),
8496                                quark_modifier_style,
8497                                style,
8498                                (GDestroyNotify) g_object_unref);
8499
8500       g_signal_connect (style, "changed",
8501                         G_CALLBACK (modifier_style_changed), widget);
8502
8503       context = gtk_widget_get_style_context (widget);
8504
8505       gtk_style_context_add_provider (context,
8506                                       GTK_STYLE_PROVIDER (style),
8507                                       GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
8508     }
8509
8510   return style;
8511 }
8512
8513 /**
8514  * gtk_widget_override_color:
8515  * @widget: a #GtkWidget
8516  * @state: the state for which to set the color
8517  * @color: (allow-none): the color to assign, or %NULL to undo the effect
8518  *     of previous calls to gtk_widget_override_color()
8519  *
8520  * Sets the color to use for a widget.
8521  *
8522  * All other style values are left untouched.
8523  *
8524  * <note><para>
8525  * This API is mostly meant as a quick way for applications to
8526  * change a widget appearance. If you are developing a widgets
8527  * library and intend this change to be themeable, it is better
8528  * done by setting meaningful CSS classes and regions in your
8529  * widget/container implementation through gtk_style_context_add_class()
8530  * and gtk_style_context_add_region().
8531  * </para><para>
8532  * This way, your widget library can install a #GtkCssProvider
8533  * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
8534  * to provide a default styling for those widgets that need so, and
8535  * this theming may fully overridden by the user's theme.
8536  * </para></note>
8537  * <note><para>
8538  * Note that for complex widgets this may bring in undesired
8539  * results (such as uniform background color everywhere), in
8540  * these cases it is better to fully style such widgets through a
8541  * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
8542  * priority.
8543  * </para></note>
8544  *
8545  * Since: 3.0
8546  */
8547 void
8548 gtk_widget_override_color (GtkWidget     *widget,
8549                            GtkStateFlags  state,
8550                            const GdkRGBA *color)
8551 {
8552   GtkModifierStyle *style;
8553
8554   g_return_if_fail (GTK_IS_WIDGET (widget));
8555
8556   style = _gtk_widget_get_modifier_properties (widget);
8557   _gtk_modifier_style_set_color (style, state, color);
8558 }
8559
8560 /**
8561  * gtk_widget_override_background_color:
8562  * @widget: a #GtkWidget
8563  * @state: the state for which to set the background color
8564  * @color: (allow-none): the color to assign, or %NULL to undo the effect
8565  *     of previous calls to gtk_widget_override_background_color()
8566  *
8567  * Sets the background color to use for a widget.
8568  *
8569  * All other style values are left untouched.
8570  * See gtk_widget_override_color().
8571  *
8572  * Since: 3.0
8573  */
8574 void
8575 gtk_widget_override_background_color (GtkWidget     *widget,
8576                                       GtkStateFlags  state,
8577                                       const GdkRGBA *color)
8578 {
8579   GtkModifierStyle *style;
8580
8581   g_return_if_fail (GTK_IS_WIDGET (widget));
8582
8583   style = _gtk_widget_get_modifier_properties (widget);
8584   _gtk_modifier_style_set_background_color (style, state, color);
8585 }
8586
8587 /**
8588  * gtk_widget_override_font:
8589  * @widget: a #GtkWidget
8590  * @font_desc: (allow-none): the font descriptiong to use, or %NULL to undo
8591  *     the effect of previous calls to gtk_widget_override_font()
8592  *
8593  * Sets the font to use for a widget. All other style values are
8594  * left untouched. See gtk_widget_override_color().
8595  *
8596  * Since: 3.0
8597  */
8598 void
8599 gtk_widget_override_font (GtkWidget                  *widget,
8600                           const PangoFontDescription *font_desc)
8601 {
8602   GtkModifierStyle *style;
8603
8604   g_return_if_fail (GTK_IS_WIDGET (widget));
8605
8606   style = _gtk_widget_get_modifier_properties (widget);
8607   _gtk_modifier_style_set_font (style, font_desc);
8608 }
8609
8610 /**
8611  * gtk_widget_override_symbolic_color:
8612  * @widget: a #GtkWidget
8613  * @name: the name of the symbolic color to modify
8614  * @color: (allow-none): the color to assign (does not need
8615  *     to be allocated), or %NULL to undo the effect of previous
8616  *     calls to gtk_widget_override_symbolic_color()
8617  *
8618  * Sets a symbolic color for a widget.
8619  *
8620  * All other style values are left untouched.
8621  * See gtk_widget_override_color() for overriding the foreground
8622  * or background color.
8623  *
8624  * Since: 3.0
8625  */
8626 void
8627 gtk_widget_override_symbolic_color (GtkWidget     *widget,
8628                                     const gchar   *name,
8629                                     const GdkRGBA *color)
8630 {
8631   GtkModifierStyle *style;
8632
8633   g_return_if_fail (GTK_IS_WIDGET (widget));
8634
8635   style = _gtk_widget_get_modifier_properties (widget);
8636   _gtk_modifier_style_map_color (style, name, color);
8637 }
8638
8639 /**
8640  * gtk_widget_override_cursor:
8641  * @widget: a #GtkWidget
8642  * @cursor: (allow-none): the color to use for primary cursor (does not need to be
8643  *     allocated), or %NULL to undo the effect of previous calls to
8644  *     of gtk_widget_override_cursor().
8645  * @secondary_cursor: (allow-none): the color to use for secondary cursor (does not
8646  *     need to be allocated), or %NULL to undo the effect of previous
8647  *     calls to of gtk_widget_override_cursor().
8648  *
8649  * Sets the cursor color to use in a widget, overriding the
8650  * #GtkWidget:cursor-color and #GtkWidget:secondary-cursor-color
8651  * style properties. All other style values are left untouched.
8652  * See also gtk_widget_modify_style().
8653  *
8654  * Note that the underlying properties have the #GdkColor type,
8655  * so the alpha value in @primary and @secondary will be ignored.
8656  *
8657  * Since: 3.0
8658  */
8659 void
8660 gtk_widget_override_cursor (GtkWidget     *widget,
8661                             const GdkRGBA *cursor,
8662                             const GdkRGBA *secondary_cursor)
8663 {
8664   GtkModifierStyle *style;
8665
8666   g_return_if_fail (GTK_IS_WIDGET (widget));
8667
8668   style = _gtk_widget_get_modifier_properties (widget);
8669   _gtk_modifier_style_set_color_property (style,
8670                                           GTK_TYPE_WIDGET,
8671                                           "cursor-color", cursor);
8672   _gtk_modifier_style_set_color_property (style,
8673                                           GTK_TYPE_WIDGET,
8674                                           "secondary-cursor-color",
8675                                           secondary_cursor);
8676 }
8677
8678 static void
8679 gtk_widget_real_direction_changed (GtkWidget        *widget,
8680                                    GtkTextDirection  previous_direction)
8681 {
8682   gtk_widget_queue_resize (widget);
8683 }
8684
8685 static void
8686 gtk_widget_real_style_set (GtkWidget *widget,
8687                            GtkStyle  *previous_style)
8688 {
8689 }
8690
8691 typedef struct {
8692   GtkWidget *previous_toplevel;
8693   GdkScreen *previous_screen;
8694   GdkScreen *new_screen;
8695 } HierarchyChangedInfo;
8696
8697 static void
8698 do_screen_change (GtkWidget *widget,
8699                   GdkScreen *old_screen,
8700                   GdkScreen *new_screen)
8701 {
8702   if (old_screen != new_screen)
8703     {
8704       GtkWidgetPrivate *priv = widget->priv;
8705
8706       if (old_screen)
8707         {
8708           PangoContext *context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
8709           if (context)
8710             g_object_set_qdata (G_OBJECT (widget), quark_pango_context, NULL);
8711         }
8712
8713       _gtk_tooltip_hide (widget);
8714
8715       if (new_screen && priv->context)
8716         gtk_style_context_set_screen (priv->context, new_screen);
8717
8718       g_signal_emit (widget, widget_signals[SCREEN_CHANGED], 0, old_screen);
8719     }
8720 }
8721
8722 static void
8723 gtk_widget_propagate_hierarchy_changed_recurse (GtkWidget *widget,
8724                                                 gpointer   client_data)
8725 {
8726   GtkWidgetPrivate *priv = widget->priv;
8727   HierarchyChangedInfo *info = client_data;
8728   gboolean new_anchored = gtk_widget_is_toplevel (widget) ||
8729                  (priv->parent && priv->parent->priv->anchored);
8730
8731   if (priv->anchored != new_anchored)
8732     {
8733       g_object_ref (widget);
8734
8735       priv->anchored = new_anchored;
8736
8737       /* This can only happen with gtk_widget_reparent() */
8738       if (priv->realized)
8739         {
8740           if (new_anchored)
8741             gtk_widget_connect_frame_clock (widget,
8742                                             gtk_widget_get_frame_clock (widget));
8743           else
8744             gtk_widget_disconnect_frame_clock (widget,
8745                                                gtk_widget_get_frame_clock (info->previous_toplevel));
8746         }
8747
8748       g_signal_emit (widget, widget_signals[HIERARCHY_CHANGED], 0, info->previous_toplevel);
8749       do_screen_change (widget, info->previous_screen, info->new_screen);
8750
8751       if (GTK_IS_CONTAINER (widget))
8752         gtk_container_forall (GTK_CONTAINER (widget),
8753                               gtk_widget_propagate_hierarchy_changed_recurse,
8754                               client_data);
8755
8756       g_object_unref (widget);
8757     }
8758 }
8759
8760 /**
8761  * _gtk_widget_propagate_hierarchy_changed:
8762  * @widget: a #GtkWidget
8763  * @previous_toplevel: Previous toplevel
8764  *
8765  * Propagates changes in the anchored state to a widget and all
8766  * children, unsetting or setting the %ANCHORED flag, and
8767  * emitting #GtkWidget::hierarchy-changed.
8768  **/
8769 void
8770 _gtk_widget_propagate_hierarchy_changed (GtkWidget *widget,
8771                                          GtkWidget *previous_toplevel)
8772 {
8773   GtkWidgetPrivate *priv = widget->priv;
8774   HierarchyChangedInfo info;
8775
8776   info.previous_toplevel = previous_toplevel;
8777   info.previous_screen = previous_toplevel ? gtk_widget_get_screen (previous_toplevel) : NULL;
8778
8779   if (gtk_widget_is_toplevel (widget) ||
8780       (priv->parent && priv->parent->priv->anchored))
8781     info.new_screen = gtk_widget_get_screen (widget);
8782   else
8783     info.new_screen = NULL;
8784
8785   if (info.previous_screen)
8786     g_object_ref (info.previous_screen);
8787   if (previous_toplevel)
8788     g_object_ref (previous_toplevel);
8789
8790   gtk_widget_propagate_hierarchy_changed_recurse (widget, &info);
8791
8792   if (previous_toplevel)
8793     g_object_unref (previous_toplevel);
8794   if (info.previous_screen)
8795     g_object_unref (info.previous_screen);
8796 }
8797
8798 static void
8799 gtk_widget_propagate_screen_changed_recurse (GtkWidget *widget,
8800                                              gpointer   client_data)
8801 {
8802   HierarchyChangedInfo *info = client_data;
8803
8804   g_object_ref (widget);
8805
8806   do_screen_change (widget, info->previous_screen, info->new_screen);
8807
8808   if (GTK_IS_CONTAINER (widget))
8809     gtk_container_forall (GTK_CONTAINER (widget),
8810                           gtk_widget_propagate_screen_changed_recurse,
8811                           client_data);
8812
8813   g_object_unref (widget);
8814 }
8815
8816 /**
8817  * gtk_widget_is_composited:
8818  * @widget: a #GtkWidget
8819  *
8820  * Whether @widget can rely on having its alpha channel
8821  * drawn correctly. On X11 this function returns whether a
8822  * compositing manager is running for @widget's screen.
8823  *
8824  * Please note that the semantics of this call will change
8825  * in the future if used on a widget that has a composited
8826  * window in its hierarchy (as set by gdk_window_set_composited()).
8827  *
8828  * Return value: %TRUE if the widget can rely on its alpha
8829  * channel being drawn correctly.
8830  *
8831  * Since: 2.10
8832  */
8833 gboolean
8834 gtk_widget_is_composited (GtkWidget *widget)
8835 {
8836   GdkScreen *screen;
8837
8838   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
8839
8840   screen = gtk_widget_get_screen (widget);
8841
8842   return gdk_screen_is_composited (screen);
8843 }
8844
8845 static void
8846 propagate_composited_changed (GtkWidget *widget,
8847                               gpointer dummy)
8848 {
8849   if (GTK_IS_CONTAINER (widget))
8850     {
8851       gtk_container_forall (GTK_CONTAINER (widget),
8852                             propagate_composited_changed,
8853                             NULL);
8854     }
8855
8856   g_signal_emit (widget, widget_signals[COMPOSITED_CHANGED], 0);
8857 }
8858
8859 void
8860 _gtk_widget_propagate_composited_changed (GtkWidget *widget)
8861 {
8862   propagate_composited_changed (widget, NULL);
8863 }
8864
8865 /**
8866  * _gtk_widget_propagate_screen_changed:
8867  * @widget: a #GtkWidget
8868  * @previous_screen: Previous screen
8869  *
8870  * Propagates changes in the screen for a widget to all
8871  * children, emitting #GtkWidget::screen-changed.
8872  **/
8873 void
8874 _gtk_widget_propagate_screen_changed (GtkWidget    *widget,
8875                                       GdkScreen    *previous_screen)
8876 {
8877   HierarchyChangedInfo info;
8878
8879   info.previous_screen = previous_screen;
8880   info.new_screen = gtk_widget_get_screen (widget);
8881
8882   if (previous_screen)
8883     g_object_ref (previous_screen);
8884
8885   gtk_widget_propagate_screen_changed_recurse (widget, &info);
8886
8887   if (previous_screen)
8888     g_object_unref (previous_screen);
8889 }
8890
8891 static void
8892 reset_style_recurse (GtkWidget *widget, gpointer data)
8893 {
8894   _gtk_widget_invalidate_style_context (widget, GTK_CSS_CHANGE_ANY);
8895
8896   if (GTK_IS_CONTAINER (widget))
8897     gtk_container_forall (GTK_CONTAINER (widget),
8898                           reset_style_recurse,
8899                           NULL);
8900 }
8901
8902 /**
8903  * gtk_widget_reset_style:
8904  * @widget: a #GtkWidget
8905  *
8906  * Updates the style context of @widget and all descendents
8907  * by updating its widget path. #GtkContainer<!-- -->s may want
8908  * to use this on a child when reordering it in a way that a different
8909  * style might apply to it. See also gtk_container_get_path_for_child().
8910  *
8911  * Since: 3.0
8912  */
8913 void
8914 gtk_widget_reset_style (GtkWidget *widget)
8915 {
8916   g_return_if_fail (GTK_IS_WIDGET (widget));
8917
8918   reset_style_recurse (widget, NULL);
8919
8920   g_list_foreach (widget->priv->attached_windows,
8921                   (GFunc) reset_style_recurse, NULL);
8922 }
8923
8924 #ifdef G_ENABLE_DEBUG
8925
8926 /* Verify invariants, see docs/widget_system.txt for notes on much of
8927  * this.  Invariants may be temporarily broken while we're in the
8928  * process of updating state, of course, so you can only
8929  * verify_invariants() after a given operation is complete.
8930  * Use push/pop_verify_invariants to help with that.
8931  */
8932 static void
8933 gtk_widget_verify_invariants (GtkWidget *widget)
8934 {
8935   GtkWidget *parent;
8936
8937   if (widget->priv->verifying_invariants_count > 0)
8938     return;
8939
8940   parent = widget->priv->parent;
8941
8942   if (widget->priv->mapped)
8943     {
8944       /* Mapped implies ... */
8945
8946       if (!widget->priv->realized)
8947         g_warning ("%s %p is mapped but not realized",
8948                    G_OBJECT_TYPE_NAME (widget), widget);
8949
8950       if (!widget->priv->visible)
8951         g_warning ("%s %p is mapped but not visible",
8952                    G_OBJECT_TYPE_NAME (widget), widget);
8953
8954       if (!widget->priv->toplevel)
8955         {
8956           if (!widget->priv->child_visible)
8957             g_warning ("%s %p is mapped but not child_visible",
8958                        G_OBJECT_TYPE_NAME (widget), widget);
8959         }
8960     }
8961   else
8962     {
8963       /* Not mapped implies... */
8964
8965 #if 0
8966   /* This check makes sense for normal toplevels, but for
8967    * something like a toplevel that is embedded within a clutter
8968    * state, mapping may depend on external factors.
8969    */
8970       if (widget->priv->toplevel)
8971         {
8972           if (widget->priv->visible)
8973             g_warning ("%s %p toplevel is visible but not mapped",
8974                        G_OBJECT_TYPE_NAME (widget), widget);
8975         }
8976 #endif
8977     }
8978
8979   /* Parent related checks aren't possible if parent has
8980    * verifying_invariants_count > 0 because parent needs to recurse
8981    * children first before the invariants will hold.
8982    */
8983   if (parent == NULL || parent->priv->verifying_invariants_count == 0)
8984     {
8985       if (parent &&
8986           parent->priv->realized)
8987         {
8988           /* Parent realized implies... */
8989
8990 #if 0
8991           /* This is in widget_system.txt but appears to fail
8992            * because there's no gtk_container_realize() that
8993            * realizes all children... instead we just lazily
8994            * wait for map to fix things up.
8995            */
8996           if (!widget->priv->realized)
8997             g_warning ("%s %p is realized but child %s %p is not realized",
8998                        G_OBJECT_TYPE_NAME (parent), parent,
8999                        G_OBJECT_TYPE_NAME (widget), widget);
9000 #endif
9001         }
9002       else if (!widget->priv->toplevel)
9003         {
9004           /* No parent or parent not realized on non-toplevel implies... */
9005
9006           if (widget->priv->realized && !widget->priv->in_reparent)
9007             g_warning ("%s %p is not realized but child %s %p is realized",
9008                        parent ? G_OBJECT_TYPE_NAME (parent) : "no parent", parent,
9009                        G_OBJECT_TYPE_NAME (widget), widget);
9010         }
9011
9012       if (parent &&
9013           parent->priv->mapped &&
9014           widget->priv->visible &&
9015           widget->priv->child_visible)
9016         {
9017           /* Parent mapped and we are visible implies... */
9018
9019           if (!widget->priv->mapped)
9020             g_warning ("%s %p is mapped but visible child %s %p is not mapped",
9021                        G_OBJECT_TYPE_NAME (parent), parent,
9022                        G_OBJECT_TYPE_NAME (widget), widget);
9023         }
9024       else if (!widget->priv->toplevel)
9025         {
9026           /* No parent or parent not mapped on non-toplevel implies... */
9027
9028           if (widget->priv->mapped && !widget->priv->in_reparent)
9029             g_warning ("%s %p is mapped but visible=%d child_visible=%d parent %s %p mapped=%d",
9030                        G_OBJECT_TYPE_NAME (widget), widget,
9031                        widget->priv->visible,
9032                        widget->priv->child_visible,
9033                        parent ? G_OBJECT_TYPE_NAME (parent) : "no parent", parent,
9034                        parent ? parent->priv->mapped : FALSE);
9035         }
9036     }
9037
9038   if (!widget->priv->realized)
9039     {
9040       /* Not realized implies... */
9041
9042 #if 0
9043       /* widget_system.txt says these hold, but they don't. */
9044       if (widget->priv->alloc_needed)
9045         g_warning ("%s %p alloc needed but not realized",
9046                    G_OBJECT_TYPE_NAME (widget), widget);
9047
9048       if (widget->priv->width_request_needed)
9049         g_warning ("%s %p width request needed but not realized",
9050                    G_OBJECT_TYPE_NAME (widget), widget);
9051
9052       if (widget->priv->height_request_needed)
9053         g_warning ("%s %p height request needed but not realized",
9054                    G_OBJECT_TYPE_NAME (widget), widget);
9055 #endif
9056     }
9057 }
9058
9059 /* The point of this push/pop is that invariants may not hold while
9060  * we're busy making changes. So we only check at the outermost call
9061  * on the call stack, after we finish updating everything.
9062  */
9063 static void
9064 gtk_widget_push_verify_invariants (GtkWidget *widget)
9065 {
9066   widget->priv->verifying_invariants_count += 1;
9067 }
9068
9069 static void
9070 gtk_widget_verify_child_invariants (GtkWidget *widget,
9071                                     gpointer   client_data)
9072 {
9073   /* We don't recurse further; this is a one-level check. */
9074   gtk_widget_verify_invariants (widget);
9075 }
9076
9077 static void
9078 gtk_widget_pop_verify_invariants (GtkWidget *widget)
9079 {
9080   g_assert (widget->priv->verifying_invariants_count > 0);
9081
9082   widget->priv->verifying_invariants_count -= 1;
9083
9084   if (widget->priv->verifying_invariants_count == 0)
9085     {
9086       gtk_widget_verify_invariants (widget);
9087
9088       if (GTK_IS_CONTAINER (widget))
9089         {
9090           /* Check one level of children, because our
9091            * push_verify_invariants() will have prevented some of the
9092            * checks. This does not recurse because if recursion is
9093            * needed, it will happen naturally as each child has a
9094            * push/pop on that child. For example if we're recursively
9095            * mapping children, we'll push/pop on each child as we map
9096            * it.
9097            */
9098           gtk_container_forall (GTK_CONTAINER (widget),
9099                                 gtk_widget_verify_child_invariants,
9100                                 NULL);
9101         }
9102     }
9103 }
9104 #endif /* G_ENABLE_DEBUG */
9105
9106 static PangoContext *
9107 gtk_widget_peek_pango_context (GtkWidget *widget)
9108 {
9109   return g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
9110 }
9111
9112 /**
9113  * gtk_widget_get_pango_context:
9114  * @widget: a #GtkWidget
9115  *
9116  * Gets a #PangoContext with the appropriate font map, font description,
9117  * and base direction for this widget. Unlike the context returned
9118  * by gtk_widget_create_pango_context(), this context is owned by
9119  * the widget (it can be used until the screen for the widget changes
9120  * or the widget is removed from its toplevel), and will be updated to
9121  * match any changes to the widget's attributes. This can be tracked
9122  * by using the #GtkWidget::screen-changed signal on the widget.
9123  *
9124  * Return value: (transfer none): the #PangoContext for the widget.
9125  **/
9126 PangoContext *
9127 gtk_widget_get_pango_context (GtkWidget *widget)
9128 {
9129   PangoContext *context;
9130
9131   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9132
9133   context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
9134   if (!context)
9135     {
9136       context = gtk_widget_create_pango_context (GTK_WIDGET (widget));
9137       g_object_set_qdata_full (G_OBJECT (widget),
9138                                quark_pango_context,
9139                                context,
9140                                g_object_unref);
9141     }
9142
9143   return context;
9144 }
9145
9146 static void
9147 update_pango_context (GtkWidget    *widget,
9148                       PangoContext *context)
9149 {
9150   PangoFontDescription *font_desc;
9151   GtkStyleContext *style_context;
9152
9153   style_context = gtk_widget_get_style_context (widget);
9154   gtk_style_context_get (style_context,
9155                          gtk_widget_get_state_flags (widget),
9156                          "font", &font_desc,
9157                          NULL);
9158
9159   pango_context_set_font_description (context, font_desc);
9160   pango_context_set_base_dir (context,
9161                               gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
9162                               PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
9163
9164   pango_font_description_free (font_desc);
9165 }
9166
9167 static void
9168 gtk_widget_update_pango_context (GtkWidget *widget)
9169 {
9170   PangoContext *context = gtk_widget_peek_pango_context (widget);
9171
9172   if (context)
9173     {
9174       GdkScreen *screen;
9175
9176       update_pango_context (widget, context);
9177
9178       screen = gtk_widget_get_screen_unchecked (widget);
9179       if (screen)
9180         {
9181           pango_cairo_context_set_resolution (context,
9182                                               gdk_screen_get_resolution (screen));
9183           pango_cairo_context_set_font_options (context,
9184                                                 gdk_screen_get_font_options (screen));
9185         }
9186     }
9187 }
9188
9189 /**
9190  * gtk_widget_create_pango_context:
9191  * @widget: a #GtkWidget
9192  *
9193  * Creates a new #PangoContext with the appropriate font map,
9194  * font description, and base direction for drawing text for
9195  * this widget. See also gtk_widget_get_pango_context().
9196  *
9197  * Return value: (transfer full): the new #PangoContext
9198  **/
9199 PangoContext *
9200 gtk_widget_create_pango_context (GtkWidget *widget)
9201 {
9202   GdkScreen *screen;
9203   PangoContext *context;
9204
9205   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9206
9207   screen = gtk_widget_get_screen_unchecked (widget);
9208   if (!screen)
9209     {
9210       GTK_NOTE (MULTIHEAD,
9211                 g_warning ("gtk_widget_create_pango_context ()) called without screen"));
9212
9213       screen = gdk_screen_get_default ();
9214     }
9215
9216   context = gdk_pango_context_get_for_screen (screen);
9217
9218   update_pango_context (widget, context);
9219   pango_context_set_language (context, gtk_get_default_language ());
9220
9221   return context;
9222 }
9223
9224 /**
9225  * gtk_widget_create_pango_layout:
9226  * @widget: a #GtkWidget
9227  * @text: text to set on the layout (can be %NULL)
9228  *
9229  * Creates a new #PangoLayout with the appropriate font map,
9230  * font description, and base direction for drawing text for
9231  * this widget.
9232  *
9233  * If you keep a #PangoLayout created in this way around, you need
9234  * to re-create it when the widget #PangoContext is replaced.
9235  * This can be tracked by using the #GtkWidget::screen-changed signal
9236  * on the widget.
9237  *
9238  * Return value: (transfer full): the new #PangoLayout
9239  **/
9240 PangoLayout *
9241 gtk_widget_create_pango_layout (GtkWidget   *widget,
9242                                 const gchar *text)
9243 {
9244   PangoLayout *layout;
9245   PangoContext *context;
9246
9247   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9248
9249   context = gtk_widget_get_pango_context (widget);
9250   layout = pango_layout_new (context);
9251
9252   if (text)
9253     pango_layout_set_text (layout, text, -1);
9254
9255   return layout;
9256 }
9257
9258 /**
9259  * gtk_widget_render_icon_pixbuf:
9260  * @widget: a #GtkWidget
9261  * @stock_id: a stock ID
9262  * @size: (type int): a stock size. A size of (GtkIconSize)-1 means
9263  *     render at the size of the source and don't scale (if there are
9264  *     multiple source sizes, GTK+ picks one of the available sizes).
9265  *
9266  * A convenience function that uses the theme engine and style
9267  * settings for @widget to look up @stock_id and render it to
9268  * a pixbuf. @stock_id should be a stock icon ID such as
9269  * #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size
9270  * such as #GTK_ICON_SIZE_MENU.
9271  *
9272  * The pixels in the returned #GdkPixbuf are shared with the rest of
9273  * the application and should not be modified. The pixbuf should be freed
9274  * after use with g_object_unref().
9275  *
9276  * Return value: (transfer full): a new pixbuf, or %NULL if the
9277  *     stock ID wasn't known
9278  *
9279  * Since: 3.0
9280  **/
9281 GdkPixbuf*
9282 gtk_widget_render_icon_pixbuf (GtkWidget   *widget,
9283                                const gchar *stock_id,
9284                                GtkIconSize  size)
9285 {
9286   GtkStyleContext *context;
9287   GtkIconSet *icon_set;
9288
9289   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9290   g_return_val_if_fail (stock_id != NULL, NULL);
9291   g_return_val_if_fail (size > GTK_ICON_SIZE_INVALID || size == -1, NULL);
9292
9293   context = gtk_widget_get_style_context (widget);
9294   icon_set = gtk_style_context_lookup_icon_set (context, stock_id);
9295
9296   if (icon_set == NULL)
9297     return NULL;
9298
9299   return gtk_icon_set_render_icon_pixbuf (icon_set, context, size);
9300 }
9301
9302 /**
9303  * gtk_widget_set_parent_window:
9304  * @widget: a #GtkWidget.
9305  * @parent_window: the new parent window.
9306  *
9307  * Sets a non default parent window for @widget.
9308  *
9309  * For GtkWindow classes, setting a @parent_window effects whether
9310  * the window is a toplevel window or can be embedded into other
9311  * widgets.
9312  *
9313  * <note><para>
9314  * For GtkWindow classes, this needs to be called before the
9315  * window is realized.
9316  * </para></note>
9317  *
9318  **/
9319 void
9320 gtk_widget_set_parent_window   (GtkWidget           *widget,
9321                                 GdkWindow           *parent_window)
9322 {
9323   GdkWindow *old_parent_window;
9324
9325   g_return_if_fail (GTK_IS_WIDGET (widget));
9326
9327   old_parent_window = g_object_get_qdata (G_OBJECT (widget),
9328                                           quark_parent_window);
9329
9330   if (parent_window != old_parent_window)
9331     {
9332       gboolean is_plug;
9333
9334       g_object_set_qdata (G_OBJECT (widget), quark_parent_window,
9335                           parent_window);
9336       if (old_parent_window)
9337         g_object_unref (old_parent_window);
9338       if (parent_window)
9339         g_object_ref (parent_window);
9340
9341       /* Unset toplevel flag when adding a parent window to a widget,
9342        * this is the primary entry point to allow toplevels to be
9343        * embeddable.
9344        */
9345 #ifdef GDK_WINDOWING_X11
9346       is_plug = GTK_IS_PLUG (widget);
9347 #else
9348       is_plug = FALSE;
9349 #endif
9350       if (GTK_IS_WINDOW (widget) && !is_plug)
9351         _gtk_window_set_is_toplevel (GTK_WINDOW (widget), parent_window == NULL);
9352     }
9353 }
9354
9355 /**
9356  * gtk_widget_get_parent_window:
9357  * @widget: a #GtkWidget.
9358  *
9359  * Gets @widget's parent window.
9360  *
9361  * Returns: (transfer none): the parent window of @widget.
9362  **/
9363 GdkWindow *
9364 gtk_widget_get_parent_window (GtkWidget *widget)
9365 {
9366   GtkWidgetPrivate *priv;
9367   GdkWindow *parent_window;
9368
9369   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9370
9371   priv = widget->priv;
9372
9373   parent_window = g_object_get_qdata (G_OBJECT (widget), quark_parent_window);
9374
9375   return (parent_window != NULL) ? parent_window :
9376          (priv->parent != NULL) ? priv->parent->priv->window : NULL;
9377 }
9378
9379
9380 /**
9381  * gtk_widget_set_child_visible:
9382  * @widget: a #GtkWidget
9383  * @is_visible: if %TRUE, @widget should be mapped along with its parent.
9384  *
9385  * Sets whether @widget should be mapped along with its when its parent
9386  * is mapped and @widget has been shown with gtk_widget_show().
9387  *
9388  * The child visibility can be set for widget before it is added to
9389  * a container with gtk_widget_set_parent(), to avoid mapping
9390  * children unnecessary before immediately unmapping them. However
9391  * it will be reset to its default state of %TRUE when the widget
9392  * is removed from a container.
9393  *
9394  * Note that changing the child visibility of a widget does not
9395  * queue a resize on the widget. Most of the time, the size of
9396  * a widget is computed from all visible children, whether or
9397  * not they are mapped. If this is not the case, the container
9398  * can queue a resize itself.
9399  *
9400  * This function is only useful for container implementations and
9401  * never should be called by an application.
9402  **/
9403 void
9404 gtk_widget_set_child_visible (GtkWidget *widget,
9405                               gboolean   is_visible)
9406 {
9407   GtkWidgetPrivate *priv;
9408
9409   g_return_if_fail (GTK_IS_WIDGET (widget));
9410   g_return_if_fail (!gtk_widget_is_toplevel (widget));
9411
9412   priv = widget->priv;
9413
9414   g_object_ref (widget);
9415   gtk_widget_verify_invariants (widget);
9416
9417   if (is_visible)
9418     priv->child_visible = TRUE;
9419   else
9420     {
9421       GtkWidget *toplevel;
9422
9423       priv->child_visible = FALSE;
9424
9425       toplevel = gtk_widget_get_toplevel (widget);
9426       if (toplevel != widget && gtk_widget_is_toplevel (toplevel))
9427         _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
9428     }
9429
9430   if (priv->parent && gtk_widget_get_realized (priv->parent))
9431     {
9432       if (gtk_widget_get_mapped (priv->parent) &&
9433           priv->child_visible &&
9434           gtk_widget_get_visible (widget))
9435         gtk_widget_map (widget);
9436       else
9437         gtk_widget_unmap (widget);
9438     }
9439
9440   gtk_widget_verify_invariants (widget);
9441   g_object_unref (widget);
9442 }
9443
9444 /**
9445  * gtk_widget_get_child_visible:
9446  * @widget: a #GtkWidget
9447  *
9448  * Gets the value set with gtk_widget_set_child_visible().
9449  * If you feel a need to use this function, your code probably
9450  * needs reorganization.
9451  *
9452  * This function is only useful for container implementations and
9453  * never should be called by an application.
9454  *
9455  * Return value: %TRUE if the widget is mapped with the parent.
9456  **/
9457 gboolean
9458 gtk_widget_get_child_visible (GtkWidget *widget)
9459 {
9460   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9461
9462   return widget->priv->child_visible;
9463 }
9464
9465 static GdkScreen *
9466 gtk_widget_get_screen_unchecked (GtkWidget *widget)
9467 {
9468   GtkWidget *toplevel;
9469
9470   toplevel = gtk_widget_get_toplevel (widget);
9471
9472   if (gtk_widget_is_toplevel (toplevel))
9473     {
9474       if (GTK_IS_WINDOW (toplevel))
9475         return gtk_window_get_screen (GTK_WINDOW (toplevel));
9476       else if (GTK_IS_INVISIBLE (toplevel))
9477         return gtk_invisible_get_screen (GTK_INVISIBLE (widget));
9478     }
9479
9480   return NULL;
9481 }
9482
9483 /**
9484  * gtk_widget_get_screen:
9485  * @widget: a #GtkWidget
9486  *
9487  * Get the #GdkScreen from the toplevel window associated with
9488  * this widget. This function can only be called after the widget
9489  * has been added to a widget hierarchy with a #GtkWindow
9490  * at the top.
9491  *
9492  * In general, you should only create screen specific
9493  * resources when a widget has been realized, and you should
9494  * free those resources when the widget is unrealized.
9495  *
9496  * Return value: (transfer none): the #GdkScreen for the toplevel for this widget.
9497  *
9498  * Since: 2.2
9499  **/
9500 GdkScreen*
9501 gtk_widget_get_screen (GtkWidget *widget)
9502 {
9503   GdkScreen *screen;
9504
9505   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9506
9507   screen = gtk_widget_get_screen_unchecked (widget);
9508
9509   if (screen)
9510     return screen;
9511   else
9512     {
9513 #if 0
9514       g_warning (G_STRLOC ": Can't get associated screen"
9515                  " for a widget unless it is inside a toplevel GtkWindow\n"
9516                  " widget type is %s associated top level type is %s",
9517                  g_type_name (G_OBJECT_TYPE(G_OBJECT (widget))),
9518                  g_type_name (G_OBJECT_TYPE(G_OBJECT (toplevel))));
9519 #endif
9520       return gdk_screen_get_default ();
9521     }
9522 }
9523
9524 /**
9525  * gtk_widget_has_screen:
9526  * @widget: a #GtkWidget
9527  *
9528  * Checks whether there is a #GdkScreen is associated with
9529  * this widget. All toplevel widgets have an associated
9530  * screen, and all widgets added into a hierarchy with a toplevel
9531  * window at the top.
9532  *
9533  * Return value: %TRUE if there is a #GdkScreen associcated
9534  *   with the widget.
9535  *
9536  * Since: 2.2
9537  **/
9538 gboolean
9539 gtk_widget_has_screen (GtkWidget *widget)
9540 {
9541   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9542
9543   return (gtk_widget_get_screen_unchecked (widget) != NULL);
9544 }
9545
9546 /**
9547  * gtk_widget_get_display:
9548  * @widget: a #GtkWidget
9549  *
9550  * Get the #GdkDisplay for the toplevel window associated with
9551  * this widget. This function can only be called after the widget
9552  * has been added to a widget hierarchy with a #GtkWindow at the top.
9553  *
9554  * In general, you should only create display specific
9555  * resources when a widget has been realized, and you should
9556  * free those resources when the widget is unrealized.
9557  *
9558  * Return value: (transfer none): the #GdkDisplay for the toplevel for this widget.
9559  *
9560  * Since: 2.2
9561  **/
9562 GdkDisplay*
9563 gtk_widget_get_display (GtkWidget *widget)
9564 {
9565   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9566
9567   return gdk_screen_get_display (gtk_widget_get_screen (widget));
9568 }
9569
9570 /**
9571  * gtk_widget_get_root_window:
9572  * @widget: a #GtkWidget
9573  *
9574  * Get the root window where this widget is located. This function can
9575  * only be called after the widget has been added to a widget
9576  * hierarchy with #GtkWindow at the top.
9577  *
9578  * The root window is useful for such purposes as creating a popup
9579  * #GdkWindow associated with the window. In general, you should only
9580  * create display specific resources when a widget has been realized,
9581  * and you should free those resources when the widget is unrealized.
9582  *
9583  * Return value: (transfer none): the #GdkWindow root window for the toplevel for this widget.
9584  *
9585  * Since: 2.2
9586  **/
9587 GdkWindow*
9588 gtk_widget_get_root_window (GtkWidget *widget)
9589 {
9590   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
9591
9592   return gdk_screen_get_root_window (gtk_widget_get_screen (widget));
9593 }
9594
9595 /**
9596  * gtk_widget_child_focus:
9597  * @widget: a #GtkWidget
9598  * @direction: direction of focus movement
9599  *
9600  * This function is used by custom widget implementations; if you're
9601  * writing an app, you'd use gtk_widget_grab_focus() to move the focus
9602  * to a particular widget, and gtk_container_set_focus_chain() to
9603  * change the focus tab order. So you may want to investigate those
9604  * functions instead.
9605  *
9606  * gtk_widget_child_focus() is called by containers as the user moves
9607  * around the window using keyboard shortcuts. @direction indicates
9608  * what kind of motion is taking place (up, down, left, right, tab
9609  * forward, tab backward). gtk_widget_child_focus() emits the
9610  * #GtkWidget::focus signal; widgets override the default handler
9611  * for this signal in order to implement appropriate focus behavior.
9612  *
9613  * The default ::focus handler for a widget should return %TRUE if
9614  * moving in @direction left the focus on a focusable location inside
9615  * that widget, and %FALSE if moving in @direction moved the focus
9616  * outside the widget. If returning %TRUE, widgets normally
9617  * call gtk_widget_grab_focus() to place the focus accordingly;
9618  * if returning %FALSE, they don't modify the current focus location.
9619  *
9620  * Return value: %TRUE if focus ended up inside @widget
9621  **/
9622 gboolean
9623 gtk_widget_child_focus (GtkWidget       *widget,
9624                         GtkDirectionType direction)
9625 {
9626   gboolean return_val;
9627
9628   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9629
9630   if (!gtk_widget_get_visible (widget) ||
9631       !gtk_widget_is_sensitive (widget))
9632     return FALSE;
9633
9634   /* child widgets must set CAN_FOCUS, containers
9635    * don't have to though.
9636    */
9637   if (!GTK_IS_CONTAINER (widget) &&
9638       !gtk_widget_get_can_focus (widget))
9639     return FALSE;
9640
9641   g_signal_emit (widget,
9642                  widget_signals[FOCUS],
9643                  0,
9644                  direction, &return_val);
9645
9646   return return_val;
9647 }
9648
9649 /**
9650  * gtk_widget_keynav_failed:
9651  * @widget: a #GtkWidget
9652  * @direction: direction of focus movement
9653  *
9654  * This function should be called whenever keyboard navigation within
9655  * a single widget hits a boundary. The function emits the
9656  * #GtkWidget::keynav-failed signal on the widget and its return
9657  * value should be interpreted in a way similar to the return value of
9658  * gtk_widget_child_focus():
9659  *
9660  * When %TRUE is returned, stay in the widget, the failed keyboard
9661  * navigation is Ok and/or there is nowhere we can/should move the
9662  * focus to.
9663  *
9664  * When %FALSE is returned, the caller should continue with keyboard
9665  * navigation outside the widget, e.g. by calling
9666  * gtk_widget_child_focus() on the widget's toplevel.
9667  *
9668  * The default ::keynav-failed handler returns %TRUE for
9669  * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
9670  * values of #GtkDirectionType, it looks at the
9671  * #GtkSettings:gtk-keynav-cursor-only setting and returns %FALSE
9672  * if the setting is %TRUE. This way the entire user interface
9673  * becomes cursor-navigatable on input devices such as mobile phones
9674  * which only have cursor keys but no tab key.
9675  *
9676  * Whenever the default handler returns %TRUE, it also calls
9677  * gtk_widget_error_bell() to notify the user of the failed keyboard
9678  * navigation.
9679  *
9680  * A use case for providing an own implementation of ::keynav-failed
9681  * (either by connecting to it or by overriding it) would be a row of
9682  * #GtkEntry widgets where the user should be able to navigate the
9683  * entire row with the cursor keys, as e.g. known from user interfaces
9684  * that require entering license keys.
9685  *
9686  * Return value: %TRUE if stopping keyboard navigation is fine, %FALSE
9687  *               if the emitting widget should try to handle the keyboard
9688  *               navigation attempt in its parent container(s).
9689  *
9690  * Since: 2.12
9691  **/
9692 gboolean
9693 gtk_widget_keynav_failed (GtkWidget        *widget,
9694                           GtkDirectionType  direction)
9695 {
9696   gboolean return_val;
9697
9698   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
9699
9700   g_signal_emit (widget, widget_signals[KEYNAV_FAILED], 0,
9701                  direction, &return_val);
9702
9703   return return_val;
9704 }
9705
9706 /**
9707  * gtk_widget_error_bell:
9708  * @widget: a #GtkWidget
9709  *
9710  * Notifies the user about an input-related error on this widget.
9711  * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
9712  * gdk_window_beep(), otherwise it does nothing.
9713  *
9714  * Note that the effect of gdk_window_beep() can be configured in many
9715  * ways, depending on the windowing backend and the desktop environment
9716  * or window manager that is used.
9717  *
9718  * Since: 2.12
9719  **/
9720 void
9721 gtk_widget_error_bell (GtkWidget *widget)
9722 {
9723   GtkWidgetPrivate *priv;
9724   GtkSettings* settings;
9725   gboolean beep;
9726
9727   g_return_if_fail (GTK_IS_WIDGET (widget));
9728
9729   priv = widget->priv;
9730
9731   settings = gtk_widget_get_settings (widget);
9732   if (!settings)
9733     return;
9734
9735   g_object_get (settings,
9736                 "gtk-error-bell", &beep,
9737                 NULL);
9738
9739   if (beep && priv->window)
9740     gdk_window_beep (priv->window);
9741 }
9742
9743 static void
9744 gtk_widget_set_usize_internal (GtkWidget          *widget,
9745                                gint                width,
9746                                gint                height,
9747                                GtkQueueResizeFlags flags)
9748 {
9749   GtkWidgetAuxInfo *aux_info;
9750   gboolean changed = FALSE;
9751
9752   g_object_freeze_notify (G_OBJECT (widget));
9753
9754   aux_info = gtk_widget_get_aux_info (widget, TRUE);
9755
9756   if (width > -2 && aux_info->width != width)
9757     {
9758       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9759         g_object_notify (G_OBJECT (widget), "width-request");
9760       aux_info->width = width;
9761       changed = TRUE;
9762     }
9763   if (height > -2 && aux_info->height != height)
9764     {
9765       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9766         g_object_notify (G_OBJECT (widget), "height-request");
9767       aux_info->height = height;
9768       changed = TRUE;
9769     }
9770
9771   if (gtk_widget_get_visible (widget) && changed)
9772     {
9773       if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
9774         gtk_widget_queue_resize (widget);
9775       else
9776         _gtk_size_group_queue_resize (widget, GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9777     }
9778
9779   g_object_thaw_notify (G_OBJECT (widget));
9780 }
9781
9782 /**
9783  * gtk_widget_set_size_request:
9784  * @widget: a #GtkWidget
9785  * @width: width @widget should request, or -1 to unset
9786  * @height: height @widget should request, or -1 to unset
9787  *
9788  * Sets the minimum size of a widget; that is, the widget's size
9789  * request will be at least @width by @height. You can use this
9790  * function to force a widget to be larger than it normally would be.
9791  *
9792  * In most cases, gtk_window_set_default_size() is a better choice for
9793  * toplevel windows than this function; setting the default size will
9794  * still allow users to shrink the window. Setting the size request
9795  * will force them to leave the window at least as large as the size
9796  * request. When dealing with window sizes,
9797  * gtk_window_set_geometry_hints() can be a useful function as well.
9798  *
9799  * Note the inherent danger of setting any fixed size - themes,
9800  * translations into other languages, different fonts, and user action
9801  * can all change the appropriate size for a given widget. So, it's
9802  * basically impossible to hardcode a size that will always be
9803  * correct.
9804  *
9805  * The size request of a widget is the smallest size a widget can
9806  * accept while still functioning well and drawing itself correctly.
9807  * However in some strange cases a widget may be allocated less than
9808  * its requested size, and in many cases a widget may be allocated more
9809  * space than it requested.
9810  *
9811  * If the size request in a given direction is -1 (unset), then
9812  * the "natural" size request of the widget will be used instead.
9813  *
9814  * The size request set here does not include any margin from the
9815  * #GtkWidget properties margin-left, margin-right, margin-top, and
9816  * margin-bottom, but it does include pretty much all other padding
9817  * or border properties set by any subclass of #GtkWidget.
9818  **/
9819 void
9820 gtk_widget_set_size_request (GtkWidget *widget,
9821                              gint       width,
9822                              gint       height)
9823 {
9824   g_return_if_fail (GTK_IS_WIDGET (widget));
9825   g_return_if_fail (width >= -1);
9826   g_return_if_fail (height >= -1);
9827
9828   if (width == 0)
9829     width = 1;
9830   if (height == 0)
9831     height = 1;
9832
9833   gtk_widget_set_usize_internal (widget, width, height, 0);
9834 }
9835
9836
9837 /**
9838  * gtk_widget_get_size_request:
9839  * @widget: a #GtkWidget
9840  * @width: (out) (allow-none): return location for width, or %NULL
9841  * @height: (out) (allow-none): return location for height, or %NULL
9842  *
9843  * Gets the size request that was explicitly set for the widget using
9844  * gtk_widget_set_size_request(). A value of -1 stored in @width or
9845  * @height indicates that that dimension has not been set explicitly
9846  * and the natural requisition of the widget will be used intead. See
9847  * gtk_widget_set_size_request(). To get the size a widget will
9848  * actually request, call gtk_widget_get_preferred_size() instead of
9849  * this function.
9850  **/
9851 void
9852 gtk_widget_get_size_request (GtkWidget *widget,
9853                              gint      *width,
9854                              gint      *height)
9855 {
9856   const GtkWidgetAuxInfo *aux_info;
9857
9858   g_return_if_fail (GTK_IS_WIDGET (widget));
9859
9860   aux_info = _gtk_widget_get_aux_info_or_defaults (widget);
9861
9862   if (width)
9863     *width = aux_info->width;
9864
9865   if (height)
9866     *height = aux_info->height;
9867 }
9868
9869 /**
9870  * _gtk_widget_override_size_request:
9871  * @widget: a #GtkWidget
9872  * @width: new forced minimum width
9873  * @height: new forced minimum height
9874  * @old_width: location to store previous forced minimum width
9875  * @old_height: location to store previous forced minumum height
9876  *
9877  * Temporarily establishes a forced minimum size for a widget; this
9878  * is used by GtkWindow when calculating the size to add to the
9879  * window's geometry widget. Cached sizes for the widget and its
9880  * parents are invalidated, so that subsequent calls to the size
9881  * negotiation machinery produce the overriden result, but the
9882  * widget is not queued for relayout or redraw. The old size must
9883  * be restored with _gtk_widget_restore_size_request() or things
9884  * will go screwy.
9885  */
9886 void
9887 _gtk_widget_override_size_request (GtkWidget *widget,
9888                                    int        width,
9889                                    int        height,
9890                                    int       *old_width,
9891                                    int       *old_height)
9892 {
9893   gtk_widget_get_size_request (widget, old_width, old_height);
9894   gtk_widget_set_usize_internal (widget, width, height,
9895                                  GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9896 }
9897
9898 /**
9899  * _gtk_widget_restore_size_request:
9900  * @widget: a #GtkWidget
9901  * @old_width: saved forced minimum size
9902  * @old_height: saved forced minimum size
9903  *
9904  * Undoes the operation of_gtk_widget_override_size_request().
9905  */
9906 void
9907 _gtk_widget_restore_size_request (GtkWidget *widget,
9908                                   int        old_width,
9909                                   int        old_height)
9910 {
9911   gtk_widget_set_usize_internal (widget, old_width, old_height,
9912                                  GTK_QUEUE_RESIZE_INVALIDATE_ONLY);
9913 }
9914
9915 /**
9916  * gtk_widget_set_events:
9917  * @widget: a #GtkWidget
9918  * @events: event mask
9919  *
9920  * Sets the event mask (see #GdkEventMask) for a widget. The event
9921  * mask determines which events a widget will receive. Keep in mind
9922  * that different widgets have different default event masks, and by
9923  * changing the event mask you may disrupt a widget's functionality,
9924  * so be careful. This function must be called while a widget is
9925  * unrealized. Consider gtk_widget_add_events() for widgets that are
9926  * already realized, or if you want to preserve the existing event
9927  * mask. This function can't be used with #GTK_NO_WINDOW widgets;
9928  * to get events on those widgets, place them inside a #GtkEventBox
9929  * and receive events on the event box.
9930  **/
9931 void
9932 gtk_widget_set_events (GtkWidget *widget,
9933                        gint       events)
9934 {
9935   g_return_if_fail (GTK_IS_WIDGET (widget));
9936   g_return_if_fail (!gtk_widget_get_realized (widget));
9937
9938   g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
9939                       GINT_TO_POINTER (events));
9940   g_object_notify (G_OBJECT (widget), "events");
9941 }
9942
9943 /**
9944  * gtk_widget_set_device_events:
9945  * @widget: a #GtkWidget
9946  * @device: a #GdkDevice
9947  * @events: event mask
9948  *
9949  * Sets the device event mask (see #GdkEventMask) for a widget. The event
9950  * mask determines which events a widget will receive from @device. Keep
9951  * in mind that different widgets have different default event masks, and by
9952  * changing the event mask you may disrupt a widget's functionality,
9953  * so be careful. This function must be called while a widget is
9954  * unrealized. Consider gtk_widget_add_device_events() for widgets that are
9955  * already realized, or if you want to preserve the existing event
9956  * mask. This function can't be used with #GTK_NO_WINDOW widgets;
9957  * to get events on those widgets, place them inside a #GtkEventBox
9958  * and receive events on the event box.
9959  *
9960  * Since: 3.0
9961  **/
9962 void
9963 gtk_widget_set_device_events (GtkWidget    *widget,
9964                               GdkDevice    *device,
9965                               GdkEventMask  events)
9966 {
9967   GHashTable *device_events;
9968
9969   g_return_if_fail (GTK_IS_WIDGET (widget));
9970   g_return_if_fail (GDK_IS_DEVICE (device));
9971   g_return_if_fail (!gtk_widget_get_realized (widget));
9972
9973   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
9974
9975   if (G_UNLIKELY (!device_events))
9976     {
9977       device_events = g_hash_table_new (NULL, NULL);
9978       g_object_set_qdata_full (G_OBJECT (widget), quark_device_event_mask, device_events,
9979                                (GDestroyNotify) g_hash_table_unref);
9980     }
9981
9982   g_hash_table_insert (device_events, device, GUINT_TO_POINTER (events));
9983 }
9984
9985 /**
9986  * gtk_widget_set_device_enabled:
9987  * @widget: a #GtkWidget
9988  * @device: a #GdkDevice
9989  * @enabled: whether to enable the device
9990  *
9991  * Enables or disables a #GdkDevice to interact with @widget
9992  * and all its children.
9993  *
9994  * It does so by descending through the #GdkWindow hierarchy
9995  * and enabling the same mask that is has for core events
9996  * (i.e. the one that gdk_window_get_events() returns).
9997  *
9998  * Since: 3.0
9999  */
10000 void
10001 gtk_widget_set_device_enabled (GtkWidget *widget,
10002                                GdkDevice *device,
10003                                gboolean   enabled)
10004 {
10005   GList *enabled_devices;
10006
10007   g_return_if_fail (GTK_IS_WIDGET (widget));
10008   g_return_if_fail (GDK_IS_DEVICE (device));
10009
10010   enabled_devices = g_object_get_qdata (G_OBJECT (widget), quark_enabled_devices);
10011   enabled_devices = g_list_append (enabled_devices, device);
10012
10013   g_object_set_qdata_full (G_OBJECT (widget), quark_enabled_devices,
10014                            enabled_devices, (GDestroyNotify) g_list_free);;
10015
10016   if (gtk_widget_get_realized (widget))
10017     gtk_widget_set_device_enabled_internal (widget, device, TRUE, enabled);
10018 }
10019
10020 /**
10021  * gtk_widget_get_device_enabled:
10022  * @widget: a #GtkWidget
10023  * @device: a #GdkDevice
10024  *
10025  * Returns whether @device can interact with @widget and its
10026  * children. See gtk_widget_set_device_enabled().
10027  *
10028  * Return value: %TRUE is @device is enabled for @widget
10029  *
10030  * Since: 3.0
10031  */
10032 gboolean
10033 gtk_widget_get_device_enabled (GtkWidget *widget,
10034                                GdkDevice *device)
10035 {
10036   GList *enabled_devices;
10037
10038   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10039   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
10040
10041   enabled_devices = g_object_get_qdata (G_OBJECT (widget), quark_enabled_devices);
10042
10043   return g_list_find (enabled_devices, device) != NULL;
10044 }
10045
10046 static void
10047 gtk_widget_add_events_internal_list (GtkWidget *widget,
10048                                      GdkDevice *device,
10049                                      gint       events,
10050                                      GList     *window_list)
10051 {
10052   GList *l;
10053
10054   for (l = window_list; l != NULL; l = l->next)
10055     {
10056       GdkWindow *window = l->data;
10057       gpointer user_data;
10058
10059       gdk_window_get_user_data (window, &user_data);
10060       if (user_data == widget)
10061         {
10062           GList *children;
10063
10064           if (device)
10065             gdk_window_set_device_events (window, device, gdk_window_get_events (window) | events);
10066           else
10067             gdk_window_set_events (window, gdk_window_get_events (window) | events);
10068
10069           children = gdk_window_get_children (window);
10070           gtk_widget_add_events_internal_list (widget, device, events, children);
10071           g_list_free (children);
10072         }
10073     }
10074 }
10075
10076 static void
10077 gtk_widget_add_events_internal (GtkWidget *widget,
10078                                 GdkDevice *device,
10079                                 gint       events)
10080 {
10081   GtkWidgetPrivate *priv = widget->priv;
10082   GList *window_list;
10083
10084   if (!gtk_widget_get_has_window (widget))
10085     window_list = gdk_window_get_children (priv->window);
10086   else
10087     window_list = g_list_prepend (NULL, priv->window);
10088
10089   gtk_widget_add_events_internal_list (widget, device, events, window_list);
10090
10091   g_list_free (window_list);
10092 }
10093
10094 /**
10095  * gtk_widget_add_events:
10096  * @widget: a #GtkWidget
10097  * @events: an event mask, see #GdkEventMask
10098  *
10099  * Adds the events in the bitfield @events to the event mask for
10100  * @widget. See gtk_widget_set_events() for details.
10101  **/
10102 void
10103 gtk_widget_add_events (GtkWidget *widget,
10104                        gint       events)
10105 {
10106   gint old_events;
10107
10108   g_return_if_fail (GTK_IS_WIDGET (widget));
10109
10110   old_events = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), quark_event_mask));
10111   g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
10112                       GINT_TO_POINTER (old_events | events));
10113
10114   if (gtk_widget_get_realized (widget))
10115     {
10116       gtk_widget_add_events_internal (widget, NULL, events);
10117       gtk_widget_update_devices_mask (widget, FALSE);
10118     }
10119
10120   g_object_notify (G_OBJECT (widget), "events");
10121 }
10122
10123 /**
10124  * gtk_widget_add_device_events:
10125  * @widget: a #GtkWidget
10126  * @device: a #GdkDevice
10127  * @events: an event mask, see #GdkEventMask
10128  *
10129  * Adds the device events in the bitfield @events to the event mask for
10130  * @widget. See gtk_widget_set_device_events() for details.
10131  *
10132  * Since: 3.0
10133  **/
10134 void
10135 gtk_widget_add_device_events (GtkWidget    *widget,
10136                               GdkDevice    *device,
10137                               GdkEventMask  events)
10138 {
10139   GdkEventMask old_events;
10140   GHashTable *device_events;
10141
10142   g_return_if_fail (GTK_IS_WIDGET (widget));
10143   g_return_if_fail (GDK_IS_DEVICE (device));
10144
10145   old_events = gtk_widget_get_device_events (widget, device);
10146
10147   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
10148
10149   if (G_UNLIKELY (!device_events))
10150     {
10151       device_events = g_hash_table_new (NULL, NULL);
10152       g_object_set_qdata_full (G_OBJECT (widget), quark_device_event_mask, device_events,
10153                                (GDestroyNotify) g_hash_table_unref);
10154     }
10155
10156   g_hash_table_insert (device_events, device,
10157                        GUINT_TO_POINTER (old_events | events));
10158
10159   if (gtk_widget_get_realized (widget))
10160     gtk_widget_add_events_internal (widget, device, events);
10161
10162   g_object_notify (G_OBJECT (widget), "events");
10163 }
10164
10165 /**
10166  * gtk_widget_get_toplevel:
10167  * @widget: a #GtkWidget
10168  *
10169  * This function returns the topmost widget in the container hierarchy
10170  * @widget is a part of. If @widget has no parent widgets, it will be
10171  * returned as the topmost widget. No reference will be added to the
10172  * returned widget; it should not be unreferenced.
10173  *
10174  * Note the difference in behavior vs. gtk_widget_get_ancestor();
10175  * <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</literal>
10176  * would return
10177  * %NULL if @widget wasn't inside a toplevel window, and if the
10178  * window was inside a #GtkWindow<!-- -->-derived widget which was in turn
10179  * inside the toplevel #GtkWindow. While the second case may
10180  * seem unlikely, it actually happens when a #GtkPlug is embedded
10181  * inside a #GtkSocket within the same application.
10182  *
10183  * To reliably find the toplevel #GtkWindow, use
10184  * gtk_widget_get_toplevel() and check if the %TOPLEVEL flags
10185  * is set on the result.
10186  * |[
10187  *  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
10188  *  if (gtk_widget_is_toplevel (toplevel))
10189  *    {
10190  *      /&ast; Perform action on toplevel. &ast;/
10191  *    }
10192  * ]|
10193  *
10194  * Return value: (transfer none): the topmost ancestor of @widget, or @widget itself
10195  *    if there's no ancestor.
10196  **/
10197 GtkWidget*
10198 gtk_widget_get_toplevel (GtkWidget *widget)
10199 {
10200   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10201
10202   while (widget->priv->parent)
10203     widget = widget->priv->parent;
10204
10205   return widget;
10206 }
10207
10208 /**
10209  * gtk_widget_get_ancestor:
10210  * @widget: a #GtkWidget
10211  * @widget_type: ancestor type
10212  *
10213  * Gets the first ancestor of @widget with type @widget_type. For example,
10214  * <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</literal> gets
10215  * the first #GtkBox that's an ancestor of @widget. No reference will be
10216  * added to the returned widget; it should not be unreferenced. See note
10217  * about checking for a toplevel #GtkWindow in the docs for
10218  * gtk_widget_get_toplevel().
10219  *
10220  * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
10221  * considers @widget to be an ancestor of itself.
10222  *
10223  * Return value: (transfer none): the ancestor widget, or %NULL if not found
10224  **/
10225 GtkWidget*
10226 gtk_widget_get_ancestor (GtkWidget *widget,
10227                          GType      widget_type)
10228 {
10229   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10230
10231   while (widget && !g_type_is_a (G_OBJECT_TYPE (widget), widget_type))
10232     widget = widget->priv->parent;
10233
10234   if (!(widget && g_type_is_a (G_OBJECT_TYPE (widget), widget_type)))
10235     return NULL;
10236
10237   return widget;
10238 }
10239
10240 /**
10241  * gtk_widget_set_visual:
10242  * @widget: a #GtkWidget
10243  * @visual: visual to be used or %NULL to unset a previous one
10244  *
10245  * Sets the visual that should be used for by widget and its children for
10246  * creating #GdkWindows. The visual must be on the same #GdkScreen as
10247  * returned by gtk_widget_get_screen(), so handling the
10248  * #GtkWidget::screen-changed signal is necessary.
10249  *
10250  * Setting a new @visual will not cause @widget to recreate its windows,
10251  * so you should call this function before @widget is realized.
10252  **/
10253 void
10254 gtk_widget_set_visual (GtkWidget *widget,
10255                        GdkVisual *visual)
10256 {
10257   g_return_if_fail (GTK_IS_WIDGET (widget));
10258   g_return_if_fail (visual == NULL || GDK_IS_VISUAL (visual));
10259   if (visual)
10260     {
10261       g_return_if_fail (gtk_widget_get_screen (widget) == gdk_visual_get_screen (visual));
10262     }
10263
10264   g_object_set_qdata_full (G_OBJECT (widget),
10265                            quark_visual,
10266                            g_object_ref (visual),
10267                            g_object_unref);
10268 }
10269
10270 /**
10271  * gtk_widget_get_visual:
10272  * @widget: a #GtkWidget
10273  *
10274  * Gets the visual that will be used to render @widget.
10275  *
10276  * Return value: (transfer none): the visual for @widget
10277  **/
10278 GdkVisual*
10279 gtk_widget_get_visual (GtkWidget *widget)
10280 {
10281   GtkWidget *w;
10282   GdkVisual *visual;
10283   GdkScreen *screen;
10284
10285   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10286
10287   if (gtk_widget_get_has_window (widget) &&
10288       widget->priv->window)
10289     return gdk_window_get_visual (widget->priv->window);
10290
10291   screen = gtk_widget_get_screen (widget);
10292
10293   for (w = widget; w != NULL; w = w->priv->parent)
10294     {
10295       visual = g_object_get_qdata (G_OBJECT (w), quark_visual);
10296       if (visual)
10297         {
10298           if (gdk_visual_get_screen (visual) == screen)
10299             return visual;
10300
10301           g_warning ("Ignoring visual set on widget `%s' that is not on the correct screen.",
10302                      gtk_widget_get_name (widget));
10303         }
10304     }
10305
10306   return gdk_screen_get_system_visual (screen);
10307 }
10308
10309 /**
10310  * gtk_widget_get_settings:
10311  * @widget: a #GtkWidget
10312  *
10313  * Gets the settings object holding the settings used for this widget.
10314  *
10315  * Note that this function can only be called when the #GtkWidget
10316  * is attached to a toplevel, since the settings object is specific
10317  * to a particular #GdkScreen.
10318  *
10319  * Return value: (transfer none): the relevant #GtkSettings object
10320  */
10321 GtkSettings*
10322 gtk_widget_get_settings (GtkWidget *widget)
10323 {
10324   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10325
10326   return gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
10327 }
10328
10329 /**
10330  * gtk_widget_get_events:
10331  * @widget: a #GtkWidget
10332  *
10333  * Returns the event mask for the widget (a bitfield containing flags
10334  * from the #GdkEventMask enumeration). These are the events that the widget
10335  * will receive.
10336  *
10337  * Return value: event mask for @widget
10338  **/
10339 gint
10340 gtk_widget_get_events (GtkWidget *widget)
10341 {
10342   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
10343
10344   return GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), quark_event_mask));
10345 }
10346
10347 /**
10348  * gtk_widget_get_device_events:
10349  * @widget: a #GtkWidget
10350  * @device: a #GdkDevice
10351  *
10352  * Returns the events mask for the widget corresponding to an specific device. These
10353  * are the events that the widget will receive when @device operates on it.
10354  *
10355  * Returns: device event mask for @widget
10356  *
10357  * Since: 3.0
10358  **/
10359 GdkEventMask
10360 gtk_widget_get_device_events (GtkWidget *widget,
10361                               GdkDevice *device)
10362 {
10363   GHashTable *device_events;
10364
10365   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
10366   g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
10367
10368   device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
10369
10370   if (!device_events)
10371     return 0;
10372
10373   return GPOINTER_TO_UINT (g_hash_table_lookup (device_events, device));
10374 }
10375
10376 /**
10377  * gtk_widget_get_pointer:
10378  * @widget: a #GtkWidget
10379  * @x: (out) (allow-none): return location for the X coordinate, or %NULL
10380  * @y: (out) (allow-none): return location for the Y coordinate, or %NULL
10381  *
10382  * Obtains the location of the mouse pointer in widget coordinates.
10383  * Widget coordinates are a bit odd; for historical reasons, they are
10384  * defined as @widget->window coordinates for widgets that are not
10385  * #GTK_NO_WINDOW widgets, and are relative to @widget->allocation.x,
10386  * @widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
10387  *
10388  * Deprecated: 3.4: Use gdk_window_get_device_position() instead.
10389  **/
10390 void
10391 gtk_widget_get_pointer (GtkWidget *widget,
10392                         gint      *x,
10393                         gint      *y)
10394 {
10395   GtkWidgetPrivate *priv;
10396
10397   g_return_if_fail (GTK_IS_WIDGET (widget));
10398
10399   priv = widget->priv;
10400
10401   if (x)
10402     *x = -1;
10403   if (y)
10404     *y = -1;
10405
10406   if (gtk_widget_get_realized (widget))
10407     {
10408       gdk_window_get_device_position (priv->window,
10409                                       gdk_device_manager_get_client_pointer (
10410                                         gdk_display_get_device_manager (
10411                                           gtk_widget_get_display (widget))),
10412                                       x, y, NULL);
10413
10414       if (!gtk_widget_get_has_window (widget))
10415         {
10416           if (x)
10417             *x -= priv->allocation.x;
10418           if (y)
10419             *y -= priv->allocation.y;
10420         }
10421     }
10422 }
10423
10424 /**
10425  * gtk_widget_is_ancestor:
10426  * @widget: a #GtkWidget
10427  * @ancestor: another #GtkWidget
10428  *
10429  * Determines whether @widget is somewhere inside @ancestor, possibly with
10430  * intermediate containers.
10431  *
10432  * Return value: %TRUE if @ancestor contains @widget as a child,
10433  *    grandchild, great grandchild, etc.
10434  **/
10435 gboolean
10436 gtk_widget_is_ancestor (GtkWidget *widget,
10437                         GtkWidget *ancestor)
10438 {
10439   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10440   g_return_val_if_fail (ancestor != NULL, FALSE);
10441
10442   while (widget)
10443     {
10444       if (widget->priv->parent == ancestor)
10445         return TRUE;
10446       widget = widget->priv->parent;
10447     }
10448
10449   return FALSE;
10450 }
10451
10452 static GQuark quark_composite_name = 0;
10453
10454 /**
10455  * gtk_widget_set_composite_name:
10456  * @widget: a #GtkWidget.
10457  * @name: the name to set
10458  *
10459  * Sets a widgets composite name. The widget must be
10460  * a composite child of its parent; see gtk_widget_push_composite_child().
10461  **/
10462 void
10463 gtk_widget_set_composite_name (GtkWidget   *widget,
10464                                const gchar *name)
10465 {
10466   g_return_if_fail (GTK_IS_WIDGET (widget));
10467   g_return_if_fail (widget->priv->composite_child);
10468   g_return_if_fail (name != NULL);
10469
10470   if (!quark_composite_name)
10471     quark_composite_name = g_quark_from_static_string ("gtk-composite-name");
10472
10473   g_object_set_qdata_full (G_OBJECT (widget),
10474                            quark_composite_name,
10475                            g_strdup (name),
10476                            g_free);
10477 }
10478
10479 /**
10480  * gtk_widget_get_composite_name:
10481  * @widget: a #GtkWidget
10482  *
10483  * Obtains the composite name of a widget.
10484  *
10485  * Returns: the composite name of @widget, or %NULL if @widget is not
10486  *   a composite child. The string should be freed when it is no
10487  *   longer needed.
10488  **/
10489 gchar*
10490 gtk_widget_get_composite_name (GtkWidget *widget)
10491 {
10492   GtkWidgetPrivate *priv;
10493
10494   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
10495
10496   priv = widget->priv;
10497
10498   if (widget->priv->composite_child && priv->parent)
10499     return _gtk_container_child_composite_name (GTK_CONTAINER (priv->parent),
10500                                                widget);
10501   else
10502     return NULL;
10503 }
10504
10505 /**
10506  * gtk_widget_push_composite_child:
10507  *
10508  * Makes all newly-created widgets as composite children until
10509  * the corresponding gtk_widget_pop_composite_child() call.
10510  *
10511  * A composite child is a child that's an implementation detail of the
10512  * container it's inside and should not be visible to people using the
10513  * container. Composite children aren't treated differently by GTK (but
10514  * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI
10515  * builders might want to treat them in a different way.
10516  *
10517  * Here is a simple example:
10518  * |[
10519  *   gtk_widget_push_composite_child ();
10520  *   scrolled_window->hscrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
10521  *   gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
10522  *   gtk_widget_pop_composite_child ();
10523  *   gtk_widget_set_parent (scrolled_window->hscrollbar,
10524  *                          GTK_WIDGET (scrolled_window));
10525  *   g_object_ref (scrolled_window->hscrollbar);
10526  * ]|
10527  **/
10528 void
10529 gtk_widget_push_composite_child (void)
10530 {
10531   composite_child_stack++;
10532 }
10533
10534 /**
10535  * gtk_widget_pop_composite_child:
10536  *
10537  * Cancels the effect of a previous call to gtk_widget_push_composite_child().
10538  **/
10539 void
10540 gtk_widget_pop_composite_child (void)
10541 {
10542   if (composite_child_stack)
10543     composite_child_stack--;
10544 }
10545
10546 static void
10547 gtk_widget_emit_direction_changed (GtkWidget        *widget,
10548                                    GtkTextDirection  old_dir)
10549 {
10550   GtkTextDirection direction;
10551   GtkStateFlags state;
10552
10553   gtk_widget_update_pango_context (widget);
10554
10555   direction = gtk_widget_get_direction (widget);
10556   state = widget->priv->state_flags;
10557   state &= GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL;
10558
10559   switch (direction)
10560     {
10561     case GTK_TEXT_DIR_LTR:
10562       state |= GTK_STATE_FLAG_DIR_LTR;
10563       break;
10564
10565     case GTK_TEXT_DIR_RTL:
10566       state |= GTK_STATE_FLAG_DIR_RTL;
10567       break;
10568
10569     case GTK_TEXT_DIR_NONE:
10570     default:
10571       g_assert_not_reached ();
10572       break;
10573     }
10574
10575   gtk_widget_set_state_flags (widget, state, TRUE);
10576
10577   g_signal_emit (widget, widget_signals[DIRECTION_CHANGED], 0, old_dir);
10578 }
10579
10580 /**
10581  * gtk_widget_set_direction:
10582  * @widget: a #GtkWidget
10583  * @dir:    the new direction
10584  *
10585  * Sets the reading direction on a particular widget. This direction
10586  * controls the primary direction for widgets containing text,
10587  * and also the direction in which the children of a container are
10588  * packed. The ability to set the direction is present in order
10589  * so that correct localization into languages with right-to-left
10590  * reading directions can be done. Generally, applications will
10591  * let the default reading direction present, except for containers
10592  * where the containers are arranged in an order that is explicitely
10593  * visual rather than logical (such as buttons for text justification).
10594  *
10595  * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
10596  * set by gtk_widget_set_default_direction() will be used.
10597  **/
10598 void
10599 gtk_widget_set_direction (GtkWidget        *widget,
10600                           GtkTextDirection  dir)
10601 {
10602   GtkTextDirection old_dir;
10603
10604   g_return_if_fail (GTK_IS_WIDGET (widget));
10605   g_return_if_fail (dir >= GTK_TEXT_DIR_NONE && dir <= GTK_TEXT_DIR_RTL);
10606
10607   old_dir = gtk_widget_get_direction (widget);
10608
10609   widget->priv->direction = dir;
10610
10611   if (old_dir != gtk_widget_get_direction (widget))
10612     gtk_widget_emit_direction_changed (widget, old_dir);
10613 }
10614
10615 /**
10616  * gtk_widget_get_direction:
10617  * @widget: a #GtkWidget
10618  *
10619  * Gets the reading direction for a particular widget. See
10620  * gtk_widget_set_direction().
10621  *
10622  * Return value: the reading direction for the widget.
10623  **/
10624 GtkTextDirection
10625 gtk_widget_get_direction (GtkWidget *widget)
10626 {
10627   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_TEXT_DIR_LTR);
10628
10629   if (widget->priv->direction == GTK_TEXT_DIR_NONE)
10630     return gtk_default_direction;
10631   else
10632     return widget->priv->direction;
10633 }
10634
10635 static void
10636 gtk_widget_set_default_direction_recurse (GtkWidget *widget, gpointer data)
10637 {
10638   GtkTextDirection old_dir = GPOINTER_TO_UINT (data);
10639
10640   g_object_ref (widget);
10641
10642   if (widget->priv->direction == GTK_TEXT_DIR_NONE)
10643     gtk_widget_emit_direction_changed (widget, old_dir);
10644
10645   if (GTK_IS_CONTAINER (widget))
10646     gtk_container_forall (GTK_CONTAINER (widget),
10647                           gtk_widget_set_default_direction_recurse,
10648                           data);
10649
10650   g_object_unref (widget);
10651 }
10652
10653 /**
10654  * gtk_widget_set_default_direction:
10655  * @dir: the new default direction. This cannot be
10656  *        %GTK_TEXT_DIR_NONE.
10657  *
10658  * Sets the default reading direction for widgets where the
10659  * direction has not been explicitly set by gtk_widget_set_direction().
10660  **/
10661 void
10662 gtk_widget_set_default_direction (GtkTextDirection dir)
10663 {
10664   g_return_if_fail (dir == GTK_TEXT_DIR_RTL || dir == GTK_TEXT_DIR_LTR);
10665
10666   if (dir != gtk_default_direction)
10667     {
10668       GList *toplevels, *tmp_list;
10669       GtkTextDirection old_dir = gtk_default_direction;
10670
10671       gtk_default_direction = dir;
10672
10673       tmp_list = toplevels = gtk_window_list_toplevels ();
10674       g_list_foreach (toplevels, (GFunc)g_object_ref, NULL);
10675
10676       while (tmp_list)
10677         {
10678           gtk_widget_set_default_direction_recurse (tmp_list->data,
10679                                                     GUINT_TO_POINTER (old_dir));
10680           g_object_unref (tmp_list->data);
10681           tmp_list = tmp_list->next;
10682         }
10683
10684       g_list_free (toplevels);
10685     }
10686 }
10687
10688 /**
10689  * gtk_widget_get_default_direction:
10690  *
10691  * Obtains the current default reading direction. See
10692  * gtk_widget_set_default_direction().
10693  *
10694  * Return value: the current default direction.
10695  **/
10696 GtkTextDirection
10697 gtk_widget_get_default_direction (void)
10698 {
10699   return gtk_default_direction;
10700 }
10701
10702 static void
10703 gtk_widget_constructed (GObject *object)
10704 {
10705   GtkWidget *widget = GTK_WIDGET (object);
10706   GtkWidgetPrivate *priv = widget->priv;
10707
10708   /* As strange as it may seem, this may happen on object construction.
10709    * init() implementations of parent types may eventually call this function,
10710    * each with its corresponding GType, which could leave a child
10711    * implementation with a wrong widget type in the widget path
10712    */
10713   if (priv->path &&
10714       G_OBJECT_TYPE (widget) != gtk_widget_path_get_object_type (priv->path))
10715     {
10716       gtk_widget_path_free (priv->path);
10717       priv->path = NULL;
10718     }
10719
10720   G_OBJECT_CLASS (gtk_widget_parent_class)->constructed (object);
10721 }
10722
10723 static void
10724 gtk_widget_dispose (GObject *object)
10725 {
10726   GtkWidget *widget = GTK_WIDGET (object);
10727   GtkWidgetPrivate *priv = widget->priv;
10728
10729   if (priv->parent)
10730     gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
10731   else if (gtk_widget_get_visible (widget))
10732     gtk_widget_hide (widget);
10733
10734   priv->visible = FALSE;
10735   if (gtk_widget_get_realized (widget))
10736     gtk_widget_unrealize (widget);
10737
10738   if (!priv->in_destruction)
10739     {
10740       priv->in_destruction = TRUE;
10741       g_signal_emit (object, widget_signals[DESTROY], 0);
10742       priv->in_destruction = FALSE;
10743     }
10744
10745   g_clear_object (&priv->muxer);
10746
10747   G_OBJECT_CLASS (gtk_widget_parent_class)->dispose (object);
10748 }
10749
10750 static void
10751 gtk_widget_real_destroy (GtkWidget *object)
10752 {
10753   /* gtk_object_destroy() will already hold a refcount on object */
10754   GtkWidget *widget = GTK_WIDGET (object);
10755   GtkWidgetPrivate *priv = widget->priv;
10756   GList *l;
10757
10758   if (GTK_WIDGET_GET_CLASS (widget)->priv->accessible_type != GTK_TYPE_ACCESSIBLE)
10759     {
10760       GtkAccessible *accessible = g_object_steal_qdata (G_OBJECT (widget), quark_accessible_object);
10761
10762       if (accessible)
10763         {
10764           gtk_accessible_set_widget (accessible, NULL);
10765           g_object_unref (accessible);
10766         }
10767     }
10768
10769   /* wipe accelerator closures (keep order) */
10770   g_object_set_qdata (G_OBJECT (widget), quark_accel_path, NULL);
10771   g_object_set_qdata (G_OBJECT (widget), quark_accel_closures, NULL);
10772
10773   /* Callers of add_mnemonic_label() should disconnect on ::destroy */
10774   g_object_set_qdata (G_OBJECT (widget), quark_mnemonic_labels, NULL);
10775
10776   gtk_grab_remove (widget);
10777
10778   for (l = priv->tick_callbacks; l;)
10779     {
10780       GList *next = l->next;
10781       destroy_tick_callback_info (widget, l->data, l);
10782       l = next;
10783     }
10784
10785   if (priv->style)
10786     g_object_unref (priv->style);
10787   priv->style = gtk_widget_get_default_style ();
10788   g_object_ref (priv->style);
10789 }
10790
10791 static void
10792 gtk_widget_finalize (GObject *object)
10793 {
10794   GtkWidget *widget = GTK_WIDGET (object);
10795   GtkWidgetPrivate *priv = widget->priv;
10796   GtkWidgetAuxInfo *aux_info;
10797   GtkAccessible *accessible;
10798
10799   gtk_grab_remove (widget);
10800
10801   g_object_unref (priv->style);
10802   priv->style = NULL;
10803
10804   g_free (priv->name);
10805
10806   aux_info = gtk_widget_get_aux_info (widget, FALSE);
10807   if (aux_info)
10808     gtk_widget_aux_info_destroy (aux_info);
10809
10810   accessible = g_object_get_qdata (G_OBJECT (widget), quark_accessible_object);
10811   if (accessible)
10812     g_object_unref (accessible);
10813
10814   if (priv->path)
10815     gtk_widget_path_free (priv->path);
10816
10817   if (priv->context)
10818     {
10819       _gtk_style_context_set_widget (priv->context, NULL);
10820       g_object_unref (priv->context);
10821     }
10822
10823   _gtk_size_request_cache_free (&priv->requests);
10824
10825   if (g_object_is_floating (object))
10826     g_warning ("A floating object was finalized. This means that someone\n"
10827                "called g_object_unref() on an object that had only a floating\n"
10828                "reference; the initial floating reference is not owned by anyone\n"
10829                "and must be removed with g_object_ref_sink().");
10830
10831   G_OBJECT_CLASS (gtk_widget_parent_class)->finalize (object);
10832 }
10833
10834 /*****************************************
10835  * gtk_widget_real_map:
10836  *
10837  *   arguments:
10838  *
10839  *   results:
10840  *****************************************/
10841
10842 static void
10843 gtk_widget_real_map (GtkWidget *widget)
10844 {
10845   GtkWidgetPrivate *priv = widget->priv;
10846
10847   g_assert (gtk_widget_get_realized (widget));
10848
10849   if (!gtk_widget_get_mapped (widget))
10850     {
10851       gtk_widget_set_mapped (widget, TRUE);
10852
10853       if (gtk_widget_get_has_window (widget))
10854         gdk_window_show (priv->window);
10855     }
10856 }
10857
10858 /*****************************************
10859  * gtk_widget_real_unmap:
10860  *
10861  *   arguments:
10862  *
10863  *   results:
10864  *****************************************/
10865
10866 static void
10867 gtk_widget_real_unmap (GtkWidget *widget)
10868 {
10869   GtkWidgetPrivate *priv = widget->priv;
10870
10871   if (gtk_widget_get_mapped (widget))
10872     {
10873       gtk_widget_set_mapped (widget, FALSE);
10874
10875       if (gtk_widget_get_has_window (widget))
10876         gdk_window_hide (priv->window);
10877     }
10878 }
10879
10880 /*****************************************
10881  * gtk_widget_real_realize:
10882  *
10883  *   arguments:
10884  *
10885  *   results:
10886  *****************************************/
10887
10888 static void
10889 gtk_widget_real_realize (GtkWidget *widget)
10890 {
10891   GtkWidgetPrivate *priv = widget->priv;
10892
10893   g_assert (!gtk_widget_get_has_window (widget));
10894
10895   gtk_widget_set_realized (widget, TRUE);
10896   if (priv->parent)
10897     {
10898       priv->window = gtk_widget_get_parent_window (widget);
10899       g_object_ref (priv->window);
10900     }
10901 }
10902
10903 /*****************************************
10904  * gtk_widget_real_unrealize:
10905  *
10906  *   arguments:
10907  *
10908  *   results:
10909  *****************************************/
10910
10911 static void
10912 gtk_widget_real_unrealize (GtkWidget *widget)
10913 {
10914   GtkWidgetPrivate *priv = widget->priv;
10915
10916   g_assert (!widget->priv->mapped);
10917
10918   /* printf ("unrealizing %s\n", g_type_name (G_TYPE_FROM_INSTANCE (widget)));
10919    */
10920
10921    /* We must do unrealize child widget BEFORE container widget.
10922     * gdk_window_destroy() destroys specified xwindow and its sub-xwindows.
10923     * So, unrealizing container widget bofore its children causes the problem
10924     * (for example, gdk_ic_destroy () with destroyed window causes crash. )
10925     */
10926
10927   if (GTK_IS_CONTAINER (widget))
10928     gtk_container_forall (GTK_CONTAINER (widget),
10929                           (GtkCallback) gtk_widget_unrealize,
10930                           NULL);
10931
10932   if (gtk_widget_get_has_window (widget))
10933     {
10934       gtk_widget_unregister_window (widget, priv->window);
10935       gdk_window_destroy (priv->window);
10936       priv->window = NULL;
10937     }
10938   else
10939     {
10940       g_object_unref (priv->window);
10941       priv->window = NULL;
10942     }
10943
10944   gtk_selection_remove_all (widget);
10945
10946   gtk_widget_set_realized (widget, FALSE);
10947 }
10948
10949 static void
10950 gtk_widget_real_adjust_size_request (GtkWidget         *widget,
10951                                      GtkOrientation     orientation,
10952                                      gint              *minimum_size,
10953                                      gint              *natural_size)
10954 {
10955   const GtkWidgetAuxInfo *aux_info;
10956
10957   aux_info =_gtk_widget_get_aux_info_or_defaults (widget);
10958
10959   if (orientation == GTK_ORIENTATION_HORIZONTAL &&
10960       aux_info->width > 0)
10961     {
10962       *minimum_size = MAX (*minimum_size, aux_info->width);
10963     }
10964   else if (orientation == GTK_ORIENTATION_VERTICAL &&
10965            aux_info->height > 0)
10966     {
10967       *minimum_size = MAX (*minimum_size, aux_info->height);
10968     }
10969
10970   /* Fix it if set_size_request made natural size smaller than min size.
10971    * This would also silently fix broken widgets, but we warn about them
10972    * in gtksizerequest.c when calling their size request vfuncs.
10973    */
10974   *natural_size = MAX (*natural_size, *minimum_size);
10975
10976   if (orientation == GTK_ORIENTATION_HORIZONTAL)
10977     {
10978       *minimum_size += (aux_info->margin.left + aux_info->margin.right);
10979       *natural_size += (aux_info->margin.left + aux_info->margin.right);
10980     }
10981   else
10982     {
10983       *minimum_size += (aux_info->margin.top + aux_info->margin.bottom);
10984       *natural_size += (aux_info->margin.top + aux_info->margin.bottom);
10985     }
10986 }
10987
10988 /**
10989  * _gtk_widget_peek_request_cache:
10990  *
10991  * Returns the address of the widget's request cache (strictly for
10992  * internal use in gtksizerequest.c)
10993  *
10994  * Return value: the address of @widget's size request cache.
10995  **/
10996 gpointer
10997 _gtk_widget_peek_request_cache (GtkWidget *widget)
10998 {
10999   /* Don't bother slowing things down with the return_if_fail guards here */
11000   return &widget->priv->requests;
11001 }
11002
11003 /*
11004  * _gtk_widget_set_device_window:
11005  * @widget: a #GtkWidget
11006  * @device: a #GdkDevice
11007  * @window: the new device window
11008  *
11009  * Sets pointer window for @widget and @device.
11010  * Does not ref @window.
11011  */
11012 void
11013 _gtk_widget_set_device_window (GtkWidget *widget,
11014                                GdkDevice *device,
11015                                GdkWindow *window)
11016 {
11017   GHashTable *device_window;
11018
11019   g_return_if_fail (GTK_IS_WIDGET (widget));
11020   g_return_if_fail (GDK_IS_DEVICE (device));
11021   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
11022
11023   if (!gtk_widget_get_mapped (widget))
11024     return;
11025
11026   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11027
11028   if (!device_window && window)
11029     {
11030       device_window = g_hash_table_new (NULL, NULL);
11031       g_object_set_qdata_full (G_OBJECT (widget),
11032                                quark_pointer_window,
11033                                device_window,
11034                                (GDestroyNotify) g_hash_table_destroy);
11035     }
11036
11037   if (window)
11038     g_hash_table_insert (device_window, device, window);
11039   else if (device_window)
11040     {
11041       g_hash_table_remove (device_window, device);
11042
11043       if (g_hash_table_size (device_window) == 0)
11044         g_object_set_qdata (G_OBJECT (widget), quark_pointer_window, NULL);
11045     }
11046 }
11047
11048 /*
11049  * _gtk_widget_get_device_window:
11050  * @widget: a #GtkWidget
11051  * @device: a #GdkDevice
11052  *
11053  * Return value: the device window set on @widget, or %NULL
11054  */
11055 GdkWindow *
11056 _gtk_widget_get_device_window (GtkWidget *widget,
11057                                GdkDevice *device)
11058 {
11059   GHashTable *device_window;
11060
11061   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11062   g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
11063
11064   if (!gtk_widget_get_mapped (widget))
11065     return NULL;
11066
11067   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11068
11069   if (!device_window)
11070     return NULL;
11071
11072   return g_hash_table_lookup (device_window, device);
11073 }
11074
11075 /*
11076  * _gtk_widget_list_devices:
11077  * @widget: a #GtkWidget
11078  *
11079  * Returns the list of #GdkDevices that is currently on top
11080  * of any window belonging to @widget.
11081  * Free the list with g_list_free(), the elements are owned
11082  * by GTK+ and must not be freed.
11083  */
11084 GList *
11085 _gtk_widget_list_devices (GtkWidget *widget)
11086 {
11087   GHashTableIter iter;
11088   GHashTable *device_window;
11089   GList *devices = NULL;
11090   gpointer key, value;
11091
11092   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11093
11094   if (!gtk_widget_get_mapped (widget))
11095     return NULL;
11096
11097   device_window = g_object_get_qdata (G_OBJECT (widget), quark_pointer_window);
11098
11099   if (G_UNLIKELY (!device_window))
11100     return NULL;
11101
11102   g_hash_table_iter_init (&iter, device_window);
11103
11104   while (g_hash_table_iter_next (&iter, &key, &value))
11105     devices = g_list_prepend (devices, key);
11106
11107   return devices;
11108 }
11109
11110 static void
11111 synth_crossing (GtkWidget       *widget,
11112                 GdkEventType     type,
11113                 GdkWindow       *window,
11114                 GdkDevice       *device,
11115                 GdkCrossingMode  mode,
11116                 GdkNotifyType    detail)
11117 {
11118   GdkEvent *event;
11119
11120   event = gdk_event_new (type);
11121
11122   event->crossing.window = g_object_ref (window);
11123   event->crossing.send_event = TRUE;
11124   event->crossing.subwindow = g_object_ref (window);
11125   event->crossing.time = GDK_CURRENT_TIME;
11126   event->crossing.x = event->crossing.y = 0;
11127   event->crossing.x_root = event->crossing.y_root = 0;
11128   event->crossing.mode = mode;
11129   event->crossing.detail = detail;
11130   event->crossing.focus = FALSE;
11131   event->crossing.state = 0;
11132   gdk_event_set_device (event, device);
11133
11134   if (!widget)
11135     widget = gtk_get_event_widget (event);
11136
11137   if (widget)
11138     gtk_widget_event_internal (widget, event);
11139
11140   gdk_event_free (event);
11141 }
11142
11143 /*
11144  * _gtk_widget_synthesize_crossing:
11145  * @from: the #GtkWidget the virtual pointer is leaving.
11146  * @to: the #GtkWidget the virtual pointer is moving to.
11147  * @mode: the #GdkCrossingMode to place on the synthesized events.
11148  *
11149  * Generate crossing event(s) on widget state (sensitivity) or GTK+ grab change.
11150  *
11151  * The real pointer window is the window that most recently received an enter notify
11152  * event.  Windows that don't select for crossing events can't become the real
11153  * poiner window.  The real pointer widget that owns the real pointer window.  The
11154  * effective pointer window is the same as the real pointer window unless the real
11155  * pointer widget is either insensitive or there is a grab on a widget that is not
11156  * an ancestor of the real pointer widget (in which case the effective pointer
11157  * window should be the root window).
11158  *
11159  * When the effective pointer window is the same as the real poiner window, we
11160  * receive crossing events from the windowing system.  When the effective pointer
11161  * window changes to become different from the real pointer window we synthesize
11162  * crossing events, attempting to follow X protocol rules:
11163  *
11164  * When the root window becomes the effective pointer window:
11165  *   - leave notify on real pointer window, detail Ancestor
11166  *   - leave notify on all of its ancestors, detail Virtual
11167  *   - enter notify on root window, detail Inferior
11168  *
11169  * When the root window ceases to be the effective pointer window:
11170  *   - leave notify on root window, detail Inferior
11171  *   - enter notify on all ancestors of real pointer window, detail Virtual
11172  *   - enter notify on real pointer window, detail Ancestor
11173  */
11174 void
11175 _gtk_widget_synthesize_crossing (GtkWidget       *from,
11176                                  GtkWidget       *to,
11177                                  GdkDevice       *device,
11178                                  GdkCrossingMode  mode)
11179 {
11180   GdkWindow *from_window = NULL, *to_window = NULL;
11181
11182   g_return_if_fail (from != NULL || to != NULL);
11183
11184   if (from != NULL)
11185     {
11186       from_window = _gtk_widget_get_device_window (from, device);
11187
11188       if (!from_window)
11189         from_window = from->priv->window;
11190     }
11191
11192   if (to != NULL)
11193     {
11194       to_window = _gtk_widget_get_device_window (to, device);
11195
11196       if (!to_window)
11197         to_window = to->priv->window;
11198     }
11199
11200   if (from_window == NULL && to_window == NULL)
11201     ;
11202   else if (from_window != NULL && to_window == NULL)
11203     {
11204       GList *from_ancestors = NULL, *list;
11205       GdkWindow *from_ancestor = from_window;
11206
11207       while (from_ancestor != NULL)
11208         {
11209           from_ancestor = gdk_window_get_effective_parent (from_ancestor);
11210           if (from_ancestor == NULL)
11211             break;
11212           from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
11213         }
11214
11215       synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11216                       device, mode, GDK_NOTIFY_ANCESTOR);
11217       for (list = g_list_last (from_ancestors); list; list = list->prev)
11218         {
11219           synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11220                           device, mode, GDK_NOTIFY_VIRTUAL);
11221         }
11222
11223       /* XXX: enter/inferior on root window? */
11224
11225       g_list_free (from_ancestors);
11226     }
11227   else if (from_window == NULL && to_window != NULL)
11228     {
11229       GList *to_ancestors = NULL, *list;
11230       GdkWindow *to_ancestor = to_window;
11231
11232       while (to_ancestor != NULL)
11233         {
11234           to_ancestor = gdk_window_get_effective_parent (to_ancestor);
11235           if (to_ancestor == NULL)
11236             break;
11237           to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
11238         }
11239
11240       /* XXX: leave/inferior on root window? */
11241
11242       for (list = to_ancestors; list; list = list->next)
11243         {
11244           synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11245                           device, mode, GDK_NOTIFY_VIRTUAL);
11246         }
11247       synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11248                       device, mode, GDK_NOTIFY_ANCESTOR);
11249
11250       g_list_free (to_ancestors);
11251     }
11252   else if (from_window == to_window)
11253     ;
11254   else
11255     {
11256       GList *from_ancestors = NULL, *to_ancestors = NULL, *list;
11257       GdkWindow *from_ancestor = from_window, *to_ancestor = to_window;
11258
11259       while (from_ancestor != NULL || to_ancestor != NULL)
11260         {
11261           if (from_ancestor != NULL)
11262             {
11263               from_ancestor = gdk_window_get_effective_parent (from_ancestor);
11264               if (from_ancestor == to_window)
11265                 break;
11266               if (from_ancestor)
11267                 from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
11268             }
11269           if (to_ancestor != NULL)
11270             {
11271               to_ancestor = gdk_window_get_effective_parent (to_ancestor);
11272               if (to_ancestor == from_window)
11273                 break;
11274               if (to_ancestor)
11275                 to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
11276             }
11277         }
11278       if (to_ancestor == from_window)
11279         {
11280           if (mode != GDK_CROSSING_GTK_UNGRAB)
11281             synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11282                             device, mode, GDK_NOTIFY_INFERIOR);
11283           for (list = to_ancestors; list; list = list->next)
11284             synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11285                             device, mode, GDK_NOTIFY_VIRTUAL);
11286           synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11287                           device, mode, GDK_NOTIFY_ANCESTOR);
11288         }
11289       else if (from_ancestor == to_window)
11290         {
11291           synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11292                           device, mode, GDK_NOTIFY_ANCESTOR);
11293           for (list = g_list_last (from_ancestors); list; list = list->prev)
11294             {
11295               synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11296                               device, mode, GDK_NOTIFY_VIRTUAL);
11297             }
11298           if (mode != GDK_CROSSING_GTK_GRAB)
11299             synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11300                             device, mode, GDK_NOTIFY_INFERIOR);
11301         }
11302       else
11303         {
11304           while (from_ancestors != NULL && to_ancestors != NULL
11305                  && from_ancestors->data == to_ancestors->data)
11306             {
11307               from_ancestors = g_list_delete_link (from_ancestors,
11308                                                    from_ancestors);
11309               to_ancestors = g_list_delete_link (to_ancestors, to_ancestors);
11310             }
11311
11312           synth_crossing (from, GDK_LEAVE_NOTIFY, from_window,
11313                           device, mode, GDK_NOTIFY_NONLINEAR);
11314
11315           for (list = g_list_last (from_ancestors); list; list = list->prev)
11316             {
11317               synth_crossing (NULL, GDK_LEAVE_NOTIFY, (GdkWindow *) list->data,
11318                               device, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
11319             }
11320           for (list = to_ancestors; list; list = list->next)
11321             {
11322               synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data,
11323                               device, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
11324             }
11325           synth_crossing (to, GDK_ENTER_NOTIFY, to_window,
11326                           device, mode, GDK_NOTIFY_NONLINEAR);
11327         }
11328       g_list_free (from_ancestors);
11329       g_list_free (to_ancestors);
11330     }
11331 }
11332
11333 static void
11334 gtk_widget_propagate_state (GtkWidget    *widget,
11335                             GtkStateData *data)
11336 {
11337   GtkWidgetPrivate *priv = widget->priv;
11338   GtkStateFlags new_flags, old_flags = priv->state_flags;
11339   GtkStateType old_state;
11340
11341   old_state = gtk_widget_get_state (widget);
11342
11343   priv->state_flags |= data->flags_to_set;
11344   priv->state_flags &= ~(data->flags_to_unset);
11345
11346   /* make insensitivity unoverridable */
11347   if (!priv->sensitive)
11348     priv->state_flags |= GTK_STATE_FLAG_INSENSITIVE;
11349
11350   if (gtk_widget_is_focus (widget) && !gtk_widget_is_sensitive (widget))
11351     {
11352       GtkWidget *window;
11353
11354       window = gtk_widget_get_toplevel (widget);
11355
11356       if (window && gtk_widget_is_toplevel (window))
11357         gtk_window_set_focus (GTK_WINDOW (window), NULL);
11358     }
11359
11360   new_flags = priv->state_flags;
11361
11362   if (old_flags != new_flags)
11363     {
11364       g_object_ref (widget);
11365
11366       if (!gtk_widget_is_sensitive (widget) && gtk_widget_has_grab (widget))
11367         gtk_grab_remove (widget);
11368
11369       gtk_style_context_set_state (gtk_widget_get_style_context (widget), new_flags);
11370
11371       g_signal_emit (widget, widget_signals[STATE_CHANGED], 0, old_state);
11372       g_signal_emit (widget, widget_signals[STATE_FLAGS_CHANGED], 0, old_flags);
11373
11374       if (!priv->shadowed &&
11375           (new_flags & GTK_STATE_FLAG_INSENSITIVE) != (old_flags & GTK_STATE_FLAG_INSENSITIVE))
11376         {
11377           GList *event_windows = NULL;
11378           GList *devices, *d;
11379
11380           devices = _gtk_widget_list_devices (widget);
11381
11382           for (d = devices; d; d = d->next)
11383             {
11384               GdkWindow *window;
11385               GdkDevice *device;
11386
11387               device = d->data;
11388               window = _gtk_widget_get_device_window (widget, device);
11389
11390               /* Do not propagate more than once to the
11391                * same window if non-multidevice aware.
11392                */
11393               if (!gdk_window_get_support_multidevice (window) &&
11394                   g_list_find (event_windows, window))
11395                 continue;
11396
11397               if (!gtk_widget_is_sensitive (widget))
11398                 _gtk_widget_synthesize_crossing (widget, NULL, d->data,
11399                                                  GDK_CROSSING_STATE_CHANGED);
11400               else
11401                 _gtk_widget_synthesize_crossing (NULL, widget, d->data,
11402                                                  GDK_CROSSING_STATE_CHANGED);
11403
11404               event_windows = g_list_prepend (event_windows, window);
11405             }
11406
11407           g_list_free (event_windows);
11408           g_list_free (devices);
11409         }
11410
11411       if (GTK_IS_CONTAINER (widget))
11412         {
11413           GtkStateData child_data;
11414
11415           /* Make sure to only propate the right states further */
11416           child_data.flags_to_set = data->flags_to_set & GTK_STATE_FLAGS_DO_PROPAGATE;
11417           child_data.flags_to_unset = data->flags_to_unset & GTK_STATE_FLAGS_DO_PROPAGATE;
11418
11419           gtk_container_forall (GTK_CONTAINER (widget),
11420                                 (GtkCallback) gtk_widget_propagate_state,
11421                                 &child_data);
11422         }
11423
11424       g_object_unref (widget);
11425     }
11426 }
11427
11428 static const GtkWidgetAuxInfo default_aux_info = {
11429   -1, -1,
11430   GTK_ALIGN_FILL,
11431   GTK_ALIGN_FILL,
11432   { 0, 0, 0, 0 }
11433 };
11434
11435 /*
11436  * gtk_widget_get_aux_info:
11437  * @widget: a #GtkWidget
11438  * @create: if %TRUE, create the structure if it doesn't exist
11439  *
11440  * Get the #GtkWidgetAuxInfo structure for the widget.
11441  *
11442  * Return value: the #GtkAuxInfo structure for the widget, or
11443  *    %NULL if @create is %FALSE and one doesn't already exist.
11444  */
11445 static GtkWidgetAuxInfo *
11446 gtk_widget_get_aux_info (GtkWidget *widget,
11447                          gboolean   create)
11448 {
11449   GtkWidgetAuxInfo *aux_info;
11450
11451   aux_info = g_object_get_qdata (G_OBJECT (widget), quark_aux_info);
11452   if (!aux_info && create)
11453     {
11454       aux_info = g_slice_new0 (GtkWidgetAuxInfo);
11455
11456       *aux_info = default_aux_info;
11457
11458       g_object_set_qdata (G_OBJECT (widget), quark_aux_info, aux_info);
11459     }
11460
11461   return aux_info;
11462 }
11463
11464 static const GtkWidgetAuxInfo*
11465 _gtk_widget_get_aux_info_or_defaults (GtkWidget *widget)
11466 {
11467   GtkWidgetAuxInfo *aux_info;
11468
11469   aux_info = gtk_widget_get_aux_info (widget, FALSE);
11470   if (aux_info == NULL)
11471     {
11472       return &default_aux_info;
11473     }
11474   else
11475     {
11476       return aux_info;
11477     }
11478 }
11479
11480 /*****************************************
11481  * gtk_widget_aux_info_destroy:
11482  *
11483  *   arguments:
11484  *
11485  *   results:
11486  *****************************************/
11487
11488 static void
11489 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
11490 {
11491   g_slice_free (GtkWidgetAuxInfo, aux_info);
11492 }
11493
11494 /**
11495  * gtk_widget_shape_combine_region:
11496  * @widget: a #GtkWidget
11497  * @region: (allow-none): shape to be added, or %NULL to remove an existing shape
11498  *
11499  * Sets a shape for this widget's GDK window. This allows for
11500  * transparent windows etc., see gdk_window_shape_combine_region()
11501  * for more information.
11502  *
11503  * Since: 3.0
11504  **/
11505 void
11506 gtk_widget_shape_combine_region (GtkWidget *widget,
11507                                  cairo_region_t *region)
11508 {
11509   GtkWidgetPrivate *priv;
11510
11511   g_return_if_fail (GTK_IS_WIDGET (widget));
11512   /*  set_shape doesn't work on widgets without gdk window */
11513   g_return_if_fail (gtk_widget_get_has_window (widget));
11514
11515   priv = widget->priv;
11516
11517   if (region == NULL)
11518     {
11519       priv->has_shape_mask = FALSE;
11520
11521       if (priv->window)
11522         gdk_window_shape_combine_region (priv->window, NULL, 0, 0);
11523
11524       g_object_set_qdata (G_OBJECT (widget), quark_shape_info, NULL);
11525     }
11526   else
11527     {
11528       priv->has_shape_mask = TRUE;
11529
11530       g_object_set_qdata_full (G_OBJECT (widget), quark_shape_info,
11531                                cairo_region_copy (region),
11532                                (GDestroyNotify) cairo_region_destroy);
11533
11534       /* set shape if widget has a gdk window already.
11535        * otherwise the shape is scheduled to be set by gtk_widget_realize().
11536        */
11537       if (priv->window)
11538         gdk_window_shape_combine_region (priv->window, region, 0, 0);
11539     }
11540 }
11541
11542 /**
11543  * gtk_widget_input_shape_combine_region:
11544  * @widget: a #GtkWidget
11545  * @region: (allow-none): shape to be added, or %NULL to remove an existing shape
11546  *
11547  * Sets an input shape for this widget's GDK window. This allows for
11548  * windows which react to mouse click in a nonrectangular region, see
11549  * gdk_window_input_shape_combine_region() for more information.
11550  *
11551  * Since: 3.0
11552  **/
11553 void
11554 gtk_widget_input_shape_combine_region (GtkWidget *widget,
11555                                        cairo_region_t *region)
11556 {
11557   GtkWidgetPrivate *priv;
11558
11559   g_return_if_fail (GTK_IS_WIDGET (widget));
11560   /*  set_shape doesn't work on widgets without gdk window */
11561   g_return_if_fail (gtk_widget_get_has_window (widget));
11562
11563   priv = widget->priv;
11564
11565   if (region == NULL)
11566     {
11567       if (priv->window)
11568         gdk_window_input_shape_combine_region (priv->window, NULL, 0, 0);
11569
11570       g_object_set_qdata (G_OBJECT (widget), quark_input_shape_info, NULL);
11571     }
11572   else
11573     {
11574       g_object_set_qdata_full (G_OBJECT (widget), quark_input_shape_info,
11575                                cairo_region_copy (region),
11576                                (GDestroyNotify) cairo_region_destroy);
11577
11578       /* set shape if widget has a gdk window already.
11579        * otherwise the shape is scheduled to be set by gtk_widget_realize().
11580        */
11581       if (priv->window)
11582         gdk_window_input_shape_combine_region (priv->window, region, 0, 0);
11583     }
11584 }
11585
11586
11587 /* style properties
11588  */
11589
11590 /**
11591  * gtk_widget_class_install_style_property_parser: (skip)
11592  * @klass: a #GtkWidgetClass
11593  * @pspec: the #GParamSpec for the style property
11594  * @parser: the parser for the style property
11595  *
11596  * Installs a style property on a widget class.
11597  **/
11598 void
11599 gtk_widget_class_install_style_property_parser (GtkWidgetClass     *klass,
11600                                                 GParamSpec         *pspec,
11601                                                 GtkRcPropertyParser parser)
11602 {
11603   g_return_if_fail (GTK_IS_WIDGET_CLASS (klass));
11604   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
11605   g_return_if_fail (pspec->flags & G_PARAM_READABLE);
11606   g_return_if_fail (!(pspec->flags & (G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT)));
11607
11608   if (g_param_spec_pool_lookup (style_property_spec_pool, pspec->name, G_OBJECT_CLASS_TYPE (klass), FALSE))
11609     {
11610       g_warning (G_STRLOC ": class `%s' already contains a style property named `%s'",
11611                  G_OBJECT_CLASS_NAME (klass),
11612                  pspec->name);
11613       return;
11614     }
11615
11616   g_param_spec_ref_sink (pspec);
11617   g_param_spec_set_qdata (pspec, quark_property_parser, (gpointer) parser);
11618   g_param_spec_pool_insert (style_property_spec_pool, pspec, G_OBJECT_CLASS_TYPE (klass));
11619 }
11620
11621 /**
11622  * gtk_widget_class_install_style_property:
11623  * @klass: a #GtkWidgetClass
11624  * @pspec: the #GParamSpec for the property
11625  *
11626  * Installs a style property on a widget class. The parser for the
11627  * style property is determined by the value type of @pspec.
11628  **/
11629 void
11630 gtk_widget_class_install_style_property (GtkWidgetClass *klass,
11631                                          GParamSpec     *pspec)
11632 {
11633   GtkRcPropertyParser parser;
11634
11635   g_return_if_fail (GTK_IS_WIDGET_CLASS (klass));
11636   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
11637
11638   parser = _gtk_rc_property_parser_from_type (G_PARAM_SPEC_VALUE_TYPE (pspec));
11639
11640   gtk_widget_class_install_style_property_parser (klass, pspec, parser);
11641 }
11642
11643 /**
11644  * gtk_widget_class_find_style_property:
11645  * @klass: a #GtkWidgetClass
11646  * @property_name: the name of the style property to find
11647  *
11648  * Finds a style property of a widget class by name.
11649  *
11650  * Returns: (transfer none): the #GParamSpec of the style property or
11651  *   %NULL if @class has no style property with that name.
11652  *
11653  * Since: 2.2
11654  */
11655 GParamSpec*
11656 gtk_widget_class_find_style_property (GtkWidgetClass *klass,
11657                                       const gchar    *property_name)
11658 {
11659   g_return_val_if_fail (property_name != NULL, NULL);
11660
11661   return g_param_spec_pool_lookup (style_property_spec_pool,
11662                                    property_name,
11663                                    G_OBJECT_CLASS_TYPE (klass),
11664                                    TRUE);
11665 }
11666
11667 /**
11668  * gtk_widget_class_list_style_properties:
11669  * @klass: a #GtkWidgetClass
11670  * @n_properties: location to return the number of style properties found
11671  *
11672  * Returns all style properties of a widget class.
11673  *
11674  * Returns: (array length=n_properties) (transfer container): a
11675  *     newly allocated array of #GParamSpec*. The array must be
11676  *     freed with g_free().
11677  *
11678  * Since: 2.2
11679  */
11680 GParamSpec**
11681 gtk_widget_class_list_style_properties (GtkWidgetClass *klass,
11682                                         guint          *n_properties)
11683 {
11684   GParamSpec **pspecs;
11685   guint n;
11686
11687   pspecs = g_param_spec_pool_list (style_property_spec_pool,
11688                                    G_OBJECT_CLASS_TYPE (klass),
11689                                    &n);
11690   if (n_properties)
11691     *n_properties = n;
11692
11693   return pspecs;
11694 }
11695
11696 /**
11697  * gtk_widget_style_get_property:
11698  * @widget: a #GtkWidget
11699  * @property_name: the name of a style property
11700  * @value: location to return the property value
11701  *
11702  * Gets the value of a style property of @widget.
11703  */
11704 void
11705 gtk_widget_style_get_property (GtkWidget   *widget,
11706                                const gchar *property_name,
11707                                GValue      *value)
11708 {
11709   GParamSpec *pspec;
11710
11711   g_return_if_fail (GTK_IS_WIDGET (widget));
11712   g_return_if_fail (property_name != NULL);
11713   g_return_if_fail (G_IS_VALUE (value));
11714
11715   g_object_ref (widget);
11716   pspec = g_param_spec_pool_lookup (style_property_spec_pool,
11717                                     property_name,
11718                                     G_OBJECT_TYPE (widget),
11719                                     TRUE);
11720   if (!pspec)
11721     g_warning ("%s: widget class `%s' has no property named `%s'",
11722                G_STRLOC,
11723                G_OBJECT_TYPE_NAME (widget),
11724                property_name);
11725   else
11726     {
11727       GtkStyleContext *context;
11728       const GValue *peek_value;
11729       GtkStateFlags state;
11730
11731       context = gtk_widget_get_style_context (widget);
11732       state = gtk_widget_get_state_flags (widget);
11733
11734       peek_value = _gtk_style_context_peek_style_property (context,
11735                                                            G_OBJECT_TYPE (widget),
11736                                                            state, pspec);
11737
11738       /* auto-conversion of the caller's value type
11739        */
11740       if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
11741         g_value_copy (peek_value, value);
11742       else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
11743         g_value_transform (peek_value, value);
11744       else
11745         g_warning ("can't retrieve style property `%s' of type `%s' as value of type `%s'",
11746                    pspec->name,
11747                    g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
11748                    G_VALUE_TYPE_NAME (value));
11749     }
11750   g_object_unref (widget);
11751 }
11752
11753 /**
11754  * gtk_widget_style_get_valist:
11755  * @widget: a #GtkWidget
11756  * @first_property_name: the name of the first property to get
11757  * @var_args: a <type>va_list</type> of pairs of property names and
11758  *     locations to return the property values, starting with the location
11759  *     for @first_property_name.
11760  *
11761  * Non-vararg variant of gtk_widget_style_get(). Used primarily by language
11762  * bindings.
11763  */
11764 void
11765 gtk_widget_style_get_valist (GtkWidget   *widget,
11766                              const gchar *first_property_name,
11767                              va_list      var_args)
11768 {
11769   GtkStyleContext *context;
11770   GtkStateFlags state;
11771   const gchar *name;
11772
11773   g_return_if_fail (GTK_IS_WIDGET (widget));
11774
11775   g_object_ref (widget);
11776   context = gtk_widget_get_style_context (widget);
11777   state = gtk_widget_get_state_flags (widget);
11778
11779   name = first_property_name;
11780   while (name)
11781     {
11782       const GValue *peek_value;
11783       GParamSpec *pspec;
11784       gchar *error;
11785
11786       pspec = g_param_spec_pool_lookup (style_property_spec_pool,
11787                                         name,
11788                                         G_OBJECT_TYPE (widget),
11789                                         TRUE);
11790       if (!pspec)
11791         {
11792           g_warning ("%s: widget class `%s' has no property named `%s'",
11793                      G_STRLOC,
11794                      G_OBJECT_TYPE_NAME (widget),
11795                      name);
11796           break;
11797         }
11798       /* style pspecs are always readable so we can spare that check here */
11799
11800       peek_value = _gtk_style_context_peek_style_property (context,
11801                                                            G_OBJECT_TYPE (widget),
11802                                                            state, pspec);
11803
11804       G_VALUE_LCOPY (peek_value, var_args, 0, &error);
11805       if (error)
11806         {
11807           g_warning ("%s: %s", G_STRLOC, error);
11808           g_free (error);
11809           break;
11810         }
11811
11812       name = va_arg (var_args, gchar*);
11813     }
11814
11815   g_object_unref (widget);
11816 }
11817
11818 /**
11819  * gtk_widget_style_get:
11820  * @widget: a #GtkWidget
11821  * @first_property_name: the name of the first property to get
11822  * @...: pairs of property names and locations to return the
11823  *     property values, starting with the location for
11824  *     @first_property_name, terminated by %NULL.
11825  *
11826  * Gets the values of a multiple style properties of @widget.
11827  */
11828 void
11829 gtk_widget_style_get (GtkWidget   *widget,
11830                       const gchar *first_property_name,
11831                       ...)
11832 {
11833   va_list var_args;
11834
11835   g_return_if_fail (GTK_IS_WIDGET (widget));
11836
11837   va_start (var_args, first_property_name);
11838   gtk_widget_style_get_valist (widget, first_property_name, var_args);
11839   va_end (var_args);
11840 }
11841
11842 /**
11843  * gtk_requisition_new:
11844  *
11845  * Allocates a new #GtkRequisition structure and initializes its elements to zero.
11846  *
11847  * Returns: a new empty #GtkRequisition. The newly allocated #GtkRequisition should
11848  *   be freed with gtk_requisition_free().
11849  *
11850  * Since: 3.0
11851  */
11852 GtkRequisition *
11853 gtk_requisition_new (void)
11854 {
11855   return g_slice_new0 (GtkRequisition);
11856 }
11857
11858 /**
11859  * gtk_requisition_copy:
11860  * @requisition: a #GtkRequisition
11861  *
11862  * Copies a #GtkRequisition.
11863  *
11864  * Returns: a copy of @requisition
11865  **/
11866 GtkRequisition *
11867 gtk_requisition_copy (const GtkRequisition *requisition)
11868 {
11869   return g_slice_dup (GtkRequisition, requisition);
11870 }
11871
11872 /**
11873  * gtk_requisition_free:
11874  * @requisition: a #GtkRequisition
11875  *
11876  * Frees a #GtkRequisition.
11877  **/
11878 void
11879 gtk_requisition_free (GtkRequisition *requisition)
11880 {
11881   g_slice_free (GtkRequisition, requisition);
11882 }
11883
11884 G_DEFINE_BOXED_TYPE (GtkRequisition, gtk_requisition,
11885                      gtk_requisition_copy,
11886                      gtk_requisition_free)
11887
11888 /**
11889  * gtk_widget_class_set_accessible_type:
11890  * @widget_class: class to set the accessible type for
11891  * @type: The object type that implements the accessible for @widget_class
11892  *
11893  * Sets the type to be used for creating accessibles for widgets of
11894  * @widget_class. The given @type must be a subtype of the type used for
11895  * accessibles of the parent class.
11896  *
11897  * This function should only be called from class init functions of widgets.
11898  *
11899  * Since: 3.2
11900  **/
11901 void
11902 gtk_widget_class_set_accessible_type (GtkWidgetClass *widget_class,
11903                                       GType           type)
11904 {
11905   GtkWidgetClassPrivate *priv;
11906
11907   g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
11908   g_return_if_fail (g_type_is_a (type, widget_class->priv->accessible_type));
11909
11910   priv = widget_class->priv;
11911
11912   priv->accessible_type = type;
11913   /* reset this - honoring the type's role is better. */
11914   priv->accessible_role = ATK_ROLE_INVALID;
11915 }
11916
11917 /**
11918  * gtk_widget_class_set_accessible_role:
11919  * @widget_class: class to set the accessible role for
11920  * @role: The role to use for accessibles created for @widget_class
11921  *
11922  * Sets the default #AtkRole to be set on accessibles created for
11923  * widgets of @widget_class. Accessibles may decide to not honor this
11924  * setting if their role reporting is more refined. Calls to
11925  * gtk_widget_class_set_accessible_type() will reset this value.
11926  *
11927  * In cases where you want more fine-grained control over the role of
11928  * accessibles created for @widget_class, you should provide your own
11929  * accessible type and use gtk_widget_class_set_accessible_type()
11930  * instead.
11931  *
11932  * If @role is #ATK_ROLE_INVALID, the default role will not be changed
11933  * and the accessible's default role will be used instead.
11934  *
11935  * This function should only be called from class init functions of widgets.
11936  *
11937  * Since: 3.2
11938  **/
11939 void
11940 gtk_widget_class_set_accessible_role (GtkWidgetClass *widget_class,
11941                                       AtkRole         role)
11942 {
11943   GtkWidgetClassPrivate *priv;
11944
11945   g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
11946
11947   priv = widget_class->priv;
11948
11949   priv->accessible_role = role;
11950 }
11951
11952 /**
11953  * _gtk_widget_peek_accessible:
11954  * @widget: a #GtkWidget
11955  *
11956  * Gets the accessible for @widget, if it has been created yet.
11957  * Otherwise, this function returns %NULL. If the @widget's implementation
11958  * does not use the default way to create accessibles, %NULL will always be
11959  * returned.
11960  *
11961  * Returns: the accessible for @widget or %NULL if none has been
11962  *     created yet.
11963  **/
11964 AtkObject *
11965 _gtk_widget_peek_accessible (GtkWidget *widget)
11966 {
11967   return g_object_get_qdata (G_OBJECT (widget),
11968                              quark_accessible_object);
11969 }
11970
11971 /**
11972  * gtk_widget_get_accessible:
11973  * @widget: a #GtkWidget
11974  *
11975  * Returns the accessible object that describes the widget to an
11976  * assistive technology.
11977  *
11978  * If accessibility support is not available, this #AtkObject
11979  * instance may be a no-op. Likewise, if no class-specific #AtkObject
11980  * implementation is available for the widget instance in question,
11981  * it will inherit an #AtkObject implementation from the first ancestor
11982  * class for which such an implementation is defined.
11983  *
11984  * The documentation of the
11985  * <ulink url="http://developer.gnome.org/atk/stable/">ATK</ulink>
11986  * library contains more information about accessible objects and their uses.
11987  *
11988  * Returns: (transfer none): the #AtkObject associated with @widget
11989  */
11990 AtkObject*
11991 gtk_widget_get_accessible (GtkWidget *widget)
11992 {
11993   GtkWidgetClass *klass;
11994
11995   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
11996
11997   klass = GTK_WIDGET_GET_CLASS (widget);
11998
11999   g_return_val_if_fail (klass->get_accessible != NULL, NULL);
12000
12001   return klass->get_accessible (widget);
12002 }
12003
12004 static AtkObject*
12005 gtk_widget_real_get_accessible (GtkWidget *widget)
12006 {
12007   AtkObject* accessible;
12008
12009   accessible = g_object_get_qdata (G_OBJECT (widget),
12010                                    quark_accessible_object);
12011   if (!accessible)
12012   {
12013     GtkWidgetClass *widget_class;
12014     GtkWidgetClassPrivate *priv;
12015     AtkObjectFactory *factory;
12016     AtkRegistry *default_registry;
12017
12018     widget_class = GTK_WIDGET_GET_CLASS (widget);
12019     priv = widget_class->priv;
12020
12021     if (priv->accessible_type == GTK_TYPE_ACCESSIBLE)
12022       {
12023         default_registry = atk_get_default_registry ();
12024         factory = atk_registry_get_factory (default_registry,
12025                                             G_TYPE_FROM_INSTANCE (widget));
12026         accessible =
12027           atk_object_factory_create_accessible (factory,
12028                                                 G_OBJECT (widget));
12029
12030         if (priv->accessible_role != ATK_ROLE_INVALID)
12031           atk_object_set_role (accessible, priv->accessible_role);
12032
12033         g_object_set_qdata (G_OBJECT (widget),
12034                             quark_accessible_object,
12035                             accessible);
12036       }
12037     else
12038       {
12039         accessible = g_object_new (priv->accessible_type,
12040                                    "widget", widget,
12041                                    NULL);
12042         if (priv->accessible_role != ATK_ROLE_INVALID)
12043           atk_object_set_role (accessible, priv->accessible_role);
12044
12045         g_object_set_qdata (G_OBJECT (widget),
12046                             quark_accessible_object,
12047                             accessible);
12048
12049         atk_object_initialize (accessible, widget);
12050
12051         /* Set the role again, since we don't want a role set
12052          * in some parent initialize() function to override
12053          * our own.
12054          */
12055         if (priv->accessible_role != ATK_ROLE_INVALID)
12056           atk_object_set_role (accessible, priv->accessible_role);
12057       }
12058   }
12059   return accessible;
12060 }
12061
12062 /*
12063  * Initialize a AtkImplementorIface instance's virtual pointers as
12064  * appropriate to this implementor's class (GtkWidget).
12065  */
12066 static void
12067 gtk_widget_accessible_interface_init (AtkImplementorIface *iface)
12068 {
12069   iface->ref_accessible = gtk_widget_ref_accessible;
12070 }
12071
12072 static AtkObject*
12073 gtk_widget_ref_accessible (AtkImplementor *implementor)
12074 {
12075   AtkObject *accessible;
12076
12077   accessible = gtk_widget_get_accessible (GTK_WIDGET (implementor));
12078   if (accessible)
12079     g_object_ref (accessible);
12080   return accessible;
12081 }
12082
12083 /*
12084  * Expand flag management
12085  */
12086
12087 static void
12088 gtk_widget_update_computed_expand (GtkWidget *widget)
12089 {
12090   GtkWidgetPrivate *priv;
12091
12092   priv = widget->priv;
12093
12094   if (priv->need_compute_expand)
12095     {
12096       gboolean h, v;
12097
12098       if (priv->hexpand_set)
12099         h = priv->hexpand;
12100       else
12101         h = FALSE;
12102
12103       if (priv->vexpand_set)
12104         v = priv->vexpand;
12105       else
12106         v = FALSE;
12107
12108       /* we don't need to use compute_expand if both expands are
12109        * forced by the app
12110        */
12111       if (!(priv->hexpand_set && priv->vexpand_set))
12112         {
12113           if (GTK_WIDGET_GET_CLASS (widget)->compute_expand != NULL)
12114             {
12115               gboolean ignored;
12116
12117               GTK_WIDGET_GET_CLASS (widget)->compute_expand (widget,
12118                                                              priv->hexpand_set ? &ignored : &h,
12119                                                              priv->vexpand_set ? &ignored : &v);
12120             }
12121         }
12122
12123       priv->need_compute_expand = FALSE;
12124       priv->computed_hexpand = h != FALSE;
12125       priv->computed_vexpand = v != FALSE;
12126     }
12127 }
12128
12129 /**
12130  * gtk_widget_queue_compute_expand:
12131  * @widget: a #GtkWidget
12132  *
12133  * Mark @widget as needing to recompute its expand flags. Call
12134  * this function when setting legacy expand child properties
12135  * on the child of a container.
12136  *
12137  * See gtk_widget_compute_expand().
12138  */
12139 void
12140 gtk_widget_queue_compute_expand (GtkWidget *widget)
12141 {
12142   GtkWidget *parent;
12143   gboolean changed_anything;
12144
12145   if (widget->priv->need_compute_expand)
12146     return;
12147
12148   changed_anything = FALSE;
12149   parent = widget;
12150   while (parent != NULL)
12151     {
12152       if (!parent->priv->need_compute_expand)
12153         {
12154           parent->priv->need_compute_expand = TRUE;
12155           changed_anything = TRUE;
12156         }
12157
12158       /* Note: if we had an invariant that "if a child needs to
12159        * compute expand, its parents also do" then we could stop going
12160        * up when we got to a parent that already needed to
12161        * compute. However, in general we compute expand lazily (as
12162        * soon as we see something in a subtree that is expand, we know
12163        * we're expanding) and so this invariant does not hold and we
12164        * have to always walk all the way up in case some ancestor
12165        * is not currently need_compute_expand.
12166        */
12167
12168       parent = parent->priv->parent;
12169     }
12170
12171   /* recomputing expand always requires
12172    * a relayout as well
12173    */
12174   if (changed_anything)
12175     gtk_widget_queue_resize (widget);
12176 }
12177
12178 /**
12179  * gtk_widget_compute_expand:
12180  * @widget: the widget
12181  * @orientation: expand direction
12182  *
12183  * Computes whether a container should give this widget extra space
12184  * when possible. Containers should check this, rather than
12185  * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
12186  *
12187  * This function already checks whether the widget is visible, so
12188  * visibility does not need to be checked separately. Non-visible
12189  * widgets are not expanded.
12190  *
12191  * The computed expand value uses either the expand setting explicitly
12192  * set on the widget itself, or, if none has been explicitly set,
12193  * the widget may expand if some of its children do.
12194  *
12195  * Return value: whether widget tree rooted here should be expanded
12196  */
12197 gboolean
12198 gtk_widget_compute_expand (GtkWidget     *widget,
12199                            GtkOrientation orientation)
12200 {
12201   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12202
12203   /* We never make a widget expand if not even showing. */
12204   if (!gtk_widget_get_visible (widget))
12205     return FALSE;
12206
12207   gtk_widget_update_computed_expand (widget);
12208
12209   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12210     {
12211       return widget->priv->computed_hexpand;
12212     }
12213   else
12214     {
12215       return widget->priv->computed_vexpand;
12216     }
12217 }
12218
12219 static void
12220 gtk_widget_set_expand (GtkWidget     *widget,
12221                        GtkOrientation orientation,
12222                        gboolean       expand)
12223 {
12224   const char *expand_prop;
12225   const char *expand_set_prop;
12226   gboolean was_both;
12227   GtkWidgetPrivate *priv;
12228
12229   g_return_if_fail (GTK_IS_WIDGET (widget));
12230
12231   priv = widget->priv;
12232
12233   expand = expand != FALSE;
12234
12235   was_both = priv->hexpand && priv->vexpand;
12236
12237   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12238     {
12239       if (priv->hexpand_set &&
12240           priv->hexpand == expand)
12241         return;
12242
12243       priv->hexpand_set = TRUE;
12244       priv->hexpand = expand;
12245
12246       expand_prop = "hexpand";
12247       expand_set_prop = "hexpand-set";
12248     }
12249   else
12250     {
12251       if (priv->vexpand_set &&
12252           priv->vexpand == expand)
12253         return;
12254
12255       priv->vexpand_set = TRUE;
12256       priv->vexpand = expand;
12257
12258       expand_prop = "vexpand";
12259       expand_set_prop = "vexpand-set";
12260     }
12261
12262   gtk_widget_queue_compute_expand (widget);
12263
12264   g_object_freeze_notify (G_OBJECT (widget));
12265   g_object_notify (G_OBJECT (widget), expand_prop);
12266   g_object_notify (G_OBJECT (widget), expand_set_prop);
12267   if (was_both != (priv->hexpand && priv->vexpand))
12268     g_object_notify (G_OBJECT (widget), "expand");
12269   g_object_thaw_notify (G_OBJECT (widget));
12270 }
12271
12272 static void
12273 gtk_widget_set_expand_set (GtkWidget      *widget,
12274                            GtkOrientation  orientation,
12275                            gboolean        set)
12276 {
12277   GtkWidgetPrivate *priv;
12278   const char *prop;
12279
12280   priv = widget->priv;
12281
12282   set = set != FALSE;
12283
12284   if (orientation == GTK_ORIENTATION_HORIZONTAL)
12285     {
12286       if (set == priv->hexpand_set)
12287         return;
12288
12289       priv->hexpand_set = set;
12290       prop = "hexpand-set";
12291     }
12292   else
12293     {
12294       if (set == priv->vexpand_set)
12295         return;
12296
12297       priv->vexpand_set = set;
12298       prop = "vexpand-set";
12299     }
12300
12301   gtk_widget_queue_compute_expand (widget);
12302
12303   g_object_notify (G_OBJECT (widget), prop);
12304 }
12305
12306 /**
12307  * gtk_widget_get_hexpand:
12308  * @widget: the widget
12309  *
12310  * Gets whether the widget would like any available extra horizontal
12311  * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
12312  * generally receive the extra space. For example, a list or
12313  * scrollable area or document in your window would often be set to
12314  * expand.
12315  *
12316  * Containers should use gtk_widget_compute_expand() rather than
12317  * this function, to see whether a widget, or any of its children,
12318  * has the expand flag set. If any child of a widget wants to
12319  * expand, the parent may ask to expand also.
12320  *
12321  * This function only looks at the widget's own hexpand flag, rather
12322  * than computing whether the entire widget tree rooted at this widget
12323  * wants to expand.
12324  *
12325  * Return value: whether hexpand flag is set
12326  */
12327 gboolean
12328 gtk_widget_get_hexpand (GtkWidget *widget)
12329 {
12330   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12331
12332   return widget->priv->hexpand;
12333 }
12334
12335 /**
12336  * gtk_widget_set_hexpand:
12337  * @widget: the widget
12338  * @expand: whether to expand
12339  *
12340  * Sets whether the widget would like any available extra horizontal
12341  * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
12342  * generally receive the extra space. For example, a list or
12343  * scrollable area or document in your window would often be set to
12344  * expand.
12345  *
12346  * Call this function to set the expand flag if you would like your
12347  * widget to become larger horizontally when the window has extra
12348  * room.
12349  *
12350  * By default, widgets automatically expand if any of their children
12351  * want to expand. (To see if a widget will automatically expand given
12352  * its current children and state, call gtk_widget_compute_expand(). A
12353  * container can decide how the expandability of children affects the
12354  * expansion of the container by overriding the compute_expand virtual
12355  * method on #GtkWidget.).
12356  *
12357  * Setting hexpand explicitly with this function will override the
12358  * automatic expand behavior.
12359  *
12360  * This function forces the widget to expand or not to expand,
12361  * regardless of children.  The override occurs because
12362  * gtk_widget_set_hexpand() sets the hexpand-set property (see
12363  * gtk_widget_set_hexpand_set()) which causes the widget's hexpand
12364  * value to be used, rather than looking at children and widget state.
12365  */
12366 void
12367 gtk_widget_set_hexpand (GtkWidget      *widget,
12368                         gboolean        expand)
12369 {
12370   g_return_if_fail (GTK_IS_WIDGET (widget));
12371
12372   gtk_widget_set_expand (widget, GTK_ORIENTATION_HORIZONTAL, expand);
12373 }
12374
12375 /**
12376  * gtk_widget_get_hexpand_set:
12377  * @widget: the widget
12378  *
12379  * Gets whether gtk_widget_set_hexpand() has been used to
12380  * explicitly set the expand flag on this widget.
12381  *
12382  * If hexpand is set, then it overrides any computed
12383  * expand value based on child widgets. If hexpand is not
12384  * set, then the expand value depends on whether any
12385  * children of the widget would like to expand.
12386  *
12387  * There are few reasons to use this function, but it's here
12388  * for completeness and consistency.
12389  *
12390  * Return value: whether hexpand has been explicitly set
12391  */
12392 gboolean
12393 gtk_widget_get_hexpand_set (GtkWidget      *widget)
12394 {
12395   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12396
12397   return widget->priv->hexpand_set;
12398 }
12399
12400 /**
12401  * gtk_widget_set_hexpand_set:
12402  * @widget: the widget
12403  * @set: value for hexpand-set property
12404  *
12405  * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
12406  * be used.
12407  *
12408  * The hexpand-set property will be set automatically when you call
12409  * gtk_widget_set_hexpand() to set hexpand, so the most likely
12410  * reason to use this function would be to unset an explicit expand
12411  * flag.
12412  *
12413  * If hexpand is set, then it overrides any computed
12414  * expand value based on child widgets. If hexpand is not
12415  * set, then the expand value depends on whether any
12416  * children of the widget would like to expand.
12417  *
12418  * There are few reasons to use this function, but it's here
12419  * for completeness and consistency.
12420  */
12421 void
12422 gtk_widget_set_hexpand_set (GtkWidget      *widget,
12423                             gboolean        set)
12424 {
12425   g_return_if_fail (GTK_IS_WIDGET (widget));
12426
12427   gtk_widget_set_expand_set (widget, GTK_ORIENTATION_HORIZONTAL, set);
12428 }
12429
12430
12431 /**
12432  * gtk_widget_get_vexpand:
12433  * @widget: the widget
12434  *
12435  * Gets whether the widget would like any available extra vertical
12436  * space.
12437  *
12438  * See gtk_widget_get_hexpand() for more detail.
12439  *
12440  * Return value: whether vexpand flag is set
12441  */
12442 gboolean
12443 gtk_widget_get_vexpand (GtkWidget *widget)
12444 {
12445   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12446
12447   return widget->priv->vexpand;
12448 }
12449
12450 /**
12451  * gtk_widget_set_vexpand:
12452  * @widget: the widget
12453  * @expand: whether to expand
12454  *
12455  * Sets whether the widget would like any available extra vertical
12456  * space.
12457  *
12458  * See gtk_widget_set_hexpand() for more detail.
12459  */
12460 void
12461 gtk_widget_set_vexpand (GtkWidget      *widget,
12462                         gboolean        expand)
12463 {
12464   g_return_if_fail (GTK_IS_WIDGET (widget));
12465
12466   gtk_widget_set_expand (widget, GTK_ORIENTATION_VERTICAL, expand);
12467 }
12468
12469 /**
12470  * gtk_widget_get_vexpand_set:
12471  * @widget: the widget
12472  *
12473  * Gets whether gtk_widget_set_vexpand() has been used to
12474  * explicitly set the expand flag on this widget.
12475  *
12476  * See gtk_widget_get_hexpand_set() for more detail.
12477  *
12478  * Return value: whether vexpand has been explicitly set
12479  */
12480 gboolean
12481 gtk_widget_get_vexpand_set (GtkWidget      *widget)
12482 {
12483   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12484
12485   return widget->priv->vexpand_set;
12486 }
12487
12488 /**
12489  * gtk_widget_set_vexpand_set:
12490  * @widget: the widget
12491  * @set: value for vexpand-set property
12492  *
12493  * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
12494  * be used.
12495  *
12496  * See gtk_widget_set_hexpand_set() for more detail.
12497  */
12498 void
12499 gtk_widget_set_vexpand_set (GtkWidget      *widget,
12500                             gboolean        set)
12501 {
12502   g_return_if_fail (GTK_IS_WIDGET (widget));
12503
12504   gtk_widget_set_expand_set (widget, GTK_ORIENTATION_VERTICAL, set);
12505 }
12506
12507 /*
12508  * GtkBuildable implementation
12509  */
12510 static GQuark            quark_builder_has_default = 0;
12511 static GQuark            quark_builder_has_focus = 0;
12512 static GQuark            quark_builder_atk_relations = 0;
12513 static GQuark            quark_builder_set_name = 0;
12514
12515 static void
12516 gtk_widget_buildable_interface_init (GtkBuildableIface *iface)
12517 {
12518   quark_builder_has_default = g_quark_from_static_string ("gtk-builder-has-default");
12519   quark_builder_has_focus = g_quark_from_static_string ("gtk-builder-has-focus");
12520   quark_builder_atk_relations = g_quark_from_static_string ("gtk-builder-atk-relations");
12521   quark_builder_set_name = g_quark_from_static_string ("gtk-builder-set-name");
12522
12523   iface->set_name = gtk_widget_buildable_set_name;
12524   iface->get_name = gtk_widget_buildable_get_name;
12525   iface->get_internal_child = gtk_widget_buildable_get_internal_child;
12526   iface->set_buildable_property = gtk_widget_buildable_set_buildable_property;
12527   iface->parser_finished = gtk_widget_buildable_parser_finished;
12528   iface->custom_tag_start = gtk_widget_buildable_custom_tag_start;
12529   iface->custom_finished = gtk_widget_buildable_custom_finished;
12530 }
12531
12532 static void
12533 gtk_widget_buildable_set_name (GtkBuildable *buildable,
12534                                const gchar  *name)
12535 {
12536   g_object_set_qdata_full (G_OBJECT (buildable), quark_builder_set_name,
12537                            g_strdup (name), g_free);
12538 }
12539
12540 static const gchar *
12541 gtk_widget_buildable_get_name (GtkBuildable *buildable)
12542 {
12543   return g_object_get_qdata (G_OBJECT (buildable), quark_builder_set_name);
12544 }
12545
12546 static GObject *
12547 gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,
12548                                          GtkBuilder   *builder,
12549                                          const gchar  *childname)
12550 {
12551   if (strcmp (childname, "accessible") == 0)
12552     return G_OBJECT (gtk_widget_get_accessible (GTK_WIDGET (buildable)));
12553
12554   return NULL;
12555 }
12556
12557 static void
12558 gtk_widget_buildable_set_buildable_property (GtkBuildable *buildable,
12559                                              GtkBuilder   *builder,
12560                                              const gchar  *name,
12561                                              const GValue *value)
12562 {
12563   if (strcmp (name, "has-default") == 0 && g_value_get_boolean (value))
12564       g_object_set_qdata (G_OBJECT (buildable), quark_builder_has_default,
12565                           GINT_TO_POINTER (TRUE));
12566   else if (strcmp (name, "has-focus") == 0 && g_value_get_boolean (value))
12567       g_object_set_qdata (G_OBJECT (buildable), quark_builder_has_focus,
12568                           GINT_TO_POINTER (TRUE));
12569   else
12570     g_object_set_property (G_OBJECT (buildable), name, value);
12571 }
12572
12573 typedef struct
12574 {
12575   gchar *action_name;
12576   GString *description;
12577   gchar *context;
12578   gboolean translatable;
12579 } AtkActionData;
12580
12581 typedef struct
12582 {
12583   gchar *target;
12584   gchar *type;
12585 } AtkRelationData;
12586
12587 static void
12588 free_action (AtkActionData *data, gpointer user_data)
12589 {
12590   g_free (data->action_name);
12591   g_string_free (data->description, TRUE);
12592   g_free (data->context);
12593   g_slice_free (AtkActionData, data);
12594 }
12595
12596 static void
12597 free_relation (AtkRelationData *data, gpointer user_data)
12598 {
12599   g_free (data->target);
12600   g_free (data->type);
12601   g_slice_free (AtkRelationData, data);
12602 }
12603
12604 static void
12605 gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
12606                                       GtkBuilder   *builder)
12607 {
12608   GSList *atk_relations;
12609
12610   if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_default))
12611     gtk_widget_grab_default (GTK_WIDGET (buildable));
12612   if (g_object_get_qdata (G_OBJECT (buildable), quark_builder_has_focus))
12613     gtk_widget_grab_focus (GTK_WIDGET (buildable));
12614
12615   atk_relations = g_object_get_qdata (G_OBJECT (buildable),
12616                                       quark_builder_atk_relations);
12617   if (atk_relations)
12618     {
12619       AtkObject *accessible;
12620       AtkRelationSet *relation_set;
12621       GSList *l;
12622       GObject *target;
12623       AtkRelationType relation_type;
12624       AtkObject *target_accessible;
12625
12626       accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
12627       relation_set = atk_object_ref_relation_set (accessible);
12628
12629       for (l = atk_relations; l; l = l->next)
12630         {
12631           AtkRelationData *relation = (AtkRelationData*)l->data;
12632
12633           target = gtk_builder_get_object (builder, relation->target);
12634           if (!target)
12635             {
12636               g_warning ("Target object %s in <relation> does not exist",
12637                          relation->target);
12638               continue;
12639             }
12640           target_accessible = gtk_widget_get_accessible (GTK_WIDGET (target));
12641           g_assert (target_accessible != NULL);
12642
12643           relation_type = atk_relation_type_for_name (relation->type);
12644           if (relation_type == ATK_RELATION_NULL)
12645             {
12646               g_warning ("<relation> type %s not found",
12647                          relation->type);
12648               continue;
12649             }
12650           atk_relation_set_add_relation_by_type (relation_set, relation_type,
12651                                                  target_accessible);
12652         }
12653       g_object_unref (relation_set);
12654
12655       g_slist_free_full (atk_relations, (GDestroyNotify) free_relation);
12656       g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
12657                           NULL);
12658     }
12659 }
12660
12661 typedef struct
12662 {
12663   GSList *actions;
12664   GSList *relations;
12665 } AccessibilitySubParserData;
12666
12667 static void
12668 accessibility_start_element (GMarkupParseContext  *context,
12669                              const gchar          *element_name,
12670                              const gchar         **names,
12671                              const gchar         **values,
12672                              gpointer              user_data,
12673                              GError              **error)
12674 {
12675   AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
12676   guint i;
12677   gint line_number, char_number;
12678
12679   if (strcmp (element_name, "relation") == 0)
12680     {
12681       gchar *target = NULL;
12682       gchar *type = NULL;
12683       AtkRelationData *relation;
12684
12685       for (i = 0; names[i]; i++)
12686         {
12687           if (strcmp (names[i], "target") == 0)
12688             target = g_strdup (values[i]);
12689           else if (strcmp (names[i], "type") == 0)
12690             type = g_strdup (values[i]);
12691           else
12692             {
12693               g_markup_parse_context_get_position (context,
12694                                                    &line_number,
12695                                                    &char_number);
12696               g_set_error (error,
12697                            GTK_BUILDER_ERROR,
12698                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
12699                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
12700                            "<input>",
12701                            line_number, char_number, names[i], "relation");
12702               g_free (target);
12703               g_free (type);
12704               return;
12705             }
12706         }
12707
12708       if (!target || !type)
12709         {
12710           g_markup_parse_context_get_position (context,
12711                                                &line_number,
12712                                                &char_number);
12713           g_set_error (error,
12714                        GTK_BUILDER_ERROR,
12715                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
12716                        "%s:%d:%d <%s> requires attribute \"%s\"",
12717                        "<input>",
12718                        line_number, char_number, "relation",
12719                        type ? "target" : "type");
12720           g_free (target);
12721           g_free (type);
12722           return;
12723         }
12724
12725       relation = g_slice_new (AtkRelationData);
12726       relation->target = target;
12727       relation->type = type;
12728
12729       data->relations = g_slist_prepend (data->relations, relation);
12730     }
12731   else if (strcmp (element_name, "action") == 0)
12732     {
12733       const gchar *action_name = NULL;
12734       const gchar *description = NULL;
12735       const gchar *msg_context = NULL;
12736       gboolean translatable = FALSE;
12737       AtkActionData *action;
12738
12739       for (i = 0; names[i]; i++)
12740         {
12741           if (strcmp (names[i], "action_name") == 0)
12742             action_name = values[i];
12743           else if (strcmp (names[i], "description") == 0)
12744             description = values[i];
12745           else if (strcmp (names[i], "translatable") == 0)
12746             {
12747               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
12748                 return;
12749             }
12750           else if (strcmp (names[i], "comments") == 0)
12751             {
12752               /* do nothing, comments are for translators */
12753             }
12754           else if (strcmp (names[i], "context") == 0)
12755             msg_context = values[i];
12756           else
12757             {
12758               g_markup_parse_context_get_position (context,
12759                                                    &line_number,
12760                                                    &char_number);
12761               g_set_error (error,
12762                            GTK_BUILDER_ERROR,
12763                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
12764                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
12765                            "<input>",
12766                            line_number, char_number, names[i], "action");
12767               return;
12768             }
12769         }
12770
12771       if (!action_name)
12772         {
12773           g_markup_parse_context_get_position (context,
12774                                                &line_number,
12775                                                &char_number);
12776           g_set_error (error,
12777                        GTK_BUILDER_ERROR,
12778                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
12779                        "%s:%d:%d <%s> requires attribute \"%s\"",
12780                        "<input>",
12781                        line_number, char_number, "action",
12782                        "action_name");
12783           return;
12784         }
12785
12786       action = g_slice_new (AtkActionData);
12787       action->action_name = g_strdup (action_name);
12788       action->description = g_string_new (description);
12789       action->context = g_strdup (msg_context);
12790       action->translatable = translatable;
12791
12792       data->actions = g_slist_prepend (data->actions, action);
12793     }
12794   else if (strcmp (element_name, "accessibility") == 0)
12795     ;
12796   else
12797     g_warning ("Unsupported tag for GtkWidget: %s\n", element_name);
12798 }
12799
12800 static void
12801 accessibility_text (GMarkupParseContext  *context,
12802                     const gchar          *text,
12803                     gsize                 text_len,
12804                     gpointer              user_data,
12805                     GError              **error)
12806 {
12807   AccessibilitySubParserData *data = (AccessibilitySubParserData*)user_data;
12808
12809   if (strcmp (g_markup_parse_context_get_element (context), "action") == 0)
12810     {
12811       AtkActionData *action = data->actions->data;
12812
12813       g_string_append_len (action->description, text, text_len);
12814     }
12815 }
12816
12817 static const GMarkupParser accessibility_parser =
12818   {
12819     accessibility_start_element,
12820     NULL,
12821     accessibility_text,
12822   };
12823
12824 typedef struct
12825 {
12826   GObject *object;
12827   guint    key;
12828   guint    modifiers;
12829   gchar   *signal;
12830 } AccelGroupParserData;
12831
12832 static void
12833 accel_group_start_element (GMarkupParseContext  *context,
12834                            const gchar          *element_name,
12835                            const gchar         **names,
12836                            const gchar         **values,
12837                            gpointer              user_data,
12838                            GError              **error)
12839 {
12840   gint i;
12841   guint key = 0;
12842   guint modifiers = 0;
12843   gchar *signal = NULL;
12844   AccelGroupParserData *parser_data = (AccelGroupParserData*)user_data;
12845
12846   for (i = 0; names[i]; i++)
12847     {
12848       if (strcmp (names[i], "key") == 0)
12849         key = gdk_keyval_from_name (values[i]);
12850       else if (strcmp (names[i], "modifiers") == 0)
12851         {
12852           if (!_gtk_builder_flags_from_string (GDK_TYPE_MODIFIER_TYPE,
12853                                                values[i],
12854                                                &modifiers,
12855                                                error))
12856               return;
12857         }
12858       else if (strcmp (names[i], "signal") == 0)
12859         signal = g_strdup (values[i]);
12860     }
12861
12862   if (key == 0 || signal == NULL)
12863     {
12864       g_warning ("<accelerator> requires key and signal attributes");
12865       return;
12866     }
12867   parser_data->key = key;
12868   parser_data->modifiers = modifiers;
12869   parser_data->signal = signal;
12870 }
12871
12872 static const GMarkupParser accel_group_parser =
12873   {
12874     accel_group_start_element,
12875   };
12876
12877 typedef struct
12878 {
12879   GSList *classes;
12880 } StyleParserData;
12881
12882 static void
12883 style_start_element (GMarkupParseContext  *context,
12884                      const gchar          *element_name,
12885                      const gchar         **names,
12886                      const gchar         **values,
12887                      gpointer              user_data,
12888                      GError              **error)
12889 {
12890   StyleParserData *style_data = (StyleParserData *)user_data;
12891   gchar *class_name;
12892
12893   if (strcmp (element_name, "class") == 0)
12894     {
12895       if (g_markup_collect_attributes (element_name,
12896                                        names,
12897                                        values,
12898                                        error,
12899                                        G_MARKUP_COLLECT_STRDUP, "name", &class_name,
12900                                        G_MARKUP_COLLECT_INVALID))
12901         {
12902           style_data->classes = g_slist_append (style_data->classes, class_name);
12903         }
12904     }
12905   else if (strcmp (element_name, "style") == 0)
12906     ;
12907   else
12908     g_warning ("Unsupported tag for GtkWidget: %s\n", element_name);
12909 }
12910
12911 static const GMarkupParser style_parser =
12912   {
12913     style_start_element,
12914   };
12915
12916 static gboolean
12917 gtk_widget_buildable_custom_tag_start (GtkBuildable     *buildable,
12918                                        GtkBuilder       *builder,
12919                                        GObject          *child,
12920                                        const gchar      *tagname,
12921                                        GMarkupParser    *parser,
12922                                        gpointer         *data)
12923 {
12924   g_assert (buildable);
12925
12926   if (strcmp (tagname, "accelerator") == 0)
12927     {
12928       AccelGroupParserData *parser_data;
12929
12930       parser_data = g_slice_new0 (AccelGroupParserData);
12931       parser_data->object = g_object_ref (buildable);
12932       *parser = accel_group_parser;
12933       *data = parser_data;
12934       return TRUE;
12935     }
12936   if (strcmp (tagname, "accessibility") == 0)
12937     {
12938       AccessibilitySubParserData *parser_data;
12939
12940       parser_data = g_slice_new0 (AccessibilitySubParserData);
12941       *parser = accessibility_parser;
12942       *data = parser_data;
12943       return TRUE;
12944     }
12945   if (strcmp (tagname, "style") == 0)
12946     {
12947       StyleParserData *parser_data;
12948
12949       parser_data = g_slice_new0 (StyleParserData);
12950       *parser = style_parser;
12951       *data = parser_data;
12952       return TRUE;
12953     }
12954
12955   return FALSE;
12956 }
12957
12958 void
12959 _gtk_widget_buildable_finish_accelerator (GtkWidget *widget,
12960                                           GtkWidget *toplevel,
12961                                           gpointer   user_data)
12962 {
12963   AccelGroupParserData *accel_data;
12964   GSList *accel_groups;
12965   GtkAccelGroup *accel_group;
12966
12967   g_return_if_fail (GTK_IS_WIDGET (widget));
12968   g_return_if_fail (GTK_IS_WIDGET (toplevel));
12969   g_return_if_fail (user_data != NULL);
12970
12971   accel_data = (AccelGroupParserData*)user_data;
12972   accel_groups = gtk_accel_groups_from_object (G_OBJECT (toplevel));
12973   if (g_slist_length (accel_groups) == 0)
12974     {
12975       accel_group = gtk_accel_group_new ();
12976       gtk_window_add_accel_group (GTK_WINDOW (toplevel), accel_group);
12977     }
12978   else
12979     {
12980       g_assert (g_slist_length (accel_groups) == 1);
12981       accel_group = g_slist_nth_data (accel_groups, 0);
12982     }
12983
12984   gtk_widget_add_accelerator (GTK_WIDGET (accel_data->object),
12985                               accel_data->signal,
12986                               accel_group,
12987                               accel_data->key,
12988                               accel_data->modifiers,
12989                               GTK_ACCEL_VISIBLE);
12990
12991   g_object_unref (accel_data->object);
12992   g_free (accel_data->signal);
12993   g_slice_free (AccelGroupParserData, accel_data);
12994 }
12995
12996 static void
12997 gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
12998                                       GtkBuilder   *builder,
12999                                       GObject      *child,
13000                                       const gchar  *tagname,
13001                                       gpointer      user_data)
13002 {
13003   if (strcmp (tagname, "accelerator") == 0)
13004     {
13005       AccelGroupParserData *accel_data;
13006       GtkWidget *toplevel;
13007
13008       accel_data = (AccelGroupParserData*)user_data;
13009       g_assert (accel_data->object);
13010
13011       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (accel_data->object));
13012
13013       _gtk_widget_buildable_finish_accelerator (GTK_WIDGET (buildable), toplevel, user_data);
13014     }
13015   else if (strcmp (tagname, "accessibility") == 0)
13016     {
13017       AccessibilitySubParserData *a11y_data;
13018
13019       a11y_data = (AccessibilitySubParserData*)user_data;
13020
13021       if (a11y_data->actions)
13022         {
13023           AtkObject *accessible;
13024           AtkAction *action;
13025           gint i, n_actions;
13026           GSList *l;
13027
13028           accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
13029
13030           if (ATK_IS_ACTION (accessible))
13031             {
13032               action = ATK_ACTION (accessible);
13033               n_actions = atk_action_get_n_actions (action);
13034
13035               for (l = a11y_data->actions; l; l = l->next)
13036                 {
13037                   AtkActionData *action_data = (AtkActionData*)l->data;
13038
13039                   for (i = 0; i < n_actions; i++)
13040                     if (strcmp (atk_action_get_name (action, i),
13041                                 action_data->action_name) == 0)
13042                       break;
13043
13044                   if (i < n_actions)
13045                     {
13046                       gchar *description;
13047
13048                       if (action_data->translatable && action_data->description->len)
13049                         description = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
13050                                                                      action_data->context,
13051                                                                      action_data->description->str);
13052                       else
13053                         description = action_data->description->str;
13054
13055                       atk_action_set_description (action, i, description);
13056                     }
13057                 }
13058             }
13059           else
13060             g_warning ("accessibility action on a widget that does not implement AtkAction");
13061
13062           g_slist_free_full (a11y_data->actions, (GDestroyNotify) free_action);
13063         }
13064
13065       if (a11y_data->relations)
13066         g_object_set_qdata (G_OBJECT (buildable), quark_builder_atk_relations,
13067                             a11y_data->relations);
13068
13069       g_slice_free (AccessibilitySubParserData, a11y_data);
13070     }
13071   else if (strcmp (tagname, "style") == 0)
13072     {
13073       StyleParserData *style_data = (StyleParserData *)user_data;
13074       GtkStyleContext *context;
13075       GSList *l;
13076
13077       context = gtk_widget_get_style_context (GTK_WIDGET (buildable));
13078
13079       for (l = style_data->classes; l; l = l->next)
13080         gtk_style_context_add_class (context, (const gchar *)l->data);
13081
13082       gtk_widget_reset_style (GTK_WIDGET (buildable));
13083
13084       g_slist_free_full (style_data->classes, g_free);
13085       g_slice_free (StyleParserData, style_data);
13086     }
13087 }
13088
13089 static GtkSizeRequestMode
13090 gtk_widget_real_get_request_mode (GtkWidget *widget)
13091 {
13092   /* By default widgets dont trade size at all. */
13093   return GTK_SIZE_REQUEST_CONSTANT_SIZE;
13094 }
13095
13096 static void
13097 gtk_widget_real_get_width (GtkWidget *widget,
13098                            gint      *minimum_size,
13099                            gint      *natural_size)
13100 {
13101   if (minimum_size)
13102     *minimum_size = 0;
13103
13104   if (natural_size)
13105     *natural_size = 0;
13106 }
13107
13108 static void
13109 gtk_widget_real_get_height (GtkWidget *widget,
13110                             gint      *minimum_size,
13111                             gint      *natural_size)
13112 {
13113   if (minimum_size)
13114     *minimum_size = 0;
13115
13116   if (natural_size)
13117     *natural_size = 0;
13118 }
13119
13120 static void
13121 gtk_widget_real_get_height_for_width (GtkWidget *widget,
13122                                       gint       width,
13123                                       gint      *minimum_height,
13124                                       gint      *natural_height)
13125 {
13126   GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
13127 }
13128
13129 static void
13130 gtk_widget_real_get_width_for_height (GtkWidget *widget,
13131                                       gint       height,
13132                                       gint      *minimum_width,
13133                                       gint      *natural_width)
13134 {
13135   GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
13136 }
13137
13138 /**
13139  * gtk_widget_get_halign:
13140  * @widget: a #GtkWidget
13141  *
13142  * Gets the value of the #GtkWidget:halign property.
13143  *
13144  * Returns: the horizontal alignment of @widget
13145  */
13146 GtkAlign
13147 gtk_widget_get_halign (GtkWidget *widget)
13148 {
13149   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
13150   return _gtk_widget_get_aux_info_or_defaults (widget)->halign;
13151 }
13152
13153 /**
13154  * gtk_widget_set_halign:
13155  * @widget: a #GtkWidget
13156  * @align: the horizontal alignment
13157  *
13158  * Sets the horizontal alignment of @widget.
13159  * See the #GtkWidget:halign property.
13160  */
13161 void
13162 gtk_widget_set_halign (GtkWidget *widget,
13163                        GtkAlign   align)
13164 {
13165   GtkWidgetAuxInfo *aux_info;
13166
13167   g_return_if_fail (GTK_IS_WIDGET (widget));
13168
13169   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13170
13171   if (aux_info->halign == align)
13172     return;
13173
13174   aux_info->halign = align;
13175   gtk_widget_queue_resize (widget);
13176   g_object_notify (G_OBJECT (widget), "halign");
13177 }
13178
13179 /**
13180  * gtk_widget_get_valign:
13181  * @widget: a #GtkWidget
13182  *
13183  * Gets the value of the #GtkWidget:valign property.
13184  *
13185  * Returns: the vertical alignment of @widget
13186  */
13187 GtkAlign
13188 gtk_widget_get_valign (GtkWidget *widget)
13189 {
13190   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
13191   return _gtk_widget_get_aux_info_or_defaults (widget)->valign;
13192 }
13193
13194 /**
13195  * gtk_widget_set_valign:
13196  * @widget: a #GtkWidget
13197  * @align: the vertical alignment
13198  *
13199  * Sets the vertical alignment of @widget.
13200  * See the #GtkWidget:valign property.
13201  */
13202 void
13203 gtk_widget_set_valign (GtkWidget *widget,
13204                        GtkAlign   align)
13205 {
13206   GtkWidgetAuxInfo *aux_info;
13207
13208   g_return_if_fail (GTK_IS_WIDGET (widget));
13209
13210   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13211
13212   if (aux_info->valign == align)
13213     return;
13214
13215   aux_info->valign = align;
13216   gtk_widget_queue_resize (widget);
13217   g_object_notify (G_OBJECT (widget), "valign");
13218 }
13219
13220 /**
13221  * gtk_widget_get_margin_left:
13222  * @widget: a #GtkWidget
13223  *
13224  * Gets the value of the #GtkWidget:margin-left property.
13225  *
13226  * Returns: The left margin of @widget
13227  *
13228  * Since: 3.0
13229  */
13230 gint
13231 gtk_widget_get_margin_left (GtkWidget *widget)
13232 {
13233   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13234
13235   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.left;
13236 }
13237
13238 /**
13239  * gtk_widget_set_margin_left:
13240  * @widget: a #GtkWidget
13241  * @margin: the left margin
13242  *
13243  * Sets the left margin of @widget.
13244  * See the #GtkWidget:margin-left property.
13245  *
13246  * Since: 3.0
13247  */
13248 void
13249 gtk_widget_set_margin_left (GtkWidget *widget,
13250                             gint       margin)
13251 {
13252   GtkWidgetAuxInfo *aux_info;
13253
13254   g_return_if_fail (GTK_IS_WIDGET (widget));
13255   g_return_if_fail (margin <= G_MAXINT16);
13256
13257   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13258
13259   if (aux_info->margin.left == margin)
13260     return;
13261
13262   aux_info->margin.left = margin;
13263   gtk_widget_queue_resize (widget);
13264   g_object_notify (G_OBJECT (widget), "margin-left");
13265 }
13266
13267 /**
13268  * gtk_widget_get_margin_right:
13269  * @widget: a #GtkWidget
13270  *
13271  * Gets the value of the #GtkWidget:margin-right property.
13272  *
13273  * Returns: The right margin of @widget
13274  *
13275  * Since: 3.0
13276  */
13277 gint
13278 gtk_widget_get_margin_right (GtkWidget *widget)
13279 {
13280   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13281
13282   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.right;
13283 }
13284
13285 /**
13286  * gtk_widget_set_margin_right:
13287  * @widget: a #GtkWidget
13288  * @margin: the right margin
13289  *
13290  * Sets the right margin of @widget.
13291  * See the #GtkWidget:margin-right property.
13292  *
13293  * Since: 3.0
13294  */
13295 void
13296 gtk_widget_set_margin_right (GtkWidget *widget,
13297                              gint       margin)
13298 {
13299   GtkWidgetAuxInfo *aux_info;
13300
13301   g_return_if_fail (GTK_IS_WIDGET (widget));
13302   g_return_if_fail (margin <= G_MAXINT16);
13303
13304   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13305
13306   if (aux_info->margin.right == margin)
13307     return;
13308
13309   aux_info->margin.right = margin;
13310   gtk_widget_queue_resize (widget);
13311   g_object_notify (G_OBJECT (widget), "margin-right");
13312 }
13313
13314 /**
13315  * gtk_widget_get_margin_top:
13316  * @widget: a #GtkWidget
13317  *
13318  * Gets the value of the #GtkWidget:margin-top property.
13319  *
13320  * Returns: The top margin of @widget
13321  *
13322  * Since: 3.0
13323  */
13324 gint
13325 gtk_widget_get_margin_top (GtkWidget *widget)
13326 {
13327   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13328
13329   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.top;
13330 }
13331
13332 /**
13333  * gtk_widget_set_margin_top:
13334  * @widget: a #GtkWidget
13335  * @margin: the top margin
13336  *
13337  * Sets the top margin of @widget.
13338  * See the #GtkWidget:margin-top property.
13339  *
13340  * Since: 3.0
13341  */
13342 void
13343 gtk_widget_set_margin_top (GtkWidget *widget,
13344                            gint       margin)
13345 {
13346   GtkWidgetAuxInfo *aux_info;
13347
13348   g_return_if_fail (GTK_IS_WIDGET (widget));
13349   g_return_if_fail (margin <= G_MAXINT16);
13350
13351   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13352
13353   if (aux_info->margin.top == margin)
13354     return;
13355
13356   aux_info->margin.top = margin;
13357   gtk_widget_queue_resize (widget);
13358   g_object_notify (G_OBJECT (widget), "margin-top");
13359 }
13360
13361 /**
13362  * gtk_widget_get_margin_bottom:
13363  * @widget: a #GtkWidget
13364  *
13365  * Gets the value of the #GtkWidget:margin-bottom property.
13366  *
13367  * Returns: The bottom margin of @widget
13368  *
13369  * Since: 3.0
13370  */
13371 gint
13372 gtk_widget_get_margin_bottom (GtkWidget *widget)
13373 {
13374   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13375
13376   return _gtk_widget_get_aux_info_or_defaults (widget)->margin.bottom;
13377 }
13378
13379 /**
13380  * gtk_widget_set_margin_bottom:
13381  * @widget: a #GtkWidget
13382  * @margin: the bottom margin
13383  *
13384  * Sets the bottom margin of @widget.
13385  * See the #GtkWidget:margin-bottom property.
13386  *
13387  * Since: 3.0
13388  */
13389 void
13390 gtk_widget_set_margin_bottom (GtkWidget *widget,
13391                               gint       margin)
13392 {
13393   GtkWidgetAuxInfo *aux_info;
13394
13395   g_return_if_fail (GTK_IS_WIDGET (widget));
13396   g_return_if_fail (margin <= G_MAXINT16);
13397
13398   aux_info = gtk_widget_get_aux_info (widget, TRUE);
13399
13400   if (aux_info->margin.bottom == margin)
13401     return;
13402
13403   aux_info->margin.bottom = margin;
13404   gtk_widget_queue_resize (widget);
13405   g_object_notify (G_OBJECT (widget), "margin-bottom");
13406 }
13407
13408 /**
13409  * gtk_widget_get_clipboard:
13410  * @widget: a #GtkWidget
13411  * @selection: a #GdkAtom which identifies the clipboard
13412  *             to use. %GDK_SELECTION_CLIPBOARD gives the
13413  *             default clipboard. Another common value
13414  *             is %GDK_SELECTION_PRIMARY, which gives
13415  *             the primary X selection.
13416  *
13417  * Returns the clipboard object for the given selection to
13418  * be used with @widget. @widget must have a #GdkDisplay
13419  * associated with it, so must be attached to a toplevel
13420  * window.
13421  *
13422  * Return value: (transfer none): the appropriate clipboard object. If no
13423  *             clipboard already exists, a new one will
13424  *             be created. Once a clipboard object has
13425  *             been created, it is persistent for all time.
13426  *
13427  * Since: 2.2
13428  **/
13429 GtkClipboard *
13430 gtk_widget_get_clipboard (GtkWidget *widget, GdkAtom selection)
13431 {
13432   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13433   g_return_val_if_fail (gtk_widget_has_screen (widget), NULL);
13434
13435   return gtk_clipboard_get_for_display (gtk_widget_get_display (widget),
13436                                         selection);
13437 }
13438
13439 /**
13440  * gtk_widget_list_mnemonic_labels:
13441  * @widget: a #GtkWidget
13442  *
13443  * Returns a newly allocated list of the widgets, normally labels, for
13444  * which this widget is the target of a mnemonic (see for example,
13445  * gtk_label_set_mnemonic_widget()).
13446
13447  * The widgets in the list are not individually referenced. If you
13448  * want to iterate through the list and perform actions involving
13449  * callbacks that might destroy the widgets, you
13450  * <emphasis>must</emphasis> call <literal>g_list_foreach (result,
13451  * (GFunc)g_object_ref, NULL)</literal> first, and then unref all the
13452  * widgets afterwards.
13453
13454  * Return value: (element-type GtkWidget) (transfer container): the list of
13455  *  mnemonic labels; free this list
13456  *  with g_list_free() when you are done with it.
13457  *
13458  * Since: 2.4
13459  **/
13460 GList *
13461 gtk_widget_list_mnemonic_labels (GtkWidget *widget)
13462 {
13463   GList *list = NULL;
13464   GSList *l;
13465
13466   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13467
13468   for (l = g_object_get_qdata (G_OBJECT (widget), quark_mnemonic_labels); l; l = l->next)
13469     list = g_list_prepend (list, l->data);
13470
13471   return list;
13472 }
13473
13474 /**
13475  * gtk_widget_add_mnemonic_label:
13476  * @widget: a #GtkWidget
13477  * @label: a #GtkWidget that acts as a mnemonic label for @widget
13478  *
13479  * Adds a widget to the list of mnemonic labels for
13480  * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
13481  * list of mnemonic labels for the widget is cleared when the
13482  * widget is destroyed, so the caller must make sure to update
13483  * its internal state at this point as well, by using a connection
13484  * to the #GtkWidget::destroy signal or a weak notifier.
13485  *
13486  * Since: 2.4
13487  **/
13488 void
13489 gtk_widget_add_mnemonic_label (GtkWidget *widget,
13490                                GtkWidget *label)
13491 {
13492   GSList *old_list, *new_list;
13493
13494   g_return_if_fail (GTK_IS_WIDGET (widget));
13495   g_return_if_fail (GTK_IS_WIDGET (label));
13496
13497   old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
13498   new_list = g_slist_prepend (old_list, label);
13499
13500   g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
13501                            new_list, (GDestroyNotify) g_slist_free);
13502 }
13503
13504 /**
13505  * gtk_widget_remove_mnemonic_label:
13506  * @widget: a #GtkWidget
13507  * @label: a #GtkWidget that was previously set as a mnemnic label for
13508  *         @widget with gtk_widget_add_mnemonic_label().
13509  *
13510  * Removes a widget from the list of mnemonic labels for
13511  * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
13512  * must have previously been added to the list with
13513  * gtk_widget_add_mnemonic_label().
13514  *
13515  * Since: 2.4
13516  **/
13517 void
13518 gtk_widget_remove_mnemonic_label (GtkWidget *widget,
13519                                   GtkWidget *label)
13520 {
13521   GSList *old_list, *new_list;
13522
13523   g_return_if_fail (GTK_IS_WIDGET (widget));
13524   g_return_if_fail (GTK_IS_WIDGET (label));
13525
13526   old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
13527   new_list = g_slist_remove (old_list, label);
13528
13529   if (new_list)
13530     g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
13531                              new_list, (GDestroyNotify) g_slist_free);
13532 }
13533
13534 /**
13535  * gtk_widget_get_no_show_all:
13536  * @widget: a #GtkWidget
13537  *
13538  * Returns the current value of the #GtkWidget:no-show-all property,
13539  * which determines whether calls to gtk_widget_show_all()
13540  * will affect this widget.
13541  *
13542  * Return value: the current value of the "no-show-all" property.
13543  *
13544  * Since: 2.4
13545  **/
13546 gboolean
13547 gtk_widget_get_no_show_all (GtkWidget *widget)
13548 {
13549   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
13550
13551   return widget->priv->no_show_all;
13552 }
13553
13554 /**
13555  * gtk_widget_set_no_show_all:
13556  * @widget: a #GtkWidget
13557  * @no_show_all: the new value for the "no-show-all" property
13558  *
13559  * Sets the #GtkWidget:no-show-all property, which determines whether
13560  * calls to gtk_widget_show_all() will affect this widget.
13561  *
13562  * This is mostly for use in constructing widget hierarchies with externally
13563  * controlled visibility, see #GtkUIManager.
13564  *
13565  * Since: 2.4
13566  **/
13567 void
13568 gtk_widget_set_no_show_all (GtkWidget *widget,
13569                             gboolean   no_show_all)
13570 {
13571   g_return_if_fail (GTK_IS_WIDGET (widget));
13572
13573   no_show_all = (no_show_all != FALSE);
13574
13575   if (widget->priv->no_show_all != no_show_all)
13576     {
13577       widget->priv->no_show_all = no_show_all;
13578
13579       g_object_notify (G_OBJECT (widget), "no-show-all");
13580     }
13581 }
13582
13583
13584 static void
13585 gtk_widget_real_set_has_tooltip (GtkWidget *widget,
13586                                  gboolean   has_tooltip,
13587                                  gboolean   force)
13588 {
13589   GtkWidgetPrivate *priv = widget->priv;
13590   gboolean priv_has_tooltip;
13591
13592   priv_has_tooltip = GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (widget),
13593                                        quark_has_tooltip));
13594
13595   if (priv_has_tooltip != has_tooltip || force)
13596     {
13597       priv_has_tooltip = has_tooltip;
13598
13599       if (priv_has_tooltip)
13600         {
13601           if (gtk_widget_get_realized (widget) && !gtk_widget_get_has_window (widget))
13602             gdk_window_set_events (priv->window,
13603                                    gdk_window_get_events (priv->window) |
13604                                    GDK_LEAVE_NOTIFY_MASK |
13605                                    GDK_POINTER_MOTION_MASK |
13606                                    GDK_POINTER_MOTION_HINT_MASK);
13607
13608           if (gtk_widget_get_has_window (widget))
13609               gtk_widget_add_events (widget,
13610                                      GDK_LEAVE_NOTIFY_MASK |
13611                                      GDK_POINTER_MOTION_MASK |
13612                                      GDK_POINTER_MOTION_HINT_MASK);
13613         }
13614
13615       g_object_set_qdata (G_OBJECT (widget), quark_has_tooltip,
13616                           GUINT_TO_POINTER (priv_has_tooltip));
13617     }
13618 }
13619
13620 /**
13621  * gtk_widget_set_tooltip_window:
13622  * @widget: a #GtkWidget
13623  * @custom_window: (allow-none): a #GtkWindow, or %NULL
13624  *
13625  * Replaces the default, usually yellow, window used for displaying
13626  * tooltips with @custom_window. GTK+ will take care of showing and
13627  * hiding @custom_window at the right moment, to behave likewise as
13628  * the default tooltip window. If @custom_window is %NULL, the default
13629  * tooltip window will be used.
13630  *
13631  * If the custom window should have the default theming it needs to
13632  * have the name "gtk-tooltip", see gtk_widget_set_name().
13633  *
13634  * Since: 2.12
13635  */
13636 void
13637 gtk_widget_set_tooltip_window (GtkWidget *widget,
13638                                GtkWindow *custom_window)
13639 {
13640   gboolean has_tooltip;
13641   gchar *tooltip_markup;
13642
13643   g_return_if_fail (GTK_IS_WIDGET (widget));
13644   g_return_if_fail (custom_window == NULL || GTK_IS_WINDOW (custom_window));
13645
13646   tooltip_markup = g_object_get_qdata (G_OBJECT (widget), quark_tooltip_markup);
13647
13648   if (custom_window)
13649     g_object_ref (custom_window);
13650
13651   g_object_set_qdata_full (G_OBJECT (widget), quark_tooltip_window,
13652                            custom_window, g_object_unref);
13653
13654   has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
13655   gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
13656
13657   if (has_tooltip && gtk_widget_get_visible (widget))
13658     gtk_widget_queue_tooltip_query (widget);
13659 }
13660
13661 /**
13662  * gtk_widget_get_tooltip_window:
13663  * @widget: a #GtkWidget
13664  *
13665  * Returns the #GtkWindow of the current tooltip. This can be the
13666  * GtkWindow created by default, or the custom tooltip window set
13667  * using gtk_widget_set_tooltip_window().
13668  *
13669  * Return value: (transfer none): The #GtkWindow of the current tooltip.
13670  *
13671  * Since: 2.12
13672  */
13673 GtkWindow *
13674 gtk_widget_get_tooltip_window (GtkWidget *widget)
13675 {
13676   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13677
13678   return g_object_get_qdata (G_OBJECT (widget), quark_tooltip_window);
13679 }
13680
13681 /**
13682  * gtk_widget_trigger_tooltip_query:
13683  * @widget: a #GtkWidget
13684  *
13685  * Triggers a tooltip query on the display where the toplevel of @widget
13686  * is located. See gtk_tooltip_trigger_tooltip_query() for more
13687  * information.
13688  *
13689  * Since: 2.12
13690  */
13691 void
13692 gtk_widget_trigger_tooltip_query (GtkWidget *widget)
13693 {
13694   gtk_tooltip_trigger_tooltip_query (gtk_widget_get_display (widget));
13695 }
13696
13697 static guint tooltip_query_id;
13698 static GSList *tooltip_query_displays;
13699
13700 static gboolean
13701 tooltip_query_idle (gpointer data)
13702 {
13703   g_slist_foreach (tooltip_query_displays, (GFunc)gtk_tooltip_trigger_tooltip_query, NULL);
13704   g_slist_foreach (tooltip_query_displays, (GFunc)g_object_unref, NULL);
13705   g_slist_free (tooltip_query_displays);
13706
13707   tooltip_query_displays = NULL;
13708   tooltip_query_id = 0;
13709
13710   return FALSE;
13711 }
13712
13713 static void
13714 gtk_widget_queue_tooltip_query (GtkWidget *widget)
13715 {
13716   GdkDisplay *display;
13717
13718   display = gtk_widget_get_display (widget);
13719
13720   if (!g_slist_find (tooltip_query_displays, display))
13721     tooltip_query_displays = g_slist_prepend (tooltip_query_displays, g_object_ref (display));
13722
13723   if (tooltip_query_id == 0)
13724     tooltip_query_id = gdk_threads_add_idle (tooltip_query_idle, NULL);
13725 }
13726
13727 /**
13728  * gtk_widget_set_tooltip_text:
13729  * @widget: a #GtkWidget
13730  * @text: (allow-none): the contents of the tooltip for @widget
13731  *
13732  * Sets @text as the contents of the tooltip. This function will take
13733  * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
13734  * handler for the #GtkWidget::query-tooltip signal.
13735  *
13736  * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
13737  *
13738  * Since: 2.12
13739  */
13740 void
13741 gtk_widget_set_tooltip_text (GtkWidget   *widget,
13742                              const gchar *text)
13743 {
13744   g_return_if_fail (GTK_IS_WIDGET (widget));
13745
13746   g_object_set (G_OBJECT (widget), "tooltip-text", text, NULL);
13747 }
13748
13749 /**
13750  * gtk_widget_get_tooltip_text:
13751  * @widget: a #GtkWidget
13752  *
13753  * Gets the contents of the tooltip for @widget.
13754  *
13755  * Return value: the tooltip text, or %NULL. You should free the
13756  *   returned string with g_free() when done.
13757  *
13758  * Since: 2.12
13759  */
13760 gchar *
13761 gtk_widget_get_tooltip_text (GtkWidget *widget)
13762 {
13763   gchar *text = NULL;
13764
13765   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13766
13767   g_object_get (G_OBJECT (widget), "tooltip-text", &text, NULL);
13768
13769   return text;
13770 }
13771
13772 /**
13773  * gtk_widget_set_tooltip_markup:
13774  * @widget: a #GtkWidget
13775  * @markup: (allow-none): the contents of the tooltip for @widget, or %NULL
13776  *
13777  * Sets @markup as the contents of the tooltip, which is marked up with
13778  *  the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
13779  *
13780  * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
13781  * and of the default handler for the #GtkWidget::query-tooltip signal.
13782  *
13783  * See also the #GtkWidget:tooltip-markup property and
13784  * gtk_tooltip_set_markup().
13785  *
13786  * Since: 2.12
13787  */
13788 void
13789 gtk_widget_set_tooltip_markup (GtkWidget   *widget,
13790                                const gchar *markup)
13791 {
13792   g_return_if_fail (GTK_IS_WIDGET (widget));
13793
13794   g_object_set (G_OBJECT (widget), "tooltip-markup", markup, NULL);
13795 }
13796
13797 /**
13798  * gtk_widget_get_tooltip_markup:
13799  * @widget: a #GtkWidget
13800  *
13801  * Gets the contents of the tooltip for @widget.
13802  *
13803  * Return value: the tooltip text, or %NULL. You should free the
13804  *   returned string with g_free() when done.
13805  *
13806  * Since: 2.12
13807  */
13808 gchar *
13809 gtk_widget_get_tooltip_markup (GtkWidget *widget)
13810 {
13811   gchar *text = NULL;
13812
13813   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
13814
13815   g_object_get (G_OBJECT (widget), "tooltip-markup", &text, NULL);
13816
13817   return text;
13818 }
13819
13820 /**
13821  * gtk_widget_set_has_tooltip:
13822  * @widget: a #GtkWidget
13823  * @has_tooltip: whether or not @widget has a tooltip.
13824  *
13825  * Sets the has-tooltip property on @widget to @has_tooltip.  See
13826  * #GtkWidget:has-tooltip for more information.
13827  *
13828  * Since: 2.12
13829  */
13830 void
13831 gtk_widget_set_has_tooltip (GtkWidget *widget,
13832                             gboolean   has_tooltip)
13833 {
13834   g_return_if_fail (GTK_IS_WIDGET (widget));
13835
13836   g_object_set (G_OBJECT (widget), "has-tooltip", has_tooltip, NULL);
13837 }
13838
13839 /**
13840  * gtk_widget_get_has_tooltip:
13841  * @widget: a #GtkWidget
13842  *
13843  * Returns the current value of the has-tooltip property.  See
13844  * #GtkWidget:has-tooltip for more information.
13845  *
13846  * Return value: current value of has-tooltip on @widget.
13847  *
13848  * Since: 2.12
13849  */
13850 gboolean
13851 gtk_widget_get_has_tooltip (GtkWidget *widget)
13852 {
13853   gboolean has_tooltip = FALSE;
13854
13855   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
13856
13857   g_object_get (G_OBJECT (widget), "has-tooltip", &has_tooltip, NULL);
13858
13859   return has_tooltip;
13860 }
13861
13862 /**
13863  * gtk_widget_get_allocation:
13864  * @widget: a #GtkWidget
13865  * @allocation: (out): a pointer to a #GtkAllocation to copy to
13866  *
13867  * Retrieves the widget's allocation.
13868  *
13869  * Note, when implementing a #GtkContainer: a widget's allocation will
13870  * be its "adjusted" allocation, that is, the widget's parent
13871  * container typically calls gtk_widget_size_allocate() with an
13872  * allocation, and that allocation is then adjusted (to handle margin
13873  * and alignment for example) before assignment to the widget.
13874  * gtk_widget_get_allocation() returns the adjusted allocation that
13875  * was actually assigned to the widget. The adjusted allocation is
13876  * guaranteed to be completely contained within the
13877  * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
13878  * is guaranteed that its children stay inside the assigned bounds,
13879  * but not that they have exactly the bounds the container assigned.
13880  * There is no way to get the original allocation assigned by
13881  * gtk_widget_size_allocate(), since it isn't stored; if a container
13882  * implementation needs that information it will have to track it itself.
13883  *
13884  * Since: 2.18
13885  */
13886 void
13887 gtk_widget_get_allocation (GtkWidget     *widget,
13888                            GtkAllocation *allocation)
13889 {
13890   GtkWidgetPrivate *priv;
13891
13892   g_return_if_fail (GTK_IS_WIDGET (widget));
13893   g_return_if_fail (allocation != NULL);
13894
13895   priv = widget->priv;
13896
13897   *allocation = priv->allocation;
13898 }
13899
13900 /**
13901  * gtk_widget_set_allocation:
13902  * @widget: a #GtkWidget
13903  * @allocation: a pointer to a #GtkAllocation to copy from
13904  *
13905  * Sets the widget's allocation.  This should not be used
13906  * directly, but from within a widget's size_allocate method.
13907  *
13908  * The allocation set should be the "adjusted" or actual
13909  * allocation. If you're implementing a #GtkContainer, you want to use
13910  * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
13911  * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
13912  * allocation inside gtk_widget_size_allocate() to create an adjusted
13913  * allocation.
13914  *
13915  * Since: 2.18
13916  */
13917 void
13918 gtk_widget_set_allocation (GtkWidget           *widget,
13919                            const GtkAllocation *allocation)
13920 {
13921   GtkWidgetPrivate *priv;
13922
13923   g_return_if_fail (GTK_IS_WIDGET (widget));
13924   g_return_if_fail (gtk_widget_get_visible (widget) || gtk_widget_is_toplevel (widget));
13925   g_return_if_fail (allocation != NULL);
13926
13927   priv = widget->priv;
13928
13929   priv->allocation = *allocation;
13930 }
13931
13932 /**
13933  * gtk_widget_get_allocated_width:
13934  * @widget: the widget to query
13935  *
13936  * Returns the width that has currently been allocated to @widget.
13937  * This function is intended to be used when implementing handlers
13938  * for the #GtkWidget::draw function.
13939  *
13940  * Returns: the width of the @widget
13941  **/
13942 int
13943 gtk_widget_get_allocated_width (GtkWidget *widget)
13944 {
13945   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13946
13947   return widget->priv->allocation.width;
13948 }
13949
13950 /**
13951  * gtk_widget_get_allocated_height:
13952  * @widget: the widget to query
13953  *
13954  * Returns the height that has currently been allocated to @widget.
13955  * This function is intended to be used when implementing handlers
13956  * for the #GtkWidget::draw function.
13957  *
13958  * Returns: the height of the @widget
13959  **/
13960 int
13961 gtk_widget_get_allocated_height (GtkWidget *widget)
13962 {
13963   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
13964
13965   return widget->priv->allocation.height;
13966 }
13967
13968 /**
13969  * gtk_widget_get_requisition:
13970  * @widget: a #GtkWidget
13971  * @requisition: (out): a pointer to a #GtkRequisition to copy to
13972  *
13973  * Retrieves the widget's requisition.
13974  *
13975  * This function should only be used by widget implementations in
13976  * order to figure whether the widget's requisition has actually
13977  * changed after some internal state change (so that they can call
13978  * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
13979  *
13980  * Normally, gtk_widget_size_request() should be used.
13981  *
13982  * Since: 2.20
13983  *
13984  * Deprecated: 3.0: The #GtkRequisition cache on the widget was
13985  * removed, If you need to cache sizes across requests and allocations,
13986  * add an explicit cache to the widget in question instead.
13987  */
13988 void
13989 gtk_widget_get_requisition (GtkWidget      *widget,
13990                             GtkRequisition *requisition)
13991 {
13992   g_return_if_fail (GTK_IS_WIDGET (widget));
13993   g_return_if_fail (requisition != NULL);
13994
13995   gtk_widget_get_preferred_size (widget, requisition, NULL);
13996 }
13997
13998 /**
13999  * gtk_widget_set_window:
14000  * @widget: a #GtkWidget
14001  * @window: (transfer full): a #GdkWindow
14002  *
14003  * Sets a widget's window. This function should only be used in a
14004  * widget's #GtkWidget::realize implementation. The %window passed is
14005  * usually either new window created with gdk_window_new(), or the
14006  * window of its parent widget as returned by
14007  * gtk_widget_get_parent_window().
14008  *
14009  * Widgets must indicate whether they will create their own #GdkWindow
14010  * by calling gtk_widget_set_has_window(). This is usually done in the
14011  * widget's init() function.
14012  *
14013  * <note><para>This function does not add any reference to @window.</para></note>
14014  *
14015  * Since: 2.18
14016  */
14017 void
14018 gtk_widget_set_window (GtkWidget *widget,
14019                        GdkWindow *window)
14020 {
14021   GtkWidgetPrivate *priv;
14022
14023   g_return_if_fail (GTK_IS_WIDGET (widget));
14024   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
14025
14026   priv = widget->priv;
14027
14028   if (priv->window != window)
14029     {
14030       priv->window = window;
14031
14032       if (gtk_widget_get_has_window (widget) && window != NULL && !gdk_window_has_native (window))
14033         gdk_window_set_opacity (window,
14034                                 priv->norender ? 0 : priv->alpha / 255.0);
14035
14036       g_object_notify (G_OBJECT (widget), "window");
14037     }
14038 }
14039
14040 /**
14041  * gtk_widget_register_window:
14042  * @widget: a #GtkWidget
14043  * @window: a #GdkWindow
14044  *
14045  * Registers a #GdkWindow with the widget and sets it up so that
14046  * the widget recieves events for it. Call gtk_widget_unregister_window()
14047  * when destroying the window.
14048  *
14049  * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
14050  * this up. This is now deprecated and you should use gtk_widget_register_window()
14051  * instead. Old code will keep working as is, although some new features like
14052  * transparency might not work perfectly.
14053  *
14054  * Since: 3.8
14055  */
14056 void
14057 gtk_widget_register_window (GtkWidget    *widget,
14058                             GdkWindow    *window)
14059 {
14060   GtkWidgetPrivate *priv;
14061   gpointer user_data;
14062
14063   g_return_if_fail (GTK_IS_WIDGET (widget));
14064   g_return_if_fail (GDK_IS_WINDOW (window));
14065
14066   gdk_window_get_user_data (window, &user_data);
14067   g_assert (user_data == NULL);
14068
14069   priv = widget->priv;
14070
14071   gdk_window_set_user_data (window, widget);
14072   priv->registered_windows = g_list_prepend (priv->registered_windows, window);
14073
14074   if (!gtk_widget_get_has_window (widget) && !gdk_window_has_native (window))
14075     gdk_window_set_opacity (window,
14076                             priv->norender_children ? 0.0 : 1.0);
14077 }
14078
14079 /**
14080  * gtk_widget_unregister_window:
14081  * @widget: a #GtkWidget
14082  * @window: a #GdkWindow
14083  *
14084  * Unregisters a #GdkWindow from the widget that was previously set up with
14085  * gtk_widget_register_window(). You need to call this when the window is
14086  * no longer used by the widget, such as when you destroy it.
14087  *
14088  * Since: 3.8
14089  */
14090 void
14091 gtk_widget_unregister_window (GtkWidget    *widget,
14092                               GdkWindow    *window)
14093 {
14094   GtkWidgetPrivate *priv;
14095   gpointer user_data;
14096
14097   g_return_if_fail (GTK_IS_WIDGET (widget));
14098   g_return_if_fail (GDK_IS_WINDOW (window));
14099
14100   priv = widget->priv;
14101
14102   gdk_window_get_user_data (window, &user_data);
14103   g_assert (user_data == widget);
14104   gdk_window_set_user_data (window, NULL);
14105   priv->registered_windows = g_list_remove (priv->registered_windows, window);
14106 }
14107
14108 /**
14109  * gtk_widget_get_window:
14110  * @widget: a #GtkWidget
14111  *
14112  * Returns the widget's window if it is realized, %NULL otherwise
14113  *
14114  * Return value: (transfer none): @widget's window.
14115  *
14116  * Since: 2.14
14117  */
14118 GdkWindow*
14119 gtk_widget_get_window (GtkWidget *widget)
14120 {
14121   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14122
14123   return widget->priv->window;
14124 }
14125
14126 /**
14127  * gtk_widget_get_support_multidevice:
14128  * @widget: a #GtkWidget
14129  *
14130  * Returns %TRUE if @widget is multiple pointer aware. See
14131  * gtk_widget_set_support_multidevice() for more information.
14132  *
14133  * Returns: %TRUE if @widget is multidevice aware.
14134  **/
14135 gboolean
14136 gtk_widget_get_support_multidevice (GtkWidget *widget)
14137 {
14138   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14139
14140   return widget->priv->multidevice;
14141 }
14142
14143 /**
14144  * gtk_widget_set_support_multidevice:
14145  * @widget: a #GtkWidget
14146  * @support_multidevice: %TRUE to support input from multiple devices.
14147  *
14148  * Enables or disables multiple pointer awareness. If this setting is %TRUE,
14149  * @widget will start receiving multiple, per device enter/leave events. Note
14150  * that if custom #GdkWindow<!-- -->s are created in #GtkWidget::realize,
14151  * gdk_window_set_support_multidevice() will have to be called manually on them.
14152  *
14153  * Since: 3.0
14154  **/
14155 void
14156 gtk_widget_set_support_multidevice (GtkWidget *widget,
14157                                     gboolean   support_multidevice)
14158 {
14159   GtkWidgetPrivate *priv;
14160
14161   g_return_if_fail (GTK_IS_WIDGET (widget));
14162
14163   priv = widget->priv;
14164   priv->multidevice = (support_multidevice == TRUE);
14165
14166   if (gtk_widget_get_realized (widget))
14167     gdk_window_set_support_multidevice (priv->window, support_multidevice);
14168 }
14169
14170 /* There are multiple alpha related sources. First of all the user can specify alpha
14171  * in gtk_widget_set_opacity, secondly we can get it from the css opacity. These two
14172  * are multiplied together to form the total alpha. Secondly, the user can specify
14173  * an opacity group for a widget, which means we must essentially handle it as having alpha.
14174  *
14175  * We handle opacity in two ways. For a windowed widget, with opacity set but no opacity
14176  * group we directly set the opacity of widget->window. This will cause gdk to properly
14177  * redirect drawing inside the window to a buffer and do OVER paint_with_alpha.
14178  *
14179  * However, if the widget is not windowed, or the user specified an opacity group for the
14180  * widget we do the opacity handling in the ::draw marshaller for the widget. A naive
14181  * implementation of this would break for windowed widgets or descendant widgets with
14182  * windows, as these would not be handled by the ::draw signal. To handle this we set
14183  * all such gdkwindows as fully transparent and then override gtk_cairo_should_draw_window()
14184  * to make the draw signal propagate to *all* child widgets/windows.
14185  *
14186  * Note: We don't make all child windows fully transparent, we stop at the first one
14187  * in each branch when propagating down the hierarchy.
14188  */
14189
14190
14191 /* This is called when priv->alpha or priv->opacity_group group changes, and should
14192  * update priv->norender and GdkWindow opacity for this widget and any children that
14193  * needs changing. It is also called whenver the parent changes, the parents
14194  * norender_children state changes, or the has_window state of the widget changes.
14195  */
14196 static void
14197 gtk_widget_propagate_alpha (GtkWidget *widget)
14198 {
14199   GtkWidgetPrivate *priv = widget->priv;
14200   GtkWidget *parent;
14201   gboolean norender, norender_children;
14202   GList *l;
14203
14204   parent = priv->parent;
14205
14206   norender =
14207     /* If this widget has an opacity group, never render it */
14208     priv->opacity_group ||
14209     /* If the parent has norender_children, propagate that here */
14210     (parent != NULL && parent->priv->norender_children);
14211
14212   /* Windowed widget children should norender if: */
14213   norender_children =
14214     /* The widget is no_window (otherwise its enought to mark it norender/alpha), and */
14215     !gtk_widget_get_has_window (widget) &&
14216      ( /* norender is set, or */
14217       norender ||
14218       /* widget has an alpha */
14219       priv->alpha != 255
14220        );
14221
14222   if (gtk_widget_get_has_window (widget))
14223     {
14224       if (priv->window != NULL && !gdk_window_has_native (priv->window))
14225         gdk_window_set_opacity (priv->window,
14226                                 norender ? 0 : priv->alpha / 255.0);
14227     }
14228   else /* !has_window */
14229     {
14230       for (l = priv->registered_windows; l != NULL; l = l->next)
14231         {
14232           GdkWindow *w = l->data;
14233           if (!gdk_window_has_native (w))
14234             gdk_window_set_opacity (w, norender_children ? 0.0 : 1.0);
14235         }
14236     }
14237
14238   priv->norender = norender;
14239   if (priv->norender_children != norender_children)
14240     {
14241       priv->norender_children = norender_children;
14242
14243       if (GTK_IS_CONTAINER (widget))
14244         gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback)gtk_widget_propagate_alpha, NULL);
14245     }
14246
14247   if (gtk_widget_get_realized (widget))
14248     gtk_widget_queue_draw (widget);
14249 }
14250
14251 static void
14252 gtk_widget_update_alpha (GtkWidget *widget)
14253 {
14254   GtkWidgetPrivate *priv;
14255   double opacity;
14256   guint8 alpha;
14257
14258   priv = widget->priv;
14259
14260   alpha = priv->user_alpha;
14261
14262   if (priv->context)
14263     {
14264       opacity =
14265         _gtk_css_number_value_get (_gtk_style_context_peek_property (priv->context,
14266                                                                      GTK_CSS_PROPERTY_OPACITY),
14267                                    100);
14268       opacity = CLAMP (opacity, 0.0, 1.0);
14269       alpha = round (priv->user_alpha * opacity);
14270     }
14271
14272   if (alpha == priv->alpha)
14273     return;
14274
14275   priv->alpha = alpha;
14276
14277   gtk_widget_propagate_alpha (widget);
14278
14279 }
14280
14281 static void
14282 gtk_widget_set_has_opacity_group  (GtkWidget *widget,
14283                                    gboolean has_opacity_group)
14284 {
14285   GtkWidgetPrivate *priv;
14286
14287   g_return_if_fail (GTK_IS_WIDGET (widget));
14288
14289   priv = widget->priv;
14290
14291   has_opacity_group = !!has_opacity_group;
14292
14293   if (priv->opacity_group == has_opacity_group)
14294     return;
14295
14296   priv->opacity_group = has_opacity_group;
14297
14298   gtk_widget_propagate_alpha (widget);
14299 }
14300
14301 /**
14302  * gtk_widget_set_opacity:
14303  * @widget: a #GtkWidget
14304  * @opacity: desired opacity, between 0 and 1
14305  *
14306  * Request the @widget to be rendered partially transparent,
14307  * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
14308  * are clamped to the [0,1] range.).
14309  * This works on both toplevel widget, and child widgets, although there
14310  * are some limitations:
14311  *
14312  * For toplevel widgets this depends on the capabilities of the windowing
14313  * system. On X11 this has any effect only on X screens with a compositing manager
14314  * running. See gtk_widget_is_composited(). On Windows it should work
14315  * always, although setting a window's opacity after the window has been
14316  * shown causes it to flicker once on Windows.
14317  *
14318  * For child widgets it doesn't work if any affected widget has a native window, or
14319  * disables double buffering.
14320  *
14321  * Since: 3.8
14322  **/
14323 void
14324 gtk_widget_set_opacity  (GtkWidget *widget,
14325                          gdouble    opacity)
14326 {
14327   GtkWidgetPrivate *priv;
14328   guint8 alpha;
14329
14330   g_return_if_fail (GTK_IS_WIDGET (widget));
14331
14332   priv = widget->priv;
14333
14334   opacity = CLAMP (opacity, 0.0, 1.0);
14335
14336   alpha = round (opacity * 255);
14337
14338   /* As a kind of hack for internal use we treat an alpha very
14339      close to 1.0 (rounds to 255) but not 1.0 as specifying that
14340      we want the opacity group behaviour wrt draw handling, but
14341      not actually an alpha value. See bug #687842 for discussions. */
14342   gtk_widget_set_has_opacity_group (widget,
14343                                     alpha == 255 && opacity != 1.0);
14344
14345   if (alpha == priv->user_alpha)
14346     return;
14347
14348   priv->user_alpha = alpha;
14349
14350   gtk_widget_update_alpha (widget);
14351
14352 }
14353
14354 /**
14355  * gtk_widget_get_opacity:
14356  * @widget: a #GtkWidget
14357  *
14358  * Fetches the requested opacity for this widget. See
14359  * gtk_widget_set_opacity().
14360  *
14361  * Return value: the requested opacity for this widget.
14362  *
14363  * Since: 3.8
14364  **/
14365 gdouble
14366 gtk_widget_get_opacity (GtkWidget *widget)
14367 {
14368   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0.0);
14369
14370   return widget->priv->alpha / 255.0;
14371 }
14372
14373 static void
14374 _gtk_widget_set_has_focus (GtkWidget *widget,
14375                            gboolean   has_focus)
14376 {
14377   widget->priv->has_focus = has_focus;
14378
14379   if (has_focus)
14380     gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_FOCUSED, FALSE);
14381   else
14382     gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_FOCUSED);
14383 }
14384
14385 /**
14386  * gtk_widget_send_focus_change:
14387  * @widget: a #GtkWidget
14388  * @event: a #GdkEvent of type GDK_FOCUS_CHANGE
14389  *
14390  * Sends the focus change @event to @widget
14391  *
14392  * This function is not meant to be used by applications. The only time it
14393  * should be used is when it is necessary for a #GtkWidget to assign focus
14394  * to a widget that is semantically owned by the first widget even though
14395  * it's not a direct child - for instance, a search entry in a floating
14396  * window similar to the quick search in #GtkTreeView.
14397  *
14398  * An example of its usage is:
14399  *
14400  * |[
14401  *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
14402  *
14403  *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
14404  *   fevent->focus_change.in = TRUE;
14405  *   fevent->focus_change.window = gtk_widget_get_window (widget);
14406  *   if (fevent->focus_change.window != NULL)
14407  *     g_object_ref (fevent->focus_change.window);
14408  *
14409  *   gtk_widget_send_focus_change (widget, fevent);
14410  *
14411  *   gdk_event_free (event);
14412  * ]|
14413  *
14414  * Return value: the return value from the event signal emission: %TRUE
14415  *   if the event was handled, and %FALSE otherwise
14416  *
14417  * Since: 2.20
14418  */
14419 gboolean
14420 gtk_widget_send_focus_change (GtkWidget *widget,
14421                               GdkEvent  *event)
14422 {
14423   gboolean res;
14424
14425   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14426   g_return_val_if_fail (event != NULL && event->type == GDK_FOCUS_CHANGE, FALSE);
14427
14428   g_object_ref (widget);
14429
14430   _gtk_widget_set_has_focus (widget, event->focus_change.in);
14431
14432   res = gtk_widget_event (widget, event);
14433
14434   g_object_notify (G_OBJECT (widget), "has-focus");
14435
14436   g_object_unref (widget);
14437
14438   return res;
14439 }
14440
14441 /**
14442  * gtk_widget_in_destruction:
14443  * @widget: a #GtkWidget
14444  *
14445  * Returns whether the widget is currently being destroyed.
14446  * This information can sometimes be used to avoid doing
14447  * unnecessary work.
14448  *
14449  * Returns: %TRUE if @widget is being destroyed
14450  */
14451 gboolean
14452 gtk_widget_in_destruction (GtkWidget *widget)
14453 {
14454   return widget->priv->in_destruction;
14455 }
14456
14457 gboolean
14458 _gtk_widget_get_in_reparent (GtkWidget *widget)
14459 {
14460   return widget->priv->in_reparent;
14461 }
14462
14463 void
14464 _gtk_widget_set_in_reparent (GtkWidget *widget,
14465                              gboolean   in_reparent)
14466 {
14467   widget->priv->in_reparent = in_reparent;
14468 }
14469
14470 gboolean
14471 _gtk_widget_get_anchored (GtkWidget *widget)
14472 {
14473   return widget->priv->anchored;
14474 }
14475
14476 void
14477 _gtk_widget_set_anchored (GtkWidget *widget,
14478                           gboolean   anchored)
14479 {
14480   widget->priv->anchored = anchored;
14481 }
14482
14483 gboolean
14484 _gtk_widget_get_shadowed (GtkWidget *widget)
14485 {
14486   return widget->priv->shadowed;
14487 }
14488
14489 void
14490 _gtk_widget_set_shadowed (GtkWidget *widget,
14491                           gboolean   shadowed)
14492 {
14493   widget->priv->shadowed = shadowed;
14494 }
14495
14496 gboolean
14497 _gtk_widget_get_alloc_needed (GtkWidget *widget)
14498 {
14499   return widget->priv->alloc_needed;
14500 }
14501
14502 void
14503 _gtk_widget_set_alloc_needed (GtkWidget *widget,
14504                               gboolean   alloc_needed)
14505 {
14506   widget->priv->alloc_needed = alloc_needed;
14507 }
14508
14509 void
14510 _gtk_widget_add_sizegroup (GtkWidget    *widget,
14511                            gpointer      group)
14512 {
14513   GSList *groups;
14514
14515   groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14516   groups = g_slist_prepend (groups, group);
14517   g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
14518
14519   widget->priv->have_size_groups = TRUE;
14520 }
14521
14522 void
14523 _gtk_widget_remove_sizegroup (GtkWidget    *widget,
14524                               gpointer      group)
14525 {
14526   GSList *groups;
14527
14528   groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14529   groups = g_slist_remove (groups, group);
14530   g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
14531
14532   widget->priv->have_size_groups = groups != NULL;
14533 }
14534
14535 GSList *
14536 _gtk_widget_get_sizegroups (GtkWidget    *widget)
14537 {
14538   if (widget->priv->have_size_groups)
14539     return g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
14540
14541   return NULL;
14542 }
14543
14544 void
14545 _gtk_widget_add_attached_window (GtkWidget    *widget,
14546                                  GtkWindow    *window)
14547 {
14548   widget->priv->attached_windows = g_list_prepend (widget->priv->attached_windows, window);
14549 }
14550
14551 void
14552 _gtk_widget_remove_attached_window (GtkWidget    *widget,
14553                                     GtkWindow    *window)
14554 {
14555   widget->priv->attached_windows = g_list_remove (widget->priv->attached_windows, window);
14556 }
14557
14558 /**
14559  * gtk_widget_path_append_for_widget:
14560  * @path: a widget path
14561  * @widget: the widget to append to the widget path
14562  *
14563  * Appends the data from @widget to the widget hierarchy represented
14564  * by @path. This function is a shortcut for adding information from
14565  * @widget to the given @path. This includes setting the name or
14566  * adding the style classes from @widget.
14567  *
14568  * Returns: the position where the data was inserted
14569  *
14570  * Since: 3.2
14571  */
14572 gint
14573 gtk_widget_path_append_for_widget (GtkWidgetPath *path,
14574                                    GtkWidget     *widget)
14575 {
14576   gint pos;
14577
14578   g_return_val_if_fail (path != NULL, 0);
14579   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
14580
14581   pos = gtk_widget_path_append_type (path, G_OBJECT_TYPE (widget));
14582
14583   if (widget->priv->name)
14584     gtk_widget_path_iter_set_name (path, pos, widget->priv->name);
14585
14586   if (widget->priv->context)
14587     {
14588       GList *classes, *l;
14589
14590       /* Also add any persistent classes in
14591        * the style context the widget path
14592        */
14593       classes = gtk_style_context_list_classes (widget->priv->context);
14594
14595       for (l = classes; l; l = l->next)
14596         gtk_widget_path_iter_add_class (path, pos, l->data);
14597
14598       g_list_free (classes);
14599     }
14600
14601   return pos;
14602 }
14603
14604 GtkWidgetPath *
14605 _gtk_widget_create_path (GtkWidget *widget)
14606 {
14607   GtkWidget *parent;
14608
14609   parent = widget->priv->parent;
14610
14611   if (parent)
14612     return gtk_container_get_path_for_child (GTK_CONTAINER (parent), widget);
14613   else
14614     {
14615       /* Widget is either toplevel or unparented, treat both
14616        * as toplevels style wise, since there are situations
14617        * where style properties might be retrieved on that
14618        * situation.
14619        */
14620       GtkWidget *attach_widget = NULL;
14621       GtkWidgetPath *result;
14622
14623       if (GTK_IS_WINDOW (widget))
14624         attach_widget = gtk_window_get_attached_to (GTK_WINDOW (widget));
14625
14626       if (attach_widget != NULL)
14627         result = gtk_widget_path_copy (gtk_widget_get_path (attach_widget));
14628       else
14629         result = gtk_widget_path_new ();
14630
14631       gtk_widget_path_append_for_widget (result, widget);
14632
14633       return result;
14634     }
14635 }
14636
14637 /**
14638  * gtk_widget_get_path:
14639  * @widget: a #GtkWidget
14640  *
14641  * Returns the #GtkWidgetPath representing @widget, if the widget
14642  * is not connected to a toplevel widget, a partial path will be
14643  * created.
14644  *
14645  * Returns: (transfer none): The #GtkWidgetPath representing @widget
14646  **/
14647 GtkWidgetPath *
14648 gtk_widget_get_path (GtkWidget *widget)
14649 {
14650   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14651
14652   if (!widget->priv->path)
14653     widget->priv->path = _gtk_widget_create_path (widget);
14654
14655   return widget->priv->path;
14656 }
14657
14658 void
14659 _gtk_widget_style_context_invalidated (GtkWidget *widget)
14660 {
14661   if (widget->priv->path)
14662     {
14663       gtk_widget_path_free (widget->priv->path);
14664       widget->priv->path = NULL;
14665     }
14666
14667   if (gtk_widget_get_realized (widget))
14668     g_signal_emit (widget, widget_signals[STYLE_UPDATED], 0);
14669   else
14670     {
14671       /* Compress all style updates so it
14672        * is only emitted once pre-realize.
14673        */
14674       widget->priv->style_update_pending = TRUE;
14675     }
14676 }
14677
14678 /**
14679  * gtk_widget_get_style_context:
14680  * @widget: a #GtkWidget
14681  *
14682  * Returns the style context associated to @widget.
14683  *
14684  * Returns: (transfer none): a #GtkStyleContext. This memory is owned by @widget and
14685  *          must not be freed.
14686  **/
14687 GtkStyleContext *
14688 gtk_widget_get_style_context (GtkWidget *widget)
14689 {
14690   GtkWidgetPrivate *priv;
14691
14692   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
14693
14694   priv = widget->priv;
14695
14696   if (G_UNLIKELY (priv->context == NULL))
14697     {
14698       GdkScreen *screen;
14699       GdkFrameClock *frame_clock;
14700
14701       priv->context = gtk_style_context_new ();
14702
14703       gtk_style_context_set_state (priv->context, priv->state_flags);
14704
14705       screen = gtk_widget_get_screen (widget);
14706       if (screen)
14707         gtk_style_context_set_screen (priv->context, screen);
14708
14709       frame_clock = gtk_widget_get_frame_clock (widget);
14710       if (frame_clock)
14711         gtk_style_context_set_frame_clock (priv->context, frame_clock);
14712
14713       if (priv->parent)
14714         gtk_style_context_set_parent (priv->context,
14715                                       gtk_widget_get_style_context (priv->parent));
14716
14717       _gtk_style_context_set_widget (priv->context, widget);
14718     }
14719
14720   return widget->priv->context;
14721 }
14722
14723 void
14724 _gtk_widget_invalidate_style_context (GtkWidget    *widget,
14725                                       GtkCssChange  change)
14726 {
14727   GtkWidgetPrivate *priv;
14728
14729   priv = widget->priv;
14730
14731   if (priv->context == NULL)
14732     return;
14733
14734   _gtk_style_context_queue_invalidate (priv->context, change);
14735 }
14736
14737 /**
14738  * gtk_widget_get_modifier_mask:
14739  * @widget: a #GtkWidget
14740  * @intent: the use case for the modifier mask
14741  *
14742  * Returns the modifier mask the @widget's windowing system backend
14743  * uses for a particular purpose.
14744  *
14745  * See gdk_keymap_get_modifier_mask().
14746  *
14747  * Returns: the modifier mask used for @intent.
14748  *
14749  * Since: 3.4
14750  **/
14751 GdkModifierType
14752 gtk_widget_get_modifier_mask (GtkWidget         *widget,
14753                               GdkModifierIntent  intent)
14754 {
14755   GdkDisplay *display;
14756
14757   g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
14758
14759   display = gtk_widget_get_display (widget);
14760
14761   return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
14762                                        intent);
14763 }
14764
14765 GtkStyle *
14766 _gtk_widget_get_style (GtkWidget *widget)
14767 {
14768   return widget->priv->style;
14769 }
14770
14771 void
14772 _gtk_widget_set_style (GtkWidget *widget,
14773                        GtkStyle  *style)
14774 {
14775   widget->priv->style = style;
14776 }
14777
14778 void
14779 _gtk_widget_update_parent_muxer (GtkWidget *widget)
14780 {
14781   GtkWidget *parent;
14782   GActionMuxer *parent_muxer;
14783
14784   if (widget->priv->muxer == NULL)
14785     return;
14786
14787   if (GTK_IS_MENU (widget))
14788     parent = gtk_menu_get_attach_widget (GTK_MENU (widget));
14789   else
14790     parent = gtk_widget_get_parent (widget);
14791
14792   parent_muxer = parent ? _gtk_widget_get_action_muxer (parent) : NULL;
14793
14794   g_action_muxer_set_parent (widget->priv->muxer, parent_muxer);
14795 }
14796
14797 GActionMuxer *
14798 _gtk_widget_get_action_muxer (GtkWidget *widget)
14799 {
14800   if (widget->priv->muxer == NULL)
14801     {
14802       widget->priv->muxer = g_action_muxer_new ();
14803       _gtk_widget_update_parent_muxer (widget);
14804     }
14805
14806   return widget->priv->muxer;
14807 }
14808
14809 /**
14810  * gtk_widget_insert_action_group:
14811  * @widget: a #GtkWidget
14812  * @name: the prefix for actions in @group
14813  * @group: a #GActionGroup
14814  *
14815  * Inserts @group into @widget. Children of @widget that implement
14816  * #GtkActionable can then be associated with actions in @group by
14817  * setting their 'action-name' to
14818  * @prefix.<replaceable>action-name</replaceable>.
14819  *
14820  * Since: 3.6
14821  */
14822 void
14823 gtk_widget_insert_action_group (GtkWidget    *widget,
14824                                 const gchar  *name,
14825                                 GActionGroup *group)
14826 {
14827   GActionMuxer *muxer;
14828
14829   g_return_if_fail (GTK_IS_WIDGET (widget));
14830   g_return_if_fail (name != NULL);
14831
14832   muxer = _gtk_widget_get_action_muxer (widget);
14833
14834   if (group)
14835     g_action_muxer_insert (muxer, name, group);
14836   else
14837     g_action_muxer_remove (muxer, name);
14838 }