Canvas

Computer Graphics Metafile Driver

#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+#include <cdlua.h>
void main(void)
+{
+  lua_State *L = lua_open();
+
+  luaopen_string(L);
+  luaopen_math(L);
+  luaopen_io(L);  
+
+  cdlua_open(L);
+
+  lua_dofile("myprog.lua");
+  
+  cdlua_close(L);
+  lua_close(L);
+}
local cdlua_open = package.loadlib("cdlua51.dll", "cdlua_open")
+cdlua_open()
"./lib?51.so;"    [in UNIX]
+
+".\\?51.dll;"     [in Windows]
+
cdXxx  -> cd.Xxx
+wdXxx  -> cd.wXxx
+CD_XXX -> cd.XXX
cdCanvas* cdlua_checkcanvas(lua_State* L, int pos);
+void cdlua_pushcanvas(lua_State* L, cdCanvas* canvas);
int cdluaim_open(lua_State* L); [in C] [for Lua 5]
bitmap:imImageCreate() -> image: imImage [in Lua] 
+
image:cdCreateBitmap() -> bitmap: cdBitmap [in Lua]
image:cdInitBitmap() -> bitmap: cdBitmap [in Lua]
image:cdCanvasPutImageRect(canvas: cdCanvas, x: number, y: number, w: number, h: number, xmin: number, xmax: number, ymin: number, ymax: number) [in Lua] 
image:wdCanvasPutImageRect(canvas: cdCanvas, x: number, y: number, w: number, h: number, xmin: number, xmax: number, ymin: number, ymax: number) [in Lua]     
image:cdCanvasGetImage(canvas: cdCanvas, x: number, y: number) [in Lua]     
image:cdCreateCanvas([res: number]) -> canvas: cdCanvas [in Lua]    
CVSROOT=:pserver:anonymous@cvs.luaforge.net:/cvsroot/cdlib
\mylibs\
+        iup\
+            bin\
+            html\
+            include\
+            lib\Linux26
+            lib\vc7
+            src
+        cd\
+        im\
+        lua5\
1) "-I/mylibs/iup/include" to find include files
+2) "-L/mylibs/iup/lib/Linux26" to find library files
+3) "-liup" to specify the library files
"filename [widthxheight] [resolution] [-t] -p[precision]" or in C style "%s %gx%g %g %s"
CD_SIZECB 
CD_COUNTERCB - int(*cdcgmcountercb)(cdContext *driver, double 
+  percent) - 
 - int(*cdcgmsclmdecb)(cdContext 
+  *driver, short scl_mde, short *drw_mode, double *factor)
 - int(*cdcgmvdcextcb)(cdContext 
+  *driver, short type, void *xmn, void *ymn, void *xmx, void *ymx)
 - int(*cdcgmbegpictcb)(cdContext 
+  *driver, char *pict)
 - int(*cdcgmbegpictbcb)(cdContext 
+  *driver)
CD_CLIP
CD_BEZIER
%dx%d %g"
"filename [widthxheight resolution]" or in C use "%s %gx%g %g"
"filename [widthxheight] [resolution] [-f] [-sseedfile]"   or in C "%s %gx%g %g %s"
CD_CLIP
CD_BEZIER
"filename [widthxheight] [resolution]"    or in C "%s %gx%g %g"
CD_FILL

+  CD_CLOSED_LINES
CD_CLIP
CD_BEZIER
"filename widthxheight"     or in C "%s %dx%d"
CD_FILLSPLINE

+  CD_FILLGRADIENT


+  CD_SPLINE
CD_FILLSPLINE
CD_FILLGRADIENT
GRADIENTCOLOR
cdVertex
cdEnd
"widthxheight [r g b] -r[resolution]"      in C "%dx%d %p %p %p -r%g"
+or
+"widthxheight [r g b a] -r[resolution] -a"    in C "%dx%d %p %p %p %p -r%g -a"
"filename [widthxheight resolution]" or in C use "%s %gx%g %g"
%p 
+    %lu
"filename -p[paper] -w[width] -h[height] -s[resolution] [-o]"
+or in C
+"%s -p%d -w%g -h%g -s%d -o"
CD_A0
CD_A1
CD_A2
CD_A3
CD_A4
CD_A5
CD_LETTER

+  CD_LEGAL
Courier, Courier-Bold, Courier-Oblique, Courier-BoldOblique,
+Helvetica, Helvetica-Bold, Helvetica-Oblique, Helvetica-BoldOblique,
+Times-Roman, Times-Bold, Times-Italic, Times-BoldItalic,
+Symbol, 
+ZapfDingbats
"[resolution]" or in C use "%lg"
"name [-d]"    or in C style "%s -d"
"filename -p[paper] -w[width] -h[height] -l[left] -r[right] -b[bottom] -t[top] -s[resolution] [-e] [-g] [-o] [-1] d[margin]"

+or in C

+"%s -p%d -w%g -h%g -l%g -r%g -b%g -t%g -s%d -e -o -1 -g -d%g"
CD_A0
CD_A1
CD_A2
CD_A3
CD_A4
CD_A5
CD_LETTER

+  CD_LEGAL
XOR
NOT_XOR
NOT_XOR
XOR
"filename widthxheight [resolution]"     or in C "%s 
+    %dx%d %g"

+  CD_BEZIER

+  CD_BEZIER
long int cdCanvasForeground(cdCanvas* canvas, long int color); [in C]
+void cdCanvasSetForeground(cdCanvas* canvas, long int color); [in C]
+
+canvas:Foreground(color: lightuserdata) -> (old_color: lightuserdata) [in Lua]
+canvas:SetForeground(color: lightuserdata) [in Lua]
CD_BLACK
CD_QUERY 
long int cdCanvasBackground(cdCanvas* canvas, long int color); [in C]
+void cdCanvasSetBackground(cdCanvas* canvas, long int color); [in C]
+
+canvas:Background(color: lightuserdata) -> (old_color: lightuserdata) [in Lua]
+canvas:SetBackground(color: lightuserdata) [in Lua]
 
CD_WHITE
CD_QUERY 
int cdCanvasWriteMode(cdCanvas* canvas, int mode); [in C]
+
+canvas:WriteMode(mode: number) -> (old_mode: number) [in Lua]
CD_REPLACE
CD_XOR
CD_NOT_XOR
CD_REPLACE
CD_QUERY 
void cdCanvasGetImageRGB(cdCanvas* canvas, unsigned char *r, 
+                   unsigned char *g, 
+                   unsigned char *b, 
+                   int x, int y, int w, int h); [in C]
+
+canvas:GetImageRGB(imagergb: cdImageRGB; x, y: number) [in Lua]
(i,j)

