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;
}
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;
}
/* Redraw the entire matrix, may or not redraw the line and column titles
-> modo : this constant specifics the titles will be redraw, with the
following values:
IMAT_DRAW_ALL -> Redraw the title columns and lines
IMAT_DRAW_COL -> Redraw just the title columns
IMAT_DRAW_LIN -> Redraw just the title lines
... always redraw the cells - the "modo" just draw the titles ...
*/
void iupMatrixDrawMatrix(Ihandle* ih, int modo)
{
ih->data->redraw = 1;
if((ih->data->lin.num == 0) || (ih->data->col.num == 0))
{
cdCanvasBackground(ih->data->cddbuffer, cdIupConvertColor(iupControlBaseGetParentBgColor(ih)));
cdCanvasClear(ih->data->cddbuffer);
}
/* Draw the corner between line and column titles, if necessary */
iupMatrixDrawTitleCorner(ih);
/* If there are columns and must draw them, then draw the titles */
if((ih->data->col.num != 0) &&
(modo == IMAT_DRAW_ALL || modo == IMAT_DRAW_COL) && ih->data->lin.titlewh)
{
iupMatrixDrawColumnTitle(ih, ih->data->col.first, ih->data->col.last);
}
/* If there are lines and must draw them, then draw the titles */
if((ih->data->lin.num != 0) &&
(modo == IMAT_DRAW_ALL || modo == IMAT_DRAW_LIN) &&
ih->data->col.titlewh)
{
iupMatrixDrawLineTitle(ih, ih->data->lin.first, ih->data->lin.last);
}
/* If there are cells in the matrix, then draw the cells */
if((ih->data->lin.num != 0) && (ih->data->col.num != 0))
iupMatrixDrawCells(ih, ih->data->lin.first, ih->data->col.first, ih->data->lin.last, ih->data->col.last);
}
static void iMatrixDrawMatrix(Ihandle* ih)
{
iupMatrixPrepareDrawData(ih);
/* fill the background because there will be empty cells */
if ((ih->data->lines.num == 1) || (ih->data->columns.num == 1))
{
cdCanvasBackground(ih->data->cddbuffer, cdIupConvertColor(ih->data->bgcolor_parent));
cdCanvasClear(ih->data->cddbuffer);
}
/* Draw the corner between line and column titles, if necessary */
iMatrixDrawTitleCorner(ih);
/* If there are columns, then draw their titles */
if (ih->data->columns.num_noscroll>1)
iupMatrixDrawColumnTitle(ih, 1, ih->data->columns.num_noscroll-1);
iupMatrixDrawColumnTitle(ih, ih->data->columns.first, ih->data->columns.last);
/* If there are lines, then draw their titles */
if (ih->data->lines.num_noscroll>1)
iupMatrixDrawLineTitle(ih, 1, ih->data->lines.num_noscroll-1);
iupMatrixDrawLineTitle(ih, ih->data->lines.first, ih->data->lines.last);
/* If there are ordinary cells, then draw them */
if (ih->data->columns.num_noscroll>1)
iupMatrixDrawCells(ih, ih->data->lines.first, 1,
ih->data->lines.last, ih->data->columns.num_noscroll-1);
if (ih->data->lines.num_noscroll>1)
iupMatrixDrawCells(ih, 1, ih->data->columns.first,
ih->data->lines.num_noscroll-1, ih->data->columns.last);
iupMatrixDrawCells(ih, ih->data->lines.first, ih->data->columns.first,
ih->data->lines.last, ih->data->columns.last);
}
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 void drawTestCD(Ihandle* ih)
{
cdCanvas* canvas = cdCreateCanvas(CD_IUP, ih);
int w = IupGetInt(ih, "PREVIEWWIDTH");
int h = IupGetInt(ih, "PREVIEWHEIGHT");
cdCanvasClear(canvas);
cdCanvasForeground(canvas, cdEncodeColor(255, 0 , 0));
cdCanvasLine(canvas, 0, 0, w-1, h-1);
cdCanvasLine(canvas, 0, h-1, w-1, 0);
cdKillCanvas(canvas);
}
static int action(Ihandle *ih)
{
cdCanvas *canvas = (cdCanvas*)IupGetAttribute(ih, "_CD_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;
}
void SimpleDrawTextFonts(cdCanvas* canvas)
{
int xoff, yoff, size;
cdCanvasBackground(canvas, CD_WHITE);
cdCanvasClear(canvas);
xoff = 470;
yoff = 150;
size = -30;
cdCanvasTextAlignment(canvas, CD_CENTER);
DrawTextFont(canvas, "Courier", size, xoff, yoff, "Courier");
DrawTextFont(canvas, "Times", size, xoff, 2*yoff, "Times Roman");
DrawTextFont(canvas, "Helvetica", size, xoff, 3*yoff, "Helvetica");
DrawTextFont(canvas, "System", size, xoff, 4*yoff, "System");
{
// static char native[50] = "Tecmedia, -60";
// static char native[50] = "-*-helvetica-medium-r-*-*-8-*";
// static char native[50] = "Edwardian Script ITC, 24";
// cdSetAttribute("ADDFONTMAP","Edwardian Script ITC=ITCEDSCR");
// char native[50] = "Book Antiqua, 24";
// cdSetAttribute("ADDFONTMAP", "Book Antiqua=BKANT");
// cdNativeFont("-d");
// cdNativeFont(native);
// DrawTextBox(xoff, yoff, native);
// DrawTextBox(xoff, yoff, "The quick brown fox.");
}
//cdNativeFont("Tecmedia, 36");
//cdSetAttribute("ADDFONTMAP", "WingDings=WingDing");
//cdNativeFont("WingDings, 36");
//cdText(500, 50, "X");
//cdText(500, 50, "abcdefghijklmnopqrstuvwxyz");
//cdText(500, 150, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
//cdText(500, 250, "1234567890");
//cdText(500, 350, "'\"!@#$%¨&*()_+-=[]^/;.,");
//cdFont(CD_COURIER, 0, 22);
//cdText(10, 60, "abcdefghijklmnopqrstuvwxyz");
//cdText(10, 160, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
//cdText(10, 260, "1234567890");
//cdText(500, 360, "'\"!@#$%¨&*()_+-=[]^/;.,");
}
static void iDialRepaint(Ihandle* ih)
{
if (!ih->data->cddbuffer)
return;
/* update render */
cdCanvasBackground(ih->data->cddbuffer, ih->data->bgcolor);
cdCanvasClear(ih->data->cddbuffer);
ih->data->Draw(ih);
/* update display */
cdCanvasFlush(ih->data->cddbuffer);
if (ih->data->has_focus)
IupCdDrawFocusRect(ih, ih->data->cdcanvas, 0, 0, ih->data->w-1, ih->data->h-1);
}
int item_print_action_cb(Ihandle* item_print)
{
Ihandle* canvas = IupGetDialogChild(item_print, "CANVAS");
unsigned int ri, gi, bi;
imImage* image;
char* title = IupGetAttribute(IupGetDialog(item_print), "TITLE");
Ihandle* config = (Ihandle*)IupGetAttribute(canvas, "CONFIG");
const char* background = IupConfigGetVariableStrDef(config, "MainWindow", "Background", "255 255 255");
cdCanvas* cd_canvas = cdCreateCanvasf(CD_PRINTER, "%s -d", title);
if (!cd_canvas)
return IUP_DEFAULT;
/* 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 x, y, canvas_width, canvas_height, view_width, view_height;
double canvas_width_mm, canvas_height_mm;
Ihandle* config = (Ihandle*)IupGetAttribute(canvas, "CONFIG");
int margin_width = IupConfigGetVariableIntDef(config, "Print", "MarginWidth", 20);
int margin_height = IupConfigGetVariableIntDef(config, "Print", "MarginHeight", 20);
cdCanvasGetSize(cd_canvas, &canvas_width, &canvas_height, &canvas_width_mm, &canvas_height_mm);
/* convert to pixels */
margin_width = (int)((margin_width * canvas_width) / canvas_width_mm);
margin_height = (int)((margin_height * canvas_height) / canvas_height_mm);
view_fit_rect(canvas_width - 2 * margin_width, canvas_height - 2 * margin_height,
image->width, image->height,
&view_width, &view_height);
x = (canvas_width - view_width) / 2;
y = (canvas_height - view_height) / 2;
imcdCanvasPutImage(cd_canvas, image, x, y, view_width, view_height, 0, 0, 0, 0);
}
cdKillCanvas(cd_canvas);
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 void iGaugeDrawGauge(Ihandle* ih)
{
int border = 3; /* includes the pixel used to draw the 3D border */
int xstart = ih->data->horiz_padding+border;
int ystart = ih->data->vert_padding+border;
int xend = ih->data->w-1 - (ih->data->horiz_padding+border);
int yend = ih->data->h-1 - (ih->data->vert_padding+border);
cdCanvasBackground(ih->data->cddbuffer, ih->data->bgcolor);
cdCanvasClear(ih->data->cddbuffer);
cdIupDrawSunkenRect(ih->data->cddbuffer, 0, 0, ih->data->w-1, ih->data->h-1,
ih->data->light_shadow, ih->data->mid_shadow, ih->data->dark_shadow);
cdCanvasForeground(ih->data->cddbuffer, ih->data->fgcolor);
if (ih->data->dashed)
{
float step = (xend - xstart + 1) / (float)IGAUGE_BLOCKS;
float boxw = step - IGAUGE_GAP;
float vx = (float)((xend-xstart + 1) * (ih->data->value - ih->data->vmin) / (ih->data->vmax - ih->data->vmin));
int intvx = (int)(100 * vx);
float i = 0;
if(ih->data->value == ih->data->vmin)
return;
while(gaugeround(100*(i + boxw)) <= intvx)
{
cdCanvasBox(ih->data->cddbuffer, xstart + gaugeround(i),
xstart + gaugeround(i + boxw) - 1, ystart, yend);
i += step;
}
}
else
{
int xmid = xstart + gaugeround((xend-xstart + 1) * (ih->data->value - ih->data->vmin) / (ih->data->vmax - ih->data->vmin));
if(ih->data->value != ih->data->vmin)
cdCanvasBox(ih->data->cddbuffer, xstart, xmid, ystart, yend );
if(ih->data->show_text)
iGaugeDrawText(ih, xmid);
}
}
/* Repaint function for all cells */
static void iCellsRenderCells(Ihandle* ih)
{
int sline = ih->data->non_scrollable_lins;
int scol = ih->data->non_scrollable_cols;
int nlines = iCellsGetNLines(ih);
int ncols = iCellsGetNCols(ih);
cdCanvasBackground(ih->data->cd_canvas, ih->data->bgcolor);
cdCanvasClear(ih->data->cd_canvas);
/* Repainting the four parts of the cells: common cells, non-scrollable
* columns, non-scrollable lines, and non-scrollable margin
* (line and column) */
iCellsRenderRangedCells(ih, sline+1, nlines, scol+1, ncols);
iCellsRenderRangedCells(ih, sline+1, nlines, 1, scol);
iCellsRenderRangedCells(ih, 1, sline, scol+1, ncols);
iCellsRenderRangedCells(ih, 1, sline, 1, scol);
}
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;
}
static void iColorbarRepaint(Ihandle* ih)
{
/* Checking errors or not initialized conditions */
if (ih->data->cddbuffer == NULL)
return;
/* If object is buffering, it will be not drawn */
if (ih->data->bufferize == 1)
return;
/* update render */
cdCanvasBackground(ih->data->cddbuffer, ih->data->bgcolor);
cdCanvasClear(ih->data->cddbuffer);
iColorbarRenderPreview(ih);
iColorbarRenderCells(ih);
/* update display */
cdCanvasFlush(ih->data->cddbuffer);
if (ih->data->has_focus)
iColorbarDrawFocusCell(ih);
}
static void iDialRepaint(Ihandle* ih)
{
if (!ih->data->cd_canvas)
return;
cdCanvasActivate(ih->data->cd_canvas);
/* update render */
cdCanvasBackground(ih->data->cd_canvas, ih->data->bgcolor);
cdCanvasClear(ih->data->cd_canvas);
ih->data->Draw(ih);
/* update display */
cdCanvasFlush(ih->data->cd_canvas);
if (ih->data->has_focus)
{
cdCanvas* cd_canvas_front = (cdCanvas*)IupGetAttribute(ih, "_CD_CANVAS"); /* front buffer canvas */
IupCdDrawFocusRect(ih, cd_canvas_front, 0, 0, ih->data->w - 1, ih->data->h - 1);
}
}
/**
* Repaint function, but it is the only one that activates the cd canvas
*/
static void repaint_all(TCells* obj) {
/* If object is buffering, it will be not drawn */
if (obj->bufferize == 1) return;
/* Checking erros or not initialized conditions */
if (obj->self == NULL) return;
if (obj->cddbuffer == NULL) return;
if (obj->no_color == -1)
obj->no_color = cdIupConvertColor(iupGetBgColor(obj->self));
/* Getting object background color and repainting it.*/
cdCanvasBackground(obj->cddbuffer, obj->no_color);
cdCanvasClear(obj->cddbuffer);
/* Repaiting all cells */
repaint_cells(obj);
/* Flushing drawing to cd double buffer canvas */
cdCanvasFlush(obj->cddbuffer);
}
int action(Ihandle *ih, float posx, float posy)
{
int iposx = (int)posx;
int iposy = (int)posy;
if (!cdcanvas)
return IUP_DEFAULT;
/* update CD canvas size */
cdCanvasActivate(cdcanvas);
/* invert scroll reference (YMAX-DY - POSY) */
iposy = 399-IupGetInt(ih, "DY") - iposy;
cdCanvasClear(cdcanvas);
cdCanvasForeground(cdcanvas, CD_RED);
cdCanvasLine(cdcanvas, 0-iposx, 0-iposy, 599-iposx, 399-iposy);
cdCanvasLine(cdcanvas, 0-iposx, 399-iposy, 599-iposx, 0-iposy);
return IUP_DEFAULT;
}
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;
}
void SimpleDrawTest(cdCanvas* canvas)
//void SimpleDrawMainTest(cdCanvas* canvas)
{
long pattern[16]; /* 4x4 pattern */
int w, h;
int xmin, xmax, ymin, ymax;
/* notice that if we are not using world coordinates
it is harder to position all the objetcs we want. */
cdCanvasGetSize(canvas, &w, &h, 0, 0);
cdCanvasBackground(canvas, CD_WHITE);
cdCanvasClear(canvas);
/* pattern initialization */
pattern[0] = CD_RED; pattern[1] = CD_RED; /* first line */
pattern[2] = CD_YELLOW; pattern[3] = CD_YELLOW;
pattern[4] = CD_RED; pattern[5] = CD_RED; /* second line */
pattern[6] = CD_YELLOW; pattern[7] = CD_YELLOW;
pattern[8] = CD_YELLOW; pattern[9] = CD_YELLOW; /* third line */
pattern[10] = CD_YELLOW; pattern[11] = CD_YELLOW;
pattern[12] = CD_YELLOW; pattern[13] = CD_YELLOW; /* fourth line */
pattern[14] = CD_YELLOW; pattern[15] = CD_YELLOW;
/* set the line attributes */
cdCanvasLineWidth(canvas, 4);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
/* in the center draw a pattern pizza
with a slice mising */
cdCanvasPattern(canvas, 4, 4, pattern);
cdCanvasSector(canvas, w/2, h/2, w/2, h/2, 45, 0);
/* draws a dark red border */
cdCanvasForeground(canvas, CD_DARK_RED);
cdCanvasInteriorStyle(canvas, CD_HOLLOW);
cdCanvasSector(canvas, w/2, h/2, w/2, h/2, 45, 0);
/* on the left a red hash diamond */
/* notice the the default back opacity is transparent
and the pattern of the sector will still be visible
inside the hatch where the two objects intersect */
cdCanvasForeground(canvas, CD_RED);
cdCanvasHatch(canvas, CD_DIAGCROSS);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, w/4, h/4);
cdCanvasVertex(canvas, w/2-w/8, h/2);
cdCanvasVertex(canvas, w/4, 3*h/4);
cdCanvasVertex(canvas, w/8, h/2);
cdCanvasEnd(canvas);
/* draws a blue roof.*/
cdCanvasForeground(canvas, CD_BLUE);
cdCanvasLine(canvas, w/8, h/2, w/4, 3*h/4);
cdCanvasLine(canvas, w/4, 3*h/4, w/2-w/8, h/2);
/* draws a dashed ribbon on the right
with a custom color */
cdCanvasForeground(canvas, cdEncodeColor(100, 25, 200));
cdCanvasLineStyle(canvas, CD_DASH_DOT);
cdCanvasBegin(canvas, CD_BEZIER);
cdCanvasVertex(canvas, 3*w/4-20, h/2-50);
cdCanvasVertex(canvas, 3*w/4+150, 3*h/4-50);
cdCanvasVertex(canvas, 3*w/4-150, 3*h/4-50);
cdCanvasVertex(canvas, 3*w/4+20, h/2-50);
cdCanvasEnd(canvas);
cdCanvasFont(canvas, "Helvetica", CD_BOLD, 40);
cdCanvasTextAlignment(canvas, CD_CENTER);
cdCanvasText(canvas, w/2, h/4-50, "Canvas Draw");
cdCanvasGetTextBox(canvas, w/2, h/4-50, "Canvas Draw", &xmin, &xmax, &ymin, &ymax);
cdCanvasRect(canvas, xmin, xmax, ymin, ymax);
}
void SimpleDrawTextAlign(cdCanvas* canvas)
{
int w, h, i, xoff, yoff, use_vector;
int text_aligment[] = {
CD_NORTH,
CD_SOUTH,
CD_EAST,
CD_WEST,
CD_NORTH_EAST,
CD_NORTH_WEST,
CD_SOUTH_EAST,
CD_SOUTH_WEST,
CD_CENTER,
CD_BASE_CENTER,
CD_BASE_RIGHT,
CD_BASE_LEFT
};
#if 1
char* text_aligment_str[] = {
"North (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"South (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"East (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"West (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"North East (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"North West (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"South East (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"South West (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"Center (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"Base Center (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"Base Right (Ãyj)\nSecond Line (Ãyj)\nThird Line",
"Base Left (Ãyj)\nSecond Line (Ãyj)\nThird Line"
};
#else
char* text_aligment_str[] = {
"North (Ãyj)",
"South (Ãyj)",
"East (Ãyj)",
"West (Ãyj)",
"North East (Ãyj)",
"North West (Ãyj)",
"South East (Ãyj)",
"South West (Ãyj)",
"Center (Ãyj)",
"Base Center (Ãyj)",
"Base Right (Ãyj)",
"Base Left (Ãyj)"
};
#endif
cdCanvasGetSize(canvas, &w, &h, 0, 0);
cdCanvasBackground(canvas, CD_WHITE);
cdCanvasClear(canvas);
use_vector = 0;
#if 0
if (use_vector)
cdCanvasVectorTextDirection(canvas, 0, 0, 1, 1);
else
cdCanvasTextOrientation(canvas, 45);
#endif
xoff = w/4;
yoff = h/7;
if (use_vector)
cdCanvasVectorCharSize(canvas, 30);
else
{
//cdCanvasFont(canvas, "Times", CD_PLAIN, 14);
cdCanvasFont(canvas, "Helvetica", CD_PLAIN, 24);
}
for (i = 0; i < 12; i++)
{
cdCanvasTextAlignment(canvas, text_aligment[i]);
if (i < 6)
{
if (use_vector)
DrawVectorTextBox(canvas, xoff, yoff*(i+1), text_aligment_str[i]);
else
DrawTextBox(canvas, xoff, yoff*(i+1), text_aligment_str[i]);
}
else
{
if (use_vector)
DrawVectorTextBox(canvas, 3*xoff, yoff*(i-5), text_aligment_str[i]);
else
DrawTextBox(canvas, 3*xoff, yoff*(i-5), text_aligment_str[i]);
}
}
}
void SimpleDrawAll(cdCanvas* canvas)
{
int w, h;
cdCanvasGetSize(canvas, &w, &h, NULL, NULL);
/* Clear the background to be white */
cdCanvasBackground(canvas, CD_WHITE);
// cdBackground(CD_GREEN);
cdCanvasClear(canvas);
/* Draw a reactangle and a polyline at the bottom-left area,
using a thick line with transparency.
Observe that transparency is only supported in a few drivers,
and line join is not supported in the IMAGERGB driver. */
cdCanvasLineWidth(canvas, 3);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasForeground(canvas, cdEncodeAlpha(CD_DARK_MAGENTA, 128));
cdCanvasRect(canvas, 100, 200, 100, 200);
cdCanvasBegin(canvas, CD_OPEN_LINES);
cdCanvasVertex(canvas, 300, 250);
cdCanvasVertex(canvas, 320, 270);
cdCanvasVertex(canvas, 350, 260);
cdCanvasVertex(canvas, 340, 200);
cdCanvasVertex(canvas, 310, 210);
cdCanvasEnd(canvas);
/* Draw the red diagonal line with a custom line style.
Observe that line styles are not supported in the IMAGERGB driver. */
cdCanvasForeground(canvas, CD_RED);
cdCanvasLineWidth(canvas, 3);
{
int dashes[] = {20, 15, 5, 5};
cdCanvasLineStyleDashes(canvas, dashes, 4);
}
cdCanvasLineStyle(canvas, CD_CUSTOM);
cdCanvasLine(canvas, 0, 0, w-1, h-1);
/* Draw the blue diagonal line with a pre-defined line style.
Observe that the pre-defined line style is dependent on the driver. */
cdCanvasForeground(canvas, CD_BLUE);
cdCanvasLineWidth(canvas, 10);
cdCanvasLineStyle(canvas, CD_DOTTED);
cdCanvasLine(canvas, 0, h-1, w-1, 0);
switch(clipping)
{
case CD_CLIPOFF:
cdCanvasClip(canvas, CD_CLIPOFF);
break;
case CD_CLIPAREA:
/* Defines the clipping area equals the canvas area minus a 100 pixels margin. */
cdCanvasClipArea(canvas, 100, w - 100, 100, h - 100);
cdCanvasClip(canvas, CD_CLIPAREA);
break;
case CD_CLIPPOLYGON:
cdCanvasBegin(canvas, CD_CLIP);
cdCanvasVertex(canvas, 100, 100);
cdCanvasVertex(canvas, w - 100, 100);
cdCanvasVertex(canvas, w / 2, h - 100);
cdCanvasEnd(canvas);
cdCanvasClip(canvas, CD_CLIPPOLYGON);
break;
case CD_CLIPREGION:
cdCanvasTextAlignment(canvas, CD_CENTER);
cdCanvasFont(canvas, "Times", CD_BOLD, 50);
cdCanvasBegin(canvas, CD_REGION);
cdCanvasRegionCombineMode(canvas, CD_UNION);
cdCanvasBox(canvas, 100, 200, 100, 200);
cdCanvasSector(canvas, w/2-50, h/2+50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2-50, h/2-50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2+50, h/2+50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2+50, h/2-50, 150, 150, 0, 360);
cdCanvasRegionCombineMode(canvas, CD_DIFFERENCE);
cdCanvasText(canvas, w/2, h/2, "TEXT");
cdCanvasEnd(canvas);
// cdCanvasOffsetRegion(canvas, -50, 50);
cdCanvasClip(canvas, CD_CLIPREGION);
cdCanvasForeground(canvas, CD_DARK_RED);
cdCanvasBox(canvas, 0,w,0,h);
break;
}
switch(write_mode)
{
case CD_REPLACE:
cdCanvasWriteMode(canvas, CD_REPLACE);
break;
case CD_XOR:
cdCanvasWriteMode(canvas, CD_XOR);
break;
case CD_NOT_XOR:
cdCanvasWriteMode(canvas, CD_NOT_XOR);
break;
}
if (use_transform)
{
cdCanvasTransform(canvas, NULL);
cdCanvasTransformTranslate(canvas, w/2, h/2);
cdCanvasTransformRotate(canvas, 30);
cdCanvasTransformScale(canvas, 0.5, 0.5);
cdCanvasTransformTranslate(canvas, -w/2, -h/2);
}
// cdSetfAttribute("ROTATE", "15 %d %d", w/2, h/2);
/* Reset line style and width */
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, 1);
// cdBackOpacity(CD_TRANSPARENT);
/* Draw an arc at bottom-left, and a sector at bottom-right.
Notice that counter-clockwise orientation of both. */
cdCanvasInteriorStyle(canvas, CD_SOLID);
cdCanvasForeground(canvas, CD_MAGENTA);
cdCanvasSector(canvas, w-100, 100, 100, 100, 50, 180);
cdCanvasForeground(canvas, CD_RED);
cdCanvasArc(canvas, 100, 100, 100, 100, 50, 180);
/* Draw a solid filled rectangle at center. */
cdCanvasForeground(canvas, CD_YELLOW);
cdCanvasBox(canvas, w/2 - 100, w/2 + 100, h/2 - 100, h/2 + 100);
/* Prepare font for text. */
cdCanvasTextAlignment(canvas, CD_CENTER);
cdCanvasTextOrientation(canvas, 70);
cdCanvasFont(canvas, "Times", CD_BOLD, 24);
/* Draw text at center, with orientation,
and draw its bounding box.
Notice that in some drivers the bounding box is not precise. */
{
int rect[8];
cdCanvasGetTextBounds(canvas, w/2, h/2, "Simple Draw (pçãí)", rect);
cdCanvasForeground(canvas, CD_RED);
cdCanvasBegin(canvas, CD_CLOSED_LINES);
cdCanvasVertex(canvas, rect[0], rect[1]);
cdCanvasVertex(canvas, rect[2], rect[3]);
cdCanvasVertex(canvas, rect[4], rect[5]);
cdCanvasVertex(canvas, rect[6], rect[7]);
cdCanvasEnd(canvas);
}
cdCanvasForeground(canvas, CD_BLUE);
cdCanvasText(canvas, w/2, h/2, "Simple Draw (pçãí)");
cdCanvasTextOrientation(canvas, 0);
/* Prepare World Coordinates */
wdCanvasViewport(canvas, 0,w-1,0,h-1);
if (w>h)
wdCanvasWindow(canvas, 0,(double)w/(double)h,0,1);
else
wdCanvasWindow(canvas, 0,1,0,(double)h/(double)w);
/* Draw a filled blue rectangle in WC */
wdCanvasBox(canvas, 0.20, 0.30, 0.40, 0.50);
cdCanvasForeground(canvas, CD_RED);
/* Draw the diagonal of that rectangle in WC */
wdCanvasLine(canvas, 0.20, 0.40, 0.30, 0.50);
// wdVectorTextDirection(0, 0, 1, 1);
/* Prepare Vector Text in WC. */
wdCanvasVectorCharSize(canvas, 0.07);
// wdVectorText(0.1, 0.4, "ñç áéíóú àèìòù âêîôû äëïöü");
// wdVectorText(0.1, 0.2, "ÑÇ ÁÉÍÓÚ ÀÈÌÒÙ ÂÊÎÔÛ ÄËÏÖÜ");
//{
// int i;
// char t[2];
// char s[10];
// int x = 20;
// int y = 0;
// t[1] = 0;
// for (i = 0; i < 256; i++)
// {
// int dx = 90;
// t[0] = (char)i;
// sprintf(s, "%d", i);
// cdText(x, y, s);
// cdText(x+dx, y, t);
// cdVectorText(x+2*dx, y, t);
//
// x += 3*dx + 2*dx/3;
// if ((i+1) % 7 == 0)
// {
// x = 20;
// y += 90;
// }
// }
//}
/* Draw vector text, and draw its bounding box.
We also use this text to show when we are using a contextplus driver. */
{
double rect[8];
cdCanvasForeground(canvas, CD_RED);
if (contextplus)
wdCanvasGetVectorTextBounds(canvas, "WDj-Plus", 0.25, 0.35, rect);
else
wdCanvasGetVectorTextBounds(canvas, "WDj", 0.25, 0.35, rect);
cdCanvasBegin(canvas, CD_CLOSED_LINES);
wdCanvasVertex(canvas, rect[0], rect[1]);
wdCanvasVertex(canvas, rect[2], rect[3]);
wdCanvasVertex(canvas, rect[4], rect[5]);
wdCanvasVertex(canvas, rect[6], rect[7]);
cdCanvasEnd(canvas);
cdCanvasLineWidth(canvas, 2);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
if (contextplus)
wdCanvasVectorText(canvas, 0.25, 0.35, "WDj-Plus");
else
wdCanvasVectorText(canvas, 0.25, 0.35, "WDj");
cdCanvasLineWidth(canvas, 1);
}
/* Draw a filled path at center-right (looks like a weird fish).
Notice that in PDF the arc is necessarily a circle arc, and not an ellipse. */
cdCanvasForeground(canvas, CD_GREEN);
cdCanvasBegin(canvas, CD_PATH);
cdCanvasPathSet(canvas, CD_PATH_MOVETO);
cdCanvasVertex(canvas, w/2 + 200, h/2);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2 + 230, h/2 + 50);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2 + 250, h/2 + 50);
cdCanvasPathSet(canvas, CD_PATH_CURVETO);
cdCanvasVertex(canvas, w/2+150+150, h/2+200-50); /* control point for start */
cdCanvasVertex(canvas, w/2+150+180, h/2+250-50); /* control point for end */
cdCanvasVertex(canvas, w/2+150+180, h/2+200-50); /* end point */
cdCanvasPathSet(canvas, CD_PATH_CURVETO);
cdCanvasVertex(canvas, w/2+150+180, h/2+150-50);
cdCanvasVertex(canvas, w/2+150+150, h/2+100-50);
cdCanvasVertex(canvas, w/2+150+300, h/2+100-50);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2+150+300, h/2-50);
cdCanvasPathSet(canvas, CD_PATH_ARC);
cdCanvasVertex(canvas, w/2+300, h/2); /* center */
cdCanvasVertex(canvas, 200, 100); /* width, height */
cdCanvasVertex(canvas, -30*1000, -170*1000); /* start angle, end angle (degrees / 1000) */
// cdCanvasPathSet(canvas, CD_PATH_CLOSE);
// cdCanvasPathSet(canvas, CD_PATH_STROKE);
cdCanvasPathSet(canvas, CD_PATH_FILL);
// cdCanvasPathSet(canvas, CD_PATH_FILLSTROKE);
cdCanvasEnd(canvas);
/* Draw 3 pixels at center left. */
cdCanvasPixel(canvas, 10, h/2+0, CD_RED);
cdCanvasPixel(canvas, 11, h/2+1, CD_GREEN);
cdCanvasPixel(canvas, 12, h/2+2, CD_BLUE);
/* Draw 4 mark types, distributed near each corner. */
cdCanvasForeground(canvas, CD_RED);
cdCanvasMarkSize(canvas, 30);
cdCanvasMarkType(canvas, CD_PLUS);
cdCanvasMark(canvas, 200, 200);
cdCanvasMarkType(canvas, CD_CIRCLE);
cdCanvasMark(canvas, w - 200, 200);
cdCanvasMarkType(canvas, CD_HOLLOW_CIRCLE);
cdCanvasMark(canvas, 200, h - 200);
cdCanvasMarkType(canvas, CD_DIAMOND);
cdCanvasMark(canvas, w - 200, h - 200);
/* Draw all the line style possibilities at bottom.
Notice that they have some small differences between drivers. */
cdCanvasLineWidth(canvas, 1);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLine(canvas, 0, 10, w, 10);
cdCanvasLineStyle(canvas, CD_DASHED);
cdCanvasLine(canvas, 0, 20, w, 20);
cdCanvasLineStyle(canvas, CD_DOTTED);
cdCanvasLine(canvas, 0, 30, w, 30);
cdCanvasLineStyle(canvas, CD_DASH_DOT);
cdCanvasLine(canvas, 0, 40, w, 40);
cdCanvasLineStyle(canvas, CD_DASH_DOT_DOT);
cdCanvasLine(canvas, 0, 50, w, 50);
/* Draw all the hatch style possibilities in the top-left corner.
Notice that they have some small differences between drivers. */
cdCanvasHatch(canvas, CD_VERTICAL);
cdCanvasBox(canvas, 0, 50, h - 60, h);
cdCanvasHatch(canvas, CD_FDIAGONAL);
cdCanvasBox(canvas, 50, 100, h - 60, h);
cdCanvasHatch(canvas, CD_BDIAGONAL);
cdCanvasBox(canvas, 100, 150, h - 60, h);
cdCanvasHatch(canvas, CD_CROSS);
cdCanvasBox(canvas, 150, 200, h - 60, h);
cdCanvasHatch(canvas, CD_HORIZONTAL);
cdCanvasBox(canvas, 200, 250, h - 60, h);
cdCanvasHatch(canvas, CD_DIAGCROSS);
cdCanvasBox(canvas, 250, 300, h - 60, h);
/* Draw 4 regions, in diamond shape,
at top, bottom, left, right,
using different interior styles. */
/* At top, not filled polygon, notice that the last line style is used. */
cdCanvasBegin(canvas, CD_CLOSED_LINES);
cdCanvasVertex(canvas, w/2, h - 100);
cdCanvasVertex(canvas, w/2 + 50, h - 150);
cdCanvasVertex(canvas, w/2, h - 200);
cdCanvasVertex(canvas, w/2 - 50, h - 150);
cdCanvasEnd(canvas);
/* At left, hatch filled polygon */
cdCanvasHatch(canvas, CD_DIAGCROSS);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, 100, h/2);
cdCanvasVertex(canvas, 150, h/2 + 50);
cdCanvasVertex(canvas, 200, h/2);
cdCanvasVertex(canvas, 150, h/2 - 50);
cdCanvasEnd(canvas);
/* At right, pattern filled polygon */
cdCanvasPattern(canvas, STYLE_SIZE, STYLE_SIZE, pattern);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, w - 100, h/2);
cdCanvasVertex(canvas, w - 150, h/2 + 50);
cdCanvasVertex(canvas, w - 200, h/2);
cdCanvasVertex(canvas, w - 150, h/2 - 50);
cdCanvasEnd(canvas);
/* At bottom, stipple filled polygon */
cdCanvasStipple(canvas, STYLE_SIZE, STYLE_SIZE, stipple);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, w/2, 100);
cdCanvasVertex(canvas, w/2 + 50, 150);
cdCanvasVertex(canvas, w/2, 200);
cdCanvasVertex(canvas, w/2 - 50, 150);
cdCanvasEnd(canvas);
/* Draw two beziers at bottom-left */
cdCanvasBegin(canvas, CD_BEZIER);
cdCanvasVertex(canvas, 100, 100);
cdCanvasVertex(canvas, 150, 200);
cdCanvasVertex(canvas, 180, 250);
cdCanvasVertex(canvas, 180, 200);
cdCanvasVertex(canvas, 180, 150);
cdCanvasVertex(canvas, 150, 100);
cdCanvasVertex(canvas, 300, 100);
cdCanvasEnd(canvas);
/* Initialize the image buffer contents */
//#define IMAGE_SIZE 16
memset(red, 0xFF, IMAGE_SIZE*IMAGE_SIZE/2);
memset(green, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(blue, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(red+IMAGE_SIZE*IMAGE_SIZE/2, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(green+IMAGE_SIZE*IMAGE_SIZE/2, 0x8F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(blue+IMAGE_SIZE*IMAGE_SIZE/2, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(red+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(green+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(blue+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(red, 0, IMAGE_SIZE);
memset(green, 0, IMAGE_SIZE);
memset(blue, 0, IMAGE_SIZE);
{
int i, offset;
for (i = 0; i < IMAGE_SIZE; i++)
{
offset = i*IMAGE_SIZE;
red[offset] = 0;
green[offset] = 0;
blue[offset] = 0;
red[offset+IMAGE_SIZE-1] = 0;
green[offset+IMAGE_SIZE-1] = 0;
blue[offset+IMAGE_SIZE-1] = 0;
}
}
//cdSetAttribute("ANTIALIAS", "0");
// cdGetImageRGB(red, green, blue, w/2 - 50, h/2-50, 100, 100);
// cdPutImageRectRGB(14, 13, red, green, blue, -20, -15, 649, 603, 0, 13, 0, 12);
// cdPutImageRectRGB(16, 16, red, green, blue, 10, 10, 608, 608, 5, 10, 5, 10);
// cdPutImageRectRGB(16, 16, red, green, blue, 10, 10, 64, 64, 5, 10, 5, 10);
// cdPutImageRGB(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, 100, h - 200, IMAGE_SIZE, IMAGE_SIZE);
// cdPutImageRGBA(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, alpha, 100, h - 200, IMAGE_SIZE, IMAGE_SIZE);
// cdPutImageRGB(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, w - 400, h - 310, 3*IMAGE_SIZE, 3*IMAGE_SIZE);
/* Draw the image on the top-right corner but increasing its actual size, and uses its full area */
cdCanvasPutImageRectRGBA(canvas, IMAGE_SIZE, IMAGE_SIZE, red, green, blue, alpha, w - 400, h - 310, 3*IMAGE_SIZE, 3*IMAGE_SIZE, 0, 0, 0, 0);
cdCanvasSetAttribute(canvas, "ROTATE", NULL);
if (use_transform)
cdCanvasTransform(canvas, NULL);
cdCanvasClip(canvas, CD_CLIPOFF);
}
static void iColorBrowserRenderImageHue(Ihandle* ih)
{
int x, y, active = 1;
unsigned char *red, *green, *blue;
unsigned char bg_red, bg_green, bg_blue;
if (!ih->data->cddbuffer)
return;
cdCanvasBackground(ih->data->cddbuffer, ih->data->bgcolor);
cdCanvasClear(ih->data->cddbuffer);
if (!iupdrvIsActive(ih))
active = 0;
if (ih->data->has_focus)
cdDrawFocusRect(ih->data->cddbuffer, 0, 0, ih->data->w-1, ih->data->h-1);
red = cdRedImage(ih->data->cddbuffer);
green = cdGreenImage(ih->data->cddbuffer);
blue = cdBlueImage(ih->data->cddbuffer);
cdDecodeColor(ih->data->bgcolor, &bg_red, &bg_green, &bg_blue);
for (y = 0; y < ih->data->h; y++)
{
float sx_max = iColorBrowserSXmax(ih, y);
for (x = 0; x < ih->data->w; x++)
{
int xl, yl;
float radius, diff1, diff2;
if (y > ih->data->Iy1 &&
y < ih->data->Iy2 &&
x > ih->data->Ix &&
x < ih->data->Ix+(int)sx_max)
continue;
xl = x - ih->data->xc;
yl = y - ih->data->yc;
radius = sqrtf(xl*xl + yl*yl);
diff1 = radius - (ih->data->R-ICB_SPACE-ICB_HUEWIDTH);
diff2 = (ih->data->R-ICB_SPACE) - radius;
if (diff1>0 && diff2>0)
{
float h, s, i;
int offset = y*ih->data->w + x;
unsigned char* r = red + offset;
unsigned char* g = green + offset;
unsigned char* b = blue + offset;
h = atan2f(yl, xl);
h = (float)(h * CD_RAD2DEG);
s = 1.0f; /* maximum saturation */
i = 0.5f; /* choose I where S is maximum */
iupColorHSI2RGB(h, s, i, r, g, b);
if (diff1<1 || diff2<1) /* anti-aliasing */
{
float diff = (float)(diff1<1? diff1: diff2);
*r = (unsigned char)((*r)*diff + bg_red*(1.0f-diff));
*g = (unsigned char)((*g)*diff + bg_green*(1.0f-diff));
*b = (unsigned char)((*b)*diff + bg_blue*(1.0f-diff));
}
if (!active)
{
*r = cdIupLIGTHER(*r);
*g = cdIupLIGTHER(*g);
*b = cdIupLIGTHER(*b);
}
}
}
}
if (active)
{
float x1, x2, y1, y2;
unsigned char shade_lr, shade_lg, shade_lb,
shade_dr, shade_dg, shade_db;
shade_dr = (unsigned char)((2 * bg_red) / 3);
shade_dg = (unsigned char)((2 * bg_green) / 3);
shade_db = (unsigned char)((2 * bg_blue) / 3);
shade_lr = (unsigned char)((255 + bg_red) / 2);
shade_lg = (unsigned char)((255 + bg_green) / 2);
shade_lb = (unsigned char)((255 + bg_blue) / 2);
cdCanvasForeground(ih->data->cddbuffer, cdEncodeColor(shade_dr, shade_dg, shade_db));
x1 = (float)(ih->data->xc-ih->data->R+ICB_SPACE); y1 = (float)ih->data->yc; x2 = (float)(x1+ICB_HUEWIDTH/2); y2 = (float)ih->data->yc;
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
iColorBrowserRotatePoints(&x1, &y1, &x2, &y2, ih->data->xc, ih->data->yc);
cdCanvasForeground(ih->data->cddbuffer, cdEncodeColor(shade_lr, shade_lg, shade_lb));
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
iColorBrowserRotatePoints(&x1, &y1, &x2, &y2, ih->data->xc, ih->data->yc);
cdCanvasForeground(ih->data->cddbuffer, cdEncodeColor(shade_dr, shade_dg, shade_db));
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
iColorBrowserRotatePoints(&x1, &y1, &x2, &y2, ih->data->xc, ih->data->yc);
cdCanvasForeground(ih->data->cddbuffer, cdEncodeColor(shade_lr, shade_lg, shade_lb));
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
iColorBrowserRotatePoints(&x1, &y1, &x2, &y2, ih->data->xc, ih->data->yc);
cdCanvasForeground(ih->data->cddbuffer, cdEncodeColor(shade_dr, shade_dg, shade_db));
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
iColorBrowserRotatePoints(&x1, &y1, &x2, &y2, ih->data->xc, ih->data->yc);
cdCanvasLine(ih->data->cddbuffer, (int) x1, (int) y1, (int) x2, (int) y2);
}
}
