void cdKillCanvas(cdCanvas *canvas)
{
assert(canvas);
if (!_cdCheckCanvas(canvas)) return;
if (canvas == cdActiveCanvas())
cdActivate(NULL);
else
cdCanvasDeactivate(canvas);
canvas->cxKillCanvas(canvas->ctxcanvas);
if (canvas->pattern) free(canvas->pattern);
if (canvas->stipple) free(canvas->stipple);
if (canvas->poly) free(canvas->poly);
if (canvas->clip_poly) free(canvas->clip_poly);
if (canvas->fpoly) free(canvas->fpoly);
if (canvas->clip_fpoly) free(canvas->clip_fpoly);
if (canvas->line_dashes) free(canvas->line_dashes);
if (canvas->path) free(canvas->path);
cdKillVectorFont(canvas->vector_font);
cdKillSimulation(canvas->simulation);
memset(canvas, 0, sizeof(cdCanvas));
free(canvas);
}
static int iMatrixDrawCallDrawCB(Ihandle* ih, int lin, int col, int x1, int x2, int y1, int y2, IFniiiiiiC draw_cb)
{
int ret;
cdCanvas* old_cnv;
IUPMAT_CLIPAREA(ih, x1, x2, y1, y2);
cdCanvasClip(ih->data->cddbuffer, CD_CLIPAREA);
old_cnv = cdActiveCanvas();
if (old_cnv != ih->data->cddbuffer) /* backward compatibility code */
cdActivate(ih->data->cddbuffer);
ret = draw_cb(ih, lin, col, x1, x2, iupMatrixInvertYAxis(ih, y1), iupMatrixInvertYAxis(ih, y2), ih->data->cddbuffer);
cdCanvasClip(ih->data->cddbuffer, CD_CLIPOFF);
if (old_cnv && old_cnv != ih->data->cddbuffer) /* backward compatibility code */
{
cdActivate(old_cnv);
cdCanvasActivate(ih->data->cddbuffer);
}
if (ret == IUP_DEFAULT)
return 0;
return 1;
}
static int iMatrixDrawCallDrawCB(Ihandle* ih, int lin, int col, int x1, int x2, int y1, int y2, IFniiiiiiC draw_cb)
{
int ret;
cdCanvas* old_cnv;
iMatrixDrawSetCellClipping(ih, x1, x2, y1, y2);
old_cnv = cdActiveCanvas();
if (old_cnv != ih->data->cd_canvas) /* backward compatibility code */
cdActivate(ih->data->cd_canvas);
ret = draw_cb(ih, lin, col, x1, x2, iupMATRIX_INVERTYAXIS(ih, y1), iupMATRIX_INVERTYAXIS(ih, y2), ih->data->cd_canvas);
iMatrixDrawResetCellClipping(ih);
if (old_cnv && old_cnv != ih->data->cd_canvas) /* backward compatibility code */
{
cdActivate(old_cnv);
cdCanvasActivate(ih->data->cd_canvas);
}
if (ret == IUP_DEFAULT)
return 0;
return 1;
}
//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();
}
static void _wdHdcpyDoit(cdCanvas *canvas, cdCanvas *canvas_copy, void (*draw_func)(cdCanvas *canvas_copy))
{
cdCanvas *old_active;
double left, right, bottom, top; /* canvas visualization window */
int canvas_hsize, canvas_vsize; /* canvas sizes in pixels */
int hdcpy_hsize, hdcpy_vsize; /* paper sizes in points */
double canvas_vpr; /* canvas viewport distortion ratio */
double hdcpy_vpr; /* paper viewport distortion ratio */
int xc, yc; /* paper center in pixels */
int xmin, xmax, ymin, ymax; /* paper viewport */
/* Activate canvas visualization surface. */
if (cdCanvasActivate(canvas) != CD_OK) return;
/* Get current canvas window parameters and sizes. */
wdCanvasGetWindow(canvas, &left, &right, &bottom, &top);
cdCanvasGetSize(canvas, &canvas_hsize, &canvas_vsize, 0L, 0L);
/* Activate hardcopy visualization surface. */
if (cdCanvasActivate(canvas_copy) != CD_OK) return;
/* Set window parameters on hardcopy surface. */
wdCanvasWindow(canvas_copy, left, right, bottom, top);
/* Adjust paper viewport, centralized, matching canvas viewport. */
canvas_vpr = (double)canvas_vsize / (double)canvas_hsize;
cdCanvasGetSize(canvas_copy, &hdcpy_hsize, &hdcpy_vsize, 0L, 0L);
hdcpy_vpr = (double)hdcpy_vsize / (double)hdcpy_hsize;
xc = (int)((double)hdcpy_hsize/2.0);
yc = (int)((double)hdcpy_vsize/2.0);
if (canvas_vpr < hdcpy_vpr)
{
xmin = 0;
xmax = hdcpy_hsize;
ymin = yc - (int)((double)hdcpy_hsize*(double)canvas_vpr/2.0);
ymax = yc + (int)((double)hdcpy_hsize*(double)canvas_vpr/2.0);
}
else
{
xmin = xc - (int)((double)hdcpy_vsize/(double)canvas_vpr/2.0);
xmax = xc + (int)((double)hdcpy_vsize/(double)canvas_vpr/2.0);
ymin = 0;
ymax = hdcpy_vsize;
}
cdCanvasClipArea(canvas_copy, xmin, xmax, ymin, ymax);
cdCanvasClip(canvas_copy, CD_CLIPAREA);
wdCanvasViewport(canvas_copy, xmin, xmax, ymin, ymax);
/* for backward compatibility */
old_active = cdActiveCanvas();
cdActivate(canvas_copy);
/* Draw on hardcopy surface. */
draw_func(canvas_copy);
if (old_active) cdActivate(old_active);
}
static int iMatrixDrawCallDrawCB(Ihandle* ih, int cor, int lin, int col, int x1, int x2, int y1, int y2)
{
IFniiiiiiC cb = (IFniiiiiiC)IupGetCallback(ih, "DRAW_CB");
if(cb)
{
int ret;
cdCanvas* old_cnv = cdActiveCanvas();
if(cor == IMAT_TITLE_COLOR)
{
x1+=1;
x2-=1;
y1+=1;
y2-=1;
}
else if(!iupAttribGetInt(ih, "HIDEFOCUS"))
{
x1+=2;
x2-=2;
y1+=2;
y2-=2;
}
CdClipArea(x1, x2, y1, y2);
cdCanvasClip(ih->data->cddbuffer, CD_CLIPAREA);
if(old_cnv != ih->data->cddbuffer) /* backward compatibility code */
cdActivate(ih->data->cddbuffer);
ret = cb(ih, lin, col, x1, x2, (ih->data->YmaxC - (y1)), INVY(y2), ih->data->cddbuffer);
cdCanvasClip(ih->data->cddbuffer, CD_CLIPOFF);
if(old_cnv && old_cnv != ih->data->cddbuffer)
{
cdActivate(old_cnv);
cdCanvasActivate(ih->data->cddbuffer);
}
if (ret == IUP_DEFAULT)
return 0;
}
return 1;
}
/* Function used to call the client; is used when a cell must be repainted. */
static void iCellsCallDrawCb(Ihandle* ih, int xmin, int xmax, int ymin, int ymax, int i, int j)
{
int oldxmin, oldxmax, oldymin, oldymax, oldclip;
int w = ih->data->w;
int h = ih->data->h;
IFniiiiiiC draw_cb;
cdCanvas* old_cnv = cdActiveCanvas();
/* Getting clipping area for post restore */
oldclip = cdCanvasClip(ih->data->cd_canvas, CD_QUERY);
cdCanvasGetClipArea(ih->data->cd_canvas, &oldxmin, &oldxmax, &oldymin, &oldymax);
if (ih->data->clipped) /* Clipping the cell area */
{
int cxmin, cxmax, cymin, cymax;
cdCanvasClip(ih->data->cd_canvas, CD_CLIPAREA);
cxmin = xmin < 0 ? 0 : xmin;
cymin = ymin < 0 ? 0 : ymin;
cxmax = xmax > w ? w : xmax;
cymax = ymax > h ? h : ymax;
cdCanvasClipArea(ih->data->cd_canvas, cxmin, cxmax, cymin, cymax);
}
draw_cb = (IFniiiiiiC)IupGetCallback(ih, "DRAW_CB");
if (draw_cb)
{
if (old_cnv != ih->data->cd_canvas) /* backward compatibility code */
cdActivate(ih->data->cd_canvas);
draw_cb(ih, i, j, xmin, xmax, ymin, ymax, ih->data->cd_canvas);
if (old_cnv && old_cnv != ih->data->cd_canvas)
{
cdActivate(old_cnv);
cdCanvasActivate(ih->data->cd_canvas);
}
}
cdCanvasClip(ih->data->cd_canvas, oldclip);
cdCanvasClipArea(ih->data->cd_canvas, oldxmin, oldxmax, oldymin, oldymax);
}
/**
* Function used to call the client; is used when a cell must be repainted.
*/
static void call_apl_draw(TCells* obj, int xmin, int xmax,
int ymin, int ymax, int i, int j) {
int cxmin, cxmax, cymin, cymax;
int oldxmin, oldxmax, oldymin, oldymax;
int w = obj->width;
int h = obj->height;
/* Getting clipping area for post restore */
int oldclip = cdCanvasClip(obj->cddbuffer,CD_QUERY);
cdCanvasGetClipArea(obj->cddbuffer,&oldxmin, &oldxmax, &oldymin, &oldymax);
/* Clipoing the cell area */
if (obj->clipped) {
cdCanvasClip(obj->cddbuffer, CD_CLIPAREA);
cxmin = xmin < 0 ? 0 : xmin;
cymin = ymin < 0 ? 0 : ymin;
cxmax = xmax > w ? w : xmax;
cymax = ymax > h ? h : ymax;
cdCanvasClipArea(obj->cddbuffer, xmin, xmax, ymin, ymax);
}
/* Calling the application draw callback. */
{
TDrawCb func = (TDrawCb)IupGetCallback(obj->self, IUP_DRAW_CB);
if (func)
{
cdCanvas* old_cnv = cdActiveCanvas();
if (old_cnv != obj->cddbuffer) /* backward compatibility code */
cdActivate(obj->cddbuffer);
func(obj->self, i, j, xmin, xmax, ymin, ymax, obj->cddbuffer);
if (old_cnv != obj->cddbuffer)
cdActivate(old_cnv);
}
}
/* Restoring clipping attributes */
cdCanvasClip(obj->cddbuffer,oldclip);
cdCanvasClipArea(obj->cddbuffer, oldxmin, oldxmax, oldymin, oldymax);
}
