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 cairo_region_t *flushed;
207 guint uses_implicit : 1;
211 cairo_region_t *dest_region; /* The destination region */
212 int dx, dy; /* The amount that the source was moved to reach dest_region */
213 } GdkWindowRegionMove;
217 static void gdk_window_drop_cairo_surface (GdkWindow *private);
219 static void gdk_window_free_paint_stack (GdkWindow *window);
221 static void gdk_window_finalize (GObject *object);
223 static void gdk_window_set_property (GObject *object,
227 static void gdk_window_get_property (GObject *object,
232 static void gdk_window_clear_backing_region (GdkWindow *window,
233 cairo_region_t *region);
235 static void recompute_visible_regions (GdkWindow *private,
236 gboolean recalculate_siblings,
237 gboolean recalculate_children);
238 static void gdk_window_flush_outstanding_moves (GdkWindow *window);
239 static void gdk_window_flush_recursive (GdkWindow *window);
240 static void do_move_region_bits_on_impl (GdkWindow *window,
241 cairo_region_t *region, /* In impl window coords */
243 static void gdk_window_invalidate_in_parent (GdkWindow *private);
244 static void move_native_children (GdkWindow *private);
245 static void update_cursor (GdkDisplay *display,
247 static void impl_window_add_update_area (GdkWindow *impl_window,
248 cairo_region_t *region);
249 static void gdk_window_region_move_free (GdkWindowRegionMove *move);
250 static void gdk_window_invalidate_region_full (GdkWindow *window,
251 const cairo_region_t *region,
252 gboolean invalidate_children,
254 static void gdk_window_invalidate_rect_full (GdkWindow *window,
255 const GdkRectangle *rect,
256 gboolean invalidate_children,
258 static void _gdk_window_propagate_has_alpha_background (GdkWindow *window);
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;
266 G_DEFINE_ABSTRACT_TYPE (GdkWindow, gdk_window, G_TYPE_OBJECT)
269 _gdk_paintable_get_type (void)
271 static GType paintable_type = 0;
275 const GTypeInfo paintable_info =
277 sizeof (GdkPaintableIface), /* class_size */
278 NULL, /* base_init */
279 NULL, /* base_finalize */
282 paintable_type = g_type_register_static (G_TYPE_INTERFACE,
283 g_intern_static_string ("GdkPaintable"),
286 g_type_interface_add_prerequisite (paintable_type, G_TYPE_OBJECT);
289 return paintable_type;
293 gdk_window_init (GdkWindow *window)
295 /* 0-initialization is good for all other fields. */
297 window->window_type = GDK_WINDOW_CHILD;
299 window->state = GDK_WINDOW_STATE_WITHDRAWN;
302 window->toplevel_window_type = -1;
304 window->effective_visibility = GDK_VISIBILITY_NOT_VIEWABLE;
305 window->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
306 /* Default to unobscured since some backends don't send visibility events */
307 window->native_visibility = GDK_VISIBILITY_UNOBSCURED;
309 window->device_cursor = g_hash_table_new_full (NULL, NULL,
310 NULL, g_object_unref);
313 /* Stop and return on the first non-NULL parent */
315 accumulate_get_window (GSignalInvocationHint *ihint,
317 const GValue *handler_return,
320 g_value_copy (handler_return, return_accu);
321 /* Continue while returning NULL */
322 return g_value_get_object (handler_return) == NULL;
326 create_surface_accumulator (GSignalInvocationHint *ihint,
328 const GValue *handler_return,
331 g_value_copy (handler_return, return_accu);
333 /* Stop on the first non-NULL return value */
334 return g_value_get_boxed (handler_return) == NULL;
337 static GQuark quark_pointer_window = 0;
340 gdk_window_class_init (GdkWindowClass *klass)
342 GObjectClass *object_class = G_OBJECT_CLASS (klass);
344 parent_class = g_type_class_peek_parent (klass);
346 object_class->finalize = gdk_window_finalize;
347 object_class->set_property = gdk_window_set_property;
348 object_class->get_property = gdk_window_get_property;
350 klass->create_surface = _gdk_offscreen_window_create_surface;
352 quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
360 * The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and
361 * gdk_window_get_cursor() for details.
365 g_object_class_install_property (object_class,
367 g_param_spec_object ("cursor",
374 * GdkWindow::pick-embedded-child:
375 * @window: the window on which the signal is emitted
376 * @x: x coordinate in the window
377 * @y: y coordinate in the window
379 * The ::pick-embedded-child signal is emitted to find an embedded
380 * child at the given position.
382 * Returns: (transfer none): the #GdkWindow of the embedded child at
387 signals[PICK_EMBEDDED_CHILD] =
388 g_signal_new (g_intern_static_string ("pick-embedded-child"),
389 G_OBJECT_CLASS_TYPE (object_class),
391 G_STRUCT_OFFSET (GdkWindowClass, pick_embedded_child),
392 accumulate_get_window, NULL,
393 _gdk_marshal_OBJECT__DOUBLE_DOUBLE,
400 * GdkWindow::to-embedder:
401 * @window: the offscreen window on which the signal is emitted
402 * @offscreen-x: x coordinate in the offscreen window
403 * @offscreen-y: y coordinate in the offscreen window
404 * @embedder-x: (out) (type double): return location for the x
405 * coordinate in the embedder window
406 * @embedder-y: (out) (type double): return location for the y
407 * coordinate in the embedder window
409 * The ::to-embedder signal is emitted to translate coordinates
410 * in an offscreen window to its embedder.
412 * See also #GtkWindow::from-embedder.
416 signals[TO_EMBEDDER] =
417 g_signal_new (g_intern_static_string ("to-embedder"),
418 G_OBJECT_CLASS_TYPE (object_class),
420 G_STRUCT_OFFSET (GdkWindowClass, to_embedder),
422 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
431 * GdkWindow::from-embedder:
432 * @window: the offscreen window on which the signal is emitted
433 * @embedder-x: x coordinate in the embedder window
434 * @embedder-y: y coordinate in the embedder window
435 * @offscreen-x: (out) (type double): return location for the x
436 * coordinate in the offscreen window
437 * @offscreen-y: (out) (type double): return location for the y
438 * coordinate in the offscreen window
440 * The ::from-embedder signal is emitted to translate coordinates
441 * in the embedder of an offscreen window to the offscreen window.
443 * See also #GtkWindow::to-embedder.
447 signals[FROM_EMBEDDER] =
448 g_signal_new (g_intern_static_string ("from-embedder"),
449 G_OBJECT_CLASS_TYPE (object_class),
451 G_STRUCT_OFFSET (GdkWindowClass, from_embedder),
453 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
462 * GdkWindow::create-surface:
463 * @window: the offscreen window on which the signal is emitted
464 * @width: the width of the offscreen surface to create
465 * @height: the height of the offscreen surface to create
467 * The ::create-surface signal is emitted when an offscreen window
468 * needs its surface (re)created, which happens either when the the
469 * window is first drawn to, or when the window is being
470 * resized. The first signal handler that returns a non-%NULL
471 * surface will stop any further signal emission, and its surface
474 * Note that it is not possible to access the window's previous
475 * surface from within any callback of this signal. Calling
476 * gdk_offscreen_window_get_surface() will lead to a crash.
478 * Returns: the newly created #cairo_surface_t for the offscreen window
482 signals[CREATE_SURFACE] =
483 g_signal_new (g_intern_static_string ("create-surface"),
484 G_OBJECT_CLASS_TYPE (object_class),
486 G_STRUCT_OFFSET (GdkWindowClass, create_surface),
487 create_surface_accumulator, NULL,
488 _gdk_marshal_BOXED__INT_INT,
489 CAIRO_GOBJECT_TYPE_SURFACE,
496 device_removed_cb (GdkDeviceManager *device_manager,
500 window->devices_inside = g_list_remove (window->devices_inside, device);
501 g_hash_table_remove (window->device_cursor, device);
503 if (window->device_events)
504 g_hash_table_remove (window->device_events, device);
508 gdk_window_finalize (GObject *object)
510 GdkWindow *window = GDK_WINDOW (object);
511 GdkDeviceManager *device_manager;
513 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
514 g_signal_handlers_disconnect_by_func (device_manager, device_removed_cb, window);
516 if (!GDK_WINDOW_DESTROYED (window))
518 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
520 g_warning ("losing last reference to undestroyed window\n");
521 _gdk_window_destroy (window, FALSE);
524 /* We use TRUE here, to keep us from actually calling
525 * XDestroyWindow() on the window
527 _gdk_window_destroy (window, TRUE);
530 gdk_window_drop_cairo_surface (window);
534 g_object_unref (window->impl);
538 if (window->impl_window != window)
540 g_object_unref (window->impl_window);
541 window->impl_window = NULL;
545 cairo_region_destroy (window->shape);
547 if (window->input_shape)
548 cairo_region_destroy (window->input_shape);
551 g_object_unref (window->cursor);
553 if (window->device_cursor)
554 g_hash_table_destroy (window->device_cursor);
556 if (window->device_events)
557 g_hash_table_destroy (window->device_events);
559 if (window->source_event_masks)
560 g_hash_table_destroy (window->source_event_masks);
562 if (window->devices_inside)
563 g_list_free (window->devices_inside);
565 if (window->layered_region)
566 cairo_region_destroy (window->layered_region);
568 G_OBJECT_CLASS (parent_class)->finalize (object);
572 gdk_window_set_property (GObject *object,
577 GdkWindow *window = (GdkWindow *)object;
582 gdk_window_set_cursor (window, g_value_get_object (value));
586 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
592 gdk_window_get_property (GObject *object,
597 GdkWindow *window = (GdkWindow *) object;
602 g_value_set_object (value, gdk_window_get_cursor (window));
606 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
612 gdk_window_is_offscreen (GdkWindow *window)
614 return window->window_type == GDK_WINDOW_OFFSCREEN;
618 gdk_window_get_impl_window (GdkWindow *window)
620 return window->impl_window;
624 _gdk_window_get_impl_window (GdkWindow *window)
626 return gdk_window_get_impl_window (window);
630 gdk_window_has_impl (GdkWindow *window)
632 return window->impl_window == window;
636 gdk_window_is_toplevel (GdkWindow *window)
639 window->parent == NULL ||
640 window->parent->window_type == GDK_WINDOW_ROOT;
644 _gdk_window_has_impl (GdkWindow *window)
646 return gdk_window_has_impl (window);
650 gdk_window_has_no_impl (GdkWindow *window)
652 return window->impl_window != window;
656 remove_layered_child_area (GdkWindow *window,
657 cairo_region_t *region)
660 cairo_region_t *child_region;
664 for (l = window->children; l; l = l->next)
668 /* If region is empty already, no need to do
669 anything potentially costly */
670 if (cairo_region_is_empty (region))
673 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
676 /* Ignore offscreen children, as they don't draw in their parent and
677 * don't take part in the clipping */
678 if (gdk_window_is_offscreen (child))
681 /* Only non-impl children with alpha add to the layered region */
682 if (!child->has_alpha_background && gdk_window_has_impl (child))
687 r.width = child->width;
688 r.height = child->height;
690 /* Bail early if child totally outside region */
691 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
694 child_region = cairo_region_create_rectangle (&r);
697 /* Adjust shape region to parent window coords */
698 cairo_region_translate (child->shape, child->x, child->y);
699 cairo_region_intersect (child_region, child->shape);
700 cairo_region_translate (child->shape, -child->x, -child->y);
703 cairo_region_subtract (region, child_region);
704 cairo_region_destroy (child_region);
709 remove_child_area (GdkWindow *window,
712 cairo_region_t *region,
713 cairo_region_t *layered_region)
716 cairo_region_t *child_region;
719 cairo_region_t *shape;
721 for (l = window->children; l; l = l->next)
728 /* If region is empty already, no need to do
729 anything potentially costly */
730 if (cairo_region_is_empty (region))
733 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
736 /* Ignore offscreen children, as they don't draw in their parent and
737 * don't take part in the clipping */
738 if (gdk_window_is_offscreen (child))
743 r.width = child->width;
744 r.height = child->height;
746 /* Bail early if child totally outside region */
747 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
750 child_region = cairo_region_create_rectangle (&r);
754 /* Adjust shape region to parent window coords */
755 cairo_region_translate (child->shape, child->x, child->y);
756 cairo_region_intersect (child_region, child->shape);
757 cairo_region_translate (child->shape, -child->x, -child->y);
759 else if (window->window_type == GDK_WINDOW_FOREIGN)
761 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_shape (child);
764 cairo_region_intersect (child_region, shape);
765 cairo_region_destroy (shape);
771 if (child->input_shape)
772 cairo_region_intersect (child_region, child->input_shape);
773 else if (window->window_type == GDK_WINDOW_FOREIGN)
775 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_input_shape (child);
778 cairo_region_intersect (child_region, shape);
779 cairo_region_destroy (shape);
784 if (child->has_alpha_background)
786 if (layered_region != NULL)
787 cairo_region_union (layered_region, child_region);
790 cairo_region_subtract (region, child_region);
791 cairo_region_destroy (child_region);
795 static GdkVisibilityState
796 effective_visibility (GdkWindow *window)
798 GdkVisibilityState native;
800 if (!gdk_window_is_viewable (window))
801 return GDK_VISIBILITY_NOT_VIEWABLE;
803 native = window->impl_window->native_visibility;
805 if (native == GDK_VISIBILITY_FULLY_OBSCURED ||
806 window->visibility == GDK_VISIBILITY_FULLY_OBSCURED)
807 return GDK_VISIBILITY_FULLY_OBSCURED;
808 else if (native == GDK_VISIBILITY_UNOBSCURED)
809 return window->visibility;
810 else /* native PARTIAL, private partial or unobscured */
811 return GDK_VISIBILITY_PARTIAL;
815 gdk_window_update_visibility (GdkWindow *window)
817 GdkVisibilityState new_visibility;
820 new_visibility = effective_visibility (window);
822 if (new_visibility != window->effective_visibility)
824 window->effective_visibility = new_visibility;
826 if (new_visibility != GDK_VISIBILITY_NOT_VIEWABLE &&
827 window->event_mask & GDK_VISIBILITY_NOTIFY_MASK)
829 event = _gdk_make_event (window, GDK_VISIBILITY_NOTIFY,
831 event->visibility.state = new_visibility;
837 gdk_window_update_visibility_recursively (GdkWindow *window,
838 GdkWindow *only_for_impl)
843 gdk_window_update_visibility (window);
844 for (l = window->children; l != NULL; l = l->next)
847 if ((only_for_impl == NULL) ||
848 (only_for_impl == child->impl_window))
849 gdk_window_update_visibility_recursively (child, only_for_impl);
854 should_apply_clip_as_shape (GdkWindow *window)
857 gdk_window_has_impl (window) &&
858 /* Not for offscreens */
859 !gdk_window_is_offscreen (window) &&
860 /* or for toplevels */
861 !gdk_window_is_toplevel (window) &&
862 /* or for foreign windows */
863 window->window_type != GDK_WINDOW_FOREIGN &&
864 /* or for the root window */
865 window->window_type != GDK_WINDOW_ROOT;
869 apply_shape (GdkWindow *window,
870 cairo_region_t *region)
872 GdkWindowImplClass *impl_class;
874 /* We trash whether we applied a shape so that
875 we can avoid unsetting it many times, which
876 could happen in e.g. apply_clip_as_shape as
877 windows get resized */
878 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
880 impl_class->shape_combine_region (window,
882 else if (window->applied_shape)
883 impl_class->shape_combine_region (window,
886 window->applied_shape = region != NULL;
890 region_rect_equal (const cairo_region_t *region,
891 const GdkRectangle *rect)
893 GdkRectangle extents;
895 if (cairo_region_num_rectangles (region) != 1)
898 cairo_region_get_extents (region, &extents);
900 return extents.x == rect->x &&
901 extents.y == rect->y &&
902 extents.width == rect->width &&
903 extents.height == rect->height;
907 apply_clip_as_shape (GdkWindow *window)
912 r.width = window->width;
913 r.height = window->height;
915 /* We only apply the clip region if would differ
916 from the actual clip region implied by the size
917 of the window. This is to avoid unneccessarily
918 adding meaningless shapes to all native subwindows */
919 if (!region_rect_equal (window->clip_region, &r))
920 apply_shape (window, window->clip_region);
922 apply_shape (window, NULL);
926 recompute_visible_regions_internal (GdkWindow *private,
927 gboolean recalculate_clip,
928 gboolean recalculate_siblings,
929 gboolean recalculate_children)
934 cairo_region_t *new_clip, *new_layered;
935 gboolean clip_region_changed;
936 gboolean abs_pos_changed;
937 int old_abs_x, old_abs_y;
939 old_abs_x = private->abs_x;
940 old_abs_y = private->abs_y;
942 /* Update absolute position */
943 if (gdk_window_has_impl (private))
945 /* Native window starts here */
951 private->abs_x = private->parent->abs_x + private->x;
952 private->abs_y = private->parent->abs_y + private->y;
956 private->abs_x != old_abs_x ||
957 private->abs_y != old_abs_y;
959 /* Update clip region based on:
962 * siblings in parents above window
964 clip_region_changed = FALSE;
965 if (recalculate_clip)
967 new_layered = cairo_region_create ();
968 if (private->viewable)
970 /* Calculate visible region (sans children) in parent window coords */
973 r.width = private->width;
974 r.height = private->height;
975 new_clip = cairo_region_create_rectangle (&r);
977 if (!gdk_window_is_toplevel (private))
979 cairo_region_intersect (new_clip, private->parent->clip_region);
980 cairo_region_union (new_layered, private->parent->layered_region);
982 /* Remove all overlapping children from parent. */
983 remove_child_area (private->parent, private, FALSE, new_clip, new_layered);
986 /* Convert from parent coords to window coords */
987 cairo_region_translate (new_clip, -private->x, -private->y);
988 cairo_region_translate (new_layered, -private->x, -private->y);
991 cairo_region_intersect (new_clip, private->shape);
994 new_clip = cairo_region_create ();
996 cairo_region_intersect (new_layered, new_clip);
998 if (private->clip_region == NULL ||
999 !cairo_region_equal (private->clip_region, new_clip))
1000 clip_region_changed = TRUE;
1002 if (private->layered_region == NULL ||
1003 !cairo_region_equal (private->layered_region, new_layered))
1004 clip_region_changed = TRUE;
1006 if (private->clip_region)
1007 cairo_region_destroy (private->clip_region);
1008 private->clip_region = new_clip;
1010 if (private->layered_region != NULL)
1011 cairo_region_destroy (private->layered_region);
1012 private->layered_region = new_layered;
1014 if (private->clip_region_with_children)
1015 cairo_region_destroy (private->clip_region_with_children);
1016 private->clip_region_with_children = cairo_region_copy (private->clip_region);
1017 if (private->window_type != GDK_WINDOW_ROOT)
1018 remove_child_area (private, NULL, FALSE, private->clip_region_with_children, NULL);
1021 if (clip_region_changed)
1023 GdkVisibilityState visibility;
1024 gboolean fully_visible;
1026 if (cairo_region_is_empty (private->clip_region))
1027 visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1032 fully_visible = cairo_region_equal (private->clip_region,
1039 r.width = private->width;
1040 r.height = private->height;
1041 fully_visible = region_rect_equal (private->clip_region, &r);
1045 visibility = GDK_VISIBILITY_UNOBSCURED;
1047 visibility = GDK_VISIBILITY_PARTIAL;
1050 if (private->visibility != visibility)
1052 private->visibility = visibility;
1053 gdk_window_update_visibility (private);
1057 /* Update all children, recursively (except for root, where children are not exact). */
1058 if ((abs_pos_changed || clip_region_changed || recalculate_children) &&
1059 private->window_type != GDK_WINDOW_ROOT)
1061 for (l = private->children; l; l = l->next)
1064 /* Only recalculate clip if the the clip region changed, otherwise
1065 * there is no way the child clip region could change (its has not e.g. moved)
1066 * Except if recalculate_children is set to force child updates
1068 recompute_visible_regions_internal (child,
1069 recalculate_clip && (clip_region_changed || recalculate_children),
1074 if (clip_region_changed &&
1075 should_apply_clip_as_shape (private))
1076 apply_clip_as_shape (private);
1078 if (recalculate_siblings &&
1079 !gdk_window_is_toplevel (private))
1081 /* If we moved a child window in parent or changed the stacking order, then we
1082 * need to recompute the visible area of all the other children in the parent
1084 for (l = private->parent->children; l; l = l->next)
1088 if (child != private)
1089 recompute_visible_regions_internal (child, TRUE, FALSE, FALSE);
1092 /* We also need to recompute the _with_children clip for the parent */
1093 recompute_visible_regions_internal (private->parent, TRUE, FALSE, FALSE);
1096 if (private->cairo_surface && gdk_window_has_impl (private))
1098 GdkWindowImplClass *iface = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1100 private->cairo_surface = iface->resize_cairo_surface (private,
1101 private->cairo_surface,
1105 else if (private->cairo_surface)
1106 gdk_window_drop_cairo_surface (private);
1109 /* Call this when private has changed in one or more of these ways:
1113 * stacking order of window changed
1116 * It will recalculate abs_x/y and the clip regions
1118 * Unless the window didn't change stacking order or size/pos, pass in TRUE
1119 * for recalculate_siblings. (Mostly used internally for the recursion)
1121 * If a child window was removed (and you can't use that child for
1122 * recompute_visible_regions), pass in TRUE for recalculate_children on the parent
1125 recompute_visible_regions (GdkWindow *private,
1126 gboolean recalculate_siblings,
1127 gboolean recalculate_children)
1129 recompute_visible_regions_internal (private,
1131 recalculate_siblings,
1132 recalculate_children);
1136 _gdk_window_update_size (GdkWindow *window)
1138 recompute_visible_regions (window, TRUE, FALSE);
1141 /* Find the native window that would be just above "child"
1142 * in the native stacking order if "child" was a native window
1143 * (it doesn't have to be native). If there is no such native
1144 * window inside this native parent then NULL is returned.
1145 * If child is NULL, find lowest native window in parent.
1148 find_native_sibling_above_helper (GdkWindow *parent,
1156 l = g_list_find (parent->children, child);
1157 g_assert (l != NULL); /* Better be a child of its parent... */
1158 l = l->prev; /* Start looking at the one above the child */
1161 l = g_list_last (parent->children);
1163 for (; l != NULL; l = l->prev)
1167 if (gdk_window_has_impl (w))
1170 g_assert (parent != w);
1171 w = find_native_sibling_above_helper (w, NULL);
1181 find_native_sibling_above (GdkWindow *parent,
1186 w = find_native_sibling_above_helper (parent, child);
1190 if (gdk_window_has_impl (parent))
1193 return find_native_sibling_above (parent->parent, parent);
1197 get_native_device_event_mask (GdkWindow *private,
1200 GdkEventMask event_mask;
1203 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device));
1205 event_mask = private->event_mask;
1207 if (private->window_type == GDK_WINDOW_ROOT ||
1208 private->window_type == GDK_WINDOW_FOREIGN)
1214 /* Do whatever the app asks to, since the app
1215 * may be asking for weird things for native windows,
1216 * but don't use motion hints as that may affect non-native
1217 * child windows that don't want it. Also, we need to
1218 * set all the app-specified masks since they will be picked
1219 * up by any implicit grabs (i.e. if they were not set as
1220 * native we would not get the events we need). */
1221 mask = private->event_mask & ~GDK_POINTER_MOTION_HINT_MASK;
1223 /* We need thse for all native windows so we can
1224 emulate events on children: */
1227 GDK_VISIBILITY_NOTIFY_MASK |
1228 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
1230 /* Additionally we select for pointer and button events
1231 * for toplevels as we need to get these to emulate
1232 * them for non-native subwindows. Even though we don't
1233 * select on them for all native windows we will get them
1234 * as the events are propagated out to the first window
1235 * that select for them.
1236 * Not selecting for button press on all windows is an
1237 * important thing, because in X only one client can do
1238 * so, and we don't want to unexpectedly prevent another
1239 * client from doing it.
1241 * We also need to do the same if the app selects for button presses
1242 * because then we will get implicit grabs for this window, and the
1243 * event mask used for that grab is based on the rest of the mask
1244 * for the window, but we might need more events than this window
1245 * lists due to some non-native child window.
1247 if (gdk_window_is_toplevel (private) ||
1248 mask & GDK_BUTTON_PRESS_MASK)
1250 GDK_POINTER_MOTION_MASK |
1251 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1259 get_native_grab_event_mask (GdkEventMask grab_mask)
1261 /* Similar to the above but for pointer events only */
1263 GDK_POINTER_MOTION_MASK |
1264 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1265 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
1268 ~GDK_POINTER_MOTION_HINT_MASK);
1272 get_native_event_mask (GdkWindow *private)
1274 return get_native_device_event_mask (private, NULL);
1277 /* Puts the native window in the right order wrt the other native windows
1278 * in the hierarchy, given the position it has in the client side data.
1279 * This is useful if some operation changed the stacking order.
1280 * This calls assumes the native window is now topmost in its native parent.
1283 sync_native_window_stack_position (GdkWindow *window)
1286 GdkWindowImplClass *impl_class;
1287 GList listhead = {0};
1289 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1291 above = find_native_sibling_above (window->parent, window);
1294 listhead.data = window;
1295 impl_class->restack_under (above, &listhead);
1300 * gdk_window_new: (constructor)
1301 * @parent: (allow-none): a #GdkWindow, or %NULL to create the window as a child of
1302 * the default root window for the default display.
1303 * @attributes: attributes of the new window
1304 * @attributes_mask: mask indicating which fields in @attributes are valid
1306 * Creates a new #GdkWindow using the attributes from
1307 * @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
1308 * more details. Note: to use this on displays other than the default
1309 * display, @parent must be specified.
1311 * Return value: (transfer full): the new #GdkWindow
1314 gdk_window_new (GdkWindow *parent,
1315 GdkWindowAttr *attributes,
1316 gint attributes_mask)
1320 GdkDisplay *display;
1323 GdkEventMask event_mask;
1324 GdkWindow *real_parent;
1325 GdkDeviceManager *device_manager;
1327 g_return_val_if_fail (attributes != NULL, NULL);
1331 GDK_NOTE (MULTIHEAD,
1332 g_warning ("gdk_window_new(): no parent specified reverting to parent = default root window"));
1334 screen = gdk_screen_get_default ();
1335 parent = gdk_screen_get_root_window (screen);
1338 screen = gdk_window_get_screen (parent);
1340 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
1342 if (GDK_WINDOW_DESTROYED (parent))
1344 g_warning ("gdk_window_new(): parent is destroyed\n");
1348 display = gdk_screen_get_display (screen);
1350 window = _gdk_display_create_window (display);
1352 /* Windows with a foreign parent are treated as if they are children
1353 * of the root window, except for actual creation.
1355 real_parent = parent;
1356 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
1357 parent = gdk_screen_get_root_window (screen);
1359 window->parent = parent;
1361 window->accept_focus = TRUE;
1362 window->focus_on_map = TRUE;
1364 if (attributes_mask & GDK_WA_X)
1369 if (attributes_mask & GDK_WA_Y)
1376 window->width = (attributes->width > 1) ? (attributes->width) : (1);
1377 window->height = (attributes->height > 1) ? (attributes->height) : (1);
1379 if (attributes->wclass == GDK_INPUT_ONLY)
1381 /* Backwards compatiblity - we've always ignored
1382 * attributes->window_type for input-only windows
1385 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_ROOT)
1386 window->window_type = GDK_WINDOW_TEMP;
1388 window->window_type = GDK_WINDOW_CHILD;
1391 window->window_type = attributes->window_type;
1394 switch (window->window_type)
1396 case GDK_WINDOW_TOPLEVEL:
1397 case GDK_WINDOW_TEMP:
1398 case GDK_WINDOW_OFFSCREEN:
1399 if (GDK_WINDOW_TYPE (parent) != GDK_WINDOW_ROOT)
1400 g_warning (G_STRLOC "Toplevel windows must be created as children of\n"
1401 "of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
1402 case GDK_WINDOW_CHILD:
1406 g_warning (G_STRLOC "cannot make windows of type %d", window->window_type);
1410 if (attributes_mask & GDK_WA_VISUAL)
1411 window->visual = attributes->visual;
1413 window->visual = gdk_screen_get_system_visual (screen);
1415 window->event_mask = attributes->event_mask;
1417 if (attributes->wclass == GDK_INPUT_OUTPUT)
1419 window->input_only = FALSE;
1420 window->depth = window->visual->depth;
1422 /* XXX: Cache this somehow? */
1423 window->background = cairo_pattern_create_rgba (0, 0, 0, 0);
1424 window->has_alpha_background = TRUE;
1429 window->input_only = TRUE;
1433 window->parent->children = g_list_prepend (window->parent->children, window);
1436 if (window->parent->window_type == GDK_WINDOW_ROOT)
1437 native = TRUE; /* Always use native windows for toplevels */
1438 else if (!window->input_only &&
1439 (attributes_mask & GDK_WA_VISUAL &&
1440 attributes->visual != gdk_window_get_visual (window->parent)))
1441 native = TRUE; /* InputOutput window with different visual than parent, needs native window */
1443 if (gdk_window_is_offscreen (window))
1445 _gdk_offscreen_window_new (window, attributes, attributes_mask);
1446 window->impl_window = window;
1450 event_mask = get_native_event_mask (window);
1452 /* Create the impl */
1453 _gdk_display_create_window_impl (display, window, real_parent, screen, event_mask, attributes, attributes_mask);
1454 window->impl_window = window;
1456 /* This will put the native window topmost in the native parent, which may
1457 * be wrong wrt other native windows in the non-native hierarchy, so restack */
1458 if (!_gdk_window_has_impl (real_parent))
1459 sync_native_window_stack_position (window);
1463 window->impl_window = g_object_ref (window->parent->impl_window);
1464 window->impl = g_object_ref (window->impl_window->impl);
1467 recompute_visible_regions (window, TRUE, FALSE);
1469 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
1470 (attributes->cursor) :
1473 device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent));
1474 g_signal_connect (device_manager, "device-removed",
1475 G_CALLBACK (device_removed_cb), window);
1481 is_parent_of (GdkWindow *parent,
1492 w = gdk_window_get_parent (w);
1499 change_impl (GdkWindow *private,
1500 GdkWindow *impl_window,
1505 GdkWindowImpl *old_impl;
1506 GdkWindow *old_impl_window;
1508 old_impl = private->impl;
1509 old_impl_window = private->impl_window;
1510 if (private != impl_window)
1511 private->impl_window = g_object_ref (impl_window);
1513 private->impl_window = private;
1514 private->impl = g_object_ref (new);
1515 if (old_impl_window != private)
1516 g_object_unref (old_impl_window);
1517 g_object_unref (old_impl);
1519 for (l = private->children; l != NULL; l = l->next)
1523 if (child->impl == old_impl)
1524 change_impl (child, impl_window, new);
1529 reparent_to_impl (GdkWindow *private)
1534 GdkWindowImplClass *impl_class;
1536 impl_class = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1538 /* Enumerate in reverse order so we get the right order for the native
1539 windows (first in childrens list is topmost, and reparent places on top) */
1540 for (l = g_list_last (private->children); l != NULL; l = l->prev)
1544 if (child->impl == private->impl)
1545 reparent_to_impl (child);
1548 show = impl_class->reparent ((GdkWindow *)child,
1549 (GdkWindow *)private,
1550 child->x, child->y);
1552 gdk_window_show_unraised ((GdkWindow *)child);
1559 * gdk_window_reparent:
1560 * @window: a #GdkWindow
1561 * @new_parent: new parent to move @window into
1562 * @x: X location inside the new parent
1563 * @y: Y location inside the new parent
1565 * Reparents @window into the given @new_parent. The window being
1566 * reparented will be unmapped as a side effect.
1570 gdk_window_reparent (GdkWindow *window,
1571 GdkWindow *new_parent,
1575 GdkWindow *old_parent;
1577 gboolean show, was_mapped, applied_clip_as_shape;
1578 gboolean do_reparent_to_impl;
1579 GdkEventMask old_native_event_mask;
1580 GdkWindowImplClass *impl_class;
1582 g_return_if_fail (GDK_IS_WINDOW (window));
1583 g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1584 g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1586 if (GDK_WINDOW_DESTROYED (window) ||
1587 (new_parent && GDK_WINDOW_DESTROYED (new_parent)))
1590 screen = gdk_window_get_screen (window);
1592 new_parent = gdk_screen_get_root_window (screen);
1594 /* No input-output children of input-only windows */
1595 if (new_parent->input_only && !window->input_only)
1598 /* Don't create loops in hierarchy */
1599 if (is_parent_of (window, new_parent))
1602 /* This might be wrong in the new parent, e.g. for non-native surfaces.
1603 To make sure we're ok, just wipe it. */
1604 gdk_window_drop_cairo_surface (window);
1606 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1607 old_parent = window->parent;
1609 was_mapped = GDK_WINDOW_IS_MAPPED (window);
1612 /* Reparenting to toplevel. Ensure we have a native window so this can work */
1613 if (new_parent->window_type == GDK_WINDOW_ROOT ||
1614 new_parent->window_type == GDK_WINDOW_FOREIGN)
1615 gdk_window_ensure_native (window);
1617 applied_clip_as_shape = should_apply_clip_as_shape (window);
1619 old_native_event_mask = 0;
1620 do_reparent_to_impl = FALSE;
1621 if (gdk_window_has_impl (window))
1623 old_native_event_mask = get_native_event_mask (window);
1625 show = impl_class->reparent (window, new_parent, x, y);
1629 /* This shouldn't happen, as we created a native in this case, check anyway to see if that ever fails */
1630 g_assert (new_parent->window_type != GDK_WINDOW_ROOT &&
1631 new_parent->window_type != GDK_WINDOW_FOREIGN);
1634 gdk_window_hide (window);
1636 do_reparent_to_impl = TRUE;
1637 change_impl (window,
1638 new_parent->impl_window,
1642 /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1645 if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1647 new_parent = gdk_screen_get_root_window (screen);
1651 old_parent->children = g_list_remove (old_parent->children, window);
1653 window->parent = new_parent;
1657 new_parent->children = g_list_prepend (new_parent->children, window);
1659 /* Switch the window type as appropriate */
1661 switch (GDK_WINDOW_TYPE (new_parent))
1663 case GDK_WINDOW_ROOT:
1664 case GDK_WINDOW_FOREIGN:
1665 if (window->toplevel_window_type != -1)
1666 GDK_WINDOW_TYPE (window) = window->toplevel_window_type;
1667 else if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
1668 GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
1670 case GDK_WINDOW_OFFSCREEN:
1671 case GDK_WINDOW_TOPLEVEL:
1672 case GDK_WINDOW_CHILD:
1673 case GDK_WINDOW_TEMP:
1674 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
1675 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
1677 /* Save the original window type so we can restore it if the
1678 * window is reparented back to be a toplevel
1680 window->toplevel_window_type = GDK_WINDOW_TYPE (window);
1681 GDK_WINDOW_TYPE (window) = GDK_WINDOW_CHILD;
1685 /* We might have changed window type for a native windows, so we
1686 need to change the event mask too. */
1687 if (gdk_window_has_impl (window))
1689 GdkEventMask native_event_mask = get_native_event_mask (window);
1691 if (native_event_mask != old_native_event_mask)
1692 impl_class->set_events (window, native_event_mask);
1695 _gdk_window_update_viewable (window);
1697 if (window->background == NULL)
1699 /* parent relative background, update has_alpha_background */
1700 if (window->parent == NULL ||
1701 window->parent->window_type == GDK_WINDOW_ROOT)
1702 window->has_alpha_background = FALSE;
1704 window->has_alpha_background = window->parent->has_alpha_background;
1707 recompute_visible_regions (window, TRUE, FALSE);
1708 if (old_parent && GDK_WINDOW_TYPE (old_parent) != GDK_WINDOW_ROOT)
1709 recompute_visible_regions (old_parent, FALSE, TRUE);
1711 _gdk_window_propagate_has_alpha_background (window);
1713 /* We used to apply the clip as the shape, but no more.
1714 Reset this to the real shape */
1715 if (gdk_window_has_impl (window) &&
1716 applied_clip_as_shape &&
1717 !should_apply_clip_as_shape (window))
1718 apply_shape (window, window->shape);
1720 if (do_reparent_to_impl)
1721 reparent_to_impl (window);
1724 /* The reparent will have put the native window topmost in the native parent,
1725 * which may be wrong wrt other native windows in the non-native hierarchy,
1727 if (!gdk_window_has_impl (new_parent))
1728 sync_native_window_stack_position (window);
1732 gdk_window_show_unraised (window);
1734 _gdk_synthesize_crossing_events_for_geometry_change (window);
1738 * gdk_window_ensure_native:
1739 * @window: a #GdkWindow
1741 * Tries to ensure that there is a window-system native window for this
1742 * GdkWindow. This may fail in some situations, returning %FALSE.
1744 * Offscreen window and children of them can never have native windows.
1746 * Some backends may not support native child windows.
1748 * Returns: %TRUE if the window has a native window, %FALSE otherwise
1753 gdk_window_ensure_native (GdkWindow *window)
1755 GdkWindow *impl_window;
1756 GdkWindowImpl *new_impl, *old_impl;
1757 GdkDisplay *display;
1761 GdkWindowImplClass *impl_class;
1763 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
1765 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_ROOT ||
1766 GDK_WINDOW_DESTROYED (window))
1769 impl_window = gdk_window_get_impl_window (window);
1771 if (gdk_window_is_offscreen (impl_window))
1772 return FALSE; /* native in offscreens not supported */
1774 if (impl_window == window)
1775 /* Already has an impl, and its not offscreen . */
1778 /* Need to create a native window */
1780 gdk_window_drop_cairo_surface (window);
1782 screen = gdk_window_get_screen (window);
1783 display = gdk_screen_get_display (screen);
1785 old_impl = window->impl;
1786 _gdk_display_create_window_impl (display,
1787 window, window->parent,
1789 get_native_event_mask (window),
1791 new_impl = window->impl;
1793 window->impl = old_impl;
1794 change_impl (window, window, new_impl);
1796 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1798 /* Native window creation will put the native window topmost in the
1799 * native parent, which may be wrong wrt the position of the previous
1800 * non-native window wrt to the other non-native children, so correct this.
1802 above = find_native_sibling_above (window->parent, window);
1805 listhead.data = window;
1806 listhead.prev = NULL;
1807 listhead.next = NULL;
1808 impl_class->restack_under ((GdkWindow *)above, &listhead);
1811 recompute_visible_regions (window, FALSE, FALSE);
1813 /* The shape may not have been set, as the clip region doesn't actually
1814 change, so do it here manually */
1815 if (should_apply_clip_as_shape (window))
1816 apply_clip_as_shape (window);
1818 reparent_to_impl (window);
1820 if (!window->input_only)
1821 impl_class->set_background (window, window->background);
1823 impl_class->input_shape_combine_region (window,
1824 window->input_shape,
1827 if (gdk_window_is_viewable (window))
1828 impl_class->show (window, FALSE);
1834 * _gdk_event_filter_unref:
1835 * @window: (allow-none): A #GdkWindow, or %NULL to be the global window
1836 * @filter: A window filter
1838 * Release a reference to @filter. Note this function may
1839 * mutate the list storage, so you need to handle this
1840 * if iterating over a list of filters.
1843 _gdk_event_filter_unref (GdkWindow *window,
1844 GdkEventFilter *filter)
1850 filters = &_gdk_default_filters;
1852 filters = &window->filters;
1854 tmp_list = *filters;
1857 GdkEventFilter *iter_filter = tmp_list->data;
1861 tmp_list = tmp_list->next;
1863 if (iter_filter != filter)
1866 g_assert (iter_filter->ref_count > 0);
1868 filter->ref_count--;
1869 if (filter->ref_count != 0)
1872 *filters = g_list_remove_link (*filters, node);
1874 g_list_free_1 (node);
1879 window_remove_filters (GdkWindow *window)
1881 while (window->filters)
1882 _gdk_event_filter_unref (window, window->filters->data);
1886 update_pointer_info_foreach (GdkDisplay *display,
1888 GdkPointerWindowInfo *pointer_info,
1891 GdkWindow *window = user_data;
1893 if (pointer_info->toplevel_under_pointer == window)
1895 g_object_unref (pointer_info->toplevel_under_pointer);
1896 pointer_info->toplevel_under_pointer = NULL;
1901 window_remove_from_pointer_info (GdkWindow *window,
1902 GdkDisplay *display)
1904 _gdk_display_pointer_info_foreach (display,
1905 update_pointer_info_foreach,
1910 * _gdk_window_destroy_hierarchy:
1911 * @window: a #GdkWindow
1912 * @recursing: If TRUE, then this is being called because a parent
1914 * @recursing_native: If TRUE, then this is being called because a native parent
1915 * was destroyed. This generally means that the call to the
1916 * windowing system to destroy the window can be omitted, since
1917 * it will be destroyed as a result of the parent being destroyed.
1918 * Unless @foreign_destroy.
1919 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
1920 * external agency. The window has already been destroyed and no
1921 * windowing system calls should be made. (This may never happen
1922 * for some windowing systems.)
1924 * Internal function to destroy a window. Like gdk_window_destroy(),
1925 * but does not drop the reference count created by gdk_window_new().
1928 _gdk_window_destroy_hierarchy (GdkWindow *window,
1930 gboolean recursing_native,
1931 gboolean foreign_destroy)
1933 GdkWindowImplClass *impl_class;
1934 GdkWindow *temp_window;
1936 GdkDisplay *display;
1940 g_return_if_fail (GDK_IS_WINDOW (window));
1942 if (GDK_WINDOW_DESTROYED (window))
1945 display = gdk_window_get_display (window);
1946 screen = gdk_window_get_screen (window);
1947 temp_window = g_object_get_qdata (G_OBJECT (screen), quark_pointer_window);
1948 if (temp_window == window)
1949 g_object_set_qdata (G_OBJECT (screen), quark_pointer_window, NULL);
1952 switch (window->window_type)
1954 case GDK_WINDOW_ROOT:
1955 if (!screen->closed)
1957 g_error ("attempted to destroy root window");
1960 /* else fall thru */
1961 case GDK_WINDOW_TOPLEVEL:
1962 case GDK_WINDOW_CHILD:
1963 case GDK_WINDOW_TEMP:
1964 case GDK_WINDOW_FOREIGN:
1965 case GDK_WINDOW_OFFSCREEN:
1966 if (window->window_type == GDK_WINDOW_FOREIGN && !foreign_destroy)
1968 /* Logically, it probably makes more sense to send
1969 * a "destroy yourself" message to the foreign window
1970 * whether or not it's in our hierarchy; but for historical
1971 * reasons, we only send "destroy yourself" messages to
1972 * foreign windows in our hierarchy.
1976 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1978 if (gdk_window_has_impl (window))
1979 impl_class->destroy_foreign (window);
1982 /* Also for historical reasons, we remove any filters
1983 * on a foreign window when it or a parent is destroyed;
1984 * this likely causes problems if two separate portions
1985 * of code are maintaining filter lists on a foreign window.
1987 window_remove_filters (window);
1993 if (window->parent->children)
1994 window->parent->children = g_list_remove (window->parent->children, window);
1997 GDK_WINDOW_IS_MAPPED (window))
1999 recompute_visible_regions (window, TRUE, FALSE);
2000 gdk_window_invalidate_in_parent (window);
2004 gdk_window_free_paint_stack (window);
2006 if (window->background)
2008 cairo_pattern_destroy (window->background);
2009 window->background = NULL;
2012 if (window->window_type == GDK_WINDOW_FOREIGN)
2013 g_assert (window->children == NULL);
2016 children = tmp = window->children;
2017 window->children = NULL;
2021 temp_window = tmp->data;
2025 _gdk_window_destroy_hierarchy (temp_window,
2027 recursing_native || gdk_window_has_impl (window),
2031 g_list_free (children);
2034 _gdk_window_clear_update_area (window);
2036 gdk_window_drop_cairo_surface (window);
2038 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
2040 if (gdk_window_has_impl (window))
2041 impl_class->destroy (window, recursing_native,
2045 /* hide to make sure we repaint and break grabs */
2046 gdk_window_hide (window);
2049 window->state |= GDK_WINDOW_STATE_WITHDRAWN;
2050 window->parent = NULL;
2051 window->destroyed = TRUE;
2053 window_remove_filters (window);
2055 window_remove_from_pointer_info (window, display);
2057 if (window->clip_region)
2059 cairo_region_destroy (window->clip_region);
2060 window->clip_region = NULL;
2063 if (window->clip_region_with_children)
2065 cairo_region_destroy (window->clip_region_with_children);
2066 window->clip_region_with_children = NULL;
2069 g_list_free_full (window->outstanding_moves, (GDestroyNotify) gdk_window_region_move_free);
2070 window->outstanding_moves = NULL;
2077 * _gdk_window_destroy:
2078 * @window: a #GdkWindow
2079 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
2080 * external agency. The window has already been destroyed and no
2081 * windowing system calls should be made. (This may never happen
2082 * for some windowing systems.)
2084 * Internal function to destroy a window. Like gdk_window_destroy(),
2085 * but does not drop the reference count created by gdk_window_new().
2088 _gdk_window_destroy (GdkWindow *window,
2089 gboolean foreign_destroy)
2091 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, foreign_destroy);
2095 * gdk_window_destroy:
2096 * @window: a #GdkWindow
2098 * Destroys the window system resources associated with @window and decrements @window's
2099 * reference count. The window system resources for all children of @window are also
2100 * destroyed, but the children's reference counts are not decremented.
2102 * Note that a window will not be destroyed automatically when its reference count
2103 * reaches zero. You must call this function yourself before that happens.
2107 gdk_window_destroy (GdkWindow *window)
2109 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, FALSE);
2110 g_object_unref (window);
2114 * gdk_window_set_user_data:
2115 * @window: a #GdkWindow
2116 * @user_data: (allow-none) (type GObject.Object): user data
2118 * For most purposes this function is deprecated in favor of
2119 * g_object_set_data(). However, for historical reasons GTK+ stores
2120 * the #GtkWidget that owns a #GdkWindow as user data on the
2121 * #GdkWindow. So, custom widget implementations should use
2122 * this function for that. If GTK+ receives an event for a #GdkWindow,
2123 * and the user data for the window is non-%NULL, GTK+ will assume the
2124 * user data is a #GtkWidget, and forward the event to that widget.
2128 gdk_window_set_user_data (GdkWindow *window,
2131 g_return_if_fail (GDK_IS_WINDOW (window));
2133 window->user_data = user_data;
2137 * gdk_window_get_user_data:
2138 * @window: a #GdkWindow
2139 * @data: (out): return location for user data
2141 * Retrieves the user data for @window, which is normally the widget
2142 * that @window belongs to. See gdk_window_set_user_data().
2146 gdk_window_get_user_data (GdkWindow *window,
2149 g_return_if_fail (GDK_IS_WINDOW (window));
2151 *data = window->user_data;
2155 * gdk_window_get_window_type:
2156 * @window: a #GdkWindow
2158 * Gets the type of the window. See #GdkWindowType.
2160 * Return value: type of window
2163 gdk_window_get_window_type (GdkWindow *window)
2165 g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
2167 return GDK_WINDOW_TYPE (window);
2171 * gdk_window_get_visual:
2172 * @window: a #GdkWindow
2174 * Gets the #GdkVisual describing the pixel format of @window.
2176 * Return value: (transfer none): a #GdkVisual
2181 gdk_window_get_visual (GdkWindow *window)
2183 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2185 return window->visual;
2189 * gdk_window_get_screen:
2190 * @window: a #GdkWindow
2192 * Gets the #GdkScreen associated with a #GdkWindow.
2194 * Return value: (transfer none): the #GdkScreen associated with @window
2199 gdk_window_get_screen (GdkWindow *window)
2201 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2203 return gdk_visual_get_screen (window->visual);
2207 * gdk_window_get_display:
2208 * @window: a #GdkWindow
2210 * Gets the #GdkDisplay associated with a #GdkWindow.
2212 * Return value: (transfer none): the #GdkDisplay associated with @window
2217 gdk_window_get_display (GdkWindow *window)
2219 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2221 return gdk_screen_get_display (gdk_visual_get_screen (window->visual));
2224 * gdk_window_is_destroyed:
2225 * @window: a #GdkWindow
2227 * Check to see if a window is destroyed..
2229 * Return value: %TRUE if the window is destroyed
2234 gdk_window_is_destroyed (GdkWindow *window)
2236 return GDK_WINDOW_DESTROYED (window);
2240 to_embedder (GdkWindow *window,
2241 gdouble offscreen_x,
2242 gdouble offscreen_y,
2243 gdouble *embedder_x,
2244 gdouble *embedder_y)
2246 g_signal_emit (window, signals[TO_EMBEDDER], 0,
2247 offscreen_x, offscreen_y,
2248 embedder_x, embedder_y);
2252 from_embedder (GdkWindow *window,
2255 gdouble *offscreen_x,
2256 gdouble *offscreen_y)
2258 g_signal_emit (window, signals[FROM_EMBEDDER], 0,
2259 embedder_x, embedder_y,
2260 offscreen_x, offscreen_y);
2264 * gdk_window_has_native:
2265 * @window: a #GdkWindow
2267 * Checks whether the window has a native window or not. Note that
2268 * you can use gdk_window_ensure_native() if a native window is needed.
2270 * Returns: %TRUE if the %window has a native window, %FALSE otherwise.
2275 gdk_window_has_native (GdkWindow *window)
2277 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2279 return window->parent == NULL || window->parent->impl != window->impl;
2283 * gdk_window_get_position:
2284 * @window: a #GdkWindow
2285 * @x: (out) (allow-none): X coordinate of window
2286 * @y: (out) (allow-none): Y coordinate of window
2288 * Obtains the position of the window as reported in the
2289 * most-recently-processed #GdkEventConfigure. Contrast with
2290 * gdk_window_get_geometry() which queries the X server for the
2291 * current window position, regardless of which events have been
2292 * received or processed.
2294 * The position coordinates are relative to the window's parent window.
2298 gdk_window_get_position (GdkWindow *window,
2302 g_return_if_fail (GDK_IS_WINDOW (window));
2311 * gdk_window_get_parent:
2312 * @window: a #GdkWindow
2314 * Obtains the parent of @window, as known to GDK. Does not query the
2315 * X server; thus this returns the parent as passed to gdk_window_new(),
2316 * not the actual parent. This should never matter unless you're using
2317 * Xlib calls mixed with GDK calls on the X11 platform. It may also
2318 * matter for toplevel windows, because the window manager may choose
2321 * Note that you should use gdk_window_get_effective_parent() when
2322 * writing generic code that walks up a window hierarchy, because
2323 * gdk_window_get_parent() will most likely not do what you expect if
2324 * there are offscreen windows in the hierarchy.
2326 * Return value: (transfer none): parent of @window
2329 gdk_window_get_parent (GdkWindow *window)
2331 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2333 return window->parent;
2337 * gdk_window_get_effective_parent:
2338 * @window: a #GdkWindow
2340 * Obtains the parent of @window, as known to GDK. Works like
2341 * gdk_window_get_parent() for normal windows, but returns the
2342 * window's embedder for offscreen windows.
2344 * See also: gdk_offscreen_window_get_embedder()
2346 * Return value: (transfer none): effective parent of @window
2351 gdk_window_get_effective_parent (GdkWindow *window)
2353 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2355 if (gdk_window_is_offscreen (window))
2356 return gdk_offscreen_window_get_embedder (window);
2358 return window->parent;
2362 * gdk_window_get_toplevel:
2363 * @window: a #GdkWindow
2365 * Gets the toplevel window that's an ancestor of @window.
2367 * Any window type but %GDK_WINDOW_CHILD is considered a
2368 * toplevel window, as is a %GDK_WINDOW_CHILD window that
2369 * has a root window as parent.
2371 * Note that you should use gdk_window_get_effective_toplevel() when
2372 * you want to get to a window's toplevel as seen on screen, because
2373 * gdk_window_get_toplevel() will most likely not do what you expect
2374 * if there are offscreen windows in the hierarchy.
2376 * Return value: (transfer none): the toplevel window containing @window
2379 gdk_window_get_toplevel (GdkWindow *window)
2381 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2383 while (window->window_type == GDK_WINDOW_CHILD)
2385 if (gdk_window_is_toplevel (window))
2387 window = window->parent;
2394 * gdk_window_get_effective_toplevel:
2395 * @window: a #GdkWindow
2397 * Gets the toplevel window that's an ancestor of @window.
2399 * Works like gdk_window_get_toplevel(), but treats an offscreen window's
2400 * embedder as its parent, using gdk_window_get_effective_parent().
2402 * See also: gdk_offscreen_window_get_embedder()
2404 * Return value: (transfer none): the effective toplevel window containing @window
2409 gdk_window_get_effective_toplevel (GdkWindow *window)
2413 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2415 while ((parent = gdk_window_get_effective_parent (window)) != NULL &&
2416 (gdk_window_get_window_type (parent) != GDK_WINDOW_ROOT))
2423 * gdk_window_get_children:
2424 * @window: a #GdkWindow
2426 * Gets the list of children of @window known to GDK.
2427 * This function only returns children created via GDK,
2428 * so for example it's useless when used with the root window;
2429 * it only returns windows an application created itself.
2431 * The returned list must be freed, but the elements in the
2434 * Return value: (transfer container) (element-type GdkWindow):
2435 * list of child windows inside @window
2438 gdk_window_get_children (GdkWindow *window)
2440 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2442 if (GDK_WINDOW_DESTROYED (window))
2445 return g_list_copy (window->children);
2449 * gdk_window_peek_children:
2450 * @window: a #GdkWindow
2452 * Like gdk_window_get_children(), but does not copy the list of
2453 * children, so the list does not need to be freed.
2455 * Return value: (transfer none) (element-type GdkWindow):
2456 * a reference to the list of child windows in @window
2459 gdk_window_peek_children (GdkWindow *window)
2461 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2463 if (GDK_WINDOW_DESTROYED (window))
2466 return window->children;
2470 * gdk_window_add_filter: (skip)
2471 * @window: (allow-none): a #GdkWindow
2472 * @function: filter callback
2473 * @data: data to pass to filter callback
2475 * Adds an event filter to @window, allowing you to intercept events
2476 * before they reach GDK. This is a low-level operation and makes it
2477 * easy to break GDK and/or GTK+, so you have to know what you're
2478 * doing. Pass %NULL for @window to get all events for all windows,
2479 * instead of events for a specific window.
2481 * If you are interested in X GenericEvents, bear in mind that
2482 * XGetEventData() has been already called on the event, and
2483 * XFreeEventData() must not be called within @function.
2486 gdk_window_add_filter (GdkWindow *window,
2487 GdkFilterFunc function,
2491 GdkEventFilter *filter;
2493 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2495 if (window && GDK_WINDOW_DESTROYED (window))
2498 /* Filters are for the native events on the native window, so
2499 ensure there is a native window. */
2501 gdk_window_ensure_native (window);
2504 tmp_list = window->filters;
2506 tmp_list = _gdk_default_filters;
2510 filter = (GdkEventFilter *)tmp_list->data;
2511 if ((filter->function == function) && (filter->data == data))
2513 filter->ref_count++;
2516 tmp_list = tmp_list->next;
2519 filter = g_new (GdkEventFilter, 1);
2520 filter->function = function;
2521 filter->data = data;
2522 filter->ref_count = 1;
2526 window->filters = g_list_append (window->filters, filter);
2528 _gdk_default_filters = g_list_append (_gdk_default_filters, filter);
2532 * gdk_window_remove_filter: (skip)
2533 * @window: a #GdkWindow
2534 * @function: previously-added filter function
2535 * @data: user data for previously-added filter function
2537 * Remove a filter previously added with gdk_window_add_filter().
2540 gdk_window_remove_filter (GdkWindow *window,
2541 GdkFilterFunc function,
2545 GdkEventFilter *filter;
2547 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2550 tmp_list = window->filters;
2552 tmp_list = _gdk_default_filters;
2556 filter = (GdkEventFilter *)tmp_list->data;
2557 tmp_list = tmp_list->next;
2559 if ((filter->function == function) && (filter->data == data))
2561 filter->flags |= GDK_EVENT_FILTER_REMOVED;
2563 _gdk_event_filter_unref (window, filter);
2571 * gdk_screen_get_toplevel_windows:
2572 * @screen: The #GdkScreen where the toplevels are located.
2574 * Obtains a list of all toplevel windows known to GDK on the screen @screen.
2575 * A toplevel window is a child of the root window (see
2576 * gdk_get_default_root_window()).
2578 * The returned list should be freed with g_list_free(), but
2579 * its elements need not be freed.
2581 * Return value: (transfer container) (element-type GdkWindow):
2582 * list of toplevel windows, free with g_list_free()
2587 gdk_screen_get_toplevel_windows (GdkScreen *screen)
2589 GdkWindow * root_window;
2590 GList *new_list = NULL;
2593 g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
2595 root_window = gdk_screen_get_root_window (screen);
2597 tmp_list = root_window->children;
2600 GdkWindow *w = tmp_list->data;
2602 if (w->window_type != GDK_WINDOW_FOREIGN)
2603 new_list = g_list_prepend (new_list, w);
2604 tmp_list = tmp_list->next;
2611 * gdk_window_is_visible:
2612 * @window: a #GdkWindow
2614 * Checks whether the window has been mapped (with gdk_window_show() or
2615 * gdk_window_show_unraised()).
2617 * Return value: %TRUE if the window is mapped
2620 gdk_window_is_visible (GdkWindow *window)
2622 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2624 return GDK_WINDOW_IS_MAPPED (window);
2628 * gdk_window_is_viewable:
2629 * @window: a #GdkWindow
2631 * Check if the window and all ancestors of the window are
2632 * mapped. (This is not necessarily "viewable" in the X sense, since
2633 * we only check as far as we have GDK window parents, not to the root
2636 * Return value: %TRUE if the window is viewable
2639 gdk_window_is_viewable (GdkWindow *window)
2641 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2643 if (window->destroyed)
2646 return window->viewable;
2650 * gdk_window_get_state:
2651 * @window: a #GdkWindow
2653 * Gets the bitwise OR of the currently active window state flags,
2654 * from the #GdkWindowState enumeration.
2656 * Return value: window state bitfield
2659 gdk_window_get_state (GdkWindow *window)
2661 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2663 return window->state;
2666 static cairo_content_t
2667 gdk_window_get_content (GdkWindow *window)
2669 cairo_surface_t *surface;
2670 cairo_content_t content;
2672 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2674 surface = _gdk_window_ref_cairo_surface (window);
2675 content = cairo_surface_get_content (surface);
2676 cairo_surface_destroy (surface);
2681 /* This creates an empty "implicit" paint region for the impl window.
2682 * By itself this does nothing, but real paints to this window
2683 * or children of it can use this surface as backing to avoid allocating
2684 * multiple surfaces for subwindow rendering. When doing so they
2685 * add to the region of the implicit paint region, which will be
2686 * pushed to the window when the implicit paint region is ended.
2687 * Such paints should not copy anything to the window on paint end, but
2688 * should rely on the implicit paint end.
2689 * The implicit paint will be automatically ended if someone draws
2690 * directly to the window or a child window.
2693 gdk_window_begin_implicit_paint (GdkWindow *window, GdkRectangle *rect)
2695 GdkWindowPaint *paint;
2697 g_assert (gdk_window_has_impl (window));
2699 if (GDK_IS_PAINTABLE (window->impl))
2700 return FALSE; /* Implementation does double buffering */
2702 if (window->paint_stack != NULL ||
2703 window->implicit_paint != NULL)
2704 return FALSE; /* Don't stack implicit paints */
2706 /* Never do implicit paints for foreign windows, they don't need
2707 * double buffer combination since they have no client side children,
2708 * and creating surfaces for them is risky since they could disappear
2711 if (window->window_type == GDK_WINDOW_FOREIGN)
2714 paint = g_new (GdkWindowPaint, 1);
2715 paint->region = cairo_region_create (); /* Empty */
2716 paint->uses_implicit = FALSE;
2717 paint->flushed = NULL;
2718 paint->surface = gdk_window_create_similar_surface (window,
2719 gdk_window_get_content (window),
2720 MAX (rect->width, 1),
2721 MAX (rect->height, 1));
2722 cairo_surface_set_device_offset (paint->surface, -rect->x, -rect->y);
2724 window->implicit_paint = paint;
2729 static cairo_surface_t *
2730 gdk_window_ref_impl_surface (GdkWindow *window)
2732 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->ref_cairo_surface (gdk_window_get_impl_window (window));
2736 gdk_cairo_create_for_impl (GdkWindow *window)
2738 cairo_surface_t *surface;
2741 surface = gdk_window_ref_impl_surface (window);
2742 cr = cairo_create (surface);
2744 cairo_surface_destroy (surface);
2749 /* Ensure that all content related to this (sub)window is pushed to the
2750 native region. If there is an active paint then that area is not
2751 pushed, in order to not show partially finished double buffers. */
2753 gdk_window_flush_implicit_paint (GdkWindow *window)
2755 GdkWindow *impl_window;
2756 GdkWindowPaint *paint;
2757 cairo_region_t *region;
2760 impl_window = gdk_window_get_impl_window (window);
2761 if (impl_window->implicit_paint == NULL)
2764 paint = impl_window->implicit_paint;
2765 region = cairo_region_copy (window->clip_region_with_children);
2767 cairo_region_translate (region, window->abs_x, window->abs_y);
2768 cairo_region_intersect (region, paint->region);
2770 /* Don't flush active double buffers, as that may show partially done
2772 for (list = window->paint_stack; list != NULL; list = list->next)
2774 GdkWindowPaint *tmp_paint = list->data;
2776 cairo_region_subtract (region, tmp_paint->region);
2779 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (region))
2783 /* Remove flushed region from the implicit paint */
2784 cairo_region_subtract (paint->region, region);
2786 /* Some regions are valid, push these to window now */
2787 cr = gdk_cairo_create_for_impl (window);
2788 gdk_cairo_region (cr, region);
2790 cairo_set_source_surface (cr, paint->surface, 0, 0);
2791 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2795 paint->flushed = region;
2798 cairo_region_destroy (region);
2801 /* Ends an implicit paint, paired with gdk_window_begin_implicit_paint returning TRUE */
2803 gdk_window_end_implicit_paint (GdkWindow *window)
2805 GdkWindowPaint *paint;
2807 g_assert (gdk_window_has_impl (window));
2809 g_assert (window->implicit_paint != NULL);
2811 paint = window->implicit_paint;
2813 window->implicit_paint = NULL;
2815 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (paint->region))
2819 /* Some regions are valid, push these to window now */
2820 cr = gdk_cairo_create_for_impl (window);
2821 gdk_cairo_region (cr, paint->region);
2823 cairo_set_source_surface (cr, paint->surface, 0, 0);
2824 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2829 cairo_region_destroy (paint->region);
2831 cairo_region_destroy (paint->flushed);
2832 cairo_surface_destroy (paint->surface);
2837 * gdk_window_begin_paint_rect:
2838 * @window: a #GdkWindow
2839 * @rectangle: rectangle you intend to draw to
2841 * A convenience wrapper around gdk_window_begin_paint_region() which
2842 * creates a rectangular region for you. See
2843 * gdk_window_begin_paint_region() for details.
2847 gdk_window_begin_paint_rect (GdkWindow *window,
2848 const GdkRectangle *rectangle)
2850 cairo_region_t *region;
2852 g_return_if_fail (GDK_IS_WINDOW (window));
2854 region = cairo_region_create_rectangle (rectangle);
2855 gdk_window_begin_paint_region (window, region);
2856 cairo_region_destroy (region);
2860 * gdk_window_begin_paint_region:
2861 * @window: a #GdkWindow
2862 * @region: region you intend to draw to
2864 * Indicates that you are beginning the process of redrawing @region.
2865 * A backing store (offscreen buffer) large enough to contain @region
2866 * will be created. The backing store will be initialized with the
2867 * background color or background surface for @window. Then, all
2868 * drawing operations performed on @window will be diverted to the
2869 * backing store. When you call gdk_window_end_paint(), the backing
2870 * store will be copied to @window, making it visible onscreen. Only
2871 * the part of @window contained in @region will be modified; that is,
2872 * drawing operations are clipped to @region.
2874 * The net result of all this is to remove flicker, because the user
2875 * sees the finished product appear all at once when you call
2876 * gdk_window_end_paint(). If you draw to @window directly without
2877 * calling gdk_window_begin_paint_region(), the user may see flicker
2878 * as individual drawing operations are performed in sequence. The
2879 * clipping and background-initializing features of
2880 * gdk_window_begin_paint_region() are conveniences for the
2881 * programmer, so you can avoid doing that work yourself.
2883 * When using GTK+, the widget system automatically places calls to
2884 * gdk_window_begin_paint_region() and gdk_window_end_paint() around
2885 * emissions of the expose_event signal. That is, if you're writing an
2886 * expose event handler, you can assume that the exposed area in
2887 * #GdkEventExpose has already been cleared to the window background,
2888 * is already set as the clip region, and already has a backing store.
2889 * Therefore in most cases, application code need not call
2890 * gdk_window_begin_paint_region(). (You can disable the automatic
2891 * calls around expose events on a widget-by-widget basis by calling
2892 * gtk_widget_set_double_buffered().)
2894 * If you call this function multiple times before calling the
2895 * matching gdk_window_end_paint(), the backing stores are pushed onto
2896 * a stack. gdk_window_end_paint() copies the topmost backing store
2897 * onscreen, subtracts the topmost region from all other regions in
2898 * the stack, and pops the stack. All drawing operations affect only
2899 * the topmost backing store in the stack. One matching call to
2900 * gdk_window_end_paint() is required for each call to
2901 * gdk_window_begin_paint_region().
2905 gdk_window_begin_paint_region (GdkWindow *window,
2906 const cairo_region_t *region)
2908 #ifdef USE_BACKING_STORE
2909 GdkRectangle clip_box;
2910 GdkWindowPaint *paint, *implicit_paint;
2911 GdkWindow *impl_window;
2914 g_return_if_fail (GDK_IS_WINDOW (window));
2916 if (GDK_WINDOW_DESTROYED (window))
2919 if (GDK_IS_PAINTABLE (window->impl))
2921 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2923 if (iface->begin_paint_region)
2924 iface->begin_paint_region ((GdkPaintable*)window->impl, window, region);
2929 impl_window = gdk_window_get_impl_window (window);
2930 implicit_paint = impl_window->implicit_paint;
2932 paint = g_new (GdkWindowPaint, 1);
2933 paint->region = cairo_region_copy (region);
2935 cairo_region_intersect (paint->region, window->clip_region_with_children);
2936 cairo_region_get_extents (paint->region, &clip_box);
2938 cairo_region_translate (paint->region, window->abs_x, window->abs_y);
2940 /* Mark the region as valid on the implicit paint */
2943 cairo_region_union (implicit_paint->region, paint->region);
2945 /* Convert back to normal coords */
2946 cairo_region_translate (paint->region, -window->abs_x, -window->abs_y);
2950 paint->uses_implicit = TRUE;
2951 paint->surface = cairo_surface_create_for_rectangle (implicit_paint->surface,
2952 window->abs_x + clip_box.x,
2953 window->abs_y + clip_box.y,
2954 MAX (clip_box.width, 1),
2955 MAX (clip_box.height, 1));
2959 paint->uses_implicit = FALSE;
2960 paint->surface = gdk_window_create_similar_surface (window,
2961 gdk_window_get_content (window),
2962 MAX (clip_box.width, 1),
2963 MAX (clip_box.height, 1));
2966 /* Normally alpha backgrounded client side windows are composited on the implicit paint
2967 by being drawn in back to front order. However, if implicit paints are not used, for
2968 instance if it was flushed due to a non-double-buffered paint in the middle of the
2969 expose we need to copy in the existing data here. */
2970 if (!gdk_window_has_impl (window) &&
2971 window->has_alpha_background &&
2973 (implicit_paint && implicit_paint->flushed != NULL && !cairo_region_is_empty (implicit_paint->flushed))))
2975 cairo_t *cr = cairo_create (paint->surface);
2976 /* We can't use gdk_cairo_set_source_window here, as that might
2977 flush the implicit paint at an unfortunate time, since this
2978 would be detected as a draw during non-expose time */
2979 cairo_surface_t *source_surface = gdk_window_ref_impl_surface (impl_window);
2980 cairo_set_source_surface (cr, source_surface,
2981 - (window->abs_x + clip_box.x),
2982 - (window->abs_y + clip_box.y));
2983 cairo_surface_destroy (source_surface);
2985 /* Only read back the flushed area if any */
2988 cairo_region_t *flushed = cairo_region_copy (implicit_paint->flushed);
2989 cairo_region_intersect (flushed, region);
2990 /* Convert from impl coords */
2991 cairo_region_translate (flushed, -window->abs_x, -window->abs_y);
2992 gdk_cairo_region (cr, flushed);
2995 /* Convert to impl coords */
2996 cairo_region_translate (flushed, window->abs_x, window->abs_y);
2997 cairo_region_subtract (implicit_paint->flushed, flushed);
2998 cairo_region_destroy (flushed);
3004 cairo_surface_set_device_offset (paint->surface, -clip_box.x, -clip_box.y);
3006 for (list = window->paint_stack; list != NULL; list = list->next)
3008 GdkWindowPaint *tmp_paint = list->data;
3010 cairo_region_subtract (tmp_paint->region, paint->region);
3013 window->paint_stack = g_slist_prepend (window->paint_stack, paint);
3015 if (!cairo_region_is_empty (paint->region))
3017 gdk_window_clear_backing_region (window,
3021 #endif /* USE_BACKING_STORE */
3025 * gdk_window_end_paint:
3026 * @window: a #GdkWindow
3028 * Indicates that the backing store created by the most recent call to
3029 * gdk_window_begin_paint_region() should be copied onscreen and
3030 * deleted, leaving the next-most-recent backing store or no backing
3031 * store at all as the active paint region. See
3032 * gdk_window_begin_paint_region() for full details. It is an error to
3033 * call this function without a matching
3034 * gdk_window_begin_paint_region() first.
3038 gdk_window_end_paint (GdkWindow *window)
3040 #ifdef USE_BACKING_STORE
3041 GdkWindow *composited;
3042 GdkWindowPaint *paint;
3043 GdkRectangle clip_box;
3044 cairo_region_t *full_clip;
3046 g_return_if_fail (GDK_IS_WINDOW (window));
3048 if (GDK_WINDOW_DESTROYED (window))
3051 if (GDK_IS_PAINTABLE (window->impl))
3053 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
3055 if (iface->end_paint)
3056 iface->end_paint ((GdkPaintable*)window->impl);
3060 if (window->paint_stack == NULL)
3062 g_warning (G_STRLOC": no preceding call to gdk_window_begin_paint_region(), see documentation");
3066 paint = window->paint_stack->data;
3068 window->paint_stack = g_slist_delete_link (window->paint_stack,
3069 window->paint_stack);
3071 cairo_region_get_extents (paint->region, &clip_box);
3073 if (!paint->uses_implicit)
3077 gdk_window_flush_outstanding_moves (window);
3079 full_clip = cairo_region_copy (window->clip_region_with_children);
3080 cairo_region_intersect (full_clip, paint->region);
3082 cr = gdk_cairo_create (window);
3083 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
3084 cairo_set_source_surface (cr, paint->surface, 0, 0);
3085 gdk_cairo_region (cr, full_clip);
3089 cairo_region_destroy (full_clip);
3092 cairo_surface_destroy (paint->surface);
3093 cairo_region_destroy (paint->region);
3096 /* find a composited window in our hierarchy to signal its
3097 * parent to redraw, calculating the clip box as we go...
3099 * stop if parent becomes NULL since then we'd have nowhere
3100 * to draw (ie: 'composited' will always be non-NULL here).
3102 for (composited = window;
3104 composited = composited->parent)
3106 clip_box.x += composited->x;
3107 clip_box.y += composited->y;
3108 clip_box.width = MIN (clip_box.width, composited->parent->width - clip_box.x);
3109 clip_box.height = MIN (clip_box.height, composited->parent->height - clip_box.y);
3111 if (composited->composited)
3113 gdk_window_invalidate_rect (GDK_WINDOW (composited->parent),
3118 #endif /* USE_BACKING_STORE */
3122 gdk_window_free_paint_stack (GdkWindow *window)
3124 if (window->paint_stack)
3126 GSList *tmp_list = window->paint_stack;
3130 GdkWindowPaint *paint = tmp_list->data;
3132 if (tmp_list == window->paint_stack)
3133 cairo_surface_destroy (paint->surface);
3135 cairo_region_destroy (paint->region);
3138 tmp_list = tmp_list->next;
3141 g_slist_free (window->paint_stack);
3142 window->paint_stack = NULL;
3147 do_move_region_bits_on_impl (GdkWindow *impl_window,
3148 cairo_region_t *dest_region, /* In impl window coords */
3151 GdkWindowImplClass *impl_class;
3153 impl_class = GDK_WINDOW_IMPL_GET_CLASS (impl_window->impl);
3155 impl_class->translate (impl_window, dest_region, dx, dy);
3158 static GdkWindowRegionMove *
3159 gdk_window_region_move_new (cairo_region_t *region,
3162 GdkWindowRegionMove *move;
3164 move = g_slice_new (GdkWindowRegionMove);
3165 move->dest_region = cairo_region_copy (region);
3173 gdk_window_region_move_free (GdkWindowRegionMove *move)
3175 cairo_region_destroy (move->dest_region);
3176 g_slice_free (GdkWindowRegionMove, move);
3180 append_move_region (GdkWindow *impl_window,
3181 cairo_region_t *new_dest_region,
3184 GdkWindowRegionMove *move, *old_move;
3185 cairo_region_t *new_total_region, *old_total_region;
3186 cairo_region_t *source_overlaps_destination;
3187 cairo_region_t *non_overwritten;
3188 gboolean added_move;
3191 if (cairo_region_is_empty (new_dest_region))
3194 /* In principle this could just append the move to the list of outstanding
3195 moves that will be replayed before drawing anything when we're handling
3196 exposes. However, we'd like to do a bit better since its commonly the case
3197 that we get multiple copies where A is copied to B and then B is copied
3198 to C, and we'd like to express this as a simple copy A to C operation. */
3200 /* We approach this by taking the new move and pushing it ahead of moves
3201 starting at the end of the list and stopping when its not safe to do so.
3202 It's not safe to push past a move if either the source of the new move
3203 is in the destination of the old move, or if the destination of the new
3204 move is in the source of the new move, or if the destination of the new
3205 move overlaps the destination of the old move. We simplify this by
3206 just comparing the total regions (src + dest) */
3207 new_total_region = cairo_region_copy (new_dest_region);
3208 cairo_region_translate (new_total_region, -dx, -dy);
3209 cairo_region_union (new_total_region, new_dest_region);
3212 for (l = g_list_last (impl_window->outstanding_moves); l != NULL; l = prev)
3217 old_total_region = cairo_region_copy (old_move->dest_region);
3218 cairo_region_translate (old_total_region, -old_move->dx, -old_move->dy);
3219 cairo_region_union (old_total_region, old_move->dest_region);
3221 cairo_region_intersect (old_total_region, new_total_region);
3222 /* If these regions intersect then its not safe to push the
3223 new region before the old one */
3224 if (!cairo_region_is_empty (old_total_region))
3226 /* The area where the new moves source overlaps the old ones
3228 source_overlaps_destination = cairo_region_copy (new_dest_region);
3229 cairo_region_translate (source_overlaps_destination, -dx, -dy);
3230 cairo_region_intersect (source_overlaps_destination, old_move->dest_region);
3231 cairo_region_translate (source_overlaps_destination, dx, dy);
3233 /* We can do all sort of optimizations here, but to do things safely it becomes
3234 quite complicated. However, a very common case is that you copy something first,
3235 then copy all that or a subset of it to a new location (i.e. if you scroll twice
3236 in the same direction). We'd like to detect this case and optimize it to one
3238 if (cairo_region_equal (source_overlaps_destination, new_dest_region))
3240 /* This means we might be able to replace the old move and the new one
3241 with the new one read from the old ones source, and a second copy of
3242 the non-overwritten parts of the old move. However, such a split
3243 is only valid if the source in the old move isn't overwritten
3244 by the destination of the new one */
3246 /* the new destination of old move if split is ok: */
3247 non_overwritten = cairo_region_copy (old_move->dest_region);
3248 cairo_region_subtract (non_overwritten, new_dest_region);
3249 /* move to source region */
3250 cairo_region_translate (non_overwritten, -old_move->dx, -old_move->dy);
3252 cairo_region_intersect (non_overwritten, new_dest_region);
3253 if (cairo_region_is_empty (non_overwritten))
3256 move = gdk_window_region_move_new (new_dest_region,
3260 impl_window->outstanding_moves =
3261 g_list_insert_before (impl_window->outstanding_moves,
3263 cairo_region_subtract (old_move->dest_region, new_dest_region);
3265 cairo_region_destroy (non_overwritten);
3268 cairo_region_destroy (source_overlaps_destination);
3269 cairo_region_destroy (old_total_region);
3272 cairo_region_destroy (old_total_region);
3275 cairo_region_destroy (new_total_region);
3279 move = gdk_window_region_move_new (new_dest_region, dx, dy);
3282 impl_window->outstanding_moves =
3283 g_list_prepend (impl_window->outstanding_moves,
3286 impl_window->outstanding_moves =
3287 g_list_insert_before (impl_window->outstanding_moves,
3292 /* Moves bits and update area by dx/dy in impl window.
3293 Takes ownership of region to avoid copy (because we may change it) */
3295 move_region_on_impl (GdkWindow *impl_window,
3296 cairo_region_t *region, /* In impl window coords */
3299 if ((dx == 0 && dy == 0) ||
3300 cairo_region_is_empty (region))
3302 cairo_region_destroy (region);
3306 g_assert (impl_window == gdk_window_get_impl_window (impl_window));
3308 /* Move any old invalid regions in the copy source area by dx/dy */
3309 if (impl_window->update_area)
3311 cairo_region_t *update_area;
3313 update_area = cairo_region_copy (region);
3315 /* Convert from target to source */
3316 cairo_region_translate (update_area, -dx, -dy);
3317 cairo_region_intersect (update_area, impl_window->update_area);
3318 /* We only copy the area, so keep the old update area invalid.
3319 It would be safe to remove it too, as code that uses
3320 move_region_on_impl generally also invalidate the source
3321 area. However, it would just use waste cycles. */
3324 cairo_region_translate (update_area, dx, dy);
3325 cairo_region_union (impl_window->update_area, update_area);
3327 /* This area of the destination is now invalid,
3328 so no need to copy to it. */
3329 cairo_region_subtract (region, update_area);
3331 cairo_region_destroy (update_area);
3334 /* If we're currently exposing this window, don't copy to this
3335 destination, as it will be overdrawn when the expose is done,
3336 instead invalidate it and repaint later. */
3337 if (impl_window->implicit_paint)
3339 GdkWindowPaint *implicit_paint = impl_window->implicit_paint;
3340 cairo_region_t *exposing;
3342 exposing = cairo_region_copy (implicit_paint->region);
3343 cairo_region_intersect (exposing, region);
3344 cairo_region_subtract (region, exposing);
3346 impl_window_add_update_area (impl_window, exposing);
3347 cairo_region_destroy (exposing);
3350 append_move_region (impl_window, region, dx, dy);
3352 cairo_region_destroy (region);
3355 /* Flushes all outstanding changes to the window, call this
3356 * before drawing directly to the window (i.e. outside a begin/end_paint pair).
3359 gdk_window_flush_outstanding_moves (GdkWindow *window)
3361 GdkWindow *impl_window;
3362 GList *l, *outstanding;
3363 GdkWindowRegionMove *move;
3365 impl_window = gdk_window_get_impl_window (window);
3366 outstanding = impl_window->outstanding_moves;
3367 impl_window->outstanding_moves = NULL;
3369 for (l = outstanding; l != NULL; l = l->next)
3373 do_move_region_bits_on_impl (impl_window,
3374 move->dest_region, move->dx, move->dy);
3376 gdk_window_region_move_free (move);
3379 g_list_free (outstanding);
3384 * @window: a #GdkWindow
3386 * Flush all outstanding cached operations on a window, leaving the
3387 * window in a state which reflects all that has been drawn before.
3389 * Gdk uses multiple kinds of caching to get better performance and
3390 * nicer drawing. For instance, during exposes all paints to a window
3391 * using double buffered rendering are keep on a surface until the last
3392 * window has been exposed. It also delays window moves/scrolls until
3393 * as long as possible until next update to avoid tearing when moving
3396 * Normally this should be completely invisible to applications, as
3397 * we automatically flush the windows when required, but this might
3398 * be needed if you for instance mix direct native drawing with
3399 * gdk drawing. For Gtk widgets that don't use double buffering this
3400 * will be called automatically before sending the expose event.
3405 gdk_window_flush (GdkWindow *window)
3407 gdk_window_flush_outstanding_moves (window);
3408 gdk_window_flush_implicit_paint (window);
3411 /* If we're about to move/resize or otherwise change the
3412 * hierarchy of a client side window in an impl and we're
3413 * called from an expose event handler then we need to
3414 * flush any already painted parts of the implicit paint
3415 * that are not part of the current paint, as these may
3416 * be used when scrolling or may overdraw the changes
3417 * caused by the hierarchy change.
3420 gdk_window_flush_if_exposing (GdkWindow *window)
3422 GdkWindow *impl_window;
3424 impl_window = gdk_window_get_impl_window (window);
3426 /* If we're in an implicit paint (i.e. in an expose handler, flush
3427 all the already finished exposes to get things to an uptodate state. */
3428 if (impl_window->implicit_paint)
3429 gdk_window_flush (window);
3434 gdk_window_flush_recursive_helper (GdkWindow *window,
3435 GdkWindowImpl *impl)
3440 for (l = window->children; l != NULL; l = l->next)
3444 if (child->impl == impl)
3445 /* Same impl, ignore */
3446 gdk_window_flush_recursive_helper (child, impl);
3448 gdk_window_flush_recursive (child);
3453 gdk_window_flush_recursive (GdkWindow *window)
3455 gdk_window_flush (window);
3456 gdk_window_flush_recursive_helper (window, window->impl);
3460 * gdk_window_get_clip_region:
3461 * @window: a #GdkWindow
3463 * Computes the region of a window that potentially can be written
3464 * to by drawing primitives. This region may not take into account
3465 * other factors such as if the window is obscured by other windows,
3466 * but no area outside of this region will be affected by drawing
3469 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3470 * when you are done.
3473 gdk_window_get_clip_region (GdkWindow *window)
3475 cairo_region_t *result;
3477 g_return_val_if_fail (GDK_WINDOW (window), NULL);
3479 result = cairo_region_copy (window->clip_region);
3481 if (window->paint_stack)
3483 cairo_region_t *paint_region = cairo_region_create ();
3484 GSList *tmp_list = window->paint_stack;
3488 GdkWindowPaint *paint = tmp_list->data;
3490 cairo_region_union (paint_region, paint->region);
3492 tmp_list = tmp_list->next;
3495 cairo_region_intersect (result, paint_region);
3496 cairo_region_destroy (paint_region);
3503 * gdk_window_get_visible_region:
3504 * @window: a #GdkWindow
3506 * Computes the region of the @window that is potentially visible.
3507 * This does not necessarily take into account if the window is
3508 * obscured by other windows, but no area outside of this region
3511 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3512 * when you are done.
3515 gdk_window_get_visible_region (GdkWindow *window)
3517 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3519 return cairo_region_copy (window->clip_region);
3523 setup_backing_rect (GdkWindow *window, GdkWindowPaint *paint)
3525 GdkWindow *bg_window;
3526 cairo_pattern_t *pattern = NULL;
3527 int x_offset = 0, y_offset = 0;
3530 cr = cairo_create (paint->surface);
3532 for (bg_window = window; bg_window; bg_window = bg_window->parent)
3534 pattern = gdk_window_get_background_pattern (bg_window);
3538 x_offset += bg_window->x;
3539 y_offset += bg_window->y;
3544 cairo_translate (cr, -x_offset, -y_offset);
3545 cairo_set_source (cr, pattern);
3546 cairo_translate (cr, x_offset, y_offset);
3549 cairo_set_source_rgb (cr, 0, 0, 0);
3555 gdk_window_clear_backing_region (GdkWindow *window,
3556 cairo_region_t *region)
3558 GdkWindowPaint *paint = window->paint_stack->data;
3559 cairo_region_t *clip;
3562 if (GDK_WINDOW_DESTROYED (window))
3565 cr = setup_backing_rect (window, paint);
3567 clip = cairo_region_copy (paint->region);
3568 cairo_region_intersect (clip, region);
3570 gdk_cairo_region (cr, clip);
3575 cairo_region_destroy (clip);
3579 gdk_window_clear_backing_region_direct (GdkWindow *window,
3580 cairo_region_t *region)
3582 GdkWindowPaint paint;
3583 cairo_region_t *clip;
3586 if (GDK_WINDOW_DESTROYED (window))
3589 paint.surface = _gdk_window_ref_cairo_surface (window);
3591 cr = setup_backing_rect (window, &paint);
3593 clip = cairo_region_copy (window->clip_region_with_children);
3594 cairo_region_intersect (clip, region);
3596 gdk_cairo_region (cr, clip);
3601 cairo_region_destroy (clip);
3602 cairo_surface_destroy (paint.surface);
3607 gdk_window_clear_region_internal (GdkWindow *window,
3608 cairo_region_t *region)
3610 if (window->paint_stack)
3611 gdk_window_clear_backing_region (window, region);
3613 gdk_window_clear_backing_region_direct (window, region);
3617 gdk_window_drop_cairo_surface (GdkWindow *window)
3619 if (window->cairo_surface)
3621 cairo_surface_finish (window->cairo_surface);
3622 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3624 window->cairo_surface = NULL;
3629 gdk_window_cairo_surface_destroy (void *data)
3631 GdkWindow *window = data;
3633 window->cairo_surface = NULL;
3636 static cairo_surface_t *
3637 gdk_window_create_cairo_surface (GdkWindow *window,
3641 cairo_surface_t *surface, *subsurface;
3643 surface = gdk_window_ref_impl_surface (window);
3644 if (gdk_window_has_impl (window))
3647 subsurface = cairo_surface_create_for_rectangle (surface,
3652 cairo_surface_destroy (surface);
3658 _gdk_window_ref_cairo_surface (GdkWindow *window)
3660 cairo_surface_t *surface;
3662 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3664 if (window->paint_stack)
3666 GdkWindowPaint *paint = window->paint_stack->data;
3668 surface = paint->surface;
3669 cairo_surface_reference (surface);
3674 /* This will be drawing directly to the window, so flush implicit paint */
3675 gdk_window_flush (window);
3677 if (!window->cairo_surface)
3679 window->cairo_surface = gdk_window_create_cairo_surface (window,
3683 if (window->cairo_surface)
3685 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3686 window, gdk_window_cairo_surface_destroy);
3690 cairo_surface_reference (window->cairo_surface);
3692 surface = window->cairo_surface;
3700 * @window: a #GdkWindow
3702 * Creates a Cairo context for drawing to @window.
3705 * Note that calling cairo_reset_clip() on the resulting #cairo_t will
3706 * produce undefined results, so avoid it at all costs.
3709 * Return value: A newly created Cairo context. Free with
3710 * cairo_destroy() when you are done drawing.
3715 gdk_cairo_create (GdkWindow *window)
3717 cairo_surface_t *surface;
3720 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3722 surface = _gdk_window_ref_cairo_surface (window);
3723 cr = cairo_create (surface);
3725 if (!window->paint_stack)
3727 gdk_cairo_region (cr, window->clip_region_with_children);
3732 GdkWindowPaint *paint = window->paint_stack->data;
3734 /* Only needs to clip to region if piggybacking
3735 on an implicit paint */
3736 if (paint->uses_implicit)
3738 gdk_cairo_region (cr, paint->region);
3743 cairo_surface_destroy (surface);
3748 /* Code for dirty-region queueing
3750 static GSList *update_windows = NULL;
3751 static guint update_idle = 0;
3752 static gboolean debug_updates = FALSE;
3754 static inline gboolean
3755 gdk_window_is_ancestor (GdkWindow *window,
3756 GdkWindow *ancestor)
3760 GdkWindow *parent = window->parent;
3762 if (parent == ancestor)
3772 gdk_window_add_update_window (GdkWindow *window)
3775 GSList *prev = NULL;
3776 gboolean has_ancestor_in_list = FALSE;
3778 for (tmp = update_windows; tmp; tmp = tmp->next)
3780 GdkWindow *parent = window->parent;
3782 /* check if tmp is an ancestor of "window"; if it is, set a
3783 * flag indicating that all following windows are either
3784 * children of "window" or from a differen hierarchy
3786 if (!has_ancestor_in_list && gdk_window_is_ancestor (window, tmp->data))
3787 has_ancestor_in_list = TRUE;
3789 /* insert in reverse stacking order when adding around siblings,
3790 * so processing updates properly paints over lower stacked windows
3792 if (parent == GDK_WINDOW (tmp->data)->parent)
3794 gint index = g_list_index (parent->children, window);
3795 for (; tmp && parent == GDK_WINDOW (tmp->data)->parent; tmp = tmp->next)
3797 gint sibling_index = g_list_index (parent->children, tmp->data);
3798 if (index > sibling_index)
3802 /* here, tmp got advanced past all lower stacked siblings */
3803 tmp = g_slist_prepend (tmp, window);
3807 update_windows = tmp;
3811 /* if "window" has an ancestor in the list and tmp is one of
3812 * "window's" children, insert "window" before tmp
3814 if (has_ancestor_in_list && gdk_window_is_ancestor (tmp->data, window))
3816 tmp = g_slist_prepend (tmp, window);
3821 update_windows = tmp;
3825 /* if we're at the end of the list and had an ancestor it it,
3826 * append to the list
3828 if (! tmp->next && has_ancestor_in_list)
3830 tmp = g_slist_append (tmp, window);
3837 /* if all above checks failed ("window" is from a different
3838 * hierarchy than what is already in the list) or the list is
3841 update_windows = g_slist_prepend (update_windows, window);
3845 gdk_window_remove_update_window (GdkWindow *window)
3847 update_windows = g_slist_remove (update_windows, window);
3851 gdk_window_update_idle (gpointer data)
3853 gdk_window_process_all_updates ();
3859 gdk_window_is_toplevel_frozen (GdkWindow *window)
3861 GdkWindow *toplevel;
3863 toplevel = gdk_window_get_toplevel (window);
3865 return toplevel->update_and_descendants_freeze_count > 0;
3869 gdk_window_schedule_update (GdkWindow *window)
3872 (window->update_freeze_count ||
3873 gdk_window_is_toplevel_frozen (window)))
3878 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
3879 gdk_window_update_idle,
3884 _gdk_window_process_updates_recurse (GdkWindow *window,
3885 cairo_region_t *expose_region)
3888 cairo_region_t *clipped_expose_region;
3889 GList *l, *children;
3891 if (cairo_region_is_empty (expose_region))
3894 if (gdk_window_is_offscreen (window->impl_window) &&
3895 gdk_window_has_impl (window))
3896 _gdk_window_add_damage ((GdkWindow *) window->impl_window, expose_region);
3899 /* Paint the window before the children, clipped to the window region
3900 with visible child windows removed */
3901 clipped_expose_region = cairo_region_copy (expose_region);
3902 cairo_region_intersect (clipped_expose_region, window->clip_region_with_children);
3904 if (!cairo_region_is_empty (clipped_expose_region) &&
3907 if (window->event_mask & GDK_EXPOSURE_MASK)
3911 event.expose.type = GDK_EXPOSE;
3912 event.expose.window = g_object_ref (window);
3913 event.expose.send_event = FALSE;
3914 event.expose.count = 0;
3915 event.expose.region = clipped_expose_region;
3916 cairo_region_get_extents (clipped_expose_region, &event.expose.area);
3918 _gdk_event_emit (&event);
3920 g_object_unref (window);
3922 else if (window->window_type != GDK_WINDOW_FOREIGN)
3924 /* No exposure mask set, so nothing will be drawn, the
3925 * app relies on the background being what it specified
3926 * for the window. So, we need to clear this manually.
3928 * For foreign windows if expose is not set that generally
3929 * means some other client paints them, so don't clear
3932 * We use begin/end_paint around the clear so that we can
3933 * piggyback on the implicit paint */
3935 gdk_window_begin_paint_region (window, clipped_expose_region);
3936 gdk_window_clear_region_internal (window, clipped_expose_region);
3937 gdk_window_end_paint (window);
3940 cairo_region_destroy (clipped_expose_region);
3942 /* Make this reentrancy safe for expose handlers freeing windows */
3943 children = g_list_copy (window->children);
3944 g_list_foreach (children, (GFunc)g_object_ref, NULL);
3946 /* Iterate over children, starting at bottommost */
3947 for (l = g_list_last (children); l != NULL; l = l->prev)
3951 if (child->destroyed || !GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
3954 /* Ignore offscreen children, as they don't draw in their parent and
3955 * don't take part in the clipping */
3956 if (gdk_window_is_offscreen (child))
3959 /* Client side child, expose */
3960 if (child->impl == window->impl)
3962 cairo_region_translate (expose_region, -child->x, -child->y);
3963 _gdk_window_process_updates_recurse ((GdkWindow *)child, expose_region);
3964 cairo_region_translate (expose_region, child->x, child->y);
3968 g_list_free_full (children, g_object_unref);
3972 /* Process and remove any invalid area on the native window by creating
3973 * expose events for the window and all non-native descendants.
3974 * Also processes any outstanding moves on the window before doing
3975 * any drawing. Note that its possible to have outstanding moves without
3976 * any invalid area as we use the update idle mechanism to coalesce
3977 * multiple moves as well as multiple invalidations.
3980 gdk_window_process_updates_internal (GdkWindow *window)
3982 GdkWindowImplClass *impl_class;
3983 gboolean save_region = FALSE;
3984 GdkRectangle clip_box;
3986 /* Ensure the window lives while updating it */
3987 g_object_ref (window);
3989 /* If an update got queued during update processing, we can get a
3990 * window in the update queue that has an empty update_area.
3993 if (window->update_area)
3995 cairo_region_t *update_area = window->update_area;
3996 window->update_area = NULL;
3998 if (gdk_window_is_viewable (window))
4000 cairo_region_t *expose_region;
4001 gboolean end_implicit;
4003 /* Clip to part visible in toplevel */
4004 cairo_region_intersect (update_area, window->clip_region);
4008 /* Make sure we see the red invalid area before redrawing. */
4009 gdk_display_sync (gdk_window_get_display (window));
4013 /* At this point we will be completely redrawing all of update_area.
4014 * If we have any outstanding moves that end up moving stuff inside
4015 * this area we don't actually need to move that as that part would
4016 * be overdrawn by the expose anyway. So, in order to copy less data
4017 * we remove these areas from the outstanding moves.
4019 if (window->outstanding_moves)
4021 GdkWindowRegionMove *move;
4022 cairo_region_t *remove;
4025 remove = cairo_region_copy (update_area);
4026 /* We iterate backwards, starting from the state that would be
4027 if we had applied all the moves. */
4028 for (l = g_list_last (window->outstanding_moves); l != NULL; l = prev)
4033 /* Don't need this area */
4034 cairo_region_subtract (move->dest_region, remove);
4036 /* However if any of the destination we do need has a source
4037 in the updated region we do need that as a destination for
4038 the earlier moves */
4039 cairo_region_translate (move->dest_region, -move->dx, -move->dy);
4040 cairo_region_subtract (remove, move->dest_region);
4042 if (cairo_region_is_empty (move->dest_region))
4044 gdk_window_region_move_free (move);
4045 window->outstanding_moves =
4046 g_list_delete_link (window->outstanding_moves, l);
4048 else /* move back */
4049 cairo_region_translate (move->dest_region, move->dx, move->dy);
4051 cairo_region_destroy (remove);
4054 /* By now we a set of window moves that should be applied, and then
4055 * an update region that should be repainted. A trivial implementation
4056 * would just do that in order, however in order to get nicer drawing
4057 * we do some tricks:
4059 * First of all, each subwindow expose may be double buffered by
4060 * itself (depending on widget setting) via
4061 * gdk_window_begin/end_paint(). But we also do an "implicit" paint,
4062 * creating a single surface the size of the invalid area on the
4063 * native window which all the individual normal paints will draw
4064 * into. This way in the normal case there will be only one surface
4065 * allocated and only once surface draw done for all the windows
4066 * in this native window.
4067 * There are a couple of reasons this may fail, for instance, some
4068 * backends (like quartz) do its own double buffering, so we disable
4069 * gdk double buffering there. Secondly, some subwindow could be
4070 * non-double buffered and draw directly to the window outside a
4071 * begin/end_paint pair. That will be lead to a gdk_window_flush
4072 * which immediately executes all outstanding moves and paints+removes
4073 * the implicit paint (further paints will allocate their own surfaces).
4075 * Secondly, in the case of implicit double buffering we expose all
4076 * the child windows into the implicit surface before we execute
4077 * the outstanding moves. This way we minimize the time between
4078 * doing the moves and rendering the new update area, thus minimizing
4079 * flashing. Of course, if any subwindow is non-double buffered we
4080 * well flush earlier than that.
4082 * Thirdly, after having done the outstanding moves we queue an
4083 * "antiexpose" on the area that will be drawn by the expose, which
4084 * means that any invalid region on the native window side before
4085 * the first expose drawing operation will be discarded, as it
4086 * has by then been overdrawn with valid data. This means we can
4087 * avoid doing the unnecessary repaint any outstanding expose events.
4090 cairo_region_get_extents (update_area, &clip_box);
4091 end_implicit = gdk_window_begin_implicit_paint (window, &clip_box);
4092 expose_region = cairo_region_copy (update_area);
4093 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
4096 /* Rendering is not double buffered by gdk, do outstanding
4097 * moves and queue antiexposure immediately. No need to do
4099 gdk_window_flush_outstanding_moves (window);
4100 save_region = impl_class->queue_antiexpose (window, update_area);
4102 /* Render the invalid areas to the implicit paint, by sending exposes.
4103 * May flush if non-double buffered widget draw. */
4104 impl_class->process_updates_recurse (window, expose_region);
4108 /* Do moves right before exposes are rendered to the window */
4109 gdk_window_flush_outstanding_moves (window);
4111 /* By this time we know that any outstanding expose for this
4112 * area is invalid and we can avoid it, so queue an antiexpose.
4113 * we have already started drawing to the window, so it would
4114 * be to late to anti-expose now. Since this is merely an
4115 * optimization we just avoid doing it at all in that case.
4117 if (window->implicit_paint != NULL && !window->implicit_paint->flushed)
4118 save_region = impl_class->queue_antiexpose (window, update_area);
4120 gdk_window_end_implicit_paint (window);
4122 cairo_region_destroy (expose_region);
4125 cairo_region_destroy (update_area);
4128 if (window->outstanding_moves)
4130 /* Flush any outstanding moves, may happen if we moved a window but got
4131 no actual invalid area */
4132 gdk_window_flush_outstanding_moves (window);
4135 g_object_unref (window);
4139 flush_all_displays (void)
4141 GSList *displays, *l;
4143 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4144 for (l = displays; l; l = l->next)
4145 gdk_display_flush (l->data);
4147 g_slist_free (displays);
4151 before_process_all_updates (void)
4153 GSList *displays, *l;
4154 GdkDisplayClass *display_class;
4156 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4157 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4158 for (l = displays; l; l = l->next)
4159 display_class->before_process_all_updates (l->data);
4161 g_slist_free (displays);
4165 after_process_all_updates (void)
4167 GSList *displays, *l;
4168 GdkDisplayClass *display_class;
4170 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4171 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4172 for (l = displays; l; l = l->next)
4173 display_class->after_process_all_updates (l->data);
4175 g_slist_free (displays);
4178 /* Currently it is not possible to override
4179 * gdk_window_process_all_updates in the same manner as
4180 * gdk_window_process_updates and gdk_window_invalidate_maybe_recurse
4181 * by implementing the GdkPaintable interface. If in the future a
4182 * backend would need this, the right solution would be to add a
4183 * method to GdkDisplay that can be optionally
4184 * NULL. gdk_window_process_all_updates can then walk the list of open
4185 * displays and call the mehod.
4189 * gdk_window_process_all_updates:
4191 * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
4192 * in the application.
4196 gdk_window_process_all_updates (void)
4198 GSList *old_update_windows = update_windows;
4199 GSList *tmp_list = update_windows;
4200 static gboolean in_process_all_updates = FALSE;
4201 static gboolean got_recursive_update = FALSE;
4203 if (in_process_all_updates)
4205 /* We can't do this now since that would recurse, so
4206 delay it until after the recursion is done. */
4207 got_recursive_update = TRUE;
4212 in_process_all_updates = TRUE;
4213 got_recursive_update = FALSE;
4216 g_source_remove (update_idle);
4218 update_windows = NULL;
4221 before_process_all_updates ();
4223 g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
4227 GdkWindow *window = tmp_list->data;
4229 if (!GDK_WINDOW_DESTROYED (window))
4231 if (window->update_freeze_count ||
4232 gdk_window_is_toplevel_frozen (window))
4233 gdk_window_add_update_window (window);
4235 gdk_window_process_updates_internal (window);
4238 g_object_unref (window);
4239 tmp_list = tmp_list->next;
4242 g_slist_free (old_update_windows);
4244 flush_all_displays ();
4246 after_process_all_updates ();
4248 in_process_all_updates = FALSE;
4250 /* If we ignored a recursive call, schedule a
4251 redraw now so that it eventually happens,
4252 otherwise we could miss an update if nothing
4253 else schedules an update. */
4254 if (got_recursive_update && !update_idle)
4256 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
4257 gdk_window_update_idle,
4262 * gdk_window_process_updates:
4263 * @window: a #GdkWindow
4264 * @update_children: whether to also process updates for child windows
4266 * Sends one or more expose events to @window. The areas in each
4267 * expose event will cover the entire update area for the window (see
4268 * gdk_window_invalidate_region() for details). Normally GDK calls
4269 * gdk_window_process_all_updates() on your behalf, so there's no
4270 * need to call this function unless you want to force expose events
4271 * to be delivered immediately and synchronously (vs. the usual
4272 * case, where GDK delivers them in an idle handler). Occasionally
4273 * this is useful to produce nicer scrolling behavior, for example.
4277 gdk_window_process_updates (GdkWindow *window,
4278 gboolean update_children)
4280 GdkWindow *impl_window;
4282 g_return_if_fail (GDK_IS_WINDOW (window));
4284 if (GDK_WINDOW_DESTROYED (window))
4287 /* Make sure the window lives during the expose callouts */
4288 g_object_ref (window);
4290 impl_window = gdk_window_get_impl_window (window);
4291 if ((impl_window->update_area ||
4292 impl_window->outstanding_moves) &&
4293 !impl_window->update_freeze_count &&
4294 !gdk_window_is_toplevel_frozen (window) &&
4296 /* Don't recurse into process_updates_internal, we'll
4297 * do the update later when idle instead. */
4298 impl_window->implicit_paint == NULL)
4300 gdk_window_process_updates_internal ((GdkWindow *)impl_window);
4301 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4304 if (update_children)
4306 /* process updates in reverse stacking order so composition or
4307 * painting over achieves the desired effect for offscreen windows
4309 GList *node, *children;
4311 children = g_list_copy (window->children);
4312 g_list_foreach (children, (GFunc)g_object_ref, NULL);
4314 for (node = g_list_last (children); node; node = node->prev)
4316 gdk_window_process_updates (node->data, TRUE);
4317 g_object_unref (node->data);
4320 g_list_free (children);
4323 g_object_unref (window);
4327 gdk_window_invalidate_rect_full (GdkWindow *window,
4328 const GdkRectangle *rect,
4329 gboolean invalidate_children,
4332 GdkRectangle window_rect;
4333 cairo_region_t *region;
4335 g_return_if_fail (GDK_IS_WINDOW (window));
4337 if (GDK_WINDOW_DESTROYED (window))
4340 if (window->input_only || !window->viewable)
4347 window_rect.width = window->width;
4348 window_rect.height = window->height;
4349 rect = &window_rect;
4352 region = cairo_region_create_rectangle (rect);
4353 gdk_window_invalidate_region_full (window, region, invalidate_children, clear_bg);
4354 cairo_region_destroy (region);
4358 * gdk_window_invalidate_rect:
4359 * @window: a #GdkWindow
4360 * @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
4362 * @invalidate_children: whether to also invalidate child windows
4364 * A convenience wrapper around gdk_window_invalidate_region() which
4365 * invalidates a rectangular region. See
4366 * gdk_window_invalidate_region() for details.
4369 gdk_window_invalidate_rect (GdkWindow *window,
4370 const GdkRectangle *rect,
4371 gboolean invalidate_children)
4373 gdk_window_invalidate_rect_full (window, rect, invalidate_children, CLEAR_BG_NONE);
4377 draw_ugly_color (GdkWindow *window,
4378 const cairo_region_t *region)
4382 cr = gdk_cairo_create (window);
4383 /* Draw ugly color all over the newly-invalid region */
4384 cairo_set_source_rgb (cr, 50000/65535., 10000/65535., 10000/65535.);
4385 gdk_cairo_region (cr, region);
4392 impl_window_add_update_area (GdkWindow *impl_window,
4393 cairo_region_t *region)
4395 if (impl_window->update_area)
4396 cairo_region_union (impl_window->update_area, region);
4399 gdk_window_add_update_window (impl_window);
4400 impl_window->update_area = cairo_region_copy (region);
4401 gdk_window_schedule_update (impl_window);
4405 /* clear_bg controls if the region will be cleared to
4406 * the background pattern if the exposure mask is not
4407 * set for the window, whereas this might not otherwise be
4408 * done (unless necessary to emulate background settings).
4409 * Set this to CLEAR_BG_WINCLEARED or CLEAR_BG_ALL if you
4410 * need to clear the background, such as when exposing the area beneath a
4411 * hidden or moved window, but not when an app requests repaint or when the
4412 * windowing system exposes a newly visible area (because then the windowing
4413 * system has already cleared the area).
4416 gdk_window_invalidate_maybe_recurse_full (GdkWindow *window,
4417 const cairo_region_t *region,
4419 GdkWindowChildFunc child_func,
4422 GdkWindow *impl_window;
4423 cairo_region_t *visible_region;
4426 g_return_if_fail (GDK_IS_WINDOW (window));
4428 if (GDK_WINDOW_DESTROYED (window))
4431 if (window->input_only ||
4432 !window->viewable ||
4433 cairo_region_is_empty (region) ||
4434 window->window_type == GDK_WINDOW_ROOT)
4437 visible_region = gdk_window_get_visible_region (window);
4438 cairo_region_intersect (visible_region, region);
4440 tmp_list = window->children;
4443 GdkWindow *child = tmp_list->data;
4445 if (!child->input_only)
4447 cairo_region_t *child_region;
4448 GdkRectangle child_rect;
4450 child_rect.x = child->x;
4451 child_rect.y = child->y;
4452 child_rect.width = child->width;
4453 child_rect.height = child->height;
4454 child_region = cairo_region_create_rectangle (&child_rect);
4456 /* remove child area from the invalid area of the parent */
4457 if (GDK_WINDOW_IS_MAPPED (child) && !child->shaped &&
4458 !child->composited &&
4459 !gdk_window_is_offscreen (child))
4460 cairo_region_subtract (visible_region, child_region);
4462 if (child_func && (*child_func) ((GdkWindow *)child, user_data))
4464 cairo_region_t *tmp = cairo_region_copy (region);
4466 cairo_region_translate (tmp, - child_rect.x, - child_rect.y);
4467 cairo_region_translate (child_region, - child_rect.x, - child_rect.y);
4468 cairo_region_intersect (child_region, tmp);
4470 gdk_window_invalidate_maybe_recurse_full ((GdkWindow *)child,
4471 child_region, clear_bg, child_func, user_data);
4473 cairo_region_destroy (tmp);
4476 cairo_region_destroy (child_region);
4479 tmp_list = tmp_list->next;
4482 impl_window = gdk_window_get_impl_window (window);
4484 if (!cairo_region_is_empty (visible_region) ||
4485 /* Even if we're not exposing anything, make sure we process
4486 idles for windows with outstanding moves */
4487 (impl_window->outstanding_moves != NULL &&
4488 impl_window->update_area == NULL))
4491 draw_ugly_color (window, region);
4493 /* Convert to impl coords */
4494 cairo_region_translate (visible_region, window->abs_x, window->abs_y);
4496 /* Only invalidate area if app requested expose events or if
4497 we need to clear the area (by request or to emulate background
4498 clearing for non-native windows or native windows with no support
4499 for window backgrounds */
4500 if (window->event_mask & GDK_EXPOSURE_MASK ||
4501 clear_bg == CLEAR_BG_ALL ||
4502 clear_bg == CLEAR_BG_WINCLEARED)
4503 impl_window_add_update_area (impl_window, visible_region);
4506 cairo_region_destroy (visible_region);
4510 * gdk_window_invalidate_maybe_recurse:
4511 * @window: a #GdkWindow
4512 * @region: a #cairo_region_t
4513 * @child_func: (scope call) (allow-none): function to use to decide if to
4514 * recurse to a child, %NULL means never recurse.
4515 * @user_data: data passed to @child_func
4517 * Adds @region to the update area for @window. The update area is the
4518 * region that needs to be redrawn, or "dirty region." The call
4519 * gdk_window_process_updates() sends one or more expose events to the
4520 * window, which together cover the entire update area. An
4521 * application would normally redraw the contents of @window in
4522 * response to those expose events.
4524 * GDK will call gdk_window_process_all_updates() on your behalf
4525 * whenever your program returns to the main loop and becomes idle, so
4526 * normally there's no need to do that manually, you just need to
4527 * invalidate regions that you know should be redrawn.
4529 * The @child_func parameter controls whether the region of
4530 * each child window that intersects @region will also be invalidated.
4531 * Only children for which @child_func returns TRUE will have the area
4535 gdk_window_invalidate_maybe_recurse (GdkWindow *window,
4536 const cairo_region_t *region,
4537 GdkWindowChildFunc child_func,
4540 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_NONE,
4541 child_func, user_data);
4545 true_predicate (GdkWindow *window,
4552 gdk_window_invalidate_region_full (GdkWindow *window,
4553 const cairo_region_t *region,
4554 gboolean invalidate_children,
4557 gdk_window_invalidate_maybe_recurse_full (window, region, clear_bg,
4558 invalidate_children ?
4559 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4564 * gdk_window_invalidate_region:
4565 * @window: a #GdkWindow
4566 * @region: a #cairo_region_t
4567 * @invalidate_children: %TRUE to also invalidate child windows
4569 * Adds @region to the update area for @window. The update area is the
4570 * region that needs to be redrawn, or "dirty region." The call
4571 * gdk_window_process_updates() sends one or more expose events to the
4572 * window, which together cover the entire update area. An
4573 * application would normally redraw the contents of @window in
4574 * response to those expose events.
4576 * GDK will call gdk_window_process_all_updates() on your behalf
4577 * whenever your program returns to the main loop and becomes idle, so
4578 * normally there's no need to do that manually, you just need to
4579 * invalidate regions that you know should be redrawn.
4581 * The @invalidate_children parameter controls whether the region of
4582 * each child window that intersects @region will also be invalidated.
4583 * If %FALSE, then the update area for child windows will remain
4584 * unaffected. See gdk_window_invalidate_maybe_recurse if you need
4585 * fine grained control over which children are invalidated.
4588 gdk_window_invalidate_region (GdkWindow *window,
4589 const cairo_region_t *region,
4590 gboolean invalidate_children)
4592 gdk_window_invalidate_maybe_recurse (window, region,
4593 invalidate_children ?
4594 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4599 * _gdk_window_invalidate_for_expose:
4600 * @window: a #GdkWindow
4601 * @region: a #cairo_region_t
4603 * Adds @region to the update area for @window. The update area is the
4604 * region that needs to be redrawn, or "dirty region." The call
4605 * gdk_window_process_updates() sends one or more expose events to the
4606 * window, which together cover the entire update area. An
4607 * application would normally redraw the contents of @window in
4608 * response to those expose events.
4610 * GDK will call gdk_window_process_all_updates() on your behalf
4611 * whenever your program returns to the main loop and becomes idle, so
4612 * normally there's no need to do that manually, you just need to
4613 * invalidate regions that you know should be redrawn.
4615 * This version of invalidation is used when you recieve expose events
4616 * from the native window system. It exposes the native window, plus
4617 * any non-native child windows (but not native child windows, as those would
4618 * have gotten their own expose events).
4621 _gdk_window_invalidate_for_expose (GdkWindow *window,
4622 cairo_region_t *region)
4624 GdkWindowRegionMove *move;
4625 cairo_region_t *move_region;
4628 /* Any invalidations comming from the windowing system will
4629 be in areas that may be moved by outstanding moves,
4630 so we need to modify the expose region correspondingly,
4631 otherwise we would expose in the wrong place, as the
4632 outstanding moves will be copied before we draw the
4634 for (l = window->outstanding_moves; l != NULL; l = l->next)
4638 /* covert to move source region */
4639 move_region = cairo_region_copy (move->dest_region);
4640 cairo_region_translate (move_region, -move->dx, -move->dy);
4642 /* Move area of region that intersects with move source
4643 by dx, dy of the move*/
4644 cairo_region_intersect (move_region, region);
4645 cairo_region_subtract (region, move_region);
4646 cairo_region_translate (move_region, move->dx, move->dy);
4647 cairo_region_union (region, move_region);
4649 cairo_region_destroy (move_region);
4652 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_WINCLEARED,
4653 (gboolean (*) (GdkWindow *, gpointer))gdk_window_has_no_impl,
4659 * gdk_window_get_update_area:
4660 * @window: a #GdkWindow
4662 * Transfers ownership of the update area from @window to the caller
4663 * of the function. That is, after calling this function, @window will
4664 * no longer have an invalid/dirty region; the update area is removed
4665 * from @window and handed to you. If a window has no update area,
4666 * gdk_window_get_update_area() returns %NULL. You are responsible for
4667 * calling cairo_region_destroy() on the returned region if it's non-%NULL.
4669 * Return value: the update area for @window
4672 gdk_window_get_update_area (GdkWindow *window)
4674 GdkWindow *impl_window;
4675 cairo_region_t *tmp_region, *to_remove;
4677 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4679 impl_window = gdk_window_get_impl_window (window);
4681 if (impl_window->update_area)
4683 tmp_region = cairo_region_copy (window->clip_region_with_children);
4684 /* Convert to impl coords */
4685 cairo_region_translate (tmp_region, window->abs_x, window->abs_y);
4686 cairo_region_intersect (tmp_region, impl_window->update_area);
4688 if (cairo_region_is_empty (tmp_region))
4690 cairo_region_destroy (tmp_region);
4695 /* Convert from impl coords */
4696 cairo_region_translate (tmp_region, -window->abs_x, -window->abs_y);
4698 /* Don't remove any update area that is overlapped by non-opaque windows
4699 (children or siblings) with alpha, as these really need to be repainted
4700 independently of this window. */
4701 to_remove = cairo_region_copy (tmp_region);
4702 cairo_region_subtract (to_remove, window->parent->layered_region);
4703 remove_layered_child_area (window, to_remove);
4705 /* Remove from update_area */
4706 cairo_region_translate (to_remove, window->abs_x, window->abs_y);
4707 cairo_region_subtract (impl_window->update_area, to_remove);
4709 cairo_region_destroy (to_remove);
4711 if (cairo_region_is_empty (impl_window->update_area) &&
4712 impl_window->outstanding_moves == NULL)
4714 cairo_region_destroy (impl_window->update_area);
4715 impl_window->update_area = NULL;
4717 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4728 * _gdk_window_clear_update_area:
4729 * @window: a #GdkWindow.
4731 * Internal function to clear the update area for a window. This
4732 * is called when the window is hidden or destroyed.
4735 _gdk_window_clear_update_area (GdkWindow *window)
4737 g_return_if_fail (GDK_IS_WINDOW (window));
4739 if (window->update_area)
4741 gdk_window_remove_update_window (window);
4743 cairo_region_destroy (window->update_area);
4744 window->update_area = NULL;
4749 * gdk_window_freeze_updates:
4750 * @window: a #GdkWindow
4752 * Temporarily freezes a window such that it won't receive expose
4753 * events. The window will begin receiving expose events again when
4754 * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
4755 * has been called more than once, gdk_window_thaw_updates() must be called
4756 * an equal number of times to begin processing exposes.
4759 gdk_window_freeze_updates (GdkWindow *window)
4761 GdkWindow *impl_window;
4763 g_return_if_fail (GDK_IS_WINDOW (window));
4765 impl_window = gdk_window_get_impl_window (window);
4766 impl_window->update_freeze_count++;
4770 * gdk_window_thaw_updates:
4771 * @window: a #GdkWindow
4773 * Thaws a window frozen with gdk_window_freeze_updates().
4776 gdk_window_thaw_updates (GdkWindow *window)
4778 GdkWindow *impl_window;
4780 g_return_if_fail (GDK_IS_WINDOW (window));
4782 impl_window = gdk_window_get_impl_window (window);
4784 g_return_if_fail (impl_window->update_freeze_count > 0);
4786 if (--impl_window->update_freeze_count == 0)
4787 gdk_window_schedule_update (GDK_WINDOW (impl_window));
4791 * gdk_window_freeze_toplevel_updates_libgtk_only:
4792 * @window: a #GdkWindow
4794 * Temporarily freezes a window and all its descendants such that it won't
4795 * receive expose events. The window will begin receiving expose events
4796 * again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
4797 * gdk_window_freeze_toplevel_updates_libgtk_only()
4798 * has been called more than once,
4799 * gdk_window_thaw_toplevel_updates_libgtk_only() must be called
4800 * an equal number of times to begin processing exposes.
4802 * This function is not part of the GDK public API and is only
4806 gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window)
4808 g_return_if_fail (GDK_IS_WINDOW (window));
4809 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4811 window->update_and_descendants_freeze_count++;
4815 * gdk_window_thaw_toplevel_updates_libgtk_only:
4816 * @window: a #GdkWindow
4818 * Thaws a window frozen with
4819 * gdk_window_freeze_toplevel_updates_libgtk_only().
4821 * This function is not part of the GDK public API and is only
4825 gdk_window_thaw_toplevel_updates_libgtk_only (GdkWindow *window)
4827 g_return_if_fail (GDK_IS_WINDOW (window));
4828 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4829 g_return_if_fail (window->update_and_descendants_freeze_count > 0);
4831 window->update_and_descendants_freeze_count--;
4833 gdk_window_schedule_update (window);
4837 * gdk_window_set_debug_updates:
4838 * @setting: %TRUE to turn on update debugging
4840 * With update debugging enabled, calls to
4841 * gdk_window_invalidate_region() clear the invalidated region of the
4842 * screen to a noticeable color, and GDK pauses for a short time
4843 * before sending exposes to windows during
4844 * gdk_window_process_updates(). The net effect is that you can see
4845 * the invalid region for each window and watch redraws as they
4846 * occur. This allows you to diagnose inefficiencies in your application.
4848 * In essence, because the GDK rendering model prevents all flicker,
4849 * if you are redrawing the same region 400 times you may never
4850 * notice, aside from noticing a speed problem. Enabling update
4851 * debugging causes GTK to flicker slowly and noticeably, so you can
4852 * see exactly what's being redrawn when, in what order.
4854 * The --gtk-debug=updates command line option passed to GTK+ programs
4855 * enables this debug option at application startup time. That's
4856 * usually more useful than calling gdk_window_set_debug_updates()
4857 * yourself, though you might want to use this function to enable
4858 * updates sometime after application startup time.
4862 gdk_window_set_debug_updates (gboolean setting)
4864 debug_updates = setting;
4868 * gdk_window_constrain_size:
4869 * @geometry: a #GdkGeometry structure
4870 * @flags: a mask indicating what portions of @geometry are set
4871 * @width: desired width of window
4872 * @height: desired height of the window
4873 * @new_width: (out): location to store resulting width
4874 * @new_height: (out): location to store resulting height
4876 * Constrains a desired width and height according to a
4877 * set of geometry hints (such as minimum and maximum size).
4880 gdk_window_constrain_size (GdkGeometry *geometry,
4887 /* This routine is partially borrowed from fvwm.
4889 * Copyright 1993, Robert Nation
4890 * You may use this code for any purpose, as long as the original
4891 * copyright remains in the source code and all documentation
4893 * which in turn borrows parts of the algorithm from uwm
4896 gint min_height = 0;
4897 gint base_width = 0;
4898 gint base_height = 0;
4901 gint max_width = G_MAXINT;
4902 gint max_height = G_MAXINT;
4904 #define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
4906 if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
4908 base_width = geometry->base_width;
4909 base_height = geometry->base_height;
4910 min_width = geometry->min_width;
4911 min_height = geometry->min_height;
4913 else if (flags & GDK_HINT_BASE_SIZE)
4915 base_width = geometry->base_width;
4916 base_height = geometry->base_height;
4917 min_width = geometry->base_width;
4918 min_height = geometry->base_height;
4920 else if (flags & GDK_HINT_MIN_SIZE)
4922 base_width = geometry->min_width;
4923 base_height = geometry->min_height;
4924 min_width = geometry->min_width;
4925 min_height = geometry->min_height;
4928 if (flags & GDK_HINT_MAX_SIZE)
4930 max_width = geometry->max_width ;
4931 max_height = geometry->max_height;
4934 if (flags & GDK_HINT_RESIZE_INC)
4936 xinc = MAX (xinc, geometry->width_inc);
4937 yinc = MAX (yinc, geometry->height_inc);
4940 /* clamp width and height to min and max values
4942 width = CLAMP (width, min_width, max_width);
4943 height = CLAMP (height, min_height, max_height);
4945 /* shrink to base + N * inc
4947 width = base_width + FLOOR (width - base_width, xinc);
4948 height = base_height + FLOOR (height - base_height, yinc);
4950 /* constrain aspect ratio, according to:
4953 * min_aspect <= -------- <= max_aspect
4957 if (flags & GDK_HINT_ASPECT &&
4958 geometry->min_aspect > 0 &&
4959 geometry->max_aspect > 0)
4963 if (geometry->min_aspect * height > width)
4965 delta = FLOOR (height - width / geometry->min_aspect, yinc);
4966 if (height - delta >= min_height)
4970 delta = FLOOR (height * geometry->min_aspect - width, xinc);
4971 if (width + delta <= max_width)
4976 if (geometry->max_aspect * height < width)
4978 delta = FLOOR (width - height * geometry->max_aspect, xinc);
4979 if (width - delta >= min_width)
4983 delta = FLOOR (width / geometry->max_aspect - height, yinc);
4984 if (height + delta <= max_height)
4993 *new_height = height;
4997 * gdk_window_get_pointer:
4998 * @window: a #GdkWindow
4999 * @x: (out) (allow-none): return location for X coordinate of pointer or %NULL to not
5000 * return the X coordinate
5001 * @y: (out) (allow-none): return location for Y coordinate of pointer or %NULL to not
5002 * return the Y coordinate
5003 * @mask: (out) (allow-none): return location for modifier mask or %NULL to not return the
5006 * Obtains the current pointer position and modifier state.
5007 * The position is given in coordinates relative to the upper left
5008 * corner of @window.
5010 * Return value: (transfer none): the window containing the pointer (as with
5011 * gdk_window_at_pointer()), or %NULL if the window containing the
5012 * pointer isn't known to GDK
5014 * Deprecated: 3.0: Use gdk_window_get_device_position() instead.
5017 gdk_window_get_pointer (GdkWindow *window,
5020 GdkModifierType *mask)
5022 GdkDisplay *display;
5024 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
5026 display = gdk_window_get_display (window);
5028 return gdk_window_get_device_position (window, display->core_pointer, x, y, mask);
5032 * gdk_window_get_device_position:
5033 * @window: a #GdkWindow.
5034 * @device: pointer #GdkDevice to query to.
5035 * @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
5036 * @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
5037 * @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
5039 * Obtains the current device position and modifier state.
5040 * The position is given in coordinates relative to the upper left
5041 * corner of @window.
5043 * Return value: (transfer none): The window underneath @device (as with
5044 * gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
5049 gdk_window_get_device_position (GdkWindow *window,
5053 GdkModifierType *mask)
5056 GdkModifierType tmp_mask;
5057 gboolean normal_child;
5059 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
5060 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
5061 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
5063 normal_child = GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_device_state (window,
5067 /* We got the coords on the impl, convert to the window */
5068 tmp_x -= window->abs_x;
5069 tmp_y -= window->abs_y;
5078 _gdk_display_enable_motion_hints (gdk_window_get_display (window), device);
5081 return _gdk_window_find_child_at (window, tmp_x, tmp_y);
5086 * gdk_get_default_root_window:
5088 * Obtains the root window (parent all other windows are inside)
5089 * for the default display and screen.
5091 * Return value: (transfer none): the default root window
5094 gdk_get_default_root_window (void)
5096 return gdk_screen_get_root_window (gdk_screen_get_default ());
5100 get_all_native_children (GdkWindow *window,
5106 for (l = window->children; l != NULL; l = l->next)
5110 if (gdk_window_has_impl (child))
5111 *native = g_list_prepend (*native, child);
5113 get_all_native_children (child, native);
5119 gdk_window_raise_internal (GdkWindow *window)
5121 GdkWindow *parent = window->parent;
5123 GList *native_children;
5125 GdkWindowImplClass *impl_class;
5129 parent->children = g_list_remove (parent->children, window);
5130 parent->children = g_list_prepend (parent->children, window);
5133 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5134 /* Just do native raise for toplevels */
5135 if (gdk_window_is_toplevel (window) ||
5136 /* The restack_under codepath should work correctly even if the parent
5137 is native, but it relies on the order of ->children to be correct,
5138 and some apps like SWT reorder the x windows without gdks knowledge,
5139 so we use raise directly in order to make these behave as before
5140 when using native windows */
5141 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5143 impl_class->raise (window);
5145 else if (gdk_window_has_impl (window))
5147 above = find_native_sibling_above (parent, window);
5150 listhead.data = window;
5151 listhead.next = NULL;
5152 listhead.prev = NULL;
5153 impl_class->restack_under ((GdkWindow *)above,
5157 impl_class->raise (window);
5161 native_children = NULL;
5162 get_all_native_children (window, &native_children);
5163 if (native_children != NULL)
5165 above = find_native_sibling_above (parent, window);
5168 impl_class->restack_under (above, native_children);
5171 /* Right order, since native_children is bottom-topmost first */
5172 for (l = native_children; l != NULL; l = l->next)
5173 impl_class->raise (l->data);
5176 g_list_free (native_children);
5182 /* Returns TRUE If the native window was mapped or unmapped */
5184 set_viewable (GdkWindow *w,
5188 GdkWindowImplClass *impl_class;
5191 if (w->viewable == val)
5197 recompute_visible_regions (w, FALSE, FALSE);
5199 for (l = w->children; l != NULL; l = l->next)
5203 if (GDK_WINDOW_IS_MAPPED (child) &&
5204 child->window_type != GDK_WINDOW_FOREIGN)
5205 set_viewable (child, val);
5208 if (gdk_window_has_impl (w) &&
5209 w->window_type != GDK_WINDOW_FOREIGN &&
5210 !gdk_window_is_toplevel (w))
5212 /* For most native windows we show/hide them not when they are
5213 * mapped/unmapped, because that may not produce the correct results.
5214 * For instance, if a native window have a non-native parent which is
5215 * hidden, but its native parent is viewable then showing the window
5216 * would make it viewable to X but its not viewable wrt the non-native
5217 * hierarchy. In order to handle this we track the gdk side viewability
5218 * and only map really viewable windows.
5220 * There are two exceptions though:
5222 * For foreign windows we don't want ever change the mapped state
5223 * except when explicitly done via gdk_window_show/hide, as this may
5224 * cause problems for client owning the foreign window when its window
5225 * is suddenly mapped or unmapped.
5227 * For toplevel windows embedded in a foreign window (e.g. a plug)
5228 * we sometimes synthesize a map of a window, but the native
5229 * window is really shown by the embedder, so we don't want to
5230 * do the show ourselves. We can't really tell this case from the normal
5231 * toplevel show as such toplevels are seen by gdk as parents of the
5232 * root window, so we make an exception for all toplevels.
5235 impl_class = GDK_WINDOW_IMPL_GET_CLASS (w->impl);
5237 impl_class->show ((GdkWindow *)w, FALSE);
5239 impl_class->hide ((GdkWindow *)w);
5247 /* Returns TRUE If the native window was mapped or unmapped */
5249 _gdk_window_update_viewable (GdkWindow *window)
5253 if (window->window_type == GDK_WINDOW_FOREIGN ||
5254 window->window_type == GDK_WINDOW_ROOT)
5256 else if (gdk_window_is_toplevel (window) ||
5257 window->parent->viewable)
5258 viewable = GDK_WINDOW_IS_MAPPED (window);
5262 return set_viewable (window, viewable);
5266 gdk_window_show_internal (GdkWindow *window, gboolean raise)
5268 GdkWindowImplClass *impl_class;
5269 gboolean was_mapped, was_viewable;
5272 g_return_if_fail (GDK_IS_WINDOW (window));
5274 if (window->destroyed)
5277 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5278 was_viewable = window->viewable;
5281 /* Keep children in (reverse) stacking order */
5282 gdk_window_raise_internal (window);
5284 if (gdk_window_has_impl (window))
5287 gdk_synthesize_window_state (window,
5288 GDK_WINDOW_STATE_WITHDRAWN,
5289 GDK_WINDOW_STATE_FOCUSED);
5296 did_show = _gdk_window_update_viewable (window);
5298 /* If it was already viewable the backend show op won't be called, call it
5299 again to ensure things happen right if the mapped tracking was not right
5300 for e.g. a foreign window.
5301 Dunno if this is strictly needed but its what happened pre-csw.
5302 Also show if not done by gdk_window_update_viewable. */
5303 if (gdk_window_has_impl (window) && (was_viewable || !did_show))
5305 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5306 impl_class->show (window, !did_show ? was_mapped : TRUE);
5309 if (!was_mapped && !gdk_window_has_impl (window))
5311 if (window->event_mask & GDK_STRUCTURE_MASK)
5312 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5314 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5315 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5318 if (!was_mapped || raise)
5320 recompute_visible_regions (window, TRUE, FALSE);
5322 /* If any decendants became visible we need to send visibility notify */
5323 gdk_window_update_visibility_recursively (window, NULL);
5325 if (gdk_window_is_viewable (window))
5327 _gdk_synthesize_crossing_events_for_geometry_change (window);
5328 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
5334 * gdk_window_show_unraised:
5335 * @window: a #GdkWindow
5337 * Shows a #GdkWindow onscreen, but does not modify its stacking
5338 * order. In contrast, gdk_window_show() will raise the window
5339 * to the top of the window stack.
5341 * On the X11 platform, in Xlib terms, this function calls
5342 * XMapWindow() (it also updates some internal GDK state, which means
5343 * that you can't really use XMapWindow() directly on a GDK window).
5346 gdk_window_show_unraised (GdkWindow *window)
5348 gdk_window_show_internal (window, FALSE);
5353 * @window: a #GdkWindow
5355 * Raises @window to the top of the Z-order (stacking order), so that
5356 * other windows with the same parent window appear below @window.
5357 * This is true whether or not the windows are visible.
5359 * If @window is a toplevel, the window manager may choose to deny the
5360 * request to move the window in the Z-order, gdk_window_raise() only
5361 * requests the restack, does not guarantee it.
5364 gdk_window_raise (GdkWindow *window)
5366 g_return_if_fail (GDK_IS_WINDOW (window));
5368 if (window->destroyed)
5371 gdk_window_flush_if_exposing (window);
5373 /* Keep children in (reverse) stacking order */
5374 gdk_window_raise_internal (window);
5376 recompute_visible_regions (window, TRUE, FALSE);
5378 if (gdk_window_is_viewable (window) &&
5379 !window->input_only)
5380 gdk_window_invalidate_region_full (window, window->clip_region, TRUE, CLEAR_BG_ALL);
5384 gdk_window_lower_internal (GdkWindow *window)
5386 GdkWindow *parent = window->parent;
5387 GdkWindowImplClass *impl_class;
5389 GList *native_children;
5394 parent->children = g_list_remove (parent->children, window);
5395 parent->children = g_list_append (parent->children, window);
5398 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5399 /* Just do native lower for toplevels */
5400 if (gdk_window_is_toplevel (window) ||
5401 /* The restack_under codepath should work correctly even if the parent
5402 is native, but it relies on the order of ->children to be correct,
5403 and some apps like SWT reorder the x windows without gdks knowledge,
5404 so we use lower directly in order to make these behave as before
5405 when using native windows */
5406 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5408 impl_class->lower (window);
5410 else if (gdk_window_has_impl (window))
5412 above = find_native_sibling_above (parent, window);
5415 listhead.data = window;
5416 listhead.next = NULL;
5417 listhead.prev = NULL;
5418 impl_class->restack_under ((GdkWindow *)above, &listhead);
5421 impl_class->raise (window);
5425 native_children = NULL;
5426 get_all_native_children (window, &native_children);
5427 if (native_children != NULL)
5429 above = find_native_sibling_above (parent, window);
5432 impl_class->restack_under ((GdkWindow *)above,
5436 /* Right order, since native_children is bottom-topmost first */
5437 for (l = native_children; l != NULL; l = l->next)
5438 impl_class->raise (l->data);
5441 g_list_free (native_children);
5448 gdk_window_invalidate_in_parent (GdkWindow *private)
5450 GdkRectangle r, child;
5452 if (gdk_window_is_toplevel (private))
5455 /* get the visible rectangle of the parent */
5457 r.width = private->parent->width;
5458 r.height = private->parent->height;
5460 child.x = private->x;
5461 child.y = private->y;
5462 child.width = private->width;
5463 child.height = private->height;
5464 gdk_rectangle_intersect (&r, &child, &r);
5466 gdk_window_invalidate_rect_full (private->parent, &r, TRUE, CLEAR_BG_ALL);
5472 * @window: a #GdkWindow
5474 * Lowers @window to the bottom of the Z-order (stacking order), so that
5475 * other windows with the same parent window appear above @window.
5476 * This is true whether or not the other windows are visible.
5478 * If @window is a toplevel, the window manager may choose to deny the
5479 * request to move the window in the Z-order, gdk_window_lower() only
5480 * requests the restack, does not guarantee it.
5482 * Note that gdk_window_show() raises the window again, so don't call this
5483 * function before gdk_window_show(). (Try gdk_window_show_unraised().)
5486 gdk_window_lower (GdkWindow *window)
5488 g_return_if_fail (GDK_IS_WINDOW (window));
5490 if (window->destroyed)
5493 gdk_window_flush_if_exposing (window);
5495 /* Keep children in (reverse) stacking order */
5496 gdk_window_lower_internal (window);
5498 recompute_visible_regions (window, TRUE, FALSE);
5500 _gdk_synthesize_crossing_events_for_geometry_change (window);
5501 gdk_window_invalidate_in_parent (window);
5505 * gdk_window_restack:
5506 * @window: a #GdkWindow
5507 * @sibling: (allow-none): a #GdkWindow that is a sibling of @window, or %NULL
5510 * Changes the position of @window in the Z-order (stacking order), so that
5511 * it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
5514 * If @sibling is %NULL, then this either raises (if @above is %TRUE) or
5515 * lowers the window.
5517 * If @window is a toplevel, the window manager may choose to deny the
5518 * request to move the window in the Z-order, gdk_window_restack() only
5519 * requests the restack, does not guarantee it.
5524 gdk_window_restack (GdkWindow *window,
5528 GdkWindowImplClass *impl_class;
5530 GdkWindow *above_native;
5531 GList *sibling_link;
5532 GList *native_children;
5535 g_return_if_fail (GDK_IS_WINDOW (window));
5536 g_return_if_fail (sibling == NULL || GDK_IS_WINDOW (sibling));
5538 if (window->destroyed)
5541 if (sibling == NULL)
5544 gdk_window_raise (window);
5546 gdk_window_lower (window);
5550 gdk_window_flush_if_exposing (window);
5552 if (gdk_window_is_toplevel (window))
5554 g_return_if_fail (gdk_window_is_toplevel (sibling));
5555 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5556 impl_class->restack_toplevel (window, sibling, above);
5560 parent = window->parent;
5563 sibling_link = g_list_find (parent->children, sibling);
5564 g_return_if_fail (sibling_link != NULL);
5565 if (sibling_link == NULL)
5568 parent->children = g_list_remove (parent->children, window);
5570 parent->children = g_list_insert_before (parent->children,
5574 parent->children = g_list_insert_before (parent->children,
5578 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5579 if (gdk_window_has_impl (window))
5581 above_native = find_native_sibling_above (parent, window);
5584 listhead.data = window;
5585 listhead.next = NULL;
5586 listhead.prev = NULL;
5587 impl_class->restack_under (above_native, &listhead);
5590 impl_class->raise (window);
5594 native_children = NULL;
5595 get_all_native_children (window, &native_children);
5596 if (native_children != NULL)
5598 above_native = find_native_sibling_above (parent, window);
5600 impl_class->restack_under (above_native,
5604 /* Right order, since native_children is bottom-topmost first */
5605 for (l = native_children; l != NULL; l = l->next)
5606 impl_class->raise (l->data);
5609 g_list_free (native_children);
5614 recompute_visible_regions (window, TRUE, FALSE);
5616 _gdk_synthesize_crossing_events_for_geometry_change (window);
5617 gdk_window_invalidate_in_parent (window);
5623 * @window: a #GdkWindow
5625 * Like gdk_window_show_unraised(), but also raises the window to the
5626 * top of the window stack (moves the window to the front of the
5629 * This function maps a window so it's visible onscreen. Its opposite
5630 * is gdk_window_hide().
5632 * When implementing a #GtkWidget, you should call this function on the widget's
5633 * #GdkWindow as part of the "map" method.
5636 gdk_window_show (GdkWindow *window)
5638 gdk_window_show_internal (window, TRUE);
5643 * @window: a #GdkWindow
5645 * For toplevel windows, withdraws them, so they will no longer be
5646 * known to the window manager; for all windows, unmaps them, so
5647 * they won't be displayed. Normally done automatically as
5648 * part of gtk_widget_hide().
5651 gdk_window_hide (GdkWindow *window)
5653 GdkWindowImplClass *impl_class;
5654 gboolean was_mapped, did_hide;
5656 g_return_if_fail (GDK_IS_WINDOW (window));
5658 if (window->destroyed)
5661 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5663 if (gdk_window_has_impl (window))
5666 if (GDK_WINDOW_IS_MAPPED (window))
5667 gdk_synthesize_window_state (window,
5669 GDK_WINDOW_STATE_WITHDRAWN);
5671 else if (was_mapped)
5673 GdkDisplay *display;
5674 GdkDeviceManager *device_manager;
5677 /* May need to break grabs on children */
5678 display = gdk_window_get_display (window);
5679 device_manager = gdk_display_get_device_manager (display);
5681 /* Get all devices */
5682 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
5683 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
5684 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
5686 for (d = devices; d; d = d->next)
5688 GdkDevice *device = d->data;
5690 if (_gdk_display_end_device_grab (display,
5692 _gdk_display_get_next_serial (display),
5695 gdk_device_ungrab (device, GDK_CURRENT_TIME);
5698 window->state = GDK_WINDOW_STATE_WITHDRAWN;
5699 g_list_free (devices);
5702 did_hide = _gdk_window_update_viewable (window);
5704 /* Hide foreign window as those are not handled by update_viewable. */
5705 if (gdk_window_has_impl (window) && (!did_hide))
5707 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5708 impl_class->hide (window);
5711 recompute_visible_regions (window, TRUE, FALSE);
5713 /* all decendants became non-visible, we need to send visibility notify */
5714 gdk_window_update_visibility_recursively (window, NULL);
5716 if (was_mapped && !gdk_window_has_impl (window))
5718 if (window->event_mask & GDK_STRUCTURE_MASK)
5719 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5721 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5722 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5724 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5727 /* Invalidate the rect */
5729 gdk_window_invalidate_in_parent (window);
5733 * gdk_window_withdraw:
5734 * @window: a toplevel #GdkWindow
5736 * Withdraws a window (unmaps it and asks the window manager to forget about it).
5737 * This function is not really useful as gdk_window_hide() automatically
5738 * withdraws toplevel windows before hiding them.
5741 gdk_window_withdraw (GdkWindow *window)
5743 GdkWindowImplClass *impl_class;
5744 gboolean was_mapped;
5746 g_return_if_fail (GDK_IS_WINDOW (window));
5748 if (window->destroyed)
5751 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5753 if (gdk_window_has_impl (window))
5755 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5756 impl_class->withdraw (window);
5760 if (window->event_mask & GDK_STRUCTURE_MASK)
5761 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5763 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5764 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5766 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5769 recompute_visible_regions (window, TRUE, FALSE);
5774 * gdk_window_set_events:
5775 * @window: a #GdkWindow
5776 * @event_mask: event mask for @window
5778 * The event mask for a window determines which events will be reported
5779 * for that window from all master input devices. For example, an event mask
5780 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5781 * press events. The event mask is the bitwise OR of values from the
5782 * #GdkEventMask enumeration.
5785 gdk_window_set_events (GdkWindow *window,
5786 GdkEventMask event_mask)
5788 GdkWindowImplClass *impl_class;
5789 GdkDisplay *display;
5791 g_return_if_fail (GDK_IS_WINDOW (window));
5793 if (window->destroyed)
5796 /* If motion hint is disabled, enable motion events again */
5797 display = gdk_window_get_display (window);
5798 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5799 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5801 GList *devices = window->devices_inside;
5805 _gdk_display_enable_motion_hints (display, (GdkDevice *) devices->data);
5806 devices = devices->next;
5810 window->event_mask = event_mask;
5812 if (gdk_window_has_impl (window))
5814 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5815 impl_class->set_events (window,
5816 get_native_event_mask (window));
5822 * gdk_window_get_events:
5823 * @window: a #GdkWindow
5825 * Gets the event mask for @window for all master input devices. See
5826 * gdk_window_set_events().
5828 * Return value: event mask for @window
5831 gdk_window_get_events (GdkWindow *window)
5833 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5835 if (window->destroyed)
5838 return window->event_mask;
5842 * gdk_window_set_device_events:
5843 * @window: a #GdkWindow
5844 * @device: #GdkDevice to enable events for.
5845 * @event_mask: event mask for @window
5847 * Sets the event mask for a given device (Normally a floating device, not
5848 * attached to any visible pointer) to @window. For example, an event mask
5849 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5850 * press events. The event mask is the bitwise OR of values from the
5851 * #GdkEventMask enumeration.
5856 gdk_window_set_device_events (GdkWindow *window,
5858 GdkEventMask event_mask)
5860 GdkEventMask device_mask;
5861 GdkDisplay *display;
5864 g_return_if_fail (GDK_IS_WINDOW (window));
5865 g_return_if_fail (GDK_IS_DEVICE (device));
5867 if (GDK_WINDOW_DESTROYED (window))
5870 /* If motion hint is disabled, enable motion events again */
5871 display = gdk_window_get_display (window);
5872 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5873 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5874 _gdk_display_enable_motion_hints (display, device);
5876 if (G_UNLIKELY (!window->device_events))
5877 window->device_events = g_hash_table_new (NULL, NULL);
5879 if (event_mask == 0)
5881 /* FIXME: unsetting events on a master device
5882 * would restore window->event_mask
5884 g_hash_table_remove (window->device_events, device);
5887 g_hash_table_insert (window->device_events, device,
5888 GINT_TO_POINTER (event_mask));
5890 native = gdk_window_get_toplevel (window);
5892 while (gdk_window_is_offscreen (native))
5894 native = gdk_offscreen_window_get_embedder (native);
5896 if (native == NULL ||
5897 (!_gdk_window_has_impl (native) &&
5898 !gdk_window_is_viewable (native)))
5901 native = gdk_window_get_toplevel (native);
5904 device_mask = get_native_device_event_mask (window, device);
5905 GDK_DEVICE_GET_CLASS (device)->select_window_events (device, native, device_mask);
5909 * gdk_window_get_device_events:
5910 * @window: a #GdkWindow.
5911 * @device: a #GdkDevice.
5913 * Returns the event mask for @window corresponding to an specific device.
5915 * Returns: device event mask for @window
5920 gdk_window_get_device_events (GdkWindow *window,
5925 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5926 g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
5928 if (GDK_WINDOW_DESTROYED (window))
5931 if (!window->device_events)
5934 mask = GPOINTER_TO_INT (g_hash_table_lookup (window->device_events, device));
5936 /* FIXME: device could be controlled by window->event_mask */
5942 gdk_window_move_resize_toplevel (GdkWindow *window,
5949 cairo_region_t *old_region, *new_region;
5950 GdkWindowImplClass *impl_class;
5957 is_resize = (width != -1) || (height != -1);
5959 if (gdk_window_is_viewable (window) &&
5960 !window->input_only)
5963 old_region = cairo_region_copy (window->clip_region);
5966 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5967 impl_class->move_resize (window, with_move, x, y, width, height);
5969 /* Avoid recomputing for pure toplevel moves, for performance reasons */
5971 recompute_visible_regions (window, TRUE, FALSE);
5975 new_region = cairo_region_copy (window->clip_region);
5977 /* This is the newly exposed area (due to any resize),
5978 * X will expose it, but lets do that without the roundtrip
5980 cairo_region_subtract (new_region, old_region);
5981 gdk_window_invalidate_region_full (window, new_region, TRUE, CLEAR_BG_WINCLEARED);
5983 cairo_region_destroy (old_region);
5984 cairo_region_destroy (new_region);
5987 _gdk_synthesize_crossing_events_for_geometry_change (window);
5992 move_native_children (GdkWindow *private)
5996 GdkWindowImplClass *impl_class;
5998 for (l = private->children; l; l = l->next)
6002 if (child->impl != private->impl)
6004 impl_class = GDK_WINDOW_IMPL_GET_CLASS (child->impl);
6005 impl_class->move_resize (child, TRUE,
6007 child->width, child->height);
6010 move_native_children (child);
6015 collect_native_child_region_helper (GdkWindow *window,
6016 GdkWindowImpl *impl,
6017 cairo_region_t **region,
6022 cairo_region_t *tmp;
6025 for (l = window->children; l != NULL; l = l->next)
6029 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
6032 if (child->impl != impl)
6034 tmp = cairo_region_copy (child->clip_region);
6035 cairo_region_translate (tmp,
6036 x_offset + child->x,
6037 y_offset + child->y);
6038 if (*region == NULL)
6042 cairo_region_union (*region, tmp);
6043 cairo_region_destroy (tmp);
6047 collect_native_child_region_helper (child, impl, region,
6048 x_offset + child->x,
6049 y_offset + child->y);
6055 static cairo_region_t *
6056 collect_native_child_region (GdkWindow *window,
6057 gboolean include_this)
6059 cairo_region_t *region;
6061 if (include_this && gdk_window_has_impl (window) && window->viewable)
6062 return cairo_region_copy (window->clip_region);
6066 collect_native_child_region_helper (window, window->impl, ®ion, 0, 0);
6073 gdk_window_move_resize_internal (GdkWindow *window,
6080 cairo_region_t *old_region, *old_layered, *new_region, *copy_area;
6081 cairo_region_t *old_native_child_region, *new_native_child_region;
6082 GdkWindow *impl_window;
6083 GdkWindowImplClass *impl_class;
6085 int old_x, old_y, old_abs_x, old_abs_y;
6088 g_return_if_fail (GDK_IS_WINDOW (window));
6090 if (window->destroyed)
6093 if (gdk_window_is_toplevel (window))
6095 gdk_window_move_resize_toplevel (window, with_move, x, y, width, height);
6099 /* Bail early if no change */
6100 if (window->width == width &&
6101 window->height == height &&
6107 gdk_window_flush_if_exposing (window);
6109 /* Handle child windows */
6115 impl_window = gdk_window_get_impl_window (window);
6120 old_native_child_region = NULL;
6121 if (gdk_window_is_viewable (window) &&
6122 !window->input_only)
6126 old_region = cairo_region_copy (window->clip_region);
6127 old_layered = cairo_region_copy (window->layered_region);
6128 /* Adjust regions to parent window coords */
6129 cairo_region_translate (old_region, window->x, window->y);
6130 cairo_region_translate (old_layered, window->x, window->y);
6132 old_native_child_region = collect_native_child_region (window, TRUE);
6133 if (old_native_child_region)
6135 /* Adjust region to parent window coords */
6136 cairo_region_translate (old_native_child_region, window->x, window->y);
6138 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6139 * source or destination for a delayed GdkWindowRegionMove. So, we need
6140 * to flush those here for the parent window and all overlapped subwindows
6141 * of it. And we need to do this before setting the new clips as those will be
6144 gdk_window_flush_recursive (window->parent);
6148 /* Set the new position and size */
6154 if (!(width < 0 && height < 0))
6158 window->width = width;
6161 window->height = height;
6164 dx = window->x - old_x;
6165 dy = window->y - old_y;
6167 old_abs_x = window->abs_x;
6168 old_abs_y = window->abs_y;
6170 recompute_visible_regions (window, TRUE, FALSE);
6172 new_native_child_region = NULL;
6173 if (old_native_child_region)
6175 new_native_child_region = collect_native_child_region (window, TRUE);
6176 /* Adjust region to parent window coords */
6177 cairo_region_translate (new_native_child_region, window->x, window->y);
6180 if (gdk_window_has_impl (window))
6182 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6184 /* Do the actual move after recomputing things, as this will have set the shape to
6185 the now correct one, thus avoiding copying regions that should not be copied. */
6186 impl_class->move_resize (window, TRUE,
6187 window->x, window->y,
6188 window->width, window->height);
6190 else if (old_abs_x != window->abs_x ||
6191 old_abs_y != window->abs_y)
6192 move_native_children (window);
6196 new_region = cairo_region_copy (window->clip_region);
6197 /* Adjust region to parent window coords */
6198 cairo_region_translate (new_region, window->x, window->y);
6201 * Part of the data at the new location can be copied from the
6202 * old location, this area is the intersection of the old region
6203 * moved as the copy will move it and then intersected with
6207 * Everything in the old and new regions that is not copied must be
6208 * invalidated (including children) as this is newly exposed
6210 if (window->has_alpha_background)
6211 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6213 copy_area = cairo_region_copy (new_region);
6215 /* Don't copy from a previously layered region */
6216 cairo_region_translate (old_layered, dx, dy);
6217 cairo_region_subtract (copy_area, old_layered);
6219 /* Don't copy into a layered region */
6220 cairo_region_translate (copy_area, -window->x, -window->y);
6221 cairo_region_subtract (copy_area, window->layered_region);
6222 cairo_region_translate (copy_area, window->x, window->y);
6224 cairo_region_union (new_region, old_region);
6226 if (old_native_child_region)
6228 /* Don't copy from inside native children, as this is copied by
6229 * the native window move.
6231 cairo_region_subtract (old_region, old_native_child_region);
6233 cairo_region_translate (old_region, dx, dy);
6235 cairo_region_intersect (copy_area, old_region);
6237 if (new_native_child_region)
6239 /* Don't copy any bits that would cause a read from the moved
6240 native windows, as we can't read that data */
6241 cairo_region_translate (new_native_child_region, dx, dy);
6242 cairo_region_subtract (copy_area, new_native_child_region);
6243 cairo_region_translate (new_native_child_region, -dx, -dy);
6246 cairo_region_subtract (new_region, copy_area);
6248 /* Convert old region to impl coords */
6249 cairo_region_translate (old_region, -dx + window->abs_x - window->x, -dy + window->abs_y - window->y);
6251 /* convert from parent coords to impl */
6252 cairo_region_translate (copy_area, window->abs_x - window->x, window->abs_y - window->y);
6254 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6256 /* Invalidate affected part in the parent window
6257 * (no higher window should be affected)
6258 * We also invalidate any children in that area, which could include
6259 * this window if it still overlaps that area.
6261 if (old_native_child_region)
6263 /* No need to expose the region that the native window move copies */
6264 cairo_region_translate (old_native_child_region, dx, dy);
6265 cairo_region_intersect (old_native_child_region, new_native_child_region);
6266 cairo_region_subtract (new_region, old_native_child_region);
6268 gdk_window_invalidate_region_full (window->parent, new_region, TRUE, CLEAR_BG_ALL);
6270 cairo_region_destroy (old_region);
6271 cairo_region_destroy (old_layered);
6272 cairo_region_destroy (new_region);
6275 if (old_native_child_region)
6277 cairo_region_destroy (old_native_child_region);
6278 cairo_region_destroy (new_native_child_region);
6281 _gdk_synthesize_crossing_events_for_geometry_change (window);
6288 * @window: a #GdkWindow
6289 * @x: X coordinate relative to window's parent
6290 * @y: Y coordinate relative to window's parent
6292 * Repositions a window relative to its parent window.
6293 * For toplevel windows, window managers may ignore or modify the move;
6294 * you should probably use gtk_window_move() on a #GtkWindow widget
6295 * anyway, instead of using GDK functions. For child windows,
6296 * the move will reliably succeed.
6298 * If you're also planning to resize the window, use gdk_window_move_resize()
6299 * to both move and resize simultaneously, for a nicer visual effect.
6302 gdk_window_move (GdkWindow *window,
6306 gdk_window_move_resize_internal (window, TRUE, x, y, -1, -1);
6310 * gdk_window_resize:
6311 * @window: a #GdkWindow
6312 * @width: new width of the window
6313 * @height: new height of the window
6315 * Resizes @window; for toplevel windows, asks the window manager to resize
6316 * the window. The window manager may not allow the resize. When using GTK+,
6317 * use gtk_window_resize() instead of this low-level GDK function.
6319 * Windows may not be resized below 1x1.
6321 * If you're also planning to move the window, use gdk_window_move_resize()
6322 * to both move and resize simultaneously, for a nicer visual effect.
6325 gdk_window_resize (GdkWindow *window,
6329 gdk_window_move_resize_internal (window, FALSE, 0, 0, width, height);
6334 * gdk_window_move_resize:
6335 * @window: a #GdkWindow
6336 * @x: new X position relative to window's parent
6337 * @y: new Y position relative to window's parent
6339 * @height: new height
6341 * Equivalent to calling gdk_window_move() and gdk_window_resize(),
6342 * except that both operations are performed at once, avoiding strange
6343 * visual effects. (i.e. the user may be able to see the window first
6344 * move, then resize, if you don't use gdk_window_move_resize().)
6347 gdk_window_move_resize (GdkWindow *window,
6353 gdk_window_move_resize_internal (window, TRUE, x, y, width, height);
6358 * gdk_window_scroll:
6359 * @window: a #GdkWindow
6360 * @dx: Amount to scroll in the X direction
6361 * @dy: Amount to scroll in the Y direction
6363 * Scroll the contents of @window, both pixels and children, by the
6364 * given amount. @window itself does not move. Portions of the window
6365 * that the scroll operation brings in from offscreen areas are
6366 * invalidated. The invalidated region may be bigger than what would
6367 * strictly be necessary.
6369 * For X11, a minimum area will be invalidated if the window has no
6370 * subwindows, or if the edges of the window's parent do not extend
6371 * beyond the edges of the window. In other cases, a multi-step process
6372 * is used to scroll the window which may produce temporary visual
6373 * artifacts and unnecessary invalidations.
6376 gdk_window_scroll (GdkWindow *window,
6380 GdkWindow *impl_window;
6381 cairo_region_t *copy_area, *noncopy_area, *old_layered_area;
6382 cairo_region_t *old_native_child_region, *new_native_child_region;
6385 g_return_if_fail (GDK_IS_WINDOW (window));
6387 if (dx == 0 && dy == 0)
6390 if (window->destroyed)
6393 gdk_window_flush_if_exposing (window);
6395 old_layered_area = cairo_region_copy (window->layered_region);
6396 old_native_child_region = collect_native_child_region (window, FALSE);
6397 if (old_native_child_region)
6399 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6400 * source or destination for a delayed GdkWindowRegionMove. So, we need
6401 * to flush those here for the window and all overlapped subwindows
6402 * of it. And we need to do this before setting the new clips as those will be
6405 gdk_window_flush_recursive (window);
6409 /* First move all child windows, without causing invalidation */
6411 tmp_list = window->children;
6414 GdkWindow *child = GDK_WINDOW (tmp_list->data);
6416 /* Just update the positions, the bits will move with the copy */
6420 tmp_list = tmp_list->next;
6423 recompute_visible_regions (window, FALSE, TRUE);
6425 new_native_child_region = NULL;
6426 if (old_native_child_region)
6427 new_native_child_region = collect_native_child_region (window, FALSE);
6429 move_native_children (window);
6431 /* Then copy the actual bits of the window w/ child windows */
6433 impl_window = gdk_window_get_impl_window (window);
6435 /* Calculate the area that can be gotten by copying the old area */
6436 if (window->has_alpha_background)
6437 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6439 copy_area = cairo_region_copy (window->clip_region);
6440 cairo_region_subtract (copy_area, old_layered_area);
6441 if (old_native_child_region)
6443 /* Don't copy from inside native children, as this is copied by
6444 * the native window move.
6446 cairo_region_subtract (copy_area, old_native_child_region);
6448 /* Don't copy any bits that would cause a read from the moved
6449 native windows, as we can't read that data */
6450 cairo_region_subtract (copy_area, new_native_child_region);
6452 cairo_region_translate (copy_area, dx, dy);
6453 cairo_region_intersect (copy_area, window->clip_region);
6454 cairo_region_subtract (copy_area, window->layered_region);
6456 /* And the rest need to be invalidated */
6457 noncopy_area = cairo_region_copy (window->clip_region);
6458 cairo_region_subtract (noncopy_area, copy_area);
6460 /* convert from window coords to impl */
6461 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6463 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6465 /* Invalidate not copied regions */
6466 if (old_native_child_region)
6468 /* No need to expose the region that the native window move copies */
6469 cairo_region_translate (old_native_child_region, dx, dy);
6470 cairo_region_intersect (old_native_child_region, new_native_child_region);
6471 cairo_region_subtract (noncopy_area, old_native_child_region);
6473 gdk_window_invalidate_region_full (window, noncopy_area, TRUE, CLEAR_BG_ALL);
6475 cairo_region_destroy (noncopy_area);
6476 cairo_region_destroy (old_layered_area);
6478 if (old_native_child_region)
6480 cairo_region_destroy (old_native_child_region);
6481 cairo_region_destroy (new_native_child_region);
6484 _gdk_synthesize_crossing_events_for_geometry_change (window);
6488 * gdk_window_move_region:
6489 * @window: a #GdkWindow
6490 * @region: The #cairo_region_t to move
6491 * @dx: Amount to move in the X direction
6492 * @dy: Amount to move in the Y direction
6494 * Move the part of @window indicated by @region by @dy pixels in the Y
6495 * direction and @dx pixels in the X direction. The portions of @region
6496 * that not covered by the new position of @region are invalidated.
6498 * Child windows are not moved.
6503 gdk_window_move_region (GdkWindow *window,
6504 const cairo_region_t *region,
6508 GdkWindow *impl_window;
6509 cairo_region_t *nocopy_area;
6510 cairo_region_t *copy_area;
6512 g_return_if_fail (GDK_IS_WINDOW (window));
6513 g_return_if_fail (region != NULL);
6515 if (dx == 0 && dy == 0)
6518 if (window->destroyed)
6521 impl_window = gdk_window_get_impl_window (window);
6523 /* compute source regions */
6524 if (window->has_alpha_background)
6525 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6527 copy_area = cairo_region_copy (region);
6528 cairo_region_intersect (copy_area, window->clip_region_with_children);
6529 cairo_region_subtract (copy_area, window->layered_region);
6530 remove_layered_child_area (window, copy_area);
6532 /* compute destination regions */
6533 cairo_region_translate (copy_area, dx, dy);
6534 cairo_region_intersect (copy_area, window->clip_region_with_children);
6535 cairo_region_subtract (copy_area, window->layered_region);
6536 remove_layered_child_area (window, copy_area);
6538 /* Invalidate parts of the region (source and dest) not covered
6540 nocopy_area = cairo_region_copy (region);
6541 cairo_region_translate (nocopy_area, dx, dy);
6542 cairo_region_union (nocopy_area, region);
6543 cairo_region_subtract (nocopy_area, copy_area);
6545 /* convert from window coords to impl */
6546 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6547 move_region_on_impl (impl_window, copy_area, dx, dy); /* Takes ownership of copy_area */
6549 gdk_window_invalidate_region_full (window, nocopy_area, FALSE, CLEAR_BG_ALL);
6550 cairo_region_destroy (nocopy_area);
6554 * gdk_window_set_background:
6555 * @window: a #GdkWindow
6556 * @color: a #GdkColor
6558 * Sets the background color of @window. (However, when using GTK+,
6559 * set the background of a widget with gtk_widget_modify_bg() - if
6560 * you're an application - or gtk_style_set_background() - if you're
6561 * implementing a custom widget.)
6563 * See also gdk_window_set_background_pattern().
6565 * Deprecated: 3.4: Use gdk_window_set_background_rgba() instead.
6568 gdk_window_set_background (GdkWindow *window,
6569 const GdkColor *color)
6571 cairo_pattern_t *pattern;
6573 g_return_if_fail (GDK_IS_WINDOW (window));
6575 pattern = cairo_pattern_create_rgb (color->red / 65535.,
6576 color->green / 65535.,
6577 color->blue / 65535.);
6579 gdk_window_set_background_pattern (window, pattern);
6581 cairo_pattern_destroy (pattern);
6585 * gdk_window_set_background_rgba:
6586 * @window: a #GdkWindow
6587 * @rgba: a #GdkRGBA color
6589 * Sets the background color of @window.
6591 * See also gdk_window_set_background_pattern().
6594 gdk_window_set_background_rgba (GdkWindow *window,
6597 cairo_pattern_t *pattern;
6599 g_return_if_fail (GDK_IS_WINDOW (window));
6600 g_return_if_fail (rgba != NULL);
6602 pattern = cairo_pattern_create_rgba (rgba->red, rgba->green,
6603 rgba->blue, rgba->alpha);
6605 gdk_window_set_background_pattern (window, pattern);
6607 cairo_pattern_destroy (pattern);
6611 /* Updates has_alpha_background recursively for all child windows
6612 that have parent-relative alpha */
6614 _gdk_window_propagate_has_alpha_background (GdkWindow *window)
6619 for (l = window->children; l; l = l->next)
6623 if (child->background == NULL &&
6624 child->has_alpha_background != window->has_alpha_background)
6626 child->has_alpha_background = window->has_alpha_background;
6627 recompute_visible_regions (child, TRUE, FALSE);
6628 _gdk_window_propagate_has_alpha_background (child);
6634 * gdk_window_set_background_pattern:
6635 * @window: a #GdkWindow
6636 * @pattern: (allow-none): a pattern to use, or %NULL
6638 * Sets the background of @window.
6640 * A background of %NULL means that the window will inherit its
6641 * background form its parent window.
6643 * The windowing system will normally fill a window with its background
6644 * when the window is obscured then exposed.
6647 gdk_window_set_background_pattern (GdkWindow *window,
6648 cairo_pattern_t *pattern)
6651 cairo_pattern_type_t type;
6653 g_return_if_fail (GDK_IS_WINDOW (window));
6655 if (window->input_only)
6659 cairo_pattern_reference (pattern);
6660 if (window->background)
6661 cairo_pattern_destroy (window->background);
6662 window->background = pattern;
6666 if (pattern == NULL)
6668 /* parent-relative, copy has_alpha from parent */
6669 if (window->parent == NULL ||
6670 window->parent->window_type == GDK_WINDOW_ROOT)
6673 has_alpha = window->parent->has_alpha_background;
6677 type = cairo_pattern_get_type (pattern);
6679 if (type == CAIRO_PATTERN_TYPE_SOLID)
6682 cairo_pattern_get_rgba (pattern, NULL, NULL, NULL, &alpha);
6686 else if (type == CAIRO_PATTERN_TYPE_LINEAR ||
6687 type == CAIRO_PATTERN_TYPE_RADIAL)
6693 cairo_pattern_get_color_stop_count (pattern, &n);
6695 for (i = 0; i < n; i++)
6697 cairo_pattern_get_color_stop_rgba (pattern, i, NULL,
6698 NULL, NULL, NULL, &alpha);
6706 else if (type == CAIRO_PATTERN_TYPE_SURFACE)
6708 cairo_surface_t *surface;
6709 cairo_content_t content;
6711 cairo_pattern_get_surface (pattern, &surface);
6712 content = cairo_surface_get_content (surface);
6714 (content == CAIRO_CONTENT_ALPHA) ||
6715 (content == CAIRO_CONTENT_COLOR_ALPHA);
6719 if (has_alpha != window->has_alpha_background)
6721 window->has_alpha_background = has_alpha;
6722 recompute_visible_regions (window, TRUE, FALSE);
6724 _gdk_window_propagate_has_alpha_background (window);
6727 if (gdk_window_has_impl (window))
6729 GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6730 impl_class->set_background (window, pattern);
6733 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
6737 * gdk_window_get_background_pattern:
6740 * Gets the pattern used to clear the background on @window. If @window
6741 * does not have its own background and reuses the parent's, %NULL is
6742 * returned and you'll have to query it yourself.
6744 * Returns: (transfer none): The pattern to use for the background or
6745 * %NULL to use the parent's background.
6750 gdk_window_get_background_pattern (GdkWindow *window)
6752 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6754 return window->background;
6758 gdk_window_set_cursor_internal (GdkWindow *window,
6762 if (GDK_WINDOW_DESTROYED (window))
6765 if (window->window_type == GDK_WINDOW_ROOT ||
6766 window->window_type == GDK_WINDOW_FOREIGN)
6767 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_device_cursor (window, device, cursor);
6770 GdkPointerWindowInfo *pointer_info;
6771 GdkDisplay *display;
6773 display = gdk_window_get_display (window);
6774 pointer_info = _gdk_display_get_pointer_info (display, device);
6776 if (_gdk_window_event_parent_of (window, pointer_info->window_under_pointer))
6777 update_cursor (display, device);
6782 * gdk_window_get_cursor:
6783 * @window: a #GdkWindow
6785 * Retrieves a #GdkCursor pointer for the cursor currently set on the
6786 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6787 * there is no custom cursor set on the specified window, and it is
6788 * using the cursor for its parent window.
6790 * Return value: (transfer none): a #GdkCursor, or %NULL. The returned
6791 * object is owned by the #GdkWindow and should not be unreferenced
6792 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6798 gdk_window_get_cursor (GdkWindow *window)
6800 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6802 return window->cursor;
6806 * gdk_window_set_cursor:
6807 * @window: a #GdkWindow
6808 * @cursor: (allow-none): a cursor
6810 * Sets the default mouse pointer for a #GdkWindow. Use gdk_cursor_new_for_display()
6811 * or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor
6812 * invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument
6813 * to gdk_window_set_cursor() means that @window will use the cursor of its
6814 * parent window. Most windows should use this default.
6817 gdk_window_set_cursor (GdkWindow *window,
6820 GdkDisplay *display;
6822 g_return_if_fail (GDK_IS_WINDOW (window));
6824 display = gdk_window_get_display (window);
6828 g_object_unref (window->cursor);
6829 window->cursor = NULL;
6832 if (!GDK_WINDOW_DESTROYED (window))
6834 GdkDeviceManager *device_manager;
6838 window->cursor = g_object_ref (cursor);
6840 device_manager = gdk_display_get_device_manager (display);
6841 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
6843 for (d = devices; d; d = d->next)
6849 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
6852 gdk_window_set_cursor_internal (window, device, window->cursor);
6855 g_list_free (devices);
6856 g_object_notify (G_OBJECT (window), "cursor");
6861 * gdk_window_get_device_cursor:
6862 * @window: a #GdkWindow.
6863 * @device: a master, pointer #GdkDevice.
6865 * Retrieves a #GdkCursor pointer for the @device currently set on the
6866 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6867 * there is no custom cursor set on the specified window, and it is
6868 * using the cursor for its parent window.
6870 * Returns: (transfer none): a #GdkCursor, or %NULL. The returned
6871 * object is owned by the #GdkWindow and should not be unreferenced
6872 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6878 gdk_window_get_device_cursor (GdkWindow *window,
6881 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6882 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
6883 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
6884 g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, NULL);
6886 return g_hash_table_lookup (window->device_cursor, device);
6890 * gdk_window_set_device_cursor:
6891 * @window: a #Gdkwindow
6892 * @device: a master, pointer #GdkDevice
6893 * @cursor: a #GdkCursor
6895 * Sets a specific #GdkCursor for a given device when it gets inside @window.
6896 * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
6897 * the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
6898 * %NULL for the @cursor argument to gdk_window_set_cursor() means that
6899 * @window will use the cursor of its parent window. Most windows should
6905 gdk_window_set_device_cursor (GdkWindow *window,
6909 g_return_if_fail (GDK_IS_WINDOW (window));
6910 g_return_if_fail (GDK_IS_DEVICE (device));
6911 g_return_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD);
6912 g_return_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER);
6915 g_hash_table_remove (window->device_cursor, device);
6917 g_hash_table_replace (window->device_cursor, device, g_object_ref (cursor));
6919 gdk_window_set_cursor_internal (window, device, cursor);
6923 * gdk_window_get_geometry:
6924 * @window: a #GdkWindow
6925 * @x: (out) (allow-none): return location for X coordinate of window (relative to its parent)
6926 * @y: (out) (allow-none): return location for Y coordinate of window (relative to its parent)
6927 * @width: (out) (allow-none): return location for width of window
6928 * @height: (out) (allow-none): return location for height of window
6930 * Any of the return location arguments to this function may be %NULL,
6931 * if you aren't interested in getting the value of that field.
6933 * The X and Y coordinates returned are relative to the parent window
6934 * of @window, which for toplevels usually means relative to the
6935 * window decorations (titlebar, etc.) rather than relative to the
6936 * root window (screen-size background window).
6938 * On the X11 platform, the geometry is obtained from the X server,
6939 * so reflects the latest position of @window; this may be out-of-sync
6940 * with the position of @window delivered in the most-recently-processed
6941 * #GdkEventConfigure. gdk_window_get_position() in contrast gets the
6942 * position from the most recent configure event.
6945 * If @window is not a toplevel, it is <emphasis>much</emphasis> better
6946 * to call gdk_window_get_position(), gdk_window_get_width() and
6947 * gdk_window_get_height() instead, because it avoids the roundtrip to
6948 * the X server and because these functions support the full 32-bit
6949 * coordinate space, whereas gdk_window_get_geometry() is restricted to
6950 * the 16-bit coordinates of X11.
6954 gdk_window_get_geometry (GdkWindow *window,
6961 GdkWindowImplClass *impl_class;
6965 GDK_NOTE (MULTIHEAD,
6966 g_message ("gdk_window_get_geometry(): Window needs "
6967 "to be non-NULL to be multi head safe"));
6968 window = gdk_screen_get_root_window ((gdk_screen_get_default ()));
6971 g_return_if_fail (GDK_IS_WINDOW (window));
6973 if (!GDK_WINDOW_DESTROYED (window))
6975 if (gdk_window_has_impl (window))
6977 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6978 impl_class->get_geometry (window, x, y,
6980 /* This reports the position wrt to the native parent, we need to convert
6981 it to be relative to the client side parent */
6982 parent = window->parent;
6983 if (parent && !gdk_window_has_impl (parent))
6986 *x -= parent->abs_x;
6988 *y -= parent->abs_y;
6998 *width = window->width;
7000 *height = window->height;
7006 * gdk_window_get_width:
7007 * @window: a #GdkWindow
7009 * Returns the width of the given @window.
7011 * On the X11 platform the returned size is the size reported in the
7012 * most-recently-processed configure event, rather than the current
7013 * size on the X server.
7015 * Returns: The width of @window
7020 gdk_window_get_width (GdkWindow *window)
7022 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7024 return window->width;
7028 * gdk_window_get_height:
7029 * @window: a #GdkWindow
7031 * Returns the height of the given @window.
7033 * On the X11 platform the returned size is the size reported in the
7034 * most-recently-processed configure event, rather than the current
7035 * size on the X server.
7037 * Returns: The height of @window
7042 gdk_window_get_height (GdkWindow *window)
7044 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7046 return window->height;
7050 * gdk_window_get_origin:
7051 * @window: a #GdkWindow
7052 * @x: (out) (allow-none): return location for X coordinate
7053 * @y: (out) (allow-none): return location for Y coordinate
7055 * Obtains the position of a window in root window coordinates.
7056 * (Compare with gdk_window_get_position() and
7057 * gdk_window_get_geometry() which return the position of a window
7058 * relative to its parent window.)
7060 * Return value: not meaningful, ignore
7063 gdk_window_get_origin (GdkWindow *window,
7067 GdkWindowImplClass *impl_class;
7069 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7071 if (GDK_WINDOW_DESTROYED (window))
7080 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7081 impl_class->get_root_coords (window,
7090 * gdk_window_get_root_coords:
7091 * @window: a #GdkWindow
7092 * @x: X coordinate in window
7093 * @y: Y coordinate in window
7094 * @root_x: (out): return location for X coordinate
7095 * @root_y: (out): return location for Y coordinate
7097 * Obtains the position of a window position in root
7098 * window coordinates. This is similar to
7099 * gdk_window_get_origin() but allows you go pass
7100 * in any position in the window, not just the origin.
7105 gdk_window_get_root_coords (GdkWindow *window,
7111 GdkWindowImplClass *impl_class;
7113 g_return_if_fail (GDK_IS_WINDOW (window));
7115 if (GDK_WINDOW_DESTROYED (window))
7122 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7123 impl_class->get_root_coords (window,
7130 * gdk_window_coords_to_parent:
7131 * @window: a child window
7132 * @x: X coordinate in child's coordinate system
7133 * @y: Y coordinate in child's coordinate system
7134 * @parent_x: (out) (allow-none): return location for X coordinate
7135 * in parent's coordinate system, or %NULL
7136 * @parent_y: (out) (allow-none): return location for Y coordinate
7137 * in parent's coordinate system, or %NULL
7139 * Transforms window coordinates from a child window to its parent
7140 * window, where the parent window is the normal parent as returned by
7141 * gdk_window_get_parent() for normal windows, and the window's
7142 * embedder as returned by gdk_offscreen_window_get_embedder() for
7143 * offscreen windows.
7145 * For normal windows, calling this function is equivalent to adding
7146 * the return values of gdk_window_get_position() to the child coordinates.
7147 * For offscreen windows however (which can be arbitrarily transformed),
7148 * this function calls the GdkWindow::to-embedder: signal to translate
7151 * You should always use this function when writing generic code that
7152 * walks up a window hierarchy.
7154 * See also: gdk_window_coords_from_parent()
7159 gdk_window_coords_to_parent (GdkWindow *window,
7165 g_return_if_fail (GDK_IS_WINDOW (window));
7167 if (gdk_window_is_offscreen (window))
7171 to_embedder (window, x, y, &px, &py);
7182 *parent_x = x + window->x;
7185 *parent_y = y + window->y;
7190 * gdk_window_coords_from_parent:
7191 * @window: a child window
7192 * @parent_x: X coordinate in parent's coordinate system
7193 * @parent_y: Y coordinate in parent's coordinate system
7194 * @x: (out) (allow-none): return location for X coordinate in child's coordinate system
7195 * @y: (out) (allow-none): return location for Y coordinate in child's coordinate system
7197 * Transforms window coordinates from a parent window to a child
7198 * window, where the parent window is the normal parent as returned by
7199 * gdk_window_get_parent() for normal windows, and the window's
7200 * embedder as returned by gdk_offscreen_window_get_embedder() for
7201 * offscreen windows.
7203 * For normal windows, calling this function is equivalent to subtracting
7204 * the return values of gdk_window_get_position() from the parent coordinates.
7205 * For offscreen windows however (which can be arbitrarily transformed),
7206 * this function calls the GdkWindow::from-embedder: signal to translate
7209 * You should always use this function when writing generic code that
7210 * walks down a window hierarchy.
7212 * See also: gdk_window_coords_to_parent()
7217 gdk_window_coords_from_parent (GdkWindow *window,
7223 g_return_if_fail (GDK_IS_WINDOW (window));
7225 if (gdk_window_is_offscreen (window))
7229 from_embedder (window, parent_x, parent_y, &cx, &cy);
7240 *x = parent_x - window->x;
7243 *y = parent_y - window->y;
7248 * gdk_window_shape_combine_region:
7249 * @window: a #GdkWindow
7250 * @shape_region: (allow-none): region of window to be non-transparent
7251 * @offset_x: X position of @shape_region in @window coordinates
7252 * @offset_y: Y position of @shape_region in @window coordinates
7254 * Makes pixels in @window outside @shape_region be transparent,
7255 * so that the window may be nonrectangular.
7257 * If @shape_region is %NULL, the shape will be unset, so the whole
7258 * window will be opaque again. @offset_x and @offset_y are ignored
7259 * if @shape_region is %NULL.
7261 * On the X11 platform, this uses an X server extension which is
7262 * widely available on most common platforms, but not available on
7263 * very old X servers, and occasionally the implementation will be
7264 * buggy. On servers without the shape extension, this function
7267 * This function works on both toplevel and child windows.
7270 gdk_window_shape_combine_region (GdkWindow *window,
7271 const cairo_region_t *shape_region,
7275 cairo_region_t *old_region, *new_region, *diff;
7277 g_return_if_fail (GDK_IS_WINDOW (window));
7279 if (GDK_WINDOW_DESTROYED (window))
7282 if (!window->shape && shape_region == NULL)
7285 window->shaped = (shape_region != NULL);
7288 cairo_region_destroy (window->shape);
7291 if (GDK_WINDOW_IS_MAPPED (window))
7292 old_region = cairo_region_copy (window->clip_region);
7296 window->shape = cairo_region_copy (shape_region);
7297 cairo_region_translate (window->shape, offset_x, offset_y);
7300 window->shape = NULL;
7302 recompute_visible_regions (window, TRUE, FALSE);
7304 if (gdk_window_has_impl (window) &&
7305 !should_apply_clip_as_shape (window))
7306 apply_shape (window, window->shape);
7310 new_region = cairo_region_copy (window->clip_region);
7312 /* New area in the window, needs invalidation */
7313 diff = cairo_region_copy (new_region);
7314 cairo_region_subtract (diff, old_region);
7316 gdk_window_invalidate_region_full (window, diff, TRUE, CLEAR_BG_ALL);
7318 cairo_region_destroy (diff);
7320 if (!gdk_window_is_toplevel (window))
7322 /* New area in the non-root parent window, needs invalidation */
7323 diff = cairo_region_copy (old_region);
7324 cairo_region_subtract (diff, new_region);
7326 /* Adjust region to parent window coords */
7327 cairo_region_translate (diff, window->x, window->y);
7329 gdk_window_invalidate_region_full (window->parent, diff, TRUE, CLEAR_BG_ALL);
7331 cairo_region_destroy (diff);
7334 cairo_region_destroy (new_region);
7335 cairo_region_destroy (old_region);
7340 do_child_shapes (GdkWindow *window,
7344 cairo_region_t *region;
7348 r.width = window->width;
7349 r.height = window->height;
7351 region = cairo_region_create_rectangle (&r);
7352 remove_child_area (window, NULL, FALSE, region, NULL);
7354 if (merge && window->shape)
7355 cairo_region_subtract (region, window->shape);
7357 gdk_window_shape_combine_region (window, region, 0, 0);
7361 * gdk_window_set_child_shapes:
7362 * @window: a #GdkWindow
7364 * Sets the shape mask of @window to the union of shape masks
7365 * for all children of @window, ignoring the shape mask of @window
7366 * itself. Contrast with gdk_window_merge_child_shapes() which includes
7367 * the shape mask of @window in the masks to be merged.
7370 gdk_window_set_child_shapes (GdkWindow *window)
7372 g_return_if_fail (GDK_IS_WINDOW (window));
7374 do_child_shapes (window, FALSE);
7378 * gdk_window_merge_child_shapes:
7379 * @window: a #GdkWindow
7381 * Merges the shape masks for any child windows into the
7382 * shape mask for @window. i.e. the union of all masks
7383 * for @window and its children will become the new mask
7384 * for @window. See gdk_window_shape_combine_region().
7386 * This function is distinct from gdk_window_set_child_shapes()
7387 * because it includes @window's shape mask in the set of shapes to
7391 gdk_window_merge_child_shapes (GdkWindow *window)
7393 g_return_if_fail (GDK_IS_WINDOW (window));
7395 do_child_shapes (window, TRUE);
7399 * gdk_window_input_shape_combine_region:
7400 * @window: a #GdkWindow
7401 * @shape_region: region of window to be non-transparent
7402 * @offset_x: X position of @shape_region in @window coordinates
7403 * @offset_y: Y position of @shape_region in @window coordinates
7405 * Like gdk_window_shape_combine_region(), but the shape applies
7406 * only to event handling. Mouse events which happen while
7407 * the pointer position corresponds to an unset bit in the
7408 * mask will be passed on the window below @window.
7410 * An input shape is typically used with RGBA windows.
7411 * The alpha channel of the window defines which pixels are
7412 * invisible and allows for nicely antialiased borders,
7413 * and the input shape controls where the window is
7416 * On the X11 platform, this requires version 1.1 of the
7419 * On the Win32 platform, this functionality is not present and the
7420 * function does nothing.
7425 gdk_window_input_shape_combine_region (GdkWindow *window,
7426 const cairo_region_t *shape_region,
7430 GdkWindowImplClass *impl_class;
7432 g_return_if_fail (GDK_IS_WINDOW (window));
7434 if (GDK_WINDOW_DESTROYED (window))
7437 if (window->input_shape)
7438 cairo_region_destroy (window->input_shape);
7442 window->input_shape = cairo_region_copy (shape_region);
7443 cairo_region_translate (window->input_shape, offset_x, offset_y);
7446 window->input_shape = NULL;
7448 if (gdk_window_has_impl (window))
7450 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7451 impl_class->input_shape_combine_region (window, window->input_shape, 0, 0);
7454 /* Pointer may have e.g. moved outside window due to the input mask change */
7455 _gdk_synthesize_crossing_events_for_geometry_change (window);
7459 do_child_input_shapes (GdkWindow *window,
7463 cairo_region_t *region;
7467 r.width = window->width;
7468 r.height = window->height;
7470 region = cairo_region_create_rectangle (&r);
7471 remove_child_area (window, NULL, TRUE, region, NULL);
7473 if (merge && window->shape)
7474 cairo_region_subtract (region, window->shape);
7475 if (merge && window->input_shape)
7476 cairo_region_subtract (region, window->input_shape);
7478 gdk_window_input_shape_combine_region (window, region, 0, 0);
7483 * gdk_window_set_child_input_shapes:
7484 * @window: a #GdkWindow
7486 * Sets the input shape mask of @window to the union of input shape masks
7487 * for all children of @window, ignoring the input shape mask of @window
7488 * itself. Contrast with gdk_window_merge_child_input_shapes() which includes
7489 * the input shape mask of @window in the masks to be merged.
7494 gdk_window_set_child_input_shapes (GdkWindow *window)
7496 g_return_if_fail (GDK_IS_WINDOW (window));
7498 do_child_input_shapes (window, FALSE);
7502 * gdk_window_merge_child_input_shapes:
7503 * @window: a #GdkWindow
7505 * Merges the input shape masks for any child windows into the
7506 * input shape mask for @window. i.e. the union of all input masks
7507 * for @window and its children will become the new input mask
7508 * for @window. See gdk_window_input_shape_combine_region().
7510 * This function is distinct from gdk_window_set_child_input_shapes()
7511 * because it includes @window's input shape mask in the set of
7512 * shapes to be merged.
7517 gdk_window_merge_child_input_shapes (GdkWindow *window)
7519 g_return_if_fail (GDK_IS_WINDOW (window));
7521 do_child_input_shapes (window, TRUE);
7526 * gdk_window_set_static_gravities:
7527 * @window: a #GdkWindow
7528 * @use_static: %TRUE to turn on static gravity
7530 * Set the bit gravity of the given window to static, and flag it so
7531 * all children get static subwindow gravity. This is used if you are
7532 * implementing scary features that involve deep knowledge of the
7533 * windowing system. Don't worry about it unless you have to.
7535 * Return value: %TRUE if the server supports static gravity
7538 gdk_window_set_static_gravities (GdkWindow *window,
7539 gboolean use_static)
7541 GdkWindowImplClass *impl_class;
7543 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7545 if (gdk_window_has_impl (window))
7547 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7548 return impl_class->set_static_gravities (window, use_static);
7555 * gdk_window_get_composited:
7556 * @window: a #GdkWindow
7558 * Determines whether @window is composited.
7560 * See gdk_window_set_composited().
7562 * Returns: %TRUE if the window is composited.
7567 gdk_window_get_composited (GdkWindow *window)
7569 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7571 return window->composited;
7575 * gdk_window_set_composited:
7576 * @window: a #GdkWindow
7577 * @composited: %TRUE to set the window as composited
7579 * Sets a #GdkWindow as composited, or unsets it. Composited
7580 * windows do not automatically have their contents drawn to
7581 * the screen. Drawing is redirected to an offscreen buffer
7582 * and an expose event is emitted on the parent of the composited
7583 * window. It is the responsibility of the parent's expose handler
7584 * to manually merge the off-screen content onto the screen in
7585 * whatever way it sees fit. See <xref linkend="composited-window-example"/>
7588 * It only makes sense for child windows to be composited; see
7589 * gdk_window_set_opacity() if you need translucent toplevel
7592 * An additional effect of this call is that the area of this
7593 * window is no longer clipped from regions marked for
7594 * invalidation on its parent. Draws done on the parent
7595 * window are also no longer clipped by the child.
7597 * This call is only supported on some systems (currently,
7598 * only X11 with new enough Xcomposite and Xdamage extensions).
7599 * You must call gdk_display_supports_composite() to check if
7600 * setting a window as composited is supported before
7601 * attempting to do so.
7606 gdk_window_set_composited (GdkWindow *window,
7607 gboolean composited)
7609 GdkDisplay *display;
7610 GdkWindowImplClass *impl_class;
7612 g_return_if_fail (GDK_IS_WINDOW (window));
7614 composited = composited != FALSE;
7616 if (window->composited == composited)
7620 gdk_window_ensure_native (window);
7622 display = gdk_window_get_display (window);
7624 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7626 if (composited && (!gdk_display_supports_composite (display) || !impl_class->set_composited))
7628 g_warning ("gdk_window_set_composited called but "
7629 "compositing is not supported");
7633 impl_class->set_composited (window, composited);
7635 recompute_visible_regions (window, TRUE, FALSE);
7637 if (GDK_WINDOW_IS_MAPPED (window))
7638 gdk_window_invalidate_in_parent (window);
7640 window->composited = composited;
7644 * gdk_window_get_modal_hint:
7645 * @window: A toplevel #GdkWindow.
7647 * Determines whether or not the window manager is hinted that @window
7648 * has modal behaviour.
7650 * Return value: whether or not the window has the modal hint set.
7655 gdk_window_get_modal_hint (GdkWindow *window)
7657 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7659 return window->modal_hint;
7663 * gdk_window_get_accept_focus:
7664 * @window: a toplevel #GdkWindow.
7666 * Determines whether or not the desktop environment shuld be hinted that
7667 * the window does not want to receive input focus.
7669 * Return value: whether or not the window should receive input focus.
7674 gdk_window_get_accept_focus (GdkWindow *window)
7676 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7678 return window->accept_focus;
7682 * gdk_window_get_focus_on_map:
7683 * @window: a toplevel #GdkWindow.
7685 * Determines whether or not the desktop environment should be hinted that the
7686 * window does not want to receive input focus when it is mapped.
7688 * Return value: whether or not the window wants to receive input focus when
7694 gdk_window_get_focus_on_map (GdkWindow *window)
7696 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7698 return window->focus_on_map;
7702 * gdk_window_is_input_only:
7703 * @window: a toplevel #GdkWindow
7705 * Determines whether or not the window is an input only window.
7707 * Return value: %TRUE if @window is input only
7712 gdk_window_is_input_only (GdkWindow *window)
7714 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7716 return window->input_only;
7720 * gdk_window_is_shaped:
7721 * @window: a toplevel #GdkWindow
7723 * Determines whether or not the window is shaped.
7725 * Return value: %TRUE if @window is shaped
7730 gdk_window_is_shaped (GdkWindow *window)
7732 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7734 return window->shaped;
7738 _gdk_window_add_damage (GdkWindow *toplevel,
7739 cairo_region_t *damaged_region)
7741 GdkDisplay *display;
7742 GdkEvent event = { 0, };
7743 event.expose.type = GDK_DAMAGE;
7744 event.expose.window = toplevel;
7745 event.expose.send_event = FALSE;
7746 event.expose.region = damaged_region;
7747 cairo_region_get_extents (event.expose.region, &event.expose.area);
7748 display = gdk_window_get_display (event.expose.window);
7749 _gdk_event_queue_append (display, gdk_event_copy (&event));
7752 /* Gets the toplevel for a window as used for events,
7753 i.e. including offscreen parents */
7755 get_event_parent (GdkWindow *window)
7757 if (gdk_window_is_offscreen (window))
7758 return gdk_offscreen_window_get_embedder ((GdkWindow *)window);
7760 return window->parent;
7763 /* Gets the toplevel for a window as used for events,
7764 i.e. including offscreen parents going up to the native
7767 get_event_toplevel (GdkWindow *window)
7771 while ((parent = get_event_parent (window)) != NULL &&
7772 (parent->window_type != GDK_WINDOW_ROOT))
7779 _gdk_window_event_parent_of (GdkWindow *parent,
7790 w = get_event_parent (w);
7797 update_cursor (GdkDisplay *display,
7800 GdkWindow *cursor_window, *parent, *toplevel;
7801 GdkWindow *pointer_window;
7802 GdkWindowImplClass *impl_class;
7803 GdkPointerWindowInfo *pointer_info;
7804 GdkDeviceGrabInfo *grab;
7807 pointer_info = _gdk_display_get_pointer_info (display, device);
7808 pointer_window = pointer_info->window_under_pointer;
7810 /* We ignore the serials here and just pick the last grab
7811 we've sent, as that would shortly be used anyway. */
7812 grab = _gdk_display_get_last_device_grab (display, device);
7815 /* the pointer is not in a descendant of the grab window */
7816 !_gdk_window_event_parent_of (grab->window, pointer_window))
7818 /* use the cursor from the grab window */
7819 cursor_window = grab->window;
7823 /* otherwise use the cursor from the pointer window */
7824 cursor_window = pointer_window;
7827 /* Find the first window with the cursor actually set, as
7828 the cursor is inherited from the parent */
7829 while (cursor_window->cursor == NULL &&
7830 (parent = get_event_parent (cursor_window)) != NULL &&
7831 parent->window_type != GDK_WINDOW_ROOT)
7832 cursor_window = parent;
7834 cursor = g_hash_table_lookup (cursor_window->device_cursor, device);
7837 cursor = cursor_window->cursor;
7839 /* Set all cursors on toplevel, otherwise its tricky to keep track of
7840 * which native window has what cursor set. */
7841 toplevel = get_event_toplevel (pointer_window);
7842 impl_class = GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl);
7843 impl_class->set_device_cursor (toplevel, device, cursor);
7847 point_in_window (GdkWindow *window,
7852 x >= 0 && x < window->width &&
7853 y >= 0 && y < window->height &&
7854 (window->shape == NULL ||
7855 cairo_region_contains_point (window->shape,
7857 (window->input_shape == NULL ||
7858 cairo_region_contains_point (window->input_shape,
7863 convert_native_coords_to_toplevel (GdkWindow *window,
7866 gdouble *toplevel_x,
7867 gdouble *toplevel_y)
7874 while (!gdk_window_is_toplevel (window))
7878 window = window->parent;
7888 convert_toplevel_coords_to_window (GdkWindow *window,
7896 GList *children, *l;
7902 while ((parent = get_event_parent (window)) != NULL &&
7903 (parent->window_type != GDK_WINDOW_ROOT))
7905 children = g_list_prepend (children, window);
7909 for (l = children; l != NULL; l = l->next)
7910 gdk_window_coords_from_parent (l->data, x, y, &x, &y);
7912 g_list_free (children);
7919 pick_embedded_child (GdkWindow *window,
7926 g_signal_emit (window,
7927 signals[PICK_EMBEDDED_CHILD], 0,
7934 _gdk_window_find_child_at (GdkWindow *window,
7939 double child_x, child_y;
7942 if (point_in_window (window, x, y))
7944 /* Children is ordered in reverse stack order, i.e. first is topmost */
7945 for (l = window->children; l != NULL; l = l->next)
7949 if (!GDK_WINDOW_IS_MAPPED (sub))
7952 gdk_window_coords_from_parent ((GdkWindow *)sub,
7954 &child_x, &child_y);
7955 if (point_in_window (sub, child_x, child_y))
7956 return (GdkWindow *)sub;
7959 if (window->num_offscreen_children > 0)
7961 sub = pick_embedded_child (window,
7964 return (GdkWindow *)sub;
7972 _gdk_window_find_descendant_at (GdkWindow *window,
7979 gdouble child_x, child_y;
7983 if (point_in_window (window, x, y))
7988 /* Children is ordered in reverse stack order, i.e. first is topmost */
7989 for (l = window->children; l != NULL; l = l->next)
7993 if (!GDK_WINDOW_IS_MAPPED (sub))
7996 gdk_window_coords_from_parent ((GdkWindow *)sub,
7998 &child_x, &child_y);
7999 if (point_in_window (sub, child_x, child_y))
8009 window->num_offscreen_children > 0)
8011 sub = pick_embedded_child (window,
8017 from_embedder (sub, x, y, &x, &y);
8025 /* Not in window at all */
8039 * @window: a toplevel #GdkWindow
8041 * Emits a short beep associated to @window in the appropriate
8042 * display, if supported. Otherwise, emits a short beep on
8043 * the display just as gdk_display_beep().
8048 gdk_window_beep (GdkWindow *window)
8050 GdkDisplay *display;
8051 GdkWindow *toplevel;
8053 g_return_if_fail (GDK_IS_WINDOW (window));
8055 if (GDK_WINDOW_DESTROYED (window))
8058 toplevel = get_event_toplevel (window);
8059 display = gdk_window_get_display (window);
8063 if (GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)->beep (toplevel))
8067 /* If windows fail to beep, we beep the display. */
8068 gdk_display_beep (display);
8072 * gdk_window_set_support_multidevice:
8073 * @window: a #GdkWindow.
8074 * @support_multidevice: %TRUE to enable multidevice support in @window.
8076 * This function will enable multidevice features in @window.
8078 * Multidevice aware windows will need to handle properly multiple,
8079 * per device enter/leave events, device grabs and grab ownerships.
8084 gdk_window_set_support_multidevice (GdkWindow *window,
8085 gboolean support_multidevice)
8087 g_return_if_fail (GDK_IS_WINDOW (window));
8089 if (GDK_WINDOW_DESTROYED (window))
8092 if (window->support_multidevice == support_multidevice)
8095 window->support_multidevice = support_multidevice;
8097 /* FIXME: What to do if called when some pointers are inside the window ? */
8101 * gdk_window_get_support_multidevice:
8102 * @window: a #GdkWindow.
8104 * Returns %TRUE if the window is aware of the existence of multiple
8107 * Returns: %TRUE if the window handles multidevice features.
8112 gdk_window_get_support_multidevice (GdkWindow *window)
8114 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
8116 if (GDK_WINDOW_DESTROYED (window))
8119 return window->support_multidevice;
8122 static const guint type_masks[] = {
8123 GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE = 0 */
8124 GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1 */
8125 GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2 */
8126 GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3 */
8127 GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4 */
8128 GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5 */
8129 GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6 */
8130 GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE = 7 */
8131 GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS = 8 */
8132 GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE = 9 */
8133 GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY = 10 */
8134 GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY = 11 */
8135 GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE = 12 */
8136 GDK_STRUCTURE_MASK, /* GDK_CONFIGURE = 13 */
8137 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_MAP = 14 */
8138 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_UNMAP = 15 */
8139 GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY = 16 */
8140 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR = 17 */
8141 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18 */
8142 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY = 19 */
8143 GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN = 20 */
8144 GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT = 21 */
8145 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER = 22 */
8146 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE = 23 */
8147 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION = 24 */
8148 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS = 25 */
8149 GDK_ALL_EVENTS_MASK, /* GDK_DROP_START = 26 */
8150 GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED = 27 */
8151 GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT = 28 */
8152 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_VISIBILITY_NOTIFY = 29 */
8153 GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30 */
8154 GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK,/* GDK_SCROLL= 31 */
8155 0, /* GDK_WINDOW_STATE = 32 */
8156 0, /* GDK_SETTING = 33 */
8157 0, /* GDK_OWNER_CHANGE = 34 */
8158 0, /* GDK_GRAB_BROKEN = 35 */
8159 0, /* GDK_DAMAGE = 36 */
8161 G_STATIC_ASSERT (G_N_ELEMENTS (type_masks) == GDK_EVENT_LAST);
8163 /* send motion events if the right buttons are down */
8165 update_evmask_for_button_motion (guint evmask,
8166 GdkModifierType mask)
8168 if (evmask & GDK_BUTTON_MOTION_MASK &&
8169 mask & (GDK_BUTTON1_MASK |
8174 evmask |= GDK_POINTER_MOTION_MASK;
8176 if ((evmask & GDK_BUTTON1_MOTION_MASK && mask & GDK_BUTTON1_MASK) ||
8177 (evmask & GDK_BUTTON2_MOTION_MASK && mask & GDK_BUTTON2_MASK) ||
8178 (evmask & GDK_BUTTON3_MOTION_MASK && mask & GDK_BUTTON3_MASK))
8179 evmask |= GDK_POINTER_MOTION_MASK;
8185 is_button_type (GdkEventType type)
8187 return type == GDK_BUTTON_PRESS ||
8188 type == GDK_2BUTTON_PRESS ||
8189 type == GDK_3BUTTON_PRESS ||
8190 type == GDK_BUTTON_RELEASE ||
8195 is_motion_type (GdkEventType type)
8197 return type == GDK_MOTION_NOTIFY ||
8198 type == GDK_ENTER_NOTIFY ||
8199 type == GDK_LEAVE_NOTIFY;
8203 find_common_ancestor (GdkWindow *win1,
8207 GList *path1 = NULL, *path2 = NULL;
8208 GList *list1, *list2;
8211 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8213 path1 = g_list_prepend (path1, tmp);
8214 tmp = get_event_parent (tmp);
8218 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8220 path2 = g_list_prepend (path2, tmp);
8221 tmp = get_event_parent (tmp);
8227 while (list1 && list2 && (list1->data == list2->data))
8230 list1 = g_list_next (list1);
8231 list2 = g_list_next (list2);
8233 g_list_free (path1);
8234 g_list_free (path2);
8240 _gdk_make_event (GdkWindow *window,
8242 GdkEvent *event_in_queue,
8243 gboolean before_event)
8245 GdkEvent *event = gdk_event_new (type);
8247 GdkModifierType the_state;
8249 the_time = gdk_event_get_time (event_in_queue);
8250 gdk_event_get_state (event_in_queue, &the_state);
8252 event->any.window = g_object_ref (window);
8253 event->any.send_event = FALSE;
8254 if (event_in_queue && event_in_queue->any.send_event)
8255 event->any.send_event = TRUE;
8259 case GDK_MOTION_NOTIFY:
8260 event->motion.time = the_time;
8261 event->motion.axes = NULL;
8262 event->motion.state = the_state;
8265 case GDK_BUTTON_PRESS:
8266 case GDK_2BUTTON_PRESS:
8267 case GDK_3BUTTON_PRESS:
8268 case GDK_BUTTON_RELEASE:
8269 event->button.time = the_time;
8270 event->button.axes = NULL;
8271 event->button.state = the_state;
8275 event->scroll.time = the_time;
8276 event->scroll.state = the_state;
8280 case GDK_KEY_RELEASE:
8281 event->key.time = the_time;
8282 event->key.state = the_state;
8285 case GDK_ENTER_NOTIFY:
8286 case GDK_LEAVE_NOTIFY:
8287 event->crossing.time = the_time;
8288 event->crossing.state = the_state;
8291 case GDK_PROPERTY_NOTIFY:
8292 event->property.time = the_time;
8293 event->property.state = the_state;
8296 case GDK_SELECTION_CLEAR:
8297 case GDK_SELECTION_REQUEST:
8298 case GDK_SELECTION_NOTIFY:
8299 event->selection.time = the_time;
8302 case GDK_PROXIMITY_IN:
8303 case GDK_PROXIMITY_OUT:
8304 event->proximity.time = the_time;
8307 case GDK_DRAG_ENTER:
8308 case GDK_DRAG_LEAVE:
8309 case GDK_DRAG_MOTION:
8310 case GDK_DRAG_STATUS:
8311 case GDK_DROP_START:
8312 case GDK_DROP_FINISHED:
8313 event->dnd.time = the_time;
8316 case GDK_FOCUS_CHANGE:
8320 case GDK_CLIENT_EVENT:
8321 case GDK_VISIBILITY_NOTIFY:
8332 _gdk_event_queue_insert_before (gdk_window_get_display (window), event_in_queue, event);
8334 _gdk_event_queue_insert_after (gdk_window_get_display (window), event_in_queue, event);
8337 _gdk_event_queue_append (gdk_window_get_display (window), event);
8343 send_crossing_event (GdkDisplay *display,
8344 GdkWindow *toplevel,
8347 GdkCrossingMode mode,
8348 GdkNotifyType notify_type,
8349 GdkWindow *subwindow,
8351 GdkDevice *source_device,
8354 GdkModifierType mask,
8356 GdkEvent *event_in_queue,
8360 guint32 window_event_mask, type_event_mask;
8361 GdkDeviceGrabInfo *grab;
8362 gboolean block_event = FALSE;
8364 grab = _gdk_display_has_device_grab (display, device, serial);
8367 !grab->owner_events)
8369 /* !owner_event => only report events wrt grab window, ignore rest */
8370 if ((GdkWindow *)window != grab->window)
8372 window_event_mask = grab->event_mask;
8375 window_event_mask = window->event_mask;
8377 if (type == GDK_LEAVE_NOTIFY)
8379 type_event_mask = GDK_LEAVE_NOTIFY_MASK;
8380 window->devices_inside = g_list_remove (window->devices_inside, device);
8382 if (!window->support_multidevice && window->devices_inside)
8384 /* Block leave events unless it's the last pointer */
8390 type_event_mask = GDK_ENTER_NOTIFY_MASK;
8392 if (!window->support_multidevice && window->devices_inside)
8394 /* Only emit enter events for the first device */
8398 if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER &&
8399 gdk_device_get_mode (device) != GDK_MODE_DISABLED &&
8400 !g_list_find (window->devices_inside, device))
8401 window->devices_inside = g_list_prepend (window->devices_inside, device);
8407 if (window_event_mask & type_event_mask)
8409 event = _gdk_make_event ((GdkWindow *)window, type, event_in_queue, TRUE);
8410 gdk_event_set_device (event, device);
8413 gdk_event_set_source_device (event, source_device);
8415 event->crossing.time = time_;
8416 event->crossing.subwindow = subwindow;
8418 g_object_ref (subwindow);
8419 convert_toplevel_coords_to_window ((GdkWindow *)window,
8420 toplevel_x, toplevel_y,
8421 &event->crossing.x, &event->crossing.y);
8422 event->crossing.x_root = toplevel_x + toplevel->x;
8423 event->crossing.y_root = toplevel_y + toplevel->y;
8424 event->crossing.mode = mode;
8425 event->crossing.detail = notify_type;
8426 event->crossing.focus = FALSE;
8427 event->crossing.state = mask;
8432 /* The coordinates are in the toplevel window that src/dest are in.
8433 * src and dest are always (if != NULL) in the same toplevel, as
8434 * we get a leave-notify and set the window_under_pointer to null
8435 * before crossing to another toplevel.
8438 _gdk_synthesize_crossing_events (GdkDisplay *display,
8442 GdkDevice *source_device,
8443 GdkCrossingMode mode,
8446 GdkModifierType mask,
8448 GdkEvent *event_in_queue,
8450 gboolean non_linear)
8453 GdkWindow *win, *last, *next;
8457 GdkWindow *toplevel;
8458 GdkNotifyType notify_type;
8460 /* TODO: Don't send events to toplevel, as we get those from the windowing system */
8465 return; /* No crossings generated between src and dest */
8467 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER)
8469 if (a && gdk_window_get_device_events (src, device) == 0)
8472 if (b && gdk_window_get_device_events (dest, device) == 0)
8479 c = find_common_ancestor (a, b);
8481 non_linear |= (c != a) && (c != b);
8483 if (a) /* There might not be a source (i.e. if no previous pointer_in_window) */
8485 toplevel = gdk_window_get_toplevel (a);
8487 /* Traverse up from a to (excluding) c sending leave events */
8489 notify_type = GDK_NOTIFY_NONLINEAR;
8491 notify_type = GDK_NOTIFY_INFERIOR;
8493 notify_type = GDK_NOTIFY_ANCESTOR;
8494 send_crossing_event (display, toplevel,
8495 a, GDK_LEAVE_NOTIFY,
8498 NULL, device, source_device,
8499 toplevel_x, toplevel_y,
8507 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8509 notify_type = GDK_NOTIFY_VIRTUAL;
8512 win = get_event_parent (a);
8513 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8515 send_crossing_event (display, toplevel,
8516 win, GDK_LEAVE_NOTIFY,
8520 device, source_device,
8521 toplevel_x, toplevel_y,
8527 win = get_event_parent (win);
8532 if (b) /* Might not be a dest, e.g. if we're moving out of the window */
8534 toplevel = gdk_window_get_toplevel ((GdkWindow *)b);
8536 /* Traverse down from c to b */
8540 win = get_event_parent (b);
8541 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8543 path = g_list_prepend (path, win);
8544 win = get_event_parent (win);
8548 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8550 notify_type = GDK_NOTIFY_VIRTUAL;
8556 list = g_list_next (list);
8562 send_crossing_event (display, toplevel,
8563 win, GDK_ENTER_NOTIFY,
8567 device, source_device,
8568 toplevel_x, toplevel_y,
8578 notify_type = GDK_NOTIFY_NONLINEAR;
8580 notify_type = GDK_NOTIFY_ANCESTOR;
8582 notify_type = GDK_NOTIFY_INFERIOR;
8584 send_crossing_event (display, toplevel,
8585 b, GDK_ENTER_NOTIFY,
8589 device, source_device,
8590 toplevel_x, toplevel_y,
8597 /* Returns the window inside the event window with the pointer in it
8598 * at the specified coordinates, or NULL if its not in any child of
8599 * the toplevel. It also takes into account !owner_events grabs.
8602 get_pointer_window (GdkDisplay *display,
8603 GdkWindow *event_window,
8609 GdkWindow *pointer_window;
8610 GdkDeviceGrabInfo *grab;
8611 GdkPointerWindowInfo *pointer_info;
8613 pointer_info = _gdk_display_get_pointer_info (display, device);
8615 if (event_window == pointer_info->toplevel_under_pointer)
8617 _gdk_window_find_descendant_at (event_window,
8618 toplevel_x, toplevel_y,
8621 pointer_window = NULL;
8623 grab = _gdk_display_has_device_grab (display, device, serial);
8625 !grab->owner_events &&
8626 pointer_window != grab->window)
8627 pointer_window = NULL;
8629 return pointer_window;
8633 _gdk_display_set_window_under_pointer (GdkDisplay *display,
8637 GdkPointerWindowInfo *device_info;
8639 device_info = _gdk_display_get_pointer_info (display, device);
8641 if (device_info->window_under_pointer)
8642 g_object_unref (device_info->window_under_pointer);
8643 device_info->window_under_pointer = window;
8647 g_object_ref (window);
8648 update_cursor (display, device);
8651 _gdk_display_enable_motion_hints (display, device);
8656 * @window: the #GdkWindow which will own the grab (the grab window).
8657 * @owner_events: if %FALSE then all pointer events are reported with respect to
8658 * @window and are only reported if selected by @event_mask. If %TRUE then pointer
8659 * events for this application are reported as normal, but pointer events outside
8660 * this application are reported with respect to @window and only if selected by
8661 * @event_mask. In either mode, unreported events are discarded.
8662 * @event_mask: specifies the event mask, which is used in accordance with
8663 * @owner_events. Note that only pointer events (i.e. button and motion events)
8665 * @confine_to: (allow-none): If non-%NULL, the pointer will be confined to this
8666 * window during the grab. If the pointer is outside @confine_to, it will
8667 * automatically be moved to the closest edge of @confine_to and enter
8668 * and leave events will be generated as necessary.
8669 * @cursor: (allow-none): the cursor to display while the grab is active. If this is %NULL then
8670 * the normal cursors are used for @window and its descendants, and the cursor
8671 * for @window is used for all other windows.
8672 * @time_: the timestamp of the event which led to this pointer grab. This usually
8673 * comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if
8674 * the time isn't known.
8676 * Grabs the pointer (usually a mouse) so that all events are passed to this
8677 * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
8678 * the grab window becomes unviewable.
8679 * This overrides any previous pointer grab by this client.
8681 * Pointer grabs are used for operations which need complete control over mouse
8682 * events, even if the mouse leaves the application.
8683 * For example in GTK+ it is used for Drag and Drop, for dragging the handle in
8684 * the #GtkHPaned and #GtkVPaned widgets.
8686 * Note that if the event mask of an X window has selected both button press and
8687 * button release events, then a button press event will cause an automatic
8688 * pointer grab until the button is released.
8689 * X does this automatically since most applications expect to receive button
8690 * press and release events in pairs.
8691 * It is equivalent to a pointer grab on the window with @owner_events set to
8694 * If you set up anything at the time you take the grab that needs to be cleaned
8695 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8696 * are emitted when the grab ends unvoluntarily.
8698 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8700 * Deprecated: 3.0: Use gdk_device_grab() instead.
8703 gdk_pointer_grab (GdkWindow * window,
8704 gboolean owner_events,
8705 GdkEventMask event_mask,
8706 GdkWindow * confine_to,
8711 GdkDisplay *display;
8712 GdkDeviceManager *device_manager;
8714 GdkGrabStatus res = 0;
8716 GList *devices, *dev;
8718 g_return_val_if_fail (window != NULL, 0);
8719 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8720 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
8722 /* We need a native window for confine to to work, ensure we have one */
8725 if (!gdk_window_ensure_native (confine_to))
8727 g_warning ("Can't confine to grabbed window, not native");
8732 /* Non-viewable client side window => fail */
8733 if (!_gdk_window_has_impl (window) &&
8734 !gdk_window_is_viewable (window))
8735 return GDK_GRAB_NOT_VIEWABLE;
8737 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);
8752 serial = _gdk_display_get_next_serial (display);
8753 device_manager = gdk_display_get_device_manager (display);
8754 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8756 /* FIXME: Should this be generic to all backends? */
8757 /* FIXME: What happens with extended devices? */
8758 for (dev = devices; dev; dev = dev->next)
8762 if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
8765 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8768 get_native_grab_event_mask (event_mask),
8773 if (res == GDK_GRAB_SUCCESS)
8774 _gdk_display_add_device_grab (display,
8786 /* FIXME: handle errors when grabbing */
8788 g_list_free (devices);
8794 * gdk_keyboard_grab:
8795 * @window: the #GdkWindow which will own the grab (the grab window).
8796 * @owner_events: if %FALSE then all keyboard events are reported with respect to
8797 * @window. If %TRUE then keyboard events for this application are
8798 * reported as normal, but keyboard events outside this application
8799 * are reported with respect to @window. Both key press and key
8800 * release events are always reported, independant of the event mask
8801 * set by the application.
8802 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is
8805 * Grabs the keyboard so that all events are passed to this
8806 * application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
8807 * This overrides any previous keyboard grab by this client.
8809 * If you set up anything at the time you take the grab that needs to be cleaned
8810 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8811 * are emitted when the grab ends unvoluntarily.
8813 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8815 * Deprecated: 3.0: Use gdk_device_grab() instead.
8818 gdk_keyboard_grab (GdkWindow *window,
8819 gboolean owner_events,
8823 GdkDisplay *display;
8824 GdkDeviceManager *device_manager;
8826 GdkGrabStatus res = 0;
8828 GList *devices, *dev;
8830 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8832 /* Non-viewable client side window => fail */
8833 if (!_gdk_window_has_impl (window) &&
8834 !gdk_window_is_viewable (window))
8835 return GDK_GRAB_NOT_VIEWABLE;
8837 native = gdk_window_get_toplevel (window);
8839 while (gdk_window_is_offscreen (native))
8841 native = gdk_offscreen_window_get_embedder (native);
8843 if (native == NULL ||
8844 (!_gdk_window_has_impl (native) &&
8845 !gdk_window_is_viewable (native)))
8846 return GDK_GRAB_NOT_VIEWABLE;
8848 native = gdk_window_get_toplevel (native);
8851 display = gdk_window_get_display (window);
8852 serial = _gdk_display_get_next_serial (display);
8853 device_manager = gdk_display_get_device_manager (display);
8854 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8856 /* FIXME: Should this be generic to all backends? */
8857 /* FIXME: What happens with extended devices? */
8858 for (dev = devices; dev; dev = dev->next)
8862 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
8865 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8868 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
8873 if (res == GDK_GRAB_SUCCESS)
8874 _gdk_display_add_device_grab (display,
8885 /* FIXME: handle errors when grabbing */
8887 g_list_free (devices);
8893 * gdk_window_geometry_changed:
8894 * @window: an embedded offscreen #GdkWindow
8896 * This function informs GDK that the geometry of an embedded
8897 * offscreen window has changed. This is necessary for GDK to keep
8898 * track of which offscreen window the pointer is in.
8903 gdk_window_geometry_changed (GdkWindow *window)
8905 _gdk_synthesize_crossing_events_for_geometry_change (window);
8909 source_events_device_added (GdkDeviceManager *device_manager,
8914 GdkEventMask event_mask;
8915 GdkInputSource source;
8917 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_FLOATING)
8921 source = gdk_device_get_source (device);
8923 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8924 GINT_TO_POINTER (source)));
8926 gdk_window_set_device_events (window, device, event_mask);
8930 source_events_device_changed (GdkDeviceManager *device_manager,
8935 GdkInputSource source;
8936 GdkEventMask event_mask;
8940 type = gdk_device_get_device_type (device);
8941 source = gdk_device_get_source (device);
8943 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8944 GINT_TO_POINTER (source)));
8949 if (type == GDK_DEVICE_TYPE_FLOATING)
8951 /* The device was just floated, enable its event mask */
8952 gdk_window_set_device_events (window, device, event_mask);
8954 else if (type == GDK_DEVICE_TYPE_SLAVE)
8955 gdk_window_set_device_events (window, device, 0);
8959 * gdk_window_set_source_events:
8960 * @window: a #GdkWindow
8961 * @source: a #GdkInputSource to define the source class.
8962 * @event_mask: event mask for @window
8964 * Sets the event mask for any floating device (i.e. not attached to any
8965 * visible pointer) that has the source defined as @source. This event
8966 * mask will be applied both to currently existing, newly added devices
8967 * after this call, and devices being attached/detached.
8972 gdk_window_set_source_events (GdkWindow *window,
8973 GdkInputSource source,
8974 GdkEventMask event_mask)
8976 GdkDeviceManager *device_manager;
8977 GdkDisplay *display;
8981 g_return_if_fail (GDK_IS_WINDOW (window));
8983 display = gdk_window_get_display (window);
8984 device_manager = gdk_display_get_device_manager (display);
8986 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
8988 /* Set event mask for existing devices */
8989 for (d = devices; d; d = d->next)
8991 GdkDevice *device = d->data;
8993 if (source == gdk_device_get_source (device))
8994 gdk_window_set_device_events (window, device, event_mask);
8997 g_list_free (devices);
8999 /* Update accounting */
9000 if (G_UNLIKELY (!window->source_event_masks))
9001 window->source_event_masks = g_hash_table_new (NULL, NULL);
9004 g_hash_table_insert (window->source_event_masks,
9005 GUINT_TO_POINTER (source),
9006 GUINT_TO_POINTER (event_mask));
9008 g_hash_table_remove (window->source_event_masks,
9009 GUINT_TO_POINTER (source));
9011 size = g_hash_table_size (window->source_event_masks);
9013 /* Update handler if needed */
9014 if (!window->device_added_handler_id && size > 0)
9016 window->device_added_handler_id =
9017 g_signal_connect (device_manager, "device-added",
9018 G_CALLBACK (source_events_device_added), window);
9019 window->device_changed_handler_id =
9020 g_signal_connect (device_manager, "device-changed",
9021 G_CALLBACK (source_events_device_changed), window);
9023 else if (window->device_added_handler_id && size == 0)
9024 g_signal_handler_disconnect (device_manager, window->device_added_handler_id);
9028 * gdk_window_get_source_events:
9029 * @window: a #GdkWindow
9030 * @source: a #GdkInputSource to define the source class.
9032 * Returns the event mask for @window corresponding to the device class specified
9035 * Returns: source event mask for @window
9038 gdk_window_get_source_events (GdkWindow *window,
9039 GdkInputSource source)
9041 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
9043 return GPOINTER_TO_UINT (g_hash_table_lookup (window->source_event_masks,
9044 GUINT_TO_POINTER (source)));
9048 do_synthesize_crossing_event (gpointer data)
9050 GdkDisplay *display;
9051 GdkWindow *changed_toplevel;
9052 GHashTableIter iter;
9053 gpointer key, value;
9056 changed_toplevel = data;
9058 changed_toplevel->synthesize_crossing_event_queued = FALSE;
9060 if (GDK_WINDOW_DESTROYED (changed_toplevel))
9063 display = gdk_window_get_display (changed_toplevel);
9064 serial = _gdk_display_get_next_serial (display);
9065 g_hash_table_iter_init (&iter, display->pointers_info);
9067 while (g_hash_table_iter_next (&iter, &key, &value))
9069 GdkWindow *new_window_under_pointer;
9070 GdkPointerWindowInfo *pointer_info = value;
9071 GdkDevice *device = key;
9073 if (changed_toplevel == pointer_info->toplevel_under_pointer)
9075 new_window_under_pointer =
9076 get_pointer_window (display, changed_toplevel,
9078 pointer_info->toplevel_x,
9079 pointer_info->toplevel_y,
9081 if (new_window_under_pointer != pointer_info->window_under_pointer)
9083 _gdk_synthesize_crossing_events (display,
9084 pointer_info->window_under_pointer,
9085 new_window_under_pointer,
9087 GDK_CROSSING_NORMAL,
9088 pointer_info->toplevel_x,
9089 pointer_info->toplevel_y,
9090 pointer_info->state,
9095 _gdk_display_set_window_under_pointer (display, device, new_window_under_pointer);
9104 _gdk_synthesize_crossing_events_for_geometry_change (GdkWindow *changed_window)
9106 GdkWindow *toplevel;
9108 toplevel = get_event_toplevel (changed_window);
9110 if (!toplevel->synthesize_crossing_event_queued)
9112 toplevel->synthesize_crossing_event_queued = TRUE;
9114 gdk_threads_add_idle_full (GDK_PRIORITY_EVENTS - 1,
9115 do_synthesize_crossing_event,
9116 g_object_ref (toplevel),
9121 /* Don't use for crossing events */
9123 get_event_window (GdkDisplay *display,
9125 GdkWindow *pointer_window,
9127 GdkModifierType mask,
9132 GdkWindow *grab_window;
9133 GdkDeviceGrabInfo *grab;
9135 grab = _gdk_display_has_device_grab (display, device, serial);
9137 if (grab != NULL && !grab->owner_events)
9139 evmask = grab->event_mask;
9140 evmask = update_evmask_for_button_motion (evmask, mask);
9142 grab_window = grab->window;
9144 if (evmask & type_masks[type])
9147 *evmask_out = evmask;
9154 while (pointer_window != NULL)
9156 evmask = pointer_window->event_mask;
9157 evmask = update_evmask_for_button_motion (evmask, mask);
9159 if (evmask & type_masks[type])
9162 *evmask_out = evmask;
9163 return pointer_window;
9166 pointer_window = get_event_parent (pointer_window);
9172 evmask = grab->event_mask;
9173 evmask = update_evmask_for_button_motion (evmask, mask);
9175 if (evmask & type_masks[type])
9178 *evmask_out = evmask;
9179 return grab->window;
9189 proxy_pointer_event (GdkDisplay *display,
9190 GdkEvent *source_event,
9193 GdkWindow *toplevel_window, *event_window;
9194 GdkWindow *pointer_window;
9195 GdkPointerWindowInfo *pointer_info;
9196 GdkDevice *device, *source_device;
9199 gdouble toplevel_x, toplevel_y;
9201 gboolean non_linear;
9203 event_window = source_event->any.window;
9204 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9205 gdk_event_get_state (source_event, &state);
9206 time_ = gdk_event_get_time (source_event);
9207 device = gdk_event_get_device (source_event);
9208 source_device = gdk_event_get_source_device (source_event);
9209 pointer_info = _gdk_display_get_pointer_info (display, device);
9210 toplevel_window = convert_native_coords_to_toplevel (event_window,
9211 toplevel_x, toplevel_y,
9212 &toplevel_x, &toplevel_y);
9215 if ((source_event->type == GDK_LEAVE_NOTIFY ||
9216 source_event->type == GDK_ENTER_NOTIFY) &&
9217 (source_event->crossing.detail == GDK_NOTIFY_NONLINEAR ||
9218 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))
9221 /* If we get crossing events with subwindow unexpectedly being NULL
9222 that means there is a native subwindow that gdk doesn't know about.
9223 We track these and forward them, with the correct virtual window
9225 This is important to get right, as metacity uses gdk for the frame
9226 windows, but gdk doesn't know about the client windows reparented
9228 if (((source_event->type == GDK_LEAVE_NOTIFY &&
9229 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9230 (source_event->type == GDK_ENTER_NOTIFY &&
9231 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9232 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9233 source_event->crossing.subwindow == NULL)
9235 /* Left for an unknown (to gdk) subwindow */
9237 /* Send leave events from window under pointer to event window
9238 that will get the subwindow == NULL window */
9239 _gdk_synthesize_crossing_events (display,
9240 pointer_info->window_under_pointer,
9242 device, source_device,
9243 source_event->crossing.mode,
9244 toplevel_x, toplevel_y,
9250 /* Send subwindow == NULL event */
9251 send_crossing_event (display,
9255 source_event->crossing.mode,
9256 source_event->crossing.detail,
9258 device, source_device,
9259 toplevel_x, toplevel_y,
9264 _gdk_display_set_window_under_pointer (display, device, NULL);
9268 pointer_window = get_pointer_window (display, toplevel_window, device,
9269 toplevel_x, toplevel_y, serial);
9271 if (((source_event->type == GDK_ENTER_NOTIFY &&
9272 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9273 (source_event->type == GDK_LEAVE_NOTIFY &&
9274 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9275 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9276 source_event->crossing.subwindow == NULL)
9278 /* Entered from an unknown (to gdk) subwindow */
9280 /* Send subwindow == NULL event */
9281 send_crossing_event (display,
9285 source_event->crossing.mode,
9286 source_event->crossing.detail,
9288 device, source_device,
9289 toplevel_x, toplevel_y,
9294 /* Send enter events from event window to pointer_window */
9295 _gdk_synthesize_crossing_events (display,
9298 device, source_device,
9299 source_event->crossing.mode,
9300 toplevel_x, toplevel_y,
9303 serial, non_linear);
9304 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9308 if (pointer_info->window_under_pointer != pointer_window)
9310 /* Either a toplevel crossing notify that ended up inside a child window,
9311 or a motion notify that got into another child window */
9313 /* Different than last time, send crossing events */
9314 _gdk_synthesize_crossing_events (display,
9315 pointer_info->window_under_pointer,
9317 device, source_device,
9318 GDK_CROSSING_NORMAL,
9319 toplevel_x, toplevel_y,
9322 serial, non_linear);
9323 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9325 else if (source_event->type == GDK_MOTION_NOTIFY)
9327 GdkWindow *event_win;
9331 event_win = get_event_window (display,
9340 gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9341 gdk_window_get_device_events (event_win, device) == 0)
9347 (evmask & GDK_POINTER_MOTION_HINT_MASK))
9349 gulong *device_serial;
9351 device_serial = g_hash_table_lookup (display->motion_hint_info, device);
9353 if (!device_serial ||
9354 (*device_serial != 0 &&
9355 serial < *device_serial))
9356 event_win = NULL; /* Ignore event */
9360 *device_serial = G_MAXULONG;
9364 if (event_win && !display->ignore_core_events)
9366 event = _gdk_make_event (event_win, GDK_MOTION_NOTIFY, source_event, FALSE);
9367 event->motion.time = time_;
9368 convert_toplevel_coords_to_window (event_win,
9369 toplevel_x, toplevel_y,
9370 &event->motion.x, &event->motion.y);
9371 event->motion.x_root = source_event->motion.x_root;
9372 event->motion.y_root = source_event->motion.y_root;
9373 event->motion.state = state;
9374 event->motion.is_hint = is_hint;
9375 event->motion.device = source_event->motion.device;
9376 event->motion.axes = g_memdup (source_event->motion.axes,
9377 sizeof (gdouble) * gdk_device_get_n_axes (source_event->motion.device));
9378 gdk_event_set_source_device (event, source_device);
9382 /* unlink all move events from queue.
9383 We handle our own, including our emulated masks. */
9387 #define GDK_ANY_BUTTON_MASK (GDK_BUTTON1_MASK | \
9388 GDK_BUTTON2_MASK | \
9389 GDK_BUTTON3_MASK | \
9390 GDK_BUTTON4_MASK | \
9394 proxy_button_event (GdkEvent *source_event,
9397 GdkWindow *toplevel_window, *event_window;
9398 GdkWindow *event_win;
9399 GdkWindow *pointer_window;
9405 gdouble toplevel_x, toplevel_y;
9406 GdkDisplay *display;
9408 GdkDevice *device, *source_device;
9410 type = source_event->any.type;
9411 event_window = source_event->any.window;
9412 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9413 gdk_event_get_state (source_event, &state);
9414 time_ = gdk_event_get_time (source_event);
9415 device = gdk_event_get_device (source_event);
9416 source_device = gdk_event_get_source_device (source_event);
9417 display = gdk_window_get_display (source_event->any.window);
9418 toplevel_window = convert_native_coords_to_toplevel (event_window,
9419 toplevel_x, toplevel_y,
9420 &toplevel_x, &toplevel_y);
9422 if (type == GDK_BUTTON_PRESS &&
9423 !source_event->any.send_event &&
9424 _gdk_display_has_device_grab (display, device, serial) == NULL)
9427 _gdk_window_find_descendant_at (toplevel_window,
9428 toplevel_x, toplevel_y,
9431 /* Find the event window, that gets the grab */
9434 (parent = get_event_parent (w)) != NULL &&
9435 parent->window_type != GDK_WINDOW_ROOT)
9437 if (w->event_mask & GDK_BUTTON_PRESS_MASK)
9441 pointer_window = (GdkWindow *)w;
9443 _gdk_display_add_device_grab (display,
9449 gdk_window_get_events (pointer_window),
9453 _gdk_display_device_grab_update (display, device, source_device, serial);
9456 pointer_window = get_pointer_window (display, toplevel_window, device,
9457 toplevel_x, toplevel_y,
9460 event_win = get_event_window (display,
9466 if (event_win == NULL || display->ignore_core_events)
9469 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9470 gdk_window_get_device_events (event_win, device) == 0)
9473 event = _gdk_make_event (event_win, type, source_event, FALSE);
9477 case GDK_BUTTON_PRESS:
9478 case GDK_BUTTON_RELEASE:
9479 event->button.button = source_event->button.button;
9480 convert_toplevel_coords_to_window (event_win,
9481 toplevel_x, toplevel_y,
9482 &event->button.x, &event->button.y);
9483 event->button.x_root = source_event->button.x_root;
9484 event->button.y_root = source_event->button.y_root;
9485 event->button.state = state;
9486 event->button.device = source_event->button.device;
9487 event->button.axes = g_memdup (source_event->button.axes,
9488 sizeof (gdouble) * gdk_device_get_n_axes (source_event->button.device));
9490 gdk_event_set_source_device (event, source_device);
9492 if (type == GDK_BUTTON_PRESS)
9493 _gdk_event_button_generate (display, event);
9497 event->scroll.direction = source_event->scroll.direction;
9498 convert_toplevel_coords_to_window (event_win,
9499 toplevel_x, toplevel_y,
9500 &event->scroll.x, &event->scroll.y);
9501 event->scroll.x_root = source_event->scroll.x_root;
9502 event->scroll.y_root = source_event->scroll.y_root;
9503 event->scroll.state = state;
9504 event->scroll.device = source_event->scroll.device;
9505 gdk_event_set_source_device (event, source_device);
9512 return TRUE; /* Always unlink original, we want to obey the emulated event mask */
9515 #ifdef DEBUG_WINDOW_PRINTING
9517 gdk_window_print (GdkWindow *window,
9521 const char *window_types[] = {
9531 g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", window,
9532 window->user_data ? g_type_name_from_instance (window->user_data) : "no widget",
9533 window->x, window->y,
9534 window->width, window->height
9537 if (gdk_window_has_impl (window))
9539 #ifdef GDK_WINDOWING_X11
9540 g_print (" impl(0x%lx)", gdk_x11_window_get_xid (window));
9544 if (window->window_type != GDK_WINDOW_CHILD)
9545 g_print (" %s", window_types[window->window_type]);
9547 if (window->input_only)
9548 g_print (" input-only");
9551 g_print (" shaped");
9553 if (!gdk_window_is_visible ((GdkWindow *)window))
9554 g_print (" hidden");
9556 g_print (" abs[%d,%d]",
9557 window->abs_x, window->abs_y);
9559 cairo_region_get_extents (window->clip_region, &r);
9560 if (cairo_region_is_empty (window->clip_region))
9561 g_print (" clipbox[empty]");
9563 g_print (" clipbox[%d,%d %dx%d]", r.x, r.y, r.width, r.height);
9570 gdk_window_print_tree (GdkWindow *window,
9572 gboolean include_input_only)
9576 if (window->input_only && !include_input_only)
9579 gdk_window_print (window, indent);
9581 for (l = window->children; l != NULL; l = l->next)
9582 gdk_window_print_tree (l->data, indent + 4, include_input_only);
9585 #endif /* DEBUG_WINDOW_PRINTING */
9588 _gdk_windowing_got_event (GdkDisplay *display,
9593 GdkWindow *event_window;
9595 gboolean unlink_event;
9596 guint old_state, old_button;
9597 GdkDeviceGrabInfo *button_release_grab;
9598 GdkPointerWindowInfo *pointer_info;
9599 GdkDevice *device, *source_device;
9600 gboolean is_toplevel;
9602 if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
9603 display->last_event_time = gdk_event_get_time (event);
9605 device = gdk_event_get_device (event);
9606 source_device = gdk_event_get_source_device (event);
9612 g_object_get (device, "input-mode", &mode, NULL);
9613 _gdk_display_device_grab_update (display, device, source_device, serial);
9615 if (mode == GDK_MODE_DISABLED ||
9616 !_gdk_display_check_grab_ownership (display, device, serial))
9618 /* Device events are blocked by another
9619 * device grab, or the device is disabled
9621 unlink_event = TRUE;
9626 event_window = event->any.window;
9630 pointer_info = _gdk_display_get_pointer_info (display, device);
9632 #ifdef DEBUG_WINDOW_PRINTING
9633 if (event->type == GDK_KEY_PRESS &&
9634 (event->key.keyval == 0xa7 ||
9635 event->key.keyval == 0xbd))
9637 gdk_window_print_tree (event_window, 0,
9638 event->key.keyval == 0xbd);
9642 if (event->type == GDK_VISIBILITY_NOTIFY)
9644 event_window->native_visibility = event->visibility.state;
9645 gdk_window_update_visibility_recursively (event_window,
9650 if (!(is_button_type (event->type) ||
9651 is_motion_type (event->type)) ||
9652 event_window->window_type == GDK_WINDOW_ROOT)
9655 is_toplevel = gdk_window_is_toplevel (event_window);
9657 if ((event->type == GDK_ENTER_NOTIFY ||
9658 event->type == GDK_LEAVE_NOTIFY) &&
9659 (event->crossing.mode == GDK_CROSSING_GRAB ||
9660 event->crossing.mode == GDK_CROSSING_UNGRAB) &&
9661 (_gdk_display_has_device_grab (display, device, serial) ||
9662 event->crossing.detail == GDK_NOTIFY_INFERIOR))
9664 /* We synthesize all crossing events due to grabs ourselves,
9665 * so we ignore the native ones caused by our native pointer_grab
9666 * calls. Otherwise we would proxy these crossing event and cause
9667 * multiple copies of crossing events for grabs.
9669 * We do want to handle grabs from other clients though, as for
9670 * instance alt-tab in metacity causes grabs like these and
9671 * we want to handle those. Thus the has_pointer_grab check.
9673 * Implicit grabs on child windows create some grabbing events
9674 * that are sent before the button press. This means we can't
9675 * detect these with the has_pointer_grab check (as the implicit
9676 * grab is only noticed when we get button press event), so we
9677 * detect these events by checking for INFERIOR enter or leave
9678 * events. These should never be a problem to filter out.
9681 /* We ended up in this window after some (perhaps other clients)
9682 grab, so update the toplevel_under_window state */
9684 event->type == GDK_ENTER_NOTIFY &&
9685 event->crossing.mode == GDK_CROSSING_UNGRAB)
9687 if (pointer_info->toplevel_under_pointer)
9688 g_object_unref (pointer_info->toplevel_under_pointer);
9689 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9692 unlink_event = TRUE;
9696 /* Track toplevel_under_pointer */
9699 if (event->type == GDK_ENTER_NOTIFY &&
9700 event->crossing.detail != GDK_NOTIFY_INFERIOR)
9702 if (pointer_info->toplevel_under_pointer)
9703 g_object_unref (pointer_info->toplevel_under_pointer);
9704 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9706 else if (event->type == GDK_LEAVE_NOTIFY &&
9707 event->crossing.detail != GDK_NOTIFY_INFERIOR &&
9708 pointer_info->toplevel_under_pointer == event_window)
9710 if (pointer_info->toplevel_under_pointer)
9711 g_object_unref (pointer_info->toplevel_under_pointer);
9712 pointer_info->toplevel_under_pointer = NULL;
9716 /* Store last pointer window and position/state */
9717 old_state = pointer_info->state;
9718 old_button = pointer_info->button;
9720 gdk_event_get_coords (event, &x, &y);
9721 convert_native_coords_to_toplevel (event_window, x, y, &x, &y);
9722 pointer_info->toplevel_x = x;
9723 pointer_info->toplevel_y = y;
9724 gdk_event_get_state (event, &pointer_info->state);
9725 if (event->type == GDK_BUTTON_PRESS ||
9726 event->type == GDK_BUTTON_RELEASE)
9727 pointer_info->button = event->button.button;
9730 (pointer_info->state != old_state ||
9731 pointer_info->button != old_button))
9732 _gdk_display_enable_motion_hints (display, device);
9734 unlink_event = FALSE;
9735 if (is_motion_type (event->type))
9736 unlink_event = proxy_pointer_event (display,
9739 else if (is_button_type (event->type))
9740 unlink_event = proxy_button_event (event,
9743 if (event->type == GDK_BUTTON_RELEASE &&
9744 !event->any.send_event)
9746 button_release_grab =
9747 _gdk_display_has_device_grab (display, device, serial);
9748 if (button_release_grab &&
9749 button_release_grab->implicit &&
9750 (event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
9752 button_release_grab->serial_end = serial;
9753 button_release_grab->implicit_ungrab = FALSE;
9754 _gdk_display_device_grab_update (display, device, source_device, serial);
9761 _gdk_event_queue_remove_link (display, event_link);
9762 g_list_free_1 (event_link);
9763 gdk_event_free (event);
9768 * gdk_window_create_similar_surface:
9769 * @window: window to make new surface similar to
9770 * @content: the content for the new surface
9771 * @width: width of the new surface
9772 * @height: height of the new surface
9774 * Create a new surface that is as compatible as possible with the
9775 * given @window. For example the new surface will have the same
9776 * fallback resolution and font options as @window. Generally, the new
9777 * surface will also use the same backend as @window, unless that is
9778 * not possible for some reason. The type of the returned surface may
9779 * be examined with cairo_surface_get_type().
9781 * Initially the surface contents are all 0 (transparent if contents
9782 * have transparency, black otherwise.)
9784 * Returns: a pointer to the newly allocated surface. The caller
9785 * owns the surface and should call cairo_surface_destroy() when done
9788 * This function always returns a valid pointer, but it will return a
9789 * pointer to a "nil" surface if @other is already in an error state
9790 * or any other error occurs.
9795 gdk_window_create_similar_surface (GdkWindow * window,
9796 cairo_content_t content,
9800 cairo_surface_t *window_surface, *surface;
9802 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
9804 window_surface = _gdk_window_ref_cairo_surface (window);
9806 switch (_gdk_rendering_mode)
9808 case GDK_RENDERING_MODE_RECORDING:
9810 cairo_rectangle_t rect = { 0, 0, width, height };
9811 surface = cairo_recording_surface_create (content, &rect);
9814 case GDK_RENDERING_MODE_IMAGE:
9815 surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
9816 content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
9819 case GDK_RENDERING_MODE_SIMILAR:
9821 surface = cairo_surface_create_similar (window_surface,
9827 cairo_surface_destroy (window_surface);
9834 * @window: a #GdkWindow
9835 * @timestamp: timestamp of the event triggering the window focus
9837 * Sets keyboard focus to @window. In most cases, gtk_window_present()
9838 * should be used on a #GtkWindow, rather than calling this function.
9842 gdk_window_focus (GdkWindow *window,
9845 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->focus (window, timestamp);
9849 * gdk_window_set_type_hint:
9850 * @window: A toplevel #GdkWindow
9851 * @hint: A hint of the function this window will have
9853 * The application can use this call to provide a hint to the window
9854 * manager about the functionality of a window. The window manager
9855 * can use this information when determining the decoration and behaviour
9858 * The hint must be set before the window is mapped.
9861 gdk_window_set_type_hint (GdkWindow *window,
9862 GdkWindowTypeHint hint)
9864 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_type_hint (window, hint);
9868 * gdk_window_get_type_hint:
9869 * @window: A toplevel #GdkWindow
9871 * This function returns the type hint set for a window.
9873 * Return value: The type hint set for @window
9878 gdk_window_get_type_hint (GdkWindow *window)
9880 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_type_hint (window);
9884 * gdk_window_set_modal_hint:
9885 * @window: A toplevel #GdkWindow
9886 * @modal: %TRUE if the window is modal, %FALSE otherwise.
9888 * The application can use this hint to tell the window manager
9889 * that a certain window has modal behaviour. The window manager
9890 * can use this information to handle modal windows in a special
9893 * You should only use this on windows for which you have
9894 * previously called gdk_window_set_transient_for()
9897 gdk_window_set_modal_hint (GdkWindow *window,
9900 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_modal_hint (window, modal);
9904 * gdk_window_set_skip_taskbar_hint:
9905 * @window: a toplevel #GdkWindow
9906 * @skips_taskbar: %TRUE to skip the taskbar
9908 * Toggles whether a window should appear in a task list or window
9909 * list. If a window's semantic type as specified with
9910 * gdk_window_set_type_hint() already fully describes the window, this
9911 * function should <emphasis>not</emphasis> be called in addition,
9912 * instead you should allow the window to be treated according to
9913 * standard policy for its semantic type.
9918 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
9919 gboolean skips_taskbar)
9921 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_taskbar_hint (window, skips_taskbar);
9925 * gdk_window_set_skip_pager_hint:
9926 * @window: a toplevel #GdkWindow
9927 * @skips_pager: %TRUE to skip the pager
9929 * Toggles whether a window should appear in a pager (workspace
9930 * switcher, or other desktop utility program that displays a small
9931 * thumbnail representation of the windows on the desktop). If a
9932 * window's semantic type as specified with gdk_window_set_type_hint()
9933 * already fully describes the window, this function should
9934 * <emphasis>not</emphasis> be called in addition, instead you should
9935 * allow the window to be treated according to standard policy for
9936 * its semantic type.
9941 gdk_window_set_skip_pager_hint (GdkWindow *window,
9942 gboolean skips_pager)
9944 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_pager_hint (window, skips_pager);
9948 * gdk_window_set_urgency_hint:
9949 * @window: a toplevel #GdkWindow
9950 * @urgent: %TRUE if the window is urgent
9952 * Toggles whether a window needs the user's
9958 gdk_window_set_urgency_hint (GdkWindow *window,
9961 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_urgency_hint (window, urgent);
9965 * gdk_window_set_geometry_hints:
9966 * @window: a toplevel #GdkWindow
9967 * @geometry: geometry hints
9968 * @geom_mask: bitmask indicating fields of @geometry to pay attention to
9970 * Sets the geometry hints for @window. Hints flagged in @geom_mask
9971 * are set, hints not flagged in @geom_mask are unset.
9972 * To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
9974 * This function provides hints to the windowing system about
9975 * acceptable sizes for a toplevel window. The purpose of
9976 * this is to constrain user resizing, but the windowing system
9977 * will typically (but is not required to) also constrain the
9978 * current size of the window to the provided values and
9979 * constrain programatic resizing via gdk_window_resize() or
9980 * gdk_window_move_resize().
9982 * Note that on X11, this effect has no effect on windows
9983 * of type %GDK_WINDOW_TEMP or windows where override redirect
9984 * has been turned on via gdk_window_set_override_redirect()
9985 * since these windows are not resizable by the user.
9987 * Since you can't count on the windowing system doing the
9988 * constraints for programmatic resizes, you should generally
9989 * call gdk_window_constrain_size() yourself to determine
9990 * appropriate sizes.
9994 gdk_window_set_geometry_hints (GdkWindow *window,
9995 const GdkGeometry *geometry,
9996 GdkWindowHints geom_mask)
9998 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_geometry_hints (window, geometry, geom_mask);
10002 * gdk_window_set_title:
10003 * @window: a toplevel #GdkWindow
10004 * @title: title of @window
10006 * Sets the title of a toplevel window, to be displayed in the titlebar.
10007 * If you haven't explicitly set the icon name for the window
10008 * (using gdk_window_set_icon_name()), the icon name will be set to
10009 * @title as well. @title must be in UTF-8 encoding (as with all
10010 * user-readable strings in GDK/GTK+). @title may not be %NULL.
10013 gdk_window_set_title (GdkWindow *window,
10014 const gchar *title)
10016 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_title (window, title);
10020 * gdk_window_set_role:
10021 * @window: a toplevel #GdkWindow
10022 * @role: a string indicating its role
10024 * When using GTK+, typically you should use gtk_window_set_role() instead
10025 * of this low-level function.
10027 * The window manager and session manager use a window's role to
10028 * distinguish it from other kinds of window in the same application.
10029 * When an application is restarted after being saved in a previous
10030 * session, all windows with the same title and role are treated as
10031 * interchangeable. So if you have two windows with the same title
10032 * that should be distinguished for session management purposes, you
10033 * should set the role on those windows. It doesn't matter what string
10034 * you use for the role, as long as you have a different role for each
10035 * non-interchangeable kind of window.
10039 gdk_window_set_role (GdkWindow *window,
10042 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_role (window, role);
10046 * gdk_window_set_startup_id:
10047 * @window: a toplevel #GdkWindow
10048 * @startup_id: a string with startup-notification identifier
10050 * When using GTK+, typically you should use gtk_window_set_startup_id()
10051 * instead of this low-level function.
10057 gdk_window_set_startup_id (GdkWindow *window,
10058 const gchar *startup_id)
10060 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_startup_id (window, startup_id);
10064 * gdk_window_set_transient_for:
10065 * @window: a toplevel #GdkWindow
10066 * @parent: another toplevel #GdkWindow
10068 * Indicates to the window manager that @window is a transient dialog
10069 * associated with the application window @parent. This allows the
10070 * window manager to do things like center @window on @parent and
10071 * keep @window above @parent.
10073 * See gtk_window_set_transient_for() if you're using #GtkWindow or
10077 gdk_window_set_transient_for (GdkWindow *window,
10080 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_transient_for (window, parent);
10084 * gdk_window_get_root_origin:
10085 * @window: a toplevel #GdkWindow
10086 * @x: (out): return location for X position of window frame
10087 * @y: (out): return location for Y position of window frame
10089 * Obtains the top-left corner of the window manager frame in root
10090 * window coordinates.
10094 gdk_window_get_root_origin (GdkWindow *window,
10098 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_root_origin (window, x, y);
10102 * gdk_window_get_frame_extents:
10103 * @window: a toplevel #GdkWindow
10104 * @rect: rectangle to fill with bounding box of the window frame
10106 * Obtains the bounding box of the window, including window manager
10107 * titlebar/borders if any. The frame position is given in root window
10108 * coordinates. To get the position of the window itself (rather than
10109 * the frame) in root window coordinates, use gdk_window_get_origin().
10113 gdk_window_get_frame_extents (GdkWindow *window,
10114 GdkRectangle *rect)
10116 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_frame_extents (window, rect);
10120 * gdk_window_set_override_redirect:
10121 * @window: a toplevel #GdkWindow
10122 * @override_redirect: %TRUE if window should be override redirect
10124 * An override redirect window is not under the control of the window manager.
10125 * This means it won't have a titlebar, won't be minimizable, etc. - it will
10126 * be entirely under the control of the application. The window manager
10127 * can't see the override redirect window at all.
10129 * Override redirect should only be used for short-lived temporary
10130 * windows, such as popup menus. #GtkMenu uses an override redirect
10131 * window in its implementation, for example.
10135 gdk_window_set_override_redirect (GdkWindow *window,
10136 gboolean override_redirect)
10138 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_override_redirect (window, override_redirect);
10142 * gdk_window_set_accept_focus:
10143 * @window: a toplevel #GdkWindow
10144 * @accept_focus: %TRUE if the window should receive input focus
10146 * Setting @accept_focus to %FALSE hints the desktop environment that the
10147 * window doesn't want to receive input focus.
10149 * On X, it is the responsibility of the window manager to interpret this
10150 * hint. ICCCM-compliant window manager usually respect it.
10155 gdk_window_set_accept_focus (GdkWindow *window,
10156 gboolean accept_focus)
10158 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_accept_focus (window, accept_focus);
10162 * gdk_window_set_focus_on_map:
10163 * @window: a toplevel #GdkWindow
10164 * @focus_on_map: %TRUE if the window should receive input focus when mapped
10166 * Setting @focus_on_map to %FALSE hints the desktop environment that the
10167 * window doesn't want to receive input focus when it is mapped.
10168 * focus_on_map should be turned off for windows that aren't triggered
10169 * interactively (such as popups from network activity).
10171 * On X, it is the responsibility of the window manager to interpret
10172 * this hint. Window managers following the freedesktop.org window
10173 * manager extension specification should respect it.
10178 gdk_window_set_focus_on_map (GdkWindow *window,
10179 gboolean focus_on_map)
10181 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_focus_on_map (window, focus_on_map);
10185 * gdk_window_set_icon_list:
10186 * @window: The #GdkWindow toplevel window to set the icon of.
10187 * @pixbufs: (transfer none) (element-type GdkPixbuf):
10188 * A list of pixbufs, of different sizes.
10190 * Sets a list of icons for the window. One of these will be used
10191 * to represent the window when it has been iconified. The icon is
10192 * usually shown in an icon box or some sort of task bar. Which icon
10193 * size is shown depends on the window manager. The window manager
10194 * can scale the icon but setting several size icons can give better
10195 * image quality since the window manager may only need to scale the
10196 * icon by a small amount or not at all.
10200 gdk_window_set_icon_list (GdkWindow *window,
10203 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_list (window, pixbufs);
10207 * gdk_window_set_icon_name:
10208 * @window: a toplevel #GdkWindow
10209 * @name: (allow-none): name of window while iconified (minimized)
10211 * Windows may have a name used while minimized, distinct from the
10212 * name they display in their titlebar. Most of the time this is a bad
10213 * idea from a user interface standpoint. But you can set such a name
10214 * with this function, if you like.
10216 * After calling this with a non-%NULL @name, calls to gdk_window_set_title()
10217 * will not update the icon title.
10219 * Using %NULL for @name unsets the icon title; further calls to
10220 * gdk_window_set_title() will again update the icon title as well.
10223 gdk_window_set_icon_name (GdkWindow *window,
10226 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_name (window, name);
10230 * gdk_window_iconify:
10231 * @window: a toplevel #GdkWindow
10233 * Asks to iconify (minimize) @window. The window manager may choose
10234 * to ignore the request, but normally will honor it. Using
10235 * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
10237 * This function only makes sense when @window is a toplevel window.
10241 gdk_window_iconify (GdkWindow *window)
10243 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->iconify (window);
10247 * gdk_window_deiconify:
10248 * @window: a toplevel #GdkWindow
10250 * Attempt to deiconify (unminimize) @window. On X11 the window manager may
10251 * choose to ignore the request to deiconify. When using GTK+,
10252 * use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
10253 * you probably want to use gtk_window_present(), which raises the window, focuses it,
10254 * unminimizes it, and puts it on the current desktop.
10258 gdk_window_deiconify (GdkWindow *window)
10260 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->deiconify (window);
10264 * gdk_window_stick:
10265 * @window: a toplevel #GdkWindow
10267 * "Pins" a window such that it's on all workspaces and does not scroll
10268 * with viewports, for window managers that have scrollable viewports.
10269 * (When using #GtkWindow, gtk_window_stick() may be more useful.)
10271 * On the X11 platform, this function depends on window manager
10272 * support, so may have no effect with many window managers. However,
10273 * GDK will do the best it can to convince the window manager to stick
10274 * the window. For window managers that don't support this operation,
10275 * there's nothing you can do to force it to happen.
10279 gdk_window_stick (GdkWindow *window)
10281 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->stick (window);
10285 * gdk_window_unstick:
10286 * @window: a toplevel #GdkWindow
10288 * Reverse operation for gdk_window_stick(); see gdk_window_stick(),
10289 * and gtk_window_unstick().
10293 gdk_window_unstick (GdkWindow *window)
10295 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unstick (window);
10299 * gdk_window_maximize:
10300 * @window: a toplevel #GdkWindow
10302 * Maximizes the window. If the window was already maximized, then
10303 * this function does nothing.
10305 * On X11, asks the window manager to maximize @window, if the window
10306 * manager supports this operation. Not all window managers support
10307 * this, and some deliberately ignore it or don't have a concept of
10308 * "maximized"; so you can't rely on the maximization actually
10309 * happening. But it will happen with most standard window managers,
10310 * and GDK makes a best effort to get it to happen.
10312 * On Windows, reliably maximizes the window.
10316 gdk_window_maximize (GdkWindow *window)
10318 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->maximize (window);
10322 * gdk_window_unmaximize:
10323 * @window: a toplevel #GdkWindow
10325 * Unmaximizes the window. If the window wasn't maximized, then this
10326 * function does nothing.
10328 * On X11, asks the window manager to unmaximize @window, if the
10329 * window manager supports this operation. Not all window managers
10330 * support this, and some deliberately ignore it or don't have a
10331 * concept of "maximized"; so you can't rely on the unmaximization
10332 * actually happening. But it will happen with most standard window
10333 * managers, and GDK makes a best effort to get it to happen.
10335 * On Windows, reliably unmaximizes the window.
10339 gdk_window_unmaximize (GdkWindow *window)
10341 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unmaximize (window);
10345 * gdk_window_fullscreen:
10346 * @window: a toplevel #GdkWindow
10348 * Moves the window into fullscreen mode. This means the
10349 * window covers the entire screen and is above any panels
10352 * If the window was already fullscreen, then this function does nothing.
10354 * On X11, asks the window manager to put @window in a fullscreen
10355 * state, if the window manager supports this operation. Not all
10356 * window managers support this, and some deliberately ignore it or
10357 * don't have a concept of "fullscreen"; so you can't rely on the
10358 * fullscreenification actually happening. But it will happen with
10359 * most standard window managers, and GDK makes a best effort to get
10365 gdk_window_fullscreen (GdkWindow *window)
10367 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->fullscreen (window);
10371 * gdk_window_unfullscreen:
10372 * @window: a toplevel #GdkWindow
10374 * Moves the window out of fullscreen mode. If the window was not
10375 * fullscreen, does nothing.
10377 * On X11, asks the window manager to move @window out of the fullscreen
10378 * state, if the window manager supports this operation. Not all
10379 * window managers support this, and some deliberately ignore it or
10380 * don't have a concept of "fullscreen"; so you can't rely on the
10381 * unfullscreenification actually happening. But it will happen with
10382 * most standard window managers, and GDK makes a best effort to get
10388 gdk_window_unfullscreen (GdkWindow *window)
10390 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unfullscreen (window);
10394 * gdk_window_set_keep_above:
10395 * @window: a toplevel #GdkWindow
10396 * @setting: whether to keep @window above other windows
10398 * Set if @window must be kept above other windows. If the
10399 * window was already above, then this function does nothing.
10401 * On X11, asks the window manager to keep @window above, if the window
10402 * manager supports this operation. Not all window managers support
10403 * this, and some deliberately ignore it or don't have a concept of
10404 * "keep above"; so you can't rely on the window being kept above.
10405 * But it will happen with most standard window managers,
10406 * and GDK makes a best effort to get it to happen.
10411 gdk_window_set_keep_above (GdkWindow *window,
10414 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_above (window, setting);
10418 * gdk_window_set_keep_below:
10419 * @window: a toplevel #GdkWindow
10420 * @setting: whether to keep @window below other windows
10422 * Set if @window must be kept below other windows. If the
10423 * window was already below, then this function does nothing.
10425 * On X11, asks the window manager to keep @window below, if the window
10426 * manager supports this operation. Not all window managers support
10427 * this, and some deliberately ignore it or don't have a concept of
10428 * "keep below"; so you can't rely on the window being kept below.
10429 * But it will happen with most standard window managers,
10430 * and GDK makes a best effort to get it to happen.
10435 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
10437 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_below (window, setting);
10441 * gdk_window_get_group:
10442 * @window: a toplevel #GdkWindow
10444 * Returns the group leader window for @window. See gdk_window_set_group().
10446 * Return value: (transfer none): the group leader window for @window
10451 gdk_window_get_group (GdkWindow *window)
10453 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_group (window);
10457 * gdk_window_set_group:
10458 * @window: a toplevel #GdkWindow
10459 * @leader: (allow-none): group leader window, or %NULL to restore the default group leader window
10461 * Sets the group leader window for @window. By default,
10462 * GDK sets the group leader for all toplevel windows
10463 * to a global window implicitly created by GDK. With this function
10464 * you can override this default.
10466 * The group leader window allows the window manager to distinguish
10467 * all windows that belong to a single application. It may for example
10468 * allow users to minimize/unminimize all windows belonging to an
10469 * application at once. You should only set a non-default group window
10470 * if your application pretends to be multiple applications.
10473 gdk_window_set_group (GdkWindow *window,
10476 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_group (window, leader);
10480 * gdk_window_set_decorations:
10481 * @window: a toplevel #GdkWindow
10482 * @decorations: decoration hint mask
10484 * "Decorations" are the features the window manager adds to a toplevel #GdkWindow.
10485 * This function sets the traditional Motif window manager hints that tell the
10486 * window manager which decorations you would like your window to have.
10487 * Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
10488 * using the GDK function directly.
10490 * The @decorations argument is the logical OR of the fields in
10491 * the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
10492 * mask, the other bits indicate which decorations should be turned off.
10493 * If #GDK_DECOR_ALL is not included, then the other bits indicate
10494 * which decorations should be turned on.
10496 * Most window managers honor a decorations hint of 0 to disable all decorations,
10497 * but very few honor all possible combinations of bits.
10501 gdk_window_set_decorations (GdkWindow *window,
10502 GdkWMDecoration decorations)
10504 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_decorations (window, decorations);
10508 * gdk_window_get_decorations:
10509 * @window: The toplevel #GdkWindow to get the decorations from
10510 * @decorations: (out): The window decorations will be written here
10512 * Returns the decorations set on the GdkWindow with
10513 * gdk_window_set_decorations().
10515 * Returns: %TRUE if the window has decorations set, %FALSE otherwise.
10518 gdk_window_get_decorations(GdkWindow *window,
10519 GdkWMDecoration *decorations)
10521 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_decorations (window, decorations);
10525 * gdk_window_set_functions:
10526 * @window: a toplevel #GdkWindow
10527 * @functions: bitmask of operations to allow on @window
10529 * Sets hints about the window management functions to make available
10530 * via buttons on the window frame.
10532 * On the X backend, this function sets the traditional Motif window
10533 * manager hint for this purpose. However, few window managers do
10534 * anything reliable or interesting with this hint. Many ignore it
10537 * The @functions argument is the logical OR of values from the
10538 * #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
10539 * then the other bits indicate which functions to disable; if
10540 * it doesn't include #GDK_FUNC_ALL, it indicates which functions to
10545 gdk_window_set_functions (GdkWindow *window,
10546 GdkWMFunction functions)
10548 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_functions (window, functions);
10552 * gdk_window_begin_resize_drag_for_device:
10553 * @window: a toplevel #GdkWindow
10554 * @edge: the edge or corner from which the drag is started
10555 * @device: the device used for the operation
10556 * @button: the button being used to drag
10557 * @root_x: root window X coordinate of mouse click that began the drag
10558 * @root_y: root window Y coordinate of mouse click that began the drag
10559 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10561 * Begins a window resize operation (for a toplevel window).
10562 * You might use this function to implement a "window resize grip," for
10563 * example; in fact #GtkStatusbar uses it. The function works best
10564 * with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a
10565 * fallback implementation for other window managers.
10570 gdk_window_begin_resize_drag_for_device (GdkWindow *window,
10571 GdkWindowEdge edge,
10578 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
10582 * gdk_window_begin_resize_drag:
10583 * @window: a toplevel #GdkWindow
10584 * @edge: the edge or corner from which the drag is started
10585 * @button: the button being used to drag
10586 * @root_x: root window X coordinate of mouse click that began the drag
10587 * @root_y: root window Y coordinate of mouse click that began the drag
10588 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10590 * Begins a window resize operation (for a toplevel window).
10592 * This function assumes that the drag is controlled by the
10593 * client pointer device, use gdk_window_begin_resize_drag_for_device()
10594 * to begin a drag with a different device.
10597 gdk_window_begin_resize_drag (GdkWindow *window,
10598 GdkWindowEdge edge,
10604 GdkDeviceManager *device_manager;
10607 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10608 device = gdk_device_manager_get_client_pointer (device_manager);
10609 gdk_window_begin_resize_drag_for_device (window, edge,
10610 device, button, root_x, root_y, timestamp);
10614 * gdk_window_begin_move_drag_for_device:
10615 * @window: a toplevel #GdkWindow
10616 * @device: the device used for the operation
10617 * @button: the button being used to drag
10618 * @root_x: root window X coordinate of mouse click that began the drag
10619 * @root_y: root window Y coordinate of mouse click that began the drag
10620 * @timestamp: timestamp of mouse click that began the drag
10622 * Begins a window move operation (for a toplevel window).
10623 * You might use this function to implement a "window move grip," for
10624 * example. The function works best with window managers that support
10625 * the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
10626 * Window Manager Hints</ulink>, but has a fallback implementation for
10627 * other window managers.
10632 gdk_window_begin_move_drag_for_device (GdkWindow *window,
10639 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_move_drag (window,
10640 device, button, root_x, root_y, timestamp);
10644 * gdk_window_begin_move_drag:
10645 * @window: a toplevel #GdkWindow
10646 * @button: the button being used to drag
10647 * @root_x: root window X coordinate of mouse click that began the drag
10648 * @root_y: root window Y coordinate of mouse click that began the drag
10649 * @timestamp: timestamp of mouse click that began the drag
10651 * Begins a window move operation (for a toplevel window).
10653 * This function assumes that the drag is controlled by the
10654 * client pointer device, use gdk_window_begin_move_drag_for_device()
10655 * to begin a drag with a different device.
10658 gdk_window_begin_move_drag (GdkWindow *window,
10664 GdkDeviceManager *device_manager;
10667 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10668 device = gdk_device_manager_get_client_pointer (device_manager);
10669 gdk_window_begin_move_drag_for_device (window, device, button, root_x, root_y, timestamp);
10673 * gdk_window_enable_synchronized_configure:
10674 * @window: a toplevel #GdkWindow
10676 * Indicates that the application will cooperate with the window
10677 * system in synchronizing the window repaint with the window
10678 * manager during resizing operations. After an application calls
10679 * this function, it must call gdk_window_configure_finished() every
10680 * time it has finished all processing associated with a set of
10681 * Configure events. Toplevel GTK+ windows automatically use this
10684 * On X, calling this function makes @window participate in the
10685 * _NET_WM_SYNC_REQUEST window manager protocol.
10690 gdk_window_enable_synchronized_configure (GdkWindow *window)
10692 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->enable_synchronized_configure (window);
10696 * gdk_window_configure_finished:
10697 * @window: a toplevel #GdkWindow
10699 * Signal to the window system that the application has finished
10700 * handling Configure events it has received. Window Managers can
10701 * use this to better synchronize the frame repaint with the
10702 * application. GTK+ applications will automatically call this
10703 * function when appropriate.
10705 * This function can only be called if gdk_window_enable_synchronized_configure()
10706 * was called previously.
10711 gdk_window_configure_finished (GdkWindow *window)
10713 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->configure_finished (window);
10717 * gdk_window_set_opacity:
10718 * @window: a top-level #GdkWindow
10719 * @opacity: opacity
10721 * Request the windowing system to make @window partially transparent,
10722 * with opacity 0 being fully transparent and 1 fully opaque. (Values
10723 * of the opacity parameter are clamped to the [0,1] range.)
10725 * On X11, this works only on X screens with a compositing manager
10728 * For setting up per-pixel alpha, see gdk_screen_get_rgba_visual().
10729 * For making non-toplevel windows translucent, see
10730 * gdk_window_set_composited().
10735 gdk_window_set_opacity (GdkWindow *window,
10738 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_opacity (window, opacity);
10741 /* This function is called when the XWindow is really gone.
10744 gdk_window_destroy_notify (GdkWindow *window)
10746 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->destroy_notify (window);
10750 * gdk_window_register_dnd:
10751 * @window: a #GdkWindow.
10753 * Registers a window as a potential drop destination.
10756 gdk_window_register_dnd (GdkWindow *window)
10758 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->register_dnd (window);
10762 * gdk_window_get_drag_protocol:
10763 * @window: the destination window
10764 * @target: (out) (allow-none) (transfer full): location of the window
10765 * where the drop should happen. This may be @window or a proxy window,
10766 * or %NULL if @window does not support Drag and Drop.
10768 * Finds out the DND protocol supported by a window.
10770 * Returns: the supported DND protocol.
10775 gdk_window_get_drag_protocol (GdkWindow *window,
10776 GdkWindow **target)
10778 g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_DRAG_PROTO_NONE);
10780 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_drag_protocol (window, target);
10785 * @window: the source window for this drag.
10786 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10787 * as list of #GdkAtoms
10789 * Starts a drag and creates a new drag context for it.
10790 * This function assumes that the drag is controlled by the
10791 * client pointer device, use gdk_drag_begin_for_device() to
10792 * begin a drag with a different device.
10794 * This function is called by the drag source.
10796 * Return value: (transfer full): a newly created #GdkDragContext
10799 gdk_drag_begin (GdkWindow *window,
10802 GdkDeviceManager *device_manager;
10805 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10806 device = gdk_device_manager_get_client_pointer (device_manager);
10808 return gdk_drag_begin_for_device (window, device, targets);
10812 * gdk_drag_begin_for_device:
10813 * @window: the source window for this drag
10814 * @device: the device that controls this drag
10815 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10816 * as list of #GdkAtoms
10818 * Starts a drag and creates a new drag context for it.
10820 * This function is called by the drag source.
10822 * Return value: (transfer full): a newly created #GdkDragContext
10825 gdk_drag_begin_for_device (GdkWindow *window,
10829 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->drag_begin (window, device, targets);
10833 * gdk_test_render_sync:
10834 * @window: a mapped #GdkWindow
10836 * Retrieves a pixel from @window to force the windowing
10837 * system to carry out any pending rendering commands.
10839 * This function is intended to be used to synchronize with rendering
10840 * pipelines, to benchmark windowing system rendering operations.
10845 gdk_test_render_sync (GdkWindow *window)
10847 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->sync_rendering (window);
10851 * gdk_test_simulate_key:
10852 * @window: a #GdkWindow to simulate a key event for
10853 * @x: x coordinate within @window for the key event
10854 * @y: y coordinate within @window for the key event
10855 * @keyval: A GDK keyboard value
10856 * @modifiers: Keyboard modifiers the event is setup with
10857 * @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
10859 * This function is intended to be used in GTK+ test programs.
10860 * If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
10861 * the given (@x,@y) coordinates within @window and simulate a
10862 * key press or release event.
10864 * When the mouse pointer is warped to the target location, use
10865 * of this function outside of test programs that run in their
10866 * own virtual windowing system (e.g. Xvfb) is not recommended.
10867 * If (@x,@y) are passed as (-1,-1), the mouse pointer will not
10868 * be warped and @window origin will be used as mouse pointer
10869 * location for the event.
10871 * Also, gdk_test_simulate_key() is a fairly low level function,
10872 * for most testing purposes, gtk_test_widget_send_key() is the
10873 * right function to call which will generate a key press event
10874 * followed by its accompanying key release event.
10876 * Returns: whether all actions necessary for a key event simulation
10877 * were carried out successfully
10882 gdk_test_simulate_key (GdkWindow *window,
10886 GdkModifierType modifiers,
10887 GdkEventType key_pressrelease)
10889 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10890 ->simulate_key (window, x, y, keyval, modifiers, key_pressrelease);
10894 * gdk_test_simulate_button:
10895 * @window: a #GdkWindow to simulate a button event for
10896 * @x: x coordinate within @window for the button event
10897 * @y: y coordinate within @window for the button event
10898 * @button: Number of the pointer button for the event, usually 1, 2 or 3
10899 * @modifiers: Keyboard modifiers the event is setup with
10900 * @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
10902 * This function is intended to be used in GTK+ test programs.
10903 * It will warp the mouse pointer to the given (@x,@y) coordinates
10904 * within @window and simulate a button press or release event.
10905 * Because the mouse pointer needs to be warped to the target
10906 * location, use of this function outside of test programs that
10907 * run in their own virtual windowing system (e.g. Xvfb) is not
10910 * Also, gdk_test_simulate_button() is a fairly low level function,
10911 * for most testing purposes, gtk_test_widget_click() is the right
10912 * function to call which will generate a button press event followed
10913 * by its accompanying button release event.
10915 * Returns: whether all actions necessary for a button event simulation
10916 * were carried out successfully
10921 gdk_test_simulate_button (GdkWindow *window,
10924 guint button, /*1..3*/
10925 GdkModifierType modifiers,
10926 GdkEventType button_pressrelease)
10928 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10929 ->simulate_button (window, x, y, button, modifiers, button_pressrelease);
10933 * gdk_property_get:
10934 * @window: a #GdkWindow
10935 * @property: the property to retrieve
10936 * @type: the desired property type, or %GDK_NONE, if any type of data
10937 * is acceptable. If this does not match the actual
10938 * type, then @actual_format and @actual_length will
10939 * be filled in, a warning will be printed to stderr
10940 * and no data will be returned.
10941 * @offset: the offset into the property at which to begin
10942 * retrieving data, in 4 byte units.
10943 * @length: the length of the data to retrieve in bytes. Data is
10944 * considered to be retrieved in 4 byte chunks, so @length
10945 * will be rounded up to the next highest 4 byte boundary
10946 * (so be careful not to pass a value that might overflow
10947 * when rounded up).
10948 * @pdelete: if %TRUE, delete the property after retrieving the
10950 * @actual_property_type: (out) (transfer none): location to store the
10951 * actual type of the property.
10952 * @actual_format: (out): location to store the actual return format of the
10953 * data; either 8, 16 or 32 bits.
10954 * @actual_length: location to store the length of the retrieved data, in
10955 * bytes. Data returned in the 32 bit format is stored
10956 * in a long variable, so the actual number of 32 bit
10957 * elements should be be calculated via
10958 * @actual_length / sizeof(glong) to ensure portability to
10960 * @data: (out) (array length=actual_length) (transfer full): location
10961 * to store a pointer to the data. The retrieved data should be
10962 * freed with g_free() when you are finished using it.
10964 * Retrieves a portion of the contents of a property. If the
10965 * property does not exist, then the function returns %FALSE,
10966 * and %GDK_NONE will be stored in @actual_property_type.
10970 * The XGetWindowProperty() function that gdk_property_get()
10971 * uses has a very confusing and complicated set of semantics.
10972 * Unfortunately, gdk_property_get() makes the situation
10973 * worse instead of better (the semantics should be considered
10974 * undefined), and also prints warnings to stderr in cases where it
10975 * should return a useful error to the program. You are advised to use
10976 * XGetWindowProperty() directly until a replacement function for
10977 * gdk_property_get()
10982 * Returns: %TRUE if data was successfully received and stored
10983 * in @data, otherwise %FALSE.
10986 gdk_property_get (GdkWindow *window,
10992 GdkAtom *actual_property_type,
10993 gint *actual_format_type,
10994 gint *actual_length,
10997 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10998 ->get_property (window, property, type, offset, length, pdelete,
10999 actual_property_type, actual_format_type,
11000 actual_length, data);
11004 * gdk_property_change: (skip)
11005 * @window: a #GdkWindow
11006 * @property: the property to change
11007 * @type: the new type for the property. If @mode is
11008 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11009 * must match the existing type or an error will occur.
11010 * @format: the new format for the property. If @mode is
11011 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11012 * must match the existing format or an error will occur.
11013 * @mode: a value describing how the new data is to be combined
11014 * with the current data.
11015 * @data: the data (a <literal>guchar *</literal>
11016 * <literal>gushort *</literal>, or <literal>gulong *</literal>,
11017 * depending on @format), cast to a <literal>guchar *</literal>.
11018 * @nelements: the number of elements of size determined by the format,
11019 * contained in @data.
11021 * Changes the contents of a property on a window.
11024 gdk_property_change (GdkWindow *window,
11029 const guchar *data,
11032 GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11033 ->change_property (window, property, type, format, mode, data, nelements);
11037 * gdk_property_delete:
11038 * @window: a #GdkWindow
11039 * @property: the property to delete
11041 * Deletes a property from a window.
11044 gdk_property_delete (GdkWindow *window,
11047 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->delete_property (window, property);