PPCODE results from the CPAN

PPCODE

IUP

view release on metacpan or search on metacpan

lib/IUP/Internal/Canvas.xs.inc view on Meta::CPAN


#### Original C function from <.../cd/include/cd.h>
# void cdCanvasSetAttribute(cdCanvas* canvas, const char* name, char* data);
void
cdSetAttribute(canvas,name,data)
                SV* canvas;
                const char* name;
                char* data;
        CODE:
                cdCanvasSetAttribute(ref2cnv(canvas),name,data);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasSetfAttribute(cdCanvas* canvas, const char* name, const char* format, ...);
void
cdSetfAttribute(canvas,name,format,...)
                SV* canvas;
                const char* name;
                const char* format;
        CODE:
                cdCanvasSetfAttribute(ref2cnv(canvas),name,format);

#### Original C function from <.../cd/include/cd.h>
# char* cdCanvasGetAttribute(cdCanvas* canvas, const char* name);
char*
cdGetAttribute(canvas,name)
                SV* canvas;
                const char* name;
        CODE:
                RETVAL = cdCanvasGetAttribute(ref2cnv(canvas),name);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasPlay(cdCanvas* canvas, cdContext *context, int xmin, int xmax, int ymin, int ymax, void *data);
#XXX-CHECKLATER: void *data vs. char *data
int
cdPlay(canvas,context,xmin,xmax,ymin,ymax,data)
                SV* canvas;
                IUP::Canvas::InternalContext context;
                int xmin;
                int xmax;
                int ymin;
                int ymax;
                char *data;
        CODE:
                RETVAL = cdCanvasPlay(ref2cnv(canvas),context,xmin,xmax,ymin,ymax,(void*)data);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetSize(cdCanvas* canvas, int *width, int *height, double *width_mm, double *height_mm);
# canvas:GetSize() -> (width, height, mm_width, mm_height: number) [in Lua]
void
cdGetSize(canvas)
                SV* canvas;
        INIT:
                int width;
                int height;
                double width_mm;
                double height_mm;
        PPCODE:
                cdCanvasGetSize(ref2cnv(canvas),&width,&height,&width_mm,&height_mm);
                XPUSHs(sv_2mortal(newSViv(width)));
                XPUSHs(sv_2mortal(newSViv(height)));
                XPUSHs(sv_2mortal(newSVnv(width_mm)));
                XPUSHs(sv_2mortal(newSVnv(height_mm)));

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasUpdateYAxis(cdCanvas* canvas, int* y);
# double cdfCanvasUpdateYAxis(cdCanvas* canvas, double* y);
double
cdUpdateYAxis(canvas,y)
                SV* canvas;
                double y;
        CODE:
                double tmpy = y;
                #XXX-CHECKLATER returns updated value (does not change param value)
                RETVAL = cdfCanvasUpdateYAxis(ref2cnv(canvas),&tmpy);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasYAxisMode(cdCanvas* canvas, int invert);
int
cdYAxisMode(canvas,invert)
                SV* canvas;
                int invert;
        CODE:
                croak("OBSOLETE: cdCanvasYAxisMode");
                RETVAL = 0;
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasInvertYAxis(cdCanvas* canvas, int y);
# double cdfCanvasInvertYAxis(cdCanvas* canvas, double y);
double
cdInvertYAxis(canvas,y)
                SV* canvas;
                double y;
        CODE:
                RETVAL = cdfCanvasInvertYAxis(ref2cnv(canvas),y);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasMM2Pixel(cdCanvas* canvas, double mm_dx, double mm_dy, int *dx, int *dy);
