commit fa409bdba8b29af82f8cd28fcf16b89b5b5074f1
parent 5f5c55ff356a5b718ed48a226c794719e3a245f9
Author: ByteProject <stefan.vogt@byteproject.net>
Date: Mon, 26 Dec 2011 22:10:23 +0100
headers / includes for libgd
Diffstat:
10 files changed, 1498 insertions(+), 0 deletions(-)
diff --git a/lib/MacOSX/libgd/include/entities.h b/lib/MacOSX/libgd/include/entities.h
@@ -0,0 +1,277 @@
+/*
+ * Generated file - do not edit directly.
+ *
+ * This file was generated from:
+ * http://www.w3.org/TR/REC-html40/sgml/entities.html
+ * by means of the script:
+ * entities.tcl
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static struct entities_s {
+ char *name;
+ int value;
+} entities[] = {
+ {"AElig", 198},
+ {"Aacute", 193},
+ {"Acirc", 194},
+ {"Agrave", 192},
+ {"Alpha", 913},
+ {"Aring", 197},
+ {"Atilde", 195},
+ {"Auml", 196},
+ {"Beta", 914},
+ {"Ccedil", 199},
+ {"Chi", 935},
+ {"Dagger", 8225},
+ {"Delta", 916},
+ {"ETH", 208},
+ {"Eacute", 201},
+ {"Ecirc", 202},
+ {"Egrave", 200},
+ {"Epsilon", 917},
+ {"Eta", 919},
+ {"Euml", 203},
+ {"Gamma", 915},
+ {"Iacute", 205},
+ {"Icirc", 206},
+ {"Igrave", 204},
+ {"Iota", 921},
+ {"Iuml", 207},
+ {"Kappa", 922},
+ {"Lambda", 923},
+ {"Mu", 924},
+ {"Ntilde", 209},
+ {"Nu", 925},
+ {"OElig", 338},
+ {"Oacute", 211},
+ {"Ocirc", 212},
+ {"Ograve", 210},
+ {"Omega", 937},
+ {"Omicron", 927},
+ {"Oslash", 216},
+ {"Otilde", 213},
+ {"Ouml", 214},
+ {"Phi", 934},
+ {"Pi", 928},
+ {"Prime", 8243},
+ {"Psi", 936},
+ {"Rho", 929},
+ {"Scaron", 352},
+ {"Sigma", 931},
+ {"THORN", 222},
+ {"Tau", 932},
+ {"Theta", 920},
+ {"Uacute", 218},
+ {"Ucirc", 219},
+ {"Ugrave", 217},
+ {"Upsilon", 933},
+ {"Uuml", 220},
+ {"Xi", 926},
+ {"Yacute", 221},
+ {"Yuml", 376},
+ {"Zeta", 918},
+ {"aacute", 225},
+ {"acirc", 226},
+ {"acute", 180},
+ {"aelig", 230},
+ {"agrave", 224},
+ {"alefsym", 8501},
+ {"alpha", 945},
+ {"amp", 38},
+ {"and", 8743},
+ {"ang", 8736},
+ {"aring", 229},
+ {"asymp", 8776},
+ {"atilde", 227},
+ {"auml", 228},
+ {"bdquo", 8222},
+ {"beta", 946},
+ {"brvbar", 166},
+ {"bull", 8226},
+ {"cap", 8745},
+ {"ccedil", 231},
+ {"cedil", 184},
+ {"cent", 162},
+ {"chi", 967},
+ {"circ", 710},
+ {"clubs", 9827},
+ {"cong", 8773},
+ {"copy", 169},
+ {"crarr", 8629},
+ {"cup", 8746},
+ {"curren", 164},
+ {"dArr", 8659},
+ {"dagger", 8224},
+ {"darr", 8595},
+ {"deg", 176},
+ {"delta", 948},
+ {"diams", 9830},
+ {"divide", 247},
+ {"eacute", 233},
+ {"ecirc", 234},
+ {"egrave", 232},
+ {"empty", 8709},
+ {"emsp", 8195},
+ {"ensp", 8194},
+ {"epsilon", 949},
+ {"equiv", 8801},
+ {"eta", 951},
+ {"eth", 240},
+ {"euml", 235},
+ {"euro", 8364},
+ {"exist", 8707},
+ {"fnof", 402},
+ {"forall", 8704},
+ {"frac12", 189},
+ {"frac14", 188},
+ {"frac34", 190},
+ {"frasl", 8260},
+ {"gamma", 947},
+ {"ge", 8805},
+ {"gt", 62},
+ {"hArr", 8660},
+ {"harr", 8596},
+ {"hearts", 9829},
+ {"hellip", 8230},
+ {"iacute", 237},
+ {"icirc", 238},
+ {"iexcl", 161},
+ {"igrave", 236},
+ {"image", 8465},
+ {"infin", 8734},
+ {"int", 8747},
+ {"iota", 953},
+ {"iquest", 191},
+ {"isin", 8712},
+ {"iuml", 239},
+ {"kappa", 954},
+ {"lArr", 8656},
+ {"lambda", 955},
+ {"lang", 9001},
+ {"laquo", 171},
+ {"larr", 8592},
+ {"lceil", 8968},
+ {"ldquo", 8220},
+ {"le", 8804},
+ {"lfloor", 8970},
+ {"lowast", 8727},
+ {"loz", 9674},
+ {"lrm", 8206},
+ {"lsaquo", 8249},
+ {"lsquo", 8216},
+ {"lt", 60},
+ {"macr", 175},
+ {"mdash", 8212},
+ {"micro", 181},
+ {"middot", 183},
+ {"minus", 8722},
+ {"mu", 956},
+ {"nabla", 8711},
+ {"nbsp", 160},
+ {"ndash", 8211},
+ {"ne", 8800},
+ {"ni", 8715},
+ {"not", 172},
+ {"notin", 8713},
+ {"nsub", 8836},
+ {"ntilde", 241},
+ {"nu", 957},
+ {"oacute", 243},
+ {"ocirc", 244},
+ {"oelig", 339},
+ {"ograve", 242},
+ {"oline", 8254},
+ {"omega", 969},
+ {"omicron", 959},
+ {"oplus", 8853},
+ {"or", 8744},
+ {"ordf", 170},
+ {"ordm", 186},
+ {"oslash", 248},
+ {"otilde", 245},
+ {"otimes", 8855},
+ {"ouml", 246},
+ {"para", 182},
+ {"part", 8706},
+ {"permil", 8240},
+ {"perp", 8869},
+ {"phi", 966},
+ {"pi", 960},
+ {"piv", 982},
+ {"plusmn", 177},
+ {"pound", 163},
+ {"prime", 8242},
+ {"prod", 8719},
+ {"prop", 8733},
+ {"psi", 968},
+ {"quot", 34},
+ {"rArr", 8658},
+ {"radic", 8730},
+ {"rang", 9002},
+ {"raquo", 187},
+ {"rarr", 8594},
+ {"rceil", 8969},
+ {"rdquo", 8221},
+ {"real", 8476},
+ {"reg", 174},
+ {"rfloor", 8971},
+ {"rho", 961},
+ {"rlm", 8207},
+ {"rsaquo", 8250},
+ {"rsquo", 8217},
+ {"sbquo", 8218},
+ {"scaron", 353},
+ {"sdot", 8901},
+ {"sect", 167},
+ {"shy", 173},
+ {"sigma", 963},
+ {"sigmaf", 962},
+ {"sim", 8764},
+ {"spades", 9824},
+ {"sub", 8834},
+ {"sube", 8838},
+ {"sum", 8721},
+ {"sup", 8835},
+ {"sup1", 185},
+ {"sup2", 178},
+ {"sup3", 179},
+ {"supe", 8839},
+ {"szlig", 223},
+ {"tau", 964},
+ {"there4", 8756},
+ {"theta", 952},
+ {"thetasym", 977},
+ {"thinsp", 8201},
+ {"thorn", 254},
+ {"tilde", 732},
+ {"times", 215},
+ {"trade", 8482},
+ {"uArr", 8657},
+ {"uacute", 250},
+ {"uarr", 8593},
+ {"ucirc", 251},
+ {"ugrave", 249},
+ {"uml", 168},
+ {"upsih", 978},
+ {"upsilon", 965},
+ {"uuml", 252},
+ {"weierp", 8472},
+ {"xi", 958},
+ {"yacute", 253},
+ {"yen", 165},
+ {"yuml", 255},
+ {"zeta", 950},
+ {"zwj", 8205},
+ {"zwnj", 8204},
+};
+
+#define ENTITY_NAME_LENGTH_MAX 8
+#define NR_OF_ENTITIES 252
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gd.h b/lib/MacOSX/libgd/include/gd.h
@@ -0,0 +1,811 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GD_H
+#define GD_H 1
+
+#define GD_MAJOR_VERSION 2
+#define GD_MINOR_VERSION 0
+#define GD_RELEASE_VERSION 36
+#define GD_EXTRA_VERSION ""
+#define GD_VERSION_STRING "2.0.36"
+
+
+/* Do the DLL dance: dllexport when building the DLL,
+ dllimport when importing from it, nothing when
+ not on Silly Silly Windows (tm Aardman Productions). */
+
+/* 2.0.20: for headers */
+
+/* 2.0.24: __stdcall also needed for Visual BASIC
+ and other languages. This breaks ABI compatibility
+ with previous DLL revs, but it's necessary. */
+
+/* 2.0.29: WIN32 programmers can declare the NONDLL macro if they
+ wish to build gd as a static library or by directly including
+ the gd sources in a project. */
+
+#ifndef WIN32
+#define NONDLL 1
+#endif /* WIN32 */
+
+#ifdef NONDLL
+#define BGD_DECLARE(rt) extern rt
+#else
+#ifdef BGDWIN32
+#define BGD_DECLARE(rt) __declspec(dllexport) rt __stdcall
+#else
+#define BGD_DECLARE(rt) __declspec(dllimport) rt _stdcall
+#endif /* BGDWIN32 */
+#endif /* NONDLL */
+
+/* 2.0.20: for actual storage of exported data, functions don't need this,
+ currently needed only for font pointers */
+#ifdef NONDLL
+/* 2.0.25: bring back extern */
+#define BGD_EXPORT_DATA_PROT extern
+#define BGD_EXPORT_DATA_IMPL
+#else
+#ifdef BGDWIN32
+#define BGD_EXPORT_DATA_PROT __declspec(dllexport) extern
+#define BGD_EXPORT_DATA_IMPL __declspec(dllexport)
+#else
+#define BGD_EXPORT_DATA_PROT __declspec(dllimport) extern
+#define BGD_EXPORT_DATA_IMPL __declspec(dllimport)
+#endif /* BGDWIN32 */
+#endif /* NONDLL */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* some might want to set DEFAULT_FONTPATH from configure in config.h */
+#ifdef NETWARE
+/* default fontpath for netware systems, could probably be handled in configure for 2.1 */
+#define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf;."
+#define PATHSEPARATOR ";"
+#endif
+
+/* 2.0.23: more Type 1 fonts */
+#ifndef DEFAULT_FONTPATH
+/* default fontpath for unix systems - whatever happened to standards ! */
+#define DEFAULT_FONTPATH "/usr/X11R6/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/truetype:/usr/X11R6/lib/X11/fonts/TTF:/usr/share/fonts/TrueType:/usr/share/fonts/truetype:/usr/openwin/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/Type1:/usr/lib/X11/fonts/Type1:/usr/openwin/lib/X11/fonts/Type1"
+#endif
+#ifndef PATHSEPARATOR
+#define PATHSEPARATOR ":"
+#endif
+
+/* gd.h: declarations file for the graphic-draw module.
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation. This software is provided "AS IS." Thomas Boutell and
+ * Boutell.Com, Inc. disclaim all warranties, either express or implied,
+ * including but not limited to implied warranties of merchantability and
+ * fitness for a particular purpose, with respect to this code and accompanying
+ * documentation. */
+
+/* stdio is needed for file I/O. */
+#include <stdio.h>
+#include "gd_io.h"
+
+/* The maximum number of palette entries in palette-based images.
+ In the wonderful new world of gd 2.0, you can of course have
+ many more colors when using truecolor mode. */
+
+#define gdMaxColors 256
+
+/* Image type. See functions below; you will not need to change
+ the elements directly. Use the provided macros to
+ access sx, sy, the color table, and colorsTotal for
+ read-only purposes. */
+
+/* If 'truecolor' is set true, the image is truecolor;
+ pixels are represented by integers, which
+ must be 32 bits wide or more.
+
+ True colors are repsented as follows:
+
+ ARGB
+
+ Where 'A' (alpha channel) occupies only the
+ LOWER 7 BITS of the MSB. This very small
+ loss of alpha channel resolution allows gd 2.x
+ to keep backwards compatibility by allowing
+ signed integers to be used to represent colors,
+ and negative numbers to represent special cases,
+ just as in gd 1.x. */
+
+#define gdAlphaMax 127
+#define gdAlphaOpaque 0
+#define gdAlphaTransparent 127
+#define gdRedMax 255
+#define gdGreenMax 255
+#define gdBlueMax 255
+#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)
+#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
+#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
+#define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
+
+/* This function accepts truecolor pixel values only. The
+ source color is composited with the destination color
+ based on the alpha channel value of the source color.
+ The resulting color is opaque. */
+
+BGD_DECLARE(int) gdAlphaBlend (int dest, int src);
+
+ typedef struct gdImageStruct
+ {
+ /* Palette-based image pixels */
+ unsigned char **pixels;
+ int sx;
+ int sy;
+ /* These are valid in palette images only. See also
+ 'alpha', which appears later in the structure to
+ preserve binary backwards compatibility */
+ int colorsTotal;
+ int red[gdMaxColors];
+ int green[gdMaxColors];
+ int blue[gdMaxColors];
+ int open[gdMaxColors];
+ /* For backwards compatibility, this is set to the
+ first palette entry with 100% transparency,
+ and is also set and reset by the
+ gdImageColorTransparent function. Newer
+ applications can allocate palette entries
+ with any desired level of transparency; however,
+ bear in mind that many viewers, notably
+ many web browsers, fail to implement
+ full alpha channel for PNG and provide
+ support for full opacity or transparency only. */
+ int transparent;
+ int *polyInts;
+ int polyAllocated;
+ struct gdImageStruct *brush;
+ struct gdImageStruct *tile;
+ int brushColorMap[gdMaxColors];
+ int tileColorMap[gdMaxColors];
+ int styleLength;
+ int stylePos;
+ int *style;
+ int interlace;
+ /* New in 2.0: thickness of line. Initialized to 1. */
+ int thick;
+ /* New in 2.0: alpha channel for palettes. Note that only
+ Macintosh Internet Explorer and (possibly) Netscape 6
+ really support multiple levels of transparency in
+ palettes, to my knowledge, as of 2/15/01. Most
+ common browsers will display 100% opaque and
+ 100% transparent correctly, and do something
+ unpredictable and/or undesirable for levels
+ in between. TBB */
+ int alpha[gdMaxColors];
+ /* Truecolor flag and pixels. New 2.0 fields appear here at the
+ end to minimize breakage of existing object code. */
+ int trueColor;
+ int **tpixels;
+ /* Should alpha channel be copied, or applied, each time a
+ pixel is drawn? This applies to truecolor images only.
+ No attempt is made to alpha-blend in palette images,
+ even if semitransparent palette entries exist.
+ To do that, build your image as a truecolor image,
+ then quantize down to 8 bits. */
+ int alphaBlendingFlag;
+ /* Should the alpha channel of the image be saved? This affects
+ PNG at the moment; other future formats may also
+ have that capability. JPEG doesn't. */
+ int saveAlphaFlag;
+
+ /* There should NEVER BE ACCESSOR MACROS FOR ITEMS BELOW HERE, so this
+ part of the structure can be safely changed in new releases. */
+
+ /* 2.0.12: anti-aliased globals. 2.0.26: just a few vestiges after
+ switching to the fast, memory-cheap implementation from PHP-gd. */
+ int AA;
+ int AA_color;
+ int AA_dont_blend;
+
+ /* 2.0.12: simple clipping rectangle. These values
+ must be checked for safety when set; please use
+ gdImageSetClip */
+ int cx1;
+ int cy1;
+ int cx2;
+ int cy2;
+ }
+ gdImage;
+
+ typedef gdImage *gdImagePtr;
+
+ typedef struct
+ {
+ /* # of characters in font */
+ int nchars;
+ /* First character is numbered... (usually 32 = space) */
+ int offset;
+ /* Character width and height */
+ int w;
+ int h;
+ /* Font data; array of characters, one row after another.
+ Easily included in code, also easily loaded from
+ data files. */
+ char *data;
+ }
+ gdFont;
+
+/* Text functions take these. */
+ typedef gdFont *gdFontPtr;
+
+/* For backwards compatibility only. Use gdImageSetStyle()
+ for MUCH more flexible line drawing. Also see
+ gdImageSetBrush(). */
+#define gdDashSize 4
+
+/* Special colors. */
+
+#define gdStyled (-2)
+#define gdBrushed (-3)
+#define gdStyledBrushed (-4)
+#define gdTiled (-5)
+
+/* NOT the same as the transparent color index.
+ This is used in line styles only. */
+#define gdTransparent (-6)
+
+#define gdAntiAliased (-7)
+
+/* Functions to manipulate images. */
+
+/* Creates a palette-based image (up to 256 colors). */
+BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy);
+
+/* An alternate name for the above (2.0). */
+#define gdImageCreatePalette gdImageCreate
+
+/* Creates a truecolor image (millions of colors). */
+BGD_DECLARE(gdImagePtr) gdImageCreateTrueColor (int sx, int sy);
+
+/* Creates an image from various file types. These functions
+ return a palette or truecolor image based on the
+ nature of the file being loaded. Truecolor PNG
+ stays truecolor; palette PNG stays palette-based;
+ JPEG is always truecolor. */
+BGD_DECLARE(gdImagePtr) gdImageCreateFromPng (FILE * fd);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromPngCtx (gdIOCtxPtr in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromPngPtr (int size, void *data);
+
+/* These read the first frame only */
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGif (FILE * fd);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx (gdIOCtxPtr in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP (FILE * inFile);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx (gdIOCtx * infile);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr (int size, void *data);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg (FILE * infile);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx (gdIOCtx * infile);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr (int size, void *data);
+
+/* A custom data source. */
+/* The source function must return -1 on error, otherwise the number
+ of bytes fetched. 0 is EOF, not an error! */
+/* context will be passed to your source function. */
+
+ typedef struct
+ {
+ int (*source) (void *context, char *buffer, int len);
+ void *context;
+ }
+ gdSource, *gdSourcePtr;
+
+ /* Deprecated in favor of gdImageCreateFromPngCtx */
+BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr in);
+
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data);
+
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2 (FILE * in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ptr (int size, void *data);
+
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Part (FILE * in, int srcx, int srcy, int w,
+ int h);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartCtx (gdIOCtxPtr in, int srcx, int srcy,
+ int w, int h);
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy,
+ int w, int h);
+ /* 2.0.10: prototype was missing */
+BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm (FILE * in);
+
+ /* NOTE: filename, not FILE */
+BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm (char *filename);
+
+BGD_DECLARE(void) gdImageDestroy (gdImagePtr im);
+
+/* Replaces or blends with the background depending on the
+ most recent call to gdImageAlphaBlending and the
+ alpha channel value of 'color'; default is to overwrite.
+ Tiling and line styling are also implemented
+ here. All other gd drawing functions pass through this call,
+ allowing for many useful effects. */
+
+BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color);
+/* FreeType 2 text output with hook to extra flags */
+
+BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y);
+BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y);
+
+BGD_DECLARE(void) gdImageAABlend (gdImagePtr im);
+
+BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+
+/* For backwards compatibility only. Use gdImageSetStyle()
+ for much more flexible line drawing. */
+BGD_DECLARE(void) gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2,
+ int color);
+/* Corners specified (not width and height). Upper left first, lower right
+ second. */
+BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2,
+ int color);
+/* Solid bar. Upper left corner first, lower right corner second. */
+BGD_DECLARE(void) gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2,
+ int color);
+BGD_DECLARE(void) gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2);
+BGD_DECLARE(void) gdImageGetClip(gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P);
+BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y);
+BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c,
+ int color);
+BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c,
+ int color);
+BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f, int x, int y,
+ unsigned char *s, int color);
+BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y,
+ unsigned char *s, int color);
+BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y,
+ unsigned short *s, int color);
+BGD_DECLARE(void) gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y,
+ unsigned short *s, int color);
+
+/* 2.0.16: for thread-safe use of gdImageStringFT and friends,
+ call this before allowing any thread to call gdImageStringFT.
+ Otherwise it is invoked by the first thread to invoke
+ gdImageStringFT, with a very small but real risk of a race condition.
+ Return 0 on success, nonzero on failure to initialize freetype. */
+BGD_DECLARE(int) gdFontCacheSetup (void);
+
+/* Optional: clean up after application is done using fonts in
+BGD_DECLARE( )
+ gdImageStringFT(). */
+BGD_DECLARE(void) gdFontCacheShutdown (void);
+/* 2.0.20: for backwards compatibility. A few applications did start calling
+ this function when it first appeared although it was never documented.
+ Simply invokes gdFontCacheShutdown. */
+BGD_DECLARE(void) gdFreeFontCache (void);
+
+/* Calls gdImageStringFT. Provided for backwards compatibility only. */
+BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y,
+ char *string);
+
+/* FreeType 2 text output */
+BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y,
+ char *string);
+
+/* 2.0.5: provides an extensible way to pass additional parameters.
+ Thanks to Wez Furlong, sorry for the delay. */
+
+ typedef struct
+ {
+ int flags; /* Logical OR of gdFTEX_ values */
+ double linespacing; /* fine tune line spacing for '\n' */
+ int charmap; /* TBB: 2.0.12: may be gdFTEX_Unicode,
+ gdFTEX_Shift_JIS, gdFTEX_Big5,
+ or gdFTEX_Adobe_Custom;
+ when not specified, maps are searched
+ for in the above order. */
+ int hdpi; /* if (flags & gdFTEX_RESOLUTION) */
+ int vdpi; /* if (flags & gdFTEX_RESOLUTION) */
+ char *xshow; /* if (flags & gdFTEX_XSHOW)
+ then, on return, xshow is a malloc'ed
+ string contining xshow position data for
+ the last string.
+
+ NB. The caller is responsible for gdFree'ing
+ the xshow string.
+ */
+ char *fontpath; /* if (flags & gdFTEX_RETURNFONTPATHNAME)
+ then, on return, fontpath is a malloc'ed
+ string containing the actual font file path name
+ used, which can be interesting when fontconfig
+ is in use.
+
+ The caller is responsible for gdFree'ing the
+ fontpath string.
+ */
+
+ }
+ gdFTStringExtra, *gdFTStringExtraPtr;
+
+#define gdFTEX_LINESPACE 1
+#define gdFTEX_CHARMAP 2
+#define gdFTEX_RESOLUTION 4
+#define gdFTEX_DISABLE_KERNING 8
+#define gdFTEX_XSHOW 16
+/* The default unless gdFTUseFontConfig(1); has been called:
+ fontlist is a full or partial font file pathname or list thereof
+ (i.e. just like before 2.0.29) */
+#define gdFTEX_FONTPATHNAME 32
+/* Necessary to use fontconfig patterns instead of font pathnames
+ as the fontlist argument, unless gdFTUseFontConfig(1); has
+ been called. New in 2.0.29 */
+#define gdFTEX_FONTCONFIG 64
+/* Sometimes interesting when fontconfig is used: the fontpath
+ element of the structure above will contain a gdMalloc'd string
+ copy of the actual font file pathname used, if this flag is set
+ when the call is made */
+#define gdFTEX_RETURNFONTPATHNAME 128
+
+/* If flag is nonzero, the fontlist parameter to gdImageStringFT
+ and gdImageStringFTEx shall be assumed to be a fontconfig font pattern
+ if fontconfig was compiled into gd. This function returns zero
+ if fontconfig is not available, nonzero otherwise. */
+BGD_DECLARE(int) gdFTUseFontConfig(int flag);
+
+/* These are NOT flags; set one in 'charmap' if you set the
+ gdFTEX_CHARMAP bit in 'flags'. */
+#define gdFTEX_Unicode 0
+#define gdFTEX_Shift_JIS 1
+#define gdFTEX_Big5 2
+#define gdFTEX_Adobe_Custom 3
+
+BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y,
+ char *string, gdFTStringExtraPtr strex);
+
+/* Point type for use in polygon drawing. */
+ typedef struct
+ {
+ int x, y;
+ }
+ gdPoint, *gdPointPtr;
+
+BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c);
+BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c);
+BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c);
+
+/* These functions still work with truecolor images,
+ for which they never return error. */
+BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b);
+/* gd 2.0: palette entries with non-opaque transparency are permitted. */
+BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a);
+/* Assumes opaque is the preferred alpha channel value */
+BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b);
+/* Closest match taking all four parameters into account.
+ A slightly different color with the same transparency
+ beats the exact same color with radically different
+ transparency */
+BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a);
+/* An alternate method */
+BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b);
+/* Returns exact, 100% opaque matches only */
+BGD_DECLARE(int) gdImageColorExact (gdImagePtr im, int r, int g, int b);
+/* Returns an exact match only, including alpha */
+BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a);
+/* Opaque only */
+BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b);
+/* Based on gdImageColorExactAlpha and gdImageColorClosestAlpha */
+BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a);
+
+/* A simpler way to obtain an opaque truecolor value for drawing on a
+ truecolor image. Not for use with palette images! */
+
+#define gdTrueColor(r, g, b) (((r) << 16) + \
+ ((g) << 8) + \
+ (b))
+
+/* Returns a truecolor value with an alpha channel component.
+ gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely
+ opaque. */
+
+#define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + \
+ ((r) << 16) + \
+ ((g) << 8) + \
+ (b))
+
+BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color);
+
+/* Converts a truecolor image to a palette-based image,
+ using a high-quality two-pass quantization routine
+ which attempts to preserve alpha channel information
+ as well as R/G/B color information when creating
+ a palette. If ditherFlag is set, the image will be
+ dithered to approximate colors better, at the expense
+ of some obvious "speckling." colorsWanted can be
+ anything up to 256. If the original source image
+ includes photographic information or anything that
+ came out of a JPEG, 256 is strongly recommended.
+
+ Better yet, don't use these function -- write real
+ truecolor PNGs and JPEGs. The disk space gain of
+ conversion to palette is not great (for small images
+ it can be negative) and the quality loss is ugly.
+
+ DIFFERENCES: gdImageCreatePaletteFromTrueColor creates and
+ returns a new image. gdImageTrueColorToPalette modifies
+ an existing image, and the truecolor pixels are discarded. */
+
+BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int ditherFlag,
+ int colorsWanted);
+
+BGD_DECLARE(void) gdImageTrueColorToPalette (gdImagePtr im, int ditherFlag,
+ int colorsWanted);
+
+/* Specifies a color index (if a palette image) or an
+ RGB color (if a truecolor image) which should be
+ considered 100% transparent. FOR TRUECOLOR IMAGES,
+ THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING
+ SAVED. Use gdImageSaveAlpha(im, 0); to
+ turn off the saving of a full alpha channel in
+ a truecolor image. Note that gdImageColorTransparent
+ is usually compatible with older browsers that
+ do not understand full alpha channels well. TBB */
+BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color);
+
+BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr dst, gdImagePtr src);
+BGD_DECLARE(void) gdImageGif (gdImagePtr im, FILE * out);
+BGD_DECLARE(void) gdImagePng (gdImagePtr im, FILE * out);
+BGD_DECLARE(void) gdImagePngCtx (gdImagePtr im, gdIOCtx * out);
+BGD_DECLARE(void) gdImageGifCtx (gdImagePtr im, gdIOCtx * out);
+
+/* 2.0.12: Compression level: 0-9 or -1, where 0 is NO COMPRESSION at all,
+ 1 is FASTEST but produces larger files, 9 provides the best
+ compression (smallest files) but takes a long time to compress, and
+ -1 selects the default compiled into the zlib library. */
+BGD_DECLARE(void) gdImagePngEx (gdImagePtr im, FILE * out, int level);
+BGD_DECLARE(void) gdImagePngCtxEx (gdImagePtr im, gdIOCtx * out, int level);
+
+BGD_DECLARE(void) gdImageWBMP (gdImagePtr image, int fg, FILE * out);
+BGD_DECLARE(void) gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out);
+
+/* Guaranteed to correctly free memory returned
+ by the gdImage*Ptr functions */
+BGD_DECLARE(void) gdFree (void *m);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImageWBMPPtr (gdImagePtr im, int *size, int fg);
+
+/* 100 is highest quality (there is always a little loss with JPEG).
+ 0 is lowest. 10 is about the lowest useful setting. */
+BGD_DECLARE(void) gdImageJpeg (gdImagePtr im, FILE * out, int quality);
+BGD_DECLARE(void) gdImageJpegCtx (gdImagePtr im, gdIOCtx * out, int quality);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImageJpegPtr (gdImagePtr im, int *size, int quality);
+
+/* Legal values for Disposal. gdDisposalNone is always used by
+ the built-in optimizer if previm is passed. */
+
+enum {
+ gdDisposalUnknown,
+ gdDisposalNone,
+ gdDisposalRestoreBackground,
+ gdDisposalRestorePrevious
+};
+
+BGD_DECLARE(void) gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops);
+BGD_DECLARE(void) gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm);
+BGD_DECLARE(void) gdImageGifAnimEnd(FILE *outFile);
+BGD_DECLARE(void) gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtx *out, int GlobalCM, int Loops);
+BGD_DECLARE(void) gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm);
+BGD_DECLARE(void) gdImageGifAnimEndCtx(gdIOCtx *out);
+BGD_DECLARE(void *) gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops);
+BGD_DECLARE(void *) gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm);
+BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size);
+
+/* A custom data sink. For backwards compatibility. Use
+ gdIOCtx instead. */
+/* The sink function must return -1 on error, otherwise the number
+ of bytes written, which must be equal to len. */
+/* context will be passed to your sink function. */
+ typedef struct
+ {
+ int (*sink) (void *context, const char *buffer, int len);
+ void *context;
+ }
+ gdSink, *gdSinkPtr;
+
+BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr out);
+
+BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * out);
+BGD_DECLARE(void) gdImageGd2 (gdImagePtr im, FILE * out, int cs, int fmt);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImageGifPtr (gdImagePtr im, int *size);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImagePngPtr (gdImagePtr im, int *size);
+BGD_DECLARE(void *) gdImagePngPtrEx (gdImagePtr im, int *size, int level);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size);
+
+/* Best to free this memory with gdFree(), not free() */
+BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size);
+
+BGD_DECLARE(void) gdImageEllipse (gdImagePtr im, int cx, int cy, int w, int h,
+ int color);
+
+/* Style is a bitwise OR ( | operator ) of these.
+ gdArc and gdChord are mutually exclusive;
+ gdChord just connects the starting and ending
+ angles with a straight line, while gdArc produces
+ a rounded edge. gdPie is a synonym for gdArc.
+ gdNoFill indicates that the arc or chord should be
+ outlined, not filled. gdEdged, used together with
+ gdNoFill, indicates that the beginning and ending
+ angles should be connected to the center; this is
+ a good way to outline (rather than fill) a
+ 'pie slice'. */
+#define gdArc 0
+#define gdPie gdArc
+#define gdChord 1
+#define gdNoFill 2
+#define gdEdged 4
+
+BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s,
+ int e, int color, int style);
+BGD_DECLARE(void) gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e,
+ int color);
+BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
+BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h,
+ int color);
+BGD_DECLARE(void) gdImageFillToBorder (gdImagePtr im, int x, int y, int border,
+ int color);
+BGD_DECLARE(void) gdImageFill (gdImagePtr im, int x, int y, int color);
+BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
+ int srcX, int srcY, int w, int h);
+BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
+ int srcX, int srcY, int w, int h, int pct);
+BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX,
+ int dstY, int srcX, int srcY, int w, int h,
+ int pct);
+
+/* Stretches or shrinks to fit, as needed. Does NOT attempt
+ to average the entire set of source pixels that scale down onto the
+ destination pixel. */
+BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
+ int srcX, int srcY, int dstW, int dstH, int srcW,
+ int srcH);
+
+/* gd 2.0: stretches or shrinks to fit, as needed. When called with a
+ truecolor destination image, this function averages the
+ entire set of source pixels that scale down onto the
+ destination pixel, taking into account what portion of the
+ destination pixel each source pixel represents. This is a
+ floating point operation, but this is not a performance issue
+ on modern hardware, except for some embedded devices. If the
+ destination is a palette image, gdImageCopyResized is
+ substituted automatically. */
+BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX,
+ int dstY, int srcX, int srcY, int dstW, int dstH,
+ int srcW, int srcH);
+
+/* gd 2.0.8: gdImageCopyRotated is added. Source
+ is a rectangle, with its upper left corner at
+ srcX and srcY. Destination is the *center* of
+ the rotated copy. Angle is in degrees, same as
+ gdImageArc. Floating point destination center
+ coordinates allow accurate rotation of
+ objects of odd-numbered width or height. */
+BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst,
+ gdImagePtr src,
+ double dstX, double dstY,
+ int srcX, int srcY,
+ int srcWidth, int srcHeight, int angle);
+
+BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush);
+BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile);
+BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c);
+BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend);
+BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels);
+/* Line thickness (defaults to 1). Affects lines, ellipses,
+ rectangles, polygons and so forth. */
+BGD_DECLARE(void) gdImageSetThickness (gdImagePtr im, int thickness);
+/* On or off (1 or 0) for all three of these. */
+BGD_DECLARE(void) gdImageInterlace (gdImagePtr im, int interlaceArg);
+BGD_DECLARE(void) gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg);
+BGD_DECLARE(void) gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg);
+
+/* Macros to access information about images. */
+
+/* Returns nonzero if the image is a truecolor image,
+ zero for a palette image. */
+
+#define gdImageTrueColor(im) ((im)->trueColor)
+
+#define gdImageSX(im) ((im)->sx)
+#define gdImageSY(im) ((im)->sy)
+#define gdImageColorsTotal(im) ((im)->colorsTotal)
+#define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : \
+ (im)->red[(c)])
+#define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : \
+ (im)->green[(c)])
+#define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : \
+ (im)->blue[(c)])
+#define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : \
+ (im)->alpha[(c)])
+#define gdImageGetTransparent(im) ((im)->transparent)
+#define gdImageGetInterlaced(im) ((im)->interlace)
+
+/* These macros provide direct access to pixels in
+ palette-based and truecolor images, respectively.
+ If you use these macros, you must perform your own
+ bounds checking. Use of the macro for the correct type
+ of image is also your responsibility. */
+#define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)]
+#define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)]
+
+/* I/O Support routines. */
+
+BGD_DECLARE(gdIOCtx *) gdNewFileCtx (FILE *);
+ /* If data is null, size is ignored and an initial data buffer is
+ allocated automatically. NOTE: this function assumes gd has the right
+ to free or reallocate "data" at will! Also note that gd will free
+ "data" when the IO context is freed. If data is not null, it must point
+ to memory allocated with gdMalloc, or by a call to gdImage[something]Ptr.
+ If not, see gdNewDynamicCtxEx for an alternative. */
+BGD_DECLARE(gdIOCtx *) gdNewDynamicCtx (int size, void *data);
+ /* 2.0.21: if freeFlag is nonzero, gd will free and/or reallocate "data" as
+ needed as described above. If freeFlag is zero, gd will never free
+ or reallocate "data," which means that the context should only be used
+ for *reading* an image from a memory buffer, or writing an image to a
+ memory buffer which is already large enough. If the memory buffer is
+ not large enough and an image write is attempted, the write operation
+ will fail. Those wishing to write an image to a buffer in memory have
+ a much simpler alternative in the gdImage[something]Ptr functions. */
+BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx (int size, void *data, int freeFlag);
+BGD_DECLARE(gdIOCtx *) gdNewSSCtx (gdSourcePtr in, gdSinkPtr out);
+BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size);
+
+#define GD2_CHUNKSIZE 128
+#define GD2_CHUNKSIZE_MIN 64
+#define GD2_CHUNKSIZE_MAX 4096
+
+#define GD2_VERS 2
+#define GD2_ID "gd2"
+
+#define GD2_FMT_RAW 1
+#define GD2_FMT_COMPRESSED 2
+
+/* Image comparison definitions */
+BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2);
+
+#define GD_CMP_IMAGE 1 /* Actual image IS different */
+#define GD_CMP_NUM_COLORS 2 /* Number of Colours in pallette differ */
+#define GD_CMP_COLOR 4 /* Image colours differ */
+#define GD_CMP_SIZE_X 8 /* Image width differs */
+#define GD_CMP_SIZE_Y 16 /* Image heights differ */
+#define GD_CMP_TRANSPARENT 32 /* Transparent colour */
+#define GD_CMP_BACKGROUND 64 /* Background colour */
+#define GD_CMP_INTERLACE 128 /* Interlaced setting */
+#define GD_CMP_TRUECOLOR 256 /* Truecolor vs palette differs */
+
+/* resolution affects ttf font rendering, particularly hinting */
+#define GD_RESOLUTION 96 /* pixels per inch */
+
+#ifdef __cplusplus
+}
+#endif
+
+/* newfangled special effects */
+#include "gdfx.h"
+
+#endif /* GD_H */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gd_io.h b/lib/MacOSX/libgd/include/gd_io.h
@@ -0,0 +1,55 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GD_IO_H
+#define GD_IO_H 1
+
+#include <stdio.h>
+
+#ifdef VMS
+#define Putchar gdPutchar
+#endif
+
+typedef struct gdIOCtx
+{
+ int (*getC) (struct gdIOCtx *);
+ int (*getBuf) (struct gdIOCtx *, void *, int);
+
+ void (*putC) (struct gdIOCtx *, int);
+ int (*putBuf) (struct gdIOCtx *, const void *, int);
+
+ /* seek must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! */
+ int (*seek) (struct gdIOCtx *, const int);
+
+ long (*tell) (struct gdIOCtx *);
+
+ void (*gd_free) (struct gdIOCtx *);
+
+}
+gdIOCtx;
+
+typedef struct gdIOCtx *gdIOCtxPtr;
+
+void Putword (int w, gdIOCtx * ctx);
+void Putchar (int c, gdIOCtx * ctx);
+
+ void gdPutC (const unsigned char c, gdIOCtx * ctx);
+ int gdPutBuf (const void *, int, gdIOCtx *);
+ void gdPutWord (int w, gdIOCtx * ctx);
+ void gdPutInt (int w, gdIOCtx * ctx);
+
+ int gdGetC (gdIOCtx * ctx);
+ int gdGetBuf (void *, int, gdIOCtx *);
+ int gdGetByte (int *result, gdIOCtx * ctx);
+ int gdGetWord (int *result, gdIOCtx * ctx);
+ int gdGetInt (int *result, gdIOCtx * ctx);
+
+ int gdSeek (gdIOCtx * ctx, const int offset);
+ long gdTell (gdIOCtx * ctx);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdcache.h b/lib/MacOSX/libgd/include/gdcache.h
@@ -0,0 +1,93 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * gdcache.h
+ *
+ * Caches of pointers to user structs in which the least-recently-used
+ * element is replaced in the event of a cache miss after the cache has
+ * reached a given size.
+ *
+ * John Ellson (ellson@graphviz.org) Oct 31, 1997
+ *
+ * Test this with:
+ * gcc -o gdcache -g -Wall -DTEST gdcache.c
+ *
+ * The cache is implemented by a singly-linked list of elements
+ * each containing a pointer to a user struct that is being managed by
+ * the cache.
+ *
+ * The head structure has a pointer to the most-recently-used
+ * element, and elements are moved to this position in the list each
+ * time they are used. The head also contains pointers to three
+ * user defined functions:
+ * - a function to test if a cached userdata matches some keydata
+ * - a function to provide a new userdata struct to the cache
+ * if there has been a cache miss.
+ * - a function to release a userdata struct when it is
+ * no longer being managed by the cache
+ *
+ * In the event of a cache miss the cache is allowed to grow up to
+ * a specified maximum size. After the maximum size is reached then
+ * the least-recently-used element is discarded to make room for the
+ * new. The most-recently-returned value is always left at the
+ * beginning of the list after retrieval.
+ *
+ * In the current implementation the cache is traversed by a linear
+ * search from most-recent to least-recent. This linear search
+ * probably limits the usefulness of this implementation to cache
+ * sizes of a few tens of elements.
+ */
+
+/*********************************************************/
+/* header */
+/*********************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#ifndef NULL
+#define NULL (void *)0
+#endif
+
+/* user defined function templates */
+typedef int (*gdCacheTestFn_t) (void *userdata, void *keydata);
+typedef void *(*gdCacheFetchFn_t) (char **error, void *keydata);
+typedef void (*gdCacheReleaseFn_t) (void *userdata);
+
+/* element structure */
+typedef struct gdCache_element_s gdCache_element_t;
+struct gdCache_element_s
+{
+ gdCache_element_t *next;
+ void *userdata;
+};
+
+/* head structure */
+typedef struct gdCache_head_s gdCache_head_t;
+struct gdCache_head_s
+{
+ gdCache_element_t *mru;
+ int size;
+ char *error;
+ gdCacheTestFn_t gdCacheTest;
+ gdCacheFetchFn_t gdCacheFetch;
+ gdCacheReleaseFn_t gdCacheRelease;
+};
+
+/* function templates */
+gdCache_head_t *gdCacheCreate (int size,
+ gdCacheTestFn_t gdCacheTest,
+ gdCacheFetchFn_t gdCacheFetch,
+ gdCacheReleaseFn_t gdCacheRelease);
+
+void gdCacheDelete (gdCache_head_t * head);
+
+void *gdCacheGet (gdCache_head_t * head, void *keydata);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfontg.h b/lib/MacOSX/libgd/include/gdfontg.h
@@ -0,0 +1,38 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _GDFONTG_H_
+#define _GDFONTG_H_ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.51 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Bold-R-Normal-Sans-15-140-75-75-C-90-ISO8859-2
+ at Mon Jan 26 14:45:58 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+ BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant;
+ BGD_DECLARE(gdFontPtr) gdFontGetGiant(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfontl.h b/lib/MacOSX/libgd/include/gdfontl.h
@@ -0,0 +1,39 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _GDFONTL_H_
+#define _GDFONTL_H_ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-normal--16-140-75-75-c-80-iso8859-2
+ at Tue Jan 6 19:39:27 1998.
+
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+ BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge;
+ BGD_DECLARE(gdFontPtr) gdFontGetLarge(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfontmb.h b/lib/MacOSX/libgd/include/gdfontmb.h
@@ -0,0 +1,37 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _GDFONTMB_H_
+#define _GDFONTMB_H_ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-bold-r-normal-sans-13-94-100-100-c-70-iso8859-2
+ at Thu Jan 8 13:54:57 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gd.h"
+
+ BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold;
+ BGD_DECLARE(gdFontPtr) gdFontGetMediumBold(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfonts.h b/lib/MacOSX/libgd/include/gdfonts.h
@@ -0,0 +1,37 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _GDFONTS_H_
+#define _GDFONTS_H_ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-semicondensed-sans-12-116-75-75-c-60-iso8859-2
+ at Thu Jan 8 14:13:20 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gd.h"
+
+ BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall;
+ BGD_DECLARE(gdFontPtr) gdFontGetSmall(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfontt.h b/lib/MacOSX/libgd/include/gdfontt.h
@@ -0,0 +1,38 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _GDFONTT_H_
+#define _GDFONTT_H_ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-2
+ at Thu Jan 8 13:49:54 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+ BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny;
+ BGD_DECLARE(gdFontPtr) gdFontGetTiny(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/MacOSX/libgd/include/gdfx.h b/lib/MacOSX/libgd/include/gdfx.h
@@ -0,0 +1,73 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GDFX_H
+#define GDFX_H 1
+
+#include "gd.h"
+
+/* im MUST be square, but can have any size. Returns a new image
+ of width and height radius * 2, in which the X axis of
+ the original has been remapped to theta (angle) and the Y axis
+ of the original has been remapped to rho (distance from center).
+ This is known as a "polar coordinate transform." */
+
+ BGD_DECLARE(gdImagePtr) gdImageSquareToCircle(gdImagePtr im, int radius);
+
+/* Draws the text 'top' and 'bottom' on 'im', curved along the
+ edge of a circle of radius 'radius', with its
+ center at 'cx' and 'cy'. 'top' is written clockwise
+ along the top; 'bottom' is written counterclockwise
+ along the bottom. 'textRadius' determines the 'height'
+ of each character; if 'textRadius' is 1/2 of 'radius',
+ characters extend halfway from the edge to the center.
+ 'fillPortion' varies from 0 to 1.0, with useful values
+ from about 0.4 to 0.9, and determines how much of the
+ 180 degrees of arc assigned to each section of text
+ is actually occupied by text; 0.9 looks better than
+ 1.0 which is rather crowded. 'font' is a freetype
+ font; see gdImageStringFT. 'points' is passed to the
+ freetype engine and has an effect on hinting; although
+ the size of the text is determined by radius, textRadius,
+ and fillPortion, you should pass a point size that
+ 'hints' appropriately -- if you know the text will be
+ large, pass a large point size such as 24.0 to get the
+ best results. 'fgcolor' can be any color, and may have
+ an alpha component, do blending, etc.
+
+ Returns 0 on success, or an error string. */
+
+BGD_DECLARE(char *) gdImageStringFTCircle(
+ gdImagePtr im,
+ int cx,
+ int cy,
+ double radius,
+ double textRadius,
+ double fillPortion,
+ char *font,
+ double points,
+ char *top,
+ char *bottom,
+ int fgcolor);
+
+ /* 2.0.16:
+ * Sharpen function added on 2003-11-19
+ * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
+ * Simple 3x3 convolution kernel
+ * Makes use of seperability
+ * Faster, but less flexible, than full-blown unsharp masking
+ * pct is sharpening percentage, and can be greater than 100
+ * Silently does nothing to non-truecolor images
+ * Silently does nothing for pct<0, as not a useful blurring function
+ * Leaves transparency/alpha-channel untouched
+ */
+
+ BGD_DECLARE(void) gdImageSharpen (gdImagePtr im, int pct);
+
+#endif /* GDFX_H */
+
+
+#ifdef __cplusplus
+}
+#endif
