new build system

git-svn-id: svn://tug.org/texlive/trunk@12450 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 198 insertions, 0 deletions

diff --git a/Build/source/libs/gd/gd-2.0.35/gddemo.c b/Build/source/libs/gd/gd-2.0.35/gddemo.c
new file mode 100644
index 00000000000..c804ee97593
--- /dev/null
+++ b/Build/source/libs/gd/gd-2.0.35/gddemo.c
@@ -0,0 +1,198 @@
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdfontt.h"
+#include "gdfonts.h"
+#include "gdfontmb.h"
+#include "gdfontl.h"
+#include "gdfontg.h"
+
+int
+main (void)
+{
+#ifdef HAVE_LIBPNG
+  /* Input and output files */
+  FILE *in;
+  FILE *out;
+
+  /* Input and output images */
+  gdImagePtr im_in = 0, im_out = 0;
+
+  /* Brush image */
+  gdImagePtr brush;
+
+  /* Color indexes */
+  int white;
+  int blue;
+  int red;
+  int green;
+
+  /* Points for polygon */
+  gdPoint points[3];
+  int i;
+
+  /* gd fonts for font test */
+  gdFontPtr fonts[5];
+  int y;
+
+  /* Create output image, in true color. */
+  im_out = gdImageCreateTrueColor (256 + 384, 384);
+  /* 2.0.2: first color allocated would automatically be background in a 
+     palette based image. Since this is a truecolor image, with an 
+     automatic background of black, we must fill it explicitly. */
+  white = gdImageColorAllocate (im_out, 255, 255, 255);
+  gdImageFilledRectangle (im_out, 0, 0, gdImageSX (im_out),
+			  gdImageSY (im_out), white);
+
+  /* Set transparent color. */
+  gdImageColorTransparent (im_out, white);
+
+  /* Try to load demoin.png and paste part of it into the
+     output image. */
+  in = fopen ("demoin.png", "rb");
+  if (!in)
+    {
+      fprintf (stderr, "Can't load source image; this demo\n");
+      fprintf (stderr, "is much more impressive if demoin.png\n");
+      fprintf (stderr, "is available.\n");
+      im_in = 0;
+    }
+  else
+    {
+      int a;
+      im_in = gdImageCreateFromPng (in);
+      fclose (in);
+      /* Now copy, and magnify as we do so */
+      gdImageCopyResampled (im_out, im_in, 32, 32, 0, 0, 192, 192, 255, 255);
+      /* Now display variously rotated space shuttles in a circle of our own */
+      for (a = 0; (a < 360); a += 45)
+	{
+	  int cx = cos (a * .0174532925) * 128;
+	  int cy = -sin (a * .0174532925) * 128;
+	  gdImageCopyRotated (im_out, im_in,
+			      256 + 192 + cx, 192 + cy,
+			      0, 0, gdImageSX (im_in), gdImageSY (im_in), a);
+	}
+    }
+  red = gdImageColorAllocate (im_out, 255, 0, 0);
+  green = gdImageColorAllocate (im_out, 0, 255, 0);
+  blue = gdImageColorAllocate (im_out, 0, 0, 255);
+  /* Fat Rectangle */
+  gdImageSetThickness (im_out, 4);
+  gdImageLine (im_out, 16, 16, 240, 16, green);
+  gdImageLine (im_out, 240, 16, 240, 240, green);
+  gdImageLine (im_out, 240, 240, 16, 240, green);
+  gdImageLine (im_out, 16, 240, 16, 16, green);
+  gdImageSetThickness (im_out, 1);
+  /* Circle */
+  gdImageArc (im_out, 128, 128, 60, 20, 0, 720, blue);
+  /* Arc */
+  gdImageArc (im_out, 128, 128, 40, 40, 90, 270, blue);
+  /* Flood fill: doesn't do much on a continuously
+     variable tone jpeg original. */
+  gdImageFill (im_out, 8, 8, blue);
+  /* Polygon */
+  points[0].x = 64;
+  points[0].y = 0;
+  points[1].x = 0;
+  points[1].y = 128;
+  points[2].x = 128;
+  points[2].y = 128;
+  gdImageFilledPolygon (im_out, points, 3, green);
+  /* 2.0.12: Antialiased Polygon */
+  gdImageSetAntiAliased (im_out, green);
+  for (i = 0; (i < 3); i++)
+    {
+      points[i].x += 128;
+    }
+  gdImageFilledPolygon (im_out, points, 3, gdAntiAliased);
+  /* Brush. A fairly wild example also involving a line style! */
+  if (im_in)
+    {
+      int style[8];
+      brush = gdImageCreateTrueColor (16, 16);
+      gdImageCopyResized (brush, im_in,
+			  0, 0, 0, 0,
+			  gdImageSX (brush), gdImageSY (brush),
+			  gdImageSX (im_in), gdImageSY (im_in));
+      gdImageSetBrush (im_out, brush);
+      /* With a style, so they won't overprint each other.
+         Normally, they would, yielding a fat-brush effect. */
+      style[0] = 0;
+      style[1] = 0;
+      style[2] = 0;
+      style[3] = 0;
+      style[4] = 0;
+      style[5] = 0;
+      style[6] = 0;
+      style[7] = 1;
+      gdImageSetStyle (im_out, style, 8);
+      /* Draw the styled, brushed line */
+      gdImageLine (im_out, 0, 255, 255, 0, gdStyledBrushed);
+    }
+  /* Text (non-truetype; see gdtestft for a freetype demo) */
+  fonts[0] = gdFontGetTiny ();
+  fonts[1] = gdFontGetSmall ();
+  fonts[2] = gdFontGetMediumBold ();
+  fonts[3] = gdFontGetLarge ();
+  fonts[4] = gdFontGetGiant ();
+  y = 0;
+  for (i = 0; (i <= 4); i++)
+    {
+      gdImageString (im_out, fonts[i], 32, 32 + y, (unsigned char *) "hi",
+		     red);
+      y += fonts[i]->h;
+    }
+  y = 0;
+  for (i = 0; (i <= 4); i++)
+    {
+      gdImageStringUp (im_out, fonts[i], 64 + y, 64,
+		       (unsigned char *) "hi", red);
+      y += fonts[i]->h;
+    }
+  /* Random antialiased lines; coordinates all over the image, 
+     but the output will respect a small clipping rectangle */
+  gdImageSetClip (im_out, 0, gdImageSY (im_out) - 100,
+		  100, gdImageSY (im_out));
+  /* Fixed seed for reproducibility of results */
+  srand (100);
+  for (i = 0; (i < 100); i++)
+    {
+      int x1 = rand () % gdImageSX (im_out);
+      int y1 = rand () % gdImageSY (im_out);
+      int x2 = rand () % gdImageSX (im_out);
+      int y2 = rand () % gdImageSY (im_out);
+      gdImageSetAntiAliased (im_out, white); 
+      gdImageLine (im_out, x1, y1, x2, y2, gdAntiAliased); 
+    }
+  /* Make output image interlaced (progressive, in the case of JPEG) */
+  gdImageInterlace (im_out, 1);
+  out = fopen ("demoout.png", "wb");
+  /* Write PNG */
+  gdImagePng (im_out, out);
+  fclose (out);
+  out = fopen ("demoout.gif", "wb");
+  /* Write GIF (2.0.28) */
+  gdImageGif (im_out, out);
+  fclose (out);
+  /* 2.0.12: also write a paletteized png comparable to the gif */
+  out = fopen ("demooutp.png", "wb");
+  gdImageTrueColorToPalette (im_out, 0, 256);
+  gdImagePng (im_out, out);
+  fclose (out);
+  gdImageDestroy (im_out);
+  if (im_in)
+    {
+      gdImageDestroy (im_in);
+    }
+#else
+  fprintf (stderr, "No PNG library support.\n");
+#endif /* HAVE_LIBPNG */
+  return 0;
+}