/* gdkimage-quartz.c

 *

 * Copyright (C) 2005 Imendio AB

 *

 * 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.

 */

#include "config.h"

#include "gdk.h"

#include "gdkimage.h"

#include "gdkprivate-quartz.h"

static GObjectClass *parent_class;

GdkImage *

_gdk_quartz_image_copy_to_image (GdkDrawable *drawable,

				 GdkImage    *image,

				 gint         src_x,

				 gint         src_y,

				 gint         dest_x,

				 gint         dest_y,

				 gint         width,

				 gint         height)

{

  GdkScreen *screen;

  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_QUARTZ (drawable), NULL);

  g_return_val_if_fail (image != NULL || (dest_x == 0 && dest_y == 0), NULL);

  screen = gdk_drawable_get_screen (drawable);

  if (!image)

    image = _gdk_image_new_for_depth (screen, GDK_IMAGE_FASTEST, NULL, 

				      width, height,

				      gdk_drawable_get_depth (drawable));

  if (GDK_IS_PIXMAP_IMPL_QUARTZ (drawable))

    {

      GdkPixmapImplQuartz *pix_impl;

      gint bytes_per_row;

      guchar *data;

      int x, y;

      pix_impl = GDK_PIXMAP_IMPL_QUARTZ (drawable);

      data = (guchar *)(pix_impl->data);

      if (src_x + width > pix_impl->width || src_y + height > pix_impl->height)

      	{

          g_warning ("Out of bounds copy-area for pixmap -> image conversion\n");

          return image;

        }

      switch (gdk_drawable_get_depth (drawable))

        {

        case 24:

          bytes_per_row = pix_impl->width * 4;

          for (y = 0; y < height; y++)

            {

              guchar *src = data + ((y + src_y) * bytes_per_row) + (src_x * 4);

              for (x = 0; x < width; x++)

                {

                  gint32 pixel;

                  /* RGB24, 4 bytes per pixel, skip first. */

                  pixel = src[0] << 16 | src[1] << 8 | src[2];

                  src += 4;

                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);

                }

            }

          break;

        case 32:

          bytes_per_row = pix_impl->width * 4;

          for (y = 0; y < height; y++)

            {

              guchar *src = data + ((y + src_y) * bytes_per_row) + (src_x * 4);

              for (x = 0; x < width; x++)

                {

                  gint32 pixel;

                  /* ARGB32, 4 bytes per pixel. */

                  pixel = src[0] << 24 | src[1] << 16 | src[2] << 8 | src[3];

                  src += 4;

                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);

                }

            }

          break;

        case 1: /* TODO: optimize */

          bytes_per_row = pix_impl->width;

          for (y = 0; y < height; y++)

            {

              guchar *src = data + ((y + src_y) * bytes_per_row) + src_x;

              for (x = 0; x < width; x++)

                {

                  gint32 pixel;

                  /* 8 bits */

                  pixel = src[0];

                  src++;

                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);

                }

            }

          break;

        default:

          g_warning ("Unsupported bit depth %d\n", gdk_drawable_get_depth (drawable));

          return image;

        }

    }

  else if (GDK_IS_WINDOW_IMPL_QUARTZ (drawable))

    {

      GdkQuartzView *view;

      NSBitmapImageRep *rep;

      guchar *data;

      int x, y;

      NSSize size;

      NSBitmapFormat format;

      gboolean has_alpha;

      gint bpp;

      gint r_byte = 0;

      gint g_byte = 1;

      gint b_byte = 2;

      gint a_byte = 3;

      gboolean le_image_data = FALSE;

      if (GDK_WINDOW_IMPL_QUARTZ (drawable) == GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (_gdk_root)->impl))

        {

          /* Special case for the root window. */

	  CGRect rect = CGRectMake (src_x, src_y, width, height);

          CGImageRef root_image_ref = CGWindowListCreateImage (rect,

                                                               kCGWindowListOptionOnScreenOnly,

                                                               kCGNullWindowID,

                                                               kCGWindowImageDefault);

          /* HACK: the NSBitmapImageRep does not copy and convert

           * CGImageRef's data so it matches what NSBitmapImageRep can

           * express in its API (which is RGBA and ARGB, premultiplied

           * and unpremultiplied), it only references the CGImageRef.

           * Therefore we need to do the host byte swapping ourselves.

           */

          if (CGImageGetBitmapInfo (root_image_ref) & kCGBitmapByteOrder32Little)

            {

              r_byte = 3;

              g_byte = 2;

              b_byte = 1;

              a_byte = 0;

              le_image_data = TRUE;

            }

          rep = [[NSBitmapImageRep alloc] initWithCGImage: root_image_ref];

          CGImageRelease (root_image_ref);

        }

      else

        {

	  NSRect rect = NSMakeRect (src_x, src_y, width, height);

          view = GDK_WINDOW_IMPL_QUARTZ (drawable)->view;

          /* We return the image even if we can't copy to it. */

          if (![view lockFocusIfCanDraw])

            return image;

          rep = [[NSBitmapImageRep alloc] initWithFocusedViewRect: rect];

          [view unlockFocus];

        }

      data = [rep bitmapData];

      size = [rep size];

      format = [rep bitmapFormat];

      has_alpha = [rep hasAlpha];

      bpp = [rep bitsPerPixel] / 8;

      /* MORE HACK: AlphaFirst seems set for le_image_data, which is

       * technically correct, but really apple, are you kidding, it's

       * in fact ABGR, not ARGB as promised in NSBitmapImageRep's API.

       */

      if (!le_image_data && (format & NSAlphaFirstBitmapFormat))

        {

          r_byte = 1;

          g_byte = 2;

          b_byte = 3;

          a_byte = 0;

        }

      for (y = 0; y < size.height; y++)

        {

          guchar *src = data + y * [rep bytesPerRow];

          for (x = 0; x < size.width; x++)

            {

              guchar r = src[r_byte];

              guchar g = src[g_byte];

              guchar b = src[b_byte];

              gint32 pixel;

              if (has_alpha)

                {

                  guchar alpha = src[a_byte];

                  /* unpremultiply if alpha > 0 */

                  if (! (format & NSAlphaNonpremultipliedBitmapFormat) && alpha)

                    {

                      r = r * 255 / alpha;

                      g = g * 255 / alpha;

                      b = b * 255 / alpha;

                    }

                  if (image->byte_order == GDK_MSB_FIRST)

                    pixel = alpha | b << 8 | g << 16 | r << 24;

                  else

                    pixel = alpha << 24 | b << 16 | g << 8 | r;

                }

              else

                {

                  if (image->byte_order == GDK_MSB_FIRST)

                    pixel = b | g << 8 | r << 16;

                  else

                    pixel = b << 16 | g << 8 | r;

                }

              src += bpp;

              gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);

            }

        }

      [rep release];

    }

  return image;

}

