Pileus Git - ~andy/gtk/blob - gtk/gtkwindow.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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gtkintl.h"
  30
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <limits.h>
  35 #include "gdk/gdk.h"
  36 #include "gdk/gdkkeysyms.h"
  37
  38 #include "gtkprivate.h"
  39 #include "gtkrc.h"
  40 #include "gtkwindow.h"
  41 #include "gtkwindowprivate.h"
  42 #include "gtkbindings.h"
  43 #include "gtkkeyhash.h"
  44 #include "gtkmain.h"
  45 #include "gtkmnemonichash.h"
  46 #include "gtkmenubar.h"
  47 #include "gtkiconfactory.h"
  48 #include "gtkicontheme.h"
  49 #include "gtkmarshalers.h"
  50 #include "gtkplug.h"
  51 #include "gtkbuildable.h"
  52 #include "gtkwidgetprivate.h"
  53
  54 #ifdef GDK_WINDOWING_X11
  55 #include "x11/gdkx.h"
  56 #endif
  57
  58 /**
  59  * SECTION:gtkwindow
  60  * @title: GtkWindow
  61  * @short_description: Toplevel which can contain other widgets
  62  *
  63  * A GtkWindow is a toplevel window which can contain other widgets.
  64  * Windows normally have decorations that are under the control
  65  * of the windowing system and allow the user to manipulate the window
  66  * (resize it, move it, close it,...).
  67  *
  68  * GTK+ also allows windows to have a resize grip (a small area in the lower
  69  * right or left corner) which can be clicked to reszie the window. To
  70  * control whether a window has a resize grip, use
  71  * gtk_window_set_has_resize_grip().
  72  *
  73  * <refsect2 id="GtkWindow-BUILDER-UI">
  74  * <title>GtkWindow as GtkBuildable</title>
  75  * <para>
  76  * The GtkWindow implementation of the GtkBuildable interface supports a
  77  * custom <tag class="starttag">accel-groups</tag> element, which supports
  78  * any number of <tag class="starttag">group</tag> elements representing the
  79  * #GtkAccelGroup objects you want to add to your window (synonymous with
  80  * gtk_window_add_accel_group().
  81  * </para>
  82  * <example>
  83  * <title>A UI definition fragment with accel groups</title>
  84  * <programlisting><![CDATA[
  85  * <object class="GtkWindow">
  86  *   <accel-groups>
  87  *     <group name="accelgroup1"/>
  88  *   </accel-groups>
  89  * </object>
  90  * <!-- -->
  91  * ...
  92  * <!-- -->
  93  * <object class="GtkAccelGroup" id="accelgroup1"/>
  94  * ]]></programlisting>
  95  * </example>
  96  * </refsect2>
  97  */
  98
  99 typedef struct _GtkDeviceGrabInfo GtkDeviceGrabInfo;
 100
 101 struct _GtkWindowPrivate
 102 {
 103   GtkMnemonicHash       *mnemonic_hash;
 104
 105   GtkWidget             *default_widget;
 106   GtkWidget             *focus_widget;
 107   GtkWindow             *transient_parent;
 108   GtkWindowGeometryInfo *geometry_info;
 109   GtkWindowGroup        *group;
 110
 111   GdkModifierType        mnemonic_modifier;
 112   GdkScreen             *screen;
 113   GdkWindow             *frame;
 114   GdkWindowTypeHint      gdk_type_hint;
 115
 116   GtkApplication        *application;
 117
 118   gdouble  opacity;
 119
 120   GdkWindow *grip_window;
 121
 122   gchar   *startup_id;
 123   gchar   *title;
 124   gchar   *wmclass_class;
 125   gchar   *wmclass_name;
 126   gchar   *wm_role;
 127
 128   guint    frame_bottom;
 129   guint    frame_left;
 130   guint    frame_right;
 131   guint    frame_top;
 132   guint    keys_changed_handler;
 133
 134   guint16  configure_request_count;
 135
 136   /* The following flags are initially TRUE (before a window is mapped).
 137    * They cause us to compute a configure request that involves
 138    * default-only parameters. Once mapped, we set them to FALSE.
 139    * Then we set them to TRUE again on unmap (for position)
 140    * and on unrealize (for size).
 141    */
 142   guint    need_default_position     : 1;
 143   guint    need_default_size         : 1;
 144
 145   guint    above_initially           : 1;
 146   guint    accept_focus              : 1;
 147   guint    below_initially           : 1;
 148   guint    builder_visible           : 1;
 149   guint    configure_notify_received : 1;
 150   guint    decorated                 : 1;
 151   guint    deletable                 : 1;
 152   guint    destroy_with_parent       : 1;
 153   guint    focus_on_map              : 1;
 154   guint    fullscreen_initially      : 1;
 155   guint    gravity                   : 5; /* GdkGravity */
 156   guint    has_focus                 : 1;
 157   guint    has_user_ref_count        : 1;
 158   guint    has_frame                 : 1;
 159   guint    has_toplevel_focus        : 1;
 160   guint    iconify_initially         : 1; /* gtk_window_iconify() called before realization */
 161   guint    is_active                 : 1;
 162   guint    maximize_initially        : 1;
 163   guint    mnemonics_visible         : 1;
 164   guint    mnemonics_visible_set     : 1;
 165   guint    modal                     : 1;
 166   guint    opacity_set               : 1;
 167   guint    position                  : 3;
 168   guint    reset_type_hint           : 1;
 169   guint    resizable                 : 1;
 170   guint    skips_pager               : 1;
 171   guint    skips_taskbar             : 1;
 172   guint    stick_initially           : 1;
 173   guint    transient_parent_group    : 1;
 174   guint    type                      : 4; /* GtkWindowType */
 175   guint    type_hint                 : 3; /* GdkWindowTypeHint if the hint is
 176                                            * one of the original eight. If not,
 177                                            * then it contains
 178                                            * GDK_WINDOW_TYPE_HINT_NORMAL
 179                                            */
 180   guint    urgent                    : 1;
 181   guint    has_resize_grip           : 1;
 182   guint    resize_grip_visible       : 1;  /* don't use, just for "resize-
 183                                             * grip-visible" notification
 184                                             */
 185
 186 };
 187
 188 enum {
 189   SET_FOCUS,
 190   FRAME_EVENT,
 191   ACTIVATE_FOCUS,
 192   ACTIVATE_DEFAULT,
 193   KEYS_CHANGED,
 194   LAST_SIGNAL
 195 };
 196
 197 enum {
 198   PROP_0,
 199
 200   /* Construct */
 201   PROP_TYPE,
 202
 203   /* Normal Props */
 204   PROP_TITLE,
 205   PROP_ROLE,
 206   PROP_RESIZABLE,
 207   PROP_MODAL,
 208   PROP_WIN_POS,
 209   PROP_DEFAULT_WIDTH,
 210   PROP_DEFAULT_HEIGHT,
 211   PROP_DESTROY_WITH_PARENT,
 212   PROP_ICON,
 213   PROP_ICON_NAME,
 214   PROP_SCREEN,
 215   PROP_TYPE_HINT,
 216   PROP_SKIP_TASKBAR_HINT,
 217   PROP_SKIP_PAGER_HINT,
 218   PROP_URGENCY_HINT,
 219   PROP_ACCEPT_FOCUS,
 220   PROP_FOCUS_ON_MAP,
 221   PROP_DECORATED,
 222   PROP_DELETABLE,
 223   PROP_GRAVITY,
 224   PROP_TRANSIENT_FOR,
 225   PROP_OPACITY,
 226   PROP_HAS_RESIZE_GRIP,
 227   PROP_RESIZE_GRIP_VISIBLE,
 228   PROP_APPLICATION,
 229   /* Readonly properties */
 230   PROP_IS_ACTIVE,
 231   PROP_HAS_TOPLEVEL_FOCUS,
 232
 233   /* Writeonly properties */
 234   PROP_STARTUP_ID,
 235
 236   PROP_MNEMONICS_VISIBLE,
 237
 238   LAST_ARG
 239 };
 240
 241 typedef struct
 242 {
 243   GList     *icon_list;
 244   gchar     *icon_name;
 245   guint      realized : 1;
 246   guint      using_default_icon : 1;
 247   guint      using_parent_icon : 1;
 248   guint      using_themed_icon : 1;
 249 } GtkWindowIconInfo;
 250
 251 typedef struct {
 252   GdkGeometry    geometry; /* Last set of geometry hints we set */
 253   GdkWindowHints flags;
 254   GdkRectangle   configure_request;
 255 } GtkWindowLastGeometryInfo;
 256
 257 struct _GtkWindowGeometryInfo
 258 {
 259   /* Properties that the app has set on the window
 260    */
 261   GdkGeometry    geometry;      /* Geometry hints */
 262   GdkWindowHints mask;
 263   GtkWidget     *widget;        /* subwidget to which hints apply */
 264   /* from last gtk_window_resize () - if > 0, indicates that
 265    * we should resize to this size.
 266    */
 267   gint           resize_width;
 268   gint           resize_height;
 269
 270   /* From last gtk_window_move () prior to mapping -
 271    * only used if initial_pos_set
 272    */
 273   gint           initial_x;
 274   gint           initial_y;
 275
 276   /* Default size - used only the FIRST time we map a window,
 277    * only if > 0.
 278    */
 279   gint           default_width;
 280   gint           default_height;
 281   /* whether to use initial_x, initial_y */
 282   guint          initial_pos_set : 1;
 283   /* CENTER_ALWAYS or other position constraint changed since
 284    * we sent the last configure request.
 285    */
 286   guint          position_constraints_changed : 1;
 287
 288   /* if true, default_width, height should be multiplied by the
 289    * increments and affect the geometry widget only
 290    */
 291   guint          default_is_geometry : 1;
 292
 293   /* if true, resize_width, height should be multiplied by the
 294    * increments and affect the geometry widget only
 295    */
 296   guint          resize_is_geometry : 1;
 297
 298   GtkWindowLastGeometryInfo last;
 299 };
 300
 301
 302 struct _GtkDeviceGrabInfo
 303 {
 304   GtkWidget *widget;
 305   GdkDevice *device;
 306   guint block_others : 1;
 307 };
 308
 309 struct _GtkWindowGroupPrivate
 310 {
 311   GSList *grabs;
 312   GSList *device_grabs;
 313 };
 314
 315 static void gtk_window_dispose            (GObject           *object);
 316 static void gtk_window_finalize           (GObject           *object);
 317 static void gtk_window_destroy            (GtkWidget         *widget);
 318 static void gtk_window_show               (GtkWidget         *widget);
 319 static void gtk_window_hide               (GtkWidget         *widget);
 320 static void gtk_window_map                (GtkWidget         *widget);
 321 static void gtk_window_unmap              (GtkWidget         *widget);
 322 static void gtk_window_realize            (GtkWidget         *widget);
 323 static void gtk_window_unrealize          (GtkWidget         *widget);
 324 static void gtk_window_size_allocate      (GtkWidget         *widget,
 325                                            GtkAllocation     *allocation);
 326 static gint gtk_window_event              (GtkWidget *widget,
 327                                            GdkEvent *event);
 328 static gboolean gtk_window_map_event      (GtkWidget         *widget,
 329                                            GdkEventAny       *event);
 330 static gboolean gtk_window_frame_event    (GtkWindow *window,
 331                                            GdkEvent *event);
 332 static gint gtk_window_configure_event    (GtkWidget         *widget,
 333                                            GdkEventConfigure *event);
 334 static gint gtk_window_key_press_event    (GtkWidget         *widget,
 335                                            GdkEventKey       *event);
 336 static gint gtk_window_key_release_event  (GtkWidget         *widget,
 337                                            GdkEventKey       *event);
 338 static gint gtk_window_button_press_event (GtkWidget         *widget,
 339                                            GdkEventButton    *event);
 340 static gint gtk_window_enter_notify_event (GtkWidget         *widget,
 341                                            GdkEventCrossing  *event);
 342 static gint gtk_window_leave_notify_event (GtkWidget         *widget,
 343                                            GdkEventCrossing  *event);
 344 static gint gtk_window_focus_in_event     (GtkWidget         *widget,
 345                                            GdkEventFocus     *event);
 346 static gint gtk_window_focus_out_event    (GtkWidget         *widget,
 347                                            GdkEventFocus     *event);
 348 static void gtk_window_style_updated      (GtkWidget         *widget);
 349 static gint gtk_window_client_event       (GtkWidget         *widget,
 350                                            GdkEventClient    *event);
 351 static gboolean gtk_window_state_event    (GtkWidget          *widget,
 352                                            GdkEventWindowState *event);
 353 static void gtk_window_check_resize       (GtkContainer      *container);
 354 static gint gtk_window_focus              (GtkWidget        *widget,
 355                                            GtkDirectionType  direction);
 356 static void gtk_window_move_focus         (GtkWidget         *widget,
 357                                            GtkDirectionType   dir);
 358 static void gtk_window_real_set_focus     (GtkWindow         *window,
 359                                            GtkWidget         *focus);
 360 static void gtk_window_direction_changed  (GtkWidget         *widget,
 361                                            GtkTextDirection   prev_dir);
 362 static void gtk_window_state_changed      (GtkWidget         *widget,
 363                                            GtkStateType       previous_state);
 364
 365 static void gtk_window_real_activate_default (GtkWindow         *window);
 366 static void gtk_window_real_activate_focus   (GtkWindow         *window);
 367 static void gtk_window_keys_changed          (GtkWindow         *window);
 368 static gint gtk_window_draw                  (GtkWidget         *widget,
 369                                               cairo_t           *cr);
 370 static void gtk_window_unset_transient_for         (GtkWindow  *window);
 371 static void gtk_window_transient_parent_realized   (GtkWidget  *parent,
 372                                                     GtkWidget  *window);
 373 static void gtk_window_transient_parent_unrealized (GtkWidget  *parent,
 374                                                     GtkWidget  *window);
 375
 376 static GdkScreen *gtk_window_check_screen (GtkWindow *window);
 377
 378 static GtkWindowGeometryInfo* gtk_window_get_geometry_info         (GtkWindow    *window,
 379                                                                     gboolean      create);
 380
 381 static void     gtk_window_move_resize               (GtkWindow    *window);
 382 static gboolean gtk_window_compare_hints             (GdkGeometry  *geometry_a,
 383                                                       guint         flags_a,
 384                                                       GdkGeometry  *geometry_b,
 385                                                       guint         flags_b);
 386 static void     gtk_window_constrain_size            (GtkWindow    *window,
 387                                                       GdkGeometry  *geometry,
 388                                                       guint         flags,
 389                                                       gint          width,
 390                                                       gint          height,
 391                                                       gint         *new_width,
 392                                                       gint         *new_height);
 393 static void     gtk_window_constrain_position        (GtkWindow    *window,
 394                                                       gint          new_width,
 395                                                       gint          new_height,
 396                                                       gint         *x,
 397                                                       gint         *y);
 398 static void     gtk_window_compute_hints             (GtkWindow    *window,
 399                                                       GdkGeometry  *new_geometry,
 400                                                       guint        *new_flags);
 401 static void     gtk_window_compute_configure_request (GtkWindow    *window,
 402                                                       GdkRectangle *request,
 403                                                       GdkGeometry  *geometry,
 404                                                       guint        *flags);
 405
 406 static void     gtk_window_set_default_size_internal (GtkWindow    *window,
 407                                                       gboolean      change_width,
 408                                                       gint          width,
 409                                                       gboolean      change_height,
 410                                                       gint          height,
 411                                                       gboolean      is_geometry);
 412
 413 static void     update_themed_icon                    (GtkIconTheme *theme,
 414                                                        GtkWindow    *window);
 415 static GList   *icon_list_from_theme                  (GtkWidget    *widget,
 416                                                        const gchar  *name);
 417 static void     gtk_window_realize_icon               (GtkWindow    *window);
 418 static void     gtk_window_unrealize_icon             (GtkWindow    *window);
 419 static void     resize_grip_create_window             (GtkWindow    *window);
 420 static void     resize_grip_destroy_window            (GtkWindow    *window);
 421 static void     update_grip_visibility                (GtkWindow    *window);
 422
 423 static void        gtk_window_notify_keys_changed (GtkWindow   *window);
 424 static GtkKeyHash *gtk_window_get_key_hash        (GtkWindow   *window);
 425 static void        gtk_window_free_key_hash       (GtkWindow   *window);
 426 static void        gtk_window_on_composited_changed (GdkScreen *screen,
 427                                                      GtkWindow *window);
 428
 429 static GSList      *toplevel_list = NULL;
 430 static guint        window_signals[LAST_SIGNAL] = { 0 };
 431 static GList       *default_icon_list = NULL;
 432 static gchar       *default_icon_name = NULL;
 433 static guint        default_icon_serial = 0;
 434 static gboolean     disable_startup_notification = FALSE;
 435 static gboolean     sent_startup_notification = FALSE;
 436
 437 static GQuark       quark_gtk_embedded = 0;
 438 static GQuark       quark_gtk_window_key_hash = 0;
 439 static GQuark       quark_gtk_window_icon_info = 0;
 440 static GQuark       quark_gtk_buildable_accels = 0;
 441
 442 static GtkBuildableIface *parent_buildable_iface;
 443
 444 static void gtk_window_set_property (GObject         *object,
 445                                      guint            prop_id,
 446                                      const GValue    *value,
 447                                      GParamSpec      *pspec);
 448 static void gtk_window_get_property (GObject         *object,
 449                                      guint            prop_id,
 450                                      GValue          *value,
 451                                      GParamSpec      *pspec);
 452
 453 /* GtkBuildable */
 454 static void gtk_window_buildable_interface_init  (GtkBuildableIface *iface);
 455 static void gtk_window_buildable_set_buildable_property (GtkBuildable        *buildable,
 456                                                          GtkBuilder          *builder,
 457                                                          const gchar         *name,
 458                                                          const GValue        *value);
 459 static void gtk_window_buildable_parser_finished (GtkBuildable     *buildable,
 460                                                   GtkBuilder       *builder);
 461 static gboolean gtk_window_buildable_custom_tag_start (GtkBuildable  *buildable,
 462                                                        GtkBuilder    *builder,
 463                                                        GObject       *child,
 464                                                        const gchar   *tagname,
 465                                                        GMarkupParser *parser,
 466                                                        gpointer      *data);
 467 static void gtk_window_buildable_custom_finished (GtkBuildable  *buildable,
 468                                                       GtkBuilder    *builder,
 469                                                       GObject       *child,
 470                                                       const gchar   *tagname,
 471                                                       gpointer       user_data);
 472
 473
 474 static void gtk_window_get_preferred_width    (GtkWidget           *widget,
 475                                                gint                *minimum_size,
 476                                                gint                *natural_size);
 477 static void gtk_window_get_preferred_height   (GtkWidget           *widget,
 478                                                gint                *minimum_size,
 479                                                gint                *natural_size);
 480
 481 G_DEFINE_TYPE_WITH_CODE (GtkWindow, gtk_window, GTK_TYPE_BIN,
 482                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 483                                                 gtk_window_buildable_interface_init))
 484
 485 static void
 486 add_tab_bindings (GtkBindingSet    *binding_set,
 487                   GdkModifierType   modifiers,
 488                   GtkDirectionType  direction)
 489 {
 490   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Tab, modifiers,
 491                                 "move-focus", 1,
 492                                 GTK_TYPE_DIRECTION_TYPE, direction);
 493   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, modifiers,
 494                                 "move-focus", 1,
 495                                 GTK_TYPE_DIRECTION_TYPE, direction);
 496 }
 497
 498 static void
 499 add_arrow_bindings (GtkBindingSet    *binding_set,
 500                     guint             keysym,
 501                     GtkDirectionType  direction)
 502 {
 503   guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
 504
 505   gtk_binding_entry_add_signal (binding_set, keysym, 0,
 506                                 "move-focus", 1,
 507                                 GTK_TYPE_DIRECTION_TYPE, direction);
 508   gtk_binding_entry_add_signal (binding_set, keysym, GDK_CONTROL_MASK,
 509                                 "move-focus", 1,
 510                                 GTK_TYPE_DIRECTION_TYPE, direction);
 511   gtk_binding_entry_add_signal (binding_set, keypad_keysym, 0,
 512                                 "move-focus", 1,
 513                                 GTK_TYPE_DIRECTION_TYPE, direction);
 514   gtk_binding_entry_add_signal (binding_set, keypad_keysym, GDK_CONTROL_MASK,
 515                                 "move-focus", 1,
 516                                 GTK_TYPE_DIRECTION_TYPE, direction);
 517 }
 518
 519 static guint32
 520 extract_time_from_startup_id (const gchar* startup_id)
 521 {
 522   gchar *timestr = g_strrstr (startup_id, "_TIME");
 523   guint32 retval = GDK_CURRENT_TIME;
 524
 525   if (timestr)
 526     {
 527       gchar *end;
 528       guint32 timestamp;
 529
 530       /* Skip past the "_TIME" part */
 531       timestr += 5;
 532
 533       end = NULL;
 534       errno = 0;
 535       timestamp = g_ascii_strtoull (timestr, &end, 0);
 536       if (errno == 0 && end != timestr)
 537         retval = timestamp;
 538     }
 539
 540   return retval;
 541 }
 542
 543 static gboolean
 544 startup_id_is_fake (const gchar* startup_id)
 545 {
 546   return strncmp (startup_id, "_TIME", 5) == 0;
 547 }
 548
 549 static void
 550 gtk_window_class_init (GtkWindowClass *klass)
 551 {
 552   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 553   GtkWidgetClass *widget_class;
 554   GtkContainerClass *container_class;
 555   GtkBindingSet *binding_set;
 556
 557   widget_class = (GtkWidgetClass*) klass;
 558   container_class = (GtkContainerClass*) klass;
 559
 560   quark_gtk_embedded = g_quark_from_static_string ("gtk-embedded");
 561   quark_gtk_window_key_hash = g_quark_from_static_string ("gtk-window-key-hash");
 562   quark_gtk_window_icon_info = g_quark_from_static_string ("gtk-window-icon-info");
 563   quark_gtk_buildable_accels = g_quark_from_static_string ("gtk-window-buildable-accels");
 564
 565   gobject_class->dispose = gtk_window_dispose;
 566   gobject_class->finalize = gtk_window_finalize;
 567
 568   gobject_class->set_property = gtk_window_set_property;
 569   gobject_class->get_property = gtk_window_get_property;
 570
 571   widget_class->destroy = gtk_window_destroy;
 572   widget_class->show = gtk_window_show;
 573   widget_class->hide = gtk_window_hide;
 574   widget_class->map = gtk_window_map;
 575   widget_class->map_event = gtk_window_map_event;
 576   widget_class->unmap = gtk_window_unmap;
 577   widget_class->realize = gtk_window_realize;
 578   widget_class->unrealize = gtk_window_unrealize;
 579   widget_class->size_allocate = gtk_window_size_allocate;
 580   widget_class->configure_event = gtk_window_configure_event;
 581   widget_class->key_press_event = gtk_window_key_press_event;
 582   widget_class->key_release_event = gtk_window_key_release_event;
 583   widget_class->enter_notify_event = gtk_window_enter_notify_event;
 584   widget_class->leave_notify_event = gtk_window_leave_notify_event;
 585   widget_class->focus_in_event = gtk_window_focus_in_event;
 586   widget_class->button_press_event = gtk_window_button_press_event;
 587   widget_class->focus_out_event = gtk_window_focus_out_event;
 588   widget_class->client_event = gtk_window_client_event;
 589   widget_class->focus = gtk_window_focus;
 590   widget_class->move_focus = gtk_window_move_focus;
 591   widget_class->draw = gtk_window_draw;
 592   widget_class->get_preferred_width = gtk_window_get_preferred_width;
 593   widget_class->get_preferred_height = gtk_window_get_preferred_height;
 594   widget_class->window_state_event = gtk_window_state_event;
 595   widget_class->direction_changed = gtk_window_direction_changed;
 596   widget_class->state_changed = gtk_window_state_changed;
 597   widget_class->style_updated = gtk_window_style_updated;
 598
 599   container_class->check_resize = gtk_window_check_resize;
 600
 601   klass->set_focus = gtk_window_real_set_focus;
 602   klass->frame_event = gtk_window_frame_event;
 603
 604   klass->activate_default = gtk_window_real_activate_default;
 605   klass->activate_focus = gtk_window_real_activate_focus;
 606   klass->keys_changed = gtk_window_keys_changed;
 607
 608   g_type_class_add_private (gobject_class, sizeof (GtkWindowPrivate));
 609
 610   /* Construct */
 611   g_object_class_install_property (gobject_class,
 612                                    PROP_TYPE,
 613                                    g_param_spec_enum ("type",
 614                                                       P_("Window Type"),
 615                                                       P_("The type of the window"),
 616                                                       GTK_TYPE_WINDOW_TYPE,
 617                                                       GTK_WINDOW_TOPLEVEL,
 618                                                       GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 619   /* Regular Props */
 620   g_object_class_install_property (gobject_class,
 621                                    PROP_TITLE,
 622                                    g_param_spec_string ("title",
 623                                                         P_("Window Title"),
 624                                                         P_("The title of the window"),
 625                                                         NULL,
 626                                                         GTK_PARAM_READWRITE));
 627
 628   g_object_class_install_property (gobject_class,
 629                                    PROP_ROLE,
 630                                    g_param_spec_string ("role",
 631                                                         P_("Window Role"),
 632                                                         P_("Unique identifier for the window to be used when restoring a session"),
 633                                                         NULL,
 634                                                         GTK_PARAM_READWRITE));
 635
 636   /**
 637    * GtkWindow:startup-id:
 638    *
 639    * The :startup-id is a write-only property for setting window's
 640    * startup notification identifier. See gtk_window_set_startup_id()
 641    * for more details.
 642    *
 643    * Since: 2.12
 644    */
 645   g_object_class_install_property (gobject_class,
 646                                    PROP_STARTUP_ID,
 647                                    g_param_spec_string ("startup-id",
 648                                                         P_("Startup ID"),
 649                                                         P_("Unique startup identifier for the window used by startup-notification"),
 650                                                         NULL,
 651                                                         GTK_PARAM_WRITABLE));
 652
 653   g_object_class_install_property (gobject_class,
 654                                    PROP_RESIZABLE,
 655                                    g_param_spec_boolean ("resizable",
 656                                                          P_("Resizable"),
 657                                                          P_("If TRUE, users can resize the window"),
 658                                                          TRUE,
 659                                                          GTK_PARAM_READWRITE));
 660
 661   g_object_class_install_property (gobject_class,
 662                                    PROP_MODAL,
 663                                    g_param_spec_boolean ("modal",
 664                                                          P_("Modal"),
 665                                                          P_("If TRUE, the window is modal (other windows are not usable while this one is up)"),
 666                                                          FALSE,
 667                                                          GTK_PARAM_READWRITE));
 668
 669   g_object_class_install_property (gobject_class,
 670                                    PROP_WIN_POS,
 671                                    g_param_spec_enum ("window-position",
 672                                                       P_("Window Position"),
 673                                                       P_("The initial position of the window"),
 674                                                       GTK_TYPE_WINDOW_POSITION,
 675                                                       GTK_WIN_POS_NONE,
 676                                                       GTK_PARAM_READWRITE));
 677
 678   g_object_class_install_property (gobject_class,
 679                                    PROP_DEFAULT_WIDTH,
 680                                    g_param_spec_int ("default-width",
 681                                                      P_("Default Width"),
 682                                                      P_("The default width of the window, used when initially showing the window"),
 683                                                      -1,
 684                                                      G_MAXINT,
 685                                                      -1,
 686                                                      GTK_PARAM_READWRITE));
 687
 688   g_object_class_install_property (gobject_class,
 689                                    PROP_DEFAULT_HEIGHT,
 690                                    g_param_spec_int ("default-height",
 691                                                      P_("Default Height"),
 692                                                      P_("The default height of the window, used when initially showing the window"),
 693                                                      -1,
 694                                                      G_MAXINT,
 695                                                      -1,
 696                                                      GTK_PARAM_READWRITE));
 697
 698   g_object_class_install_property (gobject_class,
 699                                    PROP_DESTROY_WITH_PARENT,
 700                                    g_param_spec_boolean ("destroy-with-parent",
 701                                                          P_("Destroy with Parent"),
 702                                                          P_("If this window should be destroyed when the parent is destroyed"),
 703                                                          FALSE,
 704                                                          GTK_PARAM_READWRITE));
 705
 706   g_object_class_install_property (gobject_class,
 707                                    PROP_ICON,
 708                                    g_param_spec_object ("icon",
 709                                                         P_("Icon"),
 710                                                         P_("Icon for this window"),
 711                                                         GDK_TYPE_PIXBUF,
 712                                                         GTK_PARAM_READWRITE));
 713   g_object_class_install_property (gobject_class,
 714                                    PROP_MNEMONICS_VISIBLE,
 715                                    g_param_spec_boolean ("mnemonics-visible",
 716                                                          P_("Mnemonics Visible"),
 717                                                          P_("Whether mnemonics are currently visible in this window"),
 718                                                          TRUE,
 719                                                          GTK_PARAM_READWRITE));
 720
 721   /**
 722    * GtkWindow:icon-name:
 723    *
 724    * The :icon-name property specifies the name of the themed icon to
 725    * use as the window icon. See #GtkIconTheme for more details.
 726    *
 727    * Since: 2.6
 728    */
 729   g_object_class_install_property (gobject_class,
 730                                    PROP_ICON_NAME,
 731                                    g_param_spec_string ("icon-name",
 732                                                         P_("Icon Name"),
 733                                                         P_("Name of the themed icon for this window"),
 734                                                         NULL,
 735                                                         GTK_PARAM_READWRITE));
 736
 737   g_object_class_install_property (gobject_class,
 738                                    PROP_SCREEN,
 739                                    g_param_spec_object ("screen",
 740                                                         P_("Screen"),
 741                                                         P_("The screen where this window will be displayed"),
 742                                                         GDK_TYPE_SCREEN,
 743                                                         GTK_PARAM_READWRITE));
 744
 745   g_object_class_install_property (gobject_class,
 746                                    PROP_IS_ACTIVE,
 747                                    g_param_spec_boolean ("is-active",
 748                                                          P_("Is Active"),
 749                                                          P_("Whether the toplevel is the current active window"),
 750                                                          FALSE,
 751                                                          GTK_PARAM_READABLE));
 752
 753   g_object_class_install_property (gobject_class,
 754                                    PROP_HAS_TOPLEVEL_FOCUS,
 755                                    g_param_spec_boolean ("has-toplevel-focus",
 756                                                          P_("Focus in Toplevel"),
 757                                                          P_("Whether the input focus is within this GtkWindow"),
 758                                                          FALSE,
 759                                                          GTK_PARAM_READABLE));
 760
 761   g_object_class_install_property (gobject_class,
 762                                    PROP_TYPE_HINT,
 763                                    g_param_spec_enum ("type-hint",
 764                                                       P_("Type hint"),
 765                                                       P_("Hint to help the desktop environment understand what kind of window this is and how to treat it."),
 766                                                       GDK_TYPE_WINDOW_TYPE_HINT,
 767                                                       GDK_WINDOW_TYPE_HINT_NORMAL,
 768                                                       GTK_PARAM_READWRITE));
 769
 770   g_object_class_install_property (gobject_class,
 771                                    PROP_SKIP_TASKBAR_HINT,
 772                                    g_param_spec_boolean ("skip-taskbar-hint",
 773                                                          P_("Skip taskbar"),
 774                                                          P_("TRUE if the window should not be in the task bar."),
 775                                                          FALSE,
 776                                                          GTK_PARAM_READWRITE));
 777
 778   g_object_class_install_property (gobject_class,
 779                                    PROP_SKIP_PAGER_HINT,
 780                                    g_param_spec_boolean ("skip-pager-hint",
 781                                                          P_("Skip pager"),
 782                                                          P_("TRUE if the window should not be in the pager."),
 783                                                          FALSE,
 784                                                          GTK_PARAM_READWRITE));
 785
 786   g_object_class_install_property (gobject_class,
 787                                    PROP_URGENCY_HINT,
 788                                    g_param_spec_boolean ("urgency-hint",
 789                                                          P_("Urgent"),
 790                                                          P_("TRUE if the window should be brought to the user's attention."),
 791                                                          FALSE,
 792                                                          GTK_PARAM_READWRITE));
 793
 794   /**
 795    * GtkWindow:accept-focus:
 796    *
 797    * Whether the window should receive the input focus.
 798    *
 799    * Since: 2.4
 800    */
 801   g_object_class_install_property (gobject_class,
 802                                    PROP_ACCEPT_FOCUS,
 803                                    g_param_spec_boolean ("accept-focus",
 804                                                          P_("Accept focus"),
 805                                                          P_("TRUE if the window should receive the input focus."),
 806                                                          TRUE,
 807                                                          GTK_PARAM_READWRITE));
 808
 809   /**
 810    * GtkWindow:focus-on-map:
 811    *
 812    * Whether the window should receive the input focus when mapped.
 813    *
 814    * Since: 2.6
 815    */
 816   g_object_class_install_property (gobject_class,
 817                                    PROP_FOCUS_ON_MAP,
 818                                    g_param_spec_boolean ("focus-on-map",
 819                                                          P_("Focus on map"),
 820                                                          P_("TRUE if the window should receive the input focus when mapped."),
 821                                                          TRUE,
 822                                                          GTK_PARAM_READWRITE));
 823
 824   /**
 825    * GtkWindow:decorated:
 826    *
 827    * Whether the window should be decorated by the window manager.
 828    *
 829    * Since: 2.4
 830    */
 831   g_object_class_install_property (gobject_class,
 832                                    PROP_DECORATED,
 833                                    g_param_spec_boolean ("decorated",
 834                                                          P_("Decorated"),
 835                                                          P_("Whether the window should be decorated by the window manager"),
 836                                                          TRUE,
 837                                                          GTK_PARAM_READWRITE));
 838
 839   /**
 840    * GtkWindow:deletable:
 841    *
 842    * Whether the window frame should have a close button.
 843    *
 844    * Since: 2.10
 845    */
 846   g_object_class_install_property (gobject_class,
 847                                    PROP_DELETABLE,
 848                                    g_param_spec_boolean ("deletable",
 849                                                          P_("Deletable"),
 850                                                          P_("Whether the window frame should have a close button"),
 851                                                          TRUE,
 852                                                          GTK_PARAM_READWRITE));
 853
 854   /**
 855    * GtkWindow:has-resize-grip
 856    *
 857    * Whether the window has a corner resize grip.
 858    *
 859    * Note that the resize grip is only shown if the window is
 860    * actually resizable and not maximized. Use
 861    * #GtkWindow:resize-grip-visible to find out if the resize
 862    * grip is currently shown.
 863    *
 864    * Since: 3.0
 865    */
 866   g_object_class_install_property (gobject_class,
 867                                    PROP_HAS_RESIZE_GRIP,
 868                                    g_param_spec_boolean ("has-resize-grip",
 869                                                          P_("Resize grip"),
 870                                                          P_("Specifies whether the window should have a resize grip"),
 871                                                          TRUE,
 872                                                          GTK_PARAM_READWRITE));
 873
 874   /**
 875    * GtkWindow: resize-grip-visible:
 876    *
 877    * Whether a corner resize grip is currently shown.
 878    *
 879    * Since: 3.0
 880    */
 881   g_object_class_install_property (gobject_class,
 882                                    PROP_RESIZE_GRIP_VISIBLE,
 883                                    g_param_spec_boolean ("resize-grip-visible",
 884                                                          P_("Resize grip is visible"),
 885                                                          P_("Specifies whether the window's resize grip is visible."),
 886                                                          FALSE,
 887                                                          GTK_PARAM_READABLE));
 888
 889
 890   /**
 891    * GtkWindow:gravity:
 892    *
 893    * The window gravity of the window. See gtk_window_move() and #GdkGravity for
 894    * more details about window gravity.
 895    *
 896    * Since: 2.4
 897    */
 898   g_object_class_install_property (gobject_class,
 899                                    PROP_GRAVITY,
 900                                    g_param_spec_enum ("gravity",
 901                                                       P_("Gravity"),
 902                                                       P_("The window gravity of the window"),
 903                                                       GDK_TYPE_GRAVITY,
 904                                                       GDK_GRAVITY_NORTH_WEST,
 905                                                       GTK_PARAM_READWRITE));
 906
 907
 908   /**
 909    * GtkWindow:transient-for:
 910    *
 911    * The transient parent of the window. See gtk_window_set_transient_for() for
 912    * more details about transient windows.
 913    *
 914    * Since: 2.10
 915    */
 916   g_object_class_install_property (gobject_class,
 917                                    PROP_TRANSIENT_FOR,
 918                                    g_param_spec_object ("transient-for",
 919                                                         P_("Transient for Window"),
 920                                                         P_("The transient parent of the dialog"),
 921                                                         GTK_TYPE_WINDOW,
 922                                                         GTK_PARAM_READWRITE| G_PARAM_CONSTRUCT));
 923
 924   /**
 925    * GtkWindow:opacity:
 926    *
 927    * The requested opacity of the window. See gtk_window_set_opacity() for
 928    * more details about window opacity.
 929    *
 930    * Since: 2.12
 931    */
 932   g_object_class_install_property (gobject_class,
 933                                    PROP_OPACITY,
 934                                    g_param_spec_double ("opacity",
 935                                                         P_("Opacity for Window"),
 936                                                         P_("The opacity of the window, from 0 to 1"),
 937                                                         0.0,
 938                                                         1.0,
 939                                                         1.0,
 940                                                         GTK_PARAM_READWRITE));
 941
 942   /* Style properties.
 943    */
 944   gtk_widget_class_install_style_property (widget_class,
 945                                            g_param_spec_int ("resize-grip-width",
 946                                                              P_("Width of resize grip"),
 947                                                              P_("Width of resize grip"),
 948                                                              0, G_MAXINT, 16, GTK_PARAM_READWRITE));
 949
 950   gtk_widget_class_install_style_property (widget_class,
 951                                            g_param_spec_int ("resize-grip-height",
 952                                                              P_("Height of resize grip"),
 953                                                              P_("Height of resize grip"),
 954                                                              0, G_MAXINT, 16, GTK_PARAM_READWRITE));
 955
 956
 957   /* Signals
 958    */
 959   /**
 960    * GtkWindow:application:
 961    *
 962    * The #GtkApplication associated with the window.
 963    *
 964    * The application will be kept alive for at least as long as the
 965    * window is open.
 966    *
 967    * Since: 3.0
 968    */
 969   g_object_class_install_property (gobject_class,
 970                                    PROP_APPLICATION,
 971                                    g_param_spec_object ("application",
 972                                                         P_("GtkApplication"),
 973                                                         P_("The GtkApplication for the window"),
 974                                                         GTK_TYPE_APPLICATION,
 975                                                         GTK_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 976
 977   window_signals[SET_FOCUS] =
 978     g_signal_new (I_("set-focus"),
 979                   G_TYPE_FROM_CLASS (gobject_class),
 980                   G_SIGNAL_RUN_LAST,
 981                   G_STRUCT_OFFSET (GtkWindowClass, set_focus),
 982                   NULL, NULL,
 983                   _gtk_marshal_VOID__OBJECT,
 984                   G_TYPE_NONE, 1,
 985                   GTK_TYPE_WIDGET);
 986
 987   window_signals[FRAME_EVENT] =
 988     g_signal_new (I_("frame-event"),
 989                   G_TYPE_FROM_CLASS (gobject_class),
 990                   G_SIGNAL_RUN_LAST,
 991                   G_STRUCT_OFFSET(GtkWindowClass, frame_event),
 992                   _gtk_boolean_handled_accumulator, NULL,
 993                   _gtk_marshal_BOOLEAN__BOXED,
 994                   G_TYPE_BOOLEAN, 1,
 995                   GDK_TYPE_EVENT);
 996
 997   /**
 998    * GtkWindow::activate-focus:
 999    * @window: the window which received the signal
1000    *
1001    * The ::activate-focus signal is a
1002    * <link linkend="keybinding-signals">keybinding signal</link>
1003    * which gets emitted when the user activates the currently
1004    * focused widget of @window.
1005    */
1006   window_signals[ACTIVATE_FOCUS] =
1007     g_signal_new (I_("activate-focus"),
1008                   G_TYPE_FROM_CLASS (gobject_class),
1009                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1010                   G_STRUCT_OFFSET (GtkWindowClass, activate_focus),
1011                   NULL, NULL,
1012                   _gtk_marshal_VOID__VOID,
1013                   G_TYPE_NONE,
1014                   0);
1015
1016   /**
1017    * GtkWindow::activate-default:
1018    * @window: the window which received the signal
1019    *
1020    * The ::activate-default signal is a
1021    * <link linkend="keybinding-signals">keybinding signal</link>
1022    * which gets emitted when the user activates the default widget
1023    * of @window.
1024    */
1025   window_signals[ACTIVATE_DEFAULT] =
1026     g_signal_new (I_("activate-default"),
1027                   G_TYPE_FROM_CLASS (gobject_class),
1028                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1029                   G_STRUCT_OFFSET (GtkWindowClass, activate_default),
1030                   NULL, NULL,
1031                   _gtk_marshal_VOID__VOID,
1032                   G_TYPE_NONE,
1033                   0);
1034
1035   /**
1036    * GtkWindow::keys-changed:
1037    * @window: the window which received the signal
1038    *
1039    * The ::keys-changed signal gets emitted when the set of accelerators
1040    * or mnemonics that are associated with @window changes.
1041    */
1042   window_signals[KEYS_CHANGED] =
1043     g_signal_new (I_("keys-changed"),
1044                   G_TYPE_FROM_CLASS (gobject_class),
1045                   G_SIGNAL_RUN_FIRST,
1046                   G_STRUCT_OFFSET (GtkWindowClass, keys_changed),
1047                   NULL, NULL,
1048                   _gtk_marshal_VOID__VOID,
1049                   G_TYPE_NONE,
1050                   0);
1051
1052   /*
1053    * Key bindings
1054    */
1055
1056   binding_set = gtk_binding_set_by_class (klass);
1057
1058   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0,
1059                                 "activate-focus", 0);
1060   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0,
1061                                 "activate-focus", 0);
1062
1063   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0,
1064                                 "activate-default", 0);
1065   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0,
1066                                 "activate-default", 0);
1067   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0,
1068                                 "activate-default", 0);
1069
1070   add_arrow_bindings (binding_set, GDK_KEY_Up, GTK_DIR_UP);
1071   add_arrow_bindings (binding_set, GDK_KEY_Down, GTK_DIR_DOWN);
1072   add_arrow_bindings (binding_set, GDK_KEY_Left, GTK_DIR_LEFT);
1073   add_arrow_bindings (binding_set, GDK_KEY_Right, GTK_DIR_RIGHT);
1074
1075   add_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
1076   add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
1077   add_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
1078   add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
1079 }
1080
1081 static void
1082 gtk_window_init (GtkWindow *window)
1083 {
1084   GtkWindowPrivate *priv;
1085
1086   window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window,
1087                                               GTK_TYPE_WINDOW,
1088                                               GtkWindowPrivate);
1089   priv = window->priv;
1090
1091   gtk_widget_set_has_window (GTK_WIDGET (window), TRUE);
1092   _gtk_widget_set_is_toplevel (GTK_WIDGET (window), TRUE);
1093
1094   _gtk_widget_set_anchored (GTK_WIDGET (window), TRUE);
1095
1096   gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
1097
1098   priv->title = NULL;
1099   priv->wmclass_name = g_strdup (g_get_prgname ());
1100   priv->wmclass_class = g_strdup (gdk_get_program_class ());
1101   priv->wm_role = NULL;
1102   priv->geometry_info = NULL;
1103   priv->type = GTK_WINDOW_TOPLEVEL;
1104   priv->focus_widget = NULL;
1105   priv->default_widget = NULL;
1106   priv->configure_request_count = 0;
1107   priv->resizable = TRUE;
1108   priv->configure_notify_received = FALSE;
1109   priv->position = GTK_WIN_POS_NONE;
1110   priv->need_default_size = TRUE;
1111   priv->need_default_position = TRUE;
1112   priv->modal = FALSE;
1113   priv->frame = NULL;
1114   priv->has_frame = FALSE;
1115   priv->frame_left = 0;
1116   priv->frame_right = 0;
1117   priv->frame_top = 0;
1118   priv->frame_bottom = 0;
1119   priv->gdk_type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
1120   priv->gravity = GDK_GRAVITY_NORTH_WEST;
1121   priv->decorated = TRUE;
1122   priv->mnemonic_modifier = GDK_MOD1_MASK;
1123   priv->screen = gdk_screen_get_default ();
1124
1125   priv->accept_focus = TRUE;
1126   priv->focus_on_map = TRUE;
1127   priv->deletable = TRUE;
1128   priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
1129   priv->opacity = 1.0;
1130   priv->startup_id = NULL;
1131   priv->has_resize_grip = TRUE;
1132   priv->mnemonics_visible = TRUE;
1133
1134   g_object_ref_sink (window);
1135   priv->has_user_ref_count = TRUE;
1136   toplevel_list = g_slist_prepend (toplevel_list, window);
1137
1138   g_signal_connect (priv->screen, "composited-changed",
1139                     G_CALLBACK (gtk_window_on_composited_changed), window);
1140 }
1141
1142 static void
1143 gtk_window_set_property (GObject      *object,
1144                          guint         prop_id,
1145                          const GValue *value,
1146                          GParamSpec   *pspec)
1147 {
1148   GtkWindow  *window = GTK_WINDOW (object);
1149   GtkWindowPrivate *priv = window->priv;
1150
1151   switch (prop_id)
1152     {
1153     case PROP_TYPE:
1154       priv->type = g_value_get_enum (value);
1155       break;
1156     case PROP_TITLE:
1157       gtk_window_set_title (window, g_value_get_string (value));
1158       break;
1159     case PROP_ROLE:
1160       gtk_window_set_role (window, g_value_get_string (value));
1161       break;
1162     case PROP_STARTUP_ID:
1163       gtk_window_set_startup_id (window, g_value_get_string (value));
1164       break;
1165     case PROP_RESIZABLE:
1166       gtk_window_set_resizable (window, g_value_get_boolean (value));
1167       break;
1168     case PROP_MODAL:
1169       gtk_window_set_modal (window, g_value_get_boolean (value));
1170       break;
1171     case PROP_WIN_POS:
1172       gtk_window_set_position (window, g_value_get_enum (value));
1173       break;
1174     case PROP_DEFAULT_WIDTH:
1175       gtk_window_set_default_size_internal (window,
1176                                             TRUE, g_value_get_int (value),
1177                                             FALSE, -1, FALSE);
1178       break;
1179     case PROP_DEFAULT_HEIGHT:
1180       gtk_window_set_default_size_internal (window,
1181                                             FALSE, -1,
1182                                             TRUE, g_value_get_int (value), FALSE);
1183       break;
1184     case PROP_DESTROY_WITH_PARENT:
1185       gtk_window_set_destroy_with_parent (window, g_value_get_boolean (value));
1186       break;
1187     case PROP_ICON:
1188       gtk_window_set_icon (window,
1189                            g_value_get_object (value));
1190       break;
1191     case PROP_ICON_NAME:
1192       gtk_window_set_icon_name (window, g_value_get_string (value));
1193       break;
1194     case PROP_SCREEN:
1195       gtk_window_set_screen (window, g_value_get_object (value));
1196       break;
1197     case PROP_TYPE_HINT:
1198       gtk_window_set_type_hint (window,
1199                                 g_value_get_enum (value));
1200       break;
1201     case PROP_SKIP_TASKBAR_HINT:
1202       gtk_window_set_skip_taskbar_hint (window,
1203                                         g_value_get_boolean (value));
1204       break;
1205     case PROP_SKIP_PAGER_HINT:
1206       gtk_window_set_skip_pager_hint (window,
1207                                       g_value_get_boolean (value));
1208       break;
1209     case PROP_URGENCY_HINT:
1210       gtk_window_set_urgency_hint (window,
1211                                    g_value_get_boolean (value));
1212       break;
1213     case PROP_ACCEPT_FOCUS:
1214       gtk_window_set_accept_focus (window,
1215                                    g_value_get_boolean (value));
1216       break;
1217     case PROP_FOCUS_ON_MAP:
1218       gtk_window_set_focus_on_map (window,
1219                                    g_value_get_boolean (value));
1220       break;
1221     case PROP_DECORATED:
1222       gtk_window_set_decorated (window, g_value_get_boolean (value));
1223       break;
1224     case PROP_DELETABLE:
1225       gtk_window_set_deletable (window, g_value_get_boolean (value));
1226       break;
1227     case PROP_GRAVITY:
1228       gtk_window_set_gravity (window, g_value_get_enum (value));
1229       break;
1230     case PROP_TRANSIENT_FOR:
1231       gtk_window_set_transient_for (window, g_value_get_object (value));
1232       break;
1233     case PROP_OPACITY:
1234       gtk_window_set_opacity (window, g_value_get_double (value));
1235       break;
1236     case PROP_HAS_RESIZE_GRIP:
1237       gtk_window_set_has_resize_grip (window, g_value_get_boolean (value));
1238       break;
1239     case PROP_APPLICATION:
1240       gtk_window_set_application (window, g_value_get_object (value));
1241       break;
1242     case PROP_MNEMONICS_VISIBLE:
1243       gtk_window_set_mnemonics_visible (window, g_value_get_boolean (value));
1244       break;
1245     default:
1246       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1247       break;
1248     }
1249 }
1250
1251 static void
1252 gtk_window_get_property (GObject      *object,
1253                          guint         prop_id,
1254                          GValue       *value,
1255                          GParamSpec   *pspec)
1256 {
1257   GtkWindow  *window = GTK_WINDOW (object);
1258   GtkWindowPrivate *priv = window->priv;
1259
1260   switch (prop_id)
1261     {
1262       GtkWindowGeometryInfo *info;
1263     case PROP_TYPE:
1264       g_value_set_enum (value, priv->type);
1265       break;
1266     case PROP_ROLE:
1267       g_value_set_string (value, priv->wm_role);
1268       break;
1269     case PROP_TITLE:
1270       g_value_set_string (value, priv->title);
1271       break;
1272     case PROP_RESIZABLE:
1273       g_value_set_boolean (value, priv->resizable);
1274       break;
1275     case PROP_MODAL:
1276       g_value_set_boolean (value, priv->modal);
1277       break;
1278     case PROP_WIN_POS:
1279       g_value_set_enum (value, priv->position);
1280       break;
1281     case PROP_DEFAULT_WIDTH:
1282       info = gtk_window_get_geometry_info (window, FALSE);
1283       if (!info)
1284         g_value_set_int (value, -1);
1285       else
1286         g_value_set_int (value, info->default_width);
1287       break;
1288     case PROP_DEFAULT_HEIGHT:
1289       info = gtk_window_get_geometry_info (window, FALSE);
1290       if (!info)
1291         g_value_set_int (value, -1);
1292       else
1293         g_value_set_int (value, info->default_height);
1294       break;
1295     case PROP_DESTROY_WITH_PARENT:
1296       g_value_set_boolean (value, priv->destroy_with_parent);
1297       break;
1298     case PROP_ICON:
1299       g_value_set_object (value, gtk_window_get_icon (window));
1300       break;
1301     case PROP_ICON_NAME:
1302       g_value_set_string (value, gtk_window_get_icon_name (window));
1303       break;
1304     case PROP_SCREEN:
1305       g_value_set_object (value, priv->screen);
1306       break;
1307     case PROP_IS_ACTIVE:
1308       g_value_set_boolean (value, priv->is_active);
1309       break;
1310     case PROP_HAS_TOPLEVEL_FOCUS:
1311       g_value_set_boolean (value, priv->has_toplevel_focus);
1312       break;
1313     case PROP_TYPE_HINT:
1314       g_value_set_enum (value, priv->type_hint);
1315       break;
1316     case PROP_SKIP_TASKBAR_HINT:
1317       g_value_set_boolean (value,
1318                            gtk_window_get_skip_taskbar_hint (window));
1319       break;
1320     case PROP_SKIP_PAGER_HINT:
1321       g_value_set_boolean (value,
1322                            gtk_window_get_skip_pager_hint (window));
1323       break;
1324     case PROP_URGENCY_HINT:
1325       g_value_set_boolean (value,
1326                            gtk_window_get_urgency_hint (window));
1327       break;
1328     case PROP_ACCEPT_FOCUS:
1329       g_value_set_boolean (value,
1330                            gtk_window_get_accept_focus (window));
1331       break;
1332     case PROP_FOCUS_ON_MAP:
1333       g_value_set_boolean (value,
1334                            gtk_window_get_focus_on_map (window));
1335       break;
1336     case PROP_DECORATED:
1337       g_value_set_boolean (value, gtk_window_get_decorated (window));
1338       break;
1339     case PROP_DELETABLE:
1340       g_value_set_boolean (value, gtk_window_get_deletable (window));
1341       break;
1342     case PROP_GRAVITY:
1343       g_value_set_enum (value, gtk_window_get_gravity (window));
1344       break;
1345     case PROP_TRANSIENT_FOR:
1346       g_value_set_object (value, gtk_window_get_transient_for (window));
1347       break;
1348     case PROP_OPACITY:
1349       g_value_set_double (value, gtk_window_get_opacity (window));
1350       break;
1351     case PROP_HAS_RESIZE_GRIP:
1352       g_value_set_boolean (value, priv->has_resize_grip);
1353       break;
1354     case PROP_RESIZE_GRIP_VISIBLE:
1355       g_value_set_boolean (value, gtk_window_resize_grip_is_visible (window));
1356       break;
1357     case PROP_APPLICATION:
1358       g_value_set_object (value, gtk_window_get_application (window));
1359       break;
1360     case PROP_MNEMONICS_VISIBLE:
1361       g_value_set_boolean (value, priv->mnemonics_visible);
1362       break;
1363     default:
1364       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1365       break;
1366     }
1367 }
1368
1369 static void
1370 gtk_window_buildable_interface_init (GtkBuildableIface *iface)
1371 {
1372   parent_buildable_iface = g_type_interface_peek_parent (iface);
1373   iface->set_buildable_property = gtk_window_buildable_set_buildable_property;
1374   iface->parser_finished = gtk_window_buildable_parser_finished;
1375   iface->custom_tag_start = gtk_window_buildable_custom_tag_start;
1376   iface->custom_finished = gtk_window_buildable_custom_finished;
1377 }
1378
1379 static void
1380 gtk_window_buildable_set_buildable_property (GtkBuildable        *buildable,
1381                                              GtkBuilder          *builder,
1382                                              const gchar         *name,
1383                                              const GValue        *value)
1384 {
1385   GtkWindow *window = GTK_WINDOW (buildable);
1386   GtkWindowPrivate *priv = window->priv;
1387
1388   if (strcmp (name, "visible") == 0 && g_value_get_boolean (value))
1389     priv->builder_visible = TRUE;
1390   else
1391     parent_buildable_iface->set_buildable_property (buildable, builder, name, value);
1392 }
1393
1394 static void
1395 gtk_window_buildable_parser_finished (GtkBuildable *buildable,
1396                                       GtkBuilder   *builder)
1397 {
1398   GtkWindow *window = GTK_WINDOW (buildable);
1399   GtkWindowPrivate *priv = window->priv;
1400   GObject *object;
1401   GSList *accels, *l;
1402
1403   if (priv->builder_visible)
1404     gtk_widget_show (GTK_WIDGET (buildable));
1405
1406   accels = g_object_get_qdata (G_OBJECT (buildable), quark_gtk_buildable_accels);
1407   for (l = accels; l; l = l->next)
1408     {
1409       object = gtk_builder_get_object (builder, l->data);
1410       if (!object)
1411         {
1412           g_warning ("Unknown accel group %s specified in window %s",
1413                      (const gchar*)l->data, gtk_buildable_get_name (buildable));
1414           continue;
1415         }
1416       gtk_window_add_accel_group (GTK_WINDOW (buildable),
1417                                   GTK_ACCEL_GROUP (object));
1418       g_free (l->data);
1419     }
1420
1421   g_object_set_qdata (G_OBJECT (buildable), quark_gtk_buildable_accels, NULL);
1422
1423   parent_buildable_iface->parser_finished (buildable, builder);
1424 }
1425
1426 typedef struct {
1427   GObject *object;
1428   GSList *items;
1429 } GSListSubParserData;
1430
1431 static void
1432 window_start_element (GMarkupParseContext *context,
1433                           const gchar         *element_name,
1434                           const gchar        **names,
1435                           const gchar        **values,
1436                           gpointer            user_data,
1437                           GError            **error)
1438 {
1439   guint i;
1440   GSListSubParserData *data = (GSListSubParserData*)user_data;
1441
1442   if (strcmp (element_name, "group") == 0)
1443     {
1444       for (i = 0; names[i]; i++)
1445         {
1446           if (strcmp (names[i], "name") == 0)
1447             data->items = g_slist_prepend (data->items, g_strdup (values[i]));
1448         }
1449     }
1450   else if (strcmp (element_name, "accel-groups") == 0)
1451     return;
1452   else
1453     g_warning ("Unsupported tag type for GtkWindow: %s\n",
1454                element_name);
1455
1456 }
1457
1458 static const GMarkupParser window_parser =
1459   {
1460     window_start_element
1461   };
1462
1463 static gboolean
1464 gtk_window_buildable_custom_tag_start (GtkBuildable  *buildable,
1465                                        GtkBuilder    *builder,
1466                                        GObject       *child,
1467                                        const gchar   *tagname,
1468                                        GMarkupParser *parser,
1469                                        gpointer      *data)
1470 {
1471   GSListSubParserData *parser_data;
1472
1473   if (parent_buildable_iface->custom_tag_start (buildable, builder, child,
1474                                                 tagname, parser, data))
1475     return TRUE;
1476
1477   if (strcmp (tagname, "accel-groups") == 0)
1478     {
1479       parser_data = g_slice_new0 (GSListSubParserData);
1480       parser_data->items = NULL;
1481       parser_data->object = G_OBJECT (buildable);
1482
1483       *parser = window_parser;
1484       *data = parser_data;
1485       return TRUE;
1486     }
1487
1488   return FALSE;
1489 }
1490
1491 static void
1492 gtk_window_buildable_custom_finished (GtkBuildable  *buildable,
1493                                           GtkBuilder    *builder,
1494                                           GObject       *child,
1495                                           const gchar   *tagname,
1496                                           gpointer       user_data)
1497 {
1498   GSListSubParserData *data;
1499
1500   parent_buildable_iface->custom_finished (buildable, builder, child,
1501                                            tagname, user_data);
1502
1503   if (strcmp (tagname, "accel-groups") != 0)
1504     return;
1505
1506   data = (GSListSubParserData*)user_data;
1507
1508   g_object_set_qdata_full (G_OBJECT (buildable), quark_gtk_buildable_accels,
1509                            data->items, (GDestroyNotify) g_slist_free);
1510
1511   g_slice_free (GSListSubParserData, data);
1512 }
1513
1514 /**
1515  * gtk_window_new:
1516  * @type: type of window
1517  *
1518  * Creates a new #GtkWindow, which is a toplevel window that can
1519  * contain other widgets. Nearly always, the type of the window should
1520  * be #GTK_WINDOW_TOPLEVEL. If you're implementing something like a
1521  * popup menu from scratch (which is a bad idea, just use #GtkMenu),
1522  * you might use #GTK_WINDOW_POPUP. #GTK_WINDOW_POPUP is not for
1523  * dialogs, though in some other toolkits dialogs are called "popups".
1524  * In GTK+, #GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip.
1525  * On X11, popup windows are not controlled by the <link
1526  * linkend="gtk-X11-arch">window manager</link>.
1527  *
1528  * If you simply want an undecorated window (no window borders), use
1529  * gtk_window_set_decorated(), don't use #GTK_WINDOW_POPUP.
1530  *
1531  * Return value: a new #GtkWindow.
1532  **/
1533 GtkWidget*
1534 gtk_window_new (GtkWindowType type)
1535 {
1536   GtkWindowPrivate *priv;
1537   GtkWindow *window;
1538
1539   g_return_val_if_fail (type >= GTK_WINDOW_TOPLEVEL && type <= GTK_WINDOW_POPUP, NULL);
1540
1541   window = g_object_new (GTK_TYPE_WINDOW, NULL);
1542   priv = window->priv;
1543
1544   priv->type = type;
1545
1546   return GTK_WIDGET (window);
1547 }
1548
1549 /**
1550  * gtk_window_set_title:
1551  * @window: a #GtkWindow
1552  * @title: title of the window
1553  *
1554  * Sets the title of the #GtkWindow. The title of a window will be
1555  * displayed in its title bar; on the X Window System, the title bar
1556  * is rendered by the <link linkend="gtk-X11-arch">window
1557  * manager</link>, so exactly how the title appears to users may vary
1558  * according to a user's exact configuration. The title should help a
1559  * user distinguish this window from other windows they may have
1560  * open. A good title might include the application name and current
1561  * document filename, for example.
1562  *
1563  **/
1564 void
1565 gtk_window_set_title (GtkWindow   *window,
1566                       const gchar *title)
1567 {
1568   GtkWindowPrivate *priv;
1569   GtkWidget *widget;
1570   char *new_title;
1571
1572   g_return_if_fail (GTK_IS_WINDOW (window));
1573
1574   priv = window->priv;
1575   widget = GTK_WIDGET (window);
1576
1577   new_title = g_strdup (title);
1578   g_free (priv->title);
1579   priv->title = new_title;
1580
1581   if (gtk_widget_get_realized (widget))
1582     {
1583       gdk_window_set_title (gtk_widget_get_window (widget),
1584                             priv->title);
1585     }
1586
1587   g_object_notify (G_OBJECT (window), "title");
1588 }
1589
1590 /**
1591  * gtk_window_get_title:
1592  * @window: a #GtkWindow
1593  *
1594  * Retrieves the title of the window. See gtk_window_set_title().
1595  *
1596  * Return value: the title of the window, or %NULL if none has
1597  *    been set explicitely. The returned string is owned by the widget
1598  *    and must not be modified or freed.
1599  **/
1600 G_CONST_RETURN gchar *
1601 gtk_window_get_title (GtkWindow *window)
1602 {
1603   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
1604
1605   return window->priv->title;
1606 }
1607
1608 /**
1609  * gtk_window_set_wmclass:
1610  * @window: a #GtkWindow
1611  * @wmclass_name: window name hint
1612  * @wmclass_class: window class hint
1613  *
1614  * Don't use this function. It sets the X Window System "class" and
1615  * "name" hints for a window.  According to the ICCCM, you should
1616  * always set these to the same value for all windows in an
1617  * application, and GTK+ sets them to that value by default, so calling
1618  * this function is sort of pointless. However, you may want to call
1619  * gtk_window_set_role() on each window in your application, for the
1620  * benefit of the session manager. Setting the role allows the window
1621  * manager to restore window positions when loading a saved session.
1622  *
1623  **/
1624 void
1625 gtk_window_set_wmclass (GtkWindow *window,
1626                         const gchar *wmclass_name,
1627                         const gchar *wmclass_class)
1628 {
1629   GtkWindowPrivate *priv;
1630
1631   g_return_if_fail (GTK_IS_WINDOW (window));
1632
1633   priv = window->priv;
1634
1635   g_free (priv->wmclass_name);
1636   priv->wmclass_name = g_strdup (wmclass_name);
1637
1638   g_free (priv->wmclass_class);
1639   priv->wmclass_class = g_strdup (wmclass_class);
1640
1641   if (gtk_widget_get_realized (GTK_WIDGET (window)))
1642     g_warning ("gtk_window_set_wmclass: shouldn't set wmclass after window is realized!\n");
1643 }
1644
1645 /**
1646  * gtk_window_set_role:
1647  * @window: a #GtkWindow
1648  * @role: unique identifier for the window to be used when restoring a session
1649  *
1650  * This function is only useful on X11, not with other GTK+ targets.
1651  *
1652  * In combination with the window title, the window role allows a
1653  * <link linkend="gtk-X11-arch">window manager</link> to identify "the
1654  * same" window when an application is restarted. So for example you
1655  * might set the "toolbox" role on your app's toolbox window, so that
1656  * when the user restarts their session, the window manager can put
1657  * the toolbox back in the same place.
1658  *
1659  * If a window already has a unique title, you don't need to set the
1660  * role, since the WM can use the title to identify the window when
1661  * restoring the session.
1662  *
1663  **/
1664 void
1665 gtk_window_set_role (GtkWindow   *window,
1666                      const gchar *role)
1667 {
1668   GtkWindowPrivate *priv;
1669   char *new_role;
1670
1671   g_return_if_fail (GTK_IS_WINDOW (window));
1672
1673   priv = window->priv;
1674
1675   new_role = g_strdup (role);
1676   g_free (priv->wm_role);
1677   priv->wm_role = new_role;
1678
1679   if (gtk_widget_get_realized (GTK_WIDGET (window)))
1680     gdk_window_set_role (gtk_widget_get_window (GTK_WIDGET (window)),
1681                          priv->wm_role);
1682
1683   g_object_notify (G_OBJECT (window), "role");
1684 }
1685
1686 /**
1687  * gtk_window_set_startup_id:
1688  * @window: a #GtkWindow
1689  * @startup_id: a string with startup-notification identifier
1690  *
1691  * Startup notification identifiers are used by desktop environment to
1692  * track application startup, to provide user feedback and other
1693  * features. This function changes the corresponding property on the
1694  * underlying GdkWindow. Normally, startup identifier is managed
1695  * automatically and you should only use this function in special cases
1696  * like transferring focus from other processes. You should use this
1697  * function before calling gtk_window_present() or any equivalent
1698  * function generating a window map event.
1699  *
1700  * This function is only useful on X11, not with other GTK+ targets.
1701  *
1702  * Since: 2.12
1703  **/
1704 void
1705 gtk_window_set_startup_id (GtkWindow   *window,
1706                            const gchar *startup_id)
1707 {
1708   GtkWindowPrivate *priv;
1709   GtkWidget *widget;
1710
1711   g_return_if_fail (GTK_IS_WINDOW (window));
1712
1713   priv = window->priv;
1714   widget = GTK_WIDGET (window);
1715
1716   g_free (priv->startup_id);
1717   priv->startup_id = g_strdup (startup_id);
1718
1719   if (gtk_widget_get_realized (widget))
1720     {
1721       GdkWindow *gdk_window;
1722       guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
1723
1724       gdk_window = gtk_widget_get_window (widget);
1725
1726 #ifdef GDK_WINDOWING_X11
1727       if (timestamp != GDK_CURRENT_TIME)
1728         gdk_x11_window_set_user_time (gdk_window, timestamp);
1729 #endif
1730
1731       /* Here we differentiate real and "fake" startup notification IDs,
1732        * constructed on purpose just to pass interaction timestamp
1733        */
1734       if (startup_id_is_fake (priv->startup_id))
1735         gtk_window_present_with_time (window, timestamp);
1736       else
1737         {
1738           gdk_window_set_startup_id (gdk_window,
1739                                      priv->startup_id);
1740
1741           /* If window is mapped, terminate the startup-notification too */
1742           if (gtk_widget_get_mapped (widget) &&
1743               !disable_startup_notification)
1744             gdk_notify_startup_complete_with_id (priv->startup_id);
1745         }
1746     }
1747
1748   g_object_notify (G_OBJECT (window), "startup-id");
1749 }
1750
1751 /**
1752  * gtk_window_get_role:
1753  * @window: a #GtkWindow
1754  *
1755  * Returns the role of the window. See gtk_window_set_role() for
1756  * further explanation.
1757  *
1758  * Return value: the role of the window if set, or %NULL. The
1759  *   returned is owned by the widget and must not be modified
1760  *   or freed.
1761  **/
1762 G_CONST_RETURN gchar *
1763 gtk_window_get_role (GtkWindow *window)
1764 {
1765   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
1766
1767   return window->priv->wm_role;
1768 }
1769
1770 /**
1771  * gtk_window_set_focus:
1772  * @window: a #GtkWindow
1773  * @focus: (allow-none): widget to be the new focus widget, or %NULL to unset
1774  *   any focus widget for the toplevel window.
1775  *
1776  * If @focus is not the current focus widget, and is focusable, sets
1777  * it as the focus widget for the window. If @focus is %NULL, unsets
1778  * the focus widget for this window. To set the focus to a particular
1779  * widget in the toplevel, it is usually more convenient to use
1780  * gtk_widget_grab_focus() instead of this function.
1781  **/
1782 void
1783 gtk_window_set_focus (GtkWindow *window,
1784                       GtkWidget *focus)
1785 {
1786   GtkWindowPrivate *priv;
1787   GtkWidget *parent;
1788
1789   g_return_if_fail (GTK_IS_WINDOW (window));
1790
1791   priv = window->priv;
1792
1793   if (focus)
1794     {
1795       g_return_if_fail (GTK_IS_WIDGET (focus));
1796       g_return_if_fail (gtk_widget_get_can_focus (focus));
1797     }
1798
1799   if (focus)
1800     gtk_widget_grab_focus (focus);
1801   else
1802     {
1803       /* Clear the existing focus chain, so that when we focus into
1804        * the window again, we start at the beginnning.
1805        */
1806       GtkWidget *widget = priv->focus_widget;
1807       if (widget)
1808         {
1809           while ((parent = gtk_widget_get_parent (widget)))
1810             {
1811               widget = parent;
1812               gtk_container_set_focus_child (GTK_CONTAINER (widget), NULL);
1813             }
1814         }
1815
1816       _gtk_window_internal_set_focus (window, NULL);
1817     }
1818 }
1819
1820 void
1821 _gtk_window_internal_set_focus (GtkWindow *window,
1822                                 GtkWidget *focus)
1823 {
1824   GtkWindowPrivate *priv;
1825
1826   g_return_if_fail (GTK_IS_WINDOW (window));
1827
1828   priv = window->priv;
1829
1830   if ((priv->focus_widget != focus) ||
1831       (focus && !gtk_widget_has_focus (focus)))
1832     g_signal_emit (window, window_signals[SET_FOCUS], 0, focus);
1833 }
1834
1835 /**
1836  * gtk_window_set_default:
1837  * @window: a #GtkWindow
1838  * @default_widget: (allow-none): widget to be the default, or %NULL to unset the
1839  *                  default widget for the toplevel.
1840  *
1841  * The default widget is the widget that's activated when the user
1842  * presses Enter in a dialog (for example). This function sets or
1843  * unsets the default widget for a #GtkWindow about. When setting
1844  * (rather than unsetting) the default widget it's generally easier to
1845  * call gtk_widget_grab_focus() on the widget. Before making a widget
1846  * the default widget, you must set the #GTK_CAN_DEFAULT flag on the
1847  * widget you'd like to make the default using GTK_WIDGET_SET_FLAGS().
1848  **/
1849 void
1850 gtk_window_set_default (GtkWindow *window,
1851                         GtkWidget *default_widget)
1852 {
1853   GtkWindowPrivate *priv;
1854
1855   g_return_if_fail (GTK_IS_WINDOW (window));
1856
1857   priv = window->priv;
1858
1859   if (default_widget)
1860     g_return_if_fail (gtk_widget_get_can_default (default_widget));
1861
1862   if (priv->default_widget != default_widget)
1863     {
1864       GtkWidget *old_default_widget = NULL;
1865
1866       if (default_widget)
1867         g_object_ref (default_widget);
1868
1869       if (priv->default_widget)
1870         {
1871           old_default_widget = priv->default_widget;
1872
1873           if (priv->focus_widget != priv->default_widget ||
1874               !gtk_widget_get_receives_default (priv->default_widget))
1875             _gtk_widget_set_has_default (priv->default_widget, FALSE);
1876
1877           gtk_widget_queue_draw (priv->default_widget);
1878         }
1879
1880       priv->default_widget = default_widget;
1881
1882       if (priv->default_widget)
1883         {
1884           if (priv->focus_widget == NULL ||
1885               !gtk_widget_get_receives_default (priv->focus_widget))
1886             _gtk_widget_set_has_default (priv->default_widget, TRUE);
1887
1888           gtk_widget_queue_draw (priv->default_widget);
1889         }
1890
1891       if (old_default_widget)
1892         g_object_notify (G_OBJECT (old_default_widget), "has-default");
1893
1894       if (default_widget)
1895         {
1896           g_object_notify (G_OBJECT (default_widget), "has-default");
1897           g_object_unref (default_widget);
1898         }
1899     }
1900 }
1901
1902 /**
1903  * gtk_window_get_default_widget:
1904  * @window: a #GtkWindow
1905  *
1906  * Returns the default widget for @window. See gtk_window_set_default()
1907  * for more details.
1908  *
1909  * Returns: (transfer none): the default widget, or %NULL if there is none.
1910  *
1911  * Since: 2.14
1912  **/
1913 GtkWidget *
1914 gtk_window_get_default_widget (GtkWindow *window)
1915 {
1916   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
1917
1918   return window->priv->default_widget;
1919 }
1920
1921 static gboolean
1922 handle_keys_changed (gpointer data)
1923 {
1924   GtkWindow *window = GTK_WINDOW (data);
1925   GtkWindowPrivate *priv = window->priv;
1926
1927   if (priv->keys_changed_handler)
1928     {
1929       g_source_remove (priv->keys_changed_handler);
1930       priv->keys_changed_handler = 0;
1931     }
1932
1933   g_signal_emit (window, window_signals[KEYS_CHANGED], 0);
1934
1935   return FALSE;
1936 }
1937
1938 static void
1939 gtk_window_notify_keys_changed (GtkWindow *window)
1940 {
1941   GtkWindowPrivate *priv = window->priv;
1942
1943   if (!priv->keys_changed_handler)
1944     priv->keys_changed_handler = gdk_threads_add_idle (handle_keys_changed, window);
1945 }
1946
1947 /**
1948  * gtk_window_add_accel_group:
1949  * @window: window to attach accelerator group to
1950  * @accel_group: a #GtkAccelGroup
1951  *
1952  * Associate @accel_group with @window, such that calling
1953  * gtk_accel_groups_activate() on @window will activate accelerators
1954  * in @accel_group.
1955  **/
1956 void
1957 gtk_window_add_accel_group (GtkWindow     *window,
1958                             GtkAccelGroup *accel_group)
1959 {
1960   g_return_if_fail (GTK_IS_WINDOW (window));
1961   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
1962
1963   _gtk_accel_group_attach (accel_group, G_OBJECT (window));
1964   g_signal_connect_object (accel_group, "accel-changed",
1965                            G_CALLBACK (gtk_window_notify_keys_changed),
1966                            window, G_CONNECT_SWAPPED);
1967   gtk_window_notify_keys_changed (window);
1968 }
1969
1970 /**
1971  * gtk_window_remove_accel_group:
1972  * @window: a #GtkWindow
1973  * @accel_group: a #GtkAccelGroup
1974  *
1975  * Reverses the effects of gtk_window_add_accel_group().
1976  **/
1977 void
1978 gtk_window_remove_accel_group (GtkWindow     *window,
1979                                GtkAccelGroup *accel_group)
1980 {
1981   g_return_if_fail (GTK_IS_WINDOW (window));
1982   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
1983
1984   g_signal_handlers_disconnect_by_func (accel_group,
1985                                         gtk_window_notify_keys_changed,
1986                                         window);
1987   _gtk_accel_group_detach (accel_group, G_OBJECT (window));
1988   gtk_window_notify_keys_changed (window);
1989 }
1990
1991 static GtkMnemonicHash *
1992 gtk_window_get_mnemonic_hash (GtkWindow *window,
1993                               gboolean   create)
1994 {
1995   GtkWindowPrivate *private = window->priv;
1996
1997   if (!private->mnemonic_hash && create)
1998     private->mnemonic_hash = _gtk_mnemonic_hash_new ();
1999
2000   return private->mnemonic_hash;
2001 }
2002
2003 /**
2004  * gtk_window_add_mnemonic:
2005  * @window: a #GtkWindow
2006  * @keyval: the mnemonic
2007  * @target: the widget that gets activated by the mnemonic
2008  *
2009  * Adds a mnemonic to this window.
2010  */
2011 void
2012 gtk_window_add_mnemonic (GtkWindow *window,
2013                          guint      keyval,
2014                          GtkWidget *target)
2015 {
2016   g_return_if_fail (GTK_IS_WINDOW (window));
2017   g_return_if_fail (GTK_IS_WIDGET (target));
2018
2019   _gtk_mnemonic_hash_add (gtk_window_get_mnemonic_hash (window, TRUE),
2020                           keyval, target);
2021   gtk_window_notify_keys_changed (window);
2022 }
2023
2024 /**
2025  * gtk_window_remove_mnemonic:
2026  * @window: a #GtkWindow
2027  * @keyval: the mnemonic
2028  * @target: the widget that gets activated by the mnemonic
2029  *
2030  * Removes a mnemonic from this window.
2031  */
2032 void
2033 gtk_window_remove_mnemonic (GtkWindow *window,
2034                             guint      keyval,
2035                             GtkWidget *target)
2036 {
2037   g_return_if_fail (GTK_IS_WINDOW (window));
2038   g_return_if_fail (GTK_IS_WIDGET (target));
2039
2040   _gtk_mnemonic_hash_remove (gtk_window_get_mnemonic_hash (window, TRUE),
2041                              keyval, target);
2042   gtk_window_notify_keys_changed (window);
2043 }
2044
2045 /**
2046  * gtk_window_mnemonic_activate:
2047  * @window: a #GtkWindow
2048  * @keyval: the mnemonic
2049  * @modifier: the modifiers
2050  * @returns: %TRUE if the activation is done.
2051  *
2052  * Activates the targets associated with the mnemonic.
2053  */
2054 gboolean
2055 gtk_window_mnemonic_activate (GtkWindow      *window,
2056                               guint           keyval,
2057                               GdkModifierType modifier)
2058 {
2059   GtkWindowPrivate *priv;
2060
2061   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2062
2063   priv = window->priv;
2064
2065   if (priv->mnemonic_modifier == (modifier & gtk_accelerator_get_default_mod_mask ()))
2066       {
2067         GtkMnemonicHash *mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
2068         if (mnemonic_hash)
2069           return _gtk_mnemonic_hash_activate (mnemonic_hash, keyval);
2070       }
2071
2072   return FALSE;
2073 }
2074
2075 /**
2076  * gtk_window_set_mnemonic_modifier:
2077  * @window: a #GtkWindow
2078  * @modifier: the modifier mask used to activate
2079  *               mnemonics on this window.
2080  *
2081  * Sets the mnemonic modifier for this window.
2082  **/
2083 void
2084 gtk_window_set_mnemonic_modifier (GtkWindow      *window,
2085                                   GdkModifierType modifier)
2086 {
2087   GtkWindowPrivate *priv;
2088
2089   g_return_if_fail (GTK_IS_WINDOW (window));
2090   g_return_if_fail ((modifier & ~GDK_MODIFIER_MASK) == 0);
2091
2092   priv = window->priv;
2093
2094   priv->mnemonic_modifier = modifier;
2095   gtk_window_notify_keys_changed (window);
2096 }
2097
2098 /**
2099  * gtk_window_get_mnemonic_modifier:
2100  * @window: a #GtkWindow
2101  *
2102  * Returns the mnemonic modifier for this window. See
2103  * gtk_window_set_mnemonic_modifier().
2104  *
2105  * Return value: the modifier mask used to activate
2106  *               mnemonics on this window.
2107  **/
2108 GdkModifierType
2109 gtk_window_get_mnemonic_modifier (GtkWindow *window)
2110 {
2111   g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
2112
2113   return window->priv->mnemonic_modifier;
2114 }
2115
2116 /**
2117  * gtk_window_set_position:
2118  * @window: a #GtkWindow.
2119  * @position: a position constraint.
2120  *
2121  * Sets a position constraint for this window. If the old or new
2122  * constraint is %GTK_WIN_POS_CENTER_ALWAYS, this will also cause
2123  * the window to be repositioned to satisfy the new constraint.
2124  **/
2125 void
2126 gtk_window_set_position (GtkWindow         *window,
2127                          GtkWindowPosition  position)
2128 {
2129   GtkWindowPrivate *priv;
2130
2131   g_return_if_fail (GTK_IS_WINDOW (window));
2132
2133   priv = window->priv;
2134
2135   if (position == GTK_WIN_POS_CENTER_ALWAYS ||
2136       priv->position == GTK_WIN_POS_CENTER_ALWAYS)
2137     {
2138       GtkWindowGeometryInfo *info;
2139
2140       info = gtk_window_get_geometry_info (window, TRUE);
2141
2142       /* this flag causes us to re-request the CENTER_ALWAYS
2143        * constraint in gtk_window_move_resize(), see
2144        * comment in that function.
2145        */
2146       info->position_constraints_changed = TRUE;
2147
2148       gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
2149     }
2150
2151   priv->position = position;
2152
2153   g_object_notify (G_OBJECT (window), "window-position");
2154 }
2155
2156 /**
2157  * gtk_window_activate_focus:
2158  * @window: a #GtkWindow
2159  *
2160  * Activates the current focused widget within the window.
2161  *
2162  * Return value: %TRUE if a widget got activated.
2163  **/
2164 gboolean
2165 gtk_window_activate_focus (GtkWindow *window)
2166 {
2167   GtkWindowPrivate *priv;
2168
2169   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2170
2171   priv = window->priv;
2172
2173   if (priv->focus_widget && gtk_widget_is_sensitive (priv->focus_widget))
2174     return gtk_widget_activate (priv->focus_widget);
2175
2176   return FALSE;
2177 }
2178
2179 /**
2180  * gtk_window_get_focus:
2181  * @window: a #GtkWindow
2182  *
2183  * Retrieves the current focused widget within the window.
2184  * Note that this is the widget that would have the focus
2185  * if the toplevel window focused; if the toplevel window
2186  * is not focused then  <literal>gtk_widget_has_focus (widget)</literal> will
2187  * not be %TRUE for the widget.
2188  *
2189  * Return value: (transfer none): the currently focused widget, or %NULL if there is none.
2190  **/
2191 GtkWidget *
2192 gtk_window_get_focus (GtkWindow *window)
2193 {
2194   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
2195
2196   return window->priv->focus_widget;
2197 }
2198
2199 /**
2200  * gtk_window_activate_default:
2201  * @window: a #GtkWindow
2202  *
2203  * Activates the default widget for the window, unless the current
2204  * focused widget has been configured to receive the default action
2205  * (see gtk_widget_set_receives_default()), in which case the
2206  * focused widget is activated.
2207  *
2208  * Return value: %TRUE if a widget got activated.
2209  **/
2210 gboolean
2211 gtk_window_activate_default (GtkWindow *window)
2212 {
2213   GtkWindowPrivate *priv;
2214
2215   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2216
2217   priv = window->priv;
2218
2219   if (priv->default_widget && gtk_widget_is_sensitive (priv->default_widget) &&
2220       (!priv->focus_widget || !gtk_widget_get_receives_default (priv->focus_widget)))
2221     return gtk_widget_activate (priv->default_widget);
2222   else if (priv->focus_widget && gtk_widget_is_sensitive (priv->focus_widget))
2223     return gtk_widget_activate (priv->focus_widget);
2224
2225   return FALSE;
2226 }
2227
2228 /**
2229  * gtk_window_set_modal:
2230  * @window: a #GtkWindow
2231  * @modal: whether the window is modal
2232  *
2233  * Sets a window modal or non-modal. Modal windows prevent interaction
2234  * with other windows in the same application. To keep modal dialogs
2235  * on top of main application windows, use
2236  * gtk_window_set_transient_for() to make the dialog transient for the
2237  * parent; most <link linkend="gtk-X11-arch">window managers</link>
2238  * will then disallow lowering the dialog below the parent.
2239  *
2240  *
2241  **/
2242 void
2243 gtk_window_set_modal (GtkWindow *window,
2244                       gboolean   modal)
2245 {
2246   GtkWindowPrivate *priv;
2247   GtkWidget *widget;
2248
2249   g_return_if_fail (GTK_IS_WINDOW (window));
2250
2251   priv = window->priv;
2252
2253   modal = modal != FALSE;
2254   if (priv->modal == modal)
2255     return;
2256
2257   priv->modal = modal;
2258   widget = GTK_WIDGET (window);
2259
2260   /* adjust desired modality state */
2261   if (gtk_widget_get_realized (widget))
2262     {
2263       if (priv->modal)
2264         gdk_window_set_modal_hint (gtk_widget_get_window (widget), TRUE);
2265       else
2266         gdk_window_set_modal_hint (gtk_widget_get_window (widget), FALSE);
2267     }
2268
2269   if (gtk_widget_get_visible (widget))
2270     {
2271       if (priv->modal)
2272         gtk_grab_add (widget);
2273       else
2274         gtk_grab_remove (widget);
2275     }
2276
2277   g_object_notify (G_OBJECT (window), "modal");
2278 }
2279
2280 /**
2281  * gtk_window_get_modal:
2282  * @window: a #GtkWindow
2283  *
2284  * Returns whether the window is modal. See gtk_window_set_modal().
2285  *
2286  * Return value: %TRUE if the window is set to be modal and
2287  *               establishes a grab when shown
2288  **/
2289 gboolean
2290 gtk_window_get_modal (GtkWindow *window)
2291 {
2292   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2293
2294   return window->priv->modal;
2295 }
2296
2297 /**
2298  * gtk_window_list_toplevels:
2299  *
2300  * Returns a list of all existing toplevel windows. The widgets
2301  * in the list are not individually referenced. If you want
2302  * to iterate through the list and perform actions involving
2303  * callbacks that might destroy the widgets, you <emphasis>must</emphasis> call
2304  * <literal>g_list_foreach (result, (GFunc)g_object_ref, NULL)</literal> first, and
2305  * then unref all the widgets afterwards.
2306  *
2307  * Return value: (element-type GtkWidget) (transfer container): list of toplevel widgets
2308  **/
2309 GList*
2310 gtk_window_list_toplevels (void)
2311 {
2312   GList *list = NULL;
2313   GSList *slist;
2314
2315   for (slist = toplevel_list; slist; slist = slist->next)
2316     list = g_list_prepend (list, slist->data);
2317
2318   return list;
2319 }
2320
2321 void
2322 gtk_window_add_embedded_xid (GtkWindow *window, GdkNativeWindow xid)
2323 {
2324   GList *embedded_windows;
2325
2326   g_return_if_fail (GTK_IS_WINDOW (window));
2327
2328   embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
2329   if (embedded_windows)
2330     g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
2331   embedded_windows = g_list_prepend (embedded_windows,
2332                                      GUINT_TO_POINTER (xid));
2333
2334   g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
2335                            embedded_windows,
2336                            embedded_windows ?
2337                            (GDestroyNotify) g_list_free : NULL);
2338 }
2339
2340 void
2341 gtk_window_remove_embedded_xid (GtkWindow *window, GdkNativeWindow xid)
2342 {
2343   GList *embedded_windows;
2344   GList *node;
2345
2346   g_return_if_fail (GTK_IS_WINDOW (window));
2347
2348   embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
2349   if (embedded_windows)
2350     g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
2351
2352   node = g_list_find (embedded_windows, GUINT_TO_POINTER (xid));
2353   if (node)
2354     {
2355       embedded_windows = g_list_remove_link (embedded_windows, node);
2356       g_list_free_1 (node);
2357     }
2358
2359   g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
2360                            embedded_windows,
2361                            embedded_windows ?
2362                            (GDestroyNotify) g_list_free : NULL);
2363 }
2364
2365 static void
2366 gtk_window_dispose (GObject *object)
2367 {
2368   GtkWindow *window = GTK_WINDOW (object);
2369
2370   gtk_window_set_focus (window, NULL);
2371   gtk_window_set_default (window, NULL);
2372
2373   G_OBJECT_CLASS (gtk_window_parent_class)->dispose (object);
2374 }
2375
2376 static void
2377 parent_destroyed_callback (GtkWindow *parent, GtkWindow *child)
2378 {
2379   gtk_widget_destroy (GTK_WIDGET (child));
2380 }
2381
2382 static void
2383 connect_parent_destroyed (GtkWindow *window)
2384 {
2385   GtkWindowPrivate *priv = window->priv;
2386
2387   if (priv->transient_parent)
2388     {
2389       g_signal_connect (priv->transient_parent,
2390                         "destroy",
2391                         G_CALLBACK (parent_destroyed_callback),
2392                         window);
2393     }
2394 }
2395
2396 static void
2397 disconnect_parent_destroyed (GtkWindow *window)
2398 {
2399   GtkWindowPrivate *priv = window->priv;
2400
2401   if (priv->transient_parent)
2402     {
2403       g_signal_handlers_disconnect_by_func (priv->transient_parent,
2404                                             parent_destroyed_callback,
2405                                             window);
2406     }
2407 }
2408
2409 static void
2410 gtk_window_transient_parent_realized (GtkWidget *parent,
2411                                       GtkWidget *window)
2412 {
2413   if (gtk_widget_get_realized (window))
2414     gdk_window_set_transient_for (gtk_widget_get_window (window),
2415                                   gtk_widget_get_window (parent));
2416 }
2417
2418 static void
2419 gtk_window_transient_parent_unrealized (GtkWidget *parent,
2420                                         GtkWidget *window)
2421 {
2422   if (gtk_widget_get_realized (window))
2423     gdk_property_delete (gtk_widget_get_window (window),
2424                          gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
2425 }
2426
2427 static void
2428 gtk_window_transient_parent_screen_changed (GtkWindow   *parent,
2429                                             GParamSpec  *pspec,
2430                                             GtkWindow   *window)
2431 {
2432   gtk_window_set_screen (window, parent->priv->screen);
2433 }
2434
2435 static void
2436 gtk_window_unset_transient_for  (GtkWindow *window)
2437 {
2438   GtkWindowPrivate *priv = window->priv;
2439
2440   if (priv->transient_parent)
2441     {
2442       g_signal_handlers_disconnect_by_func (priv->transient_parent,
2443                                             gtk_window_transient_parent_realized,
2444                                             window);
2445       g_signal_handlers_disconnect_by_func (priv->transient_parent,
2446                                             gtk_window_transient_parent_unrealized,
2447                                             window);
2448       g_signal_handlers_disconnect_by_func (priv->transient_parent,
2449                                             gtk_window_transient_parent_screen_changed,
2450                                             window);
2451       g_signal_handlers_disconnect_by_func (priv->transient_parent,
2452                                             gtk_widget_destroyed,
2453                                             &priv->transient_parent);
2454
2455       if (priv->destroy_with_parent)
2456         disconnect_parent_destroyed (window);
2457
2458       priv->transient_parent = NULL;
2459
2460       if (priv->transient_parent_group)
2461         {
2462           priv->transient_parent_group = FALSE;
2463           gtk_window_group_remove_window (priv->group,
2464                                           window);
2465         }
2466     }
2467 }
2468
2469 /**
2470  * gtk_window_set_transient_for:
2471  * @window: a #GtkWindow
2472  * @parent: (allow-none): parent window, or %NULL
2473  *
2474  * Dialog windows should be set transient for the main application
2475  * window they were spawned from. This allows <link
2476  * linkend="gtk-X11-arch">window managers</link> to e.g. keep the
2477  * dialog on top of the main window, or center the dialog over the
2478  * main window. gtk_dialog_new_with_buttons() and other convenience
2479  * functions in GTK+ will sometimes call
2480  * gtk_window_set_transient_for() on your behalf.
2481  *
2482  * Passing %NULL for @parent unsets the current transient window.
2483  *
2484  * On Windows, this function puts the child window on top of the parent,
2485  * much as the window manager would have done on X.
2486  */
2487 void
2488 gtk_window_set_transient_for  (GtkWindow *window,
2489                                GtkWindow *parent)
2490 {
2491   GtkWindowPrivate *priv;
2492
2493   g_return_if_fail (GTK_IS_WINDOW (window));
2494   g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
2495   g_return_if_fail (window != parent);
2496
2497   priv = window->priv;
2498
2499   if (priv->transient_parent)
2500     {
2501       if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
2502           gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)) &&
2503           (!parent || !gtk_widget_get_realized (GTK_WIDGET (parent))))
2504         gtk_window_transient_parent_unrealized (GTK_WIDGET (priv->transient_parent),
2505                                                 GTK_WIDGET (window));
2506
2507       gtk_window_unset_transient_for (window);
2508     }
2509
2510   priv->transient_parent = parent;
2511
2512   if (parent)
2513     {
2514       g_signal_connect (parent, "destroy",
2515                         G_CALLBACK (gtk_widget_destroyed),
2516                         &priv->transient_parent);
2517       g_signal_connect (parent, "realize",
2518                         G_CALLBACK (gtk_window_transient_parent_realized),
2519                         window);
2520       g_signal_connect (parent, "unrealize",
2521                         G_CALLBACK (gtk_window_transient_parent_unrealized),
2522                         window);
2523       g_signal_connect (parent, "notify::screen",
2524                         G_CALLBACK (gtk_window_transient_parent_screen_changed),
2525                         window);
2526
2527       gtk_window_set_screen (window, parent->priv->screen);
2528
2529       if (priv->destroy_with_parent)
2530         connect_parent_destroyed (window);
2531
2532       if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
2533           gtk_widget_get_realized (GTK_WIDGET (parent)))
2534         gtk_window_transient_parent_realized (GTK_WIDGET (parent),
2535                                               GTK_WIDGET (window));
2536
2537       if (parent->priv->group)
2538         {
2539           gtk_window_group_add_window (parent->priv->group, window);
2540           priv->transient_parent_group = TRUE;
2541         }
2542     }
2543 }
2544
2545 /**
2546  * gtk_window_get_transient_for:
2547  * @window: a #GtkWindow
2548  *
2549  * Fetches the transient parent for this window. See
2550  * gtk_window_set_transient_for().
2551  *
2552  * Return value: (transfer none): the transient parent for this window, or %NULL
2553  *    if no transient parent has been set.
2554  **/
2555 GtkWindow *
2556 gtk_window_get_transient_for (GtkWindow *window)
2557 {
2558   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
2559
2560   return window->priv->transient_parent;
2561 }
2562
2563 /**
2564  * gtk_window_set_opacity:
2565  * @window: a #GtkWindow
2566  * @opacity: desired opacity, between 0 and 1
2567  *
2568  * Request the windowing system to make @window partially transparent,
2569  * with opacity 0 being fully transparent and 1 fully opaque. (Values
2570  * of the opacity parameter are clamped to the [0,1] range.) On X11
2571  * this has any effect only on X screens with a compositing manager
2572  * running. See gtk_widget_is_composited(). On Windows it should work
2573  * always.
2574  *
2575  * Note that setting a window's opacity after the window has been
2576  * shown causes it to flicker once on Windows.
2577  *
2578  * Since: 2.12
2579  **/
2580 void
2581 gtk_window_set_opacity  (GtkWindow *window,
2582                          gdouble    opacity)
2583 {
2584   GtkWindowPrivate *priv;
2585
2586   g_return_if_fail (GTK_IS_WINDOW (window));
2587
2588   priv = window->priv;
2589
2590   if (opacity < 0.0)
2591     opacity = 0.0;
2592   else if (opacity > 1.0)
2593     opacity = 1.0;
2594
2595   priv->opacity_set = TRUE;
2596   priv->opacity = opacity;
2597
2598   if (gtk_widget_get_realized (GTK_WIDGET (window)))
2599     gdk_window_set_opacity (gtk_widget_get_window (GTK_WIDGET (window)),
2600                             priv->opacity);
2601 }
2602
2603 /**
2604  * gtk_window_get_opacity:
2605  * @window: a #GtkWindow
2606  *
2607  * Fetches the requested opacity for this window. See
2608  * gtk_window_set_opacity().
2609  *
2610  * Return value: the requested opacity for this window.
2611  *
2612  * Since: 2.12
2613  **/
2614 gdouble
2615 gtk_window_get_opacity (GtkWindow *window)
2616 {
2617   g_return_val_if_fail (GTK_IS_WINDOW (window), 0.0);
2618
2619   return window->priv->opacity;
2620 }
2621
2622 /**
2623  * gtk_window_get_application:
2624  * @window: a #GtkWindow
2625  *
2626  * Gets the #GtkApplication associated with the window (if any).
2627  *
2628  * Return value: a #GtkApplication, or %NULL
2629  *
2630  * Since: 3.0
2631  **/
2632 GtkApplication *
2633 gtk_window_get_application (GtkWindow *window)
2634 {
2635   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
2636
2637   return window->priv->application;
2638 }
2639
2640 static void
2641 gtk_window_release_application (GtkWindow *window)
2642 {
2643   if (window->priv->application)
2644     {
2645       GtkApplication *application;
2646
2647       /* steal reference into temp variable */
2648       application = window->priv->application;
2649       window->priv->application = NULL;
2650
2651       gtk_application_remove_window (application, window);
2652       g_object_unref (application);
2653     }
2654 }
2655
2656 /**
2657  * gtk_window_set_application:
2658  * @window: a #GtkWindow
2659  * @application: a #GtkApplication, or %NULL
2660  *
2661  * Sets or unsets the #GtkApplication associated with the window.
2662  *
2663  * The application will be kept alive for at least as long as the window
2664  * is open.
2665  *
2666  * Since: 3.0
2667  **/
2668 void
2669 gtk_window_set_application (GtkWindow      *window,
2670                             GtkApplication *application)
2671 {
2672   GtkWindowPrivate *priv;
2673
2674   g_return_if_fail (GTK_IS_WINDOW (window));
2675
2676   priv = window->priv;
2677   if (priv->application != application)
2678     {
2679       gtk_window_release_application (window);
2680
2681       priv->application = application;
2682
2683       if (priv->application != NULL)
2684         {
2685           g_object_ref (priv->application);
2686
2687           gtk_application_add_window (priv->application, window);
2688         }
2689
2690       g_object_notify (G_OBJECT (window), "application");
2691     }
2692 }
2693
2694 /**
2695  * gtk_window_set_type_hint:
2696  * @window: a #GtkWindow
2697  * @hint: the window type
2698  *
2699  * By setting the type hint for the window, you allow the window
2700  * manager to decorate and handle the window in a way which is
2701  * suitable to the function of the window in your application.
2702  *
2703  * This function should be called before the window becomes visible.
2704  *
2705  * gtk_dialog_new_with_buttons() and other convenience functions in GTK+
2706  * will sometimes call gtk_window_set_type_hint() on your behalf.
2707  *
2708  **/
2709 void
2710 gtk_window_set_type_hint (GtkWindow           *window,
2711                           GdkWindowTypeHint    hint)
2712 {
2713   GtkWindowPrivate *priv;
2714
2715   g_return_if_fail (GTK_IS_WINDOW (window));
2716   g_return_if_fail (!gtk_widget_get_mapped (GTK_WIDGET (window)));
2717
2718   priv = window->priv;
2719
2720   if (hint < GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU)
2721     priv->gdk_type_hint = hint;
2722   else
2723     priv->gdk_type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
2724
2725   priv->reset_type_hint = TRUE;
2726   priv->type_hint = hint;
2727 }
2728
2729 /**
2730  * gtk_window_get_type_hint:
2731  * @window: a #GtkWindow
2732  *
2733  * Gets the type hint for this window. See gtk_window_set_type_hint().
2734  *
2735  * Return value: the type hint for @window.
2736  **/
2737 GdkWindowTypeHint
2738 gtk_window_get_type_hint (GtkWindow *window)
2739 {
2740   g_return_val_if_fail (GTK_IS_WINDOW (window), GDK_WINDOW_TYPE_HINT_NORMAL);
2741
2742   return window->priv->type_hint;
2743 }
2744
2745 /**
2746  * gtk_window_set_skip_taskbar_hint:
2747  * @window: a #GtkWindow
2748  * @setting: %TRUE to keep this window from appearing in the task bar
2749  *
2750  * Windows may set a hint asking the desktop environment not to display
2751  * the window in the task bar. This function sets this hint.
2752  *
2753  * Since: 2.2
2754  **/
2755 void
2756 gtk_window_set_skip_taskbar_hint (GtkWindow *window,
2757                                   gboolean   setting)
2758 {
2759   GtkWindowPrivate *priv;
2760
2761   g_return_if_fail (GTK_IS_WINDOW (window));
2762
2763   priv = window->priv;
2764
2765   setting = setting != FALSE;
2766
2767   if (priv->skips_taskbar != setting)
2768     {
2769       priv->skips_taskbar = setting;
2770       if (gtk_widget_get_realized (GTK_WIDGET (window)))
2771         gdk_window_set_skip_taskbar_hint (gtk_widget_get_window (GTK_WIDGET (window)),
2772                                           priv->skips_taskbar);
2773       g_object_notify (G_OBJECT (window), "skip-taskbar-hint");
2774     }
2775 }
2776
2777 /**
2778  * gtk_window_get_skip_taskbar_hint:
2779  * @window: a #GtkWindow
2780  *
2781  * Gets the value set by gtk_window_set_skip_taskbar_hint()
2782  *
2783  * Return value: %TRUE if window shouldn't be in taskbar
2784  *
2785  * Since: 2.2
2786  **/
2787 gboolean
2788 gtk_window_get_skip_taskbar_hint (GtkWindow *window)
2789 {
2790   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2791
2792   return window->priv->skips_taskbar;
2793 }
2794
2795 /**
2796  * gtk_window_set_skip_pager_hint:
2797  * @window: a #GtkWindow
2798  * @setting: %TRUE to keep this window from appearing in the pager
2799  *
2800  * Windows may set a hint asking the desktop environment not to display
2801  * the window in the pager. This function sets this hint.
2802  * (A "pager" is any desktop navigation tool such as a workspace
2803  * switcher that displays a thumbnail representation of the windows
2804  * on the screen.)
2805  *
2806  * Since: 2.2
2807  **/
2808 void
2809 gtk_window_set_skip_pager_hint (GtkWindow *window,
2810                                 gboolean   setting)
2811 {
2812   GtkWindowPrivate *priv;
2813
2814   g_return_if_fail (GTK_IS_WINDOW (window));
2815
2816   priv = window->priv;
2817
2818   setting = setting != FALSE;
2819
2820   if (priv->skips_pager != setting)
2821     {
2822       priv->skips_pager = setting;
2823       if (gtk_widget_get_realized (GTK_WIDGET (window)))
2824         gdk_window_set_skip_pager_hint (gtk_widget_get_window (GTK_WIDGET (window)),
2825                                         priv->skips_pager);
2826       g_object_notify (G_OBJECT (window), "skip-pager-hint");
2827     }
2828 }
2829
2830 /**
2831  * gtk_window_get_skip_pager_hint:
2832  * @window: a #GtkWindow
2833  *
2834  * Gets the value set by gtk_window_set_skip_pager_hint().
2835  *
2836  * Return value: %TRUE if window shouldn't be in pager
2837  *
2838  * Since: 2.2
2839  **/
2840 gboolean
2841 gtk_window_get_skip_pager_hint (GtkWindow *window)
2842 {
2843   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2844
2845   return window->priv->skips_pager;
2846 }
2847
2848 /**
2849  * gtk_window_set_urgency_hint:
2850  * @window: a #GtkWindow
2851  * @setting: %TRUE to mark this window as urgent
2852  *
2853  * Windows may set a hint asking the desktop environment to draw
2854  * the users attention to the window. This function sets this hint.
2855  *
2856  * Since: 2.8
2857  **/
2858 void
2859 gtk_window_set_urgency_hint (GtkWindow *window,
2860                              gboolean   setting)
2861 {
2862   GtkWindowPrivate *priv;
2863
2864   g_return_if_fail (GTK_IS_WINDOW (window));
2865
2866   priv = window->priv;
2867
2868   setting = setting != FALSE;
2869
2870   if (priv->urgent != setting)
2871     {
2872       priv->urgent = setting;
2873       if (gtk_widget_get_realized (GTK_WIDGET (window)))
2874         gdk_window_set_urgency_hint (gtk_widget_get_window (GTK_WIDGET (window)),
2875                                      priv->urgent);
2876       g_object_notify (G_OBJECT (window), "urgency-hint");
2877     }
2878 }
2879
2880 /**
2881  * gtk_window_get_urgency_hint:
2882  * @window: a #GtkWindow
2883  *
2884  * Gets the value set by gtk_window_set_urgency_hint()
2885  *
2886  * Return value: %TRUE if window is urgent
2887  *
2888  * Since: 2.8
2889  **/
2890 gboolean
2891 gtk_window_get_urgency_hint (GtkWindow *window)
2892 {
2893   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2894
2895   return window->priv->urgent;
2896 }
2897
2898 /**
2899  * gtk_window_set_accept_focus:
2900  * @window: a #GtkWindow
2901  * @setting: %TRUE to let this window receive input focus
2902  *
2903  * Windows may set a hint asking the desktop environment not to receive
2904  * the input focus. This function sets this hint.
2905  *
2906  * Since: 2.4
2907  **/
2908 void
2909 gtk_window_set_accept_focus (GtkWindow *window,
2910                              gboolean   setting)
2911 {
2912   GtkWindowPrivate *priv;
2913
2914   g_return_if_fail (GTK_IS_WINDOW (window));
2915
2916   priv = window->priv;
2917
2918   setting = setting != FALSE;
2919
2920   if (priv->accept_focus != setting)
2921     {
2922       priv->accept_focus = setting;
2923       if (gtk_widget_get_realized (GTK_WIDGET (window)))
2924         gdk_window_set_accept_focus (gtk_widget_get_window (GTK_WIDGET (window)),
2925                                      priv->accept_focus);
2926       g_object_notify (G_OBJECT (window), "accept-focus");
2927     }
2928 }
2929
2930 /**
2931  * gtk_window_get_accept_focus:
2932  * @window: a #GtkWindow
2933  *
2934  * Gets the value set by gtk_window_set_accept_focus().
2935  *
2936  * Return value: %TRUE if window should receive the input focus
2937  *
2938  * Since: 2.4
2939  **/
2940 gboolean
2941 gtk_window_get_accept_focus (GtkWindow *window)
2942 {
2943   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2944
2945   return window->priv->accept_focus;
2946 }
2947
2948 /**
2949  * gtk_window_set_focus_on_map:
2950  * @window: a #GtkWindow
2951  * @setting: %TRUE to let this window receive input focus on map
2952  *
2953  * Windows may set a hint asking the desktop environment not to receive
2954  * the input focus when the window is mapped.  This function sets this
2955  * hint.
2956  *
2957  * Since: 2.6
2958  **/
2959 void
2960 gtk_window_set_focus_on_map (GtkWindow *window,
2961                              gboolean   setting)
2962 {
2963   GtkWindowPrivate *priv;
2964
2965   g_return_if_fail (GTK_IS_WINDOW (window));
2966
2967   priv = window->priv;
2968
2969   setting = setting != FALSE;
2970
2971   if (priv->focus_on_map != setting)
2972     {
2973       priv->focus_on_map = setting;
2974       if (gtk_widget_get_realized (GTK_WIDGET (window)))
2975         gdk_window_set_focus_on_map (gtk_widget_get_window (GTK_WIDGET (window)),
2976                                      priv->focus_on_map);
2977       g_object_notify (G_OBJECT (window), "focus-on-map");
2978     }
2979 }
2980
2981 /**
2982  * gtk_window_get_focus_on_map:
2983  * @window: a #GtkWindow
2984  *
2985  * Gets the value set by gtk_window_set_focus_on_map().
2986  *
2987  * Return value: %TRUE if window should receive the input focus when
2988  * mapped.
2989  *
2990  * Since: 2.6
2991  **/
2992 gboolean
2993 gtk_window_get_focus_on_map (GtkWindow *window)
2994 {
2995   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
2996
2997   return window->priv->focus_on_map;
2998 }
2999
3000 /**
3001  * gtk_window_set_destroy_with_parent:
3002  * @window: a #GtkWindow
3003  * @setting: whether to destroy @window with its transient parent
3004  *
3005  * If @setting is %TRUE, then destroying the transient parent of @window
3006  * will also destroy @window itself. This is useful for dialogs that
3007  * shouldn't persist beyond the lifetime of the main window they're
3008  * associated with, for example.
3009  **/
3010 void
3011 gtk_window_set_destroy_with_parent  (GtkWindow *window,
3012                                      gboolean   setting)
3013 {
3014   GtkWindowPrivate *priv;
3015
3016   g_return_if_fail (GTK_IS_WINDOW (window));
3017
3018   priv = window->priv;
3019
3020   if (priv->destroy_with_parent == (setting != FALSE))
3021     return;
3022
3023   if (priv->destroy_with_parent)
3024     {
3025       disconnect_parent_destroyed (window);
3026     }
3027   else
3028     {
3029       connect_parent_destroyed (window);
3030     }
3031
3032   priv->destroy_with_parent = setting;
3033
3034   g_object_notify (G_OBJECT (window), "destroy-with-parent");
3035 }
3036
3037 /**
3038  * gtk_window_get_destroy_with_parent:
3039  * @window: a #GtkWindow
3040  *
3041  * Returns whether the window will be destroyed with its transient parent. See
3042  * gtk_window_set_destroy_with_parent ().
3043  *
3044  * Return value: %TRUE if the window will be destroyed with its transient parent.
3045  **/
3046 gboolean
3047 gtk_window_get_destroy_with_parent (GtkWindow *window)
3048 {
3049   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
3050
3051   return window->priv->destroy_with_parent;
3052 }
3053
3054 static GtkWindowGeometryInfo*
3055 gtk_window_get_geometry_info (GtkWindow *window,
3056                               gboolean   create)
3057 {
3058   GtkWindowPrivate *priv = window->priv;
3059   GtkWindowGeometryInfo *info;
3060
3061   info = priv->geometry_info;
3062   if (!info && create)
3063     {
3064       info = g_new0 (GtkWindowGeometryInfo, 1);
3065
3066       info->default_width = -1;
3067       info->default_height = -1;
3068       info->resize_width = -1;
3069       info->resize_height = -1;
3070       info->initial_x = 0;
3071       info->initial_y = 0;
3072       info->initial_pos_set = FALSE;
3073       info->default_is_geometry = FALSE;
3074       info->position_constraints_changed = FALSE;
3075       info->last.configure_request.x = 0;
3076       info->last.configure_request.y = 0;
3077       info->last.configure_request.width = -1;
3078       info->last.configure_request.height = -1;
3079       info->widget = NULL;
3080       info->mask = 0;
3081       priv->geometry_info = info;
3082     }
3083
3084   return info;
3085 }
3086
3087 /**
3088  * gtk_window_set_geometry_hints:
3089  * @window: a #GtkWindow
3090  * @geometry_widget: (allow-none): widget the geometry hints will be applied to or %NULL
3091  * @geometry: (allow-none): struct containing geometry information or %NULL
3092  * @geom_mask: mask indicating which struct fields should be paid attention to
3093  *
3094  * This function sets up hints about how a window can be resized by
3095  * the user.  You can set a minimum and maximum size; allowed resize
3096  * increments (e.g. for xterm, you can only resize by the size of a
3097  * character); aspect ratios; and more. See the #GdkGeometry struct.
3098  *
3099  **/
3100 void
3101 gtk_window_set_geometry_hints (GtkWindow       *window,
3102                                GtkWidget       *geometry_widget,
3103                                GdkGeometry     *geometry,
3104                                GdkWindowHints   geom_mask)
3105 {
3106   GtkWindowGeometryInfo *info;
3107
3108   g_return_if_fail (GTK_IS_WINDOW (window));
3109   g_return_if_fail (geometry_widget == NULL || GTK_IS_WIDGET (geometry_widget));
3110
3111   info = gtk_window_get_geometry_info (window, TRUE);
3112
3113   if (info->widget)
3114     g_signal_handlers_disconnect_by_func (info->widget,
3115                                           gtk_widget_destroyed,
3116                                           &info->widget);
3117
3118   info->widget = geometry_widget;
3119   if (info->widget)
3120     g_signal_connect (geometry_widget, "destroy",
3121                       G_CALLBACK (gtk_widget_destroyed),
3122                       &info->widget);
3123
3124   if (geometry)
3125     info->geometry = *geometry;
3126
3127   /* We store gravity in priv->gravity not in the hints. */
3128   info->mask = geom_mask & ~(GDK_HINT_WIN_GRAVITY);
3129
3130   if (geom_mask & GDK_HINT_WIN_GRAVITY)
3131     {
3132       gtk_window_set_gravity (window, geometry->win_gravity);
3133     }
3134
3135   gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
3136 }
3137
3138 /**
3139  * gtk_window_set_decorated:
3140  * @window: a #GtkWindow
3141  * @setting: %TRUE to decorate the window
3142  *
3143  * By default, windows are decorated with a title bar, resize
3144  * controls, etc.  Some <link linkend="gtk-X11-arch">window
3145  * managers</link> allow GTK+ to disable these decorations, creating a
3146  * borderless window. If you set the decorated property to %FALSE
3147  * using this function, GTK+ will do its best to convince the window
3148  * manager not to decorate the window. Depending on the system, this
3149  * function may not have any effect when called on a window that is
3150  * already visible, so you should call it before calling gtk_window_show().
3151  *
3152  * On Windows, this function always works, since there's no window manager
3153  * policy involved.
3154  *
3155  **/
3156 void
3157 gtk_window_set_decorated (GtkWindow *window,
3158                           gboolean   setting)
3159 {
3160   GtkWindowPrivate *priv;
3161   GdkWindow *gdk_window;
3162
3163   g_return_if_fail (GTK_IS_WINDOW (window));
3164
3165   priv = window->priv;
3166
3167   setting = setting != FALSE;
3168
3169   if (setting == priv->decorated)
3170     return;
3171
3172   priv->decorated = setting;
3173
3174   gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
3175   if (gdk_window)
3176     {
3177       if (priv->decorated)
3178         gdk_window_set_decorations (gdk_window,
3179                                     GDK_DECOR_ALL);
3180       else
3181         gdk_window_set_decorations (gdk_window,
3182                                     0);
3183     }
3184
3185   g_object_notify (G_OBJECT (window), "decorated");
3186 }
3187
3188 /**
3189  * gtk_window_get_decorated:
3190  * @window: a #GtkWindow
3191  *
3192  * Returns whether the window has been set to have decorations
3193  * such as a title bar via gtk_window_set_decorated().
3194  *
3195  * Return value: %TRUE if the window has been set to have decorations
3196  **/
3197 gboolean
3198 gtk_window_get_decorated (GtkWindow *window)
3199 {
3200   g_return_val_if_fail (GTK_IS_WINDOW (window), TRUE);
3201
3202   return window->priv->decorated;
3203 }
3204
3205 /**
3206  * gtk_window_set_deletable:
3207  * @window: a #GtkWindow
3208  * @setting: %TRUE to decorate the window as deletable
3209  *
3210  * By default, windows have a close button in the window frame. Some
3211  * <link linkend="gtk-X11-arch">window managers</link> allow GTK+ to
3212  * disable this button. If you set the deletable property to %FALSE
3213  * using this function, GTK+ will do its best to convince the window
3214  * manager not to show a close button. Depending on the system, this
3215  * function may not have any effect when called on a window that is
3216  * already visible, so you should call it before calling gtk_window_show().
3217  *
3218  * On Windows, this function always works, since there's no window manager
3219  * policy involved.
3220  *
3221  * Since: 2.10
3222  */
3223 void
3224 gtk_window_set_deletable (GtkWindow *window,
3225                           gboolean   setting)
3226 {
3227   GtkWindowPrivate *priv;
3228   GdkWindow *gdk_window;
3229
3230   g_return_if_fail (GTK_IS_WINDOW (window));
3231
3232   priv = window->priv;
3233
3234   setting = setting != FALSE;
3235
3236   if (setting == priv->deletable)
3237     return;
3238
3239   priv->deletable = setting;
3240
3241   gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
3242   if (gdk_window)
3243     {
3244       if (priv->deletable)
3245         gdk_window_set_functions (gdk_window,
3246                                   GDK_FUNC_ALL);
3247       else
3248         gdk_window_set_functions (gdk_window,
3249                                   GDK_FUNC_ALL | GDK_FUNC_CLOSE);
3250     }
3251
3252   g_object_notify (G_OBJECT (window), "deletable");
3253 }
3254
3255 /**
3256  * gtk_window_get_deletable:
3257  * @window: a #GtkWindow
3258  *
3259  * Returns whether the window has been set to have a close button
3260  * via gtk_window_set_deletable().
3261  *
3262  * Return value: %TRUE if the window has been set to have a close button
3263  *
3264  * Since: 2.10
3265  **/
3266 gboolean
3267 gtk_window_get_deletable (GtkWindow *window)
3268 {
3269   g_return_val_if_fail (GTK_IS_WINDOW (window), TRUE);
3270
3271   return window->priv->deletable;
3272 }
3273
3274 static GtkWindowIconInfo*
3275 get_icon_info (GtkWindow *window)
3276 {
3277   return g_object_get_qdata (G_OBJECT (window), quark_gtk_window_icon_info);
3278 }
3279
3280 static void
3281 free_icon_info (GtkWindowIconInfo *info)
3282 {
3283   g_free (info->icon_name);
3284   g_slice_free (GtkWindowIconInfo, info);
3285 }
3286
3287
3288 static GtkWindowIconInfo*
3289 ensure_icon_info (GtkWindow *window)
3290 {
3291   GtkWindowIconInfo *info;
3292
3293   info = get_icon_info (window);
3294
3295   if (info == NULL)
3296     {
3297       info = g_slice_new0 (GtkWindowIconInfo);
3298       g_object_set_qdata_full (G_OBJECT (window),
3299                               quark_gtk_window_icon_info,
3300                               info,
3301                               (GDestroyNotify)free_icon_info);
3302     }
3303
3304   return info;
3305 }
3306
3307 static GList *
3308 icon_list_from_theme (GtkWidget    *widget,
3309                       const gchar  *name)
3310 {
3311   GList *list;
3312
3313   GtkIconTheme *icon_theme;
3314   GdkPixbuf *icon;
3315   gint *sizes;
3316   gint i;
3317
3318   icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
3319
3320   sizes = gtk_icon_theme_get_icon_sizes (icon_theme, name);
3321
3322   list = NULL;
3323   for (i = 0; sizes[i]; i++)
3324     {
3325       /* FIXME
3326        * We need an EWMH extension to handle scalable icons
3327        * by passing their name to the WM. For now just use a
3328        * fixed size of 48.
3329        */
3330       if (sizes[i] == -1)
3331         icon = gtk_icon_theme_load_icon (icon_theme, name,
3332                                          48, 0, NULL);
3333       else
3334         icon = gtk_icon_theme_load_icon (icon_theme, name,
3335                                          sizes[i], 0, NULL);
3336       if (icon)
3337         list = g_list_append (list, icon);
3338     }
3339
3340   g_free (sizes);
3341
3342   return list;
3343 }
3344
3345
3346 static void
3347 gtk_window_realize_icon (GtkWindow *window)
3348 {
3349   GtkWindowPrivate *priv = window->priv;
3350   GtkWidget *widget;
3351   GtkWindowIconInfo *info;
3352   GdkWindow *gdk_window;
3353   GList *icon_list;
3354
3355   widget = GTK_WIDGET (window);
3356   gdk_window = gtk_widget_get_window (widget);
3357
3358   g_return_if_fail (gdk_window != NULL);
3359
3360   /* no point setting an icon on override-redirect */
3361   if (priv->type == GTK_WINDOW_POPUP)
3362     return;
3363
3364   icon_list = NULL;
3365
3366   info = ensure_icon_info (window);
3367
3368   if (info->realized)
3369     return;
3370
3371   info->using_default_icon = FALSE;
3372   info->using_parent_icon = FALSE;
3373   info->using_themed_icon = FALSE;
3374
3375   icon_list = info->icon_list;
3376
3377   /* Look up themed icon */
3378   if (icon_list == NULL && info->icon_name)
3379     {
3380       icon_list = icon_list_from_theme (widget, info->icon_name);
3381       if (icon_list)
3382         info->using_themed_icon = TRUE;
3383     }
3384
3385   /* Inherit from transient parent */
3386   if (icon_list == NULL && priv->transient_parent)
3387     {
3388       icon_list = ensure_icon_info (priv->transient_parent)->icon_list;
3389       if (icon_list)
3390         info->using_parent_icon = TRUE;
3391     }
3392
3393   /* Inherit from default */
3394   if (icon_list == NULL)
3395     {
3396       icon_list = default_icon_list;
3397       if (icon_list)
3398         info->using_default_icon = TRUE;
3399     }
3400
3401   /* Look up themed icon */
3402   if (icon_list == NULL && default_icon_name)
3403     {
3404       icon_list = icon_list_from_theme (widget, default_icon_name);
3405       info->using_default_icon = TRUE;
3406       info->using_themed_icon = TRUE;
3407     }
3408
3409   info->realized = TRUE;
3410
3411   gdk_window_set_icon_list (gtk_widget_get_window (widget), icon_list);
3412
3413   if (info->using_themed_icon)
3414     {
3415       GtkIconTheme *icon_theme;
3416
3417       g_list_foreach (icon_list, (GFunc) g_object_unref, NULL);
3418       g_list_free (icon_list);
3419
3420       icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
3421       g_signal_connect (icon_theme, "changed",
3422                         G_CALLBACK (update_themed_icon), window);
3423     }
3424 }
3425
3426 static void
3427 gtk_window_unrealize_icon (GtkWindow *window)
3428 {
3429   GtkWindowIconInfo *info;
3430
3431   info = get_icon_info (window);
3432
3433   if (info == NULL)
3434     return;
3435
3436   if (info->using_themed_icon)
3437     {
3438       GtkIconTheme *icon_theme;
3439
3440       icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
3441
3442       g_signal_handlers_disconnect_by_func (icon_theme, update_themed_icon, window);
3443     }
3444
3445   /* We don't clear the properties on the window, just figure the
3446    * window is going away.
3447    */
3448
3449   info->realized = FALSE;
3450
3451 }
3452
3453 /**
3454  * gtk_window_set_icon_list:
3455  * @window: a #GtkWindow
3456  * @list: (element-type GdkPixbuf) (transfer container): list of #GdkPixbuf
3457  *
3458  * Sets up the icon representing a #GtkWindow. The icon is used when
3459  * the window is minimized (also known as iconified).  Some window
3460  * managers or desktop environments may also place it in the window
3461  * frame, or display it in other contexts.
3462  *
3463  * gtk_window_set_icon_list() allows you to pass in the same icon in
3464  * several hand-drawn sizes. The list should contain the natural sizes
3465  * your icon is available in; that is, don't scale the image before
3466  * passing it to GTK+. Scaling is postponed until the last minute,
3467  * when the desired final size is known, to allow best quality.
3468  *
3469  * By passing several sizes, you may improve the final image quality
3470  * of the icon, by reducing or eliminating automatic image scaling.
3471  *
3472  * Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and
3473  * larger images (64x64, 128x128) if you have them.
3474  *
3475  * See also gtk_window_set_default_icon_list() to set the icon
3476  * for all windows in your application in one go.
3477  *
3478  * Note that transient windows (those who have been set transient for another
3479  * window using gtk_window_set_transient_for()) will inherit their
3480  * icon from their transient parent. So there's no need to explicitly
3481  * set the icon on transient windows.
3482  **/
3483 void
3484 gtk_window_set_icon_list (GtkWindow  *window,
3485                           GList      *list)
3486 {
3487   GtkWindowIconInfo *info;
3488
3489   g_return_if_fail (GTK_IS_WINDOW (window));
3490
3491   info = ensure_icon_info (window);
3492
3493   if (info->icon_list == list) /* check for NULL mostly */
3494     return;
3495
3496   g_list_foreach (list,
3497                   (GFunc) g_object_ref, NULL);
3498
3499   g_list_foreach (info->icon_list,
3500                   (GFunc) g_object_unref, NULL);
3501
3502   g_list_free (info->icon_list);
3503
3504   info->icon_list = g_list_copy (list);
3505
3506   g_object_notify (G_OBJECT (window), "icon");
3507
3508   gtk_window_unrealize_icon (window);
3509
3510   if (gtk_widget_get_realized (GTK_WIDGET (window)))
3511     gtk_window_realize_icon (window);
3512
3513   /* We could try to update our transient children, but I don't think
3514    * it's really worth it. If we did it, the best way would probably
3515    * be to have children connect to notify::icon-list
3516    */
3517 }
3518
3519 /**
3520  * gtk_window_get_icon_list:
3521  * @window: a #GtkWindow
3522  *
3523  * Retrieves the list of icons set by gtk_window_set_icon_list().
3524  * The list is copied, but the reference count on each
3525  * member won't be incremented.
3526  *
3527  * Return value: (element-type GdkPixbuf) (transfer container): copy of window's icon list
3528  **/
3529 GList*
3530 gtk_window_get_icon_list (GtkWindow  *window)
3531 {
3532   GtkWindowIconInfo *info;
3533
3534   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
3535
3536   info = get_icon_info (window);
3537
3538   if (info)
3539     return g_list_copy (info->icon_list);
3540   else
3541     return NULL;
3542 }
3543
3544 /**
3545  * gtk_window_set_icon:
3546  * @window: a #GtkWindow
3547  * @icon: (allow-none): icon image, or %NULL
3548  *
3549  * Sets up the icon representing a #GtkWindow. This icon is used when
3550  * the window is minimized (also known as iconified).  Some window
3551  * managers or desktop environments may also place it in the window
3552  * frame, or display it in other contexts.
3553  *
3554  * The icon should be provided in whatever size it was naturally
3555  * drawn; that is, don't scale the image before passing it to
3556  * GTK+. Scaling is postponed until the last minute, when the desired
3557  * final size is known, to allow best quality.
3558  *
3559  * If you have your icon hand-drawn in multiple sizes, use
3560  * gtk_window_set_icon_list(). Then the best size will be used.
3561  *
3562  * This function is equivalent to calling gtk_window_set_icon_list()
3563  * with a 1-element list.
3564  *
3565  * See also gtk_window_set_default_icon_list() to set the icon
3566  * for all windows in your application in one go.
3567  **/
3568 void
3569 gtk_window_set_icon (GtkWindow  *window,
3570                      GdkPixbuf  *icon)
3571 {
3572   GList *list;
3573
3574   g_return_if_fail (GTK_IS_WINDOW (window));
3575   g_return_if_fail (icon == NULL || GDK_IS_PIXBUF (icon));
3576
3577   list = NULL;
3578
3579   if (icon)
3580     list = g_list_append (list, icon);
3581
3582   gtk_window_set_icon_list (window, list);
3583   g_list_free (list);
3584 }
3585
3586
3587 static void
3588 update_themed_icon (GtkIconTheme *icon_theme,
3589                     GtkWindow    *window)
3590 {
3591   g_object_notify (G_OBJECT (window), "icon");
3592
3593   gtk_window_unrealize_icon (window);
3594
3595   if (gtk_widget_get_realized (GTK_WIDGET (window)))
3596     gtk_window_realize_icon (window);
3597 }
3598
3599 /**
3600  * gtk_window_set_icon_name:
3601  * @window: a #GtkWindow
3602  * @name: (allow-none): the name of the themed icon
3603  *
3604  * Sets the icon for the window from a named themed icon. See
3605  * the docs for #GtkIconTheme for more details.
3606  *
3607  * Note that this has nothing to do with the WM_ICON_NAME
3608  * property which is mentioned in the ICCCM.
3609  *
3610  * Since: 2.6
3611  */
3612 void
3613 gtk_window_set_icon_name (GtkWindow   *window,
3614                           const gchar *name)
3615 {
3616   GtkWindowIconInfo *info;
3617   gchar *tmp;
3618
3619   g_return_if_fail (GTK_IS_WINDOW (window));
3620
3621   info = ensure_icon_info (window);
3622
3623   if (g_strcmp0 (info->icon_name, name) == 0)
3624     return;
3625
3626   tmp = info->icon_name;
3627   info->icon_name = g_strdup (name);
3628   g_free (tmp);
3629
3630   g_list_foreach (info->icon_list, (GFunc) g_object_unref, NULL);
3631   g_list_free (info->icon_list);
3632   info->icon_list = NULL;
3633
3634   update_themed_icon (NULL, window);
3635
3636   g_object_notify (G_OBJECT (window), "icon-name");
3637 }
3638
3639 /**
3640  * gtk_window_get_icon_name:
3641  * @window: a #GtkWindow
3642  *
3643  * Returns the name of the themed icon for the window,
3644  * see gtk_window_set_icon_name().
3645  *
3646  * Returns: the icon name or %NULL if the window has
3647  * no themed icon
3648  *
3649  * Since: 2.6
3650  */
3651 const gchar *
3652 gtk_window_get_icon_name (GtkWindow *window)
3653 {
3654   GtkWindowIconInfo *info;
3655
3656   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
3657
3658   info = ensure_icon_info (window);
3659
3660   return info->icon_name;
3661 }
3662
3663 /**
3664  * gtk_window_get_icon:
3665  * @window: a #GtkWindow
3666  *
3667  * Gets the value set by gtk_window_set_icon() (or if you've
3668  * called gtk_window_set_icon_list(), gets the first icon in
3669  * the icon list).
3670  *
3671  * Return value: (transfer none): icon for window
3672  **/
3673 GdkPixbuf*
3674 gtk_window_get_icon (GtkWindow  *window)
3675 {
3676   GtkWindowIconInfo *info;
3677
3678   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
3679
3680   info = get_icon_info (window);
3681   if (info && info->icon_list)
3682     return GDK_PIXBUF (info->icon_list->data);
3683   else
3684     return NULL;
3685 }
3686
3687 /* Load pixbuf, printing warning on failure if error == NULL
3688  */
3689 static GdkPixbuf *
3690 load_pixbuf_verbosely (const char *filename,
3691                        GError    **err)
3692 {
3693   GError *local_err = NULL;
3694   GdkPixbuf *pixbuf;
3695
3696   pixbuf = gdk_pixbuf_new_from_file (filename, &local_err);
3697
3698   if (!pixbuf)
3699     {
3700       if (err)
3701         *err = local_err;
3702       else
3703         {
3704           g_warning ("Error loading icon from file '%s':\n\t%s",
3705                      filename, local_err->message);
3706           g_error_free (local_err);
3707         }
3708     }
3709
3710   return pixbuf;
3711 }
3712
3713 /**
3714  * gtk_window_set_icon_from_file:
3715  * @window: a #GtkWindow
3716  * @filename: location of icon file
3717  * @err: (allow-none): location to store error, or %NULL.
3718  *
3719  * Sets the icon for @window.
3720  * Warns on failure if @err is %NULL.
3721  *
3722  * This function is equivalent to calling gtk_window_set_icon()
3723  * with a pixbuf created by loading the image from @filename.
3724  *
3725  * Returns: %TRUE if setting the icon succeeded.
3726  *
3727  * Since: 2.2
3728  **/
3729 gboolean
3730 gtk_window_set_icon_from_file (GtkWindow   *window,
3731                                const gchar *filename,
3732                                GError     **err)
3733 {
3734   GdkPixbuf *pixbuf = load_pixbuf_verbosely (filename, err);
3735
3736   if (pixbuf)
3737     {
3738       gtk_window_set_icon (window, pixbuf);
3739       g_object_unref (pixbuf);
3740
3741       return TRUE;
3742     }
3743   else
3744     return FALSE;
3745 }
3746
3747 /**
3748  * gtk_window_set_default_icon_list:
3749  * @list: (element-type GdkPixbuf) (transfer container): a list of #GdkPixbuf
3750  *
3751  * Sets an icon list to be used as fallback for windows that haven't
3752  * had gtk_window_set_icon_list() called on them to set up a
3753  * window-specific icon list. This function allows you to set up the
3754  * icon for all windows in your app at once.
3755  *
3756  * See gtk_window_set_icon_list() for more details.
3757  *
3758  **/
3759 void
3760 gtk_window_set_default_icon_list (GList *list)
3761 {
3762   GList *toplevels;
3763   GList *tmp_list;
3764   if (list == default_icon_list)
3765     return;
3766
3767   /* Update serial so we don't used cached pixmaps/masks
3768    */
3769   default_icon_serial++;
3770
3771   g_list_foreach (list,
3772                   (GFunc) g_object_ref, NULL);
3773
3774   g_list_foreach (default_icon_list,
3775                   (GFunc) g_object_unref, NULL);
3776
3777   g_list_free (default_icon_list);
3778
3779   default_icon_list = g_list_copy (list);
3780
3781   /* Update all toplevels */
3782   toplevels = gtk_window_list_toplevels ();
3783   tmp_list = toplevels;
3784   while (tmp_list != NULL)
3785     {
3786       GtkWindowIconInfo *info;
3787       GtkWindow *w = tmp_list->data;
3788
3789       info = get_icon_info (w);
3790       if (info && info->using_default_icon)
3791         {
3792           gtk_window_unrealize_icon (w);
3793           if (gtk_widget_get_realized (GTK_WIDGET (w)))
3794             gtk_window_realize_icon (w);
3795         }
3796
3797       tmp_list = tmp_list->next;
3798     }
3799   g_list_free (toplevels);
3800 }
3801
3802 /**
3803  * gtk_window_set_default_icon:
3804  * @icon: the icon
3805  *
3806  * Sets an icon to be used as fallback for windows that haven't
3807  * had gtk_window_set_icon() called on them from a pixbuf.
3808  *
3809  * Since: 2.4
3810  **/
3811 void
3812 gtk_window_set_default_icon (GdkPixbuf *icon)
3813 {
3814   GList *list;
3815
3816   g_return_if_fail (GDK_IS_PIXBUF (icon));
3817
3818   list = g_list_prepend (NULL, icon);
3819   gtk_window_set_default_icon_list (list);
3820   g_list_free (list);
3821 }
3822
3823 /**
3824  * gtk_window_set_default_icon_name:
3825  * @name: the name of the themed icon
3826  *
3827  * Sets an icon to be used as fallback for windows that haven't
3828  * had gtk_window_set_icon_list() called on them from a named
3829  * themed icon, see gtk_window_set_icon_name().
3830  *
3831  * Since: 2.6
3832  **/
3833 void
3834 gtk_window_set_default_icon_name (const gchar *name)
3835 {
3836   GList *tmp_list;
3837   GList *toplevels;
3838
3839   /* Update serial so we don't used cached pixmaps/masks
3840    */
3841   default_icon_serial++;
3842
3843   g_free (default_icon_name);
3844   default_icon_name = g_strdup (name);
3845
3846   g_list_foreach (default_icon_list,
3847                   (GFunc) g_object_unref, NULL);
3848
3849   g_list_free (default_icon_list);
3850   default_icon_list = NULL;
3851
3852   /* Update all toplevels */
3853   toplevels = gtk_window_list_toplevels ();
3854   tmp_list = toplevels;
3855   while (tmp_list != NULL)
3856     {
3857       GtkWindowIconInfo *info;
3858       GtkWindow *w = tmp_list->data;
3859
3860       info = get_icon_info (w);
3861       if (info && info->using_default_icon && info->using_themed_icon)
3862         {
3863           gtk_window_unrealize_icon (w);
3864           if (gtk_widget_get_realized (GTK_WIDGET (w)))
3865             gtk_window_realize_icon (w);
3866         }
3867
3868       tmp_list = tmp_list->next;
3869     }
3870   g_list_free (toplevels);
3871 }
3872
3873 /**
3874  * gtk_window_get_default_icon_name:
3875  *
3876  * Returns the fallback icon name for windows that has been set
3877  * with gtk_window_set_default_icon_name(). The returned
3878  * string is owned by GTK+ and should not be modified. It
3879  * is only valid until the next call to
3880  * gtk_window_set_default_icon_name().
3881  *
3882  * Returns: the fallback icon name for windows
3883  *
3884  * Since: 2.16
3885  */
3886 const gchar *
3887 gtk_window_get_default_icon_name (void)
3888 {
3889   return default_icon_name;
3890 }
3891
3892 /**
3893  * gtk_window_set_default_icon_from_file:
3894  * @filename: location of icon file
3895  * @err: (allow-none): location to store error, or %NULL.
3896  *
3897  * Sets an icon to be used as fallback for windows that haven't
3898  * had gtk_window_set_icon_list() called on them from a file
3899  * on disk. Warns on failure if @err is %NULL.
3900  *
3901  * Returns: %TRUE if setting the icon succeeded.
3902  *
3903  * Since: 2.2
3904  **/
3905 gboolean
3906 gtk_window_set_default_icon_from_file (const gchar *filename,
3907                                        GError     **err)
3908 {
3909   GdkPixbuf *pixbuf = load_pixbuf_verbosely (filename, err);
3910
3911   if (pixbuf)
3912     {
3913       gtk_window_set_default_icon (pixbuf);
3914       g_object_unref (pixbuf);
3915
3916       return TRUE;
3917     }
3918   else
3919     return FALSE;
3920 }
3921
3922 /**
3923  * gtk_window_get_default_icon_list:
3924  *
3925  * Gets the value set by gtk_window_set_default_icon_list().
3926  * The list is a copy and should be freed with g_list_free(),
3927  * but the pixbufs in the list have not had their reference count
3928  * incremented.
3929  *
3930  * Return value: (element-type GdkPixbuf) (transfer container): copy of default icon list
3931  **/
3932 GList*
3933 gtk_window_get_default_icon_list (void)
3934 {
3935   return g_list_copy (default_icon_list);
3936 }
3937
3938 static void
3939 gtk_window_set_default_size_internal (GtkWindow    *window,
3940                                       gboolean      change_width,
3941                                       gint          width,
3942                                       gboolean      change_height,
3943                                       gint          height,
3944                                       gboolean      is_geometry)
3945 {
3946   GtkWindowGeometryInfo *info;
3947
3948   g_return_if_fail (change_width == FALSE || width >= -1);
3949   g_return_if_fail (change_height == FALSE || height >= -1);
3950
3951   info = gtk_window_get_geometry_info (window, TRUE);
3952
3953   g_object_freeze_notify (G_OBJECT (window));
3954
3955   info->default_is_geometry = is_geometry != FALSE;
3956
3957   if (change_width)
3958     {
3959       if (width == 0)
3960         width = 1;
3961
3962       if (width < 0)
3963         width = -1;
3964
3965       info->default_width = width;
3966
3967       g_object_notify (G_OBJECT (window), "default-width");
3968     }
3969
3970   if (change_height)
3971     {
3972       if (height == 0)
3973         height = 1;
3974
3975       if (height < 0)
3976         height = -1;
3977
3978       info->default_height = height;
3979
3980       g_object_notify (G_OBJECT (window), "default-height");
3981     }
3982
3983   g_object_thaw_notify (G_OBJECT (window));
3984
3985   gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
3986 }
3987
3988 /**
3989  * gtk_window_set_default_size:
3990  * @window: a #GtkWindow
3991  * @width: width in pixels, or -1 to unset the default width
3992  * @height: height in pixels, or -1 to unset the default height
3993  *
3994  * Sets the default size of a window. If the window's "natural" size
3995  * (its size request) is larger than the default, the default will be
3996  * ignored. More generally, if the default size does not obey the
3997  * geometry hints for the window (gtk_window_set_geometry_hints() can
3998  * be used to set these explicitly), the default size will be clamped
3999  * to the nearest permitted size.
4000  *
4001  * Unlike gtk_widget_set_size_request(), which sets a size request for
4002  * a widget and thus would keep users from shrinking the window, this
4003  * function only sets the initial size, just as if the user had
4004  * resized the window themselves. Users can still shrink the window
4005  * again as they normally would. Setting a default size of -1 means to
4006  * use the "natural" default size (the size request of the window).
4007  *
4008  * For more control over a window's initial size and how resizing works,
4009  * investigate gtk_window_set_geometry_hints().
4010  *
4011  * For some uses, gtk_window_resize() is a more appropriate function.
4012  * gtk_window_resize() changes the current size of the window, rather
4013  * than the size to be used on initial display. gtk_window_resize() always
4014  * affects the window itself, not the geometry widget.
4015  *
4016  * The default size of a window only affects the first time a window is
4017  * shown; if a window is hidden and re-shown, it will remember the size
4018  * it had prior to hiding, rather than using the default size.
4019  *
4020  * Windows can't actually be 0x0 in size, they must be at least 1x1, but
4021  * passing 0 for @width and @height is OK, resulting in a 1x1 default size.
4022  **/
4023 void
4024 gtk_window_set_default_size (GtkWindow   *window,
4025                              gint         width,
4026                              gint         height)
4027 {
4028   g_return_if_fail (GTK_IS_WINDOW (window));
4029   g_return_if_fail (width >= -1);
4030   g_return_if_fail (height >= -1);
4031
4032   gtk_window_set_default_size_internal (window, TRUE, width, TRUE, height, FALSE);
4033 }
4034
4035 /**
4036  * gtk_window_set_default_geometry:
4037  * @window: a #GtkWindow
4038  * @width: width in resize increments, or -1 to unset the default width
4039  * @height: height in resize increments, or -1 to unset the default height
4040  *
4041  * Like gtk_window_set_default_size(), but @width and @height are interpreted
4042  * in terms of the base size and increment set with
4043  * gtk_window_set_geometry_hints.
4044  *
4045  * Since: 3.0
4046  */
4047 void
4048 gtk_window_set_default_geometry (GtkWindow *window,
4049                                  gint       width,
4050                                  gint       height)
4051 {
4052   g_return_if_fail (GTK_IS_WINDOW (window));
4053   g_return_if_fail (width >= -1);
4054   g_return_if_fail (height >= -1);
4055
4056   gtk_window_set_default_size_internal (window, TRUE, width, TRUE, height, TRUE);
4057 }
4058
4059 /**
4060  * gtk_window_get_default_size:
4061  * @window: a #GtkWindow
4062  * @width: (out) (allow-none): location to store the default width, or %NULL
4063  * @height: (out) (allow-none): location to store the default height, or %NULL
4064  *
4065  * Gets the default size of the window. A value of -1 for the width or
4066  * height indicates that a default size has not been explicitly set
4067  * for that dimension, so the "natural" size of the window will be
4068  * used.
4069  *
4070  **/
4071 void
4072 gtk_window_get_default_size (GtkWindow *window,
4073                              gint      *width,
4074                              gint      *height)
4075 {
4076   GtkWindowGeometryInfo *info;
4077
4078   g_return_if_fail (GTK_IS_WINDOW (window));
4079
4080   info = gtk_window_get_geometry_info (window, FALSE);
4081
4082   if (width)
4083     *width = info ? info->default_width : -1;
4084
4085   if (height)
4086     *height = info ? info->default_height : -1;
4087 }
4088
4089 /**
4090  * gtk_window_resize:
4091  * @window: a #GtkWindow
4092  * @width: width in pixels to resize the window to
4093  * @height: height in pixels to resize the window to
4094  *
4095  * Resizes the window as if the user had done so, obeying geometry
4096  * constraints. The default geometry constraint is that windows may
4097  * not be smaller than their size request; to override this
4098  * constraint, call gtk_widget_set_size_request() to set the window's
4099  * request to a smaller value.
4100  *
4101  * If gtk_window_resize() is called before showing a window for the
4102  * first time, it overrides any default size set with
4103  * gtk_window_set_default_size().
4104  *
4105  * Windows may not be resized smaller than 1 by 1 pixels.
4106  *
4107  **/
4108 void
4109 gtk_window_resize (GtkWindow *window,
4110                    gint       width,
4111                    gint       height)
4112 {
4113   GtkWindowGeometryInfo *info;
4114
4115   g_return_if_fail (GTK_IS_WINDOW (window));
4116   g_return_if_fail (width > 0);
4117   g_return_if_fail (height > 0);
4118
4119   info = gtk_window_get_geometry_info (window, TRUE);
4120
4121   info->resize_width = width;
4122   info->resize_height = height;
4123   info->resize_is_geometry = FALSE;
4124
4125   gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
4126 }
4127
4128 /**
4129  * gtk_window_resize_to_geometry:
4130  * @window: a #GtkWindow
4131  * @width: width in resize increments to resize the window to
4132  * @height: height in resize increments to resize the window to
4133  *
4134  * Like gtk_window_resize(), but @width and @height are interpreted
4135  * in terms of the base size and increment set with
4136  * gtk_window_set_geometry_hints.
4137  *
4138  * Since: 3.0
4139  */
4140 void
4141 gtk_window_resize_to_geometry (GtkWindow *window,
4142                                gint       width,
4143                                gint       height)
4144 {
4145   GtkWindowGeometryInfo *info;
4146
4147   g_return_if_fail (GTK_IS_WINDOW (window));
4148   g_return_if_fail (width > 0);
4149   g_return_if_fail (height > 0);
4150
4151   info = gtk_window_get_geometry_info (window, TRUE);
4152
4153   info->resize_width = width;
4154   info->resize_height = height;
4155   info->resize_is_geometry = TRUE;
4156
4157   gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
4158 }
4159
4160 /**
4161  * gtk_window_get_size:
4162  * @window: a #GtkWindow
4163  * @width: (out) (allow-none): return location for width, or %NULL
4164  * @height: (out) (allow-none): return location for height, or %NULL
4165  *
4166  * Obtains the current size of @window. If @window is not onscreen,
4167  * it returns the size GTK+ will suggest to the <link
4168  * linkend="gtk-X11-arch">window manager</link> for the initial window
4169  * size (but this is not reliably the same as the size the window
4170  * manager will actually select). The size obtained by
4171  * gtk_window_get_size() is the last size received in a
4172  * #GdkEventConfigure, that is, GTK+ uses its locally-stored size,
4173  * rather than querying the X server for the size. As a result, if you
4174  * call gtk_window_resize() then immediately call
4175  * gtk_window_get_size(), the size won't have taken effect yet. After
4176  * the window manager processes the resize request, GTK+ receives
4177  * notification that the size has changed via a configure event, and
4178  * the size of the window gets updated.
4179  *
4180  * Note 1: Nearly any use of this function creates a race condition,
4181  * because the size of the window may change between the time that you
4182  * get the size and the time that you perform some action assuming
4183  * that size is the current size. To avoid race conditions, connect to
4184  * "configure-event" on the window and adjust your size-dependent
4185  * state to match the size delivered in the #GdkEventConfigure.
4186  *
4187  * Note 2: The returned size does <emphasis>not</emphasis> include the
4188  * size of the window manager decorations (aka the window frame or
4189  * border). Those are not drawn by GTK+ and GTK+ has no reliable
4190  * method of determining their size.
4191  *
4192  * Note 3: If you are getting a window size in order to position
4193  * the window onscreen, there may be a better way. The preferred
4194  * way is to simply set the window's semantic type with
4195  * gtk_window_set_type_hint(), which allows the window manager to
4196  * e.g. center dialogs. Also, if you set the transient parent of
4197  * dialogs with gtk_window_set_transient_for() window managers
4198  * will often center the dialog over its parent window. It's
4199  * much preferred to let the window manager handle these
4200  * things rather than doing it yourself, because all apps will
4201  * behave consistently and according to user prefs if the window
4202  * manager handles it. Also, the window manager can take the size
4203  * of the window decorations/border into account, while your
4204  * application cannot.
4205  *
4206  * In any case, if you insist on application-specified window
4207  * positioning, there's <emphasis>still</emphasis> a better way than
4208  * doing it yourself - gtk_window_set_position() will frequently
4209  * handle the details for you.
4210  *
4211  **/
4212 void
4213 gtk_window_get_size (GtkWindow *window,
4214                      gint      *width,
4215                      gint      *height)
4216 {
4217   gint w, h;
4218
4219   g_return_if_fail (GTK_IS_WINDOW (window));
4220
4221   if (width == NULL && height == NULL)
4222     return;
4223
4224   if (gtk_widget_get_mapped (GTK_WIDGET (window)))
4225     {
4226       w = gdk_window_get_width (gtk_widget_get_window (GTK_WIDGET (window)));
4227       h = gdk_window_get_height (gtk_widget_get_window (GTK_WIDGET (window)));
4228     }
4229   else
4230     {
4231       GdkRectangle configure_request;
4232
4233       gtk_window_compute_configure_request (window,
4234                                             &configure_request,
4235                                             NULL, NULL);
4236
4237       w = configure_request.width;
4238       h = configure_request.height;
4239     }
4240
4241   if (width)
4242     *width = w;
4243   if (height)
4244     *height = h;
4245 }
4246
4247 /**
4248  * gtk_window_move:
4249  * @window: a #GtkWindow
4250  * @x: X coordinate to move window to
4251  * @y: Y coordinate to move window to
4252  *
4253  * Asks the <link linkend="gtk-X11-arch">window manager</link> to move
4254  * @window to the given position.  Window managers are free to ignore
4255  * this; most window managers ignore requests for initial window
4256  * positions (instead using a user-defined placement algorithm) and
4257  * honor requests after the window has already been shown.
4258  *
4259  * Note: the position is the position of the gravity-determined
4260  * reference point for the window. The gravity determines two things:
4261  * first, the location of the reference point in root window
4262  * coordinates; and second, which point on the window is positioned at
4263  * the reference point.
4264  *
4265  * By default the gravity is #GDK_GRAVITY_NORTH_WEST, so the reference
4266  * point is simply the @x, @y supplied to gtk_window_move(). The
4267  * top-left corner of the window decorations (aka window frame or
4268  * border) will be placed at @x, @y.  Therefore, to position a window
4269  * at the top left of the screen, you want to use the default gravity
4270  * (which is #GDK_GRAVITY_NORTH_WEST) and move the window to 0,0.
4271  *
4272  * To position a window at the bottom right corner of the screen, you
4273  * would set #GDK_GRAVITY_SOUTH_EAST, which means that the reference
4274  * point is at @x + the window width and @y + the window height, and
4275  * the bottom-right corner of the window border will be placed at that
4276  * reference point. So, to place a window in the bottom right corner
4277  * you would first set gravity to south east, then write:
4278  * <literal>gtk_window_move (window, gdk_screen_width () - window_width,
4279  * gdk_screen_height () - window_height)</literal> (note that this
4280  * example does not take multi-head scenarios into account).
4281  *
4282  * The Extended Window Manager Hints specification at <ulink
4283  * url="http://www.freedesktop.org/Standards/wm-spec">
4284  * http://www.freedesktop.org/Standards/wm-spec</ulink> has a
4285  * nice table of gravities in the "implementation notes" section.
4286  *
4287  * The gtk_window_get_position() documentation may also be relevant.
4288  */
4289 void
4290 gtk_window_move (GtkWindow *window,
4291                  gint       x,
4292                  gint       y)
4293 {
4294   GtkWindowPrivate *priv;
4295   GtkWindowGeometryInfo *info;
4296   GtkWidget *widget;
4297
4298   g_return_if_fail (GTK_IS_WINDOW (window));
4299
4300   priv = window->priv;
4301   widget = GTK_WIDGET (window);
4302
4303   info = gtk_window_get_geometry_info (window, TRUE);
4304
4305   if (gtk_widget_get_mapped (widget))
4306     {
4307       GtkAllocation allocation;
4308
4309       gtk_widget_get_allocation (widget, &allocation);
4310
4311       /* we have now sent a request with this position
4312        * with currently-active constraints, so toggle flag.
4313        */
4314       info->position_constraints_changed = FALSE;
4315
4316       /* we only constrain if mapped - if not mapped,
4317        * then gtk_window_compute_configure_request()
4318        * will apply the constraints later, and we
4319        * don't want to lose information about
4320        * what position the user set before then.
4321        * i.e. if you do a move() then turn off POS_CENTER
4322        * then show the window, your move() will work.
4323        */
4324       gtk_window_constrain_position (window,
4325                                      allocation.width, allocation.height,
4326                                      &x, &y);
4327
4328       /* Note that this request doesn't go through our standard request
4329        * framework, e.g. doesn't increment configure_request_count,
4330        * doesn't set info->last, etc.; that's because
4331        * we don't save the info needed to arrive at this same request
4332        * again.
4333        *
4334        * To gtk_window_move_resize(), this will end up looking exactly
4335        * the same as the position being changed by the window
4336        * manager.
4337        */
4338
4339       /* FIXME are we handling gravity properly for framed windows? */
4340       if (priv->frame)
4341         gdk_window_move (priv->frame,
4342                          x - priv->frame_left,
4343                          y - priv->frame_top);
4344       else
4345         gdk_window_move (gtk_widget_get_window (GTK_WIDGET (window)),
4346                          x, y);
4347     }
4348   else
4349     {
4350       /* Save this position to apply on mapping */
4351       info->initial_x = x;
4352       info->initial_y = y;
4353       info->initial_pos_set = TRUE;
4354     }
4355 }
4356
4357 /**
4358  * gtk_window_get_position:
4359  * @window: a #GtkWindow
4360  * @root_x: (out): return location for X coordinate of gravity-determined reference point
4361  * @root_y: (out): return location for Y coordinate of gravity-determined reference point
4362  *
4363  * This function returns the position you need to pass to
4364  * gtk_window_move() to keep @window in its current position.  This
4365  * means that the meaning of the returned value varies with window
4366  * gravity. See gtk_window_move() for more details.
4367  *
4368  * If you haven't changed the window gravity, its gravity will be
4369  * #GDK_GRAVITY_NORTH_WEST. This means that gtk_window_get_position()
4370  * gets the position of the top-left corner of the window manager
4371  * frame for the window. gtk_window_move() sets the position of this
4372  * same top-left corner.
4373  *
4374  * gtk_window_get_position() is not 100% reliable because the X Window System
4375  * does not specify a way to obtain the geometry of the
4376  * decorations placed on a window by the window manager.
4377  * Thus GTK+ is using a "best guess" that works with most
4378  * window managers.
4379  *
4380  * Moreover, nearly all window managers are historically broken with
4381  * respect to their handling of window gravity. So moving a window to
4382  * its current position as returned by gtk_window_get_position() tends
4383  * to result in moving the window slightly. Window managers are
4384  * slowly getting better over time.
4385  *
4386  * If a window has gravity #GDK_GRAVITY_STATIC the window manager
4387  * frame is not relevant, and thus gtk_window_get_position() will
4388  * always produce accurate results. However you can't use static
4389  * gravity to do things like place a window in a corner of the screen,
4390  * because static gravity ignores the window manager decorations.
4391  *
4392  * If you are saving and restoring your application's window
4393  * positions, you should know that it's impossible for applications to
4394  * do this without getting it somewhat wrong because applications do
4395  * not have sufficient knowledge of window manager state. The Correct
4396  * Mechanism is to support the session management protocol (see the
4397  * "GnomeClient" object in the GNOME libraries for example) and allow
4398  * the window manager to save your window sizes and positions.
4399  *
4400  **/
4401
4402 void
4403 gtk_window_get_position (GtkWindow *window,
4404                          gint      *root_x,
4405                          gint      *root_y)
4406 {
4407   GtkWindowPrivate *priv;
4408   GtkWidget *widget;
4409   GdkWindow *gdk_window;
4410
4411   g_return_if_fail (GTK_IS_WINDOW (window));
4412
4413   priv = window->priv;
4414   widget = GTK_WIDGET (window);
4415   gdk_window = gtk_widget_get_window (widget);
4416
4417   if (priv->gravity == GDK_GRAVITY_STATIC)
4418     {
4419       if (gtk_widget_get_mapped (widget))
4420         {
4421           /* This does a server round-trip, which is sort of wrong;
4422            * but a server round-trip is inevitable for
4423            * gdk_window_get_frame_extents() in the usual
4424            * NorthWestGravity case below, so not sure what else to
4425            * do. We should likely be consistent about whether we get
4426            * the client-side info or the server-side info.
4427            */
4428           gdk_window_get_origin (gdk_window, root_x, root_y);
4429         }
4430       else
4431         {
4432           GdkRectangle configure_request;
4433
4434           gtk_window_compute_configure_request (window,
4435                                                 &configure_request,
4436                                                 NULL, NULL);
4437
4438           *root_x = configure_request.x;
4439           *root_y = configure_request.y;
4440         }
4441     }
4442   else
4443     {
4444       GdkRectangle frame_extents;
4445
4446       gint x, y;
4447       gint w, h;
4448
4449       if (gtk_widget_get_mapped (widget))
4450         {
4451           if (priv->frame)
4452             gdk_window_get_frame_extents (priv->frame, &frame_extents);
4453           else
4454             gdk_window_get_frame_extents (gdk_window, &frame_extents);
4455           x = frame_extents.x;
4456           y = frame_extents.y;
4457           gtk_window_get_size (window, &w, &h);
4458         }
4459       else
4460         {
4461           /* We just say the frame has 0 size on all sides.
4462            * Not sure what else to do.
4463            */
4464           gtk_window_compute_configure_request (window,
4465                                                 &frame_extents,
4466                                                 NULL, NULL);
4467           x = frame_extents.x;
4468           y = frame_extents.y;
4469           w = frame_extents.width;
4470           h = frame_extents.height;
4471         }
4472
4473       switch (priv->gravity)
4474         {
4475         case GDK_GRAVITY_NORTH:
4476         case GDK_GRAVITY_CENTER:
4477         case GDK_GRAVITY_SOUTH:
4478           /* Find center of frame. */
4479           x += frame_extents.width / 2;
4480           /* Center client window on that point. */
4481           x -= w / 2;
4482           break;
4483
4484         case GDK_GRAVITY_SOUTH_EAST:
4485         case GDK_GRAVITY_EAST:
4486         case GDK_GRAVITY_NORTH_EAST:
4487           /* Find right edge of frame */
4488           x += frame_extents.width;
4489           /* Align left edge of client at that point. */
4490           x -= w;
4491           break;
4492         default:
4493           break;
4494         }
4495
4496       switch (priv->gravity)
4497         {
4498         case GDK_GRAVITY_WEST:
4499         case GDK_GRAVITY_CENTER:
4500         case GDK_GRAVITY_EAST:
4501           /* Find center of frame. */
4502           y += frame_extents.height / 2;
4503           /* Center client window there. */
4504           y -= h / 2;
4505           break;
4506         case GDK_GRAVITY_SOUTH_WEST:
4507         case GDK_GRAVITY_SOUTH:
4508         case GDK_GRAVITY_SOUTH_EAST:
4509           /* Find south edge of frame */
4510           y += frame_extents.height;
4511           /* Place bottom edge of client there */
4512           y -= h;
4513           break;
4514         default:
4515           break;
4516         }
4517
4518       if (root_x)
4519         *root_x = x;
4520       if (root_y)
4521         *root_y = y;
4522     }
4523 }
4524
4525 /**
4526  * gtk_window_reshow_with_initial_size:
4527  * @window: a #GtkWindow
4528  *
4529  * Hides @window, then reshows it, resetting the
4530  * default size and position of the window. Used
4531  * by GUI builders only.
4532  **/
4533 void
4534 gtk_window_reshow_with_initial_size (GtkWindow *window)
4535 {
4536   GtkWidget *widget;
4537
4538   g_return_if_fail (GTK_IS_WINDOW (window));
4539
4540   widget = GTK_WIDGET (window);
4541
4542   gtk_widget_hide (widget);
4543   gtk_widget_unrealize (widget);
4544   gtk_widget_show (widget);
4545 }
4546
4547 static void
4548 gtk_window_destroy (GtkWidget *widget)
4549 {
4550   GtkWindow *window = GTK_WINDOW (widget);
4551   GtkWindowPrivate *priv = window->priv;
4552
4553   toplevel_list = g_slist_remove (toplevel_list, window);
4554
4555   if (priv->transient_parent)
4556     gtk_window_set_transient_for (window, NULL);
4557
4558   /* frees the icons */
4559   gtk_window_set_icon_list (window, NULL);
4560
4561   if (priv->has_user_ref_count)
4562     {
4563       priv->has_user_ref_count = FALSE;
4564       g_object_unref (window);
4565     }
4566
4567   if (priv->group)
4568     gtk_window_group_remove_window (priv->group, window);
4569
4570    gtk_window_free_key_hash (window);
4571
4572   GTK_WIDGET_CLASS (gtk_window_parent_class)->destroy (widget);
4573 }
4574
4575 static void
4576 gtk_window_finalize (GObject *object)
4577 {
4578   GtkWindow *window = GTK_WINDOW (object);
4579   GtkWindowPrivate *priv = window->priv;
4580   GtkMnemonicHash *mnemonic_hash;
4581
4582   g_free (priv->title);
4583   g_free (priv->wmclass_name);
4584   g_free (priv->wmclass_class);
4585   g_free (priv->wm_role);
4586   gtk_window_release_application (window);
4587
4588   mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
4589   if (mnemonic_hash)
4590     _gtk_mnemonic_hash_free (mnemonic_hash);
4591
4592   if (priv->geometry_info)
4593     {
4594       if (priv->geometry_info->widget)
4595         g_signal_handlers_disconnect_by_func (priv->geometry_info->widget,
4596                                               gtk_widget_destroyed,
4597                                               &priv->geometry_info->widget);
4598       g_free (priv->geometry_info);
4599     }
4600
4601   if (priv->keys_changed_handler)
4602     {
4603       g_source_remove (priv->keys_changed_handler);
4604       priv->keys_changed_handler = 0;
4605     }
4606
4607   if (priv->screen)
4608     g_signal_handlers_disconnect_by_func (priv->screen,
4609                                           gtk_window_on_composited_changed, window);
4610
4611   g_free (priv->startup_id);
4612
4613   G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
4614 }
4615
4616 static void
4617 gtk_window_show (GtkWidget *widget)
4618 {
4619   GtkWindow *window = GTK_WINDOW (widget);
4620   GtkWindowPrivate *priv = window->priv;
4621   GtkContainer *container = GTK_CONTAINER (window);
4622   gboolean need_resize;
4623
4624   _gtk_widget_set_visible_flag (widget, TRUE);
4625
4626   need_resize = _gtk_container_get_need_resize (container) || !gtk_widget_get_realized (widget);
4627   _gtk_container_set_need_resize (container, FALSE);
4628
4629   if (need_resize)
4630     {
4631       GtkWindowGeometryInfo *info = gtk_window_get_geometry_info (window, TRUE);
4632       GtkAllocation allocation = { 0, 0 };
4633       GdkRectangle configure_request;
4634       GdkGeometry new_geometry;
4635       guint new_flags;
4636       gboolean was_realized;
4637
4638       /* We are going to go ahead and perform this configure request
4639        * and then emulate a configure notify by going ahead and
4640        * doing a size allocate. Sort of a synchronous
4641        * mini-copy of gtk_window_move_resize() here.
4642        */
4643       gtk_window_compute_configure_request (window,
4644                                             &configure_request,
4645                                             &new_geometry,
4646                                             &new_flags);
4647
4648       /* We update this because we are going to go ahead
4649        * and gdk_window_resize() below, rather than
4650        * queuing it.
4651        */
4652       info->last.configure_request.width = configure_request.width;
4653       info->last.configure_request.height = configure_request.height;
4654
4655       /* and allocate the window - this is normally done
4656        * in move_resize in response to configure notify
4657        */
4658       allocation.width  = configure_request.width;
4659       allocation.height = configure_request.height;
4660       gtk_widget_size_allocate (widget, &allocation);
4661
4662       /* Then we guarantee we have a realize */
4663       was_realized = FALSE;
4664       if (!gtk_widget_get_realized (widget))
4665         {
4666           gtk_widget_realize (widget);
4667           was_realized = TRUE;
4668         }
4669
4670       /* We only send configure request if we didn't just finish
4671        * creating the window; if we just created the window
4672        * then we created it with widget->allocation anyhow.
4673        */
4674       if (!was_realized)
4675         gdk_window_move_resize (gtk_widget_get_window (widget),
4676                                 configure_request.x,
4677                                 configure_request.y,
4678                                 configure_request.width,
4679                                 configure_request.height);
4680     }
4681
4682   gtk_container_check_resize (container);
4683
4684   gtk_widget_map (widget);
4685
4686   /* Try to make sure that we have some focused widget
4687    */
4688   if (!priv->focus_widget && !GTK_IS_PLUG (window))
4689     gtk_window_move_focus (widget, GTK_DIR_TAB_FORWARD);
4690
4691   if (priv->modal)
4692     gtk_grab_add (widget);
4693 }
4694
4695 static void
4696 gtk_window_hide (GtkWidget *widget)
4697 {
4698   GtkWindow *window = GTK_WINDOW (widget);
4699   GtkWindowPrivate *priv = window->priv;
4700
4701   _gtk_widget_set_visible_flag (widget, FALSE);
4702   gtk_widget_unmap (widget);
4703
4704   if (priv->modal)
4705     gtk_grab_remove (widget);
4706 }
4707
4708 static void
4709 gtk_window_map (GtkWidget *widget)
4710 {
4711   GtkWidget *child;
4712   GtkWindow *window = GTK_WINDOW (widget);
4713   GtkWindowPrivate *priv = window->priv;
4714   GdkWindow *toplevel;
4715   GdkWindow *gdk_window;
4716   gboolean auto_mnemonics;
4717
4718   gdk_window = gtk_widget_get_window (widget);
4719
4720   gtk_widget_set_mapped (widget, TRUE);
4721
4722   child = gtk_bin_get_child (&(window->bin));
4723   if (child &&
4724       gtk_widget_get_visible (child) &&
4725       !gtk_widget_get_mapped (child))
4726     gtk_widget_map (child);
4727
4728   if (priv->frame)
4729     toplevel = priv->frame;
4730   else
4731     toplevel = gdk_window;
4732
4733   if (priv->maximize_initially)
4734     gdk_window_maximize (toplevel);
4735   else
4736     gdk_window_unmaximize (toplevel);
4737
4738   if (priv->stick_initially)
4739     gdk_window_stick (toplevel);
4740   else
4741     gdk_window_unstick (toplevel);
4742
4743   if (priv->iconify_initially)
4744     gdk_window_iconify (toplevel);
4745   else
4746     gdk_window_deiconify (toplevel);
4747
4748   if (priv->fullscreen_initially)
4749     gdk_window_fullscreen (toplevel);
4750   else
4751     gdk_window_unfullscreen (toplevel);
4752
4753   gdk_window_set_keep_above (toplevel, priv->above_initially);
4754
4755   gdk_window_set_keep_below (toplevel, priv->below_initially);
4756
4757   /* No longer use the default settings */
4758   priv->need_default_size = FALSE;
4759   priv->need_default_position = FALSE;
4760
4761   if (priv->reset_type_hint)
4762     {
4763       /* We should only reset the type hint when the application
4764        * used gtk_window_set_type_hint() to change the hint.
4765        * Some applications use X directly to change the properties;
4766        * in that case, we shouldn't overwrite what they did.
4767        */
4768       gdk_window_set_type_hint (gdk_window, priv->type_hint);
4769       priv->reset_type_hint = FALSE;
4770     }
4771
4772   gdk_window_show (gdk_window);
4773
4774   if (priv->frame)
4775     gdk_window_show (priv->frame);
4776
4777   if (priv->grip_window)
4778     gdk_window_show (priv->grip_window);
4779
4780   if (!disable_startup_notification)
4781     {
4782       /* Do we have a custom startup-notification id? */
4783       if (priv->startup_id != NULL)
4784         {
4785           /* Make sure we have a "real" id */
4786           if (!startup_id_is_fake (priv->startup_id))
4787             gdk_notify_startup_complete_with_id (priv->startup_id);
4788
4789           g_free (priv->startup_id);
4790           priv->startup_id = NULL;
4791         }
4792       else if (!sent_startup_notification)
4793         {
4794           sent_startup_notification = TRUE;
4795           gdk_notify_startup_complete ();
4796         }
4797     }
4798
4799   /* if auto-mnemonics is enabled and mnemonics visible is not already set
4800    * (as in the case of popup menus), then hide mnemonics initially
4801    */
4802   g_object_get (gtk_widget_get_settings (widget), "gtk-auto-mnemonics",
4803                 &auto_mnemonics, NULL);
4804   if (auto_mnemonics && !priv->mnemonics_visible_set)
4805     gtk_window_set_mnemonics_visible (window, FALSE);
4806 }
4807
4808 static gboolean
4809 gtk_window_map_event (GtkWidget   *widget,
4810                       GdkEventAny *event)
4811 {
4812   if (!gtk_widget_get_mapped (widget))
4813     {
4814       /* we should be be unmapped, but are getting a MapEvent, this may happen
4815        * to toplevel XWindows if mapping was intercepted by a window manager
4816        * and an unmap request occoured while the MapRequestEvent was still
4817        * being handled. we work around this situaiton here by re-requesting
4818        * the window being unmapped. more details can be found in:
4819        *   http://bugzilla.gnome.org/show_bug.cgi?id=316180
4820        */
4821       gdk_window_hide (gtk_widget_get_window (widget));
4822     }
4823   return FALSE;
4824 }
4825
4826 static void
4827 gtk_window_unmap (GtkWidget *widget)
4828 {
4829   GtkWindow *window = GTK_WINDOW (widget);
4830   GtkWindowPrivate *priv = window->priv;
4831   GtkWindowGeometryInfo *info;
4832   GdkWindow *gdk_window;
4833   GdkWindowState state;
4834
4835   gdk_window = gtk_widget_get_window (widget);
4836
4837   gtk_widget_set_mapped (widget, FALSE);
4838   if (priv->frame)
4839     gdk_window_withdraw (priv->frame);
4840   else
4841     gdk_window_withdraw (gdk_window);
4842
4843   priv->configure_request_count = 0;
4844   priv->configure_notify_received = FALSE;
4845
4846   /* on unmap, we reset the default positioning of the window,
4847    * so it's placed again, but we don't reset the default
4848    * size of the window, so it's remembered.
4849    */
4850   priv->need_default_position = TRUE;
4851
4852   info = gtk_window_get_geometry_info (window, FALSE);
4853   if (info)
4854     {
4855       info->initial_pos_set = FALSE;
4856       info->position_constraints_changed = FALSE;
4857     }
4858
4859   state = gdk_window_get_state (gdk_window);
4860   priv->iconify_initially = (state & GDK_WINDOW_STATE_ICONIFIED) != 0;
4861   priv->maximize_initially = (state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
4862   priv->stick_initially = (state & GDK_WINDOW_STATE_STICKY) != 0;
4863   priv->above_initially = (state & GDK_WINDOW_STATE_ABOVE) != 0;
4864   priv->below_initially = (state & GDK_WINDOW_STATE_BELOW) != 0;
4865 }
4866
4867 static void
4868 gtk_window_realize (GtkWidget *widget)
4869 {
4870   GtkAllocation allocation;
4871   GtkWindow *window;
4872   GdkWindow *parent_window;
4873   GdkWindow *gdk_window;
4874   GdkWindowAttr attributes;
4875   gint attributes_mask;
4876   GtkWindowPrivate *priv;
4877   GtkStyleContext *context;
4878
4879   window = GTK_WINDOW (widget);
4880   priv = window->priv;
4881
4882   gtk_widget_get_allocation (widget, &allocation);
4883
4884   /* ensure widget tree is properly size allocated */
4885   if (allocation.x == -1 &&
4886       allocation.y == -1 &&
4887       allocation.width == 1 &&
4888       allocation.height == 1)
4889     {
4890       GtkRequisition requisition;
4891
4892       allocation.x = 0;
4893       allocation.y = 0;
4894       allocation.width = 200;
4895       allocation.height = 200;
4896
4897       gtk_widget_get_preferred_size (widget, &requisition, NULL);
4898       if (requisition.width || requisition.height)
4899         {
4900           /* non-empty window */
4901           allocation.width = requisition.width;
4902           allocation.height = requisition.height;
4903         }
4904       gtk_widget_size_allocate (widget, &allocation);
4905
4906       _gtk_container_queue_resize (GTK_CONTAINER (widget));
4907
4908       g_return_if_fail (!gtk_widget_get_realized (widget));
4909     }
4910
4911   gtk_widget_set_realized (widget, TRUE);
4912
4913   switch (priv->type)
4914     {
4915     case GTK_WINDOW_TOPLEVEL:
4916       attributes.window_type = GDK_WINDOW_TOPLEVEL;
4917       break;
4918     case GTK_WINDOW_POPUP:
4919       attributes.window_type = GDK_WINDOW_TEMP;
4920       break;
4921     default:
4922       g_warning (G_STRLOC": Unknown window type %d!", priv->type);
4923       break;
4924     }
4925
4926   attributes.title = priv->title;
4927   attributes.wmclass_name = priv->wmclass_name;
4928   attributes.wmclass_class = priv->wmclass_class;
4929   attributes.wclass = GDK_INPUT_OUTPUT;
4930   attributes.visual = gtk_widget_get_visual (widget);
4931
4932   if (priv->has_frame)
4933     {
4934       gtk_widget_get_allocation (widget, &allocation);
4935       attributes.width = allocation.width + priv->frame_left + priv->frame_right;
4936       attributes.height = allocation.height + priv->frame_top + priv->frame_bottom;
4937       attributes.event_mask = (GDK_EXPOSURE_MASK |
4938                                GDK_KEY_PRESS_MASK |
4939                                GDK_ENTER_NOTIFY_MASK |
4940                                GDK_LEAVE_NOTIFY_MASK |
4941                                GDK_FOCUS_CHANGE_MASK |
4942                                GDK_STRUCTURE_MASK |
4943                                GDK_BUTTON_MOTION_MASK |
4944                                GDK_POINTER_MOTION_HINT_MASK |
4945                                GDK_BUTTON_PRESS_MASK |
4946                                GDK_BUTTON_RELEASE_MASK);
4947
4948       attributes_mask = GDK_WA_VISUAL;
4949
4950       priv->frame = gdk_window_new (gtk_widget_get_root_window (widget),
4951                                       &attributes, attributes_mask);
4952
4953       if (priv->opacity_set)
4954         gdk_window_set_opacity (priv->frame, priv->opacity);
4955
4956       gdk_window_set_user_data (priv->frame, widget);
4957
4958       attributes.window_type = GDK_WINDOW_CHILD;
4959       attributes.x = priv->frame_left;
4960       attributes.y = priv->frame_top;
4961
4962       attributes_mask = GDK_WA_X | GDK_WA_Y;
4963
4964       parent_window = priv->frame;
4965
4966       g_signal_connect (window,
4967                         "event",
4968                         G_CALLBACK (gtk_window_event),
4969                         NULL);
4970     }
4971   else
4972     {
4973       attributes_mask = 0;
4974       parent_window = gtk_widget_get_root_window (widget);
4975     }
4976
4977   gtk_widget_get_allocation (widget, &allocation);
4978   attributes.width = allocation.width;
4979   attributes.height = allocation.height;
4980   attributes.event_mask = gtk_widget_get_events (widget);
4981   attributes.event_mask |= (GDK_EXPOSURE_MASK |
4982                             GDK_KEY_PRESS_MASK |
4983                             GDK_KEY_RELEASE_MASK |
4984                             GDK_ENTER_NOTIFY_MASK |
4985                             GDK_LEAVE_NOTIFY_MASK |
4986                             GDK_FOCUS_CHANGE_MASK |
4987                             GDK_STRUCTURE_MASK);
4988   attributes.type_hint = priv->type_hint;
4989
4990   attributes_mask |= GDK_WA_VISUAL | GDK_WA_TYPE_HINT;
4991   attributes_mask |= (priv->title ? GDK_WA_TITLE : 0);
4992   attributes_mask |= (priv->wmclass_name ? GDK_WA_WMCLASS : 0);
4993
4994   gdk_window = gdk_window_new (parent_window, &attributes, attributes_mask);
4995   gtk_widget_set_window (widget, gdk_window);
4996
4997   if (!priv->has_frame && priv->opacity_set)
4998     gdk_window_set_opacity (gdk_window, priv->opacity);
4999
5000   gdk_window_enable_synchronized_configure (gdk_window);
5001
5002   gdk_window_set_user_data (gdk_window, window);
5003
5004   gtk_widget_style_attach (widget);
5005   context = gtk_widget_get_style_context (widget);
5006
5007   gtk_style_context_set_background (context, gdk_window);
5008   if (priv->frame)
5009     gtk_style_context_set_background (context, priv->frame);
5010
5011   if (priv->transient_parent &&
5012       gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)))
5013     gdk_window_set_transient_for (gdk_window,
5014                                   gtk_widget_get_window (GTK_WIDGET (priv->transient_parent)));
5015
5016   if (priv->wm_role)
5017     gdk_window_set_role (gdk_window, priv->wm_role);
5018
5019   if (!priv->decorated)
5020     gdk_window_set_decorations (gdk_window, 0);
5021
5022   if (!priv->deletable)
5023     gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_CLOSE);
5024
5025   if (gtk_window_get_skip_pager_hint (window))
5026     gdk_window_set_skip_pager_hint (gdk_window, TRUE);
5027
5028   if (gtk_window_get_skip_taskbar_hint (window))
5029     gdk_window_set_skip_taskbar_hint (gdk_window, TRUE);
5030
5031   if (gtk_window_get_accept_focus (window))
5032     gdk_window_set_accept_focus (gdk_window, TRUE);
5033   else
5034     gdk_window_set_accept_focus (gdk_window, FALSE);
5035
5036   if (gtk_window_get_focus_on_map (window))
5037     gdk_window_set_focus_on_map (gdk_window, TRUE);
5038   else
5039     gdk_window_set_focus_on_map (gdk_window, FALSE);
5040
5041   if (priv->modal)
5042     gdk_window_set_modal_hint (gdk_window, TRUE);
5043   else
5044     gdk_window_set_modal_hint (gdk_window, FALSE);
5045
5046   if (priv->startup_id)
5047     {
5048 #ifdef GDK_WINDOWING_X11
5049       guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
5050       if (timestamp != GDK_CURRENT_TIME)
5051         gdk_x11_window_set_user_time (gdk_window, timestamp);
5052 #endif
5053       if (!startup_id_is_fake (priv->startup_id))
5054         gdk_window_set_startup_id (gdk_window, priv->startup_id);
5055     }
5056
5057   /* Icons */
5058   gtk_window_realize_icon (window);
5059
5060   if (priv->has_resize_grip)
5061     resize_grip_create_window (window);
5062 }
5063
5064 static void
5065 gtk_window_unrealize (GtkWidget *widget)
5066 {
5067   GtkWindow *window = GTK_WINDOW (widget);
5068   GtkWindowPrivate *priv = window->priv;
5069   GtkWindowGeometryInfo *info;
5070
5071   /* On unrealize, we reset the size of the window such
5072    * that we will re-apply the default sizing stuff
5073    * next time we show the window.
5074    *
5075    * Default positioning is reset on unmap, instead of unrealize.
5076    */
5077   priv->need_default_size = TRUE;
5078   info = gtk_window_get_geometry_info (window, FALSE);
5079   if (info)
5080     {
5081       info->resize_width = -1;
5082       info->resize_height = -1;
5083       info->last.configure_request.x = 0;
5084       info->last.configure_request.y = 0;
5085       info->last.configure_request.width = -1;
5086       info->last.configure_request.height = -1;
5087       /* be sure we reset geom hints on re-realize */
5088       info->last.flags = 0;
5089     }
5090
5091   if (priv->frame)
5092     {
5093       gdk_window_set_user_data (priv->frame, NULL);
5094       gdk_window_destroy (priv->frame);
5095       priv->frame = NULL;
5096     }
5097
5098   /* Icons */
5099   gtk_window_unrealize_icon (window);
5100
5101   if (priv->grip_window != NULL)
5102     resize_grip_destroy_window (window);
5103
5104   GTK_WIDGET_CLASS (gtk_window_parent_class)->unrealize (widget);
5105 }
5106
5107 static GtkJunctionSides
5108 get_grip_junction (GtkWidget *widget)
5109 {
5110   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
5111     return GTK_JUNCTION_CORNER_BOTTOMRIGHT;
5112   else
5113     return GTK_JUNCTION_CORNER_BOTTOMLEFT;
5114 }
5115
5116 static gboolean
5117 get_drag_edge (GtkWidget     *widget,
5118                GdkWindowEdge *edge)
5119 {
5120   GtkWindowPrivate *priv = GTK_WINDOW (widget)->priv;
5121   gboolean hresizable;
5122   gboolean vresizable;
5123   GtkTextDirection dir;
5124   GtkWindowGeometryInfo *info;
5125
5126   hresizable = TRUE;
5127   vresizable = TRUE;
5128
5129   info = priv->geometry_info;
5130   if (info)
5131     {
5132       GdkWindowHints flags = info->last.flags;
5133       GdkGeometry *geometry = &info->last.geometry;
5134
5135       if ((flags & GDK_HINT_MIN_SIZE) && (flags & GDK_HINT_MAX_SIZE))
5136         {
5137           hresizable = geometry->min_width < geometry->max_width;
5138           vresizable = geometry->min_height < geometry->max_height;
5139         }
5140     }
5141
5142   dir = gtk_widget_get_direction (widget);
5143
5144   if (hresizable && vresizable)
5145     *edge = dir == GTK_TEXT_DIR_LTR ? GDK_WINDOW_EDGE_SOUTH_EAST : GDK_WINDOW_EDGE_SOUTH_WEST;
5146   else if (hresizable)
5147     *edge = dir == GTK_TEXT_DIR_LTR ? GDK_WINDOW_EDGE_EAST : GDK_WINDOW_EDGE_WEST;
5148   else if (vresizable)
5149     *edge = GDK_WINDOW_EDGE_SOUTH;
5150   else
5151     return FALSE;
5152
5153   return TRUE;
5154 }
5155
5156 static void
5157 set_grip_cursor (GtkWindow *window)
5158 {
5159   GtkWidget *widget = GTK_WIDGET (window);
5160   GtkWindowPrivate *priv = window->priv;
5161
5162   if (priv->grip_window == NULL)
5163     return;
5164
5165   if (gtk_widget_is_sensitive (widget))
5166     {
5167       GdkWindowEdge edge;
5168       GdkDisplay *display;
5169       GdkCursorType cursor_type;
5170       GdkCursor *cursor;
5171
5172       cursor_type = GDK_LEFT_PTR;
5173
5174       if (get_drag_edge (widget, &edge))
5175         {
5176           switch (edge)
5177             {
5178             case GDK_WINDOW_EDGE_EAST:
5179               cursor_type = GDK_RIGHT_SIDE;
5180               break;
5181             case GDK_WINDOW_EDGE_SOUTH_EAST:
5182               cursor_type = GDK_BOTTOM_RIGHT_CORNER;
5183               break;
5184             case GDK_WINDOW_EDGE_SOUTH:
5185               cursor_type = GDK_BOTTOM_SIDE;
5186               break;
5187             case GDK_WINDOW_EDGE_SOUTH_WEST:
5188               cursor_type = GDK_BOTTOM_LEFT_CORNER;
5189               break;
5190             case GDK_WINDOW_EDGE_WEST:
5191               cursor_type = GDK_LEFT_SIDE;
5192               break;
5193             default: ;
5194             }
5195         }
5196
5197       display = gtk_widget_get_display (widget);
5198       cursor = gdk_cursor_new_for_display (display, cursor_type);
5199       gdk_window_set_cursor (priv->grip_window, cursor);
5200       gdk_cursor_unref (cursor);
5201     }
5202   else
5203     gdk_window_set_cursor (priv->grip_window, NULL);
5204 }
5205
5206 static void
5207 set_grip_shape (GtkWindow *window)
5208 {
5209   GtkWindowPrivate *priv = window->priv;
5210   cairo_region_t *region;
5211   cairo_surface_t *surface;
5212   cairo_t *cr;
5213   double width, height;
5214
5215   if (priv->grip_window == NULL)
5216     return;
5217
5218   width = gdk_window_get_width (priv->grip_window);
5219   height = gdk_window_get_height (priv->grip_window);
5220   surface = cairo_image_surface_create (CAIRO_FORMAT_A8, width, height);
5221
5222   cr = cairo_create (surface);
5223   cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
5224   cairo_paint (cr);
5225   cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
5226   if (get_grip_junction (GTK_WIDGET (window)) & GTK_JUNCTION_CORNER_BOTTOMRIGHT)
5227     {
5228       cairo_move_to (cr, width, 0.0);
5229       cairo_line_to (cr, width, height);
5230       cairo_line_to (cr, 0.0, height);
5231     }
5232   else
5233     {
5234       cairo_move_to (cr, 0.0, 0.0);
5235       cairo_line_to (cr, width, height);
5236       cairo_line_to (cr, 0.0, height);
5237     }
5238   cairo_close_path (cr);
5239   cairo_fill (cr);
5240   cairo_destroy (cr);
5241   region = gdk_cairo_region_create_from_surface (surface);
5242   cairo_surface_destroy (surface);
5243
5244   gdk_window_shape_combine_region (priv->grip_window, region, 0, 0);
5245   cairo_region_destroy (region);
5246 }
5247
5248 static void
5249 set_grip_position (GtkWindow *window)
5250 {
5251   GtkWindowPrivate *priv = window->priv;
5252   GdkRectangle rect;
5253
5254   if (priv->grip_window == NULL)
5255     return;
5256
5257   gtk_window_get_resize_grip_area (window, &rect);
5258   gdk_window_raise (priv->grip_window);
5259   gdk_window_move_resize (priv->grip_window,
5260                           rect.x, rect.y,
5261                           rect.width, rect.height);
5262 }
5263
5264 static void
5265 gtk_window_size_allocate (GtkWidget     *widget,
5266                           GtkAllocation *allocation)
5267 {
5268   GtkWindow *window = GTK_WINDOW (widget);
5269   GtkWindowPrivate *priv = window->priv;
5270   GtkAllocation child_allocation;
5271   GtkWidget *child;
5272   guint border_width;
5273
5274   gtk_widget_set_allocation (widget, allocation);
5275
5276   child = gtk_bin_get_child (&(window->bin));
5277   if (child && gtk_widget_get_visible (child))
5278     {
5279       border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
5280       child_allocation.x = border_width;
5281       child_allocation.y = border_width;
5282       child_allocation.width =
5283         MAX (1, (gint)allocation->width - child_allocation.x * 2);
5284       child_allocation.height =
5285         MAX (1, (gint)allocation->height - child_allocation.y * 2);
5286
5287       gtk_widget_size_allocate (child, &child_allocation);
5288     }
5289
5290   if (gtk_widget_get_realized (widget))
5291     {
5292       if (priv->frame)
5293         gdk_window_resize (priv->frame,
5294                            allocation->width + priv->frame_left + priv->frame_right,
5295                            allocation->height + priv->frame_top + priv->frame_bottom);
5296       update_grip_visibility (window);
5297       set_grip_position (window);
5298     }
5299 }
5300
5301 static gint
5302 gtk_window_event (GtkWidget *widget, GdkEvent *event)
5303 {
5304   GtkWindow *window = GTK_WINDOW (widget);
5305   GtkWindowPrivate *priv = window->priv;
5306   gboolean return_val;
5307
5308   if (priv->frame && (event->any.window == priv->frame))
5309     {
5310       if ((event->type != GDK_KEY_PRESS) &&
5311           (event->type != GDK_KEY_RELEASE) &&
5312           (event->type != GDK_FOCUS_CHANGE))
5313         {
5314           g_signal_stop_emission_by_name (widget, "event");
5315           return_val = FALSE;
5316           g_signal_emit (widget, window_signals[FRAME_EVENT], 0, event, &return_val);
5317           return TRUE;
5318         }
5319       else
5320         {
5321           g_object_unref (event->any.window);
5322           event->any.window = g_object_ref (gtk_widget_get_window (widget));
5323         }
5324     }
5325
5326   return FALSE;
5327 }
5328
5329 static gboolean
5330 gtk_window_frame_event (GtkWindow *window, GdkEvent *event)
5331 {
5332   GtkWindowPrivate *priv = window->priv;
5333   GdkEventConfigure *configure_event;
5334   GdkRectangle rect;
5335
5336   switch (event->type)
5337     {
5338     case GDK_CONFIGURE:
5339       configure_event = (GdkEventConfigure *)event;
5340
5341       /* Invalidate the decorations */
5342       rect.x = 0;
5343       rect.y = 0;
5344       rect.width = configure_event->width;
5345       rect.height = configure_event->height;
5346
5347       gdk_window_invalidate_rect (priv->frame, &rect, FALSE);
5348
5349       /* Pass on the (modified) configure event */
5350       configure_event->width -= priv->frame_left + priv->frame_right;
5351       configure_event->height -= priv->frame_top + priv->frame_bottom;
5352       return gtk_window_configure_event (GTK_WIDGET (window), configure_event);
5353       break;
5354     default:
5355       break;
5356     }
5357   return FALSE;
5358 }
5359
5360 static gint
5361 gtk_window_configure_event (GtkWidget         *widget,
5362                             GdkEventConfigure *event)
5363 {
5364   GtkAllocation allocation;
5365   GtkWindow *window = GTK_WINDOW (widget);
5366   GtkWindowPrivate *priv = window->priv;
5367   gboolean expected_reply = priv->configure_request_count > 0;
5368
5369   /* priv->configure_request_count incremented for each
5370    * configure request, and decremented to a min of 0 for
5371    * each configure notify.
5372    *
5373    * All it means is that we know we will get at least
5374    * priv->configure_request_count more configure notifies.
5375    * We could get more configure notifies than that; some
5376    * of the configure notifies we get may be unrelated to
5377    * the configure requests. But we will get at least
5378    * priv->configure_request_count notifies.
5379    */
5380
5381   if (priv->configure_request_count > 0)
5382     {
5383       priv->configure_request_count -= 1;
5384       gdk_window_thaw_toplevel_updates_libgtk_only (gtk_widget_get_window (widget));
5385     }
5386
5387   /* As an optimization, we avoid a resize when possible.
5388    *
5389    * The only times we can avoid a resize are:
5390    *   - we know only the position changed, not the size
5391    *   - we know we have made more requests and so will get more
5392    *     notifies and can wait to resize when we get them
5393    */
5394   gtk_widget_get_allocation (widget, &allocation);
5395   if (!expected_reply &&
5396       (allocation.width == event->width &&
5397        allocation.height == event->height))
5398     {
5399       gdk_window_configure_finished (gtk_widget_get_window (widget));
5400       return TRUE;
5401     }
5402
5403   /*
5404    * If we do need to resize, we do that by:
5405    *   - filling in widget->allocation with the new size
5406    *   - setting configure_notify_received to TRUE
5407    *     for use in gtk_window_move_resize()
5408    *   - queueing a resize, leading to invocation of
5409    *     gtk_window_move_resize() in an idle handler
5410    *
5411    */
5412
5413   priv->configure_notify_received = TRUE;
5414
5415   allocation.width = event->width;
5416   allocation.height = event->height;
5417   gtk_widget_set_allocation (widget, &allocation);
5418
5419   gdk_window_invalidate_rect (gtk_widget_get_window (widget), NULL, FALSE); // XXX - What was this for again?
5420
5421   _gtk_container_queue_resize (GTK_CONTAINER (widget));
5422
5423   return TRUE;
5424 }
5425
5426 static gboolean
5427 gtk_window_state_event (GtkWidget           *widget,
5428                         GdkEventWindowState *event)
5429 {
5430   update_grip_visibility (GTK_WINDOW (widget));
5431
5432   return FALSE;
5433 }
5434
5435 static void
5436 gtk_window_direction_changed (GtkWidget        *widget,
5437                               GtkTextDirection  prev_dir)
5438 {
5439   GtkWindow *window = GTK_WINDOW (widget);
5440
5441   set_grip_cursor (window);
5442   set_grip_position (window);
5443   set_grip_shape (window);
5444 }
5445
5446 static void
5447 gtk_window_state_changed (GtkWidget    *widget,
5448                           GtkStateType  previous_state)
5449 {
5450   GtkWindow *window = GTK_WINDOW (widget);
5451
5452   update_grip_visibility (window);
5453 }
5454
5455 static void
5456 gtk_window_style_updated (GtkWidget *widget)
5457 {
5458   GtkWindow *window = GTK_WINDOW (widget);
5459   GtkWindowPrivate *priv = window->priv;
5460   GdkRectangle rect;
5461
5462   if (priv->grip_window != NULL && gtk_window_get_resize_grip_area (window, &rect))
5463     {
5464       gdk_window_move_resize (priv->grip_window,
5465                               rect.x, rect.y,
5466                               rect.width, rect.height);
5467
5468       set_grip_shape (window);
5469       gtk_widget_queue_resize (widget);
5470     }
5471 }
5472
5473 static void
5474 resize_grip_create_window (GtkWindow *window)
5475 {
5476   GtkWidget *widget;
5477   GtkWindowPrivate *priv;
5478   GdkWindowAttr attributes;
5479   gint attributes_mask;
5480   GdkRectangle rect;
5481
5482   priv = window->priv;
5483   widget = GTK_WIDGET (window);
5484
5485   g_return_if_fail (gtk_widget_get_realized (widget));
5486   g_return_if_fail (priv->grip_window == NULL);
5487
5488   gtk_window_get_resize_grip_area (window, &rect);
5489
5490   attributes.x = rect.x;
5491   attributes.y = rect.y;
5492   attributes.width = rect.width;
5493   attributes.height = rect.height;
5494   attributes.window_type = GDK_WINDOW_CHILD;
5495   attributes.wclass = GDK_INPUT_OUTPUT;
5496   attributes.event_mask = gtk_widget_get_events (widget) |
5497                           GDK_EXPOSURE_MASK |
5498                           GDK_BUTTON_PRESS_MASK;
5499
5500   attributes_mask = GDK_WA_X | GDK_WA_Y;
5501
5502   priv->grip_window = gdk_window_new (gtk_widget_get_window (widget),
5503                                       &attributes,
5504                                       attributes_mask);
5505
5506   gdk_window_set_user_data (priv->grip_window, widget);
5507
5508   gdk_window_raise (priv->grip_window);
5509
5510   set_grip_shape (window);
5511   update_grip_visibility (window);
5512 }
5513
5514 static void
5515 resize_grip_destroy_window (GtkWindow *window)
5516 {
5517   GtkWindowPrivate *priv = window->priv;
5518
5519   gdk_window_set_user_data (priv->grip_window, NULL);
5520   gdk_window_destroy (priv->grip_window);
5521   priv->grip_window = NULL;
5522   update_grip_visibility (window);
5523 }
5524
5525 /**
5526  * gtk_window_set_has_resize_grip:
5527  * @window: a #GtkWindow
5528  * @value: %TRUE to allow a resize grip
5529  *
5530  * Sets whether @window has a corner resize grip.
5531  *
5532  * Note that the resize grip is only shown if the window
5533  * is actually resizable and not maximized. Use
5534  * gtk_window_resize_grip_is_visible() to find out if the
5535  * resize grip is currently shown.
5536  *
5537  * Since: 3.0
5538  */
5539 void
5540 gtk_window_set_has_resize_grip (GtkWindow *window,
5541                                 gboolean   value)
5542 {
5543   GtkWidget *widget = GTK_WIDGET (window);
5544   GtkWindowPrivate *priv = window->priv;
5545
5546   value = value != FALSE;
5547
5548   if (value != priv->has_resize_grip)
5549     {
5550       priv->has_resize_grip = value;
5551       gtk_widget_queue_draw (widget);
5552
5553       if (gtk_widget_get_realized (widget))
5554         {
5555           if (priv->has_resize_grip && priv->grip_window == NULL)
5556             resize_grip_create_window (window);
5557           else if (!priv->has_resize_grip && priv->grip_window != NULL)
5558             resize_grip_destroy_window (window);
5559         }
5560
5561       g_object_notify (G_OBJECT (window), "has-resize-grip");
5562     }
5563 }
5564
5565 static void
5566 update_grip_visibility (GtkWindow *window)
5567 {
5568   GtkWindowPrivate *priv = window->priv;
5569   gboolean val;
5570
5571   val = gtk_window_resize_grip_is_visible (window);
5572
5573   if (priv->grip_window != NULL)
5574     {
5575       if (val)
5576         {
5577           gdk_window_show (priv->grip_window);
5578           set_grip_cursor (window);
5579         }
5580       else
5581         {
5582           gdk_window_hide (priv->grip_window);
5583         }
5584     }
5585
5586   if (priv->resize_grip_visible != val)
5587     {
5588       priv->resize_grip_visible = val;
5589
5590       g_object_notify (G_OBJECT (window), "resize-grip-visible");
5591     }
5592 }
5593
5594 /**
5595  * gtk_window_resize_grip_is_visible:
5596  * @window: a #GtkWindow
5597  *
5598  * Determines whether a resize grip is visible for the specified window.
5599  *
5600  * Returns %TRUE if a resize grip exists and is visible.
5601  *
5602  * Since: 3.0
5603  */
5604 gboolean
5605 gtk_window_resize_grip_is_visible (GtkWindow *window)
5606 {
5607   GtkWidget *widget;
5608   GtkWindowPrivate *priv;
5609   GdkWindowEdge edge;
5610
5611   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
5612
5613   priv = window->priv;
5614   widget = GTK_WIDGET (window);
5615
5616   if (priv->type == GTK_WINDOW_POPUP)
5617     return FALSE;
5618
5619   if (!priv->resizable)
5620     return FALSE;
5621
5622   if (gtk_widget_get_realized (widget))
5623     {
5624       GdkWindowState state;
5625
5626       state = gdk_window_get_state (gtk_widget_get_window (widget));
5627
5628       if (state & GDK_WINDOW_STATE_MAXIMIZED || state & GDK_WINDOW_STATE_FULLSCREEN)
5629         return FALSE;
5630     }
5631
5632   if (!get_drag_edge (widget, &edge))
5633     return FALSE;
5634
5635   return window->priv->has_resize_grip;
5636 }
5637
5638 /**
5639  * gtk_window_get_has_resize_grip:
5640  * @window: a #GtkWindow
5641  *
5642  * Determines whether the window may have a resize grip.
5643  *
5644  * Returns: %TRUE if the window has a resize grip.
5645  *
5646  * Since: 3.0
5647  */
5648 gboolean
5649 gtk_window_get_has_resize_grip (GtkWindow *window)
5650 {
5651   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
5652
5653   return window->priv->has_resize_grip;
5654 }
5655
5656 /**
5657  * gtk_window_get_resize_grip_area:
5658  * @window: a #GtkWindow
5659  * @rect: a pointer to a #GdkRectangle which we should store the
5660  *     resize grip area.
5661  *
5662  * If a window has a resize grip, this will retrieve the grip
5663  * position, width and height into the specified #GdkRectangle.
5664  *
5665  * Returns: %TRUE if the resize grip's area was retrieved.
5666  *
5667  * Since: 3.0
5668  */
5669 gboolean
5670 gtk_window_get_resize_grip_area (GtkWindow *window,
5671                                  GdkRectangle *rect)
5672 {
5673   GtkWidget *widget = GTK_WIDGET (window);
5674   GtkAllocation allocation;
5675   gint grip_width;
5676   gint grip_height;
5677
5678   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
5679
5680   if (!window->priv->has_resize_grip)
5681     return FALSE;
5682
5683   gtk_widget_get_allocation (widget, &allocation);
5684
5685   gtk_widget_style_get (widget,
5686                         "resize-grip-width", &grip_width,
5687                         "resize-grip-height", &grip_height,
5688                         NULL);
5689
5690   if (grip_width > allocation.width)
5691     grip_width = allocation.width;
5692
5693   if (grip_height > allocation.height)
5694     grip_height = allocation.height;
5695
5696   rect->width = grip_width;
5697   rect->height = grip_height;
5698   rect->y = allocation.y + allocation.height - grip_height;
5699
5700   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
5701     rect->x = allocation.x + allocation.width - grip_width;
5702   else
5703     rect->x = allocation.x;
5704
5705   return TRUE;
5706 }
5707
5708 /* the accel_key and accel_mods fields of the key have to be setup
5709  * upon calling this function. it'll then return whether that key
5710  * is at all used as accelerator, and if so will OR in the
5711  * accel_flags member of the key.
5712  */
5713 gboolean
5714 _gtk_window_query_nonaccels (GtkWindow      *window,
5715                              guint           accel_key,
5716                              GdkModifierType accel_mods)
5717 {
5718   GtkWindowPrivate *priv;
5719
5720   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
5721
5722   priv = window->priv;
5723
5724   /* movement keys are considered locked accels */
5725   if (!accel_mods)
5726     {
5727       static const guint bindings[] = {
5728         GDK_KEY_space, GDK_KEY_KP_Space, GDK_KEY_Return, GDK_KEY_ISO_Enter, GDK_KEY_KP_Enter, GDK_KEY_Up, GDK_KEY_KP_Up, GDK_KEY_Down, GDK_KEY_KP_Down,
5729         GDK_KEY_Left, GDK_KEY_KP_Left, GDK_KEY_Right, GDK_KEY_KP_Right, GDK_KEY_Tab, GDK_KEY_KP_Tab, GDK_KEY_ISO_Left_Tab,
5730       };
5731       guint i;
5732
5733       for (i = 0; i < G_N_ELEMENTS (bindings); i++)
5734         if (bindings[i] == accel_key)
5735           return TRUE;
5736     }
5737
5738   /* mnemonics are considered locked accels */
5739   if (accel_mods == priv->mnemonic_modifier)
5740     {
5741       GtkMnemonicHash *mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
5742       if (mnemonic_hash && _gtk_mnemonic_hash_lookup (mnemonic_hash, accel_key))
5743         return TRUE;
5744     }
5745
5746   return FALSE;
5747 }
5748
5749 /**
5750  * gtk_window_propagate_key_event:
5751  * @window:  a #GtkWindow
5752  * @event:   a #GdkEventKey
5753  *
5754  * Propagate a key press or release event to the focus widget and
5755  * up the focus container chain until a widget handles @event.
5756  * This is normally called by the default ::key_press_event and
5757  * ::key_release_event handlers for toplevel windows,
5758  * however in some cases it may be useful to call this directly when
5759  * overriding the standard key handling for a toplevel window.
5760  *
5761  * Return value: %TRUE if a widget in the focus chain handled the event.
5762  *
5763  * Since: 2.4
5764  */
5765 gboolean
5766 gtk_window_propagate_key_event (GtkWindow        *window,
5767                                 GdkEventKey      *event)
5768 {
5769   GtkWindowPrivate *priv;
5770   gboolean handled = FALSE;
5771   GtkWidget *widget, *focus;
5772
5773   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
5774
5775   priv = window->priv;
5776   widget = GTK_WIDGET (window);
5777
5778   focus = priv->focus_widget;
5779   if (focus)
5780     g_object_ref (focus);
5781
5782   while (!handled &&
5783          focus && focus != widget &&
5784          gtk_widget_get_toplevel (focus) == widget)
5785     {
5786       GtkWidget *parent;
5787
5788       if (gtk_widget_is_sensitive (focus))
5789         handled = gtk_widget_event (focus, (GdkEvent*) event);
5790
5791       parent = gtk_widget_get_parent (focus);
5792       if (parent)
5793         g_object_ref (parent);
5794
5795       g_object_unref (focus);
5796
5797       focus = parent;
5798     }
5799
5800   if (focus)
5801     g_object_unref (focus);
5802
5803   return handled;
5804 }
5805
5806 static gint
5807 gtk_window_key_press_event (GtkWidget   *widget,
5808                             GdkEventKey *event)
5809 {
5810   GtkWindow *window = GTK_WINDOW (widget);
5811   gboolean handled = FALSE;
5812
5813   /* handle mnemonics and accelerators */
5814   if (!handled)
5815     handled = gtk_window_activate_key (window, event);
5816
5817   /* handle focus widget key events */
5818   if (!handled)
5819     handled = gtk_window_propagate_key_event (window, event);
5820
5821   /* Chain up, invokes binding set */
5822   if (!handled)
5823     handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_press_event (widget, event);
5824
5825   return handled;
5826 }
5827
5828 static gint
5829 gtk_window_key_release_event (GtkWidget   *widget,
5830                               GdkEventKey *event)
5831 {
5832   GtkWindow *window = GTK_WINDOW (widget);
5833   gboolean handled = FALSE;
5834
5835   /* handle focus widget key events */
5836   if (!handled)
5837     handled = gtk_window_propagate_key_event (window, event);
5838
5839   /* Chain up, invokes binding set */
5840   if (!handled)
5841     handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_release_event (widget, event);
5842
5843   return handled;
5844 }
5845
5846 static gint
5847 gtk_window_button_press_event (GtkWidget *widget,
5848                                GdkEventButton *event)
5849 {
5850   GtkWindowPrivate *priv = GTK_WINDOW (widget)->priv;
5851   GdkWindowEdge edge;
5852
5853   if (event->window == priv->grip_window)
5854     {
5855       if (get_drag_edge (widget, &edge))
5856         gtk_window_begin_resize_drag (GTK_WINDOW (widget),
5857                                       edge,
5858                                       event->button,
5859                                       event->x_root,
5860                                       event->y_root,
5861                                       event->time);
5862
5863       return TRUE;
5864     }
5865
5866   return FALSE;
5867 }
5868
5869 static void
5870 gtk_window_real_activate_default (GtkWindow *window)
5871 {
5872   gtk_window_activate_default (window);
5873 }
5874
5875 static void
5876 gtk_window_real_activate_focus (GtkWindow *window)
5877 {
5878   gtk_window_activate_focus (window);
5879 }
5880
5881 static gint
5882 gtk_window_enter_notify_event (GtkWidget        *widget,
5883                                GdkEventCrossing *event)
5884 {
5885   return FALSE;
5886 }
5887
5888 static gint
5889 gtk_window_leave_notify_event (GtkWidget        *widget,
5890                                GdkEventCrossing *event)
5891 {
5892   return FALSE;
5893 }
5894
5895 static void
5896 do_focus_change (GtkWidget *widget,
5897                  gboolean   in)
5898 {
5899   GdkWindow *window;
5900   GdkDeviceManager *device_manager;
5901   GList *devices, *d;
5902
5903   g_object_ref (widget);
5904
5905   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
5906   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
5907   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
5908   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
5909
5910   for (d = devices; d; d = d->next)
5911     {
5912       GdkDevice *dev = d->data;
5913       GdkEvent *fevent;
5914
5915       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
5916         continue;
5917
5918       /* Skip non-master keyboards that haven't
5919        * selected for events from this window
5920        */
5921       window = gtk_widget_get_window (widget);
5922       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
5923           window && !gdk_window_get_device_events (window, dev))
5924         continue;
5925
5926       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
5927
5928       fevent->focus_change.type = GDK_FOCUS_CHANGE;
5929       fevent->focus_change.window = window;
5930       if (window)
5931         g_object_ref (window);
5932       fevent->focus_change.in = in;
5933       gdk_event_set_device (fevent, dev);
5934
5935       gtk_widget_send_focus_change (widget, fevent);
5936
5937       gdk_event_free (fevent);
5938     }
5939
5940   g_list_free (devices);
5941   g_object_unref (widget);
5942 }
5943
5944 static gint
5945 gtk_window_focus_in_event (GtkWidget     *widget,
5946                            GdkEventFocus *event)
5947 {
5948   GtkWindow *window = GTK_WINDOW (widget);
5949
5950   /* It appears spurious focus in events can occur when
5951    *  the window is hidden. So we'll just check to see if
5952    *  the window is visible before actually handling the
5953    *  event
5954    */
5955   if (gtk_widget_get_visible (widget))
5956     {
5957       _gtk_window_set_has_toplevel_focus (window, TRUE);
5958       _gtk_window_set_is_active (window, TRUE);
5959     }
5960
5961   return FALSE;
5962 }
5963
5964 static gint
5965 gtk_window_focus_out_event (GtkWidget     *widget,
5966                             GdkEventFocus *event)
5967 {
5968   GtkWindow *window = GTK_WINDOW (widget);
5969   gboolean auto_mnemonics;
5970
5971   _gtk_window_set_has_toplevel_focus (window, FALSE);
5972   _gtk_window_set_is_active (window, FALSE);
5973
5974   /* set the mnemonic-visible property to false */
5975   g_object_get (gtk_widget_get_settings (widget),
5976                 "gtk-auto-mnemonics", &auto_mnemonics, NULL);
5977   if (auto_mnemonics)
5978     gtk_window_set_mnemonics_visible (window, FALSE);
5979
5980   return FALSE;
5981 }
5982
5983 static GdkAtom atom_rcfiles = GDK_NONE;
5984 static GdkAtom atom_iconthemes = GDK_NONE;
5985
5986 static void
5987 send_client_message_to_embedded_windows (GtkWidget *widget,
5988                                          GdkAtom    message_type)
5989 {
5990   GList *embedded_windows;
5991
5992   embedded_windows = g_object_get_qdata (G_OBJECT (widget), quark_gtk_embedded);
5993   if (embedded_windows)
5994     {
5995       GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
5996       int i;
5997
5998       for (i = 0; i < 5; i++)
5999         send_event->client.data.l[i] = 0;
6000       send_event->client.data_format = 32;
6001       send_event->client.message_type = message_type;
6002
6003       while (embedded_windows)
6004         {
6005           GdkNativeWindow xid = GDK_GPOINTER_TO_NATIVE_WINDOW(embedded_windows->data);
6006           gdk_event_send_client_message_for_display (gtk_widget_get_display (widget), send_event, xid);
6007           embedded_windows = embedded_windows->next;
6008         }
6009
6010       gdk_event_free (send_event);
6011     }
6012 }
6013
6014 static gint
6015 gtk_window_client_event (GtkWidget      *widget,
6016                          GdkEventClient *event)
6017 {
6018   if (!atom_rcfiles)
6019     {
6020       atom_rcfiles = gdk_atom_intern_static_string ("_GTK_READ_RCFILES");
6021       atom_iconthemes = gdk_atom_intern_static_string ("_GTK_LOAD_ICONTHEMES");
6022     }
6023
6024   if (event->message_type == atom_rcfiles)
6025     {
6026       send_client_message_to_embedded_windows (widget, atom_rcfiles);
6027       gtk_style_context_reset_widgets (gtk_widget_get_screen (widget));
6028     }
6029
6030   if (event->message_type == atom_iconthemes)
6031     {
6032       send_client_message_to_embedded_windows (widget, atom_iconthemes);
6033       _gtk_icon_theme_check_reload (gtk_widget_get_display (widget));
6034     }
6035
6036   return FALSE;
6037 }
6038
6039 static void
6040 gtk_window_check_resize (GtkContainer *container)
6041 {
6042   if (gtk_widget_get_visible (GTK_WIDGET (container)))
6043     gtk_window_move_resize (GTK_WINDOW (container));
6044 }
6045
6046 static gboolean
6047 gtk_window_focus (GtkWidget        *widget,
6048                   GtkDirectionType  direction)
6049 {
6050   GtkWindowPrivate *priv;
6051   GtkBin *bin;
6052   GtkWindow *window;
6053   GtkContainer *container;
6054   GtkWidget *child;
6055   GtkWidget *old_focus_child;
6056   GtkWidget *parent;
6057
6058   container = GTK_CONTAINER (widget);
6059   window = GTK_WINDOW (widget);
6060   priv = window->priv;
6061   bin = GTK_BIN (widget);
6062
6063   old_focus_child = gtk_container_get_focus_child (container);
6064
6065   /* We need a special implementation here to deal properly with wrapping
6066    * around in the tab chain without the danger of going into an
6067    * infinite loop.
6068    */
6069   if (old_focus_child)
6070     {
6071       if (gtk_widget_child_focus (old_focus_child, direction))
6072         return TRUE;
6073     }
6074
6075   if (priv->focus_widget)
6076     {
6077       if (direction == GTK_DIR_LEFT ||
6078           direction == GTK_DIR_RIGHT ||
6079           direction == GTK_DIR_UP ||
6080           direction == GTK_DIR_DOWN)
6081         {
6082           return FALSE;
6083         }
6084
6085       /* Wrapped off the end, clear the focus setting for the toplpevel */
6086       parent = gtk_widget_get_parent (priv->focus_widget);
6087       while (parent)
6088         {
6089           gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
6090           parent = gtk_widget_get_parent (parent);
6091         }
6092
6093       gtk_window_set_focus (GTK_WINDOW (container), NULL);
6094     }
6095
6096   /* Now try to focus the first widget in the window */
6097   child = gtk_bin_get_child (bin);
6098   if (child)
6099     {
6100       if (gtk_widget_child_focus (child, direction))
6101         return TRUE;
6102     }
6103
6104   return FALSE;
6105 }
6106
6107 static void
6108 gtk_window_move_focus (GtkWidget       *widget,
6109                        GtkDirectionType dir)
6110 {
6111   gtk_widget_child_focus (widget, dir);
6112
6113   if (! gtk_container_get_focus_child (GTK_CONTAINER (widget)))
6114     gtk_window_set_focus (GTK_WINDOW (widget), NULL);
6115 }
6116
6117 static void
6118 gtk_window_real_set_focus (GtkWindow *window,
6119                            GtkWidget *focus)
6120 {
6121   GtkWindowPrivate *priv = window->priv;
6122   GtkWidget *old_focus = priv->focus_widget;
6123   gboolean had_default = FALSE;
6124   gboolean focus_had_default = FALSE;
6125   gboolean old_focus_had_default = FALSE;
6126
6127   if (old_focus)
6128     {
6129       g_object_ref (old_focus);
6130       g_object_freeze_notify (G_OBJECT (old_focus));
6131       old_focus_had_default = gtk_widget_has_default (old_focus);
6132     }
6133   if (focus)
6134     {
6135       g_object_ref (focus);
6136       g_object_freeze_notify (G_OBJECT (focus));
6137       focus_had_default = gtk_widget_has_default (focus);
6138     }
6139
6140   if (priv->default_widget)
6141     had_default = gtk_widget_has_default (priv->default_widget);
6142
6143   if (priv->focus_widget)
6144     {
6145       if (gtk_widget_get_receives_default (priv->focus_widget) &&
6146           (priv->focus_widget != priv->default_widget))
6147         {
6148           _gtk_widget_set_has_default (priv->focus_widget, FALSE);
6149           gtk_widget_queue_draw (priv->focus_widget);
6150
6151           if (priv->default_widget)
6152             _gtk_widget_set_has_default (priv->default_widget, TRUE);
6153         }
6154
6155       priv->focus_widget = NULL;
6156
6157       if (priv->has_focus)
6158         do_focus_change (old_focus, FALSE);
6159
6160       g_object_notify (G_OBJECT (old_focus), "is-focus");
6161     }
6162
6163   /* The above notifications may have set a new focus widget,
6164    * if so, we don't want to override it.
6165    */
6166   if (focus && !priv->focus_widget)
6167     {
6168       priv->focus_widget = focus;
6169
6170       if (gtk_widget_get_receives_default (priv->focus_widget) &&
6171           (priv->focus_widget != priv->default_widget))
6172         {
6173           if (gtk_widget_get_can_default (priv->focus_widget))
6174             _gtk_widget_set_has_default (priv->focus_widget, TRUE);
6175
6176           if (priv->default_widget)
6177             _gtk_widget_set_has_default (priv->default_widget, FALSE);
6178         }
6179
6180       if (priv->has_focus)
6181         do_focus_change (priv->focus_widget, TRUE);
6182
6183       g_object_notify (G_OBJECT (priv->focus_widget), "is-focus");
6184     }
6185
6186   /* If the default widget changed, a redraw will have been queued
6187    * on the old and new default widgets by gtk_window_set_default(), so
6188    * we only have to worry about the case where it didn't change.
6189    * We'll sometimes queue a draw twice on the new widget but that
6190    * is harmless.
6191    */
6192   if (priv->default_widget &&
6193       (had_default != gtk_widget_has_default (priv->default_widget)))
6194     gtk_widget_queue_draw (priv->default_widget);
6195
6196   if (old_focus)
6197     {
6198       if (old_focus_had_default != gtk_widget_has_default (old_focus))
6199         gtk_widget_queue_draw (old_focus);
6200
6201       g_object_thaw_notify (G_OBJECT (old_focus));
6202       g_object_unref (old_focus);
6203     }
6204   if (focus)
6205     {
6206       if (focus_had_default != gtk_widget_has_default (focus))
6207         gtk_widget_queue_draw (focus);
6208
6209       g_object_thaw_notify (G_OBJECT (focus));
6210       g_object_unref (focus);
6211     }
6212 }
6213
6214
6215 static void
6216 gtk_window_get_preferred_width (GtkWidget *widget,
6217                                 gint      *minimum_size,
6218                                 gint      *natural_size)
6219 {
6220   GtkWindow *window;
6221   GtkWidget *child;
6222   guint border_width;
6223
6224   window = GTK_WINDOW (widget);
6225   child  = gtk_bin_get_child (GTK_BIN (window));
6226
6227   border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
6228   *minimum_size = border_width * 2;
6229   *natural_size = border_width * 2;
6230
6231   if (child && gtk_widget_get_visible (child))
6232     {
6233       gint child_min, child_nat;
6234       gtk_widget_get_preferred_width (child, &child_min, &child_nat);
6235
6236       *minimum_size += child_min;
6237       *natural_size += child_nat;
6238     }
6239 }
6240
6241 static void
6242 gtk_window_get_preferred_height (GtkWidget *widget,
6243                                  gint      *minimum_size,
6244                                  gint      *natural_size)
6245 {
6246   GtkWindow *window;
6247   GtkWidget *child;
6248   guint border_width;
6249
6250   window = GTK_WINDOW (widget);
6251   child  = gtk_bin_get_child (GTK_BIN (window));
6252
6253   border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
6254   *minimum_size = border_width * 2;
6255   *natural_size = border_width * 2;
6256
6257   if (child && gtk_widget_get_visible (child))
6258     {
6259       gint child_min, child_nat;
6260       gtk_widget_get_preferred_height (child, &child_min, &child_nat);
6261
6262       *minimum_size += child_min;
6263       *natural_size += child_nat;
6264     }
6265 }
6266
6267
6268 /**
6269  * _gtk_window_unset_focus_and_default:
6270  * @window: a #GtkWindow
6271  * @widget: a widget inside of @window
6272  *
6273  * Checks whether the focus and default widgets of @window are
6274  * @widget or a descendent of @widget, and if so, unset them.
6275  **/
6276 void
6277 _gtk_window_unset_focus_and_default (GtkWindow *window,
6278                                      GtkWidget *widget)
6279
6280 {
6281   GtkWindowPrivate *priv = window->priv;
6282   GtkWidget *child;
6283   GtkWidget *parent;
6284
6285   g_object_ref (window);
6286   g_object_ref (widget);
6287
6288   parent = gtk_widget_get_parent (widget);
6289   if (gtk_container_get_focus_child (GTK_CONTAINER (parent)) == widget)
6290     {
6291       child = priv->focus_widget;
6292
6293       while (child && child != widget)
6294         child = gtk_widget_get_parent (child);
6295
6296       if (child == widget)
6297         gtk_window_set_focus (GTK_WINDOW (window), NULL);
6298     }
6299
6300   child = priv->default_widget;
6301
6302   while (child && child != widget)
6303     child = gtk_widget_get_parent (child);
6304
6305   if (child == widget)
6306     gtk_window_set_default (window, NULL);
6307
6308   g_object_unref (widget);
6309   g_object_unref (window);
6310 }
6311
6312 /*********************************
6313  * Functions related to resizing *
6314  *********************************/
6315
6316 static void
6317 geometry_size_to_pixels (GdkGeometry *geometry,
6318                          guint        flags,
6319                          guint       *width,
6320                          guint       *height)
6321 {
6322   gint base_width = 0;
6323   gint base_height = 0;
6324   gint min_width = 0;
6325   gint min_height = 0;
6326   gint width_inc = 1;
6327   gint height_inc = 1;
6328
6329   if (flags & GDK_HINT_BASE_SIZE)
6330     {
6331       base_width = geometry->base_width;
6332       base_height = geometry->base_height;
6333     }
6334   if (flags & GDK_HINT_MIN_SIZE)
6335     {
6336       min_width = geometry->min_width;
6337       min_height = geometry->min_height;
6338     }
6339   if (flags & GDK_HINT_RESIZE_INC)
6340     {
6341       width_inc = geometry->width_inc;
6342       height_inc = geometry->height_inc;
6343     }
6344
6345   if (width)
6346     *width = MAX (*width * width_inc + base_width, min_width);
6347   if (height)
6348     *height = MAX (*height * height_inc + base_height, min_height);
6349 }
6350
6351 /* This function doesn't constrain to geometry hints */
6352 static void
6353 gtk_window_compute_configure_request_size (GtkWindow   *window,
6354                                            GdkGeometry *geometry,
6355                                            guint        flags,
6356                                            guint       *width,
6357                                            guint       *height)
6358 {
6359   GtkWindowPrivate *priv = window->priv;
6360   GtkRequisition requisition;
6361   GtkWindowGeometryInfo *info;
6362   GtkWidget *widget;
6363
6364   /* Preconditions:
6365    *  - we've done a size request
6366    */
6367
6368   widget = GTK_WIDGET (window);
6369
6370   info = gtk_window_get_geometry_info (window, FALSE);
6371
6372   if (priv->need_default_size)
6373     {
6374       gtk_widget_get_preferred_size (widget, &requisition, NULL);
6375
6376       /* Default to requisition */
6377       *width = requisition.width;
6378       *height = requisition.height;
6379
6380       /* If window is empty so requests 0, default to random nonzero size */
6381        if (*width == 0 && *height == 0)
6382          {
6383            *width = 200;
6384            *height = 200;
6385          }
6386
6387        /* Override requisition with default size */
6388
6389        if (info)
6390          {
6391            if (info->default_width > 0)
6392              *width = info->default_width;
6393            if (info->default_height > 0)
6394              *height = info->default_height;
6395
6396            if (info->default_is_geometry)
6397              geometry_size_to_pixels (geometry, flags,
6398                                       info->default_width > 0 ? width : NULL,
6399                                       info->default_height > 0 ? height : NULL);
6400          }
6401     }
6402   else
6403     {
6404       GtkAllocation allocation;
6405
6406       gtk_widget_get_allocation (widget, &allocation);
6407
6408       /* Default to keeping current size */
6409       *width = allocation.width;
6410       *height = allocation.height;
6411     }
6412
6413   /* Override any size with gtk_window_resize() values */
6414   if (info)
6415     {
6416       if (info->resize_width > 0)
6417         *width = info->resize_width;
6418       if (info->resize_height > 0)
6419         *height = info->resize_height;
6420
6421       if (info->resize_is_geometry)
6422         geometry_size_to_pixels (geometry, flags,
6423                                  info->resize_width > 0 ? width : NULL,
6424                                  info->resize_height > 0 ? height : NULL);
6425     }
6426
6427   /* Don't ever request zero width or height, its not supported by
6428      gdk. The size allocation code will round it to 1 anyway but if
6429      we do it then the value returned from this function will is
6430      not comparable to the size allocation read from the GtkWindow. */
6431   *width = MAX (*width, 1);
6432   *height = MAX (*height, 1);
6433 }
6434
6435 static GtkWindowPosition
6436 get_effective_position (GtkWindow *window)
6437 {
6438   GtkWindowPrivate *priv = window->priv;
6439   GtkWindowPosition pos = priv->position;
6440
6441   if (pos == GTK_WIN_POS_CENTER_ON_PARENT &&
6442       (priv->transient_parent == NULL ||
6443        !gtk_widget_get_mapped (GTK_WIDGET (priv->transient_parent))))
6444     pos = GTK_WIN_POS_NONE;
6445
6446   return pos;
6447 }
6448
6449 static int
6450 get_center_monitor_of_window (GtkWindow *window)
6451 {
6452   /* We could try to sort out the relative positions of the monitors and
6453    * stuff, or we could just be losers and assume you have a row
6454    * or column of monitors.
6455    */
6456   return gdk_screen_get_n_monitors (gtk_window_check_screen (window)) / 2;
6457 }
6458
6459 static int
6460 get_monitor_containing_pointer (GtkWindow *window)
6461 {
6462   gint px, py;
6463   gint monitor_num;
6464   GdkScreen *window_screen;
6465   GdkScreen *pointer_screen;
6466   GdkDisplay *display;
6467   GdkDeviceManager *device_manager;
6468   GdkDevice *pointer;
6469
6470   window_screen = gtk_window_check_screen (window);
6471   display = gdk_screen_get_display (window_screen);
6472   device_manager = gdk_display_get_device_manager (display);
6473   pointer = gdk_device_manager_get_client_pointer (device_manager);
6474
6475   gdk_display_get_device_state (display, pointer,
6476                                 &pointer_screen,
6477                                 &px, &py, NULL);
6478
6479   if (pointer_screen == window_screen)
6480     monitor_num = gdk_screen_get_monitor_at_point (pointer_screen, px, py);
6481   else
6482     monitor_num = -1;
6483
6484   return monitor_num;
6485 }
6486
6487 static void
6488 center_window_on_monitor (GtkWindow *window,
6489                           gint       w,
6490                           gint       h,
6491                           gint      *x,
6492                           gint      *y)
6493 {
6494   GdkRectangle monitor;
6495   int monitor_num;
6496
6497   monitor_num = get_monitor_containing_pointer (window);
6498
6499   if (monitor_num == -1)
6500     monitor_num = get_center_monitor_of_window (window);
6501
6502   gdk_screen_get_monitor_geometry (gtk_window_check_screen (window),
6503                                    monitor_num, &monitor);
6504
6505   *x = (monitor.width - w) / 2 + monitor.x;
6506   *y = (monitor.height - h) / 2 + monitor.y;
6507
6508   /* Be sure we aren't off the monitor, ignoring _NET_WM_STRUT
6509    * and WM decorations.
6510    */
6511   if (*x < monitor.x)
6512     *x = monitor.x;
6513   if (*y < monitor.y)
6514     *y = monitor.y;
6515 }
6516
6517 static void
6518 clamp (gint *base,
6519        gint  extent,
6520        gint  clamp_base,
6521        gint  clamp_extent)
6522 {
6523   if (extent > clamp_extent)
6524     /* Center */
6525     *base = clamp_base + clamp_extent/2 - extent/2;
6526   else if (*base < clamp_base)
6527     *base = clamp_base;
6528   else if (*base + extent > clamp_base + clamp_extent)
6529     *base = clamp_base + clamp_extent - extent;
6530 }
6531
6532 static void
6533 clamp_window_to_rectangle (gint               *x,
6534                            gint               *y,
6535                            gint                w,
6536                            gint                h,
6537                            const GdkRectangle *rect)
6538 {
6539 #ifdef DEBUGGING_OUTPUT
6540   g_print ("%s: %+d%+d %dx%d: %+d%+d: %dx%d", G_STRFUNC, rect->x, rect->y, rect->width, rect->height, *x, *y, w, h);
6541 #endif
6542
6543   /* If it is too large, center it. If it fits on the monitor but is
6544    * partially outside, move it to the closest edge. Do this
6545    * separately in x and y directions.
6546    */
6547   clamp (x, w, rect->x, rect->width);
6548   clamp (y, h, rect->y, rect->height);
6549 #ifdef DEBUGGING_OUTPUT
6550   g_print (" ==> %+d%+d: %dx%d\n", *x, *y, w, h);
6551 #endif
6552 }
6553
6554
6555 static void
6556 gtk_window_compute_configure_request (GtkWindow    *window,
6557                                       GdkRectangle *request,
6558                                       GdkGeometry  *geometry,
6559                                       guint        *flags)
6560 {
6561   GtkWindowPrivate *priv = window->priv;
6562   GdkGeometry new_geometry;
6563   guint new_flags;
6564   int w, h;
6565   GtkWidget *widget;
6566   GtkWindowPosition pos;
6567   GtkWidget *parent_widget;
6568   GtkWindowGeometryInfo *info;
6569   GdkScreen *screen;
6570   int x, y;
6571
6572   widget = GTK_WIDGET (window);
6573
6574   screen = gtk_window_check_screen (window);
6575
6576   gtk_window_compute_hints (window, &new_geometry, &new_flags);
6577   gtk_window_compute_configure_request_size (window,
6578                                              &new_geometry, new_flags,
6579                                              (guint *)&w, (guint *)&h);
6580
6581   gtk_window_constrain_size (window,
6582                              &new_geometry, new_flags,
6583                              w, h,
6584                              &w, &h);
6585
6586   parent_widget = (GtkWidget*) priv->transient_parent;
6587
6588   pos = get_effective_position (window);
6589   info = gtk_window_get_geometry_info (window, FALSE);
6590
6591   /* by default, don't change position requested */
6592   if (info)
6593     {
6594       x = info->last.configure_request.x;
6595       y = info->last.configure_request.y;
6596     }
6597   else
6598     {
6599       x = 0;
6600       y = 0;
6601     }
6602
6603
6604   if (priv->need_default_position)
6605     {
6606
6607       /* FIXME this all interrelates with window gravity.
6608        * For most of them I think we want to set GRAVITY_CENTER.
6609        *
6610        * Not sure how to go about that.
6611        */
6612
6613       switch (pos)
6614         {
6615           /* here we are only handling CENTER_ALWAYS
6616            * as it relates to default positioning,
6617            * where it's equivalent to simply CENTER
6618            */
6619         case GTK_WIN_POS_CENTER_ALWAYS:
6620         case GTK_WIN_POS_CENTER:
6621           center_window_on_monitor (window, w, h, &x, &y);
6622           break;
6623
6624         case GTK_WIN_POS_CENTER_ON_PARENT:
6625           {
6626             GtkAllocation allocation;
6627             GdkWindow *gdk_window;
6628             gint monitor_num;
6629             GdkRectangle monitor;
6630             gint ox, oy;
6631
6632             g_assert (gtk_widget_get_mapped (parent_widget)); /* established earlier */
6633
6634             gdk_window = gtk_widget_get_window (parent_widget);
6635
6636             if (gdk_window != NULL)
6637               monitor_num = gdk_screen_get_monitor_at_window (screen,
6638                                                               gdk_window);
6639             else
6640               monitor_num = -1;
6641
6642             gdk_window_get_origin (gdk_window,
6643                                    &ox, &oy);
6644
6645             gtk_widget_get_allocation (parent_widget, &allocation);
6646             x = ox + (allocation.width - w) / 2;
6647             y = oy + (allocation.height - h) / 2;
6648
6649             /* Clamp onto current monitor, ignoring _NET_WM_STRUT and
6650              * WM decorations. If parent wasn't on a monitor, just
6651              * give up.
6652              */
6653             if (monitor_num >= 0)
6654               {
6655                 gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
6656                 clamp_window_to_rectangle (&x, &y, w, h, &monitor);
6657               }
6658           }
6659           break;
6660
6661         case GTK_WIN_POS_MOUSE:
6662           {
6663             gint screen_width = gdk_screen_get_width (screen);
6664             gint screen_height = gdk_screen_get_height (screen);
6665             gint monitor_num;
6666             GdkRectangle monitor;
6667             GdkDisplay *display;
6668             GdkDeviceManager *device_manager;
6669             GdkDevice *pointer;
6670             GdkScreen *pointer_screen;
6671             gint px, py;
6672
6673             display = gdk_screen_get_display (screen);
6674             device_manager = gdk_display_get_device_manager (display);
6675             pointer = gdk_device_manager_get_client_pointer (device_manager);
6676
6677             gdk_display_get_device_state (display, pointer,
6678                                           &pointer_screen,
6679                                           &px, &py, NULL);
6680
6681             if (pointer_screen == screen)
6682               monitor_num = gdk_screen_get_monitor_at_point (screen, px, py);
6683             else
6684               monitor_num = -1;
6685
6686             x = px - w / 2;
6687             y = py - h / 2;
6688             x = CLAMP (x, 0, screen_width - w);
6689             y = CLAMP (y, 0, screen_height - h);
6690
6691             /* Clamp onto current monitor, ignoring _NET_WM_STRUT and
6692              * WM decorations. Don't try to figure out what's going
6693              * on if the mouse wasn't inside a monitor.
6694              */
6695             if (monitor_num >= 0)
6696               {
6697                 gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
6698                 clamp_window_to_rectangle (&x, &y, w, h, &monitor);
6699               }
6700           }
6701           break;
6702
6703         default:
6704           break;
6705         }
6706     } /* if (priv->need_default_position) */
6707
6708   if (priv->need_default_position && info &&
6709       info->initial_pos_set)
6710     {
6711       x = info->initial_x;
6712       y = info->initial_y;
6713       gtk_window_constrain_position (window, w, h, &x, &y);
6714     }
6715
6716   request->x = x;
6717   request->y = y;
6718   request->width = w;
6719   request->height = h;
6720
6721   if (geometry)
6722     *geometry = new_geometry;
6723   if (flags)
6724     *flags = new_flags;
6725 }
6726
6727 static void
6728 gtk_window_constrain_position (GtkWindow    *window,
6729                                gint          new_width,
6730                                gint          new_height,
6731                                gint         *x,
6732                                gint         *y)
6733 {
6734   GtkWindowPrivate *priv = window->priv;
6735
6736   /* See long comments in gtk_window_move_resize()
6737    * on when it's safe to call this function.
6738    */
6739   if (priv->position == GTK_WIN_POS_CENTER_ALWAYS)
6740     {
6741       gint center_x, center_y;
6742
6743       center_window_on_monitor (window, new_width, new_height, &center_x, &center_y);
6744
6745       *x = center_x;
6746       *y = center_y;
6747     }
6748 }
6749
6750 static void
6751 gtk_window_move_resize (GtkWindow *window)
6752 {
6753   /* Overview:
6754    *
6755    * First we determine whether any information has changed that would
6756    * cause us to revise our last configure request.  If we would send
6757    * a different configure request from last time, then
6758    * configure_request_size_changed = TRUE or
6759    * configure_request_pos_changed = TRUE. configure_request_size_changed
6760    * may be true due to new hints, a gtk_window_resize(), or whatever.
6761    * configure_request_pos_changed may be true due to gtk_window_set_position()
6762    * or gtk_window_move().
6763    *
6764    * If the configure request has changed, we send off a new one.  To
6765    * ensure GTK+ invariants are maintained (resize queue does what it
6766    * should), we go ahead and size_allocate the requested size in this
6767    * function.
6768    *
6769    * If the configure request has not changed, we don't ever resend
6770    * it, because it could mean fighting the user or window manager.
6771    *
6772    *
6773    *   To prepare the configure request, we come up with a base size/pos:
6774    *      - the one from gtk_window_move()/gtk_window_resize()
6775    *      - else default_width, default_height if we haven't ever
6776    *        been mapped
6777    *      - else the size request if we haven't ever been mapped,
6778    *        as a substitute default size
6779    *      - else the current size of the window, as received from
6780    *        configure notifies (i.e. the current allocation)
6781    *
6782    *   If GTK_WIN_POS_CENTER_ALWAYS is active, we constrain
6783    *   the position request to be centered.
6784    */
6785   GtkWindowPrivate *priv = window->priv;
6786   GtkAllocation allocation;
6787   GtkWidget *widget;
6788   GtkContainer *container;
6789   GtkWindowGeometryInfo *info;
6790   GdkGeometry new_geometry;
6791   GdkWindow *gdk_window;
6792   guint new_flags;
6793   GdkRectangle new_request;
6794   gboolean configure_request_size_changed;
6795   gboolean configure_request_pos_changed;
6796   gboolean hints_changed; /* do we need to send these again */
6797   GtkWindowLastGeometryInfo saved_last_info;
6798
6799   widget = GTK_WIDGET (window);
6800   gdk_window = gtk_widget_get_window (widget);
6801   container = GTK_CONTAINER (widget);
6802   info = gtk_window_get_geometry_info (window, TRUE);
6803
6804   configure_request_size_changed = FALSE;
6805   configure_request_pos_changed = FALSE;
6806
6807   gtk_window_compute_configure_request (window, &new_request,
6808                                         &new_geometry, &new_flags);
6809
6810   /* This check implies the invariant that we never set info->last
6811    * without setting the hints and sending off a configure request.
6812    *
6813    * If we change info->last without sending the request, we may
6814    * miss a request.
6815    */
6816   if (info->last.configure_request.x != new_request.x ||
6817       info->last.configure_request.y != new_request.y)
6818     configure_request_pos_changed = TRUE;
6819
6820   if ((info->last.configure_request.width != new_request.width ||
6821        info->last.configure_request.height != new_request.height))
6822     configure_request_size_changed = TRUE;
6823
6824   hints_changed = FALSE;
6825
6826   if (!gtk_window_compare_hints (&info->last.geometry, info->last.flags,
6827                                  &new_geometry, new_flags))
6828     {
6829       hints_changed = TRUE;
6830     }
6831
6832   /* Position Constraints
6833    * ====================
6834    *
6835    * POS_CENTER_ALWAYS is conceptually a constraint rather than
6836    * a default. The other POS_ values are used only when the
6837    * window is shown, not after that.
6838    *
6839    * However, we can't implement a position constraint as
6840    * "anytime the window size changes, center the window"
6841    * because this may well end up fighting the WM or user.  In
6842    * fact it gets in an infinite loop with at least one WM.
6843    *
6844    * Basically, applications are in no way in a position to
6845    * constrain the position of a window, with one exception:
6846    * override redirect windows. (Really the intended purpose
6847    * of CENTER_ALWAYS anyhow, I would think.)
6848    *
6849    * So the way we implement this "constraint" is to say that when WE
6850    * cause a move or resize, i.e. we make a configure request changing
6851    * window size, we recompute the CENTER_ALWAYS position to reflect
6852    * the new window size, and include it in our request.  Also, if we
6853    * just turned on CENTER_ALWAYS we snap to center with a new
6854    * request.  Otherwise, if we are just NOTIFIED of a move or resize
6855    * done by someone else e.g. the window manager, we do NOT send a
6856    * new configure request.
6857    *
6858    * For override redirect windows, this works fine; all window
6859    * sizes are from our configure requests. For managed windows,
6860    * it is at least semi-sane, though who knows what the
6861    * app author is thinking.
6862    */
6863
6864   /* This condition should be kept in sync with the condition later on
6865    * that determines whether we send a configure request.  i.e. we
6866    * should do this position constraining anytime we were going to
6867    * send a configure request anyhow, plus when constraints have
6868    * changed.
6869    */
6870   if (configure_request_pos_changed ||
6871       configure_request_size_changed ||
6872       hints_changed ||
6873       info->position_constraints_changed)
6874     {
6875       /* We request the constrained position if:
6876        *  - we were changing position, and need to clamp
6877        *    the change to the constraint
6878        *  - we're changing the size anyway
6879        *  - set_position() was called to toggle CENTER_ALWAYS on
6880        */
6881
6882       gtk_window_constrain_position (window,
6883                                      new_request.width,
6884                                      new_request.height,
6885                                      &new_request.x,
6886                                      &new_request.y);
6887
6888       /* Update whether we need to request a move */
6889       if (info->last.configure_request.x != new_request.x ||
6890           info->last.configure_request.y != new_request.y)
6891         configure_request_pos_changed = TRUE;
6892       else
6893         configure_request_pos_changed = FALSE;
6894     }
6895
6896 #if 0
6897   if (priv->type == GTK_WINDOW_TOPLEVEL)
6898     {
6899       int notify_x, notify_y;
6900
6901       /* this is the position from the last configure notify */
6902       gdk_window_get_position (widget->window, &notify_x, &notify_y);
6903
6904       g_message ("--- %s ---\n"
6905                  "last  : %d,%d\t%d x %d\n"
6906                  "this  : %d,%d\t%d x %d\n"
6907                  "alloc : %d,%d\t%d x %d\n"
6908                  "req   :      \t%d x %d\n"
6909                  "resize:      \t%d x %d\n"
6910                  "size_changed: %d pos_changed: %d hints_changed: %d\n"
6911                  "configure_notify_received: %d\n"
6912                  "configure_request_count: %d\n"
6913                  "position_constraints_changed: %d\n",
6914                  priv->title ? priv->title : "(no title)",
6915                  info->last.configure_request.x,
6916                  info->last.configure_request.y,
6917                  info->last.configure_request.width,
6918                  info->last.configure_request.height,
6919                  new_request.x,
6920                  new_request.y,
6921                  new_request.width,
6922                  new_request.height,
6923                  notify_x, notify_y,
6924                  widget->allocation.width,
6925                  widget->allocation.height,
6926                  widget->requisition.width,
6927                  widget->requisition.height,
6928                  info->resize_width,
6929                  info->resize_height,
6930                  configure_request_pos_changed,
6931                  configure_request_size_changed,
6932                  hints_changed,
6933                  priv->configure_notify_received,
6934                  priv->configure_request_count,
6935                  info->position_constraints_changed);
6936     }
6937 #endif
6938
6939   saved_last_info = info->last;
6940   info->last.geometry = new_geometry;
6941   info->last.flags = new_flags;
6942   info->last.configure_request = new_request;
6943
6944   /* need to set PPosition so the WM will look at our position,
6945    * but we don't want to count PPosition coming and going as a hints
6946    * change for future iterations. So we saved info->last prior to
6947    * this.
6948    */
6949
6950   /* Also, if the initial position was explicitly set, then we always
6951    * toggle on PPosition. This makes gtk_window_move(window, 0, 0)
6952    * work.
6953    */
6954
6955   /* Also, we toggle on PPosition if GTK_WIN_POS_ is in use and
6956    * this is an initial map
6957    */
6958
6959   if ((configure_request_pos_changed ||
6960        info->initial_pos_set ||
6961        (priv->need_default_position &&
6962         get_effective_position (window) != GTK_WIN_POS_NONE)) &&
6963       (new_flags & GDK_HINT_POS) == 0)
6964     {
6965       new_flags |= GDK_HINT_POS;
6966       hints_changed = TRUE;
6967     }
6968
6969   /* Set hints if necessary
6970    */
6971   if (hints_changed)
6972     gdk_window_set_geometry_hints (gdk_window,
6973                                    &new_geometry,
6974                                    new_flags);
6975
6976   gtk_widget_get_allocation (widget, &allocation);
6977
6978   /* handle resizing/moving and widget tree allocation
6979    */
6980   if (priv->configure_notify_received)
6981     {
6982       /* If we have received a configure event since
6983        * the last time in this function, we need to
6984        * accept our new size and size_allocate child widgets.
6985        * (see gtk_window_configure_event() for more details).
6986        *
6987        * 1 or more configure notifies may have been received.
6988        * Also, configure_notify_received will only be TRUE
6989        * if all expected configure notifies have been received
6990        * (one per configure request), as an optimization.
6991        *
6992        */
6993       priv->configure_notify_received = FALSE;
6994
6995       /* gtk_window_configure_event() filled in widget->allocation */
6996       gtk_widget_size_allocate (widget, &allocation);
6997
6998       set_grip_position (window);
6999       update_grip_visibility (window);
7000
7001       gdk_window_process_updates (gdk_window, TRUE);
7002
7003       gdk_window_configure_finished (gdk_window);
7004
7005       /* If the configure request changed, it means that
7006        * we either:
7007        *   1) coincidentally changed hints or widget properties
7008        *      impacting the configure request before getting
7009        *      a configure notify, or
7010        *   2) some broken widget is changing its size request
7011        *      during size allocation, resulting in
7012        *      a false appearance of changed configure request.
7013        *
7014        * For 1), we could just go ahead and ask for the
7015        * new size right now, but doing that for 2)
7016        * might well be fighting the user (and can even
7017        * trigger a loop). Since we really don't want to
7018        * do that, we requeue a resize in hopes that
7019        * by the time it gets handled, the child has seen
7020        * the light and is willing to go along with the
7021        * new size. (this happens for the zvt widget, since
7022        * the size_allocate() above will have stored the
7023        * requisition corresponding to the new size in the
7024        * zvt widget)
7025        *
7026        * This doesn't buy us anything for 1), but it shouldn't
7027        * hurt us too badly, since it is what would have
7028        * happened if we had gotten the configure event before
7029        * the new size had been set.
7030        */
7031
7032       if (configure_request_size_changed ||
7033           configure_request_pos_changed)
7034         {
7035           /* Don't change the recorded last info after all, because we
7036            * haven't actually updated to the new info yet - we decided
7037            * to postpone our configure request until later.
7038            */
7039           info->last = saved_last_info;
7040
7041           gtk_widget_queue_resize_no_redraw (widget); /* migth recurse for GTK_RESIZE_IMMEDIATE */
7042         }
7043
7044       return;                   /* Bail out, we didn't really process the move/resize */
7045     }
7046   else if ((configure_request_size_changed || hints_changed) &&
7047            (allocation.width != new_request.width || allocation.height != new_request.height))
7048
7049     {
7050       /* We are in one of the following situations:
7051        * A. configure_request_size_changed
7052        *    our requisition has changed and we need a different window size,
7053        *    so we request it from the window manager.
7054        * B. !configure_request_size_changed && hints_changed
7055        *    the window manager rejects our size, but we have just changed the
7056        *    window manager hints, so there's a chance our request will
7057        *    be honoured this time, so we try again.
7058        *
7059        * However, if the new requisition is the same as the current allocation,
7060        * we don't request it again, since we won't get a ConfigureNotify back from
7061        * the window manager unless it decides to change our requisition. If
7062        * we don't get the ConfigureNotify back, the resize queue will never be run.
7063        */
7064
7065       /* Now send the configure request */
7066       if (configure_request_pos_changed)
7067         {
7068           if (priv->frame)
7069             {
7070               gdk_window_move_resize (priv->frame,
7071                                       new_request.x - priv->frame_left,
7072                                       new_request.y - priv->frame_top,
7073                                       new_request.width + priv->frame_left + priv->frame_right,
7074                                       new_request.height + priv->frame_top + priv->frame_bottom);
7075               gdk_window_resize (gdk_window,
7076                                  new_request.width, new_request.height);
7077             }
7078           else
7079             gdk_window_move_resize (gdk_window,
7080                                     new_request.x, new_request.y,
7081                                     new_request.width, new_request.height);
7082         }
7083       else  /* only size changed */
7084         {
7085           if (priv->frame)
7086             gdk_window_resize (priv->frame,
7087                                new_request.width + priv->frame_left + priv->frame_right,
7088                                new_request.height + priv->frame_top + priv->frame_bottom);
7089           gdk_window_resize (gdk_window,
7090                              new_request.width, new_request.height);
7091         }
7092
7093       if (priv->type == GTK_WINDOW_POPUP)
7094         {
7095           GtkAllocation allocation;
7096
7097           /* Directly size allocate for override redirect (popup) windows. */
7098           allocation.x = 0;
7099           allocation.y = 0;
7100           allocation.width = new_request.width;
7101           allocation.height = new_request.height;
7102
7103           gtk_widget_size_allocate (widget, &allocation);
7104
7105           gdk_window_process_updates (gdk_window, TRUE);
7106
7107           if (gtk_container_get_resize_mode (container) == GTK_RESIZE_QUEUE)
7108             gtk_widget_queue_draw (widget);
7109         }
7110       else
7111         {
7112           /* Increment the number of have-not-yet-received-notify requests */
7113           priv->configure_request_count += 1;
7114           gdk_window_freeze_toplevel_updates_libgtk_only (gdk_window);
7115
7116           /* for GTK_RESIZE_QUEUE toplevels, we are now awaiting a new
7117            * configure event in response to our resizing request.
7118            * the configure event will cause a new resize with
7119            * ->configure_notify_received=TRUE.
7120            * until then, we want to
7121            * - discard expose events
7122            * - coalesce resizes for our children
7123            * - defer any window resizes until the configure event arrived
7124            * to achieve this, we queue a resize for the window, but remove its
7125            * resizing handler, so resizing will not be handled from the next
7126            * idle handler but when the configure event arrives.
7127            *
7128            * FIXME: we should also dequeue the pending redraws here, since
7129            * we handle those ourselves upon ->configure_notify_received==TRUE.
7130            */
7131           if (gtk_container_get_resize_mode (container) == GTK_RESIZE_QUEUE)
7132             {
7133               gtk_widget_queue_resize_no_redraw (widget);
7134               _gtk_container_dequeue_resize_handler (container);
7135             }
7136         }
7137     }
7138   else
7139     {
7140       /* Handle any position changes.
7141        */
7142       if (configure_request_pos_changed)
7143         {
7144           if (priv->frame)
7145             {
7146               gdk_window_move (priv->frame,
7147                                new_request.x - priv->frame_left,
7148                                new_request.y - priv->frame_top);
7149             }
7150           else
7151             gdk_window_move (gdk_window,
7152                              new_request.x, new_request.y);
7153         }
7154
7155       /* And run the resize queue.
7156        */
7157       gtk_container_resize_children (container);
7158     }
7159
7160   /* We have now processed a move/resize since the last position
7161    * constraint change, setting of the initial position, or resize.
7162    * (Not resetting these flags here can lead to infinite loops for
7163    * GTK_RESIZE_IMMEDIATE containers)
7164    */
7165   info->position_constraints_changed = FALSE;
7166   info->initial_pos_set = FALSE;
7167   info->resize_width = -1;
7168   info->resize_height = -1;
7169 }
7170
7171 /* Compare two sets of Geometry hints for equality.
7172  */
7173 static gboolean
7174 gtk_window_compare_hints (GdkGeometry *geometry_a,
7175                           guint        flags_a,
7176                           GdkGeometry *geometry_b,
7177                           guint        flags_b)
7178 {
7179   if (flags_a != flags_b)
7180     return FALSE;
7181
7182   if ((flags_a & GDK_HINT_MIN_SIZE) &&
7183       (geometry_a->min_width != geometry_b->min_width ||
7184        geometry_a->min_height != geometry_b->min_height))
7185     return FALSE;
7186
7187   if ((flags_a & GDK_HINT_MAX_SIZE) &&
7188       (geometry_a->max_width != geometry_b->max_width ||
7189        geometry_a->max_height != geometry_b->max_height))
7190     return FALSE;
7191
7192   if ((flags_a & GDK_HINT_BASE_SIZE) &&
7193       (geometry_a->base_width != geometry_b->base_width ||
7194        geometry_a->base_height != geometry_b->base_height))
7195     return FALSE;
7196
7197   if ((flags_a & GDK_HINT_ASPECT) &&
7198       (geometry_a->min_aspect != geometry_b->min_aspect ||
7199        geometry_a->max_aspect != geometry_b->max_aspect))
7200     return FALSE;
7201
7202   if ((flags_a & GDK_HINT_RESIZE_INC) &&
7203       (geometry_a->width_inc != geometry_b->width_inc ||
7204        geometry_a->height_inc != geometry_b->height_inc))
7205     return FALSE;
7206
7207   if ((flags_a & GDK_HINT_WIN_GRAVITY) &&
7208       geometry_a->win_gravity != geometry_b->win_gravity)
7209     return FALSE;
7210
7211   return TRUE;
7212 }
7213
7214 void
7215 _gtk_window_constrain_size (GtkWindow   *window,
7216                             gint         width,
7217                             gint         height,
7218                             gint        *new_width,
7219                             gint        *new_height)
7220 {
7221   GtkWindowPrivate *priv;
7222   GtkWindowGeometryInfo *info;
7223
7224   g_return_if_fail (GTK_IS_WINDOW (window));
7225
7226   priv = window->priv;
7227
7228   info = priv->geometry_info;
7229   if (info)
7230     {
7231       GdkWindowHints flags = info->last.flags;
7232       GdkGeometry *geometry = &info->last.geometry;
7233
7234       gtk_window_constrain_size (window,
7235                                  geometry,
7236                                  flags,
7237                                  width,
7238                                  height,
7239                                  new_width,
7240                                  new_height);
7241     }
7242 }
7243
7244 static void
7245 gtk_window_constrain_size (GtkWindow   *window,
7246                            GdkGeometry *geometry,
7247                            guint        flags,
7248                            gint         width,
7249                            gint         height,
7250                            gint        *new_width,
7251                            gint        *new_height)
7252 {
7253   gdk_window_constrain_size (geometry, flags, width, height,
7254                              new_width, new_height);
7255 }
7256
7257 /* Compute the set of geometry hints and flags for a window
7258  * based on the application set geometry, and requisition
7259  * of the window. gtk_widget_get_preferred_size() must have been
7260  * called first.
7261  */
7262 static void
7263 gtk_window_compute_hints (GtkWindow   *window,
7264                           GdkGeometry *new_geometry,
7265                           guint       *new_flags)
7266 {
7267   GtkWindowPrivate *priv = window->priv;
7268   GtkWidget *widget;
7269   gint extra_width = 0;
7270   gint extra_height = 0;
7271   GtkWindowGeometryInfo *geometry_info;
7272   GtkRequisition requisition;
7273
7274   widget = GTK_WIDGET (window);
7275
7276   gtk_widget_get_preferred_size (widget, &requisition, NULL);
7277   geometry_info = gtk_window_get_geometry_info (GTK_WINDOW (widget), FALSE);
7278
7279   if (geometry_info)
7280     {
7281       *new_flags = geometry_info->mask;
7282       *new_geometry = geometry_info->geometry;
7283     }
7284   else
7285     {
7286       *new_flags = 0;
7287     }
7288
7289   if (geometry_info && geometry_info->widget)
7290     {
7291       /* If the geometry widget is set, then the hints really apply to that
7292        * widget. This is pretty much meaningless unless the window layout
7293        * is such that the rest of the window adds fixed size borders to
7294        * the geometry widget. Our job is to figure the size of the borders;
7295        * We do that by asking how big the toplevel would be if the
7296        * geometry widget was *really big*.
7297        *
7298        *  +----------+
7299        *  |AAAAAAAAA | At small sizes, the minimum sizes of widgets
7300        *  |GGGGG    B| in the border can confuse things
7301        *  |GGGGG    B|
7302        *  |         B|
7303        *  +----------+
7304        *
7305        *  +-----------+
7306        *  |AAAAAAAAA  | When the geometry widget is large, things are
7307        *  |GGGGGGGGGGB| clearer.
7308        *  |GGGGGGGGGGB|
7309        *  |GGGGGGGGGG |
7310        *  +-----------+
7311        */
7312 #define TEMPORARY_SIZE 10000 /* 10,000 pixels should be bigger than real widget sizes */
7313       GtkRequisition requisition;
7314       int current_width, current_height;
7315
7316       _gtk_widget_override_size_request (geometry_info->widget,
7317                                          TEMPORARY_SIZE, TEMPORARY_SIZE,
7318                                          &current_width, &current_height);
7319       gtk_widget_get_preferred_size (widget,
7320                                      &requisition, NULL);
7321       _gtk_widget_restore_size_request (geometry_info->widget,
7322                                         current_width, current_height);
7323
7324       extra_width = requisition.width - TEMPORARY_SIZE;
7325       extra_height = requisition.height - TEMPORARY_SIZE;
7326
7327       if (extra_width < 0 || extra_width < 0)
7328         {
7329           g_warning("Toplevel size doesn't seem to directly depend on the "
7330                     "size of the geometry widget from gtk_window_set_geometry_hints(). "
7331                     "The geometry widget might not be in the window, or it might not "
7332                     "be packed into the window appropriately");
7333           extra_width = MAX(extra_width, 0);
7334           extra_height = MAX(extra_height, 0);
7335         }
7336 #undef TEMPORARY_SIZE
7337     }
7338
7339   /* We don't want to set GDK_HINT_POS in here, we just set it
7340    * in gtk_window_move_resize() when we want the position
7341    * honored.
7342    */
7343
7344   if (*new_flags & GDK_HINT_BASE_SIZE)
7345     {
7346       new_geometry->base_width += extra_width;
7347       new_geometry->base_height += extra_height;
7348     }
7349   else
7350     {
7351       /* For simplicity, we always set the base hint, even when we
7352        * don't expect it to have any visible effect.
7353        * (Note: geometry_size_to_pixels() depends on this.)
7354        */
7355       *new_flags |= GDK_HINT_BASE_SIZE;
7356
7357       new_geometry->base_width = extra_width;
7358       new_geometry->base_height = extra_height;
7359
7360       /* As for X, if BASE_SIZE is not set but MIN_SIZE is set, then the
7361        * base size is the minimum size */
7362       if (*new_flags & GDK_HINT_MIN_SIZE)
7363         {
7364           if (new_geometry->min_width > 0)
7365             new_geometry->base_width += new_geometry->min_width;
7366           if (new_geometry->min_height > 0)
7367             new_geometry->base_height += new_geometry->min_height;
7368         }
7369     }
7370
7371   if (*new_flags & GDK_HINT_MIN_SIZE)
7372     {
7373       if (new_geometry->min_width < 0)
7374         new_geometry->min_width = requisition.width;
7375       else
7376         new_geometry->min_width = MAX (requisition.width, new_geometry->min_width + extra_width);
7377
7378       if (new_geometry->min_height < 0)
7379         new_geometry->min_height = requisition.height;
7380       else
7381         new_geometry->min_height = MAX (requisition.height, new_geometry->min_height + extra_height);
7382     }
7383   else
7384     {
7385       *new_flags |= GDK_HINT_MIN_SIZE;
7386
7387       new_geometry->min_width = requisition.width;
7388       new_geometry->min_height = requisition.height;
7389     }
7390
7391   if (*new_flags & GDK_HINT_MAX_SIZE)
7392     {
7393       if (new_geometry->max_width < 0)
7394         new_geometry->max_width = requisition.width;
7395       else
7396         new_geometry->max_width += extra_width;
7397
7398       if (new_geometry->max_height < 0)
7399         new_geometry->max_height = requisition.height;
7400       else
7401         new_geometry->max_height += extra_height;
7402     }
7403   else if (!priv->resizable)
7404     {
7405       *new_flags |= GDK_HINT_MAX_SIZE;
7406
7407       new_geometry->max_width = requisition.width;
7408       new_geometry->max_height = requisition.height;
7409     }
7410
7411   *new_flags |= GDK_HINT_WIN_GRAVITY;
7412   new_geometry->win_gravity = priv->gravity;
7413 }
7414
7415 /***********************
7416  * Redrawing functions *
7417  ***********************/
7418
7419 static gboolean
7420 gtk_window_draw (GtkWidget *widget,
7421                  cairo_t   *cr)
7422 {
7423   GtkWindowPrivate *priv = GTK_WINDOW (widget)->priv;
7424   GtkStyleContext *context;
7425   gboolean ret = FALSE;
7426
7427   context = gtk_widget_get_style_context (widget);
7428
7429   gtk_style_context_save (context);
7430
7431   if (!gtk_widget_get_app_paintable (widget))
7432     {
7433       GtkStateFlags state;
7434
7435       state = gtk_widget_get_state_flags (widget);
7436
7437       if (gtk_window_has_toplevel_focus (GTK_WINDOW (widget)))
7438         state |= GTK_STATE_FLAG_FOCUSED;
7439
7440       gtk_style_context_set_state (context, state);
7441       gtk_style_context_add_class (context, GTK_STYLE_CLASS_BACKGROUND);
7442       gtk_render_background (context, cr, 0, 0,
7443                              gtk_widget_get_allocated_width (widget),
7444                              gtk_widget_get_allocated_height (widget));
7445     }
7446
7447   gtk_style_context_restore (context);
7448
7449   if (GTK_WIDGET_CLASS (gtk_window_parent_class)->draw)
7450     ret = GTK_WIDGET_CLASS (gtk_window_parent_class)->draw (widget, cr);
7451
7452   if (priv->grip_window != NULL &&
7453       gtk_cairo_should_draw_window (cr, priv->grip_window))
7454     {
7455       GdkRectangle rect;
7456
7457       gtk_style_context_save (context);
7458       cairo_save (cr);
7459
7460       gtk_cairo_transform_to_window (cr, widget, priv->grip_window);
7461       gtk_window_get_resize_grip_area (GTK_WINDOW (widget), &rect);
7462
7463       gtk_style_context_add_class (context, GTK_STYLE_CLASS_GRIP);
7464       gtk_style_context_set_junction_sides (context, get_grip_junction (widget));
7465       gtk_render_handle (context, cr, 0, 0, rect.width, rect.height);
7466
7467       cairo_restore (cr);
7468       gtk_style_context_restore (context);
7469     }
7470
7471   return ret;
7472 }
7473
7474 /**
7475  * gtk_window_set_has_frame:
7476  * @window: a #GtkWindow
7477  * @setting: a boolean
7478  *
7479  * (Note: this is a special-purpose function for the framebuffer port,
7480  *  that causes GTK+ to draw its own window border. For most applications,
7481  *  you want gtk_window_set_decorated() instead, which tells the window
7482  *  manager whether to draw the window border.)
7483  *
7484  * If this function is called on a window with setting of %TRUE, before
7485  * it is realized or showed, it will have a "frame" window around
7486  * @window->window, accessible in @window->frame. Using the signal
7487  * frame_event you can receive all events targeted at the frame.
7488  *
7489  * This function is used by the linux-fb port to implement managed
7490  * windows, but it could conceivably be used by X-programs that
7491  * want to do their own window decorations.
7492  *
7493  **/
7494 void
7495 gtk_window_set_has_frame (GtkWindow *window,
7496                           gboolean   setting)
7497 {
7498   GtkWindowPrivate *priv;
7499
7500   g_return_if_fail (GTK_IS_WINDOW (window));
7501   g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
7502
7503   priv = window->priv;
7504
7505   priv->has_frame = setting != FALSE;
7506 }
7507
7508 /**
7509  * gtk_window_get_has_frame:
7510  * @window: a #GtkWindow
7511  *
7512  * Accessor for whether the window has a frame window exterior to
7513  * @window->window. Gets the value set by gtk_window_set_has_frame ().
7514  *
7515  * Return value: %TRUE if a frame has been added to the window
7516  *   via gtk_window_set_has_frame().
7517  **/
7518 gboolean
7519 gtk_window_get_has_frame (GtkWindow *window)
7520 {
7521   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
7522
7523   return window->priv->has_frame;
7524 }
7525
7526 /**
7527  * gtk_window_set_frame_dimensions:
7528  * @window: a #GtkWindow that has a frame
7529  * @left: The width of the left border
7530  * @top: The height of the top border
7531  * @right: The width of the right border
7532  * @bottom: The height of the bottom border
7533  *
7534  * (Note: this is a special-purpose function intended for the framebuffer
7535  *  port; see gtk_window_set_has_frame(). It will have no effect on the
7536  *  window border drawn by the window manager, which is the normal
7537  *  case when using the X Window system.)
7538  *
7539  * For windows with frames (see gtk_window_set_has_frame()) this function
7540  * can be used to change the size of the frame border.
7541  **/
7542 void
7543 gtk_window_set_frame_dimensions (GtkWindow *window,
7544                                  gint       left,
7545                                  gint       top,
7546                                  gint       right,
7547                                  gint       bottom)
7548 {
7549   GtkWindowPrivate *priv;
7550   GtkAllocation allocation;
7551   GtkWidget *widget;
7552
7553   g_return_if_fail (GTK_IS_WINDOW (window));
7554
7555   priv = window->priv;
7556   widget = GTK_WIDGET (window);
7557
7558   if (priv->frame_left == left &&
7559       priv->frame_top == top &&
7560       priv->frame_right == right &&
7561       priv->frame_bottom == bottom)
7562     return;
7563
7564   priv->frame_left = left;
7565   priv->frame_top = top;
7566   priv->frame_right = right;
7567   priv->frame_bottom = bottom;
7568
7569   if (gtk_widget_get_realized (widget) && priv->frame)
7570     {
7571           gint width, height;
7572           gtk_widget_get_allocation (widget, &allocation);
7573
7574       width = allocation.width + left + right;
7575       height = allocation.height + top + bottom;
7576       gdk_window_resize (priv->frame, width, height);
7577       gdk_window_move_resize (gtk_widget_get_window (GTK_WIDGET (window)),
7578                               left, top,
7579                               allocation.width,
7580                               allocation.height);
7581     }
7582 }
7583
7584 /**
7585  * gtk_window_present:
7586  * @window: a #GtkWindow
7587  *
7588  * Presents a window to the user. This may mean raising the window
7589  * in the stacking order, deiconifying it, moving it to the current
7590  * desktop, and/or giving it the keyboard focus, possibly dependent
7591  * on the user's platform, window manager, and preferences.
7592  *
7593  * If @window is hidden, this function calls gtk_widget_show()
7594  * as well.
7595  *
7596  * This function should be used when the user tries to open a window
7597  * that's already open. Say for example the preferences dialog is
7598  * currently open, and the user chooses Preferences from the menu
7599  * a second time; use gtk_window_present() to move the already-open dialog
7600  * where the user can see it.
7601  *
7602  * If you are calling this function in response to a user interaction,
7603  * it is preferable to use gtk_window_present_with_time().
7604  *
7605  **/
7606 void
7607 gtk_window_present (GtkWindow *window)
7608 {
7609   gtk_window_present_with_time (window, GDK_CURRENT_TIME);
7610 }
7611
7612 /**
7613  * gtk_window_present_with_time:
7614  * @window: a #GtkWindow
7615  * @timestamp: the timestamp of the user interaction (typically a
7616  *   button or key press event) which triggered this call
7617  *
7618  * Presents a window to the user in response to a user interaction.
7619  * If you need to present a window without a timestamp, use
7620  * gtk_window_present(). See gtk_window_present() for details.
7621  *
7622  * Since: 2.8
7623  **/
7624 void
7625 gtk_window_present_with_time (GtkWindow *window,
7626                               guint32    timestamp)
7627 {
7628   GtkWidget *widget;
7629   GdkWindow *gdk_window;
7630
7631   g_return_if_fail (GTK_IS_WINDOW (window));
7632
7633   widget = GTK_WIDGET (window);
7634
7635   if (gtk_widget_get_visible (widget))
7636     {
7637       gdk_window = gtk_widget_get_window (widget);
7638
7639       g_assert (gdk_window != NULL);
7640
7641       gdk_window_show (gdk_window);
7642
7643       /* Translate a timestamp of GDK_CURRENT_TIME appropriately */
7644       if (timestamp == GDK_CURRENT_TIME)
7645         {
7646 #ifdef GDK_WINDOWING_X11
7647           GdkDisplay *display;
7648
7649           display = gtk_widget_get_display (GTK_WIDGET (window));
7650           timestamp = gdk_x11_display_get_user_time (display);
7651 #else
7652           timestamp = gtk_get_current_event_time ();
7653 #endif
7654         }
7655
7656       gdk_window_focus (gdk_window, timestamp);
7657     }
7658   else
7659     {
7660       gtk_widget_show (widget);
7661     }
7662 }
7663
7664 /**
7665  * gtk_window_iconify:
7666  * @window: a #GtkWindow
7667  *
7668  * Asks to iconify (i.e. minimize) the specified @window. Note that
7669  * you shouldn't assume the window is definitely iconified afterward,
7670  * because other entities (e.g. the user or <link
7671  * linkend="gtk-X11-arch">window manager</link>) could deiconify it
7672  * again, or there may not be a window manager in which case
7673  * iconification isn't possible, etc. But normally the window will end
7674  * up iconified. Just don't write code that crashes if not.
7675  *
7676  * It's permitted to call this function before showing a window,
7677  * in which case the window will be iconified before it ever appears
7678  * onscreen.
7679  *
7680  * You can track iconification via the "window-state-event" signal
7681  * on #GtkWidget.
7682  *
7683  **/
7684 void
7685 gtk_window_iconify (GtkWindow *window)
7686 {
7687   GtkWindowPrivate *priv;
7688   GtkWidget *widget;
7689   GdkWindow *toplevel;
7690
7691   g_return_if_fail (GTK_IS_WINDOW (window));
7692
7693   priv = window->priv;
7694   widget = GTK_WIDGET (window);
7695
7696   priv->iconify_initially = TRUE;
7697
7698   if (priv->frame)
7699     toplevel = priv->frame;
7700   else
7701     toplevel = gtk_widget_get_window (widget);
7702
7703   if (toplevel != NULL)
7704     gdk_window_iconify (toplevel);
7705 }
7706
7707 /**
7708  * gtk_window_deiconify:
7709  * @window: a #GtkWindow
7710  *
7711  * Asks to deiconify (i.e. unminimize) the specified @window. Note
7712  * that you shouldn't assume the window is definitely deiconified
7713  * afterward, because other entities (e.g. the user or <link
7714  * linkend="gtk-X11-arch">window manager</link>) could iconify it
7715  * again before your code which assumes deiconification gets to run.
7716  *
7717  * You can track iconification via the "window-state-event" signal
7718  * on #GtkWidget.
7719  **/
7720 void
7721 gtk_window_deiconify (GtkWindow *window)
7722 {
7723   GtkWindowPrivate *priv;
7724   GtkWidget *widget;
7725   GdkWindow *toplevel;
7726
7727   g_return_if_fail (GTK_IS_WINDOW (window));
7728
7729   priv = window->priv;
7730   widget = GTK_WIDGET (window);
7731
7732   priv->iconify_initially = FALSE;
7733
7734   if (priv->frame)
7735     toplevel = priv->frame;
7736   else
7737     toplevel = gtk_widget_get_window (widget);
7738
7739   if (toplevel != NULL)
7740     gdk_window_deiconify (toplevel);
7741 }
7742
7743 /**
7744  * gtk_window_stick:
7745  * @window: a #GtkWindow
7746  *
7747  * Asks to stick @window, which means that it will appear on all user
7748  * desktops. Note that you shouldn't assume the window is definitely
7749  * stuck afterward, because other entities (e.g. the user or <link
7750  * linkend="gtk-X11-arch">window manager</link>) could unstick it
7751  * again, and some window managers do not support sticking
7752  * windows. But normally the window will end up stuck. Just don't
7753  * write code that crashes if not.
7754  *
7755  * It's permitted to call this function before showing a window.
7756  *
7757  * You can track stickiness via the "window-state-event" signal
7758  * on #GtkWidget.
7759  *
7760  **/
7761 void
7762 gtk_window_stick (GtkWindow *window)
7763 {
7764   GtkWindowPrivate *priv;
7765   GtkWidget *widget;
7766   GdkWindow *toplevel;
7767
7768   g_return_if_fail (GTK_IS_WINDOW (window));
7769
7770   priv = window->priv;
7771   widget = GTK_WIDGET (window);
7772
7773   priv->stick_initially = TRUE;
7774
7775   if (priv->frame)
7776     toplevel = priv->frame;
7777   else
7778     toplevel = gtk_widget_get_window (widget);
7779
7780   if (toplevel != NULL)
7781     gdk_window_stick (toplevel);
7782 }
7783
7784 /**
7785  * gtk_window_unstick:
7786  * @window: a #GtkWindow
7787  *
7788  * Asks to unstick @window, which means that it will appear on only
7789  * one of the user's desktops. Note that you shouldn't assume the
7790  * window is definitely unstuck afterward, because other entities
7791  * (e.g. the user or <link linkend="gtk-X11-arch">window
7792  * manager</link>) could stick it again. But normally the window will
7793  * end up stuck. Just don't write code that crashes if not.
7794  *
7795  * You can track stickiness via the "window-state-event" signal
7796  * on #GtkWidget.
7797  *
7798  **/
7799 void
7800 gtk_window_unstick (GtkWindow *window)
7801 {
7802   GtkWindowPrivate *priv;
7803   GtkWidget *widget;
7804   GdkWindow *toplevel;
7805
7806   g_return_if_fail (GTK_IS_WINDOW (window));
7807
7808   priv = window->priv;
7809   widget = GTK_WIDGET (window);
7810
7811   priv->stick_initially = FALSE;
7812
7813   if (priv->frame)
7814     toplevel = priv->frame;
7815   else
7816     toplevel = gtk_widget_get_window (widget);
7817
7818   if (toplevel != NULL)
7819     gdk_window_unstick (toplevel);
7820 }
7821
7822 /**
7823  * gtk_window_maximize:
7824  * @window: a #GtkWindow
7825  *
7826  * Asks to maximize @window, so that it becomes full-screen. Note that
7827  * you shouldn't assume the window is definitely maximized afterward,
7828  * because other entities (e.g. the user or <link
7829  * linkend="gtk-X11-arch">window manager</link>) could unmaximize it
7830  * again, and not all window managers support maximization. But
7831  * normally the window will end up maximized. Just don't write code
7832  * that crashes if not.
7833  *
7834  * It's permitted to call this function before showing a window,
7835  * in which case the window will be maximized when it appears onscreen
7836  * initially.
7837  *
7838  * You can track maximization via the "window-state-event" signal
7839  * on #GtkWidget.
7840  *
7841  **/
7842 void
7843 gtk_window_maximize (GtkWindow *window)
7844 {
7845   GtkWindowPrivate *priv;
7846   GtkWidget *widget;
7847   GdkWindow *toplevel;
7848
7849   g_return_if_fail (GTK_IS_WINDOW (window));
7850
7851   priv = window->priv;
7852   widget = GTK_WIDGET (window);
7853
7854   priv->maximize_initially = TRUE;
7855
7856   if (priv->frame)
7857     toplevel = priv->frame;
7858   else
7859     toplevel = gtk_widget_get_window (widget);
7860
7861   if (toplevel != NULL)
7862     gdk_window_maximize (toplevel);
7863 }
7864
7865 /**
7866  * gtk_window_unmaximize:
7867  * @window: a #GtkWindow
7868  *
7869  * Asks to unmaximize @window. Note that you shouldn't assume the
7870  * window is definitely unmaximized afterward, because other entities
7871  * (e.g. the user or <link linkend="gtk-X11-arch">window
7872  * manager</link>) could maximize it again, and not all window
7873  * managers honor requests to unmaximize. But normally the window will
7874  * end up unmaximized. Just don't write code that crashes if not.
7875  *
7876  * You can track maximization via the "window-state-event" signal
7877  * on #GtkWidget.
7878  *
7879  **/
7880 void
7881 gtk_window_unmaximize (GtkWindow *window)
7882 {
7883   GtkWindowPrivate *priv;
7884   GtkWidget *widget;
7885   GdkWindow *toplevel;
7886
7887   g_return_if_fail (GTK_IS_WINDOW (window));
7888
7889   priv = window->priv;
7890   widget = GTK_WIDGET (window);
7891
7892   priv->maximize_initially = FALSE;
7893
7894   if (priv->frame)
7895     toplevel = priv->frame;
7896   else
7897     toplevel = gtk_widget_get_window (widget);
7898
7899   if (toplevel != NULL)
7900     gdk_window_unmaximize (toplevel);
7901 }
7902
7903 /**
7904  * gtk_window_fullscreen:
7905  * @window: a #GtkWindow
7906  *
7907  * Asks to place @window in the fullscreen state. Note that you
7908  * shouldn't assume the window is definitely full screen afterward,
7909  * because other entities (e.g. the user or <link
7910  * linkend="gtk-X11-arch">window manager</link>) could unfullscreen it
7911  * again, and not all window managers honor requests to fullscreen
7912  * windows. But normally the window will end up fullscreen. Just
7913  * don't write code that crashes if not.
7914  *
7915  * You can track the fullscreen state via the "window-state-event" signal
7916  * on #GtkWidget.
7917  *
7918  * Since: 2.2
7919  **/
7920 void
7921 gtk_window_fullscreen (GtkWindow *window)
7922 {
7923   GtkWindowPrivate *priv;
7924   GtkWidget *widget;
7925   GdkWindow *toplevel;
7926
7927   g_return_if_fail (GTK_IS_WINDOW (window));
7928
7929   priv = window->priv;
7930   widget = GTK_WIDGET (window);
7931
7932   priv->fullscreen_initially = TRUE;
7933
7934   if (priv->frame)
7935     toplevel = priv->frame;
7936   else
7937     toplevel = gtk_widget_get_window (widget);
7938
7939   if (toplevel != NULL)
7940     gdk_window_fullscreen (toplevel);
7941 }
7942
7943 /**
7944  * gtk_window_unfullscreen:
7945  * @window: a #GtkWindow
7946  *
7947  * Asks to toggle off the fullscreen state for @window. Note that you
7948  * shouldn't assume the window is definitely not full screen
7949  * afterward, because other entities (e.g. the user or <link
7950  * linkend="gtk-X11-arch">window manager</link>) could fullscreen it
7951  * again, and not all window managers honor requests to unfullscreen
7952  * windows. But normally the window will end up restored to its normal
7953  * state. Just don't write code that crashes if not.
7954  *
7955  * You can track the fullscreen state via the "window-state-event" signal
7956  * on #GtkWidget.
7957  *
7958  * Since: 2.2
7959  **/
7960 void
7961 gtk_window_unfullscreen (GtkWindow *window)
7962 {
7963   GtkWidget *widget;
7964   GdkWindow *toplevel;
7965   GtkWindowPrivate *priv;
7966
7967   g_return_if_fail (GTK_IS_WINDOW (window));
7968
7969   priv = window->priv;
7970   widget = GTK_WIDGET (window);
7971
7972   priv->fullscreen_initially = FALSE;
7973
7974   if (priv->frame)
7975     toplevel = priv->frame;
7976   else
7977     toplevel = gtk_widget_get_window (widget);
7978
7979   if (toplevel != NULL)
7980     gdk_window_unfullscreen (toplevel);
7981 }
7982
7983 /**
7984  * gtk_window_set_keep_above:
7985  * @window: a #GtkWindow
7986  * @setting: whether to keep @window above other windows
7987  *
7988  * Asks to keep @window above, so that it stays on top. Note that
7989  * you shouldn't assume the window is definitely above afterward,
7990  * because other entities (e.g. the user or <link
7991  * linkend="gtk-X11-arch">window manager</link>) could not keep it above,
7992  * and not all window managers support keeping windows above. But
7993  * normally the window will end kept above. Just don't write code
7994  * that crashes if not.
7995  *
7996  * It's permitted to call this function before showing a window,
7997  * in which case the window will be kept above when it appears onscreen
7998  * initially.
7999  *
8000  * You can track the above state via the "window-state-event" signal
8001  * on #GtkWidget.
8002  *
8003  * Note that, according to the <ulink
8004  * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window
8005  * Manager Hints</ulink> specification, the above state is mainly meant
8006  * for user preferences and should not be used by applications e.g. for
8007  * drawing attention to their dialogs.
8008  *
8009  * Since: 2.4
8010  **/
8011 void
8012 gtk_window_set_keep_above (GtkWindow *window,
8013                            gboolean   setting)
8014 {
8015   GtkWidget *widget;
8016   GtkWindowPrivate *priv;
8017   GdkWindow *toplevel;
8018
8019   g_return_if_fail (GTK_IS_WINDOW (window));
8020
8021   priv = window->priv;
8022   widget = GTK_WIDGET (window);
8023
8024   priv->above_initially = setting != FALSE;
8025   if (setting)
8026     priv->below_initially = FALSE;
8027
8028   if (priv->frame)
8029     toplevel = priv->frame;
8030   else
8031     toplevel = gtk_widget_get_window (widget);
8032
8033   if (toplevel != NULL)
8034     gdk_window_set_keep_above (toplevel, setting);
8035 }
8036
8037 /**
8038  * gtk_window_set_keep_below:
8039  * @window: a #GtkWindow
8040  * @setting: whether to keep @window below other windows
8041  *
8042  * Asks to keep @window below, so that it stays in bottom. Note that
8043  * you shouldn't assume the window is definitely below afterward,
8044  * because other entities (e.g. the user or <link
8045  * linkend="gtk-X11-arch">window manager</link>) could not keep it below,
8046  * and not all window managers support putting windows below. But
8047  * normally the window will be kept below. Just don't write code
8048  * that crashes if not.
8049  *
8050  * It's permitted to call this function before showing a window,
8051  * in which case the window will be kept below when it appears onscreen
8052  * initially.
8053  *
8054  * You can track the below state via the "window-state-event" signal
8055  * on #GtkWidget.
8056  *
8057  * Note that, according to the <ulink
8058  * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window
8059  * Manager Hints</ulink> specification, the above state is mainly meant
8060  * for user preferences and should not be used by applications e.g. for
8061  * drawing attention to their dialogs.
8062  *
8063  * Since: 2.4
8064  **/
8065 void
8066 gtk_window_set_keep_below (GtkWindow *window,
8067                            gboolean   setting)
8068 {
8069   GtkWidget *widget;
8070   GtkWindowPrivate *priv;
8071   GdkWindow *toplevel;
8072
8073   g_return_if_fail (GTK_IS_WINDOW (window));
8074
8075   priv = window->priv;
8076   widget = GTK_WIDGET (window);
8077
8078   priv->below_initially = setting != FALSE;
8079   if (setting)
8080     priv->above_initially = FALSE;
8081
8082   if (priv->frame)
8083     toplevel = priv->frame;
8084   else
8085     toplevel = gtk_widget_get_window (widget);
8086
8087   if (toplevel != NULL)
8088     gdk_window_set_keep_below (toplevel, setting);
8089 }
8090
8091 /**
8092  * gtk_window_set_resizable:
8093  * @window: a #GtkWindow
8094  * @resizable: %TRUE if the user can resize this window
8095  *
8096  * Sets whether the user can resize a window. Windows are user resizable
8097  * by default.
8098  **/
8099 void
8100 gtk_window_set_resizable (GtkWindow *window,
8101                           gboolean   resizable)
8102 {
8103   GtkWindowPrivate *priv;
8104
8105   g_return_if_fail (GTK_IS_WINDOW (window));
8106
8107   priv = window->priv;
8108
8109   resizable = (resizable != FALSE);
8110
8111   if (priv->resizable != resizable)
8112     {
8113       priv->resizable = (resizable != FALSE);
8114
8115       update_grip_visibility (window);
8116
8117       gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
8118
8119       g_object_notify (G_OBJECT (window), "resizable");
8120     }
8121 }
8122
8123 /**
8124  * gtk_window_get_resizable:
8125  * @window: a #GtkWindow
8126  *
8127  * Gets the value set by gtk_window_set_resizable().
8128  *
8129  * Return value: %TRUE if the user can resize the window
8130  **/
8131 gboolean
8132 gtk_window_get_resizable (GtkWindow *window)
8133 {
8134   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
8135
8136   return window->priv->resizable;
8137 }
8138
8139 /**
8140  * gtk_window_set_gravity:
8141  * @window: a #GtkWindow
8142  * @gravity: window gravity
8143  *
8144  * Window gravity defines the meaning of coordinates passed to
8145  * gtk_window_move(). See gtk_window_move() and #GdkGravity for
8146  * more details.
8147  *
8148  * The default window gravity is #GDK_GRAVITY_NORTH_WEST which will
8149  * typically "do what you mean."
8150  *
8151  **/
8152 void
8153 gtk_window_set_gravity (GtkWindow *window,
8154                         GdkGravity gravity)
8155 {
8156   GtkWindowPrivate *priv;
8157
8158   g_return_if_fail (GTK_IS_WINDOW (window));
8159
8160   priv = window->priv;
8161
8162   if (gravity != priv->gravity)
8163     {
8164       priv->gravity = gravity;
8165
8166       /* gtk_window_move_resize() will adapt gravity
8167        */
8168       gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
8169
8170       g_object_notify (G_OBJECT (window), "gravity");
8171     }
8172 }
8173
8174 /**
8175  * gtk_window_get_gravity:
8176  * @window: a #GtkWindow
8177  *
8178  * Gets the value set by gtk_window_set_gravity().
8179  *
8180  * Return value: (transfer none): window gravity
8181  **/
8182 GdkGravity
8183 gtk_window_get_gravity (GtkWindow *window)
8184 {
8185   g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
8186
8187   return window->priv->gravity;
8188 }
8189
8190 /**
8191  * gtk_window_begin_resize_drag:
8192  * @window: a #GtkWindow
8193  * @button: mouse button that initiated the drag
8194  * @edge: position of the resize control
8195  * @root_x: X position where the user clicked to initiate the drag, in root window coordinates
8196  * @root_y: Y position where the user clicked to initiate the drag
8197  * @timestamp: timestamp from the click event that initiated the drag
8198  *
8199  * Starts resizing a window. This function is used if an application
8200  * has window resizing controls. When GDK can support it, the resize
8201  * will be done using the standard mechanism for the <link
8202  * linkend="gtk-X11-arch">window manager</link> or windowing
8203  * system. Otherwise, GDK will try to emulate window resizing,
8204  * potentially not all that well, depending on the windowing system.
8205  *
8206  **/
8207 void
8208 gtk_window_begin_resize_drag  (GtkWindow    *window,
8209                                GdkWindowEdge edge,
8210                                gint          button,
8211                                gint          root_x,
8212                                gint          root_y,
8213                                guint32       timestamp)
8214 {
8215   GtkWindowPrivate *priv;
8216   GtkWidget *widget;
8217   GdkWindow *toplevel;
8218
8219   g_return_if_fail (GTK_IS_WINDOW (window));
8220   widget = GTK_WIDGET (window);
8221   g_return_if_fail (gtk_widget_get_visible (widget));
8222
8223   priv = window->priv;
8224
8225   if (priv->frame)
8226     toplevel = priv->frame;
8227   else
8228     toplevel = gtk_widget_get_window (widget);
8229
8230   gdk_window_begin_resize_drag (toplevel,
8231                                 edge, button,
8232                                 root_x, root_y,
8233                                 timestamp);
8234 }
8235
8236 /**
8237  * gtk_window_get_frame_dimensions:
8238  * @window: a #GtkWindow
8239  * @left: (out) (allow-none): location to store the width of the frame at the left, or %NULL
8240  * @top: (out) (allow-none): location to store the height of the frame at the top, or %NULL
8241  * @right: (out) (allow-none): location to store the width of the frame at the returns, or %NULL
8242  * @bottom: (out) (allow-none): location to store the height of the frame at the bottom, or %NULL
8243  *
8244  * (Note: this is a special-purpose function intended for the
8245  *  framebuffer port; see gtk_window_set_has_frame(). It will not
8246  *  return the size of the window border drawn by the <link
8247  *  linkend="gtk-X11-arch">window manager</link>, which is the normal
8248  *  case when using a windowing system.  See
8249  *  gdk_window_get_frame_extents() to get the standard window border
8250  *  extents.)
8251  *
8252  * Retrieves the dimensions of the frame window for this toplevel.
8253  * See gtk_window_set_has_frame(), gtk_window_set_frame_dimensions().
8254  **/
8255 void
8256 gtk_window_get_frame_dimensions (GtkWindow *window,
8257                                  gint      *left,
8258                                  gint      *top,
8259                                  gint      *right,
8260                                  gint      *bottom)
8261 {
8262   GtkWindowPrivate *priv;
8263
8264   g_return_if_fail (GTK_IS_WINDOW (window));
8265
8266   priv = window->priv;
8267
8268   if (left)
8269     *left = priv->frame_left;
8270   if (top)
8271     *top = priv->frame_top;
8272   if (right)
8273     *right = priv->frame_right;
8274   if (bottom)
8275     *bottom = priv->frame_bottom;
8276 }
8277
8278 /**
8279  * gtk_window_begin_move_drag:
8280  * @window: a #GtkWindow
8281  * @button: mouse button that initiated the drag
8282  * @root_x: X position where the user clicked to initiate the drag, in root window coordinates
8283  * @root_y: Y position where the user clicked to initiate the drag
8284  * @timestamp: timestamp from the click event that initiated the drag
8285  *
8286  * Starts moving a window. This function is used if an application has
8287  * window movement grips. When GDK can support it, the window movement
8288  * will be done using the standard mechanism for the <link
8289  * linkend="gtk-X11-arch">window manager</link> or windowing
8290  * system. Otherwise, GDK will try to emulate window movement,
8291  * potentially not all that well, depending on the windowing system.
8292  *
8293  **/
8294 void
8295 gtk_window_begin_move_drag  (GtkWindow *window,
8296                              gint       button,
8297                              gint       root_x,
8298                              gint       root_y,
8299                              guint32    timestamp)
8300 {
8301   GtkWindowPrivate *priv;
8302   GtkWidget *widget;
8303   GdkWindow *toplevel;
8304
8305   g_return_if_fail (GTK_IS_WINDOW (window));
8306   widget = GTK_WIDGET (window);
8307   g_return_if_fail (gtk_widget_get_visible (widget));
8308
8309   priv = window->priv;
8310
8311   if (priv->frame)
8312     toplevel = priv->frame;
8313   else
8314     toplevel = gtk_widget_get_window (widget);
8315
8316   gdk_window_begin_move_drag (toplevel,
8317                               button,
8318                               root_x, root_y,
8319                               timestamp);
8320 }
8321
8322 /**
8323  * gtk_window_set_screen:
8324  * @window: a #GtkWindow.
8325  * @screen: a #GdkScreen.
8326  *
8327  * Sets the #GdkScreen where the @window is displayed; if
8328  * the window is already mapped, it will be unmapped, and
8329  * then remapped on the new screen.
8330  *
8331  * Since: 2.2
8332  */
8333 void
8334 gtk_window_set_screen (GtkWindow *window,
8335                        GdkScreen *screen)
8336 {
8337   GtkWindowPrivate *priv;
8338   GtkWidget *widget;
8339   GdkScreen *previous_screen;
8340   gboolean was_mapped;
8341
8342   g_return_if_fail (GTK_IS_WINDOW (window));
8343   g_return_if_fail (GDK_IS_SCREEN (screen));
8344
8345   priv = window->priv;
8346
8347   if (screen == priv->screen)
8348     return;
8349
8350   widget = GTK_WIDGET (window);
8351
8352   previous_screen = priv->screen;
8353   was_mapped = gtk_widget_get_mapped (widget);
8354
8355   if (was_mapped)
8356     gtk_widget_unmap (widget);
8357   if (gtk_widget_get_realized (widget))
8358     gtk_widget_unrealize (widget);
8359
8360   gtk_window_free_key_hash (window);
8361   priv->screen = screen;
8362   gtk_widget_reset_rc_styles (widget);
8363   if (screen != previous_screen)
8364     {
8365       g_signal_handlers_disconnect_by_func (previous_screen,
8366                                             gtk_window_on_composited_changed, window);
8367       g_signal_connect (screen, "composited-changed",
8368                         G_CALLBACK (gtk_window_on_composited_changed), window);
8369
8370       _gtk_widget_propagate_screen_changed (widget, previous_screen);
8371       _gtk_widget_propagate_composited_changed (widget);
8372     }
8373   g_object_notify (G_OBJECT (window), "screen");
8374
8375   if (was_mapped)
8376     gtk_widget_map (widget);
8377 }
8378
8379 static void
8380 gtk_window_on_composited_changed (GdkScreen *screen,
8381                                   GtkWindow *window)
8382 {
8383   gtk_widget_queue_draw (GTK_WIDGET (window));
8384
8385   _gtk_widget_propagate_composited_changed (GTK_WIDGET (window));
8386 }
8387
8388 static GdkScreen *
8389 gtk_window_check_screen (GtkWindow *window)
8390 {
8391   GtkWindowPrivate *priv = window->priv;
8392
8393   if (priv->screen)
8394     return priv->screen;
8395   else
8396     {
8397       g_warning ("Screen for GtkWindow not set; you must always set\n"
8398                  "a screen for a GtkWindow before using the window");
8399       return NULL;
8400     }
8401 }
8402
8403 /**
8404  * gtk_window_get_screen:
8405  * @window: a #GtkWindow.
8406  *
8407  * Returns the #GdkScreen associated with @window.
8408  *
8409  * Return value: (transfer none): a #GdkScreen.
8410  *
8411  * Since: 2.2
8412  */
8413 GdkScreen*
8414 gtk_window_get_screen (GtkWindow *window)
8415 {
8416   g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
8417
8418   return window->priv->screen;
8419 }
8420
8421 /**
8422  * gtk_window_is_active:
8423  * @window: a #GtkWindow
8424  *
8425  * Returns whether the window is part of the current active toplevel.
8426  * (That is, the toplevel window receiving keystrokes.)
8427  * The return value is %TRUE if the window is active toplevel
8428  * itself, but also if it is, say, a #GtkPlug embedded in the active toplevel.
8429  * You might use this function if you wanted to draw a widget
8430  * differently in an active window from a widget in an inactive window.
8431  * See gtk_window_has_toplevel_focus()
8432  *
8433  * Return value: %TRUE if the window part of the current active window.
8434  *
8435  * Since: 2.4
8436  **/
8437 gboolean
8438 gtk_window_is_active (GtkWindow *window)
8439 {
8440   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
8441
8442   return window->priv->is_active;
8443 }
8444
8445 /**
8446  * gtk_window_has_toplevel_focus:
8447  * @window: a #GtkWindow
8448  *
8449  * Returns whether the input focus is within this GtkWindow.
8450  * For real toplevel windows, this is identical to gtk_window_is_active(),
8451  * but for embedded windows, like #GtkPlug, the results will differ.
8452  *
8453  * Return value: %TRUE if the input focus is within this GtkWindow
8454  *
8455  * Since: 2.4
8456  **/
8457 gboolean
8458 gtk_window_has_toplevel_focus (GtkWindow *window)
8459 {
8460   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
8461
8462   return window->priv->has_toplevel_focus;
8463 }
8464
8465 G_DEFINE_TYPE (GtkWindowGroup, gtk_window_group, G_TYPE_OBJECT)
8466
8467 static void
8468 gtk_window_group_init (GtkWindowGroup *group)
8469 {
8470   group->priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
8471                                              GTK_TYPE_WINDOW_GROUP,
8472                                              GtkWindowGroupPrivate);
8473 }
8474
8475 static void
8476 gtk_window_group_class_init (GtkWindowGroupClass *klass)
8477 {
8478   g_type_class_add_private (klass, sizeof (GtkWindowGroupPrivate));
8479 }
8480
8481 /**
8482  * gtk_window_group_new:
8483  *
8484  * Creates a new #GtkWindowGroup object. Grabs added with
8485  * gtk_grab_add() only affect windows within the same #GtkWindowGroup.
8486  *
8487  * Return value: a new #GtkWindowGroup.
8488  **/
8489 GtkWindowGroup *
8490 gtk_window_group_new (void)
8491 {
8492   return g_object_new (GTK_TYPE_WINDOW_GROUP, NULL);
8493 }
8494
8495 static void
8496 window_group_cleanup_grabs (GtkWindowGroup *group,
8497                             GtkWindow      *window)
8498 {
8499   GtkWindowGroupPrivate *priv;
8500   GtkDeviceGrabInfo *info;
8501   GSList *tmp_list;
8502   GSList *to_remove = NULL;
8503
8504   priv = group->priv;
8505
8506   tmp_list = priv->grabs;
8507   while (tmp_list)
8508     {
8509       if (gtk_widget_get_toplevel (tmp_list->data) == (GtkWidget*) window)
8510         to_remove = g_slist_prepend (to_remove, g_object_ref (tmp_list->data));
8511       tmp_list = tmp_list->next;
8512     }
8513
8514   while (to_remove)
8515     {
8516       gtk_grab_remove (to_remove->data);
8517       g_object_unref (to_remove->data);
8518       to_remove = g_slist_delete_link (to_remove, to_remove);
8519     }
8520
8521   tmp_list = priv->device_grabs;
8522
8523   while (tmp_list)
8524     {
8525       info = tmp_list->data;
8526
8527       if (gtk_widget_get_toplevel (info->widget) == (GtkWidget *) window)
8528         to_remove = g_slist_prepend (to_remove, info);
8529
8530       tmp_list = tmp_list->next;
8531     }
8532
8533   while (to_remove)
8534     {
8535       info = to_remove->data;
8536
8537       gtk_device_grab_remove (info->widget, info->device);
8538       to_remove = g_slist_delete_link (to_remove, to_remove);
8539     }
8540 }
8541
8542 /**
8543  * gtk_window_group_add_window:
8544  * @window_group: a #GtkWindowGroup
8545  * @window: the #GtkWindow to add
8546  *
8547  * Adds a window to a #GtkWindowGroup.
8548  **/
8549 void
8550 gtk_window_group_add_window (GtkWindowGroup *window_group,
8551                              GtkWindow      *window)
8552 {
8553   GtkWindowPrivate *priv;
8554
8555   g_return_if_fail (GTK_IS_WINDOW_GROUP (window_group));
8556   g_return_if_fail (GTK_IS_WINDOW (window));
8557
8558   priv = window->priv;
8559
8560   if (priv->group != window_group)
8561     {
8562       g_object_ref (window);
8563       g_object_ref (window_group);
8564
8565       if (priv->group)
8566         gtk_window_group_remove_window (priv->group, window);
8567       else
8568         window_group_cleanup_grabs (gtk_window_get_group (NULL), window);
8569
8570       priv->group = window_group;
8571
8572       g_object_unref (window);
8573     }
8574 }
8575
8576 /**
8577  * gtk_window_group_remove_window:
8578  * @window_group: a #GtkWindowGroup
8579  * @window: the #GtkWindow to remove
8580  *
8581  * Removes a window from a #GtkWindowGroup.
8582  **/
8583 void
8584 gtk_window_group_remove_window (GtkWindowGroup *window_group,
8585                                 GtkWindow      *window)
8586 {
8587   GtkWindowPrivate *priv;
8588
8589   g_return_if_fail (GTK_IS_WINDOW_GROUP (window_group));
8590   g_return_if_fail (GTK_IS_WINDOW (window));
8591   priv = window->priv;
8592   g_return_if_fail (priv->group == window_group);
8593
8594   g_object_ref (window);
8595
8596   window_group_cleanup_grabs (window_group, window);
8597   priv->group = NULL;
8598
8599   g_object_unref (window_group);
8600   g_object_unref (window);
8601 }
8602
8603 /**
8604  * gtk_window_group_list_windows:
8605  * @window_group: a #GtkWindowGroup
8606  *
8607  * Returns a list of the #GtkWindows that belong to @window_group.
8608  *
8609  * Returns: (element-type GtkWidget) (transfer container): A newly-allocated list of
8610  *   windows inside the group.
8611  *
8612  * Since: 2.14
8613  **/
8614 GList *
8615 gtk_window_group_list_windows (GtkWindowGroup *window_group)
8616 {
8617   GList *toplevels, *toplevel, *group_windows;
8618
8619   g_return_val_if_fail (GTK_IS_WINDOW_GROUP (window_group), NULL);
8620
8621   group_windows = NULL;
8622   toplevels = gtk_window_list_toplevels ();
8623
8624   for (toplevel = toplevels; toplevel; toplevel = toplevel->next)
8625     {
8626       GtkWindow *window = toplevel->data;
8627
8628       if (window_group == window->priv->group)
8629         group_windows = g_list_prepend (group_windows, window);
8630     }
8631
8632   return g_list_reverse (group_windows);
8633 }
8634
8635 /**
8636  * gtk_window_get_group:
8637  * @window: (allow-none): a #GtkWindow, or %NULL
8638  *
8639  * Returns the group for @window or the default group, if
8640  * @window is %NULL or if @window does not have an explicit
8641  * window group.
8642  *
8643  * Returns: (transfer none): the #GtkWindowGroup for a window or the default group
8644  *
8645  * Since: 2.10
8646  */
8647 GtkWindowGroup *
8648 gtk_window_get_group (GtkWindow *window)
8649 {
8650   if (window && window->priv->group)
8651     return window->priv->group;
8652   else
8653     {
8654       static GtkWindowGroup *default_group = NULL;
8655
8656       if (!default_group)
8657         default_group = gtk_window_group_new ();
8658
8659       return default_group;
8660     }
8661 }
8662
8663 /**
8664  * gtk_window_has_group:
8665  * @window: a #GtkWindow
8666  *
8667  * Returns whether @window has an explicit window group.
8668  *
8669  * Return value: %TRUE if @window has an explicit window group.
8670  *
8671  * Since 2.22
8672  **/
8673 gboolean
8674 gtk_window_has_group (GtkWindow *window)
8675 {
8676   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
8677
8678   return window->priv->group != NULL;
8679 }
8680
8681 /**
8682  * gtk_window_group_get_current_grab:
8683  * @window_group: a #GtkWindowGroup
8684  *
8685  * Gets the current grab widget of the given group,
8686  * see gtk_grab_add().
8687  *
8688  * Returns: the current grab widget of the group
8689  *
8690  * Since: 2.22
8691  */
8692 GtkWidget *
8693 gtk_window_group_get_current_grab (GtkWindowGroup *window_group)
8694 {
8695   g_return_val_if_fail (GTK_IS_WINDOW_GROUP (window_group), NULL);
8696
8697   if (window_group->priv->grabs)
8698     return GTK_WIDGET (window_group->priv->grabs->data);
8699   return NULL;
8700 }
8701
8702 void
8703 _gtk_window_group_add_grab (GtkWindowGroup *window_group,
8704                             GtkWidget      *widget)
8705 {
8706   GtkWindowGroupPrivate *priv;
8707
8708   priv = window_group->priv;
8709   priv->grabs = g_slist_prepend (priv->grabs, widget);
8710 }
8711
8712 void
8713 _gtk_window_group_remove_grab (GtkWindowGroup *window_group,
8714                                GtkWidget      *widget)
8715 {
8716   GtkWindowGroupPrivate *priv;
8717
8718   priv = window_group->priv;
8719   priv->grabs = g_slist_remove (priv->grabs, widget);
8720 }
8721
8722
8723 void
8724 _gtk_window_group_add_device_grab (GtkWindowGroup *window_group,
8725                                    GtkWidget      *widget,
8726                                    GdkDevice      *device,
8727                                    gboolean        block_others)
8728 {
8729   GtkWindowGroupPrivate *priv;
8730   GtkDeviceGrabInfo *info;
8731
8732   priv = window_group->priv;
8733
8734   info = g_slice_new0 (GtkDeviceGrabInfo);
8735   info->widget = widget;
8736   info->device = device;
8737   info->block_others = block_others;
8738
8739   priv->device_grabs = g_slist_prepend (priv->device_grabs, info);
8740 }
8741
8742 void
8743 _gtk_window_group_remove_device_grab (GtkWindowGroup *window_group,
8744                                       GtkWidget      *widget,
8745                                       GdkDevice      *device)
8746 {
8747   GtkWindowGroupPrivate *priv;
8748   GtkDeviceGrabInfo *info;
8749   GSList *list, *node = NULL;
8750   GdkDevice *other_device;
8751
8752   priv = window_group->priv;
8753   other_device = gdk_device_get_associated_device (device);
8754   list = priv->device_grabs;
8755
8756   while (list)
8757     {
8758       info = list->data;
8759
8760       if (info->widget == widget &&
8761           (info->device == device ||
8762            info->device == other_device))
8763         {
8764           node = list;
8765           break;
8766         }
8767
8768       list = list->next;
8769     }
8770
8771   if (node)
8772     {
8773       info = node->data;
8774
8775       priv->device_grabs = g_slist_delete_link (priv->device_grabs, node);
8776       g_slice_free (GtkDeviceGrabInfo, info);
8777     }
8778 }
8779
8780 /**
8781  * gtk_window_group_get_current_device_grab:
8782  * @window_group: a #GtkWindowGroup
8783  * @device: a #GdkDevice
8784  *
8785  * Returns the current grab widget for @device, or %NULL if none.
8786  *
8787  * Returns: The grab widget, or %NULL
8788  *
8789  * Since: 3.0
8790  */
8791 GtkWidget *
8792 gtk_window_group_get_current_device_grab (GtkWindowGroup *window_group,
8793                                           GdkDevice      *device)
8794 {
8795   GtkWindowGroupPrivate *priv;
8796   GtkDeviceGrabInfo *info;
8797   GdkDevice *other_device;
8798   GSList *list;
8799
8800   g_return_val_if_fail (GTK_IS_WINDOW_GROUP (window_group), NULL);
8801   g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
8802
8803   priv = window_group->priv;
8804   list = priv->device_grabs;
8805   other_device = gdk_device_get_associated_device (device);
8806
8807   while (list)
8808     {
8809       info = list->data;
8810       list = list->next;
8811
8812       if (info->device == device ||
8813           info->device == other_device)
8814         return info->widget;
8815     }
8816
8817   return NULL;
8818 }
8819
8820 gboolean
8821 _gtk_window_group_widget_is_blocked_for_device (GtkWindowGroup *window_group,
8822                                                 GtkWidget      *widget,
8823                                                 GdkDevice      *device)
8824 {
8825   GtkWindowGroupPrivate *priv;
8826   GtkDeviceGrabInfo *info;
8827   GdkDevice *other_device;
8828   GSList *list;
8829
8830   priv = window_group->priv;
8831   other_device = gdk_device_get_associated_device (device);
8832   list = priv->device_grabs;
8833
8834   while (list)
8835     {
8836       info = list->data;
8837       list = list->next;
8838
8839       /* Look for blocking grabs on other device pairs
8840        * that have the passed widget within the GTK+ grab.
8841        */
8842       if (info->block_others &&
8843           info->device != device &&
8844           info->device != other_device &&
8845           (info->widget == widget ||
8846            gtk_widget_is_ancestor (widget, info->widget)))
8847         return TRUE;
8848     }
8849
8850   return FALSE;
8851 }
8852
8853 /*
8854   Derived from XParseGeometry() in XFree86
8855
8856   Copyright 1985, 1986, 1987,1998  The Open Group
8857
8858   All Rights Reserved.
8859
8860   The above copyright notice and this permission notice shall be included
8861   in all copies or substantial portions of the Software.
8862
8863   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
8864   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
8865   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
8866   IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
8867   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
8868   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
8869   OTHER DEALINGS IN THE SOFTWARE.
8870
8871   Except as contained in this notice, the name of The Open Group shall
8872   not be used in advertising or otherwise to promote the sale, use or
8873   other dealings in this Software without prior written authorization
8874   from The Open Group.
8875 */
8876
8877
8878 /*
8879  *    XParseGeometry parses strings of the form
8880  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
8881  *   width, height, xoffset, and yoffset are unsigned integers.
8882  *   Example:  "=80x24+300-49"
8883  *   The equal sign is optional.
8884  *   It returns a bitmask that indicates which of the four values
8885  *   were actually found in the string.  For each value found,
8886  *   the corresponding argument is updated;  for each value
8887  *   not found, the corresponding argument is left unchanged.
8888  */
8889
8890 /* The following code is from Xlib, and is minimally modified, so we
8891  * can track any upstream changes if required.  Don't change this
8892  * code. Or if you do, put in a huge comment marking which thing
8893  * changed.
8894  */
8895
8896 static int
8897 read_int (gchar   *string,
8898           gchar  **next)
8899 {
8900   int result = 0;
8901   int sign = 1;
8902
8903   if (*string == '+')
8904     string++;
8905   else if (*string == '-')
8906     {
8907       string++;
8908       sign = -1;
8909     }
8910
8911   for (; (*string >= '0') && (*string <= '9'); string++)
8912     {
8913       result = (result * 10) + (*string - '0');
8914     }
8915
8916   *next = string;
8917
8918   if (sign >= 0)
8919     return (result);
8920   else
8921     return (-result);
8922 }
8923
8924 /*
8925  * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
8926  * value (x, y, width, height) was found in the parsed string.
8927  */
8928 #define NoValue         0x0000
8929 #define XValue          0x0001
8930 #define YValue          0x0002
8931 #define WidthValue      0x0004
8932 #define HeightValue     0x0008
8933 #define AllValues       0x000F
8934 #define XNegative       0x0010
8935 #define YNegative       0x0020
8936
8937 /* Try not to reformat/modify, so we can compare/sync with X sources */
8938 static int
8939 gtk_XParseGeometry (const char   *string,
8940                     int          *x,
8941                     int          *y,
8942                     unsigned int *width,
8943                     unsigned int *height)
8944 {
8945   int mask = NoValue;
8946   char *strind;
8947   unsigned int tempWidth, tempHeight;
8948   int tempX, tempY;
8949   char *nextCharacter;
8950
8951   /* These initializations are just to silence gcc */
8952   tempWidth = 0;
8953   tempHeight = 0;
8954   tempX = 0;
8955   tempY = 0;
8956
8957   if ( (string == NULL) || (*string == '\0')) return(mask);
8958   if (*string == '=')
8959     string++;  /* ignore possible '=' at beg of geometry spec */
8960
8961   strind = (char *)string;
8962   if (*strind != '+' && *strind != '-' && *strind != 'x') {
8963     tempWidth = read_int(strind, &nextCharacter);
8964     if (strind == nextCharacter)
8965       return (0);
8966     strind = nextCharacter;
8967     mask |= WidthValue;
8968   }
8969
8970   if (*strind == 'x' || *strind == 'X') {
8971     strind++;
8972     tempHeight = read_int(strind, &nextCharacter);
8973     if (strind == nextCharacter)
8974       return (0);
8975     strind = nextCharacter;
8976     mask |= HeightValue;
8977   }
8978
8979   if ((*strind == '+') || (*strind == '-')) {
8980     if (*strind == '-') {
8981       strind++;
8982       tempX = -read_int(strind, &nextCharacter);
8983       if (strind == nextCharacter)
8984         return (0);
8985       strind = nextCharacter;
8986       mask |= XNegative;
8987
8988     }
8989     else
8990       { strind++;
8991       tempX = read_int(strind, &nextCharacter);
8992       if (strind == nextCharacter)
8993         return(0);
8994       strind = nextCharacter;
8995       }
8996     mask |= XValue;
8997     if ((*strind == '+') || (*strind == '-')) {
8998       if (*strind == '-') {
8999         strind++;
9000         tempY = -read_int(strind, &nextCharacter);
9001         if (strind == nextCharacter)
9002           return(0);
9003         strind = nextCharacter;
9004         mask |= YNegative;
9005
9006       }
9007       else
9008         {
9009           strind++;
9010           tempY = read_int(strind, &nextCharacter);
9011           if (strind == nextCharacter)
9012             return(0);
9013           strind = nextCharacter;
9014         }
9015       mask |= YValue;
9016     }
9017   }
9018
9019   /* If strind isn't at the end of the string the it's an invalid
9020                 geometry specification. */
9021
9022   if (*strind != '\0') return (0);
9023
9024   if (mask & XValue)
9025     *x = tempX;
9026   if (mask & YValue)
9027     *y = tempY;
9028   if (mask & WidthValue)
9029     *width = tempWidth;
9030   if (mask & HeightValue)
9031     *height = tempHeight;
9032   return (mask);
9033 }
9034
9035 /**
9036  * gtk_window_parse_geometry:
9037  * @window: a #GtkWindow
9038  * @geometry: geometry string
9039  *
9040  * Parses a standard X Window System geometry string - see the
9041  * manual page for X (type 'man X') for details on this.
9042  * gtk_window_parse_geometry() does work on all GTK+ ports
9043  * including Win32 but is primarily intended for an X environment.
9044  *
9045  * If either a size or a position can be extracted from the
9046  * geometry string, gtk_window_parse_geometry() returns %TRUE
9047  * and calls gtk_window_set_default_size() and/or gtk_window_move()
9048  * to resize/move the window.
9049  *
9050  * If gtk_window_parse_geometry() returns %TRUE, it will also
9051  * set the #GDK_HINT_USER_POS and/or #GDK_HINT_USER_SIZE hints
9052  * indicating to the window manager that the size/position of
9053  * the window was user-specified. This causes most window
9054  * managers to honor the geometry.
9055  *
9056  * Note that for gtk_window_parse_geometry() to work as expected, it has
9057  * to be called when the window has its "final" size, i.e. after calling
9058  * gtk_widget_show_all() on the contents and gtk_window_set_geometry_hints()
9059  * on the window.
9060  * |[
9061  * #include <gtk/gtk.h>
9062  *
9063  * static void
9064  * fill_with_content (GtkWidget *vbox)
9065  * {
9066  *   /&ast; fill with content... &ast;/
9067  * }
9068  *
9069  * int
9070  * main (int argc, char *argv[])
9071  * {
9072  *   GtkWidget *window, *vbox;
9073  *   GdkGeometry size_hints = {
9074  *     100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
9075  *   };
9076  *
9077  *   gtk_init (&argc, &argv);
9078  *
9079  *   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9080  *   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
9081  *
9082  *   gtk_container_add (GTK_CONTAINER (window), vbox);
9083  *   fill_with_content (vbox);
9084  *   gtk_widget_show_all (vbox);
9085  *
9086  *   gtk_window_set_geometry_hints (GTK_WINDOW (window),
9087  *                                  window,
9088  *                                  &size_hints,
9089  *                                  GDK_HINT_MIN_SIZE |
9090  *                                  GDK_HINT_BASE_SIZE |
9091  *                                  GDK_HINT_RESIZE_INC);
9092  *
9093  *   if (argc &gt; 1)
9094  *     {
9095  *       if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
9096  *         fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
9097  *     }
9098  *
9099  *   gtk_widget_show_all (window);
9100  *   gtk_main ();
9101  *
9102  *   return 0;
9103  * }
9104  * ]|
9105  *
9106  * Return value: %TRUE if string was parsed successfully
9107  **/
9108 gboolean
9109 gtk_window_parse_geometry (GtkWindow   *window,
9110                            const gchar *geometry)
9111 {
9112   gint result, x = 0, y = 0;
9113   guint w, h;
9114   GtkWidget *child;
9115   GdkGravity grav;
9116   gboolean size_set, pos_set;
9117   GdkScreen *screen;
9118
9119   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
9120   g_return_val_if_fail (geometry != NULL, FALSE);
9121
9122   child = gtk_bin_get_child (GTK_BIN (window));
9123   if (!child || !gtk_widget_get_visible (child))
9124     g_warning ("gtk_window_parse_geometry() called on a window with no "
9125                "visible children; the window should be set up before "
9126                "gtk_window_parse_geometry() is called.");
9127
9128   screen = gtk_window_check_screen (window);
9129
9130   result = gtk_XParseGeometry (geometry, &x, &y, &w, &h);
9131
9132   size_set = FALSE;
9133   if ((result & WidthValue) || (result & HeightValue))
9134     {
9135       gtk_window_set_default_size_internal (window,
9136                                             TRUE, result & WidthValue ? w : -1,
9137                                             TRUE, result & HeightValue ? h : -1,
9138                                             TRUE);
9139       size_set = TRUE;
9140     }
9141
9142   gtk_window_get_size (window, (gint *)&w, (gint *)&h);
9143
9144   grav = GDK_GRAVITY_NORTH_WEST;
9145
9146   if ((result & XNegative) && (result & YNegative))
9147     grav = GDK_GRAVITY_SOUTH_EAST;
9148   else if (result & XNegative)
9149     grav = GDK_GRAVITY_NORTH_EAST;
9150   else if (result & YNegative)
9151     grav = GDK_GRAVITY_SOUTH_WEST;
9152
9153   if ((result & XValue) == 0)
9154     x = 0;
9155
9156   if ((result & YValue) == 0)
9157     y = 0;
9158
9159   if (grav == GDK_GRAVITY_SOUTH_WEST ||
9160       grav == GDK_GRAVITY_SOUTH_EAST)
9161     y = gdk_screen_get_height (screen) - h + y;
9162
9163   if (grav == GDK_GRAVITY_SOUTH_EAST ||
9164       grav == GDK_GRAVITY_NORTH_EAST)
9165     x = gdk_screen_get_width (screen) - w + x;
9166
9167   /* we don't let you put a window offscreen; maybe some people would
9168    * prefer to be able to, but it's kind of a bogus thing to do.
9169    */
9170   if (y < 0)
9171     y = 0;
9172
9173   if (x < 0)
9174     x = 0;
9175
9176   pos_set = FALSE;
9177   if ((result & XValue) || (result & YValue))
9178     {
9179       gtk_window_set_gravity (window, grav);
9180       gtk_window_move (window, x, y);
9181       pos_set = TRUE;
9182     }
9183
9184   if (size_set || pos_set)
9185     {
9186       /* Set USSize, USPosition hints */
9187       GtkWindowGeometryInfo *info;
9188
9189       info = gtk_window_get_geometry_info (window, TRUE);
9190
9191       if (pos_set)
9192         info->mask |= GDK_HINT_USER_POS;
9193       if (size_set)
9194         info->mask |= GDK_HINT_USER_SIZE;
9195     }
9196
9197   return result != 0;
9198 }
9199
9200 static void
9201 gtk_window_mnemonic_hash_foreach (guint      keyval,
9202                                   GSList    *targets,
9203                                   gpointer   data)
9204 {
9205   struct {
9206     GtkWindow *window;
9207     GtkWindowKeysForeachFunc func;
9208     gpointer func_data;
9209   } *info = data;
9210
9211   (*info->func) (info->window, keyval, info->window->priv->mnemonic_modifier, TRUE, info->func_data);
9212 }
9213
9214 void
9215 _gtk_window_keys_foreach (GtkWindow                *window,
9216                           GtkWindowKeysForeachFunc func,
9217                           gpointer                 func_data)
9218 {
9219   GSList *groups;
9220   GtkMnemonicHash *mnemonic_hash;
9221
9222   struct {
9223     GtkWindow *window;
9224     GtkWindowKeysForeachFunc func;
9225     gpointer func_data;
9226   } info;
9227
9228   info.window = window;
9229   info.func = func;
9230   info.func_data = func_data;
9231
9232   mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
9233   if (mnemonic_hash)
9234     _gtk_mnemonic_hash_foreach (mnemonic_hash,
9235                                 gtk_window_mnemonic_hash_foreach, &info);
9236
9237   groups = gtk_accel_groups_from_object (G_OBJECT (window));
9238   while (groups)
9239     {
9240       GtkAccelGroup *group = groups->data;
9241       gint i;
9242
9243       for (i = 0; i < group->priv->n_accels; i++)
9244         {
9245           GtkAccelKey *key = &group->priv->priv_accels[i].key;
9246
9247           if (key->accel_key)
9248             (*func) (window, key->accel_key, key->accel_mods, FALSE, func_data);
9249         }
9250
9251       groups = groups->next;
9252     }
9253 }
9254
9255 static void
9256 gtk_window_keys_changed (GtkWindow *window)
9257 {
9258   gtk_window_free_key_hash (window);
9259   gtk_window_get_key_hash (window);
9260 }
9261
9262 typedef struct _GtkWindowKeyEntry GtkWindowKeyEntry;
9263
9264 struct _GtkWindowKeyEntry
9265 {
9266   guint keyval;
9267   guint modifiers;
9268   guint is_mnemonic : 1;
9269 };
9270
9271 static void
9272 window_key_entry_destroy (gpointer data)
9273 {
9274   g_slice_free (GtkWindowKeyEntry, data);
9275 }
9276
9277 static void
9278 add_to_key_hash (GtkWindow      *window,
9279                  guint           keyval,
9280                  GdkModifierType modifiers,
9281                  gboolean        is_mnemonic,
9282                  gpointer        data)
9283 {
9284   GtkKeyHash *key_hash = data;
9285
9286   GtkWindowKeyEntry *entry = g_slice_new (GtkWindowKeyEntry);
9287
9288   entry->keyval = keyval;
9289   entry->modifiers = modifiers;
9290   entry->is_mnemonic = is_mnemonic;
9291
9292   /* GtkAccelGroup stores lowercased accelerators. To deal
9293    * with this, if <Shift> was specified, uppercase.
9294    */
9295   if (modifiers & GDK_SHIFT_MASK)
9296     {
9297       if (keyval == GDK_KEY_Tab)
9298         keyval = GDK_KEY_ISO_Left_Tab;
9299       else
9300         keyval = gdk_keyval_to_upper (keyval);
9301     }
9302
9303   _gtk_key_hash_add_entry (key_hash, keyval, entry->modifiers, entry);
9304 }
9305
9306 static GtkKeyHash *
9307 gtk_window_get_key_hash (GtkWindow *window)
9308 {
9309   GdkScreen *screen = gtk_window_check_screen (window);
9310   GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
9311
9312   if (key_hash)
9313     return key_hash;
9314
9315   key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (screen)),
9316                                 (GDestroyNotify)window_key_entry_destroy);
9317   _gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
9318   g_object_set_qdata (G_OBJECT (window), quark_gtk_window_key_hash, key_hash);
9319
9320   return key_hash;
9321 }
9322
9323 static void
9324 gtk_window_free_key_hash (GtkWindow *window)
9325 {
9326   GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
9327   if (key_hash)
9328     {
9329       _gtk_key_hash_free (key_hash);
9330       g_object_set_qdata (G_OBJECT (window), quark_gtk_window_key_hash, NULL);
9331     }
9332 }
9333
9334 /**
9335  * gtk_window_activate_key:
9336  * @window:  a #GtkWindow
9337  * @event:   a #GdkEventKey
9338  *
9339  * Activates mnemonics and accelerators for this #GtkWindow. This is normally
9340  * called by the default ::key_press_event handler for toplevel windows,
9341  * however in some cases it may be useful to call this directly when
9342  * overriding the standard key handling for a toplevel window.
9343  *
9344  * Return value: %TRUE if a mnemonic or accelerator was found and activated.
9345  *
9346  * Since: 2.4
9347  */
9348 gboolean
9349 gtk_window_activate_key (GtkWindow   *window,
9350                          GdkEventKey *event)
9351 {
9352   GtkKeyHash *key_hash;
9353   GtkWindowKeyEntry *found_entry = NULL;
9354   gboolean enable_mnemonics;
9355   gboolean enable_accels;
9356
9357   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
9358   g_return_val_if_fail (event != NULL, FALSE);
9359
9360   key_hash = gtk_window_get_key_hash (window);
9361
9362   if (key_hash)
9363     {
9364       GSList *tmp_list;
9365       GSList *entries = _gtk_key_hash_lookup (key_hash,
9366                                               event->hardware_keycode,
9367                                               event->state,
9368                                               gtk_accelerator_get_default_mod_mask (),
9369                                               event->group);
9370
9371       g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
9372                     "gtk-enable-mnemonics", &enable_mnemonics,
9373                     "gtk-enable-accels", &enable_accels,
9374                     NULL);
9375
9376       for (tmp_list = entries; tmp_list; tmp_list = tmp_list->next)
9377         {
9378           GtkWindowKeyEntry *entry = tmp_list->data;
9379           if (entry->is_mnemonic)
9380             {
9381               if (enable_mnemonics)
9382                 {
9383                   found_entry = entry;
9384                   break;
9385                 }
9386             }
9387           else
9388             {
9389               if (enable_accels && !found_entry)
9390                 {
9391                   found_entry = entry;
9392                 }
9393             }
9394         }
9395
9396       g_slist_free (entries);
9397     }
9398
9399   if (found_entry)
9400     {
9401       if (found_entry->is_mnemonic)
9402         {
9403           if (enable_mnemonics)
9404             return gtk_window_mnemonic_activate (window, found_entry->keyval,
9405                                                  found_entry->modifiers);
9406         }
9407       else
9408         {
9409           if (enable_accels)
9410             return gtk_accel_groups_activate (G_OBJECT (window), found_entry->keyval,
9411                                               found_entry->modifiers);
9412         }
9413     }
9414
9415   return FALSE;
9416 }
9417
9418 static void
9419 window_update_has_focus (GtkWindow *window)
9420 {
9421   GtkWindowPrivate *priv = window->priv;
9422   GtkWidget *widget = GTK_WIDGET (window);
9423   gboolean has_focus = priv->has_toplevel_focus && priv->is_active;
9424
9425   if (has_focus != priv->has_focus)
9426     {
9427       priv->has_focus = has_focus;
9428
9429       if (has_focus)
9430         {
9431           if (priv->focus_widget &&
9432               priv->focus_widget != widget &&
9433               !gtk_widget_has_focus (priv->focus_widget))
9434             do_focus_change (priv->focus_widget, TRUE);
9435         }
9436       else
9437         {
9438           if (priv->focus_widget &&
9439               priv->focus_widget != widget &&
9440               gtk_widget_has_focus (priv->focus_widget))
9441             do_focus_change (priv->focus_widget, FALSE);
9442         }
9443     }
9444 }
9445
9446 /**
9447  * _gtk_window_set_is_active:
9448  * @window: a #GtkWindow
9449  * @is_active: %TRUE if the window is in the currently active toplevel
9450  *
9451  * Internal function that sets whether the #GtkWindow is part
9452  * of the currently active toplevel window (taking into account inter-process
9453  * embedding.)
9454  **/
9455 void
9456 _gtk_window_set_is_active (GtkWindow *window,
9457                            gboolean   is_active)
9458 {
9459   GtkWindowPrivate *priv;
9460
9461   g_return_if_fail (GTK_IS_WINDOW (window));
9462
9463   priv = window->priv;
9464
9465   is_active = is_active != FALSE;
9466
9467   if (is_active != priv->is_active)
9468     {
9469       priv->is_active = is_active;
9470       window_update_has_focus (window);
9471
9472       g_object_notify (G_OBJECT (window), "is-active");
9473     }
9474 }
9475
9476 /**
9477  * _gtk_window_set_is_toplevel:
9478  * @window: a #GtkWindow
9479  * @is_toplevel: %TRUE if the window is still a real toplevel (nominally a
9480  * parent of the root window); %FALSE if it is not (for example, for an
9481  * in-process, parented GtkPlug)
9482  *
9483  * Internal function used by #GtkPlug when it gets parented/unparented by a
9484  * #GtkSocket.  This keeps the @window's #GTK_TOPLEVEL flag in sync with the
9485  * global list of toplevel windows.
9486  */
9487 void
9488 _gtk_window_set_is_toplevel (GtkWindow *window,
9489                              gboolean   is_toplevel)
9490 {
9491   GtkWidget *widget;
9492
9493   widget = GTK_WIDGET (window);
9494
9495   if (gtk_widget_is_toplevel (widget))
9496     g_assert (g_slist_find (toplevel_list, window) != NULL);
9497   else
9498     g_assert (g_slist_find (toplevel_list, window) == NULL);
9499
9500   if (is_toplevel == gtk_widget_is_toplevel (widget))
9501     return;
9502
9503   if (is_toplevel)
9504     {
9505       _gtk_widget_set_is_toplevel (widget, TRUE);
9506       toplevel_list = g_slist_prepend (toplevel_list, window);
9507     }
9508   else
9509     {
9510       _gtk_widget_set_is_toplevel (widget, FALSE);
9511       toplevel_list = g_slist_remove (toplevel_list, window);
9512     }
9513 }
9514
9515 /**
9516  * _gtk_window_set_has_toplevel_focus:
9517  * @window: a #GtkWindow
9518  * @has_toplevel_focus: %TRUE if the in
9519  *
9520  * Internal function that sets whether the keyboard focus for the
9521  * toplevel window (taking into account inter-process embedding.)
9522  **/
9523 void
9524 _gtk_window_set_has_toplevel_focus (GtkWindow *window,
9525                                    gboolean   has_toplevel_focus)
9526 {
9527   GtkWindowPrivate *priv;
9528
9529   g_return_if_fail (GTK_IS_WINDOW (window));
9530
9531   priv = window->priv;
9532
9533   has_toplevel_focus = has_toplevel_focus != FALSE;
9534
9535   if (has_toplevel_focus != priv->has_toplevel_focus)
9536     {
9537       priv->has_toplevel_focus = has_toplevel_focus;
9538       window_update_has_focus (window);
9539
9540       g_object_notify (G_OBJECT (window), "has-toplevel-focus");
9541     }
9542 }
9543
9544 /**
9545  * gtk_window_set_auto_startup_notification:
9546  * @setting: %TRUE to automatically do startup notification
9547  *
9548  * By default, after showing the first #GtkWindow, GTK+ calls
9549  * gdk_notify_startup_complete().  Call this function to disable
9550  * the automatic startup notification. You might do this if your
9551  * first window is a splash screen, and you want to delay notification
9552  * until after your real main window has been shown, for example.
9553  *
9554  * In that example, you would disable startup notification
9555  * temporarily, show your splash screen, then re-enable it so that
9556  * showing the main window would automatically result in notification.
9557  *
9558  * Since: 2.2
9559  **/
9560 void
9561 gtk_window_set_auto_startup_notification (gboolean setting)
9562 {
9563   disable_startup_notification = !setting;
9564 }
9565
9566 /**
9567  * gtk_window_get_window_type:
9568  * @window: a #GtkWindow
9569  *
9570  * Gets the type of the window. See #GtkWindowType.
9571  *
9572  * Return value: the type of the window
9573  *
9574  * Since: 2.20
9575  **/
9576 GtkWindowType
9577 gtk_window_get_window_type (GtkWindow *window)
9578 {
9579   g_return_val_if_fail (GTK_IS_WINDOW (window), GTK_WINDOW_TOPLEVEL);
9580
9581   return window->priv->type;
9582 }
9583
9584 /**
9585  * gtk_window_get_mnemonics_visible:
9586  * @window: a #GtkWindow
9587  *
9588  * Gets the value of the #GtkWindow:mnemonics-visible property.
9589  *
9590  * Returns: %TRUE if mnemonics are supposed to be visible
9591  * in this window.
9592  *
9593  * Since: 2.20
9594  */
9595 gboolean
9596 gtk_window_get_mnemonics_visible (GtkWindow *window)
9597 {
9598   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
9599
9600   return window->priv->mnemonics_visible;
9601 }
9602
9603 /**
9604  * gtk_window_set_mnemonics_visible:
9605  * @window: a #GtkWindow
9606  * @setting: the new value
9607  *
9608  * Sets the #GtkWindow:mnemonics-visible property.
9609  *
9610  * Since: 2.20
9611  */
9612 void
9613 gtk_window_set_mnemonics_visible (GtkWindow *window,
9614                                   gboolean   setting)
9615 {
9616   GtkWindowPrivate *priv;
9617
9618   g_return_if_fail (GTK_IS_WINDOW (window));
9619
9620   priv = window->priv;
9621
9622   setting = setting != FALSE;
9623
9624   if (priv->mnemonics_visible != setting)
9625     {
9626       priv->mnemonics_visible = setting;
9627       g_object_notify (G_OBJECT (window), "mnemonics-visible");
9628     }
9629
9630   priv->mnemonics_visible_set = TRUE;
9631 }
9632
9633 void
9634 _gtk_window_get_wmclass (GtkWindow  *window,
9635                          gchar     **wmclass_name,
9636                          gchar     **wmclass_class)
9637 {
9638   GtkWindowPrivate *priv = window->priv;
9639
9640   *wmclass_name = priv->wmclass_name;
9641   *wmclass_class = priv->wmclass_class;
9642 }