luagd.c

/*
 * luagd -- GD bindings for Lua.
 * (c) 2004-13 Alexandre Erwin Ittner <alexandre@ittner.com.br>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHOR OR COPYRIGHT HOLDER BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * If you use this package in a product, an acknowledgment in the product
 * documentation would be greatly appreciated (but it is not required).
 *
 */
 
#include <lua.h>
#include <lauxlib.h>
#include <stdlib.h>

#include <gd.h>

/* Standard gd fonts */
#include <gdfonts.h>
#include <gdfontl.h>
#include <gdfontmb.h>
#include <gdfontg.h>
#include <gdfontt.h>

#ifndef VERSION
 #error "Trying to build without -DVERSION=xxx defined. Check the Makefile"
#endif
#define LIB_VERSION     "lua-gd " VERSION
#define LIB_COPYRIGHT   LIB_VERSION " (c) 2004-13 Alexandre Erwin Ittner"

#define GD_IMAGE_PTR_TYPENAME   "gdImagePtr_handle"


/* Compatibility between Lua 5.1 and Lua 5.2 */
#if LUA_VERSION_NUM < 501
 #error "Unsuported Lua version. You must use Lua >= 5.1"
#endif

#if LUA_VERSION_NUM < 502
 #define luaL_setfuncs(L, f, unused)  { luaL_register(L, NULL, f); }
 #define lua_rawlen lua_objlen
#endif

#define boxptr(L, p)   (*(void**)(lua_newuserdata(L, sizeof(void*))) = (p))
#define unboxptr(L, i) (*(void**)(lua_touserdata(L, i)))

/* Table assumed on top */
#define tblseticons(L, c, v)    \
    lua_pushliteral(L, c);      \
    lua_pushnumber(L, v);       \
    lua_settable(L, -3);

/* Standard gd fonts */
#define MY_GD_FONT_SMALL            0
#define MY_GD_FONT_LARGE            1
#define MY_GD_FONT_MEDIUM_BOLD      2
#define MY_GD_FONT_GIANT            3
#define MY_GD_FONT_TINY             4


static int typerror(lua_State *L, int narg, const char *tname) {
    const char *msg = lua_pushfstring(L, "%s expected, got %s",
        tname, luaL_typename(L, narg));
    return luaL_argerror(L, narg, msg);
}


static gdImagePtr getImagePtr(lua_State *L, int i) {
    if (luaL_checkudata(L, i, GD_IMAGE_PTR_TYPENAME) != NULL) {
        gdImagePtr im = unboxptr(L, i);
        if (im == NULL)
            luaL_error(L, "attempt to use an invalid " GD_IMAGE_PTR_TYPENAME);
        return im;
    }
    typerror(L, i, GD_IMAGE_PTR_TYPENAME);
    return NULL;
}


static void pushImagePtr(lua_State *L, gdImagePtr im) {
    boxptr(L, im);
    luaL_getmetatable(L, GD_IMAGE_PTR_TYPENAME);
    lua_setmetatable(L, -2);    /* Done */
}


static gdFontPtr getStdFont(lua_State *L, int i) {
    int size;

    if (lua_isnumber(L, i) == 0) {
        typerror(L, i, "Standard GD Font");
        return gdFontGetSmall();
    }

    size = luaL_checkinteger(L, i);
    switch(size) {
        case MY_GD_FONT_SMALL:
            return gdFontGetSmall();

        case MY_GD_FONT_LARGE:
            return gdFontGetLarge();

        case MY_GD_FONT_MEDIUM_BOLD:
            return gdFontGetMediumBold();

        case MY_GD_FONT_GIANT:
            return gdFontGetGiant();

        case MY_GD_FONT_TINY:
            return gdFontGetTiny();

        default:
            typerror(L, i, "Standard GD Font");
            return gdFontGetSmall();
    }

    return gdFontGetSmall(); /* Not reached */
}




/* 
 * Reads a Lua table and returns a pointer to a "gdFTStringExtra" struct. The
 * table should have the following fields:
 *
 * {
 *     linespacing = 1.0,                   -- linespacing for '\n'
 *     charmap = gd.FTEX_Unicode,           -- default charset
 *     hdpi = 96,                           -- horizontal resolution
 *     vdpi = 96,                           -- vertical resolution
 *     disable_kerning = true,              -- disable kerning?
 *     xshow = true,                        -- return char positions?
 *     return_font_path_name = true,        -- return font path names?
 *     fontconfig = true                    -- use fontconfig?
 * }
 * 
 */
#ifdef GD_FREETYPE
static gdFTStringExtra *getFTStringExtraPtr(lua_State *L, int i) {
    luaL_checktype(L, i, LUA_TTABLE);

    gdFTStringExtra *ex = (gdFTStringExtra*) malloc(sizeof(gdFTStringExtra));
    if (ex == NULL)
        luaL_error(L, "Memory allocation failure");

    ex->flags = 0;

    lua_pushstring(L, "linespacing");
    lua_gettable(L, i);
    if (!lua_isnil(L, -1)) {
        ex->flags |= gdFTEX_LINESPACE;
        ex->linespacing = (double) lua_tonumber(L, -1);
    }
    lua_pop(L, 1);

    lua_pushstring(L, "charmap");
    lua_gettable(L, i);
    if (!lua_isnil(L, -1)) {
        ex->flags |= gdFTEX_CHARMAP;;
        ex->charmap = (int) lua_tonumber(L, -1);
        switch(ex->charmap) {
            case gdFTEX_Unicode:
            case gdFTEX_Shift_JIS:
            case gdFTEX_Big5:
            /* Future charsets here */
                break;
            default:
                free(ex);
                luaL_error(L, "Invalid charset");
        }
    }
    lua_pop(L, 1);

    ex->hdpi = 96;
    ex->vdpi = 96;

    lua_pushstring(L, "hdpi");
    lua_gettable(L, i);
    if (!lua_isnil(L, -1)) {
        ex->flags |= gdFTEX_RESOLUTION;
        ex->hdpi = (double) lua_tonumber(L, -1);
    }
    lua_pop(L, 1);

    lua_pushstring(L, "vdpi");
    lua_gettable(L, i);
    if (!lua_isnil(L, -1)) {
        ex->flags |= gdFTEX_RESOLUTION;
        ex->vdpi = (double) lua_tonumber(L, -1);
    }
    lua_pop(L, 1);

    lua_pushstring(L, "disable_kerning");
    lua_gettable(L, i);
    if (lua_toboolean(L, -1))
        ex->flags |= gdFTEX_DISABLE_KERNING;
    lua_pop(L, 1);

    lua_pushvalue(L, i);
    lua_pushstring(L, "xshow");
    lua_gettable(L, i);
    if (lua_toboolean(L, -1))
        ex->flags |= gdFTEX_XSHOW;
    lua_pop(L, 1);

    lua_pushstring(L, "return_font_path_name");
    lua_gettable(L, i);
    if (lua_toboolean(L, -1))
        ex->flags |= gdFTEX_RETURNFONTPATHNAME;
    lua_pop(L, 1);

    lua_pushstring(L, "fontconfig");
    lua_gettable(L, i);
    if (lua_toboolean(L, -1))
        ex->flags |= gdFTEX_FONTCONFIG;
    lua_pop(L, 1);

    return ex;
}
#endif 


