
#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;
}
