* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
+#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
#error "Only <gdk/gdk.h> can be included directly."
#endif
typedef struct _GdkPointerHooks GdkPointerHooks;
typedef struct _GdkWindowRedirect GdkWindowRedirect;
-/* Classes of windows.
- * InputOutput: Almost every window should be of this type. Such windows
- * receive events and are also displayed on screen.
- * InputOnly: Used only in special circumstances when events need to be
- * stolen from another window or windows. Input only windows
- * have no visible output, so they are handy for placing over
- * top of a group of windows in order to grab the events (or
- * filter the events) from those windows.
+/**
+ * GdkWindowClass:
+ * @GDK_INPUT_OUTPUT: window for graphics and events
+ * @GDK_INPUT_ONLY: window for events only
+ *
+ * @GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
+ * Such windows receive events and are also displayed on screen.
+ * @GDK_INPUT_ONLY windows are invisible; they are usually placed above other
+ * windows in order to trap or filter the events. You can't draw on
+ * @GDK_INPUT_ONLY windows.
*/
typedef enum
{
GDK_INPUT_ONLY
} GdkWindowClass;
-/* Types of windows.
- * Root: There is only 1 root window and it is initialized
- * at startup. Creating a window of type GDK_WINDOW_ROOT
- * is an error.
- * Toplevel: Windows which interact with the window manager.
- * Child: Windows which are children of some other type of window.
- * (Any other type of window). Most windows are child windows.
- * Dialog: A special kind of toplevel window which interacts with
- * the window manager slightly differently than a regular
- * toplevel window. Dialog windows should be used for any
- * transient window.
- * Foreign: A window that actually belongs to another application
+/**
+ * GdkWindowType:
+ * @GDK_WINDOW_ROOT: root window; this window has no parent, covers the entire
+ * screen, and is created by the window system
+ * @GDK_WINDOW_TOPLEVEL: toplevel window (used to implement #GtkWindow)
+ * @GDK_WINDOW_CHILD: child window (used to implement e.g. #GtkEntry)
+ * @GDK_WINDOW_DIALOG: useless/deprecated compatibility type
+ * @GDK_WINDOW_TEMP: override redirect temporary window (used to implement
+ * #GtkMenu)
+ * @GDK_WINDOW_FOREIGN: foreign window (see gdk_window_foreign_new())
+ * @GDK_WINDOW_OFFSCREEN: offscreen window (see
+ * <xref linkend="OFFSCREEN-WINDOWS"/>). Since 2.18
+ *
+ * Describes the kind of window.
*/
typedef enum
{
GDK_WINDOW_OFFSCREEN
} GdkWindowType;
-/* Window attribute mask values.
- * GDK_WA_TITLE: The "title" field is valid.
- * GDK_WA_X: The "x" field is valid.
- * GDK_WA_Y: The "y" field is valid.
- * GDK_WA_CURSOR: The "cursor" field is valid.
- * GDK_WA_COLORMAP: The "colormap" field is valid.
- * GDK_WA_VISUAL: The "visual" field is valid.
+/**
+ * GdkWindowAttributesType:
+ * @GDK_WA_TITLE: Honor the title field
+ * @GDK_WA_X: Honor the X coordinate field
+ * @GDK_WA_Y: Honor the Y coordinate field
+ * @GDK_WA_CURSOR: Honor the cursor field
+ * @GDK_WA_COLORMAP: Honor the colormap field
+ * @GDK_WA_VISUAL: Honor the visual field
+ * @GDK_WA_WMCLASS: Honor the wmclass_class and wmclass_name fields
+ * @GDK_WA_NOREDIR: Honor the override_redirect field
+ * @GDK_WA_TYPE_HINT: Honor the type_hint field
+ *
+ * Used to indicate which fields in the #GdkWindowAttr struct should be honored.
+ * For example, if you filled in the "cursor" and "x" fields of #GdkWindowAttr,
+ * pass "@GDK_WA_X | @GDK_WA_CURSOR" to gdk_window_new(). Fields in
+ * #GdkWindowAttr not covered by a bit in this enum are required; for example,
+ * the @width/@height, @wclass, and @window_type fields are required, they have
+ * no corresponding flag in #GdkWindowAttributesType.
*/
typedef enum
{
/* Size restriction enumeration.
*/
+/**
+ * GdkWindowHints:
+ * @GDK_HINT_POS: indicates that the program has positioned the window
+ * @GDK_HINT_MIN_SIZE: min size fields are set
+ * @GDK_HINT_MAX_SIZE: max size fields are set
+ * @GDK_HINT_BASE_SIZE: base size fields are set
+ * @GDK_HINT_ASPECT: aspect ratio fields are set
+ * @GDK_HINT_RESIZE_INC: resize increment fields are set
+ * @GDK_HINT_WIN_GRAVITY: window gravity field is set
+ * @GDK_HINT_USER_POS: indicates that the window's position was explicitly set
+ * by the user
+ * @GDK_HINT_USER_SIZE: indicates that the window's size was explicitly set by
+ * the user
+ *
+ * Used to indicate which fields of a #GdkGeometry struct should be paid
+ * attention to. Also, the presence/absence of @GDK_HINT_POS,
+ * @GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't
+ * directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set
+ * automatically by #GtkWindow if you call gtk_window_move().
+ * @GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user
+ * specified a size/position using a --geometry command-line argument;
+ * gtk_window_parse_geometry() automatically sets these flags.
+ */
typedef enum
{
GDK_HINT_POS = 1 << 0,
} GdkWindowHints;
-/* Window type hints.
- * These are hints for the window manager that indicate
- * what type of function the window has. The window manager
- * can use this when determining decoration and behaviour
- * of the window. The hint must be set before mapping the
- * window.
+/**
+ * GdkWindowTypeHint:
+ * @GDK_WINDOW_TYPE_HINT_NORMAL: Normal toplevel window.
+ * @GDK_WINDOW_TYPE_HINT_DIALOG: Dialog window.
+ * @GDK_WINDOW_TYPE_HINT_MENU: Window used to implement a menu; GTK+ uses
+ * this hint only for torn-off menus, see #GtkTearoffMenuItem.
+ * @GDK_WINDOW_TYPE_HINT_TOOLBAR: Window used to implement toolbars.
+ * @GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: Window used to display a splash
+ * screen during application startup.
+ * @GDK_WINDOW_TYPE_HINT_UTILITY: Utility windows which are not detached
+ * toolbars or dialogs.
+ * @GDK_WINDOW_TYPE_HINT_DOCK: Used for creating dock or panel windows.
+ * @GDK_WINDOW_TYPE_HINT_DESKTOP: Used for creating the desktop background
+ * window.
+ * @GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: A menu that belongs to a menubar.
+ * @GDK_WINDOW_TYPE_HINT_POPUP_MENU: A menu that does not belong to a menubar,
+ * e.g. a context menu.
+ * @GDK_WINDOW_TYPE_HINT_TOOLTIP: A tooltip.
+ * @GDK_WINDOW_TYPE_HINT_NOTIFICATION: A notification - typically a "bubble"
+ * that belongs to a status icon.
+ * @GDK_WINDOW_TYPE_HINT_COMBO: A popup from a combo box.
+ * @GDK_WINDOW_TYPE_HINT_DND: A window that is used to implement a DND cursor.
*
- * Normal: Normal toplevel window
- * Dialog: Dialog window
- * Menu: Window used to implement a menu.
- * Toolbar: Window used to implement toolbars.
+ * These are hints for the window manager that indicate what type of function
+ * the window has. The window manager can use this when determining decoration
+ * and behaviour of the window. The hint must be set before mapping the window.
+ *
+ * See the
+ * <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
+ * Window Manager Hints</ulink> specification for more details about
+ * window types.
*/
typedef enum
{
* of gdk_window_set_decorations/gdk_window_set_functions
* will need to change as well.
*/
+/**
+ * GdkWMDecoration:
+ * @GDK_DECOR_ALL: all decorations should be applied.
+ * @GDK_DECOR_BORDER: a frame should be drawn around the window.
+ * @GDK_DECOR_RESIZEH: the frame should have resize handles.
+ * @GDK_DECOR_TITLE: a titlebar should be placed above the window.
+ * @GDK_DECOR_MENU: a button for opening a menu should be included.
+ * @GDK_DECOR_MINIMIZE: a minimize button should be included.
+ * @GDK_DECOR_MAXIMIZE: a maximize button should be included.
+ *
+ * These are hints originally defined by the Motif toolkit.
+ * The window manager can use them when determining how to decorate
+ * the window. The hint must be set before mapping the window.
+ */
typedef enum
{
GDK_DECOR_ALL = 1 << 0,
GDK_DECOR_MAXIMIZE = 1 << 6
} GdkWMDecoration;
+/**
+ * GdkWMFunction:
+ * @GDK_FUNC_ALL: all functions should be offered.
+ * @GDK_FUNC_RESIZE: the window should be resizable.
+ * @GDK_FUNC_MOVE: the window should be movable.
+ * @GDK_FUNC_MINIMIZE: the window should be minimizable.
+ * @GDK_FUNC_MAXIMIZE: the window should be maximizable.
+ * @GDK_FUNC_CLOSE: the window should be closable.
+ *
+ * These are hints originally defined by the Motif toolkit. The window manager
+ * can use them when determining the functions to offer for the window. The
+ * hint must be set before mapping the window.
+ */
typedef enum
{
GDK_FUNC_ALL = 1 << 0,
* X protocol. If you change that, gdkwindow-x11.c/gdk_window_set_geometry_hints()
* will need fixing.
*/
+/**
+ * GdkGravity:
+ * @GDK_GRAVITY_NORTH_WEST: the reference point is at the top left corner.
+ * @GDK_GRAVITY_NORTH: the reference point is in the middle of the top edge.
+ * @GDK_GRAVITY_NORTH_EAST: the reference point is at the top right corner.
+ * @GDK_GRAVITY_WEST: the reference point is at the middle of the left edge.
+ * @GDK_GRAVITY_CENTER: the reference point is at the center of the window.
+ * @GDK_GRAVITY_EAST: the reference point is at the middle of the right edge.
+ * @GDK_GRAVITY_SOUTH_WEST: the reference point is at the lower left corner.
+ * @GDK_GRAVITY_SOUTH: the reference point is at the middle of the lower edge.
+ * @GDK_GRAVITY_SOUTH_EAST: the reference point is at the lower right corner.
+ * @GDK_GRAVITY_STATIC: the reference point is at the top left corner of the
+ * window itself, ignoring window manager decorations.
+ *
+ * Defines the reference point of a window and the meaning of coordinates
+ * passed to gtk_window_move(). See gtk_window_move() and the "implementation
+ * notes" section of the
+ * <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
+ * Window Manager Hints</ulink> specification for more details.
+ */
typedef enum
{
GDK_GRAVITY_NORTH_WEST = 1,
} GdkGravity;
+/**
+ * GdkWindowEdge:
+ * @GDK_WINDOW_EDGE_NORTH_WEST: the top left corner.
+ * @GDK_WINDOW_EDGE_NORTH: the top edge.
+ * @GDK_WINDOW_EDGE_NORTH_EAST: the top right corner.
+ * @GDK_WINDOW_EDGE_WEST: the left edge.
+ * @GDK_WINDOW_EDGE_EAST: the right edge.
+ * @GDK_WINDOW_EDGE_SOUTH_WEST: the lower left corner.
+ * @GDK_WINDOW_EDGE_SOUTH: the lower edge.
+ * @GDK_WINDOW_EDGE_SOUTH_EAST: the lower right corner.
+ *
+ * Determines a window edge or corner.
+ */
typedef enum
{
GDK_WINDOW_EDGE_NORTH_WEST,
GDK_WINDOW_EDGE_SOUTH_EAST
} GdkWindowEdge;
+/**
+ * GdkWindowAttr:
+ * @title: title of the window (for toplevel windows)
+ * @event_mask: event mask (see gdk_window_set_events())
+ * @x: X coordinate relative to parent window (see gdk_window_move())
+ * @y: Y coordinate relative to parent window (see gdk_window_move())
+ * @width: width of window
+ * @height: height of window
+ * @wclass: #GDK_INPUT_OUTPUT (normal window) or #GDK_INPUT_ONLY (invisible
+ * window that receives events)
+ * @visual: #GdkVisual for window
+ * @colormap: #GdkColormap for window
+ * @window_type: type of window
+ * @cursor: cursor for the window (see gdk_window_set_cursor())
+ * @wmclass_name: don't use (see gtk_window_set_wmclass())
+ * @wmclass_class: don't use (see gtk_window_set_wmclass())
+ * @override_redirect: %TRUE to bypass the window manager
+ * @type_hint: a hint of the function of the window
+ *
+ * Attributes to use for a newly-created window.
+ */
struct _GdkWindowAttr
{
gchar *title;
GdkWindowTypeHint type_hint;
};
+/**
+ * GdkGeometry:
+ * @min_width: minimum width of window (or -1 to use requisition, with
+ * #GtkWindow only)
+ * @min_height: minimum height of window (or -1 to use requisition, with
+ * #GtkWindow only)
+ * @max_width: maximum width of window (or -1 to use requisition, with
+ * #GtkWindow only)
+ * @max_height: maximum height of window (or -1 to use requisition, with
+ * #GtkWindow only)
+ * @base_width: allowed window widths are @base_width + @width_inc * N where N
+ * is any integer (-1 allowed with #GtkWindow)
+ * @base_height: allowed window widths are @base_height + @height_inc * N where
+ * N is any integer (-1 allowed with #GtkWindow)
+ * @width_inc: width resize increment
+ * @height_inc: height resize increment
+ * @min_aspect: minimum width/height ratio
+ * @max_aspect: maximum width/height ratio
+ * @win_gravity: window gravity, see gtk_window_set_gravity()
+ *
+ * The #GdkGeometry struct gives the window manager information about
+ * a window's geometry constraints. Normally you would set these on
+ * the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow
+ * then sets the hints on the #GdkWindow it creates.
+ *
+ * gdk_window_set_geometry_hints() expects the hints to be fully valid already
+ * and simply passes them to the window manager; in contrast,
+ * gtk_window_set_geometry_hints() performs some interpretation. For example,
+ * #GtkWindow will apply the hints to the geometry widget instead of the
+ * toplevel window, if you set a geometry widget. Also, the
+ * @min_width/@min_height/@max_width/@max_height fields may be set to -1, and
+ * #GtkWindow will substitute the size request of the window or geometry widget.
+ * If the minimum size hint is not provided, #GtkWindow will use its requisition
+ * as the minimum size. If the minimum size is provided and a geometry widget is
+ * set, #GtkWindow will take the minimum size as the minimum size of the
+ * geometry widget rather than the entire window. The base size is treated
+ * similarly.
+ *
+ * The canonical use-case for gtk_window_set_geometry_hints() is to get a
+ * terminal widget to resize properly. Here, the terminal text area should be
+ * the geometry widget; #GtkWindow will then automatically set the base size to
+ * the size of other widgets in the terminal window, such as the menubar and
+ * scrollbar. Then, the @width_inc and @height_inc fields should be set to the
+ * size of one character in the terminal. Finally, the base size should be set
+ * to the size of one character. The net effect is that the minimum size of the
+ * terminal will have a 1x1 character terminal area, and only terminal sizes on
+ * the "character grid" will be allowed.
+ *
+ * Here's an example of how the terminal example would be implemented, assuming
+ * a terminal area widget called "terminal" and a toplevel window "toplevel":
+ *
+ * <informalexample><programlisting><![CDATA[
+ * GdkGeometry hints;
+ *
+ * hints.base_width = terminal->char_width;
+ * hints.base_height = terminal->char_height;
+ * hints.min_width = terminal->char_width;
+ * hints.min_height = terminal->char_height;
+ * hints.width_inc = terminal->char_width;
+ * hints.height_inc = terminal->char_height;
+ *
+ * gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),
+ * GTK_WIDGET (terminal),
+ * &hints,
+ * GDK_HINT_RESIZE_INC |
+ * GDK_HINT_MIN_SIZE |
+ * GDK_HINT_BASE_SIZE);
+ * ]]></programlisting></informalexample>
+ *
+ * The other useful fields are the @min_aspect and @max_aspect fields; these
+ * contain a width/height ratio as a floating point number. If a geometry widget
+ * is set, the aspect applies to the geometry widget rather than the entire
+ * window. The most common use of these hints is probably to set @min_aspect and
+ * @max_aspect to the same value, thus forcing the window to keep a constant
+ * aspect ratio.
+ */
struct _GdkGeometry
{
gint min_width;
GdkGravity win_gravity;
};
+/**
+ * GdkPointerHooks:
+ * @get_pointer: Obtains the current pointer position and modifier state.
+ * The position is given in coordinates relative to the window containing
+ * the pointer, which is returned in @window.
+ * @window_at_pointer: Obtains the window underneath the mouse pointer,
+ * returning the location of that window in @win_x, @win_y. Returns %NULL
+ * if the window under the mouse pointer is not known to GDK (for example,
+ * belongs to another application).
+ *
+ * A table of pointers to functions for getting quantities related to
+ * the current pointer position. GDK has one global table of this type,
+ * which can be set using gdk_set_pointer_hooks().
+ *
+ * This is only useful for such low-level tools as an event recorder.
+ * Applications should never have any reason to use this facility
+ */
struct _GdkPointerHooks
{
GdkWindow* (*get_pointer) (GdkWindow *window,
#define GDK_IS_WINDOW(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
#define GDK_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
#define GDK_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowObjectClass))
+
+#ifndef GDK_DISABLE_DEPRECATED
#define GDK_WINDOW_OBJECT(object) ((GdkWindowObject *) GDK_WINDOW (object))
#ifndef GDK_COMPILATION
+
/* We used to export all of GdkWindowObject, but we don't want to keep doing so.
However, there are various parts of it accessed by macros and other code,
so we keep the old exported version public, but in reality it is larger. */
{
GdkDrawable parent_instance;
- GdkDrawable *impl; /* window-system-specific delegate object */
+ GdkDrawable *GSEAL (impl); /* window-system-specific delegate object */
- GdkWindowObject *parent;
+ GdkWindowObject *GSEAL (parent);
- gpointer user_data;
+ gpointer GSEAL (user_data);
- gint x;
- gint y;
+ gint GSEAL (x);
+ gint GSEAL (y);
- gint extension_events;
+ gint GSEAL (extension_events);
- GList *filters;
- GList *children;
+ GList *GSEAL (filters);
+ GList *GSEAL (children);
- GdkColor bg_color;
- GdkPixmap *bg_pixmap;
+ GdkColor GSEAL (bg_color);
+ GdkPixmap *GSEAL (bg_pixmap);
- GSList *paint_stack;
+ GSList *GSEAL (paint_stack);
- GdkRegion *update_area;
- guint update_freeze_count;
+ GdkRegion *GSEAL (update_area);
+ guint GSEAL (update_freeze_count);
- guint8 window_type;
- guint8 depth;
- guint8 resize_count;
+ guint8 GSEAL (window_type);
+ guint8 GSEAL (depth);
+ guint8 GSEAL (resize_count);
- GdkWindowState state;
+ GdkWindowState GSEAL (state);
- guint guffaw_gravity : 1;
- guint input_only : 1;
- guint modal_hint : 1;
- guint composited : 1;
+ guint GSEAL (guffaw_gravity) : 1;
+ guint GSEAL (input_only) : 1;
+ guint GSEAL (modal_hint) : 1;
+ guint GSEAL (composited) : 1;
- guint destroyed : 2;
+ guint GSEAL (destroyed) : 2;
- guint accept_focus : 1;
- guint focus_on_map : 1;
- guint shaped : 1;
+ guint GSEAL (accept_focus) : 1;
+ guint GSEAL (focus_on_map) : 1;
+ guint GSEAL (shaped) : 1;
+ guint GSEAL (support_multidevice) : 1;
- GdkEventMask event_mask;
+ GdkEventMask GSEAL (event_mask);
- guint update_and_descendants_freeze_count;
+ guint GSEAL (update_and_descendants_freeze_count);
- GdkWindowRedirect *redirect;
+ GdkWindowRedirect *GSEAL (redirect);
};
#endif
+#endif
struct _GdkWindowObjectClass
{
gint attributes_mask);
void gdk_window_destroy (GdkWindow *window);
GdkWindowType gdk_window_get_window_type (GdkWindow *window);
+gboolean gdk_window_is_destroyed (GdkWindow *window);
+
+#ifndef GDK_MULTIDEVICE_SAFE
GdkWindow* gdk_window_at_pointer (gint *win_x,
gint *win_y);
+#endif /* GDK_MULTIDEVICE_SAFE */
void gdk_window_show (GdkWindow *window);
void gdk_window_hide (GdkWindow *window);
void gdk_window_withdraw (GdkWindow *window);
gint height);
void gdk_window_raise (GdkWindow *window);
void gdk_window_lower (GdkWindow *window);
+void gdk_window_restack (GdkWindow *window,
+ GdkWindow *sibling,
+ gboolean above);
void gdk_window_focus (GdkWindow *window,
guint32 timestamp);
void gdk_window_set_user_data (GdkWindow *window,
gpointer user_data);
void gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect);
+gboolean gdk_window_get_accept_focus (GdkWindow *window);
void gdk_window_set_accept_focus (GdkWindow *window,
gboolean accept_focus);
+gboolean gdk_window_get_focus_on_map (GdkWindow *window);
void gdk_window_set_focus_on_map (GdkWindow *window,
gboolean focus_on_map);
void gdk_window_add_filter (GdkWindow *window,
*/
void gdk_window_set_child_shapes (GdkWindow *window);
+gboolean gdk_window_get_composited (GdkWindow *window);
void gdk_window_set_composited (GdkWindow *window,
gboolean composited);
*/
gboolean gdk_window_is_visible (GdkWindow *window);
gboolean gdk_window_is_viewable (GdkWindow *window);
+gboolean gdk_window_is_input_only (GdkWindow *window);
+gboolean gdk_window_is_shaped (GdkWindow *window);
GdkWindowState gdk_window_get_state (GdkWindow *window);
/* GdkWindow */
-#ifndef GDK_DISABLE_DEPRECATED
-void gdk_window_set_hints (GdkWindow *window,
- gint x,
- gint y,
- gint min_width,
- gint min_height,
- gint max_width,
- gint max_height,
- gint flags);
-#endif
void gdk_window_set_type_hint (GdkWindow *window,
GdkWindowTypeHint hint);
GdkWindowTypeHint gdk_window_get_type_hint (GdkWindow *window);
+gboolean gdk_window_get_modal_hint (GdkWindow *window);
void gdk_window_set_modal_hint (GdkWindow *window,
gboolean modal);
void gdk_window_begin_paint_region (GdkWindow *window,
const GdkRegion *region);
void gdk_window_end_paint (GdkWindow *window);
+void gdk_window_flush (GdkWindow *window);
void gdk_window_set_title (GdkWindow *window,
const gchar *title);
-void gdk_window_set_role (GdkWindow *window,
- const gchar *role);
-void gdk_window_set_startup_id (GdkWindow *window,
- const gchar *startup_id);
-void gdk_window_set_transient_for (GdkWindow *window,
- GdkWindow *parent);
+void gdk_window_set_role (GdkWindow *window,
+ const gchar *role);
+void gdk_window_set_startup_id (GdkWindow *window,
+ const gchar *startup_id);
+void gdk_window_set_transient_for (GdkWindow *window,
+ GdkWindow *parent);
+void gdk_window_get_background (GdkWindow *window,
+ GdkColor *color);
void gdk_window_set_background (GdkWindow *window,
const GdkColor *color);
+void gdk_window_get_back_pixmap (GdkWindow *window,
+ GdkPixmap **pixmap,
+ gboolean *parent_relative);
void gdk_window_set_back_pixmap (GdkWindow *window,
GdkPixmap *pixmap,
gboolean parent_relative);
void gdk_window_set_cursor (GdkWindow *window,
GdkCursor *cursor);
+GdkCursor *gdk_window_get_cursor (GdkWindow *window);
+void gdk_window_set_device_cursor (GdkWindow *window,
+ GdkDevice *device,
+ GdkCursor *cursor);
+GdkCursor *gdk_window_get_device_cursor (GdkWindow *window,
+ GdkDevice *device);
void gdk_window_get_user_data (GdkWindow *window,
gpointer *data);
void gdk_window_get_geometry (GdkWindow *window,
gint y,
gint *root_x,
gint *root_y);
+void gdk_window_coords_to_parent (GdkWindow *window,
+ gdouble x,
+ gdouble y,
+ gdouble *parent_x,
+ gdouble *parent_y);
+void gdk_window_coords_from_parent (GdkWindow *window,
+ gdouble parent_x,
+ gdouble parent_y,
+ gdouble *x,
+ gdouble *y);
#if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION) || defined (GDK_COMPILATION)
/* Used by gtk_handle_box_button_changed () */
gint *y);
void gdk_window_get_frame_extents (GdkWindow *window,
GdkRectangle *rect);
+
+#ifndef GDK_MULTIDEVICE_SAFE
GdkWindow* gdk_window_get_pointer (GdkWindow *window,
gint *x,
gint *y,
GdkModifierType *mask);
+#endif /* GDK_MULTIDEVICE_SAFE */
+GdkWindow * gdk_window_get_device_position (GdkWindow *window,
+ GdkDevice *device,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
GdkWindow * gdk_window_get_parent (GdkWindow *window);
GdkWindow * gdk_window_get_toplevel (GdkWindow *window);
+GdkWindow * gdk_window_get_effective_parent (GdkWindow *window);
+GdkWindow * gdk_window_get_effective_toplevel (GdkWindow *window);
+
GList * gdk_window_get_children (GdkWindow *window);
GList * gdk_window_peek_children (GdkWindow *window);
GdkEventMask gdk_window_get_events (GdkWindow *window);
void gdk_window_set_events (GdkWindow *window,
GdkEventMask event_mask);
+void gdk_window_set_device_events (GdkWindow *window,
+ GdkDevice *device,
+ GdkEventMask event_mask);
+GdkEventMask gdk_window_get_device_events (GdkWindow *window,
+ GdkDevice *device);
void gdk_window_set_icon_list (GdkWindow *window,
GList *pixbufs);
GdkWMDecoration *decorations);
void gdk_window_set_functions (GdkWindow *window,
GdkWMFunction functions);
-#if !defined(GDK_MULTIHEAD_SAFE) && !defined(GDK_DISABLE_DEPRECATED)
-GList * gdk_window_get_toplevels (void);
-#endif
void gdk_window_beep (GdkWindow *window);
void gdk_window_iconify (GdkWindow *window);
void gdk_window_enable_synchronized_configure (GdkWindow *window);
void gdk_window_configure_finished (GdkWindow *window);
-#ifndef GDK_MULTIHEAD_SAFE
-GdkPointerHooks *gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
-#endif /* GDK_MULTIHEAD_SAFE */
+#if !defined (GDK_MULTIHEAD_SAFE) && !defined (GDK_MULTIDEVICE_SAFE)
+GdkPointerHooks *gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
+#endif /* !GDK_MULTIHEAD_SAFE && !GDK_MULTIDEVICE_SAFE */
GdkWindow *gdk_get_default_root_window (void);
gint height);
void gdk_window_remove_redirection (GdkWindow *window);
-#ifndef GDK_DISABLE_DEPRECATED
-#define GDK_ROOT_PARENT() (gdk_get_default_root_window ())
-#define gdk_window_get_size gdk_drawable_get_size
-#define gdk_window_get_type gdk_window_get_window_type
-#define gdk_window_get_colormap gdk_drawable_get_colormap
-#define gdk_window_set_colormap gdk_drawable_set_colormap
-#define gdk_window_get_visual gdk_drawable_get_visual
-#define gdk_window_ref gdk_drawable_ref
-#define gdk_window_unref gdk_drawable_unref
-
-#define gdk_window_copy_area(drawable,gc,x,y,source_drawable,source_x,source_y,width,height) \
- gdk_draw_pixmap(drawable,gc,source_drawable,source_x,source_y,x,y,width,height)
-#endif /* GDK_DISABLE_DEPRECATED */
+/* Multidevice support */
+void gdk_window_set_support_multidevice (GdkWindow *window,
+ gboolean support_multidevice);
+gboolean gdk_window_get_support_multidevice (GdkWindow *window);
G_END_DECLS
projects / ~andy / gtk / blobdiff