/* gdImageCreate(int sx, int sy) */
static int LgdImageCreate(lua_State *L) {
    int sx, sy;
    gdImagePtr im;

    sx = luaL_checkinteger(L, 1);
    sy = luaL_checkinteger(L, 2);
    im = gdImageCreate(sx, sy);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}

/* gdImageCreatePalette(int sx, int sy) */
/* Useless? */
static int LgdImageCreatePalette(lua_State *L) {
    int sx, sy;
    gdImagePtr im;

    sx = luaL_checkinteger(L, 1);
    sy = luaL_checkinteger(L, 2);
    im = gdImageCreatePalette(sx, sy);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}



/* gdImageCreateTrueColor(int sx, int sy) */
static int LgdImageCreateTrueColor(lua_State *L) {
    int sx, sy;
    gdImagePtr im;

    sx = luaL_checkinteger(L, 1);
    sy = luaL_checkinteger(L, 2);
    im = gdImageCreateTrueColor(sx, sy);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}

/* gdImagePtr gdImageCreatePaletteFromTrueColor(gdImagePtr im, int ditherFlag,
    int colorsWanted) */
static int LgdImageCreatePaletteFromTrueColor(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int dither = lua_toboolean(L, 2);
    int colors = luaL_checkinteger(L, 3);
    gdImagePtr nim = gdImageCreatePaletteFromTrueColor(im, dither, colors);
    
    if (nim)
        pushImagePtr(L, nim);
    else
        lua_pushnil(L);
    return 1;
}


/* void gdImageTrueColorToPalette(gdImagePtr im, int ditherFlag,
    int colorsWanted) */
static int LgdImageTrueColorToPalette(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int dither = lua_toboolean(L, 2);
    int colors = luaL_checkinteger(L, 3);

    gdImageTrueColorToPalette(im, dither, colors);
    return 0;
}



/* gdImageDestroy(gdImagePtr im) */
static int LgdImageDestroy(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    if (im)
        gdImageDestroy(im);
    return 0;
}

#ifdef GD_JPEG
/* gdImageCreateFromJpeg(FILE *in) */
/* Changed to: gd.createFromJpeg(char *filename) */
static int LgdImageCreateFromJpeg(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromJpeg(fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromJpegPtr(int size, void *data) */
static int LgdImageCreateFromJpegPtr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromJpegPtr(size, str);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}
#endif


#ifdef GD_GIF
/* gdImageCreateFromGif (FILE *in) */
/* Changed to: gd.createFromGif (filename) */
static int LgdImageCreateFromGif (lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGif (fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}

/* gdImageCreateFromGifPtr(int size, void *data) */
static int LgdImageCreateFromGifPtr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGifPtr(size, str);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}
#endif


#ifdef GD_PNG
/* gdImageCreateFromPng(FILE *in) */
/* Changed to: gd.createFromPng(filename) */
static int LgdImageCreateFromPng(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromPng(fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromPngPtr(int size, void *data) */
static int LgdImageCreateFromPngPtr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromPngPtr(size, str);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}
#endif


/* gdImageCreateFromGd(FILE *in) */
/* Changed to: gd.createFromGd(filename) */
static int LgdImageCreateFromGd(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGd(fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromGdPtr(int size, void *data) */
static int LgdImageCreateFromGdPtr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGdPtr(size, str);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromGd2(FILE *in) */
/* Changed to: gd.createFromGd2(filename) */
static int LgdImageCreateFromGd2(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGd2(fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromGd2Ptr(int size, void *data) */
static int LgdImageCreateFromGd2Ptr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGd2Ptr(size, str);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromGd2Part(FILE *in, int x, int y, int w, int h) */
/* Changed to: gd.createFromGd2Part(filename, x, y, w, h)) */
static int LgdImageCreateFromGd2Part(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);
    const int x = luaL_checkinteger(L, 2);
    const int y = luaL_checkinteger(L, 3);
    const int w = luaL_checkinteger(L, 4);
    const int h = luaL_checkinteger(L, 5);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGd2Part(fp, x, y, w, h);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromGd2PartPtr(int size, void *data,
                int srcX, int srcY, int w, int h)  */
static int LgdImageCreateFromGd2PartPtr(lua_State *L) {
    gdImagePtr im;
    int size = lua_rawlen(L, 1);
    void *str = (void*) luaL_checkstring(L, 1);
    const int x = luaL_checkinteger(L, 2);
    const int y = luaL_checkinteger(L, 3);
    const int w = luaL_checkinteger(L, 4);
    const int h = luaL_checkinteger(L, 5);

    if (str == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromGd2PartPtr(size, str, x, y, w, h);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


#ifdef GD_XPM
/* gdImageCreateFromXbm(FILE *in) */
/* Changed to: gd.createFromXbm(filename) */
static int LgdImageCreateFromXbm(lua_State *L) {
    gdImagePtr im;
    FILE *fp;
    const char *fname = luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    if ((fp = fopen(fname, "rb")) == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromXbm(fp);
    fclose(fp);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}


/* gdImageCreateFromXpm(char *filename) */
static int LgdImageCreateFromXpm(lua_State *L) {
    gdImagePtr im;
    char *fname = (char*) luaL_checkstring(L, 1);

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;  /* Error */
    }
    im = gdImageCreateFromXpm(fname);
    if (im != NULL)
        pushImagePtr(L, im);
    else
        lua_pushnil(L); /* Error */
    return 1;
}
#endif



#ifdef GD_JPEG
/* gdImageJpeg(gdImagePtr im, FILE *out, int quality) */
/* Changed to: gd.jpeg(im, fname, quality) */
static int LgdImageJpeg(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    int quality = luaL_checkinteger(L, 3);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImageJpeg(im, fp, quality);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void *gdImageJpegPtr(gdImagePtr im, int quality) */
static int LgdImageJpegPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int quality = luaL_checkinteger(L, 2);
    char *str;
    int size;

    str = gdImageJpegPtr(im, &size, quality);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}
#endif

#ifdef GD_PNG
/* gdImagePng(gdImagePtr im, FILE *out) */
/* Changed to: gd.png(im, fname) */
static int LgdImagePng(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImagePng(im, fp);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void *gdImagePngPtr(gdImagePtr im) */
static int LgdImagePngPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    char *str;
    int size;

    str = gdImagePngPtr(im, &size);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}


/* gdImagePngEx(gdImagePtr im, FILE *out, int compression_level) */
/* Changed to: gd.pngEx(im, fname, compression_level) */
static int LgdImagePngEx(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    int level = luaL_checkinteger(L, 3);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImagePngEx(im, fp, level);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void *gdImagePngPtrEx(gdImagePtr im, int compression_level) */
static int LgdImagePngPtrEx(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int level = luaL_checkinteger(L, 2);
    char *str;
    int size;

    str = gdImagePngPtrEx(im, &size, level);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}
#endif


#ifdef GD_GIF
/* gdImageGif (gdImagePtr im, FILE *out) */
/* Changed to: gd.gif (im, fname) */
static int LgdImageGif (lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImageGif (im, fp);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}
#endif

#ifdef GD_GIF
/* void *gdImageGifPtr(gdImagePtr im) */
static int LgdImageGifPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    char *str;
    int size;

    str = gdImageGifPtr(im, &size);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}
#endif


/* gdImageGd(gdImagePtr im, FILE *out) */
/* Changed to: gd.gd(im, fname) */
static int LgdImageGd(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImageGd(im, fp);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void *gdImageGdPtr(gdImagePtr im) */
static int LgdImageGdPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    char *str;
    int size;

    str = gdImageGdPtr(im, &size);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}



/* gdImageGd2(gdImagePtr im, FILE *out, int chunkSize, int fmt) */
/* Changed to: gd.gd2(im, fname, chunkSize, fmt) */
static int LgdImageGd2(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    const char *fname = luaL_checkstring(L, 2);
    int cs = luaL_checkinteger(L, 3);
    int fmt = luaL_checkinteger(L, 4);
    FILE *fp;

    if (fname == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0);
        return 1;
    }
    gdImageGd2(im, fp, cs, fmt);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void* gdImageGd2Ptr(gdImagePtr im, int chunkSize, int fmt, int *size) */
static int LgdImageGd2Ptr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int cs = luaL_checkinteger(L, 2);
    int fmt = luaL_checkinteger(L, 3);
    char *str;
    int size;

    str = gdImageGd2Ptr(im, cs, fmt, &size);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else
        lua_pushnil(L);  /* Error */
    return 1;
}


/* void gdImageWBMP(gdImagePtr im, int fg, FILE *out) */
/* Changed to: gd.wbmp(im, int fg, filename) */
static int LgdImageWBMP(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int fg = luaL_checkinteger(L, 2);
    const char *fname = luaL_checkstring(L, 3);
    FILE *fp;

    if (fname == NULL) {
        lua_pushnil(L);
        return 1;
    }
    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushnil(L);
        return 1;
    }
    gdImageWBMP(im, fg, fp);
    fclose(fp);
    lua_pushboolean(L, 1);
    return 1;
}


/* void* gdImageWBMPPtr(gdImagePtr im, int *size) */
static int LgdImageWBMPPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int fg = luaL_checkinteger(L, 2);
    char *str;
    int size;

    str = gdImageWBMPPtr(im, &size, fg);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else {
        lua_pushnil(L);  /* Error */
    }
    return 1;
}


/* int gdImageColorAllocate(gdImagePtr im, int r, int g, int b) */
static int LgdImageColorAllocate(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c;

    c = gdImageColorAllocate(im, r, g, b);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a) */
static int LgdImageColorAllocateAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int a = luaL_checkinteger(L, 5);
    int c;

    c = gdImageColorAllocateAlpha(im, r, g, b, a);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorClosest(gdImagePtr im, int r, int g, int b) */
static int LgdImageColorClosest(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c;

    c = gdImageColorClosest(im, r, g, b);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a) */
static int LgdImageColorClosestAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int a = luaL_checkinteger(L, 5);
    int c;

    c = gdImageColorClosestAlpha(im, r, g, b, a);
    if (c > 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorClosestHWB(gdImagePtr im, int r, int g, int b) */
static int LgdImageColorClosestHWB(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c;

    c = gdImageColorClosestHWB(im, r, g, b);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorExact(gdImagePtr im, int r, int g, int b) */
static int LgdImageColorExact(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c;

    c = gdImageColorExact(im, r, g, b);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorExactAlpha(gdImagePtr im, int r, int g, int b, int a) */
static int LgdImageColorExactAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int a = luaL_checkinteger(L, 5);
    int c;

    c = gdImageColorExactAlpha(im, r, g, b, a);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorResolve(gdImagePtr im, int r, int g, int b) */
static int LgdImageColorResolve(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c;

    c = gdImageColorResolve(im, r, g, b);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a) */
static int LgdImageColorResolveAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);
    int g = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int a = luaL_checkinteger(L, 5);
    int c;

    c = gdImageColorResolveAlpha(im, r, g, b, a);
    if (c >= 0)
        lua_pushnumber(L, c);  /* ok */
    else
        lua_pushnil(L); /* Can not allocate color */
    return 1;
}


/* int gdImageColorsTotal(gdImagePtr im) */
static int LgdImageColorsTotal(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);

    lua_pushnumber(L, gdImageColorsTotal(im));  /* ok */
    return 1;
}


/* int gdImageRed(gdImagePtr im, int c) */
static int LgdImageRed(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);

    lua_pushnumber(L, gdImageRed(im, c));  /* ok */
    return 1;
}

/* int gdImageBlue(gdImagePtr im, int c) */
static int LgdImageBlue(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);

    lua_pushnumber(L, gdImageBlue(im, c));  /* ok */
    return 1;
}

/* int gdImageBlue(gdImagePtr im, int c) */
static int LgdImageGreen(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);

    lua_pushnumber(L, gdImageGreen(im, c));  /* ok */
    return 1;
}

/* int gdImageAlpha(gdImagePtr im, int color) */
static int LgdImageAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);
    lua_pushnumber(L, gdImageAlpha(im, c));
    return 1;
}

