workbench/tools/Calculator.c

   1 /*
   2     Copyright © 1995-2011, 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 BPTR 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.3 (07.10.2007) © AROS Dev Team";
 147
 148 static IPTR 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) Close(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,(IPTR *)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     strcpy(ledstring,"0");
 300 }
 301
 302 static void MakeGadgets(void)
 303 {
 304     struct Gadget *mygad = 0;
 305     struct NewGadget ng = {0};
 306     WORD col,row,i;
 307
 308     ng.ng_VisualInfo = vi;
 309
 310     mygad = CreateContext(&gadlist);
 311
 312     ng.ng_GadgetID = BTYPE_LED;
 313
 314     ng.ng_LeftEdge = win_borderleft + INNER_SPACING_X;
 315     ng.ng_TopEdge  = win_bordertop + INNER_SPACING_Y;
 316     ng.ng_Width = inner_winwidth - INNER_SPACING_X * 2;
 317     ng.ng_Height = ledheight;
 318
 319     mygad = gad[BTYPE_LED] = CreateGadget(TEXT_KIND,
 320                                           mygad,
 321                                           &ng,
 322                                           GTTX_Text, (IPTR) ledstring,
 323                                           GTTX_CopyText,TRUE,
 324                                           GTTX_Border,TRUE,
 325                                           GTTX_Justification,GTJ_RIGHT,
 326                                           TAG_DONE);
 327
 328     i = 0;
 329
 330     ng.ng_TopEdge = win_bordertop +
 331         INNER_SPACING_Y +
 332         ledheight +
 333         BUTTON_LED_SPACING;
 334
 335     ng.ng_Width = buttonwidth;
 336     ng.ng_Height = buttonheight;
 337
 338     for(row = 0; row < NUM_BUTTON_ROWS; row++)
 339     {
 340         for(col = 0; col < NUM_BUTTON_COLS; col++, i++)
 341         {
 342             ng.ng_GadgetID = bi[i].type;
 343
 344             ng.ng_LeftEdge = win_borderleft +
 345                 INNER_SPACING_X +
 346                 col * (buttonwidth + BUTTON_SPACING_X);
 347
 348             ng.ng_GadgetText = bi[i].text;
 349
 350             mygad = gad[bi[i].type] = CreateGadgetA(BUTTON_KIND,
 351                                                     mygad,
 352                                                     &ng,
 353                                                     0);
 354
 355         } /* for(col = 0;col < NUM_BUTTON_COLS; col++) */
 356
 357         ng.ng_TopEdge += buttonheight + BUTTON_SPACING_Y;
 358
 359     } /* for(row = 0; row < NUM_BUTTON_ROWS; row++) */
 360
 361     if (!mygad)
 362     {
 363         Cleanup("Can't create gadgets!");
 364     }
 365
 366 }
 367
 368 static void MakeWin(void)
 369 {
 370     win = OpenWindowTags(0,WA_PubScreen,(IPTR)scr,
 371                          WA_Left,scr->MouseX,
 372                          WA_Top,scr->MouseY,
 373                          WA_InnerWidth,inner_winwidth,
 374                          WA_InnerHeight,inner_winheight,
 375                          WA_AutoAdjust,TRUE,
 376                          WA_Title,(IPTR)"Calculator",
 377                          WA_CloseGadget,TRUE,
 378                          WA_DepthGadget,TRUE,
 379                          WA_DragBar,TRUE,
 380                          WA_Activate,TRUE,
 381                          WA_SimpleRefresh,TRUE,
 382                          WA_IDCMP,IDCMP_CLOSEWINDOW |
 383                          IDCMP_GADGETUP |
 384                          IDCMP_VANILLAKEY |
 385                          IDCMP_RAWKEY |
 386                          IDCMP_REFRESHWINDOW,
 387                          WA_Gadgets,(IPTR)gadlist,
 388                          TAG_DONE);
 389
 390     if (!win) Cleanup("Can't open window!");
 391
 392     GT_RefreshWindow(win,0);
 393
 394     ScreenToFront(win->WScreen);
 395 }
 396
 397 static void OpenTape(void)
 398 {
 399     struct List *l;
 400     struct PubScreenNode *psn;
 401     char *scrname = "";
 402     WORD x,y,w,h;
 403
 404     if (!(tapename[0]))
 405     {
 406         l = LockPubScreenList();
 407
 408         psn = (struct PubScreenNode *)l->lh_Head;
 409
 410         while (psn->psn_Node.ln_Succ)
 411         {
 412             if (psn->psn_Screen == scr)
 413             {
 414                 if (psn->psn_Node.ln_Name)
 415                 {
 416                     scrname = psn->psn_Node.ln_Name;
 417                 }
 418                 break;
 419             }
 420             psn = (struct PubScreenNode *)psn->psn_Node.ln_Succ;
 421         }
 422
 423         UnlockPubScreenList();
 424
 425         w = win->Width * 5 / 4;
 426         h = win->Height;
 427
 428         x = win->LeftEdge;
 429         y = win->TopEdge;
 430
 431         if (x > (scr->Width - (x + w)))
 432         {
 433             x -= w;
 434         } else {
 435             x += win->Width;
 436         }
 437         sprintf(tapename,deftapename,x,y,w,h,scrname);
 438     }
 439
 440     if (!(tapefh = Open(tapename,MODE_NEWFILE)))
 441     {
 442         DisplayBeep(scr);
 443     }
 444 }
 445
 446 static double GetValue(void)
 447 {
 448     double val;
 449     char c = 0,*sp;
 450
 451     sp = strchr(ledstring,comma);
 452     if (sp)
 453     {
 454         c = *sp;
 455         *sp = '.';
 456     }
 457
 458     val = strtod(ledstring,0);
 459
 460     if (sp) *sp = c;
 461
 462     return val;
 463 }
 464
 465 static void GetLeftValue(void)
 466 {
 467     leftval = GetValue();
 468 }
 469
 470 static void GetRightValue(void)
 471 {
 472     rightval = GetValue();
 473 }
 474
 475 static void LeftValToLED(void)
 476 {
 477     char *sp;
 478
 479     sprintf(ledstring,"%f",leftval);
 480
 481     sp = strchr(ledstring,'.');
 482     if (!sp) sp = strchr(ledstring,',');
 483     if (sp) *sp = comma;
 484 }
 485
 486 static char *DoOperation(void)
 487 {
 488     char *matherr = 0;
 489
 490     switch (operation)
 491     {
 492     case BTYPE_ADD:
 493         leftval += rightval;
 494         break;
 495
 496     case BTYPE_SUB:
 497         leftval -= rightval;
 498         break;
 499
 500     case BTYPE_MUL:
 501         leftval *= rightval;
 502         break;
 503
 504     case BTYPE_DIV:
 505         if (rightval == 0.0)
 506         {
 507             matherr = "Division by zero!";
 508         } else {
 509             leftval /= rightval;
 510         }
 511         break;
 512     }
 513
 514     if (leftval > 9999999999999.0) // because of MAX_VAL_LEN
 515     {
 516         matherr = "Buffer overflow!";
 517     }
 518
 519     if (!matherr) LeftValToLED();
 520
 521     return matherr;
 522 }
 523
 524 static void RefreshLED(void)
 525 {
 526     strcpy(visledstring,ledstring);
 527
 528     if ((ledstring[0] == ',') ||
 529         (ledstring[0] == '\0') ||
 530         ((ledstring[0] >= '0') && (ledstring[0] <= '9')))
 531     {
 532         visledstring[0] = '\0';
 533
 534         if ((ledstring[0] == ',') ||
 535             (ledstring[0] == '.') ||
 536             (ledstring[0] == '\0'))
 537         {
 538             strcpy(visledstring,"0");
 539         }
 540         strcat(visledstring,ledstring);
 541     }
 542
 543     GT_SetGadgetAttrs(gad[BTYPE_LED],
 544                       win,
 545                       0,
 546                       GTTX_Text,(IPTR)visledstring,
 547                       TAG_DONE);
 548 }
 549
 550 static void HandleButton(WORD type)
 551 {
 552     char *matherr = 0;
 553     WORD checklen;
 554     BOOL refresh_led = FALSE;
 555
 556     switch(type)
 557     {
 558     case BTYPE_0:
 559     case BTYPE_1:
 560     case BTYPE_2:
 561     case BTYPE_3:
 562     case BTYPE_4:
 563     case BTYPE_5:
 564     case BTYPE_6:
 565     case BTYPE_7:
 566     case BTYPE_8:
 567     case BTYPE_9:
 568         checklen = vallen;
 569         if ((strchr(ledstring,comma))) checklen--;
 570         if ((strchr(ledstring,'-'))) checklen--;
 571
 572         if (checklen < MAX_VAL_LEN)
 573         {
 574             if (state == STATE_OP)
 575             {
 576                 state = STATE_RIGHTVAL;
 577             } else if (state == STATE_EQU)
 578             {
 579                 state = STATE_LEFTVAL;
 580             }
 581
 582             if ((vallen > 0) || (type != BTYPE_0))
 583             {
 584                 ledstring[vallen++] = type + '0';
 585             }
 586             ledstring[vallen] = '\0';
 587
 588             refresh_led = TRUE;
 589
 590         } /* if (vallen < MAX_VAL_LEN) */
 591         break;
 592
 593     case BTYPE_COMMA:
 594         if (!strchr(ledstring,comma))
 595         {
 596             if (state == STATE_OP)
 597             {
 598                 state = STATE_RIGHTVAL;
 599             } else if (state == STATE_EQU)
 600             {
 601                 state = STATE_LEFTVAL;
 602             }
 603
 604             ledstring[vallen++] = comma;
 605             ledstring[vallen] = '\0';
 606
 607             refresh_led = TRUE;
 608
 609         } /* if (!strchr(ledstring,comma)) */
 610         break;
 611
 612     case BTYPE_CA:
 613         vallen = 0;
 614         leftval = 0.0;
 615         rightval = 0.0;
 616         operation = BTYPE_ADD;
 617
 618         state = STATE_LEFTVAL;
 619
 620         strcpy(ledstring,"0");
 621         refresh_led = TRUE;
 622
 623         if (tapefh) FPutC(tapefh, '\n');
 624         break;
 625
 626     case BTYPE_CE:
 627         vallen = 0;
 628         strcpy(ledstring,"0");
 629         refresh_led = TRUE;
 630
 631         switch (state)
 632         {
 633         case STATE_LEFTVAL:
 634             leftval = 0.0;
 635             break;
 636
 637         case STATE_OP:
 638         case STATE_RIGHTVAL:
 639             rightval = 0.0;
 640             break;
 641         }
 642         break;
 643
 644     case BTYPE_BS:
 645         if (vallen)
 646         {
 647             ledstring[--vallen] = '\0';
 648             if (vallen == 0) strcpy(ledstring,"0");
 649             refresh_led = TRUE;
 650         }
 651         break;
 652
 653     case BTYPE_SIGN:
 654         switch(state)
 655         {
 656         case STATE_LEFTVAL:
 657         case STATE_RIGHTVAL:
 658             if (ledstring[0] == '-')
 659             {
 660                 strcpy(ledstring,&ledstring[1]);
 661             } else {
 662                 strcpy(tempstring,ledstring);
 663                 strcpy(ledstring,"-");
 664                 strcat(ledstring,tempstring);
 665             }
 666             refresh_led = TRUE;
 667             break;
 668
 669         case STATE_EQU:
 670             leftval = -leftval;
 671             LeftValToLED();
 672             refresh_led = TRUE;
 673             break;
 674         }
 675         break;
 676
 677     case BTYPE_ADD:
 678     case BTYPE_SUB:
 679     case BTYPE_MUL:
 680     case BTYPE_DIV:
 681         switch(state)
 682         {
 683         case STATE_LEFTVAL:
 684         case STATE_EQU:
 685             GetLeftValue();
 686             rightval = leftval;
 687
 688             state = STATE_OP;
 689             vallen = 0;
 690             strcpy(ledstring,"0");
 691
 692             if (tapefh)
 693             {
 694                 FPutC(tapefh, '\t');
 695                 FPuts(tapefh, visledstring);
 696                 FPutC(tapefh, '\n');
 697                 Flush(tapefh);
 698             }
 699             break;
 700
 701         case STATE_OP:
 702             break;
 703
 704         case STATE_RIGHTVAL:
 705             GetRightValue();
 706             matherr = DoOperation();
 707             state = STATE_OP;
 708             vallen = 0;
 709             refresh_led = TRUE;
 710
 711             if (tapefh)
 712             {
 713                 FPuts(tapefh,
 714                                 (operation == BTYPE_ADD) ? "+" :
 715                                 (operation == BTYPE_SUB) ? "-" :
 716                                 (operation == BTYPE_DIV) ? ":" :
 717                                 "×");
 718                 FPutC(tapefh, '\t');
 719                 FPuts(tapefh, visledstring);
 720                 FPutC(tapefh, '\n');
 721                 Flush(tapefh);
 722             }
 723             break;
 724
 725         } /* switch(state) */
 726
 727         operation = type;
 728         break;
 729
 730     case BTYPE_EQU:
 731         if (state == STATE_LEFTVAL)
 732         {
 733             GetLeftValue();
 734             if (tapefh)
 735             {
 736                 FPutC(tapefh, '\t');
 737                 FPuts(tapefh, visledstring);
 738                 FPutC(tapefh, '\n');
 739                 Flush(tapefh);
 740             }
 741         }
 742         else if (state == STATE_RIGHTVAL)
 743         {
 744             GetRightValue();
 745             if (tapefh)
 746             {
 747                 FPuts(tapefh,
 748                                 (operation == BTYPE_ADD) ? "+" :
 749                                 (operation == BTYPE_SUB) ? "-" :
 750                                 (operation == BTYPE_DIV) ? ":" :
 751                                 "×");
 752                 FPutC(tapefh, '\t');
 753                 FPuts(tapefh, visledstring);
 754                 FPutC(tapefh, '\n');
 755                 Flush(tapefh);
 756             }
 757         }
 758
 759         matherr = DoOperation();
 760         state = STATE_EQU;
 761
 762         vallen = 0;
 763
 764         if (!matherr)
 765         {
 766             RefreshLED();
 767             if (tapefh)
 768             {
 769                 FPuts(tapefh, "=\t");
 770                 FPuts(tapefh, visledstring);
 771                 FPutC(tapefh, '\n');
 772                 Flush(tapefh);
 773             }
 774         } else {
 775             refresh_led = TRUE;
 776         }
 777         break;
 778
 779     } /* switch(type) */
 780
 781     if (matherr)
 782     {
 783         leftval = rightval = 0.0;
 784         state = STATE_LEFTVAL;
 785         operation = BTYPE_ADD;
 786         vallen = 0;
 787         strcpy(ledstring,matherr);
 788         refresh_led = TRUE;
 789     }
 790
 791     if (refresh_led) RefreshLED();
 792
 793 }
 794
 795 static void HandleAll(void)
 796 {
 797     struct IntuiMessage *msg;
 798     WORD icode,i;
 799     ULONG signals;
 800
 801     BOOL quitme = FALSE;
 802
 803     if (dotape) OpenTape();
 804
 805     while(!quitme)
 806     {
 807         signals = Wait(1L << win->UserPort->mp_SigBit | SIGBREAKF_CTRL_C);
 808
 809         if (signals & (1L << win->UserPort->mp_SigBit))
 810         {
 811             while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 812             {
 813                 switch(msg->Class)
 814                 {
 815                 case IDCMP_CLOSEWINDOW:
 816                     quitme = TRUE;
 817                     break;
 818
 819                 case IDCMP_REFRESHWINDOW:
 820                     GT_BeginRefresh(win);
 821                     GT_EndRefresh(win,TRUE);
 822                     break;
 823
 824                 case IDCMP_GADGETUP:
 825                     HandleButton(((struct Gadget *)msg->IAddress)->GadgetID);
 826                     break;
 827
 828                 case IDCMP_VANILLAKEY:
 829                     icode = toupper(msg->Code);
 830
 831                     for(i = 0;i < NUM_BUTTONS;i++)
 832                     {
 833                         if ((icode == bi[i].key1) ||
 834                             (icode == bi[i].key2))
 835                         {
 836                             icode = bi[i].type;
 837                             break;
 838                         }
 839                     }
 840                     if (i < NUM_BUTTONS)
 841                     {
 842                         HandleButton(icode);
 843                     } else if (icode == 27)
 844                     {
 845                         quitme = TRUE;
 846                     }
 847                     break;
 848
 849                 } /* switch(msg->Class) */
 850
 851                 ReplyMsg((struct Message *)msg);
 852             } /* while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort))) */
 853         } /* if(signals & (1L << win->UserPort->mp_SigBit)) */
 854         if (signals & SIGBREAKF_CTRL_C)
 855             quitme = TRUE;
 856
 857     } /* while(!quitme) */
 858 }
 859
 860 int main(void)
 861 {
 862     OpenLibs();
 863     GetArguments();
 864     DoLocale();
 865     GetVisual();
 866     InitGUI();
 867     MakeGadgets();
 868     MakeWin();
 869     HandleAll();
 870     Cleanup(0);
 871     return 0;
 872 }