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 gdk_pixmap_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,
270 damage = gdk_region_rectangle (&rect);
271 _gdk_window_add_damage (offscreen->wrapper, damage);
272 gdk_region_destroy (damage);
276 get_real_drawable (GdkOffscreenWindow *offscreen)
278 GdkPixmapObject *pixmap;
279 pixmap = (GdkPixmapObject *) offscreen->pixmap;
280 return GDK_DRAWABLE (pixmap->impl);
284 gdk_offscreen_window_draw_drawable (GdkDrawable *drawable,
293 GdkDrawable *original_src)
295 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
296 GdkDrawable *real_drawable = get_real_drawable (offscreen);
298 gdk_draw_drawable (real_drawable, gc,
303 add_damage (offscreen, xdest, ydest, width, height);
307 gdk_offscreen_window_draw_rectangle (GdkDrawable *drawable,
315 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
316 GdkDrawable *real_drawable = get_real_drawable (offscreen);
318 gdk_draw_rectangle (real_drawable,
319 gc, filled, x, y, width, height);
321 add_damage (offscreen, x, y, width, height);
326 gdk_offscreen_window_draw_arc (GdkDrawable *drawable,
336 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
337 GdkDrawable *real_drawable = get_real_drawable (offscreen);
339 gdk_draw_arc (real_drawable,
348 add_damage (offscreen, x, y, width, height);
352 gdk_offscreen_window_draw_polygon (GdkDrawable *drawable,
358 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
359 GdkDrawable *real_drawable = get_real_drawable (offscreen);
361 gdk_draw_polygon (real_drawable,
369 int min_x, min_y, max_x, max_y, i;
371 min_x = max_x = points[0].x;
372 min_y = max_y = points[0].y;
374 for (i = 1; i < npoints; i++)
376 min_x = MIN (min_x, points[i].x);
377 max_x = MAX (max_x, points[i].x);
378 min_y = MIN (min_y, points[i].y);
379 max_y = MAX (max_y, points[i].y);
382 add_damage (offscreen, min_x, min_y,
389 gdk_offscreen_window_draw_text (GdkDrawable *drawable,
397 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
398 GdkDrawable *real_drawable = get_real_drawable (offscreen);
399 GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);
401 gdk_draw_text (real_drawable,
409 /* Hard to compute the minimal size, not that often used anyway. */
410 add_damage (offscreen, 0, 0, private->width, private->height);
414 gdk_offscreen_window_draw_text_wc (GdkDrawable *drawable,
419 const GdkWChar *text,
422 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
423 GdkDrawable *real_drawable = get_real_drawable (offscreen);
424 GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);
426 gdk_draw_text_wc (real_drawable,
434 /* Hard to compute the minimal size, not that often used anyway. */
435 add_damage (offscreen, 0, 0, private->width, private->height);
439 gdk_offscreen_window_draw_points (GdkDrawable *drawable,
444 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
445 GdkDrawable *real_drawable = get_real_drawable (offscreen);
447 gdk_draw_points (real_drawable,
455 int min_x, min_y, max_x, max_y, i;
457 min_x = max_x = points[0].x;
458 min_y = max_y = points[0].y;
460 for (i = 1; i < npoints; i++)
462 min_x = MIN (min_x, points[i].x);
463 max_x = MAX (max_x, points[i].x);
464 min_y = MIN (min_y, points[i].y);
465 max_y = MAX (max_y, points[i].y);
468 add_damage (offscreen, min_x, min_y,
475 gdk_offscreen_window_draw_segments (GdkDrawable *drawable,
480 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
481 GdkDrawable *real_drawable = get_real_drawable (offscreen);
483 gdk_draw_segments (real_drawable,
490 int min_x, min_y, max_x, max_y, i;
492 min_x = max_x = segs[0].x1;
493 min_y = max_y = segs[0].y1;
495 for (i = 1; i < nsegs; i++)
497 min_x = MIN (min_x, segs[i].x1);
498 max_x = MAX (max_x, segs[i].x1);
499 min_x = MIN (min_x, segs[i].x2);
500 max_x = MAX (max_x, segs[i].x2);
501 min_y = MIN (min_y, segs[i].y1);
502 max_y = MAX (max_y, segs[i].y1);
503 min_y = MIN (min_y, segs[i].y2);
504 max_y = MAX (max_y, segs[i].y2);
507 add_damage (offscreen, min_x, min_y,
515 gdk_offscreen_window_draw_lines (GdkDrawable *drawable,
520 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
521 GdkDrawable *real_drawable = get_real_drawable (offscreen);
522 GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);
524 gdk_draw_lines (real_drawable,
529 /* Hard to compute the minimal size, as we don't know the line
530 width, and since joins are hard to calculate.
531 Its not that often used anyway, damage it all */
532 add_damage (offscreen, 0, 0, private->width, private->height);
536 gdk_offscreen_window_draw_image (GdkDrawable *drawable,
546 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
547 GdkDrawable *real_drawable = get_real_drawable (offscreen);
549 gdk_draw_image (real_drawable,
559 add_damage (offscreen, xdest, ydest, width, height);
564 gdk_offscreen_window_draw_pixbuf (GdkDrawable *drawable,
577 GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
578 GdkDrawable *real_drawable = get_real_drawable (offscreen);
580 gdk_draw_pixbuf (real_drawable,
593 add_damage (offscreen, dest_x, dest_y, width, height);
598 _gdk_offscreen_window_new (GdkWindow *window,
601 GdkWindowAttr *attributes,
602 gint attributes_mask)
604 GdkWindowObject *parent_private;
605 GdkWindowObject *private;
606 GdkOffscreenWindow *offscreen;
608 g_return_if_fail (attributes != NULL);
610 if (attributes->wclass != GDK_INPUT_OUTPUT)
611 return; /* Can't support input only offscreens */
613 private = (GdkWindowObject *)window;
615 if (private->parent != NULL && GDK_WINDOW_DESTROYED (private->parent))
618 parent_private = (GdkWindowObject*) private->parent;
619 private->impl = g_object_new (GDK_TYPE_OFFSCREEN_WINDOW, NULL);
620 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
621 offscreen->wrapper = window;
623 offscreen->screen = screen;
625 if (attributes_mask & GDK_WA_COLORMAP)
626 offscreen->colormap = g_object_ref (attributes->colormap);
629 if (gdk_screen_get_system_visual (screen) == visual)
631 offscreen->colormap = gdk_screen_get_system_colormap (screen);
632 g_object_ref (offscreen->colormap);
635 offscreen->colormap = gdk_colormap_new (visual, FALSE);
638 offscreen->pixmap = gdk_pixmap_new ((GdkDrawable *)private->parent,
645 gdk_offscreen_window_reparent (GdkWindow *window,
646 GdkWindow *new_parent,
650 GdkWindowObject *private = (GdkWindowObject *)window;
651 GdkWindowObject *new_parent_private = (GdkWindowObject *)new_parent;
652 GdkWindowObject *old_parent;
653 GdkOffscreenWindow *offscreen;
658 /* No input-output children of input-only windows */
659 if (new_parent_private->input_only && !private->input_only)
662 /* Don't create loops in hierarchy */
663 if (is_parent_of (window, new_parent))
667 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
669 was_mapped = GDK_WINDOW_IS_MAPPED (window);
671 gdk_window_hide (window);
674 private->parent->children = g_list_remove (private->parent->children, window);
676 old_parent = private->parent;
677 private->parent = new_parent_private;
681 if (new_parent_private)
682 private->parent->children = g_list_prepend (private->parent->children, window);
684 _gdk_synthesize_crossing_events_for_geometry_change (window);
686 _gdk_synthesize_crossing_events_for_geometry_change (GDK_WINDOW (old_parent));
692 from_embedder (GdkWindow *window,
693 double embedder_x, double embedder_y,
694 double *offscreen_x, double *offscreen_y)
696 GdkWindowObject *private;
698 private = (GdkWindowObject *)window;
700 g_signal_emit_by_name (private->impl_window,
702 embedder_x, embedder_y,
703 offscreen_x, offscreen_y,
708 to_embedder (GdkWindow *window,
709 double offscreen_x, double offscreen_y,
710 double *embedder_x, double *embedder_y)
712 GdkWindowObject *private;
714 private = (GdkWindowObject *)window;
716 g_signal_emit_by_name (private->impl_window,
718 offscreen_x, offscreen_y,
719 embedder_x, embedder_y,
724 gdk_offscreen_window_get_root_coords (GdkWindow *window,
730 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
731 GdkOffscreenWindow *offscreen;
737 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
738 if (offscreen->embedder)
744 tmpx = floor (dx + 0.5);
745 tmpy = floor (dy + 0.5);
746 gdk_window_get_root_coords (offscreen->embedder,
761 gdk_offscreen_window_get_deskrelative_origin (GdkWindow *window,
765 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
766 GdkOffscreenWindow *offscreen;
772 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
773 if (offscreen->embedder)
776 gdk_window_get_deskrelative_origin (offscreen->embedder,
782 tmpx = floor (tmpx + dx + 0.5);
783 tmpy = floor (tmpy + dy + 0.5);
796 gdk_offscreen_window_get_pointer (GdkWindow *window,
799 GdkModifierType *mask)
801 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
802 GdkOffscreenWindow *offscreen;
805 GdkModifierType tmpmask;
811 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
812 if (offscreen->embedder != NULL)
814 gdk_window_get_pointer (offscreen->embedder, &tmpx, &tmpy, &tmpmask);
815 from_embedder (window,
818 tmpx = floor (dtmpx + 0.5);
819 tmpy = floor (dtmpy + 0.5);
832 * gdk_offscreen_window_get_pixmap:
833 * @window: a #GdkWindow
835 * Gets the offscreen pixmap that an offscreen window renders into. If
836 * you need to keep this around over window resizes, you need to add a
839 * Returns: The offscreen pixmap, or NULL if not offscreen
842 gdk_offscreen_window_get_pixmap (GdkWindow *window)
844 GdkWindowObject *private = (GdkWindowObject *)window;
845 GdkOffscreenWindow *offscreen;
847 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
849 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
852 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
853 return offscreen->pixmap;
857 gdk_offscreen_window_raise (GdkWindow *window)
859 /* gdk_window_raise already changed the stacking order */
860 _gdk_synthesize_crossing_events_for_geometry_change (window);
864 gdk_offscreen_window_lower (GdkWindow *window)
866 /* gdk_window_lower already changed the stacking order */
867 _gdk_synthesize_crossing_events_for_geometry_change (window);
871 gdk_offscreen_window_move_resize_internal (GdkWindow *window,
876 gboolean send_expose_events)
878 GdkWindowObject *private = (GdkWindowObject *)window;
879 GdkOffscreenWindow *offscreen;
882 GdkPixmap *old_pixmap;
884 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
891 if (private->destroyed)
896 dw = width - private->width;
897 dh = height - private->height;
902 if (private->width != width ||
903 private->height != height)
905 private->width = width;
906 private->height = height;
908 old_pixmap = offscreen->pixmap;
909 offscreen->pixmap = gdk_pixmap_new (GDK_DRAWABLE (old_pixmap),
914 gc = _gdk_drawable_get_scratch_gc (offscreen->pixmap, FALSE);
915 gdk_draw_drawable (offscreen->pixmap,
920 g_object_unref (old_pixmap);
923 if (GDK_WINDOW_IS_MAPPED (private))
925 // TODO: Only invalidate new area, i.e. for larger windows
926 gdk_window_invalidate_rect (window, NULL, TRUE);
927 _gdk_synthesize_crossing_events_for_geometry_change (window);
932 gdk_offscreen_window_move_resize (GdkWindow *window,
939 GdkWindowObject *private = (GdkWindowObject *)window;
940 GdkOffscreenWindow *offscreen;
942 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
951 width = private->width;
954 height = private->height;
956 gdk_offscreen_window_move_resize_internal (window, x, y,
962 gdk_offscreen_window_show (GdkWindow *window,
963 gboolean already_mapped)
965 GdkWindowObject *private = (GdkWindowObject *)window;
967 gdk_window_clear_area_e (window, 0, 0,
968 private->width, private->height);
973 gdk_offscreen_window_hide (GdkWindow *window)
975 GdkWindowObject *private;
976 GdkOffscreenWindow *offscreen;
979 g_return_if_fail (window != NULL);
981 private = (GdkWindowObject*) window;
982 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
984 /* May need to break grabs on children */
985 display = gdk_drawable_get_display (window);
987 /* TODO: This needs updating to the new grab world */
989 if (display->pointer_grab.window != NULL)
991 if (is_parent_of (window, display->pointer_grab.window))
993 /* Call this ourselves, even though gdk_display_pointer_ungrab
994 does so too, since we want to pass implicit == TRUE so the
995 broken grab event is generated */
996 _gdk_display_unset_has_pointer_grab (display,
1000 gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
1007 gdk_offscreen_window_withdraw (GdkWindow *window)
1012 gdk_offscreen_window_get_events (GdkWindow *window)
1018 gdk_offscreen_window_set_events (GdkWindow *window,
1019 GdkEventMask event_mask)
1024 gdk_offscreen_window_set_background (GdkWindow *window,
1025 const GdkColor *color)
1027 GdkWindowObject *private = (GdkWindowObject *)window;
1028 GdkColormap *colormap = gdk_drawable_get_colormap (window);
1030 private->bg_color = *color;
1031 gdk_colormap_query_color (colormap, private->bg_color.pixel, &private->bg_color);
1033 if (private->bg_pixmap &&
1034 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1035 private->bg_pixmap != GDK_NO_BG)
1036 g_object_unref (private->bg_pixmap);
1038 private->bg_pixmap = NULL;
1042 gdk_offscreen_window_set_back_pixmap (GdkWindow *window,
1045 GdkWindowObject *private = (GdkWindowObject *)window;
1048 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1049 private->bg_pixmap != GDK_NO_BG &&
1050 !gdk_drawable_get_colormap (pixmap))
1052 g_warning ("gdk_window_set_back_pixmap(): pixmap must have a colormap");
1056 if (private->bg_pixmap &&
1057 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1058 private->bg_pixmap != GDK_NO_BG)
1059 g_object_unref (private->bg_pixmap);
1061 private->bg_pixmap = pixmap;
1064 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1065 private->bg_pixmap != GDK_NO_BG)
1066 g_object_ref (pixmap);
1070 gdk_offscreen_window_shape_combine_region (GdkWindow *window,
1071 const GdkRegion *shape_region,
1078 gdk_offscreen_window_input_shape_combine_region (GdkWindow *window,
1079 const GdkRegion *shape_region,
1086 gdk_offscreen_window_set_static_gravities (GdkWindow *window,
1087 gboolean use_static)
1093 gdk_offscreen_window_set_cursor (GdkWindow *window,
1096 GdkWindowObject *private = (GdkWindowObject *)window;
1097 GdkOffscreenWindow *offscreen;
1099 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1101 if (offscreen->cursor)
1103 gdk_cursor_unref (offscreen->cursor);
1104 offscreen->cursor = NULL;
1108 offscreen->cursor = gdk_cursor_ref (cursor);
1110 /* TODO: The cursor is never actually used... */
1114 gdk_offscreen_window_get_geometry (GdkWindow *window,
1121 GdkWindowObject *private = (GdkWindowObject *)window;
1122 GdkOffscreenWindow *offscreen;
1124 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1126 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1128 if (!GDK_WINDOW_DESTROYED (window))
1135 *width = private->width;
1137 *height = private->height;
1139 *depth = private->depth;
1144 gdk_offscreen_window_queue_antiexpose (GdkWindow *window,
1151 gdk_offscreen_window_queue_translation (GdkWindow *window,
1159 gdk_offscreen_window_set_embedder (GdkWindow *window,
1160 GdkWindow *embedder)
1162 GdkWindowObject *private = (GdkWindowObject *)window;
1163 GdkOffscreenWindow *offscreen;
1165 g_return_if_fail (GDK_IS_WINDOW (window));
1167 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
1170 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1174 g_object_ref (embedder);
1175 GDK_WINDOW_OBJECT (embedder)->num_offscreen_children++;
1178 if (offscreen->embedder)
1180 g_object_unref (offscreen->embedder);
1181 GDK_WINDOW_OBJECT (offscreen->embedder)->num_offscreen_children--;
1184 offscreen->embedder = embedder;
1188 gdk_offscreen_window_get_embedder (GdkWindow *window)
1190 GdkWindowObject *private = (GdkWindowObject *)window;
1191 GdkOffscreenWindow *offscreen;
1193 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
1195 if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))
1198 offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
1200 return offscreen->embedder;
1204 gdk_offscreen_window_class_init (GdkOffscreenWindowClass *klass)
1206 GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
1207 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1209 object_class->finalize = gdk_offscreen_window_finalize;
1211 drawable_class->create_gc = gdk_offscreen_window_create_gc;
1212 drawable_class->_copy_to_image = gdk_offscreen_window_copy_to_image;
1213 drawable_class->ref_cairo_surface = gdk_offscreen_window_ref_cairo_surface;
1214 drawable_class->set_colormap = gdk_offscreen_window_set_colormap;
1215 drawable_class->get_colormap = gdk_offscreen_window_get_colormap;
1216 drawable_class->get_depth = gdk_offscreen_window_get_depth;
1217 drawable_class->get_screen = gdk_offscreen_window_get_screen;
1218 drawable_class->get_visual = gdk_offscreen_window_get_visual;
1219 drawable_class->get_source_drawable = gdk_offscreen_window_get_source_drawable;
1220 drawable_class->get_composite_drawable = gdk_offscreen_window_get_composite_drawable;
1222 drawable_class->draw_rectangle = gdk_offscreen_window_draw_rectangle;
1223 drawable_class->draw_arc = gdk_offscreen_window_draw_arc;
1224 drawable_class->draw_polygon = gdk_offscreen_window_draw_polygon;
1225 drawable_class->draw_text = gdk_offscreen_window_draw_text;
1226 drawable_class->draw_text_wc = gdk_offscreen_window_draw_text_wc;
1227 drawable_class->draw_drawable = gdk_offscreen_window_draw_drawable;
1228 drawable_class->draw_points = gdk_offscreen_window_draw_points;
1229 drawable_class->draw_segments = gdk_offscreen_window_draw_segments;
1230 drawable_class->draw_lines = gdk_offscreen_window_draw_lines;
1231 drawable_class->draw_image = gdk_offscreen_window_draw_image;
1232 drawable_class->draw_pixbuf = gdk_offscreen_window_draw_pixbuf;
1236 gdk_offscreen_window_impl_iface_init (GdkWindowImplIface *iface)
1238 iface->show = gdk_offscreen_window_show;
1239 iface->hide = gdk_offscreen_window_hide;
1240 iface->withdraw = gdk_offscreen_window_withdraw;
1241 iface->raise = gdk_offscreen_window_raise;
1242 iface->lower = gdk_offscreen_window_lower;
1243 iface->move_resize = gdk_offscreen_window_move_resize;
1244 iface->set_background = gdk_offscreen_window_set_background;
1245 iface->set_back_pixmap = gdk_offscreen_window_set_back_pixmap;
1246 iface->get_events = gdk_offscreen_window_get_events;
1247 iface->set_events = gdk_offscreen_window_set_events;
1248 iface->reparent = gdk_offscreen_window_reparent;
1249 iface->set_cursor = gdk_offscreen_window_set_cursor;
1250 iface->get_geometry = gdk_offscreen_window_get_geometry;
1251 iface->shape_combine_region = gdk_offscreen_window_shape_combine_region;
1252 iface->input_shape_combine_region = gdk_offscreen_window_input_shape_combine_region;
1253 iface->set_static_gravities = gdk_offscreen_window_set_static_gravities;
1254 iface->queue_antiexpose = gdk_offscreen_window_queue_antiexpose;
1255 iface->queue_translation = gdk_offscreen_window_queue_translation;
1256 iface->get_root_coords = gdk_offscreen_window_get_root_coords;
1257 iface->get_deskrelative_origin = gdk_offscreen_window_get_deskrelative_origin;
1258 iface->get_pointer = gdk_offscreen_window_get_pointer;
1259 iface->destroy = gdk_offscreen_window_destroy;
1262 #define __GDK_OFFSCREEN_WINDOW_C__
1263 #include "gdkaliasdef.c"