workbench/tools/Calculator.c

   1 /*
   2     Copyright © 1995-2018, The AROS Development Team. All rights reserved.
   3     $Id$
   4     Command line options:
   5
   6     1. PUBSCREEN <name>: the name of the public screen to open the window on
   7     2. TAPE <filename>: the name of a file to record the user interactions
   8        into
   9 */
  10 #include <exec/types.h>
  11 #include <dos/dos.h>
  12 #include <intuition/intuition.h>
  13 #include <intuition/classes.h>
  14 #include <libraries/mui.h>
  15
  16 #include <proto/exec.h>
  17 #include <proto/dos.h>
  18 #include <proto/intuition.h>
  19 #include <proto/locale.h>
  20 #include <proto/alib.h>
  21 #include <proto/muimaster.h>
  22 #include <proto/utility.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 const char *version = "$VER: Calculator 1.5 (31.05.2018) © AROS Dev Team";
  29
  30 #define ARG_TEMPLATE "PUBSCREEN,TAPE/K"
  31 enum {ARG_PUBSCREEN,ARG_TAPE,NUM_ARGS};
  32
  33 /* The pattern of the tape name in case we log to a RAW: window */
  34 #define RAW_TAPE_NAME "RAW:%d/%d/%d/%d/Calculator Tape/INACTIVE/SCREEN%s"
  35
  36 enum
  37 {
  38     BTYPE_0 = 0,
  39     BTYPE_1,
  40     BTYPE_2,
  41     BTYPE_3,
  42     BTYPE_4,
  43     BTYPE_5,
  44     BTYPE_6,
  45     BTYPE_7,
  46     BTYPE_8,
  47     BTYPE_9,
  48     BTYPE_COMMA,
  49     BTYPE_BS,
  50     BTYPE_CA,
  51     BTYPE_CE,
  52     BTYPE_MUL,
  53     BTYPE_DIV,
  54     BTYPE_SUB,
  55     BTYPE_ADD,
  56     BTYPE_SIGN,
  57     BTYPE_EQU
  58 };
  59
  60 #define NUM_BUTTONS 20
  61 #define DECIMAL_BUTTON_INDEX 16
  62
  63 struct CalcButtonInfo
  64 {
  65     const char *label;
  66     ULONG btype;
  67     char shortcut;
  68 };
  69
  70 struct CalcButtonInfo BUTTONS[] =
  71 {
  72     {"7", BTYPE_7, '7'}, {"8", BTYPE_8, '8'}, {"9", BTYPE_9, '9'}, {"CA", BTYPE_CA, 'A'}, {"CE", BTYPE_CE, 'E'},
  73     {"4", BTYPE_4, '4'}, {"5", BTYPE_5, '5'}, {"6", BTYPE_6, '6'}, {"*", BTYPE_MUL, '*'}, {":", BTYPE_DIV, ':'},
  74     {"1", BTYPE_1, '1'}, {"2", BTYPE_2, '2'}, {"3", BTYPE_3, '3'}, {"+", BTYPE_ADD, '+'}, {"-", BTYPE_SUB, '-'},
  75     {"0", BTYPE_0, '0'}, {".", BTYPE_COMMA, '.'}, {"<<", BTYPE_BS, 8}, {"+/-", BTYPE_SIGN, 's'}, {"=", BTYPE_EQU, '='}
  76 };
  77
  78 /*
  79  * Most of the application state is local or in BOOPSI objects.
  80  * The only global state is to communicate the command line arguments
  81  */
  82 #define CALC_TAPENAME_MAX       320
  83 static char pubscrname[256];
  84 static char tapename[CALC_TAPENAME_MAX];
  85 static BOOL use_tape;
  86
  87 /**********************************************************************
  88  Tape BOOPSI class
  89  **********************************************************************/
  90
  91 #define TAPEA_FILEHANDLE    (TAG_USER + 20)
  92 #define TAPEM_NEWLINE       (TAG_USER + 21)
  93 #define TAPEM_PRINT_LVAL    (TAG_USER + 22)
  94 #define TAPEM_PRINT_RVAL    (TAG_USER + 23)
  95 #define TAPEM_PRINT_RESULT  (TAG_USER + 24)
  96
  97 struct TapeData
  98 {
  99     BPTR tapefh;
 100 };
 101
 102 struct MUIMP_PrintLval
 103 {
 104     STACKED ULONG MethodID;
 105     STACKED const char *str;
 106 };
 107
 108 struct MUIMP_PrintRval
 109 {
 110     STACKED ULONG MethodID;
 111     STACKED char operator;
 112     STACKED const char *str;
 113 };
 114
 115 struct MUIMP_PrintResult
 116 {
 117     STACKED ULONG MethodID;
 118     STACKED const char *str;
 119 };
 120
 121 IPTR mNewTape(struct IClass *cl, Object *obj, struct opSet *msg)
 122 {
 123     struct TagItem *tagListState = msg->ops_AttrList, *tag;
 124     Object *instance = (Object *) DoSuperMethodA(cl, obj, (APTR) msg);
 125     struct TapeData *data = INST_DATA(cl, instance);
 126     data->tapefh = BNULL;
 127
 128     while ((tag = (struct TagItem *) NextTagItem(&tagListState)))
 129     {
 130         switch (tag->ti_Tag)
 131         {
 132             case TAPEA_FILEHANDLE:
 133                 data->tapefh = (BPTR) tag->ti_Data;
 134                 break;
 135             default:
 136                 break;
 137         }
 138     }
 139     return (IPTR) instance;
 140 }
 141
 142 IPTR mDisposeTape(struct IClass *cl, Object *obj, struct opSet *msg)
 143 {
 144     struct TapeData *data = INST_DATA(cl, obj);
 145     if (data->tapefh) Close(data->tapefh);
 146     return DoSuperMethodA(cl, obj, (APTR) msg);
 147 }
 148
 149 IPTR mTapeNewline(struct IClass *cl, Object *obj, APTR msg)
 150 {
 151     struct TapeData *data = INST_DATA(cl, obj);
 152     if (data->tapefh) FPutC(data->tapefh, '\n');
 153     return (IPTR) obj;
 154 }
 155
 156 IPTR mTapePrintLval(struct IClass *cl, Object *obj, struct MUIMP_PrintLval *msg)
 157 {
 158     struct TapeData *data = INST_DATA(cl, obj);
 159     if (data->tapefh)
 160     {
 161         FPutC(data->tapefh, '\t');
 162         FPuts(data->tapefh, msg->str);
 163         FPutC(data->tapefh, '\n');
 164         Flush(data->tapefh);
 165     }
 166     return (IPTR) obj;
 167 }
 168
 169 IPTR mTapePrintRval(struct IClass *cl, Object *obj, struct MUIMP_PrintRval *msg)
 170 {
 171     struct TapeData *data = INST_DATA(cl, obj);
 172     if (data->tapefh)
 173     {
 174         FPutC(data->tapefh, msg->operator);
 175         FPutC(data->tapefh, '\t');
 176         FPuts(data->tapefh, msg->str);
 177         FPutC(data->tapefh, '\n');
 178         Flush(data->tapefh);
 179   }
 180   return (IPTR) obj;
 181 }
 182
 183 IPTR mTapePrintResult(struct IClass *cl, Object *obj, struct MUIMP_PrintResult *msg)
 184 {
 185     struct TapeData *data = INST_DATA(cl, obj);
 186     if (data->tapefh)
 187     {
 188         FPuts(data->tapefh, "=\t");
 189         FPuts(data->tapefh, msg->str);
 190         FPutC(data->tapefh, '\n');
 191         Flush(data->tapefh);
 192     }
 193     return (IPTR) obj;
 194 }
 195
 196 ULONG mSet(struct IClass *cl, Object *obj, struct opSet *msg)
 197 {
 198     struct TagItem *tagListState = msg->ops_AttrList, *tag;
 199     struct TapeData *data = INST_DATA(cl, obj);
 200
 201     while ((tag = (struct TagItem *) NextTagItem(&tagListState)))
 202     {
 203         switch (tag->ti_Tag)
 204         {
 205             case TAPEA_FILEHANDLE:
 206                 data->tapefh = (BPTR) tag->ti_Data;
 207                 break;
 208             default:
 209                 break;
 210         }
 211     }
 212     return (IPTR) obj;
 213 }
 214
 215 BOOPSI_DISPATCHER(IPTR, TapeDispatcher, cl, obj, msg)
 216 {
 217     switch (msg->MethodID)
 218     {
 219         case OM_NEW:           return mNewTape(cl, obj, (APTR) msg);
 220         case OM_DISPOSE:       return mDisposeTape(cl, obj, (APTR) msg);
 221         case OM_SET:           return mSet(cl, obj, (APTR) msg);
 222
 223         case TAPEM_NEWLINE:    return mTapeNewline(cl, obj, (APTR) msg);
 224         case TAPEM_PRINT_LVAL: return mTapePrintLval(cl, obj, (struct MUIMP_PrintLval *) msg);
 225         case TAPEM_PRINT_RVAL: return mTapePrintRval(cl, obj, (struct MUIMP_PrintRval *) msg);
 226         case TAPEM_PRINT_RESULT: return mTapePrintResult(cl, obj, (struct MUIMP_PrintResult *) msg);
 227     }
 228     return DoSuperMethodA(cl, obj, msg);
 229 }
 230 BOOPSI_DISPATCHER_END
 231
 232 static Class *make_tape_class(void)
 233 {
 234     Class *cl;
 235     cl = MakeClass(NULL, ROOTCLASS, NULL, sizeof(struct TapeData), 0);
 236     if (cl) cl->cl_Dispatcher.h_Entry = TapeDispatcher;
 237     return cl;
 238 }
 239
 240 /**********************************************************************
 241  Calculator BOOPSI class
 242  **********************************************************************/
 243
 244 #define MAX_DIGITS 13
 245 #define OM_ADD_KEY           (TAG_USER + 30)
 246 #define CALCA_DISPLAY        (TAG_USER + 31)
 247 #define CALCA_TAPE           (TAG_USER + 32)
 248 #define CALCA_DECIMAL_POINT  (TAG_USER + 33)
 249
 250 #define EDIT_BUFFER_SIZE MAX_DIGITS + 2  /* space for '-' sign and terminator byte */
 251 const char *INITIAL_DISPLAY = "\033r0";
 252 enum { STATE_LEFTVAL, STATE_OP, STATE_RIGHTVAL, STATE_EQU };
 253
 254 struct CalculatorData
 255 {
 256     char edit_buffer[EDIT_BUFFER_SIZE];
 257     int num_digits;
 258     int state;
 259     char decimal_point;
 260
 261     double lvalue, rvalue;
 262     int op;
 263     Object *display, *tape;
 264 };
 265
 266 struct MUIMP_CalcKey
 267 {
 268     STACKED ULONG MethodID;
 269     STACKED ULONG btype;
 270 };
 271
 272 static char op2char(int op)
 273 {
 274     switch (op) {
 275         case BTYPE_MUL: return '*';
 276         case BTYPE_DIV: return '*';
 277         case BTYPE_SUB: return '-';
 278         case BTYPE_ADD: return '+';
 279         default: return '?';
 280     }
 281 }
 282
 283 static void clear_edit_buffer(struct CalculatorData *data)
 284 {
 285     memset(data->edit_buffer, 0, EDIT_BUFFER_SIZE);
 286     data->num_digits = 0;
 287 }
 288
 289 IPTR mNewCalc(struct IClass *cl, Object *obj, struct opSet *msg)
 290 {
 291     struct TagItem *tagListState = msg->ops_AttrList, *tag;
 292     Object *instance = (Object *) DoSuperMethodA(cl, obj, (APTR) msg);
 293     struct CalculatorData *data = INST_DATA(cl, instance);
 294     clear_edit_buffer(data);
 295     data->display = NULL;
 296     data->tape = NULL;
 297     data->state = STATE_LEFTVAL;
 298     data->decimal_point = '.';
 299
 300     while ((tag = (struct TagItem *) NextTagItem(&tagListState)))
 301     {
 302         switch (tag->ti_Tag)
 303         {
 304             case CALCA_DISPLAY:
 305                 data->display = (Object *) tag->ti_Data;
 306                 break;
 307             case CALCA_TAPE:
 308                 data->tape = (Object *) tag->ti_Data;
 309                 break;
 310             case CALCA_DECIMAL_POINT:
 311                 data->decimal_point = (char) tag->ti_Data;
 312                 break;
 313             default:
 314                 break;
 315         }
 316     }
 317     return (IPTR) instance;
 318 }
 319
 320 IPTR mDisposeCalc(struct IClass *cl, Object *obj, struct opSet *msg)
 321 {
 322     return DoSuperMethodA(cl, obj, (APTR) msg);
 323 }
 324
 325 static BOOL is_operator(int btype)
 326 {
 327     return btype >= BTYPE_MUL && btype <= BTYPE_ADD;
 328 }
 329
 330 static BOOL can_insert_comma(struct CalculatorData *data)
 331 {
 332     if (data->num_digits == 0) return TRUE;
 333     else
 334     {
 335         int i;
 336         for (i = 0; i < data->num_digits; i++)
 337         {
 338             if (data->edit_buffer[i] == '.') return FALSE;
 339         }
 340         return TRUE;
 341     }
 342 }
 343
 344 static double eval_result(double lvalue, double rvalue, int op)
 345 {
 346     switch (op)
 347     {
 348         case BTYPE_MUL: return lvalue * rvalue;
 349         case BTYPE_DIV: return lvalue / rvalue;
 350         case BTYPE_SUB: return lvalue - rvalue;
 351         case BTYPE_ADD: return lvalue + rvalue;
 352         default: return 0;
 353     }
 354 }
 355
 356
 357 static void localize_buffer(char *buffer, char decimal_point, int from, int to)
 358 {
 359     int i;
 360     for (i = from; i < to; i ++)
 361     {
 362         if (buffer[i] == '.')
 363         {
 364             buffer[i] = decimal_point;
 365             break;
 366         }
 367     }
 368 }
 369 /*
 370  * Rendering is centralized in this function, by copying
 371  * the edit buffer into and manipulating the display buffer.
 372  * MUI/Zune's text field right-justifies text through the inclusion
 373  * of the "Esc-r" control sequence.
 374  */
 375 static void display_state(struct CalculatorData *data)
 376 {
 377     /* add 2 extra chars: Esc+'r' */
 378     static char display_buffer[EDIT_BUFFER_SIZE + 2];
 379
 380     if (data->num_digits == 0)
 381     {
 382         SetAttrs(data->display, MUIA_Text_Contents, INITIAL_DISPLAY, TAG_DONE);
 383     }
 384     else
 385     {
 386         memset(display_buffer, 0, EDIT_BUFFER_SIZE + 2);
 387         display_buffer[0] = '\033';
 388         display_buffer[1] = 'r';
 389         memcpy(display_buffer + 2, data->edit_buffer, data->num_digits);
 390         localize_buffer(display_buffer, data->decimal_point, 2, MAX_DIGITS + 3);
 391         SetAttrs(data->display, MUIA_Text_Contents, display_buffer, TAG_DONE);
 392     }
 393 }
 394
 395 static const char *localize_display(struct CalculatorData *data)
 396 {
 397     static char buffer[EDIT_BUFFER_SIZE];
 398     memset(buffer, 0, MAX_DIGITS + 1);
 399     memcpy(buffer, data->edit_buffer, data->num_digits);
 400     localize_buffer(buffer, data->decimal_point, 0, MAX_DIGITS + 1);
 401     return buffer;
 402 }
 403
 404 static void toggle_sign(struct CalculatorData *data)
 405 {
 406     BOOL sign_found = FALSE;
 407     int i;
 408     if (data->state == STATE_LEFTVAL)       data->lvalue = -data->lvalue;
 409     else if (data->state == STATE_RIGHTVAL) data->rvalue = -data->rvalue;
 410
 411     for (i = 0; i < EDIT_BUFFER_SIZE; i++)
 412     {
 413         if (data->edit_buffer[i] == '-')
 414         {
 415             sign_found = TRUE;
 416             break;
 417         }
 418     }
 419
 420     if (sign_found)
 421     {
 422         /* eliminate the sign by shifting to the left */
 423         data->num_digits--;
 424         memmove(data->edit_buffer, data->edit_buffer + 1, data->num_digits);
 425         data->edit_buffer[data->num_digits] = 0;
 426     }
 427     else
 428     {
 429         /* add sign by shifting to the right and inserting - */
 430         memmove(data->edit_buffer + 1, data->edit_buffer, data->num_digits);
 431         data->num_digits++;
 432         data->edit_buffer[0] = '-';
 433         data->edit_buffer[data->num_digits] = 0;
 434     }
 435     display_state(data);
 436 }
 437
 438 /*
 439  * This method implements the main logic of the calculator by performing transitions
 440  * of a state machine.
 441  */
 442 IPTR mAddCalcKey(struct IClass *cl, Object *obj, struct MUIMP_CalcKey *msg)
 443 {
 444     struct CalculatorData *data = INST_DATA(cl, obj);
 445     if (msg->btype <= BTYPE_9 && data->num_digits < MAX_DIGITS)
 446     {
 447         if (data->state == STATE_OP)
 448         {
 449             data->state = STATE_RIGHTVAL;
 450             clear_edit_buffer(data);
 451         }
 452         if (data->state == STATE_EQU)
 453         {
 454             data->state = STATE_LEFTVAL;
 455             clear_edit_buffer(data);
 456         }
 457         char digit = '0' + msg->btype;
 458         data->edit_buffer[data->num_digits++] = digit;
 459         display_state(data);
 460
 461     }
 462     else if (msg->btype == BTYPE_COMMA && can_insert_comma(data))
 463     {
 464         data->edit_buffer[data->num_digits++] = '.';
 465         display_state(data);
 466     }
 467     else if (is_operator(msg->btype))
 468     {
 469         if (data->state == STATE_LEFTVAL || data->state == STATE_EQU)
 470         {
 471             data->lvalue = strtod(data->edit_buffer, NULL);
 472             data->state = STATE_OP;
 473             data->op = msg->btype;
 474             if (data->tape) DoMethod(data->tape, TAPEM_PRINT_LVAL, localize_display(data));
 475         }
 476     }
 477     else if (msg->btype == BTYPE_EQU)
 478     {
 479         if (data->tape) DoMethod(data->tape, TAPEM_PRINT_RVAL, op2char(data->op), localize_display(data));
 480
 481         data->rvalue = strtod(data->edit_buffer, NULL);
 482         data->state = STATE_EQU;
 483         data->lvalue = eval_result(data->lvalue, data->rvalue, data->op);
 484         snprintf(data->edit_buffer, MAX_DIGITS, "%f", data->lvalue);
 485         /* note that there is no strnlen() in AROS !!! */
 486         data->num_digits = strlen(data->edit_buffer);
 487
 488         display_state(data);
 489         if (data->tape) DoMethod(data->tape, TAPEM_PRINT_RESULT, localize_display(data));
 490     }
 491     else if (msg->btype == BTYPE_CA)
 492     {
 493         data->lvalue = 0;
 494         data->rvalue = 0;
 495         data->op = BTYPE_ADD;
 496         data->state = STATE_LEFTVAL;
 497         clear_edit_buffer(data);
 498
 499         display_state(data);
 500         if (data->tape) DoMethod(data->tape, TAPEM_NEWLINE);
 501     }
 502     else if (msg->btype == BTYPE_CE &&
 503              (data->state == STATE_LEFTVAL || data->state == STATE_RIGHTVAL))
 504     {
 505         clear_edit_buffer(data);
 506         display_state(data);
 507
 508     }
 509     else if (msg->btype == BTYPE_SIGN && data->state != STATE_OP)
 510     {
 511         toggle_sign(data);
 512     }
 513     else if (msg->btype == BTYPE_BS &&
 514              (data->state == STATE_LEFTVAL || data->state == STATE_RIGHTVAL) &&
 515              data->num_digits > 0)
 516     {
 517         data->edit_buffer[--data->num_digits] = 0;
 518         display_state(data);
 519     }
 520     return (IPTR) obj;
 521 }
 522
 523 BOOPSI_DISPATCHER(IPTR, CalculatorDispatcher, cl, obj, msg)
 524 {
 525     switch (msg->MethodID)
 526     {
 527         case OM_NEW:     return mNewCalc(cl, obj, (APTR) msg);
 528         case OM_DISPOSE: return mDisposeCalc(cl, obj, (APTR) msg);
 529         case OM_ADD_KEY: return (IPTR) mAddCalcKey(cl, obj, (struct MUIMP_CalcKey *) msg);
 530     }
 531     return DoSuperMethodA(cl, obj, msg);
 532 }
 533 BOOPSI_DISPATCHER_END
 534
 535 static Class *make_calculator_class(void)
 536 {
 537     Class *cl;
 538     cl = MakeClass(NULL, ROOTCLASS, NULL, sizeof(struct CalculatorData), 0);
 539     if (cl) cl->cl_Dispatcher.h_Entry = CalculatorDispatcher;
 540     return cl;
 541 }
 542
 543 /**********************************************************************
 544  Main program
 545  **********************************************************************/
 546
 547 static void cleanup(char *msg)
 548 {
 549     WORD rc;
 550     if (msg)
 551     {
 552         fprintf(stderr, "Calculator: %s\n", msg);
 553         rc = RETURN_WARN;
 554     }
 555     else
 556     {
 557         rc = RETURN_OK;
 558     }
 559     exit(rc);
 560 }
 561
 562 static void dos_error(void)
 563 {
 564     static char tempstring[256];
 565     Fault(IoErr(), 0, tempstring, 255);
 566     cleanup(tempstring);
 567 }
 568
 569 static char retrieve_decimal_point(void)
 570 {
 571     struct Locale *loc;
 572     char result = '.';
 573
 574     if ((loc = OpenLocale(0)))
 575     {
 576           result = loc->loc_DecimalPoint[0];
 577           CloseLocale(loc);
 578     }
 579     return result;
 580 }
 581
 582 static void get_arguments(void)
 583 {
 584     struct RDArgs *rdargs;
 585     IPTR args[NUM_ARGS];
 586     int i;
 587
 588     for (i = 0; i < NUM_ARGS; i++) args[i] = (IPTR) NULL;
 589
 590     if (!(rdargs = ReadArgs(ARG_TEMPLATE, (IPTR *) args,0))) dos_error();
 591
 592     if (args[ARG_PUBSCREEN]) {
 593         strncpy(pubscrname, (const char *) args[ARG_PUBSCREEN], 255);
 594     }
 595
 596     if (args[ARG_TAPE])
 597     {
 598         use_tape = TRUE;
 599         strncpy(tapename, (const char *) args[ARG_TAPE], CALC_TAPENAME_MAX);
 600     }
 601     if (rdargs) FreeArgs(rdargs);
 602 }
 603
 604 static void open_raw_tape_if_needed(Object *window, Object *obj_tape)
 605 {
 606     if (use_tape && !strlen(tapename))
 607     {
 608         int x, y, w, h;
 609         struct Window *win;
 610         BPTR tapefh;
 611
 612         GetAttr(MUIA_Window_Window, window, (IPTR *) &win);
 613         w = win->Width * 5 / 4;
 614         h = win->Height;
 615         x = win->LeftEdge;
 616         y = win->TopEdge;
 617
 618         if (x > (win->WScreen->Width - (x + w))) x -= w;
 619         else                                     x += win->WScreen->Width;
 620
 621         snprintf(tapename, CALC_TAPENAME_MAX, RAW_TAPE_NAME, x, y, w, h, pubscrname);
 622         tapefh = Open(tapename, MODE_NEWFILE);
 623         SetAttrs(obj_tape, TAPEA_FILEHANDLE, tapefh);
 624     }
 625 }
 626
 627 int main(void)
 628 {
 629     Class *cl_calc = NULL, *cl_tape = NULL;
 630     Object *app = NULL, *window = NULL, *display = NULL, *button[NUM_BUTTONS],
 631       *obj_calc, *obj_tape;
 632     char decimal_point, decimal_label[2];
 633     struct Screen *pub_screen = NULL;
 634     BPTR tapefh = BNULL;
 635     int i;
 636
 637     get_arguments();
 638     decimal_point = retrieve_decimal_point();
 639     snprintf(decimal_label, 2, "%c", decimal_point);
 640
 641     display = TextObject,
 642         StringFrame,
 643         MUIA_Text_Contents, INITIAL_DISPLAY,
 644         MUIA_ShortHelp, "Display",
 645     End;
 646
 647     cl_tape = make_tape_class();
 648
 649     if (use_tape && strlen(tapename)) {
 650       tapefh = Open(tapename, MODE_NEWFILE);
 651     }
 652
 653     if (tapefh) {
 654       obj_tape = NewObject(cl_tape, NULL, TAPEA_FILEHANDLE, tapefh, TAG_DONE);
 655     }
 656     else
 657     {
 658       obj_tape = NewObject(cl_tape, NULL, TAG_DONE);
 659     }
 660
 661     cl_calc = make_calculator_class();
 662     obj_calc = NewObject(cl_calc, NULL,
 663                          CALCA_DISPLAY, display,
 664                          CALCA_TAPE, obj_tape,
 665                          CALCA_DECIMAL_POINT, decimal_point,
 666                          TAG_DONE);
 667
 668     for (i = 0; i < NUM_BUTTONS; i++)
 669     {
 670         button[i] = (i != DECIMAL_BUTTON_INDEX) ?
 671           SimpleButton(BUTTONS[i].label) : SimpleButton(decimal_label);
 672         if (BUTTONS[i].shortcut)
 673         {
 674             SetAttrs(button[i], MUIA_ControlChar, BUTTONS[i].shortcut, TAG_DONE);
 675         }
 676     }
 677
 678     if (strlen(pubscrname))
 679     {
 680         pub_screen = LockPubScreen((CONST_STRPTR) pubscrname);
 681         if (!pub_screen)
 682         {
 683             printf("Can't lock public screen '%s' -> fallback to Wanderer!\n", pubscrname);
 684             memset(pubscrname, 0, 256);
 685             strcpy(pubscrname, "Workbench");
 686             pub_screen = LockPubScreen((CONST_STRPTR) pubscrname);
 687         }
 688     }
 689
 690     app = ApplicationObject,
 691           MUIA_Application_Title, "Calculator",
 692           MUIA_Application_Version, "1.5",
 693           MUIA_Application_Copyright, "©2007-2018, AROS Dev Team",
 694           MUIA_Application_Author, "AROS Team",
 695           MUIA_Application_Description, "Simple desktop calculator",
 696           MUIA_Application_Base, "calculator",
 697           SubWindow, window = WindowObject,
 698             MUIA_Window_Title, "Calculator",
 699             MUIA_Window_ID, MAKE_ID('C', 'A', 'L', 'C'),
 700             MUIA_Window_AppWindow, TRUE,
 701             MUIA_Window_Screen, pub_screen,
 702             WindowContents, VGroup,
 703               Child, display,
 704
 705               Child, HGroup, GroupSpacing(5), MUIA_Group_SameWidth, TRUE,
 706                 Child, button[0],
 707                 Child, button[1],
 708                 Child, button[2],
 709                 Child, button[3],
 710                 Child, button[4],
 711               End,
 712
 713               Child, HGroup, GroupSpacing(5), MUIA_Group_SameWidth, TRUE,
 714                 Child, button[5],
 715                 Child, button[6],
 716                 Child, button[7],
 717                 Child, button[8],
 718                 Child, button[9],
 719               End,
 720
 721               Child, HGroup, GroupSpacing(5), MUIA_Group_SameWidth, TRUE,
 722                 Child, button[10],
 723                 Child, button[11],
 724                 Child, button[12],
 725                 Child, button[13],
 726                 Child, button[14],
 727               End,
 728
 729               Child, HGroup, GroupSpacing(5), MUIA_Group_SameWidth, TRUE,
 730                 Child, button[15],
 731                 Child, button[16],
 732                 Child, button[17],
 733                 Child, button[18],
 734                 Child, button[19],
 735               End,
 736
 737             End,
 738           End,
 739         End;
 740
 741     DoMethod(window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 742              app, 2, MUIM_Application_ReturnID,
 743              MUIV_Application_ReturnID_Quit);
 744
 745     for (i = 0; i < NUM_BUTTONS; i++)
 746     {
 747         DoMethod(button[i], MUIM_Notify, MUIA_Pressed, FALSE,
 748                  obj_calc, 2, OM_ADD_KEY, BUTTONS[i].btype);
 749     }
 750
 751     SetAttrs(window, MUIA_Window_Open, TRUE, TAG_DONE);
 752     open_raw_tape_if_needed(window, obj_tape);
 753
 754     if (pub_screen) UnlockPubScreen(0, pub_screen);
 755     {
 756         BOOL running = TRUE;
 757         ULONG sigs = 0, id;
 758
 759         while (running) {
 760             id = DoMethod(app, MUIM_Application_NewInput, (IPTR) &sigs);
 761
 762             switch(id)
 763             {
 764                 case MUIV_Application_ReturnID_Quit:
 765                     running = FALSE;
 766                     break;
 767                 default:
 768                     break;
 769             }
 770             if (running && sigs)
 771             {
 772                 sigs = Wait(sigs | SIGBREAKF_CTRL_C);
 773                 if (sigs & SIGBREAKF_CTRL_C) break;
 774             }
 775         }
 776     }
 777     set((APTR) window, MUIA_Window_Open, FALSE);
 778     MUI_DisposeObject(app);
 779
 780     DisposeObject(obj_calc);
 781     DisposeObject(obj_tape);
 782     FreeClass(cl_calc);
 783     FreeClass(cl_tape);
 784
 785     cleanup(NULL);
 786     return 0;
 787 }