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