/* int gdImageGetInterlaced(gdImagePtr im) */
static int LgdImageGetInterlaced(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int ret = gdImageGetInterlaced(im);

    if (ret != 0)
        lua_pushnumber(L, ret);
    else
        lua_pushnil(L);
    return 1;
}

/* int gdImageGetTransparent(gdImagePtr im) */
static int LgdImageGetTransparent(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int ret = gdImageGetTransparent(im);

    if (ret != -1)
        lua_pushnumber(L, ret);
    else
        lua_pushnil(L);
    return 1;
}


/* void gdImageColorTransparent(gdImagePtr im, int c) */
static int LgdImageColorTransparent(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = -1;
    if (!lua_isnil(L, 2))
      c = luaL_checkinteger(L, 2);
    gdImageColorTransparent(im, c);
    return 0;
}


/* void gdImageColorDeallocate(gdImagePtr im, int c) */
static int LgdImageColorDeallocate(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);
    gdImageColorDeallocate(im, c);
    return 0;
}


/* int gdImageSX(gdImagePtr im) */
static int LgdImageSX(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    lua_pushnumber(L, gdImageSX(im));
    return 1;
}


/* int gdImageSY(gdImagePtr im) */
static int LgdImageSY(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    lua_pushnumber(L, gdImageSY(im));
    return 1;
}


/* Fear the power of the Moon!!  ---   x, y = im:sizeXY() */
static int LgdImageSXY(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    lua_pushnumber(L, gdImageSX(im));
    lua_pushnumber(L, gdImageSY(im));
    return 2;
}


/* int gdImageBoundsSafe(gdImagePtr im, int x, int y) */
static int LgdImageBoundsSafe(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);

    if (gdImageBoundsSafe(im, x, y) != 0)
        lua_pushboolean(L, 1);
    else
        lua_pushboolean(L, 0);
    return 1;
}


/* int gdImageGetPixel(gdImagePtr im, int x, int y) */
static int LgdImageGetPixel(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);

    lua_pushnumber(L, gdImageGetPixel(im, x, y));
    return 1;
}


