void wdCanvasArc(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2)
{
double xcr, ycr, wr, hr;
_wfWorld2Canvas(canvas, xc, yc, xcr, ycr);
_wfWorld2CanvasSize(canvas, w, h, wr, hr);
cdfCanvasArc(canvas, xcr, ycr, wr, hr, angle1, angle2);
}
//void SimpleDrawTest(cdCanvas* canvas)
void SimpleDrawPoly(cdCanvas* canvas)
{
int w, h;
cdGetCanvasSize(&w, &h, 0, 0);
cdBackground(CD_WHITE);
cdClear();
//cdSetAttribute("ANTIALIAS", "0");
cdForeground(cdEncodeAlpha(cdEncodeColor(255, 0, 0), 100));
cdfCanvasArc(cdActiveCanvas(), 255, 255, 100, 100, 0, 360);
cdLine(0, 0, 200, 200);
cdBegin(CD_BEZIER);
cdVertex(100, 100);
cdVertex(150, 200);
cdVertex(180, 250);
cdVertex(180, 200);
cdVertex(180, 150);
cdVertex(150, 100);
cdVertex(300, 100);
cdEnd();
cdEnd();
}
void wdCanvasArc(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2)
{
double xcr, ycr, wr, hr;
assert(canvas);
if (!_cdCheckCanvas(canvas)) return;
_wfWorld2Canvas(canvas, xc, yc, xcr, ycr);
_wfWorld2CanvasSize(canvas, w, h, wr, hr);
cdfCanvasArc(canvas, xcr, ycr, wr, hr, angle1, angle2);
}
static void cdcgm_CircularArc(cgmPoint center, double radius, double angle1, double angle2, int arc, cdCGM* cd_cgm)
{
fix_angles(cd_cgm, &angle1, &angle2);
if (arc==CGM_OPENARC)
cdfCanvasArc(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), sScaleW(2*radius), sScaleH(2*radius), angle1, angle2);
else
{
if (arc==CGM_PIE)
cdfCanvasSector(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), sScaleW(2*radius), sScaleH(2*radius), angle1, angle2);
else /* CGM_CHORD */
cdfCanvasChord(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), sScaleW(2*radius), sScaleH(2*radius), angle1, angle2);
}
}
static void iPlotDrawHighlightedArc(cdCanvas *canvas, double xc, double yc, double w, double h, double startAngle, double endAngle)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
cdfCanvasArc(canvas, xc, yc, w, h, startAngle, endAngle);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
cdCanvasSetForeground(canvas, foreground);
}
void cdfCanvasSector(cdCanvas* canvas, double xc, double yc, double w, double h, double angle1, double angle2)
{
assert(canvas);
if (!_cdCheckCanvas(canvas)) return;
if (angle1 == angle2 || w == 0 || h == 0)
return;
sNormAngles(&angle1, &angle2);
if (canvas->interior_style == CD_HOLLOW)
{
cdfCanvasArc(canvas, xc, yc, w, h, angle1, angle2);
if (fabs(angle2-angle1) < 360)
{
double xi,yi,xf,yf;
xi = xc + w*cos(CD_DEG2RAD*angle1)/2.0;
yi = yc + h*sin(CD_DEG2RAD*angle1)/2.0;
xf = xc + w*cos(CD_DEG2RAD*angle2)/2.0;
yf = yc + h*sin(CD_DEG2RAD*angle2)/2.0;
cdfCanvasLine(canvas, xi, yi, xc, yc);
cdfCanvasLine(canvas, xc, yc, xf, yf);
}
return;
}
if (canvas->use_origin)
{
xc += canvas->forigin.x;
yc += canvas->forigin.y;
}
if (canvas->invert_yaxis)
yc = _cdInvertYAxis(canvas, yc);
if (canvas->cxFSector)
canvas->cxFSector(canvas->ctxcanvas, xc, yc, w, h, angle1, angle2);
else
canvas->cxSector(canvas->ctxcanvas, _cdRound(xc), _cdRound(yc), _cdRound(w), _cdRound(h), angle1, angle2);
}
static void cdcgm_EllipticalArc(cgmPoint center, cgmPoint first, cgmPoint second, double angle1, double angle2, int arc, cdCGM* cd_cgm)
{
/* oriented ellipsis are not supported in CD */
double w = 2*sScaleW(second.x-first.x);
double h = 2*sScaleH(second.y-first.y);
fix_angles(cd_cgm, &angle1, &angle2);
if (arc==CGM_OPENARC)
cdfCanvasArc(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), w, h, angle1, angle2);
else
{
if (arc==CGM_PIE)
cdfCanvasSector(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), w, h, angle1, angle2);
else /* CGM_CHORD */
cdfCanvasChord(cd_cgm->canvas, sScaleX(center.x), sScaleY(center.y), w, h, angle1, angle2);
}
}
void cdfSimMark(cdCanvas* canvas, double x, double y)
{
int oldinteriorstyle = canvas->interior_style;
int oldlinestyle = canvas->line_style;
int oldlinewidth = canvas->line_width;
double size, half_size, bottom, top, left, right;
if (canvas->mark_type == CD_DIAMOND ||
canvas->mark_type == CD_HOLLOW_DIAMOND)
{
if (canvas->use_origin)
{
x += canvas->forigin.x;
y += canvas->forigin.y;
}
if (canvas->invert_yaxis)
y = _cdInvertYAxis(canvas, y);
}
size = (double)canvas->mark_size;
half_size = size / 2;
bottom = y - half_size;
top = y + half_size;
left = x - half_size;
right = x + half_size;
if (canvas->interior_style != CD_SOLID &&
(canvas->mark_type == CD_CIRCLE ||
canvas->mark_type == CD_BOX ||
canvas->mark_type == CD_DIAMOND))
cdCanvasInteriorStyle(canvas, CD_SOLID);
if (canvas->line_style != CD_CONTINUOUS &&
(canvas->mark_type == CD_STAR ||
canvas->mark_type == CD_PLUS ||
canvas->mark_type == CD_X ||
canvas->mark_type == CD_HOLLOW_BOX ||
canvas->mark_type == CD_HOLLOW_CIRCLE ||
canvas->mark_type == CD_HOLLOW_DIAMOND))
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
if (canvas->line_width != 1 &&
(canvas->mark_type == CD_STAR ||
canvas->mark_type == CD_PLUS ||
canvas->mark_type == CD_X ||
canvas->mark_type == CD_HOLLOW_BOX ||
canvas->mark_type == CD_HOLLOW_CIRCLE ||
canvas->mark_type == CD_HOLLOW_DIAMOND))
cdCanvasLineWidth(canvas, 1);
switch (canvas->mark_type)
{
case CD_STAR:
cdfCanvasLine(canvas, left, bottom, right, top);
cdfCanvasLine(canvas, left, top, right, bottom);
/* continue */
case CD_PLUS:
cdfCanvasLine(canvas, left, y, right, y);
cdfCanvasLine(canvas, x, bottom, x, top);
break;
case CD_X:
cdfCanvasLine(canvas, left, bottom, right, top);
cdfCanvasLine(canvas, left, top, right, bottom);
break;
case CD_HOLLOW_CIRCLE:
cdfCanvasArc(canvas, x, y, size, size, 0, 360);
break;
case CD_HOLLOW_BOX:
cdfCanvasRect(canvas, left, right, bottom, top);
break;
case CD_CIRCLE:
cdfCanvasSector(canvas, x, y, size, size, 0, 360);
break;
case CD_BOX:
cdfCanvasBox(canvas, left, right, bottom, top);
break;
case CD_HOLLOW_DIAMOND:
case CD_DIAMOND:
/* Do not use Begin/End here so Mark can be used inside a regular BeginEnd loop */
if (!canvas->cxFPoly)
{
cdPoint poly[5]; /* leave room for one more point */
poly[0].x = _cdRound(left);
poly[0].y = _cdRound(y);
poly[1].x = _cdRound(x);
poly[1].y = _cdRound(top);
poly[2].x = _cdRound(right);
poly[2].y = _cdRound(y);
poly[3].x = _cdRound(x);
poly[3].y = _cdRound(bottom);
if (canvas->mark_type == CD_DIAMOND)
cdPoly(canvas, CD_FILL, poly, 4);
else
cdPoly(canvas, CD_CLOSED_LINES, poly, 4);
}
else
{
cdfPoint poly[5]; /* leave room for one more point */
poly[0].x = left;
poly[0].y = y;
poly[1].x = x;
poly[1].y = top;
poly[2].x = right;
poly[2].y = y;
poly[3].x = x;
poly[3].y = bottom;
if (canvas->mark_type == CD_DIAMOND)
canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
else
canvas->cxFPoly(canvas->ctxcanvas, CD_CLOSED_LINES, poly, 4);
}
break;
}
if (canvas->interior_style != oldinteriorstyle &&
(canvas->mark_type == CD_CIRCLE ||
canvas->mark_type == CD_BOX ||
canvas->mark_type == CD_DIAMOND))
cdCanvasInteriorStyle(canvas, oldinteriorstyle);
if (canvas->line_style != oldlinestyle &&
(canvas->mark_type == CD_STAR ||
canvas->mark_type == CD_PLUS ||
canvas->mark_type == CD_X ||
canvas->mark_type == CD_HOLLOW_BOX ||
canvas->mark_type == CD_HOLLOW_CIRCLE ||
canvas->mark_type == CD_HOLLOW_DIAMOND))
cdCanvasLineStyle(canvas, oldlinestyle);
if (canvas->line_width != oldlinewidth &&
(canvas->mark_type == CD_STAR ||
canvas->mark_type == CD_PLUS ||
canvas->mark_type == CD_X ||
canvas->mark_type == CD_HOLLOW_BOX ||
canvas->mark_type == CD_HOLLOW_CIRCLE ||
canvas->mark_type == CD_HOLLOW_DIAMOND))
cdCanvasLineWidth(canvas, oldlinewidth);
}
static int cdplay(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax, void *data)
{
tPrimNode *prim;
cdCanvas* pic_canvas = (cdCanvas*)data;
cdCtxCanvas* ctxcanvas = pic_canvas->ctxcanvas;
int p, i, n, scale = 0,
pic_xmin = ctxcanvas->xmin,
pic_ymin = ctxcanvas->ymin;
double factorX = 1, factorY = 1;
if ((ctxcanvas->xmax-ctxcanvas->xmin+1)>1 &&
(ctxcanvas->ymax-ctxcanvas->ymin+1)>1 &&
(xmax-xmin+1)>1 &&
(ymax-ymin+1)>1)
{
scale = 1;
factorX = ((double)(xmax-xmin+1)) / ((double)(ctxcanvas->xmax-ctxcanvas->xmin+1));
factorY = ((double)(ymax-ymin+1)) / ((double)(ctxcanvas->ymax-ctxcanvas->ymin+1));
}
if (cdsizecb)
{
int err;
err = cdsizecb(canvas, pic_canvas->w, pic_canvas->h, pic_canvas->w_mm, pic_canvas->h_mm);
if (err)
return CD_ERROR;
}
prim = ctxcanvas->prim_first;
for (i = 0; i < ctxcanvas->prim_n; i++)
{
switch (prim->type)
{
case CDPIC_LINE:
primUpdateAttrib_Line(prim, canvas);
cdCanvasLine(canvas, sScaleX(prim->param.lineboxrect.x1), sScaleY(prim->param.lineboxrect.y1), sScaleX(prim->param.lineboxrect.x2), sScaleY(prim->param.lineboxrect.y2));
break;
case CDPIC_FLINE:
primUpdateAttrib_Line(prim, canvas);
cdfCanvasLine(canvas, sfScaleX(prim->param.lineboxrectf.x1), sfScaleY(prim->param.lineboxrectf.y1), sfScaleX(prim->param.lineboxrectf.x2), sfScaleY(prim->param.lineboxrectf.y2));
break;
case CDPIC_RECT:
primUpdateAttrib_Line(prim, canvas);
cdCanvasRect(canvas, sScaleX(prim->param.lineboxrect.x1), sScaleX(prim->param.lineboxrect.x2), sScaleY(prim->param.lineboxrect.y1), sScaleY(prim->param.lineboxrect.y2));
break;
case CDPIC_FRECT:
primUpdateAttrib_Line(prim, canvas);
cdfCanvasRect(canvas, sfScaleX(prim->param.lineboxrectf.x1), sfScaleX(prim->param.lineboxrectf.x2), sfScaleY(prim->param.lineboxrectf.y1), sfScaleY(prim->param.lineboxrectf.y2));
break;
case CDPIC_BOX:
primUpdateAttrib_Fill(prim, canvas);
cdCanvasBox(canvas, sScaleX(prim->param.lineboxrect.x1), sScaleX(prim->param.lineboxrect.x2), sScaleY(prim->param.lineboxrect.y1), sScaleY(prim->param.lineboxrect.y2));
break;
case CDPIC_FBOX:
primUpdateAttrib_Fill(prim, canvas);
cdfCanvasBox(canvas, sfScaleX(prim->param.lineboxrectf.x1), sfScaleX(prim->param.lineboxrectf.x2), sfScaleY(prim->param.lineboxrectf.y1), sfScaleY(prim->param.lineboxrectf.y2));
break;
case CDPIC_ARC:
primUpdateAttrib_Line(prim, canvas);
cdCanvasArc(canvas, sScaleX(prim->param.arcsectorchord.xc), sScaleY(prim->param.arcsectorchord.yc), sScaleW(prim->param.arcsectorchord.w), sScaleH(prim->param.arcsectorchord.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_FARC:
primUpdateAttrib_Line(prim, canvas);
cdfCanvasArc(canvas, sfScaleX(prim->param.arcsectorchordf.xc), sfScaleY(prim->param.arcsectorchordf.yc), sfScaleW(prim->param.arcsectorchordf.w), sfScaleH(prim->param.arcsectorchordf.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_SECTOR:
primUpdateAttrib_Fill(prim, canvas);
cdCanvasSector(canvas, sScaleX(prim->param.arcsectorchord.xc), sScaleY(prim->param.arcsectorchord.yc), sScaleW(prim->param.arcsectorchord.w), sScaleH(prim->param.arcsectorchord.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_FSECTOR:
primUpdateAttrib_Fill(prim, canvas);
cdfCanvasSector(canvas, sfScaleX(prim->param.arcsectorchordf.xc), sfScaleY(prim->param.arcsectorchordf.yc), sfScaleW(prim->param.arcsectorchordf.w), sfScaleH(prim->param.arcsectorchordf.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_CHORD:
primUpdateAttrib_Fill(prim, canvas);
cdCanvasChord(canvas, sScaleX(prim->param.arcsectorchord.xc), sScaleY(prim->param.arcsectorchord.yc), sScaleW(prim->param.arcsectorchord.w), sScaleH(prim->param.arcsectorchord.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_FCHORD:
primUpdateAttrib_Fill(prim, canvas);
cdfCanvasChord(canvas, sfScaleX(prim->param.arcsectorchordf.xc), sfScaleY(prim->param.arcsectorchordf.yc), sfScaleW(prim->param.arcsectorchordf.w), sfScaleH(prim->param.arcsectorchordf.h), prim->param.arcsectorchord.angle1, prim->param.arcsectorchord.angle2);
break;
case CDPIC_TEXT:
primUpdateAttrib_Text(prim, canvas);
cdCanvasText(canvas, sScaleX(prim->param.text.x), sScaleY(prim->param.text.y), prim->param.text.s);
break;
case CDPIC_FTEXT:
primUpdateAttrib_Text(prim, canvas);
cdfCanvasText(canvas, sfScaleX(prim->param.textf.x), sfScaleY(prim->param.textf.y), prim->param.text.s);
break;
case CDPIC_POLY:
if (prim->param.poly.mode == CD_FILL)
primUpdateAttrib_Fill(prim, canvas);
else
primUpdateAttrib_Line(prim, canvas);
cdCanvasBegin(canvas, prim->param.poly.mode);
for (p = 0; p < prim->param.poly.n; p++)
cdCanvasVertex(canvas, sScaleX(prim->param.poly.points[p].x), sScaleY(prim->param.poly.points[p].y));
cdCanvasEnd(canvas);
break;
case CDPIC_FPOLY:
if (prim->param.poly.mode == CD_FILL)
primUpdateAttrib_Fill(prim, canvas);
else
primUpdateAttrib_Line(prim, canvas);
cdCanvasBegin(canvas, prim->param.polyf.mode);
for (p = 0; p < prim->param.polyf.n; p++)
cdfCanvasVertex(canvas, sfScaleX(prim->param.polyf.points[p].x), sfScaleY(prim->param.polyf.points[p].y));
cdCanvasEnd(canvas);
break;
case CDPIC_PATH:
if (prim->param.path.fill)
primUpdateAttrib_Fill(prim, canvas);
else
primUpdateAttrib_Line(prim, canvas);
cdCanvasBegin(canvas, CD_PATH);
n = 0;
for (p=0; p<prim->param.path.path_n; p++)
{
cdCanvasPathSet(canvas, prim->param.path.path[p]);
switch(prim->param.path.path[p])
{
case CD_PATH_MOVETO:
case CD_PATH_LINETO:
cdCanvasVertex(canvas, sScaleX(prim->param.path.points[n].x), sScaleY(prim->param.path.points[n].y));
n++;
break;
case CD_PATH_CURVETO:
case CD_PATH_ARC:
{
cdCanvasVertex(canvas, sScaleX(prim->param.path.points[n].x), sScaleY(prim->param.path.points[n].y));
cdCanvasVertex(canvas, sScaleX(prim->param.path.points[n+1].x), sScaleY(prim->param.path.points[n+1].y));
cdCanvasVertex(canvas, sScaleX(prim->param.path.points[n+2].x), sScaleY(prim->param.path.points[n+2].y));
n += 3;
}
break;
}
}
cdCanvasEnd(canvas);
break;
case CDPIC_FPATH:
if (prim->param.path.fill)
primUpdateAttrib_Fill(prim, canvas);
else
primUpdateAttrib_Line(prim, canvas);
cdCanvasBegin(canvas, CD_PATH);
n = 0;
for (p=0; p<prim->param.pathf.path_n; p++)
{
cdCanvasPathSet(canvas, prim->param.pathf.path[p]);
switch(prim->param.pathf.path[p])
{
case CD_PATH_MOVETO:
case CD_PATH_LINETO:
cdfCanvasVertex(canvas, sfScaleX(prim->param.pathf.points[n].x), sfScaleY(prim->param.pathf.points[n].y));
n++;
break;
case CD_PATH_CURVETO:
case CD_PATH_ARC:
{
cdfCanvasVertex(canvas, sfScaleX(prim->param.pathf.points[n].x), sfScaleY(prim->param.pathf.points[n].y));
cdfCanvasVertex(canvas, sfScaleX(prim->param.pathf.points[n+1].x), sfScaleY(prim->param.pathf.points[n+1].y));
cdfCanvasVertex(canvas, sfScaleX(prim->param.pathf.points[n+2].x), sfScaleY(prim->param.pathf.points[n+2].y));
n += 3;
}
break;
}
}
cdCanvasEnd(canvas);
break;
case CDPIC_IMAGERGB:
cdCanvasPutImageRectRGB(canvas, prim->param.imagergba.iw, prim->param.imagergba.ih, prim->param.imagergba.r, prim->param.imagergba.g, prim->param.imagergba.b, sScaleX(prim->param.imagergba.x), sScaleY(prim->param.imagergba.y), sScaleW(prim->param.imagergba.w), sScaleH(prim->param.imagergba.h), 0, 0, 0, 0);
break;
case CDPIC_IMAGERGBA:
cdCanvasPutImageRectRGBA(canvas, prim->param.imagergba.iw, prim->param.imagergba.ih, prim->param.imagergba.r, prim->param.imagergba.g, prim->param.imagergba.b, prim->param.imagergba.a, sScaleX(prim->param.imagergba.x), sScaleY(prim->param.imagergba.y), sScaleW(prim->param.imagergba.w), sScaleH(prim->param.imagergba.h), 0, 0, 0, 0);
break;
case CDPIC_IMAGEMAP:
cdCanvasPutImageRectMap(canvas, prim->param.imagemap.iw, prim->param.imagemap.ih, prim->param.imagemap.index, prim->param.imagemap.colors, sScaleX(prim->param.imagemap.x), sScaleY(prim->param.imagemap.y), sScaleW(prim->param.imagemap.w), sScaleH(prim->param.imagemap.h), 0, 0, 0, 0);
break;
case CDPIC_PIXEL:
cdCanvasPixel(canvas, sScaleX(prim->param.pixel.x), sScaleY(prim->param.pixel.y), prim->param.pixel.color);
break;
}
prim = prim->next;
}
return CD_OK;
}
static int cdplay(cdCanvas* canvas, int xmin, int xmax, int ymin, int ymax, void *data)
{
char* filename = (char*)data;
FILE* file;
char TextBuffer[512];
int iparam1, iparam2, iparam3, iparam4, iparam5, iparam6, iparam7, iparam8, iparam9, iparam10;
int c, t, n, w, h, func;
double dparam1, dparam2, dparam3, dparam4, dparam5, dparam6;
unsigned char* stipple, * _stipple, *red, *green, *blue, *_red, *_green, *_blue, *index, *_index, *_alpha, *alpha;
long int *pattern, *palette, *_pattern, *_palette, *colors, *_colors;
int* dashes;
double matrix[6];
const char * font_family[] =
{
"System", /* CD_SYSTEM */
"Courier", /* CD_COURIER */
"Times", /* CD_TIMES_ROMAN */
"Helvetica" /* CD_HELVETICA */
};
file = fopen(filename, "r");
if (!file)
return CD_ERROR;
func = -1;
w = 0;
h = 0;
factorX = 1;
factorY = 1;
offsetX = 0;
offsetY = 0;
factorS = 1;
fscanf(file, "%s %d %d", TextBuffer, &w, &h);
if (strcmp(TextBuffer, "CDMF") != 0)
{
fclose(file);
return CD_ERROR;
}
if (w>1 && h>1 && xmax!=0 && ymax!=0)
{
offsetX = xmin;
offsetY = ymin;
factorX = ((double)(xmax-xmin)) / (w-1);
factorY = ((double)(ymax-ymin)) / (h-1);
if (factorX < factorY)
factorS = factorX;
else
factorS = factorY;
}
if (cdsizecb)
{
int err;
err = cdsizecb(canvas, w, h, w, h);
if (err)
return CD_ERROR;
}
while (!feof(file))
{
fscanf(file, "%d", &func);
if (feof(file))
break;
switch (func)
{
case CDMF_FLUSH:
cdCanvasFlush(canvas);
break;
case CDMF_CLEAR:
cdCanvasClear(canvas);
break;
case CDMF_CLIP:
fscanf(file, "%d", &iparam1);
cdCanvasClip(canvas, iparam1);
break;
case CDMF_CLIPAREA:
fscanf(file, "%d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4);
cdCanvasClipArea(canvas, sScaleX(iparam1), sScaleX(iparam2), sScaleY(iparam3), sScaleY(iparam4));
break;
case CDMF_FCLIPAREA:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
cdfCanvasClipArea(canvas, sfScaleX(dparam1), sfScaleX(dparam2), sfScaleY(dparam3), sfScaleY(dparam4));
break;
case CDMF_MATRIX:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &matrix[0], &matrix[1], &matrix[2], &matrix[3], &matrix[4], &matrix[5]);
cdCanvasTransform(canvas, matrix);
break;
case CDMF_RESETMATRIX:
cdCanvasTransform(canvas, NULL);
break;
case CDMF_WCLIPAREA:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasClipArea(canvas, dparam1, dparam2, dparam3, dparam4);
break;
case CDMF_LINE:
fscanf(file, "%d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4);
cdCanvasLine(canvas, sScaleX(iparam1), sScaleY(iparam2), sScaleX(iparam3), sScaleY(iparam4));
break;
case CDMF_FLINE:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
cdfCanvasLine(canvas, sfScaleX(dparam1), sfScaleY(dparam2), sfScaleX(dparam3), sfScaleY(dparam4));
break;
case CDMF_WLINE:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasLine(canvas, dparam1, dparam2, dparam3, dparam4);
break;
case CDMF_RECT:
fscanf(file, "%d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4);
cdCanvasRect(canvas, sScaleX(iparam1), sScaleX(iparam2), sScaleY(iparam3), sScaleY(iparam4));
break;
case CDMF_FRECT:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
cdfCanvasRect(canvas, sfScaleX(dparam1), sfScaleX(dparam2), sfScaleY(dparam3), sfScaleY(dparam4));
break;
case CDMF_WRECT:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasRect(canvas, dparam1, dparam2, dparam3, dparam4);
break;
case CDMF_BOX:
fscanf(file, "%d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4);
cdCanvasBox(canvas, sScaleX(iparam1), sScaleX(iparam2), sScaleY(iparam3), sScaleY(iparam4));
break;
case CDMF_WBOX:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasBox(canvas, dparam1, dparam2, dparam3, dparam4);
break;
case CDMF_FBOX:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
cdfCanvasBox(canvas, sfScaleX(dparam1), sfScaleX(dparam2), sfScaleY(dparam3), sfScaleY(dparam4));
break;
case CDMF_ARC:
fscanf(file, "%d %d %d %d %lg %lg", &iparam1, &iparam2, &iparam3, &iparam4, &dparam1, &dparam2);
cdCanvasArc(canvas, sScaleX(iparam1), sScaleY(iparam2), sScaleW(iparam3), sScaleH(iparam4), dparam1, dparam2);
break;
case CDMF_FARC:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
cdfCanvasArc(canvas, sfScaleX(dparam1), sfScaleY(dparam2), sfScaleW(dparam3), sfScaleH(dparam4), dparam5, dparam6);
break;
case CDMF_WARC:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
wdCanvasArc(canvas, dparam1, dparam2, dparam3, dparam4, dparam5, dparam6);
break;
case CDMF_SECTOR:
fscanf(file, "%d %d %d %d %lg %lg", &iparam1, &iparam2, &iparam3, &iparam4, &dparam1, &dparam2);
cdCanvasSector(canvas, sScaleX(iparam1), sScaleY(iparam2), sScaleW(iparam3), sScaleH(iparam4), dparam1, dparam2);
break;
case CDMF_FSECTOR:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
cdfCanvasSector(canvas, sfScaleX(dparam1), sfScaleY(dparam2), sfScaleW(dparam3), sfScaleH(dparam4), dparam5, dparam6);
break;
case CDMF_WSECTOR:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
wdCanvasSector(canvas, dparam1, dparam2, dparam3, dparam4, dparam5, dparam6);
break;
case CDMF_CHORD:
fscanf(file, "%d %d %d %d %lg %lg", &iparam1, &iparam2, &iparam3, &iparam4, &dparam1, &dparam2);
cdCanvasChord(canvas, sScaleX(iparam1), sScaleY(iparam2), sScaleW(iparam3), sScaleH(iparam4), dparam1, dparam2);
break;
case CDMF_FCHORD:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
cdfCanvasChord(canvas, sfScaleX(dparam1), sfScaleY(dparam2), sfScaleW(dparam3), sfScaleH(dparam4), dparam5, dparam6);
break;
case CDMF_WCHORD:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4, &dparam5, &dparam6);
wdCanvasChord(canvas, dparam1, dparam2, dparam3, dparam4, dparam5, dparam6);
break;
case CDMF_TEXT:
fscanf(file, "%d %d %[^\n\r]", &iparam1, &iparam2, TextBuffer);
cdCanvasText(canvas, sScaleX(iparam1), sScaleY(iparam2), TextBuffer);
break;
case CDMF_FTEXT:
fscanf(file, "%lg %lg %[^\n\r]", &dparam1, &dparam2, TextBuffer);
cdfCanvasText(canvas, sfScaleX(dparam1), sfScaleY(dparam2), TextBuffer);
break;
case CDMF_WTEXT:
fscanf(file, "%lg %lg %[^\n\r]", &dparam1, &dparam2, TextBuffer);
wdCanvasText(canvas, dparam1, dparam2, TextBuffer);
break;
case CDMF_BEGIN:
fscanf(file, "%d", &iparam1);
cdCanvasBegin(canvas, iparam1);
break;
case CDMF_VERTEX:
fscanf(file, "%d %d", &iparam1, &iparam2);
cdCanvasVertex(canvas, sScaleX(iparam1), sScaleY(iparam2));
break;
case CDMF_FVERTEX:
fscanf(file, "%lg %lg", &dparam1, &dparam2);
cdfCanvasVertex(canvas, sfScaleX(dparam1), sfScaleY(dparam2));
break;
case CDMF_WVERTEX:
fscanf(file, "%lg %lg", &dparam1, &dparam2);
wdCanvasVertex(canvas, dparam1, dparam2);
break;
case CDMF_END:
cdCanvasEnd(canvas);
break;
case CDMF_MARK:
fscanf(file, "%d %d", &iparam1, &iparam2);
cdCanvasMark(canvas, sScaleX(iparam1), sScaleY(iparam2));
break;
case CDMF_WMARK:
fscanf(file, "%lg %lg", &dparam1, &dparam2);
wdCanvasMark(canvas, dparam1, dparam2);
break;
case CDMF_BACKOPACITY:
fscanf(file, "%d", &iparam1);
cdCanvasBackOpacity(canvas, iparam1);
break;
case CDMF_WRITEMODE:
fscanf(file, "%d", &iparam1);
cdCanvasWriteMode(canvas, iparam1);
break;
case CDMF_LINESTYLE:
fscanf(file, "%d", &iparam1);
cdCanvasLineStyle(canvas, iparam1);
break;
case CDMF_LINEWIDTH:
fscanf(file, "%d", &iparam1);
cdCanvasLineWidth(canvas, sScaleS(iparam1));
break;
case CDMF_LINECAP:
fscanf(file, "%d", &iparam1);
cdCanvasLineCap(canvas, iparam1);
break;
case CDMF_LINEJOIN:
fscanf(file, "%d", &iparam1);
cdCanvasLineJoin(canvas, iparam1);
break;
case CDMF_LINESTYLEDASHES:
fscanf(file, "%d", &iparam1);
dashes = (int*)malloc(iparam1*sizeof(int));
for (c = 0; c < iparam1; c++)
fscanf(file, "%d", &dashes[c]);
cdCanvasLineStyleDashes(canvas, dashes, iparam1);
free(dashes);
break;
case CDMF_FILLMODE:
fscanf(file, "%d", &iparam1);
cdCanvasFillMode(canvas, iparam1);
break;
case CDMF_INTERIORSTYLE:
fscanf(file, "%d", &iparam1);
cdCanvasInteriorStyle(canvas, iparam1);
break;
case CDMF_HATCH:
fscanf(file, "%d", &iparam1);
cdCanvasHatch(canvas, iparam1);
break;
case CDMF_STIPPLE:
fscanf(file, "%d %d", &iparam1, &iparam2);
t = iparam1 * iparam2;
stipple = (unsigned char*)malloc(t);
_stipple = stipple;
for (c = 0; c < t; c++)
{
fscanf(file, "%d", &iparam3);
*_stipple++ = (unsigned char)iparam3;
}
cdCanvasStipple(canvas, iparam1, iparam2, stipple);
free(stipple);
break;
case CDMF_PATTERN:
fscanf(file, "%d %d", &iparam1, &iparam2);
t = iparam1 * iparam2;
pattern = (long int*)malloc(t * sizeof(long));
_pattern = pattern;
for (c = 0; c < t; c++)
{
fscanf(file, "%d %d %d", &iparam3, &iparam4, &iparam5);
*_pattern++ = cdEncodeColor((unsigned char)iparam3, (unsigned char)iparam4, (unsigned char)iparam5);
}
cdCanvasPattern(canvas, iparam1, iparam2, pattern);
free(pattern);
break;
case CDMF_OLDFONT:
fscanf(file, "%d %d %d", &iparam1, &iparam2, &iparam3);
if (iparam1 < 0 || iparam1 > 3) break;
if (iparam3 < 0)
{
iparam3 = -sScaleH(abs(iparam3));
if (iparam3 > -5) iparam3 = -5;
}
else
{
iparam3 = sScaleH(abs(iparam3));
if (iparam3 < 5) iparam3 = 5;
}
cdCanvasFont(canvas, font_family[iparam1], iparam2, iparam3);
break;
case CDMF_FONT:
fscanf(file, "%d %d %[^\n\r]", &iparam2, &iparam3, TextBuffer);
if (iparam3 < 0)
{
iparam3 = -sScaleH(abs(iparam3));
if (iparam3 > -5) iparam3 = -5;
}
else
{
iparam3 = sScaleH(abs(iparam3));
if (iparam3 < 5) iparam3 = 5;
}
cdCanvasFont(canvas, TextBuffer, iparam2, iparam3);
break;
case CDMF_NATIVEFONT:
fscanf(file, "%[^\n\r]", TextBuffer);
cdCanvasNativeFont(canvas, TextBuffer);
break;
case CDMF_TEXTALIGNMENT:
fscanf(file, "%d", &iparam1);
cdCanvasTextAlignment(canvas, iparam1);
break;
case CDMF_TEXTORIENTATION:
fscanf(file, "%lg", &dparam1);
cdCanvasTextOrientation(canvas, dparam1);
break;
case CDMF_MARKTYPE:
fscanf(file, "%d", &iparam1);
cdCanvasMarkType(canvas, iparam1);
break;
case CDMF_MARKSIZE:
fscanf(file, "%d", &iparam1);
cdCanvasMarkSize(canvas, sScaleS(iparam1));
break;
case CDMF_PALETTE:
fscanf(file, "%d %d", &iparam1, &iparam2);
_palette = palette = (long int*)malloc(iparam1);
for (c = 0; c < iparam1; c++)
{
fscanf(file, "%d %d %d", &iparam3, &iparam4, &iparam5);
*_palette++ = cdEncodeColor((unsigned char)iparam3, (unsigned char)iparam4, (unsigned char)iparam5);
}
cdCanvasPalette(canvas, iparam1, palette, iparam2);
free(palette);
break;
case CDMF_BACKGROUND:
fscanf(file, "%d %d %d", &iparam1, &iparam2, &iparam3);
cdCanvasSetBackground(canvas, cdEncodeColor((unsigned char)iparam1, (unsigned char)iparam2, (unsigned char)iparam3));
break;
case CDMF_FOREGROUND:
fscanf(file, "%d %d %d", &iparam1, &iparam2, &iparam3);
cdCanvasSetForeground(canvas, cdEncodeColor((unsigned char)iparam1, (unsigned char)iparam2, (unsigned char)iparam3));
break;
case CDMF_PUTIMAGERGB:
fscanf(file, "%d %d %d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4, &iparam5, &iparam6);
t = iparam1 * iparam2;
_red = red = (unsigned char*) malloc(t);
_green = green = (unsigned char*) malloc(t);
_blue = blue = (unsigned char*) malloc(t);
for (c = 0; c < t; c++)
{
fscanf(file, "%d %d %d", &iparam7, &iparam8, &iparam9);
*_red++ = (unsigned char)iparam7;
*_green++ = (unsigned char)iparam8;
*_blue++ = (unsigned char)iparam9;
}
cdCanvasPutImageRectRGB(canvas, iparam1, iparam2, red, green, blue, sScaleX(iparam3), sScaleY(iparam4), sScaleW(iparam5), sScaleH(iparam6), 0, 0, 0, 0);
free(red);
free(green);
free(blue);
break;
case CDMF_PUTIMAGERGBA:
fscanf(file, "%d %d %d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4, &iparam5, &iparam6);
t = iparam1 * iparam2;
_red = red = (unsigned char*) malloc(t);
_green = green = (unsigned char*) malloc(t);
_blue = blue = (unsigned char*) malloc(t);
_alpha = alpha = (unsigned char*) malloc(t);
for (c = 0; c < t; c++)
{
fscanf(file, "%d %d %d %d", &iparam7, &iparam8, &iparam9, &iparam10);
*_red++ = (unsigned char)iparam7;
*_green++ = (unsigned char)iparam8;
*_blue++ = (unsigned char)iparam9;
*_alpha++ = (unsigned char)iparam10;
}
cdCanvasPutImageRectRGBA(canvas, iparam1, iparam2, red, green, blue, alpha, sScaleX(iparam3), sScaleY(iparam4), sScaleW(iparam5), sScaleH(iparam6), 0, 0, 0, 0);
free(red);
free(green);
free(blue);
free(alpha);
break;
case CDMF_PUTIMAGEMAP:
fscanf(file, "%d %d %d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4, &iparam5, &iparam6);
t = iparam1 * iparam2;
n = 0;
_index = index = (unsigned char*) malloc(t);
for (c = 0; c < t; c++)
{
fscanf(file, "%d", &iparam7);
*_index++ = (unsigned char)iparam7;
if (iparam7 > n)
n = iparam7;
}
_colors = colors = (long int*)malloc(n);
for (c = 0; c < n; c++)
{
fscanf(file, "%d %d %d", &iparam7, &iparam8, &iparam9);
*_colors++ = cdEncodeColor((unsigned char)iparam7, (unsigned char)iparam8, (unsigned char)iparam9);
}
cdCanvasPutImageRectMap(canvas, iparam1, iparam2, index, colors, sScaleX(iparam3), sScaleY(iparam4), sScaleW(iparam5), sScaleH(iparam6), 0, 0, 0, 0);
free(index);
free(colors);
break;
case CDMF_PIXEL:
fscanf(file, "%d %d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4, &iparam5);
cdCanvasPixel(canvas, sScaleX(iparam1), sScaleY(iparam2), cdEncodeColor((unsigned char)iparam3, (unsigned char)iparam4, (unsigned char)iparam5));
break;
case CDMF_SCROLLAREA:
fscanf(file, "%d %d %d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4, &iparam5, &iparam6);
cdCanvasScrollArea(canvas, sScaleX(iparam1), sScaleX(iparam2), sScaleY(iparam3), sScaleY(iparam4), sScaleX(iparam5), sScaleY(iparam6));
break;
case CDMF_WVECTORTEXT:
fscanf(file, "%lg %lg %[^\n\r]", &dparam1, &dparam2, TextBuffer);
wdCanvasVectorText(canvas, dparam1, dparam2, TextBuffer);
break;
case CDMF_WMULTILINEVECTORTEXT:
fscanf(file, "%lg %lg %[^\n\r]", &dparam1, &dparam2, TextBuffer);
wdCanvasVectorText(canvas, dparam1, dparam2, TextBuffer);
break;
case CDMF_VECTORTEXT:
fscanf(file, "%d %d %[^\n\r]", &iparam1, &iparam2, TextBuffer);
cdCanvasVectorText(canvas, iparam1, iparam2, TextBuffer);
break;
case CDMF_MULTILINEVECTORTEXT:
fscanf(file, "%d %d %[^\n\r]", &iparam1, &iparam2, TextBuffer);
cdCanvasVectorText(canvas, iparam1, iparam2, TextBuffer);
break;
case CDMF_WVECTORCHARSIZE:
fscanf(file, "%lg", &dparam1);
wdCanvasVectorCharSize(canvas, dparam1);
break;
case CDMF_WVECTORTEXTSIZE:
fscanf(file, "%lg %lg %[^\n\r]", &dparam1, &dparam2, TextBuffer);
wdCanvasVectorTextSize(canvas, dparam1, dparam2, TextBuffer);
break;
case CDMF_WVECTORTEXTDIRECTION:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasVectorTextDirection(canvas, dparam1, dparam2, dparam3, dparam4);
break;
case CDMF_VECTORCHARSIZE:
fscanf(file, "%d", &iparam1);
cdCanvasVectorCharSize(canvas, iparam1);
break;
case CDMF_VECTORTEXTSIZE:
fscanf(file, "%d %d %[^\n\r]", &iparam1, &iparam2, TextBuffer);
cdCanvasVectorTextSize(canvas, iparam1, iparam2, TextBuffer);
break;
case CDMF_VECTORTEXTDIRECTION:
fscanf(file, "%d %d %d %d", &iparam1, &iparam2, &iparam3, &iparam4);
cdCanvasVectorTextDirection(canvas, iparam1, iparam2, iparam3, iparam4);
break;
case CDMF_VECTORFONT:
fscanf(file, "%[^\n\r]", TextBuffer);
cdCanvasVectorFont(canvas, TextBuffer);
break;
case CDMF_VECTORTEXTTRANSFORM:
fscanf(file, "%lg %lg %lg %lg %lg %lg", &matrix[0], &matrix[1], &matrix[2], &matrix[3], &matrix[4], &matrix[5]);
cdCanvasVectorTextTransform(canvas, matrix);
break;
case CDMF_WINDOW:
fscanf(file, "%lg %lg %lg %lg", &dparam1, &dparam2, &dparam3, &dparam4);
wdCanvasWindow(canvas, dparam1, dparam2, dparam3, dparam4);
break;
default:
fclose(file);
return CD_ERROR;
}
}
fclose(file);
return CD_OK;
}
