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_focus                 (GdkWindow     *window,
 368                                                 guint32        timestamp);
 369 void          gdk_window_set_user_data         (GdkWindow     *window,
 370                                                 gpointer       user_data);
 371 void          gdk_window_set_override_redirect (GdkWindow     *window,
 372                                                 gboolean       override_redirect);
 373 void          gdk_window_set_accept_focus      (GdkWindow     *window,
 374                                                 gboolean       accept_focus);
 375 void          gdk_window_set_focus_on_map      (GdkWindow     *window,
 376                                                 gboolean       focus_on_map);
 377 void          gdk_window_add_filter            (GdkWindow     *window,
 378                                                 GdkFilterFunc  function,
 379                                                 gpointer       data);
 380 void          gdk_window_remove_filter         (GdkWindow     *window,
 381                                                 GdkFilterFunc  function,
 382                                                 gpointer       data);
 383 void          gdk_window_scroll                (GdkWindow     *window,
 384                                                 gint           dx,
 385                                                 gint           dy);
 386 void          gdk_window_move_region           (GdkWindow       *window,
 387                                                 const GdkRegion *region,
 388                                                 gint             dx,
 389                                                 gint             dy);
 390 gboolean      gdk_window_ensure_native        (GdkWindow       *window);
 391
 392 /*
 393  * This allows for making shaped (partially transparent) windows
 394  * - cool feature, needed for Drag and Drag for example.
 395  *  The shape_mask can be the mask
 396  *  from gdk_pixmap_create_from_xpm.   Stefan Wille
 397  */
 398 void gdk_window_shape_combine_mask  (GdkWindow        *window,
 399                                      GdkBitmap        *mask,
 400                                      gint              x,
 401                                      gint              y);
 402 void gdk_window_shape_combine_region (GdkWindow       *window,
 403                                       const GdkRegion *shape_region,
 404                                       gint             offset_x,
 405                                       gint             offset_y);
 406
 407 /*
 408  * This routine allows you to quickly take the shapes of all the child windows
 409  * of a window and use their shapes as the shape mask for this window - useful
 410  * for container windows that dont want to look like a big box
 411  *
 412  * - Raster
 413  */
 414 void gdk_window_set_child_shapes (GdkWindow *window);
 415
 416 void gdk_window_set_composited   (GdkWindow *window,
 417                                   gboolean   composited);
 418
 419 /*
 420  * This routine allows you to merge (ie ADD) child shapes to your
 421  * own window's shape keeping its current shape and ADDING the child
 422  * shapes to it.
 423  *
 424  * - Raster
 425  */
 426 void gdk_window_merge_child_shapes         (GdkWindow       *window);
 427
 428 void gdk_window_input_shape_combine_mask   (GdkWindow       *window,
 429                                             GdkBitmap       *mask,
 430                                             gint             x,
 431                                             gint             y);
 432 void gdk_window_input_shape_combine_region (GdkWindow       *window,
 433                                             const GdkRegion *shape_region,
 434                                             gint             offset_x,
 435                                             gint             offset_y);
 436 void gdk_window_set_child_input_shapes     (GdkWindow       *window);
 437 void gdk_window_merge_child_input_shapes   (GdkWindow       *window);
 438
 439
 440 /*
 441  * Check if a window has been shown, and whether all its
 442  * parents up to a toplevel have been shown, respectively.
 443  * Note that a window that is_viewable below is not necessarily
 444  * viewable in the X sense.
 445  */
 446 gboolean gdk_window_is_visible     (GdkWindow *window);
 447 gboolean gdk_window_is_viewable    (GdkWindow *window);
 448
 449 GdkWindowState gdk_window_get_state (GdkWindow *window);
 450
 451 /* Set static bit gravity on the parent, and static
 452  * window gravity on all children.
 453  */
 454 gboolean gdk_window_set_static_gravities (GdkWindow *window,
 455                                           gboolean   use_static);
 456
 457 /* Functions to create/lookup windows from their native equivalents */
 458 #ifndef GDK_MULTIHEAD_SAFE
 459 GdkWindow*    gdk_window_foreign_new (GdkNativeWindow anid);
 460 GdkWindow*    gdk_window_lookup      (GdkNativeWindow anid);
 461 #endif
 462 GdkWindow    *gdk_window_foreign_new_for_display (GdkDisplay      *display,
 463                                                   GdkNativeWindow  anid);
 464 GdkWindow*    gdk_window_lookup_for_display (GdkDisplay      *display,
 465                                              GdkNativeWindow  anid);
 466
 467
 468 /* GdkWindow */
 469
 470 #ifndef GDK_DISABLE_DEPRECATED
 471 void          gdk_window_set_hints       (GdkWindow       *window,
 472                                           gint             x,
 473                                           gint             y,
 474                                           gint             min_width,
 475                                           gint             min_height,
 476                                           gint             max_width,
 477                                           gint             max_height,
 478                                           gint             flags);
 479 #endif
 480 void              gdk_window_set_type_hint (GdkWindow        *window,
 481                                             GdkWindowTypeHint hint);
 482 GdkWindowTypeHint gdk_window_get_type_hint (GdkWindow        *window);
 483
 484 void          gdk_window_set_modal_hint   (GdkWindow       *window,
 485                                            gboolean         modal);
 486
 487 void gdk_window_set_skip_taskbar_hint (GdkWindow *window,
 488                                        gboolean   skips_taskbar);
 489 void gdk_window_set_skip_pager_hint   (GdkWindow *window,
 490                                        gboolean   skips_pager);
 491 void gdk_window_set_urgency_hint      (GdkWindow *window,
 492                                        gboolean   urgent);
 493
 494 void          gdk_window_set_geometry_hints (GdkWindow          *window,
 495                                              const GdkGeometry  *geometry,
 496                                              GdkWindowHints      geom_mask);
 497 void          gdk_set_sm_client_id          (const gchar        *sm_client_id);
 498
 499 void          gdk_window_begin_paint_rect   (GdkWindow          *window,
 500                                              const GdkRectangle *rectangle);
 501 void          gdk_window_begin_paint_region (GdkWindow          *window,
 502                                              const GdkRegion    *region);
 503 void          gdk_window_end_paint          (GdkWindow          *window);
 504
 505 void          gdk_window_set_title         (GdkWindow     *window,
 506                                             const gchar   *title);
 507 void          gdk_window_set_role          (GdkWindow       *window,
 508                                             const gchar     *role);
 509 void          gdk_window_set_startup_id    (GdkWindow       *window,
 510                                             const gchar     *startup_id);
 511 void          gdk_window_set_transient_for (GdkWindow       *window,
 512                                             GdkWindow       *parent);
 513 void          gdk_window_set_background  (GdkWindow       *window,
 514                                           const GdkColor  *color);
 515 void          gdk_window_set_back_pixmap (GdkWindow       *window,
 516                                           GdkPixmap       *pixmap,
 517                                           gboolean         parent_relative);
 518 void          gdk_window_set_cursor      (GdkWindow       *window,
 519                                           GdkCursor       *cursor);
 520 void          gdk_window_get_user_data   (GdkWindow       *window,
 521                                           gpointer        *data);
 522 void          gdk_window_get_geometry    (GdkWindow       *window,
 523                                           gint            *x,
 524                                           gint            *y,
 525                                           gint            *width,
 526                                           gint            *height,
 527                                           gint            *depth);
 528 void          gdk_window_get_position    (GdkWindow       *window,
 529                                           gint            *x,
 530                                           gint            *y);
 531 gint          gdk_window_get_origin      (GdkWindow       *window,
 532                                           gint            *x,
 533                                           gint            *y);
 534 gint          gdk_window_get_root_coords (GdkWindow       *window,
 535                                           gint             x,
 536                                           gint             y,
 537                                           gint            *root_x,
 538                                           gint            *root_y);
 539
 540 #if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION)
 541 /* Used by gtk_handle_box_button_changed () */
 542 gboolean      gdk_window_get_deskrelative_origin (GdkWindow       *window,
 543                                           gint            *x,
 544                                           gint            *y);
 545 #endif
 546
 547 void          gdk_window_get_root_origin (GdkWindow       *window,
 548                                           gint            *x,
 549                                           gint            *y);
 550 void          gdk_window_get_frame_extents (GdkWindow     *window,
 551                                             GdkRectangle  *rect);
 552 GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
 553                                           gint            *x,
 554                                           gint            *y,
 555                                           GdkModifierType *mask);
 556 GdkWindow *   gdk_window_get_parent      (GdkWindow       *window);
 557 GdkWindow *   gdk_window_get_toplevel    (GdkWindow       *window);
 558
 559 GList *       gdk_window_get_children    (GdkWindow       *window);
 560 GList *       gdk_window_peek_children   (GdkWindow       *window);
 561 GdkEventMask  gdk_window_get_events      (GdkWindow       *window);
 562 void          gdk_window_set_events      (GdkWindow       *window,
 563                                           GdkEventMask     event_mask);
 564
 565 void          gdk_window_set_icon_list   (GdkWindow       *window,
 566                                           GList           *pixbufs);
 567 void          gdk_window_set_icon        (GdkWindow       *window,
 568                                           GdkWindow       *icon_window,
 569                                           GdkPixmap       *pixmap,
 570                                           GdkBitmap       *mask);
 571 void          gdk_window_set_icon_name   (GdkWindow       *window,
 572                                           const gchar     *name);
 573 void          gdk_window_set_group       (GdkWindow       *window,
 574                                           GdkWindow       *leader);
 575 GdkWindow*    gdk_window_get_group       (GdkWindow       *window);
 576 void          gdk_window_set_decorations (GdkWindow       *window,
 577                                           GdkWMDecoration  decorations);
 578 gboolean      gdk_window_get_decorations (GdkWindow       *window,
 579                                           GdkWMDecoration *decorations);
 580 void          gdk_window_set_functions   (GdkWindow       *window,
 581                                           GdkWMFunction    functions);
 582 #if !defined(GDK_MULTIHEAD_SAFE) && !defined(GDK_DISABLE_DEPRECATED)
 583 GList *       gdk_window_get_toplevels   (void);
 584 #endif
 585
 586 void          gdk_window_beep            (GdkWindow       *window);
 587 void          gdk_window_iconify         (GdkWindow       *window);
 588 void          gdk_window_deiconify       (GdkWindow       *window);
 589 void          gdk_window_stick           (GdkWindow       *window);
 590 void          gdk_window_unstick         (GdkWindow       *window);
 591 void          gdk_window_maximize        (GdkWindow       *window);
 592 void          gdk_window_unmaximize      (GdkWindow       *window);
 593 void          gdk_window_fullscreen      (GdkWindow       *window);
 594 void          gdk_window_unfullscreen    (GdkWindow       *window);
 595 void          gdk_window_set_keep_above  (GdkWindow       *window,
 596                                           gboolean         setting);
 597 void          gdk_window_set_keep_below  (GdkWindow       *window,
 598                                           gboolean         setting);
 599 void          gdk_window_set_opacity     (GdkWindow       *window,
 600                                           gdouble          opacity);
 601 void          gdk_window_register_dnd    (GdkWindow       *window);
 602
 603 void gdk_window_begin_resize_drag (GdkWindow     *window,
 604                                    GdkWindowEdge  edge,
 605                                    gint           button,
 606                                    gint           root_x,
 607                                    gint           root_y,
 608                                    guint32        timestamp);
 609 void gdk_window_begin_move_drag   (GdkWindow     *window,
 610                                    gint           button,
 611                                    gint           root_x,
 612                                    gint           root_y,
 613                                    guint32        timestamp);
 614
 615 /* Interface for dirty-region queueing */
 616 void       gdk_window_invalidate_rect           (GdkWindow          *window,
 617                                                  const GdkRectangle *rect,
 618                                                  gboolean            invalidate_children);
 619 void       gdk_window_invalidate_region         (GdkWindow          *window,
 620                                                  const GdkRegion    *region,
 621                                                  gboolean            invalidate_children);
 622 void       gdk_window_invalidate_maybe_recurse  (GdkWindow          *window,
 623                                                  const GdkRegion    *region,
 624                                                  gboolean (*child_func) (GdkWindow *, gpointer),
 625                                                  gpointer   user_data);
 626 GdkRegion *gdk_window_get_update_area     (GdkWindow    *window);
 627
 628 void       gdk_window_freeze_updates      (GdkWindow    *window);
 629 void       gdk_window_thaw_updates        (GdkWindow    *window);
 630
 631 void       gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window);
 632 void       gdk_window_thaw_toplevel_updates_libgtk_only   (GdkWindow *window);
 633
 634 void       gdk_window_process_all_updates (void);
 635 void       gdk_window_process_updates     (GdkWindow    *window,
 636                                            gboolean      update_children);
 637
 638 /* Enable/disable flicker, so you can tell if your code is inefficient. */
 639 void       gdk_window_set_debug_updates   (gboolean      setting);
 640
 641 void       gdk_window_constrain_size      (GdkGeometry  *geometry,
 642                                            guint         flags,
 643                                            gint          width,
 644                                            gint          height,
 645                                            gint         *new_width,
 646                                            gint         *new_height);
 647
 648 void gdk_window_get_internal_paint_info (GdkWindow    *window,
 649                                          GdkDrawable **real_drawable,
 650                                          gint         *x_offset,
 651                                          gint         *y_offset);
 652
 653 void gdk_window_enable_synchronized_configure (GdkWindow *window);
 654 void gdk_window_configure_finished            (GdkWindow *window);
 655
 656 #ifndef GDK_MULTIHEAD_SAFE
 657 GdkPointerHooks *gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
 658 #endif /* GDK_MULTIHEAD_SAFE */
 659
 660 GdkWindow *gdk_get_default_root_window (void);
 661
 662 /* Offscreen redirection */
 663 GdkPixmap *gdk_window_get_offscreen_pixmap   (GdkWindow     *window);
 664 void       gdk_window_set_has_offscreen_children (GdkWindow     *window,
 665                                                   gboolean       has_offscreen_children);
 666 gboolean   gdk_window_get_has_offscreen_children (GdkWindow     *window);
 667 void       gdk_window_offscreen_children_changed (GdkWindow     *window);
 668
 669 void       gdk_window_redirect_to_drawable   (GdkWindow     *window,
 670                                               GdkDrawable   *drawable,
 671                                               gint           src_x,
 672                                               gint           src_y,
 673                                               gint           dest_x,
 674                                               gint           dest_y,
 675                                               gint           width,
 676                                               gint           height);
 677 void       gdk_window_remove_redirection     (GdkWindow     *window);
 678
 679 #ifndef GDK_DISABLE_DEPRECATED
 680 #define GDK_ROOT_PARENT()             (gdk_get_default_root_window ())
 681 #define gdk_window_get_size            gdk_drawable_get_size
 682 #define gdk_window_get_type            gdk_window_get_window_type
 683 #define gdk_window_get_colormap        gdk_drawable_get_colormap
 684 #define gdk_window_set_colormap        gdk_drawable_set_colormap
 685 #define gdk_window_get_visual          gdk_drawable_get_visual
 686 #define gdk_window_ref                 gdk_drawable_ref
 687 #define gdk_window_unref               gdk_drawable_unref
 688
 689 #define gdk_window_copy_area(drawable,gc,x,y,source_drawable,source_x,source_y,width,height) \
 690    gdk_draw_pixmap(drawable,gc,source_drawable,source_x,source_y,x,y,width,height)
 691 #endif /* GDK_DISABLE_DEPRECATED */
 692
 693 G_END_DECLS
 694
 695 #endif /* __GDK_WINDOW_H__ */