static int iMatrixResize_CB(Ihandle* ih)
{
if (!ih->data->cddbuffer)
{
/* update canvas size */
cdCanvasActivate(ih->data->cdcanvas);
/* this can fail if canvas size is zero */
ih->data->cddbuffer = cdCreateCanvas(CD_DBUFFER, ih->data->cdcanvas);
}
if (!ih->data->cddbuffer)
return IUP_DEFAULT;
/* update size */
cdCanvasActivate(ih->data->cddbuffer);
cdCanvasGetSize(ih->data->cddbuffer, &ih->data->w, &ih->data->h, NULL, NULL);
iupMatrixEditForceHidden(ih);
ih->data->need_calcsize = 1;
iupMatrixDraw(ih, 0);
return IUP_DEFAULT;
}
/* Callback called when the tree has its size altered
dx, dy: Canvas size, in pixels. */
static int iTreeResizeCB(Ihandle* ih, int dx, int dy)
{
if(!ih->data->cddbuffer)
{
/* update canvas size */
cdCanvasActivate(ih->data->cdcanvas);
/* this can fail if canvas size is zero */
ih->data->cddbuffer = cdCreateCanvas(CD_DBUFFER, ih->data->cdcanvas);
if(ih->data->cddbuffer)
iTreeInitTree(ih);
}
if(!ih->data->cddbuffer)
return IUP_DEFAULT;
/* update canvas size */
cdCanvasActivate(ih->data->cddbuffer);
ih->data->XmaxC = dx - 1;
ih->data->YmaxC = dy - 1;
/* update render */
iupTreeEditCheckHidden(ih);
return IUP_DEFAULT;
}
static int iColorbarResize_CB(Ihandle* ih)
{
if (!ih->data->cddbuffer)
{
/* update canvas size */
cdCanvasActivate(ih->data->cdcanvas);
/* this can fail if canvas size is zero */
ih->data->cddbuffer = cdCreateCanvas(CD_DBUFFER, ih->data->cdcanvas);
}
if (!ih->data->cddbuffer)
return IUP_DEFAULT;
/* update size */
cdCanvasActivate(ih->data->cddbuffer);
cdCanvasGetSize(ih->data->cddbuffer, &ih->data->w, &ih->data->h, NULL, NULL);
/* update render */
cdCanvasBackground(ih->data->cddbuffer, ih->data->bgcolor);
cdCanvasClear(ih->data->cddbuffer);
iColorbarRenderPreview(ih);
iColorbarRenderCells(ih);
return IUP_DEFAULT;
}
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);
}
void SimpleDraw(cdCanvas* canvas)
{
#ifdef USE_OPENGL
if (use_opengl)
SimpleUpdateSize(canvas);
#endif
/* refresh CD canvas size, when window size has changed */
cdCanvasActivate(canvas);
if (simple_draw == DRAW_TEXTFONTS)
SimpleDrawTextFonts(canvas);
else if (simple_draw == DRAW_TEXTALIGN)
SimpleDrawTextAlign(canvas);
else if (simple_draw == DRAW_TEST)
SimpleDrawTest(canvas);
else
SimpleDrawAll(canvas);
/* Adds a new page, or
flushes the file, or
flushes the screen, or
swap the double buffer. */
cdCanvasFlush(canvas);
#ifdef USE_OPENGL
if (use_opengl)
SimpleFlush();
#endif
}
static int iColorBrowserResize_CB(Ihandle* ih)
{
if (!ih->data->cddbuffer)
{
/* update canvas size */
cdCanvasActivate(ih->data->cdcanvas);
/* this can fail if canvas size is zero */
ih->data->cddbuffer = cdCreateCanvas(CD_DBUFFERRGB, ih->data->cdcanvas);
}
if (!ih->data->cddbuffer)
return IUP_DEFAULT;
/* update size */
iColorBrowserUpdateSize(ih);
iColorBrowserUpdateCursorHue(ih);
iColorBrowserUpdateCursorSI(ih);
/* update render */
iColorBrowserRenderImageHue(ih);
iColorBrowserRenderImageSI(ih);
return IUP_DEFAULT;
}
static int iDialResize_CB(Ihandle* ih)
{
/* update size */
cdCanvasActivate(ih->data->cd_canvas);
cdCanvasGetSize(ih->data->cd_canvas, &ih->data->w, &ih->data->h, NULL, NULL);
/* update number of divisions */
switch(ih->data->orientation)
{
case IDIAL_VERTICAL:
ih->data->num_div = (int)((ih->data->h-2 * IDIAL_SPACE-2) * ih->data->density);
break;
case IDIAL_HORIZONTAL:
ih->data->num_div = (int)((ih->data->w-2 * IDIAL_SPACE-2) * ih->data->density);
break;
case IDIAL_CIRCULAR:
ih->data->num_div = (int)((dialmin(ih->data->w, ih->data->h)-2 * IDIAL_SPACE-2) * ih->data->density);
break;
}
if (ih->data->num_div < 3) ih->data->num_div = 3;
/* update render */
cdCanvasBackground(ih->data->cd_canvas, ih->data->bgcolor);
cdCanvasClear(ih->data->cd_canvas);
ih->data->Draw(ih);
return IUP_DEFAULT;
}
int iupTreeKeyNodeCalcPos(Ihandle* ih, int* x, int* y, int* text_x)
{
ItreeNodePtr node = (ItreeNodePtr)ih->data->root;
float posy = IupGetFloat(ih, "POSY");
float dy = IupGetFloat(ih, "DY");
float posx = IupGetFloat(ih, "POSX");
float dx = IupGetFloat(ih, "DX");
cdCanvasActivate(ih->data->cddbuffer);
*y = (int)((1.0 + posy/dy)*(ih->data->YmaxC-ITREE_TREE_TOP_MARGIN));
while(node != ih->data->selected)
{
if(node->visible == YES)
*y -= ITREE_NODE_Y;
node = node->next;
if(node == NULL)
return 0;
}
*y -= ITREE_NODE_Y;
*x = (int)(ITREE_TREE_LEFT_MARGIN - (ih->data->XmaxC - ITREE_NODE_X) * posx / dx) + ITREE_NODE_X * node->depth;
/* if node has a text associated to it... */
*text_x = 0;
if(node->name)
{
/* Calculates its dimensions */
*text_x = iupdrvFontGetStringWidth(ih, node->name);
}
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;
}
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 wheel_cb(Ihandle *ih,float delta,int x,int y,char* status)
{
int canvas_w, canvas_h;
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS");
(void)x;
(void)y;
(void)status;
if (scale+delta==0) /* skip 0 */
{
if (scale > 0)
scale = -1;
else
scale = 1;
}
else
scale += (int)delta;
cdCanvasActivate(canvas);
cdCanvasGetSize(canvas, &canvas_w, &canvas_h, NULL, NULL);
update_scrollbar(ih, canvas_w, canvas_h);
update_viewport(ih, canvas, IupGetFloat(ih, "POSX"), IupGetFloat(ih, "POSY"));
IupRedraw(ih, 0);
return IUP_DEFAULT;
}
/*
%F cdCreateCanvas para DBuffer.
O DC é um BITMAP em memoria.
*/
static void cdcreatecanvas(cdCanvas* canvas, void *data)
{
int w, h;
cdCanvas* canvas_dbuffer = (cdCanvas*)data;
if (!canvas_dbuffer)
return;
cdCanvasActivate(canvas_dbuffer); /* Update size */
w = canvas_dbuffer->w;
h = canvas_dbuffer->h;
if (w==0) w=1;
if (h==0) h=1;
Bitmap* bitmap = new Bitmap(w, h, PixelFormat24bppRGB);
bitmap->SetResolution((REAL)(canvas_dbuffer->xres*25.4), (REAL)(canvas_dbuffer->yres*25.4));
Graphics imggraphics(bitmap);
imggraphics.Clear(Color::White);
Graphics* graphics = new Graphics(bitmap);
canvas->w = w;
canvas->h = h;
canvas->bpp = 24;
/* Initialize base driver */
cdCtxCanvas* ctxcanvas = cdwpCreateCanvas(canvas, graphics, CDW_BMP);
ctxcanvas->bitmap = bitmap;
ctxcanvas->canvas_dbuffer = canvas_dbuffer;
}
int canvas_action_cb(Ihandle* canvas)
{
int x, y, canvas_width, canvas_height;
unsigned int ri, gi, bi;
imImage* image;
cdCanvas* cd_canvas = (cdCanvas*)IupGetAttribute(canvas, "cdCanvas");
Ihandle* config = (Ihandle*)IupGetAttribute(canvas, "CONFIG");
const char* background = IupConfigGetVariableStrDef(config, "MainWindow", "Background", "255 255 255");
IupGetIntInt(canvas, "DRAWSIZE", &canvas_width, &canvas_height);
cdCanvasActivate(cd_canvas);
/* draw the background */
sscanf(background, "%u %u %u", &ri, &gi, &bi);
cdCanvasBackground(cd_canvas, cdEncodeColor((unsigned char)ri, (unsigned char)gi, (unsigned char)bi));
cdCanvasClear(cd_canvas);
/* draw the image at the center of the canvas */
image = (imImage*)IupGetAttribute(canvas, "IMAGE");
if (image)
{
int view_width, view_height;
Ihandle* zoom_val = IupGetDialogChild(canvas, "ZOOMVAL");
double zoom_index = IupGetDouble(zoom_val, "VALUE");
double zoom_factor = pow(2, zoom_index);
float posy = IupGetFloat(canvas, "POSY");
float posx = IupGetFloat(canvas, "POSX");
view_width = (int)(zoom_factor * image->width);
view_height = (int)(zoom_factor * image->height);
if (canvas_width < view_width)
x = (int)floor(-posx*view_width);
else
x = (canvas_width - view_width) / 2;
if (canvas_height < view_height)
{
/* posy is top-bottom, CD is bottom-top.
invert posy reference (YMAX-DY - POSY) */
float dy = IupGetFloat(canvas, "DY");
posy = 1.0f - dy - posy;
y = (int)floor(-posy*view_height);
}
else
y = (canvas_height - view_height) / 2;
/* black line around the image */
cdCanvasForeground(cd_canvas, CD_BLACK);
cdCanvasRect(cd_canvas, x - 1, x + view_width, y - 1, y + view_height);
imcdCanvasPutImage(cd_canvas, image, x, y, view_width, view_height, 0, 0, 0, 0);
}
cdCanvasFlush(cd_canvas);
return IUP_DEFAULT;
}
void PlayCanvasDriver(cdContext* ctx, char* StrData)
{
int w, h;
cdCanvasActivate(curCanvas);
cdCanvasBackground(curCanvas, CD_WHITE);
cdCanvasClear(curCanvas);
cdCanvasGetSize(curCanvas, &w, &h, 0, 0);
cdCanvasPlay(curCanvas, ctx, 100, w-100, 100, h-100, StrData);
// cdCanvasPlay(curCanvas, ctx, 0, 0, 0, 0, StrData);
}
static int scroll_cb(Ihandle *ih, int op, float posx, float posy)
{
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS");
printf("SCROLL_CB(%g, %g)\n", posx, posy);
cdCanvasActivate(canvas);
update_viewport(ih, canvas, posx, posy);
IupRedraw(ih, 0);
(void)op;
return IUP_DEFAULT;
}
/* Callback called when the tree needs to be redrawn. */
int iupTreeRepaint(Ihandle* ih)
{
if(!ih->data->cddbuffer)
return IUP_DEFAULT;
cdCanvasActivate(ih->data->cddbuffer);
cdCanvasNativeFont(ih->data->cddbuffer, IupGetAttribute(ih, "FONT"));
iupTreeDrawTree(ih); /* TODO: split the calcsize from the redraw */
iTreeUpdateScrollPos(ih);
cdCanvasActivate(ih->data->cddbuffer);
iupTreeDrawTree(ih);
cdCanvasFlush(ih->data->cddbuffer);
if(ih && ih->data->selected && ih->data->selected->visible == NO)
iupTreeGSSetValue(ih, "PREVIOUS", 1);
return IUP_DEFAULT;
}
static void cells_createcanvas(TCells* obj, Ihandle *self)
{
if (!obj->cdcanvas)
obj->cdcanvas = cdCreateCanvas(CD_IUP, self);
if (obj->cdcanvas)
{
cdCanvasActivate(obj->cdcanvas);
obj->cddbuffer = cdCreateCanvas(CD_DBUFFER, obj->cdcanvas);
}
}
static int resize_cb(Ihandle *ih, int canvas_w, int canvas_h)
{
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS");
/* update CD canvas */
cdCanvasActivate(canvas);
update_scrollbar(ih, canvas_w, canvas_h);
update_viewport(ih, canvas, IupGetFloat(ih, "POSX"), IupGetFloat(ih, "POSY"));
return IUP_DEFAULT;
}
int resize_cb(Ihandle *ih, int w, int h)
{
/* update page size, it is always the client size of the canvas */
IupSetfAttribute(ih, "DX", "%d", w);
IupSetfAttribute(ih, "DY", "%d", h);
if (!cdcanvas)
return IUP_DEFAULT;
/* update CD canvas size */
cdCanvasActivate(cdcanvas);
return IUP_DEFAULT;
}
static int iGaugeResize_CB(Ihandle* ih)
{
if (!ih->data->cddbuffer)
{
/* update canvas size */
cdCanvasActivate(ih->data->cdcanvas);
/* this can fail if canvas size is zero */
ih->data->cddbuffer = cdCreateCanvas(CD_DBUFFER, ih->data->cdcanvas);
}
if (!ih->data->cddbuffer)
return IUP_DEFAULT;
/* update size */
cdCanvasActivate(ih->data->cddbuffer);
cdCanvasGetSize(ih->data->cddbuffer,&ih->data->w,&ih->data->h,NULL,NULL);
/* update render */
iGaugeDrawGauge(ih);
return IUP_DEFAULT;
}
void iupMatrixDraw(Ihandle* ih, int update)
{
cdCanvasActivate(ih->data->cd_canvas);
if (ih->data->need_calcsize)
iupMatrixAuxCalcSizes(ih);
iMatrixDrawMatrix(ih);
ih->data->need_redraw = 0;
if (update)
iupMatrixDrawUpdate(ih);
}
static int action(Ihandle *ih)
{
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS");
printf("ACTION\n");
cdCanvasActivate(canvas);
cdCanvasClear(canvas);
cdCanvasForeground(canvas, CD_RED);
wdCanvasLine(canvas, 0, 0, WORLD_W, WORLD_H);
wdCanvasLine(canvas, 0, WORLD_H, WORLD_W, 0);
wdCanvasArc(canvas, WORLD_W/2, WORLD_H/2+WORLD_H/10, WORLD_W/10, WORLD_H/10, 0, 360);
return IUP_DEFAULT;
}
static void iColorBrowserDlgColorCnvRepaint(IcolorDlgData* colordlg_data)
{
int x, y, w, h, width, height, box_size = 10;
if (!colordlg_data->cd_canvas_color)
return;
cdCanvasActivate(colordlg_data->cd_canvas_color);
cdCanvasGetSize(colordlg_data->cd_canvas_color, &width, &height, NULL, NULL);
cdCanvasBackground(colordlg_data->cd_canvas_color, CD_WHITE);
cdCanvasClear(colordlg_data->cd_canvas_color);
w = (width+box_size-1)/box_size;
h = (height+box_size-1)/box_size;
cdCanvasForeground(colordlg_data->cd_canvas_color, CD_GRAY);
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
if (((x%2) && (y%2)) || (((x+1)%2) && ((y+1)%2)))
{
int xmin, xmax, ymin, ymax;
xmin = x*box_size;
xmax = xmin+box_size;
ymin = y*box_size;
ymax = ymin+box_size;
cdCanvasBox(colordlg_data->cd_canvas_color, xmin, xmax, ymin, ymax);
}
}
}
cdCanvasForeground(colordlg_data->cd_canvas_color, colordlg_data->previous_color);
cdCanvasBox(colordlg_data->cd_canvas_color, 0, width/2, 0, height);
cdCanvasForeground(colordlg_data->cd_canvas_color, colordlg_data->color);
cdCanvasBox(colordlg_data->cd_canvas_color, width/2+1, width, 0, height);
cdCanvasFlush(colordlg_data->cd_canvas_color);
}
static int cdactivate(cdCtxCanvas* ctxcanvas)
{
int w, h;
cdCanvas* canvas_dbuffer = ctxcanvas->canvas_dbuffer;
/* this is done in the canvas_dbuffer context */
/* this will update canvas size */
cdCanvasActivate(canvas_dbuffer);
w = canvas_dbuffer->w;
h = canvas_dbuffer->h;
if (w==0) w=1;
if (h==0) h=1;
/* check if the size changed */
if (w != ctxcanvas->image_dbuffer->w ||
h != ctxcanvas->image_dbuffer->h)
{
cdCanvas* canvas = ctxcanvas->canvas;
/* save the current, if the rebuild fail */
cdImage* old_image_dbuffer = ctxcanvas->image_dbuffer;
cdCtxCanvas* old_ctxcanvas = ctxcanvas;
/* if the image is rebuild, the canvas that uses the image must be also rebuild */
/* rebuild the image and the canvas */
canvas->ctxcanvas = NULL;
canvas->context->cxCreateCanvas(canvas, canvas_dbuffer);
if (!canvas->ctxcanvas)
{
canvas->ctxcanvas = old_ctxcanvas;
return CD_ERROR;
}
/* remove the old image and canvas */
cdKillImage(old_image_dbuffer);
cdgdkKillCanvas(old_ctxcanvas);
ctxcanvas = canvas->ctxcanvas;
/* update canvas attributes */
cdUpdateAttributes(canvas);
}
return CD_OK;
}
/* Callback called when the tree is scrolled. */
static int iTreeScrollCB(Ihandle* ih)
{
if (ih->data->cddbuffer)
{
cdCanvasActivate(ih->data->cddbuffer);
iupTreeEditCheckHidden(ih);
cdCanvasNativeFont(ih->data->cddbuffer, IupGetAttribute(ih, "FONT"));
iupTreeDrawTree(ih);
cdCanvasFlush(ih->data->cddbuffer);
}
if(ih && ih->data->selected && ih->data->selected->visible == NO)
iupTreeGSSetValue(ih, "PREVIOUS", 0);
return IUP_DEFAULT;
}
static int resize_cb(Ihandle *ih, int canvas_w, int canvas_h)
{
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS");
printf("RESIZE_CB(%d, %d) RASTERSIZE=%s DRAWSIZE=%s \n", canvas_w, canvas_h, IupGetAttribute(ih, "RASTERSIZE"), IupGetAttribute(ih, "DRAWSIZE"));
/* When *AUTOHIDE=Yes, this can hide a scrollbar and so change the canvas drawsize */
update_scrollbar(ih, canvas_w, canvas_h);
printf(" DRAWSIZE=%s \n", IupGetAttribute(ih, "DRAWSIZE"));
/* update the canvas size */
IupGetIntInt(ih, "DRAWSIZE", &canvas_w, &canvas_h);
/* update the application */
cdCanvasActivate(canvas);
update_scrollbar(ih, canvas_w, canvas_h);
update_viewport(ih, canvas, IupGetFloat(ih, "POSX"), IupGetFloat(ih, "POSY"));
return IUP_DEFAULT;
}
static void iColorBrowserUpdateSize(Ihandle* ih)
{
int T, D;
/* update canvas size */
cdCanvasActivate(ih->data->cddbuffer);
cdCanvasGetSize(ih->data->cddbuffer, &ih->data->w, &ih->data->h, NULL, NULL);
ih->data->R = min(ih->data->w, ih->data->h)/2;
ih->data->xc = ih->data->w/2;
ih->data->yc = ih->data->h/2;
T = ih->data->R-ICB_SPACE-ICB_HUEWIDTH-ICB_SPACE;
ih->data->Ix = ih->data->xc - T/2; /* cos(60)=0.5 */
D = (int)(2*T*0.866); /* sin(60)=0.866 */
ih->data->Iy1 = ih->data->yc - D/2;
ih->data->Iy2 = ih->data->Iy1 + D;
ih->data->SxMax = ih->data->xc + T;
}
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;
}
static int redraw_cb(Ihandle *ih)
{
int width, height;
cdCanvas *cdcanvas = (cdCanvas*)IupGetAttribute(ih, "_APP_CDCANVAS");
cdCanvasActivate(cdcanvas);
cdCanvasBackground(cdcanvas, CD_WHITE);
cdCanvasClear(cdcanvas);
cdCanvasForeground(cdcanvas, CD_RED);
cdCanvasGetSize(cdcanvas, &width, &height, NULL, NULL);
cdCanvasLine(cdcanvas, 0, 0, width-1, height-1);
cdCanvasLine(cdcanvas, 0, height-1, width-1, 0);
cdCanvasFlush(cdcanvas);
return IUP_DEFAULT;
}
static int cbCanvasRepaint(Ihandle* iup_canvas)
{
cdCanvas* cd_canvas = (cdCanvas*)IupGetAttribute(iup_canvas, "cdCanvas");
imImage* image = (imImage*)IupGetAttribute(iup_canvas, "imImage");
if (!cd_canvas || disable_repaint)
return IUP_DEFAULT;
cdCanvasActivate(cd_canvas);
cdCanvasClear(cd_canvas);
if (!image)
return IUP_DEFAULT;
imcdCanvasPutImage(cd_canvas, image, 0, 0, image->width, image->height, 0, 0, 0, 0);
cdCanvasFlush(cd_canvas);
return IUP_DEFAULT;
}
