Pileus Git - ~andy/gtk/blob - gdk/gdkwindow.h

   1 /* GDK - The GIMP Drawing Kit
   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 #if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
  28 #error "Only <gdk/gdk.h> can be included directly."
  29 #endif
  30
  31 #ifndef __GDK_WINDOW_H__
  32 #define __GDK_WINDOW_H__
  33
  34 #include <gdk/gdkdrawable.h>
  35 #include <gdk/gdktypes.h>
  36 #include <gdk/gdkevents.h>
  37
  38 G_BEGIN_DECLS
  39
  40 typedef struct _GdkGeometry          GdkGeometry;
  41 typedef struct _GdkWindowAttr        GdkWindowAttr;
  42 typedef struct _GdkPointerHooks      GdkPointerHooks;
  43 typedef struct _GdkWindowRedirect    GdkWindowRedirect;
  44
  45 /* Classes of windows.
  46  *   InputOutput: Almost every window should be of this type. Such windows
  47  *                receive events and are also displayed on screen.
  48  *   InputOnly: Used only in special circumstances when events need to be
  49  *              stolen from another window or windows. Input only windows
  50  *              have no visible output, so they are handy for placing over
  51  *              top of a group of windows in order to grab the events (or
  52  *              filter the events) from those windows.
  53  */
  54 typedef enum
  55 {
  56   GDK_INPUT_OUTPUT,
  57   GDK_INPUT_ONLY
  58 } GdkWindowClass;
  59
  60 /* Types of windows.
  61  *   Root: There is only 1 root window and it is initialized
  62  *         at startup. Creating a window of type GDK_WINDOW_ROOT
  63  *         is an error.
  64  *   Toplevel: Windows which interact with the window manager.
  65  *   Child: Windows which are children of some other type of window.
  66  *          (Any other type of window). Most windows are child windows.
  67  *   Dialog: A special kind of toplevel window which interacts with
  68  *           the window manager slightly differently than a regular
  69  *           toplevel window. Dialog windows should be used for any
  70  *           transient window.
  71  *   Foreign: A window that actually belongs to another application
  72  */
  73 typedef enum
  74 {
  75   GDK_WINDOW_ROOT,
  76   GDK_WINDOW_TOPLEVEL,
  77   GDK_WINDOW_CHILD,
  78   GDK_WINDOW_DIALOG,
  79   GDK_WINDOW_TEMP,
  80   GDK_WINDOW_FOREIGN,
  81   GDK_WINDOW_OFFSCREEN
  82 } GdkWindowType;
  83
  84 /* Window attribute mask values.
  85  *   GDK_WA_TITLE: The "title" field is valid.
  86  *   GDK_WA_X: The "x" field is valid.
  87  *   GDK_WA_Y: The "y" field is valid.
  88  *   GDK_WA_CURSOR: The "cursor" field is valid.
  89  *   GDK_WA_COLORMAP: The "colormap" field is valid.
  90  *   GDK_WA_VISUAL: The "visual" field is valid.
  91  */
  92 typedef enum
  93 {
  94   GDK_WA_TITLE     = 1 << 1,
  95   GDK_WA_X         = 1 << 2,
  96   GDK_WA_Y         = 1 << 3,
  97   GDK_WA_CURSOR    = 1 << 4,
  98   GDK_WA_COLORMAP  = 1 << 5,
  99   GDK_WA_VISUAL    = 1 << 6,
 100   GDK_WA_WMCLASS   = 1 << 7,
 101   GDK_WA_NOREDIR   = 1 << 8,
 102   GDK_WA_TYPE_HINT = 1 << 9
 103 } GdkWindowAttributesType;
 104
 105 /* Size restriction enumeration.
 106  */
 107 typedef enum
 108 {
 109   GDK_HINT_POS         = 1 << 0,
 110   GDK_HINT_MIN_SIZE    = 1 << 1,
 111   GDK_HINT_MAX_SIZE    = 1 << 2,
 112   GDK_HINT_BASE_SIZE   = 1 << 3,
 113   GDK_HINT_ASPECT      = 1 << 4,
 114   GDK_HINT_RESIZE_INC  = 1 << 5,
 115   GDK_HINT_WIN_GRAVITY = 1 << 6,
 116   GDK_HINT_USER_POS    = 1 << 7,
 117   GDK_HINT_USER_SIZE   = 1 << 8
 118 } GdkWindowHints;
 119
 120
 121 /* Window type hints.
 122  * These are hints for the window manager that indicate
 123  * what type of function the window has. The window manager
 124  * can use this when determining decoration and behaviour
 125  * of the window. The hint must be set before mapping the
 126  * window.
 127  *
 128  *   Normal: Normal toplevel window
 129  *   Dialog: Dialog window
 130  *   Menu: Window used to implement a menu.
 131  *   Toolbar: Window used to implement toolbars.
 132  */
 133 typedef enum
 134 {
 135   GDK_WINDOW_TYPE_HINT_NORMAL,
 136   GDK_WINDOW_TYPE_HINT_DIALOG,
 137   GDK_WINDOW_TYPE_HINT_MENU,            /* Torn off menu */
 138   GDK_WINDOW_TYPE_HINT_TOOLBAR,
 139   GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
 140   GDK_WINDOW_TYPE_HINT_UTILITY,
 141   GDK_WINDOW_TYPE_HINT_DOCK,
 142   GDK_WINDOW_TYPE_HINT_DESKTOP,
 143   GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,   /* A drop down menu (from a menubar) */
 144   GDK_WINDOW_TYPE_HINT_POPUP_MENU,      /* A popup menu (from right-click) */
 145   GDK_WINDOW_TYPE_HINT_TOOLTIP,
 146   GDK_WINDOW_TYPE_HINT_NOTIFICATION,
 147   GDK_WINDOW_TYPE_HINT_COMBO,
 148   GDK_WINDOW_TYPE_HINT_DND
 149 } GdkWindowTypeHint;
 150
 151 /* The next two enumeration values current match the
 152  * Motif constants. If this is changed, the implementation
 153  * of gdk_window_set_decorations/gdk_window_set_functions
 154  * will need to change as well.
 155  */
 156 typedef enum
 157 {
 158   GDK_DECOR_ALL         = 1 << 0,
 159   GDK_DECOR_BORDER      = 1 << 1,
 160   GDK_DECOR_RESIZEH     = 1 << 2,
 161   GDK_DECOR_TITLE       = 1 << 3,
 162   GDK_DECOR_MENU        = 1 << 4,
 163   GDK_DECOR_MINIMIZE    = 1 << 5,
 164   GDK_DECOR_MAXIMIZE    = 1 << 6
 165 } GdkWMDecoration;
 166
 167 typedef enum
 168 {
 169   GDK_FUNC_ALL          = 1 << 0,
 170   GDK_FUNC_RESIZE       = 1 << 1,
 171   GDK_FUNC_MOVE         = 1 << 2,
 172   GDK_FUNC_MINIMIZE     = 1 << 3,
 173   GDK_FUNC_MAXIMIZE     = 1 << 4,
 174   GDK_FUNC_CLOSE        = 1 << 5
 175 } GdkWMFunction;
 176
 177 /* Currently, these are the same values numerically as in the
 178  * X protocol. If you change that, gdkwindow-x11.c/gdk_window_set_geometry_hints()
 179  * will need fixing.
 180  */
 181 typedef enum
 182 {
 183   GDK_GRAVITY_NORTH_WEST = 1,
 184   GDK_GRAVITY_NORTH,
 185   GDK_GRAVITY_NORTH_EAST,
 186   GDK_GRAVITY_WEST,
 187   GDK_GRAVITY_CENTER,
 188   GDK_GRAVITY_EAST,
 189   GDK_GRAVITY_SOUTH_WEST,
 190   GDK_GRAVITY_SOUTH,
 191   GDK_GRAVITY_SOUTH_EAST,
 192   GDK_GRAVITY_STATIC
 193 } GdkGravity;
 194
 195
 196 typedef enum
 197 {
 198   GDK_WINDOW_EDGE_NORTH_WEST,
 199   GDK_WINDOW_EDGE_NORTH,
 200   GDK_WINDOW_EDGE_NORTH_EAST,
 201   GDK_WINDOW_EDGE_WEST,
 202   GDK_WINDOW_EDGE_EAST,
 203   GDK_WINDOW_EDGE_SOUTH_WEST,
 204   GDK_WINDOW_EDGE_SOUTH,
 205   GDK_WINDOW_EDGE_SOUTH_EAST
 206 } GdkWindowEdge;
 207
 208 struct _GdkWindowAttr
 209 {
 210   gchar *title;
 211   gint event_mask;
 212   gint x, y;
 213   gint width;
 214   gint height;
 215   GdkWindowClass wclass;
 216   GdkVisual *visual;
 217   GdkColormap *colormap;
 218   GdkWindowType window_type;
 219   GdkCursor *cursor;
 220   gchar *wmclass_name;
 221   gchar *wmclass_class;
 222   gboolean override_redirect;
 223   GdkWindowTypeHint type_hint;
 224 };
 225
 226 struct _GdkGeometry
 227 {
 228   gint min_width;
 229   gint min_height;
 230   gint max_width;
 231   gint max_height;
 232   gint base_width;
 233   gint base_height;
 234   gint width_inc;
 235   gint height_inc;
 236   gdouble min_aspect;
 237   gdouble max_aspect;
 238   GdkGravity win_gravity;
 239 };
 240
 241 struct _GdkPointerHooks
 242 {
 243   GdkWindow* (*get_pointer)       (GdkWindow       *window,
 244                                    gint            *x,
 245                                    gint            *y,
 246                                    GdkModifierType *mask);
 247   GdkWindow* (*window_at_pointer) (GdkScreen       *screen, /* unused */
 248                                    gint            *win_x,
 249                                    gint            *win_y);
 250 };
 251
 252 typedef struct _GdkWindowObject GdkWindowObject;
 253 typedef struct _GdkWindowObjectClass GdkWindowObjectClass;
 254
 255 #define GDK_TYPE_WINDOW              (gdk_window_object_get_type ())
 256 #define GDK_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW, GdkWindow))
 257 #define GDK_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW, GdkWindowObjectClass))
 258 #define GDK_IS_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
 259 #define GDK_IS_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
 260 #define GDK_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowObjectClass))
 261 #define GDK_WINDOW_OBJECT(object)    ((GdkWindowObject *) GDK_WINDOW (object))
 262
 263 #ifndef GDK_COMPILATION
 264 /* We used to export all of GdkWindowObject, but we don't want to keep doing so.
 265    However, there are various parts of it accessed by macros and other code,
 266    so we keep the old exported version public, but in reality it is larger. */
 267
 268 /**** DON'T CHANGE THIS STRUCT, the real version is in gdkinternals.h ****/
 269 struct _GdkWindowObject
 270 {
 271   GdkDrawable parent_instance;
 272
 273   GdkDrawable *impl; /* window-system-specific delegate object */
 274
 275   GdkWindowObject *parent;
 276
 277   gpointer user_data;
 278
 279   gint x;
 280   gint y;
 281
 282   gint extension_events;
 283
 284   GList *filters;
 285   GList *children;
 286
 287   GdkColor bg_color;
 288   GdkPixmap *bg_pixmap;
 289
 290   GSList *paint_stack;
 291
 292   GdkRegion *update_area;
 293   guint update_freeze_count;
 294
 295   guint8 window_type;
 296   guint8 depth;
 297   guint8 resize_count;
 298
 299   GdkWindowState state;
 300
 301   guint guffaw_gravity : 1;
 302   guint input_only : 1;
 303   guint modal_hint : 1;
 304   guint composited : 1;
 305
 306   guint destroyed : 2;
 307
 308   guint accept_focus : 1;
 309   guint focus_on_map : 1;
 310   guint shaped : 1;
 311
 312   GdkEventMask event_mask;
 313
 314   guint update_and_descendants_freeze_count;
 315
 316   GdkWindowRedirect *redirect;
 317 };
 318 #endif
 319
 320 struct _GdkWindowObjectClass
 321 {
 322   GdkDrawableClass parent_class;
 323 };
 324
 325 /* Windows
 326  */
 327 GType         gdk_window_object_get_type       (void) G_GNUC_CONST;
 328 GdkWindow*    gdk_window_new                   (GdkWindow     *parent,
 329                                                 GdkWindowAttr *attributes,
 330                                                 gint           attributes_mask);
 331 void          gdk_window_destroy               (GdkWindow     *window);
 332 GdkWindowType gdk_window_get_window_type       (GdkWindow     *window);
 333 GdkWindow*    gdk_window_at_pointer            (gint          *win_x,
 334                                                 gint          *win_y);
 335 void          gdk_window_show                  (GdkWindow     *window);
 336 void          gdk_window_hide                  (GdkWindow     *window);
 337 void          gdk_window_withdraw              (GdkWindow     *window);
 338 void          gdk_window_show_unraised         (GdkWindow     *window);
 339 void          gdk_window_move                  (GdkWindow     *window,
 340                                                 gint           x,
 341                                                 gint           y);
 342 void          gdk_window_resize                (GdkWindow     *window,
 343                                                 gint           width,
 344                                                 gint           height);
 345 void          gdk_window_move_resize           (GdkWindow     *window,
 346                                                 gint           x,
 347                                                 gint           y,
 348                                                 gint           width,
 349                                                 gint           height);
 350 void          gdk_window_reparent              (GdkWindow     *window,
 351                                                 GdkWindow     *new_parent,
 352                                                 gint           x,
 353                                                 gint           y);
 354 void          gdk_window_clear                 (GdkWindow     *window);
 355 void          gdk_window_clear_area            (GdkWindow     *window,
 356                                                 gint           x,
 357                                                 gint           y,
 358                                                 gint           width,
 359                                                 gint           height);
 360 void          gdk_window_clear_area_e          (GdkWindow     *window,
 361                                                 gint           x,
 362                                                 gint           y,
 363                                                 gint           width,
 364                                                 gint           height);
 365 void          gdk_window_raise                 (GdkWindow     *window);
 366 void          gdk_window_lower                 (GdkWindow     *window);
 367 void          gdk_window_restack               (GdkWindow     *window,
 368                                                 GdkWindow     *sibling,
 369                                                 gboolean       above);
 370 void          gdk_window_focus                 (GdkWindow     *window,
 371                                                 guint32        timestamp);
 372 void          gdk_window_set_user_data         (GdkWindow     *window,
 373                                                 gpointer       user_data);
 374 void          gdk_window_set_override_redirect (GdkWindow     *window,
 375                                                 gboolean       override_redirect);
 376 void          gdk_window_set_accept_focus      (GdkWindow     *window,
 377                                                 gboolean       accept_focus);
 378 void          gdk_window_set_focus_on_map      (GdkWindow     *window,
 379                                                 gboolean       focus_on_map);
 380 void          gdk_window_add_filter            (GdkWindow     *window,
 381                                                 GdkFilterFunc  function,
 382                                                 gpointer       data);
 383 void          gdk_window_remove_filter         (GdkWindow     *window,
 384                                                 GdkFilterFunc  function,
 385                                                 gpointer       data);
 386 void          gdk_window_scroll                (GdkWindow     *window,
 387                                                 gint           dx,
 388                                                 gint           dy);
 389 void          gdk_window_move_region           (GdkWindow       *window,
 390                                                 const GdkRegion *region,
 391                                                 gint             dx,
 392                                                 gint             dy);
 393 gboolean      gdk_window_ensure_native        (GdkWindow       *window);
 394
 395 /*
 396  * This allows for making shaped (partially transparent) windows
 397  * - cool feature, needed for Drag and Drag for example.
 398  *  The shape_mask can be the mask
 399  *  from gdk_pixmap_create_from_xpm.   Stefan Wille
 400  */
 401 void gdk_window_shape_combine_mask  (GdkWindow        *window,
 402                                      GdkBitmap        *mask,
 403                                      gint              x,
 404                                      gint              y);
 405 void gdk_window_shape_combine_region (GdkWindow       *window,
 406                                       const GdkRegion *shape_region,
 407                                       gint             offset_x,
 408                                       gint             offset_y);
 409
 410 /*
 411  * This routine allows you to quickly take the shapes of all the child windows
 412  * of a window and use their shapes as the shape mask for this window - useful
 413  * for container windows that dont want to look like a big box
 414  *
 415  * - Raster
 416  */
 417 void gdk_window_set_child_shapes (GdkWindow *window);
 418
 419 void gdk_window_set_composited   (GdkWindow *window,
 420                                   gboolean   composited);
 421
 422 /*
 423  * This routine allows you to merge (ie ADD) child shapes to your
 424  * own window's shape keeping its current shape and ADDING the child
 425  * shapes to it.
 426  *
 427  * - Raster
 428  */
 429 void gdk_window_merge_child_shapes         (GdkWindow       *window);
 430
 431 void gdk_window_input_shape_combine_mask   (GdkWindow       *window,
 432                                             GdkBitmap       *mask,
 433                                             gint             x,
 434                                             gint             y);
 435 void gdk_window_input_shape_combine_region (GdkWindow       *window,
 436                                             const GdkRegion *shape_region,
 437                                             gint             offset_x,
 438                                             gint             offset_y);
 439 void gdk_window_set_child_input_shapes     (GdkWindow       *window);
 440 void gdk_window_merge_child_input_shapes   (GdkWindow       *window);
 441
 442
 443 /*
 444  * Check if a window has been shown, and whether all its
 445  * parents up to a toplevel have been shown, respectively.
 446  * Note that a window that is_viewable below is not necessarily
 447  * viewable in the X sense.
 448  */
 449 gboolean gdk_window_is_visible     (GdkWindow *window);
 450 gboolean gdk_window_is_viewable    (GdkWindow *window);
 451
 452 GdkWindowState gdk_window_get_state (GdkWindow *window);
 453
 454 /* Set static bit gravity on the parent, and static
 455  * window gravity on all children.
 456  */
 457 gboolean gdk_window_set_static_gravities (GdkWindow *window,
 458                                           gboolean   use_static);
 459
 460 /* Functions to create/lookup windows from their native equivalents */
 461 #ifndef GDK_MULTIHEAD_SAFE
 462 GdkWindow*    gdk_window_foreign_new (GdkNativeWindow anid);
 463 GdkWindow*    gdk_window_lookup      (GdkNativeWindow anid);
 464 #endif
 465 GdkWindow    *gdk_window_foreign_new_for_display (GdkDisplay      *display,
 466                                                   GdkNativeWindow  anid);
 467 GdkWindow*    gdk_window_lookup_for_display (GdkDisplay      *display,
 468                                              GdkNativeWindow  anid);
 469
 470
 471 /* GdkWindow */
 472
 473 #ifndef GDK_DISABLE_DEPRECATED
 474 void          gdk_window_set_hints       (GdkWindow       *window,
 475                                           gint             x,
 476                                           gint             y,
 477                                           gint             min_width,
 478                                           gint             min_height,
 479                                           gint             max_width,
 480                                           gint             max_height,
 481                                           gint             flags);
 482 #endif
 483 void              gdk_window_set_type_hint (GdkWindow        *window,
 484                                             GdkWindowTypeHint hint);
 485 GdkWindowTypeHint gdk_window_get_type_hint (GdkWindow        *window);
 486
 487 void          gdk_window_set_modal_hint   (GdkWindow       *window,
 488                                            gboolean         modal);
 489
 490 void gdk_window_set_skip_taskbar_hint (GdkWindow *window,
 491                                        gboolean   skips_taskbar);
 492 void gdk_window_set_skip_pager_hint   (GdkWindow *window,
 493                                        gboolean   skips_pager);
 494 void gdk_window_set_urgency_hint      (GdkWindow *window,
 495                                        gboolean   urgent);
 496
 497 void          gdk_window_set_geometry_hints (GdkWindow          *window,
 498                                              const GdkGeometry  *geometry,
 499                                              GdkWindowHints      geom_mask);
 500 void          gdk_set_sm_client_id          (const gchar        *sm_client_id);
 501
 502 void          gdk_window_begin_paint_rect   (GdkWindow          *window,
 503                                              const GdkRectangle *rectangle);
 504 void          gdk_window_begin_paint_region (GdkWindow          *window,
 505                                              const GdkRegion    *region);
 506 void          gdk_window_end_paint          (GdkWindow          *window);
 507
 508 void          gdk_window_set_title         (GdkWindow     *window,
 509                                             const gchar   *title);
 510 void          gdk_window_set_role          (GdkWindow       *window,
 511                                             const gchar     *role);
 512 void          gdk_window_set_startup_id    (GdkWindow       *window,
 513                                             const gchar     *startup_id);
 514 void          gdk_window_set_transient_for (GdkWindow       *window,
 515                                             GdkWindow       *parent);
 516 void          gdk_window_set_background  (GdkWindow       *window,
 517                                           const GdkColor  *color);
 518 void          gdk_window_set_back_pixmap (GdkWindow       *window,
 519                                           GdkPixmap       *pixmap,
 520                                           gboolean         parent_relative);
 521 void          gdk_window_set_cursor      (GdkWindow       *window,
 522                                           GdkCursor       *cursor);
 523 GdkCursor    *gdk_window_get_cursor      (GdkWindow       *window);
 524 void          gdk_window_get_user_data   (GdkWindow       *window,
 525                                           gpointer        *data);
 526 void          gdk_window_get_geometry    (GdkWindow       *window,
 527                                           gint            *x,
 528                                           gint            *y,
 529                                           gint            *width,
 530                                           gint            *height,
 531                                           gint            *depth);
 532 void          gdk_window_get_position    (GdkWindow       *window,
 533                                           gint            *x,
 534                                           gint            *y);
 535 gint          gdk_window_get_origin      (GdkWindow       *window,
 536                                           gint            *x,
 537                                           gint            *y);
 538 void          gdk_window_get_root_coords (GdkWindow       *window,
 539                                           gint             x,
 540                                           gint             y,
 541                                           gint            *root_x,
 542                                           gint            *root_y);
 543
 544 #if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION) || defined (GDK_COMPILATION)
 545 /* Used by gtk_handle_box_button_changed () */
 546 gboolean      gdk_window_get_deskrelative_origin (GdkWindow       *window,
 547                                           gint            *x,
 548                                           gint            *y);
 549 #endif
 550
 551 void          gdk_window_get_root_origin (GdkWindow       *window,
 552                                           gint            *x,
 553                                           gint            *y);
 554 void          gdk_window_get_frame_extents (GdkWindow     *window,
 555                                             GdkRectangle  *rect);
 556 GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
 557                                           gint            *x,
 558                                           gint            *y,
 559                                           GdkModifierType *mask);
 560 GdkWindow *   gdk_window_get_parent      (GdkWindow       *window);
 561 GdkWindow *   gdk_window_get_toplevel    (GdkWindow       *window);
 562
 563 GList *       gdk_window_get_children    (GdkWindow       *window);
 564 GList *       gdk_window_peek_children   (GdkWindow       *window);
 565 GdkEventMask  gdk_window_get_events      (GdkWindow       *window);
 566 void          gdk_window_set_events      (GdkWindow       *window,
 567                                           GdkEventMask     event_mask);
 568
 569 void          gdk_window_set_icon_list   (GdkWindow       *window,
 570                                           GList           *pixbufs);
 571 void          gdk_window_set_icon        (GdkWindow       *window,
 572                                           GdkWindow       *icon_window,
 573                                           GdkPixmap       *pixmap,
 574                                           GdkBitmap       *mask);
 575 void          gdk_window_set_icon_name   (GdkWindow       *window,
 576                                           const gchar     *name);
 577 void          gdk_window_set_group       (GdkWindow       *window,
 578                                           GdkWindow       *leader);
 579 GdkWindow*    gdk_window_get_group       (GdkWindow       *window);
 580 void          gdk_window_set_decorations (GdkWindow       *window,
 581                                           GdkWMDecoration  decorations);
 582 gboolean      gdk_window_get_decorations (GdkWindow       *window,
 583                                           GdkWMDecoration *decorations);
 584 void          gdk_window_set_functions   (GdkWindow       *window,
 585                                           GdkWMFunction    functions);
 586 #if !defined(GDK_MULTIHEAD_SAFE) && !defined(GDK_DISABLE_DEPRECATED)
 587 GList *       gdk_window_get_toplevels   (void);
 588 #endif
 589
 590 void          gdk_window_beep            (GdkWindow       *window);
 591 void          gdk_window_iconify         (GdkWindow       *window);
 592 void          gdk_window_deiconify       (GdkWindow       *window);
 593 void          gdk_window_stick           (GdkWindow       *window);
 594 void          gdk_window_unstick         (GdkWindow       *window);
 595 void          gdk_window_maximize        (GdkWindow       *window);
 596 void          gdk_window_unmaximize      (GdkWindow       *window);
 597 void          gdk_window_fullscreen      (GdkWindow       *window);
 598 void          gdk_window_unfullscreen    (GdkWindow       *window);
 599 void          gdk_window_set_keep_above  (GdkWindow       *window,
 600                                           gboolean         setting);
 601 void          gdk_window_set_keep_below  (GdkWindow       *window,
 602                                           gboolean         setting);
 603 void          gdk_window_set_opacity     (GdkWindow       *window,
 604                                           gdouble          opacity);
 605 void          gdk_window_register_dnd    (GdkWindow       *window);
 606
 607 void gdk_window_begin_resize_drag (GdkWindow     *window,
 608                                    GdkWindowEdge  edge,
 609                                    gint           button,
 610                                    gint           root_x,
 611                                    gint           root_y,
 612                                    guint32        timestamp);
 613 void gdk_window_begin_move_drag   (GdkWindow     *window,
 614                                    gint           button,
 615                                    gint           root_x,
 616                                    gint           root_y,
 617                                    guint32        timestamp);
 618
 619 /* Interface for dirty-region queueing */
 620 void       gdk_window_invalidate_rect           (GdkWindow          *window,
 621                                                  const GdkRectangle *rect,
 622                                                  gboolean            invalidate_children);
 623 void       gdk_window_invalidate_region         (GdkWindow          *window,
 624                                                  const GdkRegion    *region,
 625                                                  gboolean            invalidate_children);
 626 void       gdk_window_invalidate_maybe_recurse  (GdkWindow          *window,
 627                                                  const GdkRegion    *region,
 628                                                  gboolean (*child_func) (GdkWindow *, gpointer),
 629                                                  gpointer   user_data);
 630 GdkRegion *gdk_window_get_update_area     (GdkWindow    *window);
 631
 632 void       gdk_window_freeze_updates      (GdkWindow    *window);
 633 void       gdk_window_thaw_updates        (GdkWindow    *window);
 634
 635 void       gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window);
 636 void       gdk_window_thaw_toplevel_updates_libgtk_only   (GdkWindow *window);
 637
 638 void       gdk_window_process_all_updates (void);
 639 void       gdk_window_process_updates     (GdkWindow    *window,
 640                                            gboolean      update_children);
 641
 642 /* Enable/disable flicker, so you can tell if your code is inefficient. */
 643 void       gdk_window_set_debug_updates   (gboolean      setting);
 644
 645 void       gdk_window_constrain_size      (GdkGeometry  *geometry,
 646                                            guint         flags,
 647                                            gint          width,
 648                                            gint          height,
 649                                            gint         *new_width,
 650                                            gint         *new_height);
 651
 652 void gdk_window_get_internal_paint_info (GdkWindow    *window,
 653                                          GdkDrawable **real_drawable,
 654                                          gint         *x_offset,
 655                                          gint         *y_offset);
 656
 657 void gdk_window_enable_synchronized_configure (GdkWindow *window);
 658 void gdk_window_configure_finished            (GdkWindow *window);
 659
 660 #ifndef GDK_MULTIHEAD_SAFE
 661 GdkPointerHooks *gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
 662 #endif /* GDK_MULTIHEAD_SAFE */
 663
 664 GdkWindow *gdk_get_default_root_window (void);
 665
 666 /* Offscreen redirection */
 667 GdkPixmap *gdk_offscreen_window_get_pixmap     (GdkWindow     *window);
 668 void       gdk_offscreen_window_set_embedder   (GdkWindow     *window,
 669                                                 GdkWindow     *embedder);
 670 GdkWindow *gdk_offscreen_window_get_embedder   (GdkWindow     *window);
 671 void       gdk_window_geometry_changed         (GdkWindow     *window);
 672
 673 void       gdk_window_redirect_to_drawable   (GdkWindow     *window,
 674                                               GdkDrawable   *drawable,
 675                                               gint           src_x,
 676                                               gint           src_y,
 677                                               gint           dest_x,
 678                                               gint           dest_y,
 679                                               gint           width,
 680                                               gint           height);
 681 void       gdk_window_remove_redirection     (GdkWindow     *window);
 682
 683 #ifndef GDK_DISABLE_DEPRECATED
 684 #define GDK_ROOT_PARENT()             (gdk_get_default_root_window ())
 685 #define gdk_window_get_size            gdk_drawable_get_size
 686 #define gdk_window_get_type            gdk_window_get_window_type
 687 #define gdk_window_get_colormap        gdk_drawable_get_colormap
 688 #define gdk_window_set_colormap        gdk_drawable_set_colormap
 689 #define gdk_window_get_visual          gdk_drawable_get_visual
 690 #define gdk_window_ref                 gdk_drawable_ref
 691 #define gdk_window_unref               gdk_drawable_unref
 692
 693 #define gdk_window_copy_area(drawable,gc,x,y,source_drawable,source_x,source_y,width,height) \
 694    gdk_draw_pixmap(drawable,gc,source_drawable,source_x,source_y,x,y,width,height)
 695 #endif /* GDK_DISABLE_DEPRECATED */
 696
 697 G_END_DECLS
 698
 699 #endif /* __GDK_WINDOW_H__ */