+          (j*w+i)
(0,0)
(w-1,h-1)
void cdCanvasPutImageRectRGB(cdCanvas* canvas, int iw, int ih, 
+                       const unsigned char *r, 
+                       const unsigned char *g, 
+                       const unsigned char *b, 
+                       int x, int y, int w, int h, 
+                       int xmin, int xmax, int ymin, int ymax); [in C]
+void wdCanvasPutImageRectRGB(cdCanvas* canvas, int iw, int ih, 
+                       const unsigned char *r, 
+                       const unsigned char *g, 
+                       const unsigned char *b, 
+                       double x, double y, double w, double h, 
+                       int xmin, int xmax, int ymin, int ymax); (WC) [in C]
+
+canvas:PutImageRectRGB(imagergb: cdImageRGB; x, y, w, h, xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wPutImageRectRGB(imagergb: cdImageRGB; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [in Lua]
(i,j)
(j*iw+i)
(0,0)
(iw-1,ih-1)
void cdCanvasPutImageRectRGBA(cdCanvas* canvas, int iw, int ih, 
+                        const unsigned char *r, 
+                        const unsigned char *g, 
+                        const unsigned char *b, 
+                        const unsigned char *a, 
+                        int x, int y, int w, int h, 
+                        int xmin, int xmax, int ymin, int ymax); [in C]
+void wdCanvasPutImageRectRGBA(cdCanvas* canvas, int iw, int ih, 
+                        const unsigned char *r, 
+                        const unsigned char *g, 
+                        const unsigned char *b, 
+                        const unsigned char *a, 
+                        double x, double y, double w, double h, 
+                        int xmin, int xmax, int ymin, int ymax); (WC) [in C]
+
+canvas:PutImageRectRGBA(imagergba: cdImageRGBA; x, y, w, h, xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wPutImageRectRGBA(imagergba: cdImageRGBA; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [in Lua]
result=(source * alpha + destiny * (255 - alpha))/255
void cdCanvasPutImageRectMap(cdCanvas* canvas, int iw, int ih, 
+                       const unsigned char *index, 
+                       const long int *colors, 
+                       int x, int y, int w, int h, 
+                       int xmin, int xmax, int ymin, int ymax); [in C]
+void wdCanvasPutImageRectMap(cdCanvas* canvas, int iw, int ih, 
+                       const unsigned char *index, 
+                       const long int *colors, 
+                       double x, double y, double w, double h, 
+                       int xmin, int xmax, int ymin, int ymax); (WC) [in C]
+
+canvas:PutImageRectMap(imagemap: cdImageMap; palette: cdPalette; x, y, w, h, xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wPutImageRectMap(imagemap: cdImageMap; palette: cdPalette; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [in Lua]
void cdRGB2Map(int iw, int ih, 
+               const unsigned char *r, 
+               const unsigned char *g, 
+               const unsigned char *b, 
+               unsigned char *index, 
+               int pal_size, long *color); [in C]
+
+cd.RGB2Map(imagergb: cdImageRGB, imagemap: cdImageMap, palette: cdPalette) [in Lua]
cdBitmap:
+  int w      /* image width */
+  int h      /* image heigth */
+  int type   /* image type: CD_RGBA, CD_RGB or CD_MAP */
cdBitmap* cdCreateBitmap(int w, int h, int type); [in C]
+
+cd.CreateBitmap(w, h, type: number) -> (bitmap: cdBitmap) [in Lua]
cdBitmap* cdInitBitmap(int w, int h, int type, ...); [in C]
+
+[There is no equivalent in Lua]
CD_RGBA - (unsigned char* red, unsigned char* green, unsigned char* blue, unsigned char* alpha)
+CD_RGB - (unsigned char* red, unsigned char* green, unsigned char* blue)
+CD_MAP - (unsigned char* index, lont int* colors)
void cdKillBitmap(cdBitmap* image); [in C]
+
+cd.KillBitmap(bitmap: cdBitmap) [in Lua]
unsigned char* cdBitmapGetData(cdBitmap* image, int dataptr); [in C]
+
+cd.BitmapGetData(bitmap: cdBitmap; dataptr: number) -> (data: cdImageChannel) [in Lua]
CD_IRED - red component of an RGB image. cdImageChannel in Lua.
+CD_IGREEN - green component of an RGB image. cdImageChannel in Lua.
+CD_IBLUE - blue component of an RGB image. cdImageChannel in Lua.
+CD_IALPHA - alpha component of an RGBA image. cdImageChannel in Lua.
+CD_INDEX - indices of a MAP image. cdImageChannel in Lua.
+CD_COLORS - color table of a MAP image. In this case, a type conversion must be made to (long int*).  cdPalette in Lua.
void cdBitmapSetRect(cdBitmap* image, int xmin, int xmax, int ymin, int ymax); [in C]
+
+cd.BitmapSetRect(bitmap: cdBitmap; xmin, xmax, ymin, ymax: number) [in Lua]
void cdCanvasPutBitmap(cdCanvas* canvas, cdBitmap* image, int x, int y, int w, int h); [in C]
+void wdCanvasPutBitmap(cdCanvas* canvas, cdBitmap* image, double x, double y, double w, double h); (WC) [in C]
+
+canvas:PutBitmap(image: cdBitmap; x, y, w, h: number) [in Lua]
+canvas:wPutBitmap(bitmap: cdBitmap; x, y, w, h: number) (WC) [in Lua]
void cdCanvasGetBitmap(cdCanvas* canvas, cdBitmap* image, int x, int y); [in C]
+
+canvas:GetBitmap(bitmap: cdBitmap; x, y: number) [in Lua]
void cdBitmapRGB2Map(cdBitmap* image_rgb, cdBitmap* image_map); [in C]
+
+cd.BitmapRGB2Map(bitmap_rgb: cdBitmap, bitmap_map: cdBitmap) [in Lua]
cd.CreateImageRGB(width, height: number) -> (imagergb: cdImageRGB)
cd.KillImageRGB(imagergb: cdImageRGB)
cd.CreateImageRGBA(width, height: number) -> (imagergba: cdImageRGBA)
cd.KillImageRGBA(imagergba: cdImageRGBA)
cd.CreateImageMap(width, height: number) -> (imagemap: cdImageMap)
cd.KillImageMap(imagemap: cdImageMap)
image = cd.CreateBitmap(100, 200)
+...
+image.r[y*100 + x] = 255
+image.g[y*100 + x] = 128
+image.b[y*100 + x] = 0
+...
+green = image.g[y*100 + x] -- it will return 128
r - red channel of RGB or RGBA images.
+g - gree channel of RGB or RGBA images.
+b - blue channel of RGB or RGBA images.
+a - alpha channel of RGBA images.
+m - indices channel of MAP images (valid only for cdBitmap objects).
+p - colors table of MAP images (valid only for cdBitmap objects). It is a cdPalette object.
int cdCanvasClip(cdCanvas* canvas, int mode); [in C]
+
+canvas:Clip(mode: number) -> (old_mode: number) [in Lua]
void cdCanvasClipArea(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax); [in C]
+void cdfCanvasClipArea(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); [in C]
+void wdCanvasClipArea(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); (WC) [in C]
+
+canvas:ClipArea(xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wClipArea(xmin, xmax, ymin, ymax: number) (WC) [in Lua]
int cdCanvasGetClipArea(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax); [in C]
+int cdfCanvasGetClipArea(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax); [in C]
+int wdCanvasGetClipArea(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax); (WC) [in C]
+
+canvas:GetClipArea() -> (xmin, xmax, ymin, ymax, status: number) [in Lua]
+canvas:wGetClipArea() -> (xmin, xmax, ymin, ymax, status: number) (WC) [in Lua]
CD_RED          = (255,  0,  0)
+CD_DARK_RED     = (128,  0,  0)
+CD_GREEN        = (0  ,255,  0)
+CD_DARK_GREEN   = (  0,128,  0)
+CD_BLUE         = (  0,  0,255)
+CD_DARK_BLUE    = (  0,  0,128)
+CD_YELLOW       = (255,255,  0)
+CD_DARK_YELLOW  = (128,128,  0)
+CD_MAGENTA      = (255,  0,255)
+CD_DARK_MAGENTA = (128,  0,128)
+CD_CYAN         = (  0,255,255)
+CD_DARK_CYAN    = (  0,128,128)
+CD_WHITE        = (255,255,255)
+CD_BLACK        = (  0,  0 , 0)
+CD_DARK_GRAY    = (128,128,128)
+CD_GRAY         = (192,192,192)
+
long int cdEncodeColor(unsigned char red, unsigned char green, unsigned char blue) [in C]
+
+cd.EncodeColor(r, g, b: number) -> (old_color: lightuserdata) [in Lua]
0x00RRGGBB
RR 
GG
BB
void cdDecodeColor(long int color, unsigned char *red, unsigned char *green, unsigned char *blue) [in C]
+
+cd.DecodeColor(color: lightuserdata) -> (r, g, b: number) [in Lua]
long int cdEncodeAlpha(long int color, unsigned char alpha) [in C]
+
+cd.EncodeAlpha(color: lightuserdata, alpha: number) -> (color: lightuserdata) [in Lua]
unsigned char cdDecodeAlpha(long int color) [in C]
+
+cd.DecodeAlpha(color: lightuserdata) -> (a: number) [in Lua]
unsigned char cdAlpha(long int color); [in C]
+
+cd.Alpha(color: lightuserdata) -> (r: number) [in Lua]
unsigned char cdRed(long int color); [in C]
+
+cd.Red(color: lightuserdata) -> (r: number) [in Lua]
unsigned char cdGreen(long int color); [in C]
+
+cd.Green(color: lightuserdata) -> (g: number) [in Lua]
unsigned char cdBlue(long int color); [in C]
+
+cd.Blue(color: lightuserdata) -> (b: number) [in Lua]
int cdCanvasGetColorPlanes(cdCanvas* canvas); [in C]
+
+canvas:GetColorPlanes() -> (bpp: number) [in Lua]
void cdCanvasPalette(cdCanvas* canvas, int n, const long int *color, int mode); [in C]
+
+canvas:Palette(palette: cdPalette; mode: number) [in Lua]

+          n
CD_FORCE 
CD_POLITE
CD_FORCE
CD_POLITE
cd.CreatePalette(size: number) -> (palette: cdPalette) [in Lua Only]
cd.KillPalette(palette: cdPalette) [in Lua Only]
palette[index] = cd.EncodeColor(r, g, b)
+count = #palette
+...
+color = palette[index]
+r, g, b = cd.DecodeColor(color)
void cdCanvasClear(cdCanvas* canvas); [in C]
+
+canvas:Clear() [in Lua]
void cdCanvasFlush(cdCanvas* canvas); [in C]
+    
+canvas:Flush() [in Lua]
cdState* cdCanvasSaveState(cdCanvas* canvas); [in C]
+    
+canvas:SaveState() -> (state: cdState) [in Lua]
void cdCanvasRestoreState(cdCanvas* canvas, cdState* state); [in C]
+    
+canvas:RestoreState(state: cdState) [in Lua]
void cdReleaseState(cdState* state); [in C]
+
+cd.ReleaseState(state: cdState) [in Lua]
void cdCanvasSetAttribute(cdCanvas* canvas, const char* name, char* data); [in C]
+    
+canvas:SetAttribute(name, data: string) [in Lua]
void cdCanvasSetfAttribute(cdCanvas* canvas, const char* name, const char* format, ...); [in C]
+    
+[There is no equivalent in Lua]
char* cdCanvasGetAttribute(cdCanvas* canvas, const char* name); [in C]
+    
+canvas:SetAttribute(name: string) -> (data: string) [in Lua]
void cdCanvasGetSize(cdCanvas* canvas, int *width, int *height, double *width_mm, double *height_mm); [in C]
+
+canvas:GetSize() -> (width, height, mm_width, mm_height: number) [in Lua]
int cdCanvasUpdateYAxis(cdCanvas* canvas, int *y); [in C]
+double cdfCanvasUpdateYAxis(cdCanvas* canvas, double *y); [in C]
+int cdCanvasInvertYAxis(cdCanvas* canvas, int y); [in C]
+double cdfCanvasInvertYAxis(cdCanvas* canvas, double y); [in C]
+
+canvas:UpdateYAxis(yc: number) -> (yr: number) [in Lua]
+canvas:InvertYAxis(yc: number) -> (yr: number) [in Lua]
void cdCanvasMM2Pixel(cdCanvas* canvas, double mm_dx, double mm_dy, int *dx, int *dy); [in C]
+void cdfCanvasMM2Pixel(cdCanvas* canvas, double mm_dx, double mm_dy, double *dx, double *dy); [in C]
+
+canvas:MM2Pixel(mm_dx, mm_dy: number) -> (dx, dy: number) [in Lua]
+canvas:fMM2Pixel(mm_dx, mm_dy: number) -> (dx, dy: number) [in Lua]
void cdCanvasPixel2MM(cdCanvas* canvas, int dx, int dy, double *mm_dx, double *mm_dy); [in C]
+void cdfCanvasPixel2MM(cdCanvas* canvas, double dx, double dy, double *mm_dx, double *mm_dy); [in C]
+
+canvas:Pixel2MM(dx, dy: number) -> (mm_dx, mm_dy: number) [in Lua]
+canvas:fPixel2MM(dx, dy: number) -> (mm_dx, mm_dy: number) [in Lua]
void cdCanvasOrigin(cdCanvas* canvas, int x, int y); [in C]
+void cdfCanvasOrigin(cdCanvas* canvas, double x, double y); [in C]
+
+canvas:Origin(x, y: number) [in Lua]
+canvas:fOrigin(x, y: number) [in Lua]
void cdCanvasGetOrigin(cdCanvas* canvas, int *x, int *y); [in C]
+void cdfCanvasGetOrigin(cdCanvas* canvas, double *x, double *y); [in C]
+
+canvas:GetOrigin() -> (x, y: number) [in Lua]
+canvas:fGetOrigin() -> (x, y: number) [in Lua]
void cdCanvasTransform(cdCanvas* canvas, const double* matrix); [in C]
+
+canvas:Transform(matrix: table) [in Lua]
|x'|   |sx*cos(angle)    -sin(angle)  dx|   |x|                     |0   2   4| 
+|y'| = |   sin(angle)  sy*cos(angle)  dy| * |y|      with indices   |1   3   5|
+                                            |1|
double* cdCanvasGetTransform(cdCanvas* canvas); [in C]
+
+canvas:GetTransformation() -> (matrix: table) [in Lua]
void cdCanvasTransforMultiply(cdCanvas* canvas, const double* matrix); [in C]
+
+canvas:TransformMultiply(matrix: table) [in Lua]
void cdCanvasTransformTranslate(cdCanvas* canvas, double dx, double dy); [in C]
+
+canvas:TransformTranslate(dx, dy: number) [in Lua]
void cdCanvasTransformScale(cdCanvas* canvas, double sx, double sy); [in C]
+
+canvas:TransformScale(sx, sy: number) [in Lua]
void cdCanvasTransformRotate(cdCanvas* canvas, double angle); [in C]
+
+canvas:TransformRotate(angle: number) [in Lua]
void cdCanvasTransformPoint(cdCanvas* canvas, int x, int y, int *tx, int *ty); [in C]
+void cdfCanvasTransformPoint(cdCanvas* canvas, double x, double y, double *tx, double *ty); [in C]
+
+canvas:TransformPoint(x, y: number) -> (tx, ty: number) [in Lua]
+canvas:fTransformPoint(x, y: number) -> (tx, ty: number) [in Lua]
Filled Polygons
void cdCanvasBox(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax); [in C]
+void cdfCanvasBox(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); [in C]
+void wdCanvasBox(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); (WC) [in C]
+
+canvas:Box(xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:fBox(xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wBox(xmin, xmax, ymin, ymax: number) (WC) [in Lua]
void cdCanvasSector(cdCanvas* canvas, int xc, int yc, int w, int h, double angle1, double angle2); [in C]
+void cdfCanvasSector(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); [in C]
+void wdCanvasSector(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); (WC) [in C]
+
+canvas:Sector(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:fSector(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:wSector(xc, yc, w, h, angle1, angle2: number) (WC) [in Lua]
rangle = 
+  atan2((h/2
void cdCanvasChord(cdCanvas* canvas, int xc, int yc, int w, int h, double angle1, double angle2); [in C]
+void cdfCanvasChord(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); [in C]
+void wdCanvasChord(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); (WC) [in C]
+
+canvas:Chord(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:fChord(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:wChord(xc, yc, w, h, angle1, angle2: number) (WC) [in Lua]
int cdCanvasBackOpacity(cdCanvas* canvas, int opacity); [in C]
+
+canvas:BackOpacity(opacity: number) -> (old_opacity: number) [in Lua]
int cdCanvasFillMode(cdCanvas* canvas, int mode); [in C]
+
+canvas:FillMode(mode: number) -> (old_mode: number) [in Lua]
int cdCanvasInteriorStyle(cdCanvas* canvas, int style); [in C]
+
+canvas:InteriorStyle(style: number) -> (old_style: number) [in Lua]
int cdCanvasHatch(cdCanvas* canvas, int style); [in C]
+
+canvas:Hatch(style: number) -> (old_style: number) [in Lua]
void cdCanvasStipple(cdCanvas* canvas, int w, int h, const unsigned char *fgbg) [in C]
+
+canvas:Stipple(stipple: cdStipple) [in Lua]
void wdCanvasStipple(cdCanvas* canvas, int w, int h, const unsigned char *fgbg, double w_mm, double h_mm); [in C]
+
+canvas:wStipple(stipple: cdStipple, w_mm, h_mm: number) [in Lua]
unsigned char* cdCanvasGetStipple(cdCanvas* canvas, int* w, int* h); [in C]
+
+canvas:GetStipple() - > (stipple: cdStipple) [in Lua]
void cdCanvasPattern(cdCanvas* canvas, int w, int h, const long int *color); [in C]
+
+canvas:Pattern(pattern: cdPattern) [in Lua]
void wdCanvasPattern(cdCanvas* canvas, int w, int h, const long int *color, double w_mm, double h_mm); [in C]
+
+canvas:wPattern(pattern: cdPattern, w_mm, h_mm: number) [in Lua]
long int* cdCanvasGetPattern(cdCanvas* canvas, int* w, int* h); [in C]
+
+canvas:GetPattern() - > (pattern: cdPattern) [in Lua]
cd.CreatePattern(width, height: number) -> (pattern: cdPattern)
cd.KillPattern(pattern: cdPattern)
cd.CreateStipple(width, height: number) -> (stipple: cdStipple)
cd.KillStipple(stipple: cdStipple)
pattern[y*16 + x] = cd.EncodeColor(r, g, b)
+...
+color = pattern[y*16 + x]
+r, g, b = cd.DecodeColor(color)
+...
+cd.Pattern(pattern)
cdCanvas *cdCreateCanvas(cdContext* ctx, void *data); [in C]
+
+cd.CreateCanvas(ctx: number, data: string or userdata) -> (canvas: cdCanvas) [in Lua]

+  data

+  driver/data
cdCanvas* cdCreateCanvasf(cdContext *ctx, const char* format, ...); [in C]
+
+[There is no equivalent in Lua]
void cdKillCanvas(cdCanvas *canvas); [in C]
+
+cd.KillCanvas(canvas: cdCanvas) [in Lua]
int cdCanvasActivate(cdCanvas *canvas); [in C]
+
+canvas:Activate(canvas: cdCanvas) -> (status: number) [in Lua]
void cdCanvasDeactivate(cdCanvas* canvas); [in C]
+
+canvas:Deactivate(canvas: cdCanvas) [in Lua]
int cdUseContextPlus(int use); [in C]
+
+cd.UseContextPlus(use: number) -> (old_use: number) [in Lua]
void cdInitContextPlus(void); [in C]
+
+cd.InitContextPlus() [in Lua]
cdContext* cdCanvasGetContext(cdCanvas *canvas); [in C]
+
+canvas:GetContext(canvas: cdCanvas) -> (ctx: number) [in Lua]
int cdContextCaps(cdContext* ctx); [in C]
+
+cd.ContextCaps(ctx: number) -> (caps: number) [in Lua]
int cdCanvasSimulate(cdCanvas* canvas, int mode); [in C]
+
+canvas:Simulate(mode: number) -> (old_mode: number) [in Lua]
int cdlua_open(lua_State* L); [for Lua 5]
int cdlua_close(lua_State* L); [for Lua 5]
cdCanvas* cdlua_checkcanvas(lua_State* L, int pos); [for Lua 5]
void cdlua_pushcanvas(lua_State* L, cdCanvas* canvas);
void cdCanvasLine(cdCanvas* canvas, int x1, int y1, int x2, int y2); [in C]
+void cdfCanvasLine(cdCanvas* canvas, double x1, double y1, double x2, double y2); [in C]
void wdCanvasLine(cdCanvas* canvas, double x1, double y1, double x2, double y2); (WC) [in C]
+
+canvas:Line(x1, y1, x2, y2: number) [in Lua]
+canvas:fLine(x1, y1, x2, y2: number) [in Lua]
+canvas:wLine(x1, y1, x2, y2: number) (WC) [in Lua]
(x2,y2)
Polygons and Bezier Lines
CD_CLOSED_LINES
void cdCanvasRect(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax); [in C]
void cdfCanvasRect(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); [in C]
+void wdCanvasRect(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); (WC) [in C]
+
+canvas:Rect(xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:fRect(xmin, xmax, ymin, ymax: number) [in Lua]
canvas:wRect(xmin, xmax, ymin, ymax: number) (WC) [in Lua]
void cdCanvasArc(cdCanvas* canvas, int xc, int yc, int w, int h, double angle1, double angle2); [in C]
void cdfCanvasArc(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); [in C]
+void wdCanvasArc(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2); (WC) [in C]
+
+canvas:Arc(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:fArc(xc, yc, w, h, angle1, angle2: number) [in Lua]
+canvas:wArc(xc, yc, w, h, angle1, angle2: number) (WC) [in Lua]
int cdCanvasLineStyle(cdCanvas* canvas, int style); [in C]
+
+canvas:LineStyle(style: number) -> (old_style: number) [in Lua]
CD_CUSTOM
void cdCanvasLineStyleDashes(cdCanvas* canvas, const int* dashes, int count); [in C]
+
+canvas:LineStyleDashes(dashes: table, count: number) -> (old_style: number) [in Lua]
int cdCanvasLineWidth(cdCanvas* canvas, int width); [in C]
double wdCanvasLineWidth(double width_mm); (WC) [in C]
+
+canvas:LineWidth(width: number) -> (old_width: number) [in Lua]
+canvas:wLineWidth(width_mm: number) -> (old_width_mm: number) (WC) [in Lua]
int cdCanvasLineJoin(cdCanvas* canvas, int style); [in C]
+
+canvas:LineJoin(style: number) -> (old_style: number) [in Lua]
CD_ROUND
int cdCanvasLineCap(cdCanvas* canvas, int style); [in C]
+
+canvas:LineCap(style: number) -> (old_style: number) [in Lua]
CD_CAPROUND
void cdCanvasPixel(cdCanvas* canvas, int x, int y, long int color); [in C]
+void wdCanvasPixel(cdCanvas* canvas, double x, double y, long int color); (WC) [in C]
+
+canvas:Pixel(x, y: number, color: lightuserdata) [in Lua]
+canvas:wPixel(x, y: number, color: lightuserdata) (WC) [in Lua]
void cdCanvasMark(cdCanvas* canvas, int x, int y); [in C]
+void wdCanvasMark(cdCanvas* canvas, double x, double y); (WC) [in C]
+
+canvas:Mark(x, y: number) [in Lua]
+canvas:wMark(x, y: number) (WC) [in Lua]
cdInteriorStyle(CD_SOLID);
+cdLineStyle(CD_CONTINUOUS);
+cdLineWidth(1);
int cdCanvasMarkType(cdCanvas* canvas, int type); [in C]
+
+canvas:MarkType(type: number) -> (old_type: number) [in Lua]
int cdCanvasMarkSize(cdCanvas* canvas, int size); [in C]
+double wdCanvasMarkSize(cdCanvas* canvas, double size); (WC) [in C]
+
+canvas:MarkSize(size: number) -> (old_size: number) [in Lua]
+canvas:wMarkSize(size: number) -> (old_size: number) (WC) [in Lua]
char* cdVersion(void); [in C]
+
+cd.Version() -> (version: string) [in Lua]
char* cdVersionDate(void); [in C]
+
+cd.VersionDate() -> (versiondate: string) [in Lua]
int cdVersionNumber(void); [in C]
+
+cd.VersionNumber() -> (version: number) [in Lua]
[in C]
+CD_NAME           "CD - Canvas Draw"
+CD_DESCRIPTION    "A 2D Graphics Library"
+CD_COPYRIGHT      "Copyright (C) 1994-2007 Tecgraf/PUC-Rio and PETROBRAS S/A"
+CD_VERSION        "5.0.0"
+CD_VERSION_DATE   "2007/04/09"
+CD_VERSION_NUMBER 500000
+
+[in Lua]
+cd._NAME
+cd._DESCRIPTION
+cd._COPYRIGHT
+cd._VERSION
+cd._VERSION_DATE
+cd._VERSION_NUMBER
int cdCanvasPlay(cdCanvas* canvas, cdContext* ctx, int xmin, int xmax, int ymin, int ymax, void *data); [in C]
+
+canvas:Play(ctx, xmin, xmax, ymin, ymax: number, data: string) -> (status: number) [in Lua]
int cdContextRegisterCallback(cdContext *ctx, int cb, int(*func)(cdCanvas* canvas, ...)); [in C]
+
+cd.ContextRegisterCallback(ctx, cb: number, func: function) -> (status: number) [in Lua]
int cdResizeCB(cdCanvas* canvas, int width, int height, double mm_width, double mm_height)
void cdCanvasBegin(cdCanvas* canvas, int mode); [in C]
+
+canvas:Begin(mode: number) [in Lua]
void cdCanvasVertex(cdCanvas* canvas, int x, int y); [in C]
+void cdfCanvasVertex(cdCanvas* canvas, double x, double y); [in C]
+void wdCanvasVertex(cdCanvas* canvas, double x, double y); (WC) [in C]
+
+canvas:Vertex(x, y: number) [in Lua]
+canvas:wVertex(x, y: number) (WC) [in Lua]
void cdCanvasEnd(cdCanvas* canvas); [in C]
+
+canvas:End() [in Lua]
CD_REGION
CD_REGION
CD_REGION
CD_UNION
CD_NOTINTERSECT
CD_CLIPREGION
int cdCanvasRegionCombineMode(cdCanvas* canvas, int mode); [in C]
+
+canvas:RegionCombineMode(mode: number) -> (old_mode: number) [in Lua]
CD_UNION, CD_INTERSECT, CD_DIFFERENCE or 
+  CD_NOTINTERSECT
CD_QUERY
CD_UNION
int cdCanvasIsPointInRegion(cdCanvas* canvas, int x, int y); [in C]
+
+canvas:IsPointInRegion(x, y: number) -> (status: number) [in Lua]
void cdCanvasOffsetRegion(cdCanvas* canvas, int dx, int dy); [in C]
+void wdCanvasOffsetRegion(cdCanvas* canvas, double dx, double dy); (WC) [in C]
+
+canvas:OffsetRegion(dx, dy: number) [in Lua]
+canvas:wOffsetRegion(dx, dy: number) (WC) [in Lua]
void cdCanvasGetRegionBox(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax); [in C]
+void wdCanvasGetRegionBox(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax); (WC) [in C]
+
+canvas:GetRegionBox() -> (xmin, xmax, ymin, ymax, status: number) [in Lua]
+canvas:wGetRegionBox() -> (xmin, xmax, ymin, ymax, status: number) (WC) [in Lua]
NULL
cdImage* cdCanvasCreateImage(cdCanvas* canvas, int w, int h); [in C]
+
+canvas:CreateImage(w, h: number) -> (image: cdImage) [in Lua]
w x h
CD_WHITE
void cdKillImage(cdImage* image); [in C]
+
+image:KillImage() [in Lua]
void cdCanvasGetImage(cdCanvas* canvas, cdImage* image, int x, int y); [in C]
+
+canvas:GetImage(image: cdImage; x, y: number) [in Lua]
image
(x,y)
void cdCanvasPutImageRect(cdCanvas* canvas, cdImage* image, int x, int y, int xmin, int xmax, int ymin, int ymax); [in C]
+void wdCanvasPutImageRect(cdCanvas* canvas, cdImage* image, double x, double y, int xmin, int xmax, int ymin, int ymax); (WC) [in C]
+
+canvas:PutImageRect(image: cdImage; x, y, xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wPutImageRect(image: cdImage; x, y, xmin, xmax, ymin, ymax: number) (WC) [in Lua]
(x,y)
void cdCanvasScrollArea(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax, int dx, int dy); [in C]
+
+canvas:ScrollArea(xmin, xmax, ymin, ymax, dx, dy: number) [in Lua]
(xmin,ymin)
(xmax,ymax)

+  (xmin+dx,ymin+dy)
(xmax+dx,ymax+dy)
cdGetImage
cdPutImage
void cdCanvasText(cdCanvas* canvas, int x, int y, const char* text); [in C]
+void cdfCanvasText(cdCanvas* canvas, double x, double y, const char* text); [in C]
+void wdCanvasText(cdCanvas* canvas, double x, double y, const char* text); (WC) [in C]
+
+canvas:Text(x, y: number, text: string) [in Lua]
+canvas:fText(x, y: number, text: string) [in Lua]
+canvas:wText(x, y: number, text: string) (WC) [in Lua]
(x,y)
void cdCanvasFont(cdCanvas* canvas, const char* typeface, int style, int size); [in C]
+void wdCanvasFont(cdCanvas* canvas, const char* typeface, int style, double size); (WD) [in C]
+
+canvas:Font(typeface, style, size: number) [in Lua]
+canvas:wFont(typeface, style, size: number) (WD) [in Lua]
void cdCanvasGetFont(cdCanvas* canvas, char* typeface, int *style, int *size); [in C]
+void wdCanvasGetFont(cdCanvas* canvas, char* typeface, int *style, double *size); (WC) [in C]
+
+canvas:GetFont() -> (typeface: string, style, size: number) [in Lua]
+canvas:wGetFont() -> (typeface: string, style, size: number) (WC) [in Lua]
char* cdCanvasNativeFont(cdCanvas* canvas, const char* nativefont); [in C]
+
+canvas:NativeFont(font: string) -> (old_font: string) [in Lua]
int cdCanvasTextAlignment(cdCanvas* canvas, int alignment); [in C]
+
+canvas:TextAlignment(alignment: number) -> (old_alignment: number) [in Lua]
CD_NORTH
CD_SOUTH
CD_EAST
CD_WEST
CD_NORTH_EAST
CD_NORTH_WEST

+  CD_SOUTH_EAST
CD_SOUTH_WEST
CD_CENTER
CD_BASE_LEFT
CD_BASE_CENTER
CD_BASE_RIGHT

+  CD_BASE_LEFT
CD_QUERY 
double cdCanvasTextOrientation(cdCanvas* canvas, double angle); [in C]
+
+canvas:TextOrientation(angle: number) -> (old_angle: number) [in Lua]
CD_QUERY 
void cdCanvasGetFontDim(cdCanvas* canvas, int *max_width, int *height, int *ascent, int *descent); [in C]
+void wdCanvasGetFontDim(cdCanvas* canvas, double *max_width, double *height, double *ascent, double *descent); (WC) [in C]
+
+canvas:GetFontDim() -> (max_width, height, ascent, descent: number) [in Lua]
+canvas:wGetFontDim() -> (max_width, height, ascent, descent: number) (WC) [in Lua]
NULL
void cdCanvasGetTextSize(cdCanvas* canvas, const char* text, int *width, int *height); [in C]
+void wdCanvasGetTextSize(cdCanvas* canvas, const char* text, double *width, double *height); (WC) [in C]
+
+canvas:GetTextSize(text: string) -> (width, heigth: number) [in Lua]
+canvas:wGetTextSize(text: string) -> (width, heigth: number) (WC) [in Lua]
NULL
void cdCanvasGetTextBox(cdCanvas* canvas, int x, int y, const char* text, int *xmin, int *xmax, int *ymin, int *ymax); [in C]
+void wdCanvasGetTextBox(cdCanvas* canvas, double x, double y, const char* text, double *xmin, double *xmax, double *ymin, double *ymax); (WC) [in C]
+
+canvas:GetTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) [in Lua]
+canvas:wGetTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) (WC) [in Lua]
NULL
void cdCanvasGetTextBounds(cdCanvas* canvas, int x, int y, const char *text, int *rect); [in C]
+void wdCanvasGetTextBounds(cdCanvas* canvas, double x, double y, const char* text, double *rect); (WC) [in C]
+
+canvas:GetTextBounds(x, y: number, text: string) -> (rect0, rect1, rect2, rect3, rect4, rect5, rect6, rect7: number) [in Lua]
+canvas:wGetTextBounds(x, y: number, text: string) -> (rect0, rect1, rect2, rect3, rect4, rect5, rect6, rect7: number) (WC) [in Lua]
void cdCanvasVectorText(cdCanvas* canvas, int x, int y, const char* text); [in C]
+void wdCanvasVectorText(cdCanvas* canvas, double x, double y, const char* text); (WC) [in C]
+    
+canvas:VectorText(x, y: number, text: string) [in Lua]
+canvas:wVectorText(x, y: number, text: string) (WC) [in Lua]
(x,y)
void cdCanvasMultiLineVectorText(cdCanvas* canvas, int x, int y, const char* text); [in C]
+void wdCanvasMultiLineVectorText(cdCanvas* canvas, double x, double y, const char* text); (WC) [in C]
+
+canvas:MultiLineVectorText(x, y: number, text: string) [in Lua]
+canvas:wMultiLineVectorText(x, y: number, text: string) (WC) [in Lua]
(x,y)
void cdCanvasVectorTextDirection(cdCanvas* canvas, int x1, int y1, int x2, int y2); [in C]
+void wdCanvasVectorTextDirection(cdCanvas* canvas, double x1, double y1, double x2, double y2); (WC) [in C]
+
+canvas:VectorTextDirection(x1, y1, x2, y2: number) [in Lua]
+canvas:wVectorTextDirection(x1, y1, x2, y2: number) (WC) [in Lua]
(x1,y1)
(x2,y2)
double* cdCanvasVectorTextTransform(cdCanvas* canvas, const double* matrix); [in C]
+
+canvas:VectorTextTransform(matrix: table) -> (old_matrix: table) [in Lua] 
|x'|   | scl_x*cos(ang)       -sin(ang)  trans_x |   |x|                     | 3   4   5| 
+|y'| = |       sin(ang)  scl_y*cos(ang)  trans_y | * |y|      with indices   | 0   1   2|
+                                                     |1|
void cdCanvasVectorTextSize(cdCanvas* canvas, int w, int h, const char * text); [in C]
+void wdCanvasVectorTextSize(cdCanvas* canvas, double size_x, double size_y, const char* text); (WC) [in C]
+
+canvas:VectorTextSize(w, h: number, text: string) [in Lua]
+canvas:wVectorTextSize(w, h: number, text: string) (WC) [in Lua]
w
h
double cdCanvasVectorCharSize(cdCanvas* canvas, int size); [in C]
+double wdCanvasVectorCharSize(double size); (WC) [in C]
+
+canvas:VectorCharSize(size: number) -> (old_size: number) [in Lua]
+canvas:wVectorCharSize(size: number) -> (old_size: number) (WC) [in Lua]
CD_QUERY
char* cdCanvasVectorFont(cdCanvas* canvas, const char *filename); [in C]
+
+canvas:VectorFont(filename: string) -> (fontname: string) [in Lua]
CDDIR
void cdCanvasGetVectorTextSize(cdCanvas* canvas, const char* text, int *w, int *h); [in C]
+void wdCanvasGetVectorTextSize(cdCanvas* canvas, const char* text, double *x, double *y); (WC) [in C]
+
+canvas:GetVectorTextSize(text: string) -> (w, h: number) [in Lua]
+canvas:wGetVectorTextSize(text: string) -> (w, h: number) (WC) [in Lua]
void cdCanvasGetVectorTextBounds(cdCanvas* canvas, char* text, int px, int py, int *rect); [in C]
+void wdCanvasGetVectorTextBounds(cdCanvas* canvas, char* text, double x, double y, double *rect); (WC) [in C]
+
+canvas:GetVectorTextBounds(text: string, px,py: number) -> (rect: table) [in Lua]
+canvas:wGetVectorTextBounds(text: string, px,py: number) -> (rect: table) (WC) [in Lua] 
void wdCanvasWindow(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax); [in C]
+    
+canvas:wWindow(xmin, xmax, ymin, ymax: number) [in Lua]
void wdCanvasGetWindow(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax); [in C]
+
+canvas:wGetWindow() -> (xmin, xmax, ymin, ymax: number) [in Lua]
void wdCanvasViewport(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax); [in C]
+
+canvas:wViewport(xmin, xmax, ymin, ymax: number) [in Lua]
void wdCanvasGetViewport(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax); [in C]
+
+canvas:wGetViewport() -> (xmin, xmax, ymin, ymax: number) [in Lua]
void wdCanvasWorld2Canvas(cdCanvas* canvas, double xw, double yw, int *xv, int *yv); [in C]
+
+canvas:wWorld2Canvas(xw, yw: number) -> (xv, yv: number) [in Lua]
void wdCanvasCanvas2World(cdCanvas* canvas, int xv, int yv, double *xw, double *yw); [in C]
+
+canvas:wCanvas2World(xv, yv: number) -> (xw, yw: number) [in Lua]
void wdCanvasHardcopy(cdCanvas *canvas, cdContext* ctx, void *data, void(*draw_func)(cdCanvas *canvas_copy)); [in C]
+
+canvas:wCanvasHardcopy(ctx: number, data: string or userdata, draw_func: function) [in Lua]
cd.h
wd.h
cd.h
\mylibs\
+        cd\
+        im\
+        lua5.1\
cd -> gdi32 user32 comdlg32 (system - Windows)
+   -> X11 (system - UNIX)
+   -> FreeType (included as separate library)
+cdgdiplus -> cd
+          -> gdiplus (system - Windows)
+cdxrender -> cd
+          -> Xrender Xft (system - UNIX)
+cdpdf    -> pdflib (included as separate library)
+cdlua51  -> cd
+         -> lua5.1
+cdluaim51 -> cdlua51
+          -> imlua51 
+cdluapdf51 -> cdlua51
+           -> cdpdf
CD_PS (is in fact) cdContextPS()
+cdCreateCanvas(CD_PS, "teste.ps"); (will do) canvas->Line = context->Line
struct _cdContext
+{
+  unsigned long caps;
+
+  /* can NOT be NULL */
+  void (*CreateCanvas)(cdCanvas* canvas, void *data);
+  void (*InitTable)(cdCanvas* canvas);
+
+  /* can be NULL */
+  int (*Play)(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax, void *data); 
+  int (*RegisterCallback)(int cb, cdCallback func);
+};
struct _cdCanvas
+{
+  ...
+  void (*Line)(cdCtxCanvas* ctxcanvas, int x1, int y1, int x2, int y2);
+  void (*Rect)(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax);
+  void (*Box)(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax);
+  ...
+
+  ...
+  int mark_type, mark_size;
+  int line_style, line_width;
+  int interior_style, hatch_style;
+  ...
+
+  cdVectorFont* vector_font;
+  cdSimulation* simulation;
+  cdCtxCanvas* ctxcanvas;     // context dependent defintion
+  cdContext* context;
+};
struct _cdCtxCanvas 
+{
+  cdCanvas* canvas;
+
+  char* filename; 
+
+  int last_line_style;
+  int last_fill_mode;
+  FILE* file;
+};
/* In the driver implementation file */
+
+static void cdcreatecanvas(cdCanvas *canvas, void *data)
+{
+  cdCtxCanvas* ctxcanvas = (cdCtxCanvas *)malloc(sizeof(cdCtxCanvas));
+
+  // parse data parameters
+  ...
+
+  ctxcanvas->canvas = canvas;
+  canvas->ctxcanvas = ctxcanvas;
+
+  /* update canvas context */
+  canvas->w = (int)(w_mm * res);
+  canvas->h = (int)(h_mm * res);
+  canvas->w_mm = w_mm;
+  canvas->h_mm = h_mm;
+  canvas->bpp = 24;
+  canvas->xres = res;
+  canvas->yres = res;
+}
+
+static void cdinittable(cdCanvas* canvas)
+{
+  canvas->Flush = cdflush;
+  canvas->Clear = cdclear;
+  canvas->Pixel = cdpixel;
+  canvas->Line = cdline;
+  canvas->Poly = cdpoly;
+  ...
+ }
+
+static cdContext cdMetafileContext =
+{
+  CD_CAP_ALL & ~(CD_CAP_GETIMAGERGB|CD_CAP_IMAGESRV|CD_CAP_REGION|CD_CAP_FONTDIM|CD_CAP_TEXTSIZE),
+  cdcreatecanvas,
+  cdinittable,
+  cdplay,
+  cdregistercallback,
+};
+
+cdContext* cdContextMetafile(void)
+{
+  return &cdMetafileContext;
+}
/* In the header file */
+#define CD_METAFILE cdContextMetafile()
+cdContext* cdContextMetafile(void)
+
static void set_fill_attrib(cdCtxCanvas* ctxcanvas, char* data)
+{
+  ctxcanvas->fill_attrib[0] = data[0];
+}
+
+static char* get_fill_attrib(cdCtxCanvas* ctxcanvas)
+{
+  return ctxcanvas->fill_attrib;
+}
+
+static cdAttribute fill_attrib =
+{
+  "SIMPENFILLPOLY",
+  set_fill_attrib,
+  get_fill_attrib
+}; 
ctxcanvas->fill_attrib[0] = '1';
+ctxcanvas->fill_attrib[1] = 0;
+
+cdRegisterAttribute(canvas, &fill_attrib);
cdCanvas* canvas = cdCreateCanvas(CD_NATIVEWINDOW, IupGetAttribute(IupCanvas,"CONID")); 
cdCanvasLineStyle(canvas, CD_DASHED);
cdCanvasLine(canvas, 0, 0, 100, 100);
cdCanvasKillCanvas(canvas);
cdCanvas* canvas = cdCreateCanvas(CD_NATIVEWINDOW, IupGetAttribute(IupCanvas,"CONID")); 
wdCanvasViewport(canvas, 0, 100, 0, 100); 
wdCanvasWindow(canvas, -1.5, 1.5, -3000, 3000); 
cdCanvasLineStyle(canvas, CD_DASHED); 
wdCanvasLine(canvas, -0.5, -500, 1.0, 1000); 
cdKillCanvas(canvas); 
cdCanvas* canvas = cdCreateCanvas(CD_NATIVEWINDOW, IupGetAttribute(IupCanvas,"CONID")); 
cdCanvas* db_canvas = cdCreateCanvas(CD_DBUFFER, canvas); cdCanvasActivate(db_canvas); // update canvas size, window could be resized
cdCanvasLineStyle(db_canvas, CD_DASHED); 
cdCanvasLine(db_canvas, 10, 10, 50, 50); 
cdCanvasFlush(db_canvas);  // swap to the window canvas 
cdKillCanvas(db_canvas); 
cdKillCanvas(canvas); 
cdCanvas* canvas = cdCreateCanvasf(CD_IMAGERGB, "%dx%d", width, height);
+cdCanvasLineStyle(canvas, CD_DASHED); 
+cdCanvasLine(canvas, 10, 10, 50, 50); 
+unsigned char* red = cdCanvasGetAttribute(canvas, "REDIMAGE");
+// do something with the raw image data
+cdKillCanvas(canvas); 
+
bitmap = cd.CreateBitmap(200,200,cd.RGB)
+canvas = cd.CreateCanvas(cd.IMAGERGB, bitmap)
+canvas:Font("Times", cd.BOLD, 12)
+canvas:Text(10, 10, "Test")
+canvas:KillCanvas()
cdCanvas *canvas = cdCreateCanvas(CD_NATIVEWINDOW, NULL);
+cdCanvasGetSize(canvas, &width, &height, NULL, NULL);
+// allocate red, green and blue pointers
+cdCanvasGetImageRGB(canvas, red, green, blue, 0, 0, width, height);
+cdKillCanvas(canvas);
+image = im.FileImageLoadBitmap(image_filename)
+canvas = cd.CreateCanvas(cd.EMF,emf_filename.." "..image:Width().."x"..image:Height())
+image:cdCanvasPutImageRect(canvas,0,0,0,0)
+cd.KillCanvas(canvas)
+

AIX43	IBM AIX 4.3 (ppc) / gcc 2.95 / Motif 2.1 +
AIX43cc	IBM AIX 4.3 (ppc) / cc 4.4 / Motif 2.1
AIX43_64	IBM AIX 4.3 (ppc) (64 bits libraries) / cc 4.4 / Motif 2.1
IRIX65	SGI IRIX 6.5 (mips) / gcc 3.0 / Motif 2.1 +
IRIX6465	SGI IRIX 6.5 (mips) / gcc 3.3 / Motif 1.2
IRIX6465cc	SGI IRIX 6.5 (mips) / cc MIPSpro 7.4 / Motif 1.2 +
IRIX6465_64	SGI IRIX 6.5 (mips) (64 bits libraries) / cc MIPSpro 7.4 / Motif 1.2
Linux24	Red Hat 7.3 (x86) / Kernel 2.4 / gcc 2.95 / Open Motif 2.1 +
Linux24g3	CentOS 3.9 (x86) / Kernel 2.4 / gcc 3.2 / Open Motif 2.2 + ³
Linux24g3_64	Red Hat E.L. WS 3 (x64) (64 bits libraries) / Kernel 2.4 / gcc 3.2 / Open Motif + 2.2 ³
Linux26	CentOS 4.5 (x86) / Kernel 2.6 / gcc 3.4 / Open Motif 2.2 + ³
Linux26_64	CentOS 4.5 (x64) / Kernel 2.6 / gcc 3.4 / Open Motif 2.2 + ³
Linux26g4	Ubuntu 6.06 (x86) / Kernel 2.6 / gcc 4.0 / Open Motif + 2.2 ³
Linux26g4_64	Ubuntu 6.10 (x64) / Kernel 2.6 / gcc 4.1 / + OpenMotif 2.2 ³
Linux26g4ppc	Ubuntu 7.10 (ppc) / Kernel 2.6 / gcc 4.1 / Open Motif 2.2 + ³
Linux26_ia64	Red Hat E.L. AS 4 (ia64) / Kernel 2.6 / gcc 3.4 / + Open Motif 2.2 ³
SunOS57	Sun Solaris 7 (sparc) / gcc 2.95 / Motif 2.1 +
SunOS57cc	Sun Solaris 7 (sparc) / cc 5.2 (Sun WorkShop 6 update 1) / Motif 2.1 +
SunOS57_64	Sun Solaris 7 (sparc) (64 bits libraries) / cc 5.2 (Sun WorkShop 6 update 1) / Motif 2.1 +
SunOS58	Sun Solaris 8 (sparc) / gcc 3.4 / Motif 2.1 +
SunOS58cc	Sun Solaris 8 (sparc) / Sun WorkShop 6 update 2 C++ 5.3 / Motif 2.1 +
SunOS58_64	Sun Solaris 8 (sparc) / Sun WorkShop 6 update 2 C++ 5.3 / Motif 2.1 +
SunOS510x86	Sun Solaris 10 (x86) / gcc 3.3 / Motif 2.1 +
FreeBSD54	Free BSD 5.4 (x86) / gcc 3.4 / Open Motif 2.2 + ³
HP-UXB11	HP-UX 11 (9000) / HP ANSI C++ B3910B / Motif 2.1
Darwin811	Mac OS X 10.4.11 (ppc) / Darwin Kernel Version 8.11 / gcc 4.0 / + Open Motif 2.1
Darwin811x86	Mac OS X 10.4.11 (x86) / Darwin Kernel Version 8.11 / gcc 4.0 / + Open Motif 2.1
Win32_vc6	Microsoft Visual C++ 6 (static RTL/single thread)
Win32_vc7	Microsoft Visual C++ 7.1 (.NET 2003) (static RTL/single thread) + Also compatible with Microsoft Visual C++ Toolkit 2003 - + http://msdn.microsoft.com/visualc/vctoolkit2003/ + ¹
Win32_vc8	Microsoft Visual C++ 8.0 (2005) (static RTL/multithread) + Also compatible with Microsoft Visual C++ 2005 Express Edition - + http://msdn.microsoft.com/vstudio/express/visualc/ + ¹
Win32_vc9	Microsoft Visual C++ 9.0 (2008) (static RTL/multithread) + Also compatible with Microsoft Visual C++ 2008 Express Edition - + http://msdn.microsoft.com/vstudio/express/visualc/ + ¹
Win32_dll	built using vc6, creates dependency with MSVCRT.DLL + (either other libraries or new applications).
Win32_dll7	built using vc7, creates dependency with MSVCR71.DLL + (either other libraries or new applications).
Win32_dll8	built using vc8, creates dependency with MSVCR80.DLL + (either other libraries or new applications).
Win32_dll9	built using vc9, creates dependency with MSVCR90.DLL + (either other libraries or new applications).
Win64_vc8	Same as Win32_vc8 but for 64-bits + systems using x64 standard.
Win64_vc9	Same as Win32_vc9 but for 64-bits + systems using x64 standard.
Win64_dll8	Same as Win32_dll8 but for 64-bits + systems using x64 standard.
Win64_dll9	Same as Win32_dll9 but for 64-bits + systems using x64 standard.
Win32_gcc3	Cygwin gcc 3.4 (Depends on Cygwin DLL 1.5) - + http://www.cygwin.com/ + ¹
Win32_cygw15	Same as Win32_gcc3, but using the Cygwin Posix + system
Win32_mingw3	MingW gcc 3.4 - + http://www.mingw.org/ + ¹ + Also compatible with Dev-C++ - + http://www.bloodshed.net/devcpp.html + ¹
Win32_mingw4	MingW gcc 4.x (unofficial) - + http://www.develer.com/oss/GccWinBinaries + ¹
Win32_owc1	Open Watcom 1.5 - + http://www.openwatcom.org/
Win32_bc56	Borland C++ BuilderX 1.0 / Borland C++ 5.6 Compiler - + + http://www.borland.com/products/downloads/download_cbuilderx.html + ¹,² + (the C++ BuilderX IDE can also be configured to use mingw3 or gcc3 versions.) +
Win32_bin	Executables only for Windows NT/2000/XP
Win64_bin	Same as Win32_bin but for 64-bits systems + using the x64 standard
Win32_cygw15_bin	Executables only for Windows NT/2000/XP, but + using the Cygwin Posix system

CD Fonts	Generated Font Names
CD Fonts	CD_PLAIN	CD_BOLD	CD_ITALIC	CD_BOLD\|CD_ITALIC
"System"	"SYSTEM"	"SYSTEM_BOLD"	"SYSTEM_ITALIC"	"SYSTEM_BOLDITALIC"
"Courier"	"COURIER"	"COURIER_BOLD"	"COURIER_ITALIC"	"COURIER_BOLDITALIC"
"Times"	"TIMES_ROMAN"	"TIMES_ROMAN_BOLD"	"TIMES_ROMAN_ITALIC"	"TIMES_ROMAN_BOLDITALIC"
"Helvetica"	"HELVETICA"	"HELVETICA_BOLD"	"HELVETICA_ITALIC"	"HELVETICA_BOLDITALIC"

CD Fonts	MicroStation Font Index
CD_SYSTEM	0
CD_COURIER	1
CD_TIMES_ROMAN	2
CD_HELVETICA	3

CD Fonts	AutoCAD Fonts
System	STANDARD (sem arquivo)
Courier	ROMAN (romanc.shx)
Courier + CD_BOLD	ROMAN_BOLD (romant.shx)
Times	ROMANTIC (rom_____.pfb)
Times + CD_BOLD	ROMANTIC_BOLD (romb_____.pfb)
Helvetica	SANSSERIF (sas_____.pfb)
Helvetica + CD_BOLD	SANSSERIF_BOLD (sasb____.pfb)

	Width (mm)	Length (mm)
A0	841	1187
A1	594	841
A2	420	594
A3	297	420
A4	210	297
A5	148	210
Letter	216	279
Legal	216	356

Canvas

Initialization

Control

Coordinate System

Other

Lua Binding

Overview

Function Names and Definitions

Modifications to the API

Garbage Collection

Exchanging Values between C and Lua

CDLua+IMLua

Available methods

Tecgraf Library License

CVS

Download

Tecgraf/PUC-Rio Library Download Tips

Build Configuration

Packaging

Installation

Usage

Available Platforms

Drivers

CD_CGM - Computer Graphics Metafile Driver (cdcgm.h)

Use

Behavior of Functions

Control

Coordinate System and Clipping

Primitives

Attributes

Colors

Client Images

Server Images

CD_CLIPBOARD - Clipboard Driver (cdclipbd.h)

Use

Behavior of Functions

CD_DBUFFER - Double Buffer Driver using a server image (cddbuf.h)

Use

Behavior of Functions

Control

CD_DBUFFERRGB - Double Buffer Driver using a RGB image (cdirgb.h)

Use

Behavior of Functions

Control

CD_DEBUG - CD Debug Driver (cddebug.h)

Use

Behavior of Functions

Coordinate System and Clipping

Attributes

Colors

CD_DGN - MicroStation Design File Driver (cddgn.h)

Use

Behavior of Functions

Control

Coordinate System and Clipping

Primitives

Attributes

Colors

Client Images

Server Images

CD_DXF - AutoCAD Image Exchange File Driver (cddxf.h)

Use

Behavior of Functions

Control

Coordinate System and Clipping

Primitives

Attributes

Colors

Client Images

Server Images

CD_EMF - Enhanced Metafile Driver (cdemf.h)

Use

Behavior of Functions

Control Functions

Client Images

Server Images

Microsoft Windows Base Driver Using GDI+

Behavior of Functions

Control

Coordinate System and Clipping

cd.ImageRGB(canvas: cdCanvas) -> (imagergb: cdImageRGB +or cdImageRGBA) [in Lua]
+cd.ImageRGBBitmap(canvas: cdCanvas) -> (bitmap: cdBitmap) [in Lua]

void cdGetScreenSize(int width, int height, double width_mm, double height_mm); [in C]
+cd.GetScreenSize() +-> (width, heigth, mm_width, mm_height: number) [in Lua]

int cdGetScreenColorPlanes(void); [in C]
+cd.GetScreenColorPlanes() -> (bpp: number) [in Lua]