/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2005.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include <config.h>

#include <math.h>

#include "gdk.h"

#include "gdkwindow.h"

#include "gdkinternals.h"

#include "gdkwindowimpl.h"

#include "gdkpixmap.h"

#include "gdkdrawable.h"

#include "gdktypes.h"

#include "gdkscreen.h"

#include "gdkgc.h"

#include "gdkcolor.h"

#include "gdkcursor.h"

#include "gdkalias.h"

/* LIMITATIONS:

 *

 * Offscreen windows can't be the child of a foreign window,

 *   nor contain foreign windows

 * GDK_POINTER_MOTION_HINT_MASK isn't effective

 */

typedef struct _GdkOffscreenWindowClass GdkOffscreenWindowClass;

struct _GdkOffscreenWindow

{

  GdkDrawable parent_instance;

  GdkWindow *wrapper;

  GdkCursor *cursor;

  GdkColormap *colormap;

  GdkScreen *screen;

  GdkPixmap *pixmap;

  GdkWindow *embedder;

};

struct _GdkOffscreenWindowClass

{

  GdkDrawableClass parent_class;

};

#define GDK_OFFSCREEN_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_OFFSCREEN_WINDOW, GdkOffscreenWindowClass))

#define GDK_IS_OFFSCREEN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_OFFSCREEN_WINDOW))

#define GDK_OFFSCREEN_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_OFFSCREEN_WINDOW, GdkOffscreenWindowClass))

static void       gdk_offscreen_window_impl_iface_init    (GdkWindowImplIface         *iface);

static void       gdk_offscreen_window_hide               (GdkWindow                  *window);

G_DEFINE_TYPE_WITH_CODE (GdkOffscreenWindow,

			 gdk_offscreen_window,

			 GDK_TYPE_DRAWABLE,

			 G_IMPLEMENT_INTERFACE (GDK_TYPE_WINDOW_IMPL,

						gdk_offscreen_window_impl_iface_init));

static void

gdk_offscreen_window_finalize (GObject *object)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (object);

  if (offscreen->cursor)

    gdk_cursor_unref (offscreen->cursor);

  offscreen->cursor = NULL;

  g_object_unref (offscreen->pixmap);

  G_OBJECT_CLASS (gdk_offscreen_window_parent_class)->finalize (object);

}

static void

gdk_offscreen_window_init (GdkOffscreenWindow *window)

{

}

static void

gdk_offscreen_window_destroy (GdkWindow *window,

			      gboolean   recursing,

			      gboolean   foreign_destroy)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  GdkOffscreenWindow *offscreen;

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  gdk_offscreen_window_set_embedder (window, NULL);

  if (!recursing)

    gdk_offscreen_window_hide (window);

  g_object_unref (offscreen->colormap);

  offscreen->colormap = NULL;

}

static gboolean

is_parent_of (GdkWindow *parent,

	      GdkWindow *child)

{

  GdkWindow *w;

  w = child;

  while (w != NULL)

    {

      if (w == parent)

	return TRUE;

      w = gdk_window_get_parent (w);

    }

  return FALSE;

}

static GdkGC *

gdk_offscreen_window_create_gc (GdkDrawable     *drawable,

				GdkGCValues     *values,

				GdkGCValuesMask  values_mask)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return gdk_gc_new_with_values (offscreen->pixmap, values, values_mask);

}

static GdkImage*

gdk_offscreen_window_copy_to_image (GdkDrawable    *drawable,

				    GdkImage       *image,

				    gint            src_x,

				    gint            src_y,

				    gint            dest_x,

				    gint            dest_y,

				    gint            width,

				    gint            height)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return gdk_drawable_copy_to_image (offscreen->pixmap,

				     image,

				     src_x,

				     src_y,

				     dest_x, dest_y,

				     width, height);

}

static cairo_surface_t *

gdk_offscreen_window_ref_cairo_surface (GdkDrawable *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return _gdk_drawable_ref_cairo_surface (offscreen->pixmap);

}

static GdkColormap*

gdk_offscreen_window_get_colormap (GdkDrawable *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return offscreen->colormap;

}

static void

