Tk Source Code

Artifact [fe6f9738]
Login

Artifact fe6f97381de2dc6645fb510423499f8d44fef923:

Attachment "alpha-hobbs6.patch" to ticket [809157ff] added by hobbs 2003-10-30 06:08:46.
Index: generic/tkImgPhoto.c
===================================================================
RCS file: /cvsroot/tktoolkit/tk/generic/tkImgPhoto.c,v
retrieving revision 1.36.2.2
diff -u -r1.36.2.2 tkImgPhoto.c
--- generic/tkImgPhoto.c	17 Jul 2003 13:05:53 -0000	1.36.2.2
+++ generic/tkImgPhoto.c	29 Oct 2003 23:05:57 -0000
@@ -178,10 +178,13 @@
  *				components.
  * IMAGE_CHANGED:		1 means that the instances of this image
  *				need to be redithered.
+ * COMPLEX_ALPHA:		1 means that the instances of this image
+ *				have alpha values that aren't 0 or 255.
  */
 
 #define COLOR_IMAGE		1
 #define IMAGE_CHANGED		2
+#define COMPLEX_ALPHA		4
 
 /*
  * The following data structure represents all of the instances of
@@ -374,6 +377,14 @@
  * Forward declarations
  */
 
+static int              ToggleComplexAlphaIfNeeded _ANSI_ARGS_((
+                            PhotoMaster *mPtr));
+
+static void             ImgBlendComplexAlphaPhoto _ANSI_ARGS_((XImage *bgImg,
+				PhotoInstance *iPtr,
+				int xOffset, int yOffset,
+				int width, int height));
+
 static void		PhotoFormatThreadExitProc _ANSI_ARGS_((
 			    ClientData clientData));
 static int		ImgPhotoCmd _ANSI_ARGS_((ClientData clientData,
@@ -430,6 +441,124 @@
 #undef MAX
 #define MAX(a, b)	((a) > (b)? (a): (b))
 
+
+static int
+ToggleComplexAlphaIfNeeded(PhotoMaster *mPtr)
+{
+    size_t len = MAX(mPtr->userWidth, mPtr->width) *
+	MAX(mPtr->userHeight, mPtr->height) * 4;
+    unsigned char *c   = mPtr->pix32;
+    unsigned char *end = c + len;
+
+    /*
+     * Set the COMPLEX_ALPHA flag if we have an image with partially
+     * transparent bits.
+     */
+    mPtr->flags &= ~COMPLEX_ALPHA;
+    c += 3; /* start at first alpha byte */
+    for (; c < end; c += 4) {
+	if (*c && *c != 255) {
+     	    mPtr->flags |= COMPLEX_ALPHA;
+	    break;
+	}
+    }
+    return (mPtr->flags & COMPLEX_ALPHA);
+}
+
+#ifndef GetRValue
+/*
+ * This should work on all machines, as is accesses the mask and shift data
+ * from the visualInfo. -- hobbs
+ */
+#define GetRValue(rgb)	(UCHAR((rgb & red_mask) >> red_shift))
+#define GetGValue(rgb)	(UCHAR((rgb & green_mask) >> green_shift))
+#define GetBValue(rgb)	(UCHAR((rgb & blue_mask) >> blue_shift))
+// This is the 24+ bpp version only
+//#define RGB(r,g,b)      ((unsigned)((UCHAR(r)<<red_shift)|(UCHAR(g)<<green_shift)|(UCHAR(b)<<blue_shift)))
+// This version works for 16bpp+, but it slower
+#define RGB(r,g,b)      ((unsigned)(((r*red_mask/255)&red_mask)|((g*green_mask/255)&green_mask)|((b*blue_mask/255)&blue_mask)))
+#endif
+
+static void ImgBlendComplexAlphaPhoto (
+    XImage *bgImg,
+    PhotoInstance *iPtr,
+    int xOffset, int yOffset,
+    int width, int height
+    )
+{
+    int x, y, line;
+    unsigned long pixel;
+    unsigned char r, g, b, alpha, unalpha;
+    unsigned char *alphaAr = iPtr->masterPtr->pix32;
+    unsigned char *masterPtr;
+#ifndef __WIN32__
+    /*
+     * We have to get the mask and shift info from the visual.
+     * This might be cached for better performance.
+     */
+    unsigned long red_mask, green_mask, blue_mask;
+    unsigned long red_shift, green_shift, blue_shift;
+    Visual *visual = iPtr->visualInfo.visual;
+
+    red_mask    = visual->red_mask;
+    green_mask  = visual->green_mask;
+    blue_mask   = visual->blue_mask;
+    red_shift   = 0;
+    green_shift = 0;
+    blue_shift  = 0;
+    while ((0x0001 & (red_mask >> red_shift)) == 0)	red_shift++;
+    while ((0x0001 & (green_mask >> green_shift)) == 0)	green_shift++;
+    while ((0x0001 & (blue_mask >> blue_shift)) == 0)	blue_shift++;
+#endif
+
+#define ALPHA_BLEND(bgPix, imgPix, alpha, unalpha) \
+		((bgPix * unalpha + imgPix * alpha) / 255)
+
+    for (y = 0; y < height; y++) {
+	line = (y + yOffset) * iPtr->masterPtr->width;
+	for (x = 0; x < width; x++) {
+	    masterPtr = alphaAr + ((line + x + xOffset) * 4);
+	    alpha     = masterPtr[3];
+	    /*
+	     * Ignore pixels that are fully transparent
+	     */
+	    if (alpha) {
+		/*
+		 * We could perhaps be more efficient than XGetPixel for
+		 * 24 and 32 bit displays, but this seems "fast enough".
+		 */
+		r = masterPtr[0];
+		g = masterPtr[1];
+		b = masterPtr[2];
+		if (alpha != 255) {
+		    /*
+		     * Only blend pixels that have some transparency
+		     */
+		    unsigned char ra, ga, ba;
+
+		    pixel = XGetPixel(bgImg, x, y);
+		    ra = GetRValue(pixel);
+		    ga = GetGValue(pixel);
+		    ba = GetBValue(pixel);
+		    unalpha = 255 - alpha;
+#ifndef __WIN32__
+		    if (bgImg->depth == 16) {
+			ra = UCHAR(ra << 3);
+			ga = UCHAR(ga << 3);
+			ba = UCHAR(ba << 3);
+		    }
+#endif
+		    r = ALPHA_BLEND(ra, r, alpha, unalpha);
+		    g = ALPHA_BLEND(ga, g, alpha, unalpha);
+		    b = ALPHA_BLEND(ba, b, alpha, unalpha);
+		}
+		XPutPixel(bgImg, x, y, RGB(r, g, b));
+	    }
+	}
+    }
+#undef ALPHA_BLEND
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -2082,6 +2211,9 @@
     if (oldFormat != NULL) {
 	Tcl_DecrRefCount(oldFormat);
     }
+
+    ToggleComplexAlphaIfNeeded(masterPtr);
+
     return TCL_OK;
 
   errorExit:
@@ -2234,7 +2366,6 @@
 		    validBox.width, validBox.height);
 	}
     }
