workbench/tools/calculator.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <intuition/intuition.h>
   7 #include <libraries/gadtools.h>
   8 #include <libraries/locale.h>
   9
  10 #include <proto/exec.h>
  11 #include <proto/dos.h>
  12 #include <proto/intuition.h>
  13 #include <proto/graphics.h>
  14 #include <proto/gadtools.h>
  15 #include <proto/locale.h>
  16 #include <proto/alib.h>
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #include <stdlib.h>
  22 #include <math.h>
  23
  24 #define ARG_TEMPLATE "PUBSCREEN,TAPE/K"
  25
  26 enum {ARG_PUBSCREEN,ARG_TAPE,NUM_ARGS};
  27
  28 #define MAX_VAL_LEN 13
  29
  30 #define INNER_SPACING_X 4
  31 #define INNER_SPACING_Y 4
  32
  33 #define BUTTON_SPACING_X 4
  34 #define BUTTON_SPACING_Y 4
  35
  36 #define BUTTON_LED_SPACING 4
  37
  38 #define NUM_BUTTONS 20
  39 #define NUM_BUTTON_COLS 5
  40 #define NUM_BUTTON_ROWS 4
  41
  42 #define BUTTON_EXTRA_WIDTH 8
  43 #define BUTTON_EXTRA_HEIGHT 4
  44
  45 #define LED_EXTRA_HEIGHT 4
  46
  47 enum
  48 {
  49     STATE_LEFTVAL, STATE_OP, STATE_RIGHTVAL, STATE_EQU
  50 };
  51
  52 enum
  53 {
  54     BTYPE_0,
  55     BTYPE_1,
  56     BTYPE_2,
  57     BTYPE_3,
  58     BTYPE_4,
  59     BTYPE_5,
  60     BTYPE_6,
  61     BTYPE_7,
  62     BTYPE_8,
  63     BTYPE_9,
  64     BTYPE_COMMA,
  65     BTYPE_BS,
  66     BTYPE_CA,
  67     BTYPE_CE,
  68     BTYPE_MUL,
  69     BTYPE_DIV,
  70     BTYPE_SUB,
  71     BTYPE_ADD,
  72     BTYPE_SIGN,
  73     BTYPE_EQU,
  74
  75     BTYPE_LED
  76 };
  77
  78 struct ButtonInfo
  79 {
  80     char *text;
  81     WORD type;
  82     char key1;
  83     char key2;
  84 };
  85
  86 static struct ButtonInfo bi[NUM_BUTTONS] =
  87 {
  88     {"7"        ,BTYPE_7        , '7'   , 0     },
  89     {"8"        ,BTYPE_8        , '8'   , 0     },
  90     {"9"        ,BTYPE_9        , '9'   , 0     },
  91     {"CA"       ,BTYPE_CA       , 'A'   , 127   },
  92     {"CE"       ,BTYPE_CE       , 'E'   , 0     },
  93
  94     {"4"        ,BTYPE_4        , '4'   , 0     },
  95     {"5"        ,BTYPE_5        , '5'   , 0     },
  96     {"6"        ,BTYPE_6        , '6'   , 0     },
  97     {"×"        ,BTYPE_MUL      , '*'   , 'X'   },
  98     {":"        ,BTYPE_DIV      , '/'   , ':'   },
  99
 100     {"1"        ,BTYPE_1        , '1'   , 0     },
 101     {"2"        ,BTYPE_2        , '2'   , 0     },
 102     {"3"        ,BTYPE_3        , '3'   , 0     },
 103     {"+"        ,BTYPE_ADD      , '+'   , 0     },
 104     {"-"        ,BTYPE_SUB      , '-'   , 0     },
 105
 106     {"0"        ,BTYPE_0        , '0'   , 0     },
 107     {"."        ,BTYPE_COMMA    , '.'   , ','   },
 108     {"«"        ,BTYPE_BS       , 8     , 0     },
 109     {"±"        ,BTYPE_SIGN     , 'S'   , 0     },
 110     {"="        ,BTYPE_EQU      , '='   , 13    }
 111 };
 112
 113
 114 struct IntuitionBase *IntuitionBase;
 115 struct GfxBase *GfxBase;
 116 struct Library *GadToolsBase;
 117 #ifndef __MORPHOS__
 118 struct LocaleBase *LocaleBase;
 119 #else
 120 struct Library *LocaleBase;
 121 #endif
 122
 123 static struct Screen *scr;
 124 static struct DrawInfo *dri;
 125 static struct Gadget *gadlist, *gad[NUM_BUTTONS + 2];
 126 static struct Window *win;
 127 static struct RDArgs *MyArgs;
 128 static APTR vi;
 129 static FILE *tapefh;
 130
 131 static WORD win_borderleft,win_bordertop;
 132 static WORD buttonwidth,buttonheight,ledheight;
 133 static WORD inner_winwidth,inner_winheight;
 134 static WORD vallen,state,operation;
 135
 136 static BOOL dotape;
 137
 138 static double leftval,rightval;
 139
 140 static char comma,*pubscrname;
 141 static char ledstring[256],visledstring[256],
 142                                 tempstring[256],tapename[256];
 143
 144 static char *deftapename = "RAW:%ld/%ld/%ld/%ld/Calculator Tape/INACTIVE/SCREEN%s";
 145
 146 UBYTE version[] = "$VER: Calculator 1.1 (1.5.2001)";
 147
 148 static LONG Args[NUM_ARGS];
 149
 150 static void Cleanup(char *msg)
 151 {
 152     WORD rc;
 153
 154     if (msg)
 155     {
 156         printf("Calculator: %s\n",msg);
 157         rc = RETURN_WARN;
 158     } else {
 159         rc = RETURN_OK;
 160     }
 161
 162     if (tapefh) fclose(tapefh);
 163
 164     if (win) CloseWindow(win);
 165
 166     if (gadlist) FreeGadgets(gadlist);
 167
 168     if (vi) FreeVisualInfo(vi);
 169     if (dri) FreeScreenDrawInfo(scr,dri);
 170     if (scr) UnlockPubScreen(0,scr);
 171
 172     if (MyArgs) FreeArgs(MyArgs);
 173
 174     if (LocaleBase) CloseLibrary((struct Library *)LocaleBase);
 175     if (GadToolsBase) CloseLibrary(GadToolsBase);
 176     if (GfxBase) CloseLibrary((struct Library *)GfxBase);
 177     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
 178
 179     exit (rc);
 180 }
 181
 182 static void DosError(void)
 183 {
 184     Fault(IoErr(),0,tempstring,255);
 185     Cleanup(tempstring);
 186 }
 187
 188 static void OpenLibs(void)
 189 {
 190     if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",39)))
 191     {
 192         Cleanup("Can't open intuition.library V39!");
 193     }
 194
 195     if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",39)))
 196     {
 197         Cleanup("Can't open graphics.library V39!");
 198     }
 199
 200     if (!(GadToolsBase = OpenLibrary("gadtools.library",39)))
 201     {
 202         Cleanup("Can't open gadtools.library V39!");
 203     }
 204
 205     LocaleBase = (struct LocaleBase *)OpenLibrary("locale.library",39);
 206 }
 207
 208 static void GetArguments(void)
 209 {
 210     if (!(MyArgs = ReadArgs(ARG_TEMPLATE,(LONG *)Args,0)))
 211     {
 212         DosError();
 213     }
 214
 215     pubscrname = (char *)Args[ARG_PUBSCREEN];
 216
 217     if (Args[ARG_TAPE])
 218     {
 219         strcpy(tapename,(char *)Args[ARG_TAPE]);
 220         dotape = TRUE;
 221     }
 222 }
 223
 224 static void DoLocale(void)
 225 {
 226     struct Locale *loc;
 227
 228     comma = '.';
 229
 230     if ((loc = OpenLocale(0)))
 231     {
 232         comma = loc->loc_DecimalPoint[0];
 233         CloseLocale(loc);
 234     }
 235
 236     bi[16].text[0] = comma;
 237 }
 238
 239 static void GetVisual(void)
 240 {
 241     if (pubscrname) scr = LockPubScreen(pubscrname);
 242
 243     if (!scr)
 244     {
 245         if (!(scr = LockPubScreen(0)))
 246         {
 247             Cleanup("Can't lock screen!");
 248         }
 249     }
 250
 251     if (!(dri = GetScreenDrawInfo(scr)))
 252     {
 253         Cleanup("Can't get drawinfo!");
 254     }
 255
 256     if (!(vi = GetVisualInfo(scr,0)))
 257     {
 258         Cleanup("Can't get visual info!");
 259     }
 260
 261     win_borderleft = scr->WBorLeft;
 262
 263     /* SDuvan: was scr->WBorTop + scr->Font->ta_YSize + 1 */
 264     win_bordertop = scr->WBorTop + dri->dri_Font->tf_YSize + 1;
 265
 266 }
 267
 268 static void InitGUI(void)
 269 {
 270     static struct RastPort temprp;
 271
 272     WORD i,len;
 273
 274     InitRastPort(&temprp);
 275     SetFont(&temprp,dri->dri_Font);
 276
 277     buttonheight = dri->dri_Font->tf_YSize + BUTTON_EXTRA_HEIGHT;
 278
 279     for(i = 0;i < NUM_BUTTONS;i++)
 280     {
 281         len = TextLength(&temprp,bi[i].text,strlen(bi[i].text));
 282         if (len > buttonwidth) buttonwidth = len;
 283     }
 284
 285     buttonwidth += BUTTON_EXTRA_WIDTH;
 286
 287     ledheight = dri->dri_Font->tf_YSize + LED_EXTRA_HEIGHT;
 288
 289     inner_winwidth = buttonwidth * NUM_BUTTON_COLS +
 290         BUTTON_SPACING_X * (NUM_BUTTON_COLS - 1) +
 291         INNER_SPACING_X * 2;
 292
 293     inner_winheight = buttonheight * NUM_BUTTON_ROWS +
 294         BUTTON_SPACING_Y * (NUM_BUTTON_ROWS - 1) +
 295         BUTTON_LED_SPACING +
 296         ledheight +
 297         INNER_SPACING_Y * 2;
 298
 299 #ifdef __AROS__
 300     DeinitRastPort(&temprp);
 301 #endif
 302     strcpy(ledstring,"0");
 303 }
 304
 305 static void MakeGadgets(void)
 306 {
 307     struct Gadget *mygad = 0;
 308     struct NewGadget ng = {0};
 309     WORD col,row,i;
 310
 311     ng.ng_VisualInfo = vi;
 312
 313     mygad = CreateContext(&gadlist);
 314
 315     ng.ng_GadgetID = BTYPE_LED;
 316
 317     ng.ng_LeftEdge = win_borderleft + INNER_SPACING_X;
 318     ng.ng_TopEdge  = win_bordertop + INNER_SPACING_Y;
 319     ng.ng_Width = inner_winwidth - INNER_SPACING_X * 2;
 320     ng.ng_Height = ledheight;
 321
 322     mygad = gad[BTYPE_LED] = CreateGadget(TEXT_KIND,
 323                                           mygad,
 324                                           &ng,
 325                                           GTTX_Text, (IPTR) ledstring,
 326                                           GTTX_CopyText,TRUE,
 327                                           GTTX_Border,TRUE,
 328                                           GTTX_Justification,GTJ_RIGHT,
 329                                           TAG_DONE);
 330
 331     i = 0;
 332
 333     ng.ng_TopEdge = win_bordertop +
 334         INNER_SPACING_Y +
 335         ledheight +
 336         BUTTON_LED_SPACING;
 337
 338     ng.ng_Width = buttonwidth;
 339     ng.ng_Height = buttonheight;
 340
 341     for(row = 0; row < NUM_BUTTON_ROWS; row++)
 342     {
 343         for(col = 0; col < NUM_BUTTON_COLS; col++, i++)
 344         {
 345             ng.ng_GadgetID = bi[i].type;
 346
 347             ng.ng_LeftEdge = win_borderleft +
 348                 INNER_SPACING_X +
 349                 col * (buttonwidth + BUTTON_SPACING_X);
 350
 351             ng.ng_GadgetText = bi[i].text;
 352
 353             mygad = gad[bi[i].type] = CreateGadgetA(BUTTON_KIND,
 354                                                     mygad,
 355                                                     &ng,
 356                                                     0);
 357
 358         } /* for(col = 0;col < NUM_BUTTON_COLS; col++) */
 359
 360         ng.ng_TopEdge += buttonheight + BUTTON_SPACING_Y;
 361
 362     } /* for(row = 0; row < NUM_BUTTON_ROWS; row++) */
 363
 364     if (!mygad)
 365     {
 366         Cleanup("Can't create gadgets!");
 367     }
 368
 369 }
 370
 371 static void MakeWin(void)
 372 {
 373     win = OpenWindowTags(0,WA_PubScreen,(IPTR)scr,
 374                          WA_Left,scr->MouseX,
 375                          WA_Top,scr->MouseY,
 376                          WA_InnerWidth,inner_winwidth,
 377                          WA_InnerHeight,inner_winheight,
 378                          WA_AutoAdjust,TRUE,
 379                          WA_Title,(IPTR)"Calculator",
 380                          WA_CloseGadget,TRUE,
 381                          WA_DepthGadget,TRUE,
 382                          WA_DragBar,TRUE,
 383                          WA_Activate,TRUE,
 384                          WA_SimpleRefresh,TRUE,
 385                          WA_IDCMP,IDCMP_CLOSEWINDOW |
 386                          IDCMP_GADGETUP |
 387                          IDCMP_VANILLAKEY |
 388                          IDCMP_RAWKEY |
 389                          IDCMP_REFRESHWINDOW,
 390                          WA_Gadgets,(IPTR)gadlist,
 391                          TAG_DONE);
 392
 393     if (!win) Cleanup("Can't open window!");
 394
 395     GT_RefreshWindow(win,0);
 396
 397     ScreenToFront(win->WScreen);
 398 }
 399
 400 static void OpenTape(void)
 401 {
 402     struct List *l;
 403     struct PubScreenNode *psn;
 404     char *scrname = "";
 405     WORD x,y,w,h;
 406
 407     if (!(tapename[0]))
 408     {
 409         l = LockPubScreenList();
 410
 411         psn = (struct PubScreenNode *)l->lh_Head;
 412
 413         while (psn->psn_Node.ln_Succ)
 414         {
 415             if (psn->psn_Screen == scr)
 416             {
 417                 if (psn->psn_Node.ln_Name)
 418                 {
 419                     scrname = psn->psn_Node.ln_Name;
 420                 }
 421                 break;
 422             }
 423             psn = (struct PubScreenNode *)psn->psn_Node.ln_Succ;
 424         }
 425
 426         UnlockPubScreenList();
 427
 428         w = win->Width * 5 / 4;
 429         h = win->Height;
 430
 431         x = win->LeftEdge;
 432         y = win->TopEdge;
 433
 434         if (x > (scr->Width - (x + w)))
 435         {
 436             x -= w;
 437         } else {
 438             x += win->Width;
 439         }
 440         sprintf(tapename,deftapename,x,y,w,h,scrname);
 441     }
 442
 443     if (!(tapefh = fopen(tapename,"w")))
 444     {
 445         DisplayBeep(scr);
 446     }
 447 }
 448
 449 static double GetValue(void)
 450 {
 451     double val;
 452     char c = 0,*sp;
 453
 454     sp = strchr(ledstring,comma);
 455     if (sp)
 456     {
 457         c = *sp;
 458         *sp = '.';
 459     }
 460
 461     val = strtod(ledstring,0);
 462
 463     if (sp) *sp = c;
 464
 465     return val;
 466 }
 467
 468 static void GetLeftValue(void)
 469 {
 470     leftval = GetValue();
 471 }
 472
 473 static void GetRightValue(void)
 474 {
 475     rightval = GetValue();
 476 }
 477
 478 static void LeftValToLED(void)
 479 {
 480     char *sp;
 481
 482     sprintf(ledstring,"%f",leftval);
 483
 484     sp = strchr(ledstring,'.');
 485     if (!sp) sp = strchr(ledstring,',');
 486     if (sp) *sp = comma;
 487 }
 488
 489 static char *DoOperation(void)
 490 {
 491     char *matherr = 0;
 492
 493     switch (operation)
 494     {
 495     case BTYPE_ADD:
 496         leftval += rightval;
 497         break;
 498
 499     case BTYPE_SUB:
 500         leftval -= rightval;
 501         break;
 502
 503     case BTYPE_MUL:
 504         leftval *= rightval;
 505         break;
 506
 507     case BTYPE_DIV:
 508         if (rightval == 0.0)
 509         {
 510             matherr = "Division by zero!";
 511         } else {
 512             leftval /= rightval;
 513         }
 514         break;
 515     }
 516
 517     if (!matherr) LeftValToLED();
 518
 519     return matherr;
 520 }
 521
 522 static void RefreshLED(void)
 523 {
 524     strcpy(visledstring,ledstring);
 525
 526     if ((ledstring[0] == ',') ||
 527         (ledstring[0] == '\0') ||
 528         ((ledstring[0] >= '0') && (ledstring[0] <= '9')))
 529     {
 530         visledstring[0] = '\0';
 531
 532         if ((ledstring[0] == ',') ||
 533             (ledstring[0] == '.') ||
 534             (ledstring[0] == '\0'))
 535         {
 536             strcpy(visledstring,"0");
 537         }
 538         strcat(visledstring,ledstring);
 539     }
 540
 541     GT_SetGadgetAttrs(gad[BTYPE_LED],
 542                       win,
 543                       0,
 544                       GTTX_Text,(IPTR)visledstring,
 545                       TAG_DONE);
 546 }
 547
 548 static void HandleButton(WORD type)
 549 {
 550     char *matherr = 0;
 551     WORD checklen;
 552     BOOL refresh_led = FALSE;
 553
 554     switch(type)
 555     {
 556     case BTYPE_0:
 557     case BTYPE_1:
 558     case BTYPE_2:
 559     case BTYPE_3:
 560     case BTYPE_4:
 561     case BTYPE_5:
 562     case BTYPE_6:
 563     case BTYPE_7:
 564     case BTYPE_8:
 565     case BTYPE_9:
 566         checklen = vallen;
 567         if ((strchr(ledstring,comma))) checklen--;
 568         if ((strchr(ledstring,'-'))) checklen--;
 569
 570         if (checklen < MAX_VAL_LEN)
 571         {
 572             if (state == STATE_OP)
 573             {
 574                 state = STATE_RIGHTVAL;
 575             } else if (state == STATE_EQU)
 576             {
 577                 state = STATE_LEFTVAL;
 578             }
 579
 580             if ((vallen > 0) || (type != BTYPE_0))
 581             {
 582                 ledstring[vallen++] = type + '0';
 583             }
 584             ledstring[vallen] = '\0';
 585
 586             refresh_led = TRUE;
 587
 588         } /* if (vallen < MAX_VAL_LEN) */
 589         break;
 590
 591     case BTYPE_COMMA:
 592         if (!strchr(ledstring,comma))
 593         {
 594             if (state == STATE_OP)
 595             {
 596                 state = STATE_RIGHTVAL;
 597             } else if (state == STATE_EQU)
 598             {
 599                 state = STATE_LEFTVAL;
 600             }
 601
 602             ledstring[vallen++] = comma;
 603             ledstring[vallen] = '\0';
 604
 605             refresh_led = TRUE;
 606
 607         } /* if (!strchr(ledstring,comma)) */
 608         break;
 609
 610     case BTYPE_CA:
 611         vallen = 0;
 612         leftval = 0.0;
 613         rightval = 0.0;
 614         operation = BTYPE_ADD;
 615
 616         state = STATE_LEFTVAL;
 617
 618         strcpy(ledstring,"0");
 619         refresh_led = TRUE;
 620
 621         if (tapefh) fputs("\n",tapefh);
 622         break;
 623
 624     case BTYPE_CE:
 625         vallen = 0;
 626         strcpy(ledstring,"0");
 627         refresh_led = TRUE;
 628
 629         switch (state)
 630         {
 631         case STATE_LEFTVAL:
 632             leftval = 0.0;
 633             break;
 634
 635         case STATE_OP:
 636         case STATE_RIGHTVAL:
 637             rightval = 0.0;
 638             break;
 639         }
 640         break;
 641
 642     case BTYPE_BS:
 643         if (vallen)
 644         {
 645             ledstring[--vallen] = '\0';
 646             if (vallen == 0) strcpy(ledstring,"0");
 647             refresh_led = TRUE;
 648         }
 649         break;
 650
 651     case BTYPE_SIGN:
 652         switch(state)
 653         {
 654         case STATE_LEFTVAL:
 655         case STATE_RIGHTVAL:
 656             if (ledstring[0] == '-')
 657             {
 658                 strcpy(ledstring,&ledstring[1]);
 659             } else {
 660                 strcpy(tempstring,ledstring);
 661                 strcpy(ledstring,"-");
 662                 strcat(ledstring,tempstring);
 663             }
 664             refresh_led = TRUE;
 665             break;
 666
 667         case STATE_EQU:
 668             leftval = -leftval;
 669             LeftValToLED();
 670             refresh_led = TRUE;
 671             break;
 672         }
 673         break;
 674
 675     case BTYPE_ADD:
 676     case BTYPE_SUB:
 677     case BTYPE_MUL:
 678     case BTYPE_DIV:
 679         switch(state)
 680         {
 681         case STATE_LEFTVAL:
 682         case STATE_EQU:
 683             GetLeftValue();
 684             rightval = leftval;
 685
 686             state = STATE_OP;
 687             vallen = 0;
 688             strcpy(ledstring,"0");
 689
 690             if (tapefh)
 691             {
 692                 fprintf(tapefh,"\t%s\n",visledstring);
 693                 fflush(tapefh);
 694             }
 695             break;
 696
 697         case STATE_OP:
 698             break;
 699
 700         case STATE_RIGHTVAL:
 701             GetRightValue();
 702             matherr = DoOperation();
 703             state = STATE_OP;
 704             vallen = 0;
 705             refresh_led = TRUE;
 706
 707             if (tapefh)
 708             {
 709                 fprintf(tapefh,"%s\t%s\n",(operation == BTYPE_ADD) ? "+" :
 710                                 (operation == BTYPE_SUB) ? "-" :
 711                                 (operation == BTYPE_DIV) ? ":" :
 712                                 "×" ,visledstring);
 713                 fflush(tapefh);
 714             }
 715             break;
 716
 717         } /* switch(state) */
 718
 719         operation = type;
 720         break;
 721
 722     case BTYPE_EQU:
 723         if (state == STATE_LEFTVAL)
 724         {
 725             GetLeftValue();
 726             if (tapefh)
 727             {
 728                 fprintf(tapefh,"\t%s\n",visledstring);
 729                 fflush(tapefh);
 730             }
 731         }
 732         else if (state == STATE_RIGHTVAL)
 733         {
 734             GetRightValue();
 735             if (tapefh)
 736             {
 737                 fprintf(tapefh,"%s\t%s\n",(operation == BTYPE_ADD) ? "+" :
 738                                 (operation == BTYPE_SUB) ? "-" :
 739                                 (operation == BTYPE_DIV) ? ":" :
 740                                 "×" ,visledstring);
 741                 fflush(tapefh);
 742             }
 743         }
 744
 745         matherr = DoOperation();
 746         state = STATE_EQU;
 747
 748         vallen = 0;
 749
 750         if (!matherr)
 751         {
 752             RefreshLED();
 753             if (tapefh)
 754             {
 755                 fprintf(tapefh,"=\t%s\n",visledstring);
 756                 fflush(tapefh);
 757             }
 758         } else {
 759             refresh_led = TRUE;
 760         }
 761         break;
 762
 763     } /* switch(type) */
 764
 765     if (matherr)
 766     {
 767         leftval = rightval = 0.0;
 768         state = STATE_LEFTVAL;
 769         operation = BTYPE_ADD;
 770         vallen = 0;
 771         strcpy(ledstring,matherr);
 772         refresh_led = TRUE;
 773     }
 774
 775     if (refresh_led) RefreshLED();
 776
 777 }
 778
 779 static void HandleAll(void)
 780 {
 781     struct IntuiMessage *msg;
 782     WORD icode,i;
 783     ULONG signals;
 784
 785     BOOL quitme = FALSE;
 786
 787     if (dotape) OpenTape();
 788
 789     while(!quitme)
 790     {
 791         signals = Wait(1L << win->UserPort->mp_SigBit | SIGBREAKF_CTRL_C);
 792
 793         if (signals & (1L << win->UserPort->mp_SigBit))
 794         {
 795             while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 796             {
 797                 switch(msg->Class)
 798                 {
 799                 case IDCMP_CLOSEWINDOW:
 800                     quitme = TRUE;
 801                     break;
 802
 803                 case IDCMP_REFRESHWINDOW:
 804                     GT_BeginRefresh(win);
 805                     GT_EndRefresh(win,TRUE);
 806                     break;
 807
 808                 case IDCMP_GADGETUP:
 809                     HandleButton(((struct Gadget *)msg->IAddress)->GadgetID);
 810                     break;
 811
 812                 case IDCMP_VANILLAKEY:
 813                     icode = toupper(msg->Code);
 814
 815                     for(i = 0;i < NUM_BUTTONS;i++)
 816                     {
 817                         if ((icode == bi[i].key1) ||
 818                             (icode == bi[i].key2))
 819                         {
 820                             icode = bi[i].type;
 821                             break;
 822                         }
 823                     }
 824                     if (i < NUM_BUTTONS)
 825                     {
 826                         HandleButton(icode);
 827                     } else if (icode == 27)
 828                     {
 829                         quitme = TRUE;
 830                     }
 831                     break;
 832
 833                 } /* switch(msg->Class) */
 834
 835                 ReplyMsg((struct Message *)msg);
 836             } /* while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort))) */
 837         } /* if(signals & (1L << win->UserPort->mp_SigBit)) */
 838         if (signals & SIGBREAKF_CTRL_C)
 839             quitme = TRUE;
 840
 841     } /* while(!quitme) */
 842 }
 843
 844 int main(void)
 845 {
 846     OpenLibs();
 847     GetArguments();
 848     DoLocale();
 849     GetVisual();
 850     InitGUI();
 851     MakeGadgets();
 852     MakeWin();
 853     HandleAll();
 854     Cleanup(0);
 855     return 0;
 856 }