gdk_offscreen_window_set_colormap (GdkDrawable *drawable,

				   GdkColormap*colormap)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  if (colormap && GDK_WINDOW_DESTROYED (offscreen->wrapper))

    return;

  if (offscreen->colormap == colormap)

    return;

  if (offscreen->colormap)

    g_object_unref (offscreen->colormap);

  offscreen->colormap = colormap;

  if (offscreen->colormap)

    g_object_ref (offscreen->colormap);

}

static gint

gdk_offscreen_window_get_depth (GdkDrawable *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return gdk_drawable_get_depth (offscreen->wrapper);

}

static GdkDrawable *

gdk_offscreen_window_get_source_drawable (GdkDrawable  *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return _gdk_drawable_get_source_drawable (offscreen->pixmap);

}

static GdkDrawable *

gdk_offscreen_window_get_composite_drawable (GdkDrawable *drawable,

					     gint         x,

					     gint         y,

					     gint         width,

					     gint         height,

					     gint        *composite_x_offset,

					     gint        *composite_y_offset)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return g_object_ref (offscreen->pixmap);

}

static GdkScreen*

gdk_offscreen_window_get_screen (GdkDrawable *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return offscreen->screen;

}

static GdkVisual*

gdk_offscreen_window_get_visual (GdkDrawable    *drawable)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  return gdk_drawable_get_visual (offscreen->wrapper);

}

static void

add_damage (GdkOffscreenWindow *offscreen,

	    int x, int y,

	    int w, int h,

	    gboolean is_line)

{

  GdkRectangle rect;

  GdkRegion *damage;

  rect.x = x;

  rect.y = y;

  rect.width = w;

  rect.height = h;

  if (is_line)

    {

      /* This should really take into account line width, line

       * joins (and miter) and line caps. But these are hard

       * to compute, rarely used and generally a pain. And in

       * the end a snug damage rectangle is not that important

       * as multiple damages are generally created anyway.

       *

       * So, we just add some padding around the rect.

       * We use a padding of 3 pixels, plus an extra row

       * below and on the right for the normal line size. I.E.

       * line from (0,0) to (2,0) gets h=0 but is really

       * at least one pixel tall.

       */

      rect.x -= 3;

      rect.y -= 3;

      rect.width += 7;

      rect.height += 7;

    }

  damage = gdk_region_rectangle (&rect);

  _gdk_window_add_damage (offscreen->wrapper, damage);

  gdk_region_destroy (damage);

}

static GdkDrawable *

get_real_drawable (GdkOffscreenWindow *offscreen)

{

  GdkPixmapObject *pixmap;

  pixmap = (GdkPixmapObject *) offscreen->pixmap;

  return GDK_DRAWABLE (pixmap->impl);

}

static void

gdk_offscreen_window_draw_drawable (GdkDrawable *drawable,

				    GdkGC       *gc,

				    GdkPixmap   *src,

				    gint         xsrc,

				    gint         ysrc,

				    gint         xdest,

				    gint         ydest,

				    gint         width,

				    gint         height,

				    GdkDrawable *original_src)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_drawable (real_drawable, gc,

		     src, xsrc, ysrc,

		     xdest, ydest,

		     width, height);

  add_damage (offscreen, xdest, ydest, width, height, FALSE);

}

static void

gdk_offscreen_window_draw_rectangle (GdkDrawable  *drawable,

				     GdkGC	  *gc,

				     gboolean	   filled,

				     gint	   x,

				     gint	   y,

				     gint	   width,

				     gint	   height)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_rectangle (real_drawable,

		      gc, filled, x, y, width, height);

  add_damage (offscreen, x, y, width, height, !filled);

}

static void

gdk_offscreen_window_draw_arc (GdkDrawable  *drawable,

			       GdkGC	       *gc,

			       gboolean	filled,

			       gint		x,

			       gint		y,

			       gint		width,

			       gint		height,

			       gint		angle1,

			       gint		angle2)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_arc (real_drawable,

		gc,

		filled,

		x,

		y,

		width,

		height,

		angle1,

		angle2);

  add_damage (offscreen, x, y, width, height, !filled);

}

static void

