1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-2005. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
30 #include "gdkwindow.h"
31 #include "gdkinternals.h"
32 #include "gdkwindowimpl.h"
33 #include "gdkpixmap.h"
34 #include "gdkdrawable.h"
36 #include "gdkscreen.h"
39 #include "gdkcursor.h"
44 * Offscreen windows can't be the child of a foreign window,
45 * nor contain foreign windows
46 * GDK_POINTER_MOTION_HINT_MASK isn't effective
49 typedef struct _GdkOffscreenWindow GdkOffscreenWindow;
50 typedef struct _GdkOffscreenWindowClass GdkOffscreenWindowClass;
52 struct _GdkOffscreenWindow
54 GdkDrawable parent_instance;
58 GdkColormap *colormap;
65 struct _GdkOffscreenWindowClass
67 GdkDrawableClass parent_class;
70 #define GDK_TYPE_OFFSCREEN_WINDOW (gdk_offscreen_window_get_type())
71 #define GDK_OFFSCREEN_WINDOW(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_OFFSCREEN_WINDOW, GdkOffscreenWindow))
72 #define GDK_IS_OFFSCREEN_WINDOW(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_OFFSCREEN_WINDOW))
73 #define GDK_OFFSCREEN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_OFFSCREEN_WINDOW, GdkOffscreenWindowClass))
74 #define GDK_IS_OFFSCREEN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_OFFSCREEN_WINDOW))
75 #define GDK_OFFSCREEN_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_OFFSCREEN_WINDOW, GdkOffscreenWindowClass))
77 static void gdk_offscreen_window_impl_iface_init (GdkWindowImplIface *iface);
78 static void gdk_offscreen_window_hide (GdkWindow *window);
80 G_DEFINE_TYPE_WITH_CODE (GdkOffscreenWindow,
83 G_IMPLEMENT_INTERFACE (GDK_TYPE_WINDOW_IMPL,
84 gdk_offscreen_window_impl_iface_init));
88 gdk_offscreen_window_finalize (GObject *object)
90 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (object);
92 if (offscreen->cursor)
93 gdk_cursor_unref (offscreen->cursor);
95 offscreen->cursor = NULL;
97 g_object_unref (offscreen->pixmap);
99 G_OBJECT_CLASS (gdk_offscreen_window_parent_class)->finalize (object);
103 gdk_offscreen_window_init (GdkOffscreenWindow *window)
108 gdk_offscreen_window_destroy (GdkWindow *window,
110 gboolean foreign_destroy)
112 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
113 GdkOffscreenWindow *offscreen;
115 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
117 gdk_offscreen_window_set_embedder (window, NULL);
120 gdk_offscreen_window_hide (window);
122 g_object_unref (offscreen->colormap);
123 offscreen->colormap = NULL;
127 is_parent_of (GdkWindow *parent,
138 w = gdk_window_get_parent (w);
145 gdk_offscreen_window_create_gc (GdkDrawable *drawable,
147 GdkGCValuesMask values_mask)
149 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
151 return gdk_gc_new_with_values (offscreen->pixmap, values, values_mask);
155 gdk_offscreen_window_copy_to_image (GdkDrawable *drawable,
164 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
166 return gdk_drawable_copy_to_image (offscreen->pixmap,
174 static cairo_surface_t *
175 gdk_offscreen_window_ref_cairo_surface (GdkDrawable *drawable)
177 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
179 return _gdk_drawable_ref_cairo_surface (offscreen->pixmap);
183 gdk_offscreen_window_get_colormap (GdkDrawable *drawable)
185 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
187 return offscreen->colormap;
191 gdk_offscreen_window_set_colormap (GdkDrawable *drawable,
192 GdkColormap*colormap)
194 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
196 if (colormap && GDK_WINDOW_DESTROYED (offscreen->wrapper))
199 if (offscreen->colormap == colormap)
202 if (offscreen->colormap)
203 g_object_unref (offscreen->colormap);
205 offscreen->colormap = colormap;
206 if (offscreen->colormap)
207 g_object_ref (offscreen->colormap);
212 gdk_offscreen_window_get_depth (GdkDrawable *drawable)
214 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
216 return gdk_drawable_get_depth (offscreen->wrapper);
220 gdk_offscreen_window_get_source_drawable (GdkDrawable *drawable)
222 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
224 return _gdk_drawable_get_source_drawable (offscreen->pixmap);
228 gdk_offscreen_window_get_composite_drawable (GdkDrawable *drawable,
233 gint *composite_x_offset,
234 gint *composite_y_offset)
236 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
238 return g_object_ref (offscreen->pixmap);
242 gdk_offscreen_window_get_screen (GdkDrawable *drawable)
244 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
246 return offscreen->screen;
250 gdk_offscreen_window_get_visual (GdkDrawable *drawable)
252 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
254 return gdk_drawable_get_visual (offscreen->wrapper);
258 add_damage (GdkOffscreenWindow *offscreen,
264 cairo_region_t *damage;
273 /* This should really take into account line width, line
274 * joins (and miter) and line caps. But these are hard
275 * to compute, rarely used and generally a pain. And in
276 * the end a snug damage rectangle is not that important
277 * as multiple damages are generally created anyway.
279 * So, we just add some padding around the rect.
280 * We use a padding of 3 pixels, plus an extra row
281 * below and on the right for the normal line size. I.E.
282 * line from (0,0) to (2,0) gets h=0 but is really
283 * at least one pixel tall.
291 damage = cairo_region_create_rectangle (&rect);
292 _gdk_window_add_damage (offscreen->wrapper, damage);
293 cairo_region_destroy (damage);
297 get_real_drawable (GdkOffscreenWindow *offscreen)
299 GdkPixmapObject *pixmap;
300 pixmap = (GdkPixmapObject *) offscreen->pixmap;
301 return GDK_DRAWABLE (pixmap->impl);
305 gdk_offscreen_window_draw_drawable (GdkDrawable *drawable,
314 GdkDrawable *original_src)
316 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
317 GdkDrawable *real_drawable = get_real_drawable (offscreen);
319 gdk_draw_drawable (real_drawable, gc,
324 add_damage (offscreen, xdest, ydest, width, height, FALSE);
328 gdk_offscreen_window_draw_rectangle (GdkDrawable *drawable,
336 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
337 GdkDrawable *real_drawable = get_real_drawable (offscreen);
339 gdk_draw_rectangle (real_drawable,
340 gc, filled, x, y, width, height);
342 add_damage (offscreen, x, y, width, height, !filled);
347 gdk_offscreen_window_draw_arc (GdkDrawable *drawable,
357 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
358 GdkDrawable *real_drawable = get_real_drawable (offscreen);
360 gdk_draw_arc (real_drawable,
369 add_damage (offscreen, x, y, width, height, !filled);
373 gdk_offscreen_window_draw_polygon (GdkDrawable *drawable,
379 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
380 GdkDrawable *real_drawable = get_real_drawable (offscreen);
382 gdk_draw_polygon (real_drawable,
390 int min_x, min_y, max_x, max_y, i;
392 min_x = max_x = points[0].x;
393 min_y = max_y = points[0].y;
395 for (i = 1; i < npoints; i++)
397 min_x = MIN (min_x, points[i].x);
398 max_x = MAX (max_x, points[i].x);
399 min_y = MIN (min_y, points[i].y);
400 max_y = MAX (max_y, points[i].y);
403 add_damage (offscreen, min_x, min_y,
405 max_y - min_y, !filled);
410 gdk_offscreen_window_draw_points (GdkDrawable *drawable,
415 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
416 GdkDrawable *real_drawable = get_real_drawable (offscreen);
418 gdk_draw_points (real_drawable,
426 int min_x, min_y, max_x, max_y, i;
428 min_x = max_x = points[0].x;
429 min_y = max_y = points[0].y;
431 for (i = 1; i < npoints; i++)
433 min_x = MIN (min_x, points[i].x);
434 max_x = MAX (max_x, points[i].x);
435 min_y = MIN (min_y, points[i].y);
436 max_y = MAX (max_y, points[i].y);
439 add_damage (offscreen, min_x, min_y,
447 gdk_offscreen_window_draw_segments (GdkDrawable *drawable,
452 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
453 GdkDrawable *real_drawable = get_real_drawable (offscreen);
455 gdk_draw_segments (real_drawable,
462 int min_x, min_y, max_x, max_y, i;
464 min_x = max_x = segs[0].x1;
465 min_y = max_y = segs[0].y1;
467 for (i = 0; i < nsegs; i++)
469 min_x = MIN (min_x, segs[i].x1);
470 max_x = MAX (max_x, segs[i].x1);
471 min_x = MIN (min_x, segs[i].x2);
472 max_x = MAX (max_x, segs[i].x2);
473 min_y = MIN (min_y, segs[i].y1);
474 max_y = MAX (max_y, segs[i].y1);
475 min_y = MIN (min_y, segs[i].y2);
476 max_y = MAX (max_y, segs[i].y2);
479 add_damage (offscreen, min_x, min_y,
481 max_y - min_y, TRUE);
487 gdk_offscreen_window_draw_lines (GdkDrawable *drawable,
492 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
493 GdkDrawable *real_drawable = get_real_drawable (offscreen);
494 GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);
496 gdk_draw_lines (real_drawable,
501 /* Hard to compute the minimal size, as we don't know the line
502 width, and since joins are hard to calculate.
503 Its not that often used anyway, damage it all */
504 add_damage (offscreen, 0, 0, private->width, private->height, TRUE);
508 gdk_offscreen_window_draw_image (GdkDrawable *drawable,
518 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
519 GdkDrawable *real_drawable = get_real_drawable (offscreen);
521 gdk_draw_image (real_drawable,
531 add_damage (offscreen, xdest, ydest, width, height, FALSE);
536 gdk_offscreen_window_draw_pixbuf (GdkDrawable *drawable,
549 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
550 GdkDrawable *real_drawable = get_real_drawable (offscreen);
552 gdk_draw_pixbuf (real_drawable,
565 add_damage (offscreen, dest_x, dest_y, width, height, FALSE);
570 _gdk_offscreen_window_new (GdkWindow *window,
573 GdkWindowAttr *attributes,
574 gint attributes_mask)
576 GdkWindowObject *private;
577 GdkOffscreenWindow *offscreen;
579 g_return_if_fail (attributes != NULL);
581 if (attributes->wclass != GDK_INPUT_OUTPUT)
582 return; /* Can't support input only offscreens */
584 private = (GdkWindowObject *)window;
586 if (private->parent != NULL && GDK_WINDOW_DESTROYED (private->parent))
589 private->impl = g_object_new (GDK_TYPE_OFFSCREEN_WINDOW, NULL);
590 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
591 offscreen->wrapper = window;
593 offscreen->screen = screen;
595 if (attributes_mask & GDK_WA_COLORMAP)
596 offscreen->colormap = g_object_ref (attributes->colormap);
599 if (gdk_screen_get_system_visual (screen) == visual)
601 offscreen->colormap = gdk_screen_get_system_colormap (screen);
602 g_object_ref (offscreen->colormap);
605 offscreen->colormap = gdk_colormap_new (visual, FALSE);
608 offscreen->pixmap = gdk_pixmap_new ((GdkDrawable *)private->parent,
612 gdk_drawable_set_colormap (offscreen->pixmap, offscreen->colormap);
616 gdk_offscreen_window_reparent (GdkWindow *window,
617 GdkWindow *new_parent,
621 GdkWindowObject *private = (GdkWindowObject *)window;
622 GdkWindowObject *new_parent_private = (GdkWindowObject *)new_parent;
623 GdkWindowObject *old_parent;
628 /* No input-output children of input-only windows */
629 if (new_parent_private->input_only && !private->input_only)
632 /* Don't create loops in hierarchy */
633 if (is_parent_of (window, new_parent))
637 was_mapped = GDK_WINDOW_IS_MAPPED (window);
639 gdk_window_hide (window);
642 private->parent->children = g_list_remove (private->parent->children, window);
644 old_parent = private->parent;
645 private->parent = new_parent_private;
649 if (new_parent_private)
650 private->parent->children = g_list_prepend (private->parent->children, window);
652 _gdk_synthesize_crossing_events_for_geometry_change (window);
654 _gdk_synthesize_crossing_events_for_geometry_change (GDK_WINDOW (old_parent));
660 from_embedder (GdkWindow *window,
661 double embedder_x, double embedder_y,
662 double *offscreen_x, double *offscreen_y)
664 GdkWindowObject *private;
666 private = (GdkWindowObject *)window;
668 g_signal_emit_by_name (private->impl_window,
670 embedder_x, embedder_y,
671 offscreen_x, offscreen_y,
676 to_embedder (GdkWindow *window,
677 double offscreen_x, double offscreen_y,
678 double *embedder_x, double *embedder_y)
680 GdkWindowObject *private;
682 private = (GdkWindowObject *)window;
684 g_signal_emit_by_name (private->impl_window,
686 offscreen_x, offscreen_y,
687 embedder_x, embedder_y,
692 gdk_offscreen_window_get_root_coords (GdkWindow *window,
698 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
699 GdkOffscreenWindow *offscreen;
705 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
706 if (offscreen->embedder)
712 tmpx = floor (dx + 0.5);
713 tmpy = floor (dy + 0.5);
714 gdk_window_get_root_coords (offscreen->embedder,
729 gdk_offscreen_window_get_deskrelative_origin (GdkWindow *window,
733 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
734 GdkOffscreenWindow *offscreen;
740 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
741 if (offscreen->embedder)
744 gdk_window_get_deskrelative_origin (offscreen->embedder,
750 tmpx = floor (tmpx + dx + 0.5);
751 tmpy = floor (tmpy + dy + 0.5);
764 gdk_offscreen_window_get_device_state (GdkWindow *window,
768 GdkModifierType *mask)
770 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
771 GdkOffscreenWindow *offscreen;
774 GdkModifierType tmpmask;
780 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
781 if (offscreen->embedder != NULL)
783 gdk_window_get_device_position (offscreen->embedder, device, &tmpx, &tmpy, &tmpmask);
784 from_embedder (window,
787 tmpx = floor (dtmpx + 0.5);
788 tmpy = floor (dtmpy + 0.5);
801 * gdk_offscreen_window_get_pixmap:
802 * @window: a #GdkWindow
804 * Gets the offscreen pixmap that an offscreen window renders into.
805 * If you need to keep this around over window resizes, you need to
806 * add a reference to it.
808 * Returns: The offscreen pixmap, or %NULL if not offscreen
813 gdk_offscreen_window_get_pixmap (GdkWindow *window)
815 GdkWindowObject *private = (GdkWindowObject *)window;
816 GdkOffscreenWindow *offscreen;
818 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
820 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
823 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
824 return offscreen->pixmap;
828 gdk_offscreen_window_raise (GdkWindow *window)
830 /* gdk_window_raise already changed the stacking order */
831 _gdk_synthesize_crossing_events_for_geometry_change (window);
835 gdk_offscreen_window_lower (GdkWindow *window)
837 /* gdk_window_lower already changed the stacking order */
838 _gdk_synthesize_crossing_events_for_geometry_change (window);
842 gdk_offscreen_window_move_resize_internal (GdkWindow *window,
847 gboolean send_expose_events)
849 GdkWindowObject *private = (GdkWindowObject *)window;
850 GdkOffscreenWindow *offscreen;
853 GdkPixmap *old_pixmap;
855 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
862 if (private->destroyed)
867 dw = width - private->width;
868 dh = height - private->height;
873 if (private->width != width ||
874 private->height != height)
876 private->width = width;
877 private->height = height;
879 old_pixmap = offscreen->pixmap;
880 offscreen->pixmap = gdk_pixmap_new (GDK_DRAWABLE (old_pixmap),
885 gc = _gdk_drawable_get_scratch_gc (offscreen->pixmap, FALSE);
886 gdk_draw_drawable (offscreen->pixmap,
891 g_object_unref (old_pixmap);
894 if (GDK_WINDOW_IS_MAPPED (private))
896 // TODO: Only invalidate new area, i.e. for larger windows
897 gdk_window_invalidate_rect (window, NULL, TRUE);
898 _gdk_synthesize_crossing_events_for_geometry_change (window);
903 gdk_offscreen_window_move_resize (GdkWindow *window,
910 GdkWindowObject *private = (GdkWindowObject *)window;
911 GdkOffscreenWindow *offscreen;
913 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
922 width = private->width;
925 height = private->height;
927 gdk_offscreen_window_move_resize_internal (window, x, y,
933 gdk_offscreen_window_show (GdkWindow *window,
934 gboolean already_mapped)
936 GdkWindowObject *private = (GdkWindowObject *)window;
938 gdk_window_clear_area_e (window, 0, 0,
939 private->width, private->height);
944 gdk_offscreen_window_hide (GdkWindow *window)
946 GdkWindowObject *private;
947 GdkOffscreenWindow *offscreen;
950 g_return_if_fail (window != NULL);
952 private = (GdkWindowObject*) window;
953 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
955 /* May need to break grabs on children */
956 display = gdk_drawable_get_display (window);
958 /* TODO: This needs updating to the new grab world */
960 if (display->pointer_grab.window != NULL)
962 if (is_parent_of (window, display->pointer_grab.window))
964 /* Call this ourselves, even though gdk_display_pointer_ungrab
965 does so too, since we want to pass implicit == TRUE so the
966 broken grab event is generated */
967 _gdk_display_unset_has_pointer_grab (display,
971 gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
978 gdk_offscreen_window_withdraw (GdkWindow *window)
983 gdk_offscreen_window_get_events (GdkWindow *window)
989 gdk_offscreen_window_set_events (GdkWindow *window,
990 GdkEventMask event_mask)
995 gdk_offscreen_window_set_background (GdkWindow *window,
996 const GdkColor *color)
998 GdkWindowObject *private = (GdkWindowObject *)window;
999 GdkColormap *colormap = gdk_drawable_get_colormap (window);
1001 private->bg_color = *color;
1002 gdk_colormap_query_color (colormap, private->bg_color.pixel, &private->bg_color);
1004 if (private->bg_pixmap &&
1005 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1006 private->bg_pixmap != GDK_NO_BG)
1007 g_object_unref (private->bg_pixmap);
1009 private->bg_pixmap = NULL;
1013 gdk_offscreen_window_set_back_pixmap (GdkWindow *window,
1016 GdkWindowObject *private = (GdkWindowObject *)window;
1019 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1020 private->bg_pixmap != GDK_NO_BG &&
1021 !gdk_drawable_get_colormap (pixmap))
1023 g_warning ("gdk_window_set_back_pixmap(): pixmap must have a colormap");
1027 if (private->bg_pixmap &&
1028 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1029 private->bg_pixmap != GDK_NO_BG)
1030 g_object_unref (private->bg_pixmap);
1032 private->bg_pixmap = pixmap;
1035 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1036 private->bg_pixmap != GDK_NO_BG)
1037 g_object_ref (pixmap);
1041 gdk_offscreen_window_shape_combine_region (GdkWindow *window,
1042 const cairo_region_t *shape_region,
1049 gdk_offscreen_window_input_shape_combine_region (GdkWindow *window,
1050 const cairo_region_t *shape_region,
1057 gdk_offscreen_window_set_static_gravities (GdkWindow *window,
1058 gboolean use_static)
1064 gdk_offscreen_window_get_geometry (GdkWindow *window,
1071 GdkWindowObject *private = (GdkWindowObject *)window;
1073 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1075 if (!GDK_WINDOW_DESTROYED (window))
1082 *width = private->width;
1084 *height = private->height;
1086 *depth = private->depth;
1091 gdk_offscreen_window_queue_antiexpose (GdkWindow *window,
1092 cairo_region_t *area)
1098 gdk_offscreen_window_queue_translation (GdkWindow *window,
1100 cairo_region_t *area,
1107 * gdk_offscreen_window_set_embedder:
1108 * @window: a #GdkWindow
1109 * @embedder: the #GdkWindow that @window gets embedded in
1111 * Sets @window to be embedded in @embedder.
1113 * To fully embed an offscreen window, in addition to calling this
1114 * function, it is also necessary to handle the #GdkWindow::pick-embedded-child
1115 * signal on the @embedder and the #GdkWindow::to-embedder and
1116 * #GdkWindow::from-embedder signals on @window.
1121 gdk_offscreen_window_set_embedder (GdkWindow *window,
1122 GdkWindow *embedder)
1124 GdkWindowObject *private = (GdkWindowObject *)window;
1125 GdkOffscreenWindow *offscreen;
1127 g_return_if_fail (GDK_IS_WINDOW (window));
1129 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
1132 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1136 g_object_ref (embedder);
1137 GDK_WINDOW_OBJECT (embedder)->num_offscreen_children++;
1140 if (offscreen->embedder)
1142 g_object_unref (offscreen->embedder);
1143 GDK_WINDOW_OBJECT (offscreen->embedder)->num_offscreen_children--;
1146 offscreen->embedder = embedder;
1150 * gdk_offscreen_window_get_embedder:
1151 * @window: a #GdkWindow
1153 * Gets the window that @window is embedded in.
1155 * Returns: the embedding #GdkWindow, or %NULL if @window is not an
1156 * embedded offscreen window
1161 gdk_offscreen_window_get_embedder (GdkWindow *window)
1163 GdkWindowObject *private = (GdkWindowObject *)window;
1164 GdkOffscreenWindow *offscreen;
1166 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
1168 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
1171 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1173 return offscreen->embedder;
1177 gdk_offscreen_window_class_init (GdkOffscreenWindowClass *klass)
1179 GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
1180 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1182 object_class->finalize = gdk_offscreen_window_finalize;
1184 drawable_class->create_gc = gdk_offscreen_window_create_gc;
1185 drawable_class->_copy_to_image = gdk_offscreen_window_copy_to_image;
1186 drawable_class->ref_cairo_surface = gdk_offscreen_window_ref_cairo_surface;
1187 drawable_class->set_colormap = gdk_offscreen_window_set_colormap;
1188 drawable_class->get_colormap = gdk_offscreen_window_get_colormap;
1189 drawable_class->get_depth = gdk_offscreen_window_get_depth;
1190 drawable_class->get_screen = gdk_offscreen_window_get_screen;
1191 drawable_class->get_visual = gdk_offscreen_window_get_visual;
1192 drawable_class->get_source_drawable = gdk_offscreen_window_get_source_drawable;
1193 drawable_class->get_composite_drawable = gdk_offscreen_window_get_composite_drawable;
1195 drawable_class->draw_rectangle = gdk_offscreen_window_draw_rectangle;
1196 drawable_class->draw_arc = gdk_offscreen_window_draw_arc;
1197 drawable_class->draw_polygon = gdk_offscreen_window_draw_polygon;
1198 drawable_class->draw_drawable_with_src = gdk_offscreen_window_draw_drawable;
1199 drawable_class->draw_points = gdk_offscreen_window_draw_points;
1200 drawable_class->draw_segments = gdk_offscreen_window_draw_segments;
1201 drawable_class->draw_lines = gdk_offscreen_window_draw_lines;
1202 drawable_class->draw_image = gdk_offscreen_window_draw_image;
1203 drawable_class->draw_pixbuf = gdk_offscreen_window_draw_pixbuf;
1207 gdk_offscreen_window_impl_iface_init (GdkWindowImplIface *iface)
1209 iface->show = gdk_offscreen_window_show;
1210 iface->hide = gdk_offscreen_window_hide;
1211 iface->withdraw = gdk_offscreen_window_withdraw;
1212 iface->raise = gdk_offscreen_window_raise;
1213 iface->lower = gdk_offscreen_window_lower;
1214 iface->move_resize = gdk_offscreen_window_move_resize;
1215 iface->set_background = gdk_offscreen_window_set_background;
1216 iface->set_back_pixmap = gdk_offscreen_window_set_back_pixmap;
1217 iface->get_events = gdk_offscreen_window_get_events;
1218 iface->set_events = gdk_offscreen_window_set_events;
1219 iface->reparent = gdk_offscreen_window_reparent;
1220 iface->get_geometry = gdk_offscreen_window_get_geometry;
1221 iface->shape_combine_region = gdk_offscreen_window_shape_combine_region;
1222 iface->input_shape_combine_region = gdk_offscreen_window_input_shape_combine_region;
1223 iface->set_static_gravities = gdk_offscreen_window_set_static_gravities;
1224 iface->queue_antiexpose = gdk_offscreen_window_queue_antiexpose;
1225 iface->queue_translation = gdk_offscreen_window_queue_translation;
1226 iface->get_root_coords = gdk_offscreen_window_get_root_coords;
1227 iface->get_deskrelative_origin = gdk_offscreen_window_get_deskrelative_origin;
1228 iface->get_device_state = gdk_offscreen_window_get_device_state;
1229 iface->destroy = gdk_offscreen_window_destroy;