/* void gdImageSetPixel(gdImagePtr im, int x, int y, int color) */
static int LgdImageSetPixel(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);
    int c = luaL_checkinteger(L, 4);

    gdImageSetPixel(im, x, y, c);
    return 0;
}


/* void gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int c) */
static int LgdImageLine(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x1 = luaL_checkinteger(L, 2);
    int y1 = luaL_checkinteger(L, 3);
    int x2 = luaL_checkinteger(L, 4);
    int y2 = luaL_checkinteger(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageLine(im, x1, y1, x2, y2, c);
    return 0;
}

/* void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2,
        int c) */
static int LgdImageRectangle(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x1 = luaL_checkinteger(L, 2);
    int y1 = luaL_checkinteger(L, 3);
    int x2 = luaL_checkinteger(L, 4);
    int y2 = luaL_checkinteger(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageRectangle(im, x1, y1, x2, y2, c);
    return 0;
}


/* void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2,
        int c) */
static int LgdImageFilledRectangle(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x1 = luaL_checkinteger(L, 2);
    int y1 = luaL_checkinteger(L, 3);
    int x2 = luaL_checkinteger(L, 4);
    int y2 = luaL_checkinteger(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageFilledRectangle(im, x1, y1, x2, y2, c);
    return 0;
}


/* Stack must have ONLY the table of points */
static gdPoint *getPointList(lua_State *L, int *size) {
    gdPoint *plist;
    int i;

    luaL_checktype(L, -1, LUA_TTABLE);
    *size = lua_rawlen(L, -1);
    plist = (gdPoint*) malloc(*size * sizeof(gdPoint));

    for (i = 0; i < *size; i++) {
        /* Stack: T */
        lua_rawgeti(L, 1, i + 1);

        /* Stack:  T, T'  */
        if (lua_type(L, 2) != LUA_TTABLE) {
            free(plist);
            typerror(L, 2, "Point");
        }

        lua_rawgeti(L, 2, 1);
        /* Stack:  T, T', X  */
        plist[i].x = luaL_checkinteger(L, -1);
        lua_remove(L, -1);

        lua_rawgeti(L, 2, 2);
        /* Stack:  T, T', Y  */
        plist[i].y = luaL_checkinteger(L, -1);
        lua_remove(L, -1);

        /* Stack:  T, T' */
        lua_remove(L, -1);

        /* Stack: T */
    }

    lua_remove(L, -1);
    return plist;
}



/* void gdImagePolygon(gdImagePtr im, gdPointPtr points, int pointsTotal,
        int color)
  Changed to: gd.polygon(im, { { x1, y1 }, { x2, y2 } ... }, color)  */
static int LgdImagePolygon(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdPoint *plist;
    int size;
    int c;

    c = luaL_checkinteger(L, 3);
    lua_remove(L, 3); /* Get and drop color */
    lua_remove(L, 1); /* Drop image from the stack */
    plist = getPointList(L, &size);
    gdImagePolygon(im, plist, size, c);
    free(plist);
    return 0;
}



/* void gdImageFilledPolygon(gdImagePtr im, gdPointPtr points,
        int pointsTotal, int color)
  Changed to: gd.filledPolygon(im, { { x1, y1 }, { x2, y2 } ... }, color) */
static int LgdImageFilledPolygon(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdPoint *plist;
    int size;
    int c;

    c = luaL_checkinteger(L, 3);
    lua_remove(L, 3); /* Get and drop color */
    lua_remove(L, 1); /* Drop image from the stack */

    plist = getPointList(L, &size);
    gdImageFilledPolygon(im, plist, size, c);
    free(plist);
    return 0;
}


/* void gdImageOpenPolygon(gdImagePtr im, gdPointPtr points,
        int pointsTotal, int color)
  Changed to: gd.openPolygon(im, { { x1, y1 }, { x2, y2 } ... }, color) */
static int LgdImageOpenPolygon(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdPoint *plist;
    int size;
    int c;

    c = luaL_checkinteger(L, 3);
    lua_remove(L, 3); /* Get and drop color */
    lua_remove(L, 1); /* Drop image from the stack */

    plist = getPointList(L, &size);
    gdImageOpenPolygon(im, plist, size, c);
    free(plist);
    return 0;
}



/* void gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e,
    int color) */
static int LgdImageArc(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int cx = luaL_checkinteger(L, 2);
    int cy = luaL_checkinteger(L, 3);
    int w = luaL_checkinteger(L, 4);
    int h = luaL_checkinteger(L, 5);
    int s = luaL_checkinteger(L, 6);
    int e = luaL_checkinteger(L, 7);
    int c = luaL_checkinteger(L, 8);

    gdImageArc(im, cx, cy, w, h, s, e, c);
    return 0;
}


/* void gdImageFilledArc(gdImagePtr im, int cx, int cy, int w, int h,
    int s, int e, int color, int style) */
static int LgdImageFilledArc(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int cx = luaL_checkinteger(L, 2);
    int cy = luaL_checkinteger(L, 3);
    int w = luaL_checkinteger(L, 4);
    int h = luaL_checkinteger(L, 5);
    int s = luaL_checkinteger(L, 6);
    int e = luaL_checkinteger(L, 7);
    int c = luaL_checkinteger(L, 8);
    int sty = luaL_checkinteger(L, 9);

    gdImageFilledArc(im, cx, cy, w, h, s, e, c, sty);
    return 0;
}


/* void gdImageFilledEllipse(gdImagePtr im, int cx, int cy, int w, int h,
        int color) */
static int LgdImageFilledEllipse(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int cx = luaL_checkinteger(L, 2);
    int cy = luaL_checkinteger(L, 3);
    int w = luaL_checkinteger(L, 4);
    int h = luaL_checkinteger(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageFilledEllipse(im, cx, cy, w, h, c);
    return 0;
}


/* void gdImageFill(gdImagePtr im, int x, int y, int color) */
static int LgdImageFill(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);
    int c = luaL_checkinteger(L, 4);

    gdImageFill(im, x, y, c);
    return 0;
}


/* void gdImageFillToBorder(gdImagePtr im, int x, int y, int border,
        int color) */
static int LgdImageFillToBorder(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);
    int b = luaL_checkinteger(L, 4);
    int c = luaL_checkinteger(L, 5);

    gdImageFillToBorder(im, x, y, b, c);
    return 0;
}


/* void gdImageSetAntiAliased(gdImagePtr im, int c) */
static int LgdImageSetAntiAliased(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);

    gdImageSetAntiAliased(im, c);
    return 0;
}


/* void gdImageSetAntiAliasedDontBlend(gdImagePtr im, int c) */
static int LgdImageSetAntiAliasedDontBlend(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int c = luaL_checkinteger(L, 2);

    gdImageSetAntiAliasedDontBlend(im, c, 1);
    return 0;
}


/* void gdImageSetBrush(gdImagePtr im, gdImagePtr brush) */
static int LgdImageSetBrush(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdImagePtr b = getImagePtr(L, 2);

    gdImageSetBrush(im, b);
    return 0;
}


/* void gdImageSetTile(gdImagePtr im, gdImagePtr tile) */
static int LgdImageSetTile(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdImagePtr t = getImagePtr(L, 1);

    gdImageSetTile(im, t);
    return 0;
}


/* void gdImageSetStyle(gdImagePtr im, int *style, int styleLength)  */
/* Changed To: gd.setStyle(im, { c1, c2, c3,  ...  } ) */
static int LgdImageSetStyle(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int *slist;
    int size;
    int i;

    /* Stack: Im, T */
    luaL_checktype(L, -1, LUA_TTABLE);
    size = lua_rawlen(L, -1);
    slist = (int*) malloc(size * sizeof(int));

    for (i = 0; i < size; i++) {
        /* Stack: Im, T */
        lua_rawgeti(L, 2, i + 1);

        /* Stack:  Im, T, num */
        if (lua_type(L, -1) != LUA_TNUMBER) {
            free(slist);
            typerror(L, -1, "Number");
        }

        slist[i] = luaL_checkinteger(L, -1);
        lua_remove(L, -1);

        /* Stack: Im, T */
    }

    gdImageSetStyle(im, slist, size);
    free(slist);
    return 0;
}


/* void gdImageSetThickness(gdImagePtr im, int thickness) */
static int LgdImageSetThickness(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int t = luaL_checkinteger(L, 2);

    gdImageSetThickness(im, t);
    return 0;
}


/* void gdImageAlphaBlending(gdImagePtr im, int blending) */
/* Changed to: im:alphaBlending(true_or_false) */
static int LgdImageAlphaBlending(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int b = lua_toboolean(L, 2);

    gdImageAlphaBlending(im, b);
    return 0;
}


/* void gdImageSaveAlpha(gdImagePtr im, int saveFlag) */
/* Changed to: im:saveAlpha(true_or_false) */
static int LgdImageSaveAlpha(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int b = lua_toboolean(L, 2);

    gdImageSaveAlpha(im, b);
    return 0;
}


/* gdImageInterlace(gdImagePtr im, int interlace) */
/* Changed to: im:interlace(true_or_false) */
static int LgdImageInterlace(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int i = lua_toboolean(L, 2);

    gdImageInterlace(im, i);
    return 0;
}


/* void gdImageString(gdImagePtr im, gdFontPtr font, int x, int y,
        unsigned char *s, int color) */
static int LgdImageString(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdFontPtr fnt = getStdFont(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    unsigned char *str = (unsigned char*) luaL_checkstring(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageString(im, fnt, x, y, str, c);
    return 0;
}


/* void gdImageStringUp(gdImagePtr im, gdFontPtr font, int x, int y,
        unsigned char *s, int color)  */
static int LgdImageStringUp(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdFontPtr fnt = getStdFont(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    unsigned char *str = (unsigned char*) luaL_checkstring(L, 5);
    int c = luaL_checkinteger(L, 6);

    gdImageStringUp(im, fnt, x, y, str, c);
    return 0;
}


/* void gdImageChar(gdImagePtr im, gdFontPtr font, int x, int y,
            int c, int color)  */
/* Useless? */
static int LgdImageChar(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdFontPtr fnt = getStdFont(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    char *str = (char*) luaL_checkstring(L, 5);
    int c = luaL_checkinteger(L, 6);
    int chr;

    if (str) {
        chr = (int) str[0];
    } else {
        typerror(L, 5, "string");
        return 0;
    }

    gdImageChar(im, fnt, x, y, chr, c);
    return 0;
}


/* void gdImageCharUp(gdImagePtr im, gdFontPtr font, int x, int y,
            int c, int color)  */
static int LgdImageCharUp(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    gdFontPtr fnt = getStdFont(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    char *str = (char*) luaL_checkstring(L, 5);
    int c = luaL_checkinteger(L, 6);
    int chr;

    if (str)
        chr = (int) str[0];
    else {
        typerror(L, 5, "string");
        return 0;
    }

    gdImageCharUp(im, fnt, x, y, chr, c);
    return 0;
}


/* void gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
            int srcX, int srcY, int w, int h) */
static int LgdImageCopy(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    int dstX = luaL_checkinteger(L, 3);
    int dstY = luaL_checkinteger(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int w = luaL_checkinteger(L, 7);
    int h = luaL_checkinteger(L, 8);

    gdImageCopy(dst, src, dstX, dstY, srcX, srcY, w, h);
    return 0;
}



/* void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX,
            int dstY, int srcX, int srcY, int destW, int destH,
            int srcW, int srcH)  */
static int LgdImageCopyResized(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    int dstX = luaL_checkinteger(L, 3);
    int dstY = luaL_checkinteger(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int dstW = luaL_checkinteger(L, 7);
    int dstH = luaL_checkinteger(L, 8);
    int srcW = luaL_checkinteger(L, 9);
    int srcH = luaL_checkinteger(L, 10);

    gdImageCopyResized(dst, src, dstX, dstY, srcX, srcY, dstW, dstH,
        srcW, srcH);
    return 0;
}


/* void gdImageCopyResampled(gdImagePtr dst, gdImagePtr src, int dstX,
        int dstY, int srcX, int srcY, int destW, int destH, int srcW,
        int srcH)  */
static int LgdImageCopyResampled(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    int dstX = luaL_checkinteger(L, 3);
    int dstY = luaL_checkinteger(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int dstW = luaL_checkinteger(L, 7);
    int dstH = luaL_checkinteger(L, 8);
    int srcW = luaL_checkinteger(L, 9);
    int srcH = luaL_checkinteger(L, 10);

    gdImageCopyResampled(dst, src, dstX, dstY, srcX, srcY, dstW, dstH,
        srcW, srcH);
    return 0;
}


/* void gdImageCopyRotated(gdImagePtr dst, gdImagePtr src, double dstX,
        double dstY, int srcX, int srcY, int srcW, int srcH, int angle) */
static int LgdImageCopyRotated(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    double dstX = (double) lua_tonumber(L, 3);
    double dstY = (double) lua_tonumber(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int srcW = luaL_checkinteger(L, 7);
    int srcH = luaL_checkinteger(L, 8);
    int ang = luaL_checkinteger(L, 9);

    gdImageCopyRotated(dst, src, dstX, dstY, srcX, srcY, srcW, srcH, ang);
    return 0;
}


/* void gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX,
        int dstY, int srcX, int srcY, int w, int h, int pct)  */
static int LgdImageCopyMerge(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    int dstX = luaL_checkinteger(L, 3);
    int dstY = luaL_checkinteger(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int w = luaL_checkinteger(L, 7);
    int h = luaL_checkinteger(L, 8);
    int pct = luaL_checkinteger(L, 9);

    gdImageCopyMerge(dst, src, dstX, dstY, srcX, srcY, w, h, pct);
    return 0;
}


/* void gdImageCopyMergeGray(gdImagePtr dst, gdImagePtr src, int dstX,
        int dstY, int srcX, int srcY, int w, int h, int pct) */
static int LgdImageCopyMergeGray(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);
    int dstX = luaL_checkinteger(L, 3);
    int dstY = luaL_checkinteger(L, 4);
    int srcX = luaL_checkinteger(L, 5);
    int srcY = luaL_checkinteger(L, 6);
    int w = luaL_checkinteger(L, 7);
    int h = luaL_checkinteger(L, 8);
    int pct = luaL_checkinteger(L, 9);

    gdImageCopyMergeGray(dst, src, dstX, dstY, srcX, srcY, w, h, pct);
    return 0;
}


/* void gdImagePaletteCopy(gdImagePtr dst, gdImagePtr src) */
static int LgdImagePaletteCopy(lua_State *L) {
    gdImagePtr dst = getImagePtr(L, 1);
    gdImagePtr src = getImagePtr(L, 2);

    gdImagePaletteCopy(dst, src);
    return 0;
}


/* void gdImageSquareToCircle(gdImagePtr im, int radius) */
static int LgdImageSquareToCircle(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int r = luaL_checkinteger(L, 2);

    gdImageSquareToCircle(im, r);
    return 0;
}


/* void gdImageSharpen(gdImagePtr im, int pct) */
static int LgdImageSharpen(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int pct = luaL_checkinteger(L, 2);

    gdImageSharpen(im, pct);
    return 0;
}


/* void gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2) */
static int LgdImageSetClip(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x1 = luaL_checkinteger(L, 2);
    int y1 = luaL_checkinteger(L, 3);
    int x2 = luaL_checkinteger(L, 4);
    int y2 = luaL_checkinteger(L, 5);

    gdImageSetClip(im, x1, y1, x2, y2);
    return 0;
}


/* void gdImageGetClip(gdImagePtr im, int *x1, int *y1, int *x2, int *y2) */
/* Changed to:  x1p, y1p, x2p, y2p = im:getClip() */
static int LgdImageGetClip(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;

    gdImageGetClip(im, &x1, &y1, &x2, &y2);
    lua_pushnumber(L, x1);
    lua_pushnumber(L, y1);
    lua_pushnumber(L, x2);
    lua_pushnumber(L, y2);
    return 4;
}


#ifdef GD_FONTCONFIG
/* int gdFTUseFontConfig(int flag) */
/* Changed to: gd.useFontConfig(true_or_false) */
static int LgdFTUseFontConfig(lua_State *L) {
    int b = lua_toboolean(L, 1);
    lua_pushboolean(L, gdFTUseFontConfig(b));
    return 1;
}
#endif


#ifdef GD_FREETYPE 
/* int gdFontCacheSetup(void) */
static int LgdFontCacheSetup(lua_State *L) {
    lua_pushboolean(L, !gdFontCacheSetup());
    return 1;
}


/* void gdFontCacheShutdown(void) */
static int LgdFontCacheShutdown(lua_State *L) {
    gdFontCacheShutdown();
    return 0;
}
#endif


/* char *gdImageStringFT(gdImagePtr im, int *brect, int fg, char *fontname,
        double ptsize, double angle, int x, int y, char *string)

 Changed To:
    llX, llY, lrX, lrY, urX, urY, ulX, ulY = im:stringFT(fg, fontname,
            ptsize, angle, x, y, string)

  Or (to get the points only):
    llX, llY, lrX, lrY, urX, urY, ulX, ulY = gd.stringFT(nil, fg,
            fontname, ptsize, angle, x, y, string)
*/

#ifdef GD_FREETYPE 
static int LgdImageStringFT(lua_State *L) {
    gdImagePtr im;
    int fg = luaL_checkinteger(L, 2);
    char *font = (char*) luaL_checkstring(L, 3);
    double size = (double) lua_tonumber(L, 4);
    double ang = (double) lua_tonumber(L, 5);
    int x = luaL_checkinteger(L, 6);
    int y = luaL_checkinteger(L, 7);
    char *str = (char*) luaL_checkstring(L, 8);
    int brect[8];

    if (lua_isnil(L, 1))
        im = NULL;
    else
        im = getImagePtr(L, 1);

    if (gdImageStringFT(im, brect, fg, font, size, ang, x, y, str) == NULL) {
        lua_pushnumber(L, brect[0]);
        lua_pushnumber(L, brect[1]);
        lua_pushnumber(L, brect[2]);
        lua_pushnumber(L, brect[3]);
        lua_pushnumber(L, brect[4]);
        lua_pushnumber(L, brect[5]);
        lua_pushnumber(L, brect[6]);
        lua_pushnumber(L, brect[7]);
        return 8;
    }

    lua_pushnil(L);
    return 1;
}


/* char *gdImageStringFT(gdImagePtr im, int *brect, int fg, char *fontname,
        double ptsize, double angle, int x, int y, char *string)

 Changed To:
    llX, llY, lrX, lrY, urX, urY, ulX, ulY [, xshow] [, fontpath] =
        im:stringFTEx(fg, fontname, ptsize, angle, x, y, string, { ... })

  Or:
    llX, llY, lrX, lrY, urX, urY, ulX, ulY [, xshow] [, fontpath] =
        gd.stringFTEx(nil, fg, fontname, ptsize, angle, x, y, string, { ... })

*/

static int LgdImageStringFTEx(lua_State *L) {
    gdImagePtr im;
    int fg = luaL_checkinteger(L, 2);
    char *font = (char*) luaL_checkstring(L, 3);
    double size = (double) lua_tonumber(L, 4);
    double ang = (double) lua_tonumber(L, 5);
    int x = luaL_checkinteger(L, 6);
    int y = luaL_checkinteger(L, 7);
    char *str = (char*) luaL_checkstring(L, 8);
    gdFTStringExtra *ex = getFTStringExtraPtr(L, 9);
    int brect[8];
    int ret = 8;

    if (lua_isnil(L, 1))
        im = NULL;
    else
        im = getImagePtr(L, 1);

    if (gdImageStringFTEx(im, brect, fg, font, size, ang, x, y, str, ex) == NULL) {
        lua_pushnumber(L, brect[0]);
        lua_pushnumber(L, brect[1]);
        lua_pushnumber(L, brect[2]);
        lua_pushnumber(L, brect[3]);
        lua_pushnumber(L, brect[4]);
        lua_pushnumber(L, brect[5]);
        lua_pushnumber(L, brect[6]);
        lua_pushnumber(L, brect[7]);
        ret = 8;
        if (ex->flags & gdFTEX_XSHOW) {
            lua_pushstring(L, ex->xshow);
            gdFree(ex->xshow);
            ret++;
        }
        if (ex->flags & gdFTEX_RETURNFONTPATHNAME) {
            lua_pushstring(L, ex->fontpath);
            gdFree(ex->fontpath);
            ret++;
        }

        free(ex);
        return ret;
    }

    lua_pushnil(L);
    return 1;
}



/* char *gdImageStringFTCircle(gdImagePtr im, int cx, int cy, double radius,
                double textRadius, double fillPortion, char *font,
                double points, char *top, char *bottom, int fgcolor)

   Changed to: im:stringFTCircle(cx, cy, radius, textRadius,
                   fillPortion, fontname, points, top, bottom, color)
*/

static int LgdImageStringFTCircle(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1);
    int cx = luaL_checkinteger(L, 2);
    int cy = luaL_checkinteger(L, 3);
    double radius = (double) lua_tonumber(L, 4);
    double textRadius = (double) lua_tonumber(L, 5);
    double fillPortion = (double) lua_tonumber(L, 6);
    char *font = (char*) luaL_checkstring(L, 7);
    double points = (double) lua_tonumber(L, 8);
    char *top = (char*) luaL_checkstring(L, 9);
    char *bottom = (char*) luaL_checkstring(L, 10);
    int color = luaL_checkinteger(L, 11);

    if (gdImageStringFTCircle(im, cx, cy, radius, textRadius, fillPortion,
        font, points, top, bottom, color))
        lua_pushboolean(L, 0);  /* Error */
    else
        lua_pushboolean(L, 1);
    return 1;
}
#endif


#ifdef GD_GIF
/* void gdImageGifAnimBegin(gdImagePtr im, FILE *out, int GlobalCM, int Loops)
    Changed to:  im:gifAnimBegin(filename, globalCM, loops)
*/

static int LgdImageGifAnimBegin(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1); 
    const char *fname = luaL_checkstring(L, 2);
    int globalCM = lua_toboolean(L, 3);
    int loops = luaL_checkinteger(L, 4);
    FILE *fp;

    if ((fp = fopen(fname, "wb")) == NULL) {
        lua_pushboolean(L, 0); /* Error */
        return 1;
    }

    gdImageGifAnimBegin(im, fp, globalCM, loops);
    fclose(fp);
    lua_pushboolean(L, 1);  /* ok */
    return 1;
}


/* void gdImageGifAnimAdd(gdImagePtr im, FILE *out, int LocalCM, int LeftOfs,
            int TopOfs, int Delay, int Disposal, gdImagePtr previm)
    Changed to:  im:gifAnimAdd(filename, localCM, leftOfs, topOfs, delay,
                    disposal [, previm])
*/

static int LgdImageGifAnimAdd(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1); 
    const char *fname = luaL_checkstring(L, 2);
    int localCM = lua_toboolean(L, 3);
    int leftOfs = luaL_checkinteger(L, 4);
    int topOfs = luaL_checkinteger(L, 5);
    int delay = luaL_checkinteger(L, 6);
    int disp = luaL_checkinteger(L, 7);
    gdImagePtr previm = NULL;
    FILE *fp;

    if (lua_gettop(L) >= 8)
        previm = getImagePtr(L, 8);

    if ((fp = fopen(fname, "ab")) == NULL) {
        lua_pushboolean(L, 0); /* Error */
        return 1;
    }

    gdImageGifAnimAdd(im, fp, localCM, leftOfs, topOfs, delay, disp, previm);
    fclose(fp);
    lua_pushboolean(L, 1);  /* ok */
    return 1;
}


/*  void gdImageGifAnimEnd(FILE *out)
    Changed to:  gd.gifAnimEnd(filename)
*/

static int LgdImageGifAnimEnd(lua_State *L) {
    const char *fname = luaL_checkstring(L, 1);
    FILE *fp;

    if ((fp = fopen(fname, "ab")) == NULL) {
        lua_pushboolean(L, 0); /* Error */
        return 1;
    }

    gdImageGifAnimEnd(fp);
    fclose(fp);
    lua_pushboolean(L, 1);  /* ok */
    return 1;
}


/* void* gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM,
        int Loops)
    Changed to:  im:gifAnimBeginStr(globalCM, loops)
*/

static int LgdImageGifAnimBeginPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1); 
    int globalCM = lua_toboolean(L, 2);
    int loops = luaL_checkinteger(L, 3);
    char *str;
    int size;

    str = gdImageGifAnimBeginPtr(im, &size, globalCM, loops);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else
        lua_pushnil(L);
    return 1;
}


/* void* gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM,
    int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm)

    Changed to: im:gifAnimAddStr(localCM, leftOfs, topOfs, delay,
                    disposal [, previm])
*/

static int LgdImageGifAnimAddPtr(lua_State *L) {
    gdImagePtr im = getImagePtr(L, 1); 
    int localCM = lua_toboolean(L, 2);
    int leftOfs = luaL_checkinteger(L, 3);
    int topOfs = luaL_checkinteger(L, 4);
    int delay = luaL_checkinteger(L, 5);
    int disp = luaL_checkinteger(L, 6);
    gdImagePtr previm = NULL;
    int size;
    char *str;

    if (lua_gettop(L) >= 7)
        previm = getImagePtr(L, 7);

    str = gdImageGifAnimAddPtr(im, &size, localCM, leftOfs, topOfs, delay,
            disp, previm);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else
        lua_pushnil(L);
    return 1;
}


/* void* gdImageGifAnimEndPtr(int *size)
    Changed to:  gd.gifAnimEndStr()
*/

static int LgdImageGifAnimEndPtr(lua_State *L) {
    int size;
    char *str;

    str = gdImageGifAnimEndPtr(&size);
    if (str != NULL) {
        lua_pushlstring(L, str, size);
        gdFree(str);
    } else
        lua_pushnil(L);
    return 1;
}

#endif



static const luaL_Reg LgdFunctions[] =
{
/*  Leave Lua do it!
    { "destroy",                LgdImageDestroy }, */

    { "create",                     LgdImageCreate },
    { "createPalette",              LgdImageCreatePalette },
    { "createTrueColor",            LgdImageCreateTrueColor },
    { "createPaletteFromTrueColor", LgdImageCreatePaletteFromTrueColor },
    { "trueColorToPalette",         LgdImageTrueColorToPalette },

#ifdef GD_JPEG
    { "createFromJpeg",         LgdImageCreateFromJpeg },
    { "createFromJpegStr",      LgdImageCreateFromJpegPtr },
#endif
#ifdef GD_GIF
    { "createFromGif",          LgdImageCreateFromGif },
    { "createFromGifStr",       LgdImageCreateFromGifPtr },
#endif
    { "createFromPng",          LgdImageCreateFromPng },
    { "createFromPngStr",       LgdImageCreateFromPngPtr },
    { "createFromGd",           LgdImageCreateFromGd },
    { "createFromGdStr",        LgdImageCreateFromGdPtr },
    { "createFromGd2",          LgdImageCreateFromGd2 },
    { "createFromGd2Str",       LgdImageCreateFromGd2Ptr },
    { "createFromGd2Part",      LgdImageCreateFromGd2Part },
    { "createFromGd2PartStr",   LgdImageCreateFromGd2PartPtr },

#ifdef GD_XPM
    { "createFromXbm",          LgdImageCreateFromXbm },
    { "createFromXpm",          LgdImageCreateFromXpm },
#endif

#ifdef GD_JPEG
    { "jpeg",                   LgdImageJpeg },
    { "jpegStr",                LgdImageJpegPtr },
#endif
#ifdef GD_PNG
    { "png",                    LgdImagePng },
    { "pngStr",                 LgdImagePngPtr },
    { "pngEx",                  LgdImagePngEx },
    { "pngStrEx",               LgdImagePngPtrEx },
#endif
#ifdef GD_GIF
    { "gif",                    LgdImageGif },
    { "gifStr",                 LgdImageGifPtr },
#endif
    { "gd",                     LgdImageGd },
    { "gdStr",                  LgdImageGdPtr },
    { "gd2",                    LgdImageGd2 },
    { "gd2Str",                 LgdImageGd2Ptr },
    { "wbmp",                   LgdImageWBMP },
    { "wbmpStr",                LgdImageWBMPPtr },

    { "colorAllocate",          LgdImageColorAllocate },
    { "colorAllocateAlpha",     LgdImageColorAllocateAlpha },
    { "colorClosest",           LgdImageColorClosest },
    { "colorClosestAlpha",      LgdImageColorClosestAlpha },
    { "colorClosestHWB",        LgdImageColorClosestHWB },
    { "colorExact",             LgdImageColorExact },
    { "colorExactAlpha",        LgdImageColorExactAlpha },
    { "colorResolve",           LgdImageColorResolve },
    { "colorResolveAlpha",      LgdImageColorResolveAlpha },
    { "colorsTotal",            LgdImageColorsTotal },
    { "red",                    LgdImageRed },
    { "blue",                   LgdImageBlue },
    { "green",                  LgdImageGreen },
    { "alpha",                  LgdImageAlpha },
    { "getTransparent",         LgdImageGetTransparent },
    { "colorTransparent",       LgdImageColorTransparent },
    { "colorDeallocate",        LgdImageColorDeallocate },

    { "boundsSafe",             LgdImageBoundsSafe },
    { "getPixel",               LgdImageGetPixel },
    { "sizeX",                  LgdImageSX },
    { "sizeY",                  LgdImageSY },
    { "sizeXY",                 LgdImageSXY },
    { "getClip",                LgdImageGetClip },
    { "setClip",                LgdImageSetClip },

    { "setPixel",               LgdImageSetPixel },
    { "line",                   LgdImageLine },
    { "rectangle",              LgdImageRectangle },
    { "filledRectangle",        LgdImageFilledRectangle },
    { "polygon",                LgdImagePolygon },
    { "filledPolygon",          LgdImageFilledPolygon },
    { "openPolygon",            LgdImageOpenPolygon },
    { "arc",                    LgdImageArc },
    { "filledArc",              LgdImageFilledArc },
    { "filledEllipse",          LgdImageFilledEllipse },
    { "fill",                   LgdImageFill },
    { "fillToBorder",           LgdImageFillToBorder },

    { "setAntiAliased",            LgdImageSetAntiAliased },
    { "setAntiAliasedDontBlend",   LgdImageSetAntiAliasedDontBlend },
    { "setBrush",                  LgdImageSetBrush },
    { "setTile",                   LgdImageSetTile },
    { "setStyle",                  LgdImageSetStyle },
    { "setThickness",              LgdImageSetThickness },
    { "alphaBlending",             LgdImageAlphaBlending },
    { "saveAlpha",                 LgdImageSaveAlpha },
    { "getInterlaced",             LgdImageGetInterlaced },
    { "interlace",                 LgdImageInterlace },

    { "string",                 LgdImageString },
    { "stringUp",               LgdImageStringUp },
    { "char",                   LgdImageChar },
    { "charUp",                 LgdImageCharUp },

    { "copy",                   LgdImageCopy },
    { "copyResized",            LgdImageCopyResized },
    { "copyResampled",          LgdImageCopyResampled },
    { "copyRotated",            LgdImageCopyRotated },
    { "copyMerge",              LgdImageCopyMerge },
    { "copyMergeGray",          LgdImageCopyMergeGray },
    { "paletteCopy",            LgdImagePaletteCopy },
    { "squareToCircle",         LgdImageSquareToCircle },
    { "sharpen",                LgdImageSharpen },

#ifdef GD_FREETYPE
    { "stringFT",               LgdImageStringFT },
    { "stringFTEx",             LgdImageStringFTEx },
    { "stringFTCircle",         LgdImageStringFTCircle },
    { "fontCacheSetup",         LgdFontCacheSetup },
    { "fontCacheShutdown",      LgdFontCacheShutdown },
#endif
    
#ifdef GD_FONTCONFIG
    { "useFontConfig",          LgdFTUseFontConfig },
#endif

#ifdef GD_GIF  /* Gif animation */
    { "gifAnimBegin",           LgdImageGifAnimBegin },
    { "gifAnimAdd",             LgdImageGifAnimAdd },
    { "gifAnimEnd",             LgdImageGifAnimEnd },
    { "gifAnimBeginStr",        LgdImageGifAnimBeginPtr },
    { "gifAnimAddStr",          LgdImageGifAnimAddPtr },
    { "gifAnimEndStr",          LgdImageGifAnimEndPtr },
#endif

    { NULL, NULL }
};


static const luaL_Reg LgdMetatable[] =
{
    { "__gc", LgdImageDestroy },
    { NULL, NULL }
};


int luaopen_gd(lua_State *L) {
    lua_newtable(L);
    luaL_setfuncs(L, LgdFunctions, 0);

    lua_pushliteral(L, "VERSION");
    lua_pushstring(L, LIB_VERSION);
    lua_settable(L, -3);

    lua_pushliteral(L, "COPYRIGHT");
    lua_pushstring(L, LIB_COPYRIGHT);
    lua_settable(L, -3);
    
    tblseticons(L, "MAX_COLORS", gdMaxColors);
    tblseticons(L, "GD2_FMT_RAW", GD2_FMT_RAW);
    tblseticons(L, "GD2_FMT_COMPRESSED", GD2_FMT_COMPRESSED);
    tblseticons(L, "ARC", gdArc);
    tblseticons(L, "CHORD", gdChord);
    tblseticons(L, "PIE", gdPie);
    tblseticons(L, "NO_FILL", gdNoFill);
    tblseticons(L, "EDGED", gdEdged);
    tblseticons(L, "ANTI_ALIASED", gdAntiAliased);
    tblseticons(L, "BRUSHED", gdBrushed);
    tblseticons(L, "STYLED", gdStyled);
    tblseticons(L, "STYLED_BRUSHED", gdStyledBrushed);
    tblseticons(L, "TILED", gdTiled);
    tblseticons(L, "TRANSPARENT", gdTransparent);

#ifdef GD_FREETYPE
    /* For gd.StringFTEx */
    tblseticons(L, "FTEX_Unicode", gdFTEX_Unicode);
    tblseticons(L, "FTEX_Shift_JIS", gdFTEX_Shift_JIS);
    tblseticons(L, "FTEX_Big5", gdFTEX_Big5);
#endif

#ifdef GD_GIF
    /* For gif animation */
    tblseticons(L, "DISPOSAL_NONE", gdDisposalNone);
    tblseticons(L, "DISPOSAL_UNKNOWN", gdDisposalUnknown);
    tblseticons(L, "DISPOSAL_RESTORE_BACKGROUND", gdDisposalRestoreBackground);
    tblseticons(L, "DISPOSAL_RESTORE_PREVIOUS", gdDisposalRestorePrevious);
#endif

    /* Standard gd fonts */
    tblseticons(L, "FONT_TINY", MY_GD_FONT_TINY);
    tblseticons(L, "FONT_SMALL", MY_GD_FONT_SMALL);
    tblseticons(L, "FONT_MEDIUM", MY_GD_FONT_MEDIUM_BOLD);
    tblseticons(L, "FONT_LARGE", MY_GD_FONT_LARGE);
    tblseticons(L, "FONT_GIANT", MY_GD_FONT_GIANT);

    luaL_newmetatable(L, GD_IMAGE_PTR_TYPENAME);
    lua_pushliteral(L, "__index");
    lua_pushvalue(L, -3);
    lua_settable(L, -3);
    luaL_setfuncs(L, LgdMetatable, 0);
    lua_pop(L, 1);

    return 1;
}