gdk_offscreen_window_draw_polygon (GdkDrawable  *drawable,

				   GdkGC	       *gc,

				   gboolean	filled,

				   GdkPoint     *points,

				   gint		npoints)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_polygon (real_drawable,

		    gc,

		    filled,

		    points,

		    npoints);

  if (npoints > 0)

    {

      int min_x, min_y, max_x, max_y, i;

      min_x = max_x = points[0].x;

      min_y = max_y = points[0].y;

	for (i = 1; i < npoints; i++)

	  {

	    min_x = MIN (min_x, points[i].x);

	    max_x = MAX (max_x, points[i].x);

	    min_y = MIN (min_y, points[i].y);

	    max_y = MAX (max_y, points[i].y);

	  }

	add_damage (offscreen, min_x, min_y,

		    max_x - min_x,

		    max_y - min_y, !filled);

    }

}

static void

gdk_offscreen_window_draw_text (GdkDrawable  *drawable,

				GdkFont      *font,

				GdkGC	       *gc,

				gint		x,

				gint		y,

				const gchar  *text,

				gint		text_length)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);

  gdk_draw_text (real_drawable,

		 font,

		 gc,

		 x,

		 y,

		 text,

		 text_length);

  /* Hard to compute the minimal size, not that often used anyway. */

  add_damage (offscreen, 0, 0, private->width, private->height, FALSE);

}

static void

gdk_offscreen_window_draw_text_wc (GdkDrawable	 *drawable,

				   GdkFont	 *font,

				   GdkGC		 *gc,

				   gint		  x,

				   gint		  y,

				   const GdkWChar *text,

				   gint		  text_length)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);

  gdk_draw_text_wc (real_drawable,

		    font,

		    gc,

		    x,

		    y,

		    text,

		    text_length);

  /* Hard to compute the minimal size, not that often used anyway. */

  add_damage (offscreen, 0, 0, private->width, private->height, FALSE);

}

static void

gdk_offscreen_window_draw_points (GdkDrawable  *drawable,

				  GdkGC	       *gc,

				  GdkPoint     *points,

				  gint		npoints)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_points (real_drawable,

		   gc,

		   points,

		   npoints);

  if (npoints > 0)

    {

      int min_x, min_y, max_x, max_y, i;

      min_x = max_x = points[0].x;

      min_y = max_y = points[0].y;

	for (i = 1; i < npoints; i++)

	  {

	    min_x = MIN (min_x, points[i].x);

	    max_x = MAX (max_x, points[i].x);

	    min_y = MIN (min_y, points[i].y);

	    max_y = MAX (max_y, points[i].y);

	  }

	add_damage (offscreen, min_x, min_y,

		    max_x - min_x + 1,

		    max_y - min_y + 1,

		    FALSE);

    }

}

static void

gdk_offscreen_window_draw_segments (GdkDrawable  *drawable,

				    GdkGC	 *gc,

				    GdkSegment   *segs,

				    gint	  nsegs)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_segments (real_drawable,

		     gc,

		     segs,

		     nsegs);

  if (nsegs > 0)

    {

      int min_x, min_y, max_x, max_y, i;

      min_x = max_x = segs[0].x1;

      min_y = max_y = segs[0].y1;

	for (i = 0; i < nsegs; i++)

	  {

	    min_x = MIN (min_x, segs[i].x1);

	    max_x = MAX (max_x, segs[i].x1);

	    min_x = MIN (min_x, segs[i].x2);

	    max_x = MAX (max_x, segs[i].x2);

	    min_y = MIN (min_y, segs[i].y1);

	    max_y = MAX (max_y, segs[i].y1);

	    min_y = MIN (min_y, segs[i].y2);

	    max_y = MAX (max_y, segs[i].y2);

	  }

	add_damage (offscreen, min_x, min_y,

		    max_x - min_x,

		    max_y - min_y, TRUE);

    }

}

static void

gdk_offscreen_window_draw_lines (GdkDrawable  *drawable,

				 GdkGC        *gc,

				 GdkPoint     *points,

				 gint          npoints)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);

  gdk_draw_lines (real_drawable,

		  gc,

		  points,

		  npoints);

  /* Hard to compute the minimal size, as we don't know the line

     width, and since joins are hard to calculate.

     Its not that often used anyway, damage it all */

  add_damage (offscreen, 0, 0, private->width, private->height, TRUE);

}

