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 (__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 /**
  46  * GdkWindowClass:
  47  * @GDK_INPUT_OUTPUT: window for graphics and events
  48  * @GDK_INPUT_ONLY: window for events only
  49  *
  50  * @GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
  51  * Such windows receive events and are also displayed on screen.
  52  * @GDK_INPUT_ONLY windows are invisible; they are usually placed above other
  53  * windows in order to trap or filter the events. You can't draw on
  54  * @GDK_INPUT_ONLY windows.
  55  */
  56 typedef enum
  57 {
  58   GDK_INPUT_OUTPUT,
  59   GDK_INPUT_ONLY
  60 } GdkWindowClass;
  61
  62 /**
  63  * GdkWindowType:
  64  * @GDK_WINDOW_ROOT: root window; this window has no parent, covers the entire
  65  *  screen, and is created by the window system
  66  * @GDK_WINDOW_TOPLEVEL: toplevel window (used to implement #GtkWindow)
  67  * @GDK_WINDOW_CHILD: child window (used to implement e.g. #GtkEntry)
  68  * @GDK_WINDOW_DIALOG: useless/deprecated compatibility type
  69  * @GDK_WINDOW_TEMP: override redirect temporary window (used to implement
  70  *  #GtkMenu)
  71  * @GDK_WINDOW_FOREIGN: foreign window (see gdk_window_foreign_new())
  72  * @GDK_WINDOW_OFFSCREEN: offscreen window (see
  73  *  <xref linkend="OFFSCREEN-WINDOWS"/>). Since 2.18
  74  *
  75  * Describes the kind of window.
  76  */
  77 typedef enum
  78 {
  79   GDK_WINDOW_ROOT,
  80   GDK_WINDOW_TOPLEVEL,
  81   GDK_WINDOW_CHILD,
  82   GDK_WINDOW_DIALOG,
  83   GDK_WINDOW_TEMP,
  84   GDK_WINDOW_FOREIGN,
  85   GDK_WINDOW_OFFSCREEN
  86 } GdkWindowType;
  87
  88 /**
  89  * GdkWindowAttributesType:
  90  * @GDK_WA_TITLE: Honor the title field
  91  * @GDK_WA_X: Honor the X coordinate field
  92  * @GDK_WA_Y: Honor the Y coordinate field
  93  * @GDK_WA_CURSOR: Honor the cursor field
  94  * @GDK_WA_COLORMAP: Honor the colormap field
  95  * @GDK_WA_VISUAL: Honor the visual field
  96  * @GDK_WA_WMCLASS: Honor the wmclass_class and wmclass_name fields
  97  * @GDK_WA_NOREDIR: Honor the override_redirect field
  98  * @GDK_WA_TYPE_HINT: Honor the type_hint field
  99  *
 100  * Used to indicate which fields in the #GdkWindowAttr struct should be honored.
 101  * For example, if you filled in the "cursor" and "x" fields of #GdkWindowAttr,
 102  * pass "@GDK_WA_X | @GDK_WA_CURSOR" to gdk_window_new(). Fields in
 103  * #GdkWindowAttr not covered by a bit in this enum are required; for example,
 104  * the @width/@height, @wclass, and @window_type fields are required, they have
 105  * no corresponding flag in #GdkWindowAttributesType.
 106  */
 107 typedef enum
 108 {
 109   GDK_WA_TITLE     = 1 << 1,
 110   GDK_WA_X         = 1 << 2,
 111   GDK_WA_Y         = 1 << 3,
 112   GDK_WA_CURSOR    = 1 << 4,
 113   GDK_WA_COLORMAP  = 1 << 5,
 114   GDK_WA_VISUAL    = 1 << 6,
 115   GDK_WA_WMCLASS   = 1 << 7,
 116   GDK_WA_NOREDIR   = 1 << 8,
 117   GDK_WA_TYPE_HINT = 1 << 9
 118 } GdkWindowAttributesType;
 119
 120 /* Size restriction enumeration.
 121  */
 122 /**
 123  * GdkWindowHints:
 124  * @GDK_HINT_POS: indicates that the program has positioned the window
 125  * @GDK_HINT_MIN_SIZE: min size fields are set
 126  * @GDK_HINT_MAX_SIZE: max size fields are set
 127  * @GDK_HINT_BASE_SIZE: base size fields are set
 128  * @GDK_HINT_ASPECT: aspect ratio fields are set
 129  * @GDK_HINT_RESIZE_INC: resize increment fields are set
 130  * @GDK_HINT_WIN_GRAVITY: window gravity field is set
 131  * @GDK_HINT_USER_POS: indicates that the window's position was explicitly set
 132  *  by the user
 133  * @GDK_HINT_USER_SIZE: indicates that the window's size was explicitly set by
 134  *  the user
 135  *
 136  * Used to indicate which fields of a #GdkGeometry struct should be paid
 137  * attention to. Also, the presence/absence of @GDK_HINT_POS,
 138  * @GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't
 139  * directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set
 140  * automatically by #GtkWindow if you call gtk_window_move().
 141  * @GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user
 142  * specified a size/position using a --geometry command-line argument;
 143  * gtk_window_parse_geometry() automatically sets these flags.
 144  */
 145 typedef enum
 146 {
 147   GDK_HINT_POS         = 1 << 0,
 148   GDK_HINT_MIN_SIZE    = 1 << 1,
 149   GDK_HINT_MAX_SIZE    = 1 << 2,
 150   GDK_HINT_BASE_SIZE   = 1 << 3,
 151   GDK_HINT_ASPECT      = 1 << 4,
 152   GDK_HINT_RESIZE_INC  = 1 << 5,
 153   GDK_HINT_WIN_GRAVITY = 1 << 6,
 154   GDK_HINT_USER_POS    = 1 << 7,
 155   GDK_HINT_USER_SIZE   = 1 << 8
 156 } GdkWindowHints;
 157
 158
 159 /**
 160  * GdkWindowTypeHint:
 161  * @GDK_WINDOW_TYPE_HINT_NORMAL: Normal toplevel window.
 162  * @GDK_WINDOW_TYPE_HINT_DIALOG: Dialog window.
 163  * @GDK_WINDOW_TYPE_HINT_MENU: Window used to implement a menu; GTK+ uses
 164  *  this hint only for torn-off menus, see #GtkTearoffMenuItem.
 165  * @GDK_WINDOW_TYPE_HINT_TOOLBAR: Window used to implement toolbars.
 166  * @GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: Window used to display a splash
 167  *  screen during application startup.
 168  * @GDK_WINDOW_TYPE_HINT_UTILITY: Utility windows which are not detached
 169  *  toolbars or dialogs.
 170  * @GDK_WINDOW_TYPE_HINT_DOCK: Used for creating dock or panel windows.
 171  * @GDK_WINDOW_TYPE_HINT_DESKTOP: Used for creating the desktop background
 172  *  window.
 173  * @GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: A menu that belongs to a menubar.
 174  * @GDK_WINDOW_TYPE_HINT_POPUP_MENU: A menu that does not belong to a menubar,
 175  *  e.g. a context menu.
 176  * @GDK_WINDOW_TYPE_HINT_TOOLTIP: A tooltip.
 177  * @GDK_WINDOW_TYPE_HINT_NOTIFICATION: A notification - typically a "bubble"
 178  *  that belongs to a status icon.
 179  * @GDK_WINDOW_TYPE_HINT_COMBO: A popup from a combo box.
 180  * @GDK_WINDOW_TYPE_HINT_DND: A window that is used to implement a DND cursor.
 181  *
 182  * These are hints for the window manager that indicate what type of function
 183  * the window has. The window manager can use this when determining decoration
 184  * and behaviour of the window. The hint must be set before mapping the window.
 185  *
 186  * See the
 187  * <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
 188  * Window Manager Hints</ulink> specification for more details about
 189  * window types.
 190  */
 191 typedef enum
 192 {
 193   GDK_WINDOW_TYPE_HINT_NORMAL,
 194   GDK_WINDOW_TYPE_HINT_DIALOG,
 195   GDK_WINDOW_TYPE_HINT_MENU,            /* Torn off menu */
 196   GDK_WINDOW_TYPE_HINT_TOOLBAR,
 197   GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
 198   GDK_WINDOW_TYPE_HINT_UTILITY,
 199   GDK_WINDOW_TYPE_HINT_DOCK,
 200   GDK_WINDOW_TYPE_HINT_DESKTOP,
 201   GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,   /* A drop down menu (from a menubar) */
 202   GDK_WINDOW_TYPE_HINT_POPUP_MENU,      /* A popup menu (from right-click) */
 203   GDK_WINDOW_TYPE_HINT_TOOLTIP,
 204   GDK_WINDOW_TYPE_HINT_NOTIFICATION,
 205   GDK_WINDOW_TYPE_HINT_COMBO,
 206   GDK_WINDOW_TYPE_HINT_DND
 207 } GdkWindowTypeHint;
 208
 209 /* The next two enumeration values current match the
 210  * Motif constants. If this is changed, the implementation
 211  * of gdk_window_set_decorations/gdk_window_set_functions
 212  * will need to change as well.
 213  */
 214 /**
 215  * GdkWMDecoration:
 216  * @GDK_DECOR_ALL: all decorations should be applied.
 217  * @GDK_DECOR_BORDER: a frame should be drawn around the window.
 218  * @GDK_DECOR_RESIZEH: the frame should have resize handles.
 219  * @GDK_DECOR_TITLE: a titlebar should be placed above the window.
 220  * @GDK_DECOR_MENU: a button for opening a menu should be included.
 221  * @GDK_DECOR_MINIMIZE: a minimize button should be included.
 222  * @GDK_DECOR_MAXIMIZE: a maximize button should be included.
 223  *
 224  * These are hints originally defined by the Motif toolkit.
 225  * The window manager can use them when determining how to decorate
 226  * the window. The hint must be set before mapping the window.
 227  */
 228 typedef enum
 229 {
 230   GDK_DECOR_ALL         = 1 << 0,
 231   GDK_DECOR_BORDER      = 1 << 1,
 232   GDK_DECOR_RESIZEH     = 1 << 2,
 233   GDK_DECOR_TITLE       = 1 << 3,
 234   GDK_DECOR_MENU        = 1 << 4,
 235   GDK_DECOR_MINIMIZE    = 1 << 5,
 236   GDK_DECOR_MAXIMIZE    = 1 << 6
 237 } GdkWMDecoration;
 238
 239 /**
 240  * GdkWMFunction:
 241  * @GDK_FUNC_ALL: all functions should be offered.
 242  * @GDK_FUNC_RESIZE: the window should be resizable.
 243  * @GDK_FUNC_MOVE: the window should be movable.
 244  * @GDK_FUNC_MINIMIZE: the window should be minimizable.
 245  * @GDK_FUNC_MAXIMIZE: the window should be maximizable.
 246  * @GDK_FUNC_CLOSE: the window should be closable.
 247  *
 248  * These are hints originally defined by the Motif toolkit. The window manager
 249  * can use them when determining the functions to offer for the window. The
 250  * hint must be set before mapping the window.
 251  */
 252 typedef enum
 253 {
 254   GDK_FUNC_ALL          = 1 << 0,
 255   GDK_FUNC_RESIZE       = 1 << 1,
 256   GDK_FUNC_MOVE         = 1 << 2,
 257   GDK_FUNC_MINIMIZE     = 1 << 3,
 258   GDK_FUNC_MAXIMIZE     = 1 << 4,
 259   GDK_FUNC_CLOSE        = 1 << 5
 260 } GdkWMFunction;
 261
 262 /* Currently, these are the same values numerically as in the
 263  * X protocol. If you change that, gdkwindow-x11.c/gdk_window_set_geometry_hints()
 264  * will need fixing.
 265  */
 266 /**
 267  * GdkGravity:
 268  * @GDK_GRAVITY_NORTH_WEST: the reference point is at the top left corner.
 269  * @GDK_GRAVITY_NORTH: the reference point is in the middle of the top edge.
 270  * @GDK_GRAVITY_NORTH_EAST: the reference point is at the top right corner.
 271  * @GDK_GRAVITY_WEST: the reference point is at the middle of the left edge.
 272  * @GDK_GRAVITY_CENTER: the reference point is at the center of the window.
 273  * @GDK_GRAVITY_EAST: the reference point is at the middle of the right edge.
 274  * @GDK_GRAVITY_SOUTH_WEST: the reference point is at the lower left corner.
 275  * @GDK_GRAVITY_SOUTH: the reference point is at the middle of the lower edge.
 276  * @GDK_GRAVITY_SOUTH_EAST: the reference point is at the lower right corner.
 277  * @GDK_GRAVITY_STATIC: the reference point is at the top left corner of the
 278  *  window itself, ignoring window manager decorations.
 279  *
 280  * Defines the reference point of a window and the meaning of coordinates
 281  * passed to gtk_window_move(). See gtk_window_move() and the "implementation
 282  * notes" section of the
 283  * <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
 284  * Window Manager Hints</ulink> specification for more details.
 285  */
 286 typedef enum
 287 {
 288   GDK_GRAVITY_NORTH_WEST = 1,
 289   GDK_GRAVITY_NORTH,
 290   GDK_GRAVITY_NORTH_EAST,
 291   GDK_GRAVITY_WEST,
 292   GDK_GRAVITY_CENTER,
 293   GDK_GRAVITY_EAST,
 294   GDK_GRAVITY_SOUTH_WEST,
 295   GDK_GRAVITY_SOUTH,
 296   GDK_GRAVITY_SOUTH_EAST,
 297   GDK_GRAVITY_STATIC
 298 } GdkGravity;
 299
 300
 301 /**
 302  * GdkWindowEdge:
 303  * @GDK_WINDOW_EDGE_NORTH_WEST: the top left corner.
 304  * @GDK_WINDOW_EDGE_NORTH: the top edge.
 305  * @GDK_WINDOW_EDGE_NORTH_EAST: the top right corner.
 306  * @GDK_WINDOW_EDGE_WEST: the left edge.
 307  * @GDK_WINDOW_EDGE_EAST: the right edge.
 308  * @GDK_WINDOW_EDGE_SOUTH_WEST: the lower left corner.
 309  * @GDK_WINDOW_EDGE_SOUTH: the lower edge.
 310  * @GDK_WINDOW_EDGE_SOUTH_EAST: the lower right corner.
 311  *
 312  * Determines a window edge or corner.
 313  */
 314 typedef enum
 315 {
 316   GDK_WINDOW_EDGE_NORTH_WEST,
 317   GDK_WINDOW_EDGE_NORTH,
 318   GDK_WINDOW_EDGE_NORTH_EAST,
 319   GDK_WINDOW_EDGE_WEST,
 320   GDK_WINDOW_EDGE_EAST,
 321   GDK_WINDOW_EDGE_SOUTH_WEST,
 322   GDK_WINDOW_EDGE_SOUTH,
 323   GDK_WINDOW_EDGE_SOUTH_EAST
 324 } GdkWindowEdge;
 325
 326 /**
 327  * GdkWindowAttr:
 328  * @title: title of the window (for toplevel windows)
 329  * @event_mask: event mask (see gdk_window_set_events())
 330  * @x: X coordinate relative to parent window (see gdk_window_move())
 331  * @y: Y coordinate relative to parent window (see gdk_window_move())
 332  * @width: width of window
 333  * @height: height of window
 334  * @wclass: #GDK_INPUT_OUTPUT (normal window) or #GDK_INPUT_ONLY (invisible
 335  *  window that receives events)
 336  * @visual: #GdkVisual for window
 337  * @colormap: #GdkColormap for window
 338  * @window_type: type of window
 339  * @cursor: cursor for the window (see gdk_window_set_cursor())
 340  * @wmclass_name: don't use (see gtk_window_set_wmclass())
 341  * @wmclass_class: don't use (see gtk_window_set_wmclass())
 342  * @override_redirect: %TRUE to bypass the window manager
 343  * @type_hint: a hint of the function of the window
 344  *
 345  * Attributes to use for a newly-created window.
 346  */
 347 struct _GdkWindowAttr
 348 {
 349   gchar *title;
 350   gint event_mask;
 351   gint x, y;
 352   gint width;
 353   gint height;
 354   GdkWindowClass wclass;
 355   GdkVisual *visual;
 356   GdkColormap *colormap;
 357   GdkWindowType window_type;
 358   GdkCursor *cursor;
 359   gchar *wmclass_name;
 360   gchar *wmclass_class;
 361   gboolean override_redirect;
 362   GdkWindowTypeHint type_hint;
 363 };
 364
 365 /**
 366  * GdkGeometry:
 367  * @min_width: minimum width of window (or -1 to use requisition, with
 368  *  #GtkWindow only)
 369  * @min_height: minimum height of window (or -1 to use requisition, with
 370  *  #GtkWindow only)
 371  * @max_width: maximum width of window (or -1 to use requisition, with
 372  *  #GtkWindow only)
 373  * @max_height: maximum height of window (or -1 to use requisition, with
 374  *  #GtkWindow only)
 375  * @base_width: allowed window widths are @base_width + @width_inc * N where N
 376  *  is any integer (-1 allowed with #GtkWindow)
 377  * @base_height: allowed window widths are @base_height + @height_inc * N where
 378  *  N is any integer (-1 allowed with #GtkWindow)
 379  * @width_inc: width resize increment
 380  * @height_inc: height resize increment
 381  * @min_aspect: minimum width/height ratio
 382  * @max_aspect: maximum width/height ratio
 383  * @win_gravity: window gravity, see gtk_window_set_gravity()
 384  *
 385  * The #GdkGeometry struct gives the window manager information about
 386  * a window's geometry constraints. Normally you would set these on
 387  * the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow
 388  * then sets the hints on the #GdkWindow it creates.
 389  *
 390  * gdk_window_set_geometry_hints() expects the hints to be fully valid already
 391  * and simply passes them to the window manager; in contrast,
 392  * gtk_window_set_geometry_hints() performs some interpretation. For example,
 393  * #GtkWindow will apply the hints to the geometry widget instead of the
 394  * toplevel window, if you set a geometry widget. Also, the
 395  * @min_width/@min_height/@max_width/@max_height fields may be set to -1, and
 396  * #GtkWindow will substitute the size request of the window or geometry widget.
 397  * If the minimum size hint is not provided, #GtkWindow will use its requisition
 398  * as the minimum size. If the minimum size is provided and a geometry widget is
 399  * set, #GtkWindow will take the minimum size as the minimum size of the
 400  * geometry widget rather than the entire window. The base size is treated
 401  * similarly.
 402  *
 403  * The canonical use-case for gtk_window_set_geometry_hints() is to get a
 404  * terminal widget to resize properly. Here, the terminal text area should be
 405  * the geometry widget; #GtkWindow will then automatically set the base size to
 406  * the size of other widgets in the terminal window, such as the menubar and
 407  * scrollbar. Then, the @width_inc and @height_inc fields should be set to the
 408  * size of one character in the terminal. Finally, the base size should be set
 409  * to the size of one character. The net effect is that the minimum size of the
 410  * terminal will have a 1x1 character terminal area, and only terminal sizes on
 411  * the "character grid" will be allowed.
 412  *
 413  * Here's an example of how the terminal example would be implemented, assuming
 414  * a terminal area widget called "terminal" and a toplevel window "toplevel":
 415  *
 416  * <informalexample><programlisting><![CDATA[
 417  *      GdkGeometry hints;
 418  *
 419  *      hints.base_width = terminal->char_width;
 420  *         hints.base_height = terminal->char_height;
 421  *         hints.min_width = terminal->char_width;
 422  *         hints.min_height = terminal->char_height;
 423  *         hints.width_inc = terminal->char_width;
 424  *         hints.height_inc = terminal->char_height;
 425  *
 426  *  gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),
 427  *                                 GTK_WIDGET (terminal),
 428  *                                 &hints,
 429  *                                 GDK_HINT_RESIZE_INC |
 430  *                                 GDK_HINT_MIN_SIZE |
 431  *                                 GDK_HINT_BASE_SIZE);
 432  * ]]></programlisting></informalexample>
 433  *
 434  * The other useful fields are the @min_aspect and @max_aspect fields; these
 435  * contain a width/height ratio as a floating point number. If a geometry widget
 436  * is set, the aspect applies to the geometry widget rather than the entire
 437  * window. The most common use of these hints is probably to set @min_aspect and
 438  * @max_aspect to the same value, thus forcing the window to keep a constant
 439  * aspect ratio.
 440  */
 441 struct _GdkGeometry
 442 {
 443   gint min_width;
 444   gint min_height;
 445   gint max_width;
 446   gint max_height;
 447   gint base_width;
 448   gint base_height;
 449   gint width_inc;
 450   gint height_inc;
 451   gdouble min_aspect;
 452   gdouble max_aspect;
 453   GdkGravity win_gravity;
 454 };
 455
 456 /**
 457  * GdkPointerHooks:
 458  * @get_pointer: Obtains the current pointer position and modifier state.
 459  *  The position is given in coordinates relative to the window containing
 460  *  the pointer, which is returned in @window.
 461  * @window_at_pointer: Obtains the window underneath the mouse pointer,
 462  *  returning the location of that window in @win_x, @win_y. Returns %NULL
 463  *  if the window under the mouse pointer is not known to GDK (for example,
 464  *  belongs to another application).
 465  *
 466  * A table of pointers to functions for getting quantities related to
 467  * the current pointer position. GDK has one global table of this type,
 468  * which can be set using gdk_set_pointer_hooks().
 469  *
 470  * This is only useful for such low-level tools as an event recorder.
 471  * Applications should never have any reason to use this facility
 472  */
 473 struct _GdkPointerHooks
 474 {
 475   GdkWindow* (*get_pointer)       (GdkWindow       *window,
 476                                    gint            *x,
 477                                    gint            *y,
 478                                    GdkModifierType *mask);
 479   GdkWindow* (*window_at_pointer) (GdkScreen       *screen, /* unused */
 480                                    gint            *win_x,
 481                                    gint            *win_y);
 482 };
 483
 484 typedef struct _GdkWindowObject GdkWindowObject;
 485 typedef struct _GdkWindowObjectClass GdkWindowObjectClass;
 486
 487 #define GDK_TYPE_WINDOW              (gdk_window_object_get_type ())
 488 #define GDK_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW, GdkWindow))
 489 #define GDK_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW, GdkWindowObjectClass))
 490 #define GDK_IS_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
 491 #define GDK_IS_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
 492 #define GDK_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowObjectClass))
 493
 494
 495 struct _GdkWindowObjectClass
 496 {
 497   GdkDrawableClass parent_class;
 498 };
 499
 500 /* Windows
 501  */
 502 GType         gdk_window_object_get_type       (void) G_GNUC_CONST;
 503 GdkWindow*    gdk_window_new                   (GdkWindow     *parent,
 504                                                 GdkWindowAttr *attributes,
 505                                                 gint           attributes_mask);
 506 void          gdk_window_destroy               (GdkWindow     *window);
 507 GdkWindowType gdk_window_get_window_type       (GdkWindow     *window);
 508 gboolean      gdk_window_is_destroyed          (GdkWindow     *window);
 509
 510 #ifndef GDK_MULTIDEVICE_SAFE
 511 GdkWindow*    gdk_window_at_pointer            (gint          *win_x,
 512                                                 gint          *win_y);
 513 #endif /* GDK_MULTIDEVICE_SAFE */
 514 void          gdk_window_show                  (GdkWindow     *window);
 515 void          gdk_window_hide                  (GdkWindow     *window);
 516 void          gdk_window_withdraw              (GdkWindow     *window);
 517 void          gdk_window_show_unraised         (GdkWindow     *window);
 518 void          gdk_window_move                  (GdkWindow     *window,
 519                                                 gint           x,
 520                                                 gint           y);
 521 void          gdk_window_resize                (GdkWindow     *window,
 522                                                 gint           width,
 523                                                 gint           height);
 524 void          gdk_window_move_resize           (GdkWindow     *window,
 525                                                 gint           x,
 526                                                 gint           y,
 527                                                 gint           width,
 528                                                 gint           height);
 529 void          gdk_window_reparent              (GdkWindow     *window,
 530                                                 GdkWindow     *new_parent,
 531                                                 gint           x,
 532                                                 gint           y);
 533 void          gdk_window_clear                 (GdkWindow     *window);
 534 void          gdk_window_clear_area            (GdkWindow     *window,
 535                                                 gint           x,
 536                                                 gint           y,
 537                                                 gint           width,
 538                                                 gint           height);
 539 void          gdk_window_clear_area_e          (GdkWindow     *window,
 540                                                 gint           x,
 541                                                 gint           y,
 542                                                 gint           width,
 543                                                 gint           height);
 544 void          gdk_window_raise                 (GdkWindow     *window);
 545 void          gdk_window_lower                 (GdkWindow     *window);
 546 void          gdk_window_restack               (GdkWindow     *window,
 547                                                 GdkWindow     *sibling,
 548                                                 gboolean       above);
 549 void          gdk_window_focus                 (GdkWindow     *window,
 550                                                 guint32        timestamp);
 551 void          gdk_window_set_user_data         (GdkWindow     *window,
 552                                                 gpointer       user_data);
 553 void          gdk_window_set_override_redirect (GdkWindow     *window,
 554                                                 gboolean       override_redirect);
 555 gboolean      gdk_window_get_accept_focus      (GdkWindow     *window);
 556 void          gdk_window_set_accept_focus      (GdkWindow     *window,
 557                                                 gboolean       accept_focus);
 558 gboolean      gdk_window_get_focus_on_map      (GdkWindow     *window);
 559 void          gdk_window_set_focus_on_map      (GdkWindow     *window,
 560                                                 gboolean       focus_on_map);
 561 void          gdk_window_add_filter            (GdkWindow     *window,
 562                                                 GdkFilterFunc  function,
 563                                                 gpointer       data);
 564 void          gdk_window_remove_filter         (GdkWindow     *window,
 565                                                 GdkFilterFunc  function,
 566                                                 gpointer       data);
 567 void          gdk_window_scroll                (GdkWindow     *window,
 568                                                 gint           dx,
 569                                                 gint           dy);
 570 void          gdk_window_move_region           (GdkWindow       *window,
 571                                                 const cairo_region_t *region,
 572                                                 gint             dx,
 573                                                 gint             dy);
 574 gboolean      gdk_window_ensure_native        (GdkWindow       *window);
 575
 576 /*
 577  * This allows for making shaped (partially transparent) windows
 578  * - cool feature, needed for Drag and Drag for example.
 579  */
 580 void gdk_window_shape_combine_mask  (GdkWindow        *window,
 581                                      GdkBitmap        *mask,
 582                                      gint              x,
 583                                      gint              y);
 584 void gdk_window_shape_combine_region (GdkWindow       *window,
 585                                       const cairo_region_t *shape_region,
 586                                       gint             offset_x,
 587                                       gint             offset_y);
 588
 589 /*
 590  * This routine allows you to quickly take the shapes of all the child windows
 591  * of a window and use their shapes as the shape mask for this window - useful
 592  * for container windows that dont want to look like a big box
 593  *
 594  * - Raster
 595  */
 596 void gdk_window_set_child_shapes (GdkWindow *window);
 597
 598 gboolean gdk_window_get_composited (GdkWindow *window);
 599 void gdk_window_set_composited   (GdkWindow *window,
 600                                   gboolean   composited);
 601
 602 /*
 603  * This routine allows you to merge (ie ADD) child shapes to your
 604  * own window's shape keeping its current shape and ADDING the child
 605  * shapes to it.
 606  *
 607  * - Raster
 608  */
 609 void gdk_window_merge_child_shapes         (GdkWindow       *window);
 610
 611 void gdk_window_input_shape_combine_mask   (GdkWindow       *window,
 612                                             GdkBitmap       *mask,
 613                                             gint             x,
 614                                             gint             y);
 615 void gdk_window_input_shape_combine_region (GdkWindow       *window,
 616                                             const cairo_region_t *shape_region,
 617                                             gint             offset_x,
 618                                             gint             offset_y);
 619 void gdk_window_set_child_input_shapes     (GdkWindow       *window);
 620 void gdk_window_merge_child_input_shapes   (GdkWindow       *window);
 621
 622
 623 /*
 624  * Check if a window has been shown, and whether all its
 625  * parents up to a toplevel have been shown, respectively.
 626  * Note that a window that is_viewable below is not necessarily
 627  * viewable in the X sense.
 628  */
 629 gboolean gdk_window_is_visible     (GdkWindow *window);
 630 gboolean gdk_window_is_viewable    (GdkWindow *window);
 631 gboolean gdk_window_is_input_only  (GdkWindow *window);
 632 gboolean gdk_window_is_shaped      (GdkWindow *window);
 633
 634 GdkWindowState gdk_window_get_state (GdkWindow *window);
 635
 636 /* Set static bit gravity on the parent, and static
 637  * window gravity on all children.
 638  */
 639 gboolean gdk_window_set_static_gravities (GdkWindow *window,
 640                                           gboolean   use_static);
 641
 642 /* Functions to create/lookup windows from their native equivalents */
 643 #ifndef GDK_MULTIHEAD_SAFE
 644 GdkWindow*    gdk_window_foreign_new (GdkNativeWindow anid);
 645 GdkWindow*    gdk_window_lookup      (GdkNativeWindow anid);
 646 #endif
 647 GdkWindow    *gdk_window_foreign_new_for_display (GdkDisplay      *display,
 648                                                   GdkNativeWindow  anid);
 649 GdkWindow*    gdk_window_lookup_for_display (GdkDisplay      *display,
 650                                              GdkNativeWindow  anid);
 651
 652
 653 /* GdkWindow */
 654
 655 gboolean      gdk_window_has_native         (GdkWindow       *window);
 656 void              gdk_window_set_type_hint (GdkWindow        *window,
 657                                             GdkWindowTypeHint hint);
 658 GdkWindowTypeHint gdk_window_get_type_hint (GdkWindow        *window);
 659
 660 gboolean      gdk_window_get_modal_hint   (GdkWindow       *window);
 661 void          gdk_window_set_modal_hint   (GdkWindow       *window,
 662                                            gboolean         modal);
 663
 664 void gdk_window_set_skip_taskbar_hint (GdkWindow *window,
 665                                        gboolean   skips_taskbar);
 666 void gdk_window_set_skip_pager_hint   (GdkWindow *window,
 667                                        gboolean   skips_pager);
 668 void gdk_window_set_urgency_hint      (GdkWindow *window,
 669                                        gboolean   urgent);
 670
 671 void          gdk_window_set_geometry_hints (GdkWindow          *window,
 672                                              const GdkGeometry  *geometry,
 673                                              GdkWindowHints      geom_mask);
 674 void          gdk_set_sm_client_id          (const gchar        *sm_client_id);
 675
 676 void          gdk_window_begin_paint_rect   (GdkWindow          *window,
 677                                              const GdkRectangle *rectangle);
 678 void          gdk_window_begin_paint_region (GdkWindow          *window,
 679                                              const cairo_region_t    *region);
 680 void          gdk_window_end_paint          (GdkWindow          *window);
 681 void          gdk_window_flush             (GdkWindow          *window);
 682
 683 void          gdk_window_set_title         (GdkWindow     *window,
 684                                             const gchar   *title);
 685 void          gdk_window_set_role          (GdkWindow     *window,
 686                                             const gchar   *role);
 687 void          gdk_window_set_startup_id    (GdkWindow     *window,
 688                                             const gchar   *startup_id);
 689 void          gdk_window_set_transient_for (GdkWindow     *window,
 690                                             GdkWindow     *parent);
 691 void          gdk_window_get_background  (GdkWindow       *window,
 692                                           GdkColor        *color);
 693 void          gdk_window_set_background  (GdkWindow       *window,
 694                                           const GdkColor  *color);
 695 void          gdk_window_get_back_pixmap (GdkWindow       *window,
 696                                           GdkPixmap      **pixmap,
 697                                           gboolean        *parent_relative);
 698 void          gdk_window_set_back_pixmap (GdkWindow       *window,
 699                                           GdkPixmap       *pixmap,
 700                                           gboolean         parent_relative);
 701 void          gdk_window_set_cursor      (GdkWindow       *window,
 702                                           GdkCursor       *cursor);
 703 GdkCursor    *gdk_window_get_cursor      (GdkWindow       *window);
 704 void          gdk_window_set_device_cursor (GdkWindow     *window,
 705                                             GdkDevice     *device,
 706                                             GdkCursor     *cursor);
 707 GdkCursor    *gdk_window_get_device_cursor (GdkWindow     *window,
 708                                             GdkDevice     *device);
 709 void          gdk_window_get_user_data   (GdkWindow       *window,
 710                                           gpointer        *data);
 711 void          gdk_window_get_geometry    (GdkWindow       *window,
 712                                           gint            *x,
 713                                           gint            *y,
 714                                           gint            *width,
 715                                           gint            *height,
 716                                           gint            *depth);
 717 void          gdk_window_get_position    (GdkWindow       *window,
 718                                           gint            *x,
 719                                           gint            *y);
 720 gint          gdk_window_get_origin      (GdkWindow       *window,
 721                                           gint            *x,
 722                                           gint            *y);
 723 void          gdk_window_get_root_coords (GdkWindow       *window,
 724                                           gint             x,
 725                                           gint             y,
 726                                           gint            *root_x,
 727                                           gint            *root_y);
 728 void       gdk_window_coords_to_parent   (GdkWindow       *window,
 729                                           gdouble          x,
 730                                           gdouble          y,
 731                                           gdouble         *parent_x,
 732                                           gdouble         *parent_y);
 733 void       gdk_window_coords_from_parent (GdkWindow       *window,
 734                                           gdouble          parent_x,
 735                                           gdouble          parent_y,
 736                                           gdouble         *x,
 737                                           gdouble         *y);
 738
 739 #if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION) || defined (GDK_COMPILATION)
 740 /* Used by gtk_handle_box_button_changed () */
 741 gboolean      gdk_window_get_deskrelative_origin (GdkWindow       *window,
 742                                           gint            *x,
 743                                           gint            *y);
 744 #endif
 745
 746 void          gdk_window_get_root_origin (GdkWindow       *window,
 747                                           gint            *x,
 748                                           gint            *y);
 749 void          gdk_window_get_frame_extents (GdkWindow     *window,
 750                                             GdkRectangle  *rect);
 751
 752 #ifndef GDK_MULTIDEVICE_SAFE
 753 GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
 754                                           gint            *x,
 755                                           gint            *y,
 756                                           GdkModifierType *mask);
 757 #endif /* GDK_MULTIDEVICE_SAFE */
 758 GdkWindow *   gdk_window_get_device_position (GdkWindow       *window,
 759                                               GdkDevice       *device,
 760                                               gint            *x,
 761                                               gint            *y,
 762                                               GdkModifierType *mask);
 763 GdkWindow *   gdk_window_get_parent      (GdkWindow       *window);
 764 GdkWindow *   gdk_window_get_toplevel    (GdkWindow       *window);
 765
 766 GdkWindow *   gdk_window_get_effective_parent   (GdkWindow *window);
 767 GdkWindow *   gdk_window_get_effective_toplevel (GdkWindow *window);
 768
 769 GList *       gdk_window_get_children    (GdkWindow       *window);
 770 GList *       gdk_window_peek_children   (GdkWindow       *window);
 771 GdkEventMask  gdk_window_get_events      (GdkWindow       *window);
 772 void          gdk_window_set_events      (GdkWindow       *window,
 773                                           GdkEventMask     event_mask);
 774 void          gdk_window_set_device_events (GdkWindow    *window,
 775                                             GdkDevice    *device,
 776                                             GdkEventMask  event_mask);
 777 GdkEventMask  gdk_window_get_device_events (GdkWindow    *window,
 778                                             GdkDevice    *device);
 779
 780 void          gdk_window_set_icon_list   (GdkWindow       *window,
 781                                           GList           *pixbufs);
 782 void          gdk_window_set_icon        (GdkWindow       *window,
 783                                           GdkWindow       *icon_window,
 784                                           GdkPixmap       *pixmap,
 785                                           GdkBitmap       *mask);
 786 void          gdk_window_set_icon_name   (GdkWindow       *window,
 787                                           const gchar     *name);
 788 void          gdk_window_set_group       (GdkWindow       *window,
 789                                           GdkWindow       *leader);
 790 GdkWindow*    gdk_window_get_group       (GdkWindow       *window);
 791 void          gdk_window_set_decorations (GdkWindow       *window,
 792                                           GdkWMDecoration  decorations);
 793 gboolean      gdk_window_get_decorations (GdkWindow       *window,
 794                                           GdkWMDecoration *decorations);
 795 void          gdk_window_set_functions   (GdkWindow       *window,
 796                                           GdkWMFunction    functions);
 797
 798 void          gdk_window_beep            (GdkWindow       *window);
 799 void          gdk_window_iconify         (GdkWindow       *window);
 800 void          gdk_window_deiconify       (GdkWindow       *window);
 801 void          gdk_window_stick           (GdkWindow       *window);
 802 void          gdk_window_unstick         (GdkWindow       *window);
 803 void          gdk_window_maximize        (GdkWindow       *window);
 804 void          gdk_window_unmaximize      (GdkWindow       *window);
 805 void          gdk_window_fullscreen      (GdkWindow       *window);
 806 void          gdk_window_unfullscreen    (GdkWindow       *window);
 807 void          gdk_window_set_keep_above  (GdkWindow       *window,
 808                                           gboolean         setting);
 809 void          gdk_window_set_keep_below  (GdkWindow       *window,
 810                                           gboolean         setting);
 811 void          gdk_window_set_opacity     (GdkWindow       *window,
 812                                           gdouble          opacity);
 813 void          gdk_window_register_dnd    (GdkWindow       *window);
 814
 815 void gdk_window_begin_resize_drag (GdkWindow     *window,
 816                                    GdkWindowEdge  edge,
 817                                    gint           button,
 818                                    gint           root_x,
 819                                    gint           root_y,
 820                                    guint32        timestamp);
 821 void gdk_window_begin_move_drag   (GdkWindow     *window,
 822                                    gint           button,
 823                                    gint           root_x,
 824                                    gint           root_y,
 825                                    guint32        timestamp);
 826
 827 /* Interface for dirty-region queueing */
 828 void       gdk_window_invalidate_rect           (GdkWindow          *window,
 829                                                  const GdkRectangle *rect,
 830                                                  gboolean            invalidate_children);
 831 void       gdk_window_invalidate_region         (GdkWindow          *window,
 832                                                  const cairo_region_t    *region,
 833                                                  gboolean            invalidate_children);
 834 void       gdk_window_invalidate_maybe_recurse  (GdkWindow          *window,
 835                                                  const cairo_region_t    *region,
 836                                                  gboolean (*child_func) (GdkWindow *, gpointer),
 837                                                  gpointer   user_data);
 838 cairo_region_t *gdk_window_get_update_area     (GdkWindow    *window);
 839
 840 void       gdk_window_freeze_updates      (GdkWindow    *window);
 841 void       gdk_window_thaw_updates        (GdkWindow    *window);
 842
 843 void       gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window);
 844 void       gdk_window_thaw_toplevel_updates_libgtk_only   (GdkWindow *window);
 845
 846 void       gdk_window_process_all_updates (void);
 847 void       gdk_window_process_updates     (GdkWindow    *window,
 848                                            gboolean      update_children);
 849
 850 /* Enable/disable flicker, so you can tell if your code is inefficient. */
 851 void       gdk_window_set_debug_updates   (gboolean      setting);
 852
 853 void       gdk_window_constrain_size      (GdkGeometry  *geometry,
 854                                            guint         flags,
 855                                            gint          width,
 856                                            gint          height,
 857                                            gint         *new_width,
 858                                            gint         *new_height);
 859
 860 void gdk_window_get_internal_paint_info (GdkWindow    *window,
 861                                          GdkDrawable **real_drawable,
 862                                          gint         *x_offset,
 863                                          gint         *y_offset);
 864
 865 void gdk_window_enable_synchronized_configure (GdkWindow *window);
 866 void gdk_window_configure_finished            (GdkWindow *window);
 867
 868 #if !defined (GDK_MULTIHEAD_SAFE) && !defined (GDK_MULTIDEVICE_SAFE)
 869 GdkPointerHooks *gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
 870 #endif /* !GDK_MULTIHEAD_SAFE && !GDK_MULTIDEVICE_SAFE */
 871
 872 GdkWindow *gdk_get_default_root_window (void);
 873
 874 /* Offscreen redirection */
 875 GdkPixmap *gdk_offscreen_window_get_pixmap     (GdkWindow     *window);
 876 void       gdk_offscreen_window_set_embedder   (GdkWindow     *window,
 877                                                 GdkWindow     *embedder);
 878 GdkWindow *gdk_offscreen_window_get_embedder   (GdkWindow     *window);
 879 void       gdk_window_geometry_changed         (GdkWindow     *window);
 880
 881 void       gdk_window_redirect_to_drawable   (GdkWindow     *window,
 882                                               GdkDrawable   *drawable,
 883                                               gint           src_x,
 884                                               gint           src_y,
 885                                               gint           dest_x,
 886                                               gint           dest_y,
 887                                               gint           width,
 888                                               gint           height);
 889 void       gdk_window_remove_redirection     (GdkWindow     *window);
 890
 891 /* Multidevice support */
 892 void       gdk_window_set_support_multidevice (GdkWindow *window,
 893                                                gboolean   support_multidevice);
 894 gboolean   gdk_window_get_support_multidevice (GdkWindow *window);
 895
 896 G_END_DECLS
 897
 898 #endif /* __GDK_WINDOW_H__ */