--- ./gd.c.org	Thu Jul  1 23:30:30 2004
+++ ./gd.c	Thu Aug 12 14:42:03 2004
@@ -738,14 +738,27 @@
     default:
       if (gdImageBoundsSafeMacro (im, x, y))
 	{
-	  if (im->trueColor)
-	    {
-	      if (im->alphaBlendingFlag)
-		{
-		  im->tpixels[y][x] = gdAlphaBlend (im->tpixels[y][x], color);
-		}
-	      else
-		{
+	  if (im->trueColor) {
+	      if (im->alphaBlendingFlag) {
+		      switch (im->alphaBlendingFlag) {
+			      default:
+				      im->tpixels[y][x] = gdAlphaBlend (im->tpixels[y][x], color);
+				      break;
+			      case gdEffectReplace:
+				      im->tpixels[y][x] = color;
+				      break;
+/*			      case gdEffectAlphaBlend:
+				      im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
+				      break;
+			      case gdEffectNormal:
+				      im->tpixels[y][x] = gdFullAlphaBlend(im->tpixels[y][x], color);
+				      break;
+			      case gdEffectOverlay :
+				      im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color);
+				      break; */
+		      }
+		      
+	      } else {
 		  im->tpixels[y][x] = color;
 		}
 	    }
@@ -2261,6 +2274,496 @@
     }
 }
 
+/* Taken from php... dirty hack... */
+/*
+ * Rotate function Added on 2003/12 
+ * by Pierre-Alain Joye (pajoye@pearfr.org)
+ **/
+/* Begin rotate function */
+#ifdef ROTATE_PI
+#undef ROTATE_PI
+#endif /* ROTATE_PI */
+
+#define ROTATE_DEG2RAD  3.1415926535897932384626433832795/180
+BGD_DECLARE(void) gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, double dWeight, int clrBack)
+{
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        int i, r, g, b, a, clrBackR, clrBackG, clrBackB, clrBackA;
+        FuncPtr f;
+
+        int pxlOldLeft, pxlLeft=0, pxlSrc; 
+
+        /* Keep clrBack as color index if required */
+        if (src->trueColor) {
+                pxlOldLeft = clrBack; 
+                f = gdImageGetTrueColorPixel;
+        } else {
+                pxlOldLeft = clrBack;
+                clrBackR = gdImageRed(src, clrBack);
+                clrBackG = gdImageGreen(src, clrBack);
+                clrBackB = gdImageBlue(src, clrBack);
+                clrBackA = gdImageAlpha(src, clrBack);
+                clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA);
+                f = gdImageGetPixel;
+        }
+
+        for (i = 0; i < iOffset; i++) {
+                gdImageSetPixel (dst, i, uRow, clrBack);
+        }
+
+        if (i < dst->sx) {
+                gdImageSetPixel (dst, i, uRow, clrBack);
+        }
+
+        for (i = 0; i < src->sx; i++) {
+                pxlSrc = f (src,i,uRow);
+
+                r = (int)(gdImageRed(src,pxlSrc) * dWeight);
+                g = (int)(gdImageGreen(src,pxlSrc) * dWeight);
+                b = (int)(gdImageBlue(src,pxlSrc) * dWeight);
+                a = (int)(gdImageAlpha(src,pxlSrc) * dWeight);
+
+                pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
+
+                if (pxlLeft == -1) {
+                        pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
+                }
+
+                r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft));
+                g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft));
+                b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft));
+                a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft));
+
+        if (r>255) {
+                r = 255;
+        }
+
+                if (g>255) {
+                        g = 255;
+                }
+
+                if (b>255) {
+                        b = 255;
+                }
+
+                if (a>127) {
+                        a = 127;
+                }
+
+                pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
+
+                if (pxlSrc == -1) {
+                        pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a);
+                }
+
+                if ((i + iOffset >= 0) && (i + iOffset < dst->sx)) {
+                        gdImageSetPixel (dst, i+iOffset, uRow,  pxlSrc);
+                }
+
+                pxlOldLeft = pxlLeft;
+        }
+
+        i += iOffset;
+
+        if (i < dst->sx) {
+                gdImageSetPixel (dst, i, uRow, pxlLeft);
+        }
+
+        gdImageSetPixel (dst, iOffset, uRow, clrBack);
+
+        i--;
+
+        while (++i < dst->sx) {
+                gdImageSetPixel (dst, i, uRow, clrBack);
+        }
+}
+
+void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, double dWeight, int clrBack)
+{
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        int i, iYPos=0, r, g, b, a;
+        FuncPtr f;
+        int pxlOldLeft, pxlLeft=0, pxlSrc;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+
+        for (i = 0; i<=iOffset; i++) {
+                gdImageSetPixel (dst, uCol, i, clrBack);
+        }
+        r = (int)((double)gdImageRed(src,clrBack) * dWeight);
+        g = (int)((double)gdImageGreen(src,clrBack) * dWeight);
+        b = (int)((double)gdImageBlue(src,clrBack) * dWeight);
+        a = (int)((double)gdImageAlpha(src,clrBack) * dWeight);
+
+        pxlOldLeft = gdImageColorAllocateAlpha(dst, r, g, b, a);
+
+        for (i = 0; i < src->sy; i++) {
+                pxlSrc = f (src, uCol, i);
+                iYPos = i + iOffset;
+
+                r = (int)((double)gdImageRed(src,pxlSrc) * dWeight);
+                g = (int)((double)gdImageGreen(src,pxlSrc) * dWeight);
+                b = (int)((double)gdImageBlue(src,pxlSrc) * dWeight);
+                a = (int)((double)gdImageAlpha(src,pxlSrc) * dWeight);
+
+                pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
+
+                if (pxlLeft == -1) {
+                        pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
+                }
+
+                r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft));
+                g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft));
+                b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft));
+                a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft));
+
+                if (r>255) {
+                        r = 255;
+                }
+
+                if (g>255) {
+                        g = 255;
+                }
+
+                if (b>255) {
+                        b = 255;
+                }
+
+                if (a>127) {
+                        a = 127;
+                }
+
+                pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
+
+                if (pxlSrc == -1) {
+                        pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a);
+                }
+
+                if ((iYPos >= 0) && (iYPos < dst->sy)) {
+                        gdImageSetPixel (dst, uCol, iYPos, pxlSrc);
+                }
+
+                pxlOldLeft = pxlLeft;
+        }
+
+        i = iYPos;
+        if (i < dst->sy) {
+                gdImageSetPixel (dst, uCol, i, pxlLeft);
+        }
+
+        i--;
+        while (++i < dst->sy) {
+                gdImageSetPixel (dst, uCol, i, clrBack);
+        }
+}
+
+/* Rotates an image by 90 degrees (counter clockwise) */
+BGD_DECLARE(gdImagePtr) gdImageRotate90 (gdImagePtr src)
+{
+        int uY, uX;
+        int c, r,g,b,a;
+        gdImagePtr dst;
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        FuncPtr f;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst = gdImageCreateTrueColor(src->sy, src->sx);
+
+        if (dst != NULL) {
+                gdImagePaletteCopy (dst, src);
+
+                for (uY = 0; uY<src->sy; uY++) {
+                        for (uX = 0; uX<src->sx; uX++) {
+                                c = f (src, uX, uY);
+                                if (!src->trueColor) {
+                                        r = gdImageRed(src,c);
+                                        g = gdImageGreen(src,c);
+                                        b = gdImageBlue(src,c);
+                                        a = gdImageAlpha(src,c);
+                                        c = gdTrueColorAlpha(r, g, b, a);
+                                }
+                                gdImageSetPixel(dst, uY, (dst->sy - uX - 1), c);
+                        }
+                }
+        }
+
+        return dst;
+}
+
+/* Rotates an image by 180 degrees (counter clockwise) */
+BGD_DECLARE(gdImagePtr) gdImageRotate180 (gdImagePtr src)
+{
+        int uY, uX;
+        int c,r,g,b,a;
+        gdImagePtr dst;
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        FuncPtr f;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst = gdImageCreateTrueColor(src->sx, src->sy);
+
+        if (dst != NULL) {
+                gdImagePaletteCopy (dst, src);
+
+                for (uY = 0; uY<src->sy; uY++) {
+                        for (uX = 0; uX<src->sx; uX++) {
+                                c = f (src, uX, uY);
+                                if (!src->trueColor) {
+                                        r = gdImageRed(src,c);
+                                        g = gdImageGreen(src,c);
+                                        b = gdImageBlue(src,c);
+                                        a = gdImageAlpha(src,c);
+                                        c = gdTrueColorAlpha(r, g, b, a);
+                                }
+                                gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), c);
+                        }
+                }
+        }
+
+        return dst;
+}
+
+/* Rotates an image by 270 degrees (counter clockwise) */
+BGD_DECLARE(gdImagePtr) gdImageRotate270 ( gdImagePtr src )
+{
+        int uY, uX;
+        int c,r,g,b,a;
+        gdImagePtr dst;
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        FuncPtr f;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst = gdImageCreateTrueColor(src->sy, src->sx);
+
+        if (dst != NULL) {
+                gdImagePaletteCopy (dst, src);
+
+                for (uY = 0; uY<src->sy; uY++) {
+                        for (uX = 0; uX<src->sx; uX++) {
+                                c = f (src, uX, uY);
+                                if (!src->trueColor) {
+                                        r = gdImageRed(src,c);
+                                        g = gdImageGreen(src,c);
+                                        b = gdImageBlue(src,c);
+                                        a = gdImageAlpha(src,c);
+                                        c = gdTrueColorAlpha(r, g, b, a);
+                                }
+                                gdImageSetPixel(dst, (dst->sx - uY - 1), uX, c);
+                        }
+                }
+        }
+
+        return dst;
+}
+
+BGD_DECLARE(gdImagePtr) gdImageRotate45 (gdImagePtr src, double dAngle, int clrBack)
+{
+        typedef int (*FuncPtr)(gdImagePtr, int, int);
+        gdImagePtr dst1,dst2,dst3;
+        FuncPtr f;
+        double dRadAngle, dSinE, dTan, dShear;
+        double dOffset;     /* Variable skew offset */
+        int u, iShear, newx, newy;
+        int clrBackR, clrBackG, clrBackB, clrBackA;
+
+        /* See GEMS I for the algorithm details */
+        dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
+        dSinE = sin (dRadAngle);
+        dTan = tan (dRadAngle / 2.0);
+
+        newx = (int)(src->sx + src->sy * fabs(dTan));
+        newy = src->sy;
+
+        /* 1st shear */
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst1 = gdImageCreateTrueColor(newx, newy);
+
+        /******* Perform 1st shear (horizontal) ******/
+        if (dst1 == NULL) {
+                return NULL;
+        }
+        dst1->alphaBlendingFlag = gdEffectReplace;
+
+        if (dAngle == 0.0) {
+                /* Returns copy of src */
+                gdImageCopy (dst1, src,0,0,0,0,src->sx,src->sy);
+                return dst1;
+        }
+
+        gdImagePaletteCopy (dst1, src);
+
+        dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
+        dSinE = sin (dRadAngle);
+        dTan = tan (dRadAngle / 2.0);
+
+        for (u = 0; u < dst1->sy; u++) {
+                if (dTan >= 0.0) {
+                        dShear = ((double)(u + 0.5)) * dTan;
+                } else {
+                        dShear = ((double)(u - dst1->sy) + 0.5) * dTan;
+                }
+
+                iShear = (int)floor(dShear);
+                gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack);
+        }
+
+        /*
+        The 1st shear may use the original clrBack as color index
+        Convert it once here
+        */
+        if(!src->trueColor) {
+                clrBackR = gdImageRed(src, clrBack);
+                clrBackG = gdImageGreen(src, clrBack);
+                clrBackB = gdImageBlue(src, clrBack);
+                clrBackA = gdImageAlpha(src, clrBack);
+                clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA);
+        }
+        /* 2nd shear */
+        newx = dst1->sx;
+
+        if (dSinE > 0.0) {
+                dOffset = (src->sx-1) * dSinE;
+        } else {
+                dOffset = -dSinE *  (src->sx - newx);
+        }
+
+        newy = (int) ((double) src->sx * fabs( dSinE ) + (double) src->sy * cos (dRadAngle))+1;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst2 = gdImageCreateTrueColor(newx, newy);
+        if (dst2 == NULL) {
+                gdImageDestroy(dst1);
+                return NULL;
+        }
+        dst2->alphaBlendingFlag = gdEffectReplace;
+
+        for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) {
+                iShear = (int)floor (dOffset);
+                gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), clrBack);
+        }
+
+        /* 3rd shear */
+        gdImageDestroy(dst1);
+
+        newx = (int) ((double)src->sy * fabs (dSinE) + (double)src->sx * cos (dRadAngle)) + 1;
+        newy = dst2->sy;
+
+        if (src->trueColor) {
+                f = gdImageGetTrueColorPixel;
+        } else {
+                f = gdImageGetPixel;
+        }
+        dst3 = gdImageCreateTrueColor(newx, newy);
+        if (dst3 == NULL) {
+                gdImageDestroy(dst2);
+                return NULL;
+        }
+        if (dSinE >= 0.0) {
+                dOffset = (double)(src->sx - 1) * dSinE * -dTan;
+        } else {
+                dOffset = dTan * ((double)(src->sx - 1) * -dSinE + (double)(1 - newy));
+        }
+
+        for (u = 0; u < dst3->sy; u++, dOffset += dTan) {
+                int iShear = (int)floor(dOffset);
+                gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), clrBack);
+        }
+
+        gdImageDestroy(dst2);
+
+        return dst3;
+}
+
+BGD_DECLARE(gdImagePtr) gdImageRotate (gdImagePtr src, double dAngle, int clrBack)
+{
+        gdImagePtr pMidImg;
+        gdImagePtr rotatedImg;
+        int r,g,b,a;
+        if (src == NULL) {
+                return NULL;
+        }
+
+        if (!gdImageTrueColor(src) && clrBack>=gdImageColorsTotal(src)) {
+                return NULL;
+        }
+
+        while (dAngle >= 360.0) {
+                dAngle -= 360.0;
+        }
+
+        while (dAngle < 0) {
+                dAngle += 360.0;
+        }
+
+        if (dAngle == 90.00) {
+                return gdImageRotate90(src);
+        }
+        if (dAngle == 180.00) {
+                return gdImageRotate180(src);
+        }
+        if(dAngle == 270.00) {
+                return gdImageRotate270 ( src);
+        }
+
+        if ((dAngle > 45.0) && (dAngle <= 135.0)) {
+                pMidImg = gdImageRotate90 (src);
+                dAngle -= 90.0;
+        } else if ((dAngle > 135.0) && (dAngle <= 225.0)) {
+                pMidImg = gdImageRotate180 (src);
+                dAngle -= 180.0;
+        } else if ((dAngle > 225.0) && (dAngle <= 315.0)) {
+                pMidImg = gdImageRotate270 (src);
+                dAngle -= 270.0;
+        } else {
+                return gdImageRotate45 (src, dAngle, clrBack);
+        }
+
+        if (pMidImg == NULL) {
+                return NULL;
+        }
+
+        if(!src->trueColor) {
+                r = gdImageRed(src, clrBack);
+                g = gdImageGreen(src, clrBack);
+                b = gdImageBlue(src, clrBack);
+                a = gdImageAlpha(src, clrBack);
+                clrBack =  gdTrueColorAlpha(r,g,b,a);
+        }
+
+        rotatedImg = gdImageRotate45 (pMidImg, dAngle, clrBack);
+        gdImageDestroy(pMidImg);
+
+        return rotatedImg;
+}
+/* End Rotate function */
+
+
+/* End of part taken from php... dirty hack... */
+
 /* When gd 1.x was first created, floating point was to be avoided.
    These days it is often faster than table lookups or integer
    arithmetic. The routine below is shamelessly, gloriously
--- ./gd.h.org	Thu Aug 12 13:22:18 2004
+++ ./gd.h	Thu Aug 12 13:44:33 2004
@@ -106,6 +106,10 @@
 #define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
 #define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
 #define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
+#define gdEffectReplace 0
+#define gdEffectAlphaBlend 1
+#define gdEffectNormal 2
+#define gdEffectOverlay 3
 
 /* This function accepts truecolor pixel values only. The 
 	source color is composited with the destination color
@@ -617,6 +621,12 @@
 			   int srcX, int srcY,
 			   int srcWidth, int srcHeight, int angle);
 
+gdImagePtr gdImageRotate90(gdImagePtr src);
+gdImagePtr gdImageRotate180(gdImagePtr src);
+gdImagePtr gdImageRotate270(gdImagePtr src);
+gdImagePtr gdImageRotate45(gdImagePtr src, double dAngle, int clrBack);
+gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack);
+
 BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush);
 BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile);
 BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c);