1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,
3 * Josh MacDonald, Ryan Lortie
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
22 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
23 * file for a list of people on the GTK+ Team. See the ChangeLog
24 * files for a list of changes. These files are distributed with
25 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
30 #include <cairo-gobject.h>
32 #include "gdkwindow.h"
34 #include "gdkrectangle.h"
35 #include "gdkinternals.h"
37 #include "gdkscreenprivate.h"
38 #include "gdkdisplayprivate.h"
39 #include "gdkdeviceprivate.h"
40 #include "gdkvisualprivate.h"
41 #include "gdkmarshalers.h"
42 #include "gdkwindowimpl.h"
46 #undef DEBUG_WINDOW_PRINTING
51 * @Short_description: Onscreen display areas in the target window system
54 * A #GdkWindow is a (usually) rectangular region on the screen.
55 * It's a low-level object, used to implement high-level objects such as
56 * #GtkWidget and #GtkWindow on the GTK+ level. A #GtkWindow is a toplevel
57 * window, the thing a user might think of as a "window" with a titlebar and
58 * so on; a #GtkWindow may contain many #GdkWindows. For example, each
59 * #GtkButton has a #GdkWindow associated with it.
61 * <refsect2 id="COMPOSITED-WINDOWS">
62 * <title>Composited Windows</title>
64 * Normally, the windowing system takes care of rendering the contents of a
65 * child window onto its parent window. This mechanism can be intercepted by
66 * calling gdk_window_set_composited() on the child window. For a
67 * <firstterm>composited</firstterm> window it is the responsibility of the
68 * application to render the window contents at the right spot.
70 * <example id="composited-window-example">
71 * <title>Composited windows</title>
73 * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/gdk/composited-window-example.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>
74 * </programlisting></example>
76 * In the example <xref linkend="composited-window-example"/>, a button is
77 * placed inside of an event box inside of a window. The event box is set as
78 * composited and therefore is no longer automatically drawn to the screen.
80 * When the contents of the event box change, an expose event is generated on
81 * its parent window (which, in this case, belongs to the toplevel #GtkWindow).
82 * The expose handler for this widget is responsible for merging the changes
83 * back on the screen in the way that it wishes.
85 * In our case, we merge the contents with a 50% transparency. We also set the
86 * background colour of the window to red. The effect is that the background
87 * shows through the button.
90 * <refsect2 id="OFFSCREEN-WINDOWS">
91 * <title>Offscreen Windows</title>
93 * Offscreen windows are more general than composited windows, since they allow
94 * not only to modify the rendering of the child window onto its parent, but
95 * also to apply coordinate transformations.
97 * To integrate an offscreen window into a window hierarchy, one has to call
98 * gdk_offscreen_window_set_embedder() and handle a number of signals. The
99 * #GdkWindow::pick-embedded-child signal on the embedder window is used to
100 * select an offscreen child at given coordinates, and the
101 * #GdkWindow::to-embedder and #GdkWindow::from-embedder signals on the
102 * offscreen window are used to translate coordinates between the embedder and
103 * the offscreen window.
105 * For rendering an offscreen window onto its embedder, the contents of the
106 * offscreen window are available as a surface, via
107 * gdk_offscreen_window_get_surface().
113 /* Historically a GdkWindow always matches a platform native window,
114 * be it a toplevel window or a child window. In this setup the
115 * GdkWindow (and other GdkDrawables) were platform independent classes,
116 * and the actual platform specific implementation was in a delegate
117 * object availible as "impl" in the window object.
119 * With the addition of client side windows and offscreen windows this
120 * changes a bit. The application-visible GdkWindow object behaves as
121 * it did before, but not all such windows now have a corresponding native
122 * window. Instead windows that are "client side" are emulated by the gdk
123 * code such that clipping, drawing, moving, events etc work as expected.
125 * For GdkWindows that have a native window the "impl" object is the
126 * same as before. However, for all client side windows the impl object
127 * is shared with its parent (i.e. all client windows descendants of one
128 * native window has the same impl.
130 * Additionally there is a new type of platform independent impl object,
131 * GdkOffscreenWindow. All windows of type GDK_WINDOW_OFFSCREEN get an impl
132 * of this type (while their children are generally GDK_WINDOW_CHILD virtual
133 * windows). Such windows work by allocating a #cairo_surface_t as the backing
134 * store for drawing operations, which is resized with the window.
136 * GdkWindows have a pointer to the "impl window" they are in, i.e.
137 * the topmost GdkWindow which have the same "impl" value. This is stored
138 * in impl_window, which is different from the window itself only for client
140 * All GdkWindows (native or not) track the position of the window in the parent
141 * (x, y), the size of the window (width, height), the position of the window
142 * with respect to the impl window (abs_x, abs_y). We also track the clip
143 * region of the window wrt parent windows and siblings, in window-relative
144 * coordinates with and without child windows included (clip_region,
145 * clip_region_with_children).
147 * All toplevel windows are native windows, but also child windows can be
148 * native (although not children of offscreens). We always listen to
149 * a basic set of events (see get_native_event_mask) for these windows
150 * so that we can emulate events for any client side children.
152 * For native windows we apply the calculated clip region as a window shape
153 * so that eg. client side siblings that overlap the native child properly
154 * draws over the native child window.
156 * In order to minimize flicker and for performance we use a couple of cacheing
157 * tricks. First of all, every time we do a window to window copy area, for instance
158 * when moving a client side window or when scrolling/moving a region in a window
159 * we store this in outstanding_moves instead of applying immediately. We then
160 * delay this move until we really need it (because something depends on being
161 * able to read it), or until we're handing a redraw from an expose/invalidation
162 * (actually we delay it past redraw, but before blitting the double buffer
163 * to the window). This gives us two advantages. First of all it minimizes the time
164 * from the window is moved to the exposes related to that move, secondly it allows
165 * us to be smart about how to do the copy. We combine multiple moves into one (when
166 * possible) and we don't actually do copies to anything that is or will be
167 * invalidated and exposed anyway.
169 * Secondly, we use something called a "implicit paint" during repaint handling.
170 * An implicit paint is similar to a regular paint for the paint stack, but it is
171 * not put on the stack. Instead, it is set on the impl window, and later when
172 * regular gdk_window_begin_paint_region() happen on a window of this impl window
173 * we reuse the surface from the implicit paint. During repaint we create and at the
174 * end flush an implicit paint, which means we can collect all the paints on
175 * multiple client side windows in the same backing store.
178 #define USE_BACKING_STORE /* Appears to work on Win32, too, now. */
180 /* This adds a local value to the GdkVisibilityState enum */
181 #define GDK_VISIBILITY_NOT_VIEWABLE 3
184 PICK_EMBEDDED_CHILD, /* only called if children are embedded */
198 CLEAR_BG_WINCLEARED, /* Clear backgrounds except those that the window system clears */
202 struct _GdkWindowPaint
204 cairo_region_t *region;
205 cairo_surface_t *surface;
206 guint uses_implicit : 1;
212 cairo_region_t *dest_region; /* The destination region */
213 int dx, dy; /* The amount that the source was moved to reach dest_region */
214 } GdkWindowRegionMove;
218 static void gdk_window_drop_cairo_surface (GdkWindow *private);
220 static void gdk_window_free_paint_stack (GdkWindow *window);
222 static void gdk_window_finalize (GObject *object);
224 static void gdk_window_set_property (GObject *object,
228 static void gdk_window_get_property (GObject *object,
233 static void gdk_window_clear_backing_region (GdkWindow *window,
234 cairo_region_t *region);
236 static void recompute_visible_regions (GdkWindow *private,
237 gboolean recalculate_siblings,
238 gboolean recalculate_children);
239 static void gdk_window_flush_outstanding_moves (GdkWindow *window);
240 static void gdk_window_flush_recursive (GdkWindow *window);
241 static void do_move_region_bits_on_impl (GdkWindow *window,
242 cairo_region_t *region, /* In impl window coords */
244 static void gdk_window_invalidate_in_parent (GdkWindow *private);
245 static void move_native_children (GdkWindow *private);
246 static void update_cursor (GdkDisplay *display,
248 static void impl_window_add_update_area (GdkWindow *impl_window,
249 cairo_region_t *region);
250 static void gdk_window_region_move_free (GdkWindowRegionMove *move);
251 static void gdk_window_invalidate_region_full (GdkWindow *window,
252 const cairo_region_t *region,
253 gboolean invalidate_children,
255 static void gdk_window_invalidate_rect_full (GdkWindow *window,
256 const GdkRectangle *rect,
257 gboolean invalidate_children,
260 static guint signals[LAST_SIGNAL] = { 0 };
262 static gpointer parent_class = NULL;
264 static const cairo_user_data_key_t gdk_window_cairo_key;
267 new_region_tag (void)
269 static guint32 tag = 0;
274 G_DEFINE_ABSTRACT_TYPE (GdkWindow, gdk_window, G_TYPE_OBJECT)
277 _gdk_paintable_get_type (void)
279 static GType paintable_type = 0;
283 const GTypeInfo paintable_info =
285 sizeof (GdkPaintableIface), /* class_size */
286 NULL, /* base_init */
287 NULL, /* base_finalize */
290 paintable_type = g_type_register_static (G_TYPE_INTERFACE,
291 g_intern_static_string ("GdkPaintable"),
294 g_type_interface_add_prerequisite (paintable_type, G_TYPE_OBJECT);
297 return paintable_type;
301 gdk_window_init (GdkWindow *window)
303 /* 0-initialization is good for all other fields. */
305 window->window_type = GDK_WINDOW_CHILD;
307 window->state = GDK_WINDOW_STATE_WITHDRAWN;
310 window->toplevel_window_type = -1;
312 window->effective_visibility = GDK_VISIBILITY_NOT_VIEWABLE;
313 window->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
314 /* Default to unobscured since some backends don't send visibility events */
315 window->native_visibility = GDK_VISIBILITY_UNOBSCURED;
317 window->device_cursor = g_hash_table_new_full (NULL, NULL,
318 NULL, g_object_unref);
321 /* Stop and return on the first non-NULL parent */
323 accumulate_get_window (GSignalInvocationHint *ihint,
325 const GValue *handler_return,
328 g_value_copy (handler_return, return_accu);
329 /* Continue while returning NULL */
330 return g_value_get_object (handler_return) == NULL;
334 create_surface_accumulator (GSignalInvocationHint *ihint,
336 const GValue *handler_return,
339 g_value_copy (handler_return, return_accu);
341 /* Stop on the first non-NULL return value */
342 return g_value_get_boxed (handler_return) == NULL;
345 static GQuark quark_pointer_window = 0;
348 gdk_window_class_init (GdkWindowClass *klass)
350 GObjectClass *object_class = G_OBJECT_CLASS (klass);
352 parent_class = g_type_class_peek_parent (klass);
354 object_class->finalize = gdk_window_finalize;
355 object_class->set_property = gdk_window_set_property;
356 object_class->get_property = gdk_window_get_property;
358 klass->create_surface = _gdk_offscreen_window_create_surface;
360 quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
368 * The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and
369 * gdk_window_get_cursor() for details.
373 g_object_class_install_property (object_class,
375 g_param_spec_object ("cursor",
382 * GdkWindow::pick-embedded-child:
383 * @window: the window on which the signal is emitted
384 * @x: x coordinate in the window
385 * @y: y coordinate in the window
387 * The ::pick-embedded-child signal is emitted to find an embedded
388 * child at the given position.
390 * Returns: (transfer none): the #GdkWindow of the embedded child at
395 signals[PICK_EMBEDDED_CHILD] =
396 g_signal_new (g_intern_static_string ("pick-embedded-child"),
397 G_OBJECT_CLASS_TYPE (object_class),
399 G_STRUCT_OFFSET (GdkWindowClass, pick_embedded_child),
400 accumulate_get_window, NULL,
401 _gdk_marshal_OBJECT__DOUBLE_DOUBLE,
408 * GdkWindow::to-embedder:
409 * @window: the offscreen window on which the signal is emitted
410 * @offscreen-x: x coordinate in the offscreen window
411 * @offscreen-y: y coordinate in the offscreen window
412 * @embedder-x: (out) (type double): return location for the x
413 * coordinate in the embedder window
414 * @embedder-y: (out) (type double): return location for the y
415 * coordinate in the embedder window
417 * The ::to-embedder signal is emitted to translate coordinates
418 * in an offscreen window to its embedder.
420 * See also #GtkWindow::from-embedder.
424 signals[TO_EMBEDDER] =
425 g_signal_new (g_intern_static_string ("to-embedder"),
426 G_OBJECT_CLASS_TYPE (object_class),
428 G_STRUCT_OFFSET (GdkWindowClass, to_embedder),
430 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
439 * GdkWindow::from-embedder:
440 * @window: the offscreen window on which the signal is emitted
441 * @embedder-x: x coordinate in the embedder window
442 * @embedder-y: y coordinate in the embedder window
443 * @offscreen-x: (out) (type double): return location for the x
444 * coordinate in the offscreen window
445 * @offscreen-y: (out) (type double): return location for the y
446 * coordinate in the offscreen window
448 * The ::from-embedder signal is emitted to translate coordinates
449 * in the embedder of an offscreen window to the offscreen window.
451 * See also #GtkWindow::to-embedder.
455 signals[FROM_EMBEDDER] =
456 g_signal_new (g_intern_static_string ("from-embedder"),
457 G_OBJECT_CLASS_TYPE (object_class),
459 G_STRUCT_OFFSET (GdkWindowClass, from_embedder),
461 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
470 * GdkWindow::create-surface:
471 * @window: the offscreen window on which the signal is emitted
472 * @width: the width of the offscreen surface to create
473 * @height: the height of the offscreen surface to create
475 * The ::create-surface signal is emitted when an offscreen window
476 * needs its surface (re)created, which happens either when the the
477 * window is first drawn to, or when the window is being
478 * resized. The first signal handler that returns a non-%NULL
479 * surface will stop any further signal emission, and its surface
482 * Note that it is not possible to access the window's previous
483 * surface from within any callback of this signal. Calling
484 * gdk_offscreen_window_get_surface() will lead to a crash.
486 * Returns: the newly created #cairo_surface_t for the offscreen window
490 signals[CREATE_SURFACE] =
491 g_signal_new (g_intern_static_string ("create-surface"),
492 G_OBJECT_CLASS_TYPE (object_class),
494 G_STRUCT_OFFSET (GdkWindowClass, create_surface),
495 create_surface_accumulator, NULL,
496 _gdk_marshal_BOXED__INT_INT,
497 CAIRO_GOBJECT_TYPE_SURFACE,
504 device_removed_cb (GdkDeviceManager *device_manager,
508 window->devices_inside = g_list_remove (window->devices_inside, device);
509 g_hash_table_remove (window->device_cursor, device);
511 if (window->device_events)
512 g_hash_table_remove (window->device_events, device);
516 gdk_window_finalize (GObject *object)
518 GdkWindow *window = GDK_WINDOW (object);
519 GdkDeviceManager *device_manager;
521 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
522 g_signal_handlers_disconnect_by_func (device_manager, device_removed_cb, window);
524 if (!GDK_WINDOW_DESTROYED (window))
526 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
528 g_warning ("losing last reference to undestroyed window\n");
529 _gdk_window_destroy (window, FALSE);
532 /* We use TRUE here, to keep us from actually calling
533 * XDestroyWindow() on the window
535 _gdk_window_destroy (window, TRUE);
538 gdk_window_drop_cairo_surface (window);
542 g_object_unref (window->impl);
546 if (window->impl_window != window)
548 g_object_unref (window->impl_window);
549 window->impl_window = NULL;
553 cairo_region_destroy (window->shape);
555 if (window->input_shape)
556 cairo_region_destroy (window->input_shape);
559 g_object_unref (window->cursor);
561 if (window->device_cursor)
562 g_hash_table_destroy (window->device_cursor);
564 if (window->device_events)
565 g_hash_table_destroy (window->device_events);
567 if (window->source_event_masks)
568 g_hash_table_destroy (window->source_event_masks);
570 if (window->devices_inside)
571 g_list_free (window->devices_inside);
573 G_OBJECT_CLASS (parent_class)->finalize (object);
577 gdk_window_set_property (GObject *object,
582 GdkWindow *window = (GdkWindow *)object;
587 gdk_window_set_cursor (window, g_value_get_object (value));
591 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
597 gdk_window_get_property (GObject *object,
602 GdkWindow *window = (GdkWindow *) object;
607 g_value_set_object (value, gdk_window_get_cursor (window));
611 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
617 gdk_window_is_offscreen (GdkWindow *window)
619 return window->window_type == GDK_WINDOW_OFFSCREEN;
623 gdk_window_get_impl_window (GdkWindow *window)
625 return window->impl_window;
629 _gdk_window_get_impl_window (GdkWindow *window)
631 return gdk_window_get_impl_window (window);
635 gdk_window_has_impl (GdkWindow *window)
637 return window->impl_window == window;
641 gdk_window_is_toplevel (GdkWindow *window)
644 window->parent == NULL ||
645 window->parent->window_type == GDK_WINDOW_ROOT;
649 _gdk_window_has_impl (GdkWindow *window)
651 return gdk_window_has_impl (window);
655 gdk_window_has_no_impl (GdkWindow *window)
657 return window->impl_window != window;
661 remove_child_area (GdkWindow *private,
664 cairo_region_t *region)
667 cairo_region_t *child_region;
670 cairo_region_t *shape;
672 for (l = private->children; l; l = l->next)
679 /* If region is empty already, no need to do
680 anything potentially costly */
681 if (cairo_region_is_empty (region))
684 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
687 /* Ignore offscreen children, as they don't draw in their parent and
688 * don't take part in the clipping */
689 if (gdk_window_is_offscreen (child))
694 r.width = child->width;
695 r.height = child->height;
697 /* Bail early if child totally outside region */
698 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
701 child_region = cairo_region_create_rectangle (&r);
705 /* Adjust shape region to parent window coords */
706 cairo_region_translate (child->shape, child->x, child->y);
707 cairo_region_intersect (child_region, child->shape);
708 cairo_region_translate (child->shape, -child->x, -child->y);
710 else if (private->window_type == GDK_WINDOW_FOREIGN)
712 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_shape (child);
715 cairo_region_intersect (child_region, shape);
716 cairo_region_destroy (shape);
722 if (child->input_shape)
723 cairo_region_intersect (child_region, child->input_shape);
724 else if (private->window_type == GDK_WINDOW_FOREIGN)
726 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_input_shape (child);
729 cairo_region_intersect (child_region, shape);
730 cairo_region_destroy (shape);
735 cairo_region_subtract (region, child_region);
736 cairo_region_destroy (child_region);
741 static GdkVisibilityState
742 effective_visibility (GdkWindow *window)
744 GdkVisibilityState native;
746 if (!gdk_window_is_viewable (window))
747 return GDK_VISIBILITY_NOT_VIEWABLE;
749 native = window->impl_window->native_visibility;
751 if (native == GDK_VISIBILITY_FULLY_OBSCURED ||
752 window->visibility == GDK_VISIBILITY_FULLY_OBSCURED)
753 return GDK_VISIBILITY_FULLY_OBSCURED;
754 else if (native == GDK_VISIBILITY_UNOBSCURED)
755 return window->visibility;
756 else /* native PARTIAL, private partial or unobscured */
757 return GDK_VISIBILITY_PARTIAL;
761 gdk_window_update_visibility (GdkWindow *window)
763 GdkVisibilityState new_visibility;
766 new_visibility = effective_visibility (window);
768 if (new_visibility != window->effective_visibility)
770 window->effective_visibility = new_visibility;
772 if (new_visibility != GDK_VISIBILITY_NOT_VIEWABLE &&
773 window->event_mask & GDK_VISIBILITY_NOTIFY)
775 event = _gdk_make_event (window, GDK_VISIBILITY_NOTIFY,
777 event->visibility.state = new_visibility;
783 gdk_window_update_visibility_recursively (GdkWindow *window,
784 GdkWindow *only_for_impl)
789 gdk_window_update_visibility (window);
790 for (l = window->children; l != NULL; l = l->next)
793 if ((only_for_impl == NULL) ||
794 (only_for_impl == child->impl_window))
795 gdk_window_update_visibility_recursively (child, only_for_impl);
800 should_apply_clip_as_shape (GdkWindow *window)
803 gdk_window_has_impl (window) &&
804 /* Not for offscreens */
805 !gdk_window_is_offscreen (window) &&
806 /* or for toplevels */
807 !gdk_window_is_toplevel (window) &&
808 /* or for foreign windows */
809 window->window_type != GDK_WINDOW_FOREIGN &&
810 /* or for the root window */
811 window->window_type != GDK_WINDOW_ROOT;
815 apply_shape (GdkWindow *window,
816 cairo_region_t *region)
818 GdkWindowImplClass *impl_class;
820 /* We trash whether we applied a shape so that
821 we can avoid unsetting it many times, which
822 could happen in e.g. apply_clip_as_shape as
823 windows get resized */
824 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
826 impl_class->shape_combine_region (window,
828 else if (window->applied_shape)
829 impl_class->shape_combine_region (window,
832 window->applied_shape = region != NULL;
836 region_rect_equal (const cairo_region_t *region,
837 const GdkRectangle *rect)
839 GdkRectangle extents;
841 if (cairo_region_num_rectangles (region) != 1)
844 cairo_region_get_extents (region, &extents);
846 return extents.x == rect->x &&
847 extents.y == rect->y &&
848 extents.width == rect->width &&
849 extents.height == rect->height;
853 apply_clip_as_shape (GdkWindow *window)
858 r.width = window->width;
859 r.height = window->height;
861 /* We only apply the clip region if would differ
862 from the actual clip region implied by the size
863 of the window. This is to avoid unneccessarily
864 adding meaningless shapes to all native subwindows */
865 if (!region_rect_equal (window->clip_region, &r))
866 apply_shape (window, window->clip_region);
868 apply_shape (window, NULL);
872 recompute_visible_regions_internal (GdkWindow *private,
873 gboolean recalculate_clip,
874 gboolean recalculate_siblings,
875 gboolean recalculate_children)
880 cairo_region_t *new_clip, *old_clip_region_with_children;
881 gboolean clip_region_changed;
882 gboolean abs_pos_changed;
883 int old_abs_x, old_abs_y;
885 old_abs_x = private->abs_x;
886 old_abs_y = private->abs_y;
888 /* Update absolute position */
889 if (gdk_window_has_impl (private))
891 /* Native window starts here */
897 private->abs_x = private->parent->abs_x + private->x;
898 private->abs_y = private->parent->abs_y + private->y;
902 private->abs_x != old_abs_x ||
903 private->abs_y != old_abs_y;
905 /* Update clip region based on:
908 * siblings in parents above window
910 clip_region_changed = FALSE;
911 if (recalculate_clip)
913 if (private->viewable)
915 /* Calculate visible region (sans children) in parent window coords */
918 r.width = private->width;
919 r.height = private->height;
920 new_clip = cairo_region_create_rectangle (&r);
922 if (!gdk_window_is_toplevel (private))
924 cairo_region_intersect (new_clip, private->parent->clip_region);
926 /* Remove all overlapping children from parent. */
927 remove_child_area (private->parent, private, FALSE, new_clip);
930 /* Convert from parent coords to window coords */
931 cairo_region_translate (new_clip, -private->x, -private->y);
934 cairo_region_intersect (new_clip, private->shape);
937 new_clip = cairo_region_create ();
939 if (private->clip_region == NULL ||
940 !cairo_region_equal (private->clip_region, new_clip))
941 clip_region_changed = TRUE;
943 if (private->clip_region)
944 cairo_region_destroy (private->clip_region);
945 private->clip_region = new_clip;
947 old_clip_region_with_children = private->clip_region_with_children;
948 private->clip_region_with_children = cairo_region_copy (private->clip_region);
949 if (private->window_type != GDK_WINDOW_ROOT)
950 remove_child_area (private, NULL, FALSE, private->clip_region_with_children);
952 if (clip_region_changed ||
953 !cairo_region_equal (private->clip_region_with_children, old_clip_region_with_children))
954 private->clip_tag = new_region_tag ();
956 if (old_clip_region_with_children)
957 cairo_region_destroy (old_clip_region_with_children);
960 if (clip_region_changed)
962 GdkVisibilityState visibility;
963 gboolean fully_visible;
965 if (cairo_region_is_empty (private->clip_region))
966 visibility = GDK_VISIBILITY_FULLY_OBSCURED;
971 fully_visible = cairo_region_equal (private->clip_region,
978 r.width = private->width;
979 r.height = private->height;
980 fully_visible = region_rect_equal (private->clip_region, &r);
984 visibility = GDK_VISIBILITY_UNOBSCURED;
986 visibility = GDK_VISIBILITY_PARTIAL;
989 if (private->visibility != visibility)
991 private->visibility = visibility;
992 gdk_window_update_visibility (private);
996 /* Update all children, recursively (except for root, where children are not exact). */
997 if ((abs_pos_changed || clip_region_changed || recalculate_children) &&
998 private->window_type != GDK_WINDOW_ROOT)
1000 for (l = private->children; l; l = l->next)
1003 /* Only recalculate clip if the the clip region changed, otherwise
1004 * there is no way the child clip region could change (its has not e.g. moved)
1005 * Except if recalculate_children is set to force child updates
1007 recompute_visible_regions_internal (child,
1008 recalculate_clip && (clip_region_changed || recalculate_children),
1013 if (clip_region_changed &&
1014 should_apply_clip_as_shape (private))
1015 apply_clip_as_shape (private);
1017 if (recalculate_siblings &&
1018 !gdk_window_is_toplevel (private))
1020 /* If we moved a child window in parent or changed the stacking order, then we
1021 * need to recompute the visible area of all the other children in the parent
1023 for (l = private->parent->children; l; l = l->next)
1027 if (child != private)
1028 recompute_visible_regions_internal (child, TRUE, FALSE, FALSE);
1031 /* We also need to recompute the _with_children clip for the parent */
1032 recompute_visible_regions_internal (private->parent, TRUE, FALSE, FALSE);
1035 if (private->cairo_surface && gdk_window_has_impl (private))
1037 GdkWindowImplClass *iface = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1039 private->cairo_surface = iface->resize_cairo_surface (private,
1040 private->cairo_surface,
1044 else if (private->cairo_surface)
1045 gdk_window_drop_cairo_surface (private);
1048 /* Call this when private has changed in one or more of these ways:
1052 * stacking order of window changed
1055 * It will recalculate abs_x/y and the clip regions
1057 * Unless the window didn't change stacking order or size/pos, pass in TRUE
1058 * for recalculate_siblings. (Mostly used internally for the recursion)
1060 * If a child window was removed (and you can't use that child for
1061 * recompute_visible_regions), pass in TRUE for recalculate_children on the parent
1064 recompute_visible_regions (GdkWindow *private,
1065 gboolean recalculate_siblings,
1066 gboolean recalculate_children)
1068 recompute_visible_regions_internal (private,
1070 recalculate_siblings,
1071 recalculate_children);
1075 _gdk_window_update_size (GdkWindow *window)
1077 recompute_visible_regions (window, TRUE, FALSE);
1080 /* Find the native window that would be just above "child"
1081 * in the native stacking order if "child" was a native window
1082 * (it doesn't have to be native). If there is no such native
1083 * window inside this native parent then NULL is returned.
1084 * If child is NULL, find lowest native window in parent.
1087 find_native_sibling_above_helper (GdkWindow *parent,
1095 l = g_list_find (parent->children, child);
1096 g_assert (l != NULL); /* Better be a child of its parent... */
1097 l = l->prev; /* Start looking at the one above the child */
1100 l = g_list_last (parent->children);
1102 for (; l != NULL; l = l->prev)
1106 if (gdk_window_has_impl (w))
1109 g_assert (parent != w);
1110 w = find_native_sibling_above_helper (w, NULL);
1120 find_native_sibling_above (GdkWindow *parent,
1125 w = find_native_sibling_above_helper (parent, child);
1129 if (gdk_window_has_impl (parent))
1132 return find_native_sibling_above (parent->parent, parent);
1136 get_native_device_event_mask (GdkWindow *private,
1139 GdkEventMask event_mask;
1142 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device));
1144 event_mask = private->event_mask;
1146 if (private->window_type == GDK_WINDOW_ROOT ||
1147 private->window_type == GDK_WINDOW_FOREIGN)
1153 /* Do whatever the app asks to, since the app
1154 * may be asking for weird things for native windows,
1155 * but don't use motion hints as that may affect non-native
1156 * child windows that don't want it. Also, we need to
1157 * set all the app-specified masks since they will be picked
1158 * up by any implicit grabs (i.e. if they were not set as
1159 * native we would not get the events we need). */
1160 mask = private->event_mask & ~GDK_POINTER_MOTION_HINT_MASK;
1162 /* We need thse for all native windows so we can
1163 emulate events on children: */
1166 GDK_VISIBILITY_NOTIFY_MASK |
1167 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
1169 /* Additionally we select for pointer and button events
1170 * for toplevels as we need to get these to emulate
1171 * them for non-native subwindows. Even though we don't
1172 * select on them for all native windows we will get them
1173 * as the events are propagated out to the first window
1174 * that select for them.
1175 * Not selecting for button press on all windows is an
1176 * important thing, because in X only one client can do
1177 * so, and we don't want to unexpectedly prevent another
1178 * client from doing it.
1180 * We also need to do the same if the app selects for button presses
1181 * because then we will get implicit grabs for this window, and the
1182 * event mask used for that grab is based on the rest of the mask
1183 * for the window, but we might need more events than this window
1184 * lists due to some non-native child window.
1186 if (gdk_window_is_toplevel (private) ||
1187 mask & GDK_BUTTON_PRESS_MASK)
1189 GDK_POINTER_MOTION_MASK |
1190 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1198 get_native_grab_event_mask (GdkEventMask grab_mask)
1200 /* Similar to the above but for pointer events only */
1202 GDK_POINTER_MOTION_MASK |
1203 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1204 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
1207 ~GDK_POINTER_MOTION_HINT_MASK);
1211 get_native_event_mask (GdkWindow *private)
1213 return get_native_device_event_mask (private, NULL);
1216 /* Puts the native window in the right order wrt the other native windows
1217 * in the hierarchy, given the position it has in the client side data.
1218 * This is useful if some operation changed the stacking order.
1219 * This calls assumes the native window is now topmost in its native parent.
1222 sync_native_window_stack_position (GdkWindow *window)
1225 GdkWindowImplClass *impl_class;
1226 GList listhead = {0};
1228 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1230 above = find_native_sibling_above (window->parent, window);
1233 listhead.data = window;
1234 impl_class->restack_under (above, &listhead);
1239 * gdk_window_new: (constructor)
1240 * @parent: (allow-none): a #GdkWindow, or %NULL to create the window as a child of
1241 * the default root window for the default display.
1242 * @attributes: attributes of the new window
1243 * @attributes_mask: mask indicating which fields in @attributes are valid
1245 * Creates a new #GdkWindow using the attributes from
1246 * @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
1247 * more details. Note: to use this on displays other than the default
1248 * display, @parent must be specified.
1250 * Return value: (transfer full): the new #GdkWindow
1253 gdk_window_new (GdkWindow *parent,
1254 GdkWindowAttr *attributes,
1255 gint attributes_mask)
1259 GdkDisplay *display;
1262 GdkEventMask event_mask;
1263 GdkWindow *real_parent;
1264 GdkDeviceManager *device_manager;
1266 g_return_val_if_fail (attributes != NULL, NULL);
1270 GDK_NOTE (MULTIHEAD,
1271 g_warning ("gdk_window_new(): no parent specified reverting to parent = default root window"));
1273 screen = gdk_screen_get_default ();
1274 parent = gdk_screen_get_root_window (screen);
1277 screen = gdk_window_get_screen (parent);
1279 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
1281 if (GDK_WINDOW_DESTROYED (parent))
1283 g_warning ("gdk_window_new(): parent is destroyed\n");
1287 display = gdk_screen_get_display (screen);
1289 window = _gdk_display_create_window (display);
1291 /* Windows with a foreign parent are treated as if they are children
1292 * of the root window, except for actual creation.
1294 real_parent = parent;
1295 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
1296 parent = gdk_screen_get_root_window (screen);
1298 window->parent = parent;
1300 window->accept_focus = TRUE;
1301 window->focus_on_map = TRUE;
1303 if (attributes_mask & GDK_WA_X)
1308 if (attributes_mask & GDK_WA_Y)
1315 window->width = (attributes->width > 1) ? (attributes->width) : (1);
1316 window->height = (attributes->height > 1) ? (attributes->height) : (1);
1318 if (attributes->wclass == GDK_INPUT_ONLY)
1320 /* Backwards compatiblity - we've always ignored
1321 * attributes->window_type for input-only windows
1324 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_ROOT)
1325 window->window_type = GDK_WINDOW_TEMP;
1327 window->window_type = GDK_WINDOW_CHILD;
1330 window->window_type = attributes->window_type;
1333 switch (window->window_type)
1335 case GDK_WINDOW_TOPLEVEL:
1336 case GDK_WINDOW_TEMP:
1337 case GDK_WINDOW_OFFSCREEN:
1338 if (GDK_WINDOW_TYPE (parent) != GDK_WINDOW_ROOT)
1339 g_warning (G_STRLOC "Toplevel windows must be created as children of\n"
1340 "of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
1341 case GDK_WINDOW_CHILD:
1345 g_warning (G_STRLOC "cannot make windows of type %d", window->window_type);
1349 if (attributes_mask & GDK_WA_VISUAL)
1350 window->visual = attributes->visual;
1352 window->visual = gdk_screen_get_system_visual (screen);
1354 window->event_mask = attributes->event_mask;
1356 if (attributes->wclass == GDK_INPUT_OUTPUT)
1358 window->input_only = FALSE;
1359 window->depth = window->visual->depth;
1361 /* XXX: Cache this somehow? */
1362 window->background = cairo_pattern_create_rgb (0, 0, 0);
1367 window->input_only = TRUE;
1371 window->parent->children = g_list_prepend (window->parent->children, window);
1374 if (window->parent->window_type == GDK_WINDOW_ROOT)
1375 native = TRUE; /* Always use native windows for toplevels */
1376 else if (!window->input_only &&
1377 (attributes_mask & GDK_WA_VISUAL &&
1378 attributes->visual != gdk_window_get_visual (window->parent)))
1379 native = TRUE; /* InputOutput window with different visual than parent, needs native window */
1381 if (gdk_window_is_offscreen (window))
1383 _gdk_offscreen_window_new (window, attributes, attributes_mask);
1384 window->impl_window = window;
1388 event_mask = get_native_event_mask (window);
1390 /* Create the impl */
1391 _gdk_display_create_window_impl (display, window, real_parent, screen, event_mask, attributes, attributes_mask);
1392 window->impl_window = window;
1394 /* This will put the native window topmost in the native parent, which may
1395 * be wrong wrt other native windows in the non-native hierarchy, so restack */
1396 if (!_gdk_window_has_impl (real_parent))
1397 sync_native_window_stack_position (window);
1401 window->impl_window = g_object_ref (window->parent->impl_window);
1402 window->impl = g_object_ref (window->impl_window->impl);
1405 recompute_visible_regions (window, TRUE, FALSE);
1407 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
1408 (attributes->cursor) :
1411 device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent));
1412 g_signal_connect (device_manager, "device-removed",
1413 G_CALLBACK (device_removed_cb), window);
1419 is_parent_of (GdkWindow *parent,
1430 w = gdk_window_get_parent (w);
1437 change_impl (GdkWindow *private,
1438 GdkWindow *impl_window,
1443 GdkWindowImpl *old_impl;
1444 GdkWindow *old_impl_window;
1446 old_impl = private->impl;
1447 old_impl_window = private->impl_window;
1448 if (private != impl_window)
1449 private->impl_window = g_object_ref (impl_window);
1451 private->impl_window = private;
1452 private->impl = g_object_ref (new);
1453 if (old_impl_window != private)
1454 g_object_unref (old_impl_window);
1455 g_object_unref (old_impl);
1457 for (l = private->children; l != NULL; l = l->next)
1461 if (child->impl == old_impl)
1462 change_impl (child, impl_window, new);
1467 reparent_to_impl (GdkWindow *private)
1472 GdkWindowImplClass *impl_class;
1474 impl_class = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1476 /* Enumerate in reverse order so we get the right order for the native
1477 windows (first in childrens list is topmost, and reparent places on top) */
1478 for (l = g_list_last (private->children); l != NULL; l = l->prev)
1482 if (child->impl == private->impl)
1483 reparent_to_impl (child);
1486 show = impl_class->reparent ((GdkWindow *)child,
1487 (GdkWindow *)private,
1488 child->x, child->y);
1490 gdk_window_show_unraised ((GdkWindow *)child);
1497 * gdk_window_reparent:
1498 * @window: a #GdkWindow
1499 * @new_parent: new parent to move @window into
1500 * @x: X location inside the new parent
1501 * @y: Y location inside the new parent
1503 * Reparents @window into the given @new_parent. The window being
1504 * reparented will be unmapped as a side effect.
1508 gdk_window_reparent (GdkWindow *window,
1509 GdkWindow *new_parent,
1513 GdkWindow *old_parent;
1515 gboolean show, was_mapped, applied_clip_as_shape;
1516 gboolean do_reparent_to_impl;
1517 GdkEventMask old_native_event_mask;
1518 GdkWindowImplClass *impl_class;
1520 g_return_if_fail (GDK_IS_WINDOW (window));
1521 g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1522 g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1524 if (GDK_WINDOW_DESTROYED (window) ||
1525 (new_parent && GDK_WINDOW_DESTROYED (new_parent)))
1528 screen = gdk_window_get_screen (window);
1530 new_parent = gdk_screen_get_root_window (screen);
1532 /* No input-output children of input-only windows */
1533 if (new_parent->input_only && !window->input_only)
1536 /* Don't create loops in hierarchy */
1537 if (is_parent_of (window, new_parent))
1540 /* This might be wrong in the new parent, e.g. for non-native surfaces.
1541 To make sure we're ok, just wipe it. */
1542 gdk_window_drop_cairo_surface (window);
1544 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1545 old_parent = window->parent;
1547 was_mapped = GDK_WINDOW_IS_MAPPED (window);
1550 /* Reparenting to toplevel. Ensure we have a native window so this can work */
1551 if (new_parent->window_type == GDK_WINDOW_ROOT ||
1552 new_parent->window_type == GDK_WINDOW_FOREIGN)
1553 gdk_window_ensure_native (window);
1555 applied_clip_as_shape = should_apply_clip_as_shape (window);
1557 old_native_event_mask = 0;
1558 do_reparent_to_impl = FALSE;
1559 if (gdk_window_has_impl (window))
1561 old_native_event_mask = get_native_event_mask (window);
1563 show = impl_class->reparent (window, new_parent, x, y);
1567 /* This shouldn't happen, as we created a native in this case, check anyway to see if that ever fails */
1568 g_assert (new_parent->window_type != GDK_WINDOW_ROOT &&
1569 new_parent->window_type != GDK_WINDOW_FOREIGN);
1572 gdk_window_hide (window);
1574 do_reparent_to_impl = TRUE;
1575 change_impl (window,
1576 new_parent->impl_window,
1580 /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1583 if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1585 new_parent = gdk_screen_get_root_window (screen);
1589 old_parent->children = g_list_remove (old_parent->children, window);
1591 window->parent = new_parent;
1595 new_parent->children = g_list_prepend (new_parent->children, window);
1597 /* Switch the window type as appropriate */
1599 switch (GDK_WINDOW_TYPE (new_parent))
1601 case GDK_WINDOW_ROOT:
1602 case GDK_WINDOW_FOREIGN:
1603 if (window->toplevel_window_type != -1)
1604 GDK_WINDOW_TYPE (window) = window->toplevel_window_type;
1605 else if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
1606 GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
1608 case GDK_WINDOW_OFFSCREEN:
1609 case GDK_WINDOW_TOPLEVEL:
1610 case GDK_WINDOW_CHILD:
1611 case GDK_WINDOW_TEMP:
1612 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
1613 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
1615 /* Save the original window type so we can restore it if the
1616 * window is reparented back to be a toplevel
1618 window->toplevel_window_type = GDK_WINDOW_TYPE (window);
1619 GDK_WINDOW_TYPE (window) = GDK_WINDOW_CHILD;
1623 /* We might have changed window type for a native windows, so we
1624 need to change the event mask too. */
1625 if (gdk_window_has_impl (window))
1627 GdkEventMask native_event_mask = get_native_event_mask (window);
1629 if (native_event_mask != old_native_event_mask)
1630 impl_class->set_events (window, native_event_mask);
1633 _gdk_window_update_viewable (window);
1635 recompute_visible_regions (window, TRUE, FALSE);
1636 if (old_parent && GDK_WINDOW_TYPE (old_parent) != GDK_WINDOW_ROOT)
1637 recompute_visible_regions (old_parent, FALSE, TRUE);
1639 /* We used to apply the clip as the shape, but no more.
1640 Reset this to the real shape */
1641 if (gdk_window_has_impl (window) &&
1642 applied_clip_as_shape &&
1643 !should_apply_clip_as_shape (window))
1644 apply_shape (window, window->shape);
1646 if (do_reparent_to_impl)
1647 reparent_to_impl (window);
1650 /* The reparent will have put the native window topmost in the native parent,
1651 * which may be wrong wrt other native windows in the non-native hierarchy,
1653 if (!gdk_window_has_impl (new_parent))
1654 sync_native_window_stack_position (window);
1658 gdk_window_show_unraised (window);
1660 _gdk_synthesize_crossing_events_for_geometry_change (window);
1664 * gdk_window_ensure_native:
1665 * @window: a #GdkWindow
1667 * Tries to ensure that there is a window-system native window for this
1668 * GdkWindow. This may fail in some situations, returning %FALSE.
1670 * Offscreen window and children of them can never have native windows.
1672 * Some backends may not support native child windows.
1674 * Returns: %TRUE if the window has a native window, %FALSE otherwise
1679 gdk_window_ensure_native (GdkWindow *window)
1681 GdkWindow *impl_window;
1682 GdkWindowImpl *new_impl, *old_impl;
1683 GdkDisplay *display;
1687 GdkWindowImplClass *impl_class;
1689 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
1691 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_ROOT ||
1692 GDK_WINDOW_DESTROYED (window))
1695 impl_window = gdk_window_get_impl_window (window);
1697 if (gdk_window_is_offscreen (impl_window))
1698 return FALSE; /* native in offscreens not supported */
1700 if (impl_window == window)
1701 /* Already has an impl, and its not offscreen . */
1704 /* Need to create a native window */
1706 gdk_window_drop_cairo_surface (window);
1708 screen = gdk_window_get_screen (window);
1709 display = gdk_screen_get_display (screen);
1711 old_impl = window->impl;
1712 _gdk_display_create_window_impl (display,
1713 window, window->parent,
1715 get_native_event_mask (window),
1717 new_impl = window->impl;
1719 window->impl = old_impl;
1720 change_impl (window, window, new_impl);
1722 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1724 /* Native window creation will put the native window topmost in the
1725 * native parent, which may be wrong wrt the position of the previous
1726 * non-native window wrt to the other non-native children, so correct this.
1728 above = find_native_sibling_above (window->parent, window);
1731 listhead.data = window;
1732 listhead.prev = NULL;
1733 listhead.next = NULL;
1734 impl_class->restack_under ((GdkWindow *)above, &listhead);
1737 recompute_visible_regions (window, FALSE, FALSE);
1739 /* The shape may not have been set, as the clip region doesn't actually
1740 change, so do it here manually */
1741 if (should_apply_clip_as_shape (window))
1742 apply_clip_as_shape (window);
1744 reparent_to_impl (window);
1746 if (!window->input_only)
1747 impl_class->set_background (window, window->background);
1749 impl_class->input_shape_combine_region (window,
1750 window->input_shape,
1753 if (gdk_window_is_viewable (window))
1754 impl_class->show (window, FALSE);
1760 * _gdk_event_filter_unref:
1761 * @window: (allow-none): A #GdkWindow, or %NULL to be the global window
1762 * @filter: A window filter
1764 * Release a reference to @filter. Note this function may
1765 * mutate the list storage, so you need to handle this
1766 * if iterating over a list of filters.
1769 _gdk_event_filter_unref (GdkWindow *window,
1770 GdkEventFilter *filter)
1776 filters = &_gdk_default_filters;
1778 filters = &window->filters;
1780 tmp_list = *filters;
1783 GdkEventFilter *iter_filter = tmp_list->data;
1787 tmp_list = tmp_list->next;
1789 if (iter_filter != filter)
1792 g_assert (iter_filter->ref_count > 0);
1794 filter->ref_count--;
1795 if (filter->ref_count != 0)
1798 *filters = g_list_remove_link (*filters, node);
1800 g_list_free_1 (node);
1805 window_remove_filters (GdkWindow *window)
1807 while (window->filters)
1808 _gdk_event_filter_unref (window, window->filters->data);
1812 update_pointer_info_foreach (GdkDisplay *display,
1814 GdkPointerWindowInfo *pointer_info,
1817 GdkWindow *window = user_data;
1819 if (pointer_info->toplevel_under_pointer == window)
1821 g_object_unref (pointer_info->toplevel_under_pointer);
1822 pointer_info->toplevel_under_pointer = NULL;
1827 window_remove_from_pointer_info (GdkWindow *window,
1828 GdkDisplay *display)
1830 _gdk_display_pointer_info_foreach (display,
1831 update_pointer_info_foreach,
1836 * _gdk_window_destroy_hierarchy:
1837 * @window: a #GdkWindow
1838 * @recursing: If TRUE, then this is being called because a parent
1840 * @recursing_native: If TRUE, then this is being called because a native parent
1841 * was destroyed. This generally means that the call to the
1842 * windowing system to destroy the window can be omitted, since
1843 * it will be destroyed as a result of the parent being destroyed.
1844 * Unless @foreign_destroy.
1845 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
1846 * external agency. The window has already been destroyed and no
1847 * windowing system calls should be made. (This may never happen
1848 * for some windowing systems.)
1850 * Internal function to destroy a window. Like gdk_window_destroy(),
1851 * but does not drop the reference count created by gdk_window_new().
1854 _gdk_window_destroy_hierarchy (GdkWindow *window,
1856 gboolean recursing_native,
1857 gboolean foreign_destroy)
1859 GdkWindowImplClass *impl_class;
1860 GdkWindow *temp_window;
1862 GdkDisplay *display;
1866 g_return_if_fail (GDK_IS_WINDOW (window));
1868 if (GDK_WINDOW_DESTROYED (window))
1871 display = gdk_window_get_display (window);
1872 screen = gdk_window_get_screen (window);
1873 temp_window = g_object_get_qdata (G_OBJECT (screen), quark_pointer_window);
1874 if (temp_window == window)
1875 g_object_set_qdata (G_OBJECT (screen), quark_pointer_window, NULL);
1878 switch (window->window_type)
1880 case GDK_WINDOW_ROOT:
1881 if (!screen->closed)
1883 g_error ("attempted to destroy root window");
1886 /* else fall thru */
1887 case GDK_WINDOW_TOPLEVEL:
1888 case GDK_WINDOW_CHILD:
1889 case GDK_WINDOW_TEMP:
1890 case GDK_WINDOW_FOREIGN:
1891 case GDK_WINDOW_OFFSCREEN:
1892 if (window->window_type == GDK_WINDOW_FOREIGN && !foreign_destroy)
1894 /* Logically, it probably makes more sense to send
1895 * a "destroy yourself" message to the foreign window
1896 * whether or not it's in our hierarchy; but for historical
1897 * reasons, we only send "destroy yourself" messages to
1898 * foreign windows in our hierarchy.
1902 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1904 if (gdk_window_has_impl (window))
1905 impl_class->destroy_foreign (window);
1908 /* Also for historical reasons, we remove any filters
1909 * on a foreign window when it or a parent is destroyed;
1910 * this likely causes problems if two separate portions
1911 * of code are maintaining filter lists on a foreign window.
1913 window_remove_filters (window);
1919 if (window->parent->children)
1920 window->parent->children = g_list_remove (window->parent->children, window);
1923 GDK_WINDOW_IS_MAPPED (window))
1925 recompute_visible_regions (window, TRUE, FALSE);
1926 gdk_window_invalidate_in_parent (window);
1930 gdk_window_free_paint_stack (window);
1932 if (window->background)
1934 cairo_pattern_destroy (window->background);
1935 window->background = NULL;
1938 if (window->window_type == GDK_WINDOW_FOREIGN)
1939 g_assert (window->children == NULL);
1942 children = tmp = window->children;
1943 window->children = NULL;
1947 temp_window = tmp->data;
1951 _gdk_window_destroy_hierarchy (temp_window,
1953 recursing_native || gdk_window_has_impl (window),
1957 g_list_free (children);
1960 _gdk_window_clear_update_area (window);
1962 gdk_window_drop_cairo_surface (window);
1964 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1966 if (gdk_window_has_impl (window))
1967 impl_class->destroy (window, recursing_native,
1971 /* hide to make sure we repaint and break grabs */
1972 gdk_window_hide (window);
1975 window->state |= GDK_WINDOW_STATE_WITHDRAWN;
1976 window->parent = NULL;
1977 window->destroyed = TRUE;
1979 window_remove_filters (window);
1981 window_remove_from_pointer_info (window, display);
1983 if (window->clip_region)
1985 cairo_region_destroy (window->clip_region);
1986 window->clip_region = NULL;
1989 if (window->clip_region_with_children)
1991 cairo_region_destroy (window->clip_region_with_children);
1992 window->clip_region_with_children = NULL;
1995 if (window->outstanding_moves)
1997 g_list_foreach (window->outstanding_moves, (GFunc)gdk_window_region_move_free, NULL);
1998 g_list_free (window->outstanding_moves);
1999 window->outstanding_moves = NULL;
2007 * _gdk_window_destroy:
2008 * @window: a #GdkWindow
2009 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
2010 * external agency. The window has already been destroyed and no
2011 * windowing system calls should be made. (This may never happen
2012 * for some windowing systems.)
2014 * Internal function to destroy a window. Like gdk_window_destroy(),
2015 * but does not drop the reference count created by gdk_window_new().
2018 _gdk_window_destroy (GdkWindow *window,
2019 gboolean foreign_destroy)
2021 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, foreign_destroy);
2025 * gdk_window_destroy:
2026 * @window: a #GdkWindow
2028 * Destroys the window system resources associated with @window and decrements @window's
2029 * reference count. The window system resources for all children of @window are also
2030 * destroyed, but the children's reference counts are not decremented.
2032 * Note that a window will not be destroyed automatically when its reference count
2033 * reaches zero. You must call this function yourself before that happens.
2037 gdk_window_destroy (GdkWindow *window)
2039 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, FALSE);
2040 g_object_unref (window);
2044 * gdk_window_set_user_data:
2045 * @window: a #GdkWindow
2046 * @user_data: (allow-none) (type GObject.Object): user data
2048 * For most purposes this function is deprecated in favor of
2049 * g_object_set_data(). However, for historical reasons GTK+ stores
2050 * the #GtkWidget that owns a #GdkWindow as user data on the
2051 * #GdkWindow. So, custom widget implementations should use
2052 * this function for that. If GTK+ receives an event for a #GdkWindow,
2053 * and the user data for the window is non-%NULL, GTK+ will assume the
2054 * user data is a #GtkWidget, and forward the event to that widget.
2058 gdk_window_set_user_data (GdkWindow *window,
2061 g_return_if_fail (GDK_IS_WINDOW (window));
2063 window->user_data = user_data;
2067 * gdk_window_get_user_data:
2068 * @window: a #GdkWindow
2069 * @data: (out): return location for user data
2071 * Retrieves the user data for @window, which is normally the widget
2072 * that @window belongs to. See gdk_window_set_user_data().
2076 gdk_window_get_user_data (GdkWindow *window,
2079 g_return_if_fail (GDK_IS_WINDOW (window));
2081 *data = window->user_data;
2085 * gdk_window_get_window_type:
2086 * @window: a #GdkWindow
2088 * Gets the type of the window. See #GdkWindowType.
2090 * Return value: type of window
2093 gdk_window_get_window_type (GdkWindow *window)
2095 g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
2097 return GDK_WINDOW_TYPE (window);
2101 * gdk_window_get_visual:
2102 * @window: a #GdkWindow
2104 * Gets the #GdkVisual describing the pixel format of @window.
2106 * Return value: (transfer none): a #GdkVisual
2111 gdk_window_get_visual (GdkWindow *window)
2113 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2115 return window->visual;
2119 * gdk_window_get_screen:
2120 * @window: a #GdkWindow
2122 * Gets the #GdkScreen associated with a #GdkWindow.
2124 * Return value: (transfer none): the #GdkScreen associated with @window
2129 gdk_window_get_screen (GdkWindow *window)
2131 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2133 return gdk_visual_get_screen (window->visual);
2137 * gdk_window_get_display:
2138 * @window: a #GdkWindow
2140 * Gets the #GdkDisplay associated with a #GdkWindow.
2142 * Return value: (transfer none): the #GdkDisplay associated with @window
2147 gdk_window_get_display (GdkWindow *window)
2149 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2151 return gdk_screen_get_display (gdk_visual_get_screen (window->visual));
2154 * gdk_window_is_destroyed:
2155 * @window: a #GdkWindow
2157 * Check to see if a window is destroyed..
2159 * Return value: %TRUE if the window is destroyed
2164 gdk_window_is_destroyed (GdkWindow *window)
2166 return GDK_WINDOW_DESTROYED (window);
2170 to_embedder (GdkWindow *window,
2171 gdouble offscreen_x,
2172 gdouble offscreen_y,
2173 gdouble *embedder_x,
2174 gdouble *embedder_y)
2176 g_signal_emit (window, signals[TO_EMBEDDER], 0,
2177 offscreen_x, offscreen_y,
2178 embedder_x, embedder_y);
2182 from_embedder (GdkWindow *window,
2185 gdouble *offscreen_x,
2186 gdouble *offscreen_y)
2188 g_signal_emit (window, signals[FROM_EMBEDDER], 0,
2189 embedder_x, embedder_y,
2190 offscreen_x, offscreen_y);
2194 * gdk_window_has_native:
2195 * @window: a #GdkWindow
2197 * Checks whether the window has a native window or not. Note that
2198 * you can use gdk_window_ensure_native() if a native window is needed.
2200 * Returns: %TRUE if the %window has a native window, %FALSE otherwise.
2205 gdk_window_has_native (GdkWindow *window)
2207 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2209 return window->parent == NULL || window->parent->impl != window->impl;
2213 * gdk_window_get_position:
2214 * @window: a #GdkWindow
2215 * @x: (out) (allow-none): X coordinate of window
2216 * @y: (out) (allow-none): Y coordinate of window
2218 * Obtains the position of the window as reported in the
2219 * most-recently-processed #GdkEventConfigure. Contrast with
2220 * gdk_window_get_geometry() which queries the X server for the
2221 * current window position, regardless of which events have been
2222 * received or processed.
2224 * The position coordinates are relative to the window's parent window.
2228 gdk_window_get_position (GdkWindow *window,
2232 g_return_if_fail (GDK_IS_WINDOW (window));
2241 * gdk_window_get_parent:
2242 * @window: a #GdkWindow
2244 * Obtains the parent of @window, as known to GDK. Does not query the
2245 * X server; thus this returns the parent as passed to gdk_window_new(),
2246 * not the actual parent. This should never matter unless you're using
2247 * Xlib calls mixed with GDK calls on the X11 platform. It may also
2248 * matter for toplevel windows, because the window manager may choose
2251 * Note that you should use gdk_window_get_effective_parent() when
2252 * writing generic code that walks up a window hierarchy, because
2253 * gdk_window_get_parent() will most likely not do what you expect if
2254 * there are offscreen windows in the hierarchy.
2256 * Return value: (transfer none): parent of @window
2259 gdk_window_get_parent (GdkWindow *window)
2261 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2263 return window->parent;
2267 * gdk_window_get_effective_parent:
2268 * @window: a #GdkWindow
2270 * Obtains the parent of @window, as known to GDK. Works like
2271 * gdk_window_get_parent() for normal windows, but returns the
2272 * window's embedder for offscreen windows.
2274 * See also: gdk_offscreen_window_get_embedder()
2276 * Return value: (transfer none): effective parent of @window
2281 gdk_window_get_effective_parent (GdkWindow *window)
2283 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2285 if (gdk_window_is_offscreen (window))
2286 return gdk_offscreen_window_get_embedder (window);
2288 return window->parent;
2292 * gdk_window_get_toplevel:
2293 * @window: a #GdkWindow
2295 * Gets the toplevel window that's an ancestor of @window.
2297 * Any window type but %GDK_WINDOW_CHILD is considered a
2298 * toplevel window, as is a %GDK_WINDOW_CHILD window that
2299 * has a root window as parent.
2301 * Note that you should use gdk_window_get_effective_toplevel() when
2302 * you want to get to a window's toplevel as seen on screen, because
2303 * gdk_window_get_toplevel() will most likely not do what you expect
2304 * if there are offscreen windows in the hierarchy.
2306 * Return value: (transfer none): the toplevel window containing @window
2309 gdk_window_get_toplevel (GdkWindow *window)
2311 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2313 while (window->window_type == GDK_WINDOW_CHILD)
2315 if (gdk_window_is_toplevel (window))
2317 window = window->parent;
2324 * gdk_window_get_effective_toplevel:
2325 * @window: a #GdkWindow
2327 * Gets the toplevel window that's an ancestor of @window.
2329 * Works like gdk_window_get_toplevel(), but treats an offscreen window's
2330 * embedder as its parent, using gdk_window_get_effective_parent().
2332 * See also: gdk_offscreen_window_get_embedder()
2334 * Return value: (transfer none): the effective toplevel window containing @window
2339 gdk_window_get_effective_toplevel (GdkWindow *window)
2343 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2345 while ((parent = gdk_window_get_effective_parent (window)) != NULL &&
2346 (gdk_window_get_window_type (parent) != GDK_WINDOW_ROOT))
2353 * gdk_window_get_children:
2354 * @window: a #GdkWindow
2356 * Gets the list of children of @window known to GDK.
2357 * This function only returns children created via GDK,
2358 * so for example it's useless when used with the root window;
2359 * it only returns windows an application created itself.
2361 * The returned list must be freed, but the elements in the
2364 * Return value: (transfer container) (element-type GdkWindow):
2365 * list of child windows inside @window
2368 gdk_window_get_children (GdkWindow *window)
2370 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2372 if (GDK_WINDOW_DESTROYED (window))
2375 return g_list_copy (window->children);
2379 * gdk_window_peek_children:
2380 * @window: a #GdkWindow
2382 * Like gdk_window_get_children(), but does not copy the list of
2383 * children, so the list does not need to be freed.
2385 * Return value: (transfer none) (element-type GdkWindow):
2386 * a reference to the list of child windows in @window
2389 gdk_window_peek_children (GdkWindow *window)
2391 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2393 if (GDK_WINDOW_DESTROYED (window))
2396 return window->children;
2400 * gdk_window_add_filter: (skip)
2401 * @window: (allow-none): a #GdkWindow
2402 * @function: filter callback
2403 * @data: data to pass to filter callback
2405 * Adds an event filter to @window, allowing you to intercept events
2406 * before they reach GDK. This is a low-level operation and makes it
2407 * easy to break GDK and/or GTK+, so you have to know what you're
2408 * doing. Pass %NULL for @window to get all events for all windows,
2409 * instead of events for a specific window.
2411 * If you are interested in X GenericEvents, bear in mind that
2412 * XGetEventData() has been already called on the event, and
2413 * XFreeEventData() must not be called within @function.
2416 gdk_window_add_filter (GdkWindow *window,
2417 GdkFilterFunc function,
2421 GdkEventFilter *filter;
2423 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2425 if (window && GDK_WINDOW_DESTROYED (window))
2428 /* Filters are for the native events on the native window, so
2429 ensure there is a native window. */
2431 gdk_window_ensure_native (window);
2434 tmp_list = window->filters;
2436 tmp_list = _gdk_default_filters;
2440 filter = (GdkEventFilter *)tmp_list->data;
2441 if ((filter->function == function) && (filter->data == data))
2443 filter->ref_count++;
2446 tmp_list = tmp_list->next;
2449 filter = g_new (GdkEventFilter, 1);
2450 filter->function = function;
2451 filter->data = data;
2452 filter->ref_count = 1;
2456 window->filters = g_list_append (window->filters, filter);
2458 _gdk_default_filters = g_list_append (_gdk_default_filters, filter);
2462 * gdk_window_remove_filter: (skip)
2463 * @window: a #GdkWindow
2464 * @function: previously-added filter function
2465 * @data: user data for previously-added filter function
2467 * Remove a filter previously added with gdk_window_add_filter().
2470 gdk_window_remove_filter (GdkWindow *window,
2471 GdkFilterFunc function,
2475 GdkEventFilter *filter;
2477 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2480 tmp_list = window->filters;
2482 tmp_list = _gdk_default_filters;
2486 filter = (GdkEventFilter *)tmp_list->data;
2487 tmp_list = tmp_list->next;
2489 if ((filter->function == function) && (filter->data == data))
2491 filter->flags |= GDK_EVENT_FILTER_REMOVED;
2493 _gdk_event_filter_unref (window, filter);
2501 * gdk_screen_get_toplevel_windows:
2502 * @screen: The #GdkScreen where the toplevels are located.
2504 * Obtains a list of all toplevel windows known to GDK on the screen @screen.
2505 * A toplevel window is a child of the root window (see
2506 * gdk_get_default_root_window()).
2508 * The returned list should be freed with g_list_free(), but
2509 * its elements need not be freed.
2511 * Return value: (transfer container) (element-type GdkWindow):
2512 * list of toplevel windows, free with g_list_free()
2517 gdk_screen_get_toplevel_windows (GdkScreen *screen)
2519 GdkWindow * root_window;
2520 GList *new_list = NULL;
2523 g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
2525 root_window = gdk_screen_get_root_window (screen);
2527 tmp_list = root_window->children;
2530 GdkWindow *w = tmp_list->data;
2532 if (w->window_type != GDK_WINDOW_FOREIGN)
2533 new_list = g_list_prepend (new_list, w);
2534 tmp_list = tmp_list->next;
2541 * gdk_window_is_visible:
2542 * @window: a #GdkWindow
2544 * Checks whether the window has been mapped (with gdk_window_show() or
2545 * gdk_window_show_unraised()).
2547 * Return value: %TRUE if the window is mapped
2550 gdk_window_is_visible (GdkWindow *window)
2552 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2554 return GDK_WINDOW_IS_MAPPED (window);
2558 * gdk_window_is_viewable:
2559 * @window: a #GdkWindow
2561 * Check if the window and all ancestors of the window are
2562 * mapped. (This is not necessarily "viewable" in the X sense, since
2563 * we only check as far as we have GDK window parents, not to the root
2566 * Return value: %TRUE if the window is viewable
2569 gdk_window_is_viewable (GdkWindow *window)
2571 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2573 if (window->destroyed)
2576 return window->viewable;
2580 * gdk_window_get_state:
2581 * @window: a #GdkWindow
2583 * Gets the bitwise OR of the currently active window state flags,
2584 * from the #GdkWindowState enumeration.
2586 * Return value: window state bitfield
2589 gdk_window_get_state (GdkWindow *window)
2591 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2593 return window->state;
2596 static cairo_content_t
2597 gdk_window_get_content (GdkWindow *window)
2599 cairo_surface_t *surface;
2600 cairo_content_t content;
2602 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2604 surface = _gdk_window_ref_cairo_surface (window);
2605 content = cairo_surface_get_content (surface);
2606 cairo_surface_destroy (surface);
2611 /* This creates an empty "implicit" paint region for the impl window.
2612 * By itself this does nothing, but real paints to this window
2613 * or children of it can use this surface as backing to avoid allocating
2614 * multiple surfaces for subwindow rendering. When doing so they
2615 * add to the region of the implicit paint region, which will be
2616 * pushed to the window when the implicit paint region is ended.
2617 * Such paints should not copy anything to the window on paint end, but
2618 * should rely on the implicit paint end.
2619 * The implicit paint will be automatically ended if someone draws
2620 * directly to the window or a child window.
2623 gdk_window_begin_implicit_paint (GdkWindow *window, GdkRectangle *rect)
2625 GdkWindowPaint *paint;
2627 g_assert (gdk_window_has_impl (window));
2629 if (GDK_IS_PAINTABLE (window->impl))
2630 return FALSE; /* Implementation does double buffering */
2632 if (window->paint_stack != NULL ||
2633 window->implicit_paint != NULL)
2634 return FALSE; /* Don't stack implicit paints */
2636 /* Never do implicit paints for foreign windows, they don't need
2637 * double buffer combination since they have no client side children,
2638 * and creating surfaces for them is risky since they could disappear
2641 if (window->window_type == GDK_WINDOW_FOREIGN)
2644 paint = g_new (GdkWindowPaint, 1);
2645 paint->region = cairo_region_create (); /* Empty */
2646 paint->uses_implicit = FALSE;
2647 paint->flushed = FALSE;
2648 paint->surface = gdk_window_create_similar_surface (window,
2649 gdk_window_get_content (window),
2650 MAX (rect->width, 1),
2651 MAX (rect->height, 1));
2652 cairo_surface_set_device_offset (paint->surface, -rect->x, -rect->y);
2654 window->implicit_paint = paint;
2659 static cairo_surface_t *
2660 gdk_window_ref_impl_surface (GdkWindow *window)
2662 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->ref_cairo_surface (gdk_window_get_impl_window (window));
2666 gdk_cairo_create_for_impl (GdkWindow *window)
2668 cairo_surface_t *surface;
2671 surface = gdk_window_ref_impl_surface (window);
2672 cr = cairo_create (surface);
2674 cairo_surface_destroy (surface);
2679 /* Ensure that all content related to this (sub)window is pushed to the
2680 native region. If there is an active paint then that area is not
2681 pushed, in order to not show partially finished double buffers. */
2683 gdk_window_flush_implicit_paint (GdkWindow *window)
2685 GdkWindow *impl_window;
2686 GdkWindowPaint *paint;
2687 cairo_region_t *region;
2690 impl_window = gdk_window_get_impl_window (window);
2691 if (impl_window->implicit_paint == NULL)
2694 paint = impl_window->implicit_paint;
2695 paint->flushed = TRUE;
2696 region = cairo_region_copy (window->clip_region_with_children);
2698 /* Don't flush active double buffers, as that may show partially done
2700 for (list = window->paint_stack; list != NULL; list = list->next)
2702 GdkWindowPaint *tmp_paint = list->data;
2704 cairo_region_subtract (region, tmp_paint->region);
2707 cairo_region_translate (region, -window->abs_x, -window->abs_y);
2708 cairo_region_intersect (region, paint->region);
2710 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (region))
2714 /* Remove flushed region from the implicit paint */
2715 cairo_region_subtract (paint->region, region);
2717 /* Some regions are valid, push these to window now */
2718 cr = gdk_cairo_create_for_impl (window);
2719 gdk_cairo_region (cr, region);
2721 cairo_set_source_surface (cr, paint->surface, 0, 0);
2722 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2727 cairo_region_destroy (region);
2730 /* Ends an implicit paint, paired with gdk_window_begin_implicit_paint returning TRUE */
2732 gdk_window_end_implicit_paint (GdkWindow *window)
2734 GdkWindowPaint *paint;
2736 g_assert (gdk_window_has_impl (window));
2738 g_assert (window->implicit_paint != NULL);
2740 paint = window->implicit_paint;
2742 window->implicit_paint = NULL;
2744 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (paint->region))
2748 /* Some regions are valid, push these to window now */
2749 cr = gdk_cairo_create_for_impl (window);
2750 gdk_cairo_region (cr, paint->region);
2752 cairo_set_source_surface (cr, paint->surface, 0, 0);
2753 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2758 cairo_region_destroy (paint->region);
2760 cairo_surface_destroy (paint->surface);
2765 * gdk_window_begin_paint_rect:
2766 * @window: a #GdkWindow
2767 * @rectangle: rectangle you intend to draw to
2769 * A convenience wrapper around gdk_window_begin_paint_region() which
2770 * creates a rectangular region for you. See
2771 * gdk_window_begin_paint_region() for details.
2775 gdk_window_begin_paint_rect (GdkWindow *window,
2776 const GdkRectangle *rectangle)
2778 cairo_region_t *region;
2780 g_return_if_fail (GDK_IS_WINDOW (window));
2782 region = cairo_region_create_rectangle (rectangle);
2783 gdk_window_begin_paint_region (window, region);
2784 cairo_region_destroy (region);
2788 * gdk_window_begin_paint_region:
2789 * @window: a #GdkWindow
2790 * @region: region you intend to draw to
2792 * Indicates that you are beginning the process of redrawing @region.
2793 * A backing store (offscreen buffer) large enough to contain @region
2794 * will be created. The backing store will be initialized with the
2795 * background color or background surface for @window. Then, all
2796 * drawing operations performed on @window will be diverted to the
2797 * backing store. When you call gdk_window_end_paint(), the backing
2798 * store will be copied to @window, making it visible onscreen. Only
2799 * the part of @window contained in @region will be modified; that is,
2800 * drawing operations are clipped to @region.
2802 * The net result of all this is to remove flicker, because the user
2803 * sees the finished product appear all at once when you call
2804 * gdk_window_end_paint(). If you draw to @window directly without
2805 * calling gdk_window_begin_paint_region(), the user may see flicker
2806 * as individual drawing operations are performed in sequence. The
2807 * clipping and background-initializing features of
2808 * gdk_window_begin_paint_region() are conveniences for the
2809 * programmer, so you can avoid doing that work yourself.
2811 * When using GTK+, the widget system automatically places calls to
2812 * gdk_window_begin_paint_region() and gdk_window_end_paint() around
2813 * emissions of the expose_event signal. That is, if you're writing an
2814 * expose event handler, you can assume that the exposed area in
2815 * #GdkEventExpose has already been cleared to the window background,
2816 * is already set as the clip region, and already has a backing store.
2817 * Therefore in most cases, application code need not call
2818 * gdk_window_begin_paint_region(). (You can disable the automatic
2819 * calls around expose events on a widget-by-widget basis by calling
2820 * gtk_widget_set_double_buffered().)
2822 * If you call this function multiple times before calling the
2823 * matching gdk_window_end_paint(), the backing stores are pushed onto
2824 * a stack. gdk_window_end_paint() copies the topmost backing store
2825 * onscreen, subtracts the topmost region from all other regions in
2826 * the stack, and pops the stack. All drawing operations affect only
2827 * the topmost backing store in the stack. One matching call to
2828 * gdk_window_end_paint() is required for each call to
2829 * gdk_window_begin_paint_region().
2833 gdk_window_begin_paint_region (GdkWindow *window,
2834 const cairo_region_t *region)
2836 #ifdef USE_BACKING_STORE
2837 GdkRectangle clip_box;
2838 GdkWindowPaint *paint, *implicit_paint;
2839 GdkWindow *impl_window;
2842 g_return_if_fail (GDK_IS_WINDOW (window));
2844 if (GDK_WINDOW_DESTROYED (window))
2847 if (GDK_IS_PAINTABLE (window->impl))
2849 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2851 if (iface->begin_paint_region)
2852 iface->begin_paint_region ((GdkPaintable*)window->impl, window, region);
2857 impl_window = gdk_window_get_impl_window (window);
2858 implicit_paint = impl_window->implicit_paint;
2860 paint = g_new (GdkWindowPaint, 1);
2861 paint->region = cairo_region_copy (region);
2862 paint->region_tag = new_region_tag ();
2864 cairo_region_intersect (paint->region, window->clip_region_with_children);
2865 cairo_region_get_extents (paint->region, &clip_box);
2867 cairo_region_translate (paint->region, window->abs_x, window->abs_y);
2869 /* Mark the region as valid on the implicit paint */
2872 cairo_region_union (implicit_paint->region, paint->region);
2874 /* Convert back to normal coords */
2875 cairo_region_translate (paint->region, -window->abs_x, -window->abs_y);
2879 paint->uses_implicit = TRUE;
2880 paint->surface = cairo_surface_create_for_rectangle (implicit_paint->surface,
2881 window->abs_x + clip_box.x,
2882 window->abs_y + clip_box.y,
2883 MAX (clip_box.width, 1),
2884 MAX (clip_box.height, 1));
2888 paint->uses_implicit = FALSE;
2889 paint->surface = gdk_window_create_similar_surface (window,
2890 gdk_window_get_content (window),
2891 MAX (clip_box.width, 1),
2892 MAX (clip_box.height, 1));
2894 cairo_surface_set_device_offset (paint->surface, -clip_box.x, -clip_box.y);
2896 for (list = window->paint_stack; list != NULL; list = list->next)
2898 GdkWindowPaint *tmp_paint = list->data;
2900 cairo_region_subtract (tmp_paint->region, paint->region);
2903 window->paint_stack = g_slist_prepend (window->paint_stack, paint);
2905 if (!cairo_region_is_empty (paint->region))
2907 gdk_window_clear_backing_region (window,
2911 #endif /* USE_BACKING_STORE */
2915 * gdk_window_end_paint:
2916 * @window: a #GdkWindow
2918 * Indicates that the backing store created by the most recent call to
2919 * gdk_window_begin_paint_region() should be copied onscreen and
2920 * deleted, leaving the next-most-recent backing store or no backing
2921 * store at all as the active paint region. See
2922 * gdk_window_begin_paint_region() for full details. It is an error to
2923 * call this function without a matching
2924 * gdk_window_begin_paint_region() first.
2928 gdk_window_end_paint (GdkWindow *window)
2930 #ifdef USE_BACKING_STORE
2931 GdkWindow *composited;
2932 GdkWindowPaint *paint;
2933 GdkRectangle clip_box;
2934 cairo_region_t *full_clip;
2936 g_return_if_fail (GDK_IS_WINDOW (window));
2938 if (GDK_WINDOW_DESTROYED (window))
2941 if (GDK_IS_PAINTABLE (window->impl))
2943 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2945 if (iface->end_paint)
2946 iface->end_paint ((GdkPaintable*)window->impl);
2950 if (window->paint_stack == NULL)
2952 g_warning (G_STRLOC": no preceding call to gdk_window_begin_paint_region(), see documentation");
2956 paint = window->paint_stack->data;
2958 window->paint_stack = g_slist_delete_link (window->paint_stack,
2959 window->paint_stack);
2961 cairo_region_get_extents (paint->region, &clip_box);
2963 if (!paint->uses_implicit)
2967 gdk_window_flush_outstanding_moves (window);
2969 full_clip = cairo_region_copy (window->clip_region_with_children);
2970 cairo_region_intersect (full_clip, paint->region);
2972 cr = gdk_cairo_create (window);
2973 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2974 cairo_set_source_surface (cr, paint->surface, 0, 0);
2975 gdk_cairo_region (cr, full_clip);
2979 cairo_region_destroy (full_clip);
2982 cairo_surface_destroy (paint->surface);
2983 cairo_region_destroy (paint->region);
2986 /* find a composited window in our hierarchy to signal its
2987 * parent to redraw, calculating the clip box as we go...
2989 * stop if parent becomes NULL since then we'd have nowhere
2990 * to draw (ie: 'composited' will always be non-NULL here).
2992 for (composited = window;
2994 composited = composited->parent)
2996 clip_box.x += composited->x;
2997 clip_box.y += composited->y;
2998 clip_box.width = MIN (clip_box.width, composited->parent->width - clip_box.x);
2999 clip_box.height = MIN (clip_box.height, composited->parent->height - clip_box.y);
3001 if (composited->composited)
3003 gdk_window_invalidate_rect (GDK_WINDOW (composited->parent),
3008 #endif /* USE_BACKING_STORE */
3012 gdk_window_free_paint_stack (GdkWindow *window)
3014 if (window->paint_stack)
3016 GSList *tmp_list = window->paint_stack;
3020 GdkWindowPaint *paint = tmp_list->data;
3022 if (tmp_list == window->paint_stack)
3023 cairo_surface_destroy (paint->surface);
3025 cairo_region_destroy (paint->region);
3028 tmp_list = tmp_list->next;
3031 g_slist_free (window->paint_stack);
3032 window->paint_stack = NULL;
3037 do_move_region_bits_on_impl (GdkWindow *impl_window,
3038 cairo_region_t *dest_region, /* In impl window coords */
3041 GdkWindowImplClass *impl_class;
3043 impl_class = GDK_WINDOW_IMPL_GET_CLASS (impl_window->impl);
3045 impl_class->translate (impl_window, dest_region, dx, dy);
3048 static GdkWindowRegionMove *
3049 gdk_window_region_move_new (cairo_region_t *region,
3052 GdkWindowRegionMove *move;
3054 move = g_slice_new (GdkWindowRegionMove);
3055 move->dest_region = cairo_region_copy (region);
3063 gdk_window_region_move_free (GdkWindowRegionMove *move)
3065 cairo_region_destroy (move->dest_region);
3066 g_slice_free (GdkWindowRegionMove, move);
3070 append_move_region (GdkWindow *impl_window,
3071 cairo_region_t *new_dest_region,
3074 GdkWindowRegionMove *move, *old_move;
3075 cairo_region_t *new_total_region, *old_total_region;
3076 cairo_region_t *source_overlaps_destination;
3077 cairo_region_t *non_overwritten;
3078 gboolean added_move;
3081 if (cairo_region_is_empty (new_dest_region))
3084 /* In principle this could just append the move to the list of outstanding
3085 moves that will be replayed before drawing anything when we're handling
3086 exposes. However, we'd like to do a bit better since its commonly the case
3087 that we get multiple copies where A is copied to B and then B is copied
3088 to C, and we'd like to express this as a simple copy A to C operation. */
3090 /* We approach this by taking the new move and pushing it ahead of moves
3091 starting at the end of the list and stopping when its not safe to do so.
3092 It's not safe to push past a move if either the source of the new move
3093 is in the destination of the old move, or if the destination of the new
3094 move is in the source of the new move, or if the destination of the new
3095 move overlaps the destination of the old move. We simplify this by
3096 just comparing the total regions (src + dest) */
3097 new_total_region = cairo_region_copy (new_dest_region);
3098 cairo_region_translate (new_total_region, -dx, -dy);
3099 cairo_region_union (new_total_region, new_dest_region);
3102 for (l = g_list_last (impl_window->outstanding_moves); l != NULL; l = prev)
3107 old_total_region = cairo_region_copy (old_move->dest_region);
3108 cairo_region_translate (old_total_region, -old_move->dx, -old_move->dy);
3109 cairo_region_union (old_total_region, old_move->dest_region);
3111 cairo_region_intersect (old_total_region, new_total_region);
3112 /* If these regions intersect then its not safe to push the
3113 new region before the old one */
3114 if (!cairo_region_is_empty (old_total_region))
3116 /* The area where the new moves source overlaps the old ones
3118 source_overlaps_destination = cairo_region_copy (new_dest_region);
3119 cairo_region_translate (source_overlaps_destination, -dx, -dy);
3120 cairo_region_intersect (source_overlaps_destination, old_move->dest_region);
3121 cairo_region_translate (source_overlaps_destination, dx, dy);
3123 /* We can do all sort of optimizations here, but to do things safely it becomes
3124 quite complicated. However, a very common case is that you copy something first,
3125 then copy all that or a subset of it to a new location (i.e. if you scroll twice
3126 in the same direction). We'd like to detect this case and optimize it to one
3128 if (cairo_region_equal (source_overlaps_destination, new_dest_region))
3130 /* This means we might be able to replace the old move and the new one
3131 with the new one read from the old ones source, and a second copy of
3132 the non-overwritten parts of the old move. However, such a split
3133 is only valid if the source in the old move isn't overwritten
3134 by the destination of the new one */
3136 /* the new destination of old move if split is ok: */
3137 non_overwritten = cairo_region_copy (old_move->dest_region);
3138 cairo_region_subtract (non_overwritten, new_dest_region);
3139 /* move to source region */
3140 cairo_region_translate (non_overwritten, -old_move->dx, -old_move->dy);
3142 cairo_region_intersect (non_overwritten, new_dest_region);
3143 if (cairo_region_is_empty (non_overwritten))
3146 move = gdk_window_region_move_new (new_dest_region,
3150 impl_window->outstanding_moves =
3151 g_list_insert_before (impl_window->outstanding_moves,
3153 cairo_region_subtract (old_move->dest_region, new_dest_region);
3155 cairo_region_destroy (non_overwritten);
3158 cairo_region_destroy (source_overlaps_destination);
3159 cairo_region_destroy (old_total_region);
3162 cairo_region_destroy (old_total_region);
3165 cairo_region_destroy (new_total_region);
3169 move = gdk_window_region_move_new (new_dest_region, dx, dy);
3172 impl_window->outstanding_moves =
3173 g_list_prepend (impl_window->outstanding_moves,
3176 impl_window->outstanding_moves =
3177 g_list_insert_before (impl_window->outstanding_moves,
3182 /* Moves bits and update area by dx/dy in impl window.
3183 Takes ownership of region to avoid copy (because we may change it) */
3185 move_region_on_impl (GdkWindow *impl_window,
3186 cairo_region_t *region, /* In impl window coords */
3189 if ((dx == 0 && dy == 0) ||
3190 cairo_region_is_empty (region))
3192 cairo_region_destroy (region);
3196 g_assert (impl_window == gdk_window_get_impl_window (impl_window));
3198 /* Move any old invalid regions in the copy source area by dx/dy */
3199 if (impl_window->update_area)
3201 cairo_region_t *update_area;
3203 update_area = cairo_region_copy (region);
3205 /* Convert from target to source */
3206 cairo_region_translate (update_area, -dx, -dy);
3207 cairo_region_intersect (update_area, impl_window->update_area);
3208 /* We only copy the area, so keep the old update area invalid.
3209 It would be safe to remove it too, as code that uses
3210 move_region_on_impl generally also invalidate the source
3211 area. However, it would just use waste cycles. */
3214 cairo_region_translate (update_area, dx, dy);
3215 cairo_region_union (impl_window->update_area, update_area);
3217 /* This area of the destination is now invalid,
3218 so no need to copy to it. */
3219 cairo_region_subtract (region, update_area);
3221 cairo_region_destroy (update_area);
3224 /* If we're currently exposing this window, don't copy to this
3225 destination, as it will be overdrawn when the expose is done,
3226 instead invalidate it and repaint later. */
3227 if (impl_window->implicit_paint)
3229 GdkWindowPaint *implicit_paint = impl_window->implicit_paint;
3230 cairo_region_t *exposing;
3232 exposing = cairo_region_copy (implicit_paint->region);
3233 cairo_region_intersect (exposing, region);
3234 cairo_region_subtract (region, exposing);
3236 impl_window_add_update_area (impl_window, exposing);
3237 cairo_region_destroy (exposing);
3240 append_move_region (impl_window, region, dx, dy);
3242 cairo_region_destroy (region);
3245 /* Flushes all outstanding changes to the window, call this
3246 * before drawing directly to the window (i.e. outside a begin/end_paint pair).
3249 gdk_window_flush_outstanding_moves (GdkWindow *window)
3251 GdkWindow *impl_window;
3252 GList *l, *outstanding;
3253 GdkWindowRegionMove *move;
3255 impl_window = gdk_window_get_impl_window (window);
3256 outstanding = impl_window->outstanding_moves;
3257 impl_window->outstanding_moves = NULL;
3259 for (l = outstanding; l != NULL; l = l->next)
3263 do_move_region_bits_on_impl (impl_window,
3264 move->dest_region, move->dx, move->dy);
3266 gdk_window_region_move_free (move);
3269 g_list_free (outstanding);
3274 * @window: a #GdkWindow
3276 * Flush all outstanding cached operations on a window, leaving the
3277 * window in a state which reflects all that has been drawn before.
3279 * Gdk uses multiple kinds of caching to get better performance and
3280 * nicer drawing. For instance, during exposes all paints to a window
3281 * using double buffered rendering are keep on a surface until the last
3282 * window has been exposed. It also delays window moves/scrolls until
3283 * as long as possible until next update to avoid tearing when moving
3286 * Normally this should be completely invisible to applications, as
3287 * we automatically flush the windows when required, but this might
3288 * be needed if you for instance mix direct native drawing with
3289 * gdk drawing. For Gtk widgets that don't use double buffering this
3290 * will be called automatically before sending the expose event.
3295 gdk_window_flush (GdkWindow *window)
3297 gdk_window_flush_outstanding_moves (window);
3298 gdk_window_flush_implicit_paint (window);
3301 /* If we're about to move/resize or otherwise change the
3302 * hierarchy of a client side window in an impl and we're
3303 * called from an expose event handler then we need to
3304 * flush any already painted parts of the implicit paint
3305 * that are not part of the current paint, as these may
3306 * be used when scrolling or may overdraw the changes
3307 * caused by the hierarchy change.
3310 gdk_window_flush_if_exposing (GdkWindow *window)
3312 GdkWindow *impl_window;
3314 impl_window = gdk_window_get_impl_window (window);
3316 /* If we're in an implicit paint (i.e. in an expose handler, flush
3317 all the already finished exposes to get things to an uptodate state. */
3318 if (impl_window->implicit_paint)
3319 gdk_window_flush (window);
3324 gdk_window_flush_recursive_helper (GdkWindow *window,
3325 GdkWindowImpl *impl)
3330 for (l = window->children; l != NULL; l = l->next)
3334 if (child->impl == impl)
3335 /* Same impl, ignore */
3336 gdk_window_flush_recursive_helper (child, impl);
3338 gdk_window_flush_recursive (child);
3343 gdk_window_flush_recursive (GdkWindow *window)
3345 gdk_window_flush (window);
3346 gdk_window_flush_recursive_helper (window, window->impl);
3350 * gdk_window_get_clip_region:
3351 * @window: a #GdkWindow
3353 * Computes the region of a window that potentially can be written
3354 * to by drawing primitives. This region may not take into account
3355 * other factors such as if the window is obscured by other windows,
3356 * but no area outside of this region will be affected by drawing
3359 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3360 * when you are done.
3363 gdk_window_get_clip_region (GdkWindow *window)
3365 cairo_region_t *result;
3367 g_return_val_if_fail (GDK_WINDOW (window), NULL);
3369 result = cairo_region_copy (window->clip_region);
3371 if (window->paint_stack)
3373 cairo_region_t *paint_region = cairo_region_create ();
3374 GSList *tmp_list = window->paint_stack;
3378 GdkWindowPaint *paint = tmp_list->data;
3380 cairo_region_union (paint_region, paint->region);
3382 tmp_list = tmp_list->next;
3385 cairo_region_intersect (result, paint_region);
3386 cairo_region_destroy (paint_region);
3393 * gdk_window_get_visible_region:
3394 * @window: a #GdkWindow
3396 * Computes the region of the @window that is potentially visible.
3397 * This does not necessarily take into account if the window is
3398 * obscured by other windows, but no area outside of this region
3401 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3402 * when you are done.
3405 gdk_window_get_visible_region (GdkWindow *window)
3407 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3409 return cairo_region_copy (window->clip_region);
3413 setup_backing_rect (GdkWindow *window, GdkWindowPaint *paint, int x_offset_cairo, int y_offset_cairo)
3415 GdkWindow *bg_window;
3416 cairo_pattern_t *pattern = NULL;
3417 int x_offset = 0, y_offset = 0;
3420 cr = cairo_create (paint->surface);
3422 for (bg_window = window; bg_window; bg_window = bg_window->parent)
3424 pattern = gdk_window_get_background_pattern (bg_window);
3428 x_offset += bg_window->x;
3429 y_offset += bg_window->y;
3434 cairo_translate (cr, -x_offset, -y_offset);
3435 cairo_set_source (cr, pattern);
3436 cairo_translate (cr, x_offset, y_offset);
3439 cairo_set_source_rgb (cr, 0, 0, 0);
3445 gdk_window_clear_backing_region (GdkWindow *window,
3446 cairo_region_t *region)
3448 GdkWindowPaint *paint = window->paint_stack->data;
3449 cairo_region_t *clip;
3450 GdkRectangle clipbox;
3453 if (GDK_WINDOW_DESTROYED (window))
3456 cr = setup_backing_rect (window, paint, 0, 0);
3458 clip = cairo_region_copy (paint->region);
3459 cairo_region_intersect (clip, region);
3460 cairo_region_get_extents (clip, &clipbox);
3462 gdk_cairo_region (cr, clip);
3467 cairo_region_destroy (clip);
3471 gdk_window_clear_backing_region_direct (GdkWindow *window,
3472 cairo_region_t *region)
3474 GdkWindowPaint paint;
3475 cairo_region_t *clip;
3476 GdkRectangle clipbox;
3479 if (GDK_WINDOW_DESTROYED (window))
3482 paint.surface = _gdk_window_ref_cairo_surface (window);
3484 cr = setup_backing_rect (window, &paint, 0, 0);
3486 clip = cairo_region_copy (window->clip_region_with_children);
3487 cairo_region_intersect (clip, region);
3488 cairo_region_get_extents (clip, &clipbox);
3490 gdk_cairo_region (cr, clip);
3495 cairo_region_destroy (clip);
3496 cairo_surface_destroy (paint.surface);
3501 gdk_window_clear_region_internal (GdkWindow *window,
3502 cairo_region_t *region)
3504 if (window->paint_stack)
3505 gdk_window_clear_backing_region (window, region);
3507 gdk_window_clear_backing_region_direct (window, region);
3511 gdk_window_drop_cairo_surface (GdkWindow *window)
3513 if (window->cairo_surface)
3515 cairo_surface_finish (window->cairo_surface);
3516 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3518 window->cairo_surface = NULL;
3523 gdk_window_cairo_surface_destroy (void *data)
3525 GdkWindow *window = data;
3527 window->cairo_surface = NULL;
3530 static cairo_surface_t *
3531 gdk_window_create_cairo_surface (GdkWindow *window,
3535 cairo_surface_t *surface, *subsurface;
3537 surface = gdk_window_ref_impl_surface (window);
3538 if (gdk_window_has_impl (window))
3541 subsurface = cairo_surface_create_for_rectangle (surface,
3546 cairo_surface_destroy (surface);
3552 _gdk_window_ref_cairo_surface (GdkWindow *window)
3554 cairo_surface_t *surface;
3556 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3558 if (window->paint_stack)
3560 GdkWindowPaint *paint = window->paint_stack->data;
3562 surface = paint->surface;
3563 cairo_surface_reference (surface);
3568 /* This will be drawing directly to the window, so flush implicit paint */
3569 gdk_window_flush (window);
3571 if (!window->cairo_surface)
3573 window->cairo_surface = gdk_window_create_cairo_surface (window,
3577 if (window->cairo_surface)
3579 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3580 window, gdk_window_cairo_surface_destroy);
3584 cairo_surface_reference (window->cairo_surface);
3586 surface = window->cairo_surface;
3594 * @window: a #GdkWindow
3596 * Creates a Cairo context for drawing to @window.
3599 * Note that calling cairo_reset_clip() on the resulting #cairo_t will
3600 * produce undefined results, so avoid it at all costs.
3603 * Return value: A newly created Cairo context. Free with
3604 * cairo_destroy() when you are done drawing.
3609 gdk_cairo_create (GdkWindow *window)
3611 cairo_surface_t *surface;
3614 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3616 surface = _gdk_window_ref_cairo_surface (window);
3617 cr = cairo_create (surface);
3619 if (!window->paint_stack)
3621 gdk_cairo_region (cr, window->clip_region_with_children);
3626 GdkWindowPaint *paint = window->paint_stack->data;
3628 /* Only needs to clip to region if piggybacking
3629 on an implicit paint */
3630 if (paint->uses_implicit)
3632 gdk_cairo_region (cr, paint->region);
3637 cairo_surface_destroy (surface);
3642 /* Code for dirty-region queueing
3644 static GSList *update_windows = NULL;
3645 static guint update_idle = 0;
3646 static gboolean debug_updates = FALSE;
3648 static inline gboolean
3649 gdk_window_is_ancestor (GdkWindow *window,
3650 GdkWindow *ancestor)
3654 GdkWindow *parent = window->parent;
3656 if (parent == ancestor)
3666 gdk_window_add_update_window (GdkWindow *window)
3669 GSList *prev = NULL;
3670 gboolean has_ancestor_in_list = FALSE;
3672 for (tmp = update_windows; tmp; tmp = tmp->next)
3674 GdkWindow *parent = window->parent;
3676 /* check if tmp is an ancestor of "window"; if it is, set a
3677 * flag indicating that all following windows are either
3678 * children of "window" or from a differen hierarchy
3680 if (!has_ancestor_in_list && gdk_window_is_ancestor (window, tmp->data))
3681 has_ancestor_in_list = TRUE;
3683 /* insert in reverse stacking order when adding around siblings,
3684 * so processing updates properly paints over lower stacked windows
3686 if (parent == GDK_WINDOW (tmp->data)->parent)
3688 gint index = g_list_index (parent->children, window);
3689 for (; tmp && parent == GDK_WINDOW (tmp->data)->parent; tmp = tmp->next)
3691 gint sibling_index = g_list_index (parent->children, tmp->data);
3692 if (index > sibling_index)
3696 /* here, tmp got advanced past all lower stacked siblings */
3697 tmp = g_slist_prepend (tmp, window);
3701 update_windows = tmp;
3705 /* if "window" has an ancestor in the list and tmp is one of
3706 * "window's" children, insert "window" before tmp
3708 if (has_ancestor_in_list && gdk_window_is_ancestor (tmp->data, window))
3710 tmp = g_slist_prepend (tmp, window);
3715 update_windows = tmp;
3719 /* if we're at the end of the list and had an ancestor it it,
3720 * append to the list
3722 if (! tmp->next && has_ancestor_in_list)
3724 tmp = g_slist_append (tmp, window);
3731 /* if all above checks failed ("window" is from a different
3732 * hierarchy than what is already in the list) or the list is
3735 update_windows = g_slist_prepend (update_windows, window);
3739 gdk_window_remove_update_window (GdkWindow *window)
3741 update_windows = g_slist_remove (update_windows, window);
3745 gdk_window_update_idle (gpointer data)
3747 gdk_window_process_all_updates ();
3753 gdk_window_is_toplevel_frozen (GdkWindow *window)
3755 GdkWindow *toplevel;
3757 toplevel = gdk_window_get_toplevel (window);
3759 return toplevel->update_and_descendants_freeze_count > 0;
3763 gdk_window_schedule_update (GdkWindow *window)
3766 (window->update_freeze_count ||
3767 gdk_window_is_toplevel_frozen (window)))
3772 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
3773 gdk_window_update_idle,
3778 _gdk_window_process_updates_recurse (GdkWindow *window,
3779 cairo_region_t *expose_region)
3782 cairo_region_t *child_region;
3784 GList *l, *children;
3786 if (cairo_region_is_empty (expose_region))
3789 if (gdk_window_is_offscreen (window->impl_window) &&
3790 window == window->impl_window)
3791 _gdk_window_add_damage ((GdkWindow *) window->impl_window, expose_region);
3793 /* Make this reentrancy safe for expose handlers freeing windows */
3794 children = g_list_copy (window->children);
3795 g_list_foreach (children, (GFunc)g_object_ref, NULL);
3797 /* Iterate over children, starting at topmost */
3798 for (l = children; l != NULL; l = l->next)
3802 if (child->destroyed || !GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
3805 /* Ignore offscreen children, as they don't draw in their parent and
3806 * don't take part in the clipping */
3807 if (gdk_window_is_offscreen (child))
3812 r.width = child->width;
3813 r.height = child->height;
3815 child_region = cairo_region_create_rectangle (&r);
3818 /* Adjust shape region to parent window coords */
3819 cairo_region_translate (child->shape, child->x, child->y);
3820 cairo_region_intersect (child_region, child->shape);
3821 cairo_region_translate (child->shape, -child->x, -child->y);
3824 if (child->impl == window->impl)
3826 /* Client side child, expose */
3827 cairo_region_intersect (child_region, expose_region);
3828 cairo_region_subtract (expose_region, child_region);
3829 cairo_region_translate (child_region, -child->x, -child->y);
3830 _gdk_window_process_updates_recurse ((GdkWindow *)child, child_region);
3834 /* Native child, just remove area from expose region */
3835 cairo_region_subtract (expose_region, child_region);
3837 cairo_region_destroy (child_region);
3840 g_list_foreach (children, (GFunc)g_object_unref, NULL);
3841 g_list_free (children);
3843 if (!cairo_region_is_empty (expose_region) &&
3846 if (window->event_mask & GDK_EXPOSURE_MASK)
3850 event.expose.type = GDK_EXPOSE;
3851 event.expose.window = g_object_ref (window);
3852 event.expose.send_event = FALSE;
3853 event.expose.count = 0;
3854 event.expose.region = expose_region;
3855 cairo_region_get_extents (expose_region, &event.expose.area);
3857 _gdk_event_emit (&event);
3859 g_object_unref (window);
3861 else if (window->window_type != GDK_WINDOW_FOREIGN)
3863 /* No exposure mask set, so nothing will be drawn, the
3864 * app relies on the background being what it specified
3865 * for the window. So, we need to clear this manually.
3867 * For foreign windows if expose is not set that generally
3868 * means some other client paints them, so don't clear
3871 * We use begin/end_paint around the clear so that we can
3872 * piggyback on the implicit paint */
3874 gdk_window_begin_paint_region (window, expose_region);
3875 gdk_window_clear_region_internal (window, expose_region);
3876 gdk_window_end_paint (window);
3881 /* Process and remove any invalid area on the native window by creating
3882 * expose events for the window and all non-native descendants.
3883 * Also processes any outstanding moves on the window before doing
3884 * any drawing. Note that its possible to have outstanding moves without
3885 * any invalid area as we use the update idle mechanism to coalesce
3886 * multiple moves as well as multiple invalidations.
3889 gdk_window_process_updates_internal (GdkWindow *window)
3891 GdkWindowImplClass *impl_class;
3892 gboolean save_region = FALSE;
3893 GdkRectangle clip_box;
3895 /* Ensure the window lives while updating it */
3896 g_object_ref (window);
3898 /* If an update got queued during update processing, we can get a
3899 * window in the update queue that has an empty update_area.
3902 if (window->update_area)
3904 cairo_region_t *update_area = window->update_area;
3905 window->update_area = NULL;
3907 if (gdk_window_is_viewable (window))
3909 cairo_region_t *expose_region;
3910 gboolean end_implicit;
3912 /* Clip to part visible in toplevel */
3913 cairo_region_intersect (update_area, window->clip_region);
3917 /* Make sure we see the red invalid area before redrawing. */
3918 gdk_display_sync (gdk_window_get_display (window));
3922 /* At this point we will be completely redrawing all of update_area.
3923 * If we have any outstanding moves that end up moving stuff inside
3924 * this area we don't actually need to move that as that part would
3925 * be overdrawn by the expose anyway. So, in order to copy less data
3926 * we remove these areas from the outstanding moves.
3928 if (window->outstanding_moves)
3930 GdkWindowRegionMove *move;
3931 cairo_region_t *remove;
3934 remove = cairo_region_copy (update_area);
3935 /* We iterate backwards, starting from the state that would be
3936 if we had applied all the moves. */
3937 for (l = g_list_last (window->outstanding_moves); l != NULL; l = prev)
3942 /* Don't need this area */
3943 cairo_region_subtract (move->dest_region, remove);
3945 /* However if any of the destination we do need has a source
3946 in the updated region we do need that as a destination for
3947 the earlier moves */
3948 cairo_region_translate (move->dest_region, -move->dx, -move->dy);
3949 cairo_region_subtract (remove, move->dest_region);
3951 if (cairo_region_is_empty (move->dest_region))
3953 gdk_window_region_move_free (move);
3954 window->outstanding_moves =
3955 g_list_delete_link (window->outstanding_moves, l);
3957 else /* move back */
3958 cairo_region_translate (move->dest_region, move->dx, move->dy);
3960 cairo_region_destroy (remove);
3963 /* By now we a set of window moves that should be applied, and then
3964 * an update region that should be repainted. A trivial implementation
3965 * would just do that in order, however in order to get nicer drawing
3966 * we do some tricks:
3968 * First of all, each subwindow expose may be double buffered by
3969 * itself (depending on widget setting) via
3970 * gdk_window_begin/end_paint(). But we also do an "implicit" paint,
3971 * creating a single surface the size of the invalid area on the
3972 * native window which all the individual normal paints will draw
3973 * into. This way in the normal case there will be only one surface
3974 * allocated and only once surface draw done for all the windows
3975 * in this native window.
3976 * There are a couple of reasons this may fail, for instance, some
3977 * backends (like quartz) do its own double buffering, so we disable
3978 * gdk double buffering there. Secondly, some subwindow could be
3979 * non-double buffered and draw directly to the window outside a
3980 * begin/end_paint pair. That will be lead to a gdk_window_flush
3981 * which immediately executes all outstanding moves and paints+removes
3982 * the implicit paint (further paints will allocate their own surfaces).
3984 * Secondly, in the case of implicit double buffering we expose all
3985 * the child windows into the implicit surface before we execute
3986 * the outstanding moves. This way we minimize the time between
3987 * doing the moves and rendering the new update area, thus minimizing
3988 * flashing. Of course, if any subwindow is non-double buffered we
3989 * well flush earlier than that.
3991 * Thirdly, after having done the outstanding moves we queue an
3992 * "antiexpose" on the area that will be drawn by the expose, which
3993 * means that any invalid region on the native window side before
3994 * the first expose drawing operation will be discarded, as it
3995 * has by then been overdrawn with valid data. This means we can
3996 * avoid doing the unnecessary repaint any outstanding expose events.
3999 cairo_region_get_extents (update_area, &clip_box);
4000 end_implicit = gdk_window_begin_implicit_paint (window, &clip_box);
4001 expose_region = cairo_region_copy (update_area);
4002 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
4005 /* Rendering is not double buffered by gdk, do outstanding
4006 * moves and queue antiexposure immediately. No need to do
4008 gdk_window_flush_outstanding_moves (window);
4009 save_region = impl_class->queue_antiexpose (window, update_area);
4011 /* Render the invalid areas to the implicit paint, by sending exposes.
4012 * May flush if non-double buffered widget draw. */
4013 impl_class->process_updates_recurse (window, expose_region);
4017 /* Do moves right before exposes are rendered to the window */
4018 gdk_window_flush_outstanding_moves (window);
4020 /* By this time we know that any outstanding expose for this
4021 * area is invalid and we can avoid it, so queue an antiexpose.
4022 * we have already started drawing to the window, so it would
4023 * be to late to anti-expose now. Since this is merely an
4024 * optimization we just avoid doing it at all in that case.
4026 if (window->implicit_paint != NULL && !window->implicit_paint->flushed)
4027 save_region = impl_class->queue_antiexpose (window, update_area);
4029 gdk_window_end_implicit_paint (window);
4031 cairo_region_destroy (expose_region);
4034 cairo_region_destroy (update_area);
4037 if (window->outstanding_moves)
4039 /* Flush any outstanding moves, may happen if we moved a window but got
4040 no actual invalid area */
4041 gdk_window_flush_outstanding_moves (window);
4044 g_object_unref (window);
4048 flush_all_displays (void)
4050 GSList *displays, *l;
4052 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4053 for (l = displays; l; l = l->next)
4054 gdk_display_flush (l->data);
4056 g_slist_free (displays);
4060 before_process_all_updates (void)
4062 GSList *displays, *l;
4063 GdkDisplayClass *display_class;
4065 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4066 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4067 for (l = displays; l; l = l->next)
4068 display_class->before_process_all_updates (l->data);
4070 g_slist_free (displays);
4074 after_process_all_updates (void)
4076 GSList *displays, *l;
4077 GdkDisplayClass *display_class;
4079 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4080 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4081 for (l = displays; l; l = l->next)
4082 display_class->after_process_all_updates (l->data);
4084 g_slist_free (displays);
4087 /* Currently it is not possible to override
4088 * gdk_window_process_all_updates in the same manner as
4089 * gdk_window_process_updates and gdk_window_invalidate_maybe_recurse
4090 * by implementing the GdkPaintable interface. If in the future a
4091 * backend would need this, the right solution would be to add a
4092 * method to GdkDisplay that can be optionally
4093 * NULL. gdk_window_process_all_updates can then walk the list of open
4094 * displays and call the mehod.
4098 * gdk_window_process_all_updates:
4100 * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
4101 * in the application.
4105 gdk_window_process_all_updates (void)
4107 GSList *old_update_windows = update_windows;
4108 GSList *tmp_list = update_windows;
4109 static gboolean in_process_all_updates = FALSE;
4110 static gboolean got_recursive_update = FALSE;
4112 if (in_process_all_updates)
4114 /* We can't do this now since that would recurse, so
4115 delay it until after the recursion is done. */
4116 got_recursive_update = TRUE;
4121 in_process_all_updates = TRUE;
4122 got_recursive_update = FALSE;
4125 g_source_remove (update_idle);
4127 update_windows = NULL;
4130 before_process_all_updates ();
4132 g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
4136 GdkWindow *window = tmp_list->data;
4138 if (!GDK_WINDOW_DESTROYED (window))
4140 if (window->update_freeze_count ||
4141 gdk_window_is_toplevel_frozen (window))
4142 gdk_window_add_update_window (window);
4144 gdk_window_process_updates_internal (window);
4147 g_object_unref (window);
4148 tmp_list = tmp_list->next;
4151 g_slist_free (old_update_windows);
4153 flush_all_displays ();
4155 after_process_all_updates ();
4157 in_process_all_updates = FALSE;
4159 /* If we ignored a recursive call, schedule a
4160 redraw now so that it eventually happens,
4161 otherwise we could miss an update if nothing
4162 else schedules an update. */
4163 if (got_recursive_update && !update_idle)
4165 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
4166 gdk_window_update_idle,
4171 * gdk_window_process_updates:
4172 * @window: a #GdkWindow
4173 * @update_children: whether to also process updates for child windows
4175 * Sends one or more expose events to @window. The areas in each
4176 * expose event will cover the entire update area for the window (see
4177 * gdk_window_invalidate_region() for details). Normally GDK calls
4178 * gdk_window_process_all_updates() on your behalf, so there's no
4179 * need to call this function unless you want to force expose events
4180 * to be delivered immediately and synchronously (vs. the usual
4181 * case, where GDK delivers them in an idle handler). Occasionally
4182 * this is useful to produce nicer scrolling behavior, for example.
4186 gdk_window_process_updates (GdkWindow *window,
4187 gboolean update_children)
4189 GdkWindow *impl_window;
4191 g_return_if_fail (GDK_IS_WINDOW (window));
4193 if (GDK_WINDOW_DESTROYED (window))
4196 /* Make sure the window lives during the expose callouts */
4197 g_object_ref (window);
4199 impl_window = gdk_window_get_impl_window (window);
4200 if ((impl_window->update_area ||
4201 impl_window->outstanding_moves) &&
4202 !impl_window->update_freeze_count &&
4203 !gdk_window_is_toplevel_frozen (window) &&
4205 /* Don't recurse into process_updates_internal, we'll
4206 * do the update later when idle instead. */
4207 impl_window->implicit_paint == NULL)
4209 gdk_window_process_updates_internal ((GdkWindow *)impl_window);
4210 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4213 if (update_children)
4215 /* process updates in reverse stacking order so composition or
4216 * painting over achieves the desired effect for offscreen windows
4218 GList *node, *children;
4220 children = g_list_copy (window->children);
4221 g_list_foreach (children, (GFunc)g_object_ref, NULL);
4223 for (node = g_list_last (children); node; node = node->prev)
4225 gdk_window_process_updates (node->data, TRUE);
4226 g_object_unref (node->data);
4229 g_list_free (children);
4232 g_object_unref (window);
4236 gdk_window_invalidate_rect_full (GdkWindow *window,
4237 const GdkRectangle *rect,
4238 gboolean invalidate_children,
4241 GdkRectangle window_rect;
4242 cairo_region_t *region;
4244 g_return_if_fail (GDK_IS_WINDOW (window));
4246 if (GDK_WINDOW_DESTROYED (window))
4249 if (window->input_only || !window->viewable)
4256 window_rect.width = window->width;
4257 window_rect.height = window->height;
4258 rect = &window_rect;
4261 region = cairo_region_create_rectangle (rect);
4262 gdk_window_invalidate_region_full (window, region, invalidate_children, clear_bg);
4263 cairo_region_destroy (region);
4267 * gdk_window_invalidate_rect:
4268 * @window: a #GdkWindow
4269 * @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
4271 * @invalidate_children: whether to also invalidate child windows
4273 * A convenience wrapper around gdk_window_invalidate_region() which
4274 * invalidates a rectangular region. See
4275 * gdk_window_invalidate_region() for details.
4278 gdk_window_invalidate_rect (GdkWindow *window,
4279 const GdkRectangle *rect,
4280 gboolean invalidate_children)
4282 gdk_window_invalidate_rect_full (window, rect, invalidate_children, CLEAR_BG_NONE);
4286 draw_ugly_color (GdkWindow *window,
4287 const cairo_region_t *region)
4291 cr = gdk_cairo_create (window);
4292 /* Draw ugly color all over the newly-invalid region */
4293 cairo_set_source_rgb (cr, 50000/65535., 10000/65535., 10000/65535.);
4294 gdk_cairo_region (cr, region);
4301 impl_window_add_update_area (GdkWindow *impl_window,
4302 cairo_region_t *region)
4304 if (impl_window->update_area)
4305 cairo_region_union (impl_window->update_area, region);
4308 gdk_window_add_update_window (impl_window);
4309 impl_window->update_area = cairo_region_copy (region);
4310 gdk_window_schedule_update (impl_window);
4314 /* clear_bg controls if the region will be cleared to
4315 * the background pattern if the exposure mask is not
4316 * set for the window, whereas this might not otherwise be
4317 * done (unless necessary to emulate background settings).
4318 * Set this to CLEAR_BG_WINCLEARED or CLEAR_BG_ALL if you
4319 * need to clear the background, such as when exposing the area beneath a
4320 * hidden or moved window, but not when an app requests repaint or when the
4321 * windowing system exposes a newly visible area (because then the windowing
4322 * system has already cleared the area).
4325 gdk_window_invalidate_maybe_recurse_full (GdkWindow *window,
4326 const cairo_region_t *region,
4328 GdkWindowChildFunc child_func,
4331 GdkWindow *impl_window;
4332 cairo_region_t *visible_region;
4335 g_return_if_fail (GDK_IS_WINDOW (window));
4337 if (GDK_WINDOW_DESTROYED (window))
4340 if (window->input_only ||
4341 !window->viewable ||
4342 cairo_region_is_empty (region) ||
4343 window->window_type == GDK_WINDOW_ROOT)
4346 visible_region = gdk_window_get_visible_region (window);
4347 cairo_region_intersect (visible_region, region);
4349 tmp_list = window->children;
4352 GdkWindow *child = tmp_list->data;
4354 if (!child->input_only)
4356 cairo_region_t *child_region;
4357 GdkRectangle child_rect;
4359 child_rect.x = child->x;
4360 child_rect.y = child->y;
4361 child_rect.width = child->width;
4362 child_rect.height = child->height;
4363 child_region = cairo_region_create_rectangle (&child_rect);
4365 /* remove child area from the invalid area of the parent */
4366 if (GDK_WINDOW_IS_MAPPED (child) && !child->shaped &&
4367 !child->composited &&
4368 !gdk_window_is_offscreen (child))
4369 cairo_region_subtract (visible_region, child_region);
4371 if (child_func && (*child_func) ((GdkWindow *)child, user_data))
4373 cairo_region_t *tmp = cairo_region_copy (region);
4375 cairo_region_translate (tmp, - child_rect.x, - child_rect.y);
4376 cairo_region_translate (child_region, - child_rect.x, - child_rect.y);
4377 cairo_region_intersect (child_region, tmp);
4379 gdk_window_invalidate_maybe_recurse_full ((GdkWindow *)child,
4380 child_region, clear_bg, child_func, user_data);
4382 cairo_region_destroy (tmp);
4385 cairo_region_destroy (child_region);
4388 tmp_list = tmp_list->next;
4391 impl_window = gdk_window_get_impl_window (window);
4393 if (!cairo_region_is_empty (visible_region) ||
4394 /* Even if we're not exposing anything, make sure we process
4395 idles for windows with outstanding moves */
4396 (impl_window->outstanding_moves != NULL &&
4397 impl_window->update_area == NULL))
4400 draw_ugly_color (window, region);
4402 /* Convert to impl coords */
4403 cairo_region_translate (visible_region, window->abs_x, window->abs_y);
4405 /* Only invalidate area if app requested expose events or if
4406 we need to clear the area (by request or to emulate background
4407 clearing for non-native windows or native windows with no support
4408 for window backgrounds */
4409 if (window->event_mask & GDK_EXPOSURE_MASK ||
4410 clear_bg == CLEAR_BG_ALL ||
4411 clear_bg == CLEAR_BG_WINCLEARED)
4412 impl_window_add_update_area (impl_window, visible_region);
4415 cairo_region_destroy (visible_region);
4419 * gdk_window_invalidate_maybe_recurse:
4420 * @window: a #GdkWindow
4421 * @region: a #cairo_region_t
4422 * @child_func: (scope call) (allow-none): function to use to decide if to
4423 * recurse to a child, %NULL means never recurse.
4424 * @user_data: data passed to @child_func
4426 * Adds @region to the update area for @window. The update area is the
4427 * region that needs to be redrawn, or "dirty region." The call
4428 * gdk_window_process_updates() sends one or more expose events to the
4429 * window, which together cover the entire update area. An
4430 * application would normally redraw the contents of @window in
4431 * response to those expose events.
4433 * GDK will call gdk_window_process_all_updates() on your behalf
4434 * whenever your program returns to the main loop and becomes idle, so
4435 * normally there's no need to do that manually, you just need to
4436 * invalidate regions that you know should be redrawn.
4438 * The @child_func parameter controls whether the region of
4439 * each child window that intersects @region will also be invalidated.
4440 * Only children for which @child_func returns TRUE will have the area
4444 gdk_window_invalidate_maybe_recurse (GdkWindow *window,
4445 const cairo_region_t *region,
4446 GdkWindowChildFunc child_func,
4449 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_NONE,
4450 child_func, user_data);
4454 true_predicate (GdkWindow *window,
4461 gdk_window_invalidate_region_full (GdkWindow *window,
4462 const cairo_region_t *region,
4463 gboolean invalidate_children,
4466 gdk_window_invalidate_maybe_recurse_full (window, region, clear_bg,
4467 invalidate_children ?
4468 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4473 * gdk_window_invalidate_region:
4474 * @window: a #GdkWindow
4475 * @region: a #cairo_region_t
4476 * @invalidate_children: %TRUE to also invalidate child windows
4478 * Adds @region to the update area for @window. The update area is the
4479 * region that needs to be redrawn, or "dirty region." The call
4480 * gdk_window_process_updates() sends one or more expose events to the
4481 * window, which together cover the entire update area. An
4482 * application would normally redraw the contents of @window in
4483 * response to those expose events.
4485 * GDK will call gdk_window_process_all_updates() on your behalf
4486 * whenever your program returns to the main loop and becomes idle, so
4487 * normally there's no need to do that manually, you just need to
4488 * invalidate regions that you know should be redrawn.
4490 * The @invalidate_children parameter controls whether the region of
4491 * each child window that intersects @region will also be invalidated.
4492 * If %FALSE, then the update area for child windows will remain
4493 * unaffected. See gdk_window_invalidate_maybe_recurse if you need
4494 * fine grained control over which children are invalidated.
4497 gdk_window_invalidate_region (GdkWindow *window,
4498 const cairo_region_t *region,
4499 gboolean invalidate_children)
4501 gdk_window_invalidate_maybe_recurse (window, region,
4502 invalidate_children ?
4503 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4508 * _gdk_window_invalidate_for_expose:
4509 * @window: a #GdkWindow
4510 * @region: a #cairo_region_t
4512 * Adds @region to the update area for @window. The update area is the
4513 * region that needs to be redrawn, or "dirty region." The call
4514 * gdk_window_process_updates() sends one or more expose events to the
4515 * window, which together cover the entire update area. An
4516 * application would normally redraw the contents of @window in
4517 * response to those expose events.
4519 * GDK will call gdk_window_process_all_updates() on your behalf
4520 * whenever your program returns to the main loop and becomes idle, so
4521 * normally there's no need to do that manually, you just need to
4522 * invalidate regions that you know should be redrawn.
4524 * This version of invalidation is used when you recieve expose events
4525 * from the native window system. It exposes the native window, plus
4526 * any non-native child windows (but not native child windows, as those would
4527 * have gotten their own expose events).
4530 _gdk_window_invalidate_for_expose (GdkWindow *window,
4531 cairo_region_t *region)
4533 GdkWindowRegionMove *move;
4534 cairo_region_t *move_region;
4537 /* Any invalidations comming from the windowing system will
4538 be in areas that may be moved by outstanding moves,
4539 so we need to modify the expose region correspondingly,
4540 otherwise we would expose in the wrong place, as the
4541 outstanding moves will be copied before we draw the
4543 for (l = window->outstanding_moves; l != NULL; l = l->next)
4547 /* covert to move source region */
4548 move_region = cairo_region_copy (move->dest_region);
4549 cairo_region_translate (move_region, -move->dx, -move->dy);
4551 /* Move area of region that intersects with move source
4552 by dx, dy of the move*/
4553 cairo_region_intersect (move_region, region);
4554 cairo_region_subtract (region, move_region);
4555 cairo_region_translate (move_region, move->dx, move->dy);
4556 cairo_region_union (region, move_region);
4558 cairo_region_destroy (move_region);
4561 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_WINCLEARED,
4562 (gboolean (*) (GdkWindow *, gpointer))gdk_window_has_no_impl,
4568 * gdk_window_get_update_area:
4569 * @window: a #GdkWindow
4571 * Transfers ownership of the update area from @window to the caller
4572 * of the function. That is, after calling this function, @window will
4573 * no longer have an invalid/dirty region; the update area is removed
4574 * from @window and handed to you. If a window has no update area,
4575 * gdk_window_get_update_area() returns %NULL. You are responsible for
4576 * calling cairo_region_destroy() on the returned region if it's non-%NULL.
4578 * Return value: the update area for @window
4581 gdk_window_get_update_area (GdkWindow *window)
4583 GdkWindow *impl_window;
4584 cairo_region_t *tmp_region;
4586 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4588 impl_window = gdk_window_get_impl_window (window);
4590 if (impl_window->update_area)
4592 tmp_region = cairo_region_copy (window->clip_region_with_children);
4593 /* Convert to impl coords */
4594 cairo_region_translate (tmp_region, window->abs_x, window->abs_y);
4595 cairo_region_intersect (tmp_region, impl_window->update_area);
4597 if (cairo_region_is_empty (tmp_region))
4599 cairo_region_destroy (tmp_region);
4604 cairo_region_subtract (impl_window->update_area, tmp_region);
4606 if (cairo_region_is_empty (impl_window->update_area) &&
4607 impl_window->outstanding_moves == NULL)
4609 cairo_region_destroy (impl_window->update_area);
4610 impl_window->update_area = NULL;
4612 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4615 /* Convert from impl coords */
4616 cairo_region_translate (tmp_region, -window->abs_x, -window->abs_y);
4626 * _gdk_window_clear_update_area:
4627 * @window: a #GdkWindow.
4629 * Internal function to clear the update area for a window. This
4630 * is called when the window is hidden or destroyed.
4633 _gdk_window_clear_update_area (GdkWindow *window)
4635 g_return_if_fail (GDK_IS_WINDOW (window));
4637 if (window->update_area)
4639 gdk_window_remove_update_window (window);
4641 cairo_region_destroy (window->update_area);
4642 window->update_area = NULL;
4647 * gdk_window_freeze_updates:
4648 * @window: a #GdkWindow
4650 * Temporarily freezes a window such that it won't receive expose
4651 * events. The window will begin receiving expose events again when
4652 * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
4653 * has been called more than once, gdk_window_thaw_updates() must be called
4654 * an equal number of times to begin processing exposes.
4657 gdk_window_freeze_updates (GdkWindow *window)
4659 GdkWindow *impl_window;
4661 g_return_if_fail (GDK_IS_WINDOW (window));
4663 impl_window = gdk_window_get_impl_window (window);
4664 impl_window->update_freeze_count++;
4668 * gdk_window_thaw_updates:
4669 * @window: a #GdkWindow
4671 * Thaws a window frozen with gdk_window_freeze_updates().
4674 gdk_window_thaw_updates (GdkWindow *window)
4676 GdkWindow *impl_window;
4678 g_return_if_fail (GDK_IS_WINDOW (window));
4680 impl_window = gdk_window_get_impl_window (window);
4682 g_return_if_fail (impl_window->update_freeze_count > 0);
4684 if (--impl_window->update_freeze_count == 0)
4685 gdk_window_schedule_update (GDK_WINDOW (impl_window));
4689 * gdk_window_freeze_toplevel_updates_libgtk_only:
4690 * @window: a #GdkWindow
4692 * Temporarily freezes a window and all its descendants such that it won't
4693 * receive expose events. The window will begin receiving expose events
4694 * again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
4695 * gdk_window_freeze_toplevel_updates_libgtk_only()
4696 * has been called more than once,
4697 * gdk_window_thaw_toplevel_updates_libgtk_only() must be called
4698 * an equal number of times to begin processing exposes.
4700 * This function is not part of the GDK public API and is only
4704 gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window)
4706 g_return_if_fail (GDK_IS_WINDOW (window));
4707 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4709 window->update_and_descendants_freeze_count++;
4713 * gdk_window_thaw_toplevel_updates_libgtk_only:
4714 * @window: a #GdkWindow
4716 * Thaws a window frozen with
4717 * gdk_window_freeze_toplevel_updates_libgtk_only().
4719 * This function is not part of the GDK public API and is only
4723 gdk_window_thaw_toplevel_updates_libgtk_only (GdkWindow *window)
4725 g_return_if_fail (GDK_IS_WINDOW (window));
4726 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4727 g_return_if_fail (window->update_and_descendants_freeze_count > 0);
4729 window->update_and_descendants_freeze_count--;
4731 gdk_window_schedule_update (window);
4735 * gdk_window_set_debug_updates:
4736 * @setting: %TRUE to turn on update debugging
4738 * With update debugging enabled, calls to
4739 * gdk_window_invalidate_region() clear the invalidated region of the
4740 * screen to a noticeable color, and GDK pauses for a short time
4741 * before sending exposes to windows during
4742 * gdk_window_process_updates(). The net effect is that you can see
4743 * the invalid region for each window and watch redraws as they
4744 * occur. This allows you to diagnose inefficiencies in your application.
4746 * In essence, because the GDK rendering model prevents all flicker,
4747 * if you are redrawing the same region 400 times you may never
4748 * notice, aside from noticing a speed problem. Enabling update
4749 * debugging causes GTK to flicker slowly and noticeably, so you can
4750 * see exactly what's being redrawn when, in what order.
4752 * The --gtk-debug=updates command line option passed to GTK+ programs
4753 * enables this debug option at application startup time. That's
4754 * usually more useful than calling gdk_window_set_debug_updates()
4755 * yourself, though you might want to use this function to enable
4756 * updates sometime after application startup time.
4760 gdk_window_set_debug_updates (gboolean setting)
4762 debug_updates = setting;
4766 * gdk_window_constrain_size:
4767 * @geometry: a #GdkGeometry structure
4768 * @flags: a mask indicating what portions of @geometry are set
4769 * @width: desired width of window
4770 * @height: desired height of the window
4771 * @new_width: (out): location to store resulting width
4772 * @new_height: (out): location to store resulting height
4774 * Constrains a desired width and height according to a
4775 * set of geometry hints (such as minimum and maximum size).
4778 gdk_window_constrain_size (GdkGeometry *geometry,
4785 /* This routine is partially borrowed from fvwm.
4787 * Copyright 1993, Robert Nation
4788 * You may use this code for any purpose, as long as the original
4789 * copyright remains in the source code and all documentation
4791 * which in turn borrows parts of the algorithm from uwm
4794 gint min_height = 0;
4795 gint base_width = 0;
4796 gint base_height = 0;
4799 gint max_width = G_MAXINT;
4800 gint max_height = G_MAXINT;
4802 #define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
4804 if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
4806 base_width = geometry->base_width;
4807 base_height = geometry->base_height;
4808 min_width = geometry->min_width;
4809 min_height = geometry->min_height;
4811 else if (flags & GDK_HINT_BASE_SIZE)
4813 base_width = geometry->base_width;
4814 base_height = geometry->base_height;
4815 min_width = geometry->base_width;
4816 min_height = geometry->base_height;
4818 else if (flags & GDK_HINT_MIN_SIZE)
4820 base_width = geometry->min_width;
4821 base_height = geometry->min_height;
4822 min_width = geometry->min_width;
4823 min_height = geometry->min_height;
4826 if (flags & GDK_HINT_MAX_SIZE)
4828 max_width = geometry->max_width ;
4829 max_height = geometry->max_height;
4832 if (flags & GDK_HINT_RESIZE_INC)
4834 xinc = MAX (xinc, geometry->width_inc);
4835 yinc = MAX (yinc, geometry->height_inc);
4838 /* clamp width and height to min and max values
4840 width = CLAMP (width, min_width, max_width);
4841 height = CLAMP (height, min_height, max_height);
4843 /* shrink to base + N * inc
4845 width = base_width + FLOOR (width - base_width, xinc);
4846 height = base_height + FLOOR (height - base_height, yinc);
4848 /* constrain aspect ratio, according to:
4851 * min_aspect <= -------- <= max_aspect
4855 if (flags & GDK_HINT_ASPECT &&
4856 geometry->min_aspect > 0 &&
4857 geometry->max_aspect > 0)
4861 if (geometry->min_aspect * height > width)
4863 delta = FLOOR (height - width / geometry->min_aspect, yinc);
4864 if (height - delta >= min_height)
4868 delta = FLOOR (height * geometry->min_aspect - width, xinc);
4869 if (width + delta <= max_width)
4874 if (geometry->max_aspect * height < width)
4876 delta = FLOOR (width - height * geometry->max_aspect, xinc);
4877 if (width - delta >= min_width)
4881 delta = FLOOR (width / geometry->max_aspect - height, yinc);
4882 if (height + delta <= max_height)
4891 *new_height = height;
4895 * gdk_window_get_pointer:
4896 * @window: a #GdkWindow
4897 * @x: (out) (allow-none): return location for X coordinate of pointer or %NULL to not
4898 * return the X coordinate
4899 * @y: (out) (allow-none): return location for Y coordinate of pointer or %NULL to not
4900 * return the Y coordinate
4901 * @mask: (out) (allow-none): return location for modifier mask or %NULL to not return the
4904 * Obtains the current pointer position and modifier state.
4905 * The position is given in coordinates relative to the upper left
4906 * corner of @window.
4908 * Return value: (transfer none): the window containing the pointer (as with
4909 * gdk_window_at_pointer()), or %NULL if the window containing the
4910 * pointer isn't known to GDK
4912 * Deprecated: 3.0: Use gdk_window_get_device_position() instead.
4915 gdk_window_get_pointer (GdkWindow *window,
4918 GdkModifierType *mask)
4920 GdkDisplay *display;
4922 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4924 display = gdk_window_get_display (window);
4926 return gdk_window_get_device_position (window, display->core_pointer, x, y, mask);
4930 * gdk_window_get_device_position:
4931 * @window: a #GdkWindow.
4932 * @device: pointer #GdkDevice to query to.
4933 * @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
4934 * @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
4935 * @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
4937 * Obtains the current device position and modifier state.
4938 * The position is given in coordinates relative to the upper left
4939 * corner of @window.
4941 * Return value: (transfer none): The window underneath @device (as with
4942 * gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
4947 gdk_window_get_device_position (GdkWindow *window,
4951 GdkModifierType *mask)
4954 GdkModifierType tmp_mask;
4955 gboolean normal_child;
4957 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4958 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
4959 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
4961 normal_child = GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_device_state (window,
4965 /* We got the coords on the impl, convert to the window */
4966 tmp_x -= window->abs_x;
4967 tmp_y -= window->abs_y;
4976 _gdk_display_enable_motion_hints (gdk_window_get_display (window), device);
4979 return _gdk_window_find_child_at (window, tmp_x, tmp_y);
4984 * gdk_get_default_root_window:
4986 * Obtains the root window (parent all other windows are inside)
4987 * for the default display and screen.
4989 * Return value: (transfer none): the default root window
4992 gdk_get_default_root_window (void)
4994 return gdk_screen_get_root_window (gdk_screen_get_default ());
4998 get_all_native_children (GdkWindow *window,
5004 for (l = window->children; l != NULL; l = l->next)
5008 if (gdk_window_has_impl (child))
5009 *native = g_list_prepend (*native, child);
5011 get_all_native_children (child, native);
5017 gdk_window_raise_internal (GdkWindow *window)
5019 GdkWindow *parent = window->parent;
5021 GList *native_children;
5023 GdkWindowImplClass *impl_class;
5027 parent->children = g_list_remove (parent->children, window);
5028 parent->children = g_list_prepend (parent->children, window);
5031 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5032 /* Just do native raise for toplevels */
5033 if (gdk_window_is_toplevel (window) ||
5034 /* The restack_under codepath should work correctly even if the parent
5035 is native, but it relies on the order of ->children to be correct,
5036 and some apps like SWT reorder the x windows without gdks knowledge,
5037 so we use raise directly in order to make these behave as before
5038 when using native windows */
5039 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5041 impl_class->raise (window);
5043 else if (gdk_window_has_impl (window))
5045 above = find_native_sibling_above (parent, window);
5048 listhead.data = window;
5049 listhead.next = NULL;
5050 listhead.prev = NULL;
5051 impl_class->restack_under ((GdkWindow *)above,
5055 impl_class->raise (window);
5059 native_children = NULL;
5060 get_all_native_children (window, &native_children);
5061 if (native_children != NULL)
5063 above = find_native_sibling_above (parent, window);
5066 impl_class->restack_under (above, native_children);
5069 /* Right order, since native_children is bottom-topmost first */
5070 for (l = native_children; l != NULL; l = l->next)
5071 impl_class->raise (l->data);
5074 g_list_free (native_children);
5080 /* Returns TRUE If the native window was mapped or unmapped */
5082 set_viewable (GdkWindow *w,
5086 GdkWindowImplClass *impl_class;
5089 if (w->viewable == val)
5095 recompute_visible_regions (w, FALSE, FALSE);
5097 for (l = w->children; l != NULL; l = l->next)
5101 if (GDK_WINDOW_IS_MAPPED (child) &&
5102 child->window_type != GDK_WINDOW_FOREIGN)
5103 set_viewable (child, val);
5106 if (gdk_window_has_impl (w) &&
5107 w->window_type != GDK_WINDOW_FOREIGN &&
5108 !gdk_window_is_toplevel (w))
5110 /* For most native windows we show/hide them not when they are
5111 * mapped/unmapped, because that may not produce the correct results.
5112 * For instance, if a native window have a non-native parent which is
5113 * hidden, but its native parent is viewable then showing the window
5114 * would make it viewable to X but its not viewable wrt the non-native
5115 * hierarchy. In order to handle this we track the gdk side viewability
5116 * and only map really viewable windows.
5118 * There are two exceptions though:
5120 * For foreign windows we don't want ever change the mapped state
5121 * except when explicitly done via gdk_window_show/hide, as this may
5122 * cause problems for client owning the foreign window when its window
5123 * is suddenly mapped or unmapped.
5125 * For toplevel windows embedded in a foreign window (e.g. a plug)
5126 * we sometimes synthesize a map of a window, but the native
5127 * window is really shown by the embedder, so we don't want to
5128 * do the show ourselves. We can't really tell this case from the normal
5129 * toplevel show as such toplevels are seen by gdk as parents of the
5130 * root window, so we make an exception for all toplevels.
5133 impl_class = GDK_WINDOW_IMPL_GET_CLASS (w->impl);
5135 impl_class->show ((GdkWindow *)w, FALSE);
5137 impl_class->hide ((GdkWindow *)w);
5145 /* Returns TRUE If the native window was mapped or unmapped */
5147 _gdk_window_update_viewable (GdkWindow *window)
5151 if (window->window_type == GDK_WINDOW_FOREIGN ||
5152 window->window_type == GDK_WINDOW_ROOT)
5154 else if (gdk_window_is_toplevel (window) ||
5155 window->parent->viewable)
5156 viewable = GDK_WINDOW_IS_MAPPED (window);
5160 return set_viewable (window, viewable);
5164 gdk_window_show_internal (GdkWindow *window, gboolean raise)
5166 GdkWindowImplClass *impl_class;
5167 gboolean was_mapped, was_viewable;
5170 g_return_if_fail (GDK_IS_WINDOW (window));
5172 if (window->destroyed)
5175 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5176 was_viewable = window->viewable;
5179 /* Keep children in (reverse) stacking order */
5180 gdk_window_raise_internal (window);
5182 if (gdk_window_has_impl (window))
5185 gdk_synthesize_window_state (window,
5186 GDK_WINDOW_STATE_WITHDRAWN,
5187 GDK_WINDOW_STATE_FOCUSED);
5194 did_show = _gdk_window_update_viewable (window);
5196 /* If it was already viewable the backend show op won't be called, call it
5197 again to ensure things happen right if the mapped tracking was not right
5198 for e.g. a foreign window.
5199 Dunno if this is strictly needed but its what happened pre-csw.
5200 Also show if not done by gdk_window_update_viewable. */
5201 if (gdk_window_has_impl (window) && (was_viewable || !did_show))
5203 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5204 impl_class->show (window, !did_show ? was_mapped : TRUE);
5207 if (!was_mapped && !gdk_window_has_impl (window))
5209 if (window->event_mask & GDK_STRUCTURE_MASK)
5210 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5212 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5213 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5216 if (!was_mapped || raise)
5218 recompute_visible_regions (window, TRUE, FALSE);
5220 /* If any decendants became visible we need to send visibility notify */
5221 gdk_window_update_visibility_recursively (window, NULL);
5223 if (gdk_window_is_viewable (window))
5225 _gdk_synthesize_crossing_events_for_geometry_change (window);
5226 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
5232 * gdk_window_show_unraised:
5233 * @window: a #GdkWindow
5235 * Shows a #GdkWindow onscreen, but does not modify its stacking
5236 * order. In contrast, gdk_window_show() will raise the window
5237 * to the top of the window stack.
5239 * On the X11 platform, in Xlib terms, this function calls
5240 * XMapWindow() (it also updates some internal GDK state, which means
5241 * that you can't really use XMapWindow() directly on a GDK window).
5244 gdk_window_show_unraised (GdkWindow *window)
5246 gdk_window_show_internal (window, FALSE);
5251 * @window: a #GdkWindow
5253 * Raises @window to the top of the Z-order (stacking order), so that
5254 * other windows with the same parent window appear below @window.
5255 * This is true whether or not the windows are visible.
5257 * If @window is a toplevel, the window manager may choose to deny the
5258 * request to move the window in the Z-order, gdk_window_raise() only
5259 * requests the restack, does not guarantee it.
5262 gdk_window_raise (GdkWindow *window)
5264 cairo_region_t *old_region, *new_region;
5266 g_return_if_fail (GDK_IS_WINDOW (window));
5268 if (window->destroyed)
5271 gdk_window_flush_if_exposing (window);
5274 if (gdk_window_is_viewable (window) &&
5275 !window->input_only)
5276 old_region = cairo_region_copy (window->clip_region);
5278 /* Keep children in (reverse) stacking order */
5279 gdk_window_raise_internal (window);
5281 recompute_visible_regions (window, TRUE, FALSE);
5285 new_region = cairo_region_copy (window->clip_region);
5287 cairo_region_subtract (new_region, old_region);
5288 gdk_window_invalidate_region_full (window, new_region, TRUE, CLEAR_BG_ALL);
5290 cairo_region_destroy (old_region);
5291 cairo_region_destroy (new_region);
5296 gdk_window_lower_internal (GdkWindow *window)
5298 GdkWindow *parent = window->parent;
5299 GdkWindowImplClass *impl_class;
5301 GList *native_children;
5306 parent->children = g_list_remove (parent->children, window);
5307 parent->children = g_list_append (parent->children, window);
5310 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5311 /* Just do native lower for toplevels */
5312 if (gdk_window_is_toplevel (window) ||
5313 /* The restack_under codepath should work correctly even if the parent
5314 is native, but it relies on the order of ->children to be correct,
5315 and some apps like SWT reorder the x windows without gdks knowledge,
5316 so we use lower directly in order to make these behave as before
5317 when using native windows */
5318 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5320 impl_class->lower (window);
5322 else if (gdk_window_has_impl (window))
5324 above = find_native_sibling_above (parent, window);
5327 listhead.data = window;
5328 listhead.next = NULL;
5329 listhead.prev = NULL;
5330 impl_class->restack_under ((GdkWindow *)above, &listhead);
5333 impl_class->raise (window);
5337 native_children = NULL;
5338 get_all_native_children (window, &native_children);
5339 if (native_children != NULL)
5341 above = find_native_sibling_above (parent, window);
5344 impl_class->restack_under ((GdkWindow *)above,
5348 /* Right order, since native_children is bottom-topmost first */
5349 for (l = native_children; l != NULL; l = l->next)
5350 impl_class->raise (l->data);
5353 g_list_free (native_children);
5360 gdk_window_invalidate_in_parent (GdkWindow *private)
5362 GdkRectangle r, child;
5364 if (gdk_window_is_toplevel (private))
5367 /* get the visible rectangle of the parent */
5369 r.width = private->parent->width;
5370 r.height = private->parent->height;
5372 child.x = private->x;
5373 child.y = private->y;
5374 child.width = private->width;
5375 child.height = private->height;
5376 gdk_rectangle_intersect (&r, &child, &r);
5378 gdk_window_invalidate_rect_full (private->parent, &r, TRUE, CLEAR_BG_ALL);
5384 * @window: a #GdkWindow
5386 * Lowers @window to the bottom of the Z-order (stacking order), so that
5387 * other windows with the same parent window appear above @window.
5388 * This is true whether or not the other windows are visible.
5390 * If @window is a toplevel, the window manager may choose to deny the
5391 * request to move the window in the Z-order, gdk_window_lower() only
5392 * requests the restack, does not guarantee it.
5394 * Note that gdk_window_show() raises the window again, so don't call this
5395 * function before gdk_window_show(). (Try gdk_window_show_unraised().)
5398 gdk_window_lower (GdkWindow *window)
5400 g_return_if_fail (GDK_IS_WINDOW (window));
5402 if (window->destroyed)
5405 gdk_window_flush_if_exposing (window);
5407 /* Keep children in (reverse) stacking order */
5408 gdk_window_lower_internal (window);
5410 recompute_visible_regions (window, TRUE, FALSE);
5412 _gdk_synthesize_crossing_events_for_geometry_change (window);
5413 gdk_window_invalidate_in_parent (window);
5417 * gdk_window_restack:
5418 * @window: a #GdkWindow
5419 * @sibling: (allow-none): a #GdkWindow that is a sibling of @window, or %NULL
5422 * Changes the position of @window in the Z-order (stacking order), so that
5423 * it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
5426 * If @sibling is %NULL, then this either raises (if @above is %TRUE) or
5427 * lowers the window.
5429 * If @window is a toplevel, the window manager may choose to deny the
5430 * request to move the window in the Z-order, gdk_window_restack() only
5431 * requests the restack, does not guarantee it.
5436 gdk_window_restack (GdkWindow *window,
5440 GdkWindowImplClass *impl_class;
5442 GdkWindow *above_native;
5443 GList *sibling_link;
5444 GList *native_children;
5447 g_return_if_fail (GDK_IS_WINDOW (window));
5448 g_return_if_fail (sibling == NULL || GDK_IS_WINDOW (sibling));
5450 if (window->destroyed)
5453 if (sibling == NULL)
5456 gdk_window_raise (window);
5458 gdk_window_lower (window);
5462 gdk_window_flush_if_exposing (window);
5464 if (gdk_window_is_toplevel (window))
5466 g_return_if_fail (gdk_window_is_toplevel (sibling));
5467 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5468 impl_class->restack_toplevel (window, sibling, above);
5472 parent = window->parent;
5475 sibling_link = g_list_find (parent->children, sibling);
5476 g_return_if_fail (sibling_link != NULL);
5477 if (sibling_link == NULL)
5480 parent->children = g_list_remove (parent->children, window);
5482 parent->children = g_list_insert_before (parent->children,
5486 parent->children = g_list_insert_before (parent->children,
5490 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5491 if (gdk_window_has_impl (window))
5493 above_native = find_native_sibling_above (parent, window);
5496 listhead.data = window;
5497 listhead.next = NULL;
5498 listhead.prev = NULL;
5499 impl_class->restack_under (above_native, &listhead);
5502 impl_class->raise (window);
5506 native_children = NULL;
5507 get_all_native_children (window, &native_children);
5508 if (native_children != NULL)
5510 above_native = find_native_sibling_above (parent, window);
5512 impl_class->restack_under (above_native,
5516 /* Right order, since native_children is bottom-topmost first */
5517 for (l = native_children; l != NULL; l = l->next)
5518 impl_class->raise (l->data);
5521 g_list_free (native_children);
5526 recompute_visible_regions (window, TRUE, FALSE);
5528 _gdk_synthesize_crossing_events_for_geometry_change (window);
5529 gdk_window_invalidate_in_parent (window);
5535 * @window: a #GdkWindow
5537 * Like gdk_window_show_unraised(), but also raises the window to the
5538 * top of the window stack (moves the window to the front of the
5541 * This function maps a window so it's visible onscreen. Its opposite
5542 * is gdk_window_hide().
5544 * When implementing a #GtkWidget, you should call this function on the widget's
5545 * #GdkWindow as part of the "map" method.
5548 gdk_window_show (GdkWindow *window)
5550 gdk_window_show_internal (window, TRUE);
5555 * @window: a #GdkWindow
5557 * For toplevel windows, withdraws them, so they will no longer be
5558 * known to the window manager; for all windows, unmaps them, so
5559 * they won't be displayed. Normally done automatically as
5560 * part of gtk_widget_hide().
5563 gdk_window_hide (GdkWindow *window)
5565 GdkWindowImplClass *impl_class;
5566 gboolean was_mapped, did_hide;
5568 g_return_if_fail (GDK_IS_WINDOW (window));
5570 if (window->destroyed)
5573 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5575 if (gdk_window_has_impl (window))
5578 if (GDK_WINDOW_IS_MAPPED (window))
5579 gdk_synthesize_window_state (window,
5581 GDK_WINDOW_STATE_WITHDRAWN);
5583 else if (was_mapped)
5585 GdkDisplay *display;
5586 GdkDeviceManager *device_manager;
5589 /* May need to break grabs on children */
5590 display = gdk_window_get_display (window);
5591 device_manager = gdk_display_get_device_manager (display);
5593 /* Get all devices */
5594 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
5595 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
5596 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
5598 for (d = devices; d; d = d->next)
5600 GdkDevice *device = d->data;
5602 if (_gdk_display_end_device_grab (display,
5604 _gdk_display_get_next_serial (display),
5607 gdk_device_ungrab (device, GDK_CURRENT_TIME);
5610 window->state = GDK_WINDOW_STATE_WITHDRAWN;
5611 g_list_free (devices);
5614 did_hide = _gdk_window_update_viewable (window);
5616 /* Hide foreign window as those are not handled by update_viewable. */
5617 if (gdk_window_has_impl (window) && (!did_hide))
5619 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5620 impl_class->hide (window);
5623 recompute_visible_regions (window, TRUE, FALSE);
5625 /* all decendants became non-visible, we need to send visibility notify */
5626 gdk_window_update_visibility_recursively (window, NULL);
5628 if (was_mapped && !gdk_window_has_impl (window))
5630 if (window->event_mask & GDK_STRUCTURE_MASK)
5631 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5633 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5634 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5636 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5639 /* Invalidate the rect */
5641 gdk_window_invalidate_in_parent (window);
5645 * gdk_window_withdraw:
5646 * @window: a toplevel #GdkWindow
5648 * Withdraws a window (unmaps it and asks the window manager to forget about it).
5649 * This function is not really useful as gdk_window_hide() automatically
5650 * withdraws toplevel windows before hiding them.
5653 gdk_window_withdraw (GdkWindow *window)
5655 GdkWindowImplClass *impl_class;
5656 gboolean was_mapped;
5658 g_return_if_fail (GDK_IS_WINDOW (window));
5660 if (window->destroyed)
5663 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5665 if (gdk_window_has_impl (window))
5667 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5668 impl_class->withdraw (window);
5672 if (window->event_mask & GDK_STRUCTURE_MASK)
5673 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5675 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5676 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5678 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5681 recompute_visible_regions (window, TRUE, FALSE);
5686 * gdk_window_set_events:
5687 * @window: a #GdkWindow
5688 * @event_mask: event mask for @window
5690 * The event mask for a window determines which events will be reported
5691 * for that window from all master input devices. For example, an event mask
5692 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5693 * press events. The event mask is the bitwise OR of values from the
5694 * #GdkEventMask enumeration.
5697 gdk_window_set_events (GdkWindow *window,
5698 GdkEventMask event_mask)
5700 GdkWindowImplClass *impl_class;
5701 GdkDisplay *display;
5703 g_return_if_fail (GDK_IS_WINDOW (window));
5705 if (window->destroyed)
5708 /* If motion hint is disabled, enable motion events again */
5709 display = gdk_window_get_display (window);
5710 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5711 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5713 GList *devices = window->devices_inside;
5717 _gdk_display_enable_motion_hints (display, (GdkDevice *) devices->data);
5718 devices = devices->next;
5722 window->event_mask = event_mask;
5724 if (gdk_window_has_impl (window))
5726 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5727 impl_class->set_events (window,
5728 get_native_event_mask (window));
5734 * gdk_window_get_events:
5735 * @window: a #GdkWindow
5737 * Gets the event mask for @window for all master input devices. See
5738 * gdk_window_set_events().
5740 * Return value: event mask for @window
5743 gdk_window_get_events (GdkWindow *window)
5745 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5747 if (window->destroyed)
5750 return window->event_mask;
5754 * gdk_window_set_device_events:
5755 * @window: a #GdkWindow
5756 * @device: #GdkDevice to enable events for.
5757 * @event_mask: event mask for @window
5759 * Sets the event mask for a given device (Normally a floating device, not
5760 * attached to any visible pointer) to @window. For example, an event mask
5761 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5762 * press events. The event mask is the bitwise OR of values from the
5763 * #GdkEventMask enumeration.
5768 gdk_window_set_device_events (GdkWindow *window,
5770 GdkEventMask event_mask)
5772 GdkEventMask device_mask;
5773 GdkDisplay *display;
5776 g_return_if_fail (GDK_IS_WINDOW (window));
5777 g_return_if_fail (GDK_IS_DEVICE (device));
5779 if (GDK_WINDOW_DESTROYED (window))
5782 /* If motion hint is disabled, enable motion events again */
5783 display = gdk_window_get_display (window);
5784 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5785 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5786 _gdk_display_enable_motion_hints (display, device);
5788 if (G_UNLIKELY (!window->device_events))
5789 window->device_events = g_hash_table_new (NULL, NULL);
5791 if (event_mask == 0)
5793 /* FIXME: unsetting events on a master device
5794 * would restore window->event_mask
5796 g_hash_table_remove (window->device_events, device);
5799 g_hash_table_insert (window->device_events, device,
5800 GINT_TO_POINTER (event_mask));
5802 native = gdk_window_get_toplevel (window);
5804 while (gdk_window_is_offscreen (native))
5806 native = gdk_offscreen_window_get_embedder (native);
5808 if (native == NULL ||
5809 (!_gdk_window_has_impl (native) &&
5810 !gdk_window_is_viewable (native)))
5813 native = gdk_window_get_toplevel (native);
5816 device_mask = get_native_device_event_mask (window, device);
5817 GDK_DEVICE_GET_CLASS (device)->select_window_events (device, native, device_mask);
5821 * gdk_window_get_device_events:
5822 * @window: a #GdkWindow.
5823 * @device: a #GdkDevice.
5825 * Returns the event mask for @window corresponding to an specific device.
5827 * Returns: device event mask for @window
5832 gdk_window_get_device_events (GdkWindow *window,
5837 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5838 g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
5840 if (GDK_WINDOW_DESTROYED (window))
5843 if (!window->device_events)
5846 mask = GPOINTER_TO_INT (g_hash_table_lookup (window->device_events, device));
5848 /* FIXME: device could be controlled by window->event_mask */
5854 gdk_window_move_resize_toplevel (GdkWindow *window,
5861 cairo_region_t *old_region, *new_region;
5862 GdkWindowImplClass *impl_class;
5869 is_resize = (width != -1) || (height != -1);
5871 if (gdk_window_is_viewable (window) &&
5872 !window->input_only)
5875 old_region = cairo_region_copy (window->clip_region);
5878 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5879 impl_class->move_resize (window, with_move, x, y, width, height);
5881 /* Avoid recomputing for pure toplevel moves, for performance reasons */
5883 recompute_visible_regions (window, TRUE, FALSE);
5887 new_region = cairo_region_copy (window->clip_region);
5889 /* This is the newly exposed area (due to any resize),
5890 * X will expose it, but lets do that without the roundtrip
5892 cairo_region_subtract (new_region, old_region);
5893 gdk_window_invalidate_region_full (window, new_region, TRUE, CLEAR_BG_WINCLEARED);
5895 cairo_region_destroy (old_region);
5896 cairo_region_destroy (new_region);
5899 _gdk_synthesize_crossing_events_for_geometry_change (window);
5904 move_native_children (GdkWindow *private)
5908 GdkWindowImplClass *impl_class;
5910 for (l = private->children; l; l = l->next)
5914 if (child->impl != private->impl)
5916 impl_class = GDK_WINDOW_IMPL_GET_CLASS (child->impl);
5917 impl_class->move_resize (child, TRUE,
5919 child->width, child->height);
5922 move_native_children (child);
5927 collect_native_child_region_helper (GdkWindow *window,
5928 GdkWindowImpl *impl,
5929 cairo_region_t **region,
5934 cairo_region_t *tmp;
5937 for (l = window->children; l != NULL; l = l->next)
5941 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
5944 if (child->impl != impl)
5946 tmp = cairo_region_copy (child->clip_region);
5947 cairo_region_translate (tmp,
5948 x_offset + child->x,
5949 y_offset + child->y);
5950 if (*region == NULL)
5954 cairo_region_union (*region, tmp);
5955 cairo_region_destroy (tmp);
5959 collect_native_child_region_helper (child, impl, region,
5960 x_offset + child->x,
5961 y_offset + child->y);
5967 static cairo_region_t *
5968 collect_native_child_region (GdkWindow *window,
5969 gboolean include_this)
5971 cairo_region_t *region;
5973 if (include_this && gdk_window_has_impl (window) && window->viewable)
5974 return cairo_region_copy (window->clip_region);
5978 collect_native_child_region_helper (window, window->impl, ®ion, 0, 0);
5985 gdk_window_move_resize_internal (GdkWindow *window,
5992 cairo_region_t *old_region, *new_region, *copy_area;
5993 cairo_region_t *old_native_child_region, *new_native_child_region;
5994 GdkWindow *impl_window;
5995 GdkWindowImplClass *impl_class;
5997 int old_x, old_y, old_abs_x, old_abs_y;
6000 g_return_if_fail (GDK_IS_WINDOW (window));
6002 if (window->destroyed)
6005 if (gdk_window_is_toplevel (window))
6007 gdk_window_move_resize_toplevel (window, with_move, x, y, width, height);
6011 /* Bail early if no change */
6012 if (window->width == width &&
6013 window->height == height &&
6019 gdk_window_flush_if_exposing (window);
6021 /* Handle child windows */
6026 impl_window = gdk_window_get_impl_window (window);
6031 old_native_child_region = NULL;
6032 if (gdk_window_is_viewable (window) &&
6033 !window->input_only)
6037 old_region = cairo_region_copy (window->clip_region);
6038 /* Adjust region to parent window coords */
6039 cairo_region_translate (old_region, window->x, window->y);
6041 old_native_child_region = collect_native_child_region (window, TRUE);
6042 if (old_native_child_region)
6044 /* Adjust region to parent window coords */
6045 cairo_region_translate (old_native_child_region, window->x, window->y);
6047 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6048 * source or destination for a delayed GdkWindowRegionMove. So, we need
6049 * to flush those here for the parent window and all overlapped subwindows
6050 * of it. And we need to do this before setting the new clips as those will be
6053 gdk_window_flush_recursive (window->parent);
6057 /* Set the new position and size */
6063 if (!(width < 0 && height < 0))
6067 window->width = width;
6070 window->height = height;
6073 dx = window->x - old_x;
6074 dy = window->y - old_y;
6076 old_abs_x = window->abs_x;
6077 old_abs_y = window->abs_y;
6079 recompute_visible_regions (window, TRUE, FALSE);
6081 new_native_child_region = NULL;
6082 if (old_native_child_region)
6084 new_native_child_region = collect_native_child_region (window, TRUE);
6085 /* Adjust region to parent window coords */
6086 cairo_region_translate (new_native_child_region, window->x, window->y);
6089 if (gdk_window_has_impl (window))
6091 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6093 /* Do the actual move after recomputing things, as this will have set the shape to
6094 the now correct one, thus avoiding copying regions that should not be copied. */
6095 impl_class->move_resize (window, TRUE,
6096 window->x, window->y,
6097 window->width, window->height);
6099 else if (old_abs_x != window->abs_x ||
6100 old_abs_y != window->abs_y)
6101 move_native_children (window);
6105 new_region = cairo_region_copy (window->clip_region);
6106 /* Adjust region to parent window coords */
6107 cairo_region_translate (new_region, window->x, window->y);
6110 * Part of the data at the new location can be copied from the
6111 * old location, this area is the intersection of the old region
6112 * moved as the copy will move it and then intersected with
6116 * Everything in the old and new regions that is not copied must be
6117 * invalidated (including children) as this is newly exposed
6119 copy_area = cairo_region_copy (new_region);
6121 cairo_region_union (new_region, old_region);
6123 if (old_native_child_region)
6125 /* Don't copy from inside native children, as this is copied by
6126 * the native window move.
6128 cairo_region_subtract (old_region, old_native_child_region);
6130 cairo_region_translate (old_region, dx, dy);
6132 cairo_region_intersect (copy_area, old_region);
6134 if (new_native_child_region)
6136 /* Don't copy any bits that would cause a read from the moved
6137 native windows, as we can't read that data */
6138 cairo_region_translate (new_native_child_region, dx, dy);
6139 cairo_region_subtract (copy_area, new_native_child_region);
6140 cairo_region_translate (new_native_child_region, -dx, -dy);
6143 cairo_region_subtract (new_region, copy_area);
6145 /* Convert old region to impl coords */
6146 cairo_region_translate (old_region, -dx + window->abs_x - window->x, -dy + window->abs_y - window->y);
6148 /* convert from parent coords to impl */
6149 cairo_region_translate (copy_area, window->abs_x - window->x, window->abs_y - window->y);
6151 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6153 /* Invalidate affected part in the parent window
6154 * (no higher window should be affected)
6155 * We also invalidate any children in that area, which could include
6156 * this window if it still overlaps that area.
6158 if (old_native_child_region)
6160 /* No need to expose the region that the native window move copies */
6161 cairo_region_translate (old_native_child_region, dx, dy);
6162 cairo_region_intersect (old_native_child_region, new_native_child_region);
6163 cairo_region_subtract (new_region, old_native_child_region);
6165 gdk_window_invalidate_region_full (window->parent, new_region, TRUE, CLEAR_BG_ALL);
6167 cairo_region_destroy (old_region);
6168 cairo_region_destroy (new_region);
6171 if (old_native_child_region)
6173 cairo_region_destroy (old_native_child_region);
6174 cairo_region_destroy (new_native_child_region);
6177 _gdk_synthesize_crossing_events_for_geometry_change (window);
6184 * @window: a #GdkWindow
6185 * @x: X coordinate relative to window's parent
6186 * @y: Y coordinate relative to window's parent
6188 * Repositions a window relative to its parent window.
6189 * For toplevel windows, window managers may ignore or modify the move;
6190 * you should probably use gtk_window_move() on a #GtkWindow widget
6191 * anyway, instead of using GDK functions. For child windows,
6192 * the move will reliably succeed.
6194 * If you're also planning to resize the window, use gdk_window_move_resize()
6195 * to both move and resize simultaneously, for a nicer visual effect.
6198 gdk_window_move (GdkWindow *window,
6202 gdk_window_move_resize_internal (window, TRUE, x, y, -1, -1);
6206 * gdk_window_resize:
6207 * @window: a #GdkWindow
6208 * @width: new width of the window
6209 * @height: new height of the window
6211 * Resizes @window; for toplevel windows, asks the window manager to resize
6212 * the window. The window manager may not allow the resize. When using GTK+,
6213 * use gtk_window_resize() instead of this low-level GDK function.
6215 * Windows may not be resized below 1x1.
6217 * If you're also planning to move the window, use gdk_window_move_resize()
6218 * to both move and resize simultaneously, for a nicer visual effect.
6221 gdk_window_resize (GdkWindow *window,
6225 gdk_window_move_resize_internal (window, FALSE, 0, 0, width, height);
6230 * gdk_window_move_resize:
6231 * @window: a #GdkWindow
6232 * @x: new X position relative to window's parent
6233 * @y: new Y position relative to window's parent
6235 * @height: new height
6237 * Equivalent to calling gdk_window_move() and gdk_window_resize(),
6238 * except that both operations are performed at once, avoiding strange
6239 * visual effects. (i.e. the user may be able to see the window first
6240 * move, then resize, if you don't use gdk_window_move_resize().)
6243 gdk_window_move_resize (GdkWindow *window,
6249 gdk_window_move_resize_internal (window, TRUE, x, y, width, height);
6254 * gdk_window_scroll:
6255 * @window: a #GdkWindow
6256 * @dx: Amount to scroll in the X direction
6257 * @dy: Amount to scroll in the Y direction
6259 * Scroll the contents of @window, both pixels and children, by the
6260 * given amount. @window itself does not move. Portions of the window
6261 * that the scroll operation brings in from offscreen areas are
6262 * invalidated. The invalidated region may be bigger than what would
6263 * strictly be necessary.
6265 * For X11, a minimum area will be invalidated if the window has no
6266 * subwindows, or if the edges of the window's parent do not extend
6267 * beyond the edges of the window. In other cases, a multi-step process
6268 * is used to scroll the window which may produce temporary visual
6269 * artifacts and unnecessary invalidations.
6272 gdk_window_scroll (GdkWindow *window,
6276 GdkWindow *impl_window;
6277 cairo_region_t *copy_area, *noncopy_area;
6278 cairo_region_t *old_native_child_region, *new_native_child_region;
6281 g_return_if_fail (GDK_IS_WINDOW (window));
6283 if (dx == 0 && dy == 0)
6286 if (window->destroyed)
6289 gdk_window_flush_if_exposing (window);
6291 old_native_child_region = collect_native_child_region (window, FALSE);
6292 if (old_native_child_region)
6294 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6295 * source or destination for a delayed GdkWindowRegionMove. So, we need
6296 * to flush those here for the window and all overlapped subwindows
6297 * of it. And we need to do this before setting the new clips as those will be
6300 gdk_window_flush_recursive (window);
6304 /* First move all child windows, without causing invalidation */
6306 tmp_list = window->children;
6309 GdkWindow *child = GDK_WINDOW (tmp_list->data);
6311 /* Just update the positions, the bits will move with the copy */
6315 tmp_list = tmp_list->next;
6318 recompute_visible_regions (window, FALSE, TRUE);
6320 new_native_child_region = NULL;
6321 if (old_native_child_region)
6322 new_native_child_region = collect_native_child_region (window, FALSE);
6324 move_native_children (window);
6326 /* Then copy the actual bits of the window w/ child windows */
6328 impl_window = gdk_window_get_impl_window (window);
6330 /* Calculate the area that can be gotten by copying the old area */
6331 copy_area = cairo_region_copy (window->clip_region);
6332 if (old_native_child_region)
6334 /* Don't copy from inside native children, as this is copied by
6335 * the native window move.
6337 cairo_region_subtract (copy_area, old_native_child_region);
6339 /* Don't copy any bits that would cause a read from the moved
6340 native windows, as we can't read that data */
6341 cairo_region_subtract (copy_area, new_native_child_region);
6343 cairo_region_translate (copy_area, dx, dy);
6344 cairo_region_intersect (copy_area, window->clip_region);
6346 /* And the rest need to be invalidated */
6347 noncopy_area = cairo_region_copy (window->clip_region);
6348 cairo_region_subtract (noncopy_area, copy_area);
6350 /* convert from window coords to impl */
6351 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6353 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6355 /* Invalidate not copied regions */
6356 if (old_native_child_region)
6358 /* No need to expose the region that the native window move copies */
6359 cairo_region_translate (old_native_child_region, dx, dy);
6360 cairo_region_intersect (old_native_child_region, new_native_child_region);
6361 cairo_region_subtract (noncopy_area, old_native_child_region);
6363 gdk_window_invalidate_region_full (window, noncopy_area, TRUE, CLEAR_BG_ALL);
6365 cairo_region_destroy (noncopy_area);
6367 if (old_native_child_region)
6369 cairo_region_destroy (old_native_child_region);
6370 cairo_region_destroy (new_native_child_region);
6373 _gdk_synthesize_crossing_events_for_geometry_change (window);
6377 * gdk_window_move_region:
6378 * @window: a #GdkWindow
6379 * @region: The #cairo_region_t to move
6380 * @dx: Amount to move in the X direction
6381 * @dy: Amount to move in the Y direction
6383 * Move the part of @window indicated by @region by @dy pixels in the Y
6384 * direction and @dx pixels in the X direction. The portions of @region
6385 * that not covered by the new position of @region are invalidated.
6387 * Child windows are not moved.
6392 gdk_window_move_region (GdkWindow *window,
6393 const cairo_region_t *region,
6397 GdkWindow *impl_window;
6398 cairo_region_t *nocopy_area;
6399 cairo_region_t *copy_area;
6401 g_return_if_fail (GDK_IS_WINDOW (window));
6402 g_return_if_fail (region != NULL);
6404 if (dx == 0 && dy == 0)
6407 if (window->destroyed)
6410 impl_window = gdk_window_get_impl_window (window);
6412 /* compute source regions */
6413 copy_area = cairo_region_copy (region);
6414 cairo_region_intersect (copy_area, window->clip_region_with_children);
6416 /* compute destination regions */
6417 cairo_region_translate (copy_area, dx, dy);
6418 cairo_region_intersect (copy_area, window->clip_region_with_children);
6420 /* Invalidate parts of the region (source and dest) not covered
6422 nocopy_area = cairo_region_copy (region);
6423 cairo_region_translate (nocopy_area, dx, dy);
6424 cairo_region_union (nocopy_area, region);
6425 cairo_region_subtract (nocopy_area, copy_area);
6427 /* convert from window coords to impl */
6428 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6429 move_region_on_impl (impl_window, copy_area, dx, dy); /* Takes ownership of copy_area */
6431 gdk_window_invalidate_region_full (window, nocopy_area, FALSE, CLEAR_BG_ALL);
6432 cairo_region_destroy (nocopy_area);
6436 * gdk_window_set_background:
6437 * @window: a #GdkWindow
6438 * @color: a #GdkColor
6440 * Sets the background color of @window. (However, when using GTK+,
6441 * set the background of a widget with gtk_widget_modify_bg() - if
6442 * you're an application - or gtk_style_set_background() - if you're
6443 * implementing a custom widget.)
6445 * See also gdk_window_set_background_pattern().
6448 gdk_window_set_background (GdkWindow *window,
6449 const GdkColor *color)
6451 cairo_pattern_t *pattern;
6453 g_return_if_fail (GDK_IS_WINDOW (window));
6455 pattern = cairo_pattern_create_rgb (color->red / 65535.,
6456 color->green / 65535.,
6457 color->blue / 65535.);
6459 gdk_window_set_background_pattern (window, pattern);
6461 cairo_pattern_destroy (pattern);
6465 * gdk_window_set_background_rgba:
6466 * @window: a #GdkWindow
6467 * @rgba: a #GdkRGBA color
6469 * Sets the background color of @window.
6471 * See also gdk_window_set_background_pattern().
6474 gdk_window_set_background_rgba (GdkWindow *window,
6477 cairo_pattern_t *pattern;
6479 g_return_if_fail (GDK_IS_WINDOW (window));
6480 g_return_if_fail (rgba != NULL);
6482 pattern = cairo_pattern_create_rgba (rgba->red, rgba->green,
6483 rgba->blue, rgba->alpha);
6485 gdk_window_set_background_pattern (window, pattern);
6487 cairo_pattern_destroy (pattern);
6491 * gdk_window_set_background_pattern:
6492 * @window: a #GdkWindow
6493 * @pattern: (allow-none): a pattern to use, or %NULL
6495 * Sets the background of @window.
6497 * A background of %NULL means that the window will inherit its
6498 * background form its parent window.
6500 * The windowing system will normally fill a window with its background
6501 * when the window is obscured then exposed.
6504 gdk_window_set_background_pattern (GdkWindow *window,
6505 cairo_pattern_t *pattern)
6507 g_return_if_fail (GDK_IS_WINDOW (window));
6509 if (window->input_only)
6513 cairo_pattern_reference (pattern);
6514 if (window->background)
6515 cairo_pattern_destroy (window->background);
6516 window->background = pattern;
6518 if (gdk_window_has_impl (window))
6520 GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6521 impl_class->set_background (window, pattern);
6524 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
6528 * gdk_window_get_background_pattern:
6531 * Gets the pattern used to clear the background on @window. If @window
6532 * does not have its own background and reuses the parent's, %NULL is
6533 * returned and you'll have to query it yourself.
6535 * Returns: (transfer none): The pattern to use for the background or
6536 * %NULL to use the parent's background.
6541 gdk_window_get_background_pattern (GdkWindow *window)
6543 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6545 return window->background;
6549 gdk_window_set_cursor_internal (GdkWindow *window,
6553 if (GDK_WINDOW_DESTROYED (window))
6556 if (window->window_type == GDK_WINDOW_ROOT ||
6557 window->window_type == GDK_WINDOW_FOREIGN)
6558 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_device_cursor (window, device, cursor);
6561 GdkPointerWindowInfo *pointer_info;
6562 GdkDisplay *display;
6564 display = gdk_window_get_display (window);
6565 pointer_info = _gdk_display_get_pointer_info (display, device);
6567 if (_gdk_window_event_parent_of (window, pointer_info->window_under_pointer))
6568 update_cursor (display, device);
6573 * gdk_window_get_cursor:
6574 * @window: a #GdkWindow
6576 * Retrieves a #GdkCursor pointer for the cursor currently set on the
6577 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6578 * there is no custom cursor set on the specified window, and it is
6579 * using the cursor for its parent window.
6581 * Return value: (transfer none): a #GdkCursor, or %NULL. The returned
6582 * object is owned by the #GdkWindow and should not be unreferenced
6583 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6589 gdk_window_get_cursor (GdkWindow *window)
6591 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6593 return window->cursor;
6597 * gdk_window_set_cursor:
6598 * @window: a #GdkWindow
6599 * @cursor: (allow-none): a cursor
6601 * Sets the default mouse pointer for a #GdkWindow. Use gdk_cursor_new_for_display()
6602 * or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor
6603 * invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument
6604 * to gdk_window_set_cursor() means that @window will use the cursor of its
6605 * parent window. Most windows should use this default.
6608 gdk_window_set_cursor (GdkWindow *window,
6611 GdkDisplay *display;
6613 g_return_if_fail (GDK_IS_WINDOW (window));
6615 display = gdk_window_get_display (window);
6619 g_object_unref (window->cursor);
6620 window->cursor = NULL;
6623 if (!GDK_WINDOW_DESTROYED (window))
6625 GdkDeviceManager *device_manager;
6629 window->cursor = g_object_ref (cursor);
6631 device_manager = gdk_display_get_device_manager (display);
6632 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
6634 for (d = devices; d; d = d->next)
6640 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
6643 gdk_window_set_cursor_internal (window, device, window->cursor);
6646 g_list_free (devices);
6647 g_object_notify (G_OBJECT (window), "cursor");
6652 * gdk_window_get_device_cursor:
6653 * @window: a #GdkWindow.
6654 * @device: a master, pointer #GdkDevice.
6656 * Retrieves a #GdkCursor pointer for the @device currently set on the
6657 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6658 * there is no custom cursor set on the specified window, and it is
6659 * using the cursor for its parent window.
6661 * Returns: (transfer none): a #GdkCursor, or %NULL. The returned
6662 * object is owned by the #GdkWindow and should not be unreferenced
6663 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6669 gdk_window_get_device_cursor (GdkWindow *window,
6672 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6673 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
6674 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
6675 g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, NULL);
6677 return g_hash_table_lookup (window->device_cursor, device);
6681 * gdk_window_set_device_cursor:
6682 * @window: a #Gdkwindow
6683 * @device: a master, pointer #GdkDevice
6684 * @cursor: a #GdkCursor
6686 * Sets a specific #GdkCursor for a given device when it gets inside @window.
6687 * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
6688 * the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
6689 * %NULL for the @cursor argument to gdk_window_set_cursor() means that
6690 * @window will use the cursor of its parent window. Most windows should
6696 gdk_window_set_device_cursor (GdkWindow *window,
6700 g_return_if_fail (GDK_IS_WINDOW (window));
6701 g_return_if_fail (GDK_IS_DEVICE (device));
6702 g_return_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD);
6703 g_return_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER);
6706 g_hash_table_remove (window->device_cursor, device);
6708 g_hash_table_replace (window->device_cursor, device, g_object_ref (cursor));
6710 gdk_window_set_cursor_internal (window, device, cursor);
6714 * gdk_window_get_geometry:
6715 * @window: a #GdkWindow
6716 * @x: (out) (allow-none): return location for X coordinate of window (relative to its parent)
6717 * @y: (out) (allow-none): return location for Y coordinate of window (relative to its parent)
6718 * @width: (out) (allow-none): return location for width of window
6719 * @height: (out) (allow-none): return location for height of window
6721 * Any of the return location arguments to this function may be %NULL,
6722 * if you aren't interested in getting the value of that field.
6724 * The X and Y coordinates returned are relative to the parent window
6725 * of @window, which for toplevels usually means relative to the
6726 * window decorations (titlebar, etc.) rather than relative to the
6727 * root window (screen-size background window).
6729 * On the X11 platform, the geometry is obtained from the X server,
6730 * so reflects the latest position of @window; this may be out-of-sync
6731 * with the position of @window delivered in the most-recently-processed
6732 * #GdkEventConfigure. gdk_window_get_position() in contrast gets the
6733 * position from the most recent configure event.
6736 * If @window is not a toplevel, it is <emphasis>much</emphasis> better
6737 * to call gdk_window_get_position(), gdk_window_get_width() and
6738 * gdk_window_get_height() instead, because it avoids the roundtrip to
6739 * the X server and because these functions support the full 32-bit
6740 * coordinate space, whereas gdk_window_get_geometry() is restricted to
6741 * the 16-bit coordinates of X11.
6745 gdk_window_get_geometry (GdkWindow *window,
6752 GdkWindowImplClass *impl_class;
6756 GDK_NOTE (MULTIHEAD,
6757 g_message ("gdk_window_get_geometry(): Window needs "
6758 "to be non-NULL to be multi head safe"));
6759 window = gdk_screen_get_root_window ((gdk_screen_get_default ()));
6762 g_return_if_fail (GDK_IS_WINDOW (window));
6764 if (!GDK_WINDOW_DESTROYED (window))
6766 if (gdk_window_has_impl (window))
6768 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6769 impl_class->get_geometry (window, x, y,
6771 /* This reports the position wrt to the native parent, we need to convert
6772 it to be relative to the client side parent */
6773 parent = window->parent;
6774 if (parent && !gdk_window_has_impl (parent))
6777 *x -= parent->abs_x;
6779 *y -= parent->abs_y;
6789 *width = window->width;
6791 *height = window->height;
6797 * gdk_window_get_width:
6798 * @window: a #GdkWindow
6800 * Returns the width of the given @window.
6802 * On the X11 platform the returned size is the size reported in the
6803 * most-recently-processed configure event, rather than the current
6804 * size on the X server.
6806 * Returns: The width of @window
6811 gdk_window_get_width (GdkWindow *window)
6813 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6815 return window->width;
6819 * gdk_window_get_height:
6820 * @window: a #GdkWindow
6822 * Returns the height of the given @window.
6824 * On the X11 platform the returned size is the size reported in the
6825 * most-recently-processed configure event, rather than the current
6826 * size on the X server.
6828 * Returns: The height of @window
6833 gdk_window_get_height (GdkWindow *window)
6835 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6837 return window->height;
6841 * gdk_window_get_origin:
6842 * @window: a #GdkWindow
6843 * @x: (out) (allow-none): return location for X coordinate
6844 * @y: (out) (allow-none): return location for Y coordinate
6846 * Obtains the position of a window in root window coordinates.
6847 * (Compare with gdk_window_get_position() and
6848 * gdk_window_get_geometry() which return the position of a window
6849 * relative to its parent window.)
6851 * Return value: not meaningful, ignore
6854 gdk_window_get_origin (GdkWindow *window,
6858 GdkWindowImplClass *impl_class;
6860 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6862 if (GDK_WINDOW_DESTROYED (window))
6871 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6872 impl_class->get_root_coords (window,
6881 * gdk_window_get_root_coords:
6882 * @window: a #GdkWindow
6883 * @x: X coordinate in window
6884 * @y: Y coordinate in window
6885 * @root_x: (out): return location for X coordinate
6886 * @root_y: (out): return location for Y coordinate
6888 * Obtains the position of a window position in root
6889 * window coordinates. This is similar to
6890 * gdk_window_get_origin() but allows you go pass
6891 * in any position in the window, not just the origin.
6896 gdk_window_get_root_coords (GdkWindow *window,
6902 GdkWindowImplClass *impl_class;
6904 g_return_if_fail (GDK_IS_WINDOW (window));
6906 if (GDK_WINDOW_DESTROYED (window))
6913 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6914 impl_class->get_root_coords (window,
6921 * gdk_window_coords_to_parent:
6922 * @window: a child window
6923 * @x: X coordinate in child's coordinate system
6924 * @y: Y coordinate in child's coordinate system
6925 * @parent_x: (out) (allow-none): return location for X coordinate
6926 * in parent's coordinate system, or %NULL
6927 * @parent_y: (out) (allow-none): return location for Y coordinate
6928 * in parent's coordinate system, or %NULL
6930 * Transforms window coordinates from a child window to its parent
6931 * window, where the parent window is the normal parent as returned by
6932 * gdk_window_get_parent() for normal windows, and the window's
6933 * embedder as returned by gdk_offscreen_window_get_embedder() for
6934 * offscreen windows.
6936 * For normal windows, calling this function is equivalent to adding
6937 * the return values of gdk_window_get_position() to the child coordinates.
6938 * For offscreen windows however (which can be arbitrarily transformed),
6939 * this function calls the GdkWindow::to-embedder: signal to translate
6942 * You should always use this function when writing generic code that
6943 * walks up a window hierarchy.
6945 * See also: gdk_window_coords_from_parent()
6950 gdk_window_coords_to_parent (GdkWindow *window,
6956 g_return_if_fail (GDK_IS_WINDOW (window));
6958 if (gdk_window_is_offscreen (window))
6962 to_embedder (window, x, y, &px, &py);
6973 *parent_x = x + window->x;
6976 *parent_y = y + window->y;
6981 * gdk_window_coords_from_parent:
6982 * @window: a child window
6983 * @parent_x: X coordinate in parent's coordinate system
6984 * @parent_y: Y coordinate in parent's coordinate system
6985 * @x: (out) (allow-none): return location for X coordinate in child's coordinate system
6986 * @y: (out) (allow-none): return location for Y coordinate in child's coordinate system
6988 * Transforms window coordinates from a parent window to a child
6989 * window, where the parent window is the normal parent as returned by
6990 * gdk_window_get_parent() for normal windows, and the window's
6991 * embedder as returned by gdk_offscreen_window_get_embedder() for
6992 * offscreen windows.
6994 * For normal windows, calling this function is equivalent to subtracting
6995 * the return values of gdk_window_get_position() from the parent coordinates.
6996 * For offscreen windows however (which can be arbitrarily transformed),
6997 * this function calls the GdkWindow::from-embedder: signal to translate
7000 * You should always use this function when writing generic code that
7001 * walks down a window hierarchy.
7003 * See also: gdk_window_coords_to_parent()
7008 gdk_window_coords_from_parent (GdkWindow *window,
7014 g_return_if_fail (GDK_IS_WINDOW (window));
7016 if (gdk_window_is_offscreen (window))
7020 from_embedder (window, parent_x, parent_y, &cx, &cy);
7031 *x = parent_x - window->x;
7034 *y = parent_y - window->y;
7039 * gdk_window_shape_combine_region:
7040 * @window: a #GdkWindow
7041 * @shape_region: (allow-none): region of window to be non-transparent
7042 * @offset_x: X position of @shape_region in @window coordinates
7043 * @offset_y: Y position of @shape_region in @window coordinates
7045 * Makes pixels in @window outside @shape_region be transparent,
7046 * so that the window may be nonrectangular.
7048 * If @shape_region is %NULL, the shape will be unset, so the whole
7049 * window will be opaque again. @offset_x and @offset_y are ignored
7050 * if @shape_region is %NULL.
7052 * On the X11 platform, this uses an X server extension which is
7053 * widely available on most common platforms, but not available on
7054 * very old X servers, and occasionally the implementation will be
7055 * buggy. On servers without the shape extension, this function
7058 * This function works on both toplevel and child windows.
7061 gdk_window_shape_combine_region (GdkWindow *window,
7062 const cairo_region_t *shape_region,
7066 cairo_region_t *old_region, *new_region, *diff;
7068 g_return_if_fail (GDK_IS_WINDOW (window));
7070 if (GDK_WINDOW_DESTROYED (window))
7073 if (!window->shape && shape_region == NULL)
7076 window->shaped = (shape_region != NULL);
7079 cairo_region_destroy (window->shape);
7082 if (GDK_WINDOW_IS_MAPPED (window))
7083 old_region = cairo_region_copy (window->clip_region);
7087 window->shape = cairo_region_copy (shape_region);
7088 cairo_region_translate (window->shape, offset_x, offset_y);
7091 window->shape = NULL;
7093 recompute_visible_regions (window, TRUE, FALSE);
7095 if (gdk_window_has_impl (window) &&
7096 !should_apply_clip_as_shape (window))
7097 apply_shape (window, window->shape);
7101 new_region = cairo_region_copy (window->clip_region);
7103 /* New area in the window, needs invalidation */
7104 diff = cairo_region_copy (new_region);
7105 cairo_region_subtract (diff, old_region);
7107 gdk_window_invalidate_region_full (window, diff, TRUE, CLEAR_BG_ALL);
7109 cairo_region_destroy (diff);
7111 if (!gdk_window_is_toplevel (window))
7113 /* New area in the non-root parent window, needs invalidation */
7114 diff = cairo_region_copy (old_region);
7115 cairo_region_subtract (diff, new_region);
7117 /* Adjust region to parent window coords */
7118 cairo_region_translate (diff, window->x, window->y);
7120 gdk_window_invalidate_region_full (window->parent, diff, TRUE, CLEAR_BG_ALL);
7122 cairo_region_destroy (diff);
7125 cairo_region_destroy (new_region);
7126 cairo_region_destroy (old_region);
7131 do_child_shapes (GdkWindow *window,
7135 cairo_region_t *region;
7139 r.width = window->width;
7140 r.height = window->height;
7142 region = cairo_region_create_rectangle (&r);
7143 remove_child_area (window, NULL, FALSE, region);
7145 if (merge && window->shape)
7146 cairo_region_subtract (region, window->shape);
7148 gdk_window_shape_combine_region (window, region, 0, 0);
7152 * gdk_window_set_child_shapes:
7153 * @window: a #GdkWindow
7155 * Sets the shape mask of @window to the union of shape masks
7156 * for all children of @window, ignoring the shape mask of @window
7157 * itself. Contrast with gdk_window_merge_child_shapes() which includes
7158 * the shape mask of @window in the masks to be merged.
7161 gdk_window_set_child_shapes (GdkWindow *window)
7163 g_return_if_fail (GDK_IS_WINDOW (window));
7165 do_child_shapes (window, FALSE);
7169 * gdk_window_merge_child_shapes:
7170 * @window: a #GdkWindow
7172 * Merges the shape masks for any child windows into the
7173 * shape mask for @window. i.e. the union of all masks
7174 * for @window and its children will become the new mask
7175 * for @window. See gdk_window_shape_combine_region().
7177 * This function is distinct from gdk_window_set_child_shapes()
7178 * because it includes @window's shape mask in the set of shapes to
7182 gdk_window_merge_child_shapes (GdkWindow *window)
7184 g_return_if_fail (GDK_IS_WINDOW (window));
7186 do_child_shapes (window, TRUE);
7190 * gdk_window_input_shape_combine_region:
7191 * @window: a #GdkWindow
7192 * @shape_region: region of window to be non-transparent
7193 * @offset_x: X position of @shape_region in @window coordinates
7194 * @offset_y: Y position of @shape_region in @window coordinates
7196 * Like gdk_window_shape_combine_region(), but the shape applies
7197 * only to event handling. Mouse events which happen while
7198 * the pointer position corresponds to an unset bit in the
7199 * mask will be passed on the window below @window.
7201 * An input shape is typically used with RGBA windows.
7202 * The alpha channel of the window defines which pixels are
7203 * invisible and allows for nicely antialiased borders,
7204 * and the input shape controls where the window is
7207 * On the X11 platform, this requires version 1.1 of the
7210 * On the Win32 platform, this functionality is not present and the
7211 * function does nothing.
7216 gdk_window_input_shape_combine_region (GdkWindow *window,
7217 const cairo_region_t *shape_region,
7221 GdkWindowImplClass *impl_class;
7223 g_return_if_fail (GDK_IS_WINDOW (window));
7225 if (GDK_WINDOW_DESTROYED (window))
7228 if (window->input_shape)
7229 cairo_region_destroy (window->input_shape);
7233 window->input_shape = cairo_region_copy (shape_region);
7234 cairo_region_translate (window->input_shape, offset_x, offset_y);
7237 window->input_shape = NULL;
7239 if (gdk_window_has_impl (window))
7241 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7242 impl_class->input_shape_combine_region (window, window->input_shape, 0, 0);
7245 /* Pointer may have e.g. moved outside window due to the input mask change */
7246 _gdk_synthesize_crossing_events_for_geometry_change (window);
7250 do_child_input_shapes (GdkWindow *window,
7254 cairo_region_t *region;
7258 r.width = window->width;
7259 r.height = window->height;
7261 region = cairo_region_create_rectangle (&r);
7262 remove_child_area (window, NULL, TRUE, region);
7264 if (merge && window->shape)
7265 cairo_region_subtract (region, window->shape);
7266 if (merge && window->input_shape)
7267 cairo_region_subtract (region, window->input_shape);
7269 gdk_window_input_shape_combine_region (window, region, 0, 0);
7274 * gdk_window_set_child_input_shapes:
7275 * @window: a #GdkWindow
7277 * Sets the input shape mask of @window to the union of input shape masks
7278 * for all children of @window, ignoring the input shape mask of @window
7279 * itself. Contrast with gdk_window_merge_child_input_shapes() which includes
7280 * the input shape mask of @window in the masks to be merged.
7285 gdk_window_set_child_input_shapes (GdkWindow *window)
7287 g_return_if_fail (GDK_IS_WINDOW (window));
7289 do_child_input_shapes (window, FALSE);
7293 * gdk_window_merge_child_input_shapes:
7294 * @window: a #GdkWindow
7296 * Merges the input shape masks for any child windows into the
7297 * input shape mask for @window. i.e. the union of all input masks
7298 * for @window and its children will become the new input mask
7299 * for @window. See gdk_window_input_shape_combine_region().
7301 * This function is distinct from gdk_window_set_child_input_shapes()
7302 * because it includes @window's input shape mask in the set of
7303 * shapes to be merged.
7308 gdk_window_merge_child_input_shapes (GdkWindow *window)
7310 g_return_if_fail (GDK_IS_WINDOW (window));
7312 do_child_input_shapes (window, TRUE);
7317 * gdk_window_set_static_gravities:
7318 * @window: a #GdkWindow
7319 * @use_static: %TRUE to turn on static gravity
7321 * Set the bit gravity of the given window to static, and flag it so
7322 * all children get static subwindow gravity. This is used if you are
7323 * implementing scary features that involve deep knowledge of the
7324 * windowing system. Don't worry about it unless you have to.
7326 * Return value: %TRUE if the server supports static gravity
7329 gdk_window_set_static_gravities (GdkWindow *window,
7330 gboolean use_static)
7332 GdkWindowImplClass *impl_class;
7334 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7336 if (gdk_window_has_impl (window))
7338 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7339 return impl_class->set_static_gravities (window, use_static);
7346 * gdk_window_get_composited:
7347 * @window: a #GdkWindow
7349 * Determines whether @window is composited.
7351 * See gdk_window_set_composited().
7353 * Returns: %TRUE if the window is composited.
7358 gdk_window_get_composited (GdkWindow *window)
7360 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7362 return window->composited;
7366 * gdk_window_set_composited:
7367 * @window: a #GdkWindow
7368 * @composited: %TRUE to set the window as composited
7370 * Sets a #GdkWindow as composited, or unsets it. Composited
7371 * windows do not automatically have their contents drawn to
7372 * the screen. Drawing is redirected to an offscreen buffer
7373 * and an expose event is emitted on the parent of the composited
7374 * window. It is the responsibility of the parent's expose handler
7375 * to manually merge the off-screen content onto the screen in
7376 * whatever way it sees fit. See <xref linkend="composited-window-example"/>
7379 * It only makes sense for child windows to be composited; see
7380 * gdk_window_set_opacity() if you need translucent toplevel
7383 * An additional effect of this call is that the area of this
7384 * window is no longer clipped from regions marked for
7385 * invalidation on its parent. Draws done on the parent
7386 * window are also no longer clipped by the child.
7388 * This call is only supported on some systems (currently,
7389 * only X11 with new enough Xcomposite and Xdamage extensions).
7390 * You must call gdk_display_supports_composite() to check if
7391 * setting a window as composited is supported before
7392 * attempting to do so.
7397 gdk_window_set_composited (GdkWindow *window,
7398 gboolean composited)
7400 GdkDisplay *display;
7401 GdkWindowImplClass *impl_class;
7403 g_return_if_fail (GDK_IS_WINDOW (window));
7405 composited = composited != FALSE;
7407 if (window->composited == composited)
7411 gdk_window_ensure_native (window);
7413 display = gdk_window_get_display (window);
7415 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7417 if (composited && (!gdk_display_supports_composite (display) || !impl_class->set_composited))
7419 g_warning ("gdk_window_set_composited called but "
7420 "compositing is not supported");
7424 impl_class->set_composited (window, composited);
7426 recompute_visible_regions (window, TRUE, FALSE);
7428 if (GDK_WINDOW_IS_MAPPED (window))
7429 gdk_window_invalidate_in_parent (window);
7431 window->composited = composited;
7435 * gdk_window_get_modal_hint:
7436 * @window: A toplevel #GdkWindow.
7438 * Determines whether or not the window manager is hinted that @window
7439 * has modal behaviour.
7441 * Return value: whether or not the window has the modal hint set.
7446 gdk_window_get_modal_hint (GdkWindow *window)
7448 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7450 return window->modal_hint;
7454 * gdk_window_get_accept_focus:
7455 * @window: a toplevel #GdkWindow.
7457 * Determines whether or not the desktop environment shuld be hinted that
7458 * the window does not want to receive input focus.
7460 * Return value: whether or not the window should receive input focus.
7465 gdk_window_get_accept_focus (GdkWindow *window)
7467 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7469 return window->accept_focus;
7473 * gdk_window_get_focus_on_map:
7474 * @window: a toplevel #GdkWindow.
7476 * Determines whether or not the desktop environment should be hinted that the
7477 * window does not want to receive input focus when it is mapped.
7479 * Return value: whether or not the window wants to receive input focus when
7485 gdk_window_get_focus_on_map (GdkWindow *window)
7487 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7489 return window->focus_on_map;
7493 * gdk_window_is_input_only:
7494 * @window: a toplevel #GdkWindow
7496 * Determines whether or not the window is an input only window.
7498 * Return value: %TRUE if @window is input only
7503 gdk_window_is_input_only (GdkWindow *window)
7505 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7507 return window->input_only;
7511 * gdk_window_is_shaped:
7512 * @window: a toplevel #GdkWindow
7514 * Determines whether or not the window is shaped.
7516 * Return value: %TRUE if @window is shaped
7521 gdk_window_is_shaped (GdkWindow *window)
7523 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7525 return window->shaped;
7529 window_get_size_rectangle (GdkWindow *window,
7532 rect->x = rect->y = 0;
7533 rect->width = window->width;
7534 rect->height = window->height;
7537 /* Calculates the real clipping region for a window, in window coordinates,
7538 * taking into account other windows, gc clip region and gc clip mask.
7541 _gdk_window_calculate_full_clip_region (GdkWindow *window,
7542 GdkWindow *base_window,
7543 gboolean do_children,
7544 gint *base_x_offset,
7545 gint *base_y_offset)
7547 GdkRectangle visible_rect;
7548 cairo_region_t *real_clip_region;
7549 gint x_offset, y_offset;
7550 GdkWindow *parentwin, *lastwin;
7557 if (!window->viewable || window->input_only)
7558 return cairo_region_create ();
7560 window_get_size_rectangle (window, &visible_rect);
7562 /* real_clip_region is in window coordinates */
7563 real_clip_region = cairo_region_create_rectangle (&visible_rect);
7565 x_offset = y_offset = 0;
7569 parentwin = lastwin;
7571 parentwin = lastwin->parent;
7573 /* Remove the areas of all overlapping windows above parentwin in the hiearachy */
7574 for (; parentwin != NULL &&
7575 (parentwin == window || lastwin != base_window);
7576 lastwin = parentwin, parentwin = lastwin->parent)
7579 GdkRectangle real_clip_rect;
7581 if (parentwin != window)
7583 x_offset += lastwin->x;
7584 y_offset += lastwin->y;
7587 /* children is ordered in reverse stack order */
7588 for (cur = parentwin->children;
7589 cur && cur->data != lastwin;
7592 GdkWindow *child = cur->data;
7594 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
7597 /* Ignore offscreen children, as they don't draw in their parent and
7598 * don't take part in the clipping */
7599 if (gdk_window_is_offscreen (child))
7602 window_get_size_rectangle (child, &visible_rect);
7604 /* Convert rect to "window" coords */
7605 visible_rect.x += child->x - x_offset;
7606 visible_rect.y += child->y - y_offset;
7608 /* This shortcut is really necessary for performance when there are a lot of windows */
7609 cairo_region_get_extents (real_clip_region, &real_clip_rect);
7610 if (visible_rect.x >= real_clip_rect.x + real_clip_rect.width ||
7611 visible_rect.x + visible_rect.width <= real_clip_rect.x ||
7612 visible_rect.y >= real_clip_rect.y + real_clip_rect.height ||
7613 visible_rect.y + visible_rect.height <= real_clip_rect.y)
7616 cairo_region_subtract_rectangle (real_clip_region, &visible_rect);
7619 /* Clip to the parent */
7620 window_get_size_rectangle ((GdkWindow *)parentwin, &visible_rect);
7621 /* Convert rect to "window" coords */
7622 visible_rect.x += - x_offset;
7623 visible_rect.y += - y_offset;
7625 cairo_region_intersect_rectangle (real_clip_region, &visible_rect);
7629 *base_x_offset = x_offset;
7631 *base_y_offset = y_offset;
7633 return real_clip_region;
7637 _gdk_window_add_damage (GdkWindow *toplevel,
7638 cairo_region_t *damaged_region)
7640 GdkDisplay *display;
7641 GdkEvent event = { 0, };
7642 event.expose.type = GDK_DAMAGE;
7643 event.expose.window = toplevel;
7644 event.expose.send_event = FALSE;
7645 event.expose.region = damaged_region;
7646 cairo_region_get_extents (event.expose.region, &event.expose.area);
7647 display = gdk_window_get_display (event.expose.window);
7648 _gdk_event_queue_append (display, gdk_event_copy (&event));
7651 /* Gets the toplevel for a window as used for events,
7652 i.e. including offscreen parents */
7654 get_event_parent (GdkWindow *window)
7656 if (gdk_window_is_offscreen (window))
7657 return gdk_offscreen_window_get_embedder ((GdkWindow *)window);
7659 return window->parent;
7662 /* Gets the toplevel for a window as used for events,
7663 i.e. including offscreen parents going up to the native
7666 get_event_toplevel (GdkWindow *window)
7670 while ((parent = get_event_parent (window)) != NULL &&
7671 (parent->window_type != GDK_WINDOW_ROOT))
7678 _gdk_window_event_parent_of (GdkWindow *parent,
7689 w = get_event_parent (w);
7696 update_cursor (GdkDisplay *display,
7699 GdkWindow *cursor_window, *parent, *toplevel;
7700 GdkWindow *pointer_window;
7701 GdkWindowImplClass *impl_class;
7702 GdkPointerWindowInfo *pointer_info;
7703 GdkDeviceGrabInfo *grab;
7706 pointer_info = _gdk_display_get_pointer_info (display, device);
7707 pointer_window = pointer_info->window_under_pointer;
7709 /* We ignore the serials here and just pick the last grab
7710 we've sent, as that would shortly be used anyway. */
7711 grab = _gdk_display_get_last_device_grab (display, device);
7714 /* the pointer is not in a descendant of the grab window */
7715 !_gdk_window_event_parent_of (grab->window, pointer_window))
7717 /* use the cursor from the grab window */
7718 cursor_window = grab->window;
7722 /* otherwise use the cursor from the pointer window */
7723 cursor_window = pointer_window;
7726 /* Find the first window with the cursor actually set, as
7727 the cursor is inherited from the parent */
7728 while (cursor_window->cursor == NULL &&
7729 (parent = get_event_parent (cursor_window)) != NULL &&
7730 parent->window_type != GDK_WINDOW_ROOT)
7731 cursor_window = parent;
7733 cursor = g_hash_table_lookup (cursor_window->device_cursor, device);
7736 cursor = cursor_window->cursor;
7738 /* Set all cursors on toplevel, otherwise its tricky to keep track of
7739 * which native window has what cursor set. */
7740 toplevel = get_event_toplevel (pointer_window);
7741 impl_class = GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl);
7742 impl_class->set_device_cursor (toplevel, device, cursor);
7746 point_in_window (GdkWindow *window,
7751 x >= 0 && x < window->width &&
7752 y >= 0 && y < window->height &&
7753 (window->shape == NULL ||
7754 cairo_region_contains_point (window->shape,
7756 (window->input_shape == NULL ||
7757 cairo_region_contains_point (window->input_shape,
7762 convert_native_coords_to_toplevel (GdkWindow *window,
7765 gdouble *toplevel_x,
7766 gdouble *toplevel_y)
7773 while (!gdk_window_is_toplevel (window))
7777 window = window->parent;
7787 convert_toplevel_coords_to_window (GdkWindow *window,
7795 GList *children, *l;
7801 while ((parent = get_event_parent (window)) != NULL &&
7802 (parent->window_type != GDK_WINDOW_ROOT))
7804 children = g_list_prepend (children, window);
7808 for (l = children; l != NULL; l = l->next)
7809 gdk_window_coords_from_parent (l->data, x, y, &x, &y);
7811 g_list_free (children);
7818 pick_embedded_child (GdkWindow *window,
7825 g_signal_emit (window,
7826 signals[PICK_EMBEDDED_CHILD], 0,
7833 _gdk_window_find_child_at (GdkWindow *window,
7838 double child_x, child_y;
7841 if (point_in_window (window, x, y))
7843 /* Children is ordered in reverse stack order, i.e. first is topmost */
7844 for (l = window->children; l != NULL; l = l->next)
7848 if (!GDK_WINDOW_IS_MAPPED (sub))
7851 gdk_window_coords_from_parent ((GdkWindow *)sub,
7853 &child_x, &child_y);
7854 if (point_in_window (sub, child_x, child_y))
7855 return (GdkWindow *)sub;
7858 if (window->num_offscreen_children > 0)
7860 sub = pick_embedded_child (window,
7863 return (GdkWindow *)sub;
7871 _gdk_window_find_descendant_at (GdkWindow *window,
7878 gdouble child_x, child_y;
7882 if (point_in_window (window, x, y))
7887 /* Children is ordered in reverse stack order, i.e. first is topmost */
7888 for (l = window->children; l != NULL; l = l->next)
7892 if (!GDK_WINDOW_IS_MAPPED (sub))
7895 gdk_window_coords_from_parent ((GdkWindow *)sub,
7897 &child_x, &child_y);
7898 if (point_in_window (sub, child_x, child_y))
7908 window->num_offscreen_children > 0)
7910 sub = pick_embedded_child (window,
7916 from_embedder (sub, x, y, &x, &y);
7924 /* Not in window at all */
7938 * @window: a toplevel #GdkWindow
7940 * Emits a short beep associated to @window in the appropriate
7941 * display, if supported. Otherwise, emits a short beep on
7942 * the display just as gdk_display_beep().
7947 gdk_window_beep (GdkWindow *window)
7949 GdkDisplay *display;
7950 GdkWindow *toplevel;
7952 g_return_if_fail (GDK_IS_WINDOW (window));
7954 if (GDK_WINDOW_DESTROYED (window))
7957 toplevel = get_event_toplevel (window);
7958 display = gdk_window_get_display (window);
7962 if (GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)->beep (toplevel))
7966 /* If windows fail to beep, we beep the display. */
7967 gdk_display_beep (display);
7971 * gdk_window_set_support_multidevice:
7972 * @window: a #GdkWindow.
7973 * @support_multidevice: %TRUE to enable multidevice support in @window.
7975 * This function will enable multidevice features in @window.
7977 * Multidevice aware windows will need to handle properly multiple,
7978 * per device enter/leave events, device grabs and grab ownerships.
7983 gdk_window_set_support_multidevice (GdkWindow *window,
7984 gboolean support_multidevice)
7986 g_return_if_fail (GDK_IS_WINDOW (window));
7988 if (GDK_WINDOW_DESTROYED (window))
7991 if (window->support_multidevice == support_multidevice)
7994 window->support_multidevice = support_multidevice;
7996 /* FIXME: What to do if called when some pointers are inside the window ? */
8000 * gdk_window_get_support_multidevice:
8001 * @window: a #GdkWindow.
8003 * Returns %TRUE if the window is aware of the existence of multiple
8006 * Returns: %TRUE if the window handles multidevice features.
8011 gdk_window_get_support_multidevice (GdkWindow *window)
8013 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
8015 if (GDK_WINDOW_DESTROYED (window))
8018 return window->support_multidevice;
8021 static const guint type_masks[] = {
8022 GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE = 0 */
8023 GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1 */
8024 GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2 */
8025 GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3 */
8026 GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4 */
8027 GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5 */
8028 GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6 */
8029 GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE = 7 */
8030 GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS = 8 */
8031 GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE = 9 */
8032 GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY = 10 */
8033 GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY = 11 */
8034 GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE = 12 */
8035 GDK_STRUCTURE_MASK, /* GDK_CONFIGURE = 13 */
8036 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_MAP = 14 */
8037 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_UNMAP = 15 */
8038 GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY = 16 */
8039 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR = 17 */
8040 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18 */
8041 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY = 19 */
8042 GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN = 20 */
8043 GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT = 21 */
8044 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER = 22 */
8045 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE = 23 */
8046 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION = 24 */
8047 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS = 25 */
8048 GDK_ALL_EVENTS_MASK, /* GDK_DROP_START = 26 */
8049 GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED = 27 */
8050 GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT = 28 */
8051 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_VISIBILITY_NOTIFY = 29 */
8052 GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30 */
8053 GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK,/* GDK_SCROLL= 31 */
8054 0, /* GDK_WINDOW_STATE = 32 */
8055 0, /* GDK_SETTING = 33 */
8056 0, /* GDK_OWNER_CHANGE = 34 */
8057 0, /* GDK_GRAB_BROKEN = 35 */
8058 0, /* GDK_DAMAGE = 36 */
8060 G_STATIC_ASSERT (G_N_ELEMENTS (type_masks) == GDK_EVENT_LAST);
8062 /* send motion events if the right buttons are down */
8064 update_evmask_for_button_motion (guint evmask,
8065 GdkModifierType mask)
8067 if (evmask & GDK_BUTTON_MOTION_MASK &&
8068 mask & (GDK_BUTTON1_MASK |
8073 evmask |= GDK_POINTER_MOTION_MASK;
8075 if ((evmask & GDK_BUTTON1_MOTION_MASK && mask & GDK_BUTTON1_MASK) ||
8076 (evmask & GDK_BUTTON2_MOTION_MASK && mask & GDK_BUTTON2_MASK) ||
8077 (evmask & GDK_BUTTON3_MOTION_MASK && mask & GDK_BUTTON3_MASK))
8078 evmask |= GDK_POINTER_MOTION_MASK;
8084 is_button_type (GdkEventType type)
8086 return type == GDK_BUTTON_PRESS ||
8087 type == GDK_2BUTTON_PRESS ||
8088 type == GDK_3BUTTON_PRESS ||
8089 type == GDK_BUTTON_RELEASE ||
8094 is_motion_type (GdkEventType type)
8096 return type == GDK_MOTION_NOTIFY ||
8097 type == GDK_ENTER_NOTIFY ||
8098 type == GDK_LEAVE_NOTIFY;
8102 find_common_ancestor (GdkWindow *win1,
8106 GList *path1 = NULL, *path2 = NULL;
8107 GList *list1, *list2;
8110 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8112 path1 = g_list_prepend (path1, tmp);
8113 tmp = get_event_parent (tmp);
8117 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8119 path2 = g_list_prepend (path2, tmp);
8120 tmp = get_event_parent (tmp);
8126 while (list1 && list2 && (list1->data == list2->data))
8129 list1 = g_list_next (list1);
8130 list2 = g_list_next (list2);
8132 g_list_free (path1);
8133 g_list_free (path2);
8139 _gdk_make_event (GdkWindow *window,
8141 GdkEvent *event_in_queue,
8142 gboolean before_event)
8144 GdkEvent *event = gdk_event_new (type);
8146 GdkModifierType the_state;
8148 the_time = gdk_event_get_time (event_in_queue);
8149 gdk_event_get_state (event_in_queue, &the_state);
8151 event->any.window = g_object_ref (window);
8152 event->any.send_event = FALSE;
8153 if (event_in_queue && event_in_queue->any.send_event)
8154 event->any.send_event = TRUE;
8158 case GDK_MOTION_NOTIFY:
8159 event->motion.time = the_time;
8160 event->motion.axes = NULL;
8161 event->motion.state = the_state;
8164 case GDK_BUTTON_PRESS:
8165 case GDK_2BUTTON_PRESS:
8166 case GDK_3BUTTON_PRESS:
8167 case GDK_BUTTON_RELEASE:
8168 event->button.time = the_time;
8169 event->button.axes = NULL;
8170 event->button.state = the_state;
8174 event->scroll.time = the_time;
8175 event->scroll.state = the_state;
8179 case GDK_KEY_RELEASE:
8180 event->key.time = the_time;
8181 event->key.state = the_state;
8184 case GDK_ENTER_NOTIFY:
8185 case GDK_LEAVE_NOTIFY:
8186 event->crossing.time = the_time;
8187 event->crossing.state = the_state;
8190 case GDK_PROPERTY_NOTIFY:
8191 event->property.time = the_time;
8192 event->property.state = the_state;
8195 case GDK_SELECTION_CLEAR:
8196 case GDK_SELECTION_REQUEST:
8197 case GDK_SELECTION_NOTIFY:
8198 event->selection.time = the_time;
8201 case GDK_PROXIMITY_IN:
8202 case GDK_PROXIMITY_OUT:
8203 event->proximity.time = the_time;
8206 case GDK_DRAG_ENTER:
8207 case GDK_DRAG_LEAVE:
8208 case GDK_DRAG_MOTION:
8209 case GDK_DRAG_STATUS:
8210 case GDK_DROP_START:
8211 case GDK_DROP_FINISHED:
8212 event->dnd.time = the_time;
8215 case GDK_FOCUS_CHANGE:
8219 case GDK_CLIENT_EVENT:
8220 case GDK_VISIBILITY_NOTIFY:
8231 _gdk_event_queue_insert_before (gdk_window_get_display (window), event_in_queue, event);
8233 _gdk_event_queue_insert_after (gdk_window_get_display (window), event_in_queue, event);
8236 _gdk_event_queue_append (gdk_window_get_display (window), event);
8242 send_crossing_event (GdkDisplay *display,
8243 GdkWindow *toplevel,
8246 GdkCrossingMode mode,
8247 GdkNotifyType notify_type,
8248 GdkWindow *subwindow,
8250 GdkDevice *source_device,
8253 GdkModifierType mask,
8255 GdkEvent *event_in_queue,
8259 guint32 window_event_mask, type_event_mask;
8260 GdkDeviceGrabInfo *grab;
8261 gboolean block_event = FALSE;
8263 grab = _gdk_display_has_device_grab (display, device, serial);
8266 !grab->owner_events)
8268 /* !owner_event => only report events wrt grab window, ignore rest */
8269 if ((GdkWindow *)window != grab->window)
8271 window_event_mask = grab->event_mask;
8274 window_event_mask = window->event_mask;
8276 if (type == GDK_LEAVE_NOTIFY)
8278 type_event_mask = GDK_LEAVE_NOTIFY_MASK;
8279 window->devices_inside = g_list_remove (window->devices_inside, device);
8281 if (!window->support_multidevice && window->devices_inside)
8283 /* Block leave events unless it's the last pointer */
8289 type_event_mask = GDK_ENTER_NOTIFY_MASK;
8291 if (!window->support_multidevice && window->devices_inside)
8293 /* Only emit enter events for the first device */
8297 if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER &&
8298 gdk_device_get_mode (device) != GDK_MODE_DISABLED &&
8299 !g_list_find (window->devices_inside, device))
8300 window->devices_inside = g_list_prepend (window->devices_inside, device);
8306 if (window_event_mask & type_event_mask)
8308 event = _gdk_make_event ((GdkWindow *)window, type, event_in_queue, TRUE);
8309 gdk_event_set_device (event, device);
8312 gdk_event_set_source_device (event, source_device);
8314 event->crossing.time = time_;
8315 event->crossing.subwindow = subwindow;
8317 g_object_ref (subwindow);
8318 convert_toplevel_coords_to_window ((GdkWindow *)window,
8319 toplevel_x, toplevel_y,
8320 &event->crossing.x, &event->crossing.y);
8321 event->crossing.x_root = toplevel_x + toplevel->x;
8322 event->crossing.y_root = toplevel_y + toplevel->y;
8323 event->crossing.mode = mode;
8324 event->crossing.detail = notify_type;
8325 event->crossing.focus = FALSE;
8326 event->crossing.state = mask;
8331 /* The coordinates are in the toplevel window that src/dest are in.
8332 * src and dest are always (if != NULL) in the same toplevel, as
8333 * we get a leave-notify and set the window_under_pointer to null
8334 * before crossing to another toplevel.
8337 _gdk_synthesize_crossing_events (GdkDisplay *display,
8341 GdkDevice *source_device,
8342 GdkCrossingMode mode,
8345 GdkModifierType mask,
8347 GdkEvent *event_in_queue,
8349 gboolean non_linear)
8352 GdkWindow *win, *last, *next;
8356 GdkWindow *toplevel;
8357 GdkNotifyType notify_type;
8359 /* TODO: Don't send events to toplevel, as we get those from the windowing system */
8364 return; /* No crossings generated between src and dest */
8366 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER)
8368 if (a && gdk_window_get_device_events (src, device) == 0)
8371 if (b && gdk_window_get_device_events (dest, device) == 0)
8378 c = find_common_ancestor (a, b);
8380 non_linear |= (c != a) && (c != b);
8382 if (a) /* There might not be a source (i.e. if no previous pointer_in_window) */
8384 toplevel = gdk_window_get_toplevel (a);
8386 /* Traverse up from a to (excluding) c sending leave events */
8388 notify_type = GDK_NOTIFY_NONLINEAR;
8390 notify_type = GDK_NOTIFY_INFERIOR;
8392 notify_type = GDK_NOTIFY_ANCESTOR;
8393 send_crossing_event (display, toplevel,
8394 a, GDK_LEAVE_NOTIFY,
8397 NULL, device, source_device,
8398 toplevel_x, toplevel_y,
8406 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8408 notify_type = GDK_NOTIFY_VIRTUAL;
8411 win = get_event_parent (a);
8412 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8414 send_crossing_event (display, toplevel,
8415 win, GDK_LEAVE_NOTIFY,
8419 device, source_device,
8420 toplevel_x, toplevel_y,
8426 win = get_event_parent (win);
8431 if (b) /* Might not be a dest, e.g. if we're moving out of the window */
8433 toplevel = gdk_window_get_toplevel ((GdkWindow *)b);
8435 /* Traverse down from c to b */
8439 win = get_event_parent (b);
8440 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8442 path = g_list_prepend (path, win);
8443 win = get_event_parent (win);
8447 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8449 notify_type = GDK_NOTIFY_VIRTUAL;
8455 list = g_list_next (list);
8461 send_crossing_event (display, toplevel,
8462 win, GDK_ENTER_NOTIFY,
8466 device, source_device,
8467 toplevel_x, toplevel_y,
8477 notify_type = GDK_NOTIFY_NONLINEAR;
8479 notify_type = GDK_NOTIFY_ANCESTOR;
8481 notify_type = GDK_NOTIFY_INFERIOR;
8483 send_crossing_event (display, toplevel,
8484 b, GDK_ENTER_NOTIFY,
8488 device, source_device,
8489 toplevel_x, toplevel_y,
8496 /* Returns the window inside the event window with the pointer in it
8497 * at the specified coordinates, or NULL if its not in any child of
8498 * the toplevel. It also takes into account !owner_events grabs.
8501 get_pointer_window (GdkDisplay *display,
8502 GdkWindow *event_window,
8508 GdkWindow *pointer_window;
8509 GdkDeviceGrabInfo *grab;
8510 GdkPointerWindowInfo *pointer_info;
8512 pointer_info = _gdk_display_get_pointer_info (display, device);
8514 if (event_window == pointer_info->toplevel_under_pointer)
8516 _gdk_window_find_descendant_at (event_window,
8517 toplevel_x, toplevel_y,
8520 pointer_window = NULL;
8522 grab = _gdk_display_has_device_grab (display, device, serial);
8524 !grab->owner_events &&
8525 pointer_window != grab->window)
8526 pointer_window = NULL;
8528 return pointer_window;
8532 _gdk_display_set_window_under_pointer (GdkDisplay *display,
8536 GdkPointerWindowInfo *device_info;
8538 device_info = _gdk_display_get_pointer_info (display, device);
8540 if (device_info->window_under_pointer)
8541 g_object_unref (device_info->window_under_pointer);
8542 device_info->window_under_pointer = window;
8546 g_object_ref (window);
8547 update_cursor (display, device);
8550 _gdk_display_enable_motion_hints (display, device);
8555 * @window: the #GdkWindow which will own the grab (the grab window).
8556 * @owner_events: if %FALSE then all pointer events are reported with respect to
8557 * @window and are only reported if selected by @event_mask. If %TRUE then pointer
8558 * events for this application are reported as normal, but pointer events outside
8559 * this application are reported with respect to @window and only if selected by
8560 * @event_mask. In either mode, unreported events are discarded.
8561 * @event_mask: specifies the event mask, which is used in accordance with
8562 * @owner_events. Note that only pointer events (i.e. button and motion events)
8564 * @confine_to: (allow-none): If non-%NULL, the pointer will be confined to this
8565 * window during the grab. If the pointer is outside @confine_to, it will
8566 * automatically be moved to the closest edge of @confine_to and enter
8567 * and leave events will be generated as necessary.
8568 * @cursor: (allow-none): the cursor to display while the grab is active. If this is %NULL then
8569 * the normal cursors are used for @window and its descendants, and the cursor
8570 * for @window is used for all other windows.
8571 * @time_: the timestamp of the event which led to this pointer grab. This usually
8572 * comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if
8573 * the time isn't known.
8575 * Grabs the pointer (usually a mouse) so that all events are passed to this
8576 * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
8577 * the grab window becomes unviewable.
8578 * This overrides any previous pointer grab by this client.
8580 * Pointer grabs are used for operations which need complete control over mouse
8581 * events, even if the mouse leaves the application.
8582 * For example in GTK+ it is used for Drag and Drop, for dragging the handle in
8583 * the #GtkHPaned and #GtkVPaned widgets.
8585 * Note that if the event mask of an X window has selected both button press and
8586 * button release events, then a button press event will cause an automatic
8587 * pointer grab until the button is released.
8588 * X does this automatically since most applications expect to receive button
8589 * press and release events in pairs.
8590 * It is equivalent to a pointer grab on the window with @owner_events set to
8593 * If you set up anything at the time you take the grab that needs to be cleaned
8594 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8595 * are emitted when the grab ends unvoluntarily.
8597 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8599 * Deprecated: 3.0: Use gdk_device_grab() instead.
8602 gdk_pointer_grab (GdkWindow * window,
8603 gboolean owner_events,
8604 GdkEventMask event_mask,
8605 GdkWindow * confine_to,
8610 GdkDisplay *display;
8611 GdkDeviceManager *device_manager;
8613 GdkGrabStatus res = 0;
8615 GList *devices, *dev;
8617 g_return_val_if_fail (window != NULL, 0);
8618 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8619 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
8621 /* We need a native window for confine to to work, ensure we have one */
8624 if (!gdk_window_ensure_native (confine_to))
8626 g_warning ("Can't confine to grabbed window, not native");
8631 /* Non-viewable client side window => fail */
8632 if (!_gdk_window_has_impl (window) &&
8633 !gdk_window_is_viewable (window))
8634 return GDK_GRAB_NOT_VIEWABLE;
8636 native = gdk_window_get_toplevel (window);
8637 while (gdk_window_is_offscreen (native))
8639 native = gdk_offscreen_window_get_embedder (native);
8641 if (native == NULL ||
8642 (!_gdk_window_has_impl (native) &&
8643 !gdk_window_is_viewable (native)))
8644 return GDK_GRAB_NOT_VIEWABLE;
8646 native = gdk_window_get_toplevel (native);
8649 display = gdk_window_get_display (window);
8651 serial = _gdk_display_get_next_serial (display);
8652 device_manager = gdk_display_get_device_manager (display);
8653 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8655 /* FIXME: Should this be generic to all backends? */
8656 /* FIXME: What happens with extended devices? */
8657 for (dev = devices; dev; dev = dev->next)
8661 if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
8664 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8667 get_native_grab_event_mask (event_mask),
8672 if (res == GDK_GRAB_SUCCESS)
8673 _gdk_display_add_device_grab (display,
8685 /* FIXME: handle errors when grabbing */
8687 g_list_free (devices);
8693 * gdk_keyboard_grab:
8694 * @window: the #GdkWindow which will own the grab (the grab window).
8695 * @owner_events: if %FALSE then all keyboard events are reported with respect to
8696 * @window. If %TRUE then keyboard events for this application are
8697 * reported as normal, but keyboard events outside this application
8698 * are reported with respect to @window. Both key press and key
8699 * release events are always reported, independant of the event mask
8700 * set by the application.
8701 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is
8704 * Grabs the keyboard so that all events are passed to this
8705 * application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
8706 * This overrides any previous keyboard grab by this client.
8708 * If you set up anything at the time you take the grab that needs to be cleaned
8709 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8710 * are emitted when the grab ends unvoluntarily.
8712 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8714 * Deprecated: 3.0: Use gdk_device_grab() instead.
8717 gdk_keyboard_grab (GdkWindow *window,
8718 gboolean owner_events,
8722 GdkDisplay *display;
8723 GdkDeviceManager *device_manager;
8725 GdkGrabStatus res = 0;
8727 GList *devices, *dev;
8729 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8731 /* Non-viewable client side window => fail */
8732 if (!_gdk_window_has_impl (window) &&
8733 !gdk_window_is_viewable (window))
8734 return GDK_GRAB_NOT_VIEWABLE;
8736 native = gdk_window_get_toplevel (window);
8738 while (gdk_window_is_offscreen (native))
8740 native = gdk_offscreen_window_get_embedder (native);
8742 if (native == NULL ||
8743 (!_gdk_window_has_impl (native) &&
8744 !gdk_window_is_viewable (native)))
8745 return GDK_GRAB_NOT_VIEWABLE;
8747 native = gdk_window_get_toplevel (native);
8750 display = gdk_window_get_display (window);
8751 serial = _gdk_display_get_next_serial (display);
8752 device_manager = gdk_display_get_device_manager (display);
8753 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8755 /* FIXME: Should this be generic to all backends? */
8756 /* FIXME: What happens with extended devices? */
8757 for (dev = devices; dev; dev = dev->next)
8761 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
8764 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8767 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
8772 if (res == GDK_GRAB_SUCCESS)
8773 _gdk_display_add_device_grab (display,
8784 /* FIXME: handle errors when grabbing */
8786 g_list_free (devices);
8792 * gdk_window_geometry_changed:
8793 * @window: an embedded offscreen #GdkWindow
8795 * This function informs GDK that the geometry of an embedded
8796 * offscreen window has changed. This is necessary for GDK to keep
8797 * track of which offscreen window the pointer is in.
8802 gdk_window_geometry_changed (GdkWindow *window)
8804 _gdk_synthesize_crossing_events_for_geometry_change (window);
8808 source_events_device_added (GdkDeviceManager *device_manager,
8813 GdkEventMask event_mask;
8814 GdkInputSource source;
8816 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_FLOATING)
8820 source = gdk_device_get_source (device);
8822 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8823 GINT_TO_POINTER (source)));
8825 gdk_window_set_device_events (window, device, event_mask);
8829 source_events_device_changed (GdkDeviceManager *device_manager,
8834 GdkInputSource source;
8835 GdkEventMask event_mask;
8839 type = gdk_device_get_device_type (device);
8840 source = gdk_device_get_source (device);
8842 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8843 GINT_TO_POINTER (source)));
8848 if (type == GDK_DEVICE_TYPE_FLOATING)
8850 /* The device was just floated, enable its event mask */
8851 gdk_window_set_device_events (window, device, event_mask);
8853 else if (type == GDK_DEVICE_TYPE_SLAVE)
8854 gdk_window_set_device_events (window, device, 0);
8858 * gdk_window_set_source_events:
8859 * @window: a #GdkWindow
8860 * @source: a #GdkInputSource to define the source class.
8861 * @event_mask: event mask for @window
8863 * Sets the event mask for any floating device (i.e. not attached to any
8864 * visible pointer) that has the source defined as @source. This event
8865 * mask will be applied both to currently existing, newly added devices
8866 * after this call, and devices being attached/detached.
8871 gdk_window_set_source_events (GdkWindow *window,
8872 GdkInputSource source,
8873 GdkEventMask event_mask)
8875 GdkDeviceManager *device_manager;
8876 GdkDisplay *display;
8880 g_return_if_fail (GDK_IS_WINDOW (window));
8882 display = gdk_window_get_display (window);
8883 device_manager = gdk_display_get_device_manager (display);
8885 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
8887 /* Set event mask for existing devices */
8888 for (d = devices; d; d = d->next)
8890 GdkDevice *device = d->data;
8892 if (source == gdk_device_get_source (device))
8893 gdk_window_set_device_events (window, device, event_mask);
8896 g_list_free (devices);
8898 /* Update accounting */
8899 if (G_UNLIKELY (!window->source_event_masks))
8900 window->source_event_masks = g_hash_table_new (NULL, NULL);
8903 g_hash_table_insert (window->source_event_masks,
8904 GUINT_TO_POINTER (source),
8905 GUINT_TO_POINTER (event_mask));
8907 g_hash_table_remove (window->source_event_masks,
8908 GUINT_TO_POINTER (source));
8910 size = g_hash_table_size (window->source_event_masks);
8912 /* Update handler if needed */
8913 if (!window->device_added_handler_id && size > 0)
8915 window->device_added_handler_id =
8916 g_signal_connect (device_manager, "device-added",
8917 G_CALLBACK (source_events_device_added), window);
8918 window->device_changed_handler_id =
8919 g_signal_connect (device_manager, "device-changed",
8920 G_CALLBACK (source_events_device_changed), window);
8922 else if (window->device_added_handler_id && size == 0)
8923 g_signal_handler_disconnect (device_manager, window->device_added_handler_id);
8927 * gdk_window_get_source_events:
8928 * @window: a #GdkWindow
8929 * @source: a #GdkInputSource to define the source class.
8931 * Returns the event mask for @window corresponding to the device class specified
8934 * Returns: source event mask for @window
8937 gdk_window_get_source_events (GdkWindow *window,
8938 GdkInputSource source)
8940 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8942 return GPOINTER_TO_UINT (g_hash_table_lookup (window->source_event_masks,
8943 GUINT_TO_POINTER (source)));
8947 do_synthesize_crossing_event (gpointer data)
8949 GdkDisplay *display;
8950 GdkWindow *changed_toplevel;
8951 GHashTableIter iter;
8952 gpointer key, value;
8955 changed_toplevel = data;
8957 changed_toplevel->synthesize_crossing_event_queued = FALSE;
8959 if (GDK_WINDOW_DESTROYED (changed_toplevel))
8962 display = gdk_window_get_display (changed_toplevel);
8963 serial = _gdk_display_get_next_serial (display);
8964 g_hash_table_iter_init (&iter, display->pointers_info);
8966 while (g_hash_table_iter_next (&iter, &key, &value))
8968 GdkWindow *new_window_under_pointer;
8969 GdkPointerWindowInfo *pointer_info = value;
8970 GdkDevice *device = key;
8972 if (changed_toplevel == pointer_info->toplevel_under_pointer)
8974 new_window_under_pointer =
8975 get_pointer_window (display, changed_toplevel,
8977 pointer_info->toplevel_x,
8978 pointer_info->toplevel_y,
8980 if (new_window_under_pointer != pointer_info->window_under_pointer)
8982 _gdk_synthesize_crossing_events (display,
8983 pointer_info->window_under_pointer,
8984 new_window_under_pointer,
8986 GDK_CROSSING_NORMAL,
8987 pointer_info->toplevel_x,
8988 pointer_info->toplevel_y,
8989 pointer_info->state,
8994 _gdk_display_set_window_under_pointer (display, device, new_window_under_pointer);
9003 _gdk_synthesize_crossing_events_for_geometry_change (GdkWindow *changed_window)
9005 GdkWindow *toplevel;
9007 toplevel = get_event_toplevel (changed_window);
9009 if (!toplevel->synthesize_crossing_event_queued)
9011 toplevel->synthesize_crossing_event_queued = TRUE;
9013 gdk_threads_add_idle_full (GDK_PRIORITY_EVENTS - 1,
9014 do_synthesize_crossing_event,
9015 g_object_ref (toplevel),
9020 /* Don't use for crossing events */
9022 get_event_window (GdkDisplay *display,
9024 GdkWindow *pointer_window,
9026 GdkModifierType mask,
9031 GdkWindow *grab_window;
9032 GdkDeviceGrabInfo *grab;
9034 grab = _gdk_display_has_device_grab (display, device, serial);
9036 if (grab != NULL && !grab->owner_events)
9038 evmask = grab->event_mask;
9039 evmask = update_evmask_for_button_motion (evmask, mask);
9041 grab_window = grab->window;
9043 if (evmask & type_masks[type])
9046 *evmask_out = evmask;
9053 while (pointer_window != NULL)
9055 evmask = pointer_window->event_mask;
9056 evmask = update_evmask_for_button_motion (evmask, mask);
9058 if (evmask & type_masks[type])
9061 *evmask_out = evmask;
9062 return pointer_window;
9065 pointer_window = get_event_parent (pointer_window);
9071 evmask = grab->event_mask;
9072 evmask = update_evmask_for_button_motion (evmask, mask);
9074 if (evmask & type_masks[type])
9077 *evmask_out = evmask;
9078 return grab->window;
9088 proxy_pointer_event (GdkDisplay *display,
9089 GdkEvent *source_event,
9092 GdkWindow *toplevel_window, *event_window;
9093 GdkWindow *pointer_window;
9094 GdkPointerWindowInfo *pointer_info;
9095 GdkDevice *device, *source_device;
9098 gdouble toplevel_x, toplevel_y;
9100 gboolean non_linear;
9102 event_window = source_event->any.window;
9103 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9104 gdk_event_get_state (source_event, &state);
9105 time_ = gdk_event_get_time (source_event);
9106 device = gdk_event_get_device (source_event);
9107 source_device = gdk_event_get_source_device (source_event);
9108 pointer_info = _gdk_display_get_pointer_info (display, device);
9109 toplevel_window = convert_native_coords_to_toplevel (event_window,
9110 toplevel_x, toplevel_y,
9111 &toplevel_x, &toplevel_y);
9114 if ((source_event->type == GDK_LEAVE_NOTIFY ||
9115 source_event->type == GDK_ENTER_NOTIFY) &&
9116 (source_event->crossing.detail == GDK_NOTIFY_NONLINEAR ||
9117 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))
9120 /* If we get crossing events with subwindow unexpectedly being NULL
9121 that means there is a native subwindow that gdk doesn't know about.
9122 We track these and forward them, with the correct virtual window
9124 This is important to get right, as metacity uses gdk for the frame
9125 windows, but gdk doesn't know about the client windows reparented
9127 if (((source_event->type == GDK_LEAVE_NOTIFY &&
9128 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9129 (source_event->type == GDK_ENTER_NOTIFY &&
9130 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9131 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9132 source_event->crossing.subwindow == NULL)
9134 /* Left for an unknown (to gdk) subwindow */
9136 /* Send leave events from window under pointer to event window
9137 that will get the subwindow == NULL window */
9138 _gdk_synthesize_crossing_events (display,
9139 pointer_info->window_under_pointer,
9141 device, source_device,
9142 source_event->crossing.mode,
9143 toplevel_x, toplevel_y,
9149 /* Send subwindow == NULL event */
9150 send_crossing_event (display,
9154 source_event->crossing.mode,
9155 source_event->crossing.detail,
9157 device, source_device,
9158 toplevel_x, toplevel_y,
9163 _gdk_display_set_window_under_pointer (display, device, NULL);
9167 pointer_window = get_pointer_window (display, toplevel_window, device,
9168 toplevel_x, toplevel_y, serial);
9170 if (((source_event->type == GDK_ENTER_NOTIFY &&
9171 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9172 (source_event->type == GDK_LEAVE_NOTIFY &&
9173 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9174 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9175 source_event->crossing.subwindow == NULL)
9177 /* Entered from an unknown (to gdk) subwindow */
9179 /* Send subwindow == NULL event */
9180 send_crossing_event (display,
9184 source_event->crossing.mode,
9185 source_event->crossing.detail,
9187 device, source_device,
9188 toplevel_x, toplevel_y,
9193 /* Send enter events from event window to pointer_window */
9194 _gdk_synthesize_crossing_events (display,
9197 device, source_device,
9198 source_event->crossing.mode,
9199 toplevel_x, toplevel_y,
9202 serial, non_linear);
9203 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9207 if (pointer_info->window_under_pointer != pointer_window)
9209 /* Either a toplevel crossing notify that ended up inside a child window,
9210 or a motion notify that got into another child window */
9212 /* Different than last time, send crossing events */
9213 _gdk_synthesize_crossing_events (display,
9214 pointer_info->window_under_pointer,
9216 device, source_device,
9217 GDK_CROSSING_NORMAL,
9218 toplevel_x, toplevel_y,
9221 serial, non_linear);
9222 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9224 else if (source_event->type == GDK_MOTION_NOTIFY)
9226 GdkWindow *event_win;
9230 event_win = get_event_window (display,
9239 gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9240 gdk_window_get_device_events (event_win, device) == 0)
9246 (evmask & GDK_POINTER_MOTION_HINT_MASK))
9248 gulong *device_serial;
9250 device_serial = g_hash_table_lookup (display->motion_hint_info, device);
9252 if (!device_serial ||
9253 (*device_serial != 0 &&
9254 serial < *device_serial))
9255 event_win = NULL; /* Ignore event */
9259 *device_serial = G_MAXULONG;
9263 if (event_win && !display->ignore_core_events)
9265 event = _gdk_make_event (event_win, GDK_MOTION_NOTIFY, source_event, FALSE);
9266 event->motion.time = time_;
9267 convert_toplevel_coords_to_window (event_win,
9268 toplevel_x, toplevel_y,
9269 &event->motion.x, &event->motion.y);
9270 event->motion.x_root = source_event->motion.x_root;
9271 event->motion.y_root = source_event->motion.y_root;
9272 event->motion.state = state;
9273 event->motion.is_hint = is_hint;
9274 event->motion.device = source_event->motion.device;
9275 event->motion.axes = g_memdup (source_event->motion.axes,
9276 sizeof (gdouble) * gdk_device_get_n_axes (source_event->motion.device));
9277 gdk_event_set_source_device (event, source_device);
9281 /* unlink all move events from queue.
9282 We handle our own, including our emulated masks. */
9286 #define GDK_ANY_BUTTON_MASK (GDK_BUTTON1_MASK | \
9287 GDK_BUTTON2_MASK | \
9288 GDK_BUTTON3_MASK | \
9289 GDK_BUTTON4_MASK | \
9293 proxy_button_event (GdkEvent *source_event,
9296 GdkWindow *toplevel_window, *event_window;
9297 GdkWindow *event_win;
9298 GdkWindow *pointer_window;
9304 gdouble toplevel_x, toplevel_y;
9305 GdkDisplay *display;
9307 GdkDevice *device, *source_device;
9309 type = source_event->any.type;
9310 event_window = source_event->any.window;
9311 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9312 gdk_event_get_state (source_event, &state);
9313 time_ = gdk_event_get_time (source_event);
9314 device = gdk_event_get_device (source_event);
9315 source_device = gdk_event_get_source_device (source_event);
9316 display = gdk_window_get_display (source_event->any.window);
9317 toplevel_window = convert_native_coords_to_toplevel (event_window,
9318 toplevel_x, toplevel_y,
9319 &toplevel_x, &toplevel_y);
9321 if (type == GDK_BUTTON_PRESS &&
9322 !source_event->any.send_event &&
9323 _gdk_display_has_device_grab (display, device, serial) == NULL)
9326 _gdk_window_find_descendant_at (toplevel_window,
9327 toplevel_x, toplevel_y,
9330 /* Find the event window, that gets the grab */
9333 (parent = get_event_parent (w)) != NULL &&
9334 parent->window_type != GDK_WINDOW_ROOT)
9336 if (w->event_mask & GDK_BUTTON_PRESS_MASK)
9340 pointer_window = (GdkWindow *)w;
9342 _gdk_display_add_device_grab (display,
9348 gdk_window_get_events (pointer_window),
9352 _gdk_display_device_grab_update (display, device, source_device, serial);
9355 pointer_window = get_pointer_window (display, toplevel_window, device,
9356 toplevel_x, toplevel_y,
9359 event_win = get_event_window (display,
9365 if (event_win == NULL || display->ignore_core_events)
9368 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9369 gdk_window_get_device_events (event_win, device) == 0)
9372 event = _gdk_make_event (event_win, type, source_event, FALSE);
9376 case GDK_BUTTON_PRESS:
9377 case GDK_BUTTON_RELEASE:
9378 event->button.button = source_event->button.button;
9379 convert_toplevel_coords_to_window (event_win,
9380 toplevel_x, toplevel_y,
9381 &event->button.x, &event->button.y);
9382 event->button.x_root = source_event->button.x_root;
9383 event->button.y_root = source_event->button.y_root;
9384 event->button.state = state;
9385 event->button.device = source_event->button.device;
9386 event->button.axes = g_memdup (source_event->button.axes,
9387 sizeof (gdouble) * gdk_device_get_n_axes (source_event->button.device));
9389 gdk_event_set_source_device (event, source_device);
9391 if (type == GDK_BUTTON_PRESS)
9392 _gdk_event_button_generate (display, event);
9396 event->scroll.direction = source_event->scroll.direction;
9397 convert_toplevel_coords_to_window (event_win,
9398 toplevel_x, toplevel_y,
9399 &event->scroll.x, &event->scroll.y);
9400 event->scroll.x_root = source_event->scroll.x_root;
9401 event->scroll.y_root = source_event->scroll.y_root;
9402 event->scroll.state = state;
9403 event->scroll.device = source_event->scroll.device;
9404 gdk_event_set_source_device (event, source_device);
9411 return TRUE; /* Always unlink original, we want to obey the emulated event mask */
9414 #ifdef DEBUG_WINDOW_PRINTING
9416 gdk_window_print (GdkWindow *window,
9420 const char *window_types[] = {
9430 g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", window,
9431 window->user_data ? g_type_name_from_instance (window->user_data) : "no widget",
9432 window->x, window->y,
9433 window->width, window->height
9436 if (gdk_window_has_impl (window))
9438 #ifdef GDK_WINDOWING_X11
9439 g_print (" impl(0x%lx)", gdk_x11_window_get_xid (window));
9443 if (window->window_type != GDK_WINDOW_CHILD)
9444 g_print (" %s", window_types[window->window_type]);
9446 if (window->input_only)
9447 g_print (" input-only");
9450 g_print (" shaped");
9452 if (!gdk_window_is_visible ((GdkWindow *)window))
9453 g_print (" hidden");
9455 g_print (" abs[%d,%d]",
9456 window->abs_x, window->abs_y);
9458 cairo_region_get_extents (window->clip_region, &r);
9459 if (cairo_region_is_empty (window->clip_region))
9460 g_print (" clipbox[empty]");
9462 g_print (" clipbox[%d,%d %dx%d]", r.x, r.y, r.width, r.height);
9469 gdk_window_print_tree (GdkWindow *window,
9471 gboolean include_input_only)
9475 if (window->input_only && !include_input_only)
9478 gdk_window_print (window, indent);
9480 for (l = window->children; l != NULL; l = l->next)
9481 gdk_window_print_tree (l->data, indent + 4, include_input_only);
9484 #endif /* DEBUG_WINDOW_PRINTING */
9487 _gdk_windowing_got_event (GdkDisplay *display,
9492 GdkWindow *event_window;
9494 gboolean unlink_event;
9495 guint old_state, old_button;
9496 GdkDeviceGrabInfo *button_release_grab;
9497 GdkPointerWindowInfo *pointer_info;
9498 GdkDevice *device, *source_device;
9499 gboolean is_toplevel;
9501 if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
9502 display->last_event_time = gdk_event_get_time (event);
9504 device = gdk_event_get_device (event);
9505 source_device = gdk_event_get_source_device (event);
9511 g_object_get (device, "input-mode", &mode, NULL);
9512 _gdk_display_device_grab_update (display, device, source_device, serial);
9514 if (mode == GDK_MODE_DISABLED ||
9515 !_gdk_display_check_grab_ownership (display, device, serial))
9517 /* Device events are blocked by another
9518 * device grab, or the device is disabled
9520 unlink_event = TRUE;
9525 event_window = event->any.window;
9529 pointer_info = _gdk_display_get_pointer_info (display, device);
9531 #ifdef DEBUG_WINDOW_PRINTING
9532 if (event->type == GDK_KEY_PRESS &&
9533 (event->key.keyval == 0xa7 ||
9534 event->key.keyval == 0xbd))
9536 gdk_window_print_tree (event_window, 0,
9537 event->key.keyval == 0xbd);
9541 if (event->type == GDK_VISIBILITY_NOTIFY)
9543 event_window->native_visibility = event->visibility.state;
9544 gdk_window_update_visibility_recursively (event_window,
9549 if (!(is_button_type (event->type) ||
9550 is_motion_type (event->type)) ||
9551 event_window->window_type == GDK_WINDOW_ROOT)
9554 is_toplevel = gdk_window_is_toplevel (event_window);
9556 if ((event->type == GDK_ENTER_NOTIFY ||
9557 event->type == GDK_LEAVE_NOTIFY) &&
9558 (event->crossing.mode == GDK_CROSSING_GRAB ||
9559 event->crossing.mode == GDK_CROSSING_UNGRAB) &&
9560 (_gdk_display_has_device_grab (display, device, serial) ||
9561 event->crossing.detail == GDK_NOTIFY_INFERIOR))
9563 /* We synthesize all crossing events due to grabs ourselves,
9564 * so we ignore the native ones caused by our native pointer_grab
9565 * calls. Otherwise we would proxy these crossing event and cause
9566 * multiple copies of crossing events for grabs.
9568 * We do want to handle grabs from other clients though, as for
9569 * instance alt-tab in metacity causes grabs like these and
9570 * we want to handle those. Thus the has_pointer_grab check.
9572 * Implicit grabs on child windows create some grabbing events
9573 * that are sent before the button press. This means we can't
9574 * detect these with the has_pointer_grab check (as the implicit
9575 * grab is only noticed when we get button press event), so we
9576 * detect these events by checking for INFERIOR enter or leave
9577 * events. These should never be a problem to filter out.
9580 /* We ended up in this window after some (perhaps other clients)
9581 grab, so update the toplevel_under_window state */
9583 event->type == GDK_ENTER_NOTIFY &&
9584 event->crossing.mode == GDK_CROSSING_UNGRAB)
9586 if (pointer_info->toplevel_under_pointer)
9587 g_object_unref (pointer_info->toplevel_under_pointer);
9588 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9591 unlink_event = TRUE;
9595 /* Track toplevel_under_pointer */
9598 if (event->type == GDK_ENTER_NOTIFY &&
9599 event->crossing.detail != GDK_NOTIFY_INFERIOR)
9601 if (pointer_info->toplevel_under_pointer)
9602 g_object_unref (pointer_info->toplevel_under_pointer);
9603 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9605 else if (event->type == GDK_LEAVE_NOTIFY &&
9606 event->crossing.detail != GDK_NOTIFY_INFERIOR &&
9607 pointer_info->toplevel_under_pointer == event_window)
9609 if (pointer_info->toplevel_under_pointer)
9610 g_object_unref (pointer_info->toplevel_under_pointer);
9611 pointer_info->toplevel_under_pointer = NULL;
9615 /* Store last pointer window and position/state */
9616 old_state = pointer_info->state;
9617 old_button = pointer_info->button;
9619 gdk_event_get_coords (event, &x, &y);
9620 convert_native_coords_to_toplevel (event_window, x, y, &x, &y);
9621 pointer_info->toplevel_x = x;
9622 pointer_info->toplevel_y = y;
9623 gdk_event_get_state (event, &pointer_info->state);
9624 if (event->type == GDK_BUTTON_PRESS ||
9625 event->type == GDK_BUTTON_RELEASE)
9626 pointer_info->button = event->button.button;
9629 (pointer_info->state != old_state ||
9630 pointer_info->button != old_button))
9631 _gdk_display_enable_motion_hints (display, device);
9633 unlink_event = FALSE;
9634 if (is_motion_type (event->type))
9635 unlink_event = proxy_pointer_event (display,
9638 else if (is_button_type (event->type))
9639 unlink_event = proxy_button_event (event,
9642 if (event->type == GDK_BUTTON_RELEASE &&
9643 !event->any.send_event)
9645 button_release_grab =
9646 _gdk_display_has_device_grab (display, device, serial);
9647 if (button_release_grab &&
9648 button_release_grab->implicit &&
9649 (event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
9651 button_release_grab->serial_end = serial;
9652 button_release_grab->implicit_ungrab = FALSE;
9653 _gdk_display_device_grab_update (display, device, source_device, serial);
9660 _gdk_event_queue_remove_link (display, event_link);
9661 g_list_free_1 (event_link);
9662 gdk_event_free (event);
9667 * gdk_window_create_similar_surface:
9668 * @window: window to make new surface similar to
9669 * @content: the content for the new surface
9670 * @width: width of the new surface
9671 * @height: height of the new surface
9673 * Create a new surface that is as compatible as possible with the
9674 * given @window. For example the new surface will have the same
9675 * fallback resolution and font options as @window. Generally, the new
9676 * surface will also use the same backend as @window, unless that is
9677 * not possible for some reason. The type of the returned surface may
9678 * be examined with cairo_surface_get_type().
9680 * Initially the surface contents are all 0 (transparent if contents
9681 * have transparency, black otherwise.)
9683 * Returns: a pointer to the newly allocated surface. The caller
9684 * owns the surface and should call cairo_surface_destroy() when done
9687 * This function always returns a valid pointer, but it will return a
9688 * pointer to a "nil" surface if @other is already in an error state
9689 * or any other error occurs.
9694 gdk_window_create_similar_surface (GdkWindow * window,
9695 cairo_content_t content,
9699 cairo_surface_t *window_surface, *surface;
9701 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
9703 window_surface = _gdk_window_ref_cairo_surface (window);
9705 switch (_gdk_rendering_mode)
9707 case GDK_RENDERING_MODE_RECORDING:
9709 cairo_rectangle_t rect = { 0, 0, width, height };
9710 surface = cairo_recording_surface_create (content, &rect);
9713 case GDK_RENDERING_MODE_IMAGE:
9714 surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
9715 content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
9718 case GDK_RENDERING_MODE_SIMILAR:
9720 surface = cairo_surface_create_similar (window_surface,
9726 cairo_surface_destroy (window_surface);
9733 * @window: a #GdkWindow
9734 * @timestamp: timestamp of the event triggering the window focus
9736 * Sets keyboard focus to @window. In most cases, gtk_window_present()
9737 * should be used on a #GtkWindow, rather than calling this function.
9741 gdk_window_focus (GdkWindow *window,
9744 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->focus (window, timestamp);
9748 * gdk_window_set_type_hint:
9749 * @window: A toplevel #GdkWindow
9750 * @hint: A hint of the function this window will have
9752 * The application can use this call to provide a hint to the window
9753 * manager about the functionality of a window. The window manager
9754 * can use this information when determining the decoration and behaviour
9757 * The hint must be set before the window is mapped.
9760 gdk_window_set_type_hint (GdkWindow *window,
9761 GdkWindowTypeHint hint)
9763 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_type_hint (window, hint);
9767 * gdk_window_get_type_hint:
9768 * @window: A toplevel #GdkWindow
9770 * This function returns the type hint set for a window.
9772 * Return value: The type hint set for @window
9777 gdk_window_get_type_hint (GdkWindow *window)
9779 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_type_hint (window);
9783 * gdk_window_set_modal_hint:
9784 * @window: A toplevel #GdkWindow
9785 * @modal: %TRUE if the window is modal, %FALSE otherwise.
9787 * The application can use this hint to tell the window manager
9788 * that a certain window has modal behaviour. The window manager
9789 * can use this information to handle modal windows in a special
9792 * You should only use this on windows for which you have
9793 * previously called gdk_window_set_transient_for()
9796 gdk_window_set_modal_hint (GdkWindow *window,
9799 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_modal_hint (window, modal);
9803 * gdk_window_set_skip_taskbar_hint:
9804 * @window: a toplevel #GdkWindow
9805 * @skips_taskbar: %TRUE to skip the taskbar
9807 * Toggles whether a window should appear in a task list or window
9808 * list. If a window's semantic type as specified with
9809 * gdk_window_set_type_hint() already fully describes the window, this
9810 * function should <emphasis>not</emphasis> be called in addition,
9811 * instead you should allow the window to be treated according to
9812 * standard policy for its semantic type.
9817 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
9818 gboolean skips_taskbar)
9820 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_taskbar_hint (window, skips_taskbar);
9824 * gdk_window_set_skip_pager_hint:
9825 * @window: a toplevel #GdkWindow
9826 * @skips_pager: %TRUE to skip the pager
9828 * Toggles whether a window should appear in a pager (workspace
9829 * switcher, or other desktop utility program that displays a small
9830 * thumbnail representation of the windows on the desktop). If a
9831 * window's semantic type as specified with gdk_window_set_type_hint()
9832 * already fully describes the window, this function should
9833 * <emphasis>not</emphasis> be called in addition, instead you should
9834 * allow the window to be treated according to standard policy for
9835 * its semantic type.
9840 gdk_window_set_skip_pager_hint (GdkWindow *window,
9841 gboolean skips_pager)
9843 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_pager_hint (window, skips_pager);
9847 * gdk_window_set_urgency_hint:
9848 * @window: a toplevel #GdkWindow
9849 * @urgent: %TRUE if the window is urgent
9851 * Toggles whether a window needs the user's
9857 gdk_window_set_urgency_hint (GdkWindow *window,
9860 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_urgency_hint (window, urgent);
9864 * gdk_window_set_geometry_hints:
9865 * @window: a toplevel #GdkWindow
9866 * @geometry: geometry hints
9867 * @geom_mask: bitmask indicating fields of @geometry to pay attention to
9869 * Sets the geometry hints for @window. Hints flagged in @geom_mask
9870 * are set, hints not flagged in @geom_mask are unset.
9871 * To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
9873 * This function provides hints to the windowing system about
9874 * acceptable sizes for a toplevel window. The purpose of
9875 * this is to constrain user resizing, but the windowing system
9876 * will typically (but is not required to) also constrain the
9877 * current size of the window to the provided values and
9878 * constrain programatic resizing via gdk_window_resize() or
9879 * gdk_window_move_resize().
9881 * Note that on X11, this effect has no effect on windows
9882 * of type %GDK_WINDOW_TEMP or windows where override redirect
9883 * has been turned on via gdk_window_set_override_redirect()
9884 * since these windows are not resizable by the user.
9886 * Since you can't count on the windowing system doing the
9887 * constraints for programmatic resizes, you should generally
9888 * call gdk_window_constrain_size() yourself to determine
9889 * appropriate sizes.
9893 gdk_window_set_geometry_hints (GdkWindow *window,
9894 const GdkGeometry *geometry,
9895 GdkWindowHints geom_mask)
9897 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_geometry_hints (window, geometry, geom_mask);
9901 * gdk_window_set_title:
9902 * @window: a toplevel #GdkWindow
9903 * @title: title of @window
9905 * Sets the title of a toplevel window, to be displayed in the titlebar.
9906 * If you haven't explicitly set the icon name for the window
9907 * (using gdk_window_set_icon_name()), the icon name will be set to
9908 * @title as well. @title must be in UTF-8 encoding (as with all
9909 * user-readable strings in GDK/GTK+). @title may not be %NULL.
9912 gdk_window_set_title (GdkWindow *window,
9915 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_title (window, title);
9919 * gdk_window_set_role:
9920 * @window: a toplevel #GdkWindow
9921 * @role: a string indicating its role
9923 * When using GTK+, typically you should use gtk_window_set_role() instead
9924 * of this low-level function.
9926 * The window manager and session manager use a window's role to
9927 * distinguish it from other kinds of window in the same application.
9928 * When an application is restarted after being saved in a previous
9929 * session, all windows with the same title and role are treated as
9930 * interchangeable. So if you have two windows with the same title
9931 * that should be distinguished for session management purposes, you
9932 * should set the role on those windows. It doesn't matter what string
9933 * you use for the role, as long as you have a different role for each
9934 * non-interchangeable kind of window.
9938 gdk_window_set_role (GdkWindow *window,
9941 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_role (window, role);
9945 * gdk_window_set_startup_id:
9946 * @window: a toplevel #GdkWindow
9947 * @startup_id: a string with startup-notification identifier
9949 * When using GTK+, typically you should use gtk_window_set_startup_id()
9950 * instead of this low-level function.
9956 gdk_window_set_startup_id (GdkWindow *window,
9957 const gchar *startup_id)
9959 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_startup_id (window, startup_id);
9963 * gdk_window_set_transient_for:
9964 * @window: a toplevel #GdkWindow
9965 * @parent: another toplevel #GdkWindow
9967 * Indicates to the window manager that @window is a transient dialog
9968 * associated with the application window @parent. This allows the
9969 * window manager to do things like center @window on @parent and
9970 * keep @window above @parent.
9972 * See gtk_window_set_transient_for() if you're using #GtkWindow or
9976 gdk_window_set_transient_for (GdkWindow *window,
9979 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_transient_for (window, parent);
9983 * gdk_window_get_root_origin:
9984 * @window: a toplevel #GdkWindow
9985 * @x: (out): return location for X position of window frame
9986 * @y: (out): return location for Y position of window frame
9988 * Obtains the top-left corner of the window manager frame in root
9989 * window coordinates.
9993 gdk_window_get_root_origin (GdkWindow *window,
9997 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_root_origin (window, x, y);
10001 * gdk_window_get_frame_extents:
10002 * @window: a toplevel #GdkWindow
10003 * @rect: rectangle to fill with bounding box of the window frame
10005 * Obtains the bounding box of the window, including window manager
10006 * titlebar/borders if any. The frame position is given in root window
10007 * coordinates. To get the position of the window itself (rather than
10008 * the frame) in root window coordinates, use gdk_window_get_origin().
10012 gdk_window_get_frame_extents (GdkWindow *window,
10013 GdkRectangle *rect)
10015 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_frame_extents (window, rect);
10019 * gdk_window_set_override_redirect:
10020 * @window: a toplevel #GdkWindow
10021 * @override_redirect: %TRUE if window should be override redirect
10023 * An override redirect window is not under the control of the window manager.
10024 * This means it won't have a titlebar, won't be minimizable, etc. - it will
10025 * be entirely under the control of the application. The window manager
10026 * can't see the override redirect window at all.
10028 * Override redirect should only be used for short-lived temporary
10029 * windows, such as popup menus. #GtkMenu uses an override redirect
10030 * window in its implementation, for example.
10034 gdk_window_set_override_redirect (GdkWindow *window,
10035 gboolean override_redirect)
10037 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_override_redirect (window, override_redirect);
10041 * gdk_window_set_accept_focus:
10042 * @window: a toplevel #GdkWindow
10043 * @accept_focus: %TRUE if the window should receive input focus
10045 * Setting @accept_focus to %FALSE hints the desktop environment that the
10046 * window doesn't want to receive input focus.
10048 * On X, it is the responsibility of the window manager to interpret this
10049 * hint. ICCCM-compliant window manager usually respect it.
10054 gdk_window_set_accept_focus (GdkWindow *window,
10055 gboolean accept_focus)
10057 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_accept_focus (window, accept_focus);
10061 * gdk_window_set_focus_on_map:
10062 * @window: a toplevel #GdkWindow
10063 * @focus_on_map: %TRUE if the window should receive input focus when mapped
10065 * Setting @focus_on_map to %FALSE hints the desktop environment that the
10066 * window doesn't want to receive input focus when it is mapped.
10067 * focus_on_map should be turned off for windows that aren't triggered
10068 * interactively (such as popups from network activity).
10070 * On X, it is the responsibility of the window manager to interpret
10071 * this hint. Window managers following the freedesktop.org window
10072 * manager extension specification should respect it.
10077 gdk_window_set_focus_on_map (GdkWindow *window,
10078 gboolean focus_on_map)
10080 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_focus_on_map (window, focus_on_map);
10084 * gdk_window_set_icon_list:
10085 * @window: The #GdkWindow toplevel window to set the icon of.
10086 * @pixbufs: (transfer none) (element-type GdkPixbuf):
10087 * A list of pixbufs, of different sizes.
10089 * Sets a list of icons for the window. One of these will be used
10090 * to represent the window when it has been iconified. The icon is
10091 * usually shown in an icon box or some sort of task bar. Which icon
10092 * size is shown depends on the window manager. The window manager
10093 * can scale the icon but setting several size icons can give better
10094 * image quality since the window manager may only need to scale the
10095 * icon by a small amount or not at all.
10099 gdk_window_set_icon_list (GdkWindow *window,
10102 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_list (window, pixbufs);
10106 * gdk_window_set_icon_name:
10107 * @window: a toplevel #GdkWindow
10108 * @name: (allow-none): name of window while iconified (minimized)
10110 * Windows may have a name used while minimized, distinct from the
10111 * name they display in their titlebar. Most of the time this is a bad
10112 * idea from a user interface standpoint. But you can set such a name
10113 * with this function, if you like.
10115 * After calling this with a non-%NULL @name, calls to gdk_window_set_title()
10116 * will not update the icon title.
10118 * Using %NULL for @name unsets the icon title; further calls to
10119 * gdk_window_set_title() will again update the icon title as well.
10122 gdk_window_set_icon_name (GdkWindow *window,
10125 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_name (window, name);
10129 * gdk_window_iconify:
10130 * @window: a toplevel #GdkWindow
10132 * Asks to iconify (minimize) @window. The window manager may choose
10133 * to ignore the request, but normally will honor it. Using
10134 * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
10136 * This function only makes sense when @window is a toplevel window.
10140 gdk_window_iconify (GdkWindow *window)
10142 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->iconify (window);
10146 * gdk_window_deiconify:
10147 * @window: a toplevel #GdkWindow
10149 * Attempt to deiconify (unminimize) @window. On X11 the window manager may
10150 * choose to ignore the request to deiconify. When using GTK+,
10151 * use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
10152 * you probably want to use gtk_window_present(), which raises the window, focuses it,
10153 * unminimizes it, and puts it on the current desktop.
10157 gdk_window_deiconify (GdkWindow *window)
10159 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->deiconify (window);
10163 * gdk_window_stick:
10164 * @window: a toplevel #GdkWindow
10166 * "Pins" a window such that it's on all workspaces and does not scroll
10167 * with viewports, for window managers that have scrollable viewports.
10168 * (When using #GtkWindow, gtk_window_stick() may be more useful.)
10170 * On the X11 platform, this function depends on window manager
10171 * support, so may have no effect with many window managers. However,
10172 * GDK will do the best it can to convince the window manager to stick
10173 * the window. For window managers that don't support this operation,
10174 * there's nothing you can do to force it to happen.
10178 gdk_window_stick (GdkWindow *window)
10180 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->stick (window);
10184 * gdk_window_unstick:
10185 * @window: a toplevel #GdkWindow
10187 * Reverse operation for gdk_window_stick(); see gdk_window_stick(),
10188 * and gtk_window_unstick().
10192 gdk_window_unstick (GdkWindow *window)
10194 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unstick (window);
10198 * gdk_window_maximize:
10199 * @window: a toplevel #GdkWindow
10201 * Maximizes the window. If the window was already maximized, then
10202 * this function does nothing.
10204 * On X11, asks the window manager to maximize @window, if the window
10205 * manager supports this operation. Not all window managers support
10206 * this, and some deliberately ignore it or don't have a concept of
10207 * "maximized"; so you can't rely on the maximization actually
10208 * happening. But it will happen with most standard window managers,
10209 * and GDK makes a best effort to get it to happen.
10211 * On Windows, reliably maximizes the window.
10215 gdk_window_maximize (GdkWindow *window)
10217 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->maximize (window);
10221 * gdk_window_unmaximize:
10222 * @window: a toplevel #GdkWindow
10224 * Unmaximizes the window. If the window wasn't maximized, then this
10225 * function does nothing.
10227 * On X11, asks the window manager to unmaximize @window, if the
10228 * window manager supports this operation. Not all window managers
10229 * support this, and some deliberately ignore it or don't have a
10230 * concept of "maximized"; so you can't rely on the unmaximization
10231 * actually happening. But it will happen with most standard window
10232 * managers, and GDK makes a best effort to get it to happen.
10234 * On Windows, reliably unmaximizes the window.
10238 gdk_window_unmaximize (GdkWindow *window)
10240 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unmaximize (window);
10244 * gdk_window_fullscreen:
10245 * @window: a toplevel #GdkWindow
10247 * Moves the window into fullscreen mode. This means the
10248 * window covers the entire screen and is above any panels
10251 * If the window was already fullscreen, then this function does nothing.
10253 * On X11, asks the window manager to put @window in a fullscreen
10254 * state, if the window manager supports this operation. Not all
10255 * window managers support this, and some deliberately ignore it or
10256 * don't have a concept of "fullscreen"; so you can't rely on the
10257 * fullscreenification actually happening. But it will happen with
10258 * most standard window managers, and GDK makes a best effort to get
10264 gdk_window_fullscreen (GdkWindow *window)
10266 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->fullscreen (window);
10270 * gdk_window_unfullscreen:
10271 * @window: a toplevel #GdkWindow
10273 * Moves the window out of fullscreen mode. If the window was not
10274 * fullscreen, does nothing.
10276 * On X11, asks the window manager to move @window out of the fullscreen
10277 * state, if the window manager supports this operation. Not all
10278 * window managers support this, and some deliberately ignore it or
10279 * don't have a concept of "fullscreen"; so you can't rely on the
10280 * unfullscreenification actually happening. But it will happen with
10281 * most standard window managers, and GDK makes a best effort to get
10287 gdk_window_unfullscreen (GdkWindow *window)
10289 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unfullscreen (window);
10293 * gdk_window_set_keep_above:
10294 * @window: a toplevel #GdkWindow
10295 * @setting: whether to keep @window above other windows
10297 * Set if @window must be kept above other windows. If the
10298 * window was already above, then this function does nothing.
10300 * On X11, asks the window manager to keep @window above, if the window
10301 * manager supports this operation. Not all window managers support
10302 * this, and some deliberately ignore it or don't have a concept of
10303 * "keep above"; so you can't rely on the window being kept above.
10304 * But it will happen with most standard window managers,
10305 * and GDK makes a best effort to get it to happen.
10310 gdk_window_set_keep_above (GdkWindow *window,
10313 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_above (window, setting);
10317 * gdk_window_set_keep_below:
10318 * @window: a toplevel #GdkWindow
10319 * @setting: whether to keep @window below other windows
10321 * Set if @window must be kept below other windows. If the
10322 * window was already below, then this function does nothing.
10324 * On X11, asks the window manager to keep @window below, if the window
10325 * manager supports this operation. Not all window managers support
10326 * this, and some deliberately ignore it or don't have a concept of
10327 * "keep below"; so you can't rely on the window being kept below.
10328 * But it will happen with most standard window managers,
10329 * and GDK makes a best effort to get it to happen.
10334 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
10336 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_below (window, setting);
10340 * gdk_window_get_group:
10341 * @window: a toplevel #GdkWindow
10343 * Returns the group leader window for @window. See gdk_window_set_group().
10345 * Return value: (transfer none): the group leader window for @window
10350 gdk_window_get_group (GdkWindow *window)
10352 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_group (window);
10356 * gdk_window_set_group:
10357 * @window: a toplevel #GdkWindow
10358 * @leader: (allow-none): group leader window, or %NULL to restore the default group leader window
10360 * Sets the group leader window for @window. By default,
10361 * GDK sets the group leader for all toplevel windows
10362 * to a global window implicitly created by GDK. With this function
10363 * you can override this default.
10365 * The group leader window allows the window manager to distinguish
10366 * all windows that belong to a single application. It may for example
10367 * allow users to minimize/unminimize all windows belonging to an
10368 * application at once. You should only set a non-default group window
10369 * if your application pretends to be multiple applications.
10372 gdk_window_set_group (GdkWindow *window,
10375 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_group (window, leader);
10379 * gdk_window_set_decorations:
10380 * @window: a toplevel #GdkWindow
10381 * @decorations: decoration hint mask
10383 * "Decorations" are the features the window manager adds to a toplevel #GdkWindow.
10384 * This function sets the traditional Motif window manager hints that tell the
10385 * window manager which decorations you would like your window to have.
10386 * Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
10387 * using the GDK function directly.
10389 * The @decorations argument is the logical OR of the fields in
10390 * the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
10391 * mask, the other bits indicate which decorations should be turned off.
10392 * If #GDK_DECOR_ALL is not included, then the other bits indicate
10393 * which decorations should be turned on.
10395 * Most window managers honor a decorations hint of 0 to disable all decorations,
10396 * but very few honor all possible combinations of bits.
10400 gdk_window_set_decorations (GdkWindow *window,
10401 GdkWMDecoration decorations)
10403 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_decorations (window, decorations);
10407 * gdk_window_get_decorations:
10408 * @window: The toplevel #GdkWindow to get the decorations from
10409 * @decorations: (out): The window decorations will be written here
10411 * Returns the decorations set on the GdkWindow with
10412 * gdk_window_set_decorations().
10414 * Returns: %TRUE if the window has decorations set, %FALSE otherwise.
10417 gdk_window_get_decorations(GdkWindow *window,
10418 GdkWMDecoration *decorations)
10420 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_decorations (window, decorations);
10424 * gdk_window_set_functions:
10425 * @window: a toplevel #GdkWindow
10426 * @functions: bitmask of operations to allow on @window
10428 * Sets hints about the window management functions to make available
10429 * via buttons on the window frame.
10431 * On the X backend, this function sets the traditional Motif window
10432 * manager hint for this purpose. However, few window managers do
10433 * anything reliable or interesting with this hint. Many ignore it
10436 * The @functions argument is the logical OR of values from the
10437 * #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
10438 * then the other bits indicate which functions to disable; if
10439 * it doesn't include #GDK_FUNC_ALL, it indicates which functions to
10444 gdk_window_set_functions (GdkWindow *window,
10445 GdkWMFunction functions)
10447 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_functions (window, functions);
10451 * gdk_window_begin_resize_drag_for_device:
10452 * @window: a toplevel #GdkWindow
10453 * @edge: the edge or corner from which the drag is started
10454 * @device: the device used for the operation
10455 * @button: the button being used to drag
10456 * @root_x: root window X coordinate of mouse click that began the drag
10457 * @root_y: root window Y coordinate of mouse click that began the drag
10458 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10460 * Begins a window resize operation (for a toplevel window).
10461 * You might use this function to implement a "window resize grip," for
10462 * example; in fact #GtkStatusbar uses it. The function works best
10463 * with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a
10464 * fallback implementation for other window managers.
10469 gdk_window_begin_resize_drag_for_device (GdkWindow *window,
10470 GdkWindowEdge edge,
10477 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
10481 * gdk_window_begin_resize_drag:
10482 * @window: a toplevel #GdkWindow
10483 * @edge: the edge or corner from which the drag is started
10484 * @button: the button being used to drag
10485 * @root_x: root window X coordinate of mouse click that began the drag
10486 * @root_y: root window Y coordinate of mouse click that began the drag
10487 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10489 * Begins a window resize operation (for a toplevel window).
10491 * This function assumes that the drag is controlled by the
10492 * client pointer device, use gdk_window_begin_resize_drag_for_device()
10493 * to begin a drag with a different device.
10496 gdk_window_begin_resize_drag (GdkWindow *window,
10497 GdkWindowEdge edge,
10503 GdkDeviceManager *device_manager;
10506 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10507 device = gdk_device_manager_get_client_pointer (device_manager);
10508 gdk_window_begin_resize_drag_for_device (window, edge,
10509 device, button, root_x, root_y, timestamp);
10513 * gdk_window_begin_move_drag_for_device:
10514 * @window: a toplevel #GdkWindow
10515 * @device: the device used for the operation
10516 * @button: the button being used to drag
10517 * @root_x: root window X coordinate of mouse click that began the drag
10518 * @root_y: root window Y coordinate of mouse click that began the drag
10519 * @timestamp: timestamp of mouse click that began the drag
10521 * Begins a window move operation (for a toplevel window).
10522 * You might use this function to implement a "window move grip," for
10523 * example. The function works best with window managers that support
10524 * the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
10525 * Window Manager Hints</ulink>, but has a fallback implementation for
10526 * other window managers.
10531 gdk_window_begin_move_drag_for_device (GdkWindow *window,
10538 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_move_drag (window,
10539 device, button, root_x, root_y, timestamp);
10543 * gdk_window_begin_move_drag:
10544 * @window: a toplevel #GdkWindow
10545 * @button: the button being used to drag
10546 * @root_x: root window X coordinate of mouse click that began the drag
10547 * @root_y: root window Y coordinate of mouse click that began the drag
10548 * @timestamp: timestamp of mouse click that began the drag
10550 * Begins a window move operation (for a toplevel window).
10552 * This function assumes that the drag is controlled by the
10553 * client pointer device, use gdk_window_begin_move_drag_for_device()
10554 * to begin a drag with a different device.
10557 gdk_window_begin_move_drag (GdkWindow *window,
10563 GdkDeviceManager *device_manager;
10566 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10567 device = gdk_device_manager_get_client_pointer (device_manager);
10568 gdk_window_begin_move_drag_for_device (window, device, button, root_x, root_y, timestamp);
10572 * gdk_window_enable_synchronized_configure:
10573 * @window: a toplevel #GdkWindow
10575 * Indicates that the application will cooperate with the window
10576 * system in synchronizing the window repaint with the window
10577 * manager during resizing operations. After an application calls
10578 * this function, it must call gdk_window_configure_finished() every
10579 * time it has finished all processing associated with a set of
10580 * Configure events. Toplevel GTK+ windows automatically use this
10583 * On X, calling this function makes @window participate in the
10584 * _NET_WM_SYNC_REQUEST window manager protocol.
10589 gdk_window_enable_synchronized_configure (GdkWindow *window)
10591 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->enable_synchronized_configure (window);
10595 * gdk_window_configure_finished:
10596 * @window: a toplevel #GdkWindow
10598 * Signal to the window system that the application has finished
10599 * handling Configure events it has received. Window Managers can
10600 * use this to better synchronize the frame repaint with the
10601 * application. GTK+ applications will automatically call this
10602 * function when appropriate.
10604 * This function can only be called if gdk_window_enable_synchronized_configure()
10605 * was called previously.
10610 gdk_window_configure_finished (GdkWindow *window)
10612 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->configure_finished (window);
10616 * gdk_window_set_opacity:
10617 * @window: a top-level #GdkWindow
10618 * @opacity: opacity
10620 * Request the windowing system to make @window partially transparent,
10621 * with opacity 0 being fully transparent and 1 fully opaque. (Values
10622 * of the opacity parameter are clamped to the [0,1] range.)
10624 * On X11, this works only on X screens with a compositing manager
10627 * For setting up per-pixel alpha, see gdk_screen_get_rgba_visual().
10628 * For making non-toplevel windows translucent, see
10629 * gdk_window_set_composited().
10634 gdk_window_set_opacity (GdkWindow *window,
10637 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_opacity (window, opacity);
10640 /* This function is called when the XWindow is really gone.
10643 gdk_window_destroy_notify (GdkWindow *window)
10645 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->destroy_notify (window);
10649 * gdk_window_register_dnd:
10650 * @window: a #GdkWindow.
10652 * Registers a window as a potential drop destination.
10655 gdk_window_register_dnd (GdkWindow *window)
10657 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->register_dnd (window);
10661 * gdk_window_get_drag_protocol:
10662 * @window: the destination window
10663 * @target: (out) (allow-none) (transfer full): location of the window
10664 * where the drop should happen. This may be @window or a proxy window,
10665 * or %NULL if @window does not support Drag and Drop.
10667 * Finds out the DND protocol supported by a window.
10669 * Returns: the supported DND protocol.
10674 gdk_window_get_drag_protocol (GdkWindow *window,
10675 GdkWindow **target)
10677 g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_DRAG_PROTO_NONE);
10679 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_drag_protocol (window, target);
10684 * @window: the source window for this drag.
10685 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10686 * as list of #GdkAtoms
10688 * Starts a drag and creates a new drag context for it.
10689 * This function assumes that the drag is controlled by the
10690 * client pointer device, use gdk_drag_begin_for_device() to
10691 * begin a drag with a different device.
10693 * This function is called by the drag source.
10695 * Return value: (transfer full): a newly created #GdkDragContext
10698 gdk_drag_begin (GdkWindow *window,
10701 GdkDeviceManager *device_manager;
10704 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10705 device = gdk_device_manager_get_client_pointer (device_manager);
10707 return gdk_drag_begin_for_device (window, device, targets);
10711 * gdk_drag_begin_for_device:
10712 * @window: the source window for this drag
10713 * @device: the device that controls this drag
10714 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10715 * as list of #GdkAtoms
10717 * Starts a drag and creates a new drag context for it.
10719 * This function is called by the drag source.
10721 * Return value: (transfer full): a newly created #GdkDragContext
10724 gdk_drag_begin_for_device (GdkWindow *window,
10728 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->drag_begin (window, device, targets);
10732 * gdk_test_render_sync:
10733 * @window: a mapped #GdkWindow
10735 * Retrieves a pixel from @window to force the windowing
10736 * system to carry out any pending rendering commands.
10738 * This function is intended to be used to synchronize with rendering
10739 * pipelines, to benchmark windowing system rendering operations.
10744 gdk_test_render_sync (GdkWindow *window)
10746 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->sync_rendering (window);
10750 * gdk_test_simulate_key:
10751 * @window: a #GdkWindow to simulate a key event for
10752 * @x: x coordinate within @window for the key event
10753 * @y: y coordinate within @window for the key event
10754 * @keyval: A GDK keyboard value
10755 * @modifiers: Keyboard modifiers the event is setup with
10756 * @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
10758 * This function is intended to be used in GTK+ test programs.
10759 * If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
10760 * the given (@x,@y) coordinates within @window and simulate a
10761 * key press or release event.
10763 * When the mouse pointer is warped to the target location, use
10764 * of this function outside of test programs that run in their
10765 * own virtual windowing system (e.g. Xvfb) is not recommended.
10766 * If (@x,@y) are passed as (-1,-1), the mouse pointer will not
10767 * be warped and @window origin will be used as mouse pointer
10768 * location for the event.
10770 * Also, gdk_test_simulate_key() is a fairly low level function,
10771 * for most testing purposes, gtk_test_widget_send_key() is the
10772 * right function to call which will generate a key press event
10773 * followed by its accompanying key release event.
10775 * Returns: whether all actions necessary for a key event simulation
10776 * were carried out successfully
10781 gdk_test_simulate_key (GdkWindow *window,
10785 GdkModifierType modifiers,
10786 GdkEventType key_pressrelease)
10788 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10789 ->simulate_key (window, x, y, keyval, modifiers, key_pressrelease);
10793 * gdk_test_simulate_button:
10794 * @window: a #GdkWindow to simulate a button event for
10795 * @x: x coordinate within @window for the button event
10796 * @y: y coordinate within @window for the button event
10797 * @button: Number of the pointer button for the event, usually 1, 2 or 3
10798 * @modifiers: Keyboard modifiers the event is setup with
10799 * @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
10801 * This function is intended to be used in GTK+ test programs.
10802 * It will warp the mouse pointer to the given (@x,@y) coordinates
10803 * within @window and simulate a button press or release event.
10804 * Because the mouse pointer needs to be warped to the target
10805 * location, use of this function outside of test programs that
10806 * run in their own virtual windowing system (e.g. Xvfb) is not
10809 * Also, gdk_test_simulate_button() is a fairly low level function,
10810 * for most testing purposes, gtk_test_widget_click() is the right
10811 * function to call which will generate a button press event followed
10812 * by its accompanying button release event.
10814 * Returns: whether all actions necessary for a button event simulation
10815 * were carried out successfully
10820 gdk_test_simulate_button (GdkWindow *window,
10823 guint button, /*1..3*/
10824 GdkModifierType modifiers,
10825 GdkEventType button_pressrelease)
10827 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10828 ->simulate_button (window, x, y, button, modifiers, button_pressrelease);
10832 * gdk_property_get:
10833 * @window: a #GdkWindow
10834 * @property: the property to retrieve
10835 * @type: the desired property type, or %GDK_NONE, if any type of data
10836 * is acceptable. If this does not match the actual
10837 * type, then @actual_format and @actual_length will
10838 * be filled in, a warning will be printed to stderr
10839 * and no data will be returned.
10840 * @offset: the offset into the property at which to begin
10841 * retrieving data, in 4 byte units.
10842 * @length: the length of the data to retrieve in bytes. Data is
10843 * considered to be retrieved in 4 byte chunks, so @length
10844 * will be rounded up to the next highest 4 byte boundary
10845 * (so be careful not to pass a value that might overflow
10846 * when rounded up).
10847 * @pdelete: if %TRUE, delete the property after retrieving the
10849 * @actual_property_type: (out) (transfer none): location to store the
10850 * actual type of the property.
10851 * @actual_format: (out): location to store the actual return format of the
10852 * data; either 8, 16 or 32 bits.
10853 * @actual_length: location to store the length of the retrieved data, in
10854 * bytes. Data returned in the 32 bit format is stored
10855 * in a long variable, so the actual number of 32 bit
10856 * elements should be be calculated via
10857 * @actual_length / sizeof(glong) to ensure portability to
10859 * @data: (out) (array length=actual_length) (transfer full): location
10860 * to store a pointer to the data. The retrieved data should be
10861 * freed with g_free() when you are finished using it.
10863 * Retrieves a portion of the contents of a property. If the
10864 * property does not exist, then the function returns %FALSE,
10865 * and %GDK_NONE will be stored in @actual_property_type.
10869 * The XGetWindowProperty() function that gdk_property_get()
10870 * uses has a very confusing and complicated set of semantics.
10871 * Unfortunately, gdk_property_get() makes the situation
10872 * worse instead of better (the semantics should be considered
10873 * undefined), and also prints warnings to stderr in cases where it
10874 * should return a useful error to the program. You are advised to use
10875 * XGetWindowProperty() directly until a replacement function for
10876 * gdk_property_get()
10881 * Returns: %TRUE if data was successfully received and stored
10882 * in @data, otherwise %FALSE.
10885 gdk_property_get (GdkWindow *window,
10891 GdkAtom *actual_property_type,
10892 gint *actual_format_type,
10893 gint *actual_length,
10896 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10897 ->get_property (window, property, type, offset, length, pdelete,
10898 actual_property_type, actual_format_type,
10899 actual_length, data);
10903 * gdk_property_change: (skip)
10904 * @window: a #GdkWindow
10905 * @property: the property to change
10906 * @type: the new type for the property. If @mode is
10907 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
10908 * must match the existing type or an error will occur.
10909 * @format: the new format for the property. If @mode is
10910 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
10911 * must match the existing format or an error will occur.
10912 * @mode: a value describing how the new data is to be combined
10913 * with the current data.
10914 * @data: the data (a <literal>guchar *</literal>
10915 * <literal>gushort *</literal>, or <literal>gulong *</literal>,
10916 * depending on @format), cast to a <literal>guchar *</literal>.
10917 * @nelements: the number of elements of size determined by the format,
10918 * contained in @data.
10920 * Changes the contents of a property on a window.
10923 gdk_property_change (GdkWindow *window,
10928 const guchar *data,
10931 GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10932 ->change_property (window, property, type, format, mode, data, nelements);
10936 * gdk_property_delete:
10937 * @window: a #GdkWindow
10938 * @property: the property to delete
10940 * Deletes a property from a window.
10943 gdk_property_delete (GdkWindow *window,
10946 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->delete_property (window, property);