static void

gdk_offscreen_window_draw_image (GdkDrawable *drawable,

				 GdkGC	      *gc,

				 GdkImage    *image,

				 gint	       xsrc,

				 gint	       ysrc,

				 gint	       xdest,

				 gint	       ydest,

				 gint	       width,

				 gint	       height)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_image (real_drawable,

		  gc,

		  image,

		  xsrc,

		  ysrc,

		  xdest,

		  ydest,

		  width,

		  height);

  add_damage (offscreen, xdest, ydest, width, height, FALSE);

}

static void

gdk_offscreen_window_draw_pixbuf (GdkDrawable *drawable,

				  GdkGC       *gc,

				  GdkPixbuf   *pixbuf,

				  gint         src_x,

				  gint         src_y,

				  gint         dest_x,

				  gint         dest_y,

				  gint         width,

				  gint         height,

				  GdkRgbDither dither,

				  gint         x_dither,

				  gint         y_dither)

{

  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);

  GdkDrawable *real_drawable = get_real_drawable (offscreen);

  gdk_draw_pixbuf (real_drawable,

		   gc,

		   pixbuf,

		   src_x,

		   src_y,

		   dest_x,

		   dest_y,

		   width,

		   height,

		   dither,

		   x_dither,

		   y_dither);

  add_damage (offscreen, dest_x, dest_y, width, height, FALSE);

}

void

_gdk_offscreen_window_new (GdkWindow     *window,

			   GdkScreen     *screen,

			   GdkVisual     *visual,

			   GdkWindowAttr *attributes,

			   gint           attributes_mask)

{

  GdkWindowObject *private;

  GdkOffscreenWindow *offscreen;

  g_return_if_fail (attributes != NULL);

  if (attributes->wclass != GDK_INPUT_OUTPUT)

    return; /* Can't support input only offscreens */

  private = (GdkWindowObject *)window;

  if (private->parent != NULL && GDK_WINDOW_DESTROYED (private->parent))

    return;

  private->impl = g_object_new (GDK_TYPE_OFFSCREEN_WINDOW, NULL);

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  offscreen->wrapper = window;

  offscreen->screen = screen;

  if (attributes_mask & GDK_WA_COLORMAP)

    offscreen->colormap = g_object_ref (attributes->colormap);

  else

    {

      if (gdk_screen_get_system_visual (screen) == visual)

	{

	  offscreen->colormap = gdk_screen_get_system_colormap (screen);

	  g_object_ref (offscreen->colormap);

	}

      else

	offscreen->colormap = gdk_colormap_new (visual, FALSE);

    }

  offscreen->pixmap = gdk_pixmap_new ((GdkDrawable *)private->parent,

				      private->width,

				      private->height,

				      private->depth);

  gdk_drawable_set_colormap (offscreen->pixmap, offscreen->colormap);

}

static gboolean

gdk_offscreen_window_reparent (GdkWindow *window,

			       GdkWindow *new_parent,

			       gint       x,

			       gint       y)

{

  GdkWindowObject *private = (GdkWindowObject *)window;

  GdkWindowObject *new_parent_private = (GdkWindowObject *)new_parent;

  GdkWindowObject *old_parent;

  gboolean was_mapped;

  if (new_parent)

    {

      /* No input-output children of input-only windows */

      if (new_parent_private->input_only && !private->input_only)

	return FALSE;

      /* Don't create loops in hierarchy */

      if (is_parent_of (window, new_parent))

	return FALSE;

    }

  was_mapped = GDK_WINDOW_IS_MAPPED (window);

  gdk_window_hide (window);

  if (private->parent)

    private->parent->children = g_list_remove (private->parent->children, window);

  old_parent = private->parent;

  private->parent = new_parent_private;

  private->x = x;

  private->y = y;

  if (new_parent_private)

    private->parent->children = g_list_prepend (private->parent->children, window);

  _gdk_synthesize_crossing_events_for_geometry_change (window);

  if (old_parent)

    _gdk_synthesize_crossing_events_for_geometry_change (GDK_WINDOW (old_parent));

  return was_mapped;

}

static void