static void

gdk_image_finalize (GObject *object)

{

  GdkImage *image = GDK_IMAGE (object);

  g_free (image->mem);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gdk_image_class_init (GdkImageClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->finalize = gdk_image_finalize;

}

GType

gdk_image_get_type (void)

{

  static GType object_type = 0;

  if (!object_type)

    {

      const GTypeInfo object_info =

      {

        sizeof (GdkImageClass),

        (GBaseInitFunc) NULL,

        (GBaseFinalizeFunc) NULL,

        (GClassInitFunc) gdk_image_class_init,

        NULL,           /* class_finalize */

        NULL,           /* class_data */

        sizeof (GdkImage),

        0,              /* n_preallocs */

        (GInstanceInitFunc) NULL,

      };

      object_type = g_type_register_static (G_TYPE_OBJECT,

                                            "GdkImage",

                                            &object_info,

					    0);

    }

  return object_type;

}

GdkImage *

gdk_image_new_bitmap (GdkVisual *visual, gpointer data, gint width, gint height)

{

  /* We don't implement this function because it's broken, deprecated and 

   * tricky to implement. */

  g_warning ("This function is unimplemented");

  return NULL;

}

GdkImage*

_gdk_image_new_for_depth (GdkScreen    *screen,

			  GdkImageType  type,

			  GdkVisual    *visual,

			  gint          width,

			  gint          height,

			  gint          depth)

{

  GdkImage *image;

  if (visual)

    depth = visual->depth;

  g_assert (depth == 24 || depth == 32);

  image = g_object_new (gdk_image_get_type (), NULL);

  image->type = type;

  image->visual = visual;

  image->width = width;

  image->height = height;

  image->depth = depth;

  image->byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ? GDK_LSB_FIRST : GDK_MSB_FIRST;

  /* We only support images with bpp 4 */

  image->bpp = 4;

  image->bpl = image->width * image->bpp;

  image->bits_per_pixel = image->bpp * 8;

  image->mem = g_malloc (image->bpl * image->height);

  memset (image->mem, 0x00, image->bpl * image->height);

  return image;

}

guint32

gdk_image_get_pixel (GdkImage *image,

		     gint x,

		     gint y)

{

  guchar *ptr;

  g_return_val_if_fail (image != NULL, 0);

  g_return_val_if_fail (x >= 0 && x < image->width, 0);

  g_return_val_if_fail (y >= 0 && y < image->height, 0);

  ptr = image->mem + y * image->bpl + x * image->bpp;

  return *(guint32 *)ptr;

}

void

gdk_image_put_pixel (GdkImage *image,

		     gint x,

		     gint y,

		     guint32 pixel)

{

  guchar *ptr;

  ptr = image->mem + y * image->bpl + x * image->bpp;

  *(guint32 *)ptr = pixel;

}

gint

_gdk_windowing_get_bits_for_depth (GdkDisplay *display,

				   gint        depth)

{

  if (depth == 24 || depth == 32)

    return 32;

  else

    g_assert_not_reached ();

  return 0;

}