-
 }
 
 /*
@@ -2471,21 +2602,47 @@
 	return;
     }
 
-    /*
-     * masterPtr->region describes which parts of the image contain
-     * valid data.  We set this region as the clip mask for the gc,
-     * setting its origin appropriately, and use it when drawing the
-     * image.
-     */
+    if ((instancePtr->masterPtr->flags & COMPLEX_ALPHA)
+	    && instancePtr->visualInfo.depth >= 16) {
+	XImage *bgImg = NULL;
 
-    TkSetRegion(display, instancePtr->gc, instancePtr->masterPtr->validRegion);
-    XSetClipOrigin(display, instancePtr->gc, drawableX - imageX,
-	    drawableY - imageY);
-    XCopyArea(display, instancePtr->pixels, drawable, instancePtr->gc,
-	    imageX, imageY, (unsigned) width, (unsigned) height,
-	    drawableX, drawableY);
-    XSetClipMask(display, instancePtr->gc, None);
-    XSetClipOrigin(display, instancePtr->gc, 0, 0);
+	/*
+	 * Pull the current background from the display to blend with
+	 */
+	bgImg = XGetImage(display, drawable, drawableX, drawableY,
+		(unsigned int)width, (unsigned int)height, AllPlanes, ZPixmap);
+	if (bgImg == NULL) {
+	    return;
+	}
+
+	ImgBlendComplexAlphaPhoto(bgImg, instancePtr,
+		imageX, imageY, width, height);
+
+	/*
+	 * Color info is unimportant as we only do this operation for
+	 * depth >= 16.
+	 */
+	TkPutImage(NULL, 0, display, drawable, instancePtr->gc,
+		bgImg, 0, 0, drawableX, drawableY,
+		(unsigned int) width, (unsigned int) height);
+	XDestroyImage(bgImg);
+    } else {
+	/*
+	 * masterPtr->region describes which parts of the image contain
+	 * valid data.  We set this region as the clip mask for the gc,
+	 * setting its origin appropriately, and use it when drawing the
+	 * image.
+	 */
+	TkSetRegion(display, instancePtr->gc, instancePtr->masterPtr->validRegion);
+	XSetClipOrigin(display, instancePtr->gc, drawableX - imageX,
+	               drawableY - imageY);
+	XCopyArea(display, instancePtr->pixels, drawable, instancePtr->gc,
+	          imageX, imageY, (unsigned) width, (unsigned) height,
+	          drawableX, drawableY);
+	XSetClipMask(display, instancePtr->gc, None);
+	XSetClipOrigin(display, instancePtr->gc, 0, 0);
+    }
+    XFlush (display);
 }
 
 /*
@@ -2789,6 +2946,8 @@
 	    masterPtr->ditherY = 0;
 	}
     }
+
+    ToggleComplexAlphaIfNeeded(masterPtr);
 
     /*
      * Now adjust the sizes of the pixmaps for all of the instances.