Fix for alpha channel rendering for images on OS X Mavericks; thanks to Marc Culler for the extensive patch.

4 files changed, 170 insertions, 121 deletions

diff --git a/macosx/tkMacOSXDraw.c b/macosx/tkMacOSXDraw.c
index 5be04a4..1aba8f4 100644
--- a/macosx/tkMacOSXDraw.c
+++ b/macosx/tkMacOSXDraw.c
@@ -113,10 +113,79 @@ TkMacOSXInitCGDrawing(
 /*
  *----------------------------------------------------------------------
  *
+ * BitmapRepFromDrawableRect
+ *
+ *	Extract bitmap data from a MacOSX drawable as an NSBitmapImageRep.
+ *
+ * Results:
+ *	Returns an autoreleased NSBitmapRep representing the image of the given
+ *      rectangle of the given drawable.
+ *
+ *      NOTE: The x,y coordinates should be relative to a coordinate system with
+ *      origin at the top left, as used by XImage and CGImage, not bottom
+ *      left as used by NSView.
+ *
+ * Side effects:
+ *     None
+ *
+ *----------------------------------------------------------------------
+ */
+NSBitmapImageRep*
+BitmapRepFromDrawableRect(
+        Drawable drawable,
+	int x,
+	int y,
+	unsigned int width,
+	unsigned int height)
+{
+    MacDrawable *mac_drawable = (MacDrawable *) drawable;
+    CGContextRef cg_context=NULL;
+    CGImageRef cg_image=NULL, sub_cg_image=NULL;
+    NSBitmapImageRep *bitmap_rep=NULL;
+    NSView *view=NULL;
+    if ( mac_drawable->flags & TK_IS_PIXMAP ) {
+	/* 
+	   This means that the MacDrawable is functioning as a Tk Pixmap, so its view
+	   field is NULL.  It's context field should point to a CGImage.
+	*/
+	cg_context = GetCGContextForDrawable(drawable);
+	CGRect image_rect = CGRectMake(x, y, width, height);
+	cg_image = CGBitmapContextCreateImage( (CGContextRef) cg_context);
+	sub_cg_image = CGImageCreateWithImageInRect(cg_image, image_rect);
+	if ( sub_cg_image ) {
+	    bitmap_rep = [[NSBitmapImageRep alloc] autorelease];
+	    [bitmap_rep initWithCGImage:sub_cg_image];
+	}
+	if ( cg_image ) {
+	    CGImageRelease(cg_image);
+	}
+    } else if ( (view = TkMacOSXDrawableView(mac_drawable)) ) {
+	/* convert top-left coordinates to NSView coordinates */
+	int view_height = [view bounds].size.height;
+	NSRect view_rect = NSMakeRect(x + mac_drawable->xOff,
+				      view_height - height - y - mac_drawable->yOff,
+				      width,height);
+
+	if ( [view lockFocusIfCanDraw] ) {
+	    bitmap_rep = [[NSBitmapImageRep alloc] autorelease];
+	    bitmap_rep = [bitmap_rep initWithFocusedViewRect:view_rect];
+	    [view unlockFocus];
+	} else {
+	    TkMacOSXDbgMsg("Could not lock focus on view.");
+	}
+
+    } else {
+	TkMacOSXDbgMsg("Invalid source drawable");
+    }
+    return bitmap_rep;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * XCopyArea --
  *
- *	Copies data from one drawable to another using block transfer
- *	routines.
+ *	Copies data from one drawable to another.
  *
  * Results:
  *	None.
@@ -143,76 +212,52 @@ XCopyArea(
 {
     TkMacOSXDrawingContext dc;
     MacDrawable *srcDraw = (MacDrawable *) src;
+    NSBitmapImageRep *bitmap_rep = NULL;
+    CGImageRef img = NULL;
 
     display->request++;
+
+    TkMacOSXDbgMsg("XCopyArea");
+
     if (!width || !height) {
-	/* TkMacOSXDbgMsg("Drawing of emtpy area requested"); */
+	/* This happens all the time.
+	TkMacOSXDbgMsg("Drawing of empty area requested");
+	*/
 	return;
     }
-    if (srcDraw->flags & TK_IS_PIXMAP) {
-	if (!TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
-	    return;
-	}
-	if (dc.context) {
-	    CGImageRef img = TkMacOSXCreateCGImageWithDrawable(src);
 
-	    if (img) {
-		DrawCGImage(dst, gc, dc.context, img, gc->foreground,
-			gc->background, CGRectMake(0, 0,
-			srcDraw->size.width, srcDraw->size.height),
-			CGRectMake(src_x, src_y, width, height),
-			CGRectMake(dest_x, dest_y, width, height));
-		CFRelease(img);
-	    } else {
-		TkMacOSXDbgMsg("Invalid source drawable");
+    if (!TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
+	TkMacOSXDbgMsg("Failed to setup drawing context.");
+    }
+
+    if ( dc.context ) {
+	if (srcDraw->flags & TK_IS_PIXMAP) {
+	    img = TkMacOSXCreateCGImageWithDrawable(src);
+	}else if (TkMacOSXDrawableWindow(src)) {
+	    bitmap_rep =  BitmapRepFromDrawableRect(src, src_x, src_y, width, height);
+	    if ( bitmap_rep ) {
+		img = [bitmap_rep CGImage];
 	    }
 	} else {
-	    TkMacOSXDbgMsg("Invalid destination drawable");
-	}
-	TkMacOSXRestoreDrawingContext(&dc);
-    } else if (TkMacOSXDrawableWindow(src)) {
-	NSView *view = TkMacOSXDrawableView(srcDraw);
-	NSWindow *w = [view window];
-	NSInteger gs = [w windowNumber] > 0 ? [w gState] : 0;
-	/* // alternative using per-view gState:
-	NSInteger gs = [view gState];
-	if (!gs) {
-	    [view allocateGState];
-	    if ([view lockFocusIfCanDraw]) {
-		[view unlockFocus];
-	    }
-	    gs = [view gState];
-	}
-	*/
-	if (!gs || !TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
-	    return;
+	    TkMacOSXDbgMsg("Invalid source drawable");
 	}
-	if (dc.context) {
-	    NSGraphicsContext *gc = nil;
-	    CGFloat boundsH = [view bounds].size.height;
-	    NSRect srcRect = NSMakeRect(srcDraw->xOff + src_x, boundsH -
-		    height - (srcDraw->yOff + src_y), width, height);
-
-	    if (((MacDrawable *) dst)->flags & TK_IS_PIXMAP) {
-		gc = [NSGraphicsContext graphicsContextWithGraphicsPort:
-			dc.context flipped:NO];
-		if (gc) {
-		    [NSGraphicsContext saveGraphicsState];
-		    [NSGraphicsContext setCurrentContext:gc];
-		}
-	    }
-	    NSCopyBits(gs, srcRect, NSMakePoint(dest_x,
-		    dc.portBounds.size.height - dest_y));
-	    if (gc) {
-		[NSGraphicsContext restoreGraphicsState];
-	    }
+
+	if (img) {
+	    DrawCGImage(dst, gc, dc.context, img, gc->foreground, gc->background,
+			CGRectMake(0, 0, srcDraw->size.width, srcDraw->size.height),
+			CGRectMake(src_x, src_y, width, height),
+			CGRectMake(dest_x, dest_y, width, height));
+	    CFRelease(img);
 	} else {
-	    TkMacOSXDbgMsg("Invalid destination drawable");
+	    TkMacOSXDbgMsg("Invalid source drawable");
 	}
-	TkMacOSXRestoreDrawingContext(&dc);
+
     } else {
-	TkMacOSXDbgMsg("Invalid source drawable");
+	TkMacOSXDbgMsg("Invalid destination drawable");
+	return;
     }
+
+    TkMacOSXRestoreDrawingContext(&dc);
 }
 
 /*
@@ -253,7 +298,7 @@ XCopyPlane(
 
     display->request++;
     if (!width || !height) {
-	/* TkMacOSXDbgMsg("Drawing of emtpy area requested"); */
+	/* TkMacOSXDbgMsg("Drawing of empty area requested"); */
 	return;
     }
     if (plane != 1) {
@@ -383,13 +428,7 @@ CreateCGImageWithXImage(
     char *data = NULL;
     CGDataProviderReleaseDataCallback releaseData = ReleaseData;
 
-    if (image->obdata) {
-	/*
-	 * Image from XGetImage
-	 */
-
-	img = TkMacOSXCreateCGImageWithDrawable((Pixmap) image->obdata);
-    } else if (image->bits_per_pixel == 1) {
+    if (image->bits_per_pixel == 1) {
 	/*
 	 * BW image
 	 */
diff --git a/macosx/tkMacOSXPrivate.h b/macosx/tkMacOSXPrivate.h
index 3ad0689..b4e510f 100644
--- a/macosx/tkMacOSXPrivate.h
+++ b/macosx/tkMacOSXPrivate.h
@@ -228,6 +228,8 @@ MODULE_SCOPE WindowClass TkMacOSXWindowClass(TkWindow *winPtr);
 MODULE_SCOPE int	TkMacOSXIsWindowZoomed(TkWindow *winPtr);
 MODULE_SCOPE int	TkGenerateButtonEventForXPointer(Window window);
 MODULE_SCOPE EventModifiers TkMacOSXModifierState(void);
+MODULE_SCOPE NSBitmapImageRep* BitmapRepFromDrawableRect(Drawable drawable,
+			    int x, int y, unsigned int width, unsigned int height);
 MODULE_SCOPE int	TkMacOSXSetupDrawingContext(Drawable d, GC gc,
 			    int useCG, TkMacOSXDrawingContext *dcPtr);
 MODULE_SCOPE void	TkMacOSXRestoreDrawingContext(
diff --git a/macosx/tkMacOSXSubwindows.c b/macosx/tkMacOSXSubwindows.c
index c235cbf..915dea1 100644
--- a/macosx/tkMacOSXSubwindows.c
+++ b/macosx/tkMacOSXSubwindows.c
@@ -1277,7 +1277,7 @@ UpdateOffsets(
  *	Returns a handle to a new pixmap.
  *
  * Side effects:
- *	Allocates a new Macintosh GWorld.
+ *	Allocates a new CGBitmapContext.
  *
  *----------------------------------------------------------------------
  */
@@ -1323,7 +1323,7 @@ Tk_GetPixmap(
  *	None.
  *
  * Side effects:
- *	Deletes the Macintosh GWorld created by Tk_GetPixmap.
+ *	Deletes the CGBitmapContext created by Tk_GetPixmap.
  *
  *----------------------------------------------------------------------
  */
diff --git a/macosx/tkMacOSXXStubs.c b/macosx/tkMacOSXXStubs.c
index 9594cd3..075bd65 100644
--- a/macosx/tkMacOSXXStubs.c
+++ b/macosx/tkMacOSXXStubs.c
@@ -809,7 +809,6 @@ XCreateImage(
     int bytes_per_line)
 {
     XImage *ximage;
-
     display->request++;
     ximage = (XImage *) ckalloc(sizeof(XImage));
 
@@ -819,6 +818,7 @@ XCreateImage(
     ximage->xoffset = offset;
     ximage->format = format;
     ximage->data = data;
+    ximage->obdata = NULL;
 
     if (format == ZPixmap) {
 	ximage->bits_per_pixel = 32;
@@ -850,7 +850,6 @@ XCreateImage(
     ximage->red_mask = 0x00FF0000;
     ximage->green_mask = 0x0000FF00;
     ximage->blue_mask = 0x000000FF;
-    ximage->obdata = NULL;
     ximage->f.create_image = NULL;
     ximage->f.destroy_image = DestroyImage;
     ximage->f.get_pixel = ImageGetPixel;
@@ -869,8 +868,9 @@ XCreateImage(
  *	This function copies data from a pixmap or window into an XImage.
  *
  * Results:
- *	Returns a newly allocated image containing the data from the given
- *	rectangle of the given drawable.
+ *	Returns a newly allocated XImage containing the data from the given
+ *	rectangle of the given drawable, or NULL if the XImage could not be
+ *     constructed.
  *
  * Side effects:
  *	None.
@@ -889,60 +889,70 @@ XGetImage(
     unsigned long plane_mask,
     int format)
 {
-    MacDrawable *macDraw = (MacDrawable *) d;
-    XImage *   imagePtr = NULL;
-    Pixmap     pixmap = (Pixmap) NULL;
-    Tk_Window  win = (Tk_Window) macDraw->winPtr;
-    GC	       gc;
-    char *     data = NULL;
-    int	       depth = 32;
-    int	       offset = 0;
-    int	       bitmap_pad = 0;
-    int	       bytes_per_line = 0;
-
+    NSBitmapImageRep *bitmap_rep;
+    XImage *       imagePtr = NULL;
+    char *           bitmap = NULL;
+    char *           image_data=NULL;
+    int	        depth = 32;
+    int	        offset = 0;
+    int	        bitmap_pad = 0;
+    int	        bytes_per_row = 4*width;
+    int                size;
+    TkMacOSXDbgMsg("XGetImage");
     if (format == ZPixmap) {
-	if (width > 0 && height > 0) {
-	    /*
-	     * Tk_GetPixmap fails for zero width or height.
-	     */
-
-	    pixmap = Tk_GetPixmap(display, d, width, height, depth);
+	if (width == 0 || height == 0) {
+	    /* This happens all the time.
+	    TkMacOSXDbgMsg("XGetImage: empty image requested");
+	    */
+	    return NULL;
 	}
-	if (win) {
-	    XGCValues values;
 
-	    gc = Tk_GetGC(win, 0, &values);
-	} else {
-	    gc = XCreateGC(display, pixmap, 0, NULL);
+	bitmap_rep =  BitmapRepFromDrawableRect(d, x, y,width, height);
+
+	if ( bitmap_rep == Nil                        ||
+	     [bitmap_rep bitmapFormat] != 0    || 
+	     [bitmap_rep samplesPerPixel] != 4 ||
+	     [bitmap_rep isPlanar] != 0               ) {
+	    TkMacOSXDbgMsg("XGetImage: Failed to construct NSBitmapRep");
+	    return NULL;
 	}
-	if (pixmap) {
-	    CGContextRef context;
-
-	    XCopyArea(display, d, pixmap, gc, x, y, width, height, 0, 0);
-	    context = ((MacDrawable *) pixmap)->context;
-	    if (context) {
-		data = CGBitmapContextGetData(context);
-		bytes_per_line = CGBitmapContextGetBytesPerRow(context);
+
+	NSSize image_size = NSMakeSize(width, height);
+	NSImage* ns_image = [[NSImage alloc]initWithSize:image_size];
+	[ns_image addRepresentation:bitmap_rep];
+ 
+	/* Assume premultiplied nonplanar data with 4 bytes per pixel and alpha last.*/
+	if ( [bitmap_rep bitmapFormat] == 0 &&
+	     [bitmap_rep isPlanar ] == 0 &&
+	     [bitmap_rep samplesPerPixel] == 4 ) {
+	    bytes_per_row = [bitmap_rep bytesPerRow];
+	    size = bytes_per_row*height;
+	    image_data = (char*)[bitmap_rep bitmapData];
+	    if ( image_data ) {
+		int row, n, m;
+		bitmap = ckalloc(size);
+		/*
+		  Oddly enough, the bitmap has the top row at the beginning,
+		  and the pixels are in BGRA format.
+		*/
+		for (row=0, n=0; row<height; row++, n+=bytes_per_row) {
+		    for (m=n; m<n+bytes_per_row; m+=4) {
+			*(bitmap+m)     = *(image_data+m+2);
+			*(bitmap+m+1) = *(image_data+m+1);
+			*(bitmap+m+2) = *(image_data+m);
+			*(bitmap+m+3) = *(image_data+m+3);
+		    }
+		}
 	    }
 	}
-	if (data) {
+	if (bitmap) {
 	    imagePtr = XCreateImage(display, NULL, depth, format, offset,
-		    data, width, height, bitmap_pad, bytes_per_line);
-
-	    /*
-	     * Track Pixmap underlying the XImage in the unused obdata field
-	     * so that we can treat XImages coming from XGetImage specially.
-	     */
-
-	    imagePtr->obdata = (XPointer) pixmap;
-	} else if (pixmap) {
-	    Tk_FreePixmap(display, pixmap);
-	}
-	if (!win) {
-	    XFreeGC(display, gc);
+				    (char*)bitmap, width, height, bitmap_pad, bytes_per_row);
+	    [ns_image removeRepresentation:bitmap_rep]; /*releases the rep*/
+	    [ns_image release];
 	}
     } else {
-	TkMacOSXDbgMsg("Invalid image format");
+	TkMacOSXDbgMsg("Could not extract image from drawable.");
     }
     return imagePtr;
 }
@@ -968,9 +978,7 @@ DestroyImage(
     XImage *image)
 {
     if (image) {
-	if (image->obdata) {
-	    Tk_FreePixmap((Display*) gMacDisplay, (Pixmap) image->obdata);
-	} else if (image->data) {
+	if (image->data) {
 	    ckfree(image->data);
 	}
 	ckfree((char*) image);