# canvas:MM2Pixel(mm_dx, mm_dy: number) -> (dx, dy: number) [in Lua]
void
cdMM2Pixel(canvas,mm_dx,mm_dy)
                SV* canvas;
                double mm_dx;
                double mm_dy;
        INIT:
                int rv;
                int dx;
                int dy;
        PPCODE:                
                cdCanvasMM2Pixel(ref2cnv(canvas),mm_dx,mm_dy,&dx,&dy);
                XPUSHs(sv_2mortal(newSViv(dx)));
                XPUSHs(sv_2mortal(newSViv(dy)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasPixel2MM(cdCanvas* canvas, int dx, int dy, double *mm_dx, double *mm_dy);
# canvas:Pixel2MM(dx, dy: number) -> (mm_dx, mm_dy: number) [in Lua]
void
cdPixel2MM(canvas,dx,dy)
                SV* canvas;
                int dx;
                int dy;
        INIT:
                double mm_dx;
                double mm_dy;
        PPCODE:
                cdCanvasPixel2MM(ref2cnv(canvas),dx,dy,&mm_dx,&mm_dy);
                XPUSHs(sv_2mortal(newSVnv(mm_dx)));
                XPUSHs(sv_2mortal(newSVnv(mm_dy)));


#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasMM2Pixel(cdCanvas* canvas, double mm_dx, double mm_dy, double *dx, double *dy);
# canvas:fMM2Pixel(mm_dx, mm_dy: number) -> (dx, dy: number) [in Lua]
void
cdfMM2Pixel(canvas,mm_dx,mm_dy)
                SV* canvas;
                double mm_dx;
                double mm_dy;
        INIT:
                double dx;
                double dy;
        PPCODE:
                cdfCanvasMM2Pixel(ref2cnv(canvas),mm_dx,mm_dy,&dx,&dy);
                XPUSHs(sv_2mortal(newSVnv(dx)));
                XPUSHs(sv_2mortal(newSVnv(dy)));

#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasPixel2MM(cdCanvas* canvas, double dx, double dy, double *mm_dx, double *mm_dy);
# canvas:fPixel2MM(dx, dy: number) -> (mm_dx, mm_dy: number) [in Lua]
void
cdfPixel2MM(canvas,dx,dy,mm_dx,mm_dy)
                SV* canvas;
                double dx;
                double dy;
        INIT:
                double mm_dx;
                double mm_dy;
        PPCODE:
                cdfCanvasPixel2MM(ref2cnv(canvas),dx,dy,&mm_dx,&mm_dy);
                XPUSHs(sv_2mortal(newSVnv(mm_dx)));
                XPUSHs(sv_2mortal(newSVnv(mm_dy)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasOrigin(cdCanvas* canvas, int x, int y);
void
cdOrigin(canvas,x,y)
                SV* canvas;
                int x;
                int y;
        CODE:
                cdCanvasOrigin(ref2cnv(canvas),x,y);

#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasOrigin(cdCanvas* canvas, double x, double y);
void
cdfOrigin(canvas,x,y)
                SV* canvas;
                double x;
                double y;
        CODE:
                cdfCanvasOrigin(ref2cnv(canvas),x,y);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetOrigin(cdCanvas* canvas, int *x, int *y);
# canvas:GetOrigin() -> (x, y: number) [in Lua]
void
cdGetOrigin(canvas)
                SV* canvas;
        INIT:
                int x;
                int y;
        PPCODE:
                cdCanvasGetOrigin(ref2cnv(canvas),&x,&y);
                XPUSHs(sv_2mortal(newSViv(x)));
                XPUSHs(sv_2mortal(newSViv(y)));

#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasGetOrigin(cdCanvas* canvas, double *x, double *y);
# canvas:fGetOrigin() -> (x, y: number) [in Lua]
void
cdfGetOrigin(canvas)
                SV* canvas;
        INIT:
                double x;
                double y;
        PPCODE:
                cdfCanvasGetOrigin(ref2cnv(canvas),&x,&y);
                XPUSHs(sv_2mortal(newSVnv(x)));
                XPUSHs(sv_2mortal(newSVnv(y)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransform(cdCanvas* canvas, const double* matrix);
# canvas:Transform(matrix: table) [in Lua]
void
cdTransform(canvas,matrix)
                SV* canvas;
                SV* matrix;
        INIT:
                double tmpmatrix[6];
        CODE:
                if (AV2transmatrix(matrix,tmpmatrix))
                    cdCanvasTransform(ref2cnv(canvas),tmpmatrix);
                else
                    warn("Warning: cdTransform() invalid 'matrix' parameter");

#### Original C function from <.../cd/include/cd.h>
# double* cdCanvasGetTransform(cdCanvas* canvas);
# canvas:GetTransformation() -> (matrix: table) [in Lua]
SV*
cdGetTransform(canvas)
                SV* canvas;
        INIT:
                double *matrix;
        CODE:
                matrix = cdCanvasGetTransform(ref2cnv(canvas));
                if (!matrix) XSRETURN_UNDEF;
                RETVAL = transmatrix2AV(matrix);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransformMultiply(cdCanvas* canvas, const double* matrix);
# canvas:TransformMultiply(matrix: table) [in Lua]
void
cdTransformMultiply(canvas,matrix)
                SV* canvas;
                SV* matrix;
        INIT:
                double tmpmatrix[6];
        CODE:
                if (AV2transmatrix(matrix,tmpmatrix))
                    cdCanvasTransformMultiply(ref2cnv(canvas),tmpmatrix);
                else
                    warn("Warning: cdTransform() invalid 'matrix' parameter");

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransformRotate(cdCanvas* canvas, double angle);
void
cdTransformRotate(canvas,angle)
                SV* canvas;
                double angle;
        CODE:
                cdCanvasTransformRotate(ref2cnv(canvas),angle);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransformScale(cdCanvas* canvas, double sx, double sy);
void
cdTransformScale(canvas,sx,sy)
                SV* canvas;
                double sx;
                double sy;
        CODE:
                cdCanvasTransformScale(ref2cnv(canvas),sx,sy);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransformTranslate(cdCanvas* canvas, double dx, double dy);
void
cdTransformTranslate(canvas,dx,dy)
                SV* canvas;
                double dx;
                double dy;
        CODE:
                cdCanvasTransformTranslate(ref2cnv(canvas),dx,dy);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasTransformPoint(cdCanvas* canvas, int x, int y, int *tx, int *ty);
# canvas:TransformPoint(x, y: number) -> (tx, ty: number) [in Lua]
void
cdTransformPoint(canvas,x,y)
                SV* canvas;
                int x;
                int y;
        INIT:
                int tx;
                int ty;
        PPCODE:
                cdCanvasTransformPoint(ref2cnv(canvas),x,y,&tx,&ty);
                XPUSHs(sv_2mortal(newSViv(tx)));
                XPUSHs(sv_2mortal(newSViv(ty)));

#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasTransformPoint(cdCanvas* canvas, double x, double y, double *tx, double *ty);
# canvas:fTransformPoint(x, y: number) -> (tx, ty: number) [in Lua]
void
cdfTransformPoint(canvas,x,y)
                SV* canvas;
                double x;
                double y;
        INIT:
                double tx;
                double ty;
        PPCODE:
                cdfCanvasTransformPoint(ref2cnv(canvas),x,y,&tx,&ty);
                XPUSHs(sv_2mortal(newSVnv(tx)));
                XPUSHs(sv_2mortal(newSVnv(ty)));

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasClip(cdCanvas* canvas, int mode);
int
cdClip(canvas,mode)
                SV* canvas;
                int mode;
        CODE:
                RETVAL = cdCanvasClip(ref2cnv(canvas),mode);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasClipArea(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax);
void
cdClipArea(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        CODE:
                cdCanvasClipArea(ref2cnv(canvas),xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasGetClipArea(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax);
# canvas:GetClipArea() -> (xmin, xmax, ymin, ymax, status: number) [in Lua]
void
cdGetClipArea(canvas)
                SV* canvas;
        INIT:
                int xmin;
                int xmax;
                int ymin;
                int ymax;
                int status;
        PPCODE:
                status = cdCanvasGetClipArea(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSViv(xmin)));
                XPUSHs(sv_2mortal(newSViv(xmax)));
                XPUSHs(sv_2mortal(newSViv(ymin)));
                XPUSHs(sv_2mortal(newSViv(ymax)));
                XPUSHs(sv_2mortal(newSViv(status)));

#### Original C function from <.../cd/include/cd.h>
# void cdfCanvasClipArea(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax);
void
cdfClipArea(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        CODE:
                cdfCanvasClipArea(ref2cnv(canvas),xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/cd.h>
# int cdfCanvasGetClipArea(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:GetClipArea() -> (xmin, xmax, ymin, ymax, status: number) [in Lua]
void
cdfGetClipArea(canvas)
                SV* canvas;
        INIT:
                int status;
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        PPCODE:
                status = cdfCanvasGetClipArea(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));
                XPUSHs(sv_2mortal(newSVnv(status)));

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasIsPointInRegion(cdCanvas* canvas, int x, int y);
int
cdIsPointInRegion(canvas,x,y)
                SV* canvas;
                int x;
                int y;
        CODE:
                RETVAL = cdCanvasIsPointInRegion(ref2cnv(canvas),x,y);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasOffsetRegion(cdCanvas* canvas, int x, int y);
void
cdOffsetRegion(canvas,x,y)
                SV* canvas;
                int x;
                int y;
        CODE:
                cdCanvasOffsetRegion(ref2cnv(canvas),x,y);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetRegionBox(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax);
# canvas:GetRegionBox() -> (xmin, xmax, ymin, ymax, status: number) [in Lua]
void
cdGetRegionBox(canvas)
                SV* canvas;
        INIT:
                int status = 4; /* inspired by Lua */
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        PPCODE:
                cdCanvasGetRegionBox(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSViv(xmin)));
                XPUSHs(sv_2mortal(newSViv(xmax)));
                XPUSHs(sv_2mortal(newSViv(ymin)));
                XPUSHs(sv_2mortal(newSViv(ymax)));
                XPUSHs(sv_2mortal(newSViv(status)));

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasRegionCombineMode(cdCanvas* canvas, int mode);
int
cdRegionCombineMode(canvas,mode)
                SV* canvas;
                int mode;
        CODE:
                RETVAL = cdCanvasRegionCombineMode(ref2cnv(canvas),mode);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasPixel(cdCanvas* canvas, int x, int y, long color);
void
cdPixel(canvas,x,y,color)
                SV* canvas;
                int x;
                int y;
                long color;
        CODE:
                cdCanvasPixel(ref2cnv(canvas),x,y,color);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasMark(cdCanvas* canvas, int x, int y);
void
cdMark(canvas,x,y)
                SV* canvas;
                int x;
                int y;
        CODE:
                cdCanvasMark(ref2cnv(canvas),x,y);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasBegin(cdCanvas* canvas, int mode);
void
cdBegin(canvas,mode)
                SV* canvas;
                int mode;
        CODE:
                cdCanvasBegin(ref2cnv(canvas),mode);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasPathSet(cdCanvas* canvas, int action);
void
cdPathSet(canvas,action)
                SV* canvas;
                int action;
        CODE:
                cdCanvasPathSet(ref2cnv(canvas),action);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasEnd(cdCanvas* canvas);
void

lib/IUP/Internal/Canvas.xs.inc view on Meta::CPAN

#### Original C function from <.../cd/include/cd.h>
# long* cdCanvasGetPattern(cdCanvas* canvas, int* w, int* h);
# canvas:GetPattern() - > (pattern: cdPattern) [in Lua]
IUP::Canvas::Pattern
cdGetPattern(canvas)
                SV* canvas;                
        INIT:
                int w, h;
                long *data;
                char *CLASS = "IUP::Canvas::Pattern";  /* XXX-CHECKLATER ugly hack to handle return value conversion */
        CODE:
                data = cdCanvasGetPattern(ref2cnv(canvas),&w,&h);
                if (!data || w<=0 || h<=0) XSRETURN_UNDEF;
                Newz(0, RETVAL, 1, struct __IUPinternal_cdPattern);
                if (!RETVAL) XSRETURN_UNDEF;
                RETVAL->pattern = malloc(sizeof(long)*w*h);
                if (!RETVAL->pattern) {
                  free(RETVAL);
                  XSRETURN_UNDEF;
                }
                RETVAL->w = w;
                RETVAL->h = h;
                memcpy(RETVAL->pattern, data, w*h*sizeof(long)); /* XXX-CHECKLATER we are returning a copy of the data */
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasFillMode(cdCanvas* canvas, int mode);
int
cdFillMode(canvas,mode)
                SV* canvas;
                int mode;
        CODE:
                RETVAL = cdCanvasFillMode(ref2cnv(canvas),mode);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasFont(cdCanvas* canvas, const char* type_face, int style, int size);
int
cdFont(canvas,type_face,style,size)
                SV* canvas;
                const char* type_face;
                int style;
                int size;
        CODE:
                RETVAL = cdCanvasFont(ref2cnv(canvas),type_face,style,size);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetFont(cdCanvas* canvas, char *type_face, int *style, int *size);
# canvas:GetFont() -> (typeface: string, style, size: number) [in Lua]
void
cdGetFont(canvas,type_face,style,size)
                SV* canvas;
        INIT:
                char type_face[1024]; /* XXX-CHECKLATER (HARDCODED BUFFER SIZE) 1024 taken from cd_private.h */
                int style;
                int size;
        PPCODE:
                cdCanvasGetFont(ref2cnv(canvas),type_face,&style,&size);
                XPUSHs(sv_2mortal(newSVpv(type_face,0)));
                XPUSHs(sv_2mortal(newSViv(style)));
                XPUSHs(sv_2mortal(newSViv(size)));

#### Original C function from <.../cd/include/cd.h>
# char* cdCanvasNativeFont(cdCanvas* canvas, const char* font);
char*
cdNativeFont(canvas,font)
                SV* canvas;
                const char* font;
        CODE:
                RETVAL = cdCanvasNativeFont(ref2cnv(canvas),font);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasTextAlignment(cdCanvas* canvas, int alignment);
int
cdTextAlignment(canvas,alignment)
                SV* canvas;
                int alignment;
        CODE:
                RETVAL = cdCanvasTextAlignment(ref2cnv(canvas),alignment);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# double cdCanvasTextOrientation(cdCanvas* canvas, double angle);
double
cdTextOrientation(canvas,angle)
                SV* canvas;
                double angle;
        CODE:
                RETVAL = cdCanvasTextOrientation(ref2cnv(canvas),angle);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasMarkType(cdCanvas* canvas, int type);
int
cdMarkType(canvas,type)
                SV* canvas;
                int type;
        CODE:
                RETVAL = cdCanvasMarkType(ref2cnv(canvas),type);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasMarkSize(cdCanvas* canvas, int size);
int
cdMarkSize(canvas,size)
                SV* canvas;
                int size;
        CODE:
                RETVAL = cdCanvasMarkSize(ref2cnv(canvas),size);
        OUTPUT:
                RETVAL

lib/IUP/Internal/Canvas.xs.inc view on Meta::CPAN

# double* cdCanvasVectorTextTransform(cdCanvas* canvas, const double* matrix);
# canvas:VectorTextTransform(matrix: table) -> (old_matrix: table) [in Lua] 
SV*
cdVectorTextTransform(canvas,matrix)
                SV* canvas;
                SV* matrix;
        INIT:
                double tmpmatrix[6];
                double *oldmatrix;
        CODE:
                if (!AV2transmatrix(matrix,tmpmatrix)) {
                  warn("Warning: cdVectorTextTransform() invalid 'matrix' parameter");
                  XSRETURN_UNDEF;
                }  
                oldmatrix = cdCanvasVectorTextTransform(ref2cnv(canvas),tmpmatrix);
                RETVAL = transmatrix2AV(oldmatrix);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasVectorTextSize(cdCanvas* canvas, int size_x, int size_y, const char* s);
void
cdVectorTextSize(canvas,size_x,size_y,s)
                SV* canvas;
                int size_x;
                int size_y;
                const char* s;
        CODE:
                cdCanvasVectorTextSize(ref2cnv(canvas),size_x,size_y,s);

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasVectorCharSize(cdCanvas* canvas, int size);
int
cdVectorCharSize(canvas,size)
                SV* canvas;
                int size;
        CODE:
                RETVAL = cdCanvasVectorCharSize(ref2cnv(canvas),size);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasVectorFontSize(cdCanvas* canvas, double size_x, double size_y);
void
cdVectorFontSize(canvas,size_x,size_y)
                SV* canvas;
                double size_x;
                double size_y;
        CODE:
                cdCanvasVectorFontSize(ref2cnv(canvas),size_x,size_y);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetVectorFontSize(cdCanvas* canvas, double *size_x, double *size_y);
# canvas:GetVectorFontSize() -> (size_x, size_y: number) [in Lua]
void
cdGetVectorFontSize(canvas)
                SV* canvas;
        INIT:
                double size_x;
                double size_y;
        PPCODE:
                cdCanvasGetVectorFontSize(ref2cnv(canvas),&size_x,&size_y);
                XPUSHs(sv_2mortal(newSVnv(size_x)));
                XPUSHs(sv_2mortal(newSVnv(size_y)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetVectorTextSize(cdCanvas* canvas, const char* s, int *x, int *y);
# canvas:GetVectorTextSize(text: string) -> (width, height: number) [in Lua]
void
cdGetVectorTextSize(canvas,s)
                SV* canvas;
                const char* s;
        INIT:
                int x;
                int y;
        PPCODE:
                cdCanvasGetVectorTextSize(ref2cnv(canvas),s,&x,&y);
                XPUSHs(sv_2mortal(newSViv(x)));
                XPUSHs(sv_2mortal(newSViv(y)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetVectorTextBounds(cdCanvas* canvas, const char* s, int x, int y, int *rect);
# canvas:GetVectorTextBounds(text: string, x, y: number) -> (rect: table) [in Lua]
void
cdGetVectorTextBounds(canvas,s,x,y)
                SV* canvas;
                const char* s;
                int x;
                int y;
        INIT:
                int rect[8];
        PPCODE:
                cdCanvasGetVectorTextBounds(ref2cnv(canvas),s,x,y,rect);
                /* XXX-CHECKLATER maybe return an arrayref */
                XPUSHs(sv_2mortal(newSViv(rect[0]))); /* x0 */
                XPUSHs(sv_2mortal(newSViv(rect[1]))); /* y0 */
                XPUSHs(sv_2mortal(newSViv(rect[2]))); /* x1 */
                XPUSHs(sv_2mortal(newSViv(rect[3]))); /* y1 */
                XPUSHs(sv_2mortal(newSViv(rect[4]))); /* x2 */
                XPUSHs(sv_2mortal(newSViv(rect[5]))); /* y2 */
                XPUSHs(sv_2mortal(newSViv(rect[6]))); /* x3 */
                XPUSHs(sv_2mortal(newSViv(rect[7]))); /* y3 */

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetVectorTextBox(cdCanvas* canvas, int x, int y, const char *s, int *xmin, int *xmax, int *ymin, int *ymax);
# canvas:GetVectorTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) [in Lua]
void
cdGetVectorTextBox(canvas,x,y,s)
                SV* canvas;
                int x;
                int y;
                const char* s;
        INIT:
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        PPCODE:
                cdCanvasGetVectorTextBox(ref2cnv(canvas),x,y,s,&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSViv(xmin)));
                XPUSHs(sv_2mortal(newSViv(xmax)));
                XPUSHs(sv_2mortal(newSViv(ymin)));
                XPUSHs(sv_2mortal(newSViv(ymax)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetFontDim(cdCanvas* canvas, int *max_width, int *height, int *ascent, int *descent);
# canvas:GetFontDim() -> (max_width, height, ascent, descent: number) [in Lua]
void
cdGetFontDim(canvas)
                SV* canvas;
        INIT:
                int max_width;
                int height;
                int ascent;
                int descent;
        PPCODE:
                cdCanvasGetFontDim(ref2cnv(canvas),&max_width,&height,&ascent,&descent);
                XPUSHs(sv_2mortal(newSViv(max_width)));
                XPUSHs(sv_2mortal(newSViv(height)));
                XPUSHs(sv_2mortal(newSViv(ascent)));
                XPUSHs(sv_2mortal(newSViv(descent)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetTextSize(cdCanvas* canvas, const char* s, int *width, int *height);
# canvas:GetTextSize(text: string) -> (width, heigth: number) [in Lua]
void
cdGetTextSize(canvas,s)
                SV* canvas;
                const char* s;
        INIT:
                int width;
                int height;
        PPCODE:
                cdCanvasGetTextSize(ref2cnv(canvas),s,&width,&height);
                XPUSHs(sv_2mortal(newSViv(width)));
                XPUSHs(sv_2mortal(newSViv(height)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetTextBox(cdCanvas* canvas, int x, int y, const char* s, int *xmin, int *xmax, int *ymin, int *ymax);
# canvas:GetTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) [in Lua]
void
cdGetTextBox(canvas,x,y,s)
                SV* canvas;
                int x;
                int y;
                const char* s;
        INIT:
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        PPCODE:
                cdCanvasGetTextBox(ref2cnv(canvas),x,y,s,&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSViv(xmin)));
                XPUSHs(sv_2mortal(newSViv(xmax)));
                XPUSHs(sv_2mortal(newSViv(ymin)));
                XPUSHs(sv_2mortal(newSViv(ymax)));

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetTextBounds(cdCanvas* canvas, int x, int y, const char* s, int *rect);
# canvas:GetTextBounds(x, y: number, text: string) -> (rect: table) [in Lua]
void
cdGetTextBounds(canvas,x,y,s)
                SV* canvas;
                int x;
                int y;
                const char* s;
        INIT:
                int rect[8];
        PPCODE:
                cdCanvasGetTextBounds(ref2cnv(canvas),x,y,s,rect);
                /* XXX-CHECKLATER maybe return an arrayref */
                XPUSHs(sv_2mortal(newSViv(rect[0]))); /* x0 */
                XPUSHs(sv_2mortal(newSViv(rect[1]))); /* y0 */
                XPUSHs(sv_2mortal(newSViv(rect[2]))); /* x1 */
                XPUSHs(sv_2mortal(newSViv(rect[3]))); /* y1 */
                XPUSHs(sv_2mortal(newSViv(rect[4]))); /* x2 */
                XPUSHs(sv_2mortal(newSViv(rect[5]))); /* y2 */
                XPUSHs(sv_2mortal(newSViv(rect[6]))); /* x3 */
                XPUSHs(sv_2mortal(newSViv(rect[7]))); /* y3 */

#### Original C function from <.../cd/include/cd.h>
# int cdCanvasGetColorPlanes(cdCanvas* canvas);
int
cdGetColorPlanes(canvas)
                SV* canvas;
        CODE:
                RETVAL = cdCanvasGetColorPlanes(ref2cnv(canvas));
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasPalette(cdCanvas* canvas, int n, const long *palette, int mode);
# canvas:Palette(palette: cdPalette; mode: number) [in Lua]
void
cdPalette(canvas,palette,mode)
                SV *canvas;
                IUP::Canvas::Palette palette;
                int mode;
        PREINIT:
                int n;
                long* tmppalette;
        CODE:
                cdCanvasPalette(ref2cnv(canvas),palette->n,palette->palette,mode);

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasGetImage(cdCanvas* canvas, cdImage* image, int x, int y);
IUP::Canvas::InternalServerImage
cdGetImage(canvas,x,y,w,h)
                SV* canvas;                
                int x;
                int y;
                int w;
                int h;
        INIT:
                //char *CLASS = "IUP::Canvas::InternalServerImage";  /* XXX-CHECKLATER ugly hack to handle return value conversion */
        CODE:
                RETVAL = cdCanvasCreateImage(ref2cnv(canvas),w,h);
                if (!RETVAL) XSRETURN_UNDEF;
                cdCanvasGetImage(ref2cnv(canvas),RETVAL,x,y);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# void cdCanvasPutImageRect(cdCanvas* canvas, cdImage* image, int x, int y, int xmin, int xmax, int ymin, int ymax);
void
cdPutImageRect(canvas,image,x,y,xmin,xmax,ymin,ymax)
                SV* canvas;
                IUP::Canvas::InternalServerImage image;
                int x;

lib/IUP/Internal/Canvas.xs.inc view on Meta::CPAN

void
cdDecodeColor(pkg,color,red,green,blue)
                SV* pkg;
                long color;
        INIT:
                unsigned char red;
                unsigned char green;
                unsigned char blue;
        CODE:
                cdDecodeColor(color,&red,&green,&blue);
                XPUSHs(sv_2mortal(newSViv(red)));
                XPUSHs(sv_2mortal(newSViv(green)));
                XPUSHs(sv_2mortal(newSViv(blue)));

#### Original C function from <.../cd/include/cd.h>
# unsigned char cdDecodeAlpha(long color);
unsigned char
cdDecodeAlpha(pkg,color)
                SV* pkg;
                long color;
        CODE:
                RETVAL = cdDecodeAlpha(color);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/cd.h>
# long cdEncodeAlpha(long color, unsigned char alpha);
long
cdEncodeAlpha(pkg,color,alpha)
                SV* pkg;
                long color;
                unsigned char alpha;
        CODE:
                RETVAL = cdEncodeAlpha(color,alpha);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasWindow(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax);
void
wdWindow(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        CODE:
                wdCanvasWindow(ref2cnv(canvas),xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetWindow(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:wGetWindow() -> (xmin, xmax, ymin, ymax: number) [in Lua]
void
wdGetWindow(canvas)
                SV* canvas;
        INIT:
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        PPCODE:
                wdCanvasGetWindow(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));
                

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasViewport(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax);
void
wdViewport(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        CODE:
                wdCanvasViewport(ref2cnv(canvas),xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetViewport(cdCanvas* canvas, int *xmin, int *xmax, int *ymin, int *ymax);
# canvas:wGetViewport() -> (xmin, xmax, ymin, ymax: number) [in Lua]
void
wdGetViewport(canvas)
                SV* canvas;
        INIT:
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        PPCODE:
                wdCanvasGetViewport(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSViv(xmin)));
                XPUSHs(sv_2mortal(newSViv(xmax)));
                XPUSHs(sv_2mortal(newSViv(ymin)));
                XPUSHs(sv_2mortal(newSViv(ymax)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasWorld2Canvas(cdCanvas* canvas, double xw, double yw, int *xv, int *yv);
# canvas:wWorld2Canvas(xw, yw: number) -> (xv, yv: number) [in Lua]
void
wdWorld2Canvas(canvas,xw,yw)
                SV* canvas;
                double xw;
                double yw;
        INIT:
                int xv;
                int yv;
        PPCODE:
                wdCanvasWorld2Canvas(ref2cnv(canvas),xw,yw,&xv,&yv);
                XPUSHs(sv_2mortal(newSViv(xv)));
                XPUSHs(sv_2mortal(newSViv(yv)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasWorld2CanvasSize(cdCanvas* canvas, double hw, double vw, int *hv, int *vv);
# Lua ???
void
wdWorld2CanvasSize(canvas,hw,vw)
                SV* canvas;
                double hw;
                double vw;
        INIT:
                int hv;
                int vv;
        PPCODE:
                wdCanvasWorld2CanvasSize(ref2cnv(canvas),hw,vw,&hv,&vv);
                XPUSHs(sv_2mortal(newSViv(hv)));
                XPUSHs(sv_2mortal(newSViv(vv)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasCanvas2World(cdCanvas* canvas, int xv, int yv, double *xw, double *yw);
# canvas:wCanvas2World(xv, yv: number) -> (xw, yw: number) [in Lua]
void
wdCanvas2World(canvas,xv,yv)
                SV* canvas;
                int xv;
                int yv;
        INIT:
                double xw;
                double yw;
        PPCODE:
                wdCanvasCanvas2World(ref2cnv(canvas),xv,yv,&xw,&yw);
                XPUSHs(sv_2mortal(newSVnv(xw)));
                XPUSHs(sv_2mortal(newSVnv(yw)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasSetTransform(cdCanvas* canvas, double sx, double sy, double tx, double ty);
void
wdSetTransform(canvas,sx,sy,tx,ty)
                SV* canvas;
                double sx;
                double sy;
                double tx;
                double ty;
        CODE:
                wdCanvasSetTransform(ref2cnv(canvas),sx,sy,tx,ty);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetTransform(cdCanvas* canvas, double *sx, double *sy, double *tx, double *ty);
# canvas:wGetTransform() -> (sx, sy, tx, ty: number) [in Lua]

void
wdGetTransform(canvas)
                SV* canvas;
        INIT:
                double sx;
                double sy;
                double tx;
                double ty;
        PPCODE:
                wdCanvasGetTransform(ref2cnv(canvas),&sx,&sy,&tx,&ty);
                XPUSHs(sv_2mortal(newSVnv(sx)));
                XPUSHs(sv_2mortal(newSVnv(sy)));
                XPUSHs(sv_2mortal(newSVnv(tx)));
                XPUSHs(sv_2mortal(newSVnv(ty)));                

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasTranslate(cdCanvas* canvas, double dtx, double dty);
void
wdTranslate(canvas,dtx,dty)
                SV* canvas;
                double dtx;
                double dty;
        CODE:
                wdCanvasTranslate(ref2cnv(canvas),dtx,dty);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasScale(cdCanvas* canvas, double dsx, double dsy);
void
wdScale(canvas,dsx,dsy)
                SV* canvas;
                double dsx;
                double dsy;
        CODE:
                wdCanvasScale(ref2cnv(canvas),dsx,dsy);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasClipArea(cdCanvas* canvas, double xmin, double xmax, double ymin, double ymax);
void
wdClipArea(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        CODE:
                wdCanvasClipArea(ref2cnv(canvas),xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/wd.h>
# int wdCanvasGetClipArea(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:wGetClipArea() -> (xmin, xmax, ymin, ymax, status: number) (WC) [in Lua]
void
wdGetClipArea(canvas)
                SV* canvas;
        INIT:
                int status;
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        PPCODE:
                status = wdCanvasGetClipArea(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));
                XPUSHs(sv_2mortal(newSViv(status)));

#### Original C function from <.../cd/include/wd.h>
# int wdCanvasIsPointInRegion(cdCanvas* canvas, double x, double y);
int
wdIsPointInRegion(canvas,x,y)
                SV* canvas;
                double x;
                double y;
        CODE:
                RETVAL = wdCanvasIsPointInRegion(ref2cnv(canvas),x,y);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasOffsetRegion(cdCanvas* canvas, double x, double y);
void
wdOffsetRegion(canvas,x,y)
                SV* canvas;
                double x;
                double y;
        CODE:
                wdCanvasOffsetRegion(ref2cnv(canvas),x,y);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetRegionBox(cdCanvas* canvas, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:wGetRegionBox() -> (xmin, xmax, ymin, ymax, status: number) (WC) [in Lua]
void
wdGetRegionBox(canvas,xmin,xmax,ymin,ymax)
                SV* canvas;
        INIT:
                int status = 4; /* inspired by Lua */
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        CODE:
                wdCanvasGetRegionBox(ref2cnv(canvas),&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));
                XPUSHs(sv_2mortal(newSViv(status)));


#### Original C function from <.../cd/include/wd.h>
#xxxTODO void wdCanvasHardcopy(cdCanvas* canvas, cdContext* ctx, void *data, void(*draw_func)(cdCanvas *canvas_copy));
#xxxTODO canvas:wCanvasHardcopy(ctx: number, data: string or userdata, draw_func: function) [in Lua]
#void
#wdHardcopy(canvas,ctx,data,draw_func)
#                SV* canvas;
#                cdContext* ctx;
#                void* data;
#                void(* draw_func;
#        CODE:

lib/IUP/Internal/Canvas.xs.inc view on Meta::CPAN

void
wdPutImageRect(canvas,image,x,y,xmin,xmax,ymin,ymax)
                SV* canvas;
                IUP::Canvas::InternalServerImage image;
                double x;
                double y;
                int xmin;
                int xmax;
                int ymin;
                int ymax;
        CODE:
                wdCanvasPutImageRect(ref2cnv(canvas),image,x,y,xmin,xmax,ymin,ymax);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasPutBitmap(cdCanvas* canvas, cdBitmap* bitmap, double x, double y, double w, double h);
void
wdPutBitmap(canvas,bitmap,x,y,w,h)
                SV* canvas;
                IUP::Canvas::Bitmap bitmap;
                double x;
                double y;
                double w;
                double h;
        CODE:
                wdCanvasPutBitmap(ref2cnv(canvas),bitmap,x,y,w,h);

#### Original C function from <.../cd/include/wd.h>
# double wdCanvasLineWidth(cdCanvas* canvas, double width);
double
wdLineWidth(canvas,width)
                SV* canvas;
                double width;
        CODE:
                RETVAL = wdCanvasLineWidth(ref2cnv(canvas),width);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# int wdCanvasFont(cdCanvas* canvas, const char* type_face, int style, double size);
int
wdFont(canvas,type_face,style,size)
                SV* canvas;
                const char* type_face;
                int style;
                double size;
        CODE:
                RETVAL = wdCanvasFont(ref2cnv(canvas),type_face,style,size);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetFont(cdCanvas* canvas, char *type_face, int *style, double *size);
# canvas:wGetFont() -> (typeface: string, style, size: number) (WC) [in Lua]
void
wdGetFont(canvas,type_face,style,size)
                SV* canvas;
        INIT:
                char type_face[1024]; /* XXX-CHECKLATER (HARDCODED BUFFER SIZE) 1024 taken from cd_private.h */
                int style;
                double size;
        PPCODE:
                wdCanvasGetFont(ref2cnv(canvas),type_face,&style,&size);
                XPUSHs(sv_2mortal(newSVpv(type_face,0)));
                XPUSHs(sv_2mortal(newSViv(style)));
                XPUSHs(sv_2mortal(newSVnv(size)));

#### Original C function from <.../cd/include/wd.h>
# double wdCanvasMarkSize(cdCanvas* canvas, double size);
double
wdMarkSize(canvas,size)
                SV* canvas;
                double size;
        CODE:
                RETVAL = wdCanvasMarkSize(ref2cnv(canvas),size);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetFontDim(cdCanvas* canvas, double *max_width, double *height, double *ascent, double *descent);
# canvas:wGetFontDim() -> (max_width, height, ascent, descent: number) (WC) [in Lua]
void
wdGetFontDim(canvas)
                SV* canvas;
        INIT:
                double max_width;
                double height;
                double ascent;
                double descent;
        PPCODE:
                wdCanvasGetFontDim(ref2cnv(canvas),&max_width,&height,&ascent,&descent);
                XPUSHs(sv_2mortal(newSVnv(max_width)));
                XPUSHs(sv_2mortal(newSVnv(height)));
                XPUSHs(sv_2mortal(newSVnv(ascent)));
                XPUSHs(sv_2mortal(newSVnv(descent)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetTextSize(cdCanvas* canvas, const char* s, double *width, double *height);
# canvas:wGetTextSize(text: string) -> (width, heigth: number) (WC) [in Lua]
void
wdGetTextSize(canvas,s)
                SV* canvas;
                const char* s;
        INIT:
                double width;
                double height;
        PPCODE:
                wdCanvasGetTextSize(ref2cnv(canvas),s,&width,&height);
                XPUSHs(sv_2mortal(newSVnv(width)));
                XPUSHs(sv_2mortal(newSVnv(height)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetTextBox(cdCanvas* canvas, double x, double y, const char* s, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:wGetTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) (WC) [in Lua]
void
wdGetTextBox(canvas,x,y,s)
                SV* canvas;
                double x;
                double y;
                const char* s;
        INIT:
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        PPCODE:
                wdCanvasGetTextBox(ref2cnv(canvas),x,y,s,&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetTextBounds(cdCanvas* canvas, double x, double y, const char* s, double *rect);
# canvas:wGetTextBounds(x, y: number, text: string) -> (rect: table) (WC) [in Lua]
void
wdGetTextBounds(canvas,x,y,s)
                SV* canvas;
                double x;
                double y;
                const char* s;
        INIT:
                double rect[8];
        PPCODE:
                wdCanvasGetTextBounds(ref2cnv(canvas),x,y,s,rect);
                /* XXX-CHECKLATER maybe return an arrayref */
                XPUSHs(sv_2mortal(newSVnv(rect[0]))); /* x0 */
                XPUSHs(sv_2mortal(newSVnv(rect[1]))); /* y0 */
                XPUSHs(sv_2mortal(newSVnv(rect[2]))); /* x1 */
                XPUSHs(sv_2mortal(newSVnv(rect[3]))); /* y1 */
                XPUSHs(sv_2mortal(newSVnv(rect[4]))); /* x2 */
                XPUSHs(sv_2mortal(newSVnv(rect[5]))); /* y2 */
                XPUSHs(sv_2mortal(newSVnv(rect[6]))); /* x3 */
                XPUSHs(sv_2mortal(newSVnv(rect[7]))); /* y3 */

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasStipple(cdCanvas* canvas, int w, int h, const unsigned char*fgbg, double w_mm, double h_mm);
void
wdStipple(canvas,stipple,w_mm,h_mm)
                SV* canvas;
                IUP::Canvas::Stipple stipple;
                double w_mm;
                double h_mm;
        CODE:
                wdCanvasStipple(ref2cnv(canvas),stipple->w,stipple->h,stipple->fgbg,w_mm,h_mm);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasPattern(cdCanvas* canvas, int w, int h, const long *color, double w_mm, double h_mm);
# canvas:wPattern(pattern: cdPattern, w_mm, h_mm: number) [in Lua]
void
wdPattern(canvas,pattern,w_mm,h_mm)
                SV* canvas;
                IUP::Canvas::Pattern pattern;
                double w_mm;
                double h_mm;
        CODE:
                wdCanvasPattern(ref2cnv(canvas),pattern->w,pattern->h,pattern->pattern,w_mm,h_mm);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasVectorTextDirection(cdCanvas* canvas, double x1, double y1, double x2, double y2);
void
wdVectorTextDirection(canvas,x1,y1,x2,y2)
                SV* canvas;
                double x1;
                double y1;
                double x2;
                double y2;
        CODE:
                wdCanvasVectorTextDirection(ref2cnv(canvas),x1,y1,x2,y2);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasVectorTextSize(cdCanvas* canvas, double size_x, double size_y, const char* s);
void
wdVectorTextSize(canvas,size_x,size_y,s)
                SV* canvas;
                double size_x;
                double size_y;
                const char* s;
        CODE:
                wdCanvasVectorTextSize(ref2cnv(canvas),size_x,size_y,s);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetVectorTextSize(cdCanvas* canvas, const char* s, double *x, double *y);
# canvas:wGetVectorTextSize(text: string) -> (width, height: number) [in Lua]
void
wdGetVectorTextSize(canvas,s)
                SV* canvas;
                const char* s;
        INIT:
                double x;
                double y;
        PPCODE:
                wdCanvasGetVectorTextSize(ref2cnv(canvas),s,&x,&y);
                XPUSHs(sv_2mortal(newSVnv(x)));
                XPUSHs(sv_2mortal(newSVnv(y)));

#### Original C function from <.../cd/include/wd.h>
# double wdCanvasVectorCharSize(cdCanvas* canvas, double size);
double
wdVectorCharSize(canvas,size)
                SV* canvas;
                double size;
        CODE:
                RETVAL = wdCanvasVectorCharSize(ref2cnv(canvas),size);
        OUTPUT:
                RETVAL

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasVectorText(cdCanvas* canvas, double x, double y, const char* s);
void
wdVectorText(canvas,x,y,s)
                SV* canvas;
                double x;
                double y;
                const char* s;
        CODE:
                wdCanvasVectorText(ref2cnv(canvas),x,y,s);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasMultiLineVectorText(cdCanvas* canvas, double x, double y, const char* s);
void
wdMultiLineVectorText(canvas,x,y,s)
                SV* canvas;
                double x;
                double y;
                const char* s;
        CODE:
                wdCanvasMultiLineVectorText(ref2cnv(canvas),x,y,s);

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetVectorTextBounds(cdCanvas* canvas, const char* s, double x, double y, double *rect);
# canvas:wGetVectorTextBounds(text: string, x, y: number) -> (rect: table) [in Lua] 
void
wdGetVectorTextBounds(canvas,s,x,y)
                SV* canvas;
                const char* s;
                double x;
                double y;
        INIT:
                double rect[8];
        PPCODE:
                wdCanvasGetVectorTextBounds(ref2cnv(canvas),s,x,y,rect);
                /* XXX-CHECKLATER maybe return an arrayref */
                XPUSHs(sv_2mortal(newSVnv(rect[0]))); /* x0 */
                XPUSHs(sv_2mortal(newSVnv(rect[1]))); /* y0 */
                XPUSHs(sv_2mortal(newSVnv(rect[2]))); /* x1 */
                XPUSHs(sv_2mortal(newSVnv(rect[3]))); /* y1 */
                XPUSHs(sv_2mortal(newSVnv(rect[4]))); /* x2 */
                XPUSHs(sv_2mortal(newSVnv(rect[5]))); /* y2 */
                XPUSHs(sv_2mortal(newSVnv(rect[6]))); /* x3 */
                XPUSHs(sv_2mortal(newSVnv(rect[7]))); /* y3 */

#### Original C function from <.../cd/include/wd.h>
# void wdCanvasGetVectorTextBox(cdCanvas* canvas, double x, double y, const char *s, double *xmin, double *xmax, double *ymin, double *ymax);
# canvas:wGetVectorTextBox(x, y: number, text: string) -> (xmin, xmax, ymin, ymax: number) [in Lua]
void
wdGetVectorTextBox(canvas,x,y,s,xmin,xmax,ymin,ymax)
                SV* canvas;
                double x;
                double y;
                const char* s;
        INIT:
                double xmin;
                double xmax;
                double ymin;
                double ymax;
        CODE:
                wdCanvasGetVectorTextBox(ref2cnv(canvas),x,y,s,&xmin,&xmax,&ymin,&ymax);
                XPUSHs(sv_2mortal(newSVnv(xmin)));
                XPUSHs(sv_2mortal(newSVnv(xmax)));
                XPUSHs(sv_2mortal(newSVnv(ymin)));
                XPUSHs(sv_2mortal(newSVnv(ymax)));

( run in 0.895 second using v1.01-cache-2.11-cpan-71847e10f99 )