From 7b52cc13af4e85f1ca2deb6b6c77de9c95ea0dcf Mon Sep 17 00:00:00 2001
From: scuri <scuri>
Date: Fri, 17 Oct 2008 06:10:33 +0000
Subject: First commit - moving from LuaForge to SourceForge

---
 test/cdtest/cdtest.c | 2662 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2662 insertions(+)
 create mode 100644 test/cdtest/cdtest.c

(limited to 'test/cdtest/cdtest.c')

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();
+}
+
-- 
cgit v1.2.3