diff options
Diffstat (limited to 'test/cdtest/cdtest.c')
| -rw-r--r-- | test/cdtest/cdtest.c | 2662 |
1 files changed, 2662 insertions, 0 deletions
diff --git a/test/cdtest/cdtest.c b/test/cdtest/cdtest.c new file mode 100644 index 0000000..bf701b9 --- /dev/null +++ b/test/cdtest/cdtest.c @@ -0,0 +1,2662 @@ +/*=========================================================================*/ +/* CDTEST.C - 09/12/95 */ +/* Canvas Draw Test. */ +/*=========================================================================*/ + +/*- Convenccoes Usadas: ---------------------------------------------------*/ +/* - Identificadores de funccoes associadas a um callback comeccam por f. */ +/* Ex: fResize, fRepaint. */ +/* - Identificadores de constantes sao escritos em maiusculas. */ +/* Ex: LINE, ARC, NEWPOINT. */ +/* - Identificadores de funcoes internas do programa sao escritas em */ +/* minusculas. */ +/* Ex: newpolypoint, dellist. */ +/*-------------------------------------------------------------------------*/ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include <iup.h> +#include <cd.h> +#include <wd.h> +#include <cdiup.h> +#include <cdpicture.h> +#include <cddbuf.h> +#include <cdirgb.h> +#include <cdgdiplus.h> +#include <iupkey.h> + +#include "cdtest.h" + +/*- Contexto do CD Test: --------------------------------------------------*/ +tCTC ctgc; + +/*- Parametros geometricos da primitiva sendo desenhada: ------------------*/ +tLinePos line_pos; +tBoxPos box_pos; +tPixelPos pixel_pos; +tMarkPos mark_pos; +tArcPos arc_pos; + +//#define USE_GDIPLUS + +#ifdef USE_GDIPLUS +static const int use_gdiplus = 1; +#else +static const int use_gdiplus = 0; +#endif + +static const int antialias = 1; + + +/*-------------------------------------------------------------------------*/ +/* Associa os call-backs do IUP. */ +/*-------------------------------------------------------------------------*/ +void setcallbacks(void) +{ + IupSetFunction("cmdFileExit", (Icallback) fFileExit); + + IupSetFunction("cmdEditClear", (Icallback) fEditClear); + IupSetFunction("cmdEditUndo", (Icallback) fEditUndo); + + IupSetFunction("cmdHelpAbout", (Icallback) fHelpAbout); + IupSetFunction("cmdCloseAbout", (Icallback) fCloseAbout); + + IupSetFunction("cmdWDCanvas", (Icallback) fWDCanvas); + IupSetFunction("cmdCloseWD", (Icallback) fCloseWD); + IupSetFunction("cmdPICCanvas", (Icallback) fPICCanvas); + IupSetFunction("cmdClosePIC", (Icallback) fClosePIC); + + IupSetFunction("cmdShowDialog", (Icallback) fShowDialog); + IupSetFunction("cmdLine", (Icallback) fLine); + IupSetFunction("cmdRect", (Icallback) fRect); + IupSetFunction("cmdBox", (Icallback) fBox); + IupSetFunction("cmdArc", (Icallback) fArc); + IupSetFunction("cmdSector", (Icallback) fSector); + IupSetFunction("cmdChord", (Icallback) fChord); + IupSetFunction("cmdPixel", (Icallback) fPixel); + IupSetFunction("cmdMark", (Icallback) fMark); + IupSetFunction("cmdText", (Icallback) fText); + IupSetFunction("cmdPoly", (Icallback) fPoly); + + IupSetFunction("cmdOptions", (Icallback) fOptions); + IupSetFunction("cmdOptionsHide", (Icallback) fOptionsHide); + IupSetFunction("cmdAttributes", (Icallback) fAttributes); + IupSetFunction("cmdAttributesHide", (Icallback) fAttributesHide); + IupSetFunction("cmdMsgHide", (Icallback) fMsgHide); + IupSetFunction("cmdSimulate", (Icallback) fSimulate); + IupSetFunction("cmdStretchPlay", (Icallback) fStretchPlay); + + IupSetFunction("cmdWriteMode", (Icallback) fWriteMode); + IupSetFunction("cmdLineStyle", (Icallback) fLineStyle); + IupSetFunction("cmdLineCap", (Icallback) fLineCap); + IupSetFunction("cmdLineJoin", (Icallback) fLineJoin); + IupSetFunction("cmdFillMode", (Icallback) fFillMode); + IupSetFunction("cmdFontStyle", (Icallback) fFontStyle); + IupSetFunction("cmdFontTypeFace", (Icallback) fFontTypeFace); + IupSetFunction("cmdMarkType", (Icallback) fMarkType); + IupSetFunction("cmdTextAlignment", (Icallback) fTextAlignment); + IupSetFunction("cmdHatchStyle", (Icallback) fHatchStyle); + IupSetFunction("cmdOpacity", (Icallback) fOpacity); + + IupSetFunction("cmdNoBuffering", (Icallback) fNoBuffering); + IupSetFunction("cmdImageBuffer", (Icallback) fImageBuffer); + IupSetFunction("cmdRGBBuffer", (Icallback) fRGBBuffer); + + IupSetFunction("cmdInteger", (Icallback) fInteger); + IupSetFunction("cmdReal", (Icallback) fReal); + IupSetFunction("cmdDraw", (Icallback) fDraw); + + IupSetFunction("cmdSolid", (Icallback) fSolid); + IupSetFunction("cmdHatch", (Icallback) fHatch); + IupSetFunction("cmdStipple", (Icallback) fStipple); + IupSetFunction("cmdPattern", (Icallback) fPattern); + + IupSetFunction("cmdOpenLines", (Icallback) fOpenLines); + IupSetFunction("cmdClosedLines", (Icallback) fClosedLines); + IupSetFunction("cmdFill", (Icallback) fFill); + IupSetFunction("cmdPolyClip", (Icallback) fPolyClip); + IupSetFunction("cmdPolyBezier", (Icallback) fPolyBezier); + + IupSetFunction("cmdClip", (Icallback) fClip); + IupSetFunction("cmdClipArea", (Icallback) fClipArea); + IupSetFunction("cmdClipOff", (Icallback) fClipOff); + IupSetFunction("cmdClipPoly", (Icallback) fClipPoly); + + IupSetFunction("cmdImage", (Icallback) fImage); + IupSetFunction("cmdImagePut", (Icallback) fImagePut); + IupSetFunction("cmdImageGet", (Icallback) fImageGet); + + IupSetFunction("cmdImageRGB", (Icallback) fImageRGB); + IupSetFunction("cmdImageRGBPut", (Icallback) fImageRGBPut); + IupSetFunction("cmdImageRGBGet", (Icallback) fImageRGBGet); +} + +/*-------------------------------------------------------------------------*/ +/* Inicializa o stipple e o pattern exemplo. */ +/*-------------------------------------------------------------------------*/ +void initsamples(void) +{ + int i; + + /* zera os vetores */ + for (i=0; i<100; i++) { + ctgc.stipple[i] = 0; + ctgc.pattern[i] = 0xffffffl; + } + + /* especificaccao do stipple */ + ctgc.stipple[11] = 1; /*------------*/ + ctgc.stipple[21] = 1; /* 0123456789*/ + ctgc.stipple[31] = 1; /* */ + ctgc.stipple[41] = 1; /*9 0000000000*/ + ctgc.stipple[51] = 1; /*8 0000111110*/ + /*7 0001000110*/ + ctgc.stipple[12] = 1; /*6 0010001010*/ + ctgc.stipple[52] = 1; /*5 0111110010*/ + ctgc.stipple[62] = 1; /*4 0100010010*/ + /*3 0100010100*/ + ctgc.stipple[13] = 1; /*2 0100011000*/ + ctgc.stipple[53] = 1; /*1 0111110000*/ + ctgc.stipple[73] = 1; /*0 0000000000*/ + /*------------*/ + ctgc.stipple[14] = 1; + ctgc.stipple[54] = 1; + ctgc.stipple[84] = 1; + + ctgc.stipple[15] = 1; ctgc.stipple[26] = 1; + ctgc.stipple[25] = 1; ctgc.stipple[66] = 1; + ctgc.stipple[35] = 1; ctgc.stipple[86] = 1; + ctgc.stipple[45] = 1; + ctgc.stipple[55] = 1; ctgc.stipple[48] = 1; + ctgc.stipple[85] = 1; ctgc.stipple[58] = 1; + ctgc.stipple[68] = 1; + ctgc.stipple[37] = 1; ctgc.stipple[78] = 1; + ctgc.stipple[77] = 1; ctgc.stipple[88] = 1; + ctgc.stipple[87] = 1; + + + /* especificaccao do stipple */ + ctgc.pattern[11] = CD_RED; /*------------*/ + ctgc.pattern[21] = CD_RED; /* 0123456789*/ + ctgc.pattern[31] = CD_RED; /* */ + ctgc.pattern[41] = CD_RED; /*9 WWWWWWWWWW*/ + ctgc.pattern[51] = CD_RED; /*8 WWWWGGGGGW*/ + ctgc.pattern[12] = CD_RED; /*7 WWWGGGGGBW*/ + ctgc.pattern[22] = CD_RED; /*6 WWGGGGGBBW*/ + ctgc.pattern[32] = CD_RED; /*5 WrrrrrBBBW*/ + ctgc.pattern[42] = CD_RED; /*4 WrrrrrBBBW*/ + ctgc.pattern[52] = CD_RED; /*3 WrrrrrBBWW*/ + ctgc.pattern[13] = CD_RED; /*2 WrrrrrBWWW*/ + ctgc.pattern[23] = CD_RED; /*1 WrrrrrWWWW*/ + ctgc.pattern[33] = CD_RED; /*0 WWWWWWWWWW*/ + ctgc.pattern[43] = CD_RED; /*------------*/ + ctgc.pattern[53] = CD_RED; + ctgc.pattern[14] = CD_RED; ctgc.pattern[15] = CD_RED; + ctgc.pattern[24] = CD_RED; ctgc.pattern[25] = CD_RED; + ctgc.pattern[34] = CD_RED; ctgc.pattern[35] = CD_RED; + ctgc.pattern[44] = CD_RED; ctgc.pattern[45] = CD_RED; + ctgc.pattern[54] = CD_RED; ctgc.pattern[55] = CD_RED; + + ctgc.pattern[26] = CD_BLUE; ctgc.pattern[37] = CD_BLUE; + ctgc.pattern[36] = CD_BLUE; ctgc.pattern[47] = CD_BLUE; + ctgc.pattern[46] = CD_BLUE; ctgc.pattern[57] = CD_BLUE; + ctgc.pattern[56] = CD_BLUE; ctgc.pattern[67] = CD_BLUE; + + ctgc.pattern[48] = CD_BLUE; ctgc.pattern[62] = CD_GREEN; + ctgc.pattern[58] = CD_BLUE; ctgc.pattern[63] = CD_GREEN; + ctgc.pattern[68] = CD_BLUE; ctgc.pattern[64] = CD_GREEN; + ctgc.pattern[78] = CD_BLUE; ctgc.pattern[65] = CD_GREEN; + ctgc.pattern[66] = CD_GREEN; + + ctgc.pattern[73] = CD_GREEN; ctgc.pattern[84] = CD_GREEN; + ctgc.pattern[74] = CD_GREEN; ctgc.pattern[85] = CD_GREEN; + ctgc.pattern[75] = CD_GREEN; ctgc.pattern[86] = CD_GREEN; + ctgc.pattern[76] = CD_GREEN; ctgc.pattern[87] = CD_GREEN; + ctgc.pattern[77] = CD_GREEN; ctgc.pattern[88] = CD_GREEN; + + ctgc.dashes[0] = 10; + ctgc.dashes[1] = 2; + ctgc.dashes[2] = 5; + ctgc.dashes[3] = 2; +} + +/*-------------------------------------------------------------------------*/ +/* Inicializa o CD Test. */ +/*-------------------------------------------------------------------------*/ +void CDTestInit(void) +{ + memset(&ctgc, 0, sizeof(ctgc)); + + if (use_gdiplus) + { +#ifdef USE_GDIPLUS + cdInitGdiPlus(); +#endif + } + + /* inicializaccao dos drivers */ + DriversInit(); + + /* mostra o dialogo principal */ + IupShow(IupGetHandle("dlgMain")); + + /* inicializaccao da barra de cores */ + ColorBarInit(IupGetHandle("dlgMain"), IupGetHandle("cnvColorBar"), &ctgc.foreground, &ctgc.background); + + /* cria o canvas do CD associado ao canvas do IUP */ + if (use_gdiplus) cdUseContextPlus(1); + ctgc.iup_canvas = cdCreateCanvas(CD_IUP, IupGetHandle("cnvMain")); + if (!antialias) cdCanvasSetAttribute(ctgc.iup_canvas, "ANTIALIAS", "0"); + cdActivate(ctgc.iup_canvas); + if (use_gdiplus) cdUseContextPlus(0); + + /* associa os call-backs */ + setcallbacks(); + + /* os call-backs do canvas devem ser associados depois de sua criacao */ + IupSetFunction("cmdRepaint", (Icallback) fRepaint); + IupSetFunction("cmdMotionCB", (Icallback) fMotionCB); + IupSetFunction("cmdButtonCB", (Icallback) fButtonCB); + IupSetFunction("cmdResizeCB", (Icallback) fResizeCB); + IupSetFunction("cmdGetFocusCB", (Icallback) fGetFocusCB); + + /* inicializaccao do contexto */ + ctgc.write_mode = CD_REPLACE; + ctgc.line_style = CD_CONTINUOUS; + ctgc.line_cap = CD_CAPFLAT; + ctgc.line_join = CD_MITER; + ctgc.fill_mode = CD_EVENODD; + ctgc.line_width = 1; + ctgc.font_style = CD_PLAIN; + ctgc.font_typeface = CD_SYSTEM; + ctgc.font_size = CD_STANDARD; + ctgc.text_alignment = CD_BASE_LEFT; + ctgc.text_orientation = 0; + ctgc.back_opacity = CD_TRANSPARENT; + ctgc.mark_type = CD_STAR; + ctgc.poly_mode = CD_OPEN_LINES; + ctgc.interior_style = CD_SOLID; + ctgc.hatch = CD_HORIZONTAL; + ctgc.following = FALSE; + ctgc.foreground = CD_BLACK; + ctgc.background = CD_WHITE; + ctgc.head = NULL; + ctgc.test_image = NULL; + ctgc.sim = 0; + ctgc.stretch_play = 0; + ctgc.dlg_x = IUP_CENTER; + ctgc.dlg_y = IUP_CENTER; + ctgc.visible = 0; + + /* inicializa os vetores stipple e pattern */ + initsamples(); + + /* inicializa o CDTest com a primitiva LINE */ + ctgc.dlg_cur_prim = IupGetHandle("dlgLB"); + ctgc.bt_cur_prim = IupGetHandle("btCurPrim"); + ctgc.cur_prim = LINE; + + /* inicializaccao do Canvas do IUP */ + cdActivate(ctgc.iup_canvas); + cdFont(ctgc.font_typeface,ctgc.font_style,ctgc.font_size); + cdBackground(ctgc.background); + cdClear(); + cdGetCanvasSize(&(ctgc.w),&(ctgc.h),NULL,NULL); + ctgc.bpp = cdGetColorPlanes(); + + { + double mm, xres; + cdPixel2MM(1, 0, &mm, NULL); + xres = 1.0/mm; + ctgc.res = xres; + } + + /* inicializa o canvas off-screen de double-bufering */ + ctgc.buffering = NO_BUFFER; + ctgc.buffer_canvas = NULL; + + /* inicializa o clipping */ + ctgc.clip_mode = CD_CLIPOFF; + cdGetClipArea(&(ctgc.clip_xmin), &(ctgc.clip_xmax), + &(ctgc.clip_ymin), &(ctgc.clip_ymax)); + + /* zera o buffer temporario de pontos */ + ctgc.num_points = 0; + + /* a lista de primitivas jah estah vazia, nao hah o que apagar */ + IupSetAttribute(IupGetHandle("itEditUndo"), IUP_ACTIVE, IUP_NO); + + /* atualiza o tamanho do canvas em pixels na barra de titulo */ + sprintf(ctgc.title, "CDTest 5.3 (%dx%d - %dbpp)", ctgc.w, ctgc.h, ctgc.bpp); + IupSetAttribute(IupGetHandle("dlgMain"), IUP_TITLE, ctgc.title); + + /* inicializa a barra de status */ + sprintf(ctgc.status_line, "LEFT click and drag."); + set_status(); + + /* inicializa a posiccao do mouse */ + mouse_pos(0, 0); + + /* constroi os dialogos do CDTest sem mostra-los */ + IupMap(IupGetHandle("dlgLB")); + IupMap(IupGetHandle("dlgAS")); + IupMap(IupGetHandle("dlgPixel")); + IupMap(IupGetHandle("dlgImage")); + IupMap(IupGetHandle("dlgImageRGB")); + IupMap(IupGetHandle("dlgMark")); + IupMap(IupGetHandle("dlgText")); + IupMap(IupGetHandle("dlgClip")); + IupMap(IupGetHandle("dlgAttributes")); + IupMap(IupGetHandle("dlgWDCanvas")); + IupMap(IupGetHandle("dlgPICCanvas")); + + /* cria o canvas WD */ + if (use_gdiplus) cdUseContextPlus(1); + ctgc.wd_canvas = cdCreateCanvas(CD_IUP, IupGetHandle("cnvWDCanvas")); + ctgc.pic_canvas = cdCreateCanvas(CD_IUP, IupGetHandle("cnvPICCanvas")); + ctgc.picture = cdCreateCanvas(CD_PICTURE, ""); + if (use_gdiplus) cdUseContextPlus(0); + + /* CDTEST default values */ + cdActivate(ctgc.picture); + cdLineStyleDashes(ctgc.dashes, 4); + cdPattern(10, 10, ctgc.pattern); + cdStipple(10, 10, ctgc.stipple); + cdInteriorStyle(CD_SOLID); + + cdActivate(ctgc.wd_canvas); + cdLineStyleDashes(ctgc.dashes, 4); + cdPattern(10, 10, ctgc.pattern); + cdStipple(10, 10, ctgc.stipple); + cdInteriorStyle(CD_SOLID); + + /* reativa o canvas IUP */ + cdActivate(ctgc.iup_canvas); + cdLineStyleDashes(ctgc.dashes, 4); + cdPattern(10, 10, ctgc.pattern); + cdStipple(10, 10, ctgc.stipple); + cdInteriorStyle(CD_SOLID); +} + +static void CDTestClose(void) +{ + dellist(); + + ColorBarClose(); + + if (ctgc.buffer_canvas) cdKillCanvas(ctgc.buffer_canvas); + if (ctgc.test_image) cdKillImage(ctgc.test_image); + cdKillCanvas(ctgc.picture); + cdKillCanvas(ctgc.pic_canvas); + cdKillCanvas(ctgc.wd_canvas); + cdKillCanvas(ctgc.iup_canvas); + + IupDestroy(IupGetHandle("dlgLB")); + IupDestroy(IupGetHandle("dlgAS")); + IupDestroy(IupGetHandle("dlgPixel")); + IupDestroy(IupGetHandle("dlgImage")); + IupDestroy(IupGetHandle("dlgImageRGB")); + IupDestroy(IupGetHandle("dlgMark")); + IupDestroy(IupGetHandle("dlgText")); + IupDestroy(IupGetHandle("dlgClip")); + IupDestroy(IupGetHandle("dlgAttributes")); + IupDestroy(IupGetHandle("dlgWDCanvas")); + IupDestroy(IupGetHandle("dlgPICCanvas")); + + IupDestroy(IupGetHandle("dlgMain")); +} + +static int iscurvisible(void) +{ + char* vis = IupGetAttribute(ctgc.dlg_cur_prim, IUP_VISIBLE); + if (!vis) + return 0; + return strcmp(vis, IUP_YES) == 0? 1: 0; +} + +/*-------------------------------------------------------------------------*/ +/* Copia o conteudo da lista de primitivas para o dispositivo ativo. */ +/*-------------------------------------------------------------------------*/ +void putlist(cdCanvas *target) +{ + tList *temp; + int wdc_w, wdc_h, wd = 0; + + /* ativa o canvas destino */ + cdActivate(target); + + if (target == ctgc.wd_canvas) + { + cdGetCanvasSize(&wdc_w, &wdc_h, NULL, NULL); + wdWindow(0, ctgc.w, 0, ctgc.h); + wdViewport(0, wdc_w, 0, wdc_h); + wd = 1; + } + + /* limpa o canvas com a cor de fundo */ + cdBackground(ctgc.background); + cdClear(); + cdClipArea(ctgc.clip_xmin, ctgc.clip_xmax, ctgc.clip_ymin, ctgc.clip_ymax); + cdClip(ctgc.clip_mode); + + /* coloca a lista de primitivas no canvas */ + for (temp = ctgc.head; temp; temp = (tList *) temp->next) + { + switch (temp->type) { + case LINE: + cdWriteMode(temp->par.lineboxpar.write_mode); + cdLineCap(temp->par.lineboxpar.line_cap); + cdLineJoin(temp->par.lineboxpar.line_join); + cdLineStyle(temp->par.lineboxpar.line_style); + cdLineWidth(temp->par.lineboxpar.line_width); + cdForeground(temp->par.lineboxpar.foreground); + if (wd) + wdLine(temp->par.lineboxpar.x1, temp->par.lineboxpar.y1, + temp->par.lineboxpar.x2, temp->par.lineboxpar.y2); + else + cdLine(temp->par.lineboxpar.x1, temp->par.lineboxpar.y1, + temp->par.lineboxpar.x2, temp->par.lineboxpar.y2); + break; + case RECT: + cdWriteMode(temp->par.lineboxpar.write_mode); + cdLineCap(temp->par.lineboxpar.line_cap); + cdLineJoin(temp->par.lineboxpar.line_join); + cdLineStyle(temp->par.lineboxpar.line_style); + cdLineWidth(temp->par.lineboxpar.line_width); + cdForeground(temp->par.lineboxpar.foreground); + if (wd) + wdRect(temp->par.lineboxpar.x1, temp->par.lineboxpar.x2, + temp->par.lineboxpar.y1, temp->par.lineboxpar.y2); + else + cdRect(temp->par.lineboxpar.x1, temp->par.lineboxpar.x2, + temp->par.lineboxpar.y1, temp->par.lineboxpar.y2); + break; + case BOX: + cdWriteMode(temp->par.lineboxpar.write_mode); + cdLineCap(temp->par.lineboxpar.line_cap); + cdLineJoin(temp->par.lineboxpar.line_join); + cdLineStyle(temp->par.lineboxpar.line_style); + cdLineWidth(temp->par.lineboxpar.line_width); + cdForeground(temp->par.lineboxpar.foreground); + cdBackground(temp->par.lineboxpar.background); + cdBackOpacity(temp->par.lineboxpar.back_opacity); + cdHatch(temp->par.lineboxpar.hatch); + cdInteriorStyle(temp->par.lineboxpar.interior_style); + if (wd) + wdBox(temp->par.lineboxpar.x1, temp->par.lineboxpar.x2, + temp->par.lineboxpar.y1, temp->par.lineboxpar.y2); + else + cdBox(temp->par.lineboxpar.x1, temp->par.lineboxpar.x2, + temp->par.lineboxpar.y1, temp->par.lineboxpar.y2); + break; + case ARC: + cdWriteMode(temp->par.arcsectorpar.write_mode); + cdLineCap(temp->par.arcsectorpar.line_cap); + cdLineJoin(temp->par.arcsectorpar.line_join); + cdLineStyle(temp->par.arcsectorpar.line_style); + cdLineWidth(temp->par.arcsectorpar.line_width); + cdForeground(temp->par.arcsectorpar.foreground); + if (wd) + wdArc(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + else + cdArc(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + break; + case CHORD: + cdWriteMode(temp->par.arcsectorpar.write_mode); + cdLineCap(temp->par.arcsectorpar.line_cap); + cdLineJoin(temp->par.arcsectorpar.line_join); + cdLineStyle(temp->par.arcsectorpar.line_style); + cdLineWidth(temp->par.arcsectorpar.line_width); + cdForeground(temp->par.arcsectorpar.foreground); + cdBackground(temp->par.arcsectorpar.background); + cdBackOpacity(temp->par.arcsectorpar.back_opacity); + cdHatch(temp->par.arcsectorpar.hatch); + cdInteriorStyle(temp->par.arcsectorpar.interior_style); + if (wd) + wdChord(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + else + cdChord(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + break; + case SECTOR: + cdWriteMode(temp->par.arcsectorpar.write_mode); + cdLineCap(temp->par.arcsectorpar.line_cap); + cdLineJoin(temp->par.arcsectorpar.line_join); + cdLineStyle(temp->par.arcsectorpar.line_style); + cdLineWidth(temp->par.arcsectorpar.line_width); + cdForeground(temp->par.arcsectorpar.foreground); + cdBackground(temp->par.arcsectorpar.background); + cdBackOpacity(temp->par.arcsectorpar.back_opacity); + cdHatch(temp->par.arcsectorpar.hatch); + cdInteriorStyle(temp->par.arcsectorpar.interior_style); + if (wd) + wdSector(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + else + cdSector(temp->par.arcsectorpar.xc, temp->par.arcsectorpar.yc, + temp->par.arcsectorpar.w, temp->par.arcsectorpar.h, + temp->par.arcsectorpar.angle1, temp->par.arcsectorpar.angle2); + break; + case PIXEL: + cdWriteMode(temp->par.pixelpar.write_mode); + cdPixel(temp->par.pixelpar.x, temp->par.pixelpar.y, + temp->par.pixelpar.foreground); + break; + case MARK: + cdWriteMode(temp->par.markpar.write_mode); + cdMarkSize(temp->par.markpar.mark_size); + cdMarkType(temp->par.markpar.mark_type); + cdForeground(temp->par.markpar.foreground); + if (wd) + wdMark(temp->par.markpar.x, temp->par.markpar.y); + else + cdMark(temp->par.markpar.x, temp->par.markpar.y); + break; + case TEXT: + cdWriteMode(temp->par.textpar.write_mode); + cdForeground(temp->par.textpar.foreground); + cdBackground(temp->par.textpar.background); + cdBackOpacity(temp->par.textpar.back_opacity); + cdTextAlignment(temp->par.textpar.text_alignment); + cdTextOrientation(temp->par.textpar.text_orientation); + cdFont(temp->par.textpar.font_typeface, + temp->par.textpar.font_style, + temp->par.textpar.font_size); + if (wd) + wdText(temp->par.textpar.x, temp->par.textpar.y, + temp->par.textpar.s); + else + cdText(temp->par.textpar.x, temp->par.textpar.y, + temp->par.textpar.s); + break; + case POLY: { + int i; + cdForeground(temp->par.polypar.foreground); + cdBackground(temp->par.polypar.background); + cdWriteMode(temp->par.polypar.write_mode); + cdLineCap(temp->par.polypar.line_cap); + cdLineJoin(temp->par.polypar.line_join); + cdLineStyle(temp->par.polypar.line_style); + cdLineWidth(temp->par.polypar.line_width); + cdFillMode(temp->par.polypar.fill_mode); + cdBackOpacity(temp->par.polypar.back_opacity); + cdHatch(temp->par.polypar.hatch); + cdInteriorStyle(temp->par.polypar.interior_style); + cdBegin(temp->par.polypar.poly_mode); + if (wd) + for (i=0; (i<temp->par.polypar.num_points); i++) { + wdVertex(temp->par.polypar.points[i].x, + temp->par.polypar.points[i].y); + } + else + for (i=0; (i<temp->par.polypar.num_points); i++) { + cdVertex(temp->par.polypar.points[i].x, + temp->par.polypar.points[i].y); + } + cdEnd(); + break; + case META: + cdWriteMode(CD_REPLACE); + cdLineStyle(CD_CONTINUOUS); + cdLineWidth(1); + cdBackground(CD_WHITE); + cdBackOpacity(CD_TRANSPARENT); + cdForeground(CD_BLACK); + cdInteriorStyle(CD_SOLID); + if (ctgc.stretch_play) + { + if (wd) + cdPlay(temp->par.metapar.ctx, 0, wdc_w-1, 0, wdc_h-1, temp->par.metapar.filename); + else + cdPlay(temp->par.metapar.ctx, 0, ctgc.w-1, 0, ctgc.h-1, temp->par.metapar.filename); + } + else + cdPlay(temp->par.metapar.ctx, 0, 0, 0, 0, temp->par.metapar.filename); + break; + default: + break; + } + } + } + + /* volta o clip-mode para o corrente */ + cdClip(ctgc.clip_mode); +} + +/*-------------------------------------------------------------------------*/ +/* Copia o conteudo da lista de primitivas no canvas WD. */ +/*-------------------------------------------------------------------------*/ +int fWDRepaint(void) +{ + putlist(ctgc.wd_canvas); + + /* reativa o canvas iup */ + cdActivate(ctgc.iup_canvas); + + return IUP_DEFAULT; +} + +int fPICRepaint(void) +{ + int w, h; + putlist(ctgc.picture); + + cdActivate(ctgc.pic_canvas); + cdGetCanvasSize(&w, &h, NULL, NULL); + cdClear(); + if (ctgc.stretch_play) + cdPlay(CD_PICTURE, 0, w-1, 0, h-1, ctgc.picture); + else + cdPlay(CD_PICTURE, 0, 0, 0, 0, ctgc.picture); + + /* reativa o canvas iup */ + cdActivate(ctgc.iup_canvas); + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Redesenha o canvas. */ +/*-------------------------------------------------------------------------*/ +void updatecanvas(void) +{ + if (ctgc.buffering == NO_BUFFER) + putlist(ctgc.iup_canvas); + else + { + cdActivate(ctgc.iup_canvas); + cdClip(CD_CLIPOFF); + + putlist(ctgc.buffer_canvas); + cdFlush(); + + cdActivate(ctgc.iup_canvas); + cdClip(ctgc.clip_mode); + } + + if (ctgc.wd_dialog) + fWDRepaint(); + + if (ctgc.pic_dialog) + fPICRepaint(); +} + +/*-------------------------------------------------------------------------*/ +/* Redesenha o canvas. */ +/*-------------------------------------------------------------------------*/ +int fRepaint(void) +{ + int i; + + /* ativa o canvas na tela */ + cdActivate(ctgc.iup_canvas); + wdViewport(0, ctgc.w, 0, ctgc.h); + + /* desliga o clipping durante o evento Repaint */ + cdClip(CD_CLIPOFF); + + /* double-buffering? */ + cdWriteMode(CD_REPLACE); + updatecanvas(); + + /* se o evento repaint for gerado durante o rubber band...*/ + /* ...eh preciso restaurar o estado anterior */ + if (ctgc.following) { + cdWriteMode(CD_NOT_XOR); + cdForeground(CD_BLACK); + cdLineStyle(CD_CONTINUOUS); + cdLineWidth(1); + switch (ctgc.cur_prim) { + case POLY: + for (i=0; (i<ctgc.num_points-1); i++) { + cdLine(ctgc.points[i].x, ctgc.points[i].y, + ctgc.points[i+1].x, ctgc.points[i+1].y); + } + polygon(REPAINT, 0, 0); + break; + case LINE: + line(REPAINT, 0, 0); + break; + case ARC: + case CHORD: + case SECTOR: + arc(REPAINT, 0, 0); + break; + case RECT: + case BOX: + box(REPAINT, 0, 0); + break; + default: + break; + } + } + + /* restaura o estado de clipping anterior ao evento Repaint */ + cdClip(ctgc.clip_mode); + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Ativa o canvas WD. */ +/*-------------------------------------------------------------------------*/ +int fWDCanvas(void) +{ + IupShow(IupGetHandle("dlgWDCanvas")); + ctgc.wd_dialog = TRUE; + IupSetFunction("cmdWDRepaint", (Icallback)fWDRepaint); + fWDRepaint(); + return IUP_DEFAULT; +} + +int fPICCanvas(void) +{ + IupShow(IupGetHandle("dlgPICCanvas")); + ctgc.pic_dialog = TRUE; + IupSetFunction("cmdPICRepaint", (Icallback)fPICRepaint); + fPICRepaint(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Desativa o canvas WD. */ +/*-------------------------------------------------------------------------*/ +int fCloseWD(void) +{ + ctgc.wd_dialog = FALSE; + return IUP_DEFAULT; +} + +int fClosePIC(void) +{ + ctgc.pic_dialog = FALSE; + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Apaga a ultima primitiva desenhada. */ +/*-------------------------------------------------------------------------*/ +int fEditUndo(void) +{ + /* apaga a ultima primitiva da fila */ + dellast(); + /* se nao ha mais primitivas na fila, desabilita o undo */ + if (ctgc.head == NULL) + IupSetAttribute(IupGetHandle("itEditUndo"), IUP_ACTIVE, IUP_NO); + + updatecanvas(); + + return IUP_DEFAULT; +} + +int fSimulate(Ihandle *self, int v) +{ + ignore(self); + + cdActivate(ctgc.iup_canvas); + + if (v == 1) + { + if (ctgc.sim == 1) + return IUP_DEFAULT; + + ctgc.sim = 1; + cdSimulate(CD_SIM_ALL); + sprintf(ctgc.status_line, "cdSimulate(CD_SIM_ALL)"); + } + else + { + if (ctgc.sim == 0) + return IUP_DEFAULT; + + ctgc.sim = 0; + cdSimulate(CD_SIM_NONE); + sprintf(ctgc.status_line, "cdSimulate(CD_SIM_NONE)"); + } + + set_status(); + updatecanvas(); + return IUP_DEFAULT; +} + +int fStretchPlay(Ihandle *self, int v) +{ + ignore(self); + ctgc.stretch_play = v; + updatecanvas(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Tchau. */ +/*-------------------------------------------------------------------------*/ +int fFileExit(void) +{ + IupHide(ctgc.dlg_cur_prim); + return IUP_CLOSE; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle OpenLines. */ +/*-------------------------------------------------------------------------*/ +int fOpenLines(void) +{ + ctgc.poly_mode = CD_OPEN_LINES; + sprintf(ctgc.status_line, "cdBegin(CD_OPEN_LINES)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle ClosedLines. */ +/*-------------------------------------------------------------------------*/ +int fClosedLines(void) +{ + ctgc.poly_mode = CD_CLOSED_LINES; + sprintf(ctgc.status_line, "cdBegin(CD_CLOSED_LINES)"); + set_status(); + return IUP_DEFAULT; +} + +int fPolyBezier(void) +{ + ctgc.poly_mode = CD_BEZIER; + sprintf(ctgc.status_line, "cdBegin(CD_BEZIER)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Fill. */ +/*-------------------------------------------------------------------------*/ +int fFill(void) +{ + ctgc.poly_mode = CD_FILL; + sprintf(ctgc.status_line, "cdBegin(CD_FILL)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Clip. */ +/*-------------------------------------------------------------------------*/ +int fPolyClip(void) +{ + ctgc.poly_mode = CD_CLIP; + sprintf(ctgc.status_line, "cdBegin(CD_CLIP)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Solid. */ +/*-------------------------------------------------------------------------*/ +int fSolid(void) +{ + ctgc.interior_style = CD_SOLID; + sprintf(ctgc.status_line, "cdInteriorStyle(CD_SOLID)"); + set_status(); + cdInteriorStyle(CD_SOLID); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Hatch. */ +/*-------------------------------------------------------------------------*/ +int fHatch(void) +{ + ctgc.interior_style = CD_HATCH; + cdInteriorStyle(CD_HATCH); + sprintf(ctgc.status_line, "cdInteriorStyle(CD_HATCH)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Stipple. */ +/*-------------------------------------------------------------------------*/ +int fStipple(void) +{ + ctgc.interior_style = CD_STIPPLE; + cdInteriorStyle(CD_STIPPLE); + sprintf(ctgc.status_line, "cdInteriorStyle(CD_STIPPLE)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao toggle Pattern. */ +/*-------------------------------------------------------------------------*/ +int fPattern(void) +{ + ctgc.interior_style = CD_PATTERN; + cdInteriorStyle(CD_PATTERN); + sprintf(ctgc.status_line, "cdInteriorStyle(CD_PATTERN)"); + set_status(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Seleciona o a opacidade do fundo. */ +/*-------------------------------------------------------------------------*/ +int fOpacity(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.back_opacity = CD_OPAQUE; + sprintf(ctgc.status_line, "cdBackOpacity(CD_OPAQUE)"); + break; + case 2: + ctgc.back_opacity = CD_TRANSPARENT; + sprintf(ctgc.status_line, "cdBackOpacity(CD_TRANSPARENT)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + + +/*-------------------------------------------------------------------------*/ +/* Seleciona o modo de repaint para imagem do servidor. */ +/*-------------------------------------------------------------------------*/ +int fImageBuffer(Ihandle *self, int v) +{ + ignore(self); + + /* se o toggle foi para o estado ligado... */ + if (v) { + switch (ctgc.buffering) { + case IMAGE_BUFFER: + break; + case IMAGERGB_BUFFER: + /* mata o canvas do buffer anterior */ + if (ctgc.buffer_canvas) cdKillCanvas(ctgc.buffer_canvas); + ctgc.buffer_canvas = NULL; + /* prosegue como se nao houvesse o buffer anterior */ + case NO_BUFFER: + /* cria o canvas do buffer */ + if (use_gdiplus) cdUseContextPlus(1); + ctgc.buffer_canvas = cdCreateCanvas(CD_DBUFFER, ctgc.iup_canvas); + if (!antialias) cdCanvasSetAttribute(ctgc.buffer_canvas, "ANTIALIAS", "0"); + if (use_gdiplus) cdUseContextPlus(0); + /* se nao consegui criar o canvas... */ + if (!ctgc.buffer_canvas) { + /* desabilita o double-buffering */ + ctgc.buffering = NO_BUFFER; + sprintf(ctgc.status_line, "Error creating CD_DBUFFER canvas."); + set_status(); + } + else { + /* seta o modo de escrita para double-buffering em imagem do servidor */ + ctgc.buffering = IMAGE_BUFFER; + /* reconstroe o stipple e o pattern no canvas do buffer */ + cdActivate(ctgc.buffer_canvas); + cdLineStyleDashes(ctgc.dashes, 4); + cdPattern(10, 10, ctgc.pattern); + cdStipple(10, 10, ctgc.stipple); + cdInteriorStyle(CD_SOLID); + if (ctgc.sim == 1) + cdSimulate(CD_SIM_ALL); + else + cdSimulate(CD_SIM_NONE); + /* atualiza o buffer */ + updatecanvas(); + /* muda a linha de status */ + sprintf(ctgc.status_line, "CD_DBUFFER buffer active."); + set_status(); + } + + break; + } + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Seleciona o modo de repaint para imagem RGB. */ +/*-------------------------------------------------------------------------*/ +int fRGBBuffer(Ihandle *self, int v) +{ + ignore(self); + + if (v) { + switch (ctgc.buffering) { + case IMAGERGB_BUFFER: + break; + case IMAGE_BUFFER: + /* mata o canvas do buffer anterior */ + if (ctgc.buffer_canvas) cdKillCanvas(ctgc.buffer_canvas); + ctgc.buffer_canvas = NULL; + /* prossegue como se nao houvesse o buffer anterior */ + case NO_BUFFER: + /* cria o canvas do buffer */ + ctgc.buffer_canvas = cdCreateCanvas(CD_DBUFFERRGB, ctgc.iup_canvas); + if (!antialias) cdCanvasSetAttribute(ctgc.buffer_canvas, "ANTIALIAS", "0"); + /* se nao consegui criar o canvas... */ + if (!ctgc.buffer_canvas) { + /* mata a imagem alocada */ + /* desabilita o double-buffering */ + ctgc.buffering = NO_BUFFER; + sprintf(ctgc.status_line, "Error creating CD_DBUFFERRGB canvas."); + set_status(); + } + else { + /* seta o modo de escrita para double-buffering em imagem RGB */ + ctgc.buffering = IMAGERGB_BUFFER; + /* reconstroe o stipple e o pattern no canvas do buffer */ + cdActivate(ctgc.buffer_canvas); + cdLineStyleDashes(ctgc.dashes, 4); + cdPattern(10, 10, ctgc.pattern); + cdStipple(10, 10, ctgc.stipple); + cdInteriorStyle(CD_SOLID); + if (ctgc.sim == 1) + cdSimulate(CD_SIM_ALL); + else + cdSimulate(CD_SIM_NONE); + /* atualiza o buffer */ + updatecanvas(); + /* muda a linha de status */ + sprintf(ctgc.status_line, "CD_DBUFFERRGB buffer active."); + set_status(); + } + break; + } + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Seleciona o modo de repaint para escrita diretamente na tela. */ +/*-------------------------------------------------------------------------*/ +int fNoBuffering(Ihandle *self, int v) +{ + ignore(self); + + /* se foi para double-buffering, atualiza o buffer off-screen */ + if (v) { + switch (ctgc.buffering) { + case IMAGERGB_BUFFER: + /* mata o canvas */ + if (ctgc.buffer_canvas) cdKillCanvas(ctgc.buffer_canvas); + ctgc.buffer_canvas = NULL; + /* passa a desenhar diretamente na tela */ + ctgc.buffering = NO_BUFFER; + /* atualiza o buffer */ + updatecanvas(); + break; + case IMAGE_BUFFER: + /* mata o canvas */ + if (ctgc.buffer_canvas) cdKillCanvas(ctgc.buffer_canvas); + ctgc.buffer_canvas = NULL; + /* passa a desenhar diretamente na tela */ + ctgc.buffering = NO_BUFFER; + /* atualiza o buffer */ + updatecanvas(); + break; + case NO_BUFFER: + break; + } + } + /* muda a linha de status */ + sprintf(ctgc.status_line, "Now drawing on-screen."); + set_status(); + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcoes da barra de estilos.. */ +/*-------------------------------------------------------------------------*/ +int fMarkType(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.mark_type = CD_PLUS; + sprintf(ctgc.status_line, "cdMarkType(CD_PLUS)"); + break; + case 2: + ctgc.mark_type = CD_STAR; + sprintf(ctgc.status_line, "cdMarkType(CD_STAR)"); + break; + case 3: + ctgc.mark_type = CD_CIRCLE; + sprintf(ctgc.status_line, "cdMarkType(CD_CIRCLE)"); + break; + case 4: + ctgc.mark_type = CD_X; + sprintf(ctgc.status_line, "cdMarkType(CD_X)"); + break; + case 5: + ctgc.mark_type = CD_BOX; + sprintf(ctgc.status_line, "cdMarkType(CD_BOX)"); + break; + case 6: + ctgc.mark_type = CD_DIAMOND; + sprintf(ctgc.status_line, "cdMarkType(CD_DIAMOND)"); + break; + case 7: + ctgc.mark_type = CD_HOLLOW_CIRCLE; + sprintf(ctgc.status_line, "cdMarkType(CD_HOLLOW_CIRCLE)"); + break; + case 8: + ctgc.mark_type = CD_HOLLOW_BOX; + sprintf(ctgc.status_line, "cdMarkType(CD_HOLLOW_BOX)"); + break; + case 9: + ctgc.mark_type = CD_HOLLOW_DIAMOND; + sprintf(ctgc.status_line, "cdMarkType(CD_HOLLOW_DIAMOND)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fWriteMode(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.write_mode = CD_REPLACE; + sprintf(ctgc.status_line, "cdWriteMode(CD_REPLACE)"); + break; + case 2: + ctgc.write_mode = CD_XOR; + sprintf(ctgc.status_line, "cdWriteMode(CD_XOR)"); + break; + case 3: + ctgc.write_mode = CD_NOT_XOR; + sprintf(ctgc.status_line, "cdWriteMode(CD_NOT_XOR)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fLineStyle(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.line_style = CD_CONTINUOUS; + sprintf(ctgc.status_line, "cdLineStyle(CD_CONTINUOUS)"); + break; + case 2: + ctgc.line_style = CD_DASHED; + sprintf(ctgc.status_line, "cdLineStyle(CD_DASHED)"); + break; + case 3: + ctgc.line_style = CD_DOTTED; + sprintf(ctgc.status_line, "cdLineStyle(CD_DOTTED)"); + break; + case 4: + ctgc.line_style = CD_DASH_DOT; + sprintf(ctgc.status_line, "cdLineStyle(CD_DASH_DOT)"); + break; + case 5: + ctgc.line_style = CD_DASH_DOT_DOT; + sprintf(ctgc.status_line, "cdLineStyle(CD_DASH_DOT_DOT)"); + break; + case 6: + ctgc.line_style = CD_CUSTOM; + sprintf(ctgc.status_line, "cdLineStyle(CD_CUSTOM)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fLineCap(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.line_cap = CD_CAPFLAT; + sprintf(ctgc.status_line, "cdLineCap(CD_CAPFLAT)"); + break; + case 2: + ctgc.line_cap = CD_CAPSQUARE; + sprintf(ctgc.status_line, "cdLineCap(CD_CAPSQUARE)"); + break; + case 3: + ctgc.line_cap = CD_CAPROUND; + sprintf(ctgc.status_line, "cdLineCap(CD_CAPROUND)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fLineJoin(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.line_join = CD_MITER; + sprintf(ctgc.status_line, "cdLineJoin(CD_MITER)"); + break; + case 2: + ctgc.line_join = CD_BEVEL; + sprintf(ctgc.status_line, "cdLineJoin(CD_BEVEL)"); + break; + case 3: + ctgc.line_join = CD_ROUND; + sprintf(ctgc.status_line, "cdLineJoin(CD_ROUND)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fFillMode(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.fill_mode = CD_EVENODD; + sprintf(ctgc.status_line, "cdFillMode(CD_EVENODD)"); + break; + case 2: + ctgc.fill_mode = CD_WINDING; + sprintf(ctgc.status_line, "cdFillMode(CD_WINDING)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +char* font_style[4] = {"CD_PLAIN", "CD_BOLD", "CD_ITALIC", "CD_BOLD_ITALIC"}; +char* font_face[4] = {"CD_SYSTEM", "CD_COURIER", "CD_TIMES_ROMAN", "CD_HELVETICA"}; + +int fFontStyle(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.font_style = CD_PLAIN; + break; + case 2: + ctgc.font_style = CD_BOLD; + break; + case 3: + ctgc.font_style = CD_ITALIC; + break; + case 4: + ctgc.font_style = CD_BOLD_ITALIC; + break; + } + ctgc.font_size = IupGetInt(IupGetHandle("txtFontSize"), IUP_VALUE); + sprintf(ctgc.status_line, "cdFont(%s, %s, %d)", font_face[ctgc.font_typeface], font_style[ctgc.font_style], ctgc.font_size); + set_status(); + return IUP_DEFAULT; +} + + +int fFontTypeFace(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.font_typeface = CD_SYSTEM; + break; + case 2: + ctgc.font_typeface = CD_COURIER; + break; + case 3: + ctgc.font_typeface = CD_TIMES_ROMAN; + break; + case 4: + ctgc.font_typeface = CD_HELVETICA; + break; + } + ctgc.font_size = IupGetInt(IupGetHandle("txtFontSize"), IUP_VALUE); + sprintf(ctgc.status_line, "cdFont(%s, %s, %d)", font_face[ctgc.font_typeface], font_style[ctgc.font_style], ctgc.font_size); + set_status(); + return IUP_DEFAULT; +} + +int fTextAlignment(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.text_alignment = CD_NORTH; + sprintf(ctgc.status_line, "cdTextAlignment(CD_NORTH)"); + break; + case 2 : + ctgc.text_alignment = CD_SOUTH; + sprintf(ctgc.status_line, "cdTextAlignment(CD_SOUTH)"); + break; + case 3: + ctgc.text_alignment = CD_EAST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_EAST)"); + break; + case 4: + ctgc.text_alignment = CD_WEST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_WEST)"); + break; + case 5: + ctgc.text_alignment = CD_NORTH_EAST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_NORTH_EAST)"); + break; + case 6: + ctgc.text_alignment = CD_NORTH_WEST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_NORTH_WEST)"); + break; + case 7: + ctgc.text_alignment = CD_SOUTH_EAST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_SOUTH_EAST)"); + break; + case 8: + ctgc.text_alignment = CD_SOUTH_WEST; + sprintf(ctgc.status_line, "cdTextAlignment(CD_SOUTH_WEST)"); + break; + case 9: + ctgc.text_alignment = CD_CENTER; + sprintf(ctgc.status_line, "cdTextAlignment(CD_CENTER)"); + break; + case 10: + ctgc.text_alignment = CD_BASE_LEFT; + sprintf(ctgc.status_line, "cdTextAlignment(CD_BASE_LEFT)"); + break; + case 11: + ctgc.text_alignment = CD_BASE_CENTER; + sprintf(ctgc.status_line, "cdTextAlignment(CD_BASE_CENTER)"); + break; + case 12: + ctgc.text_alignment = CD_BASE_RIGHT; + sprintf(ctgc.status_line, "cdTextAlignment(CD_BASE_RIGHT)"); + break; + } + set_status(); + return IUP_DEFAULT; +} + +int fHatchStyle(Ihandle *self, char *t, int o, int v) +{ + ignore(t); + ignore(self); + if (v == 0) return IUP_DEFAULT; + switch (o) { + case 1: + ctgc.hatch = CD_HORIZONTAL; + sprintf(ctgc.status_line, "cdHatch(CD_HORIZONTAL)"); + break; + case 2 : + ctgc.hatch = CD_VERTICAL; + sprintf(ctgc.status_line, "cdHatch(CD_VERTICAL)"); + break; + case 3: + ctgc.hatch = CD_FDIAGONAL; + sprintf(ctgc.status_line, "cdHatch(CD_FDIAGONAL)"); + break; + case 4: + ctgc.hatch = CD_BDIAGONAL; + sprintf(ctgc.status_line, "cdHatch(CD_BDIAGONAL)"); + break; + case 5: + ctgc.hatch = CD_CROSS; + sprintf(ctgc.status_line, "cdHatch(CD_CROSS)"); + break; + case 6: + ctgc.hatch = CD_DIAGCROSS; + sprintf(ctgc.status_line, "cdHatch(CD_DIAGCROSS)"); + break; + } + set_status(); + cdHatch(ctgc.hatch); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Atualiza a linha de estatus do CDTest. */ +/*-------------------------------------------------------------------------*/ +void set_status(void) +{ + IupSetAttribute(IupGetHandle("lbStatusLine"), IUP_TITLE, ctgc.status_line); +} + +/*-------------------------------------------------------------------------*/ +/* Atualiza a posiccao do mouse no dialogo principal. */ +/*-------------------------------------------------------------------------*/ +void mouse_pos(int x, int y) +{ + /* salva a posiccao do mouse no contexto */ + ctgc.x = x; + ctgc.y = y; + + /* atualiza a posiccao do mouse no feedback para o usuario */ + sprintf(ctgc.mouse_pos, "(%4d,%4d)", x, y); + IupSetAttribute(IupGetHandle("lbMousePos"), IUP_TITLE, ctgc.mouse_pos); +} + +/*-------------------------------------------------------------------------*/ +/* Mostra a caixa de dialogo corrente. */ +/*-------------------------------------------------------------------------*/ +int fShowDialog(void) +{ + if (ctgc.dlg_cur_prim != NULL) { + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Ativa a seleccao de area de clip. */ +/*-------------------------------------------------------------------------*/ +int fClip(Ihandle* self) +{ + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgClip"); + ctgc.following = FALSE; + ctgc.cur_prim = CLIP; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgClip"); + sprintf(ctgc.status_line, "LEFT click and drag to set. RIGHT clip to disable."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Atualiza a area de clipping. */ +/*-------------------------------------------------------------------------*/ +int fClipArea(void) +{ + ctgc.clip_mode = CD_CLIPAREA; + ctgc.clip_xmin = IupGetInt(IupGetHandle("txtClipXmin"), IUP_VALUE); + ctgc.clip_xmax = IupGetInt(IupGetHandle("txtClipXmax"), IUP_VALUE); + ctgc.clip_ymin = IupGetInt(IupGetHandle("txtClipYmin"), IUP_VALUE); + ctgc.clip_ymax = IupGetInt(IupGetHandle("txtClipYmax"), IUP_VALUE); + cdClipArea(ctgc.clip_xmin,ctgc.clip_xmax,ctgc.clip_ymin,ctgc.clip_ymax); + cdClip(CD_CLIPAREA); + sprintf(ctgc.status_line, "cdClipArea( %d, %d, %d, %d)", + ctgc.clip_xmin,ctgc.clip_xmax,ctgc.clip_ymin,ctgc.clip_ymax); + set_status(); + updatecanvas(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Atualiza poligono de clipping. */ +/*-------------------------------------------------------------------------*/ +int fClipPoly(void) +{ + ctgc.clip_mode=CD_CLIPPOLYGON; + cdClip(CD_CLIPPOLYGON); + sprintf(ctgc.status_line, "cdClip(CD_CLIPPOLYGON)"); + set_status(); + updatecanvas(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Desativa o Clipping. */ +/*-------------------------------------------------------------------------*/ +int fClipOff(void) +{ + ctgc.clip_mode = CD_CLIPOFF; + cdClip(CD_CLIPOFF); + sprintf(ctgc.status_line, "cdClip(CD_CLIPOFF)"); + set_status(); + updatecanvas(); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Prepara a seleccao de imagens. */ +/*-------------------------------------------------------------------------*/ +int fImage(Ihandle* self) +{ + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgImage"); + ctgc.cur_prim = IMAGE; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgImage"); + sprintf(ctgc.status_line, "LEFT click and drag to get. RIGHT click to put."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Pega a imagem. */ +/*-------------------------------------------------------------------------*/ +int fImageGet(void) +{ + int x, y, width, height; + + /* mata a image */ + if (ctgc.test_image != NULL) { + cdKillImage(ctgc.test_image); + } + + x = IupGetInt(IupGetHandle("txtImageX"), IUP_VALUE); + y = IupGetInt(IupGetHandle("txtImageY"), IUP_VALUE); + + width = IupGetInt(IupGetHandle("txtImageW"), IUP_VALUE); + height = IupGetInt(IupGetHandle("txtImageH"), IUP_VALUE); + + if (width*height != 0) + { + if (ctgc.buffering) + cdActivate(ctgc.buffer_canvas); + else + cdActivate(ctgc.iup_canvas); + + ctgc.test_image = cdCreateImage(width, height); + if (ctgc.test_image != NULL) + { + cdGetImage(ctgc.test_image, x, y); + sprintf(ctgc.status_line, "cdGetImage( image, %d, %d)", x, y); + set_status(); + } + + cdActivate(ctgc.iup_canvas); + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Coloca a imagem. */ +/*-------------------------------------------------------------------------*/ +int fImagePut(void) +{ + int x, y; + + x = IupGetInt(IupGetHandle("txtImageX"), IUP_VALUE); + y = IupGetInt(IupGetHandle("txtImageY"), IUP_VALUE); + + if (ctgc.test_image != NULL) + { + if (ctgc.buffering) + { + cdActivate(ctgc.iup_canvas); + cdClip(CD_CLIPOFF); + + cdActivate(ctgc.buffer_canvas); + } + else + cdActivate(ctgc.iup_canvas); + + cdWriteMode(ctgc.write_mode); + cdPutImage(ctgc.test_image, x, y); + sprintf(ctgc.status_line, "cdPutImage( image, %d, %d)", x, y); + set_status(); + + if (ctgc.buffering) + { + cdFlush(); + + cdActivate(ctgc.iup_canvas); + cdClip(ctgc.clip_mode); + } + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Prepara a seleccao de imagens. */ +/*-------------------------------------------------------------------------*/ +int fImageRGB(Ihandle* self) +{ + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgImageRGB"); + ctgc.cur_prim = RGB; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgImageRGB"); + sprintf(ctgc.status_line, "LEFT click and drag to get. RIGHT click to put."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Pega a imagem. */ +/*-------------------------------------------------------------------------*/ +int fImageRGBGet(void) +{ + int x, y; + + x = IupGetInt(IupGetHandle("txtImageRGBX"), IUP_VALUE); + y = IupGetInt(IupGetHandle("txtImageRGBY"), IUP_VALUE); + ctgc.rgb_w = IupGetInt(IupGetHandle("txtImageRGBW"), IUP_VALUE); + ctgc.rgb_h = IupGetInt(IupGetHandle("txtImageRGBH"), IUP_VALUE); + + if (ctgc.red) free(ctgc.red); + ctgc.red = (unsigned char *) malloc (ctgc.rgb_w*ctgc.rgb_h*sizeof(unsigned char)); + if (ctgc.green) free(ctgc.green); + ctgc.green = (unsigned char *) malloc (ctgc.rgb_w*ctgc.rgb_h*sizeof(unsigned char)); + if (ctgc.blue) free(ctgc.blue); + ctgc.blue = (unsigned char *) malloc (ctgc.rgb_w*ctgc.rgb_h*sizeof(unsigned char)); + + if ((ctgc.red!=NULL)&&(ctgc.green!=NULL)&&(ctgc.blue!=NULL)) { + sprintf(ctgc.status_line, "cdGetImageRGB( r, g, b, %d, %d, %d, %d)", + x, y, ctgc.rgb_w, ctgc.rgb_h); + set_status(); + + if (ctgc.buffering) + cdActivate(ctgc.buffer_canvas); + else + cdActivate(ctgc.iup_canvas); + + cdGetImageRGB(ctgc.red, ctgc.green, ctgc.blue, x, y, ctgc.rgb_w, ctgc.rgb_h); + + cdActivate(ctgc.iup_canvas); + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Joga a imagem na tela. */ +/*-------------------------------------------------------------------------*/ +int fImageRGBPut(void) +{ + int x, y; + + x = IupGetInt(IupGetHandle("txtImageRGBX"), IUP_VALUE); + y = IupGetInt(IupGetHandle("txtImageRGBY"), IUP_VALUE); + + if ((ctgc.red!=NULL)&&(ctgc.green!=NULL)&&(ctgc.blue!=NULL)) + { + if (ctgc.buffering) + { + cdActivate(ctgc.iup_canvas); + cdClip(CD_CLIPOFF); + + cdActivate(ctgc.buffer_canvas); + } + else + cdActivate(ctgc.iup_canvas); + + cdWriteMode(ctgc.write_mode); + sprintf(ctgc.status_line, "cdPutImageRGB( %d, %d, r, g, b, %d, %d, %d, %d)", + ctgc.rgb_w, ctgc.rgb_h, x, y, ctgc.rgb_w, ctgc.rgb_h); + set_status(); + cdPutImageRGB(ctgc.rgb_w, ctgc.rgb_h, ctgc.red, ctgc.green, ctgc.blue, x, y, ctgc.rgb_w, ctgc.rgb_h); + + if (ctgc.buffering) + { + cdFlush(); + + cdActivate(ctgc.iup_canvas); + cdClip(ctgc.clip_mode); + } + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fLine(Ihandle* self) +{ + if (ctgc.cur_prim != LINE) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgLine"); + if (ctgc.cur_prim == POLY) { /* termina o poligono em andamento */ + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = LINE; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); /* esconde o dialogo anterior */ + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgLB"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Line Parameters"); + } + sprintf(ctgc.status_line, "LEFT click and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fRect(Ihandle* self) +{ + if (ctgc.cur_prim != RECT) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgRect"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = RECT; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgLB"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Rect Parameters"); + } + sprintf(ctgc.status_line, "LEFT click and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +int fBox(Ihandle* self) +{ + if (ctgc.cur_prim != BOX) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgBox"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = BOX; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgLB"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Box Parameters"); + } + sprintf(ctgc.status_line, "LEFT click and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fArc(Ihandle* self) +{ + if (ctgc.cur_prim != ARC) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgArc"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = ARC; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgAS"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Arc Parameters"); + } + sprintf(ctgc.status_line, "LEFT click at center and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fSector(Ihandle* self) +{ + if (ctgc.cur_prim != SECTOR) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgSector"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = SECTOR; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgAS"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Sector Parameters"); + } + sprintf(ctgc.status_line, "LEFT click at center and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +int fChord(Ihandle* self) +{ + if (ctgc.cur_prim != CHORD) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgChord"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = CHORD; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgAS"); + IupSetAttribute(ctgc.dlg_cur_prim, IUP_TITLE, "Chord Parameters"); + } + sprintf(ctgc.status_line, "LEFT click at center and drag."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fPixel(Ihandle* self) +{ + if (ctgc.cur_prim != PIXEL) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgPixel"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = PIXEL; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgPixel"); + } + sprintf(ctgc.status_line, "LEFT click."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fMark(Ihandle* self) +{ + if (ctgc.cur_prim != MARK) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgMark"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = MARK; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgMark"); + } + sprintf(ctgc.status_line, "LEFT click."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fText(Ihandle* self) +{ + if (ctgc.cur_prim != TEXT) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgText"); + if (ctgc.cur_prim == POLY) { + fButtonCB(NULL, IUP_BUTTON3, 0, 0, 0, 0); + } + ctgc.cur_prim = TEXT; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgText"); + } + sprintf(ctgc.status_line, "LEFT click."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Muda a primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fPoly(Ihandle* self) +{ + if (ctgc.cur_prim != POLY) { + IupSetAttribute(ctgc.bt_cur_prim, IUP_IMAGE, "imgPoly"); + ctgc.cur_prim = POLY; + ctgc.following = FALSE; + ctgc.visible = iscurvisible(); + IupHide(ctgc.dlg_cur_prim); + if (ctgc.visible) + { + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + } + ctgc.dlg_cur_prim = IupGetHandle("dlgPoly"); + /* zera o buffer temporario de pontos */ + ctgc.num_points = 0; + } + sprintf(ctgc.status_line, "LEFT click to add vertex. RIGHT click to end."); + set_status(); + if (ctgc.visible || IupGetAttribute(self, "ISMENU")) + IupShowXY(ctgc.dlg_cur_prim, ctgc.dlg_x, ctgc.dlg_y); + return IUP_DEFAULT; +} + +int fOptions(void) +{ + IupShow(IupGetHandle("dlgOptions")); + return IUP_DEFAULT; +} + +int fOptionsHide(void) +{ + IupHide(IupGetHandle("dlgOptions")); + return IUP_DEFAULT; +} + + +/*-------------------------------------------------------------------------*/ +/* Mostra a caixa de dialogo Attributes. */ +/*-------------------------------------------------------------------------*/ +int fAttributes(void) +{ + IupShow(IupGetHandle("dlgAttributes")); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Esconde o dialogo de Attributes. */ +/*-------------------------------------------------------------------------*/ +int fAttributesHide(void) +{ + ctgc.font_size = IupGetInt(IupGetHandle("txtFontSize"), IUP_VALUE); + cdFont(ctgc.font_typeface,ctgc.font_style,ctgc.font_size); + IupHide(IupGetHandle("dlgAttributes")); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Esconde o dialogo de primitiva corrente. */ +/*-------------------------------------------------------------------------*/ +int fMsgHide(void) +{ + IupHide(ctgc.dlg_cur_prim); + ctgc.dlg_x = IupGetInt(ctgc.dlg_cur_prim, IUP_X); + ctgc.dlg_y = IupGetInt(ctgc.dlg_cur_prim, IUP_Y); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Filtra inteiros. */ +/*-------------------------------------------------------------------------*/ +int fInteger(Ihandle *self, int c) +{ + ignore(self); + if (isdigit(c) || c == '-') + return IUP_DEFAULT; + else if ((c==K_TAB) || (c==K_CR) || (c==K_LEFT) || + (c==K_RIGHT) || (c==K_DEL) || (c==K_BS) || (c==K_sTAB)) + return IUP_DEFAULT; + else + return IUP_IGNORE; +} + +/*-------------------------------------------------------------------------*/ +/* Filtra reais. */ +/*-------------------------------------------------------------------------*/ +int fReal(Ihandle *self, int c) +{ + ignore(self); + if (isdigit(c)) + return IUP_DEFAULT; + else if ((c==K_TAB) || (c==K_CR) || (c==K_LEFT) || + (c==K_RIGHT) || (c==K_DEL) || (c==K_BS) || (c==K_sTAB)) + return IUP_DEFAULT; + else if ((c=='.') || (c=='e') || (c=='E') || (c=='+') || (c=='-')) + return IUP_DEFAULT; + else + return IUP_IGNORE; +} + +/*-------------------------------------------------------------------------*/ +/* Desenha a primitiva entrada na caixa de dialogo ativa. */ +/*-------------------------------------------------------------------------*/ +void draw(void) +{ + int a, b; + + IupSetAttribute(IupGetHandle("itEditUndo"), IUP_ACTIVE, IUP_YES); + ctgc.line_width = IupGetInt(IupGetHandle("txtLineWidth"), IUP_VALUE); + if (ctgc.line_width < 1) ctgc.line_width = 1; + ctgc.font_size = IupGetInt(IupGetHandle("txtFontSize"), IUP_VALUE); + + /* escolhe entre o canvas na tela e o off-screen */ + if (ctgc.buffering) + { + cdActivate(ctgc.iup_canvas); + cdClip(CD_CLIPOFF); + + cdActivate(ctgc.buffer_canvas); + } + else + cdActivate(ctgc.iup_canvas); + + /* atualiza os atributos */ + cdWriteMode(ctgc.write_mode); + cdLineStyle(ctgc.line_style); + cdLineCap(ctgc.line_cap); + cdLineJoin(ctgc.line_join); + cdLineWidth(ctgc.line_width); + cdForeground(ctgc.foreground); + cdBackground(ctgc.background); + cdHatch(ctgc.hatch); + cdFillMode(ctgc.fill_mode); + cdInteriorStyle(ctgc.interior_style); + cdBackOpacity(ctgc.back_opacity); + + cdClipArea(ctgc.clip_xmin,ctgc.clip_xmax,ctgc.clip_ymin,ctgc.clip_ymax); + cdClip(ctgc.clip_mode); + + switch (ctgc.cur_prim) { + case LINE: + /* atualiza a linha de status */ + sprintf(ctgc.status_line, "cdLine( %d, %d, %d, %d)", line_pos.x1, + line_pos.y1, line_pos.x2, line_pos.y2); + set_status(); + /* desenha a line na tela */ + cdLine(line_pos.x1, line_pos.y1, line_pos.x2, line_pos.y2); + /* arquiva a line */ + newline(line_pos.x1, line_pos.y1, line_pos.x2, line_pos.y2); + break; + case RECT: + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdRect( %d, %d, %d, %d)",box_pos.xmin, + box_pos.xmax, box_pos.ymin, box_pos.ymax); + set_status(); + /* desenha a box na tela */ + cdRect(box_pos.xmin, box_pos.xmax, box_pos.ymin, box_pos.ymax); + /* armazena a box */ + newrect(box_pos.xmin, box_pos.xmax, box_pos.ymin, box_pos.ymax); + break; + case BOX: + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdBox( %d, %d, %d, %d)",box_pos.xmin, + box_pos.xmax, box_pos.ymin, box_pos.ymax); + set_status(); + /* desenha a box na tela */ + cdBox(box_pos.xmin, box_pos.xmax, box_pos.ymin, box_pos.ymax); + /* armazena a box */ + newbox(box_pos.xmin, box_pos.xmax, box_pos.ymin, box_pos.ymax); + break; + case ARC: + arc_pos.angle1 = IupGetFloat(IupGetHandle("txtASAngle1"),IUP_VALUE); + arc_pos.angle2 = IupGetFloat(IupGetHandle("txtASAngle2"),IUP_VALUE); + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdArc( %d, %d, %d, %d, %.5G, %.5G)", arc_pos.xc, + arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, arc_pos.angle2); + set_status(); + /* desenha o arc na tela */ + cdArc(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + /* armazena o arc */ + newarc(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + break; + case SECTOR: + arc_pos.angle1 = IupGetFloat(IupGetHandle("txtASAngle1"),IUP_VALUE); + arc_pos.angle2 = IupGetFloat(IupGetHandle("txtASAngle2"),IUP_VALUE); + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdSector( %d, %d, %d, %d, %.5G, %.5G)", arc_pos.xc, + arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, arc_pos.angle2); + set_status(); + /* desenha o sector na tela */ + cdSector(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + /* armazena o sector */ + newsector(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + break; + case CHORD: + arc_pos.angle1 = IupGetFloat(IupGetHandle("txtASAngle1"),IUP_VALUE); + arc_pos.angle2 = IupGetFloat(IupGetHandle("txtASAngle2"),IUP_VALUE); + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdChord( %d, %d, %d, %d, %.5G, %.5G)", arc_pos.xc, + arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, arc_pos.angle2); + set_status(); + /* desenha o sector na tela */ + cdChord(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + /* armazena o sector */ + newchord(arc_pos.xc, arc_pos.yc, arc_pos.w, arc_pos.h, arc_pos.angle1, + arc_pos.angle2); + break; + case PIXEL: + /* atualiza a linha de status */ + sprintf(ctgc.status_line, "cdPixel( %d, %d, 0x%.6lx )",pixel_pos.x, pixel_pos.y,ctgc.foreground); + set_status(); + /* desenha o pixel na tela */ + cdPixel(pixel_pos.x, pixel_pos.y, ctgc.foreground); + /* armazena o pixel */ + newpixel(pixel_pos.x, pixel_pos.y); + break; + case MARK: + mark_pos.size = IupGetInt(IupGetHandle("txtMarkSize"),IUP_VALUE); + /* atualiza a linha de status */ + sprintf(ctgc.status_line,"cdMark( %d, %d)", mark_pos.x, mark_pos.y); + set_status(); + /* armazena a marca */ + newmark(mark_pos.x, mark_pos.y, mark_pos.size); + /* desenha a marca na tela */ + cdMarkType(ctgc.mark_type); + cdMarkSize(mark_pos.size); + cdMark(mark_pos.x, mark_pos.y); + break; + case TEXT: + if (IupGetAttribute(IupGetHandle("txtTextS"),IUP_VALUE)) { + a=IupGetInt(IupGetHandle("txtTextX"),IUP_VALUE); + b=IupGetInt(IupGetHandle("txtTextY"),IUP_VALUE); + sprintf(ctgc.status_line," cdText( %d, %d, ""%.3s""...)", a, b, + IupGetAttribute(IupGetHandle("txtTextS"),IUP_VALUE)); + set_status(); + ctgc.text_orientation = IupGetInt(IupGetHandle("txtTextOrientation"),IUP_VALUE); + newtext(a,b,IupGetAttribute(IupGetHandle("txtTextS"),IUP_VALUE)); + cdFont(ctgc.font_typeface,ctgc.font_style,ctgc.font_size); + cdTextAlignment(ctgc.text_alignment); + cdTextOrientation(ctgc.text_orientation); + cdText(a,b,IupGetAttribute(IupGetHandle("txtTextS"),IUP_VALUE)); + } + case POLY: + if (ctgc.num_points > 1) { + cdBegin(ctgc.poly_mode); + for (a=0; (a<ctgc.num_points); a++) { + cdVertex(ctgc.points[a].x,ctgc.points[a].y); + } + cdEnd(); + if (ctgc.poly_mode != CD_CLIP) + newpoly(); + ctgc.num_points = 0; + } + break; + default: + break; + } + + if (ctgc.buffering) + { + cdFlush(); + + cdActivate(ctgc.iup_canvas); + cdClip(ctgc.clip_mode); + } +} + +/*-------------------------------------------------------------------------*/ +/* Desenha a primitiva entrada na caixa de dialogo corrente. */ +/*-------------------------------------------------------------------------*/ +int fDraw(void) +{ + /* atualiza os dados entrados na caixa de dialogo no contexto da */ + /* primitiva corrente */ + switch (ctgc.cur_prim) { + case LINE: + line_pos.x1 = IupGetInt(IupGetHandle("txtLBX1"), IUP_VALUE); + line_pos.x2 = IupGetInt(IupGetHandle("txtLBX2"), IUP_VALUE); + line_pos.y1 = IupGetInt(IupGetHandle("txtLBY1"), IUP_VALUE); + line_pos.y2 = IupGetInt(IupGetHandle("txtLBY2"), IUP_VALUE); + break; + case RECT: + case BOX: + box_pos.xmin = IupGetInt(IupGetHandle("txtLBX1"), IUP_VALUE); + box_pos.xmax = IupGetInt(IupGetHandle("txtLBX2"), IUP_VALUE); + box_pos.ymin = IupGetInt(IupGetHandle("txtLBY1"), IUP_VALUE); + box_pos.ymax = IupGetInt(IupGetHandle("txtLBY2"), IUP_VALUE); + break; + case ARC: + case CHORD: + case SECTOR: + arc_pos.xc = IupGetInt(IupGetHandle("txtASXC"), IUP_VALUE); + arc_pos.yc = IupGetInt(IupGetHandle("txtASYC"), IUP_VALUE); + arc_pos.w = IupGetInt(IupGetHandle("txtASW"), IUP_VALUE); + arc_pos.h = IupGetInt(IupGetHandle("txtASH"), IUP_VALUE); + break; + case PIXEL: + pixel_pos.x = IupGetInt(IupGetHandle("txtPixelX"), IUP_VALUE); + pixel_pos.y = IupGetInt(IupGetHandle("txtPixelY"), IUP_VALUE); + break; + case MARK: + mark_pos.x = IupGetInt(IupGetHandle("txtMarkX"), IUP_VALUE); + mark_pos.y = IupGetInt(IupGetHandle("txtMarkY"), IUP_VALUE); + break; + default: + break; + } + + /* efetivamente desenha a primitiva */ + draw(); + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Mostra a janelinha de apresentacao. */ +/*-------------------------------------------------------------------------*/ +int fHelpAbout(void) +{ + IupSetAttribute(IupGetHandle("lblVersion"), IUP_TITLE, cdVersion()); + IupShow(IupGetHandle("dlgHelpAbout")); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Mata a janelinha de apresentacao. */ +/*-------------------------------------------------------------------------*/ +int fCloseAbout(void) +{ + IupHide(IupGetHandle("dlgHelpAbout")); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Limpa o canvas e a lista de primitivas. */ +/*-------------------------------------------------------------------------*/ +int fEditClear(void) +{ + /* mata a lista de primitivas */ + dellist(); + + /* torna inativo a opcap undo */ + IupSetAttribute(IupGetHandle("itEditUndo"), IUP_ACTIVE, IUP_NO); + + updatecanvas(); + + sprintf(ctgc.status_line, "cdClear()"); + set_status(); + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao ganho de focus do canvas. */ +/*-------------------------------------------------------------------------*/ +int fGetFocusCB(Ihandle *self) +{ + ignore(self); + /* avisa ao CD que o focus foi recebido, */ + /* para que ele restaure o contexto grafico */ + cdActivate(ctgc.iup_canvas); + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao movimento do mouse. */ +/*-------------------------------------------------------------------------*/ +int fMotionCB(Ihandle *self, int x, int y, char *r) +{ + ignore(self); + ignore(r); + + cdActivate(ctgc.iup_canvas); + cdUpdateYAxis(&y); + mouse_pos(x, y); + + if (ctgc.following) { + switch(ctgc.cur_prim) { + case LINE: + line(MOVE, x, y); + follow(x, y); + break; + case RECT: + case BOX: + box(MOVE, x, y); + follow(x, y); + break; + case CLIP: + box(MOVE, x, y); + follow(x, y); + break; + case ARC: /* ARC e SECTOR... */ + case SECTOR: /* sao equivalentes */ + case CHORD: + arc(MOVE, x, y); + follow(x, y); + break; + case IMAGE: + box(MOVE, x, y); + follow(x, y); + break; + case RGB: + box(MOVE, x, y); + follow(x, y); + break; + case POLY: + polygon(MOVE, x, y); + break; + default: + break; + } + } + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao botao do mouse. */ +/*-------------------------------------------------------------------------*/ +int fButtonCB(Ihandle *self, int b, int e, int x, int y, char *r) +{ + ignore(self); + ignore(r); + + cdActivate(ctgc.iup_canvas); + cdWriteMode(CD_NOT_XOR); + cdForeground(CD_BLACK); + cdLineStyle(CD_CONTINUOUS); + cdLineWidth(1); + cdClip(CD_CLIPOFF); + + cdUpdateYAxis(&y); + mouse_pos(x, y); + + if (b == IUP_BUTTON1) { + if (e) { + switch(ctgc.cur_prim) { + case LINE: + follow(x, y); + line(NEWPOINT, x, y); + line_pos.x1 = x; + line_pos.y1 = y; + ctgc.following = TRUE; + break; + case RECT: + case BOX: + follow(x, y); + box(NEWPOINT, x, y); + box_pos.x = x; + box_pos.y = y; + ctgc.following = TRUE; + break; + case CLIP: + box(NEWPOINT, x, y); + follow(x, y); + ctgc.following = TRUE; + break; + case ARC: /* ARC e SECTOR... */ + case SECTOR: /* sao equivalentes */ + case CHORD: + follow(x, y); + arc(CENTER, x, y); + arc_pos.xc = x; + arc_pos.yc = y; + ctgc.following = TRUE; + break; + case MARK: + case PIXEL: + case TEXT: + follow(x, y); + draw(); + break; + case IMAGE: + follow(x, y); + box(NEWPOINT, x, y); + ctgc.following = TRUE; + break; + case RGB: + follow(x, y); + box(NEWPOINT, x, y); + ctgc.following = TRUE; + break; + default: + break; + } + } + else { + switch(ctgc.cur_prim) { + case LINE: + if (ctgc.following) { + ctgc.following = FALSE; + line(CLOSE, x, y); + cdClip(ctgc.clip_mode); + draw(); + } + break; + case RECT: + case BOX: + if (ctgc.following) { + ctgc.following = FALSE; + box(CLOSE, x, y); + cdClip(ctgc.clip_mode); + draw(); + } + break; + case CLIP: + if (ctgc.following) { + ctgc.following = FALSE; + box(CLOSE, x, y); + fClipArea(); + } + break; + case ARC: /* ARC e SECTOR... */ + case SECTOR: /* ...sao equivalentes */ + case CHORD: + if (ctgc.following) { + ctgc.following = FALSE; + arc(CLOSE, x, y); + cdClip(ctgc.clip_mode); + draw(); + arc_pos.w = 0; + arc_pos.h = 0; + } + break; + case POLY: + cdActivate(ctgc.iup_canvas); + polygon(NEWPOINT, x, y); + newpolypoint(x, y); + sprintf(ctgc.status_line, "cdVertex( %d, %d)", x, y); + set_status(); + ctgc.following = TRUE; + break; + case IMAGE: + if (ctgc.following) { + ctgc.following = FALSE; + box(CLOSE, x, y); + cdClip(ctgc.clip_mode); + fImageGet(); + } + break; + case RGB: + if (ctgc.following) { + ctgc.following = FALSE; + box(CLOSE, x, y); + cdClip(ctgc.clip_mode); + fImageRGBGet(); + } + break; + default: + break; + } + } + } + else if (b == IUP_BUTTON3) { + if (e) { + switch (ctgc.cur_prim) { + case IMAGE: + cdClip(ctgc.clip_mode); + follow(x, y); + fImagePut(); + break; + case RGB: + cdClip(ctgc.clip_mode); + follow(x, y); + fImageRGBPut(); + break; + case CLIP: + fClipOff(); + break; + default: + break; + } + } + else { + switch (ctgc.cur_prim) { + case POLY: + cdActivate(ctgc.iup_canvas); + ctgc.following = FALSE; + polygon(CLOSE, x, y); + sprintf(ctgc.status_line, "cdEnd()"); + set_status(); + fDraw(); + break; + default: + break; + } + } + } + + return IUP_DEFAULT; +} + +/*-------------------------------------------------------------------------*/ +/* Funcao associada ao resize do canvas. */ +/*-------------------------------------------------------------------------*/ +int fResizeCB(Ihandle *self, int width, int height) +{ + ignore(self); + + /* atualiza o contexto do programa */ + ctgc.w = width; + ctgc.h = height; + + /* atualiza o tamanho do canvas em pixels no titulo */ + sprintf(ctgc.title, "CDTest 5.3 (%dx%d - %dbpp)", ctgc.w, ctgc.h, ctgc.bpp); + IupSetAttribute(IupGetHandle("dlgMain"), IUP_TITLE, ctgc.title); + + /* reconstroi o buffer off-screen, se necessario */ + if (ctgc.buffering) + cdActivate(ctgc.buffer_canvas); + else + cdActivate(ctgc.iup_canvas); + + return IUP_DEFAULT; +} + +void cdtest_loadled(void); + +/*-------------------------------------------------------------------------*/ +/* Rotina principal. */ +/*-------------------------------------------------------------------------*/ +void main(void) +{ + char *err = NULL; + + /* inicializa o IUP */ + IupOpen(); + + /* carrega o LED */ +#ifdef USE_LED + err = IupLoad("cdtest.led"); +#else + cdtest_loadled(); +#endif + + if (!err) + { + /* inicializa o CDTest */ + CDTestInit(); + } + else + { + /* imprime uma mensagem de erro */ + IupMessage("LED Error:", err); + IupClose(); + return; + } + + IupMainLoop(); + + CDTestClose(); + + IupClose(); +} + |