summaryrefslogtreecommitdiff
path: root/src/lua3/cdlua.c
diff options
context:
space:
mode:
authorscuri <scuri>2008-10-17 06:10:33 +0000
committerscuri <scuri>2008-10-17 06:10:33 +0000
commit7b52cc13af4e85f1ca2deb6b6c77de9c95ea0dcf (patch)
treed0857278bde2eff784227c57dcaf930346ceb7ac /src/lua3/cdlua.c
First commit - moving from LuaForge to SourceForge
Diffstat (limited to 'src/lua3/cdlua.c')
-rw-r--r--src/lua3/cdlua.c4366
1 files changed, 4366 insertions, 0 deletions
diff --git a/src/lua3/cdlua.c b/src/lua3/cdlua.c
new file mode 100644
index 0000000..ea5ac44
--- /dev/null
+++ b/src/lua3/cdlua.c
@@ -0,0 +1,4366 @@
+/***************************************************************************\
+* CDLUA.C, for LUA 3.1 *
+* Diego Fernandes Nehab, Antonio Escano Scuri *
+* 01/99 *
+* Implements all that TOLUA couldn't handle. *
+\***************************************************************************/
+
+/***************************************************************************\
+* Included definitions. *
+\***************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+/***************************************************************************\
+* CD Definitions. *
+\***************************************************************************/
+#include "cd.h"
+#include "wd.h"
+
+#include "cdirgb.h" /* cdRedImage, cdGreenImage, cdBlueImage */
+
+/* error checking when there is no active canvas */
+#include "cdvoid.h"
+
+/***************************************************************************\
+* LUA Definitions. *
+\***************************************************************************/
+#include <lua.h>
+#include <lauxlib.h>
+
+/***************************************************************************\
+* CDLUA Definitions. *
+\***************************************************************************/
+#include "cdlua.h"
+#include "cdlua3_private.h"
+
+/***************************************************************************\
+* Globals. *
+\***************************************************************************/
+static int color_tag;
+static int stipple_tag;
+static int pattern_tag;
+static int image_tag;
+static int bitmap_tag;
+static int imagergb_tag;
+static int imagergba_tag;
+static int palette_tag;
+static int imagemap_tag;
+static int channel_tag;
+static int canvas_tag;
+static int state_tag;
+
+static channel_t channel_info;
+static cdCanvas *void_canvas;
+static cdContextLUA* cdlua_drivers[50];
+static int cdlua_numdrivers = 0;
+static lua_Object cdlua_namespace;
+
+int luaL_cd_open(void); /* from toluacd.c */
+int luaL_wd_open(void); /* from toluawd.c */
+void cdlua_initdrivers(void); /* to cdluactx.c */
+
+
+/***************************************************************************\
+* Creation and destruction of types LUA can't handle. *
+\***************************************************************************/
+
+void cdlua_setnamespace(char* name, char* new_name)
+{
+ lua_Object obj = lua_getglobal(name);
+ lua_pushobject(cdlua_namespace);
+ lua_pushstring(new_name);
+ lua_pushobject(obj);
+ lua_settable();
+}
+
+void cdlua_register(char* name, lua_CFunction func)
+{
+ lua_register(name, func);
+
+ if (name[0] == 'w')
+ {
+ char new_name[100];
+ new_name[0] = 'w';
+ strcpy(new_name+1, name+2);
+ cdlua_setnamespace(name, new_name); /* wdXXX */
+ }
+ else
+ cdlua_setnamespace(name, name+2); /* cdXXX */
+}
+
+void cdlua_pushnumber(double num, char* name)
+{
+ lua_pushnumber(num); lua_setglobal(name);
+ cdlua_setnamespace(name, name+3); /* CD_XXXX */
+}
+
+static void cdlua_pushcolor(long color, char* name)
+{
+ lua_pushusertag((void*)color, color_tag); lua_setglobal(name);
+ cdlua_setnamespace(name, name+3); /* CD_XXXX */
+}
+
+void cdlua_addcontext(cdContextLUA* luactx)
+{
+ int i;
+ luactx->id = cdlua_numdrivers;
+ cdlua_drivers[cdlua_numdrivers] = luactx;
+
+ cdlua_pushnumber(cdlua_numdrivers, luactx->name);
+
+ /* skip CD_SIZECB, register other callbacks */
+ for (i=1; i<luactx->cb_n; i++)
+ {
+ cdlua_pushnumber(i, luactx->cb_list[i].name);
+ }
+
+ cdlua_numdrivers++;
+}
+
+/***************************************************************************\
+* Creates a CD canvas as a canvas_tag usertag lua_Object. *
+* If the creation fails, the function returns a nil lua_Object. *
+\***************************************************************************/
+static void cdlua_createcanvas(void)
+{
+ lua_Object driver;
+
+ long int driver_i;
+ canvas_t *canvas_p;
+ void *data_p;
+
+ /* if there is not enough memory */
+ canvas_p = (canvas_t *) malloc(sizeof(canvas_t));
+ if (!canvas_p) {
+ lua_pushnil();
+ return;
+ }
+
+ /* get driver parameter */
+ driver = lua_getparam(1);
+ if (!lua_isnumber(driver))
+ lua_error("cdCreateCanvas: invalid driver parameter!");
+ driver_i = (long int) lua_getnumber(driver);
+
+ if (driver_i >= cdlua_numdrivers)
+ lua_error("cdCreateCanvas: unknown driver!");
+
+ data_p = cdlua_drivers[driver_i]->checkdata(2);
+ canvas_p->cd_canvas = cdCreateCanvas(cdlua_drivers[driver_i]->ctx(), data_p);
+
+ /* if creation failed, return nil so that the user can compare */
+ /* the result with nil and know that it failed */
+ if (!canvas_p->cd_canvas) {
+ free(canvas_p);
+ lua_pushnil();
+ }
+ /* else, return a canvas_t structure */
+ else
+ lua_pushusertag((void *) canvas_p, canvas_tag);
+}
+
+static lua_Object wdlua_hardcopy_func_lua = 0;
+
+static void wdlua_hardcopy_func(void)
+{
+ lua_callfunction(wdlua_hardcopy_func_lua);
+}
+
+static void wdlua_hardcopy(void)
+{
+ lua_Object driver;
+ lua_Object canvas;
+
+ long int driver_i;
+ canvas_t *canvas_p;
+ void *data_p;
+
+ /* get driver parameter */
+ driver = lua_getparam(1);
+ if (!lua_isnumber(driver))
+ lua_error("wdHardcopy: invalid driver parameter!");
+ driver_i = (long int) lua_getnumber(driver);
+
+ canvas = lua_getparam(3);
+
+ if (canvas == LUA_NOOBJECT)
+ lua_error("wdHardcopy: canvas parameter missing!");
+
+ /* if the creation failed, canvas can be nil, in which case we */
+ /* issue an error */
+ if (lua_isnil(canvas))
+ lua_error("wdHardcopy: attempt to get a NIL canvas!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("wdHardcopy: invalid canvas parameter!");
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("wdHardcopy: attempt to get a killed canvas!");
+
+ wdlua_hardcopy_func_lua = lua_getparam(4);
+
+ if (!lua_isfunction(wdlua_hardcopy_func_lua))
+ lua_error("wdHardcopy: invalid draw function!");
+
+ if (lua_getparam(5) != LUA_NOOBJECT)
+ lua_error("wdHardcopy: too many parameters!");
+
+ if (driver_i >= cdlua_numdrivers)
+ lua_error("wdHardcopy: unknown driver!");
+
+ data_p = cdlua_drivers[driver_i]->checkdata(2);
+ wdHardcopy(cdlua_drivers[driver_i]->ctx(), data_p, canvas_p->cd_canvas, wdlua_hardcopy_func);
+}
+
+static void cdlua_getcontext(void)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+ cdContext* ctx;
+ int driver_i = -1, i;
+
+ canvas = lua_getparam(1);
+
+ if (canvas == LUA_NOOBJECT)
+ lua_error("cdGetContext: canvas parameter missing!");
+
+ /* if the creation failed, canvas can be nil, in which case we */
+ /* issue an error */
+ if (lua_isnil(canvas))
+ lua_error("cdGetContext: attempt to get a NIL canvas!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("cdGetContext: invalid canvas parameter!");
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("cdGetContext: attempt to get a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdGetContext: too many parameters!");
+
+ ctx = cdGetContext(canvas_p->cd_canvas);
+
+ for (i=0; i < cdlua_numdrivers; i++)
+ {
+ if (ctx == cdlua_drivers[i]->ctx())
+ {
+ driver_i = i;
+ break;
+ }
+ }
+
+ if (i == cdlua_numdrivers)
+ lua_error("cdGetContext: unknown driver!");
+
+ lua_pushnumber(driver_i);
+}
+
+static void cdlua_contextcaps(void)
+{
+ lua_Object driver;
+ long int driver_i;
+ unsigned long caps;
+
+ /* get driver parameter */
+ driver = lua_getparam(1);
+ if (!lua_isnumber(driver))
+ lua_error("cdCreateCanvas: invalid driver parameter!");
+ driver_i = (long int) lua_getnumber(driver);
+
+ if (driver_i >= cdlua_numdrivers)
+ lua_error("cdContextCaps: unknown driver!");
+
+ caps = cdContextCaps(cdlua_drivers[driver_i]->ctx());
+
+ lua_pushnumber(caps);
+}
+
+/***************************************************************************\
+* Activates a cd canvas. *
+\***************************************************************************/
+static void cdlua_activate(void)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+
+ canvas = lua_getparam(1);
+
+ if (canvas == LUA_NOOBJECT)
+ lua_error("cdActivate: canvas parameter missing!");
+
+ /* if canvas is nil, activate a void canvas */
+ if (lua_isnil(canvas)) {
+ lua_pushnumber(cdActivate(void_canvas));
+ return;
+ }
+
+ if (lua_tag(canvas) != canvas_tag) {
+ cdActivate(void_canvas);
+ lua_error("cdActivate: invalid canvas parameter!");
+ }
+
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas) {
+ cdActivate(void_canvas);
+ lua_error("cdActivate: attempt to activate a killed canvas!");
+ }
+
+ if (lua_getparam(2) != LUA_NOOBJECT) {
+ cdActivate(void_canvas);
+ lua_error("cdActivate: too many parameters!");
+ }
+
+ lua_pushnumber(cdActivate(canvas_p->cd_canvas));
+}
+
+/***************************************************************************\
+* Returns the active canvas. *
+\***************************************************************************/
+static void cdlua_activecanvas(void)
+{
+ canvas_t *canvas_p;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdActiveCanvas: too many parameters!");
+
+ canvas_p = (canvas_t *) malloc(sizeof(canvas_t));
+ if (!canvas_p) {
+ lua_pushnil();
+ return;
+ }
+
+ canvas_p->cd_canvas = cdActiveCanvas();
+
+ /* if the active canvas is NULL, return nil so that the user can compare */
+ /* the result with nil */
+ if (!canvas_p->cd_canvas) {
+ free(canvas_p);
+ lua_pushnil();
+ }
+ else
+ lua_pushusertag((void *) canvas_p, canvas_tag);
+}
+
+cdCanvas* cdlua_checkcanvas(int pos)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+
+ canvas = lua_getparam(pos);
+
+ if (canvas == LUA_NOOBJECT)
+ lua_error("cdlua_getcanvas: canvas parameter missing!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("cdlua_getcanvas: invalid canvas parameter!");
+
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("cdlua_getcanvas: attempt to get a killed canvas!");
+
+ return canvas_p->cd_canvas;
+}
+
+cdCanvas* cdlua_getcanvas(void)
+{
+ return cdlua_checkcanvas(1);
+}
+
+void cdlua_pushcanvas(cdCanvas* canvas)
+{
+ canvas_t *canvas_p = (canvas_t *) malloc(sizeof(canvas_t));
+ canvas_p->cd_canvas = canvas;
+ lua_pushusertag((void *)canvas_p, canvas_tag);
+}
+
+static void cdlua_savestate(void)
+{
+ state_t *state_p;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdSaveState: too many parameters!");
+
+ state_p = (state_t *) malloc(sizeof(state_t));
+ if (!state_p) {
+ lua_pushnil();
+ return;
+ }
+
+ state_p->state = cdSaveState();
+
+ /* if the active canvas is NULL, return nil so that the user can compare */
+ /* the result with nil */
+ if (!state_p->state) {
+ free(state_p);
+ lua_pushnil();
+ }
+ else
+ lua_pushusertag((void *) state_p, state_tag);
+}
+
+static void cdlua_restorestate(void)
+{
+ lua_Object state;
+ state_t *state_p;
+
+ state = lua_getparam(1);
+ if (state == LUA_NOOBJECT)
+ lua_error("cdRestoreState: state parameter missing!");
+ if (lua_isnil(state))
+ lua_error("cdRestoreState: attempt to restore a NIL state!");
+
+ if (lua_tag(state) != state_tag)
+ lua_error("cdRestoreState: invalid canvas parameter!");
+
+ state_p = (state_t *) lua_getuserdata(state);
+ if (!state_p->state)
+ lua_error("cdRestoreState: attempt to restore a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdRestoreState: too many parameters!");
+
+ cdRestoreState(state_p->state);
+}
+
+static void cdlua_releasestate(void)
+{
+ lua_Object state;
+ state_t *state_p;
+
+ state = lua_getparam(1);
+ if (state == LUA_NOOBJECT)
+ lua_error("cdReleaseState: state parameter missing!");
+ if (lua_isnil(state))
+ lua_error("cdReleaseState: attempt to release a NIL state!");
+
+ if (lua_tag(state) != state_tag)
+ lua_error("cdReleaseState: invalid canvas parameter!");
+
+ state_p = (state_t *) lua_getuserdata(state);
+ if (!state_p->state)
+ lua_error("cdReleaseState: attempt to release a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdReleaseState: too many parameters!");
+
+ cdReleaseState(state_p->state);
+ state_p->state = NULL;
+}
+
+static void cdlua_LineStyleDashes(void)
+{
+ lua_Object dashes, count, value;
+ int *dashes_int, dashes_count, i;
+
+ dashes = lua_getparam(1);
+ if (dashes == LUA_NOOBJECT)
+ lua_error("cdLineStyleDashes: dashes parameter missing!");
+ if (lua_isnil(dashes))
+ lua_error("cdLineStyleDashes: dashes parameter is nil!");
+ if (!lua_istable(dashes))
+ lua_error("cdLineStyleDashes: invalid dashes parameter!");
+
+ count = lua_getparam(2);
+ if (count == LUA_NOOBJECT)
+ lua_error("cdLineStyleDashes: count parameter missing!");
+ if (lua_isnil(count))
+ lua_error("cdLineStyleDashes: count parameter is nil!");
+ if (!lua_isnumber(dashes))
+ lua_error("cdLineStyleDashes: invalid count parameter!");
+
+ dashes_count = (int)lua_getnumber(count);
+ dashes_int = malloc(dashes_count*sizeof(int));
+
+ for (i=0; i < dashes_count; i++)
+ {
+ lua_pushobject(dashes);
+ lua_pushnumber(i+1);
+ value = lua_gettable();
+
+ if (!lua_isnumber(value))
+ lua_error("cdLineStyleDashes: invalid dash!");
+
+ dashes_int[i] = (int)lua_getnumber(value);
+ }
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdLineStyleDashes: too many parameters!");
+
+ cdLineStyleDashes(dashes_int, dashes_count);
+ free(dashes_int);
+}
+
+/***************************************************************************\
+* Frees a previously alocated canvas. *
+\***************************************************************************/
+static void cdlua_killcanvas(void)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+ cdCanvas *current_canvas;
+
+ canvas = lua_getparam(1);
+
+ if (canvas == LUA_NOOBJECT)
+ lua_error("cdKillCanvas: canvas parameter missing!");
+
+ /* if the creation failed, canvas can be nil, in which case we */
+ /* issue an error */
+ if (lua_isnil(canvas))
+ lua_error("cdKillCanvas: attempt to kill a NIL canvas!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("cdKillCanvas: invalid canvas parameter!");
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("cdKillCanvas: attempt to kill a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillCanvas: too many parameters!");
+
+ /* find out about the currently active canvas */
+ current_canvas = cdActiveCanvas();
+
+ /* this should never happen, unless the user did it on purpouse! */
+ if (canvas_p->cd_canvas == void_canvas)
+ lua_error("cdKillCanvas: trying to kill the void canvas???");
+
+ /* if the user killed the currently active canvas, activate void canvas */
+ if (canvas_p->cd_canvas == current_canvas) {
+ cdActivate(void_canvas);
+ }
+
+ cdKillCanvas(canvas_p->cd_canvas);
+ canvas_p->cd_canvas = NULL;
+}
+
+/***************************************************************************\
+* Creates a color as a color_tag usertag lua_Object. The color value is *
+* placed in the (void *) value. Not beautiful, but works best. *
+\***************************************************************************/
+static void cdlua_encodecolor(void)
+{
+ lua_Object red, green, blue;
+ float red_f, green_f, blue_f;
+ unsigned char red_i, green_i, blue_i;
+ long int color_i;
+
+ red = lua_getparam(1);
+ green = lua_getparam(2);
+ blue = lua_getparam(3);
+ if (!(lua_isnumber(red) && lua_isnumber(green) && lua_isnumber(blue)))
+ lua_error("cdEncodeColor: invalid color component parameter!");
+ red_f = (float) lua_getnumber(red);
+ green_f = (float) lua_getnumber(green);
+ blue_f = (float) lua_getnumber(blue);
+ if (red_f < 0 || red_f > 255 || green_f < 0 ||
+ green_f > 255 || blue_f < 0 || blue_f > 255)
+ lua_error("cdEncodeColor: color components values should be in range [0, 255]!");
+ red_i = (unsigned char) (red_f);
+ green_i = (unsigned char) (green_f);
+ blue_i = (unsigned char) (blue_f);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdEncodeColor: too many parameters!");
+
+ color_i = cdEncodeColor(red_i, green_i, blue_i);
+ lua_pushusertag((void *) color_i, color_tag);
+}
+
+static void cdlua_encodealpha(void)
+{
+ lua_Object color, alpha;
+ float alpha_f;
+ unsigned char alpha_i;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdEncodeAlpha: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ alpha = lua_getparam(2);
+ if (!lua_isnumber(alpha))
+ lua_error("cdEncodeAlpha: invalid alpha parameter!");
+ alpha_f = (float) lua_getnumber(alpha);
+ if (alpha_f < 0 || alpha_f > 255)
+ lua_error("cdEncodeAlpha: alpha components values should be in range [0, 255]!");
+ alpha_i = (unsigned char) (alpha_f);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdEncodeAlpha: too many parameters!");
+
+ color_i = cdEncodeAlpha(color_i, alpha_i);
+ lua_pushusertag((void *) color_i, color_tag);
+}
+
+/***************************************************************************\
+* Decodes a color previously created. *
+\***************************************************************************/
+static void cdlua_decodecolor(void)
+{
+ lua_Object color;
+ long int color_i;
+ unsigned char red_i, green_i, blue_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdDecodeColor: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdDecodeColor: too many parameters!");
+
+ cdDecodeColor(color_i, &red_i, &green_i, &blue_i);
+ lua_pushnumber(red_i);
+ lua_pushnumber(green_i);
+ lua_pushnumber(blue_i);
+}
+
+static void cdlua_decodealpha(void)
+{
+ lua_Object color;
+ long int color_i;
+ unsigned char alpha_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdDecodeAlpha: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdDecodeAlpha: too many parameters!");
+
+ alpha_i = cdDecodeAlpha(color_i);
+ lua_pushnumber(alpha_i);
+}
+
+static void cdlua_alpha(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdRed: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdAlpha: too many parameters!");
+
+ lua_pushnumber(cdAlpha(color_i));
+}
+
+static void cdlua_red(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdRed: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdRed: too many parameters!");
+
+ lua_pushnumber(cdRed(color_i));
+}
+
+static void cdlua_blue(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdBlue: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdBlue: too many parameters!");
+
+ lua_pushnumber(cdBlue(color_i));
+}
+
+static void cdlua_green(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdGreen: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdGreen: too many parameters!");
+
+ lua_pushnumber(cdGreen(color_i));
+}
+
+static void cdlua_reserved(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdReserved: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdReserved: too many parameters!");
+
+ lua_pushnumber(cdReserved(color_i));
+}
+
+/***************************************************************************\
+* Creates a stipple as a stipple_tag usertag lua_Object. *
+\***************************************************************************/
+static void cdlua_createstipple(void)
+{
+ lua_Object width, height;
+ long int width_i, height_i;
+ stipple_t *stipple_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateStipple: invalid dimension parameters!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateStipple: stipple dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreateStipple: too many parameters!");
+
+ stipple_p = (stipple_t *) malloc(sizeof(stipple_t));
+ if (!stipple_p) {
+ lua_pushnil();
+ return;
+ }
+
+ stipple_p->size = width_i*height_i;
+ stipple_p->height = height_i;
+ stipple_p->width = width_i;
+ stipple_p->value = (unsigned char *) malloc(stipple_p->size);
+ if (!stipple_p->value) {
+ free(stipple_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(stipple_p->value, '\0', stipple_p->size);
+ lua_pushusertag((void *) stipple_p, stipple_tag);
+}
+
+static void cdlua_getstipple(void)
+{
+ int width, height;
+ unsigned char * stipple;
+ stipple_t *stipple_p;
+
+ stipple = cdGetStipple(&width, &height);
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdGetStipple: too many parameters!");
+
+ stipple_p = (stipple_t *) malloc(sizeof(stipple_t));
+ if (!stipple_p) {
+ lua_pushnil();
+ return;
+ }
+
+ stipple_p->size = width*height;
+ stipple_p->height = height;
+ stipple_p->width = width;
+ stipple_p->value = (unsigned char *) malloc(stipple_p->size);
+ if (!stipple_p->value) {
+ free(stipple_p);
+ lua_pushnil();
+ return;
+ }
+
+ memcpy(stipple_p->value, stipple, stipple_p->size);
+ lua_pushusertag((void *) stipple_p, stipple_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated stipple. We don't free stipple_p to prevent *
+* a problem if the user called killstipple twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killstipple(void)
+{
+ lua_Object stipple;
+ stipple_t *stipple_p;
+
+ stipple = lua_getparam(1);
+ if (stipple == LUA_NOOBJECT)
+ lua_error("cdKillStipple: stipple parameter missing!");
+ if (lua_isnil(stipple))
+ lua_error("cdKillStipple: attempt to kill a NIL stipple!");
+ if (lua_tag(stipple) != stipple_tag)
+ lua_error("cdKillStipple: invalid stipple parameter!");
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p->value)
+ lua_error("cdKillStipple: attempt to kill a killed stipple!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillStipple: too many parameters!");
+
+ free(stipple_p->value);
+ stipple_p->value = NULL;
+}
+
+/***************************************************************************\
+* Creates a pattern as a pattern_tag usertag lua_Object. A pattern can be *
+* considered and treated as a color table. *
+\***************************************************************************/
+static void cdlua_createpattern(void)
+{
+ lua_Object width, height;
+ long int width_i, height_i;
+ pattern_t *pattern_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreatePattern: invalid dimension parameters!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreatePattern: pattern dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreatePattern: too many parameters!");
+
+ pattern_p = (pattern_t *) malloc(sizeof(pattern_t));
+ if (!pattern_p) {
+ lua_pushnil();
+ return;
+ }
+
+ pattern_p->size = width_i*height_i;
+ pattern_p->width = width_i;
+ pattern_p->height = height_i;
+ pattern_p->color = (long int *) malloc(pattern_p->size * sizeof(long int));
+ if (!pattern_p->color) {
+ free(pattern_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(pattern_p->color, 255, pattern_p->size * sizeof(long int));
+ lua_pushusertag((void *) pattern_p, pattern_tag);
+}
+
+static void cdlua_getpattern(void)
+{
+ int width, height;
+ long int * pattern;
+ pattern_t *pattern_p;
+
+ pattern = cdGetPattern(&width, &height);
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdGetPattern: too many parameters!");
+
+ pattern_p = (pattern_t *) malloc(sizeof(pattern_t));
+ if (!pattern_p) {
+ lua_pushnil();
+ return;
+ }
+
+ pattern_p->size = width*height;
+ pattern_p->height = height;
+ pattern_p->width = width;
+ pattern_p->color = (long int *) malloc(pattern_p->size * sizeof(long int));
+ if (!pattern_p->color) {
+ free(pattern_p);
+ lua_pushnil();
+ return;
+ }
+
+ memcpy(pattern_p->color, pattern, pattern_p->size * sizeof(long int));
+ lua_pushusertag((void *) pattern_p, pattern_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated pattern. We don't free pattern_p to prevent *
+* a problem if the user called killpattern twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killpattern(void)
+{
+ lua_Object pattern;
+ pattern_t *pattern_p;
+
+ pattern = lua_getparam(1);
+
+ if (pattern == LUA_NOOBJECT)
+ lua_error("cdKillPattern: pattern parameter missing!");
+ if (lua_isnil(pattern))
+ lua_error("cdKillPattern: attempt to kill a NIL pattern!");
+ if (lua_tag(pattern) != pattern_tag)
+ lua_error("cdKillPattern: invalid pattern parameter!");
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p->color)
+ lua_error("cdKillPattern: attempt to kill a killed pattern!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillPattern: too many parameters!");
+
+ free(pattern_p->color);
+ pattern_p->color = NULL;
+}
+
+/***************************************************************************\
+* Creates a palette as a palette_tag usertag lua_Object. A palette can be *
+* considered and treated as a color table. *
+\***************************************************************************/
+static void cdlua_createpalette(void)
+{
+ lua_Object size;
+ long int size_i;
+ palette_t *palette_p;
+
+ size = lua_getparam(1);
+ if (!(lua_isnumber(size)))
+ lua_error("cdCreatePalette: invalid size parameter!");
+ size_i = (long int) lua_getnumber(size);
+ if (size_i < 1)
+ lua_error("cdCreatePalette: palette size should be a positive integer!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdCreatePalette: too many parameters!");
+
+ palette_p = (palette_t *) malloc(sizeof(palette_t));
+ if (!palette_p) {
+ lua_pushnil();
+ return;
+ }
+
+ palette_p->size = size_i;
+ palette_p->color = (long int *) malloc(palette_p->size * sizeof(long int));
+ if (!palette_p->color) {
+ free(palette_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(palette_p->color, 255, palette_p->size * sizeof(long int));
+ lua_pushusertag((void *) palette_p, palette_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated palette. We don't free palette_p to prevent *
+* a problem if the user called killpalette twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killpalette(void)
+{
+ lua_Object palette;
+ palette_t *palette_p;
+
+ palette = lua_getparam(1);
+ if (palette == LUA_NOOBJECT)
+ lua_error("cdKillPalette: palette parameter missing!");
+ if (lua_isnil(palette))
+ lua_error("cdKillPalette: attempt to kill a NIL palette!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("cdKillPalette: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("cdKillPalette: attempt to kill a killed palette!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillPalette: too many parameters!");
+
+ free(palette_p->color);
+ palette_p->color = NULL;
+}
+
+/***************************************************************************\
+* Image Extended Functions. *
+\***************************************************************************/
+
+static void cdlua_createbitmap(void)
+{
+ lua_Object width;
+ lua_Object height;
+ lua_Object type;
+
+ long int width_i;
+ long int height_i;
+ int type_i;
+ bitmap_t *image_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ type = lua_getparam(3);
+ if (!(lua_isnumber(type) && lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateBitmap: invalid parameters!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ type_i = (long int) lua_getnumber(type);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateBitmap: imagemap dimensions should be positive integers!");
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdCreateBitmap: too many parameters!");
+
+ image_p = (bitmap_t *) malloc(sizeof(bitmap_t));
+ if (!image_p) {
+ lua_pushnil();
+ return;
+ }
+
+ image_p->image = cdCreateBitmap(width_i, height_i, type_i);
+ if (!image_p->image) {
+ free(image_p);
+ lua_pushnil();
+ }
+ else
+ lua_pushusertag((void *) image_p, bitmap_tag);
+}
+
+static void cdlua_killbitmap(void)
+{
+ lua_Object image;
+ bitmap_t *image_p;
+
+ image = lua_getparam(1);
+ if (image == LUA_NOOBJECT)
+ lua_error("cdKillBitmap: image parameter missing!");
+ if (lua_isnil(image))
+ lua_error("cdKillBitmap: attempt to kill a NIL image!");
+ if (lua_tag(image) != bitmap_tag)
+ lua_error("cdKillBitmap: invalid image parameter!");
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p->image)
+ lua_error("cdKillBitmap: attempt to kill a killed image");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillBitmap: too many parameters!");
+
+ cdKillBitmap(image_p->image);
+ image_p->image = NULL;
+}
+
+static void cdlua_getbitmap(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+
+ bitmap_t *image_p;
+ int x_i;
+ int y_i;
+
+ image = lua_getparam(1);
+ if (image == LUA_NOOBJECT)
+ lua_error("cdGetBitmap: image parameter missing!");
+ if (lua_isnil(image))
+ lua_error("cdGetBitmap: attempt to get NIL image");
+ if (lua_tag(image) != bitmap_tag)
+ lua_error("cdGetBitmap: invalid image parameter!");
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p->image)
+ lua_error("cdGetBitmap: attempt to get a killed image");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("cdGetBitmap: invalid (x, y) parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdGetBitmap: too many parameters!");
+
+ cdGetBitmap(image_p->image, x_i, y_i);
+}
+
+static void cdlua_putbitmap(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+
+ bitmap_t *image_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+
+ image = lua_getparam(1);
+ if (image == LUA_NOOBJECT)
+ lua_error("cdPutBitmap: image parameter missing!");
+ if (lua_isnil(image))
+ lua_error("cdPutBitmap: attempt to put a NIL image!");
+ if (lua_tag(image) != bitmap_tag)
+ lua_error("cdPutBitmap: invalid image parameter!");
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p->image)
+ lua_error("cdPutBitmap: attempt to put a killed image!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h)))
+ lua_error("cdPutBitmap: invalid (x, y) parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutBitmap: target region dimensions should be positive integers!");
+
+ if (lua_getparam(6) != LUA_NOOBJECT)
+ lua_error("cdPutBitmap: too many parameters!");
+
+ cdPutBitmap(image_p->image, x_i, y_i, w_i, h_i);
+}
+
+static void wdlua_putbitmap(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+
+ bitmap_t *image_p;
+ double x_i;
+ double y_i;
+ double w_i;
+ double h_i;
+
+ image = lua_getparam(1);
+ if (image == LUA_NOOBJECT)
+ lua_error("wdPutBitmap: image parameter missing!");
+ if (lua_isnil(image))
+ lua_error("wdPutBitmap: attempt to put a NIL image!");
+ if (lua_tag(image) != bitmap_tag)
+ lua_error("wdPutBitmap: invalid image parameter!");
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p->image)
+ lua_error("wdPutBitmap: attempt to put a killed image!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h)))
+ lua_error("wdPutBitmap: invalid (x, y) parameter!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+ w_i = (double) lua_getnumber(w);
+ h_i = (double) lua_getnumber(h);
+ if (w_i < 0 || h_i < 0)
+ lua_error("wdPutBitmap: target region dimensions should be positive integers!");
+
+ if (lua_getparam(6) != LUA_NOOBJECT)
+ lua_error("wdPutBitmap: too many parameters!");
+
+ wdPutBitmap(image_p->image, x_i, y_i, w_i, h_i);
+}
+
+static void cdlua_bitmapsetrect(void)
+{
+ lua_Object image;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ bitmap_t *image_p;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ image = lua_getparam(1);
+ if (image == LUA_NOOBJECT)
+ lua_error("cdBitmapSetRect: image parameter missing!");
+ if (lua_isnil(image))
+ lua_error("cdBitmapSetRect: attempt to get a NIL image!");
+ if (lua_tag(image) != bitmap_tag)
+ lua_error("cdBitmapSetRect: invalid image parameter!");
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p->image)
+ lua_error("cdBitmapSetRect: attempt to get a killed image!");
+
+ xmin = lua_getparam(2);
+ xmax = lua_getparam(3);
+ ymin = lua_getparam(4);
+ ymax = lua_getparam(5);
+ if (!(lua_isnumber(xmin) && lua_isnumber(xmax) &&
+ lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("cdBitmapSetRect: invalid parameter!");
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+
+ if (lua_getparam(6) != LUA_NOOBJECT)
+ lua_error("cdBitmapSetRect: too many parameters!");
+
+ cdBitmapSetRect(image_p->image, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+static void cdlua_rgb2mapex(void)
+{
+ lua_Object imagemap;
+ lua_Object imagergb;
+
+ bitmap_t *imagemap_p;
+ bitmap_t *imagergb_p;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdBitmapRGB2Map: attempt to put a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdBitmapRGB2Map: invalid imagergb parameter!");
+ imagergb_p = (bitmap_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->image))
+ lua_error("cdBitmapRGB2Map: attempt to put a killed imagergb!");
+
+ imagemap = lua_getparam(2);
+ if (lua_isnil(imagemap))
+ lua_error("cdBitmapRGB2Map: attempt to put a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("cdBitmapRGB2Map: imagemap invalid parameter!");
+ imagemap_p = (bitmap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->image)
+ lua_error("cdBitmapRGB2Map: attempt to put a killed imagemap!");
+
+ if (imagergb_p->image->type != CD_RGB || imagemap_p->image->type <= 0)
+ lua_error("cdBitmapRGB2Map: invalid image type!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdBitmapRGB2Map: too many parameters!");
+
+ cdBitmapRGB2Map(imagergb_p->image, imagemap_p->image);
+}
+
+/***************************************************************************\
+* Creates a buffer for a RGB image. *
+\***************************************************************************/
+static void cdlua_createimagergb(void)
+{
+ lua_Object width, height;
+ long int width_i, height_i;
+ imagergb_t *imagergb_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateImageRGB: invalid imagergb parameter!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateImageRGB: image dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreateImageRGB: too many parameters!");
+
+ imagergb_p = (imagergb_t *) malloc(sizeof(imagergb_t));
+ if (!imagergb_p) {
+ lua_pushnil();
+ return;
+ }
+
+ imagergb_p->width = width_i;
+ imagergb_p->height = height_i;
+ imagergb_p->size = width_i*height_i;
+ imagergb_p->red = (unsigned char *) malloc(imagergb_p->size);
+ imagergb_p->green = (unsigned char *) malloc(imagergb_p->size);
+ imagergb_p->blue = (unsigned char *) malloc(imagergb_p->size);
+
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue)) {
+ if (imagergb_p->red) free(imagergb_p->red);
+ if (imagergb_p->green) free(imagergb_p->green);
+ if (imagergb_p->blue) free(imagergb_p->blue);
+ free(imagergb_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(imagergb_p->red, 255, imagergb_p->size);
+ memset(imagergb_p->green, 255, imagergb_p->size);
+ memset(imagergb_p->blue, 255, imagergb_p->size);
+
+ lua_pushusertag((void *) imagergb_p, imagergb_tag);
+}
+
+static void cdlua_imagergb(void)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+ cdCanvas *current_canvas;
+ int w, h, type = CD_RGB;
+
+ canvas = lua_getparam(1);
+
+ /* if the creation failed, canvas can be nil, in which case we */
+ /* issue an error */
+ if (lua_isnil(canvas))
+ lua_error("cdImageRGB: attempt to get a NIL canvas!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("cdImageRGB: invalid canvas parameter!");
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("cdImageRGB: attempt to get a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdImageRGB: too many parameters!");
+
+ if (cdAlphaImage(canvas_p->cd_canvas))
+ type = CD_RGBA;
+
+ current_canvas = cdActiveCanvas();
+ cdActivate(canvas_p->cd_canvas);
+ cdGetCanvasSize(&w, &h, NULL, NULL);
+ cdActivate(current_canvas);
+
+ if (type == CD_RGBA)
+ {
+ imagergba_t *imagergba_p = (imagergba_t *) malloc(sizeof(imagergba_t));
+ if (!imagergba_p) {
+ lua_pushnil();
+ return;
+ }
+
+ imagergba_p->width = w;
+ imagergba_p->height = h;
+ imagergba_p->size = w*h;
+ imagergba_p->red = cdRedImage(canvas_p->cd_canvas);
+ imagergba_p->green = cdGreenImage(canvas_p->cd_canvas);
+ imagergba_p->blue = cdBlueImage(canvas_p->cd_canvas);
+ imagergba_p->blue = cdAlphaImage(canvas_p->cd_canvas);
+
+ lua_pushusertag((void *) imagergba_p, imagergba_tag);
+ }
+ else
+ {
+ imagergb_t * imagergb_p = (imagergb_t *) malloc(sizeof(imagergb_t));
+ if (!imagergb_p) {
+ lua_pushnil();
+ return;
+ }
+
+ imagergb_p->width = w;
+ imagergb_p->height = h;
+ imagergb_p->size = w*h;
+ imagergb_p->red = cdRedImage(canvas_p->cd_canvas);
+ imagergb_p->green = cdGreenImage(canvas_p->cd_canvas);
+ imagergb_p->blue = cdBlueImage(canvas_p->cd_canvas);
+
+ lua_pushusertag((void *) imagergb_p, imagergb_tag);
+ }
+}
+
+static void cdlua_imagergbbitmap(void)
+{
+ lua_Object canvas;
+ canvas_t *canvas_p;
+ cdCanvas *current_canvas;
+ bitmap_t *image_p;
+ int w, h, type = CD_RGB;
+
+ canvas = lua_getparam(1);
+
+ /* if the creation failed, canvas can be nil, in which case we */
+ /* issue an error */
+ if (lua_isnil(canvas))
+ lua_error("cdImageRGBBitmap: attempt to get a NIL canvas!");
+
+ if (lua_tag(canvas) != canvas_tag)
+ lua_error("cdImageRGBBitmap: invalid canvas parameter!");
+ canvas_p = (canvas_t *) lua_getuserdata(canvas);
+ if (!canvas_p->cd_canvas)
+ lua_error("cdImageRGBBitmap: attempt to get a killed canvas!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdImageRGBBitmap: too many parameters!");
+
+ if (cdAlphaImage(canvas_p->cd_canvas))
+ type = CD_RGBA;
+
+ current_canvas = cdActiveCanvas();
+ cdActivate(canvas_p->cd_canvas);
+ cdGetCanvasSize(&w, &h, NULL, NULL);
+ cdActivate(current_canvas);
+
+ image_p = (bitmap_t *) malloc(sizeof(bitmap_t));
+ if (!image_p) {
+ lua_pushnil();
+ return;
+ }
+
+ image_p->image = cdInitBitmap(w, h, type,
+ cdRedImage(canvas_p->cd_canvas),
+ cdGreenImage(canvas_p->cd_canvas),
+ cdBlueImage(canvas_p->cd_canvas),
+ cdAlphaImage(canvas_p->cd_canvas));
+
+ lua_pushusertag((void *)image_p, bitmap_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated imagergb. We don't free imagergb_p to avoid *
+* problems if the user called killimagergb twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killimagergb(void)
+{
+ lua_Object imagergb;
+ imagergb_t *imagergb_p;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdKillImageRGB: attempt to kill a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdKillImageRGB: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("cdKillImageRGB: attempt to kill a killed imagergb!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillImageRGB: too many parameters!");
+
+ free(imagergb_p->red);
+ free(imagergb_p->green);
+ free(imagergb_p->blue);
+ imagergb_p->red = NULL;
+ imagergb_p->green = NULL;
+ imagergb_p->blue = NULL;
+}
+
+/***************************************************************************\
+* Creates a buffer for a RGBA image. *
+\***************************************************************************/
+static void cdlua_createimagergba(void)
+{
+ lua_Object width, height;
+ long int width_i, height_i;
+ imagergba_t *imagergba_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateImageRGBA: invalid imagergba parameter!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateImageRGBA: image dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreateImageRGBA: too many parameters!");
+
+ imagergba_p = (imagergba_t *) malloc(sizeof(imagergba_t));
+ if (!imagergba_p) {
+ lua_pushnil();
+ return;
+ }
+
+ imagergba_p->width = width_i;
+ imagergba_p->height = height_i;
+ imagergba_p->size = width_i*height_i;
+ imagergba_p->red = (unsigned char *) malloc(imagergba_p->size);
+ imagergba_p->green = (unsigned char *) malloc(imagergba_p->size);
+ imagergba_p->blue = (unsigned char *) malloc(imagergba_p->size);
+ imagergba_p->alpha = (unsigned char *) malloc(imagergba_p->size);
+
+ if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue && imagergba_p->alpha)) {
+ if (imagergba_p->red) free(imagergba_p->red);
+ if (imagergba_p->green) free(imagergba_p->green);
+ if (imagergba_p->blue) free(imagergba_p->blue);
+ if (imagergba_p->alpha) free(imagergba_p->alpha);
+ free(imagergba_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(imagergba_p->red, 255, imagergba_p->size);
+ memset(imagergba_p->green, 255, imagergba_p->size);
+ memset(imagergba_p->blue, 255, imagergba_p->size);
+ memset(imagergba_p->alpha, 255, imagergba_p->size);
+
+ lua_pushusertag((void *) imagergba_p, imagergba_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated imagergba. Don't free imagergba_p to avoid *
+* problems if the user called killimagergba twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killimagergba(void)
+{
+ lua_Object imagergba;
+ imagergba_t *imagergba_p;
+
+ imagergba = lua_getparam(1);
+ if (lua_isnil(imagergba))
+ lua_error("cdKillImageRGBA: attempt to kill a NIL imagergba!");
+ if (lua_tag(imagergba) != imagergba_tag)
+ lua_error("cdKillImageRGBA: invalid imagergba parameter!");
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue && imagergba_p->alpha))
+ lua_error("cdKillImageRGBA: attempt to kill a killed imagergba!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillImageRGBA: too many parameters!");
+
+ free(imagergba_p->red);
+ free(imagergba_p->green);
+ free(imagergba_p->blue);
+ free(imagergba_p->alpha);
+ imagergba_p->red = NULL;
+ imagergba_p->green = NULL;
+ imagergba_p->blue = NULL;
+ imagergba_p->alpha = NULL;
+}
+
+/***************************************************************************\
+* Creates a imagemap as a imagemap_tag usertag lua_Object. *
+\***************************************************************************/
+static void cdlua_createimagemap(void)
+{
+ lua_Object width;
+ lua_Object height;
+
+ long int width_i;
+ long int height_i;
+ imagemap_t *imagemap_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateImageMap: invalid imagemap parameter!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateImageMap: imagemap dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreateImageMap: too many parameters!");
+
+ imagemap_p = (imagemap_t *) malloc(sizeof(imagemap_t));
+ if (!imagemap_p) {
+ lua_pushnil();
+ return;
+ }
+
+ imagemap_p->size = width_i*height_i;
+ imagemap_p->width = width_i;
+ imagemap_p->height = height_i;
+ imagemap_p->index = (unsigned char *) malloc(imagemap_p->size);
+ if (!imagemap_p->index) {
+ free(imagemap_p);
+ lua_pushnil();
+ return;
+ }
+
+ memset(imagemap_p->index, 0, imagemap_p->size);
+ lua_pushusertag((void *) imagemap_p, imagemap_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated imagemap. We don't free imagemap_p to avoid *
+* problems if the user called killimagemap twice with the same object. The *
+* structure will be freed by a userdata "gc" fallback in LUA 3.0. *
+\***************************************************************************/
+static void cdlua_killimagemap(void)
+{
+ lua_Object imagemap;
+ imagemap_t *imagemap_p;
+
+ imagemap = lua_getparam(1);
+ if (lua_isnil(imagemap))
+ lua_error("cdKillImageMap: attempt to kill a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("cdKillImageMap: invalid imagemap parameter!");
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->index)
+ lua_error("cdKillImageMap: attempt to kill a killed imagemap!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillImageMap: too many parameters!");
+
+ free(imagemap_p->index);
+ imagemap_p->index = NULL;
+}
+
+/***************************************************************************\
+* Creates an image as a image_tag usertag lua_Object. *
+\***************************************************************************/
+static void cdlua_createimage(void)
+{
+ lua_Object width;
+ lua_Object height;
+
+ long int width_i;
+ long int height_i;
+ image_t *image_p;
+
+ width = lua_getparam(1);
+ height = lua_getparam(2);
+ if (!(lua_isnumber(width) && lua_isnumber(height)))
+ lua_error("cdCreateImage: invalid dimension parameters!");
+ width_i = (long int) lua_getnumber(width);
+ height_i = (long int) lua_getnumber(height);
+ if (width_i < 1 || height_i < 1)
+ lua_error("cdCreateImage: imagemap dimensions should be positive integers!");
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdCreateImage: too many parameters!");
+
+ image_p = (image_t *) malloc(sizeof(image_t));
+ if (!image_p) {
+ lua_pushnil();
+ return;
+ }
+
+ image_p->cd_image = cdCreateImage(width_i, height_i);
+ if (!image_p->cd_image) {
+ free(image_p);
+ lua_pushnil();
+ }
+ else
+ lua_pushusertag((void *) image_p, image_tag);
+}
+
+/***************************************************************************\
+* Frees a previously allocated image. *
+\***************************************************************************/
+static void cdlua_killimage(void)
+{
+ lua_Object image;
+ image_t *image_p;
+
+ image = lua_getparam(1);
+ if (lua_isnil(image))
+ lua_error("cdKillImage: attempt to kill a NIL image!");
+ if (lua_tag(image) != image_tag)
+ lua_error("cdKillImage: invalid image parameter!");
+ image_p = (image_t *) lua_getuserdata(image);
+ if (!image_p->cd_image)
+ lua_error("cdKillImage: attempt to kill a killed image");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdKillImage: too many parameters!");
+
+ cdKillImage(image_p->cd_image);
+ image_p->cd_image = NULL;
+}
+
+/***************************************************************************\
+* Fallback definitions. *
+\***************************************************************************/
+/***************************************************************************\
+* stipple "settable" fallback. *
+\***************************************************************************/
+static void stipplesettable_fb(void)
+{
+ lua_Object stipple, index, value;
+
+ stipple_t *stipple_p;
+ long int index_i;
+ unsigned char value_i;
+
+ stipple = lua_getparam(1);
+ index = lua_getparam(2);
+ value = lua_getparam(3);
+
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p) {
+ lua_error("stipple_tag \"settable\": invalid stipple_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("stipple_tag \"settable\": index should be a number!");
+ }
+
+ if (!lua_isnumber(value)) {
+ lua_error("stipple_tag \"settable\": value should be a number!");
+ }
+
+ value_i = (unsigned char) lua_getnumber(value);
+ if ((value_i != 0 && value_i != 1))
+ lua_error("stipple_tag \"settable\": value should belong to {0, 1}!");
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= stipple_p->size)
+ lua_error("stipple_tag \"settable\": index is out of bounds!");
+
+ stipple_p->value[index_i] = value_i;
+}
+
+/***************************************************************************\
+* imagemap "settable" fallback. *
+\***************************************************************************/
+static void imagemapsettable_fb(void)
+{
+ lua_Object imagemap, index, value;
+
+ imagemap_t *imagemap_p;
+ long int index_i;
+ long int value_i;
+
+ imagemap = lua_getparam(1);
+ index = lua_getparam(2);
+ value = lua_getparam(3);
+
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p) {
+ lua_error("imagemap_tag \"settable\": invalid imagemap_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("imagemap_tag \"settable\": index should be a number!");
+ }
+
+ if (!lua_isnumber(value)) {
+ lua_error("imagemap_tag \"settable\": value should be a number!");
+ }
+
+ value_i = (long int) lua_getnumber(value);
+ if ((value_i < 0 || value_i > 255))
+ lua_error("imagemap_tag \"settable\": value should be in range [0, 255]!");
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= imagemap_p->size)
+ lua_error("imagemap_tag \"settable\": index is out of bounds!");
+
+ imagemap_p->index[index_i] = (unsigned char) value_i;
+}
+
+/***************************************************************************\
+* pattern "settable" fallback. *
+\***************************************************************************/
+static void patternsettable_fb(void)
+{
+ lua_Object pattern, index, color;
+
+ pattern_t *pattern_p;
+ long int index_i;
+ long int color_i;
+
+ pattern = lua_getparam(1);
+ index = lua_getparam(2);
+ color = lua_getparam(3);
+
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p) {
+ lua_error("pattern_tag \"settable\": invalid pattern_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("pattern_tag \"settable\": index should be a number!");
+ }
+
+ if (lua_tag(color) != color_tag)
+ lua_error("pattern_tag \"settable\": value should be of type color_tag!");
+
+ color_i = (long int) lua_getuserdata(color);
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= pattern_p->size)
+ lua_error("pattern_tag \"settable\": index is out of bounds!");
+
+ pattern_p->color[index_i] = color_i;
+}
+
+/***************************************************************************\
+* palette "settable" fallback. *
+\***************************************************************************/
+static void palettesettable_fb(void)
+{
+ lua_Object palette, index, color;
+
+ palette_t *palette_p;
+ long int index_i;
+ long int color_i;
+
+ palette = lua_getparam(1);
+ index = lua_getparam(2);
+ color = lua_getparam(3);
+
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p) {
+ lua_error("palette_tag \"settable\": invalid palette_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("palette_tag \"settable\": index should be a number!");
+ }
+
+ if (lua_tag(color) != color_tag)
+ lua_error("palette_tag \"settable\": value should be of type color_tag!");
+
+ color_i = (long int) lua_getuserdata(color);
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= palette_p->size)
+ lua_error("palette_tag \"settable\": index is out of bounds!");
+
+ palette_p->color[index_i] = color_i;
+}
+
+/***************************************************************************\
+* channel "settable" fallback. This fallback is called when a LUA line like *
+* "imagergb.r[y*w + x] = c" is executed. The imagergb "gettable" fallback *
+* fills and returns a channel structure with info about the buffer. This *
+* structure is consulted and the value is assigned where it should. *
+\***************************************************************************/
+static void channelsettable_fb(void)
+{
+ lua_Object channel, index, value;
+
+ channel_t *channel_p;
+ long int index_i;
+ long int value_i;
+
+ channel = lua_getparam(1);
+ index = lua_getparam(2);
+ value = lua_getparam(3);
+
+ channel_p = (channel_t *) lua_getuserdata(channel);
+ if (!channel_p) {
+ lua_error("channel_tag \"settable\": invalid channel_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("channel_tag \"settable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || (channel_p->size > 0 && index_i >= channel_p->size) ||
+ (channel_p->size == -1 && index_i >= 256)) {
+ lua_error("channel_tag \"settable\": index is out of bounds!");
+ }
+
+ if (channel_p->size > 0)
+ {
+ if (!lua_isnumber(value)) {
+ lua_error("channel_tag \"settable\": value should be a number!");
+ }
+
+ value_i = (long int) lua_getnumber(value);
+ if ((value_i < 0 || value_i > 255)) {
+ lua_error("channel_tag \"settable\": value should be in range [0, 255]!");
+ }
+
+ channel_p->value[index_i] = (unsigned char) value_i;
+ }
+ else
+ {
+ if (lua_tag(value) != color_tag)
+ lua_error("channel_tag \"settable\": value should be of type color_tag!");
+
+ value_i = (long int) lua_getuserdata(value);
+
+ ((long int*)channel_p->value)[index_i] = value_i;
+ }
+}
+
+/***************************************************************************\
+* stipple "gettable" fallback. *
+\***************************************************************************/
+static void stipplegettable_fb(void)
+{
+ lua_Object stipple, index;
+
+ stipple_t *stipple_p;
+ long int index_i;
+
+ stipple = lua_getparam(1);
+ index = lua_getparam(2);
+
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p)
+ lua_error("stipple_tag \"gettable\": invalid stipple_tag object!");
+
+ if (!lua_isnumber(index)) {
+ lua_error("stipple_tag \"gettable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= stipple_p->size)
+ lua_error("stipple_tag \"gettable\": index is out of bounds!");
+
+ lua_pushnumber(stipple_p->value[index_i]);
+}
+
+/***************************************************************************\
+* imagemap "gettable" fallback. *
+\***************************************************************************/
+static void imagemapgettable_fb(void)
+{
+ lua_Object imagemap, index;
+
+ imagemap_t *imagemap_p;
+ long int index_i;
+
+ imagemap = lua_getparam(1);
+ index = lua_getparam(2);
+
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p)
+ lua_error("imagemap_tag \"gettable\": invalid imagemap_tag object!");
+
+ if (!lua_isnumber(index)) {
+ lua_error("imagemap_tag \"gettable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= imagemap_p->size)
+ lua_error("imagemap_tag \"gettable\": index is out of bounds!");
+
+ lua_pushnumber(imagemap_p->index[index_i]);
+}
+
+/***************************************************************************\
+* pattern "gettable" fallback. *
+\***************************************************************************/
+static void patterngettable_fb(void)
+{
+ lua_Object pattern, index;
+
+ pattern_t *pattern_p;
+ long int index_i;
+
+ pattern = lua_getparam(1);
+ index = lua_getparam(2);
+
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p)
+ lua_error("pattern_tag \"gettable\": invalid pattern_tag object!");
+
+ if (!lua_isnumber(index)) {
+ lua_error("pattern_tag \"gettable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= pattern_p->size)
+ lua_error("pattern_tag \"gettable\": index is out of bounds!");
+
+ lua_pushusertag((void *) pattern_p->color[index_i], color_tag);
+}
+
+/***************************************************************************\
+* palette "gettable" fallback. *
+\***************************************************************************/
+static void palettegettable_fb(void)
+{
+ lua_Object palette, index;
+
+ palette_t *palette_p;
+ long int index_i;
+
+ palette = lua_getparam(1);
+ index = lua_getparam(2);
+
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p)
+ lua_error("palette_tag \"gettable\": invalid palette_tag object!");
+
+ if (!lua_isnumber(index)) {
+ lua_error("palette_tag \"gettable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+ if (index_i < 0 || index_i >= palette_p->size)
+ lua_error("palette_tag \"gettable\": index is out of bounds!");
+
+ lua_pushusertag((void *) palette_p->color[index_i], color_tag);
+}
+
+/***************************************************************************\
+* channel "gettable" fallback. This fallback is called when a LUA line like *
+* "c = imagergb.r[y*w + x]" is executed. The imagergb "gettable" fallback *
+* fills and returns a channel structure with info about the buffer. This *
+* structure is consulted and the appropriate value is returned. *
+\***************************************************************************/
+static void channelgettable_fb(void)
+{
+ lua_Object channel, index;
+
+ channel_t *channel_p;
+ long int index_i;
+
+ channel = lua_getparam(1);
+ index = lua_getparam(2);
+
+ channel_p = (channel_t *) lua_getuserdata(channel);
+ if (!channel_p) {
+ lua_error("channel_tag \"gettable\": invalid channel_tag object!");
+ }
+
+ if (!lua_isnumber(index)) {
+ lua_error("channel_tag \"gettable\": index should be a number!");
+ }
+
+ index_i = (long int) lua_getnumber(index);
+
+ if (index_i < 0 || (channel_p->size > 0 && index_i >= channel_p->size) ||
+ (channel_p->size == -1 && index_i >= 256)) {
+ lua_error("channel_tag \"gettable\": index is out of bounds!");
+ }
+
+ if (channel_p->size == -1)
+ lua_pushusertag((void *) ((long int*)channel_p->value)[index_i], color_tag);
+ else
+ lua_pushnumber(channel_p->value[index_i]);
+}
+
+/***************************************************************************\
+* imagergb "gettable" fallback. This fallback is called when a LUA line *
+* like "c = imagergb.r[y*w + x]" or "imagergb.r[y*w + x] = c" is executed. *
+* The channel_info global is filled and its address is returned with a *
+* channel_tag usertag lua_Object. The following "gettable" or "settable" *
+* then assigns or returns the appropriate value. *
+\***************************************************************************/
+static void imagergbgettable_fb(void)
+{
+ lua_Object imagergb, index;
+
+ char *index_s;
+ imagergb_t *imagergb_p;
+
+ imagergb = lua_getparam(1);
+ index = lua_getparam(2);
+
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!imagergb_p)
+ lua_error("imagergb_tag \"gettable\": invalid imagergb_tag object!");
+
+ if (!lua_isstring(index)) {
+ lua_error("imagergb_tag \"gettable\": index should be a channel name!");
+ }
+ index_s = (char *) lua_getstring(index);
+
+ channel_info.size = imagergb_p->size;
+
+ if (*index_s == 'r' || *index_s == 'R') {
+ channel_info.value = imagergb_p->red;
+ }
+ else if (*index_s == 'g' || *index_s == 'G') {
+ channel_info.value = imagergb_p->green;
+ }
+ else if (*index_s == 'b' || *index_s == 'B') {
+ channel_info.value = imagergb_p->blue;
+ }
+ else {
+ lua_error("imagergb_tag \"gettable\": index is an invalid channel name!");
+ }
+
+ lua_pushusertag((void *) &channel_info, channel_tag);
+}
+
+/***************************************************************************\
+* imagergba "gettable" fallback. This fallback is called when a LUA line *
+* like "c = imagergba.r[y*w + x]" or "imagergba.r[y*w + x] = c" is executed.*
+* The channel_info global is filled and its address is returned with a *
+* channel_tag usertag lua_Object. The following "gettable" or "settable" *
+* then assigns or returns the appropriate value. *
+\***************************************************************************/
+static void imagergbagettable_fb(void)
+{
+ lua_Object imagergba, index;
+
+ char *index_s;
+ imagergba_t *imagergba_p;
+
+ imagergba = lua_getparam(1);
+ index = lua_getparam(2);
+
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!imagergba_p)
+ lua_error("imagergba_tag \"gettable\": invalid imagergba_tag object!");
+
+ if (!lua_isstring(index)) {
+ lua_error("imagergba_tag \"gettable\": index should be a channel name!");
+ }
+ index_s = (char *) lua_getstring(index);
+
+ channel_info.size = imagergba_p->size;
+
+ if (*index_s == 'r' || *index_s == 'R') {
+ channel_info.value = imagergba_p->red;
+ }
+ else if (*index_s == 'g' || *index_s == 'G') {
+ channel_info.value = imagergba_p->green;
+ }
+ else if (*index_s == 'b' || *index_s == 'B') {
+ channel_info.value = imagergba_p->blue;
+ }
+ else if (*index_s == 'a' || *index_s == 'A') {
+ channel_info.value = imagergba_p->alpha;
+ }
+ else {
+ lua_error("imagergba_tag \"gettable\": index is an invalid channel name!");
+ }
+
+ lua_pushusertag((void *) &channel_info, channel_tag);
+}
+
+/***************************************************************************\
+* bitmap "gettable" fallback. This fallback is called when a LUA line *
+* like "c = bitmap.r[y*w + x]" or "bitmap.r[y*w + x] = c" is executed.*
+* The channel_info global is filled and its address is returned with a *
+* channel_tag usertag lua_Object. The following "gettable" or "settable" *
+* then assigns or returns the appropriate value. *
+\***************************************************************************/
+static void bitmapgettable_fb(void)
+{
+ lua_Object image, index;
+
+ char *index_s;
+ bitmap_t *image_p;
+
+ image = lua_getparam(1);
+ index = lua_getparam(2);
+
+ image_p = (bitmap_t *) lua_getuserdata(image);
+ if (!image_p)
+ lua_error("bitmap_tag \"gettable\": invalid bitmap_tag object!");
+
+ if (!lua_isstring(index)) {
+ lua_error("bitmap_tag \"gettable\": index should be a channel name!");
+ }
+ index_s = (char *) lua_getstring(index);
+
+ channel_info.size = image_p->image->w * image_p->image->h;
+
+ if (*index_s == 'r' || *index_s == 'R') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_IRED);
+ }
+ else if (*index_s == 'g' || *index_s == 'G') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_IGREEN);
+ }
+ else if (*index_s == 'b' || *index_s == 'B') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_IBLUE);
+ }
+ else if (*index_s == 'a' || *index_s == 'A') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_IALPHA);
+ }
+ else if (*index_s == 'i' || *index_s == 'I') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_INDEX);
+ }
+ else if (*index_s == 'c' || *index_s == 'C') {
+ channel_info.value = cdBitmapGetData(image_p->image, CD_COLORS);
+ channel_info.size = -1;
+ }
+ else {
+ lua_error("imagergba_tag \"gettable\": index is an invalid channel name!");
+ }
+
+ lua_pushusertag((void *) &channel_info, channel_tag);
+}
+
+static void stategc_fb(void)
+{
+ lua_Object state;
+
+ state_t *state_p;
+
+ state = lua_getparam(1);
+ state_p = (state_t *) lua_getuserdata(state);
+ if (!state_p)
+ lua_error("state_tag \"gc\": invalid state_tag object!");
+
+ if (state_p->state) cdReleaseState(state_p->state);
+
+ /* free the state_t structure */
+ free(state_p);
+}
+
+/***************************************************************************\
+* stipple "gc" fallback. *
+\***************************************************************************/
+static void stipplegc_fb(void)
+{
+ lua_Object stipple;
+
+ stipple_t *stipple_p;
+
+ stipple = lua_getparam(1);
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p)
+ lua_error("stipple_tag \"gc\": invalid stipple_tag object!");
+
+ /* if the stipple has not been killed, kill it */
+ if (stipple_p->value) free(stipple_p->value);
+
+ /* free the stipple_t structure */
+ free(stipple_p);
+}
+
+/***************************************************************************\
+* pattern "gc" fallback. *
+\***************************************************************************/
+static void patterngc_fb(void)
+{
+ lua_Object pattern;
+
+ pattern_t *pattern_p;
+
+ pattern = lua_getparam(1);
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p)
+ lua_error("pattern_tag \"gc\": invalid pattern_tag object!");
+
+ /* if the pattern has not been killed, kill it */
+ if (pattern_p->color) free(pattern_p->color);
+
+ /* free the pattern_t structure */
+ free(pattern_p);
+}
+
+/***************************************************************************\
+* palette "gc" fallback. *
+\***************************************************************************/
+static void palettegc_fb(void)
+{
+ lua_Object palette;
+
+ palette_t *palette_p;
+
+ palette = lua_getparam(1);
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p)
+ lua_error("palette_tag \"gc\": invalid palette_tag object!");
+
+ /* if the palette has not been killed, kill it */
+ if (palette_p->color) free(palette_p->color);
+
+ /* free the palette_t structure */
+ free(palette_p);
+}
+
+/***************************************************************************\
+* imagergb "gc" fallback. *
+\***************************************************************************/
+static void imagergbgc_fb(void)
+{
+ lua_Object imagergb;
+
+ imagergb_t *imagergb_p;
+
+ imagergb = lua_getparam(1);
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!imagergb_p)
+ lua_error("imagergb_tag \"gc\": invalid imagergb_tag object!");
+
+ /* if the imagergb has not been killed, kill it */
+ if (imagergb_p->red) free(imagergb_p->red);
+ if (imagergb_p->green) free(imagergb_p->green);
+ if (imagergb_p->blue) free(imagergb_p->blue);
+
+ /* free the imagergb_t structure */
+ free(imagergb_p);
+}
+
+/***************************************************************************\
+* imagergba "gc" fallback. *
+\***************************************************************************/
+static void imagergbagc_fb(void)
+{
+ lua_Object imagergba;
+
+ imagergba_t *imagergba_p;
+
+ imagergba = lua_getparam(1);
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!imagergba_p)
+ lua_error("imagergba_tag \"gc\": invalid imagergba_tag object!");
+
+ /* if the imagergba has not been killed, kill it */
+ if (imagergba_p->red) free(imagergba_p->red);
+ if (imagergba_p->green) free(imagergba_p->green);
+ if (imagergba_p->blue) free(imagergba_p->blue);
+ if (imagergba_p->alpha) free(imagergba_p->alpha);
+
+ /* free the imagergba_t structure */
+ free(imagergba_p);
+}
+
+/***************************************************************************\
+* imagemap "gc" fallback. *
+\***************************************************************************/
+static void imagemapgc_fb(void)
+{
+ lua_Object imagemap;
+
+ imagemap_t *imagemap_p;
+
+ imagemap = lua_getparam(1);
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p)
+ lua_error("imagemap_tag \"gc\": invalid imagemap_tag object!");
+
+ /* if the imagemap has not been killed, kill it */
+ if (imagemap_p->index) free(imagemap_p->index);
+
+ /* free the imagemap_t structure */
+ free(imagemap_p);
+}
+
+/***************************************************************************\
+* bitmap "gc" fallback. *
+\***************************************************************************/
+static void bitmapgc_fb(void)
+{
+ lua_Object bitmap;
+
+ bitmap_t *bitmap_p;
+
+ bitmap = lua_getparam(1);
+ bitmap_p = (bitmap_t *) lua_getuserdata(bitmap);
+ if (!bitmap_p)
+ lua_error("bitmap_tag \"gc\": invalid bitmap_tag object!");
+
+ /* if the bitmap has not been killed, kill it */
+ if (bitmap_p->image) cdKillBitmap(bitmap_p->image);
+
+ /* free the bitmap_t structure */
+ free(bitmap_p);
+}
+
+/***************************************************************************\
+* cdPixel. *
+\***************************************************************************/
+static void cdlua_pixel (void)
+{
+ lua_Object x;
+ lua_Object y;
+ lua_Object color;
+
+ int x_i;
+ int y_i;
+ long int color_i;
+
+ x = lua_getparam(1);
+ y = lua_getparam(2);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("cdPixel: pixel coordinates should be integers!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+
+ color = lua_getparam(3);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdPixel: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdPixel: too many parameters!");
+
+ cdPixel(x_i, y_i, color_i);
+}
+
+static void wdlua_pixel (void)
+{
+ lua_Object x;
+ lua_Object y;
+ lua_Object color;
+
+ double x_i;
+ double y_i;
+ long int color_i;
+
+ x = lua_getparam(1);
+ y = lua_getparam(2);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("wdPixel: pixel coordinates should be numbers!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+
+ color = lua_getparam(3);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdPixel: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdPixel: too many parameters!");
+
+ wdPixel(x_i, y_i, color_i);
+}
+
+/***************************************************************************\
+* cdGetCanvasSize. *
+\***************************************************************************/
+static void cdlua_getcanvassize(void)
+{
+ int width;
+ int height;
+ double mm_width;
+ double mm_height;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdGetCanvasSize: too many parameters!");
+
+ cdGetCanvasSize(&width, &height, &mm_width, &mm_height);
+ lua_pushnumber(width);
+ lua_pushnumber(height);
+ lua_pushnumber(mm_width);
+ lua_pushnumber(mm_height);
+}
+
+/***************************************************************************\
+* Register callback functions. *
+\***************************************************************************/
+static void cdlua_registercallback(void)
+{
+ lua_Object driver, cb, func;
+ int driver_i, cb_i, func_lock;
+ cdContextLUA* luactx;
+ cdCallbackLUA* cdCB;
+
+ driver = lua_getparam(1);
+ if (!lua_isnumber(driver))
+ lua_error("cdRegisterCallback: invalid driver parameter!");
+ driver_i = (int) lua_getnumber(driver);
+
+ cb = lua_getparam(2);
+ if (!lua_isnumber(cb))
+ lua_error("cdRegisterCallback: invalid cb parameter!");
+ cb_i = (int) lua_getnumber(cb);
+
+ func = lua_getparam(3);
+ if (lua_isnil(func))
+ func_lock = -1;
+ else if (!lua_isfunction(func))
+ {
+ lua_error("cdRegisterCallback: invalid func parameter!");
+ return;
+ }
+ else {
+ lua_pushobject(func);
+ func_lock = lua_ref(1);
+ }
+
+ if (driver_i >= cdlua_numdrivers)
+ lua_error("cdRegisterCallback: invalid driver parameter!");
+
+ luactx = cdlua_drivers[driver_i];
+
+ if (cb_i >= luactx->cb_n)
+ lua_error("cdRegisterCallback: invalid cb parameter!");
+
+ cdCB = &luactx->cb_list[cb_i];
+
+ if (cdCB->lock != -1) {
+ lua_unref(cdCB->lock);
+ cdCB->lock = func_lock;
+ if (func_lock == -1) {
+ cdRegisterCallback(luactx->ctx(), cb_i, NULL);
+ }
+ }
+ else {
+ if (func_lock != -1) {
+ cdRegisterCallback(luactx->ctx(), cb_i, (cdCallback)cdCB->func);
+ cdCB->lock = func_lock;
+ }
+ }
+}
+
+/***************************************************************************\
+* cdPlay. *
+\***************************************************************************/
+static void cdlua_play(void)
+{
+ lua_Object driver;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+ lua_Object data;
+
+ int driver_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+ char *data_s;
+
+ driver = lua_getparam(1);
+ if (!lua_isnumber(driver))
+ lua_error("cdPlay: invalid driver parameter!");
+ driver_i = (long int) lua_getnumber(driver);
+
+ xmin = lua_getparam(2);
+ xmax = lua_getparam(3);
+ ymin = lua_getparam(4);
+ ymax = lua_getparam(5);
+ if (!(lua_isnumber(xmin) && lua_isnumber(xmax) &&
+ lua_isnumber(ymin) && lua_isnumber(ymin)))
+ lua_error("cdPlay: invalid viewport!");
+ xmin_i = (long int) lua_getnumber(xmin);
+ xmax_i = (long int) lua_getnumber(xmax);
+ ymin_i = (long int) lua_getnumber(ymin);
+ ymax_i = (long int) lua_getnumber(ymax);
+
+ data = lua_getparam(6);
+ if (!lua_isstring(data))
+ lua_error("cdPlay: data should be of type string!");
+ data_s = lua_getstring(data);
+
+ if (driver_i >= cdlua_numdrivers)
+ lua_error("cdPlay: unknown driver!");
+
+ if (lua_getparam(7) != LUA_NOOBJECT)
+ lua_error("cdPlay: too many parameters!");
+
+ cdPlay(cdlua_drivers[driver_i]->ctx(), xmin_i, xmax_i, ymin_i, ymax_i, data_s);
+}
+
+/***************************************************************************\
+* cdUpdateYAxis. *
+\***************************************************************************/
+
+static void cdlua_updateyaxis(void)
+{
+ lua_Object y;
+
+ int y_i;
+
+ y = lua_getparam(1);
+ if (!lua_isnumber(y))
+ lua_error("cdUpdateYAxis: invalid (y) parameter!");
+ y_i = (int) lua_getnumber(y);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdUpdateYAxis: too many parameters!");
+
+ cdUpdateYAxis(&y_i);
+ lua_pushnumber(y_i);
+}
+
+/***************************************************************************\
+* cdGetClipArea. *
+\***************************************************************************/
+static void cdlua_getcliparea(void)
+{
+ int xmin;
+ int xmax;
+ int ymin;
+ int ymax;
+ int status;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdGetClipArea: too many parameters!");
+
+ status = cdGetClipArea(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+ lua_pushnumber(status);
+}
+
+static void cdlua_RegionBox(void)
+{
+ int xmin;
+ int xmax;
+ int ymin;
+ int ymax;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdRegionBox: too many parameters!");
+
+ cdRegionBox(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+static void cdlua_getclippoly(void)
+{
+ int n, i;
+ int *pts;
+ lua_Object points;
+
+ pts = cdGetClipPoly(&n);
+ lua_pushnumber(n);
+
+ points = lua_createtable();
+
+ for (i=0; i < 2*n; i++)
+ {
+ lua_pushobject(points);
+ lua_pushnumber(i+1);
+ lua_pushnumber(pts[i]);
+ lua_settable();
+ }
+}
+
+static void wdlua_getclippoly(void)
+{
+ int n, i;
+ double *pts;
+ lua_Object points;
+
+ pts = wdGetClipPoly(&n);
+ lua_pushnumber(n);
+
+ points = lua_createtable();
+
+ for (i=0; i < 2*n; i++)
+ {
+ lua_pushobject(points);
+ lua_pushnumber(i+1);
+ lua_pushnumber(pts[i]);
+ lua_settable();
+ }
+}
+
+/***************************************************************************\
+* cdMM2Pixel. *
+\***************************************************************************/
+static void cdlua_mm2pixel(void)
+{
+ lua_Object mm_dx;
+ lua_Object mm_dy;
+
+ double mm_dx_d;
+ double mm_dy_d;
+ int dx;
+ int dy;
+
+ mm_dx = lua_getparam(1);
+ mm_dy = lua_getparam(2);
+ if (!(lua_isnumber(mm_dx) && lua_isnumber(mm_dy)))
+ lua_error("cdMM2Pixel: invalid (mm_dx, mm_dy) parameter!");
+ mm_dx_d = (double) lua_getnumber(mm_dx);
+ mm_dy_d = (double) lua_getnumber(mm_dy);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdMM2Pixel: too many parameters!");
+
+ cdMM2Pixel(mm_dx, mm_dy, &dx, &dy);
+ lua_pushnumber(dx);
+ lua_pushnumber(dy);
+}
+
+/***************************************************************************\
+* cdPixel2MM. *
+\***************************************************************************/
+static void cdlua_pixel2mm(void)
+{
+ lua_Object dx;
+ lua_Object dy;
+ int dx_i;
+ int dy_i;
+
+ double mm_dx;
+ double mm_dy;
+
+ dx = lua_getparam(1);
+ dy = lua_getparam(2);
+ if (!(lua_isnumber(dx) && lua_isnumber(dy)))
+ lua_error("cdPixel2MM: invalid (dx, dy) parameter!");
+ dx_i = (int) lua_getnumber(dx);
+ dy_i = (int) lua_getnumber(dy);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdPixel2MM: too many parameters!");
+
+ cdPixel2MM(dx_i, dy_i, &mm_dx, &mm_dy);
+ lua_pushnumber(mm_dx);
+ lua_pushnumber(mm_dy);
+}
+
+/***************************************************************************\
+* cdStipple. *
+\***************************************************************************/
+static void cdlua_stipple(void)
+{
+ lua_Object stipple;
+ stipple_t *stipple_p;
+
+ stipple = lua_getparam(1);
+ if (lua_isnil(stipple))
+ lua_error("cdStipple: attempt to set a NIL stipple!");
+ if (lua_tag(stipple) != stipple_tag)
+ lua_error("cdStipple: invalid stipple parameter!");
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p->value)
+ lua_error("cdStipple: attempt to set a killed stipple!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdStipple: too many parameters!");
+
+ cdStipple(stipple_p->width, stipple_p->height, stipple_p->value);
+}
+
+static void wdlua_stipple(void)
+{
+ lua_Object stipple;
+ stipple_t *stipple_p;
+ double w_mm;
+ double h_mm;
+
+ stipple = lua_getparam(1);
+ if (lua_isnil(stipple))
+ lua_error("wdStipple: attempt to set a NIL stipple!");
+ if (lua_tag(stipple) != stipple_tag)
+ lua_error("wdStipple: invalid stipple parameter!");
+ stipple_p = (stipple_t *) lua_getuserdata(stipple);
+ if (!stipple_p->value)
+ lua_error("wdStipple: attempt to set a killed stipple!");
+
+ w_mm = (double)luaL_check_number(2);
+ h_mm = (double)luaL_check_number(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdStipple: too many parameters!");
+
+ wdStipple(stipple_p->width, stipple_p->height, stipple_p->value, w_mm, h_mm);
+}
+
+/***************************************************************************\
+* cdPattern. *
+\***************************************************************************/
+static void cdlua_pattern(void)
+{
+ lua_Object pattern;
+ pattern_t *pattern_p;
+
+ pattern = lua_getparam(1);
+ if (lua_isnil(pattern))
+ lua_error("cdPattern: attempt to set a NIL pattern!");
+ if (lua_tag(pattern) != pattern_tag)
+ lua_error("cdPattern: invalid pattern parameter!");
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p->color)
+ lua_error("cdPattern: attempt to set a killed pattern!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdPattern: too many parameters!");
+
+ cdPattern(pattern_p->width, pattern_p->height, pattern_p->color);
+}
+
+static void wdlua_pattern(void)
+{
+ lua_Object pattern;
+ pattern_t *pattern_p;
+ double w_mm;
+ double h_mm;
+
+ pattern = lua_getparam(1);
+ if (lua_isnil(pattern))
+ lua_error("wdPattern: attempt to set a NIL pattern!");
+ if (lua_tag(pattern) != pattern_tag)
+ lua_error("wdPattern: invalid pattern parameter!");
+ pattern_p = (pattern_t *) lua_getuserdata(pattern);
+ if (!pattern_p->color)
+ lua_error("wdPattern: attempt to set a killed pattern!");
+
+ w_mm = (double)luaL_check_number(2);
+ h_mm = (double)luaL_check_number(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdPattern: too many parameters!");
+
+ wdPattern(pattern_p->width, pattern_p->height, pattern_p->color, w_mm, h_mm);
+}
+
+/***************************************************************************\
+* cdFontDim. *
+\***************************************************************************/
+static void cdlua_fontdim(void)
+{
+ int max_width;
+ int height;
+ int ascent;
+ int descent;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdFontDim: too many parameters!");
+
+ cdFontDim(&max_width, &height, &ascent, &descent);
+ lua_pushnumber(max_width);
+ lua_pushnumber(height);
+ lua_pushnumber(ascent);
+ lua_pushnumber(descent);
+}
+
+/***************************************************************************\
+* cdTextSize. *
+\***************************************************************************/
+static void cdlua_textsize(void)
+{
+ lua_Object text;
+ char* text_s;
+
+ int width;
+ int height;
+
+ text = lua_getparam(1);
+ if (!lua_isstring(text))
+ lua_error("cdTextSize: text should be of type string!");
+ text_s = (char*) lua_getstring(text);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdTextSize: too many parameters!");
+
+ cdTextSize(text_s, &width, &height);
+ lua_pushnumber(width);
+ lua_pushnumber(height);
+}
+
+static void cdlua_textbox(void)
+{
+ int xmin;
+ int xmax;
+ int ymin;
+ int ymax;
+ int x = (int)luaL_check_number(1);
+ int y = (int)luaL_check_number(2);
+ char* s = (char*)luaL_check_string(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdTextBox: too many parameters!");
+
+ cdTextBox(x, y, s, &xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+static void wdlua_textbox(void)
+{
+ double xmin;
+ double xmax;
+ double ymin;
+ double ymax;
+ double x = (double)luaL_check_number(1);
+ double y = (double)luaL_check_number(2);
+ char* s = (char*)luaL_check_string(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdTextBox: too many parameters!");
+
+ wdTextBox(x, y, s, &xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+static void cdlua_textbounds(void)
+{
+ int rect[8];
+ int x = (int)luaL_check_number(1);
+ int y = (int)luaL_check_number(2);
+ char* s = (char*)luaL_check_string(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdTextBox: too many parameters!");
+
+ cdTextBounds(x, y, s, rect);
+ lua_pushnumber(rect[0]);
+ lua_pushnumber(rect[1]);
+ lua_pushnumber(rect[2]);
+ lua_pushnumber(rect[3]);
+ lua_pushnumber(rect[4]);
+ lua_pushnumber(rect[5]);
+ lua_pushnumber(rect[6]);
+ lua_pushnumber(rect[7]);
+}
+
+static void wdlua_textbounds(void)
+{
+ double rect[8];
+ double x = (double)luaL_check_number(1);
+ double y = (double)luaL_check_number(2);
+ char* s = (char*)luaL_check_string(3);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdTextBox: too many parameters!");
+
+ wdTextBounds(x, y, s, rect);
+ lua_pushnumber(rect[0]);
+ lua_pushnumber(rect[1]);
+ lua_pushnumber(rect[2]);
+ lua_pushnumber(rect[3]);
+ lua_pushnumber(rect[4]);
+ lua_pushnumber(rect[5]);
+ lua_pushnumber(rect[6]);
+ lua_pushnumber(rect[7]);
+}
+
+static void cdlua_getfont(void)
+{
+ int type_face, style, size;
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdGetFont: too many parameters!");
+
+ cdGetFont(&type_face, &style, &size);
+ lua_pushnumber(type_face);
+ lua_pushnumber(style);
+ lua_pushnumber(size);
+}
+
+static void wdlua_getfont(void)
+{
+ int type_face, style;
+ double size;
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("wdGetFont: too many parameters!");
+
+ wdGetFont(&type_face, &style, &size);
+ lua_pushnumber(type_face);
+ lua_pushnumber(style);
+ lua_pushnumber(size);
+}
+
+/***************************************************************************\
+* cdPalette. *
+\***************************************************************************/
+static void cdlua_palette(void)
+{
+ lua_Object palette;
+ lua_Object mode;
+ palette_t *palette_p;
+ int mode_i;
+
+ palette = lua_getparam(1);
+ if (lua_isnil(palette))
+ lua_error("cdPalette: attempt to set a NIL palette!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("cdPalette: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("cdPalette: attempt to set a killed palette!");
+
+ mode = lua_getparam(2);
+ if (!lua_isnumber(mode))
+ lua_error("cdPalette: invalid mode parameter!");
+ mode_i = (int) lua_getnumber(mode);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("cdPalette: too many parameters!");
+
+ cdPalette(palette_p->size, palette_p->color, mode_i);
+}
+
+/***************************************************************************\
+* cdBackground. *
+\***************************************************************************/
+static void cdlua_background(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdBackground: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdBackground: too many parameters!");
+
+ color_i = cdBackground(color_i);
+ lua_pushusertag((void*) color_i, color_tag);
+}
+
+/***************************************************************************\
+* cdForeground. *
+\***************************************************************************/
+static void cdlua_foreground(void)
+{
+ lua_Object color;
+ long int color_i;
+
+ color = lua_getparam(1);
+ if (lua_tag(color) != color_tag)
+ lua_error("cdForeground: invalid color parameter!");
+ color_i = (long int) lua_getuserdata(color);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdForeground: too many parameters!");
+
+ color_i = cdForeground(color_i);
+ lua_pushusertag((void*) color_i, color_tag);
+}
+
+/***************************************************************************\
+* cdGetImageRGB. *
+\***************************************************************************/
+static void cdlua_getimagergb(void)
+{
+ lua_Object imagergb;
+ lua_Object x;
+ lua_Object y;
+
+ imagergb_t *imagergb_p;
+ int x_i;
+ int y_i;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdGetImageRGB: attempt to get a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdGetImageRGB: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("cdGetImageRGB: attempt to get a killed imagergb!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("cdGetImageRGB: invalid (x, y) parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdGetImageRGB: too many parameters!");
+
+ cdGetImageRGB(imagergb_p->red, imagergb_p->green, imagergb_p->blue,
+ x_i, y_i, imagergb_p->width, imagergb_p->height);
+}
+/***************************************************************************\
+* cdPutImageRGB. *
+\***************************************************************************/
+
+static void cdlua_rgb2map(void)
+{
+ lua_Object imagemap;
+ lua_Object palette;
+ lua_Object imagergb;
+
+ imagemap_t *imagemap_p;
+ palette_t *palette_p;
+ imagergb_t *imagergb_p;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdRGB2Map: attempt to put a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdRGB2Map: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("cdRGB2Map: attempt to put a killed imagergb!");
+
+ imagemap = lua_getparam(2);
+ if (lua_isnil(imagemap))
+ lua_error("cdRGB2Map: attempt to put a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("cdRGB2Map: imagemap invalid parameter!");
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->index)
+ lua_error("cdRGB2Map: attempt to put a killed imagemap!");
+
+ palette = lua_getparam(3);
+ if (lua_isnil(palette))
+ lua_error("cdRGB2Map: NIL pallete!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("cdRGB2Map: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("cdRGB2Map: killed pallete!");
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdRGB2Map: too many parameters!");
+
+ cdRGB2Map(imagergb_p->width, imagergb_p->height,
+ imagergb_p->red, imagergb_p->green, imagergb_p->blue,
+ imagemap_p->index, palette_p->size, palette_p->color);
+}
+
+static void cdlua_putimagergb(void)
+{
+ lua_Object imagergb;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+
+ imagergb_t *imagergb_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdPutImageRGB: attempt to put a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdPutImageRGB: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("cdPutImageRGB: attempt to put a killed imagergb!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h)))
+ lua_error("cdPutImageRGB: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageRGB: target region dimensions should be positive integers!");
+
+ if (lua_getparam(6) != LUA_NOOBJECT)
+ lua_error("cdPutImageRGB: too many parameters!");
+
+ cdPutImageRGB(imagergb_p->width, imagergb_p->height, imagergb_p->red,
+ imagergb_p->green, imagergb_p->blue, x_i, y_i, w_i, h_i);
+}
+
+static void cdlua_putimagerectrgb(void)
+{
+ lua_Object imagergb;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagergb_t *imagergb_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("cdPutImageRectRGB: attempt to put a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("cdPutImageRectRGB: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("cdPutImageRectRGB: attempt to put a killed imagergb!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ xmin = lua_getparam(6);
+ xmax = lua_getparam(7);
+ ymin = lua_getparam(8);
+ ymax = lua_getparam(9);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("cdPutImageRectRGB: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageRectRGB: target region dimensions should be positive integers!");
+
+ if (lua_getparam(10) != LUA_NOOBJECT)
+ lua_error("cdPutImageRectRGB: too many parameters!");
+
+ cdPutImageRectRGB(imagergb_p->width, imagergb_p->height, imagergb_p->red,
+ imagergb_p->green, imagergb_p->blue, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+static void wdlua_putimagerectrgb(void)
+{
+ lua_Object imagergb;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagergb_t *imagergb_p;
+ double x_i;
+ double y_i;
+ double w_i;
+ double h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagergb = lua_getparam(1);
+ if (lua_isnil(imagergb))
+ lua_error("wdPutImageRectRGB: attempt to put a NIL imagergb!");
+ if (lua_tag(imagergb) != imagergb_tag)
+ lua_error("wdPutImageRectRGB: invalid imagergb parameter!");
+ imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+ if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+ lua_error("wdPutImageRectRGB: attempt to put a killed imagergb!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ xmin = lua_getparam(6);
+ xmax = lua_getparam(7);
+ ymin = lua_getparam(8);
+ ymax = lua_getparam(9);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("wdPutImageRectRGB: invalid parameter!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+ w_i = (double) lua_getnumber(w);
+ h_i = (double) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("wdPutImageRectRGB: target region dimensions should be positive integers!");
+
+ if (lua_getparam(10) != LUA_NOOBJECT)
+ lua_error("wdPutImageRectRGB: too many parameters!");
+
+ wdPutImageRectRGB(imagergb_p->width, imagergb_p->height, imagergb_p->red,
+ imagergb_p->green, imagergb_p->blue, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+/***************************************************************************\
+* cdPutImageRGBA. *
+\***************************************************************************/
+static void cdlua_putimagergba(void)
+{
+ lua_Object imagergba;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+
+ imagergba_t *imagergba_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+
+ imagergba = lua_getparam(1);
+ if (lua_isnil(imagergba))
+ lua_error("cdPutImageRGBA: attempt to put a NIL imagergba!");
+ if (lua_tag(imagergba) != imagergba_tag)
+ lua_error("cdPutImageRGBA: invalid imagergba parameter!");
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue && imagergba_p->alpha))
+ lua_error("cdPutImageRGBA: attempt to put a killed imagergba!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h)))
+ lua_error("cdPutImageRGBA: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageRGBA: target region dimensions should be positive integers!");
+
+ if (lua_getparam(6) != LUA_NOOBJECT)
+ lua_error("cdPutImageRGBA: too many parameters!");
+
+ cdPutImageRGBA(imagergba_p->width, imagergba_p->height, imagergba_p->red,
+ imagergba_p->green, imagergba_p->blue, imagergba_p->alpha, x_i, y_i, w_i, h_i);
+}
+
+static void cdlua_putimagerectrgba(void)
+{
+ lua_Object imagergba;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagergba_t *imagergba_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagergba = lua_getparam(1);
+ if (lua_isnil(imagergba))
+ lua_error("cdPutImageRectRGBA: attempt to put a NIL imagergba!");
+ if (lua_tag(imagergba) != imagergba_tag)
+ lua_error("cdPutImageRectRGBA: invalid imagergba parameter!");
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue && imagergba_p->alpha))
+ lua_error("cdPutImageRectRGBA: attempt to put a killed imagergba!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ xmin = lua_getparam(6);
+ xmax = lua_getparam(7);
+ ymin = lua_getparam(8);
+ ymax = lua_getparam(9);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("cdPutImageRectRGBA: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageRectRGBA: target region dimensions should be positive integers!");
+
+ if (lua_getparam(10) != LUA_NOOBJECT)
+ lua_error("cdPutImageRectRGBA: too many parameters!");
+
+ cdPutImageRectRGBA(imagergba_p->width, imagergba_p->height, imagergba_p->red,
+ imagergba_p->green, imagergba_p->blue, imagergba_p->alpha, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+static void wdlua_putimagerectrgba(void)
+{
+ lua_Object imagergba;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagergba_t *imagergba_p;
+ double x_i;
+ double y_i;
+ double w_i;
+ double h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagergba = lua_getparam(1);
+ if (lua_isnil(imagergba))
+ lua_error("wdPutImageRectRGBA: attempt to put a NIL imagergba!");
+ if (lua_tag(imagergba) != imagergba_tag)
+ lua_error("wdPutImageRectRGBA: invalid imagergba parameter!");
+ imagergba_p = (imagergba_t *) lua_getuserdata(imagergba);
+ if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue && imagergba_p->alpha))
+ lua_error("wdPutImageRectRGBA: attempt to put a killed imagergba!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ w = lua_getparam(4);
+ h = lua_getparam(5);
+ xmin = lua_getparam(6);
+ xmax = lua_getparam(7);
+ ymin = lua_getparam(8);
+ ymax = lua_getparam(9);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("wdPutImageRectRGBA: invalid parameter!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+ w_i = (double) lua_getnumber(w);
+ h_i = (double) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("wdPutImageRectRGBA: target region dimensions should be positive integers!");
+
+ if (lua_getparam(10) != LUA_NOOBJECT)
+ lua_error("wdPutImageRectRGBA: too many parameters!");
+
+ wdPutImageRectRGBA(imagergba_p->width, imagergba_p->height, imagergba_p->red,
+ imagergba_p->green, imagergba_p->blue, imagergba_p->alpha, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+/***************************************************************************\
+* cdPutImageMap. *
+\***************************************************************************/
+static void cdlua_putimagemap(void)
+{
+ lua_Object imagemap;
+ lua_Object palette;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+
+ imagemap_t *imagemap_p;
+ palette_t *palette_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+
+ imagemap = lua_getparam(1);
+ if (lua_isnil(imagemap))
+ lua_error("cdPutImageMap: attempt to put a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("cdPutImageMap: imagemap invalid parameter!");
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->index)
+ lua_error("cdPutImageMap: attempt to put a killed imagemap!");
+
+ palette = lua_getparam(2);
+ if (lua_isnil(palette))
+ lua_error("cdPutImageMap: NIL pallete!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("cdPutImageMap: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("cdPutImageMap: killed pallete!");
+
+ x = lua_getparam(3);
+ y = lua_getparam(4);
+ w = lua_getparam(5);
+ h = lua_getparam(6);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h)))
+ lua_error("cdPutImageMap: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageMap: target region dimensions should be positive integers!");
+
+ if (lua_getparam(7) != LUA_NOOBJECT)
+ lua_error("cdPutImageMap: too many parameters!");
+
+ cdPutImageMap(imagemap_p->width, imagemap_p->height, imagemap_p->index,
+ palette_p->color, x_i, y_i, w_i, h_i);
+}
+
+static void cdlua_putimagerectmap(void)
+{
+ lua_Object imagemap;
+ lua_Object palette;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagemap_t *imagemap_p;
+ palette_t *palette_p;
+ int x_i;
+ int y_i;
+ int w_i;
+ int h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagemap = lua_getparam(1);
+ if (lua_isnil(imagemap))
+ lua_error("cdPutImageMap: attempt to put a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("cdPutImageMap: imagemap invalid parameter!");
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->index)
+ lua_error("cdPutImageMap: attempt to put a killed imagemap!");
+
+ palette = lua_getparam(2);
+ if (lua_isnil(palette))
+ lua_error("cdPutImageRectMap: NIL pallete!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("cdPutImageRectMap: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("cdPutImageRectMap: killed pallete!");
+
+ x = lua_getparam(3);
+ y = lua_getparam(4);
+ w = lua_getparam(5);
+ h = lua_getparam(6);
+ xmin = lua_getparam(7);
+ xmax = lua_getparam(8);
+ ymin = lua_getparam(9);
+ ymax = lua_getparam(10);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("cdPutImageRectMap: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ w_i = (int) lua_getnumber(w);
+ h_i = (int) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("cdPutImageRectMap: target region dimensions should be positive integers!");
+
+ if (lua_getparam(11) != LUA_NOOBJECT)
+ lua_error("cdPutImageRectMap: too many parameters!");
+
+ cdPutImageRectMap(imagemap_p->width, imagemap_p->height, imagemap_p->index,
+ palette_p->color, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+static void wdlua_putimagerectmap(void)
+{
+ lua_Object imagemap;
+ lua_Object palette;
+ lua_Object x;
+ lua_Object y;
+ lua_Object w;
+ lua_Object h;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ imagemap_t *imagemap_p;
+ palette_t *palette_p;
+ double x_i;
+ double y_i;
+ double w_i;
+ double h_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ imagemap = lua_getparam(1);
+ if (lua_isnil(imagemap))
+ lua_error("wdPutImageMap: attempt to put a NIL imagemap!");
+ if (lua_tag(imagemap) != imagemap_tag)
+ lua_error("wdPutImageMap: imagemap invalid parameter!");
+ imagemap_p = (imagemap_t *) lua_getuserdata(imagemap);
+ if (!imagemap_p->index)
+ lua_error("wdPutImageMap: attempt to put a killed imagemap!");
+
+ palette = lua_getparam(2);
+ if (lua_isnil(palette))
+ lua_error("wdPutImageRectMap: NIL pallete!");
+ if (lua_tag(palette) != palette_tag)
+ lua_error("wdPutImageRectMap: invalid palette parameter!");
+ palette_p = (palette_t *) lua_getuserdata(palette);
+ if (!palette_p->color)
+ lua_error("wdPutImageRectMap: killed pallete!");
+
+ x = lua_getparam(3);
+ y = lua_getparam(4);
+ w = lua_getparam(5);
+ h = lua_getparam(6);
+ xmin = lua_getparam(7);
+ xmax = lua_getparam(8);
+ ymin = lua_getparam(9);
+ ymax = lua_getparam(10);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(w) && lua_isnumber(h) &&
+ lua_isnumber(xmin) && lua_isnumber(xmax) && lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("wdPutImageRectMap: invalid parameter!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+ w_i = (double) lua_getnumber(w);
+ h_i = (double) lua_getnumber(h);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+ if (w_i < 0 || h_i < 0)
+ lua_error("wdPutImageRectMap: target region dimensions should be positive integers!");
+
+ if (lua_getparam(11) != LUA_NOOBJECT)
+ lua_error("wdPutImageRectMap: too many parameters!");
+
+ wdPutImageRectMap(imagemap_p->width, imagemap_p->height, imagemap_p->index,
+ palette_p->color, x_i, y_i, w_i, h_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+/***************************************************************************\
+* cdGetImage. *
+\***************************************************************************/
+static void cdlua_getimage(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+
+ image_t *image_p;
+ int x_i;
+ int y_i;
+
+ image = lua_getparam(1);
+ if (lua_isnil(image))
+ lua_error("cdGetImage: attempt to get NIL image");
+ if (lua_tag(image) != image_tag)
+ lua_error("cdGetImage: invalid image parameter!");
+ image_p = (image_t *) lua_getuserdata(image);
+ if (!image_p->cd_image)
+ lua_error("cdGetImage: attempt to get a killed image");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("cdGetImage: invalid (x, y) parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdGetImage: too many parameters!");
+ cdGetImage(image_p->cd_image, x_i, y_i);
+}
+
+/***************************************************************************\
+* cdPutImage. *
+\***************************************************************************/
+static void cdlua_putimage(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+
+ image_t *image_p;
+ int x_i;
+ int y_i;
+
+ image = lua_getparam(1);
+ if (lua_isnil(image))
+ lua_error("cdPutImage: attempt to put a NIL image!");
+ if (lua_tag(image) != image_tag)
+ lua_error("cdPutImage: invalid image parameter!");
+ image_p = (image_t *) lua_getuserdata(image);
+ if (!image_p->cd_image)
+ lua_error("cdPutImage: attempt to put a killed image!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ if (!(lua_isnumber(x) && lua_isnumber(y)))
+ lua_error("cdPutImage: invalid (x, y) parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdPutImage: too many parameters!");
+
+ cdPutImage(image_p->cd_image, x_i, y_i);
+}
+
+/***************************************************************************\
+* cdPutImageRect. *
+\***************************************************************************/
+static void cdlua_putimagerect(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ image_t *image_p;
+ int x_i;
+ int y_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ image = lua_getparam(1);
+ if (lua_isnil(image))
+ lua_error("cdPutImageRect: attempt to put a NIL image!");
+ if (lua_tag(image) != image_tag)
+ lua_error("cdPutImageRect: invalid image parameter!");
+ image_p = (image_t *) lua_getuserdata(image);
+ if (!image_p->cd_image)
+ lua_error("cdPutImageRect: attempt to put a killed image!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ xmin = lua_getparam(4);
+ xmax = lua_getparam(5);
+ ymin = lua_getparam(6);
+ ymax = lua_getparam(7);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(xmin) && lua_isnumber(xmax) &&
+ lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("cdPutImageRect: invalid parameter!");
+ x_i = (int) lua_getnumber(x);
+ y_i = (int) lua_getnumber(y);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+
+ if (lua_getparam(8) != LUA_NOOBJECT)
+ lua_error("cdPutImageRect: too many parameters!");
+
+ cdPutImageRect(image_p->cd_image, x_i, y_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+static void wdlua_putimagerect(void)
+{
+ lua_Object image;
+ lua_Object x;
+ lua_Object y;
+ lua_Object xmin;
+ lua_Object xmax;
+ lua_Object ymin;
+ lua_Object ymax;
+
+ image_t *image_p;
+ double x_i;
+ double y_i;
+ int xmin_i;
+ int xmax_i;
+ int ymin_i;
+ int ymax_i;
+
+ image = lua_getparam(1);
+ if (lua_isnil(image))
+ lua_error("wdPutImageRect: attempt to put a NIL image!");
+ if (lua_tag(image) != image_tag)
+ lua_error("wdPutImageRect: invalid image parameter!");
+ image_p = (image_t *) lua_getuserdata(image);
+ if (!image_p->cd_image)
+ lua_error("wdPutImageRect: attempt to put a killed image!");
+
+ x = lua_getparam(2);
+ y = lua_getparam(3);
+ xmin = lua_getparam(4);
+ xmax = lua_getparam(5);
+ ymin = lua_getparam(6);
+ ymax = lua_getparam(7);
+ if (!(lua_isnumber(x) && lua_isnumber(y) && lua_isnumber(xmin) && lua_isnumber(xmax) &&
+ lua_isnumber(ymin) && lua_isnumber(ymax)))
+ lua_error("wdPutImageRect: invalid parameter!");
+ x_i = (double) lua_getnumber(x);
+ y_i = (double) lua_getnumber(y);
+ xmin_i = (int) lua_getnumber(xmin);
+ xmax_i = (int) lua_getnumber(xmax);
+ ymin_i = (int) lua_getnumber(ymin);
+ ymax_i = (int) lua_getnumber(ymax);
+
+ if (lua_getparam(8) != LUA_NOOBJECT)
+ lua_error("wdPutImageRect: too many parameters!");
+
+ wdPutImageRect(image_p->cd_image, x_i, y_i, xmin_i, xmax_i, ymin_i, ymax_i);
+}
+
+/***************************************************************************\
+* cdVersion. *
+\***************************************************************************/
+
+static void cdlua_version(void)
+{
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("cdVersion: too many parameters!");
+
+ lua_pushstring(cdVersion());
+}
+
+/***************************************************************************\
+* wdGetViewport. *
+\***************************************************************************/
+static void wdlua_getviewport(void)
+{
+ int xmin;
+ int xmax;
+ int ymin;
+ int ymax;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("wdGetViewport: too many parameters!");
+
+ wdGetViewport(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+/***************************************************************************\
+* wdGetWindow. *
+\***************************************************************************/
+static void wdlua_getwindow(void)
+{
+ double xmin;
+ double xmax;
+ double ymin;
+ double ymax;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("wdGetWindow: too many parameters!");
+
+ wdGetWindow(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+/***************************************************************************\
+* wdGetClipArea. *
+\***************************************************************************/
+static void wdlua_getcliparea(void)
+{
+ double xmin;
+ double xmax;
+ double ymin;
+ double ymax;
+ int status;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("wdGetClipArea: too many parameters!");
+
+ status = wdGetClipArea(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+ lua_pushnumber(status);
+}
+
+static void wdlua_RegionBox(void)
+{
+ double xmin;
+ double xmax;
+ double ymin;
+ double ymax;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("wdRegionBox: too many parameters!");
+
+ wdRegionBox(&xmin, &xmax, &ymin, &ymax);
+ lua_pushnumber(xmin);
+ lua_pushnumber(xmax);
+ lua_pushnumber(ymin);
+ lua_pushnumber(ymax);
+}
+
+/***************************************************************************\
+* wdFontDim. *
+\***************************************************************************/
+static void wdlua_fontdim(void)
+{
+ double max_width;
+ double height;
+ double ascent;
+ double descent;
+
+ if (lua_getparam(1) != LUA_NOOBJECT)
+ lua_error("wdFontDim: too many parameters!");
+
+ wdFontDim(&max_width, &height, &ascent, &descent);
+ lua_pushnumber(max_width);
+ lua_pushnumber(height);
+ lua_pushnumber(ascent);
+ lua_pushnumber(descent);
+}
+
+/***************************************************************************\
+* wdTextSize. *
+\***************************************************************************/
+static void wdlua_textsize(void)
+{
+ lua_Object text;
+ char* text_s;
+
+ double width;
+ double height;
+
+ text = lua_getparam(1);
+ if (!lua_isstring(text))
+ lua_error("wdTextSize: invalid text parameter!");
+ text_s = (char*) lua_getstring(text);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("wdTextSize: too many parameters!");
+
+ wdTextSize(text_s, &width, &height);
+ lua_pushnumber(width);
+ lua_pushnumber(height);
+}
+
+/***************************************************************************\
+* wdGetVectorTextSize. *
+\***************************************************************************/
+static void wdlua_getvectortextsize(void)
+{
+ lua_Object text;
+ char* text_s;
+
+ double width;
+ double height;
+
+ text = lua_getparam(1);
+ if (!lua_isstring(text))
+ lua_error("wdGetVectorTextSize: invalid text parameter!");
+ text_s = (char*) lua_getstring(text);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("wdGetVectorTextSize: too many parameters!");
+
+ wdGetVectorTextSize(text_s, &width, &height);
+ lua_pushnumber(width);
+ lua_pushnumber(height);
+}
+
+static void cdlua_vectortexttransform(void)
+{
+ lua_Object old_table, table, value;
+ double matrix[6], *old_matrix;
+ int i;
+
+ table = lua_getparam(1);
+ if (!lua_istable(table))
+ lua_error("cdVectorTextTransform: invalid table parameter!");
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdVectorTextTransform: too many parameters!");
+
+ for (i=0; i < 6; i++)
+ {
+ lua_pushobject(table);
+ lua_pushnumber(i+1);
+ value = lua_gettable();
+
+ if (!lua_isnumber(value))
+ lua_error("cdVectorTextTransform: invalid value!");
+
+ matrix[i] = lua_getnumber(value);
+ }
+
+ old_matrix = cdVectorTextTransform(matrix);
+
+ old_table = lua_createtable();
+
+ for (i=0; i < 6; i++)
+ {
+ lua_pushobject(old_table);
+ lua_pushnumber(i+1);
+ lua_pushnumber(old_matrix[i]);
+ lua_settable();
+ }
+}
+
+static void cdlua_vectortextbounds(void)
+{
+ char* s = (char*)luaL_check_string(1);
+ int x = (int)luaL_check_number(2);
+ int y = (int)luaL_check_number(3);
+ int rect[8], i;
+ lua_Object lua_rect;
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("cdGetVectorTextBounds: too many parameters!");
+
+ cdGetVectorTextBounds(s, x, y, rect);
+
+ lua_rect = lua_createtable();
+
+ for (i=0; i < 8; i++)
+ {
+ lua_pushobject(lua_rect);
+ lua_pushnumber(i+1);
+ lua_pushnumber(rect[i]);
+ lua_settable();
+ }
+}
+
+static void wdlua_vectortextbounds(void)
+{
+ char* s = (char*)luaL_check_string(1);
+ double x = luaL_check_number(2);
+ double y = luaL_check_number(3);
+ double rect[8];
+ int i;
+ lua_Object lua_rect;
+
+ if (lua_getparam(4) != LUA_NOOBJECT)
+ lua_error("wdGetVectorTextBounds: too many parameters!");
+
+ wdGetVectorTextBounds(s, x, y, rect);
+
+ lua_rect = lua_createtable();
+
+ for (i=0; i < 8; i++)
+ {
+ lua_pushobject(lua_rect);
+ lua_pushnumber(i+1);
+ lua_pushnumber(rect[i]);
+ lua_settable();
+ }
+}
+
+static void cdlua_getvectortextsize(void)
+{
+ lua_Object text;
+ char* text_s;
+
+ int width;
+ int height;
+
+ text = lua_getparam(1);
+ if (!lua_isstring(text))
+ lua_error("cdGetVectorTextSize: invalid text parameter!");
+ text_s = (char*) lua_getstring(text);
+
+ if (lua_getparam(2) != LUA_NOOBJECT)
+ lua_error("cdGetTextSize: too many parameters!");
+
+ cdGetVectorTextSize(text_s, &width, &height);
+ lua_pushnumber(width);
+ lua_pushnumber(height);
+}
+/***************************************************************************\
+* wdWorld2Canvas. *
+\***************************************************************************/
+static void wdlua_world2canvas(void)
+{
+ lua_Object xw;
+ lua_Object yw;
+ double xw_d;
+ double yw_d;
+
+ int xv_i;
+ int yv_i;
+
+ xw = lua_getparam(1);
+ yw = lua_getparam(2);
+ if (!(lua_isnumber(xw) && lua_isnumber(yw)))
+ lua_error("wdWorld2Canvas: invalid (xw, yw) parameter!");
+ xw_d = (double) lua_getnumber(xw);
+ yw_d = (double) lua_getnumber(yw);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("wdWorld2Canvas: too many parameters!");
+
+ wdWorld2Canvas(xw_d, yw_d, &xv_i, &yv_i);
+ lua_pushnumber(xv_i);
+ lua_pushnumber(yv_i);
+}
+
+/***************************************************************************\
+* wdCanvas2World. *
+\***************************************************************************/
+static void wdlua_canvas2world(void)
+{
+ lua_Object xv;
+ lua_Object yv;
+ int xv_i;
+ int yv_i;
+
+ double xw_d;
+ double yw_d;
+
+ xv = lua_getparam(1);
+ yv = lua_getparam(2);
+ if (!(lua_isnumber(xv) && lua_isnumber(yv)))
+ lua_error("wdCanvas2World: invalid (xc, yc) parameter!");
+ xv_i = (int) lua_getnumber(xv);
+ yv_i = (int) lua_getnumber(yv);
+
+ if (lua_getparam(3) != LUA_NOOBJECT)
+ lua_error("wdCanvas2World: too many parameters!");
+
+ wdCanvas2World(xv_i, yv_i, &xw_d, &yw_d);
+ lua_pushnumber(xw_d);
+ lua_pushnumber(yw_d);
+}
+
+/***************************************************************************\
+* Initializes CDLua. *
+\***************************************************************************/
+static void cdlua_pushstring(char* str, char* name)
+{
+ lua_pushstring(str); lua_setglobal(name);
+ cdlua_setnamespace(name, name+2); /* CD_XXXX = _XXXX */
+}
+
+static void setinfo(void)
+{
+ cdlua_pushstring(CD_COPYRIGHT, "CD_COPYRIGHT");
+ cdlua_pushstring("A 2D Graphics Library", "CD_DESCRIPTION");
+ cdlua_pushstring("CD - Canvas Draw", "CD_NAME");
+ cdlua_pushstring("CD "CD_VERSION, "CD_VERSION");
+}
+
+void cdlua_open(void)
+{
+ char version[50];
+ lua_Object imlua_tag;
+
+ cdlua_namespace = lua_createtable();
+ lua_pushobject(cdlua_namespace); lua_setglobal ("cd");
+
+ sprintf(version, "CDLua %s", cdVersion());
+ lua_pushstring(version); lua_setglobal ("CDLUA_VERSION");
+ setinfo();
+
+ /* check if IM has been initialized */
+ imlua_tag = lua_getglobal("IMLUA_INSTALLED");
+
+ /* get IM defined tags, let IM handle with the user tag objects */
+ if ((imlua_tag != LUA_NOOBJECT) && (!lua_isnil(imlua_tag)))
+ {
+ imlua_tag = lua_getglobal("IMLUA_COLOR_TAG");
+ color_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_IMAGERGB_TAG");
+ imagergb_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_IMAGERGBA_TAG");
+ imagergba_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_PALETTE_TAG");
+ palette_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_IMAGEMAP_TAG");
+ imagemap_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_CHANNEL_TAG");
+ channel_tag = (int) lua_getnumber(imlua_tag);
+ imlua_tag = lua_getglobal("IMLUA_BITMAP_TAG");
+ bitmap_tag = (int) lua_getnumber(imlua_tag);
+ }
+ else /* define CD own tags and fallbacks */
+ {
+ /* create user tags */
+ color_tag = lua_newtag();
+ bitmap_tag = lua_newtag();
+ imagergb_tag = lua_newtag();
+ imagergba_tag = lua_newtag();
+ imagemap_tag = lua_newtag();
+ palette_tag = lua_newtag();
+ channel_tag = lua_newtag();
+
+ /* hook "settable" and "gettable" tag methods */
+ lua_pushcfunction(palettesettable_fb); lua_settagmethod(palette_tag, "settable");
+ lua_pushcfunction(imagemapsettable_fb); lua_settagmethod(imagemap_tag, "settable");
+ lua_pushcfunction(channelsettable_fb); lua_settagmethod(channel_tag, "settable");
+
+ lua_pushcfunction(palettegettable_fb); lua_settagmethod(palette_tag, "gettable");
+ lua_pushcfunction(imagemapgettable_fb); lua_settagmethod(imagemap_tag, "gettable");
+ lua_pushcfunction(channelgettable_fb); lua_settagmethod(channel_tag, "gettable");
+ lua_pushcfunction(imagergbgettable_fb); lua_settagmethod(imagergb_tag, "gettable");
+ lua_pushcfunction(imagergbagettable_fb); lua_settagmethod(imagergba_tag, "gettable");
+ lua_pushcfunction(bitmapgettable_fb); lua_settagmethod(bitmap_tag, "gettable");
+
+ lua_pushcfunction(palettegc_fb); lua_settagmethod(palette_tag, "gc");
+ lua_pushcfunction(imagemapgc_fb); lua_settagmethod(imagemap_tag, "gc");
+ lua_pushcfunction(imagergbgc_fb); lua_settagmethod(imagergb_tag, "gc");
+ lua_pushcfunction(imagergbagc_fb); lua_settagmethod(imagergba_tag, "gc");
+ lua_pushcfunction(bitmapgc_fb); lua_settagmethod(bitmap_tag, "gc");
+ }
+
+ /* these are not handled by IM */
+ stipple_tag = lua_newtag();
+ pattern_tag = lua_newtag();
+ image_tag = lua_newtag();
+ canvas_tag = lua_newtag();
+ state_tag = lua_newtag();
+
+ /* hook "settable" and "gettable" tag methods */
+ lua_pushcfunction(stipplesettable_fb); lua_settagmethod(stipple_tag, "settable");
+ lua_pushcfunction(patternsettable_fb); lua_settagmethod(pattern_tag, "settable");
+ lua_pushcfunction(stipplegettable_fb); lua_settagmethod(stipple_tag, "gettable");
+ lua_pushcfunction(patterngettable_fb); lua_settagmethod(pattern_tag, "gettable");
+
+ lua_pushcfunction(stipplegc_fb); lua_settagmethod(stipple_tag, "gc");
+ lua_pushcfunction(patterngc_fb); lua_settagmethod(pattern_tag, "gc");
+ lua_pushcfunction(stategc_fb); lua_settagmethod(state_tag, "gc");
+
+ /* register used tags in global context for other libraries use */
+ lua_pushnumber(1.0f); lua_setglobal("CDLUA_INSTALLED");
+
+ lua_pushnumber(color_tag); lua_setglobal(COLOR_TAG);
+ lua_pushnumber(stipple_tag); lua_setglobal(STIPPLE_TAG);
+ lua_pushnumber(pattern_tag); lua_setglobal(PATTERN_TAG);
+ lua_pushnumber(image_tag); lua_setglobal(IMAGE_TAG);
+ lua_pushnumber(bitmap_tag); lua_setglobal(BITMAP_TAG);
+ lua_pushnumber(imagergb_tag); lua_setglobal(IMAGERGB_TAG);
+ lua_pushnumber(imagergba_tag); lua_setglobal(IMAGERGBA_TAG);
+ lua_pushnumber(imagemap_tag); lua_setglobal(IMAGEMAP_TAG);
+ lua_pushnumber(palette_tag); lua_setglobal(PALETTE_TAG);
+ lua_pushnumber(channel_tag); lua_setglobal(CHANNEL_TAG);
+ lua_pushnumber(canvas_tag); lua_setglobal(CANVAS_TAG);
+ lua_pushnumber(state_tag); lua_setglobal(STATE_TAG);
+
+ /* registered cd functions */
+ cdlua_register("cdSaveState", cdlua_savestate);
+ cdlua_register("cdRestoreState", cdlua_restorestate);
+ cdlua_register("cdReleaseState", cdlua_releasestate);
+ cdlua_register("cdCreateCanvas", cdlua_createcanvas);
+ cdlua_register("cdContextCaps", cdlua_contextcaps);
+ cdlua_register("cdGetContext", cdlua_getcontext);
+ cdlua_register("cdActivate", cdlua_activate);
+ cdlua_register("cdActiveCanvas", cdlua_activecanvas);
+ cdlua_register("cdKillCanvas", cdlua_killcanvas);
+ cdlua_register("cdCreateStipple", cdlua_createstipple);
+ cdlua_register("cdGetStipple", cdlua_getstipple);
+ cdlua_register("cdKillStipple", cdlua_killstipple);
+ cdlua_register("cdCreatePattern", cdlua_createpattern);
+ cdlua_register("cdGetPattern", cdlua_getpattern);
+ cdlua_register("cdKillPattern", cdlua_killpattern);
+ cdlua_register("cdCreatePalette", cdlua_createpalette);
+ cdlua_register("cdKillPalette", cdlua_killpalette);
+ cdlua_register("cdCreateImage", cdlua_createimage);
+ cdlua_register("cdKillImage", cdlua_killimage);
+ cdlua_register("cdImageRGB", cdlua_imagergb);
+ cdlua_register("cdImageRGBBitmap", cdlua_imagergbbitmap);
+ cdlua_register("cdCreateImageRGB", cdlua_createimagergb);
+ cdlua_register("cdKillImageRGB", cdlua_killimagergb);
+ cdlua_register("cdCreateImageRGBA", cdlua_createimagergba);
+ cdlua_register("cdKillImageRGBA", cdlua_killimagergba);
+ cdlua_register("cdCreateImageMap", cdlua_createimagemap);
+ cdlua_register("cdKillImageMap", cdlua_killimagemap);
+
+ cdlua_register("cdRegisterCallback", cdlua_registercallback);
+ cdlua_register("cdEncodeColor", cdlua_encodecolor);
+ cdlua_register("cdDecodeColor", cdlua_decodecolor);
+ cdlua_register("cdEncodeAlpha", cdlua_encodealpha);
+ cdlua_register("cdDecodeAlpha", cdlua_decodealpha);
+ cdlua_register("cdReserved", cdlua_reserved);
+ cdlua_register("cdBlue", cdlua_blue);
+ cdlua_register("cdGreen", cdlua_green);
+ cdlua_register("cdRed", cdlua_red);
+ cdlua_register("cdAlpha", cdlua_alpha);
+ cdlua_register("cdForeground", cdlua_foreground);
+ cdlua_register("cdBackground", cdlua_background);
+ cdlua_register("cdUpdateYAxis", cdlua_updateyaxis);
+ cdlua_register("cdFontDim", cdlua_fontdim);
+ cdlua_register("cdGetCanvasSize", cdlua_getcanvassize);
+ cdlua_register("cdGetClipPoly", cdlua_getclippoly);
+ cdlua_register("cdGetClipArea", cdlua_getcliparea);
+ cdlua_register("cdRegionBox", cdlua_RegionBox);
+ cdlua_register("cdGetImage", cdlua_getimage);
+ cdlua_register("cdGetImageRGB", cdlua_getimagergb);
+ cdlua_register("cdMM2Pixel", cdlua_mm2pixel);
+ cdlua_register("cdPalette", cdlua_palette);
+ cdlua_register("cdPattern", cdlua_pattern);
+ cdlua_register("cdPixel", cdlua_pixel);
+ cdlua_register("cdPixel2MM", cdlua_pixel2mm);
+ cdlua_register("cdPlay", cdlua_play);
+ cdlua_register("cdPutImage", cdlua_putimage);
+ cdlua_register("cdRGB2Map", cdlua_rgb2map);
+ cdlua_register("cdPutImageRGB", cdlua_putimagergb);
+ cdlua_register("cdPutImageRectRGB", cdlua_putimagerectrgb);
+ cdlua_register("cdPutImageRGBA", cdlua_putimagergba);
+ cdlua_register("cdPutImageRectRGBA", cdlua_putimagerectrgba);
+ cdlua_register("cdPutImageMap", cdlua_putimagemap);
+ cdlua_register("cdPutImageRectMap", cdlua_putimagerectmap);
+ cdlua_register("cdPutImageRect", cdlua_putimagerect);
+ cdlua_register("cdStipple", cdlua_stipple);
+ cdlua_register("cdTextSize", cdlua_textsize);
+ cdlua_register("cdTextBox", cdlua_textbox);
+ cdlua_register("cdTextBounds", cdlua_textbounds);
+ cdlua_register("cdGetFont", cdlua_getfont);
+ cdlua_register("cdVersion", cdlua_version);
+ cdlua_register("cdGetVectorTextSize", cdlua_getvectortextsize);
+ cdlua_register("cdVectorTextTransform", cdlua_vectortexttransform);
+ cdlua_register("cdVectorTextBounds", cdlua_vectortextbounds);
+ cdlua_register("cdCreateBitmap", cdlua_createbitmap);
+ cdlua_register("cdKillBitmap", cdlua_killbitmap);
+ cdlua_register("cdBitmapSetRect", cdlua_bitmapsetrect);
+ cdlua_register("cdPutBitmap", cdlua_putbitmap);
+ cdlua_register("cdGetBitmap", cdlua_getbitmap);
+ cdlua_register("cdBitmapRGB2Map", cdlua_rgb2mapex);
+ cdlua_register("cdLineStyleDashes", cdlua_LineStyleDashes);
+
+ /* registered wd functions */
+ cdlua_register("wdHardcopy", wdlua_hardcopy);
+ cdlua_register("wdPutBitmap", wdlua_putbitmap);
+ cdlua_register("wdGetWindow", wdlua_getwindow);
+ cdlua_register("wdGetViewport", wdlua_getviewport);
+ cdlua_register("wdWorld2Canvas", wdlua_world2canvas);
+ cdlua_register("wdCanvas2World", wdlua_canvas2world);
+ cdlua_register("wdGetClipArea", wdlua_getcliparea);
+ cdlua_register("wdRegionBox", wdlua_RegionBox);
+ cdlua_register("wdMM2Pixel", cdlua_mm2pixel);
+ cdlua_register("wdPixel2MM", cdlua_pixel2mm);
+ cdlua_register("wdFontDim", wdlua_fontdim);
+ cdlua_register("wdGetFont", wdlua_getfont);
+ cdlua_register("wdTextSize", wdlua_textsize);
+ cdlua_register("wdGetVectorTextSize", wdlua_getvectortextsize);
+ cdlua_register("wdVectorTextBounds", wdlua_vectortextbounds);
+ cdlua_register("wdPixel", wdlua_pixel);
+ cdlua_register("wdTextBox", wdlua_textbox);
+ cdlua_register("wdTextBounds", wdlua_textbounds);
+ cdlua_register("wdPutImageRectRGB", wdlua_putimagerectrgb);
+ cdlua_register("wdPutImageRectRGBA", wdlua_putimagerectrgba);
+ cdlua_register("wdPutImageRectMap", wdlua_putimagerectmap);
+ cdlua_register("wdPutImageRect", wdlua_putimagerect);
+ cdlua_register("wdStipple", wdlua_stipple);
+ cdlua_register("wdPattern", wdlua_pattern);
+ cdlua_register("wdGetClipPoly", wdlua_getclippoly);
+
+ cdlua_initdrivers();
+
+ /* color constants */
+ cdlua_pushcolor(CD_RED, "CD_RED");
+ cdlua_pushcolor(CD_DARK_RED, "CD_DARK_RED");
+ cdlua_pushcolor(CD_GREEN, "CD_GREEN");
+ cdlua_pushcolor(CD_DARK_GREEN, "CD_DARK_GREEN");
+ cdlua_pushcolor(CD_BLUE, "CD_BLUE");
+ cdlua_pushcolor(CD_DARK_BLUE, "CD_DARK_BLUE");
+ cdlua_pushcolor(CD_YELLOW, "CD_YELLOW");
+ cdlua_pushcolor(CD_DARK_YELLOW, "CD_DARK_YELLOW");
+ cdlua_pushcolor(CD_MAGENTA, "CD_MAGENTA");
+ cdlua_pushcolor(CD_DARK_MAGENTA, "CD_DARK_MAGENTA");
+ cdlua_pushcolor(CD_CYAN, "CD_CYAN");
+ cdlua_pushcolor(CD_DARK_CYAN, "CD_DARK_CYAN");
+ cdlua_pushcolor(CD_WHITE, "CD_WHITE");
+ cdlua_pushcolor(CD_BLACK, "CD_BLACK");
+ cdlua_pushcolor(CD_DARK_GRAY, "CD_DARK_GRAY");
+ cdlua_pushcolor(CD_GRAY, "CD_GRAY");
+
+ /* cdplay constants */
+ cdlua_pushnumber(CD_SIZECB, "CD_SIZECB");
+
+ /* create void canvas used when there is no active canvas to avoid protection faults */
+ void_canvas = cdCreateCanvas(CD_VOID, NULL);
+ cdActivate(void_canvas);
+
+ /* initialize toLua implementation */
+ luaL_cd_open();
+ luaL_wd_open();
+}
+
+void cdlua_close(void)
+{
+ cdKillCanvas(void_canvas);
+}