1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,
3 * Josh MacDonald, Ryan Lortie
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
22 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
23 * file for a list of people on the GTK+ Team. See the ChangeLog
24 * files for a list of changes. These files are distributed with
25 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
30 #include <cairo-gobject.h>
32 #include "gdkwindow.h"
34 #include "gdkrectangle.h"
35 #include "gdkinternals.h"
37 #include "gdkscreenprivate.h"
38 #include "gdkdisplayprivate.h"
39 #include "gdkdeviceprivate.h"
40 #include "gdkvisualprivate.h"
41 #include "gdkmarshalers.h"
42 #include "gdkwindowimpl.h"
46 #undef DEBUG_WINDOW_PRINTING
51 * @Short_description: Onscreen display areas in the target window system
54 * A #GdkWindow is a (usually) rectangular region on the screen.
55 * It's a low-level object, used to implement high-level objects such as
56 * #GtkWidget and #GtkWindow on the GTK+ level. A #GtkWindow is a toplevel
57 * window, the thing a user might think of as a "window" with a titlebar and
58 * so on; a #GtkWindow may contain many #GdkWindows. For example, each
59 * #GtkButton has a #GdkWindow associated with it.
61 * <refsect2 id="COMPOSITED-WINDOWS">
62 * <title>Composited Windows</title>
64 * Normally, the windowing system takes care of rendering the contents of a
65 * child window onto its parent window. This mechanism can be intercepted by
66 * calling gdk_window_set_composited() on the child window. For a
67 * <firstterm>composited</firstterm> window it is the responsibility of the
68 * application to render the window contents at the right spot.
70 * <example id="composited-window-example">
71 * <title>Composited windows</title>
73 * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/gdk/composited-window-example.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>
74 * </programlisting></example>
76 * In the example <xref linkend="composited-window-example"/>, a button is
77 * placed inside of an event box inside of a window. The event box is set as
78 * composited and therefore is no longer automatically drawn to the screen.
80 * When the contents of the event box change, an expose event is generated on
81 * its parent window (which, in this case, belongs to the toplevel #GtkWindow).
82 * The expose handler for this widget is responsible for merging the changes
83 * back on the screen in the way that it wishes.
85 * In our case, we merge the contents with a 50% transparency. We also set the
86 * background colour of the window to red. The effect is that the background
87 * shows through the button.
90 * <refsect2 id="OFFSCREEN-WINDOWS">
91 * <title>Offscreen Windows</title>
93 * Offscreen windows are more general than composited windows, since they allow
94 * not only to modify the rendering of the child window onto its parent, but
95 * also to apply coordinate transformations.
97 * To integrate an offscreen window into a window hierarchy, one has to call
98 * gdk_offscreen_window_set_embedder() and handle a number of signals. The
99 * #GdkWindow::pick-embedded-child signal on the embedder window is used to
100 * select an offscreen child at given coordinates, and the
101 * #GdkWindow::to-embedder and #GdkWindow::from-embedder signals on the
102 * offscreen window are used to translate coordinates between the embedder and
103 * the offscreen window.
105 * For rendering an offscreen window onto its embedder, the contents of the
106 * offscreen window are available as a surface, via
107 * gdk_offscreen_window_get_surface().
113 /* Historically a GdkWindow always matches a platform native window,
114 * be it a toplevel window or a child window. In this setup the
115 * GdkWindow (and other GdkDrawables) were platform independent classes,
116 * and the actual platform specific implementation was in a delegate
117 * object availible as "impl" in the window object.
119 * With the addition of client side windows and offscreen windows this
120 * changes a bit. The application-visible GdkWindow object behaves as
121 * it did before, but not all such windows now have a corresponding native
122 * window. Instead windows that are "client side" are emulated by the gdk
123 * code such that clipping, drawing, moving, events etc work as expected.
125 * For GdkWindows that have a native window the "impl" object is the
126 * same as before. However, for all client side windows the impl object
127 * is shared with its parent (i.e. all client windows descendants of one
128 * native window has the same impl.
130 * Additionally there is a new type of platform independent impl object,
131 * GdkOffscreenWindow. All windows of type GDK_WINDOW_OFFSCREEN get an impl
132 * of this type (while their children are generally GDK_WINDOW_CHILD virtual
133 * windows). Such windows work by allocating a #cairo_surface_t as the backing
134 * store for drawing operations, which is resized with the window.
136 * GdkWindows have a pointer to the "impl window" they are in, i.e.
137 * the topmost GdkWindow which have the same "impl" value. This is stored
138 * in impl_window, which is different from the window itself only for client
140 * All GdkWindows (native or not) track the position of the window in the parent
141 * (x, y), the size of the window (width, height), the position of the window
142 * with respect to the impl window (abs_x, abs_y). We also track the clip
143 * region of the window wrt parent windows and siblings, in window-relative
144 * coordinates with and without child windows included (clip_region,
145 * clip_region_with_children).
147 * All toplevel windows are native windows, but also child windows can be
148 * native (although not children of offscreens). We always listen to
149 * a basic set of events (see get_native_event_mask) for these windows
150 * so that we can emulate events for any client side children.
152 * For native windows we apply the calculated clip region as a window shape
153 * so that eg. client side siblings that overlap the native child properly
154 * draws over the native child window.
156 * In order to minimize flicker and for performance we use a couple of cacheing
157 * tricks. First of all, every time we do a window to window copy area, for instance
158 * when moving a client side window or when scrolling/moving a region in a window
159 * we store this in outstanding_moves instead of applying immediately. We then
160 * delay this move until we really need it (because something depends on being
161 * able to read it), or until we're handing a redraw from an expose/invalidation
162 * (actually we delay it past redraw, but before blitting the double buffer
163 * to the window). This gives us two advantages. First of all it minimizes the time
164 * from the window is moved to the exposes related to that move, secondly it allows
165 * us to be smart about how to do the copy. We combine multiple moves into one (when
166 * possible) and we don't actually do copies to anything that is or will be
167 * invalidated and exposed anyway.
169 * Secondly, we use something called a "implicit paint" during repaint handling.
170 * An implicit paint is similar to a regular paint for the paint stack, but it is
171 * not put on the stack. Instead, it is set on the impl window, and later when
172 * regular gdk_window_begin_paint_region() happen on a window of this impl window
173 * we reuse the surface from the implicit paint. During repaint we create and at the
174 * end flush an implicit paint, which means we can collect all the paints on
175 * multiple client side windows in the same backing store.
178 #define USE_BACKING_STORE /* Appears to work on Win32, too, now. */
180 /* This adds a local value to the GdkVisibilityState enum */
181 #define GDK_VISIBILITY_NOT_VIEWABLE 3
184 PICK_EMBEDDED_CHILD, /* only called if children are embedded */
198 CLEAR_BG_WINCLEARED, /* Clear backgrounds except those that the window system clears */
202 struct _GdkWindowPaint
204 cairo_region_t *region;
205 cairo_surface_t *surface;
206 guint uses_implicit : 1;
211 cairo_region_t *dest_region; /* The destination region */
212 int dx, dy; /* The amount that the source was moved to reach dest_region */
213 } GdkWindowRegionMove;
217 static void gdk_window_drop_cairo_surface (GdkWindow *private);
219 static void gdk_window_free_paint_stack (GdkWindow *window);
221 static void gdk_window_finalize (GObject *object);
223 static void gdk_window_set_property (GObject *object,
227 static void gdk_window_get_property (GObject *object,
232 static void gdk_window_clear_backing_region (GdkWindow *window,
233 cairo_region_t *region);
235 static void recompute_visible_regions (GdkWindow *private,
236 gboolean recalculate_siblings,
237 gboolean recalculate_children);
238 static void gdk_window_flush_outstanding_moves (GdkWindow *window);
239 static void gdk_window_flush_recursive (GdkWindow *window);
240 static void do_move_region_bits_on_impl (GdkWindow *window,
241 cairo_region_t *region, /* In impl window coords */
243 static void gdk_window_invalidate_in_parent (GdkWindow *private);
244 static void move_native_children (GdkWindow *private);
245 static void update_cursor (GdkDisplay *display,
247 static void impl_window_add_update_area (GdkWindow *impl_window,
248 cairo_region_t *region);
249 static void gdk_window_region_move_free (GdkWindowRegionMove *move);
250 static void gdk_window_invalidate_region_full (GdkWindow *window,
251 const cairo_region_t *region,
252 gboolean invalidate_children,
254 static void gdk_window_invalidate_rect_full (GdkWindow *window,
255 const GdkRectangle *rect,
256 gboolean invalidate_children,
258 static void _gdk_window_propagate_has_alpha_background (GdkWindow *window);
260 static guint signals[LAST_SIGNAL] = { 0 };
262 static gpointer parent_class = NULL;
264 static const cairo_user_data_key_t gdk_window_cairo_key;
266 G_DEFINE_ABSTRACT_TYPE (GdkWindow, gdk_window, G_TYPE_OBJECT)
269 _gdk_paintable_get_type (void)
271 static GType paintable_type = 0;
275 const GTypeInfo paintable_info =
277 sizeof (GdkPaintableIface), /* class_size */
278 NULL, /* base_init */
279 NULL, /* base_finalize */
282 paintable_type = g_type_register_static (G_TYPE_INTERFACE,
283 g_intern_static_string ("GdkPaintable"),
286 g_type_interface_add_prerequisite (paintable_type, G_TYPE_OBJECT);
289 return paintable_type;
293 gdk_window_init (GdkWindow *window)
295 /* 0-initialization is good for all other fields. */
297 window->window_type = GDK_WINDOW_CHILD;
299 window->state = GDK_WINDOW_STATE_WITHDRAWN;
302 window->toplevel_window_type = -1;
304 window->effective_visibility = GDK_VISIBILITY_NOT_VIEWABLE;
305 window->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
306 /* Default to unobscured since some backends don't send visibility events */
307 window->native_visibility = GDK_VISIBILITY_UNOBSCURED;
309 window->device_cursor = g_hash_table_new_full (NULL, NULL,
310 NULL, g_object_unref);
313 /* Stop and return on the first non-NULL parent */
315 accumulate_get_window (GSignalInvocationHint *ihint,
317 const GValue *handler_return,
320 g_value_copy (handler_return, return_accu);
321 /* Continue while returning NULL */
322 return g_value_get_object (handler_return) == NULL;
326 create_surface_accumulator (GSignalInvocationHint *ihint,
328 const GValue *handler_return,
331 g_value_copy (handler_return, return_accu);
333 /* Stop on the first non-NULL return value */
334 return g_value_get_boxed (handler_return) == NULL;
337 static GQuark quark_pointer_window = 0;
340 gdk_window_class_init (GdkWindowClass *klass)
342 GObjectClass *object_class = G_OBJECT_CLASS (klass);
344 parent_class = g_type_class_peek_parent (klass);
346 object_class->finalize = gdk_window_finalize;
347 object_class->set_property = gdk_window_set_property;
348 object_class->get_property = gdk_window_get_property;
350 klass->create_surface = _gdk_offscreen_window_create_surface;
352 quark_pointer_window = g_quark_from_static_string ("gtk-pointer-window");
360 * The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and
361 * gdk_window_get_cursor() for details.
365 g_object_class_install_property (object_class,
367 g_param_spec_object ("cursor",
374 * GdkWindow::pick-embedded-child:
375 * @window: the window on which the signal is emitted
376 * @x: x coordinate in the window
377 * @y: y coordinate in the window
379 * The ::pick-embedded-child signal is emitted to find an embedded
380 * child at the given position.
382 * Returns: (transfer none): the #GdkWindow of the embedded child at
387 signals[PICK_EMBEDDED_CHILD] =
388 g_signal_new (g_intern_static_string ("pick-embedded-child"),
389 G_OBJECT_CLASS_TYPE (object_class),
391 G_STRUCT_OFFSET (GdkWindowClass, pick_embedded_child),
392 accumulate_get_window, NULL,
393 _gdk_marshal_OBJECT__DOUBLE_DOUBLE,
400 * GdkWindow::to-embedder:
401 * @window: the offscreen window on which the signal is emitted
402 * @offscreen-x: x coordinate in the offscreen window
403 * @offscreen-y: y coordinate in the offscreen window
404 * @embedder-x: (out) (type double): return location for the x
405 * coordinate in the embedder window
406 * @embedder-y: (out) (type double): return location for the y
407 * coordinate in the embedder window
409 * The ::to-embedder signal is emitted to translate coordinates
410 * in an offscreen window to its embedder.
412 * See also #GtkWindow::from-embedder.
416 signals[TO_EMBEDDER] =
417 g_signal_new (g_intern_static_string ("to-embedder"),
418 G_OBJECT_CLASS_TYPE (object_class),
420 G_STRUCT_OFFSET (GdkWindowClass, to_embedder),
422 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
431 * GdkWindow::from-embedder:
432 * @window: the offscreen window on which the signal is emitted
433 * @embedder-x: x coordinate in the embedder window
434 * @embedder-y: y coordinate in the embedder window
435 * @offscreen-x: (out) (type double): return location for the x
436 * coordinate in the offscreen window
437 * @offscreen-y: (out) (type double): return location for the y
438 * coordinate in the offscreen window
440 * The ::from-embedder signal is emitted to translate coordinates
441 * in the embedder of an offscreen window to the offscreen window.
443 * See also #GtkWindow::to-embedder.
447 signals[FROM_EMBEDDER] =
448 g_signal_new (g_intern_static_string ("from-embedder"),
449 G_OBJECT_CLASS_TYPE (object_class),
451 G_STRUCT_OFFSET (GdkWindowClass, from_embedder),
453 _gdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
462 * GdkWindow::create-surface:
463 * @window: the offscreen window on which the signal is emitted
464 * @width: the width of the offscreen surface to create
465 * @height: the height of the offscreen surface to create
467 * The ::create-surface signal is emitted when an offscreen window
468 * needs its surface (re)created, which happens either when the the
469 * window is first drawn to, or when the window is being
470 * resized. The first signal handler that returns a non-%NULL
471 * surface will stop any further signal emission, and its surface
474 * Note that it is not possible to access the window's previous
475 * surface from within any callback of this signal. Calling
476 * gdk_offscreen_window_get_surface() will lead to a crash.
478 * Returns: the newly created #cairo_surface_t for the offscreen window
482 signals[CREATE_SURFACE] =
483 g_signal_new (g_intern_static_string ("create-surface"),
484 G_OBJECT_CLASS_TYPE (object_class),
486 G_STRUCT_OFFSET (GdkWindowClass, create_surface),
487 create_surface_accumulator, NULL,
488 _gdk_marshal_BOXED__INT_INT,
489 CAIRO_GOBJECT_TYPE_SURFACE,
496 device_removed_cb (GdkDeviceManager *device_manager,
500 window->devices_inside = g_list_remove (window->devices_inside, device);
501 g_hash_table_remove (window->device_cursor, device);
503 if (window->device_events)
504 g_hash_table_remove (window->device_events, device);
508 gdk_window_finalize (GObject *object)
510 GdkWindow *window = GDK_WINDOW (object);
511 GdkDeviceManager *device_manager;
513 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
514 g_signal_handlers_disconnect_by_func (device_manager, device_removed_cb, window);
516 if (!GDK_WINDOW_DESTROYED (window))
518 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
520 g_warning ("losing last reference to undestroyed window\n");
521 _gdk_window_destroy (window, FALSE);
524 /* We use TRUE here, to keep us from actually calling
525 * XDestroyWindow() on the window
527 _gdk_window_destroy (window, TRUE);
530 gdk_window_drop_cairo_surface (window);
534 g_object_unref (window->impl);
538 if (window->impl_window != window)
540 g_object_unref (window->impl_window);
541 window->impl_window = NULL;
545 cairo_region_destroy (window->shape);
547 if (window->input_shape)
548 cairo_region_destroy (window->input_shape);
551 g_object_unref (window->cursor);
553 if (window->device_cursor)
554 g_hash_table_destroy (window->device_cursor);
556 if (window->device_events)
557 g_hash_table_destroy (window->device_events);
559 if (window->source_event_masks)
560 g_hash_table_destroy (window->source_event_masks);
562 if (window->devices_inside)
563 g_list_free (window->devices_inside);
565 G_OBJECT_CLASS (parent_class)->finalize (object);
569 gdk_window_set_property (GObject *object,
574 GdkWindow *window = (GdkWindow *)object;
579 gdk_window_set_cursor (window, g_value_get_object (value));
583 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
589 gdk_window_get_property (GObject *object,
594 GdkWindow *window = (GdkWindow *) object;
599 g_value_set_object (value, gdk_window_get_cursor (window));
603 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
609 gdk_window_is_offscreen (GdkWindow *window)
611 return window->window_type == GDK_WINDOW_OFFSCREEN;
615 gdk_window_get_impl_window (GdkWindow *window)
617 return window->impl_window;
621 _gdk_window_get_impl_window (GdkWindow *window)
623 return gdk_window_get_impl_window (window);
627 gdk_window_has_impl (GdkWindow *window)
629 return window->impl_window == window;
633 gdk_window_is_toplevel (GdkWindow *window)
636 window->parent == NULL ||
637 window->parent->window_type == GDK_WINDOW_ROOT;
641 _gdk_window_has_impl (GdkWindow *window)
643 return gdk_window_has_impl (window);
647 gdk_window_has_no_impl (GdkWindow *window)
649 return window->impl_window != window;
653 remove_child_area (GdkWindow *private,
656 cairo_region_t *region,
657 cairo_region_t *layered_region)
660 cairo_region_t *child_region;
663 cairo_region_t *shape;
665 for (l = private->children; l; l = l->next)
672 /* If region is empty already, no need to do
673 anything potentially costly */
674 if (cairo_region_is_empty (region))
677 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
680 /* Ignore offscreen children, as they don't draw in their parent and
681 * don't take part in the clipping */
682 if (gdk_window_is_offscreen (child))
687 r.width = child->width;
688 r.height = child->height;
690 /* Bail early if child totally outside region */
691 if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
694 child_region = cairo_region_create_rectangle (&r);
698 /* Adjust shape region to parent window coords */
699 cairo_region_translate (child->shape, child->x, child->y);
700 cairo_region_intersect (child_region, child->shape);
701 cairo_region_translate (child->shape, -child->x, -child->y);
703 else if (private->window_type == GDK_WINDOW_FOREIGN)
705 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_shape (child);
708 cairo_region_intersect (child_region, shape);
709 cairo_region_destroy (shape);
715 if (child->input_shape)
716 cairo_region_intersect (child_region, child->input_shape);
717 else if (private->window_type == GDK_WINDOW_FOREIGN)
719 shape = GDK_WINDOW_IMPL_GET_CLASS (child)->get_input_shape (child);
722 cairo_region_intersect (child_region, shape);
723 cairo_region_destroy (shape);
728 if (child->has_alpha_background)
730 if (layered_region != NULL)
731 cairo_region_union (layered_region, child_region);
734 cairo_region_subtract (region, child_region);
735 cairo_region_destroy (child_region);
740 static GdkVisibilityState
741 effective_visibility (GdkWindow *window)
743 GdkVisibilityState native;
745 if (!gdk_window_is_viewable (window))
746 return GDK_VISIBILITY_NOT_VIEWABLE;
748 native = window->impl_window->native_visibility;
750 if (native == GDK_VISIBILITY_FULLY_OBSCURED ||
751 window->visibility == GDK_VISIBILITY_FULLY_OBSCURED)
752 return GDK_VISIBILITY_FULLY_OBSCURED;
753 else if (native == GDK_VISIBILITY_UNOBSCURED)
754 return window->visibility;
755 else /* native PARTIAL, private partial or unobscured */
756 return GDK_VISIBILITY_PARTIAL;
760 gdk_window_update_visibility (GdkWindow *window)
762 GdkVisibilityState new_visibility;
765 new_visibility = effective_visibility (window);
767 if (new_visibility != window->effective_visibility)
769 window->effective_visibility = new_visibility;
771 if (new_visibility != GDK_VISIBILITY_NOT_VIEWABLE &&
772 window->event_mask & GDK_VISIBILITY_NOTIFY)
774 event = _gdk_make_event (window, GDK_VISIBILITY_NOTIFY,
776 event->visibility.state = new_visibility;
782 gdk_window_update_visibility_recursively (GdkWindow *window,
783 GdkWindow *only_for_impl)
788 gdk_window_update_visibility (window);
789 for (l = window->children; l != NULL; l = l->next)
792 if ((only_for_impl == NULL) ||
793 (only_for_impl == child->impl_window))
794 gdk_window_update_visibility_recursively (child, only_for_impl);
799 should_apply_clip_as_shape (GdkWindow *window)
802 gdk_window_has_impl (window) &&
803 /* Not for offscreens */
804 !gdk_window_is_offscreen (window) &&
805 /* or for toplevels */
806 !gdk_window_is_toplevel (window) &&
807 /* or for foreign windows */
808 window->window_type != GDK_WINDOW_FOREIGN &&
809 /* or for the root window */
810 window->window_type != GDK_WINDOW_ROOT;
814 apply_shape (GdkWindow *window,
815 cairo_region_t *region)
817 GdkWindowImplClass *impl_class;
819 /* We trash whether we applied a shape so that
820 we can avoid unsetting it many times, which
821 could happen in e.g. apply_clip_as_shape as
822 windows get resized */
823 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
825 impl_class->shape_combine_region (window,
827 else if (window->applied_shape)
828 impl_class->shape_combine_region (window,
831 window->applied_shape = region != NULL;
835 region_rect_equal (const cairo_region_t *region,
836 const GdkRectangle *rect)
838 GdkRectangle extents;
840 if (cairo_region_num_rectangles (region) != 1)
843 cairo_region_get_extents (region, &extents);
845 return extents.x == rect->x &&
846 extents.y == rect->y &&
847 extents.width == rect->width &&
848 extents.height == rect->height;
852 apply_clip_as_shape (GdkWindow *window)
857 r.width = window->width;
858 r.height = window->height;
860 /* We only apply the clip region if would differ
861 from the actual clip region implied by the size
862 of the window. This is to avoid unneccessarily
863 adding meaningless shapes to all native subwindows */
864 if (!region_rect_equal (window->clip_region, &r))
865 apply_shape (window, window->clip_region);
867 apply_shape (window, NULL);
871 recompute_visible_regions_internal (GdkWindow *private,
872 gboolean recalculate_clip,
873 gboolean recalculate_siblings,
874 gboolean recalculate_children)
879 cairo_region_t *new_clip, *new_layered;
880 gboolean clip_region_changed;
881 gboolean abs_pos_changed;
882 int old_abs_x, old_abs_y;
884 old_abs_x = private->abs_x;
885 old_abs_y = private->abs_y;
887 /* Update absolute position */
888 if (gdk_window_has_impl (private))
890 /* Native window starts here */
896 private->abs_x = private->parent->abs_x + private->x;
897 private->abs_y = private->parent->abs_y + private->y;
901 private->abs_x != old_abs_x ||
902 private->abs_y != old_abs_y;
904 /* Update clip region based on:
907 * siblings in parents above window
909 clip_region_changed = FALSE;
910 if (recalculate_clip)
912 new_layered = cairo_region_create ();
913 if (private->viewable)
915 /* Calculate visible region (sans children) in parent window coords */
918 r.width = private->width;
919 r.height = private->height;
920 new_clip = cairo_region_create_rectangle (&r);
922 if (!gdk_window_is_toplevel (private))
924 cairo_region_intersect (new_clip, private->parent->clip_region);
925 cairo_region_union (new_layered, private->parent->layered_region);
927 /* Remove all overlapping children from parent. */
928 remove_child_area (private->parent, private, FALSE, new_clip, new_layered);
931 /* Convert from parent coords to window coords */
932 cairo_region_translate (new_clip, -private->x, -private->y);
933 cairo_region_translate (new_layered, -private->x, -private->y);
936 cairo_region_intersect (new_clip, private->shape);
939 new_clip = cairo_region_create ();
941 cairo_region_intersect (new_layered, new_clip);
943 if (private->clip_region == NULL ||
944 !cairo_region_equal (private->clip_region, new_clip))
945 clip_region_changed = TRUE;
947 if (private->layered_region == NULL ||
948 !cairo_region_equal (private->layered_region, new_layered))
949 clip_region_changed = TRUE;
951 if (private->clip_region)
952 cairo_region_destroy (private->clip_region);
953 private->clip_region = new_clip;
955 if (private->layered_region != NULL)
956 cairo_region_destroy (private->layered_region);
957 private->layered_region = new_layered;
959 if (private->clip_region_with_children)
960 cairo_region_destroy (private->clip_region_with_children);
961 private->clip_region_with_children = cairo_region_copy (private->clip_region);
962 if (private->window_type != GDK_WINDOW_ROOT)
963 remove_child_area (private, NULL, FALSE, private->clip_region_with_children, NULL);
966 if (clip_region_changed)
968 GdkVisibilityState visibility;
969 gboolean fully_visible;
971 if (cairo_region_is_empty (private->clip_region))
972 visibility = GDK_VISIBILITY_FULLY_OBSCURED;
977 fully_visible = cairo_region_equal (private->clip_region,
984 r.width = private->width;
985 r.height = private->height;
986 fully_visible = region_rect_equal (private->clip_region, &r);
990 visibility = GDK_VISIBILITY_UNOBSCURED;
992 visibility = GDK_VISIBILITY_PARTIAL;
995 if (private->visibility != visibility)
997 private->visibility = visibility;
998 gdk_window_update_visibility (private);
1002 /* Update all children, recursively (except for root, where children are not exact). */
1003 if ((abs_pos_changed || clip_region_changed || recalculate_children) &&
1004 private->window_type != GDK_WINDOW_ROOT)
1006 for (l = private->children; l; l = l->next)
1009 /* Only recalculate clip if the the clip region changed, otherwise
1010 * there is no way the child clip region could change (its has not e.g. moved)
1011 * Except if recalculate_children is set to force child updates
1013 recompute_visible_regions_internal (child,
1014 recalculate_clip && (clip_region_changed || recalculate_children),
1019 if (clip_region_changed &&
1020 should_apply_clip_as_shape (private))
1021 apply_clip_as_shape (private);
1023 if (recalculate_siblings &&
1024 !gdk_window_is_toplevel (private))
1026 /* If we moved a child window in parent or changed the stacking order, then we
1027 * need to recompute the visible area of all the other children in the parent
1029 for (l = private->parent->children; l; l = l->next)
1033 if (child != private)
1034 recompute_visible_regions_internal (child, TRUE, FALSE, FALSE);
1037 /* We also need to recompute the _with_children clip for the parent */
1038 recompute_visible_regions_internal (private->parent, TRUE, FALSE, FALSE);
1041 if (private->cairo_surface && gdk_window_has_impl (private))
1043 GdkWindowImplClass *iface = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1045 private->cairo_surface = iface->resize_cairo_surface (private,
1046 private->cairo_surface,
1050 else if (private->cairo_surface)
1051 gdk_window_drop_cairo_surface (private);
1054 /* Call this when private has changed in one or more of these ways:
1058 * stacking order of window changed
1061 * It will recalculate abs_x/y and the clip regions
1063 * Unless the window didn't change stacking order or size/pos, pass in TRUE
1064 * for recalculate_siblings. (Mostly used internally for the recursion)
1066 * If a child window was removed (and you can't use that child for
1067 * recompute_visible_regions), pass in TRUE for recalculate_children on the parent
1070 recompute_visible_regions (GdkWindow *private,
1071 gboolean recalculate_siblings,
1072 gboolean recalculate_children)
1074 recompute_visible_regions_internal (private,
1076 recalculate_siblings,
1077 recalculate_children);
1081 _gdk_window_update_size (GdkWindow *window)
1083 recompute_visible_regions (window, TRUE, FALSE);
1086 /* Find the native window that would be just above "child"
1087 * in the native stacking order if "child" was a native window
1088 * (it doesn't have to be native). If there is no such native
1089 * window inside this native parent then NULL is returned.
1090 * If child is NULL, find lowest native window in parent.
1093 find_native_sibling_above_helper (GdkWindow *parent,
1101 l = g_list_find (parent->children, child);
1102 g_assert (l != NULL); /* Better be a child of its parent... */
1103 l = l->prev; /* Start looking at the one above the child */
1106 l = g_list_last (parent->children);
1108 for (; l != NULL; l = l->prev)
1112 if (gdk_window_has_impl (w))
1115 g_assert (parent != w);
1116 w = find_native_sibling_above_helper (w, NULL);
1126 find_native_sibling_above (GdkWindow *parent,
1131 w = find_native_sibling_above_helper (parent, child);
1135 if (gdk_window_has_impl (parent))
1138 return find_native_sibling_above (parent->parent, parent);
1142 get_native_device_event_mask (GdkWindow *private,
1145 GdkEventMask event_mask;
1148 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device));
1150 event_mask = private->event_mask;
1152 if (private->window_type == GDK_WINDOW_ROOT ||
1153 private->window_type == GDK_WINDOW_FOREIGN)
1159 /* Do whatever the app asks to, since the app
1160 * may be asking for weird things for native windows,
1161 * but don't use motion hints as that may affect non-native
1162 * child windows that don't want it. Also, we need to
1163 * set all the app-specified masks since they will be picked
1164 * up by any implicit grabs (i.e. if they were not set as
1165 * native we would not get the events we need). */
1166 mask = private->event_mask & ~GDK_POINTER_MOTION_HINT_MASK;
1168 /* We need thse for all native windows so we can
1169 emulate events on children: */
1172 GDK_VISIBILITY_NOTIFY_MASK |
1173 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
1175 /* Additionally we select for pointer and button events
1176 * for toplevels as we need to get these to emulate
1177 * them for non-native subwindows. Even though we don't
1178 * select on them for all native windows we will get them
1179 * as the events are propagated out to the first window
1180 * that select for them.
1181 * Not selecting for button press on all windows is an
1182 * important thing, because in X only one client can do
1183 * so, and we don't want to unexpectedly prevent another
1184 * client from doing it.
1186 * We also need to do the same if the app selects for button presses
1187 * because then we will get implicit grabs for this window, and the
1188 * event mask used for that grab is based on the rest of the mask
1189 * for the window, but we might need more events than this window
1190 * lists due to some non-native child window.
1192 if (gdk_window_is_toplevel (private) ||
1193 mask & GDK_BUTTON_PRESS_MASK)
1195 GDK_POINTER_MOTION_MASK |
1196 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1204 get_native_grab_event_mask (GdkEventMask grab_mask)
1206 /* Similar to the above but for pointer events only */
1208 GDK_POINTER_MOTION_MASK |
1209 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1210 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
1213 ~GDK_POINTER_MOTION_HINT_MASK);
1217 get_native_event_mask (GdkWindow *private)
1219 return get_native_device_event_mask (private, NULL);
1222 /* Puts the native window in the right order wrt the other native windows
1223 * in the hierarchy, given the position it has in the client side data.
1224 * This is useful if some operation changed the stacking order.
1225 * This calls assumes the native window is now topmost in its native parent.
1228 sync_native_window_stack_position (GdkWindow *window)
1231 GdkWindowImplClass *impl_class;
1232 GList listhead = {0};
1234 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1236 above = find_native_sibling_above (window->parent, window);
1239 listhead.data = window;
1240 impl_class->restack_under (above, &listhead);
1245 * gdk_window_new: (constructor)
1246 * @parent: (allow-none): a #GdkWindow, or %NULL to create the window as a child of
1247 * the default root window for the default display.
1248 * @attributes: attributes of the new window
1249 * @attributes_mask: mask indicating which fields in @attributes are valid
1251 * Creates a new #GdkWindow using the attributes from
1252 * @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
1253 * more details. Note: to use this on displays other than the default
1254 * display, @parent must be specified.
1256 * Return value: (transfer full): the new #GdkWindow
1259 gdk_window_new (GdkWindow *parent,
1260 GdkWindowAttr *attributes,
1261 gint attributes_mask)
1265 GdkDisplay *display;
1268 GdkEventMask event_mask;
1269 GdkWindow *real_parent;
1270 GdkDeviceManager *device_manager;
1272 g_return_val_if_fail (attributes != NULL, NULL);
1276 GDK_NOTE (MULTIHEAD,
1277 g_warning ("gdk_window_new(): no parent specified reverting to parent = default root window"));
1279 screen = gdk_screen_get_default ();
1280 parent = gdk_screen_get_root_window (screen);
1283 screen = gdk_window_get_screen (parent);
1285 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
1287 if (GDK_WINDOW_DESTROYED (parent))
1289 g_warning ("gdk_window_new(): parent is destroyed\n");
1293 display = gdk_screen_get_display (screen);
1295 window = _gdk_display_create_window (display);
1297 /* Windows with a foreign parent are treated as if they are children
1298 * of the root window, except for actual creation.
1300 real_parent = parent;
1301 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
1302 parent = gdk_screen_get_root_window (screen);
1304 window->parent = parent;
1306 window->accept_focus = TRUE;
1307 window->focus_on_map = TRUE;
1309 if (attributes_mask & GDK_WA_X)
1314 if (attributes_mask & GDK_WA_Y)
1321 window->width = (attributes->width > 1) ? (attributes->width) : (1);
1322 window->height = (attributes->height > 1) ? (attributes->height) : (1);
1324 if (attributes->wclass == GDK_INPUT_ONLY)
1326 /* Backwards compatiblity - we've always ignored
1327 * attributes->window_type for input-only windows
1330 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_ROOT)
1331 window->window_type = GDK_WINDOW_TEMP;
1333 window->window_type = GDK_WINDOW_CHILD;
1336 window->window_type = attributes->window_type;
1339 switch (window->window_type)
1341 case GDK_WINDOW_TOPLEVEL:
1342 case GDK_WINDOW_TEMP:
1343 case GDK_WINDOW_OFFSCREEN:
1344 if (GDK_WINDOW_TYPE (parent) != GDK_WINDOW_ROOT)
1345 g_warning (G_STRLOC "Toplevel windows must be created as children of\n"
1346 "of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
1347 case GDK_WINDOW_CHILD:
1351 g_warning (G_STRLOC "cannot make windows of type %d", window->window_type);
1355 if (attributes_mask & GDK_WA_VISUAL)
1356 window->visual = attributes->visual;
1358 window->visual = gdk_screen_get_system_visual (screen);
1360 window->event_mask = attributes->event_mask;
1362 if (attributes->wclass == GDK_INPUT_OUTPUT)
1364 window->input_only = FALSE;
1365 window->depth = window->visual->depth;
1367 /* XXX: Cache this somehow? */
1368 window->background = cairo_pattern_create_rgb (0, 0, 0);
1373 window->input_only = TRUE;
1377 window->parent->children = g_list_prepend (window->parent->children, window);
1380 if (window->parent->window_type == GDK_WINDOW_ROOT)
1381 native = TRUE; /* Always use native windows for toplevels */
1382 else if (!window->input_only &&
1383 (attributes_mask & GDK_WA_VISUAL &&
1384 attributes->visual != gdk_window_get_visual (window->parent)))
1385 native = TRUE; /* InputOutput window with different visual than parent, needs native window */
1387 if (gdk_window_is_offscreen (window))
1389 _gdk_offscreen_window_new (window, attributes, attributes_mask);
1390 window->impl_window = window;
1394 event_mask = get_native_event_mask (window);
1396 /* Create the impl */
1397 _gdk_display_create_window_impl (display, window, real_parent, screen, event_mask, attributes, attributes_mask);
1398 window->impl_window = window;
1400 /* This will put the native window topmost in the native parent, which may
1401 * be wrong wrt other native windows in the non-native hierarchy, so restack */
1402 if (!_gdk_window_has_impl (real_parent))
1403 sync_native_window_stack_position (window);
1407 window->impl_window = g_object_ref (window->parent->impl_window);
1408 window->impl = g_object_ref (window->impl_window->impl);
1411 recompute_visible_regions (window, TRUE, FALSE);
1413 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
1414 (attributes->cursor) :
1417 device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent));
1418 g_signal_connect (device_manager, "device-removed",
1419 G_CALLBACK (device_removed_cb), window);
1425 is_parent_of (GdkWindow *parent,
1436 w = gdk_window_get_parent (w);
1443 change_impl (GdkWindow *private,
1444 GdkWindow *impl_window,
1449 GdkWindowImpl *old_impl;
1450 GdkWindow *old_impl_window;
1452 old_impl = private->impl;
1453 old_impl_window = private->impl_window;
1454 if (private != impl_window)
1455 private->impl_window = g_object_ref (impl_window);
1457 private->impl_window = private;
1458 private->impl = g_object_ref (new);
1459 if (old_impl_window != private)
1460 g_object_unref (old_impl_window);
1461 g_object_unref (old_impl);
1463 for (l = private->children; l != NULL; l = l->next)
1467 if (child->impl == old_impl)
1468 change_impl (child, impl_window, new);
1473 reparent_to_impl (GdkWindow *private)
1478 GdkWindowImplClass *impl_class;
1480 impl_class = GDK_WINDOW_IMPL_GET_CLASS (private->impl);
1482 /* Enumerate in reverse order so we get the right order for the native
1483 windows (first in childrens list is topmost, and reparent places on top) */
1484 for (l = g_list_last (private->children); l != NULL; l = l->prev)
1488 if (child->impl == private->impl)
1489 reparent_to_impl (child);
1492 show = impl_class->reparent ((GdkWindow *)child,
1493 (GdkWindow *)private,
1494 child->x, child->y);
1496 gdk_window_show_unraised ((GdkWindow *)child);
1503 * gdk_window_reparent:
1504 * @window: a #GdkWindow
1505 * @new_parent: new parent to move @window into
1506 * @x: X location inside the new parent
1507 * @y: Y location inside the new parent
1509 * Reparents @window into the given @new_parent. The window being
1510 * reparented will be unmapped as a side effect.
1514 gdk_window_reparent (GdkWindow *window,
1515 GdkWindow *new_parent,
1519 GdkWindow *old_parent;
1521 gboolean show, was_mapped, applied_clip_as_shape;
1522 gboolean do_reparent_to_impl;
1523 GdkEventMask old_native_event_mask;
1524 GdkWindowImplClass *impl_class;
1526 g_return_if_fail (GDK_IS_WINDOW (window));
1527 g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1528 g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1530 if (GDK_WINDOW_DESTROYED (window) ||
1531 (new_parent && GDK_WINDOW_DESTROYED (new_parent)))
1534 screen = gdk_window_get_screen (window);
1536 new_parent = gdk_screen_get_root_window (screen);
1538 /* No input-output children of input-only windows */
1539 if (new_parent->input_only && !window->input_only)
1542 /* Don't create loops in hierarchy */
1543 if (is_parent_of (window, new_parent))
1546 /* This might be wrong in the new parent, e.g. for non-native surfaces.
1547 To make sure we're ok, just wipe it. */
1548 gdk_window_drop_cairo_surface (window);
1550 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1551 old_parent = window->parent;
1553 was_mapped = GDK_WINDOW_IS_MAPPED (window);
1556 /* Reparenting to toplevel. Ensure we have a native window so this can work */
1557 if (new_parent->window_type == GDK_WINDOW_ROOT ||
1558 new_parent->window_type == GDK_WINDOW_FOREIGN)
1559 gdk_window_ensure_native (window);
1561 applied_clip_as_shape = should_apply_clip_as_shape (window);
1563 old_native_event_mask = 0;
1564 do_reparent_to_impl = FALSE;
1565 if (gdk_window_has_impl (window))
1567 old_native_event_mask = get_native_event_mask (window);
1569 show = impl_class->reparent (window, new_parent, x, y);
1573 /* This shouldn't happen, as we created a native in this case, check anyway to see if that ever fails */
1574 g_assert (new_parent->window_type != GDK_WINDOW_ROOT &&
1575 new_parent->window_type != GDK_WINDOW_FOREIGN);
1578 gdk_window_hide (window);
1580 do_reparent_to_impl = TRUE;
1581 change_impl (window,
1582 new_parent->impl_window,
1586 /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1589 if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1591 new_parent = gdk_screen_get_root_window (screen);
1595 old_parent->children = g_list_remove (old_parent->children, window);
1597 window->parent = new_parent;
1601 new_parent->children = g_list_prepend (new_parent->children, window);
1603 /* Switch the window type as appropriate */
1605 switch (GDK_WINDOW_TYPE (new_parent))
1607 case GDK_WINDOW_ROOT:
1608 case GDK_WINDOW_FOREIGN:
1609 if (window->toplevel_window_type != -1)
1610 GDK_WINDOW_TYPE (window) = window->toplevel_window_type;
1611 else if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
1612 GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
1614 case GDK_WINDOW_OFFSCREEN:
1615 case GDK_WINDOW_TOPLEVEL:
1616 case GDK_WINDOW_CHILD:
1617 case GDK_WINDOW_TEMP:
1618 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
1619 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
1621 /* Save the original window type so we can restore it if the
1622 * window is reparented back to be a toplevel
1624 window->toplevel_window_type = GDK_WINDOW_TYPE (window);
1625 GDK_WINDOW_TYPE (window) = GDK_WINDOW_CHILD;
1629 /* We might have changed window type for a native windows, so we
1630 need to change the event mask too. */
1631 if (gdk_window_has_impl (window))
1633 GdkEventMask native_event_mask = get_native_event_mask (window);
1635 if (native_event_mask != old_native_event_mask)
1636 impl_class->set_events (window, native_event_mask);
1639 _gdk_window_update_viewable (window);
1641 if (window->background == NULL)
1643 /* parent relative background, update has_alpha_background */
1644 if (window->parent == NULL ||
1645 window->parent->window_type == GDK_WINDOW_ROOT)
1646 window->has_alpha_background = FALSE;
1648 window->has_alpha_background = window->parent->has_alpha_background;
1651 recompute_visible_regions (window, TRUE, FALSE);
1652 if (old_parent && GDK_WINDOW_TYPE (old_parent) != GDK_WINDOW_ROOT)
1653 recompute_visible_regions (old_parent, FALSE, TRUE);
1655 _gdk_window_propagate_has_alpha_background (window);
1657 /* We used to apply the clip as the shape, but no more.
1658 Reset this to the real shape */
1659 if (gdk_window_has_impl (window) &&
1660 applied_clip_as_shape &&
1661 !should_apply_clip_as_shape (window))
1662 apply_shape (window, window->shape);
1664 if (do_reparent_to_impl)
1665 reparent_to_impl (window);
1668 /* The reparent will have put the native window topmost in the native parent,
1669 * which may be wrong wrt other native windows in the non-native hierarchy,
1671 if (!gdk_window_has_impl (new_parent))
1672 sync_native_window_stack_position (window);
1676 gdk_window_show_unraised (window);
1678 _gdk_synthesize_crossing_events_for_geometry_change (window);
1682 * gdk_window_ensure_native:
1683 * @window: a #GdkWindow
1685 * Tries to ensure that there is a window-system native window for this
1686 * GdkWindow. This may fail in some situations, returning %FALSE.
1688 * Offscreen window and children of them can never have native windows.
1690 * Some backends may not support native child windows.
1692 * Returns: %TRUE if the window has a native window, %FALSE otherwise
1697 gdk_window_ensure_native (GdkWindow *window)
1699 GdkWindow *impl_window;
1700 GdkWindowImpl *new_impl, *old_impl;
1701 GdkDisplay *display;
1705 GdkWindowImplClass *impl_class;
1707 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
1709 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_ROOT ||
1710 GDK_WINDOW_DESTROYED (window))
1713 impl_window = gdk_window_get_impl_window (window);
1715 if (gdk_window_is_offscreen (impl_window))
1716 return FALSE; /* native in offscreens not supported */
1718 if (impl_window == window)
1719 /* Already has an impl, and its not offscreen . */
1722 /* Need to create a native window */
1724 gdk_window_drop_cairo_surface (window);
1726 screen = gdk_window_get_screen (window);
1727 display = gdk_screen_get_display (screen);
1729 old_impl = window->impl;
1730 _gdk_display_create_window_impl (display,
1731 window, window->parent,
1733 get_native_event_mask (window),
1735 new_impl = window->impl;
1737 window->impl = old_impl;
1738 change_impl (window, window, new_impl);
1740 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1742 /* Native window creation will put the native window topmost in the
1743 * native parent, which may be wrong wrt the position of the previous
1744 * non-native window wrt to the other non-native children, so correct this.
1746 above = find_native_sibling_above (window->parent, window);
1749 listhead.data = window;
1750 listhead.prev = NULL;
1751 listhead.next = NULL;
1752 impl_class->restack_under ((GdkWindow *)above, &listhead);
1755 recompute_visible_regions (window, FALSE, FALSE);
1757 /* The shape may not have been set, as the clip region doesn't actually
1758 change, so do it here manually */
1759 if (should_apply_clip_as_shape (window))
1760 apply_clip_as_shape (window);
1762 reparent_to_impl (window);
1764 if (!window->input_only)
1765 impl_class->set_background (window, window->background);
1767 impl_class->input_shape_combine_region (window,
1768 window->input_shape,
1771 if (gdk_window_is_viewable (window))
1772 impl_class->show (window, FALSE);
1778 * _gdk_event_filter_unref:
1779 * @window: (allow-none): A #GdkWindow, or %NULL to be the global window
1780 * @filter: A window filter
1782 * Release a reference to @filter. Note this function may
1783 * mutate the list storage, so you need to handle this
1784 * if iterating over a list of filters.
1787 _gdk_event_filter_unref (GdkWindow *window,
1788 GdkEventFilter *filter)
1794 filters = &_gdk_default_filters;
1796 filters = &window->filters;
1798 tmp_list = *filters;
1801 GdkEventFilter *iter_filter = tmp_list->data;
1805 tmp_list = tmp_list->next;
1807 if (iter_filter != filter)
1810 g_assert (iter_filter->ref_count > 0);
1812 filter->ref_count--;
1813 if (filter->ref_count != 0)
1816 *filters = g_list_remove_link (*filters, node);
1818 g_list_free_1 (node);
1823 window_remove_filters (GdkWindow *window)
1825 while (window->filters)
1826 _gdk_event_filter_unref (window, window->filters->data);
1830 update_pointer_info_foreach (GdkDisplay *display,
1832 GdkPointerWindowInfo *pointer_info,
1835 GdkWindow *window = user_data;
1837 if (pointer_info->toplevel_under_pointer == window)
1839 g_object_unref (pointer_info->toplevel_under_pointer);
1840 pointer_info->toplevel_under_pointer = NULL;
1845 window_remove_from_pointer_info (GdkWindow *window,
1846 GdkDisplay *display)
1848 _gdk_display_pointer_info_foreach (display,
1849 update_pointer_info_foreach,
1854 * _gdk_window_destroy_hierarchy:
1855 * @window: a #GdkWindow
1856 * @recursing: If TRUE, then this is being called because a parent
1858 * @recursing_native: If TRUE, then this is being called because a native parent
1859 * was destroyed. This generally means that the call to the
1860 * windowing system to destroy the window can be omitted, since
1861 * it will be destroyed as a result of the parent being destroyed.
1862 * Unless @foreign_destroy.
1863 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
1864 * external agency. The window has already been destroyed and no
1865 * windowing system calls should be made. (This may never happen
1866 * for some windowing systems.)
1868 * Internal function to destroy a window. Like gdk_window_destroy(),
1869 * but does not drop the reference count created by gdk_window_new().
1872 _gdk_window_destroy_hierarchy (GdkWindow *window,
1874 gboolean recursing_native,
1875 gboolean foreign_destroy)
1877 GdkWindowImplClass *impl_class;
1878 GdkWindow *temp_window;
1880 GdkDisplay *display;
1884 g_return_if_fail (GDK_IS_WINDOW (window));
1886 if (GDK_WINDOW_DESTROYED (window))
1889 display = gdk_window_get_display (window);
1890 screen = gdk_window_get_screen (window);
1891 temp_window = g_object_get_qdata (G_OBJECT (screen), quark_pointer_window);
1892 if (temp_window == window)
1893 g_object_set_qdata (G_OBJECT (screen), quark_pointer_window, NULL);
1896 switch (window->window_type)
1898 case GDK_WINDOW_ROOT:
1899 if (!screen->closed)
1901 g_error ("attempted to destroy root window");
1904 /* else fall thru */
1905 case GDK_WINDOW_TOPLEVEL:
1906 case GDK_WINDOW_CHILD:
1907 case GDK_WINDOW_TEMP:
1908 case GDK_WINDOW_FOREIGN:
1909 case GDK_WINDOW_OFFSCREEN:
1910 if (window->window_type == GDK_WINDOW_FOREIGN && !foreign_destroy)
1912 /* Logically, it probably makes more sense to send
1913 * a "destroy yourself" message to the foreign window
1914 * whether or not it's in our hierarchy; but for historical
1915 * reasons, we only send "destroy yourself" messages to
1916 * foreign windows in our hierarchy.
1920 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1922 if (gdk_window_has_impl (window))
1923 impl_class->destroy_foreign (window);
1926 /* Also for historical reasons, we remove any filters
1927 * on a foreign window when it or a parent is destroyed;
1928 * this likely causes problems if two separate portions
1929 * of code are maintaining filter lists on a foreign window.
1931 window_remove_filters (window);
1937 if (window->parent->children)
1938 window->parent->children = g_list_remove (window->parent->children, window);
1941 GDK_WINDOW_IS_MAPPED (window))
1943 recompute_visible_regions (window, TRUE, FALSE);
1944 gdk_window_invalidate_in_parent (window);
1948 gdk_window_free_paint_stack (window);
1950 if (window->background)
1952 cairo_pattern_destroy (window->background);
1953 window->background = NULL;
1956 if (window->window_type == GDK_WINDOW_FOREIGN)
1957 g_assert (window->children == NULL);
1960 children = tmp = window->children;
1961 window->children = NULL;
1965 temp_window = tmp->data;
1969 _gdk_window_destroy_hierarchy (temp_window,
1971 recursing_native || gdk_window_has_impl (window),
1975 g_list_free (children);
1978 _gdk_window_clear_update_area (window);
1980 gdk_window_drop_cairo_surface (window);
1982 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
1984 if (gdk_window_has_impl (window))
1985 impl_class->destroy (window, recursing_native,
1989 /* hide to make sure we repaint and break grabs */
1990 gdk_window_hide (window);
1993 window->state |= GDK_WINDOW_STATE_WITHDRAWN;
1994 window->parent = NULL;
1995 window->destroyed = TRUE;
1997 window_remove_filters (window);
1999 window_remove_from_pointer_info (window, display);
2001 if (window->clip_region)
2003 cairo_region_destroy (window->clip_region);
2004 window->clip_region = NULL;
2007 if (window->clip_region_with_children)
2009 cairo_region_destroy (window->clip_region_with_children);
2010 window->clip_region_with_children = NULL;
2013 if (window->outstanding_moves)
2015 g_list_foreach (window->outstanding_moves, (GFunc)gdk_window_region_move_free, NULL);
2016 g_list_free (window->outstanding_moves);
2017 window->outstanding_moves = NULL;
2025 * _gdk_window_destroy:
2026 * @window: a #GdkWindow
2027 * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
2028 * external agency. The window has already been destroyed and no
2029 * windowing system calls should be made. (This may never happen
2030 * for some windowing systems.)
2032 * Internal function to destroy a window. Like gdk_window_destroy(),
2033 * but does not drop the reference count created by gdk_window_new().
2036 _gdk_window_destroy (GdkWindow *window,
2037 gboolean foreign_destroy)
2039 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, foreign_destroy);
2043 * gdk_window_destroy:
2044 * @window: a #GdkWindow
2046 * Destroys the window system resources associated with @window and decrements @window's
2047 * reference count. The window system resources for all children of @window are also
2048 * destroyed, but the children's reference counts are not decremented.
2050 * Note that a window will not be destroyed automatically when its reference count
2051 * reaches zero. You must call this function yourself before that happens.
2055 gdk_window_destroy (GdkWindow *window)
2057 _gdk_window_destroy_hierarchy (window, FALSE, FALSE, FALSE);
2058 g_object_unref (window);
2062 * gdk_window_set_user_data:
2063 * @window: a #GdkWindow
2064 * @user_data: (allow-none) (type GObject.Object): user data
2066 * For most purposes this function is deprecated in favor of
2067 * g_object_set_data(). However, for historical reasons GTK+ stores
2068 * the #GtkWidget that owns a #GdkWindow as user data on the
2069 * #GdkWindow. So, custom widget implementations should use
2070 * this function for that. If GTK+ receives an event for a #GdkWindow,
2071 * and the user data for the window is non-%NULL, GTK+ will assume the
2072 * user data is a #GtkWidget, and forward the event to that widget.
2076 gdk_window_set_user_data (GdkWindow *window,
2079 g_return_if_fail (GDK_IS_WINDOW (window));
2081 window->user_data = user_data;
2085 * gdk_window_get_user_data:
2086 * @window: a #GdkWindow
2087 * @data: (out): return location for user data
2089 * Retrieves the user data for @window, which is normally the widget
2090 * that @window belongs to. See gdk_window_set_user_data().
2094 gdk_window_get_user_data (GdkWindow *window,
2097 g_return_if_fail (GDK_IS_WINDOW (window));
2099 *data = window->user_data;
2103 * gdk_window_get_window_type:
2104 * @window: a #GdkWindow
2106 * Gets the type of the window. See #GdkWindowType.
2108 * Return value: type of window
2111 gdk_window_get_window_type (GdkWindow *window)
2113 g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
2115 return GDK_WINDOW_TYPE (window);
2119 * gdk_window_get_visual:
2120 * @window: a #GdkWindow
2122 * Gets the #GdkVisual describing the pixel format of @window.
2124 * Return value: (transfer none): a #GdkVisual
2129 gdk_window_get_visual (GdkWindow *window)
2131 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2133 return window->visual;
2137 * gdk_window_get_screen:
2138 * @window: a #GdkWindow
2140 * Gets the #GdkScreen associated with a #GdkWindow.
2142 * Return value: (transfer none): the #GdkScreen associated with @window
2147 gdk_window_get_screen (GdkWindow *window)
2149 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2151 return gdk_visual_get_screen (window->visual);
2155 * gdk_window_get_display:
2156 * @window: a #GdkWindow
2158 * Gets the #GdkDisplay associated with a #GdkWindow.
2160 * Return value: (transfer none): the #GdkDisplay associated with @window
2165 gdk_window_get_display (GdkWindow *window)
2167 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2169 return gdk_screen_get_display (gdk_visual_get_screen (window->visual));
2172 * gdk_window_is_destroyed:
2173 * @window: a #GdkWindow
2175 * Check to see if a window is destroyed..
2177 * Return value: %TRUE if the window is destroyed
2182 gdk_window_is_destroyed (GdkWindow *window)
2184 return GDK_WINDOW_DESTROYED (window);
2188 to_embedder (GdkWindow *window,
2189 gdouble offscreen_x,
2190 gdouble offscreen_y,
2191 gdouble *embedder_x,
2192 gdouble *embedder_y)
2194 g_signal_emit (window, signals[TO_EMBEDDER], 0,
2195 offscreen_x, offscreen_y,
2196 embedder_x, embedder_y);
2200 from_embedder (GdkWindow *window,
2203 gdouble *offscreen_x,
2204 gdouble *offscreen_y)
2206 g_signal_emit (window, signals[FROM_EMBEDDER], 0,
2207 embedder_x, embedder_y,
2208 offscreen_x, offscreen_y);
2212 * gdk_window_has_native:
2213 * @window: a #GdkWindow
2215 * Checks whether the window has a native window or not. Note that
2216 * you can use gdk_window_ensure_native() if a native window is needed.
2218 * Returns: %TRUE if the %window has a native window, %FALSE otherwise.
2223 gdk_window_has_native (GdkWindow *window)
2225 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2227 return window->parent == NULL || window->parent->impl != window->impl;
2231 * gdk_window_get_position:
2232 * @window: a #GdkWindow
2233 * @x: (out) (allow-none): X coordinate of window
2234 * @y: (out) (allow-none): Y coordinate of window
2236 * Obtains the position of the window as reported in the
2237 * most-recently-processed #GdkEventConfigure. Contrast with
2238 * gdk_window_get_geometry() which queries the X server for the
2239 * current window position, regardless of which events have been
2240 * received or processed.
2242 * The position coordinates are relative to the window's parent window.
2246 gdk_window_get_position (GdkWindow *window,
2250 g_return_if_fail (GDK_IS_WINDOW (window));
2259 * gdk_window_get_parent:
2260 * @window: a #GdkWindow
2262 * Obtains the parent of @window, as known to GDK. Does not query the
2263 * X server; thus this returns the parent as passed to gdk_window_new(),
2264 * not the actual parent. This should never matter unless you're using
2265 * Xlib calls mixed with GDK calls on the X11 platform. It may also
2266 * matter for toplevel windows, because the window manager may choose
2269 * Note that you should use gdk_window_get_effective_parent() when
2270 * writing generic code that walks up a window hierarchy, because
2271 * gdk_window_get_parent() will most likely not do what you expect if
2272 * there are offscreen windows in the hierarchy.
2274 * Return value: (transfer none): parent of @window
2277 gdk_window_get_parent (GdkWindow *window)
2279 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2281 return window->parent;
2285 * gdk_window_get_effective_parent:
2286 * @window: a #GdkWindow
2288 * Obtains the parent of @window, as known to GDK. Works like
2289 * gdk_window_get_parent() for normal windows, but returns the
2290 * window's embedder for offscreen windows.
2292 * See also: gdk_offscreen_window_get_embedder()
2294 * Return value: (transfer none): effective parent of @window
2299 gdk_window_get_effective_parent (GdkWindow *window)
2301 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2303 if (gdk_window_is_offscreen (window))
2304 return gdk_offscreen_window_get_embedder (window);
2306 return window->parent;
2310 * gdk_window_get_toplevel:
2311 * @window: a #GdkWindow
2313 * Gets the toplevel window that's an ancestor of @window.
2315 * Any window type but %GDK_WINDOW_CHILD is considered a
2316 * toplevel window, as is a %GDK_WINDOW_CHILD window that
2317 * has a root window as parent.
2319 * Note that you should use gdk_window_get_effective_toplevel() when
2320 * you want to get to a window's toplevel as seen on screen, because
2321 * gdk_window_get_toplevel() will most likely not do what you expect
2322 * if there are offscreen windows in the hierarchy.
2324 * Return value: (transfer none): the toplevel window containing @window
2327 gdk_window_get_toplevel (GdkWindow *window)
2329 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2331 while (window->window_type == GDK_WINDOW_CHILD)
2333 if (gdk_window_is_toplevel (window))
2335 window = window->parent;
2342 * gdk_window_get_effective_toplevel:
2343 * @window: a #GdkWindow
2345 * Gets the toplevel window that's an ancestor of @window.
2347 * Works like gdk_window_get_toplevel(), but treats an offscreen window's
2348 * embedder as its parent, using gdk_window_get_effective_parent().
2350 * See also: gdk_offscreen_window_get_embedder()
2352 * Return value: (transfer none): the effective toplevel window containing @window
2357 gdk_window_get_effective_toplevel (GdkWindow *window)
2361 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2363 while ((parent = gdk_window_get_effective_parent (window)) != NULL &&
2364 (gdk_window_get_window_type (parent) != GDK_WINDOW_ROOT))
2371 * gdk_window_get_children:
2372 * @window: a #GdkWindow
2374 * Gets the list of children of @window known to GDK.
2375 * This function only returns children created via GDK,
2376 * so for example it's useless when used with the root window;
2377 * it only returns windows an application created itself.
2379 * The returned list must be freed, but the elements in the
2382 * Return value: (transfer container) (element-type GdkWindow):
2383 * list of child windows inside @window
2386 gdk_window_get_children (GdkWindow *window)
2388 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2390 if (GDK_WINDOW_DESTROYED (window))
2393 return g_list_copy (window->children);
2397 * gdk_window_peek_children:
2398 * @window: a #GdkWindow
2400 * Like gdk_window_get_children(), but does not copy the list of
2401 * children, so the list does not need to be freed.
2403 * Return value: (transfer none) (element-type GdkWindow):
2404 * a reference to the list of child windows in @window
2407 gdk_window_peek_children (GdkWindow *window)
2409 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
2411 if (GDK_WINDOW_DESTROYED (window))
2414 return window->children;
2418 * gdk_window_add_filter: (skip)
2419 * @window: (allow-none): a #GdkWindow
2420 * @function: filter callback
2421 * @data: data to pass to filter callback
2423 * Adds an event filter to @window, allowing you to intercept events
2424 * before they reach GDK. This is a low-level operation and makes it
2425 * easy to break GDK and/or GTK+, so you have to know what you're
2426 * doing. Pass %NULL for @window to get all events for all windows,
2427 * instead of events for a specific window.
2429 * If you are interested in X GenericEvents, bear in mind that
2430 * XGetEventData() has been already called on the event, and
2431 * XFreeEventData() must not be called within @function.
2434 gdk_window_add_filter (GdkWindow *window,
2435 GdkFilterFunc function,
2439 GdkEventFilter *filter;
2441 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2443 if (window && GDK_WINDOW_DESTROYED (window))
2446 /* Filters are for the native events on the native window, so
2447 ensure there is a native window. */
2449 gdk_window_ensure_native (window);
2452 tmp_list = window->filters;
2454 tmp_list = _gdk_default_filters;
2458 filter = (GdkEventFilter *)tmp_list->data;
2459 if ((filter->function == function) && (filter->data == data))
2461 filter->ref_count++;
2464 tmp_list = tmp_list->next;
2467 filter = g_new (GdkEventFilter, 1);
2468 filter->function = function;
2469 filter->data = data;
2470 filter->ref_count = 1;
2474 window->filters = g_list_append (window->filters, filter);
2476 _gdk_default_filters = g_list_append (_gdk_default_filters, filter);
2480 * gdk_window_remove_filter: (skip)
2481 * @window: a #GdkWindow
2482 * @function: previously-added filter function
2483 * @data: user data for previously-added filter function
2485 * Remove a filter previously added with gdk_window_add_filter().
2488 gdk_window_remove_filter (GdkWindow *window,
2489 GdkFilterFunc function,
2493 GdkEventFilter *filter;
2495 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
2498 tmp_list = window->filters;
2500 tmp_list = _gdk_default_filters;
2504 filter = (GdkEventFilter *)tmp_list->data;
2505 tmp_list = tmp_list->next;
2507 if ((filter->function == function) && (filter->data == data))
2509 filter->flags |= GDK_EVENT_FILTER_REMOVED;
2511 _gdk_event_filter_unref (window, filter);
2519 * gdk_screen_get_toplevel_windows:
2520 * @screen: The #GdkScreen where the toplevels are located.
2522 * Obtains a list of all toplevel windows known to GDK on the screen @screen.
2523 * A toplevel window is a child of the root window (see
2524 * gdk_get_default_root_window()).
2526 * The returned list should be freed with g_list_free(), but
2527 * its elements need not be freed.
2529 * Return value: (transfer container) (element-type GdkWindow):
2530 * list of toplevel windows, free with g_list_free()
2535 gdk_screen_get_toplevel_windows (GdkScreen *screen)
2537 GdkWindow * root_window;
2538 GList *new_list = NULL;
2541 g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
2543 root_window = gdk_screen_get_root_window (screen);
2545 tmp_list = root_window->children;
2548 GdkWindow *w = tmp_list->data;
2550 if (w->window_type != GDK_WINDOW_FOREIGN)
2551 new_list = g_list_prepend (new_list, w);
2552 tmp_list = tmp_list->next;
2559 * gdk_window_is_visible:
2560 * @window: a #GdkWindow
2562 * Checks whether the window has been mapped (with gdk_window_show() or
2563 * gdk_window_show_unraised()).
2565 * Return value: %TRUE if the window is mapped
2568 gdk_window_is_visible (GdkWindow *window)
2570 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2572 return GDK_WINDOW_IS_MAPPED (window);
2576 * gdk_window_is_viewable:
2577 * @window: a #GdkWindow
2579 * Check if the window and all ancestors of the window are
2580 * mapped. (This is not necessarily "viewable" in the X sense, since
2581 * we only check as far as we have GDK window parents, not to the root
2584 * Return value: %TRUE if the window is viewable
2587 gdk_window_is_viewable (GdkWindow *window)
2589 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2591 if (window->destroyed)
2594 return window->viewable;
2598 * gdk_window_get_state:
2599 * @window: a #GdkWindow
2601 * Gets the bitwise OR of the currently active window state flags,
2602 * from the #GdkWindowState enumeration.
2604 * Return value: window state bitfield
2607 gdk_window_get_state (GdkWindow *window)
2609 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2611 return window->state;
2614 static cairo_content_t
2615 gdk_window_get_content (GdkWindow *window)
2617 cairo_surface_t *surface;
2618 cairo_content_t content;
2620 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2622 surface = _gdk_window_ref_cairo_surface (window);
2623 content = cairo_surface_get_content (surface);
2624 cairo_surface_destroy (surface);
2629 /* This creates an empty "implicit" paint region for the impl window.
2630 * By itself this does nothing, but real paints to this window
2631 * or children of it can use this surface as backing to avoid allocating
2632 * multiple surfaces for subwindow rendering. When doing so they
2633 * add to the region of the implicit paint region, which will be
2634 * pushed to the window when the implicit paint region is ended.
2635 * Such paints should not copy anything to the window on paint end, but
2636 * should rely on the implicit paint end.
2637 * The implicit paint will be automatically ended if someone draws
2638 * directly to the window or a child window.
2641 gdk_window_begin_implicit_paint (GdkWindow *window, GdkRectangle *rect)
2643 GdkWindowPaint *paint;
2645 g_assert (gdk_window_has_impl (window));
2647 if (GDK_IS_PAINTABLE (window->impl))
2648 return FALSE; /* Implementation does double buffering */
2650 if (window->paint_stack != NULL ||
2651 window->implicit_paint != NULL)
2652 return FALSE; /* Don't stack implicit paints */
2654 /* Never do implicit paints for foreign windows, they don't need
2655 * double buffer combination since they have no client side children,
2656 * and creating surfaces for them is risky since they could disappear
2659 if (window->window_type == GDK_WINDOW_FOREIGN)
2662 paint = g_new (GdkWindowPaint, 1);
2663 paint->region = cairo_region_create (); /* Empty */
2664 paint->uses_implicit = FALSE;
2665 paint->flushed = FALSE;
2666 paint->surface = gdk_window_create_similar_surface (window,
2667 gdk_window_get_content (window),
2668 MAX (rect->width, 1),
2669 MAX (rect->height, 1));
2670 cairo_surface_set_device_offset (paint->surface, -rect->x, -rect->y);
2672 window->implicit_paint = paint;
2677 static cairo_surface_t *
2678 gdk_window_ref_impl_surface (GdkWindow *window)
2680 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->ref_cairo_surface (gdk_window_get_impl_window (window));
2684 gdk_cairo_create_for_impl (GdkWindow *window)
2686 cairo_surface_t *surface;
2689 surface = gdk_window_ref_impl_surface (window);
2690 cr = cairo_create (surface);
2692 cairo_surface_destroy (surface);
2697 /* Ensure that all content related to this (sub)window is pushed to the
2698 native region. If there is an active paint then that area is not
2699 pushed, in order to not show partially finished double buffers. */
2701 gdk_window_flush_implicit_paint (GdkWindow *window)
2703 GdkWindow *impl_window;
2704 GdkWindowPaint *paint;
2705 cairo_region_t *region;
2708 impl_window = gdk_window_get_impl_window (window);
2709 if (impl_window->implicit_paint == NULL)
2712 paint = impl_window->implicit_paint;
2713 paint->flushed = TRUE;
2714 region = cairo_region_copy (window->clip_region_with_children);
2716 /* Don't flush active double buffers, as that may show partially done
2718 for (list = window->paint_stack; list != NULL; list = list->next)
2720 GdkWindowPaint *tmp_paint = list->data;
2722 cairo_region_subtract (region, tmp_paint->region);
2725 cairo_region_translate (region, -window->abs_x, -window->abs_y);
2726 cairo_region_intersect (region, paint->region);
2728 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (region))
2732 /* Remove flushed region from the implicit paint */
2733 cairo_region_subtract (paint->region, region);
2735 /* Some regions are valid, push these to window now */
2736 cr = gdk_cairo_create_for_impl (window);
2737 gdk_cairo_region (cr, region);
2739 cairo_set_source_surface (cr, paint->surface, 0, 0);
2740 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2745 cairo_region_destroy (region);
2748 /* Ends an implicit paint, paired with gdk_window_begin_implicit_paint returning TRUE */
2750 gdk_window_end_implicit_paint (GdkWindow *window)
2752 GdkWindowPaint *paint;
2754 g_assert (gdk_window_has_impl (window));
2756 g_assert (window->implicit_paint != NULL);
2758 paint = window->implicit_paint;
2760 window->implicit_paint = NULL;
2762 if (!GDK_WINDOW_DESTROYED (window) && !cairo_region_is_empty (paint->region))
2766 /* Some regions are valid, push these to window now */
2767 cr = gdk_cairo_create_for_impl (window);
2768 gdk_cairo_region (cr, paint->region);
2770 cairo_set_source_surface (cr, paint->surface, 0, 0);
2771 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2776 cairo_region_destroy (paint->region);
2778 cairo_surface_destroy (paint->surface);
2783 * gdk_window_begin_paint_rect:
2784 * @window: a #GdkWindow
2785 * @rectangle: rectangle you intend to draw to
2787 * A convenience wrapper around gdk_window_begin_paint_region() which
2788 * creates a rectangular region for you. See
2789 * gdk_window_begin_paint_region() for details.
2793 gdk_window_begin_paint_rect (GdkWindow *window,
2794 const GdkRectangle *rectangle)
2796 cairo_region_t *region;
2798 g_return_if_fail (GDK_IS_WINDOW (window));
2800 region = cairo_region_create_rectangle (rectangle);
2801 gdk_window_begin_paint_region (window, region);
2802 cairo_region_destroy (region);
2806 * gdk_window_begin_paint_region:
2807 * @window: a #GdkWindow
2808 * @region: region you intend to draw to
2810 * Indicates that you are beginning the process of redrawing @region.
2811 * A backing store (offscreen buffer) large enough to contain @region
2812 * will be created. The backing store will be initialized with the
2813 * background color or background surface for @window. Then, all
2814 * drawing operations performed on @window will be diverted to the
2815 * backing store. When you call gdk_window_end_paint(), the backing
2816 * store will be copied to @window, making it visible onscreen. Only
2817 * the part of @window contained in @region will be modified; that is,
2818 * drawing operations are clipped to @region.
2820 * The net result of all this is to remove flicker, because the user
2821 * sees the finished product appear all at once when you call
2822 * gdk_window_end_paint(). If you draw to @window directly without
2823 * calling gdk_window_begin_paint_region(), the user may see flicker
2824 * as individual drawing operations are performed in sequence. The
2825 * clipping and background-initializing features of
2826 * gdk_window_begin_paint_region() are conveniences for the
2827 * programmer, so you can avoid doing that work yourself.
2829 * When using GTK+, the widget system automatically places calls to
2830 * gdk_window_begin_paint_region() and gdk_window_end_paint() around
2831 * emissions of the expose_event signal. That is, if you're writing an
2832 * expose event handler, you can assume that the exposed area in
2833 * #GdkEventExpose has already been cleared to the window background,
2834 * is already set as the clip region, and already has a backing store.
2835 * Therefore in most cases, application code need not call
2836 * gdk_window_begin_paint_region(). (You can disable the automatic
2837 * calls around expose events on a widget-by-widget basis by calling
2838 * gtk_widget_set_double_buffered().)
2840 * If you call this function multiple times before calling the
2841 * matching gdk_window_end_paint(), the backing stores are pushed onto
2842 * a stack. gdk_window_end_paint() copies the topmost backing store
2843 * onscreen, subtracts the topmost region from all other regions in
2844 * the stack, and pops the stack. All drawing operations affect only
2845 * the topmost backing store in the stack. One matching call to
2846 * gdk_window_end_paint() is required for each call to
2847 * gdk_window_begin_paint_region().
2851 gdk_window_begin_paint_region (GdkWindow *window,
2852 const cairo_region_t *region)
2854 #ifdef USE_BACKING_STORE
2855 GdkRectangle clip_box;
2856 GdkWindowPaint *paint, *implicit_paint;
2857 GdkWindow *impl_window;
2860 g_return_if_fail (GDK_IS_WINDOW (window));
2862 if (GDK_WINDOW_DESTROYED (window))
2865 if (GDK_IS_PAINTABLE (window->impl))
2867 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2869 if (iface->begin_paint_region)
2870 iface->begin_paint_region ((GdkPaintable*)window->impl, window, region);
2875 impl_window = gdk_window_get_impl_window (window);
2876 implicit_paint = impl_window->implicit_paint;
2878 paint = g_new (GdkWindowPaint, 1);
2879 paint->region = cairo_region_copy (region);
2881 cairo_region_intersect (paint->region, window->clip_region_with_children);
2882 cairo_region_get_extents (paint->region, &clip_box);
2884 cairo_region_translate (paint->region, window->abs_x, window->abs_y);
2886 /* Mark the region as valid on the implicit paint */
2889 cairo_region_union (implicit_paint->region, paint->region);
2891 /* Convert back to normal coords */
2892 cairo_region_translate (paint->region, -window->abs_x, -window->abs_y);
2896 paint->uses_implicit = TRUE;
2897 paint->surface = cairo_surface_create_for_rectangle (implicit_paint->surface,
2898 window->abs_x + clip_box.x,
2899 window->abs_y + clip_box.y,
2900 MAX (clip_box.width, 1),
2901 MAX (clip_box.height, 1));
2905 paint->uses_implicit = FALSE;
2906 paint->surface = gdk_window_create_similar_surface (window,
2907 gdk_window_get_content (window),
2908 MAX (clip_box.width, 1),
2909 MAX (clip_box.height, 1));
2911 cairo_surface_set_device_offset (paint->surface, -clip_box.x, -clip_box.y);
2913 for (list = window->paint_stack; list != NULL; list = list->next)
2915 GdkWindowPaint *tmp_paint = list->data;
2917 cairo_region_subtract (tmp_paint->region, paint->region);
2920 window->paint_stack = g_slist_prepend (window->paint_stack, paint);
2922 if (!cairo_region_is_empty (paint->region))
2924 gdk_window_clear_backing_region (window,
2928 #endif /* USE_BACKING_STORE */
2932 * gdk_window_end_paint:
2933 * @window: a #GdkWindow
2935 * Indicates that the backing store created by the most recent call to
2936 * gdk_window_begin_paint_region() should be copied onscreen and
2937 * deleted, leaving the next-most-recent backing store or no backing
2938 * store at all as the active paint region. See
2939 * gdk_window_begin_paint_region() for full details. It is an error to
2940 * call this function without a matching
2941 * gdk_window_begin_paint_region() first.
2945 gdk_window_end_paint (GdkWindow *window)
2947 #ifdef USE_BACKING_STORE
2948 GdkWindow *composited;
2949 GdkWindowPaint *paint;
2950 GdkRectangle clip_box;
2951 cairo_region_t *full_clip;
2953 g_return_if_fail (GDK_IS_WINDOW (window));
2955 if (GDK_WINDOW_DESTROYED (window))
2958 if (GDK_IS_PAINTABLE (window->impl))
2960 GdkPaintableIface *iface = GDK_PAINTABLE_GET_IFACE (window->impl);
2962 if (iface->end_paint)
2963 iface->end_paint ((GdkPaintable*)window->impl);
2967 if (window->paint_stack == NULL)
2969 g_warning (G_STRLOC": no preceding call to gdk_window_begin_paint_region(), see documentation");
2973 paint = window->paint_stack->data;
2975 window->paint_stack = g_slist_delete_link (window->paint_stack,
2976 window->paint_stack);
2978 cairo_region_get_extents (paint->region, &clip_box);
2980 if (!paint->uses_implicit)
2984 gdk_window_flush_outstanding_moves (window);
2986 full_clip = cairo_region_copy (window->clip_region_with_children);
2987 cairo_region_intersect (full_clip, paint->region);
2989 cr = gdk_cairo_create (window);
2990 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
2991 cairo_set_source_surface (cr, paint->surface, 0, 0);
2992 gdk_cairo_region (cr, full_clip);
2996 cairo_region_destroy (full_clip);
2999 cairo_surface_destroy (paint->surface);
3000 cairo_region_destroy (paint->region);
3003 /* find a composited window in our hierarchy to signal its
3004 * parent to redraw, calculating the clip box as we go...
3006 * stop if parent becomes NULL since then we'd have nowhere
3007 * to draw (ie: 'composited' will always be non-NULL here).
3009 for (composited = window;
3011 composited = composited->parent)
3013 clip_box.x += composited->x;
3014 clip_box.y += composited->y;
3015 clip_box.width = MIN (clip_box.width, composited->parent->width - clip_box.x);
3016 clip_box.height = MIN (clip_box.height, composited->parent->height - clip_box.y);
3018 if (composited->composited)
3020 gdk_window_invalidate_rect (GDK_WINDOW (composited->parent),
3025 #endif /* USE_BACKING_STORE */
3029 gdk_window_free_paint_stack (GdkWindow *window)
3031 if (window->paint_stack)
3033 GSList *tmp_list = window->paint_stack;
3037 GdkWindowPaint *paint = tmp_list->data;
3039 if (tmp_list == window->paint_stack)
3040 cairo_surface_destroy (paint->surface);
3042 cairo_region_destroy (paint->region);
3045 tmp_list = tmp_list->next;
3048 g_slist_free (window->paint_stack);
3049 window->paint_stack = NULL;
3054 do_move_region_bits_on_impl (GdkWindow *impl_window,
3055 cairo_region_t *dest_region, /* In impl window coords */
3058 GdkWindowImplClass *impl_class;
3060 impl_class = GDK_WINDOW_IMPL_GET_CLASS (impl_window->impl);
3062 impl_class->translate (impl_window, dest_region, dx, dy);
3065 static GdkWindowRegionMove *
3066 gdk_window_region_move_new (cairo_region_t *region,
3069 GdkWindowRegionMove *move;
3071 move = g_slice_new (GdkWindowRegionMove);
3072 move->dest_region = cairo_region_copy (region);
3080 gdk_window_region_move_free (GdkWindowRegionMove *move)
3082 cairo_region_destroy (move->dest_region);
3083 g_slice_free (GdkWindowRegionMove, move);
3087 append_move_region (GdkWindow *impl_window,
3088 cairo_region_t *new_dest_region,
3091 GdkWindowRegionMove *move, *old_move;
3092 cairo_region_t *new_total_region, *old_total_region;
3093 cairo_region_t *source_overlaps_destination;
3094 cairo_region_t *non_overwritten;
3095 gboolean added_move;
3098 if (cairo_region_is_empty (new_dest_region))
3101 /* In principle this could just append the move to the list of outstanding
3102 moves that will be replayed before drawing anything when we're handling
3103 exposes. However, we'd like to do a bit better since its commonly the case
3104 that we get multiple copies where A is copied to B and then B is copied
3105 to C, and we'd like to express this as a simple copy A to C operation. */
3107 /* We approach this by taking the new move and pushing it ahead of moves
3108 starting at the end of the list and stopping when its not safe to do so.
3109 It's not safe to push past a move if either the source of the new move
3110 is in the destination of the old move, or if the destination of the new
3111 move is in the source of the new move, or if the destination of the new
3112 move overlaps the destination of the old move. We simplify this by
3113 just comparing the total regions (src + dest) */
3114 new_total_region = cairo_region_copy (new_dest_region);
3115 cairo_region_translate (new_total_region, -dx, -dy);
3116 cairo_region_union (new_total_region, new_dest_region);
3119 for (l = g_list_last (impl_window->outstanding_moves); l != NULL; l = prev)
3124 old_total_region = cairo_region_copy (old_move->dest_region);
3125 cairo_region_translate (old_total_region, -old_move->dx, -old_move->dy);
3126 cairo_region_union (old_total_region, old_move->dest_region);
3128 cairo_region_intersect (old_total_region, new_total_region);
3129 /* If these regions intersect then its not safe to push the
3130 new region before the old one */
3131 if (!cairo_region_is_empty (old_total_region))
3133 /* The area where the new moves source overlaps the old ones
3135 source_overlaps_destination = cairo_region_copy (new_dest_region);
3136 cairo_region_translate (source_overlaps_destination, -dx, -dy);
3137 cairo_region_intersect (source_overlaps_destination, old_move->dest_region);
3138 cairo_region_translate (source_overlaps_destination, dx, dy);
3140 /* We can do all sort of optimizations here, but to do things safely it becomes
3141 quite complicated. However, a very common case is that you copy something first,
3142 then copy all that or a subset of it to a new location (i.e. if you scroll twice
3143 in the same direction). We'd like to detect this case and optimize it to one
3145 if (cairo_region_equal (source_overlaps_destination, new_dest_region))
3147 /* This means we might be able to replace the old move and the new one
3148 with the new one read from the old ones source, and a second copy of
3149 the non-overwritten parts of the old move. However, such a split
3150 is only valid if the source in the old move isn't overwritten
3151 by the destination of the new one */
3153 /* the new destination of old move if split is ok: */
3154 non_overwritten = cairo_region_copy (old_move->dest_region);
3155 cairo_region_subtract (non_overwritten, new_dest_region);
3156 /* move to source region */
3157 cairo_region_translate (non_overwritten, -old_move->dx, -old_move->dy);
3159 cairo_region_intersect (non_overwritten, new_dest_region);
3160 if (cairo_region_is_empty (non_overwritten))
3163 move = gdk_window_region_move_new (new_dest_region,
3167 impl_window->outstanding_moves =
3168 g_list_insert_before (impl_window->outstanding_moves,
3170 cairo_region_subtract (old_move->dest_region, new_dest_region);
3172 cairo_region_destroy (non_overwritten);
3175 cairo_region_destroy (source_overlaps_destination);
3176 cairo_region_destroy (old_total_region);
3179 cairo_region_destroy (old_total_region);
3182 cairo_region_destroy (new_total_region);
3186 move = gdk_window_region_move_new (new_dest_region, dx, dy);
3189 impl_window->outstanding_moves =
3190 g_list_prepend (impl_window->outstanding_moves,
3193 impl_window->outstanding_moves =
3194 g_list_insert_before (impl_window->outstanding_moves,
3199 /* Moves bits and update area by dx/dy in impl window.
3200 Takes ownership of region to avoid copy (because we may change it) */
3202 move_region_on_impl (GdkWindow *impl_window,
3203 cairo_region_t *region, /* In impl window coords */
3206 if ((dx == 0 && dy == 0) ||
3207 cairo_region_is_empty (region))
3209 cairo_region_destroy (region);
3213 g_assert (impl_window == gdk_window_get_impl_window (impl_window));
3215 /* Move any old invalid regions in the copy source area by dx/dy */
3216 if (impl_window->update_area)
3218 cairo_region_t *update_area;
3220 update_area = cairo_region_copy (region);
3222 /* Convert from target to source */
3223 cairo_region_translate (update_area, -dx, -dy);
3224 cairo_region_intersect (update_area, impl_window->update_area);
3225 /* We only copy the area, so keep the old update area invalid.
3226 It would be safe to remove it too, as code that uses
3227 move_region_on_impl generally also invalidate the source
3228 area. However, it would just use waste cycles. */
3231 cairo_region_translate (update_area, dx, dy);
3232 cairo_region_union (impl_window->update_area, update_area);
3234 /* This area of the destination is now invalid,
3235 so no need to copy to it. */
3236 cairo_region_subtract (region, update_area);
3238 cairo_region_destroy (update_area);
3241 /* If we're currently exposing this window, don't copy to this
3242 destination, as it will be overdrawn when the expose is done,
3243 instead invalidate it and repaint later. */
3244 if (impl_window->implicit_paint)
3246 GdkWindowPaint *implicit_paint = impl_window->implicit_paint;
3247 cairo_region_t *exposing;
3249 exposing = cairo_region_copy (implicit_paint->region);
3250 cairo_region_intersect (exposing, region);
3251 cairo_region_subtract (region, exposing);
3253 impl_window_add_update_area (impl_window, exposing);
3254 cairo_region_destroy (exposing);
3257 append_move_region (impl_window, region, dx, dy);
3259 cairo_region_destroy (region);
3262 /* Flushes all outstanding changes to the window, call this
3263 * before drawing directly to the window (i.e. outside a begin/end_paint pair).
3266 gdk_window_flush_outstanding_moves (GdkWindow *window)
3268 GdkWindow *impl_window;
3269 GList *l, *outstanding;
3270 GdkWindowRegionMove *move;
3272 impl_window = gdk_window_get_impl_window (window);
3273 outstanding = impl_window->outstanding_moves;
3274 impl_window->outstanding_moves = NULL;
3276 for (l = outstanding; l != NULL; l = l->next)
3280 do_move_region_bits_on_impl (impl_window,
3281 move->dest_region, move->dx, move->dy);
3283 gdk_window_region_move_free (move);
3286 g_list_free (outstanding);
3291 * @window: a #GdkWindow
3293 * Flush all outstanding cached operations on a window, leaving the
3294 * window in a state which reflects all that has been drawn before.
3296 * Gdk uses multiple kinds of caching to get better performance and
3297 * nicer drawing. For instance, during exposes all paints to a window
3298 * using double buffered rendering are keep on a surface until the last
3299 * window has been exposed. It also delays window moves/scrolls until
3300 * as long as possible until next update to avoid tearing when moving
3303 * Normally this should be completely invisible to applications, as
3304 * we automatically flush the windows when required, but this might
3305 * be needed if you for instance mix direct native drawing with
3306 * gdk drawing. For Gtk widgets that don't use double buffering this
3307 * will be called automatically before sending the expose event.
3312 gdk_window_flush (GdkWindow *window)
3314 gdk_window_flush_outstanding_moves (window);
3315 gdk_window_flush_implicit_paint (window);
3318 /* If we're about to move/resize or otherwise change the
3319 * hierarchy of a client side window in an impl and we're
3320 * called from an expose event handler then we need to
3321 * flush any already painted parts of the implicit paint
3322 * that are not part of the current paint, as these may
3323 * be used when scrolling or may overdraw the changes
3324 * caused by the hierarchy change.
3327 gdk_window_flush_if_exposing (GdkWindow *window)
3329 GdkWindow *impl_window;
3331 impl_window = gdk_window_get_impl_window (window);
3333 /* If we're in an implicit paint (i.e. in an expose handler, flush
3334 all the already finished exposes to get things to an uptodate state. */
3335 if (impl_window->implicit_paint)
3336 gdk_window_flush (window);
3341 gdk_window_flush_recursive_helper (GdkWindow *window,
3342 GdkWindowImpl *impl)
3347 for (l = window->children; l != NULL; l = l->next)
3351 if (child->impl == impl)
3352 /* Same impl, ignore */
3353 gdk_window_flush_recursive_helper (child, impl);
3355 gdk_window_flush_recursive (child);
3360 gdk_window_flush_recursive (GdkWindow *window)
3362 gdk_window_flush (window);
3363 gdk_window_flush_recursive_helper (window, window->impl);
3367 * gdk_window_get_clip_region:
3368 * @window: a #GdkWindow
3370 * Computes the region of a window that potentially can be written
3371 * to by drawing primitives. This region may not take into account
3372 * other factors such as if the window is obscured by other windows,
3373 * but no area outside of this region will be affected by drawing
3376 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3377 * when you are done.
3380 gdk_window_get_clip_region (GdkWindow *window)
3382 cairo_region_t *result;
3384 g_return_val_if_fail (GDK_WINDOW (window), NULL);
3386 result = cairo_region_copy (window->clip_region);
3388 if (window->paint_stack)
3390 cairo_region_t *paint_region = cairo_region_create ();
3391 GSList *tmp_list = window->paint_stack;
3395 GdkWindowPaint *paint = tmp_list->data;
3397 cairo_region_union (paint_region, paint->region);
3399 tmp_list = tmp_list->next;
3402 cairo_region_intersect (result, paint_region);
3403 cairo_region_destroy (paint_region);
3410 * gdk_window_get_visible_region:
3411 * @window: a #GdkWindow
3413 * Computes the region of the @window that is potentially visible.
3414 * This does not necessarily take into account if the window is
3415 * obscured by other windows, but no area outside of this region
3418 * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
3419 * when you are done.
3422 gdk_window_get_visible_region (GdkWindow *window)
3424 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3426 return cairo_region_copy (window->clip_region);
3430 setup_backing_rect (GdkWindow *window, GdkWindowPaint *paint, int x_offset_cairo, int y_offset_cairo)
3432 GdkWindow *bg_window;
3433 cairo_pattern_t *pattern = NULL;
3434 int x_offset = 0, y_offset = 0;
3437 cr = cairo_create (paint->surface);
3439 for (bg_window = window; bg_window; bg_window = bg_window->parent)
3441 pattern = gdk_window_get_background_pattern (bg_window);
3445 x_offset += bg_window->x;
3446 y_offset += bg_window->y;
3451 cairo_translate (cr, -x_offset, -y_offset);
3452 cairo_set_source (cr, pattern);
3453 cairo_translate (cr, x_offset, y_offset);
3456 cairo_set_source_rgb (cr, 0, 0, 0);
3462 gdk_window_clear_backing_region (GdkWindow *window,
3463 cairo_region_t *region)
3465 GdkWindowPaint *paint = window->paint_stack->data;
3466 cairo_region_t *clip;
3467 GdkRectangle clipbox;
3470 if (GDK_WINDOW_DESTROYED (window))
3473 cr = setup_backing_rect (window, paint, 0, 0);
3475 clip = cairo_region_copy (paint->region);
3476 cairo_region_intersect (clip, region);
3477 cairo_region_get_extents (clip, &clipbox);
3479 gdk_cairo_region (cr, clip);
3484 cairo_region_destroy (clip);
3488 gdk_window_clear_backing_region_direct (GdkWindow *window,
3489 cairo_region_t *region)
3491 GdkWindowPaint paint;
3492 cairo_region_t *clip;
3493 GdkRectangle clipbox;
3496 if (GDK_WINDOW_DESTROYED (window))
3499 paint.surface = _gdk_window_ref_cairo_surface (window);
3501 cr = setup_backing_rect (window, &paint, 0, 0);
3503 clip = cairo_region_copy (window->clip_region_with_children);
3504 cairo_region_intersect (clip, region);
3505 cairo_region_get_extents (clip, &clipbox);
3507 gdk_cairo_region (cr, clip);
3512 cairo_region_destroy (clip);
3513 cairo_surface_destroy (paint.surface);
3518 gdk_window_clear_region_internal (GdkWindow *window,
3519 cairo_region_t *region)
3521 if (window->paint_stack)
3522 gdk_window_clear_backing_region (window, region);
3524 gdk_window_clear_backing_region_direct (window, region);
3528 gdk_window_drop_cairo_surface (GdkWindow *window)
3530 if (window->cairo_surface)
3532 cairo_surface_finish (window->cairo_surface);
3533 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3535 window->cairo_surface = NULL;
3540 gdk_window_cairo_surface_destroy (void *data)
3542 GdkWindow *window = data;
3544 window->cairo_surface = NULL;
3547 static cairo_surface_t *
3548 gdk_window_create_cairo_surface (GdkWindow *window,
3552 cairo_surface_t *surface, *subsurface;
3554 surface = gdk_window_ref_impl_surface (window);
3555 if (gdk_window_has_impl (window))
3558 subsurface = cairo_surface_create_for_rectangle (surface,
3563 cairo_surface_destroy (surface);
3569 _gdk_window_ref_cairo_surface (GdkWindow *window)
3571 cairo_surface_t *surface;
3573 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3575 if (window->paint_stack)
3577 GdkWindowPaint *paint = window->paint_stack->data;
3579 surface = paint->surface;
3580 cairo_surface_reference (surface);
3585 /* This will be drawing directly to the window, so flush implicit paint */
3586 gdk_window_flush (window);
3588 if (!window->cairo_surface)
3590 window->cairo_surface = gdk_window_create_cairo_surface (window,
3594 if (window->cairo_surface)
3596 cairo_surface_set_user_data (window->cairo_surface, &gdk_window_cairo_key,
3597 window, gdk_window_cairo_surface_destroy);
3601 cairo_surface_reference (window->cairo_surface);
3603 surface = window->cairo_surface;
3611 * @window: a #GdkWindow
3613 * Creates a Cairo context for drawing to @window.
3616 * Note that calling cairo_reset_clip() on the resulting #cairo_t will
3617 * produce undefined results, so avoid it at all costs.
3620 * Return value: A newly created Cairo context. Free with
3621 * cairo_destroy() when you are done drawing.
3626 gdk_cairo_create (GdkWindow *window)
3628 cairo_surface_t *surface;
3631 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
3633 surface = _gdk_window_ref_cairo_surface (window);
3634 cr = cairo_create (surface);
3636 if (!window->paint_stack)
3638 gdk_cairo_region (cr, window->clip_region_with_children);
3643 GdkWindowPaint *paint = window->paint_stack->data;
3645 /* Only needs to clip to region if piggybacking
3646 on an implicit paint */
3647 if (paint->uses_implicit)
3649 gdk_cairo_region (cr, paint->region);
3654 cairo_surface_destroy (surface);
3659 /* Code for dirty-region queueing
3661 static GSList *update_windows = NULL;
3662 static guint update_idle = 0;
3663 static gboolean debug_updates = FALSE;
3665 static inline gboolean
3666 gdk_window_is_ancestor (GdkWindow *window,
3667 GdkWindow *ancestor)
3671 GdkWindow *parent = window->parent;
3673 if (parent == ancestor)
3683 gdk_window_add_update_window (GdkWindow *window)
3686 GSList *prev = NULL;
3687 gboolean has_ancestor_in_list = FALSE;
3689 for (tmp = update_windows; tmp; tmp = tmp->next)
3691 GdkWindow *parent = window->parent;
3693 /* check if tmp is an ancestor of "window"; if it is, set a
3694 * flag indicating that all following windows are either
3695 * children of "window" or from a differen hierarchy
3697 if (!has_ancestor_in_list && gdk_window_is_ancestor (window, tmp->data))
3698 has_ancestor_in_list = TRUE;
3700 /* insert in reverse stacking order when adding around siblings,
3701 * so processing updates properly paints over lower stacked windows
3703 if (parent == GDK_WINDOW (tmp->data)->parent)
3705 gint index = g_list_index (parent->children, window);
3706 for (; tmp && parent == GDK_WINDOW (tmp->data)->parent; tmp = tmp->next)
3708 gint sibling_index = g_list_index (parent->children, tmp->data);
3709 if (index > sibling_index)
3713 /* here, tmp got advanced past all lower stacked siblings */
3714 tmp = g_slist_prepend (tmp, window);
3718 update_windows = tmp;
3722 /* if "window" has an ancestor in the list and tmp is one of
3723 * "window's" children, insert "window" before tmp
3725 if (has_ancestor_in_list && gdk_window_is_ancestor (tmp->data, window))
3727 tmp = g_slist_prepend (tmp, window);
3732 update_windows = tmp;
3736 /* if we're at the end of the list and had an ancestor it it,
3737 * append to the list
3739 if (! tmp->next && has_ancestor_in_list)
3741 tmp = g_slist_append (tmp, window);
3748 /* if all above checks failed ("window" is from a different
3749 * hierarchy than what is already in the list) or the list is
3752 update_windows = g_slist_prepend (update_windows, window);
3756 gdk_window_remove_update_window (GdkWindow *window)
3758 update_windows = g_slist_remove (update_windows, window);
3762 gdk_window_update_idle (gpointer data)
3764 gdk_window_process_all_updates ();
3770 gdk_window_is_toplevel_frozen (GdkWindow *window)
3772 GdkWindow *toplevel;
3774 toplevel = gdk_window_get_toplevel (window);
3776 return toplevel->update_and_descendants_freeze_count > 0;
3780 gdk_window_schedule_update (GdkWindow *window)
3783 (window->update_freeze_count ||
3784 gdk_window_is_toplevel_frozen (window)))
3789 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
3790 gdk_window_update_idle,
3795 _gdk_window_process_updates_recurse (GdkWindow *window,
3796 cairo_region_t *expose_region)
3799 cairo_region_t *clipped_expose_region;
3800 GList *l, *children;
3802 if (cairo_region_is_empty (expose_region))
3805 if (gdk_window_is_offscreen (window->impl_window) &&
3806 window == window->impl_window)
3807 _gdk_window_add_damage ((GdkWindow *) window->impl_window, expose_region);
3810 /* Paint the window before the children, clipped to the window region
3811 with visible child windows removed */
3812 clipped_expose_region = cairo_region_copy (expose_region);
3813 cairo_region_intersect (clipped_expose_region, window->clip_region_with_children);
3815 if (!cairo_region_is_empty (clipped_expose_region) &&
3818 if (window->event_mask & GDK_EXPOSURE_MASK)
3822 event.expose.type = GDK_EXPOSE;
3823 event.expose.window = g_object_ref (window);
3824 event.expose.send_event = FALSE;
3825 event.expose.count = 0;
3826 event.expose.region = clipped_expose_region;
3827 cairo_region_get_extents (clipped_expose_region, &event.expose.area);
3829 _gdk_event_emit (&event);
3831 g_object_unref (window);
3833 else if (window->window_type != GDK_WINDOW_FOREIGN)
3835 /* No exposure mask set, so nothing will be drawn, the
3836 * app relies on the background being what it specified
3837 * for the window. So, we need to clear this manually.
3839 * For foreign windows if expose is not set that generally
3840 * means some other client paints them, so don't clear
3843 * We use begin/end_paint around the clear so that we can
3844 * piggyback on the implicit paint */
3846 gdk_window_begin_paint_region (window, clipped_expose_region);
3847 gdk_window_clear_region_internal (window, clipped_expose_region);
3848 gdk_window_end_paint (window);
3851 cairo_region_destroy (clipped_expose_region);
3853 /* Make this reentrancy safe for expose handlers freeing windows */
3854 children = g_list_copy (window->children);
3855 g_list_foreach (children, (GFunc)g_object_ref, NULL);
3857 /* Iterate over children, starting at bottommost */
3858 for (l = g_list_last (children); l != NULL; l = l->prev)
3862 if (child->destroyed || !GDK_WINDOW_IS_MAPPED (child) || child->input_only || child->composited)
3865 /* Ignore offscreen children, as they don't draw in their parent and
3866 * don't take part in the clipping */
3867 if (gdk_window_is_offscreen (child))
3870 /* Client side child, expose */
3871 if (child->impl == window->impl)
3873 cairo_region_translate (expose_region, -child->x, -child->y);
3874 _gdk_window_process_updates_recurse ((GdkWindow *)child, expose_region);
3875 cairo_region_translate (expose_region, child->x, child->y);
3879 g_list_foreach (children, (GFunc)g_object_unref, NULL);
3880 g_list_free (children);
3884 /* Process and remove any invalid area on the native window by creating
3885 * expose events for the window and all non-native descendants.
3886 * Also processes any outstanding moves on the window before doing
3887 * any drawing. Note that its possible to have outstanding moves without
3888 * any invalid area as we use the update idle mechanism to coalesce
3889 * multiple moves as well as multiple invalidations.
3892 gdk_window_process_updates_internal (GdkWindow *window)
3894 GdkWindowImplClass *impl_class;
3895 gboolean save_region = FALSE;
3896 GdkRectangle clip_box;
3898 /* Ensure the window lives while updating it */
3899 g_object_ref (window);
3901 /* If an update got queued during update processing, we can get a
3902 * window in the update queue that has an empty update_area.
3905 if (window->update_area)
3907 cairo_region_t *update_area = window->update_area;
3908 window->update_area = NULL;
3910 if (gdk_window_is_viewable (window))
3912 cairo_region_t *expose_region;
3913 gboolean end_implicit;
3915 /* Clip to part visible in toplevel */
3916 cairo_region_intersect (update_area, window->clip_region);
3920 /* Make sure we see the red invalid area before redrawing. */
3921 gdk_display_sync (gdk_window_get_display (window));
3925 /* At this point we will be completely redrawing all of update_area.
3926 * If we have any outstanding moves that end up moving stuff inside
3927 * this area we don't actually need to move that as that part would
3928 * be overdrawn by the expose anyway. So, in order to copy less data
3929 * we remove these areas from the outstanding moves.
3931 if (window->outstanding_moves)
3933 GdkWindowRegionMove *move;
3934 cairo_region_t *remove;
3937 remove = cairo_region_copy (update_area);
3938 /* We iterate backwards, starting from the state that would be
3939 if we had applied all the moves. */
3940 for (l = g_list_last (window->outstanding_moves); l != NULL; l = prev)
3945 /* Don't need this area */
3946 cairo_region_subtract (move->dest_region, remove);
3948 /* However if any of the destination we do need has a source
3949 in the updated region we do need that as a destination for
3950 the earlier moves */
3951 cairo_region_translate (move->dest_region, -move->dx, -move->dy);
3952 cairo_region_subtract (remove, move->dest_region);
3954 if (cairo_region_is_empty (move->dest_region))
3956 gdk_window_region_move_free (move);
3957 window->outstanding_moves =
3958 g_list_delete_link (window->outstanding_moves, l);
3960 else /* move back */
3961 cairo_region_translate (move->dest_region, move->dx, move->dy);
3963 cairo_region_destroy (remove);
3966 /* By now we a set of window moves that should be applied, and then
3967 * an update region that should be repainted. A trivial implementation
3968 * would just do that in order, however in order to get nicer drawing
3969 * we do some tricks:
3971 * First of all, each subwindow expose may be double buffered by
3972 * itself (depending on widget setting) via
3973 * gdk_window_begin/end_paint(). But we also do an "implicit" paint,
3974 * creating a single surface the size of the invalid area on the
3975 * native window which all the individual normal paints will draw
3976 * into. This way in the normal case there will be only one surface
3977 * allocated and only once surface draw done for all the windows
3978 * in this native window.
3979 * There are a couple of reasons this may fail, for instance, some
3980 * backends (like quartz) do its own double buffering, so we disable
3981 * gdk double buffering there. Secondly, some subwindow could be
3982 * non-double buffered and draw directly to the window outside a
3983 * begin/end_paint pair. That will be lead to a gdk_window_flush
3984 * which immediately executes all outstanding moves and paints+removes
3985 * the implicit paint (further paints will allocate their own surfaces).
3987 * Secondly, in the case of implicit double buffering we expose all
3988 * the child windows into the implicit surface before we execute
3989 * the outstanding moves. This way we minimize the time between
3990 * doing the moves and rendering the new update area, thus minimizing
3991 * flashing. Of course, if any subwindow is non-double buffered we
3992 * well flush earlier than that.
3994 * Thirdly, after having done the outstanding moves we queue an
3995 * "antiexpose" on the area that will be drawn by the expose, which
3996 * means that any invalid region on the native window side before
3997 * the first expose drawing operation will be discarded, as it
3998 * has by then been overdrawn with valid data. This means we can
3999 * avoid doing the unnecessary repaint any outstanding expose events.
4002 cairo_region_get_extents (update_area, &clip_box);
4003 end_implicit = gdk_window_begin_implicit_paint (window, &clip_box);
4004 expose_region = cairo_region_copy (update_area);
4005 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
4008 /* Rendering is not double buffered by gdk, do outstanding
4009 * moves and queue antiexposure immediately. No need to do
4011 gdk_window_flush_outstanding_moves (window);
4012 save_region = impl_class->queue_antiexpose (window, update_area);
4014 /* Render the invalid areas to the implicit paint, by sending exposes.
4015 * May flush if non-double buffered widget draw. */
4016 impl_class->process_updates_recurse (window, expose_region);
4020 /* Do moves right before exposes are rendered to the window */
4021 gdk_window_flush_outstanding_moves (window);
4023 /* By this time we know that any outstanding expose for this
4024 * area is invalid and we can avoid it, so queue an antiexpose.
4025 * we have already started drawing to the window, so it would
4026 * be to late to anti-expose now. Since this is merely an
4027 * optimization we just avoid doing it at all in that case.
4029 if (window->implicit_paint != NULL && !window->implicit_paint->flushed)
4030 save_region = impl_class->queue_antiexpose (window, update_area);
4032 gdk_window_end_implicit_paint (window);
4034 cairo_region_destroy (expose_region);
4037 cairo_region_destroy (update_area);
4040 if (window->outstanding_moves)
4042 /* Flush any outstanding moves, may happen if we moved a window but got
4043 no actual invalid area */
4044 gdk_window_flush_outstanding_moves (window);
4047 g_object_unref (window);
4051 flush_all_displays (void)
4053 GSList *displays, *l;
4055 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4056 for (l = displays; l; l = l->next)
4057 gdk_display_flush (l->data);
4059 g_slist_free (displays);
4063 before_process_all_updates (void)
4065 GSList *displays, *l;
4066 GdkDisplayClass *display_class;
4068 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4069 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4070 for (l = displays; l; l = l->next)
4071 display_class->before_process_all_updates (l->data);
4073 g_slist_free (displays);
4077 after_process_all_updates (void)
4079 GSList *displays, *l;
4080 GdkDisplayClass *display_class;
4082 displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
4083 display_class = GDK_DISPLAY_GET_CLASS (displays->data);
4084 for (l = displays; l; l = l->next)
4085 display_class->after_process_all_updates (l->data);
4087 g_slist_free (displays);
4090 /* Currently it is not possible to override
4091 * gdk_window_process_all_updates in the same manner as
4092 * gdk_window_process_updates and gdk_window_invalidate_maybe_recurse
4093 * by implementing the GdkPaintable interface. If in the future a
4094 * backend would need this, the right solution would be to add a
4095 * method to GdkDisplay that can be optionally
4096 * NULL. gdk_window_process_all_updates can then walk the list of open
4097 * displays and call the mehod.
4101 * gdk_window_process_all_updates:
4103 * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
4104 * in the application.
4108 gdk_window_process_all_updates (void)
4110 GSList *old_update_windows = update_windows;
4111 GSList *tmp_list = update_windows;
4112 static gboolean in_process_all_updates = FALSE;
4113 static gboolean got_recursive_update = FALSE;
4115 if (in_process_all_updates)
4117 /* We can't do this now since that would recurse, so
4118 delay it until after the recursion is done. */
4119 got_recursive_update = TRUE;
4124 in_process_all_updates = TRUE;
4125 got_recursive_update = FALSE;
4128 g_source_remove (update_idle);
4130 update_windows = NULL;
4133 before_process_all_updates ();
4135 g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
4139 GdkWindow *window = tmp_list->data;
4141 if (!GDK_WINDOW_DESTROYED (window))
4143 if (window->update_freeze_count ||
4144 gdk_window_is_toplevel_frozen (window))
4145 gdk_window_add_update_window (window);
4147 gdk_window_process_updates_internal (window);
4150 g_object_unref (window);
4151 tmp_list = tmp_list->next;
4154 g_slist_free (old_update_windows);
4156 flush_all_displays ();
4158 after_process_all_updates ();
4160 in_process_all_updates = FALSE;
4162 /* If we ignored a recursive call, schedule a
4163 redraw now so that it eventually happens,
4164 otherwise we could miss an update if nothing
4165 else schedules an update. */
4166 if (got_recursive_update && !update_idle)
4168 gdk_threads_add_idle_full (GDK_PRIORITY_REDRAW,
4169 gdk_window_update_idle,
4174 * gdk_window_process_updates:
4175 * @window: a #GdkWindow
4176 * @update_children: whether to also process updates for child windows
4178 * Sends one or more expose events to @window. The areas in each
4179 * expose event will cover the entire update area for the window (see
4180 * gdk_window_invalidate_region() for details). Normally GDK calls
4181 * gdk_window_process_all_updates() on your behalf, so there's no
4182 * need to call this function unless you want to force expose events
4183 * to be delivered immediately and synchronously (vs. the usual
4184 * case, where GDK delivers them in an idle handler). Occasionally
4185 * this is useful to produce nicer scrolling behavior, for example.
4189 gdk_window_process_updates (GdkWindow *window,
4190 gboolean update_children)
4192 GdkWindow *impl_window;
4194 g_return_if_fail (GDK_IS_WINDOW (window));
4196 if (GDK_WINDOW_DESTROYED (window))
4199 /* Make sure the window lives during the expose callouts */
4200 g_object_ref (window);
4202 impl_window = gdk_window_get_impl_window (window);
4203 if ((impl_window->update_area ||
4204 impl_window->outstanding_moves) &&
4205 !impl_window->update_freeze_count &&
4206 !gdk_window_is_toplevel_frozen (window) &&
4208 /* Don't recurse into process_updates_internal, we'll
4209 * do the update later when idle instead. */
4210 impl_window->implicit_paint == NULL)
4212 gdk_window_process_updates_internal ((GdkWindow *)impl_window);
4213 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4216 if (update_children)
4218 /* process updates in reverse stacking order so composition or
4219 * painting over achieves the desired effect for offscreen windows
4221 GList *node, *children;
4223 children = g_list_copy (window->children);
4224 g_list_foreach (children, (GFunc)g_object_ref, NULL);
4226 for (node = g_list_last (children); node; node = node->prev)
4228 gdk_window_process_updates (node->data, TRUE);
4229 g_object_unref (node->data);
4232 g_list_free (children);
4235 g_object_unref (window);
4239 gdk_window_invalidate_rect_full (GdkWindow *window,
4240 const GdkRectangle *rect,
4241 gboolean invalidate_children,
4244 GdkRectangle window_rect;
4245 cairo_region_t *region;
4247 g_return_if_fail (GDK_IS_WINDOW (window));
4249 if (GDK_WINDOW_DESTROYED (window))
4252 if (window->input_only || !window->viewable)
4259 window_rect.width = window->width;
4260 window_rect.height = window->height;
4261 rect = &window_rect;
4264 region = cairo_region_create_rectangle (rect);
4265 gdk_window_invalidate_region_full (window, region, invalidate_children, clear_bg);
4266 cairo_region_destroy (region);
4270 * gdk_window_invalidate_rect:
4271 * @window: a #GdkWindow
4272 * @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
4274 * @invalidate_children: whether to also invalidate child windows
4276 * A convenience wrapper around gdk_window_invalidate_region() which
4277 * invalidates a rectangular region. See
4278 * gdk_window_invalidate_region() for details.
4281 gdk_window_invalidate_rect (GdkWindow *window,
4282 const GdkRectangle *rect,
4283 gboolean invalidate_children)
4285 gdk_window_invalidate_rect_full (window, rect, invalidate_children, CLEAR_BG_NONE);
4289 draw_ugly_color (GdkWindow *window,
4290 const cairo_region_t *region)
4294 cr = gdk_cairo_create (window);
4295 /* Draw ugly color all over the newly-invalid region */
4296 cairo_set_source_rgb (cr, 50000/65535., 10000/65535., 10000/65535.);
4297 gdk_cairo_region (cr, region);
4304 impl_window_add_update_area (GdkWindow *impl_window,
4305 cairo_region_t *region)
4307 if (impl_window->update_area)
4308 cairo_region_union (impl_window->update_area, region);
4311 gdk_window_add_update_window (impl_window);
4312 impl_window->update_area = cairo_region_copy (region);
4313 gdk_window_schedule_update (impl_window);
4317 /* clear_bg controls if the region will be cleared to
4318 * the background pattern if the exposure mask is not
4319 * set for the window, whereas this might not otherwise be
4320 * done (unless necessary to emulate background settings).
4321 * Set this to CLEAR_BG_WINCLEARED or CLEAR_BG_ALL if you
4322 * need to clear the background, such as when exposing the area beneath a
4323 * hidden or moved window, but not when an app requests repaint or when the
4324 * windowing system exposes a newly visible area (because then the windowing
4325 * system has already cleared the area).
4328 gdk_window_invalidate_maybe_recurse_full (GdkWindow *window,
4329 const cairo_region_t *region,
4331 GdkWindowChildFunc child_func,
4334 GdkWindow *impl_window;
4335 cairo_region_t *visible_region;
4338 g_return_if_fail (GDK_IS_WINDOW (window));
4340 if (GDK_WINDOW_DESTROYED (window))
4343 if (window->input_only ||
4344 !window->viewable ||
4345 cairo_region_is_empty (region) ||
4346 window->window_type == GDK_WINDOW_ROOT)
4349 visible_region = gdk_window_get_visible_region (window);
4350 cairo_region_intersect (visible_region, region);
4352 tmp_list = window->children;
4355 GdkWindow *child = tmp_list->data;
4357 if (!child->input_only)
4359 cairo_region_t *child_region;
4360 GdkRectangle child_rect;
4362 child_rect.x = child->x;
4363 child_rect.y = child->y;
4364 child_rect.width = child->width;
4365 child_rect.height = child->height;
4366 child_region = cairo_region_create_rectangle (&child_rect);
4368 /* remove child area from the invalid area of the parent */
4369 if (GDK_WINDOW_IS_MAPPED (child) && !child->shaped &&
4370 !child->composited &&
4371 !gdk_window_is_offscreen (child))
4372 cairo_region_subtract (visible_region, child_region);
4374 if (child_func && (*child_func) ((GdkWindow *)child, user_data))
4376 cairo_region_t *tmp = cairo_region_copy (region);
4378 cairo_region_translate (tmp, - child_rect.x, - child_rect.y);
4379 cairo_region_translate (child_region, - child_rect.x, - child_rect.y);
4380 cairo_region_intersect (child_region, tmp);
4382 gdk_window_invalidate_maybe_recurse_full ((GdkWindow *)child,
4383 child_region, clear_bg, child_func, user_data);
4385 cairo_region_destroy (tmp);
4388 cairo_region_destroy (child_region);
4391 tmp_list = tmp_list->next;
4394 impl_window = gdk_window_get_impl_window (window);
4396 if (!cairo_region_is_empty (visible_region) ||
4397 /* Even if we're not exposing anything, make sure we process
4398 idles for windows with outstanding moves */
4399 (impl_window->outstanding_moves != NULL &&
4400 impl_window->update_area == NULL))
4403 draw_ugly_color (window, region);
4405 /* Convert to impl coords */
4406 cairo_region_translate (visible_region, window->abs_x, window->abs_y);
4408 /* Only invalidate area if app requested expose events or if
4409 we need to clear the area (by request or to emulate background
4410 clearing for non-native windows or native windows with no support
4411 for window backgrounds */
4412 if (window->event_mask & GDK_EXPOSURE_MASK ||
4413 clear_bg == CLEAR_BG_ALL ||
4414 clear_bg == CLEAR_BG_WINCLEARED)
4415 impl_window_add_update_area (impl_window, visible_region);
4418 cairo_region_destroy (visible_region);
4422 * gdk_window_invalidate_maybe_recurse:
4423 * @window: a #GdkWindow
4424 * @region: a #cairo_region_t
4425 * @child_func: (scope call) (allow-none): function to use to decide if to
4426 * recurse to a child, %NULL means never recurse.
4427 * @user_data: data passed to @child_func
4429 * Adds @region to the update area for @window. The update area is the
4430 * region that needs to be redrawn, or "dirty region." The call
4431 * gdk_window_process_updates() sends one or more expose events to the
4432 * window, which together cover the entire update area. An
4433 * application would normally redraw the contents of @window in
4434 * response to those expose events.
4436 * GDK will call gdk_window_process_all_updates() on your behalf
4437 * whenever your program returns to the main loop and becomes idle, so
4438 * normally there's no need to do that manually, you just need to
4439 * invalidate regions that you know should be redrawn.
4441 * The @child_func parameter controls whether the region of
4442 * each child window that intersects @region will also be invalidated.
4443 * Only children for which @child_func returns TRUE will have the area
4447 gdk_window_invalidate_maybe_recurse (GdkWindow *window,
4448 const cairo_region_t *region,
4449 GdkWindowChildFunc child_func,
4452 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_NONE,
4453 child_func, user_data);
4457 true_predicate (GdkWindow *window,
4464 gdk_window_invalidate_region_full (GdkWindow *window,
4465 const cairo_region_t *region,
4466 gboolean invalidate_children,
4469 gdk_window_invalidate_maybe_recurse_full (window, region, clear_bg,
4470 invalidate_children ?
4471 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4476 * gdk_window_invalidate_region:
4477 * @window: a #GdkWindow
4478 * @region: a #cairo_region_t
4479 * @invalidate_children: %TRUE to also invalidate child windows
4481 * Adds @region to the update area for @window. The update area is the
4482 * region that needs to be redrawn, or "dirty region." The call
4483 * gdk_window_process_updates() sends one or more expose events to the
4484 * window, which together cover the entire update area. An
4485 * application would normally redraw the contents of @window in
4486 * response to those expose events.
4488 * GDK will call gdk_window_process_all_updates() on your behalf
4489 * whenever your program returns to the main loop and becomes idle, so
4490 * normally there's no need to do that manually, you just need to
4491 * invalidate regions that you know should be redrawn.
4493 * The @invalidate_children parameter controls whether the region of
4494 * each child window that intersects @region will also be invalidated.
4495 * If %FALSE, then the update area for child windows will remain
4496 * unaffected. See gdk_window_invalidate_maybe_recurse if you need
4497 * fine grained control over which children are invalidated.
4500 gdk_window_invalidate_region (GdkWindow *window,
4501 const cairo_region_t *region,
4502 gboolean invalidate_children)
4504 gdk_window_invalidate_maybe_recurse (window, region,
4505 invalidate_children ?
4506 true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
4511 * _gdk_window_invalidate_for_expose:
4512 * @window: a #GdkWindow
4513 * @region: a #cairo_region_t
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 * This version of invalidation is used when you recieve expose events
4528 * from the native window system. It exposes the native window, plus
4529 * any non-native child windows (but not native child windows, as those would
4530 * have gotten their own expose events).
4533 _gdk_window_invalidate_for_expose (GdkWindow *window,
4534 cairo_region_t *region)
4536 GdkWindowRegionMove *move;
4537 cairo_region_t *move_region;
4540 /* Any invalidations comming from the windowing system will
4541 be in areas that may be moved by outstanding moves,
4542 so we need to modify the expose region correspondingly,
4543 otherwise we would expose in the wrong place, as the
4544 outstanding moves will be copied before we draw the
4546 for (l = window->outstanding_moves; l != NULL; l = l->next)
4550 /* covert to move source region */
4551 move_region = cairo_region_copy (move->dest_region);
4552 cairo_region_translate (move_region, -move->dx, -move->dy);
4554 /* Move area of region that intersects with move source
4555 by dx, dy of the move*/
4556 cairo_region_intersect (move_region, region);
4557 cairo_region_subtract (region, move_region);
4558 cairo_region_translate (move_region, move->dx, move->dy);
4559 cairo_region_union (region, move_region);
4561 cairo_region_destroy (move_region);
4564 gdk_window_invalidate_maybe_recurse_full (window, region, CLEAR_BG_WINCLEARED,
4565 (gboolean (*) (GdkWindow *, gpointer))gdk_window_has_no_impl,
4571 * gdk_window_get_update_area:
4572 * @window: a #GdkWindow
4574 * Transfers ownership of the update area from @window to the caller
4575 * of the function. That is, after calling this function, @window will
4576 * no longer have an invalid/dirty region; the update area is removed
4577 * from @window and handed to you. If a window has no update area,
4578 * gdk_window_get_update_area() returns %NULL. You are responsible for
4579 * calling cairo_region_destroy() on the returned region if it's non-%NULL.
4581 * Return value: the update area for @window
4584 gdk_window_get_update_area (GdkWindow *window)
4586 GdkWindow *impl_window;
4587 cairo_region_t *tmp_region;
4589 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4591 impl_window = gdk_window_get_impl_window (window);
4593 if (impl_window->update_area)
4595 tmp_region = cairo_region_copy (window->clip_region_with_children);
4596 /* Convert to impl coords */
4597 cairo_region_translate (tmp_region, window->abs_x, window->abs_y);
4598 cairo_region_intersect (tmp_region, impl_window->update_area);
4600 if (cairo_region_is_empty (tmp_region))
4602 cairo_region_destroy (tmp_region);
4607 cairo_region_subtract (impl_window->update_area, tmp_region);
4609 if (cairo_region_is_empty (impl_window->update_area) &&
4610 impl_window->outstanding_moves == NULL)
4612 cairo_region_destroy (impl_window->update_area);
4613 impl_window->update_area = NULL;
4615 gdk_window_remove_update_window ((GdkWindow *)impl_window);
4618 /* Convert from impl coords */
4619 cairo_region_translate (tmp_region, -window->abs_x, -window->abs_y);
4629 * _gdk_window_clear_update_area:
4630 * @window: a #GdkWindow.
4632 * Internal function to clear the update area for a window. This
4633 * is called when the window is hidden or destroyed.
4636 _gdk_window_clear_update_area (GdkWindow *window)
4638 g_return_if_fail (GDK_IS_WINDOW (window));
4640 if (window->update_area)
4642 gdk_window_remove_update_window (window);
4644 cairo_region_destroy (window->update_area);
4645 window->update_area = NULL;
4650 * gdk_window_freeze_updates:
4651 * @window: a #GdkWindow
4653 * Temporarily freezes a window such that it won't receive expose
4654 * events. The window will begin receiving expose events again when
4655 * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
4656 * has been called more than once, gdk_window_thaw_updates() must be called
4657 * an equal number of times to begin processing exposes.
4660 gdk_window_freeze_updates (GdkWindow *window)
4662 GdkWindow *impl_window;
4664 g_return_if_fail (GDK_IS_WINDOW (window));
4666 impl_window = gdk_window_get_impl_window (window);
4667 impl_window->update_freeze_count++;
4671 * gdk_window_thaw_updates:
4672 * @window: a #GdkWindow
4674 * Thaws a window frozen with gdk_window_freeze_updates().
4677 gdk_window_thaw_updates (GdkWindow *window)
4679 GdkWindow *impl_window;
4681 g_return_if_fail (GDK_IS_WINDOW (window));
4683 impl_window = gdk_window_get_impl_window (window);
4685 g_return_if_fail (impl_window->update_freeze_count > 0);
4687 if (--impl_window->update_freeze_count == 0)
4688 gdk_window_schedule_update (GDK_WINDOW (impl_window));
4692 * gdk_window_freeze_toplevel_updates_libgtk_only:
4693 * @window: a #GdkWindow
4695 * Temporarily freezes a window and all its descendants such that it won't
4696 * receive expose events. The window will begin receiving expose events
4697 * again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
4698 * gdk_window_freeze_toplevel_updates_libgtk_only()
4699 * has been called more than once,
4700 * gdk_window_thaw_toplevel_updates_libgtk_only() must be called
4701 * an equal number of times to begin processing exposes.
4703 * This function is not part of the GDK public API and is only
4707 gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *window)
4709 g_return_if_fail (GDK_IS_WINDOW (window));
4710 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4712 window->update_and_descendants_freeze_count++;
4716 * gdk_window_thaw_toplevel_updates_libgtk_only:
4717 * @window: a #GdkWindow
4719 * Thaws a window frozen with
4720 * gdk_window_freeze_toplevel_updates_libgtk_only().
4722 * This function is not part of the GDK public API and is only
4726 gdk_window_thaw_toplevel_updates_libgtk_only (GdkWindow *window)
4728 g_return_if_fail (GDK_IS_WINDOW (window));
4729 g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
4730 g_return_if_fail (window->update_and_descendants_freeze_count > 0);
4732 window->update_and_descendants_freeze_count--;
4734 gdk_window_schedule_update (window);
4738 * gdk_window_set_debug_updates:
4739 * @setting: %TRUE to turn on update debugging
4741 * With update debugging enabled, calls to
4742 * gdk_window_invalidate_region() clear the invalidated region of the
4743 * screen to a noticeable color, and GDK pauses for a short time
4744 * before sending exposes to windows during
4745 * gdk_window_process_updates(). The net effect is that you can see
4746 * the invalid region for each window and watch redraws as they
4747 * occur. This allows you to diagnose inefficiencies in your application.
4749 * In essence, because the GDK rendering model prevents all flicker,
4750 * if you are redrawing the same region 400 times you may never
4751 * notice, aside from noticing a speed problem. Enabling update
4752 * debugging causes GTK to flicker slowly and noticeably, so you can
4753 * see exactly what's being redrawn when, in what order.
4755 * The --gtk-debug=updates command line option passed to GTK+ programs
4756 * enables this debug option at application startup time. That's
4757 * usually more useful than calling gdk_window_set_debug_updates()
4758 * yourself, though you might want to use this function to enable
4759 * updates sometime after application startup time.
4763 gdk_window_set_debug_updates (gboolean setting)
4765 debug_updates = setting;
4769 * gdk_window_constrain_size:
4770 * @geometry: a #GdkGeometry structure
4771 * @flags: a mask indicating what portions of @geometry are set
4772 * @width: desired width of window
4773 * @height: desired height of the window
4774 * @new_width: (out): location to store resulting width
4775 * @new_height: (out): location to store resulting height
4777 * Constrains a desired width and height according to a
4778 * set of geometry hints (such as minimum and maximum size).
4781 gdk_window_constrain_size (GdkGeometry *geometry,
4788 /* This routine is partially borrowed from fvwm.
4790 * Copyright 1993, Robert Nation
4791 * You may use this code for any purpose, as long as the original
4792 * copyright remains in the source code and all documentation
4794 * which in turn borrows parts of the algorithm from uwm
4797 gint min_height = 0;
4798 gint base_width = 0;
4799 gint base_height = 0;
4802 gint max_width = G_MAXINT;
4803 gint max_height = G_MAXINT;
4805 #define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
4807 if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
4809 base_width = geometry->base_width;
4810 base_height = geometry->base_height;
4811 min_width = geometry->min_width;
4812 min_height = geometry->min_height;
4814 else if (flags & GDK_HINT_BASE_SIZE)
4816 base_width = geometry->base_width;
4817 base_height = geometry->base_height;
4818 min_width = geometry->base_width;
4819 min_height = geometry->base_height;
4821 else if (flags & GDK_HINT_MIN_SIZE)
4823 base_width = geometry->min_width;
4824 base_height = geometry->min_height;
4825 min_width = geometry->min_width;
4826 min_height = geometry->min_height;
4829 if (flags & GDK_HINT_MAX_SIZE)
4831 max_width = geometry->max_width ;
4832 max_height = geometry->max_height;
4835 if (flags & GDK_HINT_RESIZE_INC)
4837 xinc = MAX (xinc, geometry->width_inc);
4838 yinc = MAX (yinc, geometry->height_inc);
4841 /* clamp width and height to min and max values
4843 width = CLAMP (width, min_width, max_width);
4844 height = CLAMP (height, min_height, max_height);
4846 /* shrink to base + N * inc
4848 width = base_width + FLOOR (width - base_width, xinc);
4849 height = base_height + FLOOR (height - base_height, yinc);
4851 /* constrain aspect ratio, according to:
4854 * min_aspect <= -------- <= max_aspect
4858 if (flags & GDK_HINT_ASPECT &&
4859 geometry->min_aspect > 0 &&
4860 geometry->max_aspect > 0)
4864 if (geometry->min_aspect * height > width)
4866 delta = FLOOR (height - width / geometry->min_aspect, yinc);
4867 if (height - delta >= min_height)
4871 delta = FLOOR (height * geometry->min_aspect - width, xinc);
4872 if (width + delta <= max_width)
4877 if (geometry->max_aspect * height < width)
4879 delta = FLOOR (width - height * geometry->max_aspect, xinc);
4880 if (width - delta >= min_width)
4884 delta = FLOOR (width / geometry->max_aspect - height, yinc);
4885 if (height + delta <= max_height)
4894 *new_height = height;
4898 * gdk_window_get_pointer:
4899 * @window: a #GdkWindow
4900 * @x: (out) (allow-none): return location for X coordinate of pointer or %NULL to not
4901 * return the X coordinate
4902 * @y: (out) (allow-none): return location for Y coordinate of pointer or %NULL to not
4903 * return the Y coordinate
4904 * @mask: (out) (allow-none): return location for modifier mask or %NULL to not return the
4907 * Obtains the current pointer position and modifier state.
4908 * The position is given in coordinates relative to the upper left
4909 * corner of @window.
4911 * Return value: (transfer none): the window containing the pointer (as with
4912 * gdk_window_at_pointer()), or %NULL if the window containing the
4913 * pointer isn't known to GDK
4915 * Deprecated: 3.0: Use gdk_window_get_device_position() instead.
4918 gdk_window_get_pointer (GdkWindow *window,
4921 GdkModifierType *mask)
4923 GdkDisplay *display;
4925 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4927 display = gdk_window_get_display (window);
4929 return gdk_window_get_device_position (window, display->core_pointer, x, y, mask);
4933 * gdk_window_get_device_position:
4934 * @window: a #GdkWindow.
4935 * @device: pointer #GdkDevice to query to.
4936 * @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
4937 * @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
4938 * @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
4940 * Obtains the current device position and modifier state.
4941 * The position is given in coordinates relative to the upper left
4942 * corner of @window.
4944 * Return value: (transfer none): The window underneath @device (as with
4945 * gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
4950 gdk_window_get_device_position (GdkWindow *window,
4954 GdkModifierType *mask)
4957 GdkModifierType tmp_mask;
4958 gboolean normal_child;
4960 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
4961 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
4962 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
4964 normal_child = GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_device_state (window,
4968 /* We got the coords on the impl, convert to the window */
4969 tmp_x -= window->abs_x;
4970 tmp_y -= window->abs_y;
4979 _gdk_display_enable_motion_hints (gdk_window_get_display (window), device);
4982 return _gdk_window_find_child_at (window, tmp_x, tmp_y);
4987 * gdk_get_default_root_window:
4989 * Obtains the root window (parent all other windows are inside)
4990 * for the default display and screen.
4992 * Return value: (transfer none): the default root window
4995 gdk_get_default_root_window (void)
4997 return gdk_screen_get_root_window (gdk_screen_get_default ());
5001 get_all_native_children (GdkWindow *window,
5007 for (l = window->children; l != NULL; l = l->next)
5011 if (gdk_window_has_impl (child))
5012 *native = g_list_prepend (*native, child);
5014 get_all_native_children (child, native);
5020 gdk_window_raise_internal (GdkWindow *window)
5022 GdkWindow *parent = window->parent;
5024 GList *native_children;
5026 GdkWindowImplClass *impl_class;
5030 parent->children = g_list_remove (parent->children, window);
5031 parent->children = g_list_prepend (parent->children, window);
5034 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5035 /* Just do native raise for toplevels */
5036 if (gdk_window_is_toplevel (window) ||
5037 /* The restack_under codepath should work correctly even if the parent
5038 is native, but it relies on the order of ->children to be correct,
5039 and some apps like SWT reorder the x windows without gdks knowledge,
5040 so we use raise directly in order to make these behave as before
5041 when using native windows */
5042 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5044 impl_class->raise (window);
5046 else if (gdk_window_has_impl (window))
5048 above = find_native_sibling_above (parent, window);
5051 listhead.data = window;
5052 listhead.next = NULL;
5053 listhead.prev = NULL;
5054 impl_class->restack_under ((GdkWindow *)above,
5058 impl_class->raise (window);
5062 native_children = NULL;
5063 get_all_native_children (window, &native_children);
5064 if (native_children != NULL)
5066 above = find_native_sibling_above (parent, window);
5069 impl_class->restack_under (above, native_children);
5072 /* Right order, since native_children is bottom-topmost first */
5073 for (l = native_children; l != NULL; l = l->next)
5074 impl_class->raise (l->data);
5077 g_list_free (native_children);
5083 /* Returns TRUE If the native window was mapped or unmapped */
5085 set_viewable (GdkWindow *w,
5089 GdkWindowImplClass *impl_class;
5092 if (w->viewable == val)
5098 recompute_visible_regions (w, FALSE, FALSE);
5100 for (l = w->children; l != NULL; l = l->next)
5104 if (GDK_WINDOW_IS_MAPPED (child) &&
5105 child->window_type != GDK_WINDOW_FOREIGN)
5106 set_viewable (child, val);
5109 if (gdk_window_has_impl (w) &&
5110 w->window_type != GDK_WINDOW_FOREIGN &&
5111 !gdk_window_is_toplevel (w))
5113 /* For most native windows we show/hide them not when they are
5114 * mapped/unmapped, because that may not produce the correct results.
5115 * For instance, if a native window have a non-native parent which is
5116 * hidden, but its native parent is viewable then showing the window
5117 * would make it viewable to X but its not viewable wrt the non-native
5118 * hierarchy. In order to handle this we track the gdk side viewability
5119 * and only map really viewable windows.
5121 * There are two exceptions though:
5123 * For foreign windows we don't want ever change the mapped state
5124 * except when explicitly done via gdk_window_show/hide, as this may
5125 * cause problems for client owning the foreign window when its window
5126 * is suddenly mapped or unmapped.
5128 * For toplevel windows embedded in a foreign window (e.g. a plug)
5129 * we sometimes synthesize a map of a window, but the native
5130 * window is really shown by the embedder, so we don't want to
5131 * do the show ourselves. We can't really tell this case from the normal
5132 * toplevel show as such toplevels are seen by gdk as parents of the
5133 * root window, so we make an exception for all toplevels.
5136 impl_class = GDK_WINDOW_IMPL_GET_CLASS (w->impl);
5138 impl_class->show ((GdkWindow *)w, FALSE);
5140 impl_class->hide ((GdkWindow *)w);
5148 /* Returns TRUE If the native window was mapped or unmapped */
5150 _gdk_window_update_viewable (GdkWindow *window)
5154 if (window->window_type == GDK_WINDOW_FOREIGN ||
5155 window->window_type == GDK_WINDOW_ROOT)
5157 else if (gdk_window_is_toplevel (window) ||
5158 window->parent->viewable)
5159 viewable = GDK_WINDOW_IS_MAPPED (window);
5163 return set_viewable (window, viewable);
5167 gdk_window_show_internal (GdkWindow *window, gboolean raise)
5169 GdkWindowImplClass *impl_class;
5170 gboolean was_mapped, was_viewable;
5173 g_return_if_fail (GDK_IS_WINDOW (window));
5175 if (window->destroyed)
5178 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5179 was_viewable = window->viewable;
5182 /* Keep children in (reverse) stacking order */
5183 gdk_window_raise_internal (window);
5185 if (gdk_window_has_impl (window))
5188 gdk_synthesize_window_state (window,
5189 GDK_WINDOW_STATE_WITHDRAWN,
5190 GDK_WINDOW_STATE_FOCUSED);
5197 did_show = _gdk_window_update_viewable (window);
5199 /* If it was already viewable the backend show op won't be called, call it
5200 again to ensure things happen right if the mapped tracking was not right
5201 for e.g. a foreign window.
5202 Dunno if this is strictly needed but its what happened pre-csw.
5203 Also show if not done by gdk_window_update_viewable. */
5204 if (gdk_window_has_impl (window) && (was_viewable || !did_show))
5206 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5207 impl_class->show (window, !did_show ? was_mapped : TRUE);
5210 if (!was_mapped && !gdk_window_has_impl (window))
5212 if (window->event_mask & GDK_STRUCTURE_MASK)
5213 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5215 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5216 _gdk_make_event (window, GDK_MAP, NULL, FALSE);
5219 if (!was_mapped || raise)
5221 recompute_visible_regions (window, TRUE, FALSE);
5223 /* If any decendants became visible we need to send visibility notify */
5224 gdk_window_update_visibility_recursively (window, NULL);
5226 if (gdk_window_is_viewable (window))
5228 _gdk_synthesize_crossing_events_for_geometry_change (window);
5229 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
5235 * gdk_window_show_unraised:
5236 * @window: a #GdkWindow
5238 * Shows a #GdkWindow onscreen, but does not modify its stacking
5239 * order. In contrast, gdk_window_show() will raise the window
5240 * to the top of the window stack.
5242 * On the X11 platform, in Xlib terms, this function calls
5243 * XMapWindow() (it also updates some internal GDK state, which means
5244 * that you can't really use XMapWindow() directly on a GDK window).
5247 gdk_window_show_unraised (GdkWindow *window)
5249 gdk_window_show_internal (window, FALSE);
5254 * @window: a #GdkWindow
5256 * Raises @window to the top of the Z-order (stacking order), so that
5257 * other windows with the same parent window appear below @window.
5258 * This is true whether or not the windows are visible.
5260 * If @window is a toplevel, the window manager may choose to deny the
5261 * request to move the window in the Z-order, gdk_window_raise() only
5262 * requests the restack, does not guarantee it.
5265 gdk_window_raise (GdkWindow *window)
5267 g_return_if_fail (GDK_IS_WINDOW (window));
5269 if (window->destroyed)
5272 gdk_window_flush_if_exposing (window);
5274 /* Keep children in (reverse) stacking order */
5275 gdk_window_raise_internal (window);
5277 recompute_visible_regions (window, TRUE, FALSE);
5279 if (gdk_window_is_viewable (window) &&
5280 !window->input_only)
5281 gdk_window_invalidate_region_full (window, window->clip_region, TRUE, CLEAR_BG_ALL);
5285 gdk_window_lower_internal (GdkWindow *window)
5287 GdkWindow *parent = window->parent;
5288 GdkWindowImplClass *impl_class;
5290 GList *native_children;
5295 parent->children = g_list_remove (parent->children, window);
5296 parent->children = g_list_append (parent->children, window);
5299 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5300 /* Just do native lower for toplevels */
5301 if (gdk_window_is_toplevel (window) ||
5302 /* The restack_under codepath should work correctly even if the parent
5303 is native, but it relies on the order of ->children to be correct,
5304 and some apps like SWT reorder the x windows without gdks knowledge,
5305 so we use lower directly in order to make these behave as before
5306 when using native windows */
5307 (gdk_window_has_impl (window) && gdk_window_has_impl (parent)))
5309 impl_class->lower (window);
5311 else if (gdk_window_has_impl (window))
5313 above = find_native_sibling_above (parent, window);
5316 listhead.data = window;
5317 listhead.next = NULL;
5318 listhead.prev = NULL;
5319 impl_class->restack_under ((GdkWindow *)above, &listhead);
5322 impl_class->raise (window);
5326 native_children = NULL;
5327 get_all_native_children (window, &native_children);
5328 if (native_children != NULL)
5330 above = find_native_sibling_above (parent, window);
5333 impl_class->restack_under ((GdkWindow *)above,
5337 /* Right order, since native_children is bottom-topmost first */
5338 for (l = native_children; l != NULL; l = l->next)
5339 impl_class->raise (l->data);
5342 g_list_free (native_children);
5349 gdk_window_invalidate_in_parent (GdkWindow *private)
5351 GdkRectangle r, child;
5353 if (gdk_window_is_toplevel (private))
5356 /* get the visible rectangle of the parent */
5358 r.width = private->parent->width;
5359 r.height = private->parent->height;
5361 child.x = private->x;
5362 child.y = private->y;
5363 child.width = private->width;
5364 child.height = private->height;
5365 gdk_rectangle_intersect (&r, &child, &r);
5367 gdk_window_invalidate_rect_full (private->parent, &r, TRUE, CLEAR_BG_ALL);
5373 * @window: a #GdkWindow
5375 * Lowers @window to the bottom of the Z-order (stacking order), so that
5376 * other windows with the same parent window appear above @window.
5377 * This is true whether or not the other windows are visible.
5379 * If @window is a toplevel, the window manager may choose to deny the
5380 * request to move the window in the Z-order, gdk_window_lower() only
5381 * requests the restack, does not guarantee it.
5383 * Note that gdk_window_show() raises the window again, so don't call this
5384 * function before gdk_window_show(). (Try gdk_window_show_unraised().)
5387 gdk_window_lower (GdkWindow *window)
5389 g_return_if_fail (GDK_IS_WINDOW (window));
5391 if (window->destroyed)
5394 gdk_window_flush_if_exposing (window);
5396 /* Keep children in (reverse) stacking order */
5397 gdk_window_lower_internal (window);
5399 recompute_visible_regions (window, TRUE, FALSE);
5401 _gdk_synthesize_crossing_events_for_geometry_change (window);
5402 gdk_window_invalidate_in_parent (window);
5406 * gdk_window_restack:
5407 * @window: a #GdkWindow
5408 * @sibling: (allow-none): a #GdkWindow that is a sibling of @window, or %NULL
5411 * Changes the position of @window in the Z-order (stacking order), so that
5412 * it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
5415 * If @sibling is %NULL, then this either raises (if @above is %TRUE) or
5416 * lowers the window.
5418 * If @window is a toplevel, the window manager may choose to deny the
5419 * request to move the window in the Z-order, gdk_window_restack() only
5420 * requests the restack, does not guarantee it.
5425 gdk_window_restack (GdkWindow *window,
5429 GdkWindowImplClass *impl_class;
5431 GdkWindow *above_native;
5432 GList *sibling_link;
5433 GList *native_children;
5436 g_return_if_fail (GDK_IS_WINDOW (window));
5437 g_return_if_fail (sibling == NULL || GDK_IS_WINDOW (sibling));
5439 if (window->destroyed)
5442 if (sibling == NULL)
5445 gdk_window_raise (window);
5447 gdk_window_lower (window);
5451 gdk_window_flush_if_exposing (window);
5453 if (gdk_window_is_toplevel (window))
5455 g_return_if_fail (gdk_window_is_toplevel (sibling));
5456 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5457 impl_class->restack_toplevel (window, sibling, above);
5461 parent = window->parent;
5464 sibling_link = g_list_find (parent->children, sibling);
5465 g_return_if_fail (sibling_link != NULL);
5466 if (sibling_link == NULL)
5469 parent->children = g_list_remove (parent->children, window);
5471 parent->children = g_list_insert_before (parent->children,
5475 parent->children = g_list_insert_before (parent->children,
5479 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5480 if (gdk_window_has_impl (window))
5482 above_native = find_native_sibling_above (parent, window);
5485 listhead.data = window;
5486 listhead.next = NULL;
5487 listhead.prev = NULL;
5488 impl_class->restack_under (above_native, &listhead);
5491 impl_class->raise (window);
5495 native_children = NULL;
5496 get_all_native_children (window, &native_children);
5497 if (native_children != NULL)
5499 above_native = find_native_sibling_above (parent, window);
5501 impl_class->restack_under (above_native,
5505 /* Right order, since native_children is bottom-topmost first */
5506 for (l = native_children; l != NULL; l = l->next)
5507 impl_class->raise (l->data);
5510 g_list_free (native_children);
5515 recompute_visible_regions (window, TRUE, FALSE);
5517 _gdk_synthesize_crossing_events_for_geometry_change (window);
5518 gdk_window_invalidate_in_parent (window);
5524 * @window: a #GdkWindow
5526 * Like gdk_window_show_unraised(), but also raises the window to the
5527 * top of the window stack (moves the window to the front of the
5530 * This function maps a window so it's visible onscreen. Its opposite
5531 * is gdk_window_hide().
5533 * When implementing a #GtkWidget, you should call this function on the widget's
5534 * #GdkWindow as part of the "map" method.
5537 gdk_window_show (GdkWindow *window)
5539 gdk_window_show_internal (window, TRUE);
5544 * @window: a #GdkWindow
5546 * For toplevel windows, withdraws them, so they will no longer be
5547 * known to the window manager; for all windows, unmaps them, so
5548 * they won't be displayed. Normally done automatically as
5549 * part of gtk_widget_hide().
5552 gdk_window_hide (GdkWindow *window)
5554 GdkWindowImplClass *impl_class;
5555 gboolean was_mapped, did_hide;
5557 g_return_if_fail (GDK_IS_WINDOW (window));
5559 if (window->destroyed)
5562 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5564 if (gdk_window_has_impl (window))
5567 if (GDK_WINDOW_IS_MAPPED (window))
5568 gdk_synthesize_window_state (window,
5570 GDK_WINDOW_STATE_WITHDRAWN);
5572 else if (was_mapped)
5574 GdkDisplay *display;
5575 GdkDeviceManager *device_manager;
5578 /* May need to break grabs on children */
5579 display = gdk_window_get_display (window);
5580 device_manager = gdk_display_get_device_manager (display);
5582 /* Get all devices */
5583 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
5584 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
5585 devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
5587 for (d = devices; d; d = d->next)
5589 GdkDevice *device = d->data;
5591 if (_gdk_display_end_device_grab (display,
5593 _gdk_display_get_next_serial (display),
5596 gdk_device_ungrab (device, GDK_CURRENT_TIME);
5599 window->state = GDK_WINDOW_STATE_WITHDRAWN;
5600 g_list_free (devices);
5603 did_hide = _gdk_window_update_viewable (window);
5605 /* Hide foreign window as those are not handled by update_viewable. */
5606 if (gdk_window_has_impl (window) && (!did_hide))
5608 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5609 impl_class->hide (window);
5612 recompute_visible_regions (window, TRUE, FALSE);
5614 /* all decendants became non-visible, we need to send visibility notify */
5615 gdk_window_update_visibility_recursively (window, NULL);
5617 if (was_mapped && !gdk_window_has_impl (window))
5619 if (window->event_mask & GDK_STRUCTURE_MASK)
5620 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5622 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5623 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5625 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5628 /* Invalidate the rect */
5630 gdk_window_invalidate_in_parent (window);
5634 * gdk_window_withdraw:
5635 * @window: a toplevel #GdkWindow
5637 * Withdraws a window (unmaps it and asks the window manager to forget about it).
5638 * This function is not really useful as gdk_window_hide() automatically
5639 * withdraws toplevel windows before hiding them.
5642 gdk_window_withdraw (GdkWindow *window)
5644 GdkWindowImplClass *impl_class;
5645 gboolean was_mapped;
5647 g_return_if_fail (GDK_IS_WINDOW (window));
5649 if (window->destroyed)
5652 was_mapped = GDK_WINDOW_IS_MAPPED (window);
5654 if (gdk_window_has_impl (window))
5656 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5657 impl_class->withdraw (window);
5661 if (window->event_mask & GDK_STRUCTURE_MASK)
5662 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5664 if (window->parent && window->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
5665 _gdk_make_event (window, GDK_UNMAP, NULL, FALSE);
5667 _gdk_synthesize_crossing_events_for_geometry_change (window->parent);
5670 recompute_visible_regions (window, TRUE, FALSE);
5675 * gdk_window_set_events:
5676 * @window: a #GdkWindow
5677 * @event_mask: event mask for @window
5679 * The event mask for a window determines which events will be reported
5680 * for that window from all master input devices. For example, an event mask
5681 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5682 * press events. The event mask is the bitwise OR of values from the
5683 * #GdkEventMask enumeration.
5686 gdk_window_set_events (GdkWindow *window,
5687 GdkEventMask event_mask)
5689 GdkWindowImplClass *impl_class;
5690 GdkDisplay *display;
5692 g_return_if_fail (GDK_IS_WINDOW (window));
5694 if (window->destroyed)
5697 /* If motion hint is disabled, enable motion events again */
5698 display = gdk_window_get_display (window);
5699 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5700 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5702 GList *devices = window->devices_inside;
5706 _gdk_display_enable_motion_hints (display, (GdkDevice *) devices->data);
5707 devices = devices->next;
5711 window->event_mask = event_mask;
5713 if (gdk_window_has_impl (window))
5715 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5716 impl_class->set_events (window,
5717 get_native_event_mask (window));
5723 * gdk_window_get_events:
5724 * @window: a #GdkWindow
5726 * Gets the event mask for @window for all master input devices. See
5727 * gdk_window_set_events().
5729 * Return value: event mask for @window
5732 gdk_window_get_events (GdkWindow *window)
5734 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5736 if (window->destroyed)
5739 return window->event_mask;
5743 * gdk_window_set_device_events:
5744 * @window: a #GdkWindow
5745 * @device: #GdkDevice to enable events for.
5746 * @event_mask: event mask for @window
5748 * Sets the event mask for a given device (Normally a floating device, not
5749 * attached to any visible pointer) to @window. For example, an event mask
5750 * including #GDK_BUTTON_PRESS_MASK means the window should report button
5751 * press events. The event mask is the bitwise OR of values from the
5752 * #GdkEventMask enumeration.
5757 gdk_window_set_device_events (GdkWindow *window,
5759 GdkEventMask event_mask)
5761 GdkEventMask device_mask;
5762 GdkDisplay *display;
5765 g_return_if_fail (GDK_IS_WINDOW (window));
5766 g_return_if_fail (GDK_IS_DEVICE (device));
5768 if (GDK_WINDOW_DESTROYED (window))
5771 /* If motion hint is disabled, enable motion events again */
5772 display = gdk_window_get_display (window);
5773 if ((window->event_mask & GDK_POINTER_MOTION_HINT_MASK) &&
5774 !(event_mask & GDK_POINTER_MOTION_HINT_MASK))
5775 _gdk_display_enable_motion_hints (display, device);
5777 if (G_UNLIKELY (!window->device_events))
5778 window->device_events = g_hash_table_new (NULL, NULL);
5780 if (event_mask == 0)
5782 /* FIXME: unsetting events on a master device
5783 * would restore window->event_mask
5785 g_hash_table_remove (window->device_events, device);
5788 g_hash_table_insert (window->device_events, device,
5789 GINT_TO_POINTER (event_mask));
5791 native = gdk_window_get_toplevel (window);
5793 while (gdk_window_is_offscreen (native))
5795 native = gdk_offscreen_window_get_embedder (native);
5797 if (native == NULL ||
5798 (!_gdk_window_has_impl (native) &&
5799 !gdk_window_is_viewable (native)))
5802 native = gdk_window_get_toplevel (native);
5805 device_mask = get_native_device_event_mask (window, device);
5806 GDK_DEVICE_GET_CLASS (device)->select_window_events (device, native, device_mask);
5810 * gdk_window_get_device_events:
5811 * @window: a #GdkWindow.
5812 * @device: a #GdkDevice.
5814 * Returns the event mask for @window corresponding to an specific device.
5816 * Returns: device event mask for @window
5821 gdk_window_get_device_events (GdkWindow *window,
5826 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
5827 g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
5829 if (GDK_WINDOW_DESTROYED (window))
5832 if (!window->device_events)
5835 mask = GPOINTER_TO_INT (g_hash_table_lookup (window->device_events, device));
5837 /* FIXME: device could be controlled by window->event_mask */
5843 gdk_window_move_resize_toplevel (GdkWindow *window,
5850 cairo_region_t *old_region, *new_region;
5851 GdkWindowImplClass *impl_class;
5858 is_resize = (width != -1) || (height != -1);
5860 if (gdk_window_is_viewable (window) &&
5861 !window->input_only)
5864 old_region = cairo_region_copy (window->clip_region);
5867 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
5868 impl_class->move_resize (window, with_move, x, y, width, height);
5870 /* Avoid recomputing for pure toplevel moves, for performance reasons */
5872 recompute_visible_regions (window, TRUE, FALSE);
5876 new_region = cairo_region_copy (window->clip_region);
5878 /* This is the newly exposed area (due to any resize),
5879 * X will expose it, but lets do that without the roundtrip
5881 cairo_region_subtract (new_region, old_region);
5882 gdk_window_invalidate_region_full (window, new_region, TRUE, CLEAR_BG_WINCLEARED);
5884 cairo_region_destroy (old_region);
5885 cairo_region_destroy (new_region);
5888 _gdk_synthesize_crossing_events_for_geometry_change (window);
5893 move_native_children (GdkWindow *private)
5897 GdkWindowImplClass *impl_class;
5899 for (l = private->children; l; l = l->next)
5903 if (child->impl != private->impl)
5905 impl_class = GDK_WINDOW_IMPL_GET_CLASS (child->impl);
5906 impl_class->move_resize (child, TRUE,
5908 child->width, child->height);
5911 move_native_children (child);
5916 collect_native_child_region_helper (GdkWindow *window,
5917 GdkWindowImpl *impl,
5918 cairo_region_t **region,
5923 cairo_region_t *tmp;
5926 for (l = window->children; l != NULL; l = l->next)
5930 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
5933 if (child->impl != impl)
5935 tmp = cairo_region_copy (child->clip_region);
5936 cairo_region_translate (tmp,
5937 x_offset + child->x,
5938 y_offset + child->y);
5939 if (*region == NULL)
5943 cairo_region_union (*region, tmp);
5944 cairo_region_destroy (tmp);
5948 collect_native_child_region_helper (child, impl, region,
5949 x_offset + child->x,
5950 y_offset + child->y);
5956 static cairo_region_t *
5957 collect_native_child_region (GdkWindow *window,
5958 gboolean include_this)
5960 cairo_region_t *region;
5962 if (include_this && gdk_window_has_impl (window) && window->viewable)
5963 return cairo_region_copy (window->clip_region);
5967 collect_native_child_region_helper (window, window->impl, ®ion, 0, 0);
5974 gdk_window_move_resize_internal (GdkWindow *window,
5981 cairo_region_t *old_region, *old_layered, *new_region, *copy_area;
5982 cairo_region_t *old_native_child_region, *new_native_child_region;
5983 GdkWindow *impl_window;
5984 GdkWindowImplClass *impl_class;
5986 int old_x, old_y, old_abs_x, old_abs_y;
5989 g_return_if_fail (GDK_IS_WINDOW (window));
5991 if (window->destroyed)
5994 if (gdk_window_is_toplevel (window))
5996 gdk_window_move_resize_toplevel (window, with_move, x, y, width, height);
6000 /* Bail early if no change */
6001 if (window->width == width &&
6002 window->height == height &&
6008 gdk_window_flush_if_exposing (window);
6010 /* Handle child windows */
6016 impl_window = gdk_window_get_impl_window (window);
6021 old_native_child_region = NULL;
6022 if (gdk_window_is_viewable (window) &&
6023 !window->input_only)
6027 old_region = cairo_region_copy (window->clip_region);
6028 old_layered = cairo_region_copy (window->layered_region);
6029 /* Adjust regions to parent window coords */
6030 cairo_region_translate (old_region, window->x, window->y);
6031 cairo_region_translate (old_layered, window->x, window->y);
6033 old_native_child_region = collect_native_child_region (window, TRUE);
6034 if (old_native_child_region)
6036 /* Adjust region to parent window coords */
6037 cairo_region_translate (old_native_child_region, window->x, window->y);
6039 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6040 * source or destination for a delayed GdkWindowRegionMove. So, we need
6041 * to flush those here for the parent window and all overlapped subwindows
6042 * of it. And we need to do this before setting the new clips as those will be
6045 gdk_window_flush_recursive (window->parent);
6049 /* Set the new position and size */
6055 if (!(width < 0 && height < 0))
6059 window->width = width;
6062 window->height = height;
6065 dx = window->x - old_x;
6066 dy = window->y - old_y;
6068 old_abs_x = window->abs_x;
6069 old_abs_y = window->abs_y;
6071 recompute_visible_regions (window, TRUE, FALSE);
6073 new_native_child_region = NULL;
6074 if (old_native_child_region)
6076 new_native_child_region = collect_native_child_region (window, TRUE);
6077 /* Adjust region to parent window coords */
6078 cairo_region_translate (new_native_child_region, window->x, window->y);
6081 if (gdk_window_has_impl (window))
6083 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6085 /* Do the actual move after recomputing things, as this will have set the shape to
6086 the now correct one, thus avoiding copying regions that should not be copied. */
6087 impl_class->move_resize (window, TRUE,
6088 window->x, window->y,
6089 window->width, window->height);
6091 else if (old_abs_x != window->abs_x ||
6092 old_abs_y != window->abs_y)
6093 move_native_children (window);
6097 new_region = cairo_region_copy (window->clip_region);
6098 /* Adjust region to parent window coords */
6099 cairo_region_translate (new_region, window->x, window->y);
6102 * Part of the data at the new location can be copied from the
6103 * old location, this area is the intersection of the old region
6104 * moved as the copy will move it and then intersected with
6108 * Everything in the old and new regions that is not copied must be
6109 * invalidated (including children) as this is newly exposed
6111 if (window->has_alpha_background)
6112 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6114 copy_area = cairo_region_copy (new_region);
6116 /* Don't copy from a previously layered region */
6117 cairo_region_translate (old_layered, dx, dy);
6118 cairo_region_subtract (copy_area, old_layered);
6120 /* Don't copy into a layered region */
6121 cairo_region_translate (copy_area, -window->x, -window->y);
6122 cairo_region_subtract (copy_area, window->layered_region);
6123 cairo_region_translate (copy_area, window->x, window->y);
6125 cairo_region_union (new_region, old_region);
6127 if (old_native_child_region)
6129 /* Don't copy from inside native children, as this is copied by
6130 * the native window move.
6132 cairo_region_subtract (old_region, old_native_child_region);
6134 cairo_region_translate (old_region, dx, dy);
6136 cairo_region_intersect (copy_area, old_region);
6138 if (new_native_child_region)
6140 /* Don't copy any bits that would cause a read from the moved
6141 native windows, as we can't read that data */
6142 cairo_region_translate (new_native_child_region, dx, dy);
6143 cairo_region_subtract (copy_area, new_native_child_region);
6144 cairo_region_translate (new_native_child_region, -dx, -dy);
6147 cairo_region_subtract (new_region, copy_area);
6149 /* Convert old region to impl coords */
6150 cairo_region_translate (old_region, -dx + window->abs_x - window->x, -dy + window->abs_y - window->y);
6152 /* convert from parent coords to impl */
6153 cairo_region_translate (copy_area, window->abs_x - window->x, window->abs_y - window->y);
6155 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6157 /* Invalidate affected part in the parent window
6158 * (no higher window should be affected)
6159 * We also invalidate any children in that area, which could include
6160 * this window if it still overlaps that area.
6162 if (old_native_child_region)
6164 /* No need to expose the region that the native window move copies */
6165 cairo_region_translate (old_native_child_region, dx, dy);
6166 cairo_region_intersect (old_native_child_region, new_native_child_region);
6167 cairo_region_subtract (new_region, old_native_child_region);
6169 gdk_window_invalidate_region_full (window->parent, new_region, TRUE, CLEAR_BG_ALL);
6171 cairo_region_destroy (old_region);
6172 cairo_region_destroy (old_layered);
6173 cairo_region_destroy (new_region);
6176 if (old_native_child_region)
6178 cairo_region_destroy (old_native_child_region);
6179 cairo_region_destroy (new_native_child_region);
6182 _gdk_synthesize_crossing_events_for_geometry_change (window);
6189 * @window: a #GdkWindow
6190 * @x: X coordinate relative to window's parent
6191 * @y: Y coordinate relative to window's parent
6193 * Repositions a window relative to its parent window.
6194 * For toplevel windows, window managers may ignore or modify the move;
6195 * you should probably use gtk_window_move() on a #GtkWindow widget
6196 * anyway, instead of using GDK functions. For child windows,
6197 * the move will reliably succeed.
6199 * If you're also planning to resize the window, use gdk_window_move_resize()
6200 * to both move and resize simultaneously, for a nicer visual effect.
6203 gdk_window_move (GdkWindow *window,
6207 gdk_window_move_resize_internal (window, TRUE, x, y, -1, -1);
6211 * gdk_window_resize:
6212 * @window: a #GdkWindow
6213 * @width: new width of the window
6214 * @height: new height of the window
6216 * Resizes @window; for toplevel windows, asks the window manager to resize
6217 * the window. The window manager may not allow the resize. When using GTK+,
6218 * use gtk_window_resize() instead of this low-level GDK function.
6220 * Windows may not be resized below 1x1.
6222 * If you're also planning to move the window, use gdk_window_move_resize()
6223 * to both move and resize simultaneously, for a nicer visual effect.
6226 gdk_window_resize (GdkWindow *window,
6230 gdk_window_move_resize_internal (window, FALSE, 0, 0, width, height);
6235 * gdk_window_move_resize:
6236 * @window: a #GdkWindow
6237 * @x: new X position relative to window's parent
6238 * @y: new Y position relative to window's parent
6240 * @height: new height
6242 * Equivalent to calling gdk_window_move() and gdk_window_resize(),
6243 * except that both operations are performed at once, avoiding strange
6244 * visual effects. (i.e. the user may be able to see the window first
6245 * move, then resize, if you don't use gdk_window_move_resize().)
6248 gdk_window_move_resize (GdkWindow *window,
6254 gdk_window_move_resize_internal (window, TRUE, x, y, width, height);
6259 * gdk_window_scroll:
6260 * @window: a #GdkWindow
6261 * @dx: Amount to scroll in the X direction
6262 * @dy: Amount to scroll in the Y direction
6264 * Scroll the contents of @window, both pixels and children, by the
6265 * given amount. @window itself does not move. Portions of the window
6266 * that the scroll operation brings in from offscreen areas are
6267 * invalidated. The invalidated region may be bigger than what would
6268 * strictly be necessary.
6270 * For X11, a minimum area will be invalidated if the window has no
6271 * subwindows, or if the edges of the window's parent do not extend
6272 * beyond the edges of the window. In other cases, a multi-step process
6273 * is used to scroll the window which may produce temporary visual
6274 * artifacts and unnecessary invalidations.
6277 gdk_window_scroll (GdkWindow *window,
6281 GdkWindow *impl_window;
6282 cairo_region_t *copy_area, *noncopy_area, *old_layered_area;
6283 cairo_region_t *old_native_child_region, *new_native_child_region;
6286 g_return_if_fail (GDK_IS_WINDOW (window));
6288 if (dx == 0 && dy == 0)
6291 if (window->destroyed)
6294 gdk_window_flush_if_exposing (window);
6296 old_layered_area = cairo_region_copy (window->layered_region);
6297 old_native_child_region = collect_native_child_region (window, FALSE);
6298 if (old_native_child_region)
6300 /* Any native window move will immediately copy stuff to the destination, which may overwrite a
6301 * source or destination for a delayed GdkWindowRegionMove. So, we need
6302 * to flush those here for the window and all overlapped subwindows
6303 * of it. And we need to do this before setting the new clips as those will be
6306 gdk_window_flush_recursive (window);
6310 /* First move all child windows, without causing invalidation */
6312 tmp_list = window->children;
6315 GdkWindow *child = GDK_WINDOW (tmp_list->data);
6317 /* Just update the positions, the bits will move with the copy */
6321 tmp_list = tmp_list->next;
6324 recompute_visible_regions (window, FALSE, TRUE);
6326 new_native_child_region = NULL;
6327 if (old_native_child_region)
6328 new_native_child_region = collect_native_child_region (window, FALSE);
6330 move_native_children (window);
6332 /* Then copy the actual bits of the window w/ child windows */
6334 impl_window = gdk_window_get_impl_window (window);
6336 /* Calculate the area that can be gotten by copying the old area */
6337 if (window->has_alpha_background)
6338 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6340 copy_area = cairo_region_copy (window->clip_region);
6341 cairo_region_subtract (copy_area, old_layered_area);
6342 if (old_native_child_region)
6344 /* Don't copy from inside native children, as this is copied by
6345 * the native window move.
6347 cairo_region_subtract (copy_area, old_native_child_region);
6349 /* Don't copy any bits that would cause a read from the moved
6350 native windows, as we can't read that data */
6351 cairo_region_subtract (copy_area, new_native_child_region);
6353 cairo_region_translate (copy_area, dx, dy);
6354 cairo_region_intersect (copy_area, window->clip_region);
6355 cairo_region_subtract (copy_area, window->layered_region);
6357 /* And the rest need to be invalidated */
6358 noncopy_area = cairo_region_copy (window->clip_region);
6359 cairo_region_subtract (noncopy_area, copy_area);
6361 /* convert from window coords to impl */
6362 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6364 move_region_on_impl (impl_window, copy_area, dx, dy); /* takes ownership of copy_area */
6366 /* Invalidate not copied regions */
6367 if (old_native_child_region)
6369 /* No need to expose the region that the native window move copies */
6370 cairo_region_translate (old_native_child_region, dx, dy);
6371 cairo_region_intersect (old_native_child_region, new_native_child_region);
6372 cairo_region_subtract (noncopy_area, old_native_child_region);
6374 gdk_window_invalidate_region_full (window, noncopy_area, TRUE, CLEAR_BG_ALL);
6376 cairo_region_destroy (noncopy_area);
6377 cairo_region_destroy (old_layered_area);
6379 if (old_native_child_region)
6381 cairo_region_destroy (old_native_child_region);
6382 cairo_region_destroy (new_native_child_region);
6385 _gdk_synthesize_crossing_events_for_geometry_change (window);
6389 * gdk_window_move_region:
6390 * @window: a #GdkWindow
6391 * @region: The #cairo_region_t to move
6392 * @dx: Amount to move in the X direction
6393 * @dy: Amount to move in the Y direction
6395 * Move the part of @window indicated by @region by @dy pixels in the Y
6396 * direction and @dx pixels in the X direction. The portions of @region
6397 * that not covered by the new position of @region are invalidated.
6399 * Child windows are not moved.
6404 gdk_window_move_region (GdkWindow *window,
6405 const cairo_region_t *region,
6409 GdkWindow *impl_window;
6410 cairo_region_t *nocopy_area;
6411 cairo_region_t *copy_area;
6413 g_return_if_fail (GDK_IS_WINDOW (window));
6414 g_return_if_fail (region != NULL);
6416 if (dx == 0 && dy == 0)
6419 if (window->destroyed)
6422 impl_window = gdk_window_get_impl_window (window);
6424 /* compute source regions */
6425 if (window->has_alpha_background)
6426 copy_area = cairo_region_create (); /* Copy nothing for alpha windows */
6428 copy_area = cairo_region_copy (region);
6429 cairo_region_intersect (copy_area, window->clip_region_with_children);
6430 cairo_region_subtract (copy_area, window->layered_region);
6432 /* compute destination regions */
6433 cairo_region_translate (copy_area, dx, dy);
6434 cairo_region_intersect (copy_area, window->clip_region_with_children);
6435 cairo_region_subtract (copy_area, window->layered_region);
6437 /* Invalidate parts of the region (source and dest) not covered
6439 nocopy_area = cairo_region_copy (region);
6440 cairo_region_translate (nocopy_area, dx, dy);
6441 cairo_region_union (nocopy_area, region);
6442 cairo_region_subtract (nocopy_area, copy_area);
6444 /* convert from window coords to impl */
6445 cairo_region_translate (copy_area, window->abs_x, window->abs_y);
6446 move_region_on_impl (impl_window, copy_area, dx, dy); /* Takes ownership of copy_area */
6448 gdk_window_invalidate_region_full (window, nocopy_area, FALSE, CLEAR_BG_ALL);
6449 cairo_region_destroy (nocopy_area);
6453 * gdk_window_set_background:
6454 * @window: a #GdkWindow
6455 * @color: a #GdkColor
6457 * Sets the background color of @window. (However, when using GTK+,
6458 * set the background of a widget with gtk_widget_modify_bg() - if
6459 * you're an application - or gtk_style_set_background() - if you're
6460 * implementing a custom widget.)
6462 * See also gdk_window_set_background_pattern().
6465 gdk_window_set_background (GdkWindow *window,
6466 const GdkColor *color)
6468 cairo_pattern_t *pattern;
6470 g_return_if_fail (GDK_IS_WINDOW (window));
6472 pattern = cairo_pattern_create_rgb (color->red / 65535.,
6473 color->green / 65535.,
6474 color->blue / 65535.);
6476 gdk_window_set_background_pattern (window, pattern);
6478 cairo_pattern_destroy (pattern);
6482 * gdk_window_set_background_rgba:
6483 * @window: a #GdkWindow
6484 * @rgba: a #GdkRGBA color
6486 * Sets the background color of @window.
6488 * See also gdk_window_set_background_pattern().
6491 gdk_window_set_background_rgba (GdkWindow *window,
6494 cairo_pattern_t *pattern;
6496 g_return_if_fail (GDK_IS_WINDOW (window));
6497 g_return_if_fail (rgba != NULL);
6499 pattern = cairo_pattern_create_rgba (rgba->red, rgba->green,
6500 rgba->blue, rgba->alpha);
6502 gdk_window_set_background_pattern (window, pattern);
6504 cairo_pattern_destroy (pattern);
6508 /* Updates has_alpha_background recursively for all child windows
6509 that have parent-relative alpha */
6511 _gdk_window_propagate_has_alpha_background (GdkWindow *window)
6516 for (l = window->children; l; l = l->next)
6520 if (child->background == NULL &&
6521 child->has_alpha_background != window->has_alpha_background)
6523 child->has_alpha_background = window->has_alpha_background;
6524 recompute_visible_regions (child, TRUE, FALSE);
6525 _gdk_window_propagate_has_alpha_background (child);
6531 * gdk_window_set_background_pattern:
6532 * @window: a #GdkWindow
6533 * @pattern: (allow-none): a pattern to use, or %NULL
6535 * Sets the background of @window.
6537 * A background of %NULL means that the window will inherit its
6538 * background form its parent window.
6540 * The windowing system will normally fill a window with its background
6541 * when the window is obscured then exposed.
6544 gdk_window_set_background_pattern (GdkWindow *window,
6545 cairo_pattern_t *pattern)
6548 cairo_pattern_type_t type;
6550 g_return_if_fail (GDK_IS_WINDOW (window));
6552 if (window->input_only)
6556 cairo_pattern_reference (pattern);
6557 if (window->background)
6558 cairo_pattern_destroy (window->background);
6559 window->background = pattern;
6563 if (pattern == NULL)
6565 /* parent-relative, copy has_alpha from parent */
6566 if (window->parent == NULL ||
6567 window->parent->window_type == GDK_WINDOW_ROOT)
6570 has_alpha = window->parent->has_alpha_background;
6574 type = cairo_pattern_get_type (pattern);
6576 if (type == CAIRO_PATTERN_TYPE_SOLID)
6579 cairo_pattern_get_rgba (pattern, NULL, NULL, NULL, &alpha);
6583 else if (type == CAIRO_PATTERN_TYPE_LINEAR ||
6584 type == CAIRO_PATTERN_TYPE_RADIAL)
6590 cairo_pattern_get_color_stop_count (pattern, &n);
6592 for (i = 0; i < n; i++)
6594 cairo_pattern_get_color_stop_rgba (pattern, i, NULL,
6595 NULL, NULL, NULL, &alpha);
6603 else if (type == CAIRO_PATTERN_TYPE_SURFACE)
6605 cairo_surface_t *surface;
6606 cairo_content_t content;
6608 cairo_pattern_get_surface (pattern, &surface);
6609 content = cairo_surface_get_content (surface);
6611 (content == CAIRO_CONTENT_ALPHA) ||
6612 (content == CAIRO_CONTENT_COLOR_ALPHA);
6616 if (has_alpha != window->has_alpha_background)
6618 window->has_alpha_background = has_alpha;
6619 recompute_visible_regions (window, TRUE, FALSE);
6621 _gdk_window_propagate_has_alpha_background (window);
6624 if (gdk_window_has_impl (window))
6626 GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6627 impl_class->set_background (window, pattern);
6630 gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
6634 * gdk_window_get_background_pattern:
6637 * Gets the pattern used to clear the background on @window. If @window
6638 * does not have its own background and reuses the parent's, %NULL is
6639 * returned and you'll have to query it yourself.
6641 * Returns: (transfer none): The pattern to use for the background or
6642 * %NULL to use the parent's background.
6647 gdk_window_get_background_pattern (GdkWindow *window)
6649 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6651 return window->background;
6655 gdk_window_set_cursor_internal (GdkWindow *window,
6659 if (GDK_WINDOW_DESTROYED (window))
6662 if (window->window_type == GDK_WINDOW_ROOT ||
6663 window->window_type == GDK_WINDOW_FOREIGN)
6664 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_device_cursor (window, device, cursor);
6667 GdkPointerWindowInfo *pointer_info;
6668 GdkDisplay *display;
6670 display = gdk_window_get_display (window);
6671 pointer_info = _gdk_display_get_pointer_info (display, device);
6673 if (_gdk_window_event_parent_of (window, pointer_info->window_under_pointer))
6674 update_cursor (display, device);
6679 * gdk_window_get_cursor:
6680 * @window: a #GdkWindow
6682 * Retrieves a #GdkCursor pointer for the cursor currently set on the
6683 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6684 * there is no custom cursor set on the specified window, and it is
6685 * using the cursor for its parent window.
6687 * Return value: (transfer none): a #GdkCursor, or %NULL. The returned
6688 * object is owned by the #GdkWindow and should not be unreferenced
6689 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6695 gdk_window_get_cursor (GdkWindow *window)
6697 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6699 return window->cursor;
6703 * gdk_window_set_cursor:
6704 * @window: a #GdkWindow
6705 * @cursor: (allow-none): a cursor
6707 * Sets the default mouse pointer for a #GdkWindow. Use gdk_cursor_new_for_display()
6708 * or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor
6709 * invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument
6710 * to gdk_window_set_cursor() means that @window will use the cursor of its
6711 * parent window. Most windows should use this default.
6714 gdk_window_set_cursor (GdkWindow *window,
6717 GdkDisplay *display;
6719 g_return_if_fail (GDK_IS_WINDOW (window));
6721 display = gdk_window_get_display (window);
6725 g_object_unref (window->cursor);
6726 window->cursor = NULL;
6729 if (!GDK_WINDOW_DESTROYED (window))
6731 GdkDeviceManager *device_manager;
6735 window->cursor = g_object_ref (cursor);
6737 device_manager = gdk_display_get_device_manager (display);
6738 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
6740 for (d = devices; d; d = d->next)
6746 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
6749 gdk_window_set_cursor_internal (window, device, window->cursor);
6752 g_list_free (devices);
6753 g_object_notify (G_OBJECT (window), "cursor");
6758 * gdk_window_get_device_cursor:
6759 * @window: a #GdkWindow.
6760 * @device: a master, pointer #GdkDevice.
6762 * Retrieves a #GdkCursor pointer for the @device currently set on the
6763 * specified #GdkWindow, or %NULL. If the return value is %NULL then
6764 * there is no custom cursor set on the specified window, and it is
6765 * using the cursor for its parent window.
6767 * Returns: (transfer none): a #GdkCursor, or %NULL. The returned
6768 * object is owned by the #GdkWindow and should not be unreferenced
6769 * directly. Use gdk_window_set_cursor() to unset the cursor of the
6775 gdk_window_get_device_cursor (GdkWindow *window,
6778 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
6779 g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
6780 g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
6781 g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, NULL);
6783 return g_hash_table_lookup (window->device_cursor, device);
6787 * gdk_window_set_device_cursor:
6788 * @window: a #Gdkwindow
6789 * @device: a master, pointer #GdkDevice
6790 * @cursor: a #GdkCursor
6792 * Sets a specific #GdkCursor for a given device when it gets inside @window.
6793 * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
6794 * the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
6795 * %NULL for the @cursor argument to gdk_window_set_cursor() means that
6796 * @window will use the cursor of its parent window. Most windows should
6802 gdk_window_set_device_cursor (GdkWindow *window,
6806 g_return_if_fail (GDK_IS_WINDOW (window));
6807 g_return_if_fail (GDK_IS_DEVICE (device));
6808 g_return_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD);
6809 g_return_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER);
6812 g_hash_table_remove (window->device_cursor, device);
6814 g_hash_table_replace (window->device_cursor, device, g_object_ref (cursor));
6816 gdk_window_set_cursor_internal (window, device, cursor);
6820 * gdk_window_get_geometry:
6821 * @window: a #GdkWindow
6822 * @x: (out) (allow-none): return location for X coordinate of window (relative to its parent)
6823 * @y: (out) (allow-none): return location for Y coordinate of window (relative to its parent)
6824 * @width: (out) (allow-none): return location for width of window
6825 * @height: (out) (allow-none): return location for height of window
6827 * Any of the return location arguments to this function may be %NULL,
6828 * if you aren't interested in getting the value of that field.
6830 * The X and Y coordinates returned are relative to the parent window
6831 * of @window, which for toplevels usually means relative to the
6832 * window decorations (titlebar, etc.) rather than relative to the
6833 * root window (screen-size background window).
6835 * On the X11 platform, the geometry is obtained from the X server,
6836 * so reflects the latest position of @window; this may be out-of-sync
6837 * with the position of @window delivered in the most-recently-processed
6838 * #GdkEventConfigure. gdk_window_get_position() in contrast gets the
6839 * position from the most recent configure event.
6842 * If @window is not a toplevel, it is <emphasis>much</emphasis> better
6843 * to call gdk_window_get_position(), gdk_window_get_width() and
6844 * gdk_window_get_height() instead, because it avoids the roundtrip to
6845 * the X server and because these functions support the full 32-bit
6846 * coordinate space, whereas gdk_window_get_geometry() is restricted to
6847 * the 16-bit coordinates of X11.
6851 gdk_window_get_geometry (GdkWindow *window,
6858 GdkWindowImplClass *impl_class;
6862 GDK_NOTE (MULTIHEAD,
6863 g_message ("gdk_window_get_geometry(): Window needs "
6864 "to be non-NULL to be multi head safe"));
6865 window = gdk_screen_get_root_window ((gdk_screen_get_default ()));
6868 g_return_if_fail (GDK_IS_WINDOW (window));
6870 if (!GDK_WINDOW_DESTROYED (window))
6872 if (gdk_window_has_impl (window))
6874 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6875 impl_class->get_geometry (window, x, y,
6877 /* This reports the position wrt to the native parent, we need to convert
6878 it to be relative to the client side parent */
6879 parent = window->parent;
6880 if (parent && !gdk_window_has_impl (parent))
6883 *x -= parent->abs_x;
6885 *y -= parent->abs_y;
6895 *width = window->width;
6897 *height = window->height;
6903 * gdk_window_get_width:
6904 * @window: a #GdkWindow
6906 * Returns the width of the given @window.
6908 * On the X11 platform the returned size is the size reported in the
6909 * most-recently-processed configure event, rather than the current
6910 * size on the X server.
6912 * Returns: The width of @window
6917 gdk_window_get_width (GdkWindow *window)
6919 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6921 return window->width;
6925 * gdk_window_get_height:
6926 * @window: a #GdkWindow
6928 * Returns the height of the given @window.
6930 * On the X11 platform the returned size is the size reported in the
6931 * most-recently-processed configure event, rather than the current
6932 * size on the X server.
6934 * Returns: The height of @window
6939 gdk_window_get_height (GdkWindow *window)
6941 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6943 return window->height;
6947 * gdk_window_get_origin:
6948 * @window: a #GdkWindow
6949 * @x: (out) (allow-none): return location for X coordinate
6950 * @y: (out) (allow-none): return location for Y coordinate
6952 * Obtains the position of a window in root window coordinates.
6953 * (Compare with gdk_window_get_position() and
6954 * gdk_window_get_geometry() which return the position of a window
6955 * relative to its parent window.)
6957 * Return value: not meaningful, ignore
6960 gdk_window_get_origin (GdkWindow *window,
6964 GdkWindowImplClass *impl_class;
6966 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
6968 if (GDK_WINDOW_DESTROYED (window))
6977 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
6978 impl_class->get_root_coords (window,
6987 * gdk_window_get_root_coords:
6988 * @window: a #GdkWindow
6989 * @x: X coordinate in window
6990 * @y: Y coordinate in window
6991 * @root_x: (out): return location for X coordinate
6992 * @root_y: (out): return location for Y coordinate
6994 * Obtains the position of a window position in root
6995 * window coordinates. This is similar to
6996 * gdk_window_get_origin() but allows you go pass
6997 * in any position in the window, not just the origin.
7002 gdk_window_get_root_coords (GdkWindow *window,
7008 GdkWindowImplClass *impl_class;
7010 g_return_if_fail (GDK_IS_WINDOW (window));
7012 if (GDK_WINDOW_DESTROYED (window))
7019 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7020 impl_class->get_root_coords (window,
7027 * gdk_window_coords_to_parent:
7028 * @window: a child window
7029 * @x: X coordinate in child's coordinate system
7030 * @y: Y coordinate in child's coordinate system
7031 * @parent_x: (out) (allow-none): return location for X coordinate
7032 * in parent's coordinate system, or %NULL
7033 * @parent_y: (out) (allow-none): return location for Y coordinate
7034 * in parent's coordinate system, or %NULL
7036 * Transforms window coordinates from a child window to its parent
7037 * window, where the parent window is the normal parent as returned by
7038 * gdk_window_get_parent() for normal windows, and the window's
7039 * embedder as returned by gdk_offscreen_window_get_embedder() for
7040 * offscreen windows.
7042 * For normal windows, calling this function is equivalent to adding
7043 * the return values of gdk_window_get_position() to the child coordinates.
7044 * For offscreen windows however (which can be arbitrarily transformed),
7045 * this function calls the GdkWindow::to-embedder: signal to translate
7048 * You should always use this function when writing generic code that
7049 * walks up a window hierarchy.
7051 * See also: gdk_window_coords_from_parent()
7056 gdk_window_coords_to_parent (GdkWindow *window,
7062 g_return_if_fail (GDK_IS_WINDOW (window));
7064 if (gdk_window_is_offscreen (window))
7068 to_embedder (window, x, y, &px, &py);
7079 *parent_x = x + window->x;
7082 *parent_y = y + window->y;
7087 * gdk_window_coords_from_parent:
7088 * @window: a child window
7089 * @parent_x: X coordinate in parent's coordinate system
7090 * @parent_y: Y coordinate in parent's coordinate system
7091 * @x: (out) (allow-none): return location for X coordinate in child's coordinate system
7092 * @y: (out) (allow-none): return location for Y coordinate in child's coordinate system
7094 * Transforms window coordinates from a parent window to a child
7095 * window, where the parent window is the normal parent as returned by
7096 * gdk_window_get_parent() for normal windows, and the window's
7097 * embedder as returned by gdk_offscreen_window_get_embedder() for
7098 * offscreen windows.
7100 * For normal windows, calling this function is equivalent to subtracting
7101 * the return values of gdk_window_get_position() from the parent coordinates.
7102 * For offscreen windows however (which can be arbitrarily transformed),
7103 * this function calls the GdkWindow::from-embedder: signal to translate
7106 * You should always use this function when writing generic code that
7107 * walks down a window hierarchy.
7109 * See also: gdk_window_coords_to_parent()
7114 gdk_window_coords_from_parent (GdkWindow *window,
7120 g_return_if_fail (GDK_IS_WINDOW (window));
7122 if (gdk_window_is_offscreen (window))
7126 from_embedder (window, parent_x, parent_y, &cx, &cy);
7137 *x = parent_x - window->x;
7140 *y = parent_y - window->y;
7145 * gdk_window_shape_combine_region:
7146 * @window: a #GdkWindow
7147 * @shape_region: (allow-none): region of window to be non-transparent
7148 * @offset_x: X position of @shape_region in @window coordinates
7149 * @offset_y: Y position of @shape_region in @window coordinates
7151 * Makes pixels in @window outside @shape_region be transparent,
7152 * so that the window may be nonrectangular.
7154 * If @shape_region is %NULL, the shape will be unset, so the whole
7155 * window will be opaque again. @offset_x and @offset_y are ignored
7156 * if @shape_region is %NULL.
7158 * On the X11 platform, this uses an X server extension which is
7159 * widely available on most common platforms, but not available on
7160 * very old X servers, and occasionally the implementation will be
7161 * buggy. On servers without the shape extension, this function
7164 * This function works on both toplevel and child windows.
7167 gdk_window_shape_combine_region (GdkWindow *window,
7168 const cairo_region_t *shape_region,
7172 cairo_region_t *old_region, *new_region, *diff;
7174 g_return_if_fail (GDK_IS_WINDOW (window));
7176 if (GDK_WINDOW_DESTROYED (window))
7179 if (!window->shape && shape_region == NULL)
7182 window->shaped = (shape_region != NULL);
7185 cairo_region_destroy (window->shape);
7188 if (GDK_WINDOW_IS_MAPPED (window))
7189 old_region = cairo_region_copy (window->clip_region);
7193 window->shape = cairo_region_copy (shape_region);
7194 cairo_region_translate (window->shape, offset_x, offset_y);
7197 window->shape = NULL;
7199 recompute_visible_regions (window, TRUE, FALSE);
7201 if (gdk_window_has_impl (window) &&
7202 !should_apply_clip_as_shape (window))
7203 apply_shape (window, window->shape);
7207 new_region = cairo_region_copy (window->clip_region);
7209 /* New area in the window, needs invalidation */
7210 diff = cairo_region_copy (new_region);
7211 cairo_region_subtract (diff, old_region);
7213 gdk_window_invalidate_region_full (window, diff, TRUE, CLEAR_BG_ALL);
7215 cairo_region_destroy (diff);
7217 if (!gdk_window_is_toplevel (window))
7219 /* New area in the non-root parent window, needs invalidation */
7220 diff = cairo_region_copy (old_region);
7221 cairo_region_subtract (diff, new_region);
7223 /* Adjust region to parent window coords */
7224 cairo_region_translate (diff, window->x, window->y);
7226 gdk_window_invalidate_region_full (window->parent, diff, TRUE, CLEAR_BG_ALL);
7228 cairo_region_destroy (diff);
7231 cairo_region_destroy (new_region);
7232 cairo_region_destroy (old_region);
7237 do_child_shapes (GdkWindow *window,
7241 cairo_region_t *region;
7245 r.width = window->width;
7246 r.height = window->height;
7248 region = cairo_region_create_rectangle (&r);
7249 remove_child_area (window, NULL, FALSE, region, NULL);
7251 if (merge && window->shape)
7252 cairo_region_subtract (region, window->shape);
7254 gdk_window_shape_combine_region (window, region, 0, 0);
7258 * gdk_window_set_child_shapes:
7259 * @window: a #GdkWindow
7261 * Sets the shape mask of @window to the union of shape masks
7262 * for all children of @window, ignoring the shape mask of @window
7263 * itself. Contrast with gdk_window_merge_child_shapes() which includes
7264 * the shape mask of @window in the masks to be merged.
7267 gdk_window_set_child_shapes (GdkWindow *window)
7269 g_return_if_fail (GDK_IS_WINDOW (window));
7271 do_child_shapes (window, FALSE);
7275 * gdk_window_merge_child_shapes:
7276 * @window: a #GdkWindow
7278 * Merges the shape masks for any child windows into the
7279 * shape mask for @window. i.e. the union of all masks
7280 * for @window and its children will become the new mask
7281 * for @window. See gdk_window_shape_combine_region().
7283 * This function is distinct from gdk_window_set_child_shapes()
7284 * because it includes @window's shape mask in the set of shapes to
7288 gdk_window_merge_child_shapes (GdkWindow *window)
7290 g_return_if_fail (GDK_IS_WINDOW (window));
7292 do_child_shapes (window, TRUE);
7296 * gdk_window_input_shape_combine_region:
7297 * @window: a #GdkWindow
7298 * @shape_region: region of window to be non-transparent
7299 * @offset_x: X position of @shape_region in @window coordinates
7300 * @offset_y: Y position of @shape_region in @window coordinates
7302 * Like gdk_window_shape_combine_region(), but the shape applies
7303 * only to event handling. Mouse events which happen while
7304 * the pointer position corresponds to an unset bit in the
7305 * mask will be passed on the window below @window.
7307 * An input shape is typically used with RGBA windows.
7308 * The alpha channel of the window defines which pixels are
7309 * invisible and allows for nicely antialiased borders,
7310 * and the input shape controls where the window is
7313 * On the X11 platform, this requires version 1.1 of the
7316 * On the Win32 platform, this functionality is not present and the
7317 * function does nothing.
7322 gdk_window_input_shape_combine_region (GdkWindow *window,
7323 const cairo_region_t *shape_region,
7327 GdkWindowImplClass *impl_class;
7329 g_return_if_fail (GDK_IS_WINDOW (window));
7331 if (GDK_WINDOW_DESTROYED (window))
7334 if (window->input_shape)
7335 cairo_region_destroy (window->input_shape);
7339 window->input_shape = cairo_region_copy (shape_region);
7340 cairo_region_translate (window->input_shape, offset_x, offset_y);
7343 window->input_shape = NULL;
7345 if (gdk_window_has_impl (window))
7347 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7348 impl_class->input_shape_combine_region (window, window->input_shape, 0, 0);
7351 /* Pointer may have e.g. moved outside window due to the input mask change */
7352 _gdk_synthesize_crossing_events_for_geometry_change (window);
7356 do_child_input_shapes (GdkWindow *window,
7360 cairo_region_t *region;
7364 r.width = window->width;
7365 r.height = window->height;
7367 region = cairo_region_create_rectangle (&r);
7368 remove_child_area (window, NULL, TRUE, region, NULL);
7370 if (merge && window->shape)
7371 cairo_region_subtract (region, window->shape);
7372 if (merge && window->input_shape)
7373 cairo_region_subtract (region, window->input_shape);
7375 gdk_window_input_shape_combine_region (window, region, 0, 0);
7380 * gdk_window_set_child_input_shapes:
7381 * @window: a #GdkWindow
7383 * Sets the input shape mask of @window to the union of input shape masks
7384 * for all children of @window, ignoring the input shape mask of @window
7385 * itself. Contrast with gdk_window_merge_child_input_shapes() which includes
7386 * the input shape mask of @window in the masks to be merged.
7391 gdk_window_set_child_input_shapes (GdkWindow *window)
7393 g_return_if_fail (GDK_IS_WINDOW (window));
7395 do_child_input_shapes (window, FALSE);
7399 * gdk_window_merge_child_input_shapes:
7400 * @window: a #GdkWindow
7402 * Merges the input shape masks for any child windows into the
7403 * input shape mask for @window. i.e. the union of all input masks
7404 * for @window and its children will become the new input mask
7405 * for @window. See gdk_window_input_shape_combine_region().
7407 * This function is distinct from gdk_window_set_child_input_shapes()
7408 * because it includes @window's input shape mask in the set of
7409 * shapes to be merged.
7414 gdk_window_merge_child_input_shapes (GdkWindow *window)
7416 g_return_if_fail (GDK_IS_WINDOW (window));
7418 do_child_input_shapes (window, TRUE);
7423 * gdk_window_set_static_gravities:
7424 * @window: a #GdkWindow
7425 * @use_static: %TRUE to turn on static gravity
7427 * Set the bit gravity of the given window to static, and flag it so
7428 * all children get static subwindow gravity. This is used if you are
7429 * implementing scary features that involve deep knowledge of the
7430 * windowing system. Don't worry about it unless you have to.
7432 * Return value: %TRUE if the server supports static gravity
7435 gdk_window_set_static_gravities (GdkWindow *window,
7436 gboolean use_static)
7438 GdkWindowImplClass *impl_class;
7440 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7442 if (gdk_window_has_impl (window))
7444 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7445 return impl_class->set_static_gravities (window, use_static);
7452 * gdk_window_get_composited:
7453 * @window: a #GdkWindow
7455 * Determines whether @window is composited.
7457 * See gdk_window_set_composited().
7459 * Returns: %TRUE if the window is composited.
7464 gdk_window_get_composited (GdkWindow *window)
7466 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7468 return window->composited;
7472 * gdk_window_set_composited:
7473 * @window: a #GdkWindow
7474 * @composited: %TRUE to set the window as composited
7476 * Sets a #GdkWindow as composited, or unsets it. Composited
7477 * windows do not automatically have their contents drawn to
7478 * the screen. Drawing is redirected to an offscreen buffer
7479 * and an expose event is emitted on the parent of the composited
7480 * window. It is the responsibility of the parent's expose handler
7481 * to manually merge the off-screen content onto the screen in
7482 * whatever way it sees fit. See <xref linkend="composited-window-example"/>
7485 * It only makes sense for child windows to be composited; see
7486 * gdk_window_set_opacity() if you need translucent toplevel
7489 * An additional effect of this call is that the area of this
7490 * window is no longer clipped from regions marked for
7491 * invalidation on its parent. Draws done on the parent
7492 * window are also no longer clipped by the child.
7494 * This call is only supported on some systems (currently,
7495 * only X11 with new enough Xcomposite and Xdamage extensions).
7496 * You must call gdk_display_supports_composite() to check if
7497 * setting a window as composited is supported before
7498 * attempting to do so.
7503 gdk_window_set_composited (GdkWindow *window,
7504 gboolean composited)
7506 GdkDisplay *display;
7507 GdkWindowImplClass *impl_class;
7509 g_return_if_fail (GDK_IS_WINDOW (window));
7511 composited = composited != FALSE;
7513 if (window->composited == composited)
7517 gdk_window_ensure_native (window);
7519 display = gdk_window_get_display (window);
7521 impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
7523 if (composited && (!gdk_display_supports_composite (display) || !impl_class->set_composited))
7525 g_warning ("gdk_window_set_composited called but "
7526 "compositing is not supported");
7530 impl_class->set_composited (window, composited);
7532 recompute_visible_regions (window, TRUE, FALSE);
7534 if (GDK_WINDOW_IS_MAPPED (window))
7535 gdk_window_invalidate_in_parent (window);
7537 window->composited = composited;
7541 * gdk_window_get_modal_hint:
7542 * @window: A toplevel #GdkWindow.
7544 * Determines whether or not the window manager is hinted that @window
7545 * has modal behaviour.
7547 * Return value: whether or not the window has the modal hint set.
7552 gdk_window_get_modal_hint (GdkWindow *window)
7554 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7556 return window->modal_hint;
7560 * gdk_window_get_accept_focus:
7561 * @window: a toplevel #GdkWindow.
7563 * Determines whether or not the desktop environment shuld be hinted that
7564 * the window does not want to receive input focus.
7566 * Return value: whether or not the window should receive input focus.
7571 gdk_window_get_accept_focus (GdkWindow *window)
7573 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7575 return window->accept_focus;
7579 * gdk_window_get_focus_on_map:
7580 * @window: a toplevel #GdkWindow.
7582 * Determines whether or not the desktop environment should be hinted that the
7583 * window does not want to receive input focus when it is mapped.
7585 * Return value: whether or not the window wants to receive input focus when
7591 gdk_window_get_focus_on_map (GdkWindow *window)
7593 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7595 return window->focus_on_map;
7599 * gdk_window_is_input_only:
7600 * @window: a toplevel #GdkWindow
7602 * Determines whether or not the window is an input only window.
7604 * Return value: %TRUE if @window is input only
7609 gdk_window_is_input_only (GdkWindow *window)
7611 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7613 return window->input_only;
7617 * gdk_window_is_shaped:
7618 * @window: a toplevel #GdkWindow
7620 * Determines whether or not the window is shaped.
7622 * Return value: %TRUE if @window is shaped
7627 gdk_window_is_shaped (GdkWindow *window)
7629 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
7631 return window->shaped;
7635 window_get_size_rectangle (GdkWindow *window,
7638 rect->x = rect->y = 0;
7639 rect->width = window->width;
7640 rect->height = window->height;
7643 /* Calculates the real clipping region for a window, in window coordinates,
7644 * taking into account other windows, gc clip region and gc clip mask.
7647 _gdk_window_calculate_full_clip_region (GdkWindow *window,
7648 GdkWindow *base_window,
7649 gboolean do_children,
7650 gint *base_x_offset,
7651 gint *base_y_offset)
7653 GdkRectangle visible_rect;
7654 cairo_region_t *real_clip_region;
7655 gint x_offset, y_offset;
7656 GdkWindow *parentwin, *lastwin;
7663 if (!window->viewable || window->input_only)
7664 return cairo_region_create ();
7666 window_get_size_rectangle (window, &visible_rect);
7668 /* real_clip_region is in window coordinates */
7669 real_clip_region = cairo_region_create_rectangle (&visible_rect);
7671 x_offset = y_offset = 0;
7675 parentwin = lastwin;
7677 parentwin = lastwin->parent;
7679 /* Remove the areas of all overlapping windows above parentwin in the hiearachy */
7680 for (; parentwin != NULL &&
7681 (parentwin == window || lastwin != base_window);
7682 lastwin = parentwin, parentwin = lastwin->parent)
7685 GdkRectangle real_clip_rect;
7687 if (parentwin != window)
7689 x_offset += lastwin->x;
7690 y_offset += lastwin->y;
7693 /* children is ordered in reverse stack order */
7694 for (cur = parentwin->children;
7695 cur && cur->data != lastwin;
7698 GdkWindow *child = cur->data;
7700 if (!GDK_WINDOW_IS_MAPPED (child) || child->input_only)
7703 /* Ignore offscreen children, as they don't draw in their parent and
7704 * don't take part in the clipping */
7705 if (gdk_window_is_offscreen (child))
7708 window_get_size_rectangle (child, &visible_rect);
7710 /* Convert rect to "window" coords */
7711 visible_rect.x += child->x - x_offset;
7712 visible_rect.y += child->y - y_offset;
7714 /* This shortcut is really necessary for performance when there are a lot of windows */
7715 cairo_region_get_extents (real_clip_region, &real_clip_rect);
7716 if (visible_rect.x >= real_clip_rect.x + real_clip_rect.width ||
7717 visible_rect.x + visible_rect.width <= real_clip_rect.x ||
7718 visible_rect.y >= real_clip_rect.y + real_clip_rect.height ||
7719 visible_rect.y + visible_rect.height <= real_clip_rect.y)
7722 cairo_region_subtract_rectangle (real_clip_region, &visible_rect);
7725 /* Clip to the parent */
7726 window_get_size_rectangle ((GdkWindow *)parentwin, &visible_rect);
7727 /* Convert rect to "window" coords */
7728 visible_rect.x += - x_offset;
7729 visible_rect.y += - y_offset;
7731 cairo_region_intersect_rectangle (real_clip_region, &visible_rect);
7735 *base_x_offset = x_offset;
7737 *base_y_offset = y_offset;
7739 return real_clip_region;
7743 _gdk_window_add_damage (GdkWindow *toplevel,
7744 cairo_region_t *damaged_region)
7746 GdkDisplay *display;
7747 GdkEvent event = { 0, };
7748 event.expose.type = GDK_DAMAGE;
7749 event.expose.window = toplevel;
7750 event.expose.send_event = FALSE;
7751 event.expose.region = damaged_region;
7752 cairo_region_get_extents (event.expose.region, &event.expose.area);
7753 display = gdk_window_get_display (event.expose.window);
7754 _gdk_event_queue_append (display, gdk_event_copy (&event));
7757 /* Gets the toplevel for a window as used for events,
7758 i.e. including offscreen parents */
7760 get_event_parent (GdkWindow *window)
7762 if (gdk_window_is_offscreen (window))
7763 return gdk_offscreen_window_get_embedder ((GdkWindow *)window);
7765 return window->parent;
7768 /* Gets the toplevel for a window as used for events,
7769 i.e. including offscreen parents going up to the native
7772 get_event_toplevel (GdkWindow *window)
7776 while ((parent = get_event_parent (window)) != NULL &&
7777 (parent->window_type != GDK_WINDOW_ROOT))
7784 _gdk_window_event_parent_of (GdkWindow *parent,
7795 w = get_event_parent (w);
7802 update_cursor (GdkDisplay *display,
7805 GdkWindow *cursor_window, *parent, *toplevel;
7806 GdkWindow *pointer_window;
7807 GdkWindowImplClass *impl_class;
7808 GdkPointerWindowInfo *pointer_info;
7809 GdkDeviceGrabInfo *grab;
7812 pointer_info = _gdk_display_get_pointer_info (display, device);
7813 pointer_window = pointer_info->window_under_pointer;
7815 /* We ignore the serials here and just pick the last grab
7816 we've sent, as that would shortly be used anyway. */
7817 grab = _gdk_display_get_last_device_grab (display, device);
7820 /* the pointer is not in a descendant of the grab window */
7821 !_gdk_window_event_parent_of (grab->window, pointer_window))
7823 /* use the cursor from the grab window */
7824 cursor_window = grab->window;
7828 /* otherwise use the cursor from the pointer window */
7829 cursor_window = pointer_window;
7832 /* Find the first window with the cursor actually set, as
7833 the cursor is inherited from the parent */
7834 while (cursor_window->cursor == NULL &&
7835 (parent = get_event_parent (cursor_window)) != NULL &&
7836 parent->window_type != GDK_WINDOW_ROOT)
7837 cursor_window = parent;
7839 cursor = g_hash_table_lookup (cursor_window->device_cursor, device);
7842 cursor = cursor_window->cursor;
7844 /* Set all cursors on toplevel, otherwise its tricky to keep track of
7845 * which native window has what cursor set. */
7846 toplevel = get_event_toplevel (pointer_window);
7847 impl_class = GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl);
7848 impl_class->set_device_cursor (toplevel, device, cursor);
7852 point_in_window (GdkWindow *window,
7857 x >= 0 && x < window->width &&
7858 y >= 0 && y < window->height &&
7859 (window->shape == NULL ||
7860 cairo_region_contains_point (window->shape,
7862 (window->input_shape == NULL ||
7863 cairo_region_contains_point (window->input_shape,
7868 convert_native_coords_to_toplevel (GdkWindow *window,
7871 gdouble *toplevel_x,
7872 gdouble *toplevel_y)
7879 while (!gdk_window_is_toplevel (window))
7883 window = window->parent;
7893 convert_toplevel_coords_to_window (GdkWindow *window,
7901 GList *children, *l;
7907 while ((parent = get_event_parent (window)) != NULL &&
7908 (parent->window_type != GDK_WINDOW_ROOT))
7910 children = g_list_prepend (children, window);
7914 for (l = children; l != NULL; l = l->next)
7915 gdk_window_coords_from_parent (l->data, x, y, &x, &y);
7917 g_list_free (children);
7924 pick_embedded_child (GdkWindow *window,
7931 g_signal_emit (window,
7932 signals[PICK_EMBEDDED_CHILD], 0,
7939 _gdk_window_find_child_at (GdkWindow *window,
7944 double child_x, child_y;
7947 if (point_in_window (window, x, y))
7949 /* Children is ordered in reverse stack order, i.e. first is topmost */
7950 for (l = window->children; l != NULL; l = l->next)
7954 if (!GDK_WINDOW_IS_MAPPED (sub))
7957 gdk_window_coords_from_parent ((GdkWindow *)sub,
7959 &child_x, &child_y);
7960 if (point_in_window (sub, child_x, child_y))
7961 return (GdkWindow *)sub;
7964 if (window->num_offscreen_children > 0)
7966 sub = pick_embedded_child (window,
7969 return (GdkWindow *)sub;
7977 _gdk_window_find_descendant_at (GdkWindow *window,
7984 gdouble child_x, child_y;
7988 if (point_in_window (window, x, y))
7993 /* Children is ordered in reverse stack order, i.e. first is topmost */
7994 for (l = window->children; l != NULL; l = l->next)
7998 if (!GDK_WINDOW_IS_MAPPED (sub))
8001 gdk_window_coords_from_parent ((GdkWindow *)sub,
8003 &child_x, &child_y);
8004 if (point_in_window (sub, child_x, child_y))
8014 window->num_offscreen_children > 0)
8016 sub = pick_embedded_child (window,
8022 from_embedder (sub, x, y, &x, &y);
8030 /* Not in window at all */
8044 * @window: a toplevel #GdkWindow
8046 * Emits a short beep associated to @window in the appropriate
8047 * display, if supported. Otherwise, emits a short beep on
8048 * the display just as gdk_display_beep().
8053 gdk_window_beep (GdkWindow *window)
8055 GdkDisplay *display;
8056 GdkWindow *toplevel;
8058 g_return_if_fail (GDK_IS_WINDOW (window));
8060 if (GDK_WINDOW_DESTROYED (window))
8063 toplevel = get_event_toplevel (window);
8064 display = gdk_window_get_display (window);
8068 if (GDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)->beep (toplevel))
8072 /* If windows fail to beep, we beep the display. */
8073 gdk_display_beep (display);
8077 * gdk_window_set_support_multidevice:
8078 * @window: a #GdkWindow.
8079 * @support_multidevice: %TRUE to enable multidevice support in @window.
8081 * This function will enable multidevice features in @window.
8083 * Multidevice aware windows will need to handle properly multiple,
8084 * per device enter/leave events, device grabs and grab ownerships.
8089 gdk_window_set_support_multidevice (GdkWindow *window,
8090 gboolean support_multidevice)
8092 g_return_if_fail (GDK_IS_WINDOW (window));
8094 if (GDK_WINDOW_DESTROYED (window))
8097 if (window->support_multidevice == support_multidevice)
8100 window->support_multidevice = support_multidevice;
8102 /* FIXME: What to do if called when some pointers are inside the window ? */
8106 * gdk_window_get_support_multidevice:
8107 * @window: a #GdkWindow.
8109 * Returns %TRUE if the window is aware of the existence of multiple
8112 * Returns: %TRUE if the window handles multidevice features.
8117 gdk_window_get_support_multidevice (GdkWindow *window)
8119 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
8121 if (GDK_WINDOW_DESTROYED (window))
8124 return window->support_multidevice;
8127 static const guint type_masks[] = {
8128 GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE = 0 */
8129 GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1 */
8130 GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2 */
8131 GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3 */
8132 GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4 */
8133 GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5 */
8134 GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6 */
8135 GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE = 7 */
8136 GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS = 8 */
8137 GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE = 9 */
8138 GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY = 10 */
8139 GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY = 11 */
8140 GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE = 12 */
8141 GDK_STRUCTURE_MASK, /* GDK_CONFIGURE = 13 */
8142 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_MAP = 14 */
8143 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_UNMAP = 15 */
8144 GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY = 16 */
8145 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR = 17 */
8146 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18 */
8147 GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY = 19 */
8148 GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN = 20 */
8149 GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT = 21 */
8150 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER = 22 */
8151 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE = 23 */
8152 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION = 24 */
8153 GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS = 25 */
8154 GDK_ALL_EVENTS_MASK, /* GDK_DROP_START = 26 */
8155 GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED = 27 */
8156 GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT = 28 */
8157 GDK_VISIBILITY_NOTIFY_MASK, /* GDK_VISIBILITY_NOTIFY = 29 */
8158 GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30 */
8159 GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK,/* GDK_SCROLL= 31 */
8160 0, /* GDK_WINDOW_STATE = 32 */
8161 0, /* GDK_SETTING = 33 */
8162 0, /* GDK_OWNER_CHANGE = 34 */
8163 0, /* GDK_GRAB_BROKEN = 35 */
8164 0, /* GDK_DAMAGE = 36 */
8166 G_STATIC_ASSERT (G_N_ELEMENTS (type_masks) == GDK_EVENT_LAST);
8168 /* send motion events if the right buttons are down */
8170 update_evmask_for_button_motion (guint evmask,
8171 GdkModifierType mask)
8173 if (evmask & GDK_BUTTON_MOTION_MASK &&
8174 mask & (GDK_BUTTON1_MASK |
8179 evmask |= GDK_POINTER_MOTION_MASK;
8181 if ((evmask & GDK_BUTTON1_MOTION_MASK && mask & GDK_BUTTON1_MASK) ||
8182 (evmask & GDK_BUTTON2_MOTION_MASK && mask & GDK_BUTTON2_MASK) ||
8183 (evmask & GDK_BUTTON3_MOTION_MASK && mask & GDK_BUTTON3_MASK))
8184 evmask |= GDK_POINTER_MOTION_MASK;
8190 is_button_type (GdkEventType type)
8192 return type == GDK_BUTTON_PRESS ||
8193 type == GDK_2BUTTON_PRESS ||
8194 type == GDK_3BUTTON_PRESS ||
8195 type == GDK_BUTTON_RELEASE ||
8200 is_motion_type (GdkEventType type)
8202 return type == GDK_MOTION_NOTIFY ||
8203 type == GDK_ENTER_NOTIFY ||
8204 type == GDK_LEAVE_NOTIFY;
8208 find_common_ancestor (GdkWindow *win1,
8212 GList *path1 = NULL, *path2 = NULL;
8213 GList *list1, *list2;
8216 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8218 path1 = g_list_prepend (path1, tmp);
8219 tmp = get_event_parent (tmp);
8223 while (tmp != NULL && tmp->window_type != GDK_WINDOW_ROOT)
8225 path2 = g_list_prepend (path2, tmp);
8226 tmp = get_event_parent (tmp);
8232 while (list1 && list2 && (list1->data == list2->data))
8235 list1 = g_list_next (list1);
8236 list2 = g_list_next (list2);
8238 g_list_free (path1);
8239 g_list_free (path2);
8245 _gdk_make_event (GdkWindow *window,
8247 GdkEvent *event_in_queue,
8248 gboolean before_event)
8250 GdkEvent *event = gdk_event_new (type);
8252 GdkModifierType the_state;
8254 the_time = gdk_event_get_time (event_in_queue);
8255 gdk_event_get_state (event_in_queue, &the_state);
8257 event->any.window = g_object_ref (window);
8258 event->any.send_event = FALSE;
8259 if (event_in_queue && event_in_queue->any.send_event)
8260 event->any.send_event = TRUE;
8264 case GDK_MOTION_NOTIFY:
8265 event->motion.time = the_time;
8266 event->motion.axes = NULL;
8267 event->motion.state = the_state;
8270 case GDK_BUTTON_PRESS:
8271 case GDK_2BUTTON_PRESS:
8272 case GDK_3BUTTON_PRESS:
8273 case GDK_BUTTON_RELEASE:
8274 event->button.time = the_time;
8275 event->button.axes = NULL;
8276 event->button.state = the_state;
8280 event->scroll.time = the_time;
8281 event->scroll.state = the_state;
8285 case GDK_KEY_RELEASE:
8286 event->key.time = the_time;
8287 event->key.state = the_state;
8290 case GDK_ENTER_NOTIFY:
8291 case GDK_LEAVE_NOTIFY:
8292 event->crossing.time = the_time;
8293 event->crossing.state = the_state;
8296 case GDK_PROPERTY_NOTIFY:
8297 event->property.time = the_time;
8298 event->property.state = the_state;
8301 case GDK_SELECTION_CLEAR:
8302 case GDK_SELECTION_REQUEST:
8303 case GDK_SELECTION_NOTIFY:
8304 event->selection.time = the_time;
8307 case GDK_PROXIMITY_IN:
8308 case GDK_PROXIMITY_OUT:
8309 event->proximity.time = the_time;
8312 case GDK_DRAG_ENTER:
8313 case GDK_DRAG_LEAVE:
8314 case GDK_DRAG_MOTION:
8315 case GDK_DRAG_STATUS:
8316 case GDK_DROP_START:
8317 case GDK_DROP_FINISHED:
8318 event->dnd.time = the_time;
8321 case GDK_FOCUS_CHANGE:
8325 case GDK_CLIENT_EVENT:
8326 case GDK_VISIBILITY_NOTIFY:
8337 _gdk_event_queue_insert_before (gdk_window_get_display (window), event_in_queue, event);
8339 _gdk_event_queue_insert_after (gdk_window_get_display (window), event_in_queue, event);
8342 _gdk_event_queue_append (gdk_window_get_display (window), event);
8348 send_crossing_event (GdkDisplay *display,
8349 GdkWindow *toplevel,
8352 GdkCrossingMode mode,
8353 GdkNotifyType notify_type,
8354 GdkWindow *subwindow,
8356 GdkDevice *source_device,
8359 GdkModifierType mask,
8361 GdkEvent *event_in_queue,
8365 guint32 window_event_mask, type_event_mask;
8366 GdkDeviceGrabInfo *grab;
8367 gboolean block_event = FALSE;
8369 grab = _gdk_display_has_device_grab (display, device, serial);
8372 !grab->owner_events)
8374 /* !owner_event => only report events wrt grab window, ignore rest */
8375 if ((GdkWindow *)window != grab->window)
8377 window_event_mask = grab->event_mask;
8380 window_event_mask = window->event_mask;
8382 if (type == GDK_LEAVE_NOTIFY)
8384 type_event_mask = GDK_LEAVE_NOTIFY_MASK;
8385 window->devices_inside = g_list_remove (window->devices_inside, device);
8387 if (!window->support_multidevice && window->devices_inside)
8389 /* Block leave events unless it's the last pointer */
8395 type_event_mask = GDK_ENTER_NOTIFY_MASK;
8397 if (!window->support_multidevice && window->devices_inside)
8399 /* Only emit enter events for the first device */
8403 if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER &&
8404 gdk_device_get_mode (device) != GDK_MODE_DISABLED &&
8405 !g_list_find (window->devices_inside, device))
8406 window->devices_inside = g_list_prepend (window->devices_inside, device);
8412 if (window_event_mask & type_event_mask)
8414 event = _gdk_make_event ((GdkWindow *)window, type, event_in_queue, TRUE);
8415 gdk_event_set_device (event, device);
8418 gdk_event_set_source_device (event, source_device);
8420 event->crossing.time = time_;
8421 event->crossing.subwindow = subwindow;
8423 g_object_ref (subwindow);
8424 convert_toplevel_coords_to_window ((GdkWindow *)window,
8425 toplevel_x, toplevel_y,
8426 &event->crossing.x, &event->crossing.y);
8427 event->crossing.x_root = toplevel_x + toplevel->x;
8428 event->crossing.y_root = toplevel_y + toplevel->y;
8429 event->crossing.mode = mode;
8430 event->crossing.detail = notify_type;
8431 event->crossing.focus = FALSE;
8432 event->crossing.state = mask;
8437 /* The coordinates are in the toplevel window that src/dest are in.
8438 * src and dest are always (if != NULL) in the same toplevel, as
8439 * we get a leave-notify and set the window_under_pointer to null
8440 * before crossing to another toplevel.
8443 _gdk_synthesize_crossing_events (GdkDisplay *display,
8447 GdkDevice *source_device,
8448 GdkCrossingMode mode,
8451 GdkModifierType mask,
8453 GdkEvent *event_in_queue,
8455 gboolean non_linear)
8458 GdkWindow *win, *last, *next;
8462 GdkWindow *toplevel;
8463 GdkNotifyType notify_type;
8465 /* TODO: Don't send events to toplevel, as we get those from the windowing system */
8470 return; /* No crossings generated between src and dest */
8472 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER)
8474 if (a && gdk_window_get_device_events (src, device) == 0)
8477 if (b && gdk_window_get_device_events (dest, device) == 0)
8484 c = find_common_ancestor (a, b);
8486 non_linear |= (c != a) && (c != b);
8488 if (a) /* There might not be a source (i.e. if no previous pointer_in_window) */
8490 toplevel = gdk_window_get_toplevel (a);
8492 /* Traverse up from a to (excluding) c sending leave events */
8494 notify_type = GDK_NOTIFY_NONLINEAR;
8496 notify_type = GDK_NOTIFY_INFERIOR;
8498 notify_type = GDK_NOTIFY_ANCESTOR;
8499 send_crossing_event (display, toplevel,
8500 a, GDK_LEAVE_NOTIFY,
8503 NULL, device, source_device,
8504 toplevel_x, toplevel_y,
8512 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8514 notify_type = GDK_NOTIFY_VIRTUAL;
8517 win = get_event_parent (a);
8518 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8520 send_crossing_event (display, toplevel,
8521 win, GDK_LEAVE_NOTIFY,
8525 device, source_device,
8526 toplevel_x, toplevel_y,
8532 win = get_event_parent (win);
8537 if (b) /* Might not be a dest, e.g. if we're moving out of the window */
8539 toplevel = gdk_window_get_toplevel ((GdkWindow *)b);
8541 /* Traverse down from c to b */
8545 win = get_event_parent (b);
8546 while (win != c && win->window_type != GDK_WINDOW_ROOT)
8548 path = g_list_prepend (path, win);
8549 win = get_event_parent (win);
8553 notify_type = GDK_NOTIFY_NONLINEAR_VIRTUAL;
8555 notify_type = GDK_NOTIFY_VIRTUAL;
8561 list = g_list_next (list);
8567 send_crossing_event (display, toplevel,
8568 win, GDK_ENTER_NOTIFY,
8572 device, source_device,
8573 toplevel_x, toplevel_y,
8583 notify_type = GDK_NOTIFY_NONLINEAR;
8585 notify_type = GDK_NOTIFY_ANCESTOR;
8587 notify_type = GDK_NOTIFY_INFERIOR;
8589 send_crossing_event (display, toplevel,
8590 b, GDK_ENTER_NOTIFY,
8594 device, source_device,
8595 toplevel_x, toplevel_y,
8602 /* Returns the window inside the event window with the pointer in it
8603 * at the specified coordinates, or NULL if its not in any child of
8604 * the toplevel. It also takes into account !owner_events grabs.
8607 get_pointer_window (GdkDisplay *display,
8608 GdkWindow *event_window,
8614 GdkWindow *pointer_window;
8615 GdkDeviceGrabInfo *grab;
8616 GdkPointerWindowInfo *pointer_info;
8618 pointer_info = _gdk_display_get_pointer_info (display, device);
8620 if (event_window == pointer_info->toplevel_under_pointer)
8622 _gdk_window_find_descendant_at (event_window,
8623 toplevel_x, toplevel_y,
8626 pointer_window = NULL;
8628 grab = _gdk_display_has_device_grab (display, device, serial);
8630 !grab->owner_events &&
8631 pointer_window != grab->window)
8632 pointer_window = NULL;
8634 return pointer_window;
8638 _gdk_display_set_window_under_pointer (GdkDisplay *display,
8642 GdkPointerWindowInfo *device_info;
8644 device_info = _gdk_display_get_pointer_info (display, device);
8646 if (device_info->window_under_pointer)
8647 g_object_unref (device_info->window_under_pointer);
8648 device_info->window_under_pointer = window;
8652 g_object_ref (window);
8653 update_cursor (display, device);
8656 _gdk_display_enable_motion_hints (display, device);
8661 * @window: the #GdkWindow which will own the grab (the grab window).
8662 * @owner_events: if %FALSE then all pointer events are reported with respect to
8663 * @window and are only reported if selected by @event_mask. If %TRUE then pointer
8664 * events for this application are reported as normal, but pointer events outside
8665 * this application are reported with respect to @window and only if selected by
8666 * @event_mask. In either mode, unreported events are discarded.
8667 * @event_mask: specifies the event mask, which is used in accordance with
8668 * @owner_events. Note that only pointer events (i.e. button and motion events)
8670 * @confine_to: (allow-none): If non-%NULL, the pointer will be confined to this
8671 * window during the grab. If the pointer is outside @confine_to, it will
8672 * automatically be moved to the closest edge of @confine_to and enter
8673 * and leave events will be generated as necessary.
8674 * @cursor: (allow-none): the cursor to display while the grab is active. If this is %NULL then
8675 * the normal cursors are used for @window and its descendants, and the cursor
8676 * for @window is used for all other windows.
8677 * @time_: the timestamp of the event which led to this pointer grab. This usually
8678 * comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if
8679 * the time isn't known.
8681 * Grabs the pointer (usually a mouse) so that all events are passed to this
8682 * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
8683 * the grab window becomes unviewable.
8684 * This overrides any previous pointer grab by this client.
8686 * Pointer grabs are used for operations which need complete control over mouse
8687 * events, even if the mouse leaves the application.
8688 * For example in GTK+ it is used for Drag and Drop, for dragging the handle in
8689 * the #GtkHPaned and #GtkVPaned widgets.
8691 * Note that if the event mask of an X window has selected both button press and
8692 * button release events, then a button press event will cause an automatic
8693 * pointer grab until the button is released.
8694 * X does this automatically since most applications expect to receive button
8695 * press and release events in pairs.
8696 * It is equivalent to a pointer grab on the window with @owner_events set to
8699 * If you set up anything at the time you take the grab that needs to be cleaned
8700 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8701 * are emitted when the grab ends unvoluntarily.
8703 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8705 * Deprecated: 3.0: Use gdk_device_grab() instead.
8708 gdk_pointer_grab (GdkWindow * window,
8709 gboolean owner_events,
8710 GdkEventMask event_mask,
8711 GdkWindow * confine_to,
8716 GdkDisplay *display;
8717 GdkDeviceManager *device_manager;
8719 GdkGrabStatus res = 0;
8721 GList *devices, *dev;
8723 g_return_val_if_fail (window != NULL, 0);
8724 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8725 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
8727 /* We need a native window for confine to to work, ensure we have one */
8730 if (!gdk_window_ensure_native (confine_to))
8732 g_warning ("Can't confine to grabbed window, not native");
8737 /* Non-viewable client side window => fail */
8738 if (!_gdk_window_has_impl (window) &&
8739 !gdk_window_is_viewable (window))
8740 return GDK_GRAB_NOT_VIEWABLE;
8742 native = gdk_window_get_toplevel (window);
8743 while (gdk_window_is_offscreen (native))
8745 native = gdk_offscreen_window_get_embedder (native);
8747 if (native == NULL ||
8748 (!_gdk_window_has_impl (native) &&
8749 !gdk_window_is_viewable (native)))
8750 return GDK_GRAB_NOT_VIEWABLE;
8752 native = gdk_window_get_toplevel (native);
8755 display = gdk_window_get_display (window);
8757 serial = _gdk_display_get_next_serial (display);
8758 device_manager = gdk_display_get_device_manager (display);
8759 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8761 /* FIXME: Should this be generic to all backends? */
8762 /* FIXME: What happens with extended devices? */
8763 for (dev = devices; dev; dev = dev->next)
8767 if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
8770 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8773 get_native_grab_event_mask (event_mask),
8778 if (res == GDK_GRAB_SUCCESS)
8779 _gdk_display_add_device_grab (display,
8791 /* FIXME: handle errors when grabbing */
8793 g_list_free (devices);
8799 * gdk_keyboard_grab:
8800 * @window: the #GdkWindow which will own the grab (the grab window).
8801 * @owner_events: if %FALSE then all keyboard events are reported with respect to
8802 * @window. If %TRUE then keyboard events for this application are
8803 * reported as normal, but keyboard events outside this application
8804 * are reported with respect to @window. Both key press and key
8805 * release events are always reported, independant of the event mask
8806 * set by the application.
8807 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is
8810 * Grabs the keyboard so that all events are passed to this
8811 * application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
8812 * This overrides any previous keyboard grab by this client.
8814 * If you set up anything at the time you take the grab that needs to be cleaned
8815 * up when the grab ends, you should handle the #GdkEventGrabBroken events that
8816 * are emitted when the grab ends unvoluntarily.
8818 * Returns: %GDK_GRAB_SUCCESS if the grab was successful.
8820 * Deprecated: 3.0: Use gdk_device_grab() instead.
8823 gdk_keyboard_grab (GdkWindow *window,
8824 gboolean owner_events,
8828 GdkDisplay *display;
8829 GdkDeviceManager *device_manager;
8831 GdkGrabStatus res = 0;
8833 GList *devices, *dev;
8835 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
8837 /* Non-viewable client side window => fail */
8838 if (!_gdk_window_has_impl (window) &&
8839 !gdk_window_is_viewable (window))
8840 return GDK_GRAB_NOT_VIEWABLE;
8842 native = gdk_window_get_toplevel (window);
8844 while (gdk_window_is_offscreen (native))
8846 native = gdk_offscreen_window_get_embedder (native);
8848 if (native == NULL ||
8849 (!_gdk_window_has_impl (native) &&
8850 !gdk_window_is_viewable (native)))
8851 return GDK_GRAB_NOT_VIEWABLE;
8853 native = gdk_window_get_toplevel (native);
8856 display = gdk_window_get_display (window);
8857 serial = _gdk_display_get_next_serial (display);
8858 device_manager = gdk_display_get_device_manager (display);
8859 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
8861 /* FIXME: Should this be generic to all backends? */
8862 /* FIXME: What happens with extended devices? */
8863 for (dev = devices; dev; dev = dev->next)
8867 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
8870 res = GDK_DEVICE_GET_CLASS (device)->grab (device,
8873 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
8878 if (res == GDK_GRAB_SUCCESS)
8879 _gdk_display_add_device_grab (display,
8890 /* FIXME: handle errors when grabbing */
8892 g_list_free (devices);
8898 * gdk_window_geometry_changed:
8899 * @window: an embedded offscreen #GdkWindow
8901 * This function informs GDK that the geometry of an embedded
8902 * offscreen window has changed. This is necessary for GDK to keep
8903 * track of which offscreen window the pointer is in.
8908 gdk_window_geometry_changed (GdkWindow *window)
8910 _gdk_synthesize_crossing_events_for_geometry_change (window);
8914 source_events_device_added (GdkDeviceManager *device_manager,
8919 GdkEventMask event_mask;
8920 GdkInputSource source;
8922 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_FLOATING)
8926 source = gdk_device_get_source (device);
8928 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8929 GINT_TO_POINTER (source)));
8931 gdk_window_set_device_events (window, device, event_mask);
8935 source_events_device_changed (GdkDeviceManager *device_manager,
8940 GdkInputSource source;
8941 GdkEventMask event_mask;
8945 type = gdk_device_get_device_type (device);
8946 source = gdk_device_get_source (device);
8948 event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,
8949 GINT_TO_POINTER (source)));
8954 if (type == GDK_DEVICE_TYPE_FLOATING)
8956 /* The device was just floated, enable its event mask */
8957 gdk_window_set_device_events (window, device, event_mask);
8959 else if (type == GDK_DEVICE_TYPE_SLAVE)
8960 gdk_window_set_device_events (window, device, 0);
8964 * gdk_window_set_source_events:
8965 * @window: a #GdkWindow
8966 * @source: a #GdkInputSource to define the source class.
8967 * @event_mask: event mask for @window
8969 * Sets the event mask for any floating device (i.e. not attached to any
8970 * visible pointer) that has the source defined as @source. This event
8971 * mask will be applied both to currently existing, newly added devices
8972 * after this call, and devices being attached/detached.
8977 gdk_window_set_source_events (GdkWindow *window,
8978 GdkInputSource source,
8979 GdkEventMask event_mask)
8981 GdkDeviceManager *device_manager;
8982 GdkDisplay *display;
8986 g_return_if_fail (GDK_IS_WINDOW (window));
8988 display = gdk_window_get_display (window);
8989 device_manager = gdk_display_get_device_manager (display);
8991 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
8993 /* Set event mask for existing devices */
8994 for (d = devices; d; d = d->next)
8996 GdkDevice *device = d->data;
8998 if (source == gdk_device_get_source (device))
8999 gdk_window_set_device_events (window, device, event_mask);
9002 g_list_free (devices);
9004 /* Update accounting */
9005 if (G_UNLIKELY (!window->source_event_masks))
9006 window->source_event_masks = g_hash_table_new (NULL, NULL);
9009 g_hash_table_insert (window->source_event_masks,
9010 GUINT_TO_POINTER (source),
9011 GUINT_TO_POINTER (event_mask));
9013 g_hash_table_remove (window->source_event_masks,
9014 GUINT_TO_POINTER (source));
9016 size = g_hash_table_size (window->source_event_masks);
9018 /* Update handler if needed */
9019 if (!window->device_added_handler_id && size > 0)
9021 window->device_added_handler_id =
9022 g_signal_connect (device_manager, "device-added",
9023 G_CALLBACK (source_events_device_added), window);
9024 window->device_changed_handler_id =
9025 g_signal_connect (device_manager, "device-changed",
9026 G_CALLBACK (source_events_device_changed), window);
9028 else if (window->device_added_handler_id && size == 0)
9029 g_signal_handler_disconnect (device_manager, window->device_added_handler_id);
9033 * gdk_window_get_source_events:
9034 * @window: a #GdkWindow
9035 * @source: a #GdkInputSource to define the source class.
9037 * Returns the event mask for @window corresponding to the device class specified
9040 * Returns: source event mask for @window
9043 gdk_window_get_source_events (GdkWindow *window,
9044 GdkInputSource source)
9046 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
9048 return GPOINTER_TO_UINT (g_hash_table_lookup (window->source_event_masks,
9049 GUINT_TO_POINTER (source)));
9053 do_synthesize_crossing_event (gpointer data)
9055 GdkDisplay *display;
9056 GdkWindow *changed_toplevel;
9057 GHashTableIter iter;
9058 gpointer key, value;
9061 changed_toplevel = data;
9063 changed_toplevel->synthesize_crossing_event_queued = FALSE;
9065 if (GDK_WINDOW_DESTROYED (changed_toplevel))
9068 display = gdk_window_get_display (changed_toplevel);
9069 serial = _gdk_display_get_next_serial (display);
9070 g_hash_table_iter_init (&iter, display->pointers_info);
9072 while (g_hash_table_iter_next (&iter, &key, &value))
9074 GdkWindow *new_window_under_pointer;
9075 GdkPointerWindowInfo *pointer_info = value;
9076 GdkDevice *device = key;
9078 if (changed_toplevel == pointer_info->toplevel_under_pointer)
9080 new_window_under_pointer =
9081 get_pointer_window (display, changed_toplevel,
9083 pointer_info->toplevel_x,
9084 pointer_info->toplevel_y,
9086 if (new_window_under_pointer != pointer_info->window_under_pointer)
9088 _gdk_synthesize_crossing_events (display,
9089 pointer_info->window_under_pointer,
9090 new_window_under_pointer,
9092 GDK_CROSSING_NORMAL,
9093 pointer_info->toplevel_x,
9094 pointer_info->toplevel_y,
9095 pointer_info->state,
9100 _gdk_display_set_window_under_pointer (display, device, new_window_under_pointer);
9109 _gdk_synthesize_crossing_events_for_geometry_change (GdkWindow *changed_window)
9111 GdkWindow *toplevel;
9113 toplevel = get_event_toplevel (changed_window);
9115 if (!toplevel->synthesize_crossing_event_queued)
9117 toplevel->synthesize_crossing_event_queued = TRUE;
9119 gdk_threads_add_idle_full (GDK_PRIORITY_EVENTS - 1,
9120 do_synthesize_crossing_event,
9121 g_object_ref (toplevel),
9126 /* Don't use for crossing events */
9128 get_event_window (GdkDisplay *display,
9130 GdkWindow *pointer_window,
9132 GdkModifierType mask,
9137 GdkWindow *grab_window;
9138 GdkDeviceGrabInfo *grab;
9140 grab = _gdk_display_has_device_grab (display, device, serial);
9142 if (grab != NULL && !grab->owner_events)
9144 evmask = grab->event_mask;
9145 evmask = update_evmask_for_button_motion (evmask, mask);
9147 grab_window = grab->window;
9149 if (evmask & type_masks[type])
9152 *evmask_out = evmask;
9159 while (pointer_window != NULL)
9161 evmask = pointer_window->event_mask;
9162 evmask = update_evmask_for_button_motion (evmask, mask);
9164 if (evmask & type_masks[type])
9167 *evmask_out = evmask;
9168 return pointer_window;
9171 pointer_window = get_event_parent (pointer_window);
9177 evmask = grab->event_mask;
9178 evmask = update_evmask_for_button_motion (evmask, mask);
9180 if (evmask & type_masks[type])
9183 *evmask_out = evmask;
9184 return grab->window;
9194 proxy_pointer_event (GdkDisplay *display,
9195 GdkEvent *source_event,
9198 GdkWindow *toplevel_window, *event_window;
9199 GdkWindow *pointer_window;
9200 GdkPointerWindowInfo *pointer_info;
9201 GdkDevice *device, *source_device;
9204 gdouble toplevel_x, toplevel_y;
9206 gboolean non_linear;
9208 event_window = source_event->any.window;
9209 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9210 gdk_event_get_state (source_event, &state);
9211 time_ = gdk_event_get_time (source_event);
9212 device = gdk_event_get_device (source_event);
9213 source_device = gdk_event_get_source_device (source_event);
9214 pointer_info = _gdk_display_get_pointer_info (display, device);
9215 toplevel_window = convert_native_coords_to_toplevel (event_window,
9216 toplevel_x, toplevel_y,
9217 &toplevel_x, &toplevel_y);
9220 if ((source_event->type == GDK_LEAVE_NOTIFY ||
9221 source_event->type == GDK_ENTER_NOTIFY) &&
9222 (source_event->crossing.detail == GDK_NOTIFY_NONLINEAR ||
9223 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))
9226 /* If we get crossing events with subwindow unexpectedly being NULL
9227 that means there is a native subwindow that gdk doesn't know about.
9228 We track these and forward them, with the correct virtual window
9230 This is important to get right, as metacity uses gdk for the frame
9231 windows, but gdk doesn't know about the client windows reparented
9233 if (((source_event->type == GDK_LEAVE_NOTIFY &&
9234 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9235 (source_event->type == GDK_ENTER_NOTIFY &&
9236 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9237 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9238 source_event->crossing.subwindow == NULL)
9240 /* Left for an unknown (to gdk) subwindow */
9242 /* Send leave events from window under pointer to event window
9243 that will get the subwindow == NULL window */
9244 _gdk_synthesize_crossing_events (display,
9245 pointer_info->window_under_pointer,
9247 device, source_device,
9248 source_event->crossing.mode,
9249 toplevel_x, toplevel_y,
9255 /* Send subwindow == NULL event */
9256 send_crossing_event (display,
9260 source_event->crossing.mode,
9261 source_event->crossing.detail,
9263 device, source_device,
9264 toplevel_x, toplevel_y,
9269 _gdk_display_set_window_under_pointer (display, device, NULL);
9273 pointer_window = get_pointer_window (display, toplevel_window, device,
9274 toplevel_x, toplevel_y, serial);
9276 if (((source_event->type == GDK_ENTER_NOTIFY &&
9277 source_event->crossing.detail == GDK_NOTIFY_INFERIOR) ||
9278 (source_event->type == GDK_LEAVE_NOTIFY &&
9279 (source_event->crossing.detail == GDK_NOTIFY_VIRTUAL ||
9280 source_event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
9281 source_event->crossing.subwindow == NULL)
9283 /* Entered from an unknown (to gdk) subwindow */
9285 /* Send subwindow == NULL event */
9286 send_crossing_event (display,
9290 source_event->crossing.mode,
9291 source_event->crossing.detail,
9293 device, source_device,
9294 toplevel_x, toplevel_y,
9299 /* Send enter events from event window to pointer_window */
9300 _gdk_synthesize_crossing_events (display,
9303 device, source_device,
9304 source_event->crossing.mode,
9305 toplevel_x, toplevel_y,
9308 serial, non_linear);
9309 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9313 if (pointer_info->window_under_pointer != pointer_window)
9315 /* Either a toplevel crossing notify that ended up inside a child window,
9316 or a motion notify that got into another child window */
9318 /* Different than last time, send crossing events */
9319 _gdk_synthesize_crossing_events (display,
9320 pointer_info->window_under_pointer,
9322 device, source_device,
9323 GDK_CROSSING_NORMAL,
9324 toplevel_x, toplevel_y,
9327 serial, non_linear);
9328 _gdk_display_set_window_under_pointer (display, device, pointer_window);
9330 else if (source_event->type == GDK_MOTION_NOTIFY)
9332 GdkWindow *event_win;
9336 event_win = get_event_window (display,
9345 gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9346 gdk_window_get_device_events (event_win, device) == 0)
9352 (evmask & GDK_POINTER_MOTION_HINT_MASK))
9354 gulong *device_serial;
9356 device_serial = g_hash_table_lookup (display->motion_hint_info, device);
9358 if (!device_serial ||
9359 (*device_serial != 0 &&
9360 serial < *device_serial))
9361 event_win = NULL; /* Ignore event */
9365 *device_serial = G_MAXULONG;
9369 if (event_win && !display->ignore_core_events)
9371 event = _gdk_make_event (event_win, GDK_MOTION_NOTIFY, source_event, FALSE);
9372 event->motion.time = time_;
9373 convert_toplevel_coords_to_window (event_win,
9374 toplevel_x, toplevel_y,
9375 &event->motion.x, &event->motion.y);
9376 event->motion.x_root = source_event->motion.x_root;
9377 event->motion.y_root = source_event->motion.y_root;
9378 event->motion.state = state;
9379 event->motion.is_hint = is_hint;
9380 event->motion.device = source_event->motion.device;
9381 event->motion.axes = g_memdup (source_event->motion.axes,
9382 sizeof (gdouble) * gdk_device_get_n_axes (source_event->motion.device));
9383 gdk_event_set_source_device (event, source_device);
9387 /* unlink all move events from queue.
9388 We handle our own, including our emulated masks. */
9392 #define GDK_ANY_BUTTON_MASK (GDK_BUTTON1_MASK | \
9393 GDK_BUTTON2_MASK | \
9394 GDK_BUTTON3_MASK | \
9395 GDK_BUTTON4_MASK | \
9399 proxy_button_event (GdkEvent *source_event,
9402 GdkWindow *toplevel_window, *event_window;
9403 GdkWindow *event_win;
9404 GdkWindow *pointer_window;
9410 gdouble toplevel_x, toplevel_y;
9411 GdkDisplay *display;
9413 GdkDevice *device, *source_device;
9415 type = source_event->any.type;
9416 event_window = source_event->any.window;
9417 gdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
9418 gdk_event_get_state (source_event, &state);
9419 time_ = gdk_event_get_time (source_event);
9420 device = gdk_event_get_device (source_event);
9421 source_device = gdk_event_get_source_device (source_event);
9422 display = gdk_window_get_display (source_event->any.window);
9423 toplevel_window = convert_native_coords_to_toplevel (event_window,
9424 toplevel_x, toplevel_y,
9425 &toplevel_x, &toplevel_y);
9427 if (type == GDK_BUTTON_PRESS &&
9428 !source_event->any.send_event &&
9429 _gdk_display_has_device_grab (display, device, serial) == NULL)
9432 _gdk_window_find_descendant_at (toplevel_window,
9433 toplevel_x, toplevel_y,
9436 /* Find the event window, that gets the grab */
9439 (parent = get_event_parent (w)) != NULL &&
9440 parent->window_type != GDK_WINDOW_ROOT)
9442 if (w->event_mask & GDK_BUTTON_PRESS_MASK)
9446 pointer_window = (GdkWindow *)w;
9448 _gdk_display_add_device_grab (display,
9454 gdk_window_get_events (pointer_window),
9458 _gdk_display_device_grab_update (display, device, source_device, serial);
9461 pointer_window = get_pointer_window (display, toplevel_window, device,
9462 toplevel_x, toplevel_y,
9465 event_win = get_event_window (display,
9471 if (event_win == NULL || display->ignore_core_events)
9474 if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER &&
9475 gdk_window_get_device_events (event_win, device) == 0)
9478 event = _gdk_make_event (event_win, type, source_event, FALSE);
9482 case GDK_BUTTON_PRESS:
9483 case GDK_BUTTON_RELEASE:
9484 event->button.button = source_event->button.button;
9485 convert_toplevel_coords_to_window (event_win,
9486 toplevel_x, toplevel_y,
9487 &event->button.x, &event->button.y);
9488 event->button.x_root = source_event->button.x_root;
9489 event->button.y_root = source_event->button.y_root;
9490 event->button.state = state;
9491 event->button.device = source_event->button.device;
9492 event->button.axes = g_memdup (source_event->button.axes,
9493 sizeof (gdouble) * gdk_device_get_n_axes (source_event->button.device));
9495 gdk_event_set_source_device (event, source_device);
9497 if (type == GDK_BUTTON_PRESS)
9498 _gdk_event_button_generate (display, event);
9502 event->scroll.direction = source_event->scroll.direction;
9503 convert_toplevel_coords_to_window (event_win,
9504 toplevel_x, toplevel_y,
9505 &event->scroll.x, &event->scroll.y);
9506 event->scroll.x_root = source_event->scroll.x_root;
9507 event->scroll.y_root = source_event->scroll.y_root;
9508 event->scroll.state = state;
9509 event->scroll.device = source_event->scroll.device;
9510 gdk_event_set_source_device (event, source_device);
9517 return TRUE; /* Always unlink original, we want to obey the emulated event mask */
9520 #ifdef DEBUG_WINDOW_PRINTING
9522 gdk_window_print (GdkWindow *window,
9526 const char *window_types[] = {
9536 g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", window,
9537 window->user_data ? g_type_name_from_instance (window->user_data) : "no widget",
9538 window->x, window->y,
9539 window->width, window->height
9542 if (gdk_window_has_impl (window))
9544 #ifdef GDK_WINDOWING_X11
9545 g_print (" impl(0x%lx)", gdk_x11_window_get_xid (window));
9549 if (window->window_type != GDK_WINDOW_CHILD)
9550 g_print (" %s", window_types[window->window_type]);
9552 if (window->input_only)
9553 g_print (" input-only");
9556 g_print (" shaped");
9558 if (!gdk_window_is_visible ((GdkWindow *)window))
9559 g_print (" hidden");
9561 g_print (" abs[%d,%d]",
9562 window->abs_x, window->abs_y);
9564 cairo_region_get_extents (window->clip_region, &r);
9565 if (cairo_region_is_empty (window->clip_region))
9566 g_print (" clipbox[empty]");
9568 g_print (" clipbox[%d,%d %dx%d]", r.x, r.y, r.width, r.height);
9575 gdk_window_print_tree (GdkWindow *window,
9577 gboolean include_input_only)
9581 if (window->input_only && !include_input_only)
9584 gdk_window_print (window, indent);
9586 for (l = window->children; l != NULL; l = l->next)
9587 gdk_window_print_tree (l->data, indent + 4, include_input_only);
9590 #endif /* DEBUG_WINDOW_PRINTING */
9593 _gdk_windowing_got_event (GdkDisplay *display,
9598 GdkWindow *event_window;
9600 gboolean unlink_event;
9601 guint old_state, old_button;
9602 GdkDeviceGrabInfo *button_release_grab;
9603 GdkPointerWindowInfo *pointer_info;
9604 GdkDevice *device, *source_device;
9605 gboolean is_toplevel;
9607 if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
9608 display->last_event_time = gdk_event_get_time (event);
9610 device = gdk_event_get_device (event);
9611 source_device = gdk_event_get_source_device (event);
9617 g_object_get (device, "input-mode", &mode, NULL);
9618 _gdk_display_device_grab_update (display, device, source_device, serial);
9620 if (mode == GDK_MODE_DISABLED ||
9621 !_gdk_display_check_grab_ownership (display, device, serial))
9623 /* Device events are blocked by another
9624 * device grab, or the device is disabled
9626 unlink_event = TRUE;
9631 event_window = event->any.window;
9635 pointer_info = _gdk_display_get_pointer_info (display, device);
9637 #ifdef DEBUG_WINDOW_PRINTING
9638 if (event->type == GDK_KEY_PRESS &&
9639 (event->key.keyval == 0xa7 ||
9640 event->key.keyval == 0xbd))
9642 gdk_window_print_tree (event_window, 0,
9643 event->key.keyval == 0xbd);
9647 if (event->type == GDK_VISIBILITY_NOTIFY)
9649 event_window->native_visibility = event->visibility.state;
9650 gdk_window_update_visibility_recursively (event_window,
9655 if (!(is_button_type (event->type) ||
9656 is_motion_type (event->type)) ||
9657 event_window->window_type == GDK_WINDOW_ROOT)
9660 is_toplevel = gdk_window_is_toplevel (event_window);
9662 if ((event->type == GDK_ENTER_NOTIFY ||
9663 event->type == GDK_LEAVE_NOTIFY) &&
9664 (event->crossing.mode == GDK_CROSSING_GRAB ||
9665 event->crossing.mode == GDK_CROSSING_UNGRAB) &&
9666 (_gdk_display_has_device_grab (display, device, serial) ||
9667 event->crossing.detail == GDK_NOTIFY_INFERIOR))
9669 /* We synthesize all crossing events due to grabs ourselves,
9670 * so we ignore the native ones caused by our native pointer_grab
9671 * calls. Otherwise we would proxy these crossing event and cause
9672 * multiple copies of crossing events for grabs.
9674 * We do want to handle grabs from other clients though, as for
9675 * instance alt-tab in metacity causes grabs like these and
9676 * we want to handle those. Thus the has_pointer_grab check.
9678 * Implicit grabs on child windows create some grabbing events
9679 * that are sent before the button press. This means we can't
9680 * detect these with the has_pointer_grab check (as the implicit
9681 * grab is only noticed when we get button press event), so we
9682 * detect these events by checking for INFERIOR enter or leave
9683 * events. These should never be a problem to filter out.
9686 /* We ended up in this window after some (perhaps other clients)
9687 grab, so update the toplevel_under_window state */
9689 event->type == GDK_ENTER_NOTIFY &&
9690 event->crossing.mode == GDK_CROSSING_UNGRAB)
9692 if (pointer_info->toplevel_under_pointer)
9693 g_object_unref (pointer_info->toplevel_under_pointer);
9694 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9697 unlink_event = TRUE;
9701 /* Track toplevel_under_pointer */
9704 if (event->type == GDK_ENTER_NOTIFY &&
9705 event->crossing.detail != GDK_NOTIFY_INFERIOR)
9707 if (pointer_info->toplevel_under_pointer)
9708 g_object_unref (pointer_info->toplevel_under_pointer);
9709 pointer_info->toplevel_under_pointer = g_object_ref (event_window);
9711 else if (event->type == GDK_LEAVE_NOTIFY &&
9712 event->crossing.detail != GDK_NOTIFY_INFERIOR &&
9713 pointer_info->toplevel_under_pointer == event_window)
9715 if (pointer_info->toplevel_under_pointer)
9716 g_object_unref (pointer_info->toplevel_under_pointer);
9717 pointer_info->toplevel_under_pointer = NULL;
9721 /* Store last pointer window and position/state */
9722 old_state = pointer_info->state;
9723 old_button = pointer_info->button;
9725 gdk_event_get_coords (event, &x, &y);
9726 convert_native_coords_to_toplevel (event_window, x, y, &x, &y);
9727 pointer_info->toplevel_x = x;
9728 pointer_info->toplevel_y = y;
9729 gdk_event_get_state (event, &pointer_info->state);
9730 if (event->type == GDK_BUTTON_PRESS ||
9731 event->type == GDK_BUTTON_RELEASE)
9732 pointer_info->button = event->button.button;
9735 (pointer_info->state != old_state ||
9736 pointer_info->button != old_button))
9737 _gdk_display_enable_motion_hints (display, device);
9739 unlink_event = FALSE;
9740 if (is_motion_type (event->type))
9741 unlink_event = proxy_pointer_event (display,
9744 else if (is_button_type (event->type))
9745 unlink_event = proxy_button_event (event,
9748 if (event->type == GDK_BUTTON_RELEASE &&
9749 !event->any.send_event)
9751 button_release_grab =
9752 _gdk_display_has_device_grab (display, device, serial);
9753 if (button_release_grab &&
9754 button_release_grab->implicit &&
9755 (event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
9757 button_release_grab->serial_end = serial;
9758 button_release_grab->implicit_ungrab = FALSE;
9759 _gdk_display_device_grab_update (display, device, source_device, serial);
9766 _gdk_event_queue_remove_link (display, event_link);
9767 g_list_free_1 (event_link);
9768 gdk_event_free (event);
9773 * gdk_window_create_similar_surface:
9774 * @window: window to make new surface similar to
9775 * @content: the content for the new surface
9776 * @width: width of the new surface
9777 * @height: height of the new surface
9779 * Create a new surface that is as compatible as possible with the
9780 * given @window. For example the new surface will have the same
9781 * fallback resolution and font options as @window. Generally, the new
9782 * surface will also use the same backend as @window, unless that is
9783 * not possible for some reason. The type of the returned surface may
9784 * be examined with cairo_surface_get_type().
9786 * Initially the surface contents are all 0 (transparent if contents
9787 * have transparency, black otherwise.)
9789 * Returns: a pointer to the newly allocated surface. The caller
9790 * owns the surface and should call cairo_surface_destroy() when done
9793 * This function always returns a valid pointer, but it will return a
9794 * pointer to a "nil" surface if @other is already in an error state
9795 * or any other error occurs.
9800 gdk_window_create_similar_surface (GdkWindow * window,
9801 cairo_content_t content,
9805 cairo_surface_t *window_surface, *surface;
9807 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
9809 window_surface = _gdk_window_ref_cairo_surface (window);
9811 switch (_gdk_rendering_mode)
9813 case GDK_RENDERING_MODE_RECORDING:
9815 cairo_rectangle_t rect = { 0, 0, width, height };
9816 surface = cairo_recording_surface_create (content, &rect);
9819 case GDK_RENDERING_MODE_IMAGE:
9820 surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
9821 content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
9824 case GDK_RENDERING_MODE_SIMILAR:
9826 surface = cairo_surface_create_similar (window_surface,
9832 cairo_surface_destroy (window_surface);
9839 * @window: a #GdkWindow
9840 * @timestamp: timestamp of the event triggering the window focus
9842 * Sets keyboard focus to @window. In most cases, gtk_window_present()
9843 * should be used on a #GtkWindow, rather than calling this function.
9847 gdk_window_focus (GdkWindow *window,
9850 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->focus (window, timestamp);
9854 * gdk_window_set_type_hint:
9855 * @window: A toplevel #GdkWindow
9856 * @hint: A hint of the function this window will have
9858 * The application can use this call to provide a hint to the window
9859 * manager about the functionality of a window. The window manager
9860 * can use this information when determining the decoration and behaviour
9863 * The hint must be set before the window is mapped.
9866 gdk_window_set_type_hint (GdkWindow *window,
9867 GdkWindowTypeHint hint)
9869 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_type_hint (window, hint);
9873 * gdk_window_get_type_hint:
9874 * @window: A toplevel #GdkWindow
9876 * This function returns the type hint set for a window.
9878 * Return value: The type hint set for @window
9883 gdk_window_get_type_hint (GdkWindow *window)
9885 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_type_hint (window);
9889 * gdk_window_set_modal_hint:
9890 * @window: A toplevel #GdkWindow
9891 * @modal: %TRUE if the window is modal, %FALSE otherwise.
9893 * The application can use this hint to tell the window manager
9894 * that a certain window has modal behaviour. The window manager
9895 * can use this information to handle modal windows in a special
9898 * You should only use this on windows for which you have
9899 * previously called gdk_window_set_transient_for()
9902 gdk_window_set_modal_hint (GdkWindow *window,
9905 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_modal_hint (window, modal);
9909 * gdk_window_set_skip_taskbar_hint:
9910 * @window: a toplevel #GdkWindow
9911 * @skips_taskbar: %TRUE to skip the taskbar
9913 * Toggles whether a window should appear in a task list or window
9914 * list. If a window's semantic type as specified with
9915 * gdk_window_set_type_hint() already fully describes the window, this
9916 * function should <emphasis>not</emphasis> be called in addition,
9917 * instead you should allow the window to be treated according to
9918 * standard policy for its semantic type.
9923 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
9924 gboolean skips_taskbar)
9926 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_taskbar_hint (window, skips_taskbar);
9930 * gdk_window_set_skip_pager_hint:
9931 * @window: a toplevel #GdkWindow
9932 * @skips_pager: %TRUE to skip the pager
9934 * Toggles whether a window should appear in a pager (workspace
9935 * switcher, or other desktop utility program that displays a small
9936 * thumbnail representation of the windows on the desktop). If a
9937 * window's semantic type as specified with gdk_window_set_type_hint()
9938 * already fully describes the window, this function should
9939 * <emphasis>not</emphasis> be called in addition, instead you should
9940 * allow the window to be treated according to standard policy for
9941 * its semantic type.
9946 gdk_window_set_skip_pager_hint (GdkWindow *window,
9947 gboolean skips_pager)
9949 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_skip_pager_hint (window, skips_pager);
9953 * gdk_window_set_urgency_hint:
9954 * @window: a toplevel #GdkWindow
9955 * @urgent: %TRUE if the window is urgent
9957 * Toggles whether a window needs the user's
9963 gdk_window_set_urgency_hint (GdkWindow *window,
9966 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_urgency_hint (window, urgent);
9970 * gdk_window_set_geometry_hints:
9971 * @window: a toplevel #GdkWindow
9972 * @geometry: geometry hints
9973 * @geom_mask: bitmask indicating fields of @geometry to pay attention to
9975 * Sets the geometry hints for @window. Hints flagged in @geom_mask
9976 * are set, hints not flagged in @geom_mask are unset.
9977 * To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
9979 * This function provides hints to the windowing system about
9980 * acceptable sizes for a toplevel window. The purpose of
9981 * this is to constrain user resizing, but the windowing system
9982 * will typically (but is not required to) also constrain the
9983 * current size of the window to the provided values and
9984 * constrain programatic resizing via gdk_window_resize() or
9985 * gdk_window_move_resize().
9987 * Note that on X11, this effect has no effect on windows
9988 * of type %GDK_WINDOW_TEMP or windows where override redirect
9989 * has been turned on via gdk_window_set_override_redirect()
9990 * since these windows are not resizable by the user.
9992 * Since you can't count on the windowing system doing the
9993 * constraints for programmatic resizes, you should generally
9994 * call gdk_window_constrain_size() yourself to determine
9995 * appropriate sizes.
9999 gdk_window_set_geometry_hints (GdkWindow *window,
10000 const GdkGeometry *geometry,
10001 GdkWindowHints geom_mask)
10003 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_geometry_hints (window, geometry, geom_mask);
10007 * gdk_window_set_title:
10008 * @window: a toplevel #GdkWindow
10009 * @title: title of @window
10011 * Sets the title of a toplevel window, to be displayed in the titlebar.
10012 * If you haven't explicitly set the icon name for the window
10013 * (using gdk_window_set_icon_name()), the icon name will be set to
10014 * @title as well. @title must be in UTF-8 encoding (as with all
10015 * user-readable strings in GDK/GTK+). @title may not be %NULL.
10018 gdk_window_set_title (GdkWindow *window,
10019 const gchar *title)
10021 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_title (window, title);
10025 * gdk_window_set_role:
10026 * @window: a toplevel #GdkWindow
10027 * @role: a string indicating its role
10029 * When using GTK+, typically you should use gtk_window_set_role() instead
10030 * of this low-level function.
10032 * The window manager and session manager use a window's role to
10033 * distinguish it from other kinds of window in the same application.
10034 * When an application is restarted after being saved in a previous
10035 * session, all windows with the same title and role are treated as
10036 * interchangeable. So if you have two windows with the same title
10037 * that should be distinguished for session management purposes, you
10038 * should set the role on those windows. It doesn't matter what string
10039 * you use for the role, as long as you have a different role for each
10040 * non-interchangeable kind of window.
10044 gdk_window_set_role (GdkWindow *window,
10047 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_role (window, role);
10051 * gdk_window_set_startup_id:
10052 * @window: a toplevel #GdkWindow
10053 * @startup_id: a string with startup-notification identifier
10055 * When using GTK+, typically you should use gtk_window_set_startup_id()
10056 * instead of this low-level function.
10062 gdk_window_set_startup_id (GdkWindow *window,
10063 const gchar *startup_id)
10065 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_startup_id (window, startup_id);
10069 * gdk_window_set_transient_for:
10070 * @window: a toplevel #GdkWindow
10071 * @parent: another toplevel #GdkWindow
10073 * Indicates to the window manager that @window is a transient dialog
10074 * associated with the application window @parent. This allows the
10075 * window manager to do things like center @window on @parent and
10076 * keep @window above @parent.
10078 * See gtk_window_set_transient_for() if you're using #GtkWindow or
10082 gdk_window_set_transient_for (GdkWindow *window,
10085 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_transient_for (window, parent);
10089 * gdk_window_get_root_origin:
10090 * @window: a toplevel #GdkWindow
10091 * @x: (out): return location for X position of window frame
10092 * @y: (out): return location for Y position of window frame
10094 * Obtains the top-left corner of the window manager frame in root
10095 * window coordinates.
10099 gdk_window_get_root_origin (GdkWindow *window,
10103 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_root_origin (window, x, y);
10107 * gdk_window_get_frame_extents:
10108 * @window: a toplevel #GdkWindow
10109 * @rect: rectangle to fill with bounding box of the window frame
10111 * Obtains the bounding box of the window, including window manager
10112 * titlebar/borders if any. The frame position is given in root window
10113 * coordinates. To get the position of the window itself (rather than
10114 * the frame) in root window coordinates, use gdk_window_get_origin().
10118 gdk_window_get_frame_extents (GdkWindow *window,
10119 GdkRectangle *rect)
10121 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_frame_extents (window, rect);
10125 * gdk_window_set_override_redirect:
10126 * @window: a toplevel #GdkWindow
10127 * @override_redirect: %TRUE if window should be override redirect
10129 * An override redirect window is not under the control of the window manager.
10130 * This means it won't have a titlebar, won't be minimizable, etc. - it will
10131 * be entirely under the control of the application. The window manager
10132 * can't see the override redirect window at all.
10134 * Override redirect should only be used for short-lived temporary
10135 * windows, such as popup menus. #GtkMenu uses an override redirect
10136 * window in its implementation, for example.
10140 gdk_window_set_override_redirect (GdkWindow *window,
10141 gboolean override_redirect)
10143 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_override_redirect (window, override_redirect);
10147 * gdk_window_set_accept_focus:
10148 * @window: a toplevel #GdkWindow
10149 * @accept_focus: %TRUE if the window should receive input focus
10151 * Setting @accept_focus to %FALSE hints the desktop environment that the
10152 * window doesn't want to receive input focus.
10154 * On X, it is the responsibility of the window manager to interpret this
10155 * hint. ICCCM-compliant window manager usually respect it.
10160 gdk_window_set_accept_focus (GdkWindow *window,
10161 gboolean accept_focus)
10163 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_accept_focus (window, accept_focus);
10167 * gdk_window_set_focus_on_map:
10168 * @window: a toplevel #GdkWindow
10169 * @focus_on_map: %TRUE if the window should receive input focus when mapped
10171 * Setting @focus_on_map to %FALSE hints the desktop environment that the
10172 * window doesn't want to receive input focus when it is mapped.
10173 * focus_on_map should be turned off for windows that aren't triggered
10174 * interactively (such as popups from network activity).
10176 * On X, it is the responsibility of the window manager to interpret
10177 * this hint. Window managers following the freedesktop.org window
10178 * manager extension specification should respect it.
10183 gdk_window_set_focus_on_map (GdkWindow *window,
10184 gboolean focus_on_map)
10186 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_focus_on_map (window, focus_on_map);
10190 * gdk_window_set_icon_list:
10191 * @window: The #GdkWindow toplevel window to set the icon of.
10192 * @pixbufs: (transfer none) (element-type GdkPixbuf):
10193 * A list of pixbufs, of different sizes.
10195 * Sets a list of icons for the window. One of these will be used
10196 * to represent the window when it has been iconified. The icon is
10197 * usually shown in an icon box or some sort of task bar. Which icon
10198 * size is shown depends on the window manager. The window manager
10199 * can scale the icon but setting several size icons can give better
10200 * image quality since the window manager may only need to scale the
10201 * icon by a small amount or not at all.
10205 gdk_window_set_icon_list (GdkWindow *window,
10208 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_list (window, pixbufs);
10212 * gdk_window_set_icon_name:
10213 * @window: a toplevel #GdkWindow
10214 * @name: (allow-none): name of window while iconified (minimized)
10216 * Windows may have a name used while minimized, distinct from the
10217 * name they display in their titlebar. Most of the time this is a bad
10218 * idea from a user interface standpoint. But you can set such a name
10219 * with this function, if you like.
10221 * After calling this with a non-%NULL @name, calls to gdk_window_set_title()
10222 * will not update the icon title.
10224 * Using %NULL for @name unsets the icon title; further calls to
10225 * gdk_window_set_title() will again update the icon title as well.
10228 gdk_window_set_icon_name (GdkWindow *window,
10231 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_icon_name (window, name);
10235 * gdk_window_iconify:
10236 * @window: a toplevel #GdkWindow
10238 * Asks to iconify (minimize) @window. The window manager may choose
10239 * to ignore the request, but normally will honor it. Using
10240 * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
10242 * This function only makes sense when @window is a toplevel window.
10246 gdk_window_iconify (GdkWindow *window)
10248 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->iconify (window);
10252 * gdk_window_deiconify:
10253 * @window: a toplevel #GdkWindow
10255 * Attempt to deiconify (unminimize) @window. On X11 the window manager may
10256 * choose to ignore the request to deiconify. When using GTK+,
10257 * use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
10258 * you probably want to use gtk_window_present(), which raises the window, focuses it,
10259 * unminimizes it, and puts it on the current desktop.
10263 gdk_window_deiconify (GdkWindow *window)
10265 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->deiconify (window);
10269 * gdk_window_stick:
10270 * @window: a toplevel #GdkWindow
10272 * "Pins" a window such that it's on all workspaces and does not scroll
10273 * with viewports, for window managers that have scrollable viewports.
10274 * (When using #GtkWindow, gtk_window_stick() may be more useful.)
10276 * On the X11 platform, this function depends on window manager
10277 * support, so may have no effect with many window managers. However,
10278 * GDK will do the best it can to convince the window manager to stick
10279 * the window. For window managers that don't support this operation,
10280 * there's nothing you can do to force it to happen.
10284 gdk_window_stick (GdkWindow *window)
10286 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->stick (window);
10290 * gdk_window_unstick:
10291 * @window: a toplevel #GdkWindow
10293 * Reverse operation for gdk_window_stick(); see gdk_window_stick(),
10294 * and gtk_window_unstick().
10298 gdk_window_unstick (GdkWindow *window)
10300 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unstick (window);
10304 * gdk_window_maximize:
10305 * @window: a toplevel #GdkWindow
10307 * Maximizes the window. If the window was already maximized, then
10308 * this function does nothing.
10310 * On X11, asks the window manager to maximize @window, if the window
10311 * manager supports this operation. Not all window managers support
10312 * this, and some deliberately ignore it or don't have a concept of
10313 * "maximized"; so you can't rely on the maximization actually
10314 * happening. But it will happen with most standard window managers,
10315 * and GDK makes a best effort to get it to happen.
10317 * On Windows, reliably maximizes the window.
10321 gdk_window_maximize (GdkWindow *window)
10323 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->maximize (window);
10327 * gdk_window_unmaximize:
10328 * @window: a toplevel #GdkWindow
10330 * Unmaximizes the window. If the window wasn't maximized, then this
10331 * function does nothing.
10333 * On X11, asks the window manager to unmaximize @window, if the
10334 * window manager supports this operation. Not all window managers
10335 * support this, and some deliberately ignore it or don't have a
10336 * concept of "maximized"; so you can't rely on the unmaximization
10337 * actually happening. But it will happen with most standard window
10338 * managers, and GDK makes a best effort to get it to happen.
10340 * On Windows, reliably unmaximizes the window.
10344 gdk_window_unmaximize (GdkWindow *window)
10346 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unmaximize (window);
10350 * gdk_window_fullscreen:
10351 * @window: a toplevel #GdkWindow
10353 * Moves the window into fullscreen mode. This means the
10354 * window covers the entire screen and is above any panels
10357 * If the window was already fullscreen, then this function does nothing.
10359 * On X11, asks the window manager to put @window in a fullscreen
10360 * state, if the window manager supports this operation. Not all
10361 * window managers support this, and some deliberately ignore it or
10362 * don't have a concept of "fullscreen"; so you can't rely on the
10363 * fullscreenification actually happening. But it will happen with
10364 * most standard window managers, and GDK makes a best effort to get
10370 gdk_window_fullscreen (GdkWindow *window)
10372 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->fullscreen (window);
10376 * gdk_window_unfullscreen:
10377 * @window: a toplevel #GdkWindow
10379 * Moves the window out of fullscreen mode. If the window was not
10380 * fullscreen, does nothing.
10382 * On X11, asks the window manager to move @window out of the fullscreen
10383 * state, if the window manager supports this operation. Not all
10384 * window managers support this, and some deliberately ignore it or
10385 * don't have a concept of "fullscreen"; so you can't rely on the
10386 * unfullscreenification actually happening. But it will happen with
10387 * most standard window managers, and GDK makes a best effort to get
10393 gdk_window_unfullscreen (GdkWindow *window)
10395 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->unfullscreen (window);
10399 * gdk_window_set_keep_above:
10400 * @window: a toplevel #GdkWindow
10401 * @setting: whether to keep @window above other windows
10403 * Set if @window must be kept above other windows. If the
10404 * window was already above, then this function does nothing.
10406 * On X11, asks the window manager to keep @window above, if the window
10407 * manager supports this operation. Not all window managers support
10408 * this, and some deliberately ignore it or don't have a concept of
10409 * "keep above"; so you can't rely on the window being kept above.
10410 * But it will happen with most standard window managers,
10411 * and GDK makes a best effort to get it to happen.
10416 gdk_window_set_keep_above (GdkWindow *window,
10419 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_above (window, setting);
10423 * gdk_window_set_keep_below:
10424 * @window: a toplevel #GdkWindow
10425 * @setting: whether to keep @window below other windows
10427 * Set if @window must be kept below other windows. If the
10428 * window was already below, then this function does nothing.
10430 * On X11, asks the window manager to keep @window below, if the window
10431 * manager supports this operation. Not all window managers support
10432 * this, and some deliberately ignore it or don't have a concept of
10433 * "keep below"; so you can't rely on the window being kept below.
10434 * But it will happen with most standard window managers,
10435 * and GDK makes a best effort to get it to happen.
10440 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
10442 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_keep_below (window, setting);
10446 * gdk_window_get_group:
10447 * @window: a toplevel #GdkWindow
10449 * Returns the group leader window for @window. See gdk_window_set_group().
10451 * Return value: (transfer none): the group leader window for @window
10456 gdk_window_get_group (GdkWindow *window)
10458 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_group (window);
10462 * gdk_window_set_group:
10463 * @window: a toplevel #GdkWindow
10464 * @leader: (allow-none): group leader window, or %NULL to restore the default group leader window
10466 * Sets the group leader window for @window. By default,
10467 * GDK sets the group leader for all toplevel windows
10468 * to a global window implicitly created by GDK. With this function
10469 * you can override this default.
10471 * The group leader window allows the window manager to distinguish
10472 * all windows that belong to a single application. It may for example
10473 * allow users to minimize/unminimize all windows belonging to an
10474 * application at once. You should only set a non-default group window
10475 * if your application pretends to be multiple applications.
10478 gdk_window_set_group (GdkWindow *window,
10481 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_group (window, leader);
10485 * gdk_window_set_decorations:
10486 * @window: a toplevel #GdkWindow
10487 * @decorations: decoration hint mask
10489 * "Decorations" are the features the window manager adds to a toplevel #GdkWindow.
10490 * This function sets the traditional Motif window manager hints that tell the
10491 * window manager which decorations you would like your window to have.
10492 * Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
10493 * using the GDK function directly.
10495 * The @decorations argument is the logical OR of the fields in
10496 * the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
10497 * mask, the other bits indicate which decorations should be turned off.
10498 * If #GDK_DECOR_ALL is not included, then the other bits indicate
10499 * which decorations should be turned on.
10501 * Most window managers honor a decorations hint of 0 to disable all decorations,
10502 * but very few honor all possible combinations of bits.
10506 gdk_window_set_decorations (GdkWindow *window,
10507 GdkWMDecoration decorations)
10509 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_decorations (window, decorations);
10513 * gdk_window_get_decorations:
10514 * @window: The toplevel #GdkWindow to get the decorations from
10515 * @decorations: (out): The window decorations will be written here
10517 * Returns the decorations set on the GdkWindow with
10518 * gdk_window_set_decorations().
10520 * Returns: %TRUE if the window has decorations set, %FALSE otherwise.
10523 gdk_window_get_decorations(GdkWindow *window,
10524 GdkWMDecoration *decorations)
10526 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_decorations (window, decorations);
10530 * gdk_window_set_functions:
10531 * @window: a toplevel #GdkWindow
10532 * @functions: bitmask of operations to allow on @window
10534 * Sets hints about the window management functions to make available
10535 * via buttons on the window frame.
10537 * On the X backend, this function sets the traditional Motif window
10538 * manager hint for this purpose. However, few window managers do
10539 * anything reliable or interesting with this hint. Many ignore it
10542 * The @functions argument is the logical OR of values from the
10543 * #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
10544 * then the other bits indicate which functions to disable; if
10545 * it doesn't include #GDK_FUNC_ALL, it indicates which functions to
10550 gdk_window_set_functions (GdkWindow *window,
10551 GdkWMFunction functions)
10553 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_functions (window, functions);
10557 * gdk_window_begin_resize_drag_for_device:
10558 * @window: a toplevel #GdkWindow
10559 * @edge: the edge or corner from which the drag is started
10560 * @device: the device used for the operation
10561 * @button: the button being used to drag
10562 * @root_x: root window X coordinate of mouse click that began the drag
10563 * @root_y: root window Y coordinate of mouse click that began the drag
10564 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10566 * Begins a window resize operation (for a toplevel window).
10567 * You might use this function to implement a "window resize grip," for
10568 * example; in fact #GtkStatusbar uses it. The function works best
10569 * with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a
10570 * fallback implementation for other window managers.
10575 gdk_window_begin_resize_drag_for_device (GdkWindow *window,
10576 GdkWindowEdge edge,
10583 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
10587 * gdk_window_begin_resize_drag:
10588 * @window: a toplevel #GdkWindow
10589 * @edge: the edge or corner from which the drag is started
10590 * @button: the button being used to drag
10591 * @root_x: root window X coordinate of mouse click that began the drag
10592 * @root_y: root window Y coordinate of mouse click that began the drag
10593 * @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
10595 * Begins a window resize operation (for a toplevel window).
10597 * This function assumes that the drag is controlled by the
10598 * client pointer device, use gdk_window_begin_resize_drag_for_device()
10599 * to begin a drag with a different device.
10602 gdk_window_begin_resize_drag (GdkWindow *window,
10603 GdkWindowEdge edge,
10609 GdkDeviceManager *device_manager;
10612 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10613 device = gdk_device_manager_get_client_pointer (device_manager);
10614 gdk_window_begin_resize_drag_for_device (window, edge,
10615 device, button, root_x, root_y, timestamp);
10619 * gdk_window_begin_move_drag_for_device:
10620 * @window: a toplevel #GdkWindow
10621 * @device: the device used for the operation
10622 * @button: the button being used to drag
10623 * @root_x: root window X coordinate of mouse click that began the drag
10624 * @root_y: root window Y coordinate of mouse click that began the drag
10625 * @timestamp: timestamp of mouse click that began the drag
10627 * Begins a window move operation (for a toplevel window).
10628 * You might use this function to implement a "window move grip," for
10629 * example. The function works best with window managers that support
10630 * the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended
10631 * Window Manager Hints</ulink>, but has a fallback implementation for
10632 * other window managers.
10637 gdk_window_begin_move_drag_for_device (GdkWindow *window,
10644 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->begin_move_drag (window,
10645 device, button, root_x, root_y, timestamp);
10649 * gdk_window_begin_move_drag:
10650 * @window: a toplevel #GdkWindow
10651 * @button: the button being used to drag
10652 * @root_x: root window X coordinate of mouse click that began the drag
10653 * @root_y: root window Y coordinate of mouse click that began the drag
10654 * @timestamp: timestamp of mouse click that began the drag
10656 * Begins a window move operation (for a toplevel window).
10658 * This function assumes that the drag is controlled by the
10659 * client pointer device, use gdk_window_begin_move_drag_for_device()
10660 * to begin a drag with a different device.
10663 gdk_window_begin_move_drag (GdkWindow *window,
10669 GdkDeviceManager *device_manager;
10672 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10673 device = gdk_device_manager_get_client_pointer (device_manager);
10674 gdk_window_begin_move_drag_for_device (window, device, button, root_x, root_y, timestamp);
10678 * gdk_window_enable_synchronized_configure:
10679 * @window: a toplevel #GdkWindow
10681 * Indicates that the application will cooperate with the window
10682 * system in synchronizing the window repaint with the window
10683 * manager during resizing operations. After an application calls
10684 * this function, it must call gdk_window_configure_finished() every
10685 * time it has finished all processing associated with a set of
10686 * Configure events. Toplevel GTK+ windows automatically use this
10689 * On X, calling this function makes @window participate in the
10690 * _NET_WM_SYNC_REQUEST window manager protocol.
10695 gdk_window_enable_synchronized_configure (GdkWindow *window)
10697 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->enable_synchronized_configure (window);
10701 * gdk_window_configure_finished:
10702 * @window: a toplevel #GdkWindow
10704 * Signal to the window system that the application has finished
10705 * handling Configure events it has received. Window Managers can
10706 * use this to better synchronize the frame repaint with the
10707 * application. GTK+ applications will automatically call this
10708 * function when appropriate.
10710 * This function can only be called if gdk_window_enable_synchronized_configure()
10711 * was called previously.
10716 gdk_window_configure_finished (GdkWindow *window)
10718 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->configure_finished (window);
10722 * gdk_window_set_opacity:
10723 * @window: a top-level #GdkWindow
10724 * @opacity: opacity
10726 * Request the windowing system to make @window partially transparent,
10727 * with opacity 0 being fully transparent and 1 fully opaque. (Values
10728 * of the opacity parameter are clamped to the [0,1] range.)
10730 * On X11, this works only on X screens with a compositing manager
10733 * For setting up per-pixel alpha, see gdk_screen_get_rgba_visual().
10734 * For making non-toplevel windows translucent, see
10735 * gdk_window_set_composited().
10740 gdk_window_set_opacity (GdkWindow *window,
10743 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->set_opacity (window, opacity);
10746 /* This function is called when the XWindow is really gone.
10749 gdk_window_destroy_notify (GdkWindow *window)
10751 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->destroy_notify (window);
10755 * gdk_window_register_dnd:
10756 * @window: a #GdkWindow.
10758 * Registers a window as a potential drop destination.
10761 gdk_window_register_dnd (GdkWindow *window)
10763 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->register_dnd (window);
10767 * gdk_window_get_drag_protocol:
10768 * @window: the destination window
10769 * @target: (out) (allow-none) (transfer full): location of the window
10770 * where the drop should happen. This may be @window or a proxy window,
10771 * or %NULL if @window does not support Drag and Drop.
10773 * Finds out the DND protocol supported by a window.
10775 * Returns: the supported DND protocol.
10780 gdk_window_get_drag_protocol (GdkWindow *window,
10781 GdkWindow **target)
10783 g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_DRAG_PROTO_NONE);
10785 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_drag_protocol (window, target);
10790 * @window: the source window for this drag.
10791 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10792 * as list of #GdkAtoms
10794 * Starts a drag and creates a new drag context for it.
10795 * This function assumes that the drag is controlled by the
10796 * client pointer device, use gdk_drag_begin_for_device() to
10797 * begin a drag with a different device.
10799 * This function is called by the drag source.
10801 * Return value: (transfer full): a newly created #GdkDragContext
10804 gdk_drag_begin (GdkWindow *window,
10807 GdkDeviceManager *device_manager;
10810 device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
10811 device = gdk_device_manager_get_client_pointer (device_manager);
10813 return gdk_drag_begin_for_device (window, device, targets);
10817 * gdk_drag_begin_for_device:
10818 * @window: the source window for this drag
10819 * @device: the device that controls this drag
10820 * @targets: (transfer none) (element-type GdkAtom): the offered targets,
10821 * as list of #GdkAtoms
10823 * Starts a drag and creates a new drag context for it.
10825 * This function is called by the drag source.
10827 * Return value: (transfer full): a newly created #GdkDragContext
10830 gdk_drag_begin_for_device (GdkWindow *window,
10834 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)->drag_begin (window, device, targets);
10838 * gdk_test_render_sync:
10839 * @window: a mapped #GdkWindow
10841 * Retrieves a pixel from @window to force the windowing
10842 * system to carry out any pending rendering commands.
10844 * This function is intended to be used to synchronize with rendering
10845 * pipelines, to benchmark windowing system rendering operations.
10850 gdk_test_render_sync (GdkWindow *window)
10852 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->sync_rendering (window);
10856 * gdk_test_simulate_key:
10857 * @window: a #GdkWindow to simulate a key event for
10858 * @x: x coordinate within @window for the key event
10859 * @y: y coordinate within @window for the key event
10860 * @keyval: A GDK keyboard value
10861 * @modifiers: Keyboard modifiers the event is setup with
10862 * @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
10864 * This function is intended to be used in GTK+ test programs.
10865 * If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
10866 * the given (@x,@y) coordinates within @window and simulate a
10867 * key press or release event.
10869 * When the mouse pointer is warped to the target location, use
10870 * of this function outside of test programs that run in their
10871 * own virtual windowing system (e.g. Xvfb) is not recommended.
10872 * If (@x,@y) are passed as (-1,-1), the mouse pointer will not
10873 * be warped and @window origin will be used as mouse pointer
10874 * location for the event.
10876 * Also, gdk_test_simulate_key() is a fairly low level function,
10877 * for most testing purposes, gtk_test_widget_send_key() is the
10878 * right function to call which will generate a key press event
10879 * followed by its accompanying key release event.
10881 * Returns: whether all actions necessary for a key event simulation
10882 * were carried out successfully
10887 gdk_test_simulate_key (GdkWindow *window,
10891 GdkModifierType modifiers,
10892 GdkEventType key_pressrelease)
10894 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10895 ->simulate_key (window, x, y, keyval, modifiers, key_pressrelease);
10899 * gdk_test_simulate_button:
10900 * @window: a #GdkWindow to simulate a button event for
10901 * @x: x coordinate within @window for the button event
10902 * @y: y coordinate within @window for the button event
10903 * @button: Number of the pointer button for the event, usually 1, 2 or 3
10904 * @modifiers: Keyboard modifiers the event is setup with
10905 * @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
10907 * This function is intended to be used in GTK+ test programs.
10908 * It will warp the mouse pointer to the given (@x,@y) coordinates
10909 * within @window and simulate a button press or release event.
10910 * Because the mouse pointer needs to be warped to the target
10911 * location, use of this function outside of test programs that
10912 * run in their own virtual windowing system (e.g. Xvfb) is not
10915 * Also, gdk_test_simulate_button() is a fairly low level function,
10916 * for most testing purposes, gtk_test_widget_click() is the right
10917 * function to call which will generate a button press event followed
10918 * by its accompanying button release event.
10920 * Returns: whether all actions necessary for a button event simulation
10921 * were carried out successfully
10926 gdk_test_simulate_button (GdkWindow *window,
10929 guint button, /*1..3*/
10930 GdkModifierType modifiers,
10931 GdkEventType button_pressrelease)
10933 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
10934 ->simulate_button (window, x, y, button, modifiers, button_pressrelease);
10938 * gdk_property_get:
10939 * @window: a #GdkWindow
10940 * @property: the property to retrieve
10941 * @type: the desired property type, or %GDK_NONE, if any type of data
10942 * is acceptable. If this does not match the actual
10943 * type, then @actual_format and @actual_length will
10944 * be filled in, a warning will be printed to stderr
10945 * and no data will be returned.
10946 * @offset: the offset into the property at which to begin
10947 * retrieving data, in 4 byte units.
10948 * @length: the length of the data to retrieve in bytes. Data is
10949 * considered to be retrieved in 4 byte chunks, so @length
10950 * will be rounded up to the next highest 4 byte boundary
10951 * (so be careful not to pass a value that might overflow
10952 * when rounded up).
10953 * @pdelete: if %TRUE, delete the property after retrieving the
10955 * @actual_property_type: (out) (transfer none): location to store the
10956 * actual type of the property.
10957 * @actual_format: (out): location to store the actual return format of the
10958 * data; either 8, 16 or 32 bits.
10959 * @actual_length: location to store the length of the retrieved data, in
10960 * bytes. Data returned in the 32 bit format is stored
10961 * in a long variable, so the actual number of 32 bit
10962 * elements should be be calculated via
10963 * @actual_length / sizeof(glong) to ensure portability to
10965 * @data: (out) (array length=actual_length) (transfer full): location
10966 * to store a pointer to the data. The retrieved data should be
10967 * freed with g_free() when you are finished using it.
10969 * Retrieves a portion of the contents of a property. If the
10970 * property does not exist, then the function returns %FALSE,
10971 * and %GDK_NONE will be stored in @actual_property_type.
10975 * The XGetWindowProperty() function that gdk_property_get()
10976 * uses has a very confusing and complicated set of semantics.
10977 * Unfortunately, gdk_property_get() makes the situation
10978 * worse instead of better (the semantics should be considered
10979 * undefined), and also prints warnings to stderr in cases where it
10980 * should return a useful error to the program. You are advised to use
10981 * XGetWindowProperty() directly until a replacement function for
10982 * gdk_property_get()
10987 * Returns: %TRUE if data was successfully received and stored
10988 * in @data, otherwise %FALSE.
10991 gdk_property_get (GdkWindow *window,
10997 GdkAtom *actual_property_type,
10998 gint *actual_format_type,
10999 gint *actual_length,
11002 return GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11003 ->get_property (window, property, type, offset, length, pdelete,
11004 actual_property_type, actual_format_type,
11005 actual_length, data);
11009 * gdk_property_change: (skip)
11010 * @window: a #GdkWindow
11011 * @property: the property to change
11012 * @type: the new type for the property. If @mode is
11013 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11014 * must match the existing type or an error will occur.
11015 * @format: the new format for the property. If @mode is
11016 * %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this
11017 * must match the existing format or an error will occur.
11018 * @mode: a value describing how the new data is to be combined
11019 * with the current data.
11020 * @data: the data (a <literal>guchar *</literal>
11021 * <literal>gushort *</literal>, or <literal>gulong *</literal>,
11022 * depending on @format), cast to a <literal>guchar *</literal>.
11023 * @nelements: the number of elements of size determined by the format,
11024 * contained in @data.
11026 * Changes the contents of a property on a window.
11029 gdk_property_change (GdkWindow *window,
11034 const guchar *data,
11037 GDK_WINDOW_IMPL_GET_CLASS (window->impl)
11038 ->change_property (window, property, type, format, mode, data, nelements);
11042 * gdk_property_delete:
11043 * @window: a #GdkWindow
11044 * @property: the property to delete
11046 * Deletes a property from a window.
11049 gdk_property_delete (GdkWindow *window,
11052 GDK_WINDOW_IMPL_GET_CLASS (window->impl)->delete_property (window, property);