from_embedder (GdkWindow *window,

	       double embedder_x, double embedder_y,

	       double *offscreen_x, double *offscreen_y)

{

  GdkWindowObject *private;

  private = (GdkWindowObject *)window;

  g_signal_emit_by_name (private->impl_window,

			 "from-embedder",

			 embedder_x, embedder_y,

			 offscreen_x, offscreen_y,

			 NULL);

}

static void

to_embedder (GdkWindow *window,

	     double offscreen_x, double offscreen_y,

	     double *embedder_x, double *embedder_y)

{

  GdkWindowObject *private;

  private = (GdkWindowObject *)window;

  g_signal_emit_by_name (private->impl_window,

			 "to-embedder",

			 offscreen_x, offscreen_y,

			 embedder_x, embedder_y,

			 NULL);

}

static gint

gdk_offscreen_window_get_root_coords (GdkWindow *window,

				      gint       x,

				      gint       y,

				      gint      *root_x,

				      gint      *root_y)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  GdkOffscreenWindow *offscreen;

  int tmpx, tmpy;

  tmpx = x;

  tmpy = y;

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  if (offscreen->embedder)

    {

      double dx, dy;

      to_embedder (window,

		   x, y,

		   &dx, &dy;;

      tmpx = floor (dx + 0.5);

      tmpy = floor (dy + 0.5);

      gdk_window_get_root_coords (offscreen->embedder,

				  tmpx, tmpy,

				  &tmpx, &tmpy);

    }

  if (root_x)

    *root_x = tmpx;

  if (root_y)

    *root_y = tmpy;

  return TRUE;

}

static gint

gdk_offscreen_window_get_deskrelative_origin (GdkWindow *window,

					      gint      *x,

					      gint      *y)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  GdkOffscreenWindow *offscreen;

  int tmpx, tmpy;

  tmpx = 0;

  tmpy = 0;

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  if (offscreen->embedder)

    {

      double dx, dy;

      gdk_window_get_deskrelative_origin (offscreen->embedder,

					  &tmpx, &tmpy);

      to_embedder (window,

		   0, 0,

		   &dx, &dy;;

      tmpx = floor (tmpx + dx + 0.5);

      tmpy = floor (tmpy + dy + 0.5);

    }

  if (x)

    *x = tmpx;

  if (y)

    *y = tmpy;

  return TRUE;

}

static gboolean

gdk_offscreen_window_get_pointer (GdkWindow       *window,

				  gint            *x,

				  gint            *y,

				  GdkModifierType *mask)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  GdkOffscreenWindow *offscreen;

  int tmpx, tmpy;

  double dtmpx, dtmpy;

  GdkModifierType tmpmask;

  tmpx = 0;

  tmpy = 0;

  tmpmask = 0;

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  if (offscreen->embedder != NULL)

    {

      gdk_window_get_pointer (offscreen->embedder, &tmpx, &tmpy, &tmpmask);

      from_embedder (window,

		     tmpx, tmpy,

		     &dtmpx, &dtmpy);

      tmpx = floor (dtmpx + 0.5);

      tmpy = floor (dtmpy + 0.5);

    }

  if (x)

    *x = tmpx;

  if (y)

    *y = tmpy;

  if (mask)

    *mask = tmpmask;

  return TRUE;

}

GdkDrawable *

_gdk_offscreen_window_get_real_drawable (GdkOffscreenWindow *offscreen)

{

  return get_real_drawable (offscreen);

}

/**

 * gdk_offscreen_window_get_pixmap:

 * @window: a #GdkWindow

 *

 * Gets the offscreen pixmap that an offscreen window renders into.

 * If you need to keep this around over window resizes, you need to

 * add a reference to it.

 *

 * Returns: The offscreen pixmap, or %NULL if not offscreen

 *

 * Since: 2.18

 */

GdkPixmap *

gdk_offscreen_window_get_pixmap (GdkWindow *window)

{

  GdkWindowObject *private = (GdkWindowObject *)window;

  GdkOffscreenWindow *offscreen;

  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);

  if (!GDK_IS_OFFSCREEN_WINDOW (private->impl))

    return NULL;

  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  return offscreen->pixmap;

}

static void

gdk_offscreen_window_raise (GdkWindow *window)

{