SOURCES: gd-rotate_from_php.patch - updated from php 5.2.0 (incomp...

qboosh qboosh at pld-linux.org
Sat Dec 23 02:55:19 CET 2006


Author: qboosh                       Date: Sat Dec 23 01:55:19 2006 GMT
Module: SOURCES                       Tag: HEAD
---- Log message:
- updated from php 5.2.0 (incompatible with older php!)

---- Files affected:
SOURCES:
   gd-rotate_from_php.patch (1.2 -> 1.3) 

---- Diffs:

================================================================
Index: SOURCES/gd-rotate_from_php.patch
diff -u SOURCES/gd-rotate_from_php.patch:1.2 SOURCES/gd-rotate_from_php.patch:1.3
--- SOURCES/gd-rotate_from_php.patch:1.2	Thu Aug 12 14:50:57 2004
+++ SOURCES/gd-rotate_from_php.patch	Sat Dec 23 02:55:14 2006
@@ -1,6 +1,17 @@
---- ./gd.c.org	Thu Jul  1 23:30:30 2004
-+++ ./gd.c	Thu Aug 12 14:42:03 2004
-@@ -738,14 +738,27 @@
+--- gd-2.0.33/gd.c.orig	2006-12-23 02:27:25.723423857 +0100
++++ gd-2.0.33/gd.c	2006-12-23 02:31:59.599031139 +0100
+@@ -65,6 +65,10 @@
+ 
+ static void gdImageBrushApply (gdImagePtr im, int x, int y);
+ static void gdImageTileApply (gdImagePtr im, int x, int y);
++/* from php */
++static int gdLayerOverlay(int dst, int src);
++static int gdAlphaOverlayColor(int src, int dst, int max);
++/* end from php */
+ BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y);
+ 
+ BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy)
+@@ -761,16 +765,22 @@
      default:
        if (gdImageBoundsSafeMacro (im, x, y))
  	{
@@ -12,37 +23,34 @@
 -		}
 -	      else
 -		{
+-		  im->tpixels[y][x] = color;
+-		}
 +	  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:
++			      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);
++				      im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
 +				      break;
 +			      case gdEffectOverlay :
 +				      im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color);
-+				      break; */
++				      break;
 +		      }
-+		      
-+	      } else {
- 		  im->tpixels[y][x] = color;
- 		}
  	    }
-@@ -2261,6 +2274,496 @@
+ 	  else
+ 	    {
+@@ -2287,6 +2297,564 @@
      }
  }
  
-+/* Taken from php... dirty hack... */
++/* Taken from php */
 +/*
-+ * Rotate function Added on 2003/12 
++ * Rotate function Added on 2003/12
 + * by Pierre-Alain Joye (pajoye at pearfr.org)
 + **/
 +/* Begin rotate function */
@@ -51,491 +59,559 @@
 +#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)
++BGD_DECLARE(void) gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, double dWeight, int clrBack, int ignoretransparent)
 +{
-+        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);
-+        }
++	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;
++		}
++
++		if (ignoretransparent && pxlSrc == dst->transparent) {
++			pxlSrc = dst->transparent;
++		} else {
++			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)
++void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, double dWeight, int clrBack, int ignoretransparent)
 +{
-+        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);
-+        }
++	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;
++		}
++
++		if (ignoretransparent && pxlSrc == dst->transparent) {
++			pxlSrc = dst->transparent;
++		} else {
++			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)
++BGD_DECLARE(gdImagePtr) gdImageRotate90 (gdImagePtr src, int ignoretransparent)
 +{
-+        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);
-+                        }
-+                }
-+        }
++	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);
++	dst->transparent = src->transparent;
++
++	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);
++				}
++				if (ignoretransparent && c == dst->transparent) {
++					gdImageSetPixel(dst, uY, (dst->sy - uX - 1), dst->transparent);
++				} else {
++					gdImageSetPixel(dst, uY, (dst->sy - uX - 1), c);
++				}
++			}
++		}
++	}
 +
-+        return dst;
++	return dst;
 +}
 +
 +/* Rotates an image by 180 degrees (counter clockwise) */
-+BGD_DECLARE(gdImagePtr) gdImageRotate180 (gdImagePtr src)
++BGD_DECLARE(gdImagePtr) gdImageRotate180 (gdImagePtr src, int ignoretransparent)
 +{
-+        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);
-+                        }
-+                }
-+        }
++	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);
++	dst->transparent = src->transparent;
++
++	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);
++				}
++
++				if (ignoretransparent && c == dst->transparent) {
++					gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), dst->transparent);
++				} else {
++					gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), c);
++				}
++			}
++		}
++	}
 +
-+        return dst;
++	return dst;
 +}
 +
 +/* Rotates an image by 270 degrees (counter clockwise) */
-+BGD_DECLARE(gdImagePtr) gdImageRotate270 ( gdImagePtr src )
++BGD_DECLARE(gdImagePtr) gdImageRotate270 (gdImagePtr src, int ignoretransparent)
 +{
-+        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);
<<Diff was trimmed, longer than 597 lines>>

---- CVS-web:
    http://cvs.pld-linux.org/SOURCES/gd-rotate_from_php.patch?r1=1.2&r2=1.3&f=u



More information about the pld-cvs-commit mailing list