First commit - moving from LuaForge to SourceForge

1 files changed, 950 insertions, 0 deletions

diff --git a/src/lua3/cdluactx.c b/src/lua3/cdluactx.c
new file mode 100644
index 0000000..fc09313
--- /dev/null
+++ b/src/lua3/cdluactx.c
@@ -0,0 +1,950 @@
+/***************************************************************************\
+* CDLUA.C, for LUA 3.1                                                      *
+* Diego Fernandes Nehab, Antonio Escano Scuri                               *
+* 01/99                                                                     *
+\***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "cd.h"
+#include "wd.h"
+
+#include "cdimage.h"
+#include "cdirgb.h"
+#include "cddxf.h"
+#include "cddgn.h"
+#include "cdcgm.h"
+#include "cdwmf.h"
+#include "cdemf.h"
+#include "cdnative.h"
+#include "cdprint.h"
+#include "cdclipbd.h"
+#include "cdmf.h"
+#include "cdps.h"
+#include "cddbuf.h"
+#include "cdgdiplus.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "cdlua.h"
+#include "cdlua3_private.h"
+
+
+/***************************************************************************\
+* CD_CGM.                                                                   *
+\***************************************************************************/
+static void *cdcgm_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_CGM: data should be of type string!");
+
+  return lua_getstring(data);
+}
+
+static int cgm_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h);
+static int cgm_countercb(cdCanvas *canvas, double percent);
+static int cgm_sclmdecb(cdCanvas *canvas, short scl_mde, short *draw_mode_i, double *factor_f);
+static int cgm_vdcextcb(cdCanvas *canvas, short type, void *xmn, void *ymn, void *xmx, void *ymx);
+static int cgm_begpictcb(cdCanvas *canvas, char *pict);
+static int cgm_begpictbcb(cdCanvas *canvas);
+static int cgm_begmtfcb(cdCanvas *canvas, int *xmn, int *ymn, int *xmx, int *ymx);
+
+static cdCallbackLUA cdluacgmcb[7] = {
+{
+  -1,
+  "CD_SIZECB",
+  (cdCallback)cgm_sizecb
+},
+{
+  -1,
+  "CD_CGMCOUNTERCB",
+  (cdCallback)cgm_countercb
+},
+{
+  -1,
+  "CD_CGMSCLMDECB",
+  (cdCallback)cgm_sclmdecb
+},
+{
+  -1,
+  "CD_CGMVDCEXTCB",
+  (cdCallback)cgm_vdcextcb
+},
+{
+  -1,
+  "CD_CGMBEGPICTCB",
+  (cdCallback)cgm_begpictcb
+},
+{
+  -1,
+  "CD_CGMBEGPICTBCB",
+  (cdCallback)cgm_begpictbcb
+},
+{
+  -1,
+  "CD_CGMBEGMTFCB",
+  (cdCallback)cgm_begmtfcb
+}
+};
+
+static cdContextLUA cdluacgmctx = 
+{
+  0,
+  "CD_CGM",
+  cdContextCGM,
+  cdcgm_checkdata,
+  cdluacgmcb,
+  7
+};
+
+/***************************************************************************\
+* CGM CD_COUNTERCB.                                                         *
+\***************************************************************************/
+static int cgm_countercb(cdCanvas *canvas, double percent)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMCOUNTERCB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( percent);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMCOUNTERCB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CGM CD_BEGPICTCB.                                                         *
+\***************************************************************************/
+static int cgm_begpictcb(cdCanvas *canvas, char *pict)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMBEGPICTCB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushstring(pict);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMBEGPICTCB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+static int cgm_begmtfcb(cdCanvas *canvas, int *xmn, int *ymn, int *xmx, int *ymx)
+{
+  lua_Object func, result, xmn_l, ymn_l, xmx_l, ymx_l;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMBEGMTFCB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMBEGMTFCB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+  if (result_i == 1) {
+    lua_endblock();
+    return 1;
+  }
+
+  xmn_l = lua_getresult(2);
+  if (!lua_isnumber(xmn_l))
+    lua_error("cdPlay: CD_CGMBEGMTFCB: invalid xmn return value!");
+  *xmn = (int) lua_getnumber(xmn_l);
+
+  ymn_l = lua_getresult(3);
+  if (!lua_isnumber(ymn_l))
+    lua_error("cdPlay: CD_CGMBEGMTFCB: invalid ymn return value!");
+  *ymn = (int) lua_getnumber(ymn_l);
+
+  xmx_l = lua_getresult(4);
+  if (!lua_isnumber(xmx_l))
+    lua_error("cdPlay: CD_CGMBEGMTFCB: invalid xmx return value!");
+  *xmx = (int) lua_getnumber(xmx_l);
+
+  ymx_l = lua_getresult(5);
+  if (!lua_isnumber(ymx_l))
+    lua_error("cdPlay: CD_CGMBEGMTFCB: invalid ymx return value!");
+  *ymx = (int) lua_getnumber(ymx_l);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CGM CD_BEGPICTBCB.                                                         *
+\***************************************************************************/
+static int cgm_begpictbcb(cdCanvas *canvas)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMBEGPICTBCB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMBEGPICTBCB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CGM CD_SIZECB.                                                            *
+\***************************************************************************/
+static int cgm_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_SIZECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( w);
+  lua_pushnumber( h);
+  lua_pushnumber( mm_w);
+  lua_pushnumber( mm_h);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_SIZECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CGM CD_SCLMDE.                                                            *
+\***************************************************************************/
+static int cgm_sclmdecb(cdCanvas *canvas, short scl_mde, short *draw_mode_i, double *factor_f)
+{
+  lua_Object func, result, draw_mode, factor;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMSCLMDECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( scl_mde);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMSCLMDECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+  if (result_i == 1) {
+    lua_endblock();
+    return 1;
+  }
+
+  draw_mode = lua_getresult(2);
+  if (!lua_isnumber(draw_mode))
+    lua_error("cdPlay: CD_CGMSCLMDECB: invalid draw_mode return value!");
+  *draw_mode_i = (short) lua_getnumber(draw_mode);
+
+  factor = lua_getresult(3);
+  if (!lua_isnumber(factor))
+    lua_error("cdPlay: CD_CGMSCLMDECB: invalid factor return value!");
+  *factor_f = (double) lua_getnumber(factor);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CGM CD_VDCEXTCB.                                                          *
+\***************************************************************************/
+static int cgm_vdcextcb(cdCanvas *canvas, short type, void *xmn, void *ymn, void *xmx, void *ymx)
+{
+  lua_Object func, result, xmn_l, ymn_l, xmx_l, ymx_l;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluacgmcb[CD_CGMVDCEXTCB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_CGMVDCEXTCB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+  if (result_i == 1) {
+    lua_endblock();
+    return 1;
+  }
+
+  xmn_l = lua_getresult(2);
+  if (!lua_isnumber(xmn_l))
+    lua_error("cdPlay: CD_CGMVDCEXTCB: invalid xmn return value!");
+  if (type == 1) *((float *) xmn) = (float) lua_getnumber(xmn_l);
+  else *((int *) xmn) = (int) lua_getnumber(xmn_l);
+
+  ymn_l = lua_getresult(3);
+  if (!lua_isnumber(ymn_l))
+    lua_error("cdPlay: CD_CGMVDCEXTCB: invalid ymn return value!");
+  if (type == 1) *((float *) ymn) = (float) lua_getnumber(ymn_l);
+  else *((int *) ymn) = (int) lua_getnumber(ymn_l);
+
+  xmx_l = lua_getresult(4);
+  if (!lua_isnumber(xmx_l))
+    lua_error("cdPlay: CD_CGMVDCEXTCB: invalid xmx return value!");
+  if (type == 1) *((float *) xmx) = (float) lua_getnumber(xmx_l);
+  else *((int *) xmx) = (int) lua_getnumber(xmx_l);
+
+  ymx_l = lua_getresult(5);
+  if (!lua_isnumber(ymx_l))
+    lua_error("cdPlay: CD_CGMVDCEXTCB: invalid ymx return value!");
+  if (type == 1) *((float *) ymx) = (float) lua_getnumber(ymx_l);
+  else *((int *) ymx) = (int) lua_getnumber(ymx_l);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CD_DBUFFER.                                                                 *
+\***************************************************************************/
+static void *cddbuf_checkdata(int param)
+{
+  canvas_t *canvas_p;
+  lua_Object canvas;
+  int canvas_tag = (int)lua_getnumber(lua_getglobal(CANVAS_TAG));
+
+  canvas = lua_getparam(param);
+  if (lua_isnil(canvas))
+    lua_error("cdCreateCanvas CD_DBUFFER: data is a NIL canvas!");
+
+  if (lua_tag(canvas) != canvas_tag)
+    lua_error("cdCreateCanvas CD_DBUFFER: data should be of type canvas_tag!");
+
+  canvas_p = (canvas_t *) lua_getuserdata(canvas);
+  if (!canvas_p->cd_canvas)
+    lua_error("cdCreateCanvas CD_DBUFFER: data is a killed canvas!");
+
+  return canvas_p->cd_canvas;
+}
+
+static cdContextLUA cdluadbufctx = 
+{
+  0,
+  "CD_DBUFFER",
+  cdContextDBuffer,
+  cddbuf_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_IMAGE.                                                                 *
+\***************************************************************************/
+static void *cdimage_checkdata(int param)
+{                
+  int image_tag;
+  image_t *image_p;
+  lua_Object image = lua_getparam(param);
+  if (lua_isnil(image))
+    lua_error("cdCreateCanvas CD_IMAGE: data is a NIL image!");
+
+  image_tag = (int)lua_getnumber(lua_getglobal(IMAGE_TAG));
+  if (lua_tag(image) != image_tag)
+    lua_error("cdCreateCanvas CD_IMAGE: data should be of type image_tag!");
+
+  image_p = (image_t *) lua_getuserdata(image);
+  if (!image_p->cd_image)
+    lua_error("cdCreateCanvas CD_IMAGE: data is a killed image!");
+
+  return image_p->cd_image;
+}
+
+static cdContextLUA cdluaimagectx = 
+{
+  0,
+  "CD_IMAGE",
+  cdContextImage,
+  cdimage_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_IMAGERGB.                                                              *
+\***************************************************************************/
+static void *cdimagergb_checkdata(int param)
+{
+  lua_Object imagergb;
+  static char data_s[50];
+
+  imagergb = lua_getparam(param);
+  if (lua_isnil(imagergb))
+    lua_error("cdCreateCanvas CD_IMAGERGB: data is a NIL imagergb!");
+
+  if (lua_isstring(imagergb))
+  {
+    char* str = lua_getstring(imagergb);
+    strcpy(data_s, str);
+  }
+  else
+  {
+    lua_Object res;
+    int bitmap_tag = (int)lua_getnumber(lua_getglobal(BITMAP_TAG));
+
+    if (lua_tag(imagergb) == bitmap_tag)
+    {
+      bitmap_t *imagergb_p;
+
+      imagergb_p = (bitmap_t *) lua_getuserdata(imagergb);
+      if (!imagergb_p->image)
+        lua_error("cdCreateCanvas CD_IMAGERGB: data is a killed imagergb!");
+
+      if (imagergb_p->image->type != CD_RGB && imagergb_p->image->type != CD_RGBA)
+        lua_error("cdCreateCanvas CD_IMAGERGB: bitmap should be of type rgb or rgba!");
+
+      res = lua_getparam(param+1);
+      if (res == LUA_NOOBJECT || lua_isnil(res))
+      {
+        if (imagergb_p->image->type == CD_RGBA)
+          sprintf(data_s, "%dx%d %p %p %p %p -a", imagergb_p->image->w, imagergb_p->image->h,
+                                                  cdBitmapGetData(imagergb_p->image, CD_IRED), 
+                                                  cdBitmapGetData(imagergb_p->image, CD_IGREEN), 
+                                                  cdBitmapGetData(imagergb_p->image, CD_IBLUE),
+                                                  cdBitmapGetData(imagergb_p->image, CD_IALPHA));
+        else
+          sprintf(data_s, "%dx%d %p %p %p", imagergb_p->image->w, imagergb_p->image->h,
+                                            cdBitmapGetData(imagergb_p->image, CD_IRED), 
+                                            cdBitmapGetData(imagergb_p->image, CD_IGREEN), 
+                                            cdBitmapGetData(imagergb_p->image, CD_IBLUE));
+      }
+      else
+      {
+        double res_f = lua_getnumber(res);
+        if (imagergb_p->image->type == CD_RGBA)
+          sprintf(data_s, "%dx%d %p %p %p %p -r%g -a", imagergb_p->image->w, imagergb_p->image->h,
+                                                    cdBitmapGetData(imagergb_p->image, CD_IRED), 
+                                                    cdBitmapGetData(imagergb_p->image, CD_IGREEN), 
+                                                    cdBitmapGetData(imagergb_p->image, CD_IBLUE), 
+                                                    cdBitmapGetData(imagergb_p->image, CD_IALPHA), 
+                                                    res_f);
+        else
+          sprintf(data_s, "%dx%d %p %p %p -r%g", imagergb_p->image->w, imagergb_p->image->h,
+                                                cdBitmapGetData(imagergb_p->image, CD_IRED), 
+                                                cdBitmapGetData(imagergb_p->image, CD_IGREEN), 
+                                                cdBitmapGetData(imagergb_p->image, CD_IBLUE), 
+                                                res_f);
+      }
+    }
+    else
+    {
+      imagergb_t *imagergb_p;
+      int imagergb_tag = (int)lua_getnumber(lua_getglobal(IMAGERGB_TAG));
+
+      if (lua_tag(imagergb) != imagergb_tag)
+      {
+        imagergba_t *imagergba_p;
+        int imagergba_tag = (int)lua_getnumber(lua_getglobal(IMAGERGBA_TAG));
+        if (lua_tag(imagergb) != imagergba_tag)
+          lua_error("cdCreateCanvas CD_IMAGERGB: data should be of type imagergb_tag or imagergba_tag!");
+
+        imagergba_p = (imagergba_t *) lua_getuserdata(imagergb);
+        if (!(imagergba_p->red && imagergba_p->green && imagergba_p->blue))
+          lua_error("cdCreateCanvas CD_IMAGERGB: data is a killed imagergba!");
+
+        res = lua_getparam(param+1);
+        if (res == LUA_NOOBJECT || lua_isnil(res))
+        {
+          sprintf(data_s, "%dx%d %p %p %p", imagergba_p->width, imagergba_p->height,
+            imagergba_p->red, imagergba_p->green, imagergba_p->blue);
+        }
+        else
+        {
+          double res_f = lua_getnumber(res);
+          sprintf(data_s, "%dx%d %p %p %p -r%g", imagergba_p->width, imagergba_p->height,
+            imagergba_p->red, imagergba_p->green, imagergba_p->blue, res_f);
+        }
+
+        return data_s;
+      }
+
+      imagergb_p = (imagergb_t *) lua_getuserdata(imagergb);
+      if (!(imagergb_p->red && imagergb_p->green && imagergb_p->blue))
+        lua_error("cdCreateCanvas CD_IMAGERGB: data is a killed imagergb!");
+
+      res = lua_getparam(param+1);
+      if (res == LUA_NOOBJECT || lua_isnil(res))
+      {
+        sprintf(data_s, "%dx%d %p %p %p", imagergb_p->width, imagergb_p->height,
+          imagergb_p->red, imagergb_p->green, imagergb_p->blue);
+      }
+      else
+      {
+        double res_f = lua_getnumber(res);
+        sprintf(data_s, "%dx%d %p %p %p -r%g", imagergb_p->width, imagergb_p->height,
+          imagergb_p->red, imagergb_p->green, imagergb_p->blue, res_f);
+      }
+    }
+  }
+
+  return data_s;
+}
+
+static cdContextLUA cdluaimagergbctx = 
+{
+  0,
+  "CD_IMAGERGB",
+  cdContextImageRGB,
+  cdimagergb_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_DXF.                                                                   *
+\***************************************************************************/
+static void *cddxf_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_DXF: data should be of type string!");
+  
+  return lua_getstring(data);
+}
+
+static cdContextLUA cdluadxfctx = 
+{
+  0,
+  "CD_DXF",
+  cdContextDXF,
+  cddxf_checkdata
+};
+
+/***************************************************************************\
+* CD_DGN.                                                                   *
+\***************************************************************************/
+static void *cddgn_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_DGN: data should be of type string!");
+  
+  return lua_getstring(data);
+}
+
+static cdContextLUA cdluadgnctx = 
+{
+  0,
+  "CD_DGN",
+  cdContextDGN,
+  cddgn_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_WMF.                                                                   *
+\***************************************************************************/
+static void *cdwmf_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_WMF: data should be of type string!");
+  
+  return lua_getstring(data);
+}
+
+static int wmf_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h);
+
+static cdCallbackLUA cdluawmfcb[1] = 
+{{
+  -1,
+  "CD_SIZECB",
+  (cdCallback)wmf_sizecb
+}};
+
+static cdContextLUA cdluawmfctx = 
+{
+  0,
+  "CD_WMF",
+  cdContextWMF,
+  cdwmf_checkdata,
+  cdluawmfcb,
+  1
+};
+
+/***************************************************************************\
+* WMF CD_SIZECB.                                                            *
+\***************************************************************************/
+static int wmf_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluawmfcb[CD_SIZECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( w);
+  lua_pushnumber( h);
+  lua_pushnumber( mm_w);
+  lua_pushnumber( mm_h);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_SIZECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CD_EMF.                                                                   *
+\***************************************************************************/
+static void *cdemf_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_EMF: data should be of type string!");
+  
+  return lua_getstring(data);
+}
+
+static int emf_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h);
+
+static cdCallbackLUA cdluaemfcb[1] = 
+{{
+  -1,
+  "CD_SIZECB",
+  (cdCallback)emf_sizecb
+}};
+
+static cdContextLUA cdluaemfctx = 
+{
+  0,
+  "CD_EMF",
+  cdContextEMF,
+  cdemf_checkdata,
+  cdluaemfcb,
+  1
+};
+
+/***************************************************************************\
+* EMF CD_SIZECB.                                                            *
+\***************************************************************************/
+static int emf_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluaemfcb[CD_SIZECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( w);
+  lua_pushnumber( h);
+  lua_pushnumber( mm_w);
+  lua_pushnumber( mm_h);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_SIZECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CD_METAFILE.                                                              *
+\***************************************************************************/
+static void *cdmetafile_checkdata(int param)
+{
+  lua_Object data;
+
+  data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_METAFILE: data should be of type string!");
+
+  return lua_getstring(data);
+}
+
+static int metafile_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h);
+
+static cdCallbackLUA cdluamfcb[1] = 
+{{
+  -1,
+  "CD_SIZECB",
+  (cdCallback)metafile_sizecb
+}};
+
+static cdContextLUA cdluamfctx = 
+{
+  0,
+  "CD_METAFILE",
+  cdContextMetafile,
+  cdmetafile_checkdata,
+  cdluamfcb,
+  1
+};
+
+/***************************************************************************\
+* METAFILE CD_SIZECB.                                                       *
+\***************************************************************************/
+static int metafile_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluamfcb[CD_SIZECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( w);
+  lua_pushnumber( h);
+  lua_pushnumber( mm_w);
+  lua_pushnumber( mm_h);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_SIZECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CD_PS.                                                                    *
+\***************************************************************************/
+static void *cdps_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_PS: data should be of type string!");
+
+  return lua_getstring(data);
+}
+
+static cdContextLUA cdluapsctx = 
+{
+  0,
+  "CD_PS",
+  cdContextPS,
+  cdps_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_PRINTER.                                                               *
+\***************************************************************************/
+static void *cdprinter_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_PRINTER: data should be of type string!");
+
+  return lua_getstring(data);
+}
+
+static cdContextLUA cdluaprinterctx = 
+{
+  0,
+  "CD_PRINTER",
+  cdContextPrinter,
+  cdprinter_checkdata,
+  NULL,
+  0
+};
+
+/***************************************************************************\
+* CD_CLIPBOARD.                                                             *
+\***************************************************************************/
+static void *cdclipboard_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_CLIPBOARD: data should be of type string!");
+
+  return lua_getstring(data);
+}
+
+static int clipboard_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h);
+
+static cdCallbackLUA cdluaclipboardcb[1] = 
+{{
+  -1,
+  "CD_SIZECB",
+  (cdCallback)clipboard_sizecb
+}};
+
+static cdContextLUA cdluaclipboardctx = 
+{
+  0,
+  "CD_CLIPBOARD",
+  cdContextClipboard,
+  cdclipboard_checkdata,
+  cdluaclipboardcb,
+  1
+};
+
+/***************************************************************************\
+* CLIPBOARD CD_SIZECB.                                                      *
+\***************************************************************************/
+static int clipboard_sizecb(cdCanvas *canvas, int w, int h, double mm_w, double mm_h)
+{
+  lua_Object func, result;
+  int result_i;
+
+  lua_beginblock();
+  func = lua_getref(cdluaclipboardcb[CD_SIZECB].lock);
+
+  cdlua_pushcanvas(canvas);
+  lua_pushnumber( w);
+  lua_pushnumber( h);
+  lua_pushnumber( mm_w);
+  lua_pushnumber( mm_h);
+  lua_callfunction(func);
+
+  result = lua_getresult(1);
+  if (!lua_isnumber(result))
+    lua_error("cdPlay: CD_SIZECB: invalid return value!");
+  result_i = (int) lua_getnumber(result);
+
+  lua_endblock();
+  
+  return result_i;
+}
+
+/***************************************************************************\
+* CD_NATIVEWINDOW.                                                          *
+\***************************************************************************/
+static void *cdnativewindow_checkdata(int param)
+{
+  lua_Object data = lua_getparam(param);
+
+#ifdef WIN32
+  if (!lua_isuserdata(data))
+    lua_error("cdCreateCanvas CD_NATIVEWINDOW: data should be of type userdata!");
+
+  return lua_getuserdata(data);
+#else
+  if (!lua_isstring(data))
+    lua_error("cdCreateCanvas CD_NATIVEWINDOW: data should be of type string!");
+
+  return lua_getstring(data);
+#endif
+}
+
+static cdContextLUA cdluanativewindowctx = 
+{
+  0,
+  "CD_NATIVEWINDOW",
+  cdContextNativeWindow,
+  cdnativewindow_checkdata,
+  NULL,
+  0
+};
+
+static void cdlua_getscreensize(void)
+{
+  int width;
+  int height;
+  double mm_width;
+  double mm_height;
+
+  if (lua_getparam(1) != LUA_NOOBJECT)
+    lua_error("cdGetScreenSize: too many parameters!");
+
+  cdGetScreenSize(&width, &height, &mm_width, &mm_height);
+  lua_pushnumber( width);
+  lua_pushnumber( height);
+  lua_pushnumber( mm_width);
+  lua_pushnumber( mm_height);
+}
+
+static void cdlua_getscreencolorplanes(void)
+{
+ int L_result = cdGetScreenColorPlanes();
+ lua_pushnumber(L_result);
+}
+
+static void cdlua_usecontextplus(void)
+{
+  int use = (int)luaL_check_number(1);
+  int L_result = cdUseContextPlus(use);
+  lua_pushnumber(L_result);
+}
+
+/*******************************************************************************/
+
+void cdlua_initdrivers(void)
+{
+  cdlua_register("cdGetScreenColorPlanes",cdlua_getscreencolorplanes);
+  cdlua_register("cdGetScreenSize",cdlua_getscreensize);
+
+  cdlua_register("cdUseContextPlus",cdlua_usecontextplus);
+
+  /* from GDI+ addicional polygon modes */
+  cdlua_pushnumber(CD_SPLINE, "CD_SPLINE");
+  cdlua_pushnumber(CD_FILLSPLINE, "CD_FILLSPLINE");
+  cdlua_pushnumber(CD_FILLGRADIENT, "CD_FILLGRADIENT");
+
+  cdlua_addcontext(&cdluaimagectx);
+  cdlua_addcontext(&cdluaimagergbctx);
+  cdlua_addcontext(&cdluadxfctx);
+  cdlua_addcontext(&cdluadgnctx);
+  cdlua_addcontext(&cdluacgmctx);
+  cdlua_addcontext(&cdluamfctx);
+  cdlua_addcontext(&cdluapsctx);
+  cdlua_addcontext(&cdluaclipboardctx);
+  cdlua_addcontext(&cdluanativewindowctx);
+  cdlua_addcontext(&cdluaprinterctx);
+  cdlua_addcontext(&cdluawmfctx);
+  cdlua_addcontext(&cdluaemfctx);
+  cdlua_addcontext(&cdluadbufctx);
+}
+