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, see <http://www.gnu.org/licenses/>.
20 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
21 * file for a list of people on the GTK+ Team. See the ChangeLog
22 * files for a list of changes. These files are distributed with
23 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
28 #include <cairo-gobject.h>
30 #include "gdkwindow.h"
32 #include "gdkrectangle.h"
33 #include "gdkinternals.h"
35 #include "gdkscreenprivate.h"
36 #include "gdkdisplayprivate.h"
37 #include "gdkdeviceprivate.h"
38 #include "gdkvisualprivate.h"
39 #include "gdkmarshalers.h"
40 #include "gdkwindowimpl.h"
44 #undef DEBUG_WINDOW_PRINTING
49 * @Short_description: Onscreen display areas in the target window system
52 * A #GdkWindow is a (usually) rectangular region on the screen.
53 * It's a low-level object, used to implement high-level objects such as
54 * #GtkWidget and #GtkWindow on the GTK+ level. A #GtkWindow is a toplevel
55 * window, the thing a user might think of as a "window" with a titlebar and
56 * so on; a #GtkWindow may contain many #GdkWindows. For example, each
57 * #GtkButton has a #GdkWindow associated with it.
59 * <refsect2 id="COMPOSITED-WINDOWS">
60 * <title>Composited Windows</title>
62 * Normally, the windowing system takes care of rendering the contents of a
63 * child window onto its parent window. This mechanism can be intercepted by
64 * calling gdk_window_set_composited() on the child window. For a
65 * <firstterm>composited</firstterm> window it is the responsibility of the
66 * application to render the window contents at the right spot.
68 * <example id="composited-window-example">
69 * <title>Composited windows</title>
71 * <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>
72 * </programlisting></example>
74 * In the example <xref linkend="composited-window-example"/>, a button is
75 * placed inside of an event box inside of a window. The event box is set as
76 * composited and therefore is no longer automatically drawn to the screen.
78 * When the contents of the event box change, an expose event is generated on
79 * its parent window (which, in this case, belongs to the toplevel #GtkWindow).
80 * The expose handler for this widget is responsible for merging the changes
81 * back on the screen in the way that it wishes.
83 * In our case, we merge the contents with a 50% transparency. We also set the
84 * background colour of the window to red. The effect is that the background
85 * shows through the button.
88 * <refsect2 id="OFFSCREEN-WINDOWS">
89 * <title>Offscreen Windows</title>
91 * Offscreen windows are more general than composited windows, since they allow
92 * not only to modify the rendering of the child window onto its parent, but
93 * also to apply coordinate transformations.
95 * To integrate an offscreen window into a window hierarchy, one has to call
96 * gdk_offscreen_window_set_embedder() and handle a number of signals. The
97 * #GdkWindow::pick-embedded-child signal on the embedder window is used to
98 * select an offscreen child at given coordinates, and the
99 * #GdkWindow::to-embedder and #GdkWindow::from-embedder signals on the
100 * offscreen window are used to translate coordinates between the embedder and
101 * the offscreen window.
103 * For rendering an offscreen window onto its embedder, the contents of the
104 * offscreen window are available as a surface, via
105 * gdk_offscreen_window_get_surface().
111 /* Historically a GdkWindow always matches a platform native window,
112 * be it a toplevel window or a child window. In this setup the
113 * GdkWindow (and other GdkDrawables) were platform independent classes,
114 * and the actual platform specific implementation was in a delegate
115 * object availible as "impl" in the window object.
117 * With the addition of client side windows and offscreen windows this
118 * changes a bit. The application-visible GdkWindow object behaves as
119 * it did before, but not all such windows now have a corresponding native
120 * window. Instead windows that are "client side" are emulated by the gdk
121 * code such that clipping, drawing, moving, events etc work as expected.
123 * For GdkWindows that have a native window the "impl" object is the
124 * same as before. However, for all client side windows the impl object
125 * is shared with its parent (i.e. all client windows descendants of one
126 * native window has the same impl.
128 * Additionally there is a new type of platform independent impl object,
129 * GdkOffscreenWindow. All windows of type GDK_WINDOW_OFFSCREEN get an impl
130 * of this type (while their children are generally GDK_WINDOW_CHILD virtual
131 * windows). Such windows work by allocating a #cairo_surface_t as the backing
132 * store for drawing operations, which is resized with the window.
134 * GdkWindows have a pointer to the "impl window" they are in, i.e.
135 * the topmost GdkWindow which have the same "impl" value. This is stored
136 * in impl_window, which is different from the window itself only for client
138 * All GdkWindows (native or not) track the position of the window in the parent
139 * (x, y), the size of the window (width, height), the position of the window
140 * with respect to the impl window (abs_x, abs_y). We also track the clip
141 * region of the window wrt parent windows and siblings, in window-relative
142 * coordinates with and without child windows included (clip_region,
143 * clip_region_with_children).
145 * All toplevel windows are native windows, but also child windows can be
146 * native (although not children of offscreens). We always listen to
147 * a basic set of events (see get_native_event_mask) for these windows
148 * so that we can emulate events for any client side children.
150 * For native windows we apply the calculated clip region as a window shape
151 * so that eg. client side siblings that overlap the native child properly
152 * draws over the native child window.
154 * In order to minimize flicker and for performance we use a couple of cacheing
155 * tricks. First of all, every time we do a window to window copy area, for instance
156 * when moving a client side window or when scrolling/moving a region in a window
157 * we store this in outstanding_moves instead of applying immediately. We then
158 * delay this move until we really need it (because something depends on being
159 * able to read it), or until we're handing a redraw from an expose/invalidation
160 * (actually we delay it past redraw, but before blitting the double buffer
161 * to the window). This gives us two advantages. First of all it minimizes the time
162 * from the window is moved to the exposes related to that move, secondly it allows
163 * us to be smart about how to do the copy. We combine multiple moves into one (when
164 * possible) and we don't actually do copies to anything that is or will be
165 * invalidated and exposed anyway.
167 * Secondly, we use something called a "implicit paint" during repaint handling.
168 * An implicit paint is similar to a regular paint for the paint stack, but it is
169 * not put on the stack. Instead, it is set on the impl window, and later when
170 * regular gdk_window_begin_paint_region() happen on a window of this impl window
171 * we reuse the surface from the implicit paint. During repaint we create and at the
172 * end flush an implicit paint, which means we can collect all the paints on
173 * multiple client side windows in the same backing store.
176 #define USE_BACKING_STORE /* Appears to work on Win32, too, now. */
178 /* This adds a local value to the GdkVisibilityState enum */
179 #define GDK_VISIBILITY_NOT_VIEWABLE 3
182 PICK_EMBEDDED_CHILD, /* only called if children are embedded */
196 CLEAR_BG_WINCLEARED, /* Clear backgrounds except those that the window system clears */
200 struct _GdkWindowPaint
202 cairo_region_t *region;
203 cairo_surface_t *surface;
204 cairo_region_t *flushed;
205 guint uses_implicit : 1;
209 cairo_region_t *dest_region; /* The destination region */
210 int dx, dy; /* The amount that the source was moved to reach dest_region */
211 } GdkWindowRegionMove;
215 static void gdk_window_drop_cairo_surface (GdkWindow *private);
217 static void gdk_window_free_paint_stack (GdkWindow *window);
219 static void gdk_window_finalize (GObject *object);
221 static void gdk_window_set_property (GObject *object,
225 static void gdk_window_get_property (GObject *object,
230 static void gdk_window_clear_backing_region (GdkWindow *window,
231 cairo_region_t *region);
233 static void recompute_visible_regions (GdkWindow *private,
234 gboolean recalculate_siblings,
235 gboolean recalculate_children);
236 static void gdk_window_flush_outstanding_moves (GdkWindow *window);
237 static void gdk_window_flush_recursive (GdkWindow *window);
238 static void do_move_region_bits_on_impl (GdkWindow *window,
239 cairo_region_t *region, /* In impl window coords */
241 static void gdk_window_invalidate_in_parent (GdkWindow *private);
242 static void move_native_children (GdkWindow *private);
243 static void update_cursor (GdkDisplay *display,
245 static void impl_window_add_update_area (GdkWindow *impl_window,
246 cairo_region_t *region);
247 static void gdk_window_region_move_free (GdkWindowRegionMove *move);
248 static void gdk_window_invalidate_region_full (GdkWindow *window,
249 const cairo_region_t *region,
250 gboolean invalidate_children,
252 static void gdk_window_invalidate_rect_full (GdkWindow *window,
253 const GdkRectangle *rect,
254 gboolean invalidate_children,
256 static void _gdk_window_propagate_has_alpha_background (GdkWindow *window);
257 static cairo_surface_t *gdk_window_ref_impl_surface (GdkWindow *window);
259 static guint signals[LAST_SIGNAL] = { 0 };
261 static gpointer parent_class = NULL;
263 static const cairo_user_data_key_t gdk_window_cairo_key;
265 G_DEFINE_ABSTRACT_TYPE (GdkWindow, gdk_window, G_TYPE_OBJECT)
267 #ifdef DEBUG_WINDOW_PRINTING
269 print_region (cairo_region_t *region)
271 GString *s = g_string_new ("{");
272 if (cairo_region_is_empty (region))
274 g_string_append (s, "empty");
278 int num = cairo_region_num_rectangles (region);
279 cairo_rectangle_int_t r;
283 cairo_region_get_rectangle (region, 0, &r);
284 g_string_append_printf (s, "%dx%d @%d,%d", r.width, r.height, r.x, r.y);
288 cairo_region_get_extents (region, &r);
289 g_string_append_printf (s, "extent: %dx%d @%d,%d, details: ", r.width, r.height, r.x, r.y);
290 for (int i = 0; i < num; i++)
292 g_string_append_printf (s, "[%dx%d @%d,%d]", r.width, r.height, r.x, r.y);
294 g_string_append (s, ", ");
298 g_string_append (s, "}");
299 return g_string_free (s, FALSE);
304 _gdk_paintable_get_type (void)
306 static GType paintable_type = 0;
310 const GTypeInfo paintable_info =
312 sizeof (GdkPaintableIface), /* class_size */
313 NULL, /* base_init */
314 NULL, /* base_finalize */
317 paintable_type = g_type_register_static (G_TYPE_INTERFACE,
318 g_intern_static_string ("GdkPaintable"),
321 g_type_interface_add_prerequisite (paintable_type, G_TYPE_OBJECT);
324 return paintable_type;
328 gdk_window_init (GdkWindow *window)
330 /* 0-initialization is good for all other fields. */
332 window->window_type = GDK_WINDOW_CHILD;
334 window->state = GDK_WINDOW_STATE_WITHDRAWN;
337 window->toplevel_window_type = -1;
339 window->effective_visibility = GDK_VISIBILITY_NOT_VIEWABLE;
340 window->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
341 /* Default to unobscured since some backends don't send visibility events */
342 window->native_visibility = GDK_VISIBILITY_UNOBSCURED;
344 window->device_cursor = g_hash_table_new_full (NULL, NULL,
345 NULL, g_object_unref);
348 /* Stop and return on the first non-NULL parent */
350 accumulate_get_window (GSignalInvocationHint *ihint,
352 const GValue *handler_return,
355 g_value_copy (handler_return, return_accu);
356 /* Continue while returning NULL */
357 return g_value_get_object (handler_return) == NULL;
361 create_surface_accumulator (GSignalInvocationHint *ihint,
363 const GValue *handler_return,
366 g_value_copy (handler_return, return_accu);
368 /* Stop on the first non-NULL return value */
369 return g_value_get_boxed (handler_return) == NULL;
372 static GQuark quark_pointer_window = 0;
375 gdk_window_class_init (GdkWindowClass *klass)
377 GObjectClass *object_class = G_OBJECT_CLASS (klass);
379 parent_class = g_type_class_peek_parent (klass);
381 object_class->finalize = gdk_window_finalize;
382 object_class->set_property = gdk_window_set_property;
383 object_class->get_property = gdk_window_get_property;
385 klass->create_surface = _gdk_offscreen_window_create_surface;
387 quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
395 * The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and
396 * gdk_window_get_cursor() for details.
400 g_object_class_install_property (object_class,
402 g_param_spec_object ("cursor",
409 * GdkWindow::pick-embedded-child:
410 * @window: the window on which the signal is emitted
411 * @x: x coordinate in the window
412 * @y: y coordinate in the window
414 * The ::pick-embedded-child signal is emitted to find an embedded
415 * child at the given position.
417 * Returns: (transfer none): the #GdkWindow of the embedded child at
422 signals[PICK_EMBEDDED_CHILD] =
423 g_signal_new (g_intern_static_string ("pick-embedded-child"),
424 G_OBJECT_CLASS_TYPE (object_class),
426 G_STRUCT_OFFSET (GdkWindowClass, pick_embedded_child),
427 accumulate_get_window, NULL,
428 _gdk_marshal_OBJECT__DOUBLE_DOUBLE,
435 * GdkWindow::to-embedder:
436 * @window: the offscreen window on which the signal is emitted
437 * @offscreen_x: x coordinate in the offscreen window
438 * @offscreen_y: y coordinate in the offscreen window
439 * @embedder_x: (out) (type double): return location for the x
440 * coordinate in the embedder window
441 * @embedder_y: (out) (type double): return location for the y
442 * coordinate in the embedder window
444 * The ::to-embedder signal is emitted to translate coordinates
445 * in an offscreen window to its embedder.
447 * See also #GtkWindow::from-embedder.
451 signals[TO_EMBEDDER] =
452 g_signal_new (g_intern_static_string ("to-embedder"),
453 G_OBJECT_CLASS_TYPE (object_class),
455 G_STRUCT_OFFSET (GdkWindowClass, to_embedder),
457 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
466 * GdkWindow::from-embedder:
467 * @window: the offscreen window on which the signal is emitted
468 * @embedder_x: x coordinate in the embedder window
469 * @embedder_y: y coordinate in the embedder window
470 * @offscreen_x: (out) (type double): return location for the x
471 * coordinate in the offscreen window
472 * @offscreen_y: (out) (type double): return location for the y
473 * coordinate in the offscreen window
475 * The ::from-embedder signal is emitted to translate coordinates
476 * in the embedder of an offscreen window to the offscreen window.
478 * See also #GtkWindow::to-embedder.
482 signals[FROM_EMBEDDER] =
483 g_signal_new (g_intern_static_string ("from-embedder"),
484 G_OBJECT_CLASS_TYPE (object_class),
486 G_STRUCT_OFFSET (GdkWindowClass, from_embedder),
488 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
497 * GdkWindow::create-surface:
498 * @window: the offscreen window on which the signal is emitted
499 * @width: the width of the offscreen surface to create
500 * @height: the height of the offscreen surface to create
502 * The ::create-surface signal is emitted when an offscreen window
503 * needs its surface (re)created, which happens either when the the
504 * window is first drawn to, or when the window is being
505 * resized. The first signal handler that returns a non-%NULL
506 * surface will stop any further signal emission, and its surface
509 * Note that it is not possible to access the window's previous
510 * surface from within any callback of this signal. Calling
511 * gdk_offscreen_window_get_surface() will lead to a crash.
513 * Returns: the newly created #cairo_surface_t for the offscreen window
517 signals[CREATE_SURFACE] =
518 g_signal_new (g_intern_static_string ("create-surface"),
519 G_OBJECT_CLASS_TYPE (object_class),
521 G_STRUCT_OFFSET (GdkWindowClass, create_surface),
522 create_surface_accumulator, NULL,
523 _gdk_marshal_BOXED__INT_INT,
524 CAIRO_GOBJECT_TYPE_SURFACE,
531 device_removed_cb (GdkDeviceManager *device_manager,
535 window->devices_inside = g_list_remove (window->devices_inside, device);
536 g_hash_table_remove (window->device_cursor, device);
538 if (window->device_events)
539 g_hash_table_remove (window->device_events, device);
543 gdk_window_finalize (GObject *object)
545 GdkWindow *window = GDK_WINDOW (object);
546 GdkDeviceManager *device_manager;
548 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
549 g_signal_handlers_disconnect_by_func (device_manager, device_removed_cb, window);
551 if (!GDK_WINDOW_DESTROYED (window))
553 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
555 g_warning ("losing last reference to undestroyed window\n");
556 _gdk_window_destroy (window, FALSE);
559 /* We use TRUE here, to keep us from actually calling
560 * XDestroyWindow() on the window
562 _gdk_window_destroy (window, TRUE);
565 gdk_window_drop_cairo_surface (window);
569 g_object_unref (window->impl);
573 if (window->impl_window != window)
575 g_object_unref (window->impl_window);
576 window->impl_window = NULL;
580 cairo_region_destroy (window->shape);
582 if (window->input_shape)
583 cairo_region_destroy (window->input_shape);
586 g_object_unref (window->cursor);
588 if (window->device_cursor)
589 g_hash_table_destroy (window->device_cursor);
591 if (window->device_events)
592 g_hash_table_destroy (window->device_events);
594 if (window->source_event_masks)
595 g_hash_table_destroy (window->source_event_masks);
597 if (window->devices_inside)
598 g_list_free (window->devices_inside);
600 if (window->layered_region)
601 cairo_region_destroy (window->layered_region);
603 G_OBJECT_CLASS (parent_class)->finalize (object);
607 gdk_window_set_property (GObject *object,
612 GdkWindow *window = (GdkWindow *)object;
617 gdk_window_set_cursor (window, g_value_get_object (value));
621 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
627 gdk_window_get_property (GObject *object,
632 GdkWindow *window = (GdkWindow *) object;
637 g_value_set_object (value, gdk_window_get_cursor (window));
641 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
647 gdk_window_is_offscreen (GdkWindow *window)
649 return window->window_type == GDK_WINDOW_OFFSCREEN;
653 gdk_window_get_impl_window (GdkWindow *window)
655 return window->impl_window;
659 _gdk_window_get_impl_window (GdkWindow *window)
661 return gdk_window_get_impl_window (window);
665 gdk_window_has_impl (GdkWindow *window)
667 return window->impl_window == window;
671 gdk_window_is_toplevel (GdkWindow *window)
674 window->parent == NULL ||
675 window->parent->window_type == GDK_WINDOW_ROOT;
679 _gdk_window_has_impl (GdkWindow *window)
681 return gdk_window_has_impl (window);
685 gdk_window_has_no_impl (GdkWindow *window)
687 return window->impl_window != window;
691 remove_layered_child_area (GdkWindow *window,
692 cairo_region_t *region)
695 cairo_region_t *child_region;
699 for (l = window->children; l; l = l->next)
703 /* If region is empty already, no need to do
704 anything potentially costly */
705 if (cairo_region_is_empty (region))
708 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
711 /* Ignore offscreen children, as they don't draw in their parent and
712 * don't take part in the clipping */
713 if (gdk_window_is_offscreen (child))
716 /* Only non-impl children with alpha add to the layered region */
717 if (!child->has_alpha_background && gdk_window_has_impl (child))
722 r.width = child->width;
723 r.height = child->height;
725 /* Bail early if child totally outside region */
726 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
729 child_region = cairo_region_create_rectangle (&r);
732 /* Adjust shape region to parent window coords */
733 cairo_region_translate (child->shape, child->x, child->y);
734 cairo_region_intersect (child_region, child->shape);
735 cairo_region_translate (child->shape, -child->x, -child->y);
738 cairo_region_subtract (region, child_region);
739 cairo_region_destroy (child_region);
744 remove_child_area (GdkWindow *window,
747 cairo_region_t *region,
748 cairo_region_t *layered_region)
751 cairo_region_t *child_region;
754 cairo_region_t *shape;
756 for (l = window->children; l; l = l->next)
763 /* If region is empty already, no need to do
764 anything potentially costly */
765 if (cairo_region_is_empty (region))
768 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
771 /* Ignore offscreen children, as they don't draw in their parent and
772 * don't take part in the clipping */
773 if (gdk_window_is_offscreen (child))
778 r.width = child->width;
779 r.height = child->height;
781 /* Bail early if child totally outside region */
782 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
785 child_region = cairo_region_create_rectangle (&r);
789 /* Adjust shape region to parent window coords */
790 cairo_region_translate (child->shape, child->x, child->y);
791 cairo_region_intersect (child_region, child->shape);
792 cairo_region_translate (child->shape, -child->x, -child->y);
794 else if (window->window_type == GDK_WINDOW_FOREIGN)
796 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_shape (child);
799 cairo_region_intersect (child_region, shape);
800 cairo_region_destroy (shape);
806 if (child->input_shape)
807 cairo_region_intersect (child_region, child->input_shape);
808 else if (window->window_type == GDK_WINDOW_FOREIGN)
810 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_input_shape (child);
813 cairo_region_intersect (child_region, shape);
814 cairo_region_destroy (shape);
819 if (child->has_alpha_background)
821 if (layered_region != NULL)
822 cairo_region_union (layered_region, child_region);
825 cairo_region_subtract (region, child_region);
826 cairo_region_destroy (child_region);
830 static GdkVisibilityState
831 effective_visibility (GdkWindow *window)
833 GdkVisibilityState native;
835 if (!gdk_window_is_viewable (window))
836 return GDK_VISIBILITY_NOT_VIEWABLE;
838 native = window->impl_window->native_visibility;
840 if (native == GDK_VISIBILITY_FULLY_OBSCURED ||
841 window->visibility == GDK_VISIBILITY_FULLY_OBSCURED)
842 return GDK_VISIBILITY_FULLY_OBSCURED;
843 else if (native == GDK_VISIBILITY_UNOBSCURED)
844 return window->visibility;
845 else /* native PARTIAL, private partial or unobscured */
846 return GDK_VISIBILITY_PARTIAL;
850 gdk_window_update_visibility (GdkWindow *window)
852 GdkVisibilityState new_visibility;
855 new_visibility = effective_visibility (window);
857 if (new_visibility != window->effective_visibility)
859 window->effective_visibility = new_visibility;
861 if (new_visibility != GDK_VISIBILITY_NOT_VIEWABLE &&
862 window->event_mask & GDK_VISIBILITY_NOTIFY_MASK)
864 event = _gdk_make_event (window, GDK_VISIBILITY_NOTIFY,
866 event->visibility.state = new_visibility;
872 gdk_window_update_visibility_recursively (GdkWindow *window,
873 GdkWindow *only_for_impl)
878 gdk_window_update_visibility (window);
879 for (l = window->children; l != NULL; l = l->next)
882 if ((only_for_impl == NULL) ||
883 (only_for_impl == child->impl_window))
884 gdk_window_update_visibility_recursively (child, only_for_impl);
889 should_apply_clip_as_shape (GdkWindow *window)
892 gdk_window_has_impl (window) &&
893 /* Not for offscreens */
894 !gdk_window_is_offscreen (window) &&
895 /* or for toplevels */
896 !gdk_window_is_toplevel (window) &&
897 /* or for foreign windows */
898 window->window_type != GDK_WINDOW_FOREIGN &&
899 /* or for the root window */
900 window->window_type != GDK_WINDOW_ROOT;
904 apply_shape (GdkWindow *window,
905 cairo_region_t *region)
907 GdkWindowImplClass *impl_class;
909 /* We trash whether we applied a shape so that
910 we can avoid unsetting it many times, which
911 could happen in e.g. apply_clip_as_shape as
912 windows get resized */
913 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
915 impl_class->shape_combine_region (window,
917 else if (window->applied_shape)
918 impl_class->shape_combine_region (window,
921 window->applied_shape = region != NULL;
925 region_rect_equal (const cairo_region_t *region,
926 const GdkRectangle *rect)
928 GdkRectangle extents;
930 if (cairo_region_num_rectangles (region) != 1)
933 cairo_region_get_extents (region, &extents);
935 return extents.x == rect->x &&
936 extents.y == rect->y &&
937 extents.width == rect->width &&
938 extents.height == rect->height;
942 apply_clip_as_shape (GdkWindow *window)
947 r.width = window->width;
948 r.height = window->height;
950 /* We only apply the clip region if would differ
951 from the actual clip region implied by the size
952 of the window. This is to avoid unneccessarily
953 adding meaningless shapes to all native subwindows */
954 if (!region_rect_equal (window->clip_region, &r))
955 apply_shape (window, window->clip_region);
957 apply_shape (window, NULL);
961 recompute_visible_regions_internal (GdkWindow *private,
962 gboolean recalculate_clip,
963 gboolean recalculate_siblings,
964 gboolean recalculate_children)
969 cairo_region_t *new_clip, *new_layered;
970 gboolean clip_region_changed;
971 gboolean abs_pos_changed;
972 int old_abs_x, old_abs_y;
974 old_abs_x = private->abs_x;
975 old_abs_y = private->abs_y;
977 /* Update absolute position */
978 if (gdk_window_has_impl (private))
980 /* Native window starts here */
986 private->abs_x = private->parent->abs_x + private->x;
987 private->abs_y = private->parent->abs_y + private->y;
991 private->abs_x != old_abs_x ||
992 private->abs_y != old_abs_y;
994 /* Update clip region based on:
997 * siblings in parents above window
999 clip_region_changed = FALSE;
1000 if (recalculate_clip)
1002 new_layered = cairo_region_create ();
1003 if (private->viewable)
1005 /* Calculate visible region (sans children) in parent window coords */
1008 r.width = private->width;
1009 r.height = private->height;
1010 new_clip = cairo_region_create_rectangle (&r);
1012 if (!gdk_window_is_toplevel (private))
1014 cairo_region_intersect (new_clip, private->parent->clip_region);
1015 cairo_region_union (new_layered, private->parent->layered_region);
1017 /* Remove all overlapping children from parent. */
1018 remove_child_area (private->parent, private, FALSE, new_clip, new_layered);
1021 /* Convert from parent coords to window coords */
1022 cairo_region_translate (new_clip, -private->x, -private->y);
1023 cairo_region_translate (new_layered, -private->x, -private->y);
1026 cairo_region_intersect (new_clip, private->shape);
1029 new_clip = cairo_region_create ();
1031 cairo_region_intersect (new_layered, new_clip);
1033 if (private->clip_region == NULL ||
1034 !cairo_region_equal (private->clip_region, new_clip))
1035 clip_region_changed = TRUE;
1037 if (private->layered_region == NULL ||
1038 !cairo_region_equal (private->layered_region, new_layered))
1039 clip_region_changed = TRUE;
1041 if (private->clip_region)
1042 cairo_region_destroy (private->clip_region);
1043 private->clip_region = new_clip;
1045 if (private->layered_region != NULL)
1046 cairo_region_destroy (private->layered_region);
1047 private->layered_region = new_layered;
1049 if (private->clip_region_with_children)
1050 cairo_region_destroy (private->clip_region_with_children);
1051 private->clip_region_with_children = cairo_region_copy (private->clip_region);
1052 if (private->window_type != GDK_WINDOW_ROOT)
1053 remove_child_area (private, NULL, FALSE, private->clip_region_with_children, NULL);
1056 if (clip_region_changed)
1058 GdkVisibilityState visibility;
1059 gboolean fully_visible;
1061 if (cairo_region_is_empty (private->clip_region))
1062 visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1067 fully_visible = cairo_region_equal (private->clip_region,
1074 r.width = private->width;
1075 r.height = private->height;
1076 fully_visible = region_rect_equal (private->clip_region, &r);
1080 visibility = GDK_VISIBILITY_UNOBSCURED;
1082 visibility = GDK_VISIBILITY_PARTIAL;
1085 if (private->visibility != visibility)
1087 private->visibility = visibility;
1088 gdk_window_update_visibility (private);
1092 /* Update all children, recursively (except for root, where children are not exact). */
1093 if ((abs_pos_changed || clip_region_changed || recalculate_children) &&
1094 private->window_type != GDK_WINDOW_ROOT)
1096 for (l = private->children; l; l = l->next)
1099 /* Only recalculate clip if the the clip region changed, otherwise
1100 * there is no way the child clip region could change (its has not e.g. moved)
1101 * Except if recalculate_children is set to force child updates
1103 recompute_visible_regions_internal (child,
1104 recalculate_clip && (clip_region_changed || recalculate_children),
1109 if (clip_region_changed &&
1110 should_apply_clip_as_shape (private))
1111 apply_clip_as_shape (private);
1113 if (recalculate_siblings &&
1114 !gdk_window_is_toplevel (private))
1116 /* If we moved a child window in parent or changed the stacking order, then we
1117 * need to recompute the visible area of all the other children in the parent
1119 for (l = private->parent->children; l; l = l->next)
1123 if (child != private)
1124 recompute_visible_regions_internal (child, TRUE, FALSE, FALSE);
1127 /* We also need to recompute the _with_children clip for the parent */
1128 recompute_visible_regions_internal (private->parent, TRUE, FALSE, FALSE);
1131 if (private->cairo_surface && gdk_window_has_impl (private))
1133 GdkWindowImplClass *iface = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1135 private->cairo_surface = iface->resize_cairo_surface (private,
1136 private->cairo_surface,
1140 else if (private->cairo_surface)
1141 gdk_window_drop_cairo_surface (private);
1144 /* Call this when private has changed in one or more of these ways:
1148 * stacking order of window changed
1151 * It will recalculate abs_x/y and the clip regions
1153 * Unless the window didn't change stacking order or size/pos, pass in TRUE
1154 * for recalculate_siblings. (Mostly used internally for the recursion)
1156 * If a child window was removed (and you can't use that child for
1157 * recompute_visible_regions), pass in TRUE for recalculate_children on the parent
1160 recompute_visible_regions (GdkWindow *private,
1161 gboolean recalculate_siblings,
1162 gboolean recalculate_children)
1164 recompute_visible_regions_internal (private,
1166 recalculate_siblings,
1167 recalculate_children);
1171 _gdk_window_update_size (GdkWindow *window)
1173 recompute_visible_regions (window, TRUE, FALSE);
1176 /* Find the native window that would be just above "child"
1177 * in the native stacking order if "child" was a native window
1178 * (it doesn't have to be native). If there is no such native
1179 * window inside this native parent then NULL is returned.
1180 * If child is NULL, find lowest native window in parent.
1183 find_native_sibling_above_helper (GdkWindow *parent,
1191 l = g_list_find (parent->children, child);
1192 g_assert (l != NULL); /* Better be a child of its parent... */
1193 l = l->prev; /* Start looking at the one above the child */
1196 l = g_list_last (parent->children);
1198 for (; l != NULL; l = l->prev)
1202 if (gdk_window_has_impl (w))
1205 g_assert (parent != w);
1206 w = find_native_sibling_above_helper (w, NULL);
1216 find_native_sibling_above (GdkWindow *parent,
1221 w = find_native_sibling_above_helper (parent, child);
1225 if (gdk_window_has_impl (parent))
1228 return find_native_sibling_above (parent->parent, parent);
1232 get_native_device_event_mask (GdkWindow *private,
1235 GdkEventMask event_mask;
1238 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device));
1240 event_mask = private->event_mask;
1242 if (private->window_type == GDK_WINDOW_ROOT ||
1243 private->window_type == GDK_WINDOW_FOREIGN)
1249 /* Do whatever the app asks to, since the app
1250 * may be asking for weird things for native windows,
1251 * but don't use motion hints as that may affect non-native
1252 * child windows that don't want it. Also, we need to
1253 * set all the app-specified masks since they will be picked
1254 * up by any implicit grabs (i.e. if they were not set as
1255 * native we would not get the events we need). */
1256 mask = private->event_mask & ~GDK_POINTER_MOTION_HINT_MASK;
1258 /* We need thse for all native windows so we can
1259 emulate events on children: */
1262 GDK_VISIBILITY_NOTIFY_MASK |
1263 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
1265 /* Additionally we select for pointer and button events
1266 * for toplevels as we need to get these to emulate
1267 * them for non-native subwindows. Even though we don't
1268 * select on them for all native windows we will get them
1269 * as the events are propagated out to the first window
1270 * that select for them.
1271 * Not selecting for button press on all windows is an
1272 * important thing, because in X only one client can do
1273 * so, and we don't want to unexpectedly prevent another
1274 * client from doing it.
1276 * We also need to do the same if the app selects for button presses
1277 * because then we will get implicit grabs for this window, and the
1278 * event mask used for that grab is based on the rest of the mask
1279 * for the window, but we might need more events than this window
1280 * lists due to some non-native child window.
1282 if (gdk_window_is_toplevel (private) ||
1283 mask & GDK_BUTTON_PRESS_MASK)
1286 GDK_POINTER_MOTION_MASK |
1287 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1295 get_native_grab_event_mask (GdkEventMask grab_mask)
1297 /* Similar to the above but for pointer events only */
1299 GDK_POINTER_MOTION_MASK |
1300 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1301 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
1304 ~GDK_POINTER_MOTION_HINT_MASK);
1308 get_native_event_mask (GdkWindow *private)
1310 return get_native_device_event_mask (private, NULL);
1313 /* Puts the native window in the right order wrt the other native windows
1314 * in the hierarchy, given the position it has in the client side data.
1315 * This is useful if some operation changed the stacking order.
1316 * This calls assumes the native window is now topmost in its native parent.
1319 sync_native_window_stack_position (GdkWindow *window)
1322 GdkWindowImplClass *impl_class;
1323 GList listhead = {0};
1325 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1327 above = find_native_sibling_above (window->parent, window);
1330 listhead.data = window;
1331 impl_class->restack_under (above, &listhead);
1336 * gdk_window_new: (constructor)
1337 * @parent: (allow-none): a #GdkWindow, or %NULL to create the window as a child of
1338 * the default root window for the default display.
1339 * @attributes: attributes of the new window
1340 * @attributes_mask: (type GdkWindowAttributesType): mask indicating which
1341 * fields in @attributes are valid
1343 * Creates a new #GdkWindow using the attributes from
1344 * @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
1345 * more details. Note: to use this on displays other than the default
1346 * display, @parent must be specified.
1348 * Return value: (transfer full): the new #GdkWindow
1351 gdk_window_new (GdkWindow *parent,
1352 GdkWindowAttr *attributes,
1353 gint attributes_mask)
1357 GdkDisplay *display;
1360 GdkEventMask event_mask;
1361 GdkWindow *real_parent;
1362 GdkDeviceManager *device_manager;
1364 g_return_val_if_fail (attributes != NULL, NULL);
1368 GDK_NOTE (MULTIHEAD,
1369 g_warning ("gdk_window_new(): no parent specified reverting to parent = default root window"));
1371 screen = gdk_screen_get_default ();
1372 parent = gdk_screen_get_root_window (screen);
1375 screen = gdk_window_get_screen (parent);
1377 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
1379 if (GDK_WINDOW_DESTROYED (parent))
1381 g_warning ("gdk_window_new(): parent is destroyed\n");
1385 display = gdk_screen_get_display (screen);
1387 window = _gdk_display_create_window (display);
1389 /* Windows with a foreign parent are treated as if they are children
1390 * of the root window, except for actual creation.
1392 real_parent = parent;
1393 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
1394 parent = gdk_screen_get_root_window (screen);
1396 window->parent = parent;
1398 window->accept_focus = TRUE;
1399 window->focus_on_map = TRUE;
1401 if (attributes_mask & GDK_WA_X)
1406 if (attributes_mask & GDK_WA_Y)
1413 window->width = (attributes->width > 1) ? (attributes->width) : (1);
1414 window->height = (attributes->height > 1) ? (attributes->height) : (1);
1416 if (attributes->wclass == GDK_INPUT_ONLY)
1418 /* Backwards compatiblity - we've always ignored
1419 * attributes->window_type for input-only windows
1422 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_ROOT)
1423 window->window_type = GDK_WINDOW_TEMP;
1425 window->window_type = GDK_WINDOW_CHILD;
1428 window->window_type = attributes->window_type;
1431 switch (window->window_type)
1433 case GDK_WINDOW_TOPLEVEL:
1434 case GDK_WINDOW_TEMP:
1435 case GDK_WINDOW_OFFSCREEN:
1436 if (GDK_WINDOW_TYPE (parent) != GDK_WINDOW_ROOT)
1437 g_warning (G_STRLOC "Toplevel windows must be created as children of\n"
1438 "of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
1439 case GDK_WINDOW_CHILD:
1443 g_warning (G_STRLOC "cannot make windows of type %d", window->window_type);
1447 if (attributes_mask & GDK_WA_VISUAL)
1448 window->visual = attributes->visual;
1450 window->visual = gdk_screen_get_system_visual (screen);
1452 window->event_mask = attributes->event_mask;
1454 if (attributes->wclass == GDK_INPUT_OUTPUT)
1456 window->input_only = FALSE;
1457 window->depth = window->visual->depth;
1459 /* XXX: Cache this somehow? */
1460 window->background = cairo_pattern_create_rgba (0, 0, 0, 0);
1461 window->has_alpha_background = TRUE;
1466 window->input_only = TRUE;
1470 window->parent->children = g_list_prepend (window->parent->children, window);
1473 if (window->parent->window_type == GDK_WINDOW_ROOT)
1474 native = TRUE; /* Always use native windows for toplevels */
1475 else if (!window->input_only &&
1476 (attributes_mask & GDK_WA_VISUAL &&
1477 attributes->visual != gdk_window_get_visual (window->parent)))
1478 native = TRUE; /* InputOutput window with different visual than parent, needs native window */
1480 if (gdk_window_is_offscreen (window))
1482 _gdk_offscreen_window_new (window, attributes, attributes_mask);
1483 window->impl_window = window;
1487 event_mask = get_native_event_mask (window);
1489 /* Create the impl */
1490 _gdk_display_create_window_impl (display, window, real_parent, screen, event_mask, attributes, attributes_mask);
1491 window->impl_window = window;
1493 /* This will put the native window topmost in the native parent, which may
1494 * be wrong wrt other native windows in the non-native hierarchy, so restack */
1495 if (!_gdk_window_has_impl (real_parent))
1496 sync_native_window_stack_position (window);
1500 window->impl_window = g_object_ref (window->parent->impl_window);
1501 window->impl = g_object_ref (window->impl_window->impl);
1504 recompute_visible_regions (window, TRUE, FALSE);
1506 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
1507 (attributes->cursor) :
1510 device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent));
1511 g_signal_connect (device_manager, "device-removed",
1512 G_CALLBACK (device_removed_cb), window);
1518 is_parent_of (GdkWindow *parent,
1529 w = gdk_window_get_parent (w);
1536 change_impl (GdkWindow *private,
1537 GdkWindow *impl_window,
1542 GdkWindowImpl *old_impl;
1543 GdkWindow *old_impl_window;
1545 old_impl = private->impl;
1546 old_impl_window = private->impl_window;
1547 if (private != impl_window)
1548 private->impl_window = g_object_ref (impl_window);
1550 private->impl_window = private;
1551 private->impl = g_object_ref (new);
1552 if (old_impl_window != private)
1553 g_object_unref (old_impl_window);
1554 g_object_unref (old_impl);
1556 for (l = private->children; l != NULL; l = l->next)
1560 if (child->impl == old_impl)
1561 change_impl (child, impl_window, new);
1566 reparent_to_impl (GdkWindow *private)
1571 GdkWindowImplClass *impl_class;
1573 impl_class = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1575 /* Enumerate in reverse order so we get the right order for the native
1576 windows (first in childrens list is topmost, and reparent places on top) */
1577 for (l = g_list_last (private->children); l != NULL; l = l->prev)
1581 if (child->impl == private->impl)
1582 reparent_to_impl (child);
1585 show = impl_class->reparent ((GdkWindow *)child,
1586 (GdkWindow *)private,
1587 child->x, child->y);
1589 gdk_window_show_unraised ((GdkWindow *)child);
1596 * gdk_window_reparent:
1597 * @window: a #GdkWindow
1598 * @new_parent: new parent to move @window into
1599 * @x: X location inside the new parent
1600 * @y: Y location inside the new parent
1602 * Reparents @window into the given @new_parent. The window being
1603 * reparented will be unmapped as a side effect.
1607 gdk_window_reparent (GdkWindow *window,
1608 GdkWindow *new_parent,
1612 GdkWindow *old_parent;
1614 gboolean show, was_mapped, applied_clip_as_shape;
1615 gboolean do_reparent_to_impl;
1616 GdkEventMask old_native_event_mask;
1617 GdkWindowImplClass *impl_class;
1619 g_return_if_fail (GDK_IS_WINDOW (window));
1620 g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1621 g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1623 if (GDK_WINDOW_DESTROYED (window) ||
1624 (new_parent && GDK_WINDOW_DESTROYED (new_parent)))
1627 screen = gdk_window_get_screen (window);
1629 new_parent = gdk_screen_get_root_window (screen);
1631 /* No input-output children of input-only windows */
1632 if (new_parent->input_only && !window->input_only)
1635 /* Don't create loops in hierarchy */
1636 if (is_parent_of (window, new_parent))
1639 /* This might be wrong in the new parent, e.g. for non-native surfaces.
1640 To make sure we're ok, just wipe it. */
1641 gdk_window_drop_cairo_surface (window);
1643 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1644 old_parent = window->parent;
1646 was_mapped = GDK_WINDOW_IS_MAPPED (window);
1649 /* Reparenting to toplevel. Ensure we have a native window so this can work */
1650 if (new_parent->window_type == GDK_WINDOW_ROOT ||
1651 new_parent->window_type == GDK_WINDOW_FOREIGN)
1652 gdk_window_ensure_native (window);
1654 applied_clip_as_shape = should_apply_clip_as_shape (window);
1656 old_native_event_mask = 0;
1657 do_reparent_to_impl = FALSE;
1658 if (gdk_window_has_impl (window))
1660 old_native_event_mask = get_native_event_mask (window);
1662 show = impl_class->reparent (window, new_parent, x, y);
1666 /* This shouldn't happen, as we created a native in this case, check anyway to see if that ever fails */
1667 g_assert (new_parent->window_type != GDK_WINDOW_ROOT &&
1668 new_parent->window_type != GDK_WINDOW_FOREIGN);
1671 gdk_window_hide (window);
1673 do_reparent_to_impl = TRUE;
1674 change_impl (window,
1675 new_parent->impl_window,
1679 /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1682 if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1684 new_parent = gdk_screen_get_root_window (screen);
1688 old_parent->children = g_list_remove (old_parent->children, window);
1690 window->parent = new_parent;
1694 new_parent->children = g_list_prepend (new_parent->children, window);
1696 /* Switch the window type as appropriate */
1698 switch (GDK_WINDOW_TYPE (new_parent))
1700 case GDK_WINDOW_ROOT:
1701 case GDK_WINDOW_FOREIGN:
1702 if (window->toplevel_window_type != -1)
1703 GDK_WINDOW_TYPE (window) = window->toplevel_window_type;
1704 else if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
1705 GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
1707 case GDK_WINDOW_OFFSCREEN:
1708 case GDK_WINDOW_TOPLEVEL:
1709 case GDK_WINDOW_CHILD:
1710 case GDK_WINDOW_TEMP:
1711 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
1712 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
1714 /* Save the original window type so we can restore it if the
1715 * window is reparented back to be a toplevel
1717 window->toplevel_window_type = GDK_WINDOW_TYPE (window);
1718 GDK_WINDOW_TYPE (window) = GDK_WINDOW_CHILD;
1722 /* We might have changed window type for a native windows, so we
1723 need to change the event mask too. */
1724 if (gdk_window_has_impl (window))
1726 GdkEventMask native_event_mask = get_native_event_mask (window);
1728 if (native_event_mask != old_native_event_mask)
1729 impl_class->set_events (window, native_event_mask);
1732 _gdk_window_update_viewable (window);
1734 if (window->background == NULL)
1736 /* parent relative background, update has_alpha_background */
1737 if (window->parent == NULL ||
1738 window->parent->window_type == GDK_WINDOW_ROOT)
1739 window->has_alpha_background = FALSE;
1741 window->has_alpha_background = window->parent->has_alpha_background;
1744 recompute_visible_regions (window, TRUE, FALSE);
1745 if (old_parent && GDK_WINDOW_TYPE (old_parent) != GDK_WINDOW_ROOT)
1746 recompute_visible_regions (old_parent, FALSE, TRUE);
1748 _gdk_window_propagate_has_alpha_background (window);
1750 /* We used to apply the clip as the shape, but no more.
1751 Reset this to the real shape */
1752 if (gdk_window_has_impl (window) &&
1753 applied_clip_as_shape &&
1754 !should_apply_clip_as_shape (window))
1755 apply_shape (window, window->shape);
1757 if (do_reparent_to_impl)
1758 reparent_to_impl (window);
1761 /* The reparent will have put the native window topmost in the native parent,
1762 * which may be wrong wrt other native windows in the non-native hierarchy,
1764 if (!gdk_window_has_impl (new_parent))
1765 sync_native_window_stack_position (window);
1769 gdk_window_show_unraised (window);
1771 _gdk_synthesize_crossing_events_for_geometry_change (window);
1775 * gdk_window_ensure_native:
1776 * @window: a #GdkWindow
1778 * Tries to ensure that there is a window-system native window for this
1779 * GdkWindow. This may fail in some situations, returning %FALSE.
1781 * Offscreen window and children of them can never have native windows.
1783 * Some backends may not support native child windows.
1785 * Returns: %TRUE if the window has a native window, %FALSE otherwise
1790 gdk_window_ensure_native (GdkWindow *window)
1792 GdkWindow *impl_window;
1793 GdkWindowImpl *new_impl, *old_impl;
1794 GdkDisplay *display;
1798 GdkWindowImplClass *impl_class;
1800 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
1802 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_ROOT ||
1803 GDK_WINDOW_DESTROYED (window))
1806 impl_window = gdk_window_get_impl_window (window);
1808 if (gdk_window_is_offscreen (impl_window))
1809 return FALSE; /* native in offscreens not supported */
1811 if (impl_window == window)
1812 /* Already has an impl, and its not offscreen . */
1815 /* Need to create a native window */
1817 gdk_window_drop_cairo_surface (window);
1819 screen = gdk_window_get_screen (window);
1820 display = gdk_screen_get_display (screen);
1822 old_impl = window->impl;
1823 _gdk_display_create_window_impl (display,
1824 window, window->parent,
1826 get_native_event_mask (window),
1828 new_impl = window->impl;
1830 window->impl = old_impl;
1831 change_impl (window, window, new_impl);
1833 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1835 /* Native window creation will put the native window topmost in the
1836 * native parent, which may be wrong wrt the position of the previous
1837 * non-native window wrt to the other non-native children, so correct this.
1839 above = find_native_sibling_above (window->parent, window);
1842 listhead.data = window;
1843 listhead.prev = NULL;
1844 listhead.next = NULL;
1845 impl_class->restack_under ((GdkWindow *)above, &listhead);
1848 recompute_visible_regions (window, FALSE, FALSE);
1850 /* The shape may not have been set, as the clip region doesn't actually
1851 change, so do it here manually */
1852 if (should_apply_clip_as_shape (window))
1853 apply_clip_as_shape (window);
1855 reparent_to_impl (window);
1857 if (!window->input_only)
1858 impl_class->set_background (window, window->background);
1860 impl_class->input_shape_combine_region (window,
1861 window->input_shape,
1864 if (gdk_window_is_viewable (window))
1865 impl_class->show (window, FALSE);
1871 * _gdk_event_filter_unref:
1872 * @window: (allow-none): A #GdkWindow, or %NULL to be the global window
1873 * @filter: A window filter
1875 * Release a reference to @filter. Note this function may
1876 * mutate the list storage, so you need to handle this
1877 * if iterating over a list of filters.
1880 _gdk_event_filter_unref (GdkWindow *window,
1881 GdkEventFilter *filter)
1887 filters = &_gdk_default_filters;
1889 filters = &window->filters;
1891 tmp_list = *filters;
1894 GdkEventFilter *iter_filter = tmp_list->data;
1898 tmp_list = tmp_list->next;
1900 if (iter_filter != filter)
1903 g_assert (iter_filter->ref_count > 0);
1905 filter->ref_count--;
1906 if (filter->ref_count != 0)
1909 *filters = g_list_remove_link (*filters, node);
1911 g_list_free_1 (node);
1916 window_remove_filters (GdkWindow *window)
1918 while (window->filters)
1919 _gdk_event_filter_unref (window, window->filters->data);
1923 update_pointer_info_foreach (GdkDisplay *display,
1925 GdkPointerWindowInfo *pointer_info,
1928 GdkWindow *window = user_data;
1930 if (pointer_info->toplevel_under_pointer == window)
1932 g_object_unref (pointer_info->toplevel_under_pointer);
1933 pointer_info->toplevel_under_pointer = NULL;
1938 window_remove_from_pointer_info (GdkWindow *window,
1939 GdkDisplay *display)
1941 _gdk_display_pointer_info_foreach (display,
1942 update_pointer_info_foreach,
1947 * _gdk_window_destroy_hierarchy:
1948 * @window: a #GdkWindow
1949 * @recursing: If TRUE, then this is being called because a parent
1951 * @recursing_native: If TRUE, then this is being called because a native parent
1952 * was destroyed. This generally means that the call to the
1953 * windowing system to destroy the window can be omitted, since
1954 * it will be destroyed as a result of the parent being destroyed.
1955 * Unless @foreign_destroy.
1956 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
1957 * external agency. The window has already been destroyed and no
1958 * windowing system calls should be made. (This may never happen
1959 * for some windowing systems.)
1961 * Internal function to destroy a window. Like gdk_window_destroy(),
1962 * but does not drop the reference count created by gdk_window_new().
1965 _gdk_window_destroy_hierarchy (GdkWindow *window,
1967 gboolean recursing_native,
1968 gboolean foreign_destroy)
1970 GdkWindowImplClass *impl_class;
1971 GdkWindow *temp_window;
1973 GdkDisplay *display;
1977 g_return_if_fail (GDK_IS_WINDOW (window));
1979 if (GDK_WINDOW_DESTROYED (window))
1982 display = gdk_window_get_display (window);
1983 screen = gdk_window_get_screen (window);
1984 temp_window = g_object_get_qdata (G_OBJECT (screen), quark_pointer_window);
1985 if (temp_window == window)
1986 g_object_set_qdata (G_OBJECT (screen), quark_pointer_window, NULL);
1989 switch (window->window_type)
1991 case GDK_WINDOW_ROOT:
1992 if (!screen->closed)
1994 g_error ("attempted to destroy root window");
1997 /* else fall thru */
1998 case GDK_WINDOW_TOPLEVEL:
1999 case GDK_WINDOW_CHILD:
2000 case GDK_WINDOW_TEMP:
2001 case GDK_WINDOW_FOREIGN:
2002 case GDK_WINDOW_OFFSCREEN:
2003 if (window->window_type == GDK_WINDOW_FOREIGN && !foreign_destroy)
2005 /* Logically, it probably makes more sense to send
2006 * a "destroy yourself" message to the foreign window
2007 * whether or not it's in our hierarchy; but for historical
2008 * reasons, we only send "destroy yourself" messages to
2009 * foreign windows in our hierarchy.
2013 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
2015 if (gdk_window_has_impl (window))
2016 impl_class->destroy_foreign (window);
2019 /* Also for historical reasons, we remove any filters
2020 * on a foreign window when it or a parent is destroyed;
2021 * this likely causes problems if two separate portions
2022 * of code are maintaining filter lists on a foreign window.
2024 window_remove_filters (window);
2030 if (window->parent->children)
2031 window->parent->children = g_list_remove (window->parent->children, window);
2034 GDK_WINDOW_IS_MAPPED (window))
2036 recompute_visible_regions (window, TRUE, FALSE);
2037 gdk_window_invalidate_in_parent (window);
2041 gdk_window_free_paint_stack (window);
2043 if (window->background)
2045 cairo_pattern_destroy (window->background);
2046 window->background = NULL;
2049 if (window->window_type == GDK_WINDOW_FOREIGN)
2050 g_assert (window->children == NULL);
2053 children = tmp = window->children;
2054 window->children = NULL;
2058 temp_window = tmp->data;
2062 _gdk_window_destroy_hierarchy (temp_window,
2064 recursing_native || gdk_window_has_impl (window),
2068 g_list_free (children);
2071 _gdk_window_clear_update_area (window);
2073 gdk_window_drop_cairo_surface (window);
2075 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
2077 if (gdk_window_has_impl (window))
2078 impl_class->destroy (window, recursing_native,
2082 /* hide to make sure we repaint and break grabs */
2083 gdk_window_hide (window);
2086 window->state |= GDK_WINDOW_STATE_WITHDRAWN;
2087 window->parent = NULL;
2088 window->destroyed = TRUE;
2090 window_remove_filters (window);
2092 window_remove_from_pointer_info (window, display);
2094 if (window->clip_region)
2096 cairo_region_destroy (window->clip_region);
2097 window->clip_region = NULL;
2100 if (window->clip_region_with_children)
2102 cairo_region_destroy (window->clip_region_with_children);
2103 window->clip_region_with_children = NULL;
2106 g_list_free_full (window->outstanding_moves, (GDestroyNotify) gdk_window_region_move_free);
2107 window->outstanding_moves = NULL;
2114 * _gdk_window_destroy:
2115 * @window: a #GdkWindow
2116 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
2117 * external agency. The window has already been destroyed and no
2118 * windowing system calls should be made. (This may never happen
2119 * for some windowing systems.)
2121 * Internal function to destroy a window. Like gdk_window_destroy(),
2122 * but does not drop the reference count created by gdk_window_new().
2125 _gdk_window_destroy (GdkWindow *window,
2126 gboolean foreign_destroy)
2128 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, foreign_destroy);
2132 * gdk_window_destroy:
2133 * @window: a #GdkWindow
2135 * Destroys the window system resources associated with @window and decrements @window's
2136 * reference count. The window system resources for all children of @window are also
2137 * destroyed, but the children's reference counts are not decremented.
2139 * Note that a window will not be destroyed automatically when its reference count
2140 * reaches zero. You must call this function yourself before that happens.
2144 gdk_window_destroy (GdkWindow *window)
2146 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, FALSE);
2147 g_object_unref (window);
2151 * gdk_window_set_user_data:
2152 * @window: a #GdkWindow
2153 * @user_data: (allow-none) (type GObject.Object): user data
2155 * For most purposes this function is deprecated in favor of
2156 * g_object_set_data(). However, for historical reasons GTK+ stores
2157 * the #GtkWidget that owns a #GdkWindow as user data on the
2158 * #GdkWindow. So, custom widget implementations should use
2159 * this function for that. If GTK+ receives an event for a #GdkWindow,
2160 * and the user data for the window is non-%NULL, GTK+ will assume the
2161 * user data is a #GtkWidget, and forward the event to that widget.
2165 gdk_window_set_user_data (GdkWindow *window,
2168 g_return_if_fail (GDK_IS_WINDOW (window));
2170 window->user_data = user_data;
2174 * gdk_window_get_user_data:
2175 * @window: a #GdkWindow
2176 * @data: (out): return location for user data
2178 * Retrieves the user data for @window, which is normally the widget
2179 * that @window belongs to. See gdk_window_set_user_data().
2183 gdk_window_get_user_data (GdkWindow *window,
2186 g_return_if_fail (GDK_IS_WINDOW (window));
2188 *data = window->user_data;
2192 * gdk_window_get_window_type:
2193 * @window: a #GdkWindow
2195 * Gets the type of the window. See #GdkWindowType.
2197 * Return value: type of window
2200 gdk_window_get_window_type (GdkWindow *window)
2202 g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
2204 return GDK_WINDOW_TYPE (window);
2208 * gdk_window_get_visual:
2209 * @window: a #GdkWindow
2211 * Gets the #GdkVisual describing the pixel format of @window.
2213 * Return value: (transfer none): a #GdkVisual
2218 gdk_window_get_visual (GdkWindow *window)
2220 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2222 return window->visual;
2226 * gdk_window_get_screen:
2227 * @window: a #GdkWindow
2229 * Gets the #GdkScreen associated with a #GdkWindow.
2231 * Return value: (transfer none): the #GdkScreen associated with @window
2236 gdk_window_get_screen (GdkWindow *window)
2238 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2240 return gdk_visual_get_screen (window->visual);
2244 * gdk_window_get_display:
2245 * @window: a #GdkWindow
2247 * Gets the #GdkDisplay associated with a #GdkWindow.
2249 * Return value: (transfer none): the #GdkDisplay associated with @window
2254 gdk_window_get_display (GdkWindow *window)
2256 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2258 return gdk_screen_get_display (gdk_visual_get_screen (window->visual));
2261 * gdk_window_is_destroyed:
2262 * @window: a #GdkWindow
2264 * Check to see if a window is destroyed..
2266 * Return value: %TRUE if the window is destroyed
2271 gdk_window_is_destroyed (GdkWindow *window)
2273 return GDK_WINDOW_DESTROYED (window);
2277 to_embedder (GdkWindow *window,
2278 gdouble offscreen_x,
2279 gdouble offscreen_y,
2280 gdouble *embedder_x,
2281 gdouble *embedder_y)
2283 g_signal_emit (window, signals[TO_EMBEDDER], 0,
2284 offscreen_x, offscreen_y,
2285 embedder_x, embedder_y);
2289 from_embedder (GdkWindow *window,
2292 gdouble *offscreen_x,
2293 gdouble *offscreen_y)
2295 g_signal_emit (window, signals[FROM_EMBEDDER], 0,
2296 embedder_x, embedder_y,
2297 offscreen_x, offscreen_y);
2301 * gdk_window_has_native:
2302 * @window: a #GdkWindow
2304 * Checks whether the window has a native window or not. Note that
2305 * you can use gdk_window_ensure_native() if a native window is needed.
2307 * Returns: %TRUE if the %window has a native window, %FALSE otherwise.
2312 gdk_window_has_native (GdkWindow *window)
2314 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2316 return window->parent == NULL || window->parent->impl != window->impl;
2320 * gdk_window_get_position:
2321 * @window: a #GdkWindow
2322 * @x: (out) (allow-none): X coordinate of window
2323 * @y: (out) (allow-none): Y coordinate of window
2325 * Obtains the position of the window as reported in the
2326 * most-recently-processed #GdkEventConfigure. Contrast with
2327 * gdk_window_get_geometry() which queries the X server for the
2328 * current window position, regardless of which events have been
2329 * received or processed.
2331 * The position coordinates are relative to the window's parent window.
2335 gdk_window_get_position (GdkWindow *window,
2339 g_return_if_fail (GDK_IS_WINDOW (window));
2348 * gdk_window_get_parent:
2349 * @window: a #GdkWindow
2351 * Obtains the parent of @window, as known to GDK. Does not query the
2352 * X server; thus this returns the parent as passed to gdk_window_new(),
2353 * not the actual parent. This should never matter unless you're using
2354 * Xlib calls mixed with GDK calls on the X11 platform. It may also
2355 * matter for toplevel windows, because the window manager may choose
2358 * Note that you should use gdk_window_get_effective_parent() when
2359 * writing generic code that walks up a window hierarchy, because
2360 * gdk_window_get_parent() will most likely not do what you expect if
2361 * there are offscreen windows in the hierarchy.
2363 * Return value: (transfer none): parent of @window
2366 gdk_window_get_parent (GdkWindow *window)
2368 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2370 return window->parent;
2374 * gdk_window_get_effective_parent:
2375 * @window: a #GdkWindow
2377 * Obtains the parent of @window, as known to GDK. Works like
2378 * gdk_window_get_parent() for normal windows, but returns the
2379 * window's embedder for offscreen windows.
2381 * See also: gdk_offscreen_window_get_embedder()
2383 * Return value: (transfer none): effective parent of @window
2388 gdk_window_get_effective_parent (GdkWindow *window)
2390 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2392 if (gdk_window_is_offscreen (window))
2393 return gdk_offscreen_window_get_embedder (window);
2395 return window->parent;
2399 * gdk_window_get_toplevel:
2400 * @window: a #GdkWindow
2402 * Gets the toplevel window that's an ancestor of @window.
2404 * Any window type but %GDK_WINDOW_CHILD is considered a
2405 * toplevel window, as is a %GDK_WINDOW_CHILD window that
2406 * has a root window as parent.
2408 * Note that you should use gdk_window_get_effective_toplevel() when
2409 * you want to get to a window's toplevel as seen on screen, because
2410 * gdk_window_get_toplevel() will most likely not do what you expect
2411 * if there are offscreen windows in the hierarchy.
2413 * Return value: (transfer none): the toplevel window containing @window
2416 gdk_window_get_toplevel (GdkWindow *window)
2418 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2420 while (window->window_type == GDK_WINDOW_CHILD)
2422 if (gdk_window_is_toplevel (window))
2424 window = window->parent;
2431 * gdk_window_get_effective_toplevel:
2432 * @window: a #GdkWindow
2434 * Gets the toplevel window that's an ancestor of @window.
2436 * Works like gdk_window_get_toplevel(), but treats an offscreen window's
2437 * embedder as its parent, using gdk_window_get_effective_parent().
2439 * See also: gdk_offscreen_window_get_embedder()
2441 * Return value: (transfer none): the effective toplevel window containing @window
2446 gdk_window_get_effective_toplevel (GdkWindow *window)
2450 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2452 while ((parent = gdk_window_get_effective_parent (window)) != NULL &&
2453 (gdk_window_get_window_type (parent) != GDK_WINDOW_ROOT))
2460 * gdk_window_get_children:
2461 * @window: a #GdkWindow
2463 * Gets the list of children of @window known to GDK.
2464 * This function only returns children created via GDK,
2465 * so for example it's useless when used with the root window;
2466 * it only returns windows an application created itself.
2468 * The returned list must be freed, but the elements in the
2471 * Return value: (transfer container) (element-type GdkWindow):
2472 * list of child windows inside @window
2475 gdk_window_get_children (GdkWindow *window)
2477 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2479 if (GDK_WINDOW_DESTROYED (window))
2482 return g_list_copy (window->children);
2486 * gdk_window_peek_children:
2487 * @window: a #GdkWindow
2489 * Like gdk_window_get_children(), but does not copy the list of
2490 * children, so the list does not need to be freed.
2492 * Return value: (transfer none) (element-type GdkWindow):
2493 * a reference to the list of child windows in @window
2496 gdk_window_peek_children (GdkWindow *window)
2498 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2500 if (GDK_WINDOW_DESTROYED (window))
2503 return window->children;
2507 * gdk_window_add_filter: (skip)
2508 * @window: (allow-none): a #GdkWindow
2509 * @function: filter callback
2510 * @data: data to pass to filter callback
2512 * Adds an event filter to @window, allowing you to intercept events
2513 * before they reach GDK. This is a low-level operation and makes it
2514 * easy to break GDK and/or GTK+, so you have to know what you're
2515 * doing. Pass %NULL for @window to get all events for all windows,
2516 * instead of events for a specific window.
2518 * If you are interested in X GenericEvents, bear in mind that
2519 * XGetEventData() has been already called on the event, and
2520 * XFreeEventData() must not be called within @function.
2523 gdk_window_add_filter (GdkWindow *window,
2524 GdkFilterFunc function,
2528 GdkEventFilter *filter;
2530 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2532 if (window && GDK_WINDOW_DESTROYED (window))
2535 /* Filters are for the native events on the native window, so
2536 ensure there is a native window. */
2538 gdk_window_ensure_native (window);
2541 tmp_list = window->filters;
2543 tmp_list = _gdk_default_filters;
2547 filter = (GdkEventFilter *)tmp_list->data;
2548 if ((filter->function == function) && (filter->data == data))
2550 filter->ref_count++;
2553 tmp_list = tmp_list->next;
2556 filter = g_new (GdkEventFilter, 1);
2557 filter->function = function;
2558 filter->data = data;
2559 filter->ref_count = 1;
2563 window->filters = g_list_append (window->filters, filter);
2565 _gdk_default_filters = g_list_append (_gdk_default_filters, filter);
2569 * gdk_window_remove_filter: (skip)
2570 * @window: a #GdkWindow
2571 * @function: previously-added filter function
2572 * @data: user data for previously-added filter function
2574 * Remove a filter previously added with gdk_window_add_filter().
2577 gdk_window_remove_filter (GdkWindow *window,
2578 GdkFilterFunc function,
2582 GdkEventFilter *filter;
2584 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2587 tmp_list = window->filters;
2589 tmp_list = _gdk_default_filters;
2593 filter = (GdkEventFilter *)tmp_list->data;
2594 tmp_list = tmp_list->next;
2596 if ((filter->function == function) && (filter->data == data))
2598 filter->flags |= GDK_EVENT_FILTER_REMOVED;
2600 _gdk_event_filter_unref (window, filter);
2608 * gdk_screen_get_toplevel_windows:
2609 * @screen: The #GdkScreen where the toplevels are located.
2611 * Obtains a list of all toplevel windows known to GDK on the screen @screen.
2612 * A toplevel window is a child of the root window (see
2613 * gdk_get_default_root_window()).
2615 * The returned list should be freed with g_list_free(), but
2616 * its elements need not be freed.
2618 * Return value: (transfer container) (element-type GdkWindow):
2619 * list of toplevel windows, free with g_list_free()
2624 gdk_screen_get_toplevel_windows (GdkScreen *screen)
2626 GdkWindow * root_window;
2627 GList *new_list = NULL;
2630 g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
2632 root_window = gdk_screen_get_root_window (screen);
2634 tmp_list = root_window->children;
2637 GdkWindow *w = tmp_list->data;
2639 if (w->window_type != GDK_WINDOW_FOREIGN)
2640 new_list = g_list_prepend (new_list, w);
2641 tmp_list = tmp_list->next;
2648 * gdk_window_is_visible:
2649 * @window: a #GdkWindow
2651 * Checks whether the window has been mapped (with gdk_window_show() or
2652 * gdk_window_show_unraised()).
2654 * Return value: %TRUE if the window is mapped
2657 gdk_window_is_visible (GdkWindow *window)
2659 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2661 return GDK_WINDOW_IS_MAPPED (window);
2665 * gdk_window_is_viewable:
2666 * @window: a #GdkWindow
2668 * Check if the window and all ancestors of the window are
2669 * mapped. (This is not necessarily "viewable" in the X sense, since
2670 * we only check as far as we have GDK window parents, not to the root
2673 * Return value: %TRUE if the window is viewable
2676 gdk_window_is_viewable (GdkWindow *window)
2678 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2680 if (window->destroyed)
2683 return window->viewable;
2687 * gdk_window_get_state:
2688 * @window: a #GdkWindow
2690 * Gets the bitwise OR of the currently active window state flags,
2691 * from the #GdkWindowState enumeration.
2693 * Return value: window state bitfield
2696 gdk_window_get_state (GdkWindow *window)
2698 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2700 return window->state;
2703 static cairo_content_t
2704 gdk_window_get_content (GdkWindow *window)
2706 cairo_surface_t *surface;
2707 cairo_content_t content;
2709 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2711 surface = gdk_window_ref_impl_surface (window);
2712 content = cairo_surface_get_content (surface);
2713 cairo_surface_destroy (surface);
2718 /* This creates an empty "implicit" paint region for the impl window.
2719 * By itself this does nothing, but real paints to this window
2720 * or children of it can use this surface as backing to avoid allocating
2721 * multiple surfaces for subwindow rendering. When doing so they
2722 * add to the region of the implicit paint region, which will be
2723 * pushed to the window when the implicit paint region is ended.
2724 * Such paints should not copy anything to the window on paint end, but
2725 * should rely on the implicit paint end.
2726 * The implicit paint will be automatically ended if someone draws
2727 * directly to the window or a child window.
2730 gdk_window_begin_implicit_paint (GdkWindow *window, GdkRectangle *rect)
2732 GdkWindowPaint *paint;
2734 g_assert (gdk_window_has_impl (window));
2736 if (GDK_IS_PAINTABLE (window->impl))
2737 return FALSE; /* Implementation does double buffering */
2739 if (window->paint_stack != NULL ||
2740 window->implicit_paint != NULL)
2741 return FALSE; /* Don't stack implicit paints */
2743 /* Never do implicit paints for foreign windows, they don't need
2744 * double buffer combination since they have no client side children,
2745 * and creating surfaces for them is risky since they could disappear
2748 if (window->window_type == GDK_WINDOW_FOREIGN)
2751 paint = g_new (GdkWindowPaint, 1);
2752 paint->region = cairo_region_create (); /* Empty */
2753 paint->uses_implicit = FALSE;
2754 paint->flushed = NULL;
2755 paint->surface = gdk_window_create_similar_surface (window,
2756 gdk_window_get_content (window),
2757 MAX (rect->width, 1),
2758 MAX (rect->height, 1));
2759 cairo_surface_set_device_offset (paint->surface, -rect->x, -rect->y);
2761 window->implicit_paint = paint;
2766 static cairo_surface_t *
2767 gdk_window_ref_impl_surface (GdkWindow *window)
2769 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->ref_cairo_surface (gdk_window_get_impl_window (window));
2773 gdk_cairo_create_for_impl (GdkWindow *window)
2775 cairo_surface_t *surface;
2778 surface = gdk_window_ref_impl_surface (window);
2779 cr = cairo_create (surface);
2781 cairo_surface_destroy (surface);
2786 /* This is called whenever something is drawing directly to the
2787 * window, bypassing the double buffering. When this happens we
2788 * need to mark any the currently drawn data in the double buffer
2789 * as invalid to avoid later drawing it back over the directly
2790 * rendered pixels. We also need to mark this region as "flushed"
2791 * so that if we later try to paint on it double-buffered we need
2792 * to read back the on-window pixels rather than relying on what
2793 * is in the current double-buffer pixmap.
2795 * Note that this doesn't correctly handle the case where the
2796 * non-double buffered drawing uses transparency and relies on
2797 * what the windows below it draws. A fix for that would require
2798 * drawing the existing double-buffered background to the window,
2799 * but that causes ugly flashes. Non-double buffered drawing is
2800 * typically only used in old code or when the drawed widget
2801 * already has a double-buffering layer, and in these cases the
2802 * pixels are opaque anyway. If you need transparency, don't
2803 * disable double buffering.
2806 gdk_window_flush_implicit_paint (GdkWindow *window)
2808 GdkWindow *impl_window;
2809 GdkWindowPaint *paint;
2810 cairo_region_t *region;
2812 impl_window = gdk_window_get_impl_window (window);
2813 if (impl_window->implicit_paint == NULL)
2816 paint = impl_window->implicit_paint;
2818 region = cairo_region_copy (window->clip_region_with_children);
2819 cairo_region_translate (region, window->abs_x, window->abs_y);
2821 /* Anything in the whole flushed window that was drawn is now
2822 considered unpainted, so that we don't push it back at the
2823 end of the implicit paint overwriting the directly rendered
2825 cairo_region_subtract (paint->region, region);
2827 /* Save flushed area so we can read it back if we draw over it later */
2828 if (paint->flushed == NULL)
2829 paint->flushed = region;
2832 cairo_region_union (paint->flushed, region);
2833 cairo_region_destroy (region);
2837 /* Ends an implicit paint, paired with gdk_window_begin_implicit_paint returning TRUE */
2839 gdk_window_end_implicit_paint (GdkWindow *window)
2841 GdkWindowPaint *paint;
2843 g_assert (gdk_window_has_impl (window));
2845 g_assert (window->implicit_paint != NULL);
2847 paint = window->implicit_paint;
2849 window->implicit_paint = NULL;
2851 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (paint->region))
2855 /* Some regions are valid, push these to window now */
2856 cr = gdk_cairo_create_for_impl (window);
2857 gdk_cairo_region (cr, paint->region);
2859 cairo_set_source_surface (cr, paint->surface, 0, 0);
2860 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2865 cairo_region_destroy (paint->region);
2867 cairo_region_destroy (paint->flushed);
2868 cairo_surface_destroy (paint->surface);
2873 * gdk_window_begin_paint_rect:
2874 * @window: a #GdkWindow
2875 * @rectangle: rectangle you intend to draw to
2877 * A convenience wrapper around gdk_window_begin_paint_region() which
2878 * creates a rectangular region for you. See
2879 * gdk_window_begin_paint_region() for details.
2883 gdk_window_begin_paint_rect (GdkWindow *window,
2884 const GdkRectangle *rectangle)
2886 cairo_region_t *region;
2888 g_return_if_fail (GDK_IS_WINDOW (window));
2890 region = cairo_region_create_rectangle (rectangle);
2891 gdk_window_begin_paint_region (window, region);
2892 cairo_region_destroy (region);
2896 * gdk_window_begin_paint_region:
2897 * @window: a #GdkWindow
2898 * @region: region you intend to draw to
2900 * Indicates that you are beginning the process of redrawing @region.
2901 * A backing store (offscreen buffer) large enough to contain @region
2902 * will be created. The backing store will be initialized with the
2903 * background color or background surface for @window. Then, all
2904 * drawing operations performed on @window will be diverted to the
2905 * backing store. When you call gdk_window_end_paint(), the backing
2906 * store will be copied to @window, making it visible onscreen. Only
2907 * the part of @window contained in @region will be modified; that is,
2908 * drawing operations are clipped to @region.
2910 * The net result of all this is to remove flicker, because the user
2911 * sees the finished product appear all at once when you call
2912 * gdk_window_end_paint(). If you draw to @window directly without
2913 * calling gdk_window_begin_paint_region(), the user may see flicker
2914 * as individual drawing operations are performed in sequence. The
2915 * clipping and background-initializing features of
2916 * gdk_window_begin_paint_region() are conveniences for the
2917 * programmer, so you can avoid doing that work yourself.
2919 * When using GTK+, the widget system automatically places calls to
2920 * gdk_window_begin_paint_region() and gdk_window_end_paint() around
2921 * emissions of the expose_event signal. That is, if you're writing an
2922 * expose event handler, you can assume that the exposed area in
2923 * #GdkEventExpose has already been cleared to the window background,
2924 * is already set as the clip region, and already has a backing store.
2925 * Therefore in most cases, application code need not call
2926 * gdk_window_begin_paint_region(). (You can disable the automatic
2927 * calls around expose events on a widget-by-widget basis by calling
2928 * gtk_widget_set_double_buffered().)
2930 * If you call this function multiple times before calling the
2931 * matching gdk_window_end_paint(), the backing stores are pushed onto
2932 * a stack. gdk_window_end_paint() copies the topmost backing store
2933 * onscreen, subtracts the topmost region from all other regions in
2934 * the stack, and pops the stack. All drawing operations affect only
2935 * the topmost backing store in the stack. One matching call to
2936 * gdk_window_end_paint() is required for each call to
2937 * gdk_window_begin_paint_region().
2941 gdk_window_begin_paint_region (GdkWindow *window,
2942 const cairo_region_t *region)
2944 #ifdef USE_BACKING_STORE
2945 GdkRectangle clip_box;
2946 GdkWindowPaint *paint, *implicit_paint;
2947 GdkWindow *impl_window;
2950 g_return_if_fail (GDK_IS_WINDOW (window));
2952 if (GDK_WINDOW_DESTROYED (window))
2955 if (GDK_IS_PAINTABLE (window->impl))
2957 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2959 if (iface->begin_paint_region)
2960 iface->begin_paint_region ((GdkPaintable*)window->impl, window, region);
2965 impl_window = gdk_window_get_impl_window (window);
2966 implicit_paint = impl_window->implicit_paint;
2968 paint = g_new (GdkWindowPaint, 1);
2969 paint->region = cairo_region_copy (region);
2971 cairo_region_intersect (paint->region, window->clip_region_with_children);
2972 cairo_region_get_extents (paint->region, &clip_box);
2974 cairo_region_translate (paint->region, window->abs_x, window->abs_y);
2976 /* Mark the region as valid on the implicit paint */
2979 cairo_region_union (implicit_paint->region, paint->region);
2981 /* Convert back to normal coords */
2982 cairo_region_translate (paint->region, -window->abs_x, -window->abs_y);
2986 paint->uses_implicit = TRUE;
2987 paint->surface = cairo_surface_create_for_rectangle (implicit_paint->surface,
2988 window->abs_x + clip_box.x,
2989 window->abs_y + clip_box.y,
2990 MAX (clip_box.width, 1),
2991 MAX (clip_box.height, 1));
2995 paint->uses_implicit = FALSE;
2996 paint->surface = gdk_window_create_similar_surface (window,
2997 gdk_window_get_content (window),
2998 MAX (clip_box.width, 1),
2999 MAX (clip_box.height, 1));
3002 /* Normally alpha backgrounded client side windows are composited on the implicit paint
3003 by being drawn in back to front order. However, if implicit paints are not used, for
3004 instance if it was flushed due to a non-double-buffered paint in the middle of the
3005 expose we need to copy in the existing data here. */
3006 if (!gdk_window_has_impl (window) &&
3007 window->has_alpha_background &&
3009 (implicit_paint && implicit_paint->flushed != NULL && !cairo_region_is_empty (implicit_paint->flushed))))
3011 cairo_t *cr = cairo_create (paint->surface);
3012 /* We can't use gdk_cairo_set_source_window here, as that might
3013 flush the implicit paint at an unfortunate time, since this
3014 would be detected as a draw during non-expose time */
3015 cairo_surface_t *source_surface = gdk_window_ref_impl_surface (impl_window);
3016 cairo_set_source_surface (cr, source_surface,
3017 - (window->abs_x + clip_box.x),
3018 - (window->abs_y + clip_box.y));
3019 cairo_surface_destroy (source_surface);
3021 /* Only read back the flushed area if any */
3024 cairo_region_t *flushed = cairo_region_copy (implicit_paint->flushed);
3025 /* Convert from impl coords */
3026 cairo_region_translate (flushed, -window->abs_x, -window->abs_y);
3027 cairo_region_intersect (flushed, paint->region);
3028 gdk_cairo_region (cr, flushed);
3031 /* Convert to impl coords */
3032 cairo_region_translate (flushed, window->abs_x, window->abs_y);
3033 cairo_region_subtract (implicit_paint->flushed, flushed);
3034 cairo_region_destroy (flushed);
3040 cairo_surface_set_device_offset (paint->surface, -clip_box.x, -clip_box.y);
3042 for (list = window->paint_stack; list != NULL; list = list->next)
3044 GdkWindowPaint *tmp_paint = list->data;
3046 cairo_region_subtract (tmp_paint->region, paint->region);
3049 window->paint_stack = g_slist_prepend (window->paint_stack, paint);
3051 if (!cairo_region_is_empty (paint->region))
3053 gdk_window_clear_backing_region (window,
3057 #endif /* USE_BACKING_STORE */
3061 * gdk_window_end_paint:
3062 * @window: a #GdkWindow
3064 * Indicates that the backing store created by the most recent call to
3065 * gdk_window_begin_paint_region() should be copied onscreen and
3066 * deleted, leaving the next-most-recent backing store or no backing
3067 * store at all as the active paint region. See
3068 * gdk_window_begin_paint_region() for full details. It is an error to
3069 * call this function without a matching
3070 * gdk_window_begin_paint_region() first.
3074 gdk_window_end_paint (GdkWindow *window)
3076 #ifdef USE_BACKING_STORE
3077 GdkWindow *composited;
3078 GdkWindowPaint *paint;
3079 GdkRectangle clip_box;
3080 cairo_region_t *full_clip;
3082 g_return_if_fail (GDK_IS_WINDOW (window));
3084 if (GDK_WINDOW_DESTROYED (window))
3087 if (GDK_IS_PAINTABLE (window->impl))
3089 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
3091 if (iface->end_paint)
3092 iface->end_paint ((GdkPaintable*)window->impl);
3096 if (window->paint_stack == NULL)
3098 g_warning (G_STRLOC": no preceding call to gdk_window_begin_paint_region(), see documentation");
3102 paint = window->paint_stack->data;
3104 window->paint_stack = g_slist_delete_link (window->paint_stack,
3105 window->paint_stack);
3107 cairo_region_get_extents (paint->region, &clip_box);
3109 if (!paint->uses_implicit)
3113 gdk_window_flush_outstanding_moves (window);
3115 full_clip = cairo_region_copy (window->clip_region_with_children);
3116 cairo_region_intersect (full_clip, paint->region);
3118 cr = gdk_cairo_create (window);
3119 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
3120 cairo_set_source_surface (cr, paint->surface, 0, 0);
3121 gdk_cairo_region (cr, full_clip);
3125 cairo_region_destroy (full_clip);
3128 cairo_surface_destroy (paint->surface);
3129 cairo_region_destroy (paint->region);
3132 /* find a composited window in our hierarchy to signal its
3133 * parent to redraw, calculating the clip box as we go...
3135 * stop if parent becomes NULL since then we'd have nowhere
3136 * to draw (ie: 'composited' will always be non-NULL here).
3138 for (composited = window;
3140 composited = composited->parent)
3142 clip_box.x += composited->x;
3143 clip_box.y += composited->y;
3144 clip_box.width = MIN (clip_box.width, composited->parent->width - clip_box.x);
3145 clip_box.height = MIN (clip_box.height, composited->parent->height - clip_box.y);
3147 if (composited->composited)
3149 gdk_window_invalidate_rect (GDK_WINDOW (composited->parent),
3154 #endif /* USE_BACKING_STORE */
3158 gdk_window_free_paint_stack (GdkWindow *window)
3160 if (window->paint_stack)
3162 GSList *tmp_list = window->paint_stack;
3166 GdkWindowPaint *paint = tmp_list->data;
3168 if (tmp_list == window->paint_stack)
3169 cairo_surface_destroy (paint->surface);
3171 cairo_region_destroy (paint->region);
3174 tmp_list = tmp_list->next;
3177 g_slist_free (window->paint_stack);
3178 window->paint_stack = NULL;
3183 do_move_region_bits_on_impl (GdkWindow *impl_window,
3184 cairo_region_t *dest_region, /* In impl window coords */
3187 GdkWindowImplClass *impl_class;
3189 impl_class = GDK_WINDOW_IMPL_GET_CLASS (impl_window->impl);
3191 impl_class->translate (impl_window, dest_region, dx, dy);
3194 static GdkWindowRegionMove *
3195 gdk_window_region_move_new (cairo_region_t *region,
3198 GdkWindowRegionMove *move;
3200 move = g_slice_new (GdkWindowRegionMove);
3201 move->dest_region = cairo_region_copy (region);
3209 gdk_window_region_move_free (GdkWindowRegionMove *move)
3211 cairo_region_destroy (move->dest_region);
3212 g_slice_free (GdkWindowRegionMove, move);
3216 append_move_region (GdkWindow *impl_window,
3217 cairo_region_t *new_dest_region,
3220 GdkWindowRegionMove *move, *old_move;
3221 cairo_region_t *new_total_region, *old_total_region;
3222 cairo_region_t *source_overlaps_destination;
3223 cairo_region_t *non_overwritten;
3224 gboolean added_move;
3227 if (cairo_region_is_empty (new_dest_region))
3230 /* In principle this could just append the move to the list of outstanding
3231 moves that will be replayed before drawing anything when we're handling
3232 exposes. However, we'd like to do a bit better since its commonly the case
3233 that we get multiple copies where A is copied to B and then B is copied
3234 to C, and we'd like to express this as a simple copy A to C operation. */
3236 /* We approach this by taking the new move and pushing it ahead of moves
3237 starting at the end of the list and stopping when its not safe to do so.
3238 It's not safe to push past a move if either the source of the new move
3239 is in the destination of the old move, or if the destination of the new
3240 move is in the source of the new move, or if the destination of the new
3241 move overlaps the destination of the old move. We simplify this by
3242 just comparing the total regions (src + dest) */
3243 new_total_region = cairo_region_copy (new_dest_region);
3244 cairo_region_translate (new_total_region, -dx, -dy);
3245 cairo_region_union (new_total_region, new_dest_region);
3248 for (l = g_list_last (impl_window->outstanding_moves); l != NULL; l = prev)
3253 old_total_region = cairo_region_copy (old_move->dest_region);
3254 cairo_region_translate (old_total_region, -old_move->dx, -old_move->dy);
3255 cairo_region_union (old_total_region, old_move->dest_region);
3257 cairo_region_intersect (old_total_region, new_total_region);
3258 /* If these regions intersect then its not safe to push the
3259 new region before the old one */
3260 if (!cairo_region_is_empty (old_total_region))
3262 /* The area where the new moves source overlaps the old ones
3264 source_overlaps_destination = cairo_region_copy (new_dest_region);
3265 cairo_region_translate (source_overlaps_destination, -dx, -dy);
3266 cairo_region_intersect (source_overlaps_destination, old_move->dest_region);
3267 cairo_region_translate (source_overlaps_destination, dx, dy);
3269 /* We can do all sort of optimizations here, but to do things safely it becomes
3270 quite complicated. However, a very common case is that you copy something first,
3271 then copy all that or a subset of it to a new location (i.e. if you scroll twice
3272 in the same direction). We'd like to detect this case and optimize it to one
3274 if (cairo_region_equal (source_overlaps_destination, new_dest_region))
3276 /* This means we might be able to replace the old move and the new one
3277 with the new one read from the old ones source, and a second copy of
3278 the non-overwritten parts of the old move. However, such a split
3279 is only valid if the source in the old move isn't overwritten
3280 by the destination of the new one */
3282 /* the new destination of old move if split is ok: */
3283 non_overwritten = cairo_region_copy (old_move->dest_region);
3284 cairo_region_subtract (non_overwritten, new_dest_region);
3285 /* move to source region */
3286 cairo_region_translate (non_overwritten, -old_move->dx, -old_move->dy);
3288 cairo_region_intersect (non_overwritten, new_dest_region);
3289 if (cairo_region_is_empty (non_overwritten))
3292 move = gdk_window_region_move_new (new_dest_region,
3296 impl_window->outstanding_moves =
3297 g_list_insert_before (impl_window->outstanding_moves,
3299 cairo_region_subtract (old_move->dest_region, new_dest_region);
3301 cairo_region_destroy (non_overwritten);
3304 cairo_region_destroy (source_overlaps_destination);
3305 cairo_region_destroy (old_total_region);
3308 cairo_region_destroy (old_total_region);
3311 cairo_region_destroy (new_total_region);
3315 move = gdk_window_region_move_new (new_dest_region, dx, dy);
3318 impl_window->outstanding_moves =
3319 g_list_prepend (impl_window->outstanding_moves,
3322 impl_window->outstanding_moves =
3323 g_list_insert_before (impl_window->outstanding_moves,
3328 /* Moves bits and update area by dx/dy in impl window.
3329 Takes ownership of region to avoid copy (because we may change it) */
3331 move_region_on_impl (GdkWindow *impl_window,
3332 cairo_region_t *region, /* In impl window coords */
3335 if ((dx == 0 && dy == 0) ||
3336 cairo_region_is_empty (region))
3338 cairo_region_destroy (region);
3342 g_assert (impl_window == gdk_window_get_impl_window (impl_window));
3344 /* Move any old invalid regions in the copy source area by dx/dy */
3345 if (impl_window->update_area)
3347 cairo_region_t *update_area;
3349 update_area = cairo_region_copy (region);
3351 /* Convert from target to source */
3352 cairo_region_translate (update_area, -dx, -dy);
3353 cairo_region_intersect (update_area, impl_window->update_area);
3354 /* We only copy the area, so keep the old update area invalid.
3355 It would be safe to remove it too, as code that uses
3356 move_region_on_impl generally also invalidate the source
3357 area. However, it would just use waste cycles. */
3360 cairo_region_translate (update_area, dx, dy);
3361 cairo_region_union (impl_window->update_area, update_area);
3363 /* This area of the destination is now invalid,
3364 so no need to copy to it. */
3365 cairo_region_subtract (region, update_area);
3367 cairo_region_destroy (update_area);
3370 /* If we're currently exposing this window, don't copy to this
3371 destination, as it will be overdrawn when the expose is done,
3372 instead invalidate it and repaint later. */
3373 if (impl_window->implicit_paint)
3375 GdkWindowPaint *implicit_paint = impl_window->implicit_paint;
3376 cairo_region_t *exposing;
3378 exposing = cairo_region_copy (implicit_paint->region);
3379 cairo_region_intersect (exposing, region);
3380 cairo_region_subtract (region, exposing);
3382 impl_window_add_update_area (impl_window, exposing);
3383 cairo_region_destroy (exposing);
3386 append_move_region (impl_window, region, dx, dy);
3388 cairo_region_destroy (region);
3391 /* Flushes all outstanding changes to the window, call this
3392 * before drawing directly to the window (i.e. outside a begin/end_paint pair).
3395 gdk_window_flush_outstanding_moves (GdkWindow *window)
3397 GdkWindow *impl_window;
3398 GList *l, *outstanding;
3399 GdkWindowRegionMove *move;
3401 impl_window = gdk_window_get_impl_window (window);
3402 outstanding = impl_window->outstanding_moves;
3403 impl_window->outstanding_moves = NULL;
3405 for (l = outstanding; l != NULL; l = l->next)
3409 do_move_region_bits_on_impl (impl_window,
3410 move->dest_region, move->dx, move->dy);
3412 gdk_window_region_move_free (move);
3415 g_list_free (outstanding);
3420 * @window: a #GdkWindow
3422 * Flush all outstanding cached operations on a window, leaving the
3423 * window in a state which reflects all that has been drawn before.
3425 * Gdk uses multiple kinds of caching to get better performance and
3426 * nicer drawing. For instance, during exposes all paints to a window
3427 * using double buffered rendering are keep on a surface until the last
3428 * window has been exposed. It also delays window moves/scrolls until
3429 * as long as possible until next update to avoid tearing when moving
3432 * Normally this should be completely invisible to applications, as
3433 * we automatically flush the windows when required, but this might
3434 * be needed if you for instance mix direct native drawing with
3435 * gdk drawing. For Gtk widgets that don't use double buffering this
3436 * will be called automatically before sending the expose event.
3441 gdk_window_flush (GdkWindow *window)
3443 gdk_window_flush_outstanding_moves (window);
3444 gdk_window_flush_implicit_paint (window);
3447 /* If we're about to move/resize or otherwise change the
3448 * hierarchy of a client side window in an impl and we're
3449 * called from an expose event handler then we need to
3450 * flush any already painted parts of the implicit paint
3451 * that are not part of the current paint, as these may
3452 * be used when scrolling or may overdraw the changes
3453 * caused by the hierarchy change.
3456 gdk_window_flush_if_exposing (GdkWindow *window)
3458 GdkWindow *impl_window;
3460 impl_window = gdk_window_get_impl_window (window);
3462 /* If we're in an implicit paint (i.e. in an expose handler, flush
3463 all the already finished exposes to get things to an uptodate state. */
3464 if (impl_window->implicit_paint)
3465 gdk_window_flush (window);
3470 gdk_window_flush_recursive_helper (GdkWindow *window,
3471 GdkWindowImpl *impl)
3476 for (l = window->children; l != NULL; l = l->next)
3480 if (child->impl == impl)
3481 /* Same impl, ignore */
3482 gdk_window_flush_recursive_helper (child, impl);
3484 gdk_window_flush_recursive (child);
3489 gdk_window_flush_recursive (GdkWindow *window)
3491 gdk_window_flush (window);
3492 gdk_window_flush_recursive_helper (window, window->impl);
3496 * gdk_window_get_clip_region:
3497 * @window: a #GdkWindow
3499 * Computes the region of a window that potentially can be written
3500 * to by drawing primitives. This region may not take into account
3501 * other factors such as if the window is obscured by other windows,
3502 * but no area outside of this region will be affected by drawing
3505 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3506 * when you are done.
3509 gdk_window_get_clip_region (GdkWindow *window)
3511 cairo_region_t *result;
3513 g_return_val_if_fail (GDK_WINDOW (window), NULL);
3515 result = cairo_region_copy (window->clip_region);
3517 if (window->paint_stack)
3519 cairo_region_t *paint_region = cairo_region_create ();
3520 GSList *tmp_list = window->paint_stack;
3524 GdkWindowPaint *paint = tmp_list->data;
3526 cairo_region_union (paint_region, paint->region);
3528 tmp_list = tmp_list->next;
3531 cairo_region_intersect (result, paint_region);
3532 cairo_region_destroy (paint_region);
3539 * gdk_window_get_visible_region:
3540 * @window: a #GdkWindow
3542 * Computes the region of the @window that is potentially visible.
3543 * This does not necessarily take into account if the window is
3544 * obscured by other windows, but no area outside of this region
3547 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3548 * when you are done.
3551 gdk_window_get_visible_region (GdkWindow *window)
3553 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3555 return cairo_region_copy (window->clip_region);
3559 setup_backing_rect (GdkWindow *window, GdkWindowPaint *paint)
3561 GdkWindow *bg_window;
3562 cairo_pattern_t *pattern = NULL;
3563 int x_offset = 0, y_offset = 0;
3566 cr = cairo_create (paint->surface);
3568 for (bg_window = window; bg_window; bg_window = bg_window->parent)
3570 pattern = gdk_window_get_background_pattern (bg_window);
3574 x_offset += bg_window->x;
3575 y_offset += bg_window->y;
3580 cairo_translate (cr, -x_offset, -y_offset);
3581 cairo_set_source (cr, pattern);
3582 cairo_translate (cr, x_offset, y_offset);
3585 cairo_set_source_rgb (cr, 0, 0, 0);
3591 gdk_window_clear_backing_region (GdkWindow *window,
3592 cairo_region_t *region)
3594 GdkWindowPaint *paint = window->paint_stack->data;
3595 cairo_region_t *clip;
3598 if (GDK_WINDOW_DESTROYED (window))
3601 cr = setup_backing_rect (window, paint);
3603 clip = cairo_region_copy (paint->region);
3604 cairo_region_intersect (clip, region);
3606 gdk_cairo_region (cr, clip);
3611 cairo_region_destroy (clip);
3615 gdk_window_drop_cairo_surface (GdkWindow *window)
3617 if (window->cairo_surface)
3619 cairo_surface_finish (window->cairo_surface);
3620 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3622 window->cairo_surface = NULL;
3627 gdk_window_cairo_surface_destroy (void *data)
3629 GdkWindow *window = data;
3631 window->cairo_surface = NULL;
3634 static cairo_surface_t *
3635 gdk_window_create_cairo_surface (GdkWindow *window,
3639 cairo_surface_t *surface, *subsurface;
3641 surface = gdk_window_ref_impl_surface (window);
3642 if (gdk_window_has_impl (window))
3645 subsurface = cairo_surface_create_for_rectangle (surface,
3650 cairo_surface_destroy (surface);
3656 _gdk_window_ref_cairo_surface (GdkWindow *window)
3658 cairo_surface_t *surface;
3660 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3662 if (window->paint_stack)
3664 GdkWindowPaint *paint = window->paint_stack->data;
3666 surface = paint->surface;
3667 cairo_surface_reference (surface);
3672 /* This will be drawing directly to the window, so flush implicit paint */
3673 gdk_window_flush (window);
3675 if (!window->cairo_surface)
3677 window->cairo_surface = gdk_window_create_cairo_surface (window,
3681 if (window->cairo_surface)
3683 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3684 window, gdk_window_cairo_surface_destroy);
3688 cairo_surface_reference (window->cairo_surface);
3690 surface = window->cairo_surface;
3698 * @window: a #GdkWindow
3700 * Creates a Cairo context for drawing to @window.
3703 * Note that calling cairo_reset_clip() on the resulting #cairo_t will
3704 * produce undefined results, so avoid it at all costs.
3707 * Return value: A newly created Cairo context. Free with
3708 * cairo_destroy() when you are done drawing.
3713 gdk_cairo_create (GdkWindow *window)
3715 cairo_surface_t *surface;
3718 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3720 surface = _gdk_window_ref_cairo_surface (window);
3721 cr = cairo_create (surface);
3723 if (!window->paint_stack)
3725 gdk_cairo_region (cr, window->clip_region_with_children);
3730 GdkWindowPaint *paint = window->paint_stack->data;
3732 /* Only needs to clip to region if piggybacking
3733 on an implicit paint */
3734 if (paint->uses_implicit)
3736 gdk_cairo_region (cr, paint->region);
3741 cairo_surface_destroy (surface);
3746 /* Code for dirty-region queueing
3748 static GSList *update_windows = NULL;
3749 static guint update_idle = 0;
3750 static gboolean debug_updates = FALSE;
3752 static inline gboolean
3753 gdk_window_is_ancestor (GdkWindow *window,
3754 GdkWindow *ancestor)
3758 GdkWindow *parent = window->parent;
3760 if (parent == ancestor)
3770 gdk_window_add_update_window (GdkWindow *window)
3773 GSList *prev = NULL;
3774 gboolean has_ancestor_in_list = FALSE;
3776 for (tmp = update_windows; tmp; tmp = tmp->next)
3778 GdkWindow *parent = window->parent;
3780 /* check if tmp is an ancestor of "window"; if it is, set a
3781 * flag indicating that all following windows are either
3782 * children of "window" or from a differen hierarchy
3784 if (!has_ancestor_in_list && gdk_window_is_ancestor (window, tmp->data))
3785 has_ancestor_in_list = TRUE;
3787 /* insert in reverse stacking order when adding around siblings,
3788 * so processing updates properly paints over lower stacked windows
3790 if (parent == GDK_WINDOW (tmp->data)->parent)
3792 gint index = g_list_index (parent->children, window);
3793 for (; tmp && parent == GDK_WINDOW (tmp->data)->parent; tmp = tmp->next)
3795 gint sibling_index = g_list_index (parent->children, tmp->data);
3796 if (index > sibling_index)
3800 /* here, tmp got advanced past all lower stacked siblings */
3801 tmp = g_slist_prepend (tmp, window);
3805 update_windows = tmp;
3809 /* if "window" has an ancestor in the list and tmp is one of
3810 * "window's" children, insert "window" before tmp
3812 if (has_ancestor_in_list && gdk_window_is_ancestor (tmp->data, window))
3814 tmp = g_slist_prepend (tmp, window);
3819 update_windows = tmp;
3823 /* if we're at the end of the list and had an ancestor it it,
3824 * append to the list
3826 if (! tmp->next && has_ancestor_in_list)
3828 tmp = g_slist_append (tmp, window);
3835 /* if all above checks failed ("window" is from a different
3836 * hierarchy than what is already in the list) or the list is
3839 update_windows = g_slist_prepend (update_windows, window);
3843 gdk_window_remove_update_window (GdkWindow *window)
3845 update_windows = g_slist_remove (update_windows, window);
3849 gdk_window_update_idle (gpointer data)
3851 gdk_window_process_all_updates ();
3857 gdk_window_is_toplevel_frozen (GdkWindow *window)
3859 GdkWindow *toplevel;
3861 toplevel = gdk_window_get_toplevel (window);
3863 return toplevel->update_and_descendants_freeze_count > 0;
3867 gdk_window_schedule_update (GdkWindow *window)
3870 (window->update_freeze_count ||
3871 gdk_window_is_toplevel_frozen (window)))
3876 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
3877 gdk_window_update_idle,
3882 _gdk_window_process_updates_recurse (GdkWindow *window,
3883 cairo_region_t *expose_region)
3886 cairo_region_t *clipped_expose_region;
3887 GList *l, *children;
3889 if (cairo_region_is_empty (expose_region))
3892 if (gdk_window_is_offscreen (window->impl_window) &&
3893 gdk_window_has_impl (window))
3894 _gdk_window_add_damage ((GdkWindow *) window->impl_window, expose_region);
3897 /* Paint the window before the children, clipped to the window region
3898 with visible child windows removed */
3899 clipped_expose_region = cairo_region_copy (expose_region);
3900 cairo_region_intersect (clipped_expose_region, window->clip_region_with_children);
3902 if (!cairo_region_is_empty (clipped_expose_region) &&
3905 if (window->event_mask & GDK_EXPOSURE_MASK)
3909 event.expose.type = GDK_EXPOSE;
3910 event.expose.window = g_object_ref (window);
3911 event.expose.send_event = FALSE;
3912 event.expose.count = 0;
3913 event.expose.region = clipped_expose_region;
3914 cairo_region_get_extents (clipped_expose_region, &event.expose.area);
3916 _gdk_event_emit (&event);
3918 g_object_unref (window);
3920 else if (window->window_type != GDK_WINDOW_FOREIGN)
3922 /* No exposure mask set, so nothing will be drawn, the
3923 * app relies on the background being what it specified
3924 * for the window. So, we need to clear this manually.
3926 * For foreign windows if expose is not set that generally
3927 * means some other client paints them, so don't clear
3930 * We use begin/end_paint around the clear so that we can
3931 * piggyback on the implicit paint */
3933 gdk_window_begin_paint_region (window, clipped_expose_region);
3934 /* The actual clear happens in begin_paint_region */
3935 gdk_window_end_paint (window);
3938 cairo_region_destroy (clipped_expose_region);
3940 /* Make this reentrancy safe for expose handlers freeing windows */
3941 children = g_list_copy (window->children);
3942 g_list_foreach (children, (GFunc)g_object_ref, NULL);
3944 /* Iterate over children, starting at bottommost */
3945 for (l = g_list_last (children); l != NULL; l = l->prev)
3949 if (child->destroyed || !GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
3952 /* Ignore offscreen children, as they don't draw in their parent and
3953 * don't take part in the clipping */
3954 if (gdk_window_is_offscreen (child))
3957 /* Client side child, expose */
3958 if (child->impl == window->impl)
3960 cairo_region_translate (expose_region, -child->x, -child->y);
3961 _gdk_window_process_updates_recurse ((GdkWindow *)child, expose_region);
3962 cairo_region_translate (expose_region, child->x, child->y);
3966 g_list_free_full (children, g_object_unref);
3970 /* Process and remove any invalid area on the native window by creating
3971 * expose events for the window and all non-native descendants.
3972 * Also processes any outstanding moves on the window before doing
3973 * any drawing. Note that its possible to have outstanding moves without
3974 * any invalid area as we use the update idle mechanism to coalesce
3975 * multiple moves as well as multiple invalidations.
3978 gdk_window_process_updates_internal (GdkWindow *window)
3980 GdkWindowImplClass *impl_class;
3981 gboolean save_region = FALSE;
3982 GdkRectangle clip_box;
3984 /* Ensure the window lives while updating it */
3985 g_object_ref (window);
3987 /* If an update got queued during update processing, we can get a
3988 * window in the update queue that has an empty update_area.
3991 if (window->update_area)
3993 cairo_region_t *update_area = window->update_area;
3994 window->update_area = NULL;
3996 if (gdk_window_is_viewable (window))
3998 cairo_region_t *expose_region;
3999 gboolean end_implicit;
4001 /* Clip to part visible in toplevel */
4002 cairo_region_intersect (update_area, window->clip_region);
4006 /* Make sure we see the red invalid area before redrawing. */
4007 gdk_display_sync (gdk_window_get_display (window));
4011 /* At this point we will be completely redrawing all of update_area.
4012 * If we have any outstanding moves that end up moving stuff inside
4013 * this area we don't actually need to move that as that part would
4014 * be overdrawn by the expose anyway. So, in order to copy less data
4015 * we remove these areas from the outstanding moves.
4017 if (window->outstanding_moves)
4019 GdkWindowRegionMove *move;
4020 cairo_region_t *remove;
4023 remove = cairo_region_copy (update_area);
4024 /* We iterate backwards, starting from the state that would be
4025 if we had applied all the moves. */
4026 for (l = g_list_last (window->outstanding_moves); l != NULL; l = prev)
4031 /* Don't need this area */
4032 cairo_region_subtract (move->dest_region, remove);
4034 /* However if any of the destination we do need has a source
4035 in the updated region we do need that as a destination for
4036 the earlier moves */
4037 cairo_region_translate (move->dest_region, -move->dx, -move->dy);
4038 cairo_region_subtract (remove, move->dest_region);
4040 if (cairo_region_is_empty (move->dest_region))
4042 gdk_window_region_move_free (move);
4043 window->outstanding_moves =
4044 g_list_delete_link (window->outstanding_moves, l);
4046 else /* move back */
4047 cairo_region_translate (move->dest_region, move->dx, move->dy);
4049 cairo_region_destroy (remove);
4052 /* By now we a set of window moves that should be applied, and then
4053 * an update region that should be repainted. A trivial implementation
4054 * would just do that in order, however in order to get nicer drawing
4055 * we do some tricks:
4057 * First of all, each subwindow expose may be double buffered by
4058 * itself (depending on widget setting) via
4059 * gdk_window_begin/end_paint(). But we also do an "implicit" paint,
4060 * creating a single surface the size of the invalid area on the
4061 * native window which all the individual normal paints will draw
4062 * into. This way in the normal case there will be only one surface
4063 * allocated and only once surface draw done for all the windows
4064 * in this native window.
4065 * There are a couple of reasons this may fail, for instance, some
4066 * backends (like quartz) do its own double buffering, so we disable
4067 * gdk double buffering there. Secondly, some subwindow could be
4068 * non-double buffered and draw directly to the window outside a
4069 * begin/end_paint pair. That will be lead to a gdk_window_flush
4070 * which immediately executes all outstanding moves and paints+removes
4071 * the implicit paint (further paints will allocate their own surfaces).
4073 * Secondly, in the case of implicit double buffering we expose all
4074 * the child windows into the implicit surface before we execute
4075 * the outstanding moves. This way we minimize the time between
4076 * doing the moves and rendering the new update area, thus minimizing
4077 * flashing. Of course, if any subwindow is non-double buffered we
4078 * well flush earlier than that.
4080 * Thirdly, after having done the outstanding moves we queue an
4081 * "antiexpose" on the area that will be drawn by the expose, which
4082 * means that any invalid region on the native window side before
4083 * the first expose drawing operation will be discarded, as it
4084 * has by then been overdrawn with valid data. This means we can
4085 * avoid doing the unnecessary repaint any outstanding expose events.
4088 cairo_region_get_extents (update_area, &clip_box);
4089 end_implicit = gdk_window_begin_implicit_paint (window, &clip_box);
4090 expose_region = cairo_region_copy (update_area);
4091 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
4094 /* Rendering is not double buffered by gdk, do outstanding
4095 * moves and queue antiexposure immediately. No need to do
4097 gdk_window_flush_outstanding_moves (window);
4098 save_region = impl_class->queue_antiexpose (window, update_area);
4100 /* Render the invalid areas to the implicit paint, by sending exposes.
4101 * May flush if non-double buffered widget draw. */
4102 impl_class->process_updates_recurse (window, expose_region);
4106 /* Do moves right before exposes are rendered to the window */
4107 gdk_window_flush_outstanding_moves (window);
4109 /* By this time we know that any outstanding expose for this
4110 * area is invalid and we can avoid it, so queue an antiexpose.
4111 * we have already started drawing to the window, so it would
4112 * be to late to anti-expose now. Since this is merely an
4113 * optimization we just avoid doing it at all in that case.
4115 if (window->implicit_paint != NULL && !window->implicit_paint->flushed)
4116 save_region = impl_class->queue_antiexpose (window, update_area);
4118 gdk_window_end_implicit_paint (window);
4120 cairo_region_destroy (expose_region);
4123 cairo_region_destroy (update_area);
4126 if (window->outstanding_moves)
4128 /* Flush any outstanding moves, may happen if we moved a window but got
4129 no actual invalid area */
4130 gdk_window_flush_outstanding_moves (window);
4133 g_object_unref (window);
4137 flush_all_displays (void)
4139 GSList *displays, *l;
4141 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4142 for (l = displays; l; l = l->next)
4143 gdk_display_flush (l->data);
4145 g_slist_free (displays);
4149 before_process_all_updates (void)
4151 GSList *displays, *l;
4152 GdkDisplayClass *display_class;
4154 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4155 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4156 for (l = displays; l; l = l->next)
4157 display_class->before_process_all_updates (l->data);
4159 g_slist_free (displays);
4163 after_process_all_updates (void)
4165 GSList *displays, *l;
4166 GdkDisplayClass *display_class;
4168 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4169 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4170 for (l = displays; l; l = l->next)
4171 display_class->after_process_all_updates (l->data);
4173 g_slist_free (displays);
4176 /* Currently it is not possible to override
4177 * gdk_window_process_all_updates in the same manner as
4178 * gdk_window_process_updates and gdk_window_invalidate_maybe_recurse
4179 * by implementing the GdkPaintable interface. If in the future a
4180 * backend would need this, the right solution would be to add a
4181 * method to GdkDisplay that can be optionally
4182 * NULL. gdk_window_process_all_updates can then walk the list of open
4183 * displays and call the mehod.
4187 * gdk_window_process_all_updates:
4189 * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
4190 * in the application.
4194 gdk_window_process_all_updates (void)
4196 GSList *old_update_windows = update_windows;
4197 GSList *tmp_list = update_windows;
4198 static gboolean in_process_all_updates = FALSE;
4199 static gboolean got_recursive_update = FALSE;
4201 if (in_process_all_updates)
4203 /* We can't do this now since that would recurse, so
4204 delay it until after the recursion is done. */
4205 got_recursive_update = TRUE;
4210 in_process_all_updates = TRUE;
4211 got_recursive_update = FALSE;
4214 g_source_remove (update_idle);
4216 update_windows = NULL;
4219 before_process_all_updates ();
4221 g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
4225 GdkWindow *window = tmp_list->data;
4227 if (!GDK_WINDOW_DESTROYED (window))
4229 if (window->update_freeze_count ||
4230 gdk_window_is_toplevel_frozen (window))
4231 gdk_window_add_update_window (window);
4233 gdk_window_process_updates_internal (window);
4236 g_object_unref (window);
4237 tmp_list = tmp_list->next;
4240 g_slist_free (old_update_windows);
4242 flush_all_displays ();
4244 after_process_all_updates ();
4246 in_process_all_updates = FALSE;
4248 /* If we ignored a recursive call, schedule a
4249 redraw now so that it eventually happens,
4250 otherwise we could miss an update if nothing
4251 else schedules an update. */
4252 if (got_recursive_update && !update_idle)
4254 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
4255 gdk_window_update_idle,
4260 * gdk_window_process_updates:
4261 * @window: a #GdkWindow
4262 * @update_children: whether to also process updates for child windows
4264 * Sends one or more expose events to @window. The areas in each
4265 * expose event will cover the entire update area for the window (see
4266 * gdk_window_invalidate_region() for details). Normally GDK calls
4267 * gdk_window_process_all_updates() on your behalf, so there's no
4268 * need to call this function unless you want to force expose events
4269 * to be delivered immediately and synchronously (vs. the usual
4270 * case, where GDK delivers them in an idle handler). Occasionally
4271 * this is useful to produce nicer scrolling behavior, for example.
4275 gdk_window_process_updates (GdkWindow *window,
4276 gboolean update_children)
4278 GdkWindow *impl_window;
4280 g_return_if_fail (GDK_IS_WINDOW (window));
4282 if (GDK_WINDOW_DESTROYED (window))
4285 /* Make sure the window lives during the expose callouts */
4286 g_object_ref (window);
4288 impl_window = gdk_window_get_impl_window (window);
4289 if ((impl_window->update_area ||
4290 impl_window->outstanding_moves) &&
4291 !impl_window->update_freeze_count &&
4292 !gdk_window_is_toplevel_frozen (window) &&
4294 /* Don't recurse into process_updates_internal, we'll
4295 * do the update later when idle instead. */
4296 impl_window->implicit_paint == NULL)
4298 gdk_window_process_updates_internal ((GdkWindow *)impl_window);
4299 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4302 if (update_children)
4304 /* process updates in reverse stacking order so composition or
4305 * painting over achieves the desired effect for offscreen windows
4307 GList *node, *children;
4309 children = g_list_copy (window->children);
4310 g_list_foreach (children, (GFunc)g_object_ref, NULL);
4312 for (node = g_list_last (children); node; node = node->prev)
4314 gdk_window_process_updates (node->data, TRUE);
4315 g_object_unref (node->data);
4318 g_list_free (children);
4321 g_object_unref (window);
4325 gdk_window_invalidate_rect_full (GdkWindow *window,
4326 const GdkRectangle *rect,
4327 gboolean invalidate_children,
4330 GdkRectangle window_rect;
4331 cairo_region_t *region;
4333 g_return_if_fail (GDK_IS_WINDOW (window));
4335 if (GDK_WINDOW_DESTROYED (window))
4338 if (window->input_only || !window->viewable)
4345 window_rect.width = window->width;
4346 window_rect.height = window->height;
4347 rect = &window_rect;
4350 region = cairo_region_create_rectangle (rect);
4351 gdk_window_invalidate_region_full (window, region, invalidate_children, clear_bg);
4352 cairo_region_destroy (region);
4356 * gdk_window_invalidate_rect:
4357 * @window: a #GdkWindow
4358 * @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
4360 * @invalidate_children: whether to also invalidate child windows
4362 * A convenience wrapper around gdk_window_invalidate_region() which
4363 * invalidates a rectangular region. See
4364 * gdk_window_invalidate_region() for details.
4367 gdk_window_invalidate_rect (GdkWindow *window,
4368 const GdkRectangle *rect,
4369 gboolean invalidate_children)
4371 gdk_window_invalidate_rect_full (window, rect, invalidate_children, CLEAR_BG_NONE);
4375 draw_ugly_color (GdkWindow *window,
4376 const cairo_region_t *region)
4380 cr = gdk_cairo_create (window);
4381 /* Draw ugly color all over the newly-invalid region */
4382 cairo_set_source_rgb (cr, 50000/65535., 10000/65535., 10000/65535.);
4383 gdk_cairo_region (cr, region);
4390 impl_window_add_update_area (GdkWindow *impl_window,
4391 cairo_region_t *region)
4393 if (impl_window->update_area)
4394 cairo_region_union (impl_window->update_area, region);
4397 gdk_window_add_update_window (impl_window);
4398 impl_window->update_area = cairo_region_copy (region);
4399 gdk_window_schedule_update (impl_window);
4403 /* clear_bg controls if the region will be cleared to
4404 * the background pattern if the exposure mask is not
4405 * set for the window, whereas this might not otherwise be
4406 * done (unless necessary to emulate background settings).
4407 * Set this to CLEAR_BG_WINCLEARED or CLEAR_BG_ALL if you
4408 * need to clear the background, such as when exposing the area beneath a
4409 * hidden or moved window, but not when an app requests repaint or when the
4410 * windowing system exposes a newly visible area (because then the windowing
4411 * system has already cleared the area).
4414 gdk_window_invalidate_maybe_recurse_full (GdkWindow *window,
4415 const cairo_region_t *region,
4417 GdkWindowChildFunc child_func,
4420 GdkWindow *impl_window;
4421 cairo_region_t *visible_region;
4424 g_return_if_fail (GDK_IS_WINDOW (window));
4426 if (GDK_WINDOW_DESTROYED (window))
4429 if (window->input_only ||
4430 !window->viewable ||
4431 cairo_region_is_empty (region) ||
4432 window->window_type == GDK_WINDOW_ROOT)
4435 visible_region = gdk_window_get_visible_region (window);
4436 cairo_region_intersect (visible_region, region);
4438 tmp_list = window->children;
4441 GdkWindow *child = tmp_list->data;
4443 if (!child->input_only)
4445 cairo_region_t *child_region;
4446 GdkRectangle child_rect;
4448 child_rect.x = child->x;
4449 child_rect.y = child->y;
4450 child_rect.width = child->width;
4451 child_rect.height = child->height;
4452 child_region = cairo_region_create_rectangle (&child_rect);
4454 /* remove child area from the invalid area of the parent */
4455 if (GDK_WINDOW_IS_MAPPED (child) && !child->shaped &&
4456 !child->composited &&
4457 !gdk_window_is_offscreen (child))
4458 cairo_region_subtract (visible_region, child_region);
4460 if (child_func && (*child_func) ((GdkWindow *)child, user_data))
4462 cairo_region_t *tmp = cairo_region_copy (region);
4464 cairo_region_translate (tmp, - child_rect.x, - child_rect.y);
4465 cairo_region_translate (child_region, - child_rect.x, - child_rect.y);
4466 cairo_region_intersect (child_region, tmp);
4468 gdk_window_invalidate_maybe_recurse_full ((GdkWindow *)child,
4469 child_region, clear_bg, child_func, user_data);
4471 cairo_region_destroy (tmp);
4474 cairo_region_destroy (child_region);
4477 tmp_list = tmp_list->next;
4480 impl_window = gdk_window_get_impl_window (window);
4482 if (!cairo_region_is_empty (visible_region) ||
4483 /* Even if we're not exposing anything, make sure we process
4484 idles for windows with outstanding moves */
4485 (impl_window->outstanding_moves != NULL &&
4486 impl_window->update_area == NULL))
4489 draw_ugly_color (window, region);
4491 /* Convert to impl coords */
4492 cairo_region_translate (visible_region, window->abs_x, window->abs_y);
4494 /* Only invalidate area if app requested expose events or if
4495 we need to clear the area (by request or to emulate background
4496 clearing for non-native windows or native windows with no support
4497 for window backgrounds */
4498 if (window->event_mask & GDK_EXPOSURE_MASK ||
4499 clear_bg == CLEAR_BG_ALL ||
4500 clear_bg == CLEAR_BG_WINCLEARED)
4501 impl_window_add_update_area (impl_window, visible_region);
4504 cairo_region_destroy (visible_region);
4508 * gdk_window_invalidate_maybe_recurse:
4509 * @window: a #GdkWindow
4510 * @region: a #cairo_region_t
4511 * @child_func: (scope call) (allow-none): function to use to decide if to
4512 * recurse to a child, %NULL means never recurse.
4513 * @user_data: data passed to @child_func
4515 * Adds @region to the update area for @window. The update area is the
4516 * region that needs to be redrawn, or "dirty region." The call
4517 * gdk_window_process_updates() sends one or more expose events to the
4518 * window, which together cover the entire update area. An
4519 * application would normally redraw the contents of @window in
4520 * response to those expose events.
4522 * GDK will call gdk_window_process_all_updates() on your behalf
4523 * whenever your program returns to the main loop and becomes idle, so
4524 * normally there's no need to do that manually, you just need to
4525 * invalidate regions that you know should be redrawn.
4527 * The @child_func parameter controls whether the region of
4528 * each child window that intersects @region will also be invalidated.
4529 * Only children for which @child_func returns TRUE will have the area
4533 gdk_window_invalidate_maybe_recurse (GdkWindow *window,
4534 const cairo_region_t *region,
4535 GdkWindowChildFunc child_func,
4538 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_NONE,
4539 child_func, user_data);
4543 true_predicate (GdkWindow *window,
4550 gdk_window_invalidate_region_full (GdkWindow *window,
4551 const cairo_region_t *region,
4552 gboolean invalidate_children,
4555 gdk_window_invalidate_maybe_recurse_full (window, region, clear_bg,
4556 invalidate_children ?
4557 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4562 * gdk_window_invalidate_region:
4563 * @window: a #GdkWindow
4564 * @region: a #cairo_region_t
4565 * @invalidate_children: %TRUE to also invalidate child windows
4567 * Adds @region to the update area for @window. The update area is the
4568 * region that needs to be redrawn, or "dirty region." The call
4569 * gdk_window_process_updates() sends one or more expose events to the
4570 * window, which together cover the entire update area. An
4571 * application would normally redraw the contents of @window in
4572 * response to those expose events.
4574 * GDK will call gdk_window_process_all_updates() on your behalf
4575 * whenever your program returns to the main loop and becomes idle, so
4576 * normally there's no need to do that manually, you just need to
4577 * invalidate regions that you know should be redrawn.
4579 * The @invalidate_children parameter controls whether the region of
4580 * each child window that intersects @region will also be invalidated.
4581 * If %FALSE, then the update area for child windows will remain
4582 * unaffected. See gdk_window_invalidate_maybe_recurse if you need
4583 * fine grained control over which children are invalidated.
4586 gdk_window_invalidate_region (GdkWindow *window,
4587 const cairo_region_t *region,
4588 gboolean invalidate_children)
4590 gdk_window_invalidate_maybe_recurse (window, region,
4591 invalidate_children ?
4592 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4597 * _gdk_window_invalidate_for_expose:
4598 * @window: a #GdkWindow
4599 * @region: a #cairo_region_t
4601 * Adds @region to the update area for @window. The update area is the
4602 * region that needs to be redrawn, or "dirty region." The call
4603 * gdk_window_process_updates() sends one or more expose events to the
4604 * window, which together cover the entire update area. An
4605 * application would normally redraw the contents of @window in
4606 * response to those expose events.
4608 * GDK will call gdk_window_process_all_updates() on your behalf
4609 * whenever your program returns to the main loop and becomes idle, so
4610 * normally there's no need to do that manually, you just need to
4611 * invalidate regions that you know should be redrawn.
4613 * This version of invalidation is used when you recieve expose events
4614 * from the native window system. It exposes the native window, plus
4615 * any non-native child windows (but not native child windows, as those would
4616 * have gotten their own expose events).
4619 _gdk_window_invalidate_for_expose (GdkWindow *window,
4620 cairo_region_t *region)
4622 GdkWindowRegionMove *move;
4623 cairo_region_t *move_region;
4626 /* Any invalidations comming from the windowing system will
4627 be in areas that may be moved by outstanding moves,
4628 so we need to modify the expose region correspondingly,
4629 otherwise we would expose in the wrong place, as the
4630 outstanding moves will be copied before we draw the
4632 for (l = window->outstanding_moves; l != NULL; l = l->next)
4636 /* covert to move source region */
4637 move_region = cairo_region_copy (move->dest_region);
4638 cairo_region_translate (move_region, -move->dx, -move->dy);
4640 /* Move area of region that intersects with move source
4641 by dx, dy of the move*/
4642 cairo_region_intersect (move_region, region);
4643 cairo_region_subtract (region, move_region);
4644 cairo_region_translate (move_region, move->dx, move->dy);
4645 cairo_region_union (region, move_region);
4647 cairo_region_destroy (move_region);
4650 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_WINCLEARED,
4651 (gboolean (*) (GdkWindow *, gpointer))gdk_window_has_no_impl,
4657 * gdk_window_get_update_area:
4658 * @window: a #GdkWindow
4660 * Transfers ownership of the update area from @window to the caller
4661 * of the function. That is, after calling this function, @window will
4662 * no longer have an invalid/dirty region; the update area is removed
4663 * from @window and handed to you. If a window has no update area,
4664 * gdk_window_get_update_area() returns %NULL. You are responsible for
4665 * calling cairo_region_destroy() on the returned region if it's non-%NULL.
4667 * Return value: the update area for @window
4670 gdk_window_get_update_area (GdkWindow *window)
4672 GdkWindow *impl_window;
4673 cairo_region_t *tmp_region, *to_remove;
4675 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4677 impl_window = gdk_window_get_impl_window (window);
4679 if (impl_window->update_area)
4681 tmp_region = cairo_region_copy (window->clip_region_with_children);
4682 /* Convert to impl coords */
4683 cairo_region_translate (tmp_region, window->abs_x, window->abs_y);
4684 cairo_region_intersect (tmp_region, impl_window->update_area);
4686 if (cairo_region_is_empty (tmp_region))
4688 cairo_region_destroy (tmp_region);
4693 /* Convert from impl coords */
4694 cairo_region_translate (tmp_region, -window->abs_x, -window->abs_y);
4696 /* Don't remove any update area that is overlapped by non-opaque windows
4697 (children or siblings) with alpha, as these really need to be repainted
4698 independently of this window. */
4699 to_remove = cairo_region_copy (tmp_region);
4700 cairo_region_subtract (to_remove, window->parent->layered_region);
4701 remove_layered_child_area (window, to_remove);
4703 /* Remove from update_area */
4704 cairo_region_translate (to_remove, window->abs_x, window->abs_y);
4705 cairo_region_subtract (impl_window->update_area, to_remove);
4707 cairo_region_destroy (to_remove);
4709 if (cairo_region_is_empty (impl_window->update_area) &&
4710 impl_window->outstanding_moves == NULL)
4712 cairo_region_destroy (impl_window->update_area);
4713 impl_window->update_area = NULL;
4715 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4726 * _gdk_window_clear_update_area:
4727 * @window: a #GdkWindow.
4729 * Internal function to clear the update area for a window. This
4730 * is called when the window is hidden or destroyed.
4733 _gdk_window_clear_update_area (GdkWindow *window)
4735 g_return_if_fail (GDK_IS_WINDOW (window));
4737 if (window->update_area)
4739 gdk_window_remove_update_window (window);
4741 cairo_region_destroy (window->update_area);
4742 window->update_area = NULL;
4747 * gdk_window_freeze_updates:
4748 * @window: a #GdkWindow
4750 * Temporarily freezes a window such that it won't receive expose
4751 * events. The window will begin receiving expose events again when
4752 * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
4753 * has been called more than once, gdk_window_thaw_updates() must be called
4754 * an equal number of times to begin processing exposes.
4757 gdk_window_freeze_updates (GdkWindow *window)
4759 GdkWindow *impl_window;
4761 g_return_if_fail (GDK_IS_WINDOW (window));
4763 impl_window = gdk_window_get_impl_window (window);
4764 impl_window->update_freeze_count++;
4768 * gdk_window_thaw_updates:
4769 * @window: a #GdkWindow
4771 * Thaws a window frozen with gdk_window_freeze_updates().
4774 gdk_window_thaw_updates (GdkWindow *window)
4776 GdkWindow *impl_window;
4778 g_return_if_fail (GDK_IS_WINDOW (window));
4780 impl_window = gdk_window_get_impl_window (window);
4782 g_return_if_fail (impl_window->update_freeze_count > 0);
4784 if (--impl_window->update_freeze_count == 0)
4785 gdk_window_schedule_update (GDK_WINDOW (impl_window));
4789 * gdk_window_freeze_toplevel_updates_libgtk_only:
4790 * @window: a #GdkWindow
4792 * Temporarily freezes a window and all its descendants such that it won't
4793 * receive expose events. The window will begin receiving expose events
4794 * again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
4795 * gdk_window_freeze_toplevel_updates_libgtk_only()
4796 * has been called more than once,
4797 * gdk_window_thaw_toplevel_updates_libgtk_only() must be called
4798 * an equal number of times to begin processing exposes.
4800 * This function is not part of the GDK public API and is only
4804 gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window)
4806 g_return_if_fail (GDK_IS_WINDOW (window));
4807 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4809 window->update_and_descendants_freeze_count++;
4813 * gdk_window_thaw_toplevel_updates_libgtk_only:
4814 * @window: a #GdkWindow
4816 * Thaws a window frozen with
4817 * gdk_window_freeze_toplevel_updates_libgtk_only().
4819 * This function is not part of the GDK public API and is only
4823 gdk_window_thaw_toplevel_updates_libgtk_only (GdkWindow *window)
4825 g_return_if_fail (GDK_IS_WINDOW (window));
4826 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4827 g_return_if_fail (window->update_and_descendants_freeze_count > 0);
4829 window->update_and_descendants_freeze_count--;
4831 gdk_window_schedule_update (window);
4835 * gdk_window_set_debug_updates:
4836 * @setting: %TRUE to turn on update debugging
4838 * With update debugging enabled, calls to
4839 * gdk_window_invalidate_region() clear the invalidated region of the
4840 * screen to a noticeable color, and GDK pauses for a short time
4841 * before sending exposes to windows during
4842 * gdk_window_process_updates(). The net effect is that you can see
4843 * the invalid region for each window and watch redraws as they
4844 * occur. This allows you to diagnose inefficiencies in your application.
4846 * In essence, because the GDK rendering model prevents all flicker,
4847 * if you are redrawing the same region 400 times you may never
4848 * notice, aside from noticing a speed problem. Enabling update
4849 * debugging causes GTK to flicker slowly and noticeably, so you can
4850 * see exactly what's being redrawn when, in what order.
4852 * The --gtk-debug=updates command line option passed to GTK+ programs
4853 * enables this debug option at application startup time. That's
4854 * usually more useful than calling gdk_window_set_debug_updates()
4855 * yourself, though you might want to use this function to enable
4856 * updates sometime after application startup time.
4860 gdk_window_set_debug_updates (gboolean setting)
4862 debug_updates = setting;
4866 * gdk_window_constrain_size:
4867 * @geometry: a #GdkGeometry structure
4868 * @flags: a mask indicating what portions of @geometry are set
4869 * @width: desired width of window
4870 * @height: desired height of the window
4871 * @new_width: (out): location to store resulting width
4872 * @new_height: (out): location to store resulting height
4874 * Constrains a desired width and height according to a
4875 * set of geometry hints (such as minimum and maximum size).
4878 gdk_window_constrain_size (GdkGeometry *geometry,
4885 /* This routine is partially borrowed from fvwm.
4887 * Copyright 1993, Robert Nation
4888 * You may use this code for any purpose, as long as the original
4889 * copyright remains in the source code and all documentation
4891 * which in turn borrows parts of the algorithm from uwm
4894 gint min_height = 0;
4895 gint base_width = 0;
4896 gint base_height = 0;
4899 gint max_width = G_MAXINT;
4900 gint max_height = G_MAXINT;
4902 #define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
4904 if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
4906 base_width = geometry->base_width;
4907 base_height = geometry->base_height;
4908 min_width = geometry->min_width;
4909 min_height = geometry->min_height;
4911 else if (flags & GDK_HINT_BASE_SIZE)
4913 base_width = geometry->base_width;
4914 base_height = geometry->base_height;
4915 min_width = geometry->base_width;
4916 min_height = geometry->base_height;
4918 else if (flags & GDK_HINT_MIN_SIZE)
4920 base_width = geometry->min_width;
4921 base_height = geometry->min_height;
4922 min_width = geometry->min_width;
4923 min_height = geometry->min_height;
4926 if (flags & GDK_HINT_MAX_SIZE)
4928 max_width = geometry->max_width ;
4929 max_height = geometry->max_height;
4932 if (flags & GDK_HINT_RESIZE_INC)
4934 xinc = MAX (xinc, geometry->width_inc);
4935 yinc = MAX (yinc, geometry->height_inc);
4938 /* clamp width and height to min and max values
4940 width = CLAMP (width, min_width, max_width);
4941 height = CLAMP (height, min_height, max_height);
4943 /* shrink to base + N * inc
4945 width = base_width + FLOOR (width - base_width, xinc);
4946 height = base_height + FLOOR (height - base_height, yinc);
4948 /* constrain aspect ratio, according to:
4951 * min_aspect <= -------- <= max_aspect
4955 if (flags & GDK_HINT_ASPECT &&
4956 geometry->min_aspect > 0 &&
4957 geometry->max_aspect > 0)
4961 if (geometry->min_aspect * height > width)
4963 delta = FLOOR (height - width / geometry->min_aspect, yinc);
4964 if (height - delta >= min_height)
4968 delta = FLOOR (height * geometry->min_aspect - width, xinc);
4969 if (width + delta <= max_width)
4974 if (geometry->max_aspect * height < width)
4976 delta = FLOOR (width - height * geometry->max_aspect, xinc);
4977 if (width - delta >= min_width)
4981 delta = FLOOR (width / geometry->max_aspect - height, yinc);
4982 if (height + delta <= max_height)
4991 *new_height = height;
4995 * gdk_window_get_pointer:
4996 * @window: a #GdkWindow
4997 * @x: (out) (allow-none): return location for X coordinate of pointer or %NULL to not
4998 * return the X coordinate
4999 * @y: (out) (allow-none): return location for Y coordinate of pointer or %NULL to not
5000 * return the Y coordinate
5001 * @mask: (out) (allow-none): return location for modifier mask or %NULL to not return the
5004 * Obtains the current pointer position and modifier state.
5005 * The position is given in coordinates relative to the upper left
5006 * corner of @window.
5008 * Return value: (transfer none): the window containing the pointer (as with
5009 * gdk_window_at_pointer()), or %NULL if the window containing the
5010 * pointer isn't known to GDK
5012 * Deprecated: 3.0: Use gdk_window_get_device_position() instead.
5015 gdk_window_get_pointer (GdkWindow *window,
5018 GdkModifierType *mask)
5020 GdkDisplay *display;
5022 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
5024 display = gdk_window_get_display (window);
5026 return gdk_window_get_device_position (window, display->core_pointer, x, y, mask);
5030 * gdk_window_get_device_position:
5031 * @window: a #GdkWindow.
5032 * @device: pointer #GdkDevice to query to.
5033 * @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
5034 * @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
5035 * @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
5037 * Obtains the current device position and modifier state.
5038 * The position is given in coordinates relative to the upper left
5039 * corner of @window.
5041 * Return value: (transfer none): The window underneath @device (as with
5042 * gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
5047 gdk_window_get_device_position (GdkWindow *window,
5051 GdkModifierType *mask)
5054 GdkModifierType tmp_mask;
5055 gboolean normal_child;
5057 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
5058 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
5059 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
5061 normal_child = GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_device_state (window,
5065 /* We got the coords on the impl, convert to the window */
5066 tmp_x -= window->abs_x;
5067 tmp_y -= window->abs_y;
5076 _gdk_display_enable_motion_hints (gdk_window_get_display (window), device);
5079 return _gdk_window_find_child_at (window, tmp_x, tmp_y);
5084 * gdk_get_default_root_window:
5086 * Obtains the root window (parent all other windows are inside)
5087 * for the default display and screen.
5089 * Return value: (transfer none): the default root window
5092 gdk_get_default_root_window (void)
5094 return gdk_screen_get_root_window (gdk_screen_get_default ());
5098 get_all_native_children (GdkWindow *window,
5104 for (l = window->children; l != NULL; l = l->next)
5108 if (gdk_window_has_impl (child))
5109 *native = g_list_prepend (*native, child);
5111 get_all_native_children (child, native);
5117 gdk_window_raise_internal (GdkWindow *window)
5119 GdkWindow *parent = window->parent;
5121 GList *native_children;
5123 GdkWindowImplClass *impl_class;
5127 parent->children = g_list_remove (parent->children, window);
5128 parent->children = g_list_prepend (parent->children, window);
5131 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5132 /* Just do native raise for toplevels */
5133 if (gdk_window_is_toplevel (window) ||
5134 /* The restack_under codepath should work correctly even if the parent
5135 is native, but it relies on the order of ->children to be correct,
5136 and some apps like SWT reorder the x windows without gdks knowledge,
5137 so we use raise directly in order to make these behave as before
5138 when using native windows */
5139 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5141 impl_class->raise (window);
5143 else if (gdk_window_has_impl (window))
5145 above = find_native_sibling_above (parent, window);
5148 listhead.data = window;
5149 listhead.next = NULL;
5150 listhead.prev = NULL;
5151 impl_class->restack_under ((GdkWindow *)above,
5155 impl_class->raise (window);
5159 native_children = NULL;
5160 get_all_native_children (window, &native_children);
5161 if (native_children != NULL)
5163 above = find_native_sibling_above (parent, window);
5166 impl_class->restack_under (above, native_children);
5169 /* Right order, since native_children is bottom-topmost first */
5170 for (l = native_children; l != NULL; l = l->next)
5171 impl_class->raise (l->data);
5174 g_list_free (native_children);
5180 /* Returns TRUE If the native window was mapped or unmapped */
5182 set_viewable (GdkWindow *w,
5186 GdkWindowImplClass *impl_class;
5189 if (w->viewable == val)
5195 recompute_visible_regions (w, FALSE, FALSE);
5197 for (l = w->children; l != NULL; l = l->next)
5201 if (GDK_WINDOW_IS_MAPPED (child) &&
5202 child->window_type != GDK_WINDOW_FOREIGN)
5203 set_viewable (child, val);
5206 if (gdk_window_has_impl (w) &&
5207 w->window_type != GDK_WINDOW_FOREIGN &&
5208 !gdk_window_is_toplevel (w))
5210 /* For most native windows we show/hide them not when they are
5211 * mapped/unmapped, because that may not produce the correct results.
5212 * For instance, if a native window have a non-native parent which is
5213 * hidden, but its native parent is viewable then showing the window
5214 * would make it viewable to X but its not viewable wrt the non-native
5215 * hierarchy. In order to handle this we track the gdk side viewability
5216 * and only map really viewable windows.
5218 * There are two exceptions though:
5220 * For foreign windows we don't want ever change the mapped state
5221 * except when explicitly done via gdk_window_show/hide, as this may
5222 * cause problems for client owning the foreign window when its window
5223 * is suddenly mapped or unmapped.
5225 * For toplevel windows embedded in a foreign window (e.g. a plug)
5226 * we sometimes synthesize a map of a window, but the native
5227 * window is really shown by the embedder, so we don't want to
5228 * do the show ourselves. We can't really tell this case from the normal
5229 * toplevel show as such toplevels are seen by gdk as parents of the
5230 * root window, so we make an exception for all toplevels.
5233 impl_class = GDK_WINDOW_IMPL_GET_CLASS (w->impl);
5235 impl_class->show ((GdkWindow *)w, FALSE);
5237 impl_class->hide ((GdkWindow *)w);
5245 /* Returns TRUE If the native window was mapped or unmapped */
5247 _gdk_window_update_viewable (GdkWindow *window)
5251 if (window->window_type == GDK_WINDOW_FOREIGN ||
5252 window->window_type == GDK_WINDOW_ROOT)
5254 else if (gdk_window_is_toplevel (window) ||
5255 window->parent->viewable)
5256 viewable = GDK_WINDOW_IS_MAPPED (window);
5260 return set_viewable (window, viewable);
5264 gdk_window_show_internal (GdkWindow *window, gboolean raise)
5266 GdkWindowImplClass *impl_class;
5267 gboolean was_mapped, was_viewable;
5270 g_return_if_fail (GDK_IS_WINDOW (window));
5272 if (window->destroyed)
5275 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5276 was_viewable = window->viewable;
5279 /* Keep children in (reverse) stacking order */
5280 gdk_window_raise_internal (window);
5282 if (gdk_window_has_impl (window))
5285 gdk_synthesize_window_state (window,
5286 GDK_WINDOW_STATE_WITHDRAWN,
5287 GDK_WINDOW_STATE_FOCUSED);
5294 did_show = _gdk_window_update_viewable (window);
5296 /* If it was already viewable the backend show op won't be called, call it
5297 again to ensure things happen right if the mapped tracking was not right
5298 for e.g. a foreign window.
5299 Dunno if this is strictly needed but its what happened pre-csw.
5300 Also show if not done by gdk_window_update_viewable. */
5301 if (gdk_window_has_impl (window) && (was_viewable || !did_show))
5303 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5304 impl_class->show (window, !did_show ? was_mapped : TRUE);
5307 if (!was_mapped && !gdk_window_has_impl (window))
5309 if (window->event_mask & GDK_STRUCTURE_MASK)
5310 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5312 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5313 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5316 if (!was_mapped || raise)
5318 recompute_visible_regions (window, TRUE, FALSE);
5320 /* If any decendants became visible we need to send visibility notify */
5321 gdk_window_update_visibility_recursively (window, NULL);
5323 if (gdk_window_is_viewable (window))
5325 _gdk_synthesize_crossing_events_for_geometry_change (window);
5326 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
5332 * gdk_window_show_unraised:
5333 * @window: a #GdkWindow
5335 * Shows a #GdkWindow onscreen, but does not modify its stacking
5336 * order. In contrast, gdk_window_show() will raise the window
5337 * to the top of the window stack.
5339 * On the X11 platform, in Xlib terms, this function calls
5340 * XMapWindow() (it also updates some internal GDK state, which means
5341 * that you can't really use XMapWindow() directly on a GDK window).
5344 gdk_window_show_unraised (GdkWindow *window)
5346 gdk_window_show_internal (window, FALSE);
5351 * @window: a #GdkWindow
5353 * Raises @window to the top of the Z-order (stacking order), so that
5354 * other windows with the same parent window appear below @window.
5355 * This is true whether or not the windows are visible.
5357 * If @window is a toplevel, the window manager may choose to deny the
5358 * request to move the window in the Z-order, gdk_window_raise() only
5359 * requests the restack, does not guarantee it.
5362 gdk_window_raise (GdkWindow *window)
5364 g_return_if_fail (GDK_IS_WINDOW (window));
5366 if (window->destroyed)
5369 gdk_window_flush_if_exposing (window);
5371 /* Keep children in (reverse) stacking order */
5372 gdk_window_raise_internal (window);
5374 recompute_visible_regions (window, TRUE, FALSE);
5376 if (gdk_window_is_viewable (window) &&
5377 !window->input_only)
5378 gdk_window_invalidate_region_full (window, window->clip_region, TRUE, CLEAR_BG_ALL);
5382 gdk_window_lower_internal (GdkWindow *window)
5384 GdkWindow *parent = window->parent;
5385 GdkWindowImplClass *impl_class;
5387 GList *native_children;
5392 parent->children = g_list_remove (parent->children, window);
5393 parent->children = g_list_append (parent->children, window);
5396 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5397 /* Just do native lower for toplevels */
5398 if (gdk_window_is_toplevel (window) ||
5399 /* The restack_under codepath should work correctly even if the parent
5400 is native, but it relies on the order of ->children to be correct,
5401 and some apps like SWT reorder the x windows without gdks knowledge,
5402 so we use lower directly in order to make these behave as before
5403 when using native windows */
5404 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5406 impl_class->lower (window);
5408 else if (gdk_window_has_impl (window))
5410 above = find_native_sibling_above (parent, window);
5413 listhead.data = window;
5414 listhead.next = NULL;
5415 listhead.prev = NULL;
5416 impl_class->restack_under ((GdkWindow *)above, &listhead);
5419 impl_class->raise (window);
5423 native_children = NULL;
5424 get_all_native_children (window, &native_children);
5425 if (native_children != NULL)
5427 above = find_native_sibling_above (parent, window);
5430 impl_class->restack_under ((GdkWindow *)above,
5434 /* Right order, since native_children is bottom-topmost first */
5435 for (l = native_children; l != NULL; l = l->next)
5436 impl_class->raise (l->data);
5439 g_list_free (native_children);
5446 gdk_window_invalidate_in_parent (GdkWindow *private)
5448 GdkRectangle r, child;
5450 if (gdk_window_is_toplevel (private))
5453 /* get the visible rectangle of the parent */
5455 r.width = private->parent->width;
5456 r.height = private->parent->height;
5458 child.x = private->x;
5459 child.y = private->y;
5460 child.width = private->width;
5461 child.height = private->height;
5462 gdk_rectangle_intersect (&r, &child, &r);
5464 gdk_window_invalidate_rect_full (private->parent, &r, TRUE, CLEAR_BG_ALL);
5470 * @window: a #GdkWindow
5472 * Lowers @window to the bottom of the Z-order (stacking order), so that
5473 * other windows with the same parent window appear above @window.
5474 * This is true whether or not the other windows are visible.
5476 * If @window is a toplevel, the window manager may choose to deny the
5477 * request to move the window in the Z-order, gdk_window_lower() only
5478 * requests the restack, does not guarantee it.
5480 * Note that gdk_window_show() raises the window again, so don't call this
5481 * function before gdk_window_show(). (Try gdk_window_show_unraised().)
5484 gdk_window_lower (GdkWindow *window)
5486 g_return_if_fail (GDK_IS_WINDOW (window));
5488 if (window->destroyed)
5491 gdk_window_flush_if_exposing (window);
5493 /* Keep children in (reverse) stacking order */
5494 gdk_window_lower_internal (window);
5496 recompute_visible_regions (window, TRUE, FALSE);
5498 _gdk_synthesize_crossing_events_for_geometry_change (window);
5499 gdk_window_invalidate_in_parent (window);
5503 * gdk_window_restack:
5504 * @window: a #GdkWindow
5505 * @sibling: (allow-none): a #GdkWindow that is a sibling of @window, or %NULL
5508 * Changes the position of @window in the Z-order (stacking order), so that
5509 * it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
5512 * If @sibling is %NULL, then this either raises (if @above is %TRUE) or
5513 * lowers the window.
5515 * If @window is a toplevel, the window manager may choose to deny the
5516 * request to move the window in the Z-order, gdk_window_restack() only
5517 * requests the restack, does not guarantee it.
5522 gdk_window_restack (GdkWindow *window,
5526 GdkWindowImplClass *impl_class;
5528 GdkWindow *above_native;
5529 GList *sibling_link;
5530 GList *native_children;
5533 g_return_if_fail (GDK_IS_WINDOW (window));
5534 g_return_if_fail (sibling == NULL || GDK_IS_WINDOW (sibling));
5536 if (window->destroyed)
5539 if (sibling == NULL)
5542 gdk_window_raise (window);
5544 gdk_window_lower (window);
5548 gdk_window_flush_if_exposing (window);
5550 if (gdk_window_is_toplevel (window))
5552 g_return_if_fail (gdk_window_is_toplevel (sibling));
5553 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5554 impl_class->restack_toplevel (window, sibling, above);
5558 parent = window->parent;
5561 sibling_link = g_list_find (parent->children, sibling);
5562 g_return_if_fail (sibling_link != NULL);
5563 if (sibling_link == NULL)
5566 parent->children = g_list_remove (parent->children, window);
5568 parent->children = g_list_insert_before (parent->children,
5572 parent->children = g_list_insert_before (parent->children,
5576 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5577 if (gdk_window_has_impl (window))
5579 above_native = find_native_sibling_above (parent, window);
5582 listhead.data = window;
5583 listhead.next = NULL;
5584 listhead.prev = NULL;
5585 impl_class->restack_under (above_native, &listhead);
5588 impl_class->raise (window);
5592 native_children = NULL;
5593 get_all_native_children (window, &native_children);
5594 if (native_children != NULL)
5596 above_native = find_native_sibling_above (parent, window);
5598 impl_class->restack_under (above_native,
5602 /* Right order, since native_children is bottom-topmost first */
5603 for (l = native_children; l != NULL; l = l->next)
5604 impl_class->raise (l->data);
5607 g_list_free (native_children);
5612 recompute_visible_regions (window, TRUE, FALSE);
5614 _gdk_synthesize_crossing_events_for_geometry_change (window);
5615 gdk_window_invalidate_in_parent (window);
5621 * @window: a #GdkWindow
5623 * Like gdk_window_show_unraised(), but also raises the window to the
5624 * top of the window stack (moves the window to the front of the
5627 * This function maps a window so it's visible onscreen. Its opposite
5628 * is gdk_window_hide().
5630 * When implementing a #GtkWidget, you should call this function on the widget's
5631 * #GdkWindow as part of the "map" method.
5634 gdk_window_show (GdkWindow *window)
5636 gdk_window_show_internal (window, TRUE);
5641 * @window: a #GdkWindow
5643 * For toplevel windows, withdraws them, so they will no longer be
5644 * known to the window manager; for all windows, unmaps them, so
5645 * they won't be displayed. Normally done automatically as
5646 * part of gtk_widget_hide().
5649 gdk_window_hide (GdkWindow *window)
5651 GdkWindowImplClass *impl_class;
5652 gboolean was_mapped, did_hide;
5654 g_return_if_fail (GDK_IS_WINDOW (window));
5656 if (window->destroyed)
5659 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5661 if (gdk_window_has_impl (window))
5664 if (GDK_WINDOW_IS_MAPPED (window))
5665 gdk_synthesize_window_state (window,
5667 GDK_WINDOW_STATE_WITHDRAWN);
5669 else if (was_mapped)
5671 GdkDisplay *display;
5672 GdkDeviceManager *device_manager;
5675 /* May need to break grabs on children */
5676 display = gdk_window_get_display (window);
5677 device_manager = gdk_display_get_device_manager (display);
5679 /* Get all devices */
5680 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
5681 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
5682 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
5684 for (d = devices; d; d = d->next)
5686 GdkDevice *device = d->data;
5688 if (_gdk_display_end_device_grab (display,
5690 _gdk_display_get_next_serial (display),
5693 gdk_device_ungrab (device, GDK_CURRENT_TIME);
5696 window->state = GDK_WINDOW_STATE_WITHDRAWN;
5697 g_list_free (devices);
5700 did_hide = _gdk_window_update_viewable (window);
5702 /* Hide foreign window as those are not handled by update_viewable. */
5703 if (gdk_window_has_impl (window) && (!did_hide))
5705 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5706 impl_class->hide (window);
5709 recompute_visible_regions (window, TRUE, FALSE);
5711 /* all decendants became non-visible, we need to send visibility notify */
5712 gdk_window_update_visibility_recursively (window, NULL);
5714 if (was_mapped && !gdk_window_has_impl (window))
5716 if (window->event_mask & GDK_STRUCTURE_MASK)
5717 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5719 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5720 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5722 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5725 /* Invalidate the rect */
5727 gdk_window_invalidate_in_parent (window);
5731 * gdk_window_withdraw:
5732 * @window: a toplevel #GdkWindow
5734 * Withdraws a window (unmaps it and asks the window manager to forget about it).
5735 * This function is not really useful as gdk_window_hide() automatically
5736 * withdraws toplevel windows before hiding them.
5739 gdk_window_withdraw (GdkWindow *window)
5741 GdkWindowImplClass *impl_class;
5742 gboolean was_mapped;
5744 g_return_if_fail (GDK_IS_WINDOW (window));
5746 if (window->destroyed)
5749 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5751 if (gdk_window_has_impl (window))
5753 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5754 impl_class->withdraw (window);
5758 if (window->event_mask & GDK_STRUCTURE_MASK)
5759 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5761 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5762 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5764 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5767 recompute_visible_regions (window, TRUE, FALSE);
5772 * gdk_window_set_events:
5773 * @window: a #GdkWindow
5774 * @event_mask: event mask for @window
5776 * The event mask for a window determines which events will be reported
5777 * for that window from all master input devices. For example, an event mask
5778 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5779 * press events. The event mask is the bitwise OR of values from the
5780 * #GdkEventMask enumeration.
5783 gdk_window_set_events (GdkWindow *window,
5784 GdkEventMask event_mask)
5786 GdkWindowImplClass *impl_class;
5787 GdkDisplay *display;
5789 g_return_if_fail (GDK_IS_WINDOW (window));
5791 if (window->destroyed)
5794 /* If motion hint is disabled, enable motion events again */
5795 display = gdk_window_get_display (window);
5796 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5797 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5799 GList *devices = window->devices_inside;
5803 _gdk_display_enable_motion_hints (display, (GdkDevice *) devices->data);
5804 devices = devices->next;
5808 window->event_mask = event_mask;
5810 if (gdk_window_has_impl (window))
5812 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5813 impl_class->set_events (window,
5814 get_native_event_mask (window));
5820 * gdk_window_get_events:
5821 * @window: a #GdkWindow
5823 * Gets the event mask for @window for all master input devices. See
5824 * gdk_window_set_events().
5826 * Return value: event mask for @window
5829 gdk_window_get_events (GdkWindow *window)
5831 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5833 if (window->destroyed)
5836 return window->event_mask;
5840 * gdk_window_set_device_events:
5841 * @window: a #GdkWindow
5842 * @device: #GdkDevice to enable events for.
5843 * @event_mask: event mask for @window
5845 * Sets the event mask for a given device (Normally a floating device, not
5846 * attached to any visible pointer) to @window. For example, an event mask
5847 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5848 * press events. The event mask is the bitwise OR of values from the
5849 * #GdkEventMask enumeration.
5854 gdk_window_set_device_events (GdkWindow *window,
5856 GdkEventMask event_mask)
5858 GdkEventMask device_mask;
5859 GdkDisplay *display;
5862 g_return_if_fail (GDK_IS_WINDOW (window));
5863 g_return_if_fail (GDK_IS_DEVICE (device));
5865 if (GDK_WINDOW_DESTROYED (window))
5868 /* If motion hint is disabled, enable motion events again */
5869 display = gdk_window_get_display (window);
5870 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5871 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5872 _gdk_display_enable_motion_hints (display, device);
5874 if (G_UNLIKELY (!window->device_events))
5875 window->device_events = g_hash_table_new (NULL, NULL);
5877 if (event_mask == 0)
5879 /* FIXME: unsetting events on a master device
5880 * would restore window->event_mask
5882 g_hash_table_remove (window->device_events, device);
5885 g_hash_table_insert (window->device_events, device,
5886 GINT_TO_POINTER (event_mask));
5888 native = gdk_window_get_toplevel (window);
5890 while (gdk_window_is_offscreen (native))
5892 native = gdk_offscreen_window_get_embedder (native);
5894 if (native == NULL ||
5895 (!_gdk_window_has_impl (native) &&
5896 !gdk_window_is_viewable (native)))
5899 native = gdk_window_get_toplevel (native);
5902 device_mask = get_native_device_event_mask (window, device);
5903 GDK_DEVICE_GET_CLASS (device)->select_window_events (device, native, device_mask);
5907 * gdk_window_get_device_events:
5908 * @window: a #GdkWindow.
5909 * @device: a #GdkDevice.
5911 * Returns the event mask for @window corresponding to an specific device.
5913 * Returns: device event mask for @window
5918 gdk_window_get_device_events (GdkWindow *window,
5923 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5924 g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
5926 if (GDK_WINDOW_DESTROYED (window))
5929 if (!window->device_events)
5932 mask = GPOINTER_TO_INT (g_hash_table_lookup (window->device_events, device));
5934 /* FIXME: device could be controlled by window->event_mask */
5940 gdk_window_move_resize_toplevel (GdkWindow *window,
5947 cairo_region_t *old_region, *new_region;
5948 GdkWindowImplClass *impl_class;
5955 is_resize = (width != -1) || (height != -1);
5957 if (gdk_window_is_viewable (window) &&
5958 !window->input_only)
5961 old_region = cairo_region_copy (window->clip_region);
5964 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5965 impl_class->move_resize (window, with_move, x, y, width, height);
5967 /* Avoid recomputing for pure toplevel moves, for performance reasons */
5969 recompute_visible_regions (window, TRUE, FALSE);
5973 new_region = cairo_region_copy (window->clip_region);
5975 /* This is the newly exposed area (due to any resize),
5976 * X will expose it, but lets do that without the roundtrip
5978 cairo_region_subtract (new_region, old_region);
5979 gdk_window_invalidate_region_full (window, new_region, TRUE, CLEAR_BG_WINCLEARED);
5981 cairo_region_destroy (old_region);
5982 cairo_region_destroy (new_region);
5985 _gdk_synthesize_crossing_events_for_geometry_change (window);
5990 move_native_children (GdkWindow *private)
5994 GdkWindowImplClass *impl_class;
5996 for (l = private->children; l; l = l->next)
6000 if (child->impl != private->impl)
6002 impl_class = GDK_WINDOW_IMPL_GET_CLASS (child->impl);
6003 impl_class->move_resize (child, TRUE,
6005 child->width, child->height);
6008 move_native_children (child);
6013 collect_native_child_region_helper (GdkWindow *window,
6014 GdkWindowImpl *impl,
6015 cairo_region_t **region,
6020 cairo_region_t *tmp;
6023 for (l = window->children; l != NULL; l = l->next)
6027 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
6030 if (child->impl != impl)
6032 tmp = cairo_region_copy (child->clip_region);
6033 cairo_region_translate (tmp,
6034 x_offset + child->x,
6035 y_offset + child->y);
6036 if (*region == NULL)
6040 cairo_region_union (*region, tmp);
6041 cairo_region_destroy (tmp);
6045 collect_native_child_region_helper (child, impl, region,
6046 x_offset + child->x,
6047 y_offset + child->y);
6053 static cairo_region_t *
6054 collect_native_child_region (GdkWindow *window,
6055 gboolean include_this)
6057 cairo_region_t *region;
6059 if (include_this && gdk_window_has_impl (window) && window->viewable)
6060 return cairo_region_copy (window->clip_region);
6064 collect_native_child_region_helper (window, window->impl, ®ion, 0, 0);
6071 gdk_window_move_resize_internal (GdkWindow *window,
6078 cairo_region_t *old_region, *old_layered, *new_region, *copy_area;
6079 cairo_region_t *old_native_child_region, *new_native_child_region;
6080 GdkWindow *impl_window;
6081 GdkWindowImplClass *impl_class;
6083 int old_x, old_y, old_abs_x, old_abs_y;
6086 g_return_if_fail (GDK_IS_WINDOW (window));
6088 if (window->destroyed)
6091 if (gdk_window_is_toplevel (window))
6093 gdk_window_move_resize_toplevel (window, with_move, x, y, width, height);
6097 /* Bail early if no change */
6098 if (window->width == width &&
6099 window->height == height &&
6105 gdk_window_flush_if_exposing (window);
6107 /* Handle child windows */
6113 impl_window = gdk_window_get_impl_window (window);
6118 old_native_child_region = NULL;
6119 if (gdk_window_is_viewable (window) &&
6120 !window->input_only)
6124 old_region = cairo_region_copy (window->clip_region);
6125 old_layered = cairo_region_copy (window->layered_region);
6126 /* Adjust regions to parent window coords */
6127 cairo_region_translate (old_region, window->x, window->y);
6128 cairo_region_translate (old_layered, window->x, window->y);
6130 old_native_child_region = collect_native_child_region (window, TRUE);
6131 if (old_native_child_region)
6133 /* Adjust region to parent window coords */
6134 cairo_region_translate (old_native_child_region, window->x, window->y);
6136 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6137 * source or destination for a delayed GdkWindowRegionMove. So, we need
6138 * to flush those here for the parent window and all overlapped subwindows
6139 * of it. And we need to do this before setting the new clips as those will be
6142 gdk_window_flush_recursive (window->parent);
6146 /* Set the new position and size */
6152 if (!(width < 0 && height < 0))
6156 window->width = width;
6159 window->height = height;
6162 dx = window->x - old_x;
6163 dy = window->y - old_y;
6165 old_abs_x = window->abs_x;
6166 old_abs_y = window->abs_y;
6168 recompute_visible_regions (window, TRUE, FALSE);
6170 new_native_child_region = NULL;
6171 if (old_native_child_region)
6173 new_native_child_region = collect_native_child_region (window, TRUE);
6174 /* Adjust region to parent window coords */
6175 cairo_region_translate (new_native_child_region, window->x, window->y);
6178 if (gdk_window_has_impl (window))
6180 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6182 /* Do the actual move after recomputing things, as this will have set the shape to
6183 the now correct one, thus avoiding copying regions that should not be copied. */
6184 impl_class->move_resize (window, TRUE,
6185 window->x, window->y,
6186 window->width, window->height);
6188 else if (old_abs_x != window->abs_x ||
6189 old_abs_y != window->abs_y)
6190 move_native_children (window);
6194 new_region = cairo_region_copy (window->clip_region);
6195 /* Adjust region to parent window coords */
6196 cairo_region_translate (new_region, window->x, window->y);
6199 * Part of the data at the new location can be copied from the
6200 * old location, this area is the intersection of the old region
6201 * moved as the copy will move it and then intersected with
6205 * Everything in the old and new regions that is not copied must be
6206 * invalidated (including children) as this is newly exposed
6208 if (window->has_alpha_background)
6209 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6211 copy_area = cairo_region_copy (new_region);
6213 /* Don't copy from a previously layered region */
6214 cairo_region_translate (old_layered, dx, dy);
6215 cairo_region_subtract (copy_area, old_layered);
6217 /* Don't copy into a layered region */
6218 cairo_region_translate (copy_area, -window->x, -window->y);
6219 cairo_region_subtract (copy_area, window->layered_region);
6220 cairo_region_translate (copy_area, window->x, window->y);
6222 cairo_region_union (new_region, old_region);
6224 if (old_native_child_region)
6226 /* Don't copy from inside native children, as this is copied by
6227 * the native window move.
6229 cairo_region_subtract (old_region, old_native_child_region);
6231 cairo_region_translate (old_region, dx, dy);
6233 cairo_region_intersect (copy_area, old_region);
6235 if (new_native_child_region)
6237 /* Don't copy any bits that would cause a read from the moved
6238 native windows, as we can't read that data */
6239 cairo_region_translate (new_native_child_region, dx, dy);
6240 cairo_region_subtract (copy_area, new_native_child_region);
6241 cairo_region_translate (new_native_child_region, -dx, -dy);
6244 cairo_region_subtract (new_region, copy_area);
6246 /* Convert old region to impl coords */
6247 cairo_region_translate (old_region, -dx + window->abs_x - window->x, -dy + window->abs_y - window->y);
6249 /* convert from parent coords to impl */
6250 cairo_region_translate (copy_area, window->abs_x - window->x, window->abs_y - window->y);
6252 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6254 /* Invalidate affected part in the parent window
6255 * (no higher window should be affected)
6256 * We also invalidate any children in that area, which could include
6257 * this window if it still overlaps that area.
6259 if (old_native_child_region)
6261 /* No need to expose the region that the native window move copies */
6262 cairo_region_translate (old_native_child_region, dx, dy);
6263 cairo_region_intersect (old_native_child_region, new_native_child_region);
6264 cairo_region_subtract (new_region, old_native_child_region);
6266 gdk_window_invalidate_region_full (window->parent, new_region, TRUE, CLEAR_BG_ALL);
6268 cairo_region_destroy (old_region);
6269 cairo_region_destroy (old_layered);
6270 cairo_region_destroy (new_region);
6273 if (old_native_child_region)
6275 cairo_region_destroy (old_native_child_region);
6276 cairo_region_destroy (new_native_child_region);
6279 _gdk_synthesize_crossing_events_for_geometry_change (window);
6286 * @window: a #GdkWindow
6287 * @x: X coordinate relative to window's parent
6288 * @y: Y coordinate relative to window's parent
6290 * Repositions a window relative to its parent window.
6291 * For toplevel windows, window managers may ignore or modify the move;
6292 * you should probably use gtk_window_move() on a #GtkWindow widget
6293 * anyway, instead of using GDK functions. For child windows,
6294 * the move will reliably succeed.
6296 * If you're also planning to resize the window, use gdk_window_move_resize()
6297 * to both move and resize simultaneously, for a nicer visual effect.
6300 gdk_window_move (GdkWindow *window,
6304 gdk_window_move_resize_internal (window, TRUE, x, y, -1, -1);
6308 * gdk_window_resize:
6309 * @window: a #GdkWindow
6310 * @width: new width of the window
6311 * @height: new height of the window
6313 * Resizes @window; for toplevel windows, asks the window manager to resize
6314 * the window. The window manager may not allow the resize. When using GTK+,
6315 * use gtk_window_resize() instead of this low-level GDK function.
6317 * Windows may not be resized below 1x1.
6319 * If you're also planning to move the window, use gdk_window_move_resize()
6320 * to both move and resize simultaneously, for a nicer visual effect.
6323 gdk_window_resize (GdkWindow *window,
6327 gdk_window_move_resize_internal (window, FALSE, 0, 0, width, height);
6332 * gdk_window_move_resize:
6333 * @window: a #GdkWindow
6334 * @x: new X position relative to window's parent
6335 * @y: new Y position relative to window's parent
6337 * @height: new height
6339 * Equivalent to calling gdk_window_move() and gdk_window_resize(),
6340 * except that both operations are performed at once, avoiding strange
6341 * visual effects. (i.e. the user may be able to see the window first
6342 * move, then resize, if you don't use gdk_window_move_resize().)
6345 gdk_window_move_resize (GdkWindow *window,
6351 gdk_window_move_resize_internal (window, TRUE, x, y, width, height);
6356 * gdk_window_scroll:
6357 * @window: a #GdkWindow
6358 * @dx: Amount to scroll in the X direction
6359 * @dy: Amount to scroll in the Y direction
6361 * Scroll the contents of @window, both pixels and children, by the
6362 * given amount. @window itself does not move. Portions of the window
6363 * that the scroll operation brings in from offscreen areas are
6364 * invalidated. The invalidated region may be bigger than what would
6365 * strictly be necessary.
6367 * For X11, a minimum area will be invalidated if the window has no
6368 * subwindows, or if the edges of the window's parent do not extend
6369 * beyond the edges of the window. In other cases, a multi-step process
6370 * is used to scroll the window which may produce temporary visual
6371 * artifacts and unnecessary invalidations.
6374 gdk_window_scroll (GdkWindow *window,
6378 GdkWindow *impl_window;
6379 cairo_region_t *copy_area, *noncopy_area, *old_layered_area;
6380 cairo_region_t *old_native_child_region, *new_native_child_region;
6383 g_return_if_fail (GDK_IS_WINDOW (window));
6385 if (dx == 0 && dy == 0)
6388 if (window->destroyed)
6391 gdk_window_flush_if_exposing (window);
6393 old_layered_area = cairo_region_copy (window->layered_region);
6394 old_native_child_region = collect_native_child_region (window, FALSE);
6395 if (old_native_child_region)
6397 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6398 * source or destination for a delayed GdkWindowRegionMove. So, we need
6399 * to flush those here for the window and all overlapped subwindows
6400 * of it. And we need to do this before setting the new clips as those will be
6403 gdk_window_flush_recursive (window);
6407 /* First move all child windows, without causing invalidation */
6409 tmp_list = window->children;
6412 GdkWindow *child = GDK_WINDOW (tmp_list->data);
6414 /* Just update the positions, the bits will move with the copy */
6418 tmp_list = tmp_list->next;
6421 recompute_visible_regions (window, FALSE, TRUE);
6423 new_native_child_region = NULL;
6424 if (old_native_child_region)
6425 new_native_child_region = collect_native_child_region (window, FALSE);
6427 move_native_children (window);
6429 /* Then copy the actual bits of the window w/ child windows */
6431 impl_window = gdk_window_get_impl_window (window);
6433 /* Calculate the area that can be gotten by copying the old area */
6434 if (window->has_alpha_background)
6435 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6437 copy_area = cairo_region_copy (window->clip_region);
6438 cairo_region_subtract (copy_area, old_layered_area);
6439 if (old_native_child_region)
6441 /* Don't copy from inside native children, as this is copied by
6442 * the native window move.
6444 cairo_region_subtract (copy_area, old_native_child_region);
6446 /* Don't copy any bits that would cause a read from the moved
6447 native windows, as we can't read that data */
6448 cairo_region_subtract (copy_area, new_native_child_region);
6450 cairo_region_translate (copy_area, dx, dy);
6451 cairo_region_intersect (copy_area, window->clip_region);
6452 cairo_region_subtract (copy_area, window->layered_region);
6454 /* And the rest need to be invalidated */
6455 noncopy_area = cairo_region_copy (window->clip_region);
6456 cairo_region_subtract (noncopy_area, copy_area);
6458 /* convert from window coords to impl */
6459 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6461 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6463 /* Invalidate not copied regions */
6464 if (old_native_child_region)
6466 /* No need to expose the region that the native window move copies */
6467 cairo_region_translate (old_native_child_region, dx, dy);
6468 cairo_region_intersect (old_native_child_region, new_native_child_region);
6469 cairo_region_subtract (noncopy_area, old_native_child_region);
6471 gdk_window_invalidate_region_full (window, noncopy_area, TRUE, CLEAR_BG_ALL);
6473 cairo_region_destroy (noncopy_area);
6474 cairo_region_destroy (old_layered_area);
6476 if (old_native_child_region)
6478 cairo_region_destroy (old_native_child_region);
6479 cairo_region_destroy (new_native_child_region);
6482 _gdk_synthesize_crossing_events_for_geometry_change (window);
6486 * gdk_window_move_region:
6487 * @window: a #GdkWindow
6488 * @region: The #cairo_region_t to move
6489 * @dx: Amount to move in the X direction
6490 * @dy: Amount to move in the Y direction
6492 * Move the part of @window indicated by @region by @dy pixels in the Y
6493 * direction and @dx pixels in the X direction. The portions of @region
6494 * that not covered by the new position of @region are invalidated.
6496 * Child windows are not moved.
6501 gdk_window_move_region (GdkWindow *window,
6502 const cairo_region_t *region,
6506 GdkWindow *impl_window;
6507 cairo_region_t *nocopy_area;
6508 cairo_region_t *copy_area;
6510 g_return_if_fail (GDK_IS_WINDOW (window));
6511 g_return_if_fail (region != NULL);
6513 if (dx == 0 && dy == 0)
6516 if (window->destroyed)
6519 impl_window = gdk_window_get_impl_window (window);
6521 /* compute source regions */
6522 if (window->has_alpha_background)
6523 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6525 copy_area = cairo_region_copy (region);
6526 cairo_region_intersect (copy_area, window->clip_region_with_children);
6527 cairo_region_subtract (copy_area, window->layered_region);
6528 remove_layered_child_area (window, copy_area);
6530 /* compute destination regions */
6531 cairo_region_translate (copy_area, dx, dy);
6532 cairo_region_intersect (copy_area, window->clip_region_with_children);
6533 cairo_region_subtract (copy_area, window->layered_region);
6534 remove_layered_child_area (window, copy_area);
6536 /* Invalidate parts of the region (source and dest) not covered
6538 nocopy_area = cairo_region_copy (region);
6539 cairo_region_translate (nocopy_area, dx, dy);
6540 cairo_region_union (nocopy_area, region);
6541 cairo_region_subtract (nocopy_area, copy_area);
6543 /* convert from window coords to impl */
6544 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6545 move_region_on_impl (impl_window, copy_area, dx, dy); /* Takes ownership of copy_area */
6547 gdk_window_invalidate_region_full (window, nocopy_area, FALSE, CLEAR_BG_ALL);
6548 cairo_region_destroy (nocopy_area);
6552 * gdk_window_set_background:
6553 * @window: a #GdkWindow
6554 * @color: a #GdkColor
6556 * Sets the background color of @window. (However, when using GTK+,
6557 * set the background of a widget with gtk_widget_modify_bg() - if
6558 * you're an application - or gtk_style_set_background() - if you're
6559 * implementing a custom widget.)
6561 * See also gdk_window_set_background_pattern().
6563 * Deprecated: 3.4: Use gdk_window_set_background_rgba() instead.
6566 gdk_window_set_background (GdkWindow *window,
6567 const GdkColor *color)
6569 cairo_pattern_t *pattern;
6571 g_return_if_fail (GDK_IS_WINDOW (window));
6573 pattern = cairo_pattern_create_rgb (color->red / 65535.,
6574 color->green / 65535.,
6575 color->blue / 65535.);
6577 gdk_window_set_background_pattern (window, pattern);
6579 cairo_pattern_destroy (pattern);
6583 * gdk_window_set_background_rgba:
6584 * @window: a #GdkWindow
6585 * @rgba: a #GdkRGBA color
6587 * Sets the background color of @window.
6589 * See also gdk_window_set_background_pattern().
6592 gdk_window_set_background_rgba (GdkWindow *window,
6595 cairo_pattern_t *pattern;
6597 g_return_if_fail (GDK_IS_WINDOW (window));
6598 g_return_if_fail (rgba != NULL);
6600 pattern = cairo_pattern_create_rgba (rgba->red, rgba->green,
6601 rgba->blue, rgba->alpha);
6603 gdk_window_set_background_pattern (window, pattern);
6605 cairo_pattern_destroy (pattern);
6609 /* Updates has_alpha_background recursively for all child windows
6610 that have parent-relative alpha */
6612 _gdk_window_propagate_has_alpha_background (GdkWindow *window)
6617 for (l = window->children; l; l = l->next)
6621 if (child->background == NULL &&
6622 child->has_alpha_background != window->has_alpha_background)
6624 child->has_alpha_background = window->has_alpha_background;
6625 recompute_visible_regions (child, TRUE, FALSE);
6626 _gdk_window_propagate_has_alpha_background (child);
6632 * gdk_window_set_background_pattern:
6633 * @window: a #GdkWindow
6634 * @pattern: (allow-none): a pattern to use, or %NULL
6636 * Sets the background of @window.
6638 * A background of %NULL means that the window will inherit its
6639 * background form its parent window.
6641 * The windowing system will normally fill a window with its background
6642 * when the window is obscured then exposed.
6645 gdk_window_set_background_pattern (GdkWindow *window,
6646 cairo_pattern_t *pattern)
6649 cairo_pattern_type_t type;
6651 g_return_if_fail (GDK_IS_WINDOW (window));
6653 if (window->input_only)
6657 cairo_pattern_reference (pattern);
6658 if (window->background)
6659 cairo_pattern_destroy (window->background);
6660 window->background = pattern;
6664 if (pattern == NULL)
6666 /* parent-relative, copy has_alpha from parent */
6667 if (window->parent == NULL ||
6668 window->parent->window_type == GDK_WINDOW_ROOT)
6671 has_alpha = window->parent->has_alpha_background;
6675 type = cairo_pattern_get_type (pattern);
6677 if (type == CAIRO_PATTERN_TYPE_SOLID)
6680 cairo_pattern_get_rgba (pattern, NULL, NULL, NULL, &alpha);
6684 else if (type == CAIRO_PATTERN_TYPE_LINEAR ||
6685 type == CAIRO_PATTERN_TYPE_RADIAL)
6691 cairo_pattern_get_color_stop_count (pattern, &n);
6693 for (i = 0; i < n; i++)
6695 cairo_pattern_get_color_stop_rgba (pattern, i, NULL,
6696 NULL, NULL, NULL, &alpha);
6704 else if (type == CAIRO_PATTERN_TYPE_SURFACE)
6706 cairo_surface_t *surface;
6707 cairo_content_t content;
6709 cairo_pattern_get_surface (pattern, &surface);
6710 content = cairo_surface_get_content (surface);
6712 (content == CAIRO_CONTENT_ALPHA) ||
6713 (content == CAIRO_CONTENT_COLOR_ALPHA);
6717 if (has_alpha != window->has_alpha_background)
6719 window->has_alpha_background = has_alpha;
6720 recompute_visible_regions (window, TRUE, FALSE);
6722 _gdk_window_propagate_has_alpha_background (window);
6725 if (gdk_window_has_impl (window))
6727 GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6728 impl_class->set_background (window, pattern);
6731 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
6735 * gdk_window_get_background_pattern:
6738 * Gets the pattern used to clear the background on @window. If @window
6739 * does not have its own background and reuses the parent's, %NULL is
6740 * returned and you'll have to query it yourself.
6742 * Returns: (transfer none): The pattern to use for the background or
6743 * %NULL to use the parent's background.
6748 gdk_window_get_background_pattern (GdkWindow *window)
6750 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6752 return window->background;
6756 gdk_window_set_cursor_internal (GdkWindow *window,
6760 if (GDK_WINDOW_DESTROYED (window))
6763 if (window->window_type == GDK_WINDOW_ROOT ||
6764 window->window_type == GDK_WINDOW_FOREIGN)
6765 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_device_cursor (window, device, cursor);
6768 GdkPointerWindowInfo *pointer_info;
6769 GdkDisplay *display;
6771 display = gdk_window_get_display (window);
6772 pointer_info = _gdk_display_get_pointer_info (display, device);
6774 if (_gdk_window_event_parent_of (window, pointer_info->window_under_pointer))
6775 update_cursor (display, device);
6780 * gdk_window_get_cursor:
6781 * @window: a #GdkWindow
6783 * Retrieves a #GdkCursor pointer for the cursor currently set on the
6784 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6785 * there is no custom cursor set on the specified window, and it is
6786 * using the cursor for its parent window.
6788 * Return value: (transfer none): a #GdkCursor, or %NULL. The returned
6789 * object is owned by the #GdkWindow and should not be unreferenced
6790 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6796 gdk_window_get_cursor (GdkWindow *window)
6798 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6800 return window->cursor;
6804 * gdk_window_set_cursor:
6805 * @window: a #GdkWindow
6806 * @cursor: (allow-none): a cursor
6808 * Sets the default mouse pointer for a #GdkWindow. Use gdk_cursor_new_for_display()
6809 * or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor
6810 * invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument
6811 * to gdk_window_set_cursor() means that @window will use the cursor of its
6812 * parent window. Most windows should use this default.
6815 gdk_window_set_cursor (GdkWindow *window,
6818 GdkDisplay *display;
6820 g_return_if_fail (GDK_IS_WINDOW (window));
6822 display = gdk_window_get_display (window);
6826 g_object_unref (window->cursor);
6827 window->cursor = NULL;
6830 if (!GDK_WINDOW_DESTROYED (window))
6832 GdkDeviceManager *device_manager;
6836 window->cursor = g_object_ref (cursor);
6838 device_manager = gdk_display_get_device_manager (display);
6839 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
6841 for (d = devices; d; d = d->next)
6847 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
6850 gdk_window_set_cursor_internal (window, device, window->cursor);
6853 g_list_free (devices);
6854 g_object_notify (G_OBJECT (window), "cursor");
6859 * gdk_window_get_device_cursor:
6860 * @window: a #GdkWindow.
6861 * @device: a master, pointer #GdkDevice.
6863 * Retrieves a #GdkCursor pointer for the @device currently set on the
6864 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6865 * there is no custom cursor set on the specified window, and it is
6866 * using the cursor for its parent window.
6868 * Returns: (transfer none): a #GdkCursor, or %NULL. The returned
6869 * object is owned by the #GdkWindow and should not be unreferenced
6870 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6876 gdk_window_get_device_cursor (GdkWindow *window,
6879 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6880 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
6881 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
6882 g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, NULL);
6884 return g_hash_table_lookup (window->device_cursor, device);
6888 * gdk_window_set_device_cursor:
6889 * @window: a #Gdkwindow
6890 * @device: a master, pointer #GdkDevice
6891 * @cursor: a #GdkCursor
6893 * Sets a specific #GdkCursor for a given device when it gets inside @window.
6894 * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
6895 * the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
6896 * %NULL for the @cursor argument to gdk_window_set_cursor() means that
6897 * @window will use the cursor of its parent window. Most windows should
6903 gdk_window_set_device_cursor (GdkWindow *window,
6907 g_return_if_fail (GDK_IS_WINDOW (window));
6908 g_return_if_fail (GDK_IS_DEVICE (device));
6909 g_return_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD);
6910 g_return_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER);
6913 g_hash_table_remove (window->device_cursor, device);
6915 g_hash_table_replace (window->device_cursor, device, g_object_ref (cursor));
6917 gdk_window_set_cursor_internal (window, device, cursor);
6921 * gdk_window_get_geometry:
6922 * @window: a #GdkWindow
6923 * @x: (out) (allow-none): return location for X coordinate of window (relative to its parent)
6924 * @y: (out) (allow-none): return location for Y coordinate of window (relative to its parent)
6925 * @width: (out) (allow-none): return location for width of window
6926 * @height: (out) (allow-none): return location for height of window
6928 * Any of the return location arguments to this function may be %NULL,
6929 * if you aren't interested in getting the value of that field.
6931 * The X and Y coordinates returned are relative to the parent window
6932 * of @window, which for toplevels usually means relative to the
6933 * window decorations (titlebar, etc.) rather than relative to the
6934 * root window (screen-size background window).
6936 * On the X11 platform, the geometry is obtained from the X server,
6937 * so reflects the latest position of @window; this may be out-of-sync
6938 * with the position of @window delivered in the most-recently-processed
6939 * #GdkEventConfigure. gdk_window_get_position() in contrast gets the
6940 * position from the most recent configure event.
6943 * If @window is not a toplevel, it is <emphasis>much</emphasis> better
6944 * to call gdk_window_get_position(), gdk_window_get_width() and
6945 * gdk_window_get_height() instead, because it avoids the roundtrip to
6946 * the X server and because these functions support the full 32-bit
6947 * coordinate space, whereas gdk_window_get_geometry() is restricted to
6948 * the 16-bit coordinates of X11.
6952 gdk_window_get_geometry (GdkWindow *window,
6959 GdkWindowImplClass *impl_class;
6963 GDK_NOTE (MULTIHEAD,
6964 g_message ("gdk_window_get_geometry(): Window needs "
6965 "to be non-NULL to be multi head safe"));
6966 window = gdk_screen_get_root_window ((gdk_screen_get_default ()));
6969 g_return_if_fail (GDK_IS_WINDOW (window));
6971 if (!GDK_WINDOW_DESTROYED (window))
6973 if (gdk_window_has_impl (window))
6975 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6976 impl_class->get_geometry (window, x, y,
6978 /* This reports the position wrt to the native parent, we need to convert
6979 it to be relative to the client side parent */
6980 parent = window->parent;
6981 if (parent && !gdk_window_has_impl (parent))
6984 *x -= parent->abs_x;
6986 *y -= parent->abs_y;
6996 *width = window->width;
6998 *height = window->height;
7004 * gdk_window_get_width:
7005 * @window: a #GdkWindow
7007 * Returns the width of the given @window.
7009 * On the X11 platform the returned size is the size reported in the
7010 * most-recently-processed configure event, rather than the current
7011 * size on the X server.
7013 * Returns: The width of @window
7018 gdk_window_get_width (GdkWindow *window)
7020 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7022 return window->width;
7026 * gdk_window_get_height:
7027 * @window: a #GdkWindow
7029 * Returns the height of the given @window.
7031 * On the X11 platform the returned size is the size reported in the
7032 * most-recently-processed configure event, rather than the current
7033 * size on the X server.
7035 * Returns: The height of @window
7040 gdk_window_get_height (GdkWindow *window)
7042 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7044 return window->height;
7048 * gdk_window_get_origin:
7049 * @window: a #GdkWindow
7050 * @x: (out) (allow-none): return location for X coordinate
7051 * @y: (out) (allow-none): return location for Y coordinate
7053 * Obtains the position of a window in root window coordinates.
7054 * (Compare with gdk_window_get_position() and
7055 * gdk_window_get_geometry() which return the position of a window
7056 * relative to its parent window.)
7058 * Return value: not meaningful, ignore
7061 gdk_window_get_origin (GdkWindow *window,
7065 GdkWindowImplClass *impl_class;
7067 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
7069 if (GDK_WINDOW_DESTROYED (window))
7078 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7079 impl_class->get_root_coords (window,
7088 * gdk_window_get_root_coords:
7089 * @window: a #GdkWindow
7090 * @x: X coordinate in window
7091 * @y: Y coordinate in window
7092 * @root_x: (out): return location for X coordinate
7093 * @root_y: (out): return location for Y coordinate
7095 * Obtains the position of a window position in root
7096 * window coordinates. This is similar to
7097 * gdk_window_get_origin() but allows you go pass
7098 * in any position in the window, not just the origin.
7103 gdk_window_get_root_coords (GdkWindow *window,
7109 GdkWindowImplClass *impl_class;
7111 g_return_if_fail (GDK_IS_WINDOW (window));
7113 if (GDK_WINDOW_DESTROYED (window))
7120 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7121 impl_class->get_root_coords (window,
7128 * gdk_window_coords_to_parent:
7129 * @window: a child window
7130 * @x: X coordinate in child's coordinate system
7131 * @y: Y coordinate in child's coordinate system
7132 * @parent_x: (out) (allow-none): return location for X coordinate
7133 * in parent's coordinate system, or %NULL
7134 * @parent_y: (out) (allow-none): return location for Y coordinate
7135 * in parent's coordinate system, or %NULL
7137 * Transforms window coordinates from a child window to its parent
7138 * window, where the parent window is the normal parent as returned by
7139 * gdk_window_get_parent() for normal windows, and the window's
7140 * embedder as returned by gdk_offscreen_window_get_embedder() for
7141 * offscreen windows.
7143 * For normal windows, calling this function is equivalent to adding
7144 * the return values of gdk_window_get_position() to the child coordinates.
7145 * For offscreen windows however (which can be arbitrarily transformed),
7146 * this function calls the GdkWindow::to-embedder: signal to translate
7149 * You should always use this function when writing generic code that
7150 * walks up a window hierarchy.
7152 * See also: gdk_window_coords_from_parent()
7157 gdk_window_coords_to_parent (GdkWindow *window,
7163 g_return_if_fail (GDK_IS_WINDOW (window));
7165 if (gdk_window_is_offscreen (window))
7169 to_embedder (window, x, y, &px, &py);
7180 *parent_x = x + window->x;
7183 *parent_y = y + window->y;
7188 * gdk_window_coords_from_parent:
7189 * @window: a child window
7190 * @parent_x: X coordinate in parent's coordinate system
7191 * @parent_y: Y coordinate in parent's coordinate system
7192 * @x: (out) (allow-none): return location for X coordinate in child's coordinate system
7193 * @y: (out) (allow-none): return location for Y coordinate in child's coordinate system
7195 * Transforms window coordinates from a parent window to a child
7196 * window, where the parent window is the normal parent as returned by
7197 * gdk_window_get_parent() for normal windows, and the window's
7198 * embedder as returned by gdk_offscreen_window_get_embedder() for
7199 * offscreen windows.
7201 * For normal windows, calling this function is equivalent to subtracting
7202 * the return values of gdk_window_get_position() from the parent coordinates.
7203 * For offscreen windows however (which can be arbitrarily transformed),
7204 * this function calls the GdkWindow::from-embedder: signal to translate
7207 * You should always use this function when writing generic code that
7208 * walks down a window hierarchy.
7210 * See also: gdk_window_coords_to_parent()
7215 gdk_window_coords_from_parent (GdkWindow *window,
7221 g_return_if_fail (GDK_IS_WINDOW (window));
7223 if (gdk_window_is_offscreen (window))
7227 from_embedder (window, parent_x, parent_y, &cx, &cy);
7238 *x = parent_x - window->x;
7241 *y = parent_y - window->y;
7246 * gdk_window_shape_combine_region:
7247 * @window: a #GdkWindow
7248 * @shape_region: (allow-none): region of window to be non-transparent
7249 * @offset_x: X position of @shape_region in @window coordinates
7250 * @offset_y: Y position of @shape_region in @window coordinates
7252 * Makes pixels in @window outside @shape_region be transparent,
7253 * so that the window may be nonrectangular.
7255 * If @shape_region is %NULL, the shape will be unset, so the whole
7256 * window will be opaque again. @offset_x and @offset_y are ignored
7257 * if @shape_region is %NULL.
7259 * On the X11 platform, this uses an X server extension which is
7260 * widely available on most common platforms, but not available on
7261 * very old X servers, and occasionally the implementation will be
7262 * buggy. On servers without the shape extension, this function
7265 * This function works on both toplevel and child windows.
7268 gdk_window_shape_combine_region (GdkWindow *window,
7269 const cairo_region_t *shape_region,
7273 cairo_region_t *old_region, *new_region, *diff;
7275 g_return_if_fail (GDK_IS_WINDOW (window));
7277 if (GDK_WINDOW_DESTROYED (window))
7280 if (!window->shape && shape_region == NULL)
7283 window->shaped = (shape_region != NULL);
7286 cairo_region_destroy (window->shape);
7289 if (GDK_WINDOW_IS_MAPPED (window))
7290 old_region = cairo_region_copy (window->clip_region);
7294 window->shape = cairo_region_copy (shape_region);
7295 cairo_region_translate (window->shape, offset_x, offset_y);
7298 window->shape = NULL;
7300 recompute_visible_regions (window, TRUE, FALSE);
7302 if (gdk_window_has_impl (window) &&
7303 !should_apply_clip_as_shape (window))
7304 apply_shape (window, window->shape);
7308 new_region = cairo_region_copy (window->clip_region);
7310 /* New area in the window, needs invalidation */
7311 diff = cairo_region_copy (new_region);
7312 cairo_region_subtract (diff, old_region);
7314 gdk_window_invalidate_region_full (window, diff, TRUE, CLEAR_BG_ALL);
7316 cairo_region_destroy (diff);
7318 if (!gdk_window_is_toplevel (window))
7320 /* New area in the non-root parent window, needs invalidation */
7321 diff = cairo_region_copy (old_region);
7322 cairo_region_subtract (diff, new_region);
7324 /* Adjust region to parent window coords */
7325 cairo_region_translate (diff, window->x, window->y);
7327 gdk_window_invalidate_region_full (window->parent, diff, TRUE, CLEAR_BG_ALL);
7329 cairo_region_destroy (diff);
7332 cairo_region_destroy (new_region);
7333 cairo_region_destroy (old_region);
7338 do_child_shapes (GdkWindow *window,
7342 cairo_region_t *region;
7346 r.width = window->width;
7347 r.height = window->height;
7349 region = cairo_region_create_rectangle (&r);
7350 remove_child_area (window, NULL, FALSE, region, NULL);
7352 if (merge && window->shape)
7353 cairo_region_subtract (region, window->shape);
7355 gdk_window_shape_combine_region (window, region, 0, 0);
7359 * gdk_window_set_child_shapes:
7360 * @window: a #GdkWindow
7362 * Sets the shape mask of @window to the union of shape masks
7363 * for all children of @window, ignoring the shape mask of @window
7364 * itself. Contrast with gdk_window_merge_child_shapes() which includes
7365 * the shape mask of @window in the masks to be merged.
7368 gdk_window_set_child_shapes (GdkWindow *window)
7370 g_return_if_fail (GDK_IS_WINDOW (window));
7372 do_child_shapes (window, FALSE);
7376 * gdk_window_merge_child_shapes:
7377 * @window: a #GdkWindow
7379 * Merges the shape masks for any child windows into the
7380 * shape mask for @window. i.e. the union of all masks
7381 * for @window and its children will become the new mask
7382 * for @window. See gdk_window_shape_combine_region().
7384 * This function is distinct from gdk_window_set_child_shapes()
7385 * because it includes @window's shape mask in the set of shapes to
7389 gdk_window_merge_child_shapes (GdkWindow *window)
7391 g_return_if_fail (GDK_IS_WINDOW (window));
7393 do_child_shapes (window, TRUE);
7397 * gdk_window_input_shape_combine_region:
7398 * @window: a #GdkWindow
7399 * @shape_region: region of window to be non-transparent
7400 * @offset_x: X position of @shape_region in @window coordinates
7401 * @offset_y: Y position of @shape_region in @window coordinates
7403 * Like gdk_window_shape_combine_region(), but the shape applies
7404 * only to event handling. Mouse events which happen while
7405 * the pointer position corresponds to an unset bit in the
7406 * mask will be passed on the window below @window.
7408 * An input shape is typically used with RGBA windows.
7409 * The alpha channel of the window defines which pixels are
7410 * invisible and allows for nicely antialiased borders,
7411 * and the input shape controls where the window is
7414 * On the X11 platform, this requires version 1.1 of the
7417 * On the Win32 platform, this functionality is not present and the
7418 * function does nothing.
7423 gdk_window_input_shape_combine_region (GdkWindow *window,
7424 const cairo_region_t *shape_region,
7428 GdkWindowImplClass *impl_class;
7430 g_return_if_fail (GDK_IS_WINDOW (window));
7432 if (GDK_WINDOW_DESTROYED (window))
7435 if (window->input_shape)
7436 cairo_region_destroy (window->input_shape);
7440 window->input_shape = cairo_region_copy (shape_region);
7441 cairo_region_translate (window->input_shape, offset_x, offset_y);
7444 window->input_shape = NULL;
7446 if (gdk_window_has_impl (window))
7448 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7449 impl_class->input_shape_combine_region (window, window->input_shape, 0, 0);
7452 /* Pointer may have e.g. moved outside window due to the input mask change */
7453 _gdk_synthesize_crossing_events_for_geometry_change (window);
7457 do_child_input_shapes (GdkWindow *window,
7461 cairo_region_t *region;
7465 r.width = window->width;
7466 r.height = window->height;
7468 region = cairo_region_create_rectangle (&r);
7469 remove_child_area (window, NULL, TRUE, region, NULL);
7471 if (merge && window->shape)
7472 cairo_region_subtract (region, window->shape);
7473 if (merge && window->input_shape)
7474 cairo_region_subtract (region, window->input_shape);
7476 gdk_window_input_shape_combine_region (window, region, 0, 0);
7481 * gdk_window_set_child_input_shapes:
7482 * @window: a #GdkWindow
7484 * Sets the input shape mask of @window to the union of input shape masks
7485 * for all children of @window, ignoring the input shape mask of @window
7486 * itself. Contrast with gdk_window_merge_child_input_shapes() which includes
7487 * the input shape mask of @window in the masks to be merged.
7492 gdk_window_set_child_input_shapes (GdkWindow *window)
7494 g_return_if_fail (GDK_IS_WINDOW (window));
7496 do_child_input_shapes (window, FALSE);
7500 * gdk_window_merge_child_input_shapes:
7501 * @window: a #GdkWindow
7503 * Merges the input shape masks for any child windows into the
7504 * input shape mask for @window. i.e. the union of all input masks
7505 * for @window and its children will become the new input mask
7506 * for @window. See gdk_window_input_shape_combine_region().
7508 * This function is distinct from gdk_window_set_child_input_shapes()
7509 * because it includes @window's input shape mask in the set of
7510 * shapes to be merged.
7515 gdk_window_merge_child_input_shapes (GdkWindow *window)
7517 g_return_if_fail (GDK_IS_WINDOW (window));
7519 do_child_input_shapes (window, TRUE);
7524 * gdk_window_set_static_gravities:
7525 * @window: a #GdkWindow
7526 * @use_static: %TRUE to turn on static gravity
7528 * Set the bit gravity of the given window to static, and flag it so
7529 * all children get static subwindow gravity. This is used if you are
7530 * implementing scary features that involve deep knowledge of the
7531 * windowing system. Don't worry about it unless you have to.
7533 * Return value: %TRUE if the server supports static gravity
7536 gdk_window_set_static_gravities (GdkWindow *window,
7537 gboolean use_static)
7539 GdkWindowImplClass *impl_class;
7541 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7543 if (gdk_window_has_impl (window))
7545 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7546 return impl_class->set_static_gravities (window, use_static);
7553 * gdk_window_get_composited:
7554 * @window: a #GdkWindow
7556 * Determines whether @window is composited.
7558 * See gdk_window_set_composited().
7560 * Returns: %TRUE if the window is composited.
7565 gdk_window_get_composited (GdkWindow *window)
7567 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7569 return window->composited;
7573 * gdk_window_set_composited:
7574 * @window: a #GdkWindow
7575 * @composited: %TRUE to set the window as composited
7577 * Sets a #GdkWindow as composited, or unsets it. Composited
7578 * windows do not automatically have their contents drawn to
7579 * the screen. Drawing is redirected to an offscreen buffer
7580 * and an expose event is emitted on the parent of the composited
7581 * window. It is the responsibility of the parent's expose handler
7582 * to manually merge the off-screen content onto the screen in
7583 * whatever way it sees fit. See <xref linkend="composited-window-example"/>
7586 * It only makes sense for child windows to be composited; see
7587 * gdk_window_set_opacity() if you need translucent toplevel
7590 * An additional effect of this call is that the area of this
7591 * window is no longer clipped from regions marked for
7592 * invalidation on its parent. Draws done on the parent
7593 * window are also no longer clipped by the child.
7595 * This call is only supported on some systems (currently,
7596 * only X11 with new enough Xcomposite and Xdamage extensions).
7597 * You must call gdk_display_supports_composite() to check if
7598 * setting a window as composited is supported before
7599 * attempting to do so.
7604 gdk_window_set_composited (GdkWindow *window,
7605 gboolean composited)
7607 GdkDisplay *display;
7608 GdkWindowImplClass *impl_class;
7610 g_return_if_fail (GDK_IS_WINDOW (window));
7612 composited = composited != FALSE;
7614 if (window->composited == composited)
7618 gdk_window_ensure_native (window);
7620 display = gdk_window_get_display (window);
7622 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7624 if (composited && (!gdk_display_supports_composite (display) || !impl_class->set_composited))
7626 g_warning ("gdk_window_set_composited called but "
7627 "compositing is not supported");
7631 impl_class->set_composited (window, composited);
7633 recompute_visible_regions (window, TRUE, FALSE);
7635 if (GDK_WINDOW_IS_MAPPED (window))
7636 gdk_window_invalidate_in_parent (window);
7638 window->composited = composited;
7642 * gdk_window_get_modal_hint:
7643 * @window: A toplevel #GdkWindow.
7645 * Determines whether or not the window manager is hinted that @window
7646 * has modal behaviour.
7648 * Return value: whether or not the window has the modal hint set.
7653 gdk_window_get_modal_hint (GdkWindow *window)
7655 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7657 return window->modal_hint;
7661 * gdk_window_get_accept_focus:
7662 * @window: a toplevel #GdkWindow.
7664 * Determines whether or not the desktop environment shuld be hinted that
7665 * the window does not want to receive input focus.
7667 * Return value: whether or not the window should receive input focus.
7672 gdk_window_get_accept_focus (GdkWindow *window)
7674 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7676 return window->accept_focus;
7680 * gdk_window_get_focus_on_map:
7681 * @window: a toplevel #GdkWindow.
7683 * Determines whether or not the desktop environment should be hinted that the
7684 * window does not want to receive input focus when it is mapped.
7686 * Return value: whether or not the window wants to receive input focus when
7692 gdk_window_get_focus_on_map (GdkWindow *window)
7694 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7696 return window->focus_on_map;
7700 * gdk_window_is_input_only:
7701 * @window: a toplevel #GdkWindow
7703 * Determines whether or not the window is an input only window.
7705 * Return value: %TRUE if @window is input only
7710 gdk_window_is_input_only (GdkWindow *window)
7712 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7714 return window->input_only;
7718 * gdk_window_is_shaped:
7719 * @window: a toplevel #GdkWindow
7721 * Determines whether or not the window is shaped.
7723 * Return value: %TRUE if @window is shaped
7728 gdk_window_is_shaped (GdkWindow *window)
7730 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7732 return window->shaped;
7736 _gdk_window_add_damage (GdkWindow *toplevel,
7737 cairo_region_t *damaged_region)
7739 GdkDisplay *display;
7740 GdkEvent event = { 0, };
7741 event.expose.type = GDK_DAMAGE;
7742 event.expose.window = toplevel;
7743 event.expose.send_event = FALSE;
7744 event.expose.region = damaged_region;
7745 cairo_region_get_extents (event.expose.region, &event.expose.area);
7746 display = gdk_window_get_display (event.expose.window);
7747 _gdk_event_queue_append (display, gdk_event_copy (&event));
7750 /* Gets the toplevel for a window as used for events,
7751 i.e. including offscreen parents */
7753 get_event_parent (GdkWindow *window)
7755 if (gdk_window_is_offscreen (window))
7756 return gdk_offscreen_window_get_embedder ((GdkWindow *)window);
7758 return window->parent;
7761 /* Gets the toplevel for a window as used for events,
7762 i.e. including offscreen parents going up to the native
7765 get_event_toplevel (GdkWindow *window)
7769 while ((parent = get_event_parent (window)) != NULL &&
7770 (parent->window_type != GDK_WINDOW_ROOT))
7777 _gdk_window_event_parent_of (GdkWindow *parent,
7788 w = get_event_parent (w);
7795 update_cursor (GdkDisplay *display,
7798 GdkWindow *cursor_window, *parent, *toplevel;
7799 GdkWindow *pointer_window;
7800 GdkWindowImplClass *impl_class;
7801 GdkPointerWindowInfo *pointer_info;
7802 GdkDeviceGrabInfo *grab;
7805 pointer_info = _gdk_display_get_pointer_info (display, device);
7806 pointer_window = pointer_info->window_under_pointer;
7808 /* We ignore the serials here and just pick the last grab
7809 we've sent, as that would shortly be used anyway. */
7810 grab = _gdk_display_get_last_device_grab (display, device);
7813 /* the pointer is not in a descendant of the grab window */
7814 !_gdk_window_event_parent_of (grab->window, pointer_window))
7816 /* use the cursor from the grab window */
7817 cursor_window = grab->window;
7821 /* otherwise use the cursor from the pointer window */
7822 cursor_window = pointer_window;
7825 /* Find the first window with the cursor actually set, as
7826 the cursor is inherited from the parent */
7827 while (cursor_window->cursor == NULL &&
7828 (parent = get_event_parent (cursor_window)) != NULL &&
7829 parent->window_type != GDK_WINDOW_ROOT)
7830 cursor_window = parent;
7832 cursor = g_hash_table_lookup (cursor_window->device_cursor, device);
7835 cursor = cursor_window->cursor;
7837 /* Set all cursors on toplevel, otherwise its tricky to keep track of
7838 * which native window has what cursor set. */
7839 toplevel = get_event_toplevel (pointer_window);
7840 impl_class = GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl);
7841 impl_class->set_device_cursor (toplevel, device, cursor);
7845 point_in_window (GdkWindow *window,
7850 x >= 0 && x < window->width &&
7851 y >= 0 && y < window->height &&
7852 (window->shape == NULL ||
7853 cairo_region_contains_point (window->shape,
7855 (window->input_shape == NULL ||
7856 cairo_region_contains_point (window->input_shape,
7861 convert_native_coords_to_toplevel (GdkWindow *window,
7864 gdouble *toplevel_x,
7865 gdouble *toplevel_y)
7872 while (!gdk_window_is_toplevel (window))
7876 window = window->parent;
7886 convert_toplevel_coords_to_window (GdkWindow *window,
7894 GList *children, *l;
7900 while ((parent = get_event_parent (window)) != NULL &&
7901 (parent->window_type != GDK_WINDOW_ROOT))
7903 children = g_list_prepend (children, window);
7907 for (l = children; l != NULL; l = l->next)
7908 gdk_window_coords_from_parent (l->data, x, y, &x, &y);
7910 g_list_free (children);
7917 pick_embedded_child (GdkWindow *window,
7924 g_signal_emit (window,
7925 signals[PICK_EMBEDDED_CHILD], 0,
7932 _gdk_window_find_child_at (GdkWindow *window,
7937 double child_x, child_y;
7940 if (point_in_window (window, x, y))
7942 /* Children is ordered in reverse stack order, i.e. first is topmost */
7943 for (l = window->children; l != NULL; l = l->next)
7947 if (!GDK_WINDOW_IS_MAPPED (sub))
7950 gdk_window_coords_from_parent ((GdkWindow *)sub,
7952 &child_x, &child_y);
7953 if (point_in_window (sub, child_x, child_y))
7954 return (GdkWindow *)sub;
7957 if (window->num_offscreen_children > 0)
7959 sub = pick_embedded_child (window,
7962 return (GdkWindow *)sub;
7970 _gdk_window_find_descendant_at (GdkWindow *window,
7977 gdouble child_x, child_y;
7981 if (point_in_window (window, x, y))
7986 /* Children is ordered in reverse stack order, i.e. first is topmost */
7987 for (l = window->children; l != NULL; l = l->next)
7991 if (!GDK_WINDOW_IS_MAPPED (sub))
7994 gdk_window_coords_from_parent ((GdkWindow *)sub,
7996 &child_x, &child_y);
7997 if (point_in_window (sub, child_x, child_y))
8007 window->num_offscreen_children > 0)
8009 sub = pick_embedded_child (window,
8015 from_embedder (sub, x, y, &x, &y);
8023 /* Not in window at all */
8037 * @window: a toplevel #GdkWindow
8039 * Emits a short beep associated to @window in the appropriate
8040 * display, if supported. Otherwise, emits a short beep on
8041 * the display just as gdk_display_beep().
8046 gdk_window_beep (GdkWindow *window)
8048 GdkDisplay *display;
8049 GdkWindow *toplevel;
8051 g_return_if_fail (GDK_IS_WINDOW (window));
8053 if (GDK_WINDOW_DESTROYED (window))
8056 toplevel = get_event_toplevel (window);
8057 display = gdk_window_get_display (window);
8061 if (GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)->beep (toplevel))
8065 /* If windows fail to beep, we beep the display. */
8066 gdk_display_beep (display);
8070 * gdk_window_set_support_multidevice:
8071 * @window: a #GdkWindow.
8072 * @support_multidevice: %TRUE to enable multidevice support in @window.
8074 * This function will enable multidevice features in @window.
8076 * Multidevice aware windows will need to handle properly multiple,
8077 * per device enter/leave events, device grabs and grab ownerships.
8082 gdk_window_set_support_multidevice (GdkWindow *window,
8083 gboolean support_multidevice)
8085 g_return_if_fail (GDK_IS_WINDOW (window));
8087 if (GDK_WINDOW_DESTROYED (window))
8090 if (window->support_multidevice == support_multidevice)
8093 window->support_multidevice = support_multidevice;
8095 /* FIXME: What to do if called when some pointers are inside the window ? */
8099 * gdk_window_get_support_multidevice:
8100 * @window: a #GdkWindow.
8102 * Returns %TRUE if the window is aware of the existence of multiple
8105 * Returns: %TRUE if the window handles multidevice features.
8110 gdk_window_get_support_multidevice (GdkWindow *window)
8112 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
8114 if (GDK_WINDOW_DESTROYED (window))
8117 return window->support_multidevice;
8120 static const guint type_masks[] = {
8121 GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE = 0 */
8122 GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1 */
8123 GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2 */
8124 GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3 */
8125 GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4 */
8126 GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5 */
8127 GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6 */
8128 GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE = 7 */
8129 GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS = 8 */
8130 GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE = 9 */
8131 GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY = 10 */
8132 GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY = 11 */
8133 GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE = 12 */
8134 GDK_STRUCTURE_MASK, /* GDK_CONFIGURE = 13 */
8135 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_MAP = 14 */
8136 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_UNMAP = 15 */
8137 GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY = 16 */
8138 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR = 17 */
8139 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18 */
8140 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY = 19 */
8141 GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN = 20 */
8142 GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT = 21 */
8143 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER = 22 */
8144 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE = 23 */
8145 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION = 24 */
8146 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS = 25 */
8147 GDK_ALL_EVENTS_MASK, /* GDK_DROP_START = 26 */
8148 GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED = 27 */
8149 GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT = 28 */
8150 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_VISIBILITY_NOTIFY = 29 */
8151 GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30 */
8152 GDK_SCROLL_MASK | GDK_SMOOTH_SCROLL_MASK,/* GDK_SCROLL= 31 */
8153 0, /* GDK_WINDOW_STATE = 32 */
8154 0, /* GDK_SETTING = 33 */
8155 0, /* GDK_OWNER_CHANGE = 34 */
8156 0, /* GDK_GRAB_BROKEN = 35 */
8157 0, /* GDK_DAMAGE = 36 */
8158 GDK_TOUCH_MASK, /* GDK_TOUCH_BEGIN = 37 */
8159 GDK_TOUCH_MASK, /* GDK_TOUCH_UPDATE = 38 */
8160 GDK_TOUCH_MASK, /* GDK_TOUCH_END = 39 */
8161 GDK_TOUCH_MASK /* GDK_TOUCH_CANCEL = 40 */
8163 G_STATIC_ASSERT (G_N_ELEMENTS (type_masks) == GDK_EVENT_LAST);
8165 /* send motion events if the right buttons are down */
8167 update_evmask_for_button_motion (guint evmask,
8168 GdkModifierType mask)
8170 if (evmask & GDK_BUTTON_MOTION_MASK &&
8171 mask & (GDK_BUTTON1_MASK |
8176 evmask |= GDK_POINTER_MOTION_MASK;
8178 if ((evmask & GDK_BUTTON1_MOTION_MASK && mask & GDK_BUTTON1_MASK) ||
8179 (evmask & GDK_BUTTON2_MOTION_MASK && mask & GDK_BUTTON2_MASK) ||
8180 (evmask & GDK_BUTTON3_MOTION_MASK && mask & GDK_BUTTON3_MASK))
8181 evmask |= GDK_POINTER_MOTION_MASK;
8187 is_button_type (GdkEventType type)
8189 return type == GDK_BUTTON_PRESS ||
8190 type == GDK_2BUTTON_PRESS ||
8191 type == GDK_3BUTTON_PRESS ||
8192 type == GDK_BUTTON_RELEASE ||
8193 type == GDK_TOUCH_BEGIN ||
8194 type == GDK_TOUCH_END ||
8199 is_motion_type (GdkEventType type)
8201 return type == GDK_MOTION_NOTIFY ||
8202 type == GDK_TOUCH_UPDATE ||
8203 type == GDK_ENTER_NOTIFY ||
8204 type == GDK_LEAVE_NOTIFY;
8208 is_touch_type (GdkEventType type)
8210 return type == GDK_TOUCH_BEGIN ||
8211 type == GDK_TOUCH_UPDATE ||
8212 type == GDK_TOUCH_END ||
8213 type == GDK_TOUCH_CANCEL;
8217 find_common_ancestor (GdkWindow *win1,
8221 GList *path1 = NULL, *path2 = NULL;
8222 GList *list1, *list2;
8225 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8227 path1 = g_list_prepend (path1, tmp);
8228 tmp = get_event_parent (tmp);
8232 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8234 path2 = g_list_prepend (path2, tmp);
8235 tmp = get_event_parent (tmp);
8241 while (list1 && list2 && (list1->data == list2->data))
8244 list1 = g_list_next (list1);
8245 list2 = g_list_next (list2);
8247 g_list_free (path1);
8248 g_list_free (path2);
8254 _gdk_make_event (GdkWindow *window,
8256 GdkEvent *event_in_queue,
8257 gboolean before_event)
8259 GdkEvent *event = gdk_event_new (type);
8261 GdkModifierType the_state;
8263 the_time = gdk_event_get_time (event_in_queue);
8264 gdk_event_get_state (event_in_queue, &the_state);
8266 event->any.window = g_object_ref (window);
8267 event->any.send_event = FALSE;
8268 if (event_in_queue && event_in_queue->any.send_event)
8269 event->any.send_event = TRUE;
8273 case GDK_MOTION_NOTIFY:
8274 event->motion.time = the_time;
8275 event->motion.axes = NULL;
8276 event->motion.state = the_state;
8279 case GDK_BUTTON_PRESS:
8280 case GDK_2BUTTON_PRESS:
8281 case GDK_3BUTTON_PRESS:
8282 case GDK_BUTTON_RELEASE:
8283 event->button.time = the_time;
8284 event->button.axes = NULL;
8285 event->button.state = the_state;
8288 case GDK_TOUCH_BEGIN:
8289 case GDK_TOUCH_UPDATE:
8291 case GDK_TOUCH_CANCEL:
8292 event->touch.time = the_time;
8293 event->touch.axes = NULL;
8294 event->touch.state = the_state;
8298 event->scroll.time = the_time;
8299 event->scroll.state = the_state;
8303 case GDK_KEY_RELEASE:
8304 event->key.time = the_time;
8305 event->key.state = the_state;
8308 case GDK_ENTER_NOTIFY:
8309 case GDK_LEAVE_NOTIFY:
8310 event->crossing.time = the_time;
8311 event->crossing.state = the_state;
8314 case GDK_PROPERTY_NOTIFY:
8315 event->property.time = the_time;
8316 event->property.state = the_state;
8319 case GDK_SELECTION_CLEAR:
8320 case GDK_SELECTION_REQUEST:
8321 case GDK_SELECTION_NOTIFY:
8322 event->selection.time = the_time;
8325 case GDK_PROXIMITY_IN:
8326 case GDK_PROXIMITY_OUT:
8327 event->proximity.time = the_time;
8330 case GDK_DRAG_ENTER:
8331 case GDK_DRAG_LEAVE:
8332 case GDK_DRAG_MOTION:
8333 case GDK_DRAG_STATUS:
8334 case GDK_DROP_START:
8335 case GDK_DROP_FINISHED:
8336 event->dnd.time = the_time;
8339 case GDK_FOCUS_CHANGE:
8343 case GDK_CLIENT_EVENT:
8344 case GDK_VISIBILITY_NOTIFY:
8355 _gdk_event_queue_insert_before (gdk_window_get_display (window), event_in_queue, event);
8357 _gdk_event_queue_insert_after (gdk_window_get_display (window), event_in_queue, event);
8360 _gdk_event_queue_append (gdk_window_get_display (window), event);
8366 send_crossing_event (GdkDisplay *display,
8367 GdkWindow *toplevel,
8370 GdkCrossingMode mode,
8371 GdkNotifyType notify_type,
8372 GdkWindow *subwindow,
8374 GdkDevice *source_device,
8377 GdkModifierType mask,
8379 GdkEvent *event_in_queue,
8383 guint32 window_event_mask, type_event_mask;
8384 GdkDeviceGrabInfo *grab;
8385 GdkTouchGrabInfo *touch_grab = NULL;
8386 GdkPointerWindowInfo *pointer_info;
8387 gboolean block_event = FALSE;
8388 GdkEventSequence *sequence;
8390 grab = _gdk_display_has_device_grab (display, device, serial);
8391 pointer_info = _gdk_display_get_pointer_info (display, device);
8393 sequence = gdk_event_get_event_sequence (event_in_queue);
8395 touch_grab = _gdk_display_has_touch_grab (display, device, sequence, serial);
8399 if (window != touch_grab->window)
8402 window_event_mask = touch_grab->event_mask;
8404 else if (grab != NULL &&
8405 !grab->owner_events)
8407 /* !owner_event => only report events wrt grab window, ignore rest */
8408 if ((GdkWindow *)window != grab->window)
8410 window_event_mask = grab->event_mask;
8413 window_event_mask = window->event_mask;
8415 if (type == GDK_ENTER_NOTIFY &&
8416 pointer_info->need_touch_press_enter &&
8417 mode != GDK_CROSSING_TOUCH_BEGIN &&
8418 mode != GDK_CROSSING_TOUCH_END)
8422 else if (type == GDK_LEAVE_NOTIFY)
8424 type_event_mask = GDK_LEAVE_NOTIFY_MASK;
8425 window->devices_inside = g_list_remove (window->devices_inside, device);
8427 if (!window->support_multidevice && window->devices_inside)
8429 /* Block leave events unless it's the last pointer */
8435 type_event_mask = GDK_ENTER_NOTIFY_MASK;
8437 if (!window->support_multidevice && window->devices_inside)
8439 /* Only emit enter events for the first device */
8443 if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER &&
8444 gdk_device_get_mode (device) != GDK_MODE_DISABLED &&
8445 !g_list_find (window->devices_inside, device))
8446 window->devices_inside = g_list_prepend (window->devices_inside, device);
8452 if (window_event_mask & type_event_mask)
8454 event = _gdk_make_event ((GdkWindow *)window, type, event_in_queue, TRUE);
8455 gdk_event_set_device (event, device);
8458 gdk_event_set_source_device (event, source_device);
8460 event->crossing.time = time_;
8461 event->crossing.subwindow = subwindow;
8463 g_object_ref (subwindow);
8464 convert_toplevel_coords_to_window ((GdkWindow *)window,
8465 toplevel_x, toplevel_y,
8466 &event->crossing.x, &event->crossing.y);
8467 event->crossing.x_root = toplevel_x + toplevel->x;
8468 event->crossing.y_root = toplevel_y + toplevel->y;
8469 event->crossing.mode = mode;
8470 event->crossing.detail = notify_type;
8471 event->crossing.focus = FALSE;
8472 event->crossing.state = mask;
8477 /* The coordinates are in the toplevel window that src/dest are in.
8478 * src and dest are always (if != NULL) in the same toplevel, as
8479 * we get a leave-notify and set the window_under_pointer to null
8480 * before crossing to another toplevel.
8483 _gdk_synthesize_crossing_events (GdkDisplay *display,
8487 GdkDevice *source_device,
8488 GdkCrossingMode mode,
8491 GdkModifierType mask,
8493 GdkEvent *event_in_queue,
8495 gboolean non_linear)
8498 GdkWindow *win, *last, *next;
8502 GdkWindow *toplevel;
8503 GdkNotifyType notify_type;
8505 /* TODO: Don't send events to toplevel, as we get those from the windowing system */
8510 return; /* No crossings generated between src and dest */
8512 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER)
8514 if (a && gdk_window_get_device_events (src, device) == 0)
8517 if (b && gdk_window_get_device_events (dest, device) == 0)
8524 c = find_common_ancestor (a, b);
8526 non_linear |= (c != a) && (c != b);
8528 if (a) /* There might not be a source (i.e. if no previous pointer_in_window) */
8530 toplevel = gdk_window_get_toplevel (a);
8532 /* Traverse up from a to (excluding) c sending leave events */
8534 notify_type = GDK_NOTIFY_NONLINEAR;
8536 notify_type = GDK_NOTIFY_INFERIOR;
8538 notify_type = GDK_NOTIFY_ANCESTOR;
8539 send_crossing_event (display, toplevel,
8540 a, GDK_LEAVE_NOTIFY,
8543 NULL, device, source_device,
8544 toplevel_x, toplevel_y,
8552 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8554 notify_type = GDK_NOTIFY_VIRTUAL;
8557 win = get_event_parent (a);
8558 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8560 send_crossing_event (display, toplevel,
8561 win, GDK_LEAVE_NOTIFY,
8565 device, source_device,
8566 toplevel_x, toplevel_y,
8572 win = get_event_parent (win);
8577 if (b) /* Might not be a dest, e.g. if we're moving out of the window */
8579 toplevel = gdk_window_get_toplevel ((GdkWindow *)b);
8581 /* Traverse down from c to b */
8585 win = get_event_parent (b);
8586 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8588 path = g_list_prepend (path, win);
8589 win = get_event_parent (win);
8593 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8595 notify_type = GDK_NOTIFY_VIRTUAL;
8601 list = g_list_next (list);
8607 send_crossing_event (display, toplevel,
8608 win, GDK_ENTER_NOTIFY,
8612 device, source_device,
8613 toplevel_x, toplevel_y,
8623 notify_type = GDK_NOTIFY_NONLINEAR;
8625 notify_type = GDK_NOTIFY_ANCESTOR;
8627 notify_type = GDK_NOTIFY_INFERIOR;
8629 send_crossing_event (display, toplevel,
8630 b, GDK_ENTER_NOTIFY,
8634 device, source_device,
8635 toplevel_x, toplevel_y,
8642 /* Returns the window inside the event window with the pointer in it
8643 * at the specified coordinates, or NULL if its not in any child of
8644 * the toplevel. It also takes into account !owner_events grabs.
8647 get_pointer_window (GdkDisplay *display,
8648 GdkWindow *event_window,
8654 GdkWindow *pointer_window;
8655 GdkDeviceGrabInfo *grab;
8656 GdkPointerWindowInfo *pointer_info;
8658 pointer_info = _gdk_display_get_pointer_info (display, device);
8660 if (event_window == pointer_info->toplevel_under_pointer)
8662 _gdk_window_find_descendant_at (event_window,
8663 toplevel_x, toplevel_y,
8666 pointer_window = NULL;
8668 grab = _gdk_display_has_device_grab (display, device, serial);
8670 !grab->owner_events &&
8671 pointer_window != grab->window)
8672 pointer_window = NULL;
8674 return pointer_window;
8678 _gdk_display_set_window_under_pointer (GdkDisplay *display,
8682 GdkPointerWindowInfo *device_info;
8684 device_info = _gdk_display_get_pointer_info (display, device);
8686 if (device_info->window_under_pointer)
8687 g_object_unref (device_info->window_under_pointer);
8688 device_info->window_under_pointer = window;
8692 g_object_ref (window);
8693 update_cursor (display, device);
8696 _gdk_display_enable_motion_hints (display, device);
8701 * @window: the #GdkWindow which will own the grab (the grab window).
8702 * @owner_events: if %FALSE then all pointer events are reported with respect to
8703 * @window and are only reported if selected by @event_mask. If %TRUE then pointer
8704 * events for this application are reported as normal, but pointer events outside
8705 * this application are reported with respect to @window and only if selected by
8706 * @event_mask. In either mode, unreported events are discarded.
8707 * @event_mask: specifies the event mask, which is used in accordance with
8708 * @owner_events. Note that only pointer events (i.e. button and motion events)
8710 * @confine_to: (allow-none): If non-%NULL, the pointer will be confined to this
8711 * window during the grab. If the pointer is outside @confine_to, it will
8712 * automatically be moved to the closest edge of @confine_to and enter
8713 * and leave events will be generated as necessary.
8714 * @cursor: (allow-none): the cursor to display while the grab is active. If this is %NULL then
8715 * the normal cursors are used for @window and its descendants, and the cursor
8716 * for @window is used for all other windows.
8717 * @time_: the timestamp of the event which led to this pointer grab. This usually
8718 * comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if
8719 * the time isn't known.
8721 * Grabs the pointer (usually a mouse) so that all events are passed to this
8722 * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
8723 * the grab window becomes unviewable.
8724 * This overrides any previous pointer grab by this client.
8726 * Pointer grabs are used for operations which need complete control over mouse
8727 * events, even if the mouse leaves the application.
8728 * For example in GTK+ it is used for Drag and Drop, for dragging the handle in
8729 * the #GtkHPaned and #GtkVPaned widgets.
8731 * Note that if the event mask of an X window has selected both button press and
8732 * button release events, then a button press event will cause an automatic
8733 * pointer grab until the button is released.
8734 * X does this automatically since most applications expect to receive button
8735 * press and release events in pairs.
8736 * It is equivalent to a pointer grab on the window with @owner_events set to
8739 * If you set up anything at the time you take the grab that needs to be cleaned
8740 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8741 * are emitted when the grab ends unvoluntarily.
8743 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8745 * Deprecated: 3.0: Use gdk_device_grab() instead.
8748 gdk_pointer_grab (GdkWindow * window,
8749 gboolean owner_events,
8750 GdkEventMask event_mask,
8751 GdkWindow * confine_to,
8756 GdkDisplay *display;
8757 GdkDeviceManager *device_manager;
8759 GdkGrabStatus res = 0;
8761 GList *devices, *dev;
8763 g_return_val_if_fail (window != NULL, 0);
8764 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8765 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
8767 /* We need a native window for confine to to work, ensure we have one */
8770 if (!gdk_window_ensure_native (confine_to))
8772 g_warning ("Can't confine to grabbed window, not native");
8777 /* Non-viewable client side window => fail */
8778 if (!_gdk_window_has_impl (window) &&
8779 !gdk_window_is_viewable (window))
8780 return GDK_GRAB_NOT_VIEWABLE;
8782 native = gdk_window_get_toplevel (window);
8783 while (gdk_window_is_offscreen (native))
8785 native = gdk_offscreen_window_get_embedder (native);
8787 if (native == NULL ||
8788 (!_gdk_window_has_impl (native) &&
8789 !gdk_window_is_viewable (native)))
8790 return GDK_GRAB_NOT_VIEWABLE;
8792 native = gdk_window_get_toplevel (native);
8795 display = gdk_window_get_display (window);
8797 serial = _gdk_display_get_next_serial (display);
8798 device_manager = gdk_display_get_device_manager (display);
8799 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8801 /* FIXME: Should this be generic to all backends? */
8802 /* FIXME: What happens with extended devices? */
8803 for (dev = devices; dev; dev = dev->next)
8807 if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
8810 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8813 get_native_grab_event_mask (event_mask),
8818 if (res == GDK_GRAB_SUCCESS)
8819 _gdk_display_add_device_grab (display,
8831 /* FIXME: handle errors when grabbing */
8833 g_list_free (devices);
8839 * gdk_keyboard_grab:
8840 * @window: the #GdkWindow which will own the grab (the grab window).
8841 * @owner_events: if %FALSE then all keyboard events are reported with respect to
8842 * @window. If %TRUE then keyboard events for this application are
8843 * reported as normal, but keyboard events outside this application
8844 * are reported with respect to @window. Both key press and key
8845 * release events are always reported, independant of the event mask
8846 * set by the application.
8847 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is
8850 * Grabs the keyboard so that all events are passed to this
8851 * application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
8852 * This overrides any previous keyboard grab by this client.
8854 * If you set up anything at the time you take the grab that needs to be cleaned
8855 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8856 * are emitted when the grab ends unvoluntarily.
8858 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8860 * Deprecated: 3.0: Use gdk_device_grab() instead.
8863 gdk_keyboard_grab (GdkWindow *window,
8864 gboolean owner_events,
8868 GdkDisplay *display;
8869 GdkDeviceManager *device_manager;
8871 GdkGrabStatus res = 0;
8873 GList *devices, *dev;
8875 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8877 /* Non-viewable client side window => fail */
8878 if (!_gdk_window_has_impl (window) &&
8879 !gdk_window_is_viewable (window))
8880 return GDK_GRAB_NOT_VIEWABLE;
8882 native = gdk_window_get_toplevel (window);
8884 while (gdk_window_is_offscreen (native))
8886 native = gdk_offscreen_window_get_embedder (native);
8888 if (native == NULL ||
8889 (!_gdk_window_has_impl (native) &&
8890 !gdk_window_is_viewable (native)))
8891 return GDK_GRAB_NOT_VIEWABLE;
8893 native = gdk_window_get_toplevel (native);
8896 display = gdk_window_get_display (window);
8897 serial = _gdk_display_get_next_serial (display);
8898 device_manager = gdk_display_get_device_manager (display);
8899 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8901 /* FIXME: Should this be generic to all backends? */
8902 /* FIXME: What happens with extended devices? */
8903 for (dev = devices; dev; dev = dev->next)
8907 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
8910 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8913 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
8918 if (res == GDK_GRAB_SUCCESS)
8919 _gdk_display_add_device_grab (display,
8930 /* FIXME: handle errors when grabbing */
8932 g_list_free (devices);
8938 * gdk_window_geometry_changed:
8939 * @window: an embedded offscreen #GdkWindow
8941 * This function informs GDK that the geometry of an embedded
8942 * offscreen window has changed. This is necessary for GDK to keep
8943 * track of which offscreen window the pointer is in.
8948 gdk_window_geometry_changed (GdkWindow *window)
8950 _gdk_synthesize_crossing_events_for_geometry_change (window);
8954 source_events_device_added (GdkDeviceManager *device_manager,
8959 GdkEventMask event_mask;
8960 GdkInputSource source;
8962 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_FLOATING)
8966 source = gdk_device_get_source (device);
8968 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8969 GINT_TO_POINTER (source)));
8971 gdk_window_set_device_events (window, device, event_mask);
8975 source_events_device_changed (GdkDeviceManager *device_manager,
8980 GdkInputSource source;
8981 GdkEventMask event_mask;
8985 type = gdk_device_get_device_type (device);
8986 source = gdk_device_get_source (device);
8988 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8989 GINT_TO_POINTER (source)));
8994 if (type == GDK_DEVICE_TYPE_FLOATING)
8996 /* The device was just floated, enable its event mask */
8997 gdk_window_set_device_events (window, device, event_mask);
8999 else if (type == GDK_DEVICE_TYPE_SLAVE)
9000 gdk_window_set_device_events (window, device, 0);
9004 * gdk_window_set_source_events:
9005 * @window: a #GdkWindow
9006 * @source: a #GdkInputSource to define the source class.
9007 * @event_mask: event mask for @window
9009 * Sets the event mask for any floating device (i.e. not attached to any
9010 * visible pointer) that has the source defined as @source. This event
9011 * mask will be applied both to currently existing, newly added devices
9012 * after this call, and devices being attached/detached.
9017 gdk_window_set_source_events (GdkWindow *window,
9018 GdkInputSource source,
9019 GdkEventMask event_mask)
9021 GdkDeviceManager *device_manager;
9022 GdkDisplay *display;
9026 g_return_if_fail (GDK_IS_WINDOW (window));
9028 display = gdk_window_get_display (window);
9029 device_manager = gdk_display_get_device_manager (display);
9031 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
9033 /* Set event mask for existing devices */
9034 for (d = devices; d; d = d->next)
9036 GdkDevice *device = d->data;
9038 if (source == gdk_device_get_source (device))
9039 gdk_window_set_device_events (window, device, event_mask);
9042 g_list_free (devices);
9044 /* Update accounting */
9045 if (G_UNLIKELY (!window->source_event_masks))
9046 window->source_event_masks = g_hash_table_new (NULL, NULL);
9049 g_hash_table_insert (window->source_event_masks,
9050 GUINT_TO_POINTER (source),
9051 GUINT_TO_POINTER (event_mask));
9053 g_hash_table_remove (window->source_event_masks,
9054 GUINT_TO_POINTER (source));
9056 size = g_hash_table_size (window->source_event_masks);
9058 /* Update handler if needed */
9059 if (!window->device_added_handler_id && size > 0)
9061 window->device_added_handler_id =
9062 g_signal_connect (device_manager, "device-added",
9063 G_CALLBACK (source_events_device_added), window);
9064 window->device_changed_handler_id =
9065 g_signal_connect (device_manager, "device-changed",
9066 G_CALLBACK (source_events_device_changed), window);
9068 else if (window->device_added_handler_id && size == 0)
9069 g_signal_handler_disconnect (device_manager, window->device_added_handler_id);
9073 * gdk_window_get_source_events:
9074 * @window: a #GdkWindow
9075 * @source: a #GdkInputSource to define the source class.
9077 * Returns the event mask for @window corresponding to the device class specified
9080 * Returns: source event mask for @window
9083 gdk_window_get_source_events (GdkWindow *window,
9084 GdkInputSource source)
9086 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
9088 return GPOINTER_TO_UINT (g_hash_table_lookup (window->source_event_masks,
9089 GUINT_TO_POINTER (source)));
9093 do_synthesize_crossing_event (gpointer data)
9095 GdkDisplay *display;
9096 GdkWindow *changed_toplevel;
9097 GHashTableIter iter;
9098 gpointer key, value;
9101 changed_toplevel = data;
9103 changed_toplevel->synthesize_crossing_event_queued = FALSE;
9105 if (GDK_WINDOW_DESTROYED (changed_toplevel))
9108 display = gdk_window_get_display (changed_toplevel);
9109 serial = _gdk_display_get_next_serial (display);
9110 g_hash_table_iter_init (&iter, display->pointers_info);
9112 while (g_hash_table_iter_next (&iter, &key, &value))
9114 GdkWindow *new_window_under_pointer;
9115 GdkPointerWindowInfo *pointer_info = value;
9116 GdkDevice *device = key;
9118 if (changed_toplevel == pointer_info->toplevel_under_pointer)
9120 new_window_under_pointer =
9121 get_pointer_window (display, changed_toplevel,
9123 pointer_info->toplevel_x,
9124 pointer_info->toplevel_y,
9126 if (new_window_under_pointer != pointer_info->window_under_pointer)
9128 _gdk_synthesize_crossing_events (display,
9129 pointer_info->window_under_pointer,
9130 new_window_under_pointer,
9131 device, pointer_info->last_slave,
9132 GDK_CROSSING_NORMAL,
9133 pointer_info->toplevel_x,
9134 pointer_info->toplevel_y,
9135 pointer_info->state,
9140 _gdk_display_set_window_under_pointer (display, device, new_window_under_pointer);
9149 _gdk_synthesize_crossing_events_for_geometry_change (GdkWindow *changed_window)
9151 GdkWindow *toplevel;
9153 toplevel = get_event_toplevel (changed_window);
9155 if (!toplevel->synthesize_crossing_event_queued)
9157 toplevel->synthesize_crossing_event_queued = TRUE;
9159 gdk_threads_add_idle_full (GDK_PRIORITY_EVENTS - 1,
9160 do_synthesize_crossing_event,
9161 g_object_ref (toplevel),
9166 /* Don't use for crossing events */
9168 get_event_window (GdkDisplay *display,
9170 GdkEventSequence *sequence,
9171 GdkWindow *pointer_window,
9173 GdkModifierType mask,
9175 gboolean pointer_emulated,
9178 guint evmask, emulated_mask = 0;
9179 GdkWindow *grab_window;
9180 GdkDeviceGrabInfo *grab;
9181 GdkTouchGrabInfo *touch_grab;
9183 touch_grab = _gdk_display_has_touch_grab (display, device, sequence, serial);
9184 grab = _gdk_display_get_last_device_grab (display, device);
9186 if (is_touch_type (type) && pointer_emulated)
9190 case GDK_TOUCH_BEGIN:
9191 emulated_mask |= GDK_BUTTON_PRESS_MASK;
9193 case GDK_TOUCH_UPDATE:
9194 emulated_mask |= GDK_POINTER_MOTION_MASK;
9197 emulated_mask |= GDK_BUTTON_RELEASE_MASK;
9203 if (touch_grab != NULL &&
9204 (!grab || grab->implicit || touch_grab->serial >= grab->serial_start))
9206 evmask = touch_grab->event_mask;
9207 evmask = update_evmask_for_button_motion (evmask, mask);
9209 if (evmask & (type_masks[type] | emulated_mask))
9212 *evmask_out = evmask;
9213 return touch_grab->window;
9219 if (grab != NULL && !grab->owner_events)
9221 evmask = grab->event_mask;
9222 evmask = update_evmask_for_button_motion (evmask, mask);
9224 grab_window = grab->window;
9226 if (evmask & (type_masks[type] | emulated_mask))
9229 *evmask_out = evmask;
9236 while (pointer_window != NULL)
9238 evmask = pointer_window->event_mask;
9239 evmask = update_evmask_for_button_motion (evmask, mask);
9241 if (evmask & (type_masks[type] | emulated_mask))
9244 *evmask_out = evmask;
9245 return pointer_window;
9248 pointer_window = get_event_parent (pointer_window);
9254 evmask = grab->event_mask;
9255 evmask = update_evmask_for_button_motion (evmask, mask);
9257 if (evmask & (type_masks[type] | emulated_mask))
9260 *evmask_out = evmask;
9261 return grab->window;
9271 proxy_pointer_event (GdkDisplay *display,
9272 GdkEvent *source_event,
9275 GdkWindow *toplevel_window, *event_window;
9276 GdkWindow *pointer_window;
9277 GdkPointerWindowInfo *pointer_info;
9278 GdkDevice *device, *source_device;
9281 gdouble toplevel_x, toplevel_y;
9283 gboolean non_linear, need_synthetic_enter = FALSE;
9286 event_type = source_event->type;
9287 event_window = source_event->any.window;
9288 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9289 gdk_event_get_state (source_event, &state);
9290 time_ = gdk_event_get_time (source_event);
9291 device = gdk_event_get_device (source_event);
9292 source_device = gdk_event_get_source_device (source_event);
9293 pointer_info = _gdk_display_get_pointer_info (display, device);
9294 toplevel_window = convert_native_coords_to_toplevel (event_window,
9295 toplevel_x, toplevel_y,
9296 &toplevel_x, &toplevel_y);
9299 if ((source_event->type == GDK_LEAVE_NOTIFY ||
9300 source_event->type == GDK_ENTER_NOTIFY) &&
9301 (source_event->crossing.detail == GDK_NOTIFY_NONLINEAR ||
9302 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))
9305 if (pointer_info->need_touch_press_enter &&
9306 gdk_device_get_source (pointer_info->last_slave) != GDK_SOURCE_TOUCHSCREEN &&
9307 (source_event->type != GDK_TOUCH_UPDATE ||
9308 _gdk_event_get_pointer_emulated (source_event)))
9310 pointer_info->need_touch_press_enter = FALSE;
9311 need_synthetic_enter = TRUE;
9314 /* If we get crossing events with subwindow unexpectedly being NULL
9315 that means there is a native subwindow that gdk doesn't know about.
9316 We track these and forward them, with the correct virtual window
9318 This is important to get right, as metacity uses gdk for the frame
9319 windows, but gdk doesn't know about the client windows reparented
9321 if (((source_event->type == GDK_LEAVE_NOTIFY &&
9322 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9323 (source_event->type == GDK_ENTER_NOTIFY &&
9324 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9325 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9326 source_event->crossing.subwindow == NULL)
9328 /* Left for an unknown (to gdk) subwindow */
9330 /* Send leave events from window under pointer to event window
9331 that will get the subwindow == NULL window */
9332 _gdk_synthesize_crossing_events (display,
9333 pointer_info->window_under_pointer,
9335 device, source_device,
9336 source_event->crossing.mode,
9337 toplevel_x, toplevel_y,
9343 /* Send subwindow == NULL event */
9344 send_crossing_event (display,
9348 source_event->crossing.mode,
9349 source_event->crossing.detail,
9351 device, source_device,
9352 toplevel_x, toplevel_y,
9357 _gdk_display_set_window_under_pointer (display, device, NULL);
9361 pointer_window = get_pointer_window (display, toplevel_window, device,
9362 toplevel_x, toplevel_y, serial);
9364 if (((source_event->type == GDK_ENTER_NOTIFY &&
9365 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9366 (source_event->type == GDK_LEAVE_NOTIFY &&
9367 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9368 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9369 source_event->crossing.subwindow == NULL)
9371 /* Entered from an unknown (to gdk) subwindow */
9373 /* Send subwindow == NULL event */
9374 send_crossing_event (display,
9378 source_event->crossing.mode,
9379 source_event->crossing.detail,
9381 device, source_device,
9382 toplevel_x, toplevel_y,
9387 /* Send enter events from event window to pointer_window */
9388 _gdk_synthesize_crossing_events (display,
9391 device, source_device,
9392 source_event->crossing.mode,
9393 toplevel_x, toplevel_y,
9396 serial, non_linear);
9397 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9401 if ((source_event->type != GDK_TOUCH_UPDATE ||
9402 _gdk_event_get_pointer_emulated (source_event)) &&
9403 pointer_info->window_under_pointer != pointer_window)
9405 /* Either a toplevel crossing notify that ended up inside a child window,
9406 or a motion notify that got into another child window */
9408 /* Different than last time, send crossing events */
9409 _gdk_synthesize_crossing_events (display,
9410 pointer_info->window_under_pointer,
9412 device, source_device,
9413 GDK_CROSSING_NORMAL,
9414 toplevel_x, toplevel_y,
9417 serial, non_linear);
9418 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9420 else if (source_event->type == GDK_MOTION_NOTIFY ||
9421 source_event->type == GDK_TOUCH_UPDATE)
9423 GdkWindow *event_win;
9426 GdkEventSequence *sequence;
9428 sequence = gdk_event_get_event_sequence (source_event);
9430 event_win = get_event_window (display,
9437 _gdk_event_get_pointer_emulated (source_event),
9440 if (event_type == GDK_TOUCH_UPDATE)
9442 if (_gdk_event_get_pointer_emulated (source_event))
9444 /* Touch events emulating pointer events are transformed back
9445 * to pointer events if:
9446 * 1 - The event window doesn't select for touch events
9447 * 2 - There's no touch grab for this sequence, which means
9448 * it was started as a pointer sequence, but a device
9449 * grab added touch events afterwards, the sequence must
9450 * not mutate in this case.
9452 if ((evmask & GDK_TOUCH_MASK) == 0 ||
9453 !_gdk_display_has_touch_grab (display, device, sequence, serial))
9454 event_type = GDK_MOTION_NOTIFY;
9456 else if ((evmask & GDK_TOUCH_MASK) == 0)
9460 if (is_touch_type (source_event->type) && !is_touch_type (event_type))
9461 state |= GDK_BUTTON1_MASK;
9464 gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9465 gdk_window_get_device_events (event_win, device) == 0)
9468 /* The last device to interact with the window was a touch device,
9469 * which synthesized a leave notify event, so synthesize another enter
9470 * notify to tell the pointer is on the window.
9472 if (need_synthetic_enter)
9473 _gdk_synthesize_crossing_events (display,
9474 NULL, pointer_window,
9475 device, source_device,
9476 GDK_CROSSING_DEVICE_SWITCH,
9477 toplevel_x, toplevel_y,
9484 event_type == GDK_MOTION_NOTIFY &&
9485 (evmask & GDK_POINTER_MOTION_HINT_MASK))
9487 gulong *device_serial;
9489 device_serial = g_hash_table_lookup (display->motion_hint_info, device);
9491 if (!device_serial ||
9492 (*device_serial != 0 &&
9493 serial < *device_serial))
9494 event_win = NULL; /* Ignore event */
9498 *device_serial = G_MAXULONG;
9505 event = gdk_event_new (event_type);
9506 event->any.window = g_object_ref (event_win);
9507 event->any.send_event = source_event->any.send_event;
9509 gdk_event_set_device (event, gdk_event_get_device (source_event));
9510 gdk_event_set_source_device (event, source_device);
9512 if (event_type == GDK_TOUCH_UPDATE)
9514 event->touch.time = time_;
9515 event->touch.state = state | GDK_BUTTON1_MASK;
9516 event->touch.sequence = source_event->touch.sequence;
9517 event->touch.emulating_pointer = source_event->touch.emulating_pointer;
9518 convert_toplevel_coords_to_window (event_win,
9519 toplevel_x, toplevel_y,
9520 &event->touch.x, &event->touch.y);
9521 gdk_event_get_root_coords (source_event,
9522 &event->touch.x_root,
9523 &event->touch.y_root);
9525 event->touch.axes = g_memdup (source_event->touch.axes,
9526 sizeof (gdouble) * gdk_device_get_n_axes (source_event->touch.device));
9530 event->motion.time = time_;
9531 event->motion.state = state;
9532 event->motion.is_hint = is_hint;
9534 convert_toplevel_coords_to_window (event_win,
9535 toplevel_x, toplevel_y,
9536 &event->motion.x, &event->motion.y);
9537 gdk_event_get_root_coords (source_event,
9538 &event->motion.x_root,
9539 &event->motion.y_root);
9541 if (is_touch_type (source_event->type))
9542 event->motion.axes = g_memdup (source_event->touch.axes,
9543 sizeof (gdouble) * gdk_device_get_n_axes (source_event->touch.device));
9545 event->motion.axes = g_memdup (source_event->motion.axes,
9546 sizeof (gdouble) * gdk_device_get_n_axes (source_event->motion.device));
9549 /* Just insert the event */
9550 _gdk_event_queue_insert_after (gdk_window_get_display (event_win),
9551 source_event, event);
9554 /* unlink all move events from queue.
9555 We handle our own, including our emulated masks. */
9559 #define GDK_ANY_BUTTON_MASK (GDK_BUTTON1_MASK | \
9560 GDK_BUTTON2_MASK | \
9561 GDK_BUTTON3_MASK | \
9562 GDK_BUTTON4_MASK | \
9566 proxy_button_event (GdkEvent *source_event,
9569 GdkWindow *toplevel_window, *event_window;
9570 GdkWindow *event_win;
9571 GdkWindow *pointer_window;
9574 GdkPointerWindowInfo *pointer_info;
9575 GdkDeviceGrabInfo *pointer_grab;
9579 gdouble toplevel_x, toplevel_y;
9580 GdkDisplay *display;
9582 GdkDevice *device, *source_device;
9583 GdkEventMask evmask;
9584 GdkEventSequence *sequence;
9586 type = source_event->any.type;
9587 event_window = source_event->any.window;
9588 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9589 gdk_event_get_state (source_event, &state);
9590 time_ = gdk_event_get_time (source_event);
9591 device = gdk_event_get_device (source_event);
9592 source_device = gdk_event_get_source_device (source_event);
9593 display = gdk_window_get_display (source_event->any.window);
9594 toplevel_window = convert_native_coords_to_toplevel (event_window,
9595 toplevel_x, toplevel_y,
9596 &toplevel_x, &toplevel_y);
9598 sequence = gdk_event_get_event_sequence (source_event);
9600 pointer_info = _gdk_display_get_pointer_info (display, device);
9601 pointer_grab = _gdk_display_has_device_grab (display, device, serial);
9603 if ((type == GDK_BUTTON_PRESS ||
9604 type == GDK_TOUCH_BEGIN) &&
9605 !source_event->any.send_event &&
9607 (type == GDK_TOUCH_BEGIN && pointer_grab->implicit &&
9608 !_gdk_event_get_pointer_emulated (source_event))))
9611 _gdk_window_find_descendant_at (toplevel_window,
9612 toplevel_x, toplevel_y,
9615 /* Find the event window, that gets the grab */
9618 (parent = get_event_parent (w)) != NULL &&
9619 parent->window_type != GDK_WINDOW_ROOT)
9621 if (w->event_mask & GDK_BUTTON_PRESS_MASK &&
9622 (type == GDK_BUTTON_PRESS ||
9623 _gdk_event_get_pointer_emulated (source_event)))
9626 if (type == GDK_TOUCH_BEGIN &&
9627 w->event_mask & GDK_TOUCH_MASK)
9636 if (type == GDK_TOUCH_BEGIN &&
9637 pointer_window->event_mask & GDK_TOUCH_MASK)
9639 _gdk_display_add_touch_grab (display, device, sequence,
9640 pointer_window, event_window,
9641 gdk_window_get_events (pointer_window),
9644 else if (type == GDK_BUTTON_PRESS ||
9645 _gdk_event_get_pointer_emulated (source_event))
9647 _gdk_display_add_device_grab (display,
9653 gdk_window_get_events (pointer_window),
9657 _gdk_display_device_grab_update (display, device,
9658 source_device, serial);
9663 pointer_window = get_pointer_window (display, toplevel_window, device,
9664 toplevel_x, toplevel_y,
9667 event_win = get_event_window (display,
9673 _gdk_event_get_pointer_emulated (source_event),
9676 if (type == GDK_TOUCH_BEGIN || type == GDK_TOUCH_END)
9678 if (_gdk_event_get_pointer_emulated (source_event))
9680 if ((evmask & GDK_TOUCH_MASK) == 0 ||
9681 !_gdk_display_has_touch_grab (display, device, sequence, serial))
9683 if (type == GDK_TOUCH_BEGIN)
9684 type = GDK_BUTTON_PRESS;
9685 else if (type == GDK_TOUCH_END)
9686 type = GDK_BUTTON_RELEASE;
9689 else if ((evmask & GDK_TOUCH_MASK) == 0)
9693 if (source_event->type == GDK_TOUCH_END && !is_touch_type (type))
9694 state |= GDK_BUTTON1_MASK;
9696 if (event_win == NULL)
9699 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9700 gdk_window_get_device_events (event_win, device) == 0)
9703 if ((type == GDK_BUTTON_PRESS ||
9704 (type == GDK_TOUCH_BEGIN &&
9705 _gdk_event_get_pointer_emulated (source_event))) &&
9706 pointer_info->need_touch_press_enter)
9708 GdkCrossingMode mode;
9710 /* The last device to interact with the window was a touch device,
9711 * which synthesized a leave notify event, so synthesize another enter
9712 * notify to tell the pointer is on the window.
9714 if (gdk_device_get_source (source_device) == GDK_SOURCE_TOUCHSCREEN)
9715 mode = GDK_CROSSING_TOUCH_BEGIN;
9717 mode = GDK_CROSSING_DEVICE_SWITCH;
9719 pointer_info->need_touch_press_enter = FALSE;
9720 _gdk_synthesize_crossing_events (display,
9722 pointer_info->window_under_pointer,
9723 device, source_device, mode,
9724 toplevel_x, toplevel_y,
9725 state, time_, source_event,
9728 else if (type == GDK_SCROLL &&
9729 (((evmask & GDK_SMOOTH_SCROLL_MASK) == 0 &&
9730 source_event->scroll.direction == GDK_SCROLL_SMOOTH) ||
9731 ((evmask & GDK_SMOOTH_SCROLL_MASK) != 0 &&
9732 source_event->scroll.direction != GDK_SCROLL_SMOOTH &&
9733 _gdk_event_get_pointer_emulated (source_event))))
9736 event = _gdk_make_event (event_win, type, source_event, FALSE);
9740 case GDK_BUTTON_PRESS:
9741 case GDK_BUTTON_RELEASE:
9742 event->button.button = source_event->button.button;
9743 convert_toplevel_coords_to_window (event_win,
9744 toplevel_x, toplevel_y,
9745 &event->button.x, &event->button.y);
9746 gdk_event_get_root_coords (source_event,
9747 &event->button.x_root,
9748 &event->button.y_root);
9749 gdk_event_set_device (event, gdk_event_get_device (source_event));
9750 gdk_event_set_source_device (event, source_device);
9752 if (is_touch_type (source_event->type))
9754 if (type == GDK_BUTTON_RELEASE)
9755 event->button.state |= GDK_BUTTON1_MASK;
9756 event->button.button = 1;
9757 event->button.axes = g_memdup (source_event->touch.axes,
9758 sizeof (gdouble) * gdk_device_get_n_axes (source_event->touch.device));
9762 event->button.button = source_event->button.button;
9763 event->button.axes = g_memdup (source_event->button.axes,
9764 sizeof (gdouble) * gdk_device_get_n_axes (source_event->button.device));
9767 if (type == GDK_BUTTON_PRESS)
9768 _gdk_event_button_generate (display, event);
9769 else if ((type == GDK_BUTTON_RELEASE ||
9770 (type == GDK_TOUCH_END &&
9771 _gdk_event_get_pointer_emulated (source_event))) &&
9772 pointer_window == pointer_info->window_under_pointer &&
9773 gdk_device_get_source (source_device) == GDK_SOURCE_TOUCHSCREEN)
9775 /* Synthesize a leave notify event
9776 * whenever a touch device is released
9778 pointer_info->need_touch_press_enter = TRUE;
9779 _gdk_synthesize_crossing_events (display,
9780 pointer_window, NULL,
9781 device, source_device,
9782 GDK_CROSSING_TOUCH_END,
9783 toplevel_x, toplevel_y,
9789 case GDK_TOUCH_BEGIN:
9791 convert_toplevel_coords_to_window (event_win,
9792 toplevel_x, toplevel_y,
9793 &event->button.x, &event->button.y);
9794 gdk_event_get_root_coords (source_event,
9795 &event->touch.x_root,
9796 &event->touch.y_root);
9797 event->touch.state = state;
9798 event->touch.device = source_event->touch.device;
9799 event->touch.axes = g_memdup (source_event->touch.axes,
9800 sizeof (gdouble) * gdk_device_get_n_axes (source_event->touch.device));
9801 event->touch.sequence = source_event->touch.sequence;
9802 event->touch.emulating_pointer = source_event->touch.emulating_pointer;
9804 gdk_event_set_source_device (event, source_device);
9806 if ((type == GDK_TOUCH_END &&
9807 _gdk_event_get_pointer_emulated (source_event)) &&
9808 pointer_window == pointer_info->window_under_pointer &&
9809 gdk_device_get_source (source_device) == GDK_SOURCE_TOUCHSCREEN)
9811 /* Synthesize a leave notify event
9812 * whenever a touch device is released
9814 pointer_info->need_touch_press_enter = TRUE;
9815 _gdk_synthesize_crossing_events (display,
9816 pointer_window, NULL,
9817 device, source_device,
9818 GDK_CROSSING_TOUCH_END,
9819 toplevel_x, toplevel_y,
9826 event->scroll.direction = source_event->scroll.direction;
9827 convert_toplevel_coords_to_window (event_win,
9828 toplevel_x, toplevel_y,
9829 &event->scroll.x, &event->scroll.y);
9830 event->scroll.x_root = source_event->scroll.x_root;
9831 event->scroll.y_root = source_event->scroll.y_root;
9832 event->scroll.state = state;
9833 event->scroll.device = source_event->scroll.device;
9834 event->scroll.delta_x = source_event->scroll.delta_x;
9835 event->scroll.delta_y = source_event->scroll.delta_y;
9836 gdk_event_set_source_device (event, source_device);
9843 return TRUE; /* Always unlink original, we want to obey the emulated event mask */
9846 #ifdef DEBUG_WINDOW_PRINTING
9848 #ifdef GDK_WINDOWING_X11
9849 #include "x11/gdkx.h"
9853 gdk_window_print (GdkWindow *window,
9857 const char *window_types[] = {
9867 g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", window,
9868 window->user_data ? g_type_name_from_instance (window->user_data) : "no widget",
9869 window->x, window->y,
9870 window->width, window->height
9873 if (gdk_window_has_impl (window))
9875 #ifdef GDK_WINDOWING_X11
9876 g_print (" impl(0x%lx)", gdk_x11_window_get_xid (window));
9880 if (window->window_type != GDK_WINDOW_CHILD)
9881 g_print (" %s", window_types[window->window_type]);
9883 if (window->input_only)
9884 g_print (" input-only");
9887 g_print (" shaped");
9889 if (!gdk_window_is_visible ((GdkWindow *)window))
9890 g_print (" hidden");
9892 g_print (" abs[%d,%d]",
9893 window->abs_x, window->abs_y);
9895 s = print_region (window->clip_region);
9896 g_print (" clipbox[%s]", s);
9903 gdk_window_print_tree (GdkWindow *window,
9905 gboolean include_input_only)
9909 if (window->input_only && !include_input_only)
9912 gdk_window_print (window, indent);
9914 for (l = window->children; l != NULL; l = l->next)
9915 gdk_window_print_tree (l->data, indent + 4, include_input_only);
9918 #endif /* DEBUG_WINDOW_PRINTING */
9921 _gdk_windowing_got_event (GdkDisplay *display,
9926 GdkWindow *event_window;
9928 gboolean unlink_event;
9929 GdkDeviceGrabInfo *button_release_grab;
9930 GdkPointerWindowInfo *pointer_info = NULL;
9931 GdkDevice *device, *source_device;
9932 gboolean is_toplevel;
9934 if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
9935 display->last_event_time = gdk_event_get_time (event);
9937 device = gdk_event_get_device (event);
9938 source_device = gdk_event_get_source_device (event);
9944 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
9946 pointer_info = _gdk_display_get_pointer_info (display, device);
9948 if (source_device != pointer_info->last_slave &&
9949 gdk_device_get_device_type (source_device) == GDK_DEVICE_TYPE_SLAVE)
9950 pointer_info->last_slave = source_device;
9952 source_device = pointer_info->last_slave;
9955 g_object_get (device, "input-mode", &mode, NULL);
9956 _gdk_display_device_grab_update (display, device, source_device, serial);
9958 if (mode == GDK_MODE_DISABLED ||
9959 !_gdk_display_check_grab_ownership (display, device, serial))
9961 /* Device events are blocked by another
9962 * device grab, or the device is disabled
9964 unlink_event = TRUE;
9969 event_window = event->any.window;
9973 #ifdef DEBUG_WINDOW_PRINTING
9974 if (event->type == GDK_KEY_PRESS &&
9975 (event->key.keyval == 0xa7 ||
9976 event->key.keyval == 0xbd))
9978 gdk_window_print_tree (event_window, 0, event->key.keyval == 0xbd);
9982 if (event->type == GDK_VISIBILITY_NOTIFY)
9984 event_window->native_visibility = event->visibility.state;
9985 gdk_window_update_visibility_recursively (event_window, event_window);
9989 if (!(is_button_type (event->type) ||
9990 is_motion_type (event->type)) ||
9991 event_window->window_type == GDK_WINDOW_ROOT)
9994 is_toplevel = gdk_window_is_toplevel (event_window);
9996 if ((event->type == GDK_ENTER_NOTIFY ||
9997 event->type == GDK_LEAVE_NOTIFY) &&
9998 (event->crossing.mode == GDK_CROSSING_GRAB ||
9999 event->crossing.mode == GDK_CROSSING_UNGRAB) &&
10000 (_gdk_display_has_device_grab (display, device, serial) ||
10001 event->crossing.detail == GDK_NOTIFY_INFERIOR))
10003 /* We synthesize all crossing events due to grabs ourselves,
10004 * so we ignore the native ones caused by our native pointer_grab
10005 * calls. Otherwise we would proxy these crossing event and cause
10006 * multiple copies of crossing events for grabs.
10008 * We do want to handle grabs from other clients though, as for
10009 * instance alt-tab in metacity causes grabs like these and
10010 * we want to handle those. Thus the has_pointer_grab check.
10012 * Implicit grabs on child windows create some grabbing events
10013 * that are sent before the button press. This means we can't
10014 * detect these with the has_pointer_grab check (as the implicit
10015 * grab is only noticed when we get button press event), so we
10016 * detect these events by checking for INFERIOR enter or leave
10017 * events. These should never be a problem to filter out.
10020 /* We ended up in this window after some (perhaps other clients)
10021 * grab, so update the toplevel_under_window state
10024 event->type == GDK_ENTER_NOTIFY &&
10025 event->crossing.mode == GDK_CROSSING_UNGRAB)
10027 if (pointer_info->toplevel_under_pointer)
10028 g_object_unref (pointer_info->toplevel_under_pointer);
10029 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
10032 unlink_event = TRUE;
10036 /* Track toplevel_under_pointer */
10039 if (event->type == GDK_ENTER_NOTIFY &&
10040 event->crossing.detail != GDK_NOTIFY_INFERIOR)
10042 if (pointer_info->toplevel_under_pointer)
10043 g_object_unref (pointer_info->toplevel_under_pointer);
10044 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
10046 else if (event->type == GDK_LEAVE_NOTIFY &&
10047 event->crossing.detail != GDK_NOTIFY_INFERIOR &&
10048 pointer_info->toplevel_under_pointer == event_window)
10050 if (pointer_info->toplevel_under_pointer)
10051 g_object_unref (pointer_info->toplevel_under_pointer);
10052 pointer_info->toplevel_under_pointer = NULL;
10056 if (pointer_info &&
10057 (!is_touch_type (event->type) ||
10058 _gdk_event_get_pointer_emulated (event)))
10060 guint old_state, old_button;
10062 /* Store last pointer window and position/state */
10063 old_state = pointer_info->state;
10064 old_button = pointer_info->button;
10066 gdk_event_get_coords (event, &x, &y);
10067 convert_native_coords_to_toplevel (event_window, x, y, &x, &y);
10068 pointer_info->toplevel_x = x;
10069 pointer_info->toplevel_y = y;
10070 gdk_event_get_state (event, &pointer_info->state);
10072 if (event->type == GDK_BUTTON_PRESS ||
10073 event->type == GDK_BUTTON_RELEASE)
10074 pointer_info->button = event->button.button;
10075 else if (event->type == GDK_TOUCH_BEGIN ||
10076 event->type == GDK_TOUCH_END)
10077 pointer_info->button = 1;
10080 (pointer_info->state != old_state ||
10081 pointer_info->button != old_button))
10082 _gdk_display_enable_motion_hints (display, device);
10085 unlink_event = FALSE;
10086 if (is_motion_type (event->type))
10087 unlink_event = proxy_pointer_event (display, event, serial);
10088 else if (is_button_type (event->type))
10089 unlink_event = proxy_button_event (event, serial);
10091 if ((event->type == GDK_BUTTON_RELEASE ||
10092 event->type == GDK_TOUCH_END) &&
10093 !event->any.send_event)
10095 GdkEventSequence *sequence;
10097 sequence = gdk_event_get_event_sequence (event);
10098 if (event->type == GDK_TOUCH_END && sequence)
10100 _gdk_display_end_touch_grab (display, device, sequence);
10103 if (event->type == GDK_BUTTON_RELEASE ||
10104 _gdk_event_get_pointer_emulated (event))
10106 button_release_grab =
10107 _gdk_display_has_device_grab (display, device, serial);
10109 if (button_release_grab &&
10110 button_release_grab->implicit &&
10111 (event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
10113 button_release_grab->serial_end = serial;
10114 button_release_grab->implicit_ungrab = FALSE;
10115 _gdk_display_device_grab_update (display, device, source_device, serial);
10123 _gdk_event_queue_remove_link (display, event_link);
10124 g_list_free_1 (event_link);
10125 gdk_event_free (event);
10130 * gdk_window_create_similar_surface:
10131 * @window: window to make new surface similar to
10132 * @content: the content for the new surface
10133 * @width: width of the new surface
10134 * @height: height of the new surface
10136 * Create a new surface that is as compatible as possible with the
10137 * given @window. For example the new surface will have the same
10138 * fallback resolution and font options as @window. Generally, the new
10139 * surface will also use the same backend as @window, unless that is
10140 * not possible for some reason. The type of the returned surface may
10141 * be examined with cairo_surface_get_type().
10143 * Initially the surface contents are all 0 (transparent if contents
10144 * have transparency, black otherwise.)
10146 * Returns: a pointer to the newly allocated surface. The caller
10147 * owns the surface and should call cairo_surface_destroy() when done
10150 * This function always returns a valid pointer, but it will return a
10151 * pointer to a "nil" surface if @other is already in an error state
10152 * or any other error occurs.
10157 gdk_window_create_similar_surface (GdkWindow * window,
10158 cairo_content_t content,
10162 cairo_surface_t *window_surface, *surface;
10164 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
10166 window_surface = gdk_window_ref_impl_surface (window);
10168 switch (_gdk_rendering_mode)
10170 case GDK_RENDERING_MODE_RECORDING:
10172 cairo_rectangle_t rect = { 0, 0, width, height };
10173 surface = cairo_recording_surface_create (content, &rect);
10176 case GDK_RENDERING_MODE_IMAGE:
10177 surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
10178 content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
10181 case GDK_RENDERING_MODE_SIMILAR:
10183 surface = cairo_surface_create_similar (window_surface,
10189 cairo_surface_destroy (window_surface);
10195 * gdk_window_focus:
10196 * @window: a #GdkWindow
10197 * @timestamp: timestamp of the event triggering the window focus
10199 * Sets keyboard focus to @window. In most cases, gtk_window_present()
10200 * should be used on a #GtkWindow, rather than calling this function.
10204 gdk_window_focus (GdkWindow *window,
10207 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->focus (window, timestamp);
10211 * gdk_window_set_type_hint:
10212 * @window: A toplevel #GdkWindow
10213 * @hint: A hint of the function this window will have
10215 * The application can use this call to provide a hint to the window
10216 * manager about the functionality of a window. The window manager
10217 * can use this information when determining the decoration and behaviour
10220 * The hint must be set before the window is mapped.
10223 gdk_window_set_type_hint (GdkWindow *window,
10224 GdkWindowTypeHint hint)
10226 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_type_hint (window, hint);
10230 * gdk_window_get_type_hint:
10231 * @window: A toplevel #GdkWindow
10233 * This function returns the type hint set for a window.
10235 * Return value: The type hint set for @window
10240 gdk_window_get_type_hint (GdkWindow *window)
10242 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_type_hint (window);
10246 * gdk_window_set_modal_hint:
10247 * @window: A toplevel #GdkWindow
10248 * @modal: %TRUE if the window is modal, %FALSE otherwise.
10250 * The application can use this hint to tell the window manager
10251 * that a certain window has modal behaviour. The window manager
10252 * can use this information to handle modal windows in a special
10255 * You should only use this on windows for which you have
10256 * previously called gdk_window_set_transient_for()
10259 gdk_window_set_modal_hint (GdkWindow *window,
10262 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_modal_hint (window, modal);
10266 * gdk_window_set_skip_taskbar_hint:
10267 * @window: a toplevel #GdkWindow
10268 * @skips_taskbar: %TRUE to skip the taskbar
10270 * Toggles whether a window should appear in a task list or window
10271 * list. If a window's semantic type as specified with
10272 * gdk_window_set_type_hint() already fully describes the window, this
10273 * function should <emphasis>not</emphasis> be called in addition,
10274 * instead you should allow the window to be treated according to
10275 * standard policy for its semantic type.
10280 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
10281 gboolean skips_taskbar)
10283 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_taskbar_hint (window, skips_taskbar);
10287 * gdk_window_set_skip_pager_hint:
10288 * @window: a toplevel #GdkWindow
10289 * @skips_pager: %TRUE to skip the pager
10291 * Toggles whether a window should appear in a pager (workspace
10292 * switcher, or other desktop utility program that displays a small
10293 * thumbnail representation of the windows on the desktop). If a
10294 * window's semantic type as specified with gdk_window_set_type_hint()
10295 * already fully describes the window, this function should
10296 * <emphasis>not</emphasis> be called in addition, instead you should
10297 * allow the window to be treated according to standard policy for
10298 * its semantic type.
10303 gdk_window_set_skip_pager_hint (GdkWindow *window,
10304 gboolean skips_pager)
10306 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_pager_hint (window, skips_pager);
10310 * gdk_window_set_urgency_hint:
10311 * @window: a toplevel #GdkWindow
10312 * @urgent: %TRUE if the window is urgent
10314 * Toggles whether a window needs the user's
10315 * urgent attention.
10320 gdk_window_set_urgency_hint (GdkWindow *window,
10323 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_urgency_hint (window, urgent);
10327 * gdk_window_set_geometry_hints:
10328 * @window: a toplevel #GdkWindow
10329 * @geometry: geometry hints
10330 * @geom_mask: bitmask indicating fields of @geometry to pay attention to
10332 * Sets the geometry hints for @window. Hints flagged in @geom_mask
10333 * are set, hints not flagged in @geom_mask are unset.
10334 * To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
10336 * This function provides hints to the windowing system about
10337 * acceptable sizes for a toplevel window. The purpose of
10338 * this is to constrain user resizing, but the windowing system
10339 * will typically (but is not required to) also constrain the
10340 * current size of the window to the provided values and
10341 * constrain programatic resizing via gdk_window_resize() or
10342 * gdk_window_move_resize().
10344 * Note that on X11, this effect has no effect on windows
10345 * of type %GDK_WINDOW_TEMP or windows where override redirect
10346 * has been turned on via gdk_window_set_override_redirect()
10347 * since these windows are not resizable by the user.
10349 * Since you can't count on the windowing system doing the
10350 * constraints for programmatic resizes, you should generally
10351 * call gdk_window_constrain_size() yourself to determine
10352 * appropriate sizes.
10356 gdk_window_set_geometry_hints (GdkWindow *window,
10357 const GdkGeometry *geometry,
10358 GdkWindowHints geom_mask)
10360 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_geometry_hints (window, geometry, geom_mask);
10364 * gdk_window_set_title:
10365 * @window: a toplevel #GdkWindow
10366 * @title: title of @window
10368 * Sets the title of a toplevel window, to be displayed in the titlebar.
10369 * If you haven't explicitly set the icon name for the window
10370 * (using gdk_window_set_icon_name()), the icon name will be set to
10371 * @title as well. @title must be in UTF-8 encoding (as with all
10372 * user-readable strings in GDK/GTK+). @title may not be %NULL.
10375 gdk_window_set_title (GdkWindow *window,
10376 const gchar *title)
10378 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_title (window, title);
10382 * gdk_window_set_role:
10383 * @window: a toplevel #GdkWindow
10384 * @role: a string indicating its role
10386 * When using GTK+, typically you should use gtk_window_set_role() instead
10387 * of this low-level function.
10389 * The window manager and session manager use a window's role to
10390 * distinguish it from other kinds of window in the same application.
10391 * When an application is restarted after being saved in a previous
10392 * session, all windows with the same title and role are treated as
10393 * interchangeable. So if you have two windows with the same title
10394 * that should be distinguished for session management purposes, you
10395 * should set the role on those windows. It doesn't matter what string
10396 * you use for the role, as long as you have a different role for each
10397 * non-interchangeable kind of window.
10401 gdk_window_set_role (GdkWindow *window,
10404 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_role (window, role);
10408 * gdk_window_set_startup_id:
10409 * @window: a toplevel #GdkWindow
10410 * @startup_id: a string with startup-notification identifier
10412 * When using GTK+, typically you should use gtk_window_set_startup_id()
10413 * instead of this low-level function.
10419 gdk_window_set_startup_id (GdkWindow *window,
10420 const gchar *startup_id)
10422 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_startup_id (window, startup_id);
10426 * gdk_window_set_transient_for:
10427 * @window: a toplevel #GdkWindow
10428 * @parent: another toplevel #GdkWindow
10430 * Indicates to the window manager that @window is a transient dialog
10431 * associated with the application window @parent. This allows the
10432 * window manager to do things like center @window on @parent and
10433 * keep @window above @parent.
10435 * See gtk_window_set_transient_for() if you're using #GtkWindow or
10439 gdk_window_set_transient_for (GdkWindow *window,
10442 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_transient_for (window, parent);
10446 * gdk_window_get_root_origin:
10447 * @window: a toplevel #GdkWindow
10448 * @x: (out): return location for X position of window frame
10449 * @y: (out): return location for Y position of window frame
10451 * Obtains the top-left corner of the window manager frame in root
10452 * window coordinates.
10456 gdk_window_get_root_origin (GdkWindow *window,
10460 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_root_origin (window, x, y);
10464 * gdk_window_get_frame_extents:
10465 * @window: a toplevel #GdkWindow
10466 * @rect: (out): rectangle to fill with bounding box of the window frame
10468 * Obtains the bounding box of the window, including window manager
10469 * titlebar/borders if any. The frame position is given in root window
10470 * coordinates. To get the position of the window itself (rather than
10471 * the frame) in root window coordinates, use gdk_window_get_origin().
10475 gdk_window_get_frame_extents (GdkWindow *window,
10476 GdkRectangle *rect)
10478 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_frame_extents (window, rect);
10482 * gdk_window_set_override_redirect:
10483 * @window: a toplevel #GdkWindow
10484 * @override_redirect: %TRUE if window should be override redirect
10486 * An override redirect window is not under the control of the window manager.
10487 * This means it won't have a titlebar, won't be minimizable, etc. - it will
10488 * be entirely under the control of the application. The window manager
10489 * can't see the override redirect window at all.
10491 * Override redirect should only be used for short-lived temporary
10492 * windows, such as popup menus. #GtkMenu uses an override redirect
10493 * window in its implementation, for example.
10497 gdk_window_set_override_redirect (GdkWindow *window,
10498 gboolean override_redirect)
10500 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_override_redirect (window, override_redirect);
10504 * gdk_window_set_accept_focus:
10505 * @window: a toplevel #GdkWindow
10506 * @accept_focus: %TRUE if the window should receive input focus
10508 * Setting @accept_focus to %FALSE hints the desktop environment that the
10509 * window doesn't want to receive input focus.
10511 * On X, it is the responsibility of the window manager to interpret this
10512 * hint. ICCCM-compliant window manager usually respect it.
10517 gdk_window_set_accept_focus (GdkWindow *window,
10518 gboolean accept_focus)
10520 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_accept_focus (window, accept_focus);
10524 * gdk_window_set_focus_on_map:
10525 * @window: a toplevel #GdkWindow
10526 * @focus_on_map: %TRUE if the window should receive input focus when mapped
10528 * Setting @focus_on_map to %FALSE hints the desktop environment that the
10529 * window doesn't want to receive input focus when it is mapped.
10530 * focus_on_map should be turned off for windows that aren't triggered
10531 * interactively (such as popups from network activity).
10533 * On X, it is the responsibility of the window manager to interpret
10534 * this hint. Window managers following the freedesktop.org window
10535 * manager extension specification should respect it.
10540 gdk_window_set_focus_on_map (GdkWindow *window,
10541 gboolean focus_on_map)
10543 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_focus_on_map (window, focus_on_map);
10547 * gdk_window_set_icon_list:
10548 * @window: The #GdkWindow toplevel window to set the icon of.
10549 * @pixbufs: (transfer none) (element-type GdkPixbuf):
10550 * A list of pixbufs, of different sizes.
10552 * Sets a list of icons for the window. One of these will be used
10553 * to represent the window when it has been iconified. The icon is
10554 * usually shown in an icon box or some sort of task bar. Which icon
10555 * size is shown depends on the window manager. The window manager
10556 * can scale the icon but setting several size icons can give better
10557 * image quality since the window manager may only need to scale the
10558 * icon by a small amount or not at all.
10562 gdk_window_set_icon_list (GdkWindow *window,
10565 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_list (window, pixbufs);
10569 * gdk_window_set_icon_name:
10570 * @window: a toplevel #GdkWindow
10571 * @name: (allow-none): name of window while iconified (minimized)
10573 * Windows may have a name used while minimized, distinct from the
10574 * name they display in their titlebar. Most of the time this is a bad
10575 * idea from a user interface standpoint. But you can set such a name
10576 * with this function, if you like.
10578 * After calling this with a non-%NULL @name, calls to gdk_window_set_title()
10579 * will not update the icon title.
10581 * Using %NULL for @name unsets the icon title; further calls to
10582 * gdk_window_set_title() will again update the icon title as well.
10585 gdk_window_set_icon_name (GdkWindow *window,
10588 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_name (window, name);
10592 * gdk_window_iconify:
10593 * @window: a toplevel #GdkWindow
10595 * Asks to iconify (minimize) @window. The window manager may choose
10596 * to ignore the request, but normally will honor it. Using
10597 * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
10599 * This function only makes sense when @window is a toplevel window.
10603 gdk_window_iconify (GdkWindow *window)
10605 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->iconify (window);
10609 * gdk_window_deiconify:
10610 * @window: a toplevel #GdkWindow
10612 * Attempt to deiconify (unminimize) @window. On X11 the window manager may
10613 * choose to ignore the request to deiconify. When using GTK+,
10614 * use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
10615 * you probably want to use gtk_window_present(), which raises the window, focuses it,
10616 * unminimizes it, and puts it on the current desktop.
10620 gdk_window_deiconify (GdkWindow *window)
10622 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->deiconify (window);
10626 * gdk_window_stick:
10627 * @window: a toplevel #GdkWindow
10629 * "Pins" a window such that it's on all workspaces and does not scroll
10630 * with viewports, for window managers that have scrollable viewports.
10631 * (When using #GtkWindow, gtk_window_stick() may be more useful.)
10633 * On the X11 platform, this function depends on window manager
10634 * support, so may have no effect with many window managers. However,
10635 * GDK will do the best it can to convince the window manager to stick
10636 * the window. For window managers that don't support this operation,
10637 * there's nothing you can do to force it to happen.
10641 gdk_window_stick (GdkWindow *window)
10643 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->stick (window);
10647 * gdk_window_unstick:
10648 * @window: a toplevel #GdkWindow
10650 * Reverse operation for gdk_window_stick(); see gdk_window_stick(),
10651 * and gtk_window_unstick().
10655 gdk_window_unstick (GdkWindow *window)
10657 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unstick (window);
10661 * gdk_window_maximize:
10662 * @window: a toplevel #GdkWindow
10664 * Maximizes the window. If the window was already maximized, then
10665 * this function does nothing.
10667 * On X11, asks the window manager to maximize @window, if the window
10668 * manager supports this operation. Not all window managers support
10669 * this, and some deliberately ignore it or don't have a concept of
10670 * "maximized"; so you can't rely on the maximization actually
10671 * happening. But it will happen with most standard window managers,
10672 * and GDK makes a best effort to get it to happen.
10674 * On Windows, reliably maximizes the window.
10678 gdk_window_maximize (GdkWindow *window)
10680 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->maximize (window);
10684 * gdk_window_unmaximize:
10685 * @window: a toplevel #GdkWindow
10687 * Unmaximizes the window. If the window wasn't maximized, then this
10688 * function does nothing.
10690 * On X11, asks the window manager to unmaximize @window, if the
10691 * window manager supports this operation. Not all window managers
10692 * support this, and some deliberately ignore it or don't have a
10693 * concept of "maximized"; so you can't rely on the unmaximization
10694 * actually happening. But it will happen with most standard window
10695 * managers, and GDK makes a best effort to get it to happen.
10697 * On Windows, reliably unmaximizes the window.
10701 gdk_window_unmaximize (GdkWindow *window)
10703 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unmaximize (window);
10707 * gdk_window_fullscreen:
10708 * @window: a toplevel #GdkWindow
10710 * Moves the window into fullscreen mode. This means the
10711 * window covers the entire screen and is above any panels
10714 * If the window was already fullscreen, then this function does nothing.
10716 * On X11, asks the window manager to put @window in a fullscreen
10717 * state, if the window manager supports this operation. Not all
10718 * window managers support this, and some deliberately ignore it or
10719 * don't have a concept of "fullscreen"; so you can't rely on the
10720 * fullscreenification actually happening. But it will happen with
10721 * most standard window managers, and GDK makes a best effort to get
10727 gdk_window_fullscreen (GdkWindow *window)
10729 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->fullscreen (window);
10733 * gdk_window_unfullscreen:
10734 * @window: a toplevel #GdkWindow
10736 * Moves the window out of fullscreen mode. If the window was not
10737 * fullscreen, does nothing.
10739 * On X11, asks the window manager to move @window out of the fullscreen
10740 * state, if the window manager supports this operation. Not all
10741 * window managers support this, and some deliberately ignore it or
10742 * don't have a concept of "fullscreen"; so you can't rely on the
10743 * unfullscreenification actually happening. But it will happen with
10744 * most standard window managers, and GDK makes a best effort to get
10750 gdk_window_unfullscreen (GdkWindow *window)
10752 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unfullscreen (window);
10756 * gdk_window_set_keep_above:
10757 * @window: a toplevel #GdkWindow
10758 * @setting: whether to keep @window above other windows
10760 * Set if @window must be kept above other windows. If the
10761 * window was already above, then this function does nothing.
10763 * On X11, asks the window manager to keep @window above, if the window
10764 * manager supports this operation. Not all window managers support
10765 * this, and some deliberately ignore it or don't have a concept of
10766 * "keep above"; so you can't rely on the window being kept above.
10767 * But it will happen with most standard window managers,
10768 * and GDK makes a best effort to get it to happen.
10773 gdk_window_set_keep_above (GdkWindow *window,
10776 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_above (window, setting);
10780 * gdk_window_set_keep_below:
10781 * @window: a toplevel #GdkWindow
10782 * @setting: whether to keep @window below other windows
10784 * Set if @window must be kept below other windows. If the
10785 * window was already below, then this function does nothing.
10787 * On X11, asks the window manager to keep @window below, if the window
10788 * manager supports this operation. Not all window managers support
10789 * this, and some deliberately ignore it or don't have a concept of
10790 * "keep below"; so you can't rely on the window being kept below.
10791 * But it will happen with most standard window managers,
10792 * and GDK makes a best effort to get it to happen.
10797 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
10799 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_below (window, setting);
10803 * gdk_window_get_group:
10804 * @window: a toplevel #GdkWindow
10806 * Returns the group leader window for @window. See gdk_window_set_group().
10808 * Return value: (transfer none): the group leader window for @window
10813 gdk_window_get_group (GdkWindow *window)
10815 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_group (window);
10819 * gdk_window_set_group:
10820 * @window: a toplevel #GdkWindow
10821 * @leader: (allow-none): group leader window, or %NULL to restore the default group leader window
10823 * Sets the group leader window for @window. By default,
10824 * GDK sets the group leader for all toplevel windows
10825 * to a global window implicitly created by GDK. With this function
10826 * you can override this default.
10828 * The group leader window allows the window manager to distinguish
10829 * all windows that belong to a single application. It may for example
10830 * allow users to minimize/unminimize all windows belonging to an
10831 * application at once. You should only set a non-default group window
10832 * if your application pretends to be multiple applications.
10835 gdk_window_set_group (GdkWindow *window,
10838 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_group (window, leader);
10842 * gdk_window_set_decorations:
10843 * @window: a toplevel #GdkWindow
10844 * @decorations: decoration hint mask
10846 * "Decorations" are the features the window manager adds to a toplevel #GdkWindow.
10847 * This function sets the traditional Motif window manager hints that tell the
10848 * window manager which decorations you would like your window to have.
10849 * Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
10850 * using the GDK function directly.
10852 * The @decorations argument is the logical OR of the fields in
10853 * the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
10854 * mask, the other bits indicate which decorations should be turned off.
10855 * If #GDK_DECOR_ALL is not included, then the other bits indicate
10856 * which decorations should be turned on.
10858 * Most window managers honor a decorations hint of 0 to disable all decorations,
10859 * but very few honor all possible combinations of bits.
10863 gdk_window_set_decorations (GdkWindow *window,
10864 GdkWMDecoration decorations)
10866 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_decorations (window, decorations);
10870 * gdk_window_get_decorations:
10871 * @window: The toplevel #GdkWindow to get the decorations from
10872 * @decorations: (out): The window decorations will be written here
10874 * Returns the decorations set on the GdkWindow with
10875 * gdk_window_set_decorations().
10877 * Returns: %TRUE if the window has decorations set, %FALSE otherwise.
10880 gdk_window_get_decorations(GdkWindow *window,
10881 GdkWMDecoration *decorations)
10883 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_decorations (window, decorations);
10887 * gdk_window_set_functions:
10888 * @window: a toplevel #GdkWindow
10889 * @functions: bitmask of operations to allow on @window
10891 * Sets hints about the window management functions to make available
10892 * via buttons on the window frame.
10894 * On the X backend, this function sets the traditional Motif window
10895 * manager hint for this purpose. However, few window managers do
10896 * anything reliable or interesting with this hint. Many ignore it
10899 * The @functions argument is the logical OR of values from the
10900 * #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
10901 * then the other bits indicate which functions to disable; if
10902 * it doesn't include #GDK_FUNC_ALL, it indicates which functions to
10907 gdk_window_set_functions (GdkWindow *window,
10908 GdkWMFunction functions)
10910 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_functions (window, functions);
10914 * gdk_window_begin_resize_drag_for_device:
10915 * @window: a toplevel #GdkWindow
10916 * @edge: the edge or corner from which the drag is started
10917 * @device: the device used for the operation
10918 * @button: the button being used to drag
10919 * @root_x: root window X coordinate of mouse click that began the drag
10920 * @root_y: root window Y coordinate of mouse click that began the drag
10921 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10923 * Begins a window resize operation (for a toplevel window).
10924 * You might use this function to implement a "window resize grip," for
10925 * example; in fact #GtkStatusbar uses it. The function works best
10926 * with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a
10927 * fallback implementation for other window managers.
10932 gdk_window_begin_resize_drag_for_device (GdkWindow *window,
10933 GdkWindowEdge edge,
10940 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
10944 * gdk_window_begin_resize_drag:
10945 * @window: a toplevel #GdkWindow
10946 * @edge: the edge or corner from which the drag is started
10947 * @button: the button being used to drag
10948 * @root_x: root window X coordinate of mouse click that began the drag
10949 * @root_y: root window Y coordinate of mouse click that began the drag
10950 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10952 * Begins a window resize operation (for a toplevel window).
10954 * This function assumes that the drag is controlled by the
10955 * client pointer device, use gdk_window_begin_resize_drag_for_device()
10956 * to begin a drag with a different device.
10959 gdk_window_begin_resize_drag (GdkWindow *window,
10960 GdkWindowEdge edge,
10966 GdkDeviceManager *device_manager;
10969 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10970 device = gdk_device_manager_get_client_pointer (device_manager);
10971 gdk_window_begin_resize_drag_for_device (window, edge,
10972 device, button, root_x, root_y, timestamp);
10976 * gdk_window_begin_move_drag_for_device:
10977 * @window: a toplevel #GdkWindow
10978 * @device: the device used for the operation
10979 * @button: the button being used to drag
10980 * @root_x: root window X coordinate of mouse click that began the drag
10981 * @root_y: root window Y coordinate of mouse click that began the drag
10982 * @timestamp: timestamp of mouse click that began the drag
10984 * Begins a window move operation (for a toplevel window).
10985 * You might use this function to implement a "window move grip," for
10986 * example. The function works best with window managers that support
10987 * the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
10988 * Window Manager Hints</ulink>, but has a fallback implementation for
10989 * other window managers.
10994 gdk_window_begin_move_drag_for_device (GdkWindow *window,
11001 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_move_drag (window,
11002 device, button, root_x, root_y, timestamp);
11006 * gdk_window_begin_move_drag:
11007 * @window: a toplevel #GdkWindow
11008 * @button: the button being used to drag
11009 * @root_x: root window X coordinate of mouse click that began the drag
11010 * @root_y: root window Y coordinate of mouse click that began the drag
11011 * @timestamp: timestamp of mouse click that began the drag
11013 * Begins a window move operation (for a toplevel window).
11015 * This function assumes that the drag is controlled by the
11016 * client pointer device, use gdk_window_begin_move_drag_for_device()
11017 * to begin a drag with a different device.
11020 gdk_window_begin_move_drag (GdkWindow *window,
11026 GdkDeviceManager *device_manager;
11029 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
11030 device = gdk_device_manager_get_client_pointer (device_manager);
11031 gdk_window_begin_move_drag_for_device (window, device, button, root_x, root_y, timestamp);
11035 * gdk_window_enable_synchronized_configure:
11036 * @window: a toplevel #GdkWindow
11038 * Indicates that the application will cooperate with the window
11039 * system in synchronizing the window repaint with the window
11040 * manager during resizing operations. After an application calls
11041 * this function, it must call gdk_window_configure_finished() every
11042 * time it has finished all processing associated with a set of
11043 * Configure events. Toplevel GTK+ windows automatically use this
11046 * On X, calling this function makes @window participate in the
11047 * _NET_WM_SYNC_REQUEST window manager protocol.
11052 gdk_window_enable_synchronized_configure (GdkWindow *window)
11054 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->enable_synchronized_configure (window);
11058 * gdk_window_configure_finished:
11059 * @window: a toplevel #GdkWindow
11061 * Signal to the window system that the application has finished
11062 * handling Configure events it has received. Window Managers can
11063 * use this to better synchronize the frame repaint with the
11064 * application. GTK+ applications will automatically call this
11065 * function when appropriate.
11067 * This function can only be called if gdk_window_enable_synchronized_configure()
11068 * was called previously.
11073 gdk_window_configure_finished (GdkWindow *window)
11075 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->configure_finished (window);
11079 * gdk_window_set_opacity:
11080 * @window: a top-level #GdkWindow
11081 * @opacity: opacity
11083 * Request the windowing system to make @window partially transparent,
11084 * with opacity 0 being fully transparent and 1 fully opaque. (Values
11085 * of the opacity parameter are clamped to the [0,1] range.)
11087 * On X11, this works only on X screens with a compositing manager
11090 * For setting up per-pixel alpha, see gdk_screen_get_rgba_visual().
11091 * For making non-toplevel windows translucent, see
11092 * gdk_window_set_composited().
11097 gdk_window_set_opacity (GdkWindow *window,
11100 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_opacity (window, opacity);
11103 /* This function is called when the XWindow is really gone.
11106 gdk_window_destroy_notify (GdkWindow *window)
11108 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->destroy_notify (window);
11112 * gdk_window_register_dnd:
11113 * @window: a #GdkWindow.
11115 * Registers a window as a potential drop destination.
11118 gdk_window_register_dnd (GdkWindow *window)
11120 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->register_dnd (window);
11124 * gdk_window_get_drag_protocol:
11125 * @window: the destination window
11126 * @target: (out) (allow-none) (transfer full): location of the window
11127 * where the drop should happen. This may be @window or a proxy window,
11128 * or %NULL if @window does not support Drag and Drop.
11130 * Finds out the DND protocol supported by a window.
11132 * Returns: the supported DND protocol.
11137 gdk_window_get_drag_protocol (GdkWindow *window,
11138 GdkWindow **target)
11140 g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_DRAG_PROTO_NONE);
11142 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_drag_protocol (window, target);
11147 * @window: the source window for this drag.
11148 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
11149 * as list of #GdkAtoms
11151 * Starts a drag and creates a new drag context for it.
11152 * This function assumes that the drag is controlled by the
11153 * client pointer device, use gdk_drag_begin_for_device() to
11154 * begin a drag with a different device.
11156 * This function is called by the drag source.
11158 * Return value: (transfer full): a newly created #GdkDragContext
11161 gdk_drag_begin (GdkWindow *window,
11164 GdkDeviceManager *device_manager;
11167 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
11168 device = gdk_device_manager_get_client_pointer (device_manager);
11170 return gdk_drag_begin_for_device (window, device, targets);
11174 * gdk_drag_begin_for_device:
11175 * @window: the source window for this drag
11176 * @device: the device that controls this drag
11177 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
11178 * as list of #GdkAtoms
11180 * Starts a drag and creates a new drag context for it.
11182 * This function is called by the drag source.
11184 * Return value: (transfer full): a newly created #GdkDragContext
11187 gdk_drag_begin_for_device (GdkWindow *window,
11191 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->drag_begin (window, device, targets);
11195 * gdk_test_render_sync:
11196 * @window: a mapped #GdkWindow
11198 * Retrieves a pixel from @window to force the windowing
11199 * system to carry out any pending rendering commands.
11201 * This function is intended to be used to synchronize with rendering
11202 * pipelines, to benchmark windowing system rendering operations.
11207 gdk_test_render_sync (GdkWindow *window)
11209 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->sync_rendering (window);
11213 * gdk_test_simulate_key:
11214 * @window: a #GdkWindow to simulate a key event for
11215 * @x: x coordinate within @window for the key event
11216 * @y: y coordinate within @window for the key event
11217 * @keyval: A GDK keyboard value
11218 * @modifiers: Keyboard modifiers the event is setup with
11219 * @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
11221 * This function is intended to be used in GTK+ test programs.
11222 * If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
11223 * the given (@x,@y) coordinates within @window and simulate a
11224 * key press or release event.
11226 * When the mouse pointer is warped to the target location, use
11227 * of this function outside of test programs that run in their
11228 * own virtual windowing system (e.g. Xvfb) is not recommended.
11229 * If (@x,@y) are passed as (-1,-1), the mouse pointer will not
11230 * be warped and @window origin will be used as mouse pointer
11231 * location for the event.
11233 * Also, gdk_test_simulate_key() is a fairly low level function,
11234 * for most testing purposes, gtk_test_widget_send_key() is the
11235 * right function to call which will generate a key press event
11236 * followed by its accompanying key release event.
11238 * Returns: whether all actions necessary for a key event simulation
11239 * were carried out successfully
11244 gdk_test_simulate_key (GdkWindow *window,
11248 GdkModifierType modifiers,
11249 GdkEventType key_pressrelease)
11251 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11252 ->simulate_key (window, x, y, keyval, modifiers, key_pressrelease);
11256 * gdk_test_simulate_button:
11257 * @window: a #GdkWindow to simulate a button event for
11258 * @x: x coordinate within @window for the button event
11259 * @y: y coordinate within @window for the button event
11260 * @button: Number of the pointer button for the event, usually 1, 2 or 3
11261 * @modifiers: Keyboard modifiers the event is setup with
11262 * @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
11264 * This function is intended to be used in GTK+ test programs.
11265 * It will warp the mouse pointer to the given (@x,@y) coordinates
11266 * within @window and simulate a button press or release event.
11267 * Because the mouse pointer needs to be warped to the target
11268 * location, use of this function outside of test programs that
11269 * run in their own virtual windowing system (e.g. Xvfb) is not
11272 * Also, gdk_test_simulate_button() is a fairly low level function,
11273 * for most testing purposes, gtk_test_widget_click() is the right
11274 * function to call which will generate a button press event followed
11275 * by its accompanying button release event.
11277 * Returns: whether all actions necessary for a button event simulation
11278 * were carried out successfully
11283 gdk_test_simulate_button (GdkWindow *window,
11286 guint button, /*1..3*/
11287 GdkModifierType modifiers,
11288 GdkEventType button_pressrelease)
11290 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11291 ->simulate_button (window, x, y, button, modifiers, button_pressrelease);
11295 * gdk_property_get:
11296 * @window: a #GdkWindow
11297 * @property: the property to retrieve
11298 * @type: the desired property type, or %GDK_NONE, if any type of data
11299 * is acceptable. If this does not match the actual
11300 * type, then @actual_format and @actual_length will
11301 * be filled in, a warning will be printed to stderr
11302 * and no data will be returned.
11303 * @offset: the offset into the property at which to begin
11304 * retrieving data, in 4 byte units.
11305 * @length: the length of the data to retrieve in bytes. Data is
11306 * considered to be retrieved in 4 byte chunks, so @length
11307 * will be rounded up to the next highest 4 byte boundary
11308 * (so be careful not to pass a value that might overflow
11309 * when rounded up).
11310 * @pdelete: if %TRUE, delete the property after retrieving the
11312 * @actual_property_type: (out) (transfer none): location to store the
11313 * actual type of the property.
11314 * @actual_format: (out): location to store the actual return format of the
11315 * data; either 8, 16 or 32 bits.
11316 * @actual_length: location to store the length of the retrieved data, in
11317 * bytes. Data returned in the 32 bit format is stored
11318 * in a long variable, so the actual number of 32 bit
11319 * elements should be be calculated via
11320 * @actual_length / sizeof(glong) to ensure portability to
11322 * @data: (out) (array length=actual_length) (transfer full): location
11323 * to store a pointer to the data. The retrieved data should be
11324 * freed with g_free() when you are finished using it.
11326 * Retrieves a portion of the contents of a property. If the
11327 * property does not exist, then the function returns %FALSE,
11328 * and %GDK_NONE will be stored in @actual_property_type.
11332 * The XGetWindowProperty() function that gdk_property_get()
11333 * uses has a very confusing and complicated set of semantics.
11334 * Unfortunately, gdk_property_get() makes the situation
11335 * worse instead of better (the semantics should be considered
11336 * undefined), and also prints warnings to stderr in cases where it
11337 * should return a useful error to the program. You are advised to use
11338 * XGetWindowProperty() directly until a replacement function for
11339 * gdk_property_get()
11344 * Returns: %TRUE if data was successfully received and stored
11345 * in @data, otherwise %FALSE.
11348 gdk_property_get (GdkWindow *window,
11354 GdkAtom *actual_property_type,
11355 gint *actual_format_type,
11356 gint *actual_length,
11359 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11360 ->get_property (window, property, type, offset, length, pdelete,
11361 actual_property_type, actual_format_type,
11362 actual_length, data);
11366 * gdk_property_change: (skip)
11367 * @window: a #GdkWindow
11368 * @property: the property to change
11369 * @type: the new type for the property. If @mode is
11370 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11371 * must match the existing type or an error will occur.
11372 * @format: the new format for the property. If @mode is
11373 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11374 * must match the existing format or an error will occur.
11375 * @mode: a value describing how the new data is to be combined
11376 * with the current data.
11377 * @data: the data (a <literal>guchar *</literal>
11378 * <literal>gushort *</literal>, or <literal>gulong *</literal>,
11379 * depending on @format), cast to a <literal>guchar *</literal>.
11380 * @nelements: the number of elements of size determined by the format,
11381 * contained in @data.
11383 * Changes the contents of a property on a window.
11386 gdk_property_change (GdkWindow *window,
11391 const guchar *data,
11394 GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11395 ->change_property (window, property, type, format, mode, data, nelements);
11399 * gdk_property_delete:
11400 * @window: a #GdkWindow
11401 * @property: the property to delete
11403 * Deletes a property from a window.
11406 gdk_property_delete (GdkWindow *window,
11409 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->delete_property (window, property);