source: mainline/uspace/app/calculator/calculator.c@ 45004f3

serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 45004f3 was 45004f3, checked in by Jiri Svoboda <jiri@…>, 4 years ago

Text-style window title bar
  • Property mode set to 100644
File size: 21.7 KB
Line 
1/*
2 * Copyright (c) 2021 Jiri Svoboda
3 * Copyright (c) 2016 Martin Decky
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup calculator
31 * @{
32 */
33/** @file
34 *
35 * Inspired by the code released at https://github.com/osgroup/HelenOSProject
36 *
37 */
38
39#include <clipboard.h>
40#include <ctype.h>
41#include <io/kbd_event.h>
42#include <stdbool.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <str.h>
46#include <ui/entry.h>
47#include <ui/fixed.h>
48#include <ui/menubar.h>
49#include <ui/menu.h>
50#include <ui/menuentry.h>
51#include <ui/pbutton.h>
52#include <ui/ui.h>
53#include <ui/window.h>
54
55#define NAME "calculator"
56
57#define NULL_DISPLAY "0"
58
59#define SYNTAX_ERROR_DISPLAY "Syntax error"
60#define NUMERIC_ERROR_DISPLAY "Numerical error"
61#define UNKNOWN_ERROR_DISPLAY "Unknown error"
62
63#define EXPR_MAX_LEN 22
64
65typedef enum {
66 STATE_INITIAL = 0,
67 STATE_FINISH,
68 STATE_ERROR,
69 STATE_DIGIT,
70 STATE_VALUE
71} parser_state_t;
72
73typedef enum {
74 ERROR_SYNTAX = 0,
75 ERROR_NUMERIC
76} error_type_t;
77
78typedef enum {
79 OPERATOR_NONE = 0,
80 OPERATOR_ADD,
81 OPERATOR_SUB,
82 OPERATOR_MUL,
83 OPERATOR_DIV
84} operator_t;
85
86typedef enum {
87 ITEM_VALUE = 0,
88 ITEM_OPERATOR
89} stack_item_type_t;
90
91typedef struct {
92 link_t link;
93
94 stack_item_type_t type;
95 union {
96 int64_t value;
97 operator_t operator;
98 } data;
99} stack_item_t;
100
101/** Dimensions. Most of this should not be needed with auto layout */
102typedef struct {
103 gfx_rect_t menubar_rect;
104 gfx_rect_t entry_rect;
105 gfx_coord2_t btn_orig;
106 gfx_coord2_t btn_stride;
107 gfx_coord2_t btn_dim;
108} calc_geom_t;
109
110typedef struct {
111 ui_t *ui;
112 ui_resource_t *ui_res;
113 ui_pbutton_t *btn_eval;
114 ui_pbutton_t *btn_clear;
115 ui_pbutton_t *btn_add;
116 ui_pbutton_t *btn_sub;
117 ui_pbutton_t *btn_mul;
118 ui_pbutton_t *btn_div;
119 ui_pbutton_t *btn_0;
120 ui_pbutton_t *btn_1;
121 ui_pbutton_t *btn_2;
122 ui_pbutton_t *btn_3;
123 ui_pbutton_t *btn_4;
124 ui_pbutton_t *btn_5;
125 ui_pbutton_t *btn_6;
126 ui_pbutton_t *btn_7;
127 ui_pbutton_t *btn_8;
128 ui_pbutton_t *btn_9;
129 ui_menu_bar_t *menubar;
130 calc_geom_t geom;
131} calc_t;
132
133static void display_update(void);
134
135static void calc_file_exit(ui_menu_entry_t *, void *);
136static void calc_edit_copy(ui_menu_entry_t *, void *);
137static void calc_edit_paste(ui_menu_entry_t *, void *);
138
139static void calc_pb_clicked(ui_pbutton_t *, void *);
140static void calc_eval_clicked(ui_pbutton_t *, void *);
141static void calc_clear_clicked(ui_pbutton_t *, void *);
142
143static ui_pbutton_cb_t calc_pbutton_cb = {
144 .clicked = calc_pb_clicked
145};
146
147static ui_pbutton_cb_t calc_clear_cb = {
148 .clicked = calc_clear_clicked
149};
150
151static ui_pbutton_cb_t calc_eval_cb = {
152 .clicked = calc_eval_clicked
153};
154
155static void wnd_close(ui_window_t *, void *);
156static void wnd_kbd_event(ui_window_t *, void *, kbd_event_t *);
157
158static ui_window_cb_t window_cb = {
159 .close = wnd_close,
160 .kbd = wnd_kbd_event
161};
162
163static char *expr = NULL;
164static ui_entry_t *display;
165
166/** Window close request
167 *
168 * @param window Window
169 * @param arg Argument (calc_t *)
170 */
171static void wnd_close(ui_window_t *window, void *arg)
172{
173 calc_t *calc = (calc_t *) arg;
174
175 ui_quit(calc->ui);
176}
177
178/** Window keyboard event
179 *
180 * @param window Window
181 * @param arg Argument (calc_t *)
182 * @param event Keyboard event
183 */
184static void wnd_kbd_event(ui_window_t *window, void *arg, kbd_event_t *event)
185{
186 calc_t *calc = (calc_t *) arg;
187
188 if (event->type == KEY_PRESS && (event->mods & KM_CTRL) != 0) {
189 switch (event->key) {
190 case KC_C:
191 calc_edit_copy(NULL, calc);
192 break;
193 case KC_V:
194 calc_edit_paste(NULL, calc);
195 break;
196 default:
197 break;
198 }
199 }
200
201 switch (event->key) {
202 case KC_ENTER:
203 if (event->type == KEY_PRESS)
204 ui_pbutton_press(calc->btn_eval);
205 else
206 ui_pbutton_release(calc->btn_eval);
207 break;
208 case KC_BACKSPACE:
209 if (event->type == KEY_PRESS)
210 ui_pbutton_press(calc->btn_clear);
211 else
212 ui_pbutton_release(calc->btn_clear);
213 break;
214 case KC_MINUS:
215 if (event->type == KEY_PRESS)
216 ui_pbutton_press(calc->btn_sub);
217 else
218 ui_pbutton_release(calc->btn_sub);
219 break;
220 case KC_EQUALS:
221 if (event->type == KEY_PRESS)
222 ui_pbutton_press(calc->btn_add);
223 else
224 ui_pbutton_release(calc->btn_add);
225 break;
226 case KC_SLASH:
227 if (event->type == KEY_PRESS)
228 ui_pbutton_press(calc->btn_div);
229 else
230 ui_pbutton_release(calc->btn_div);
231 break;
232 case KC_0:
233 if (event->type == KEY_PRESS)
234 ui_pbutton_press(calc->btn_0);
235 else
236 ui_pbutton_release(calc->btn_0);
237 break;
238 case KC_1:
239 if (event->type == KEY_PRESS)
240 ui_pbutton_press(calc->btn_1);
241 else
242 ui_pbutton_release(calc->btn_1);
243 break;
244 case KC_2:
245 if (event->type == KEY_PRESS)
246 ui_pbutton_press(calc->btn_2);
247 else
248 ui_pbutton_release(calc->btn_2);
249 break;
250 case KC_3:
251 if (event->type == KEY_PRESS)
252 ui_pbutton_press(calc->btn_3);
253 else
254 ui_pbutton_release(calc->btn_3);
255 break;
256 case KC_4:
257 if (event->type == KEY_PRESS)
258 ui_pbutton_press(calc->btn_4);
259 else
260 ui_pbutton_release(calc->btn_4);
261 break;
262 case KC_5:
263 if (event->type == KEY_PRESS)
264 ui_pbutton_press(calc->btn_5);
265 else
266 ui_pbutton_release(calc->btn_5);
267 break;
268 case KC_6:
269 if (event->type == KEY_PRESS)
270 ui_pbutton_press(calc->btn_6);
271 else
272 ui_pbutton_release(calc->btn_6);
273 break;
274 case KC_7:
275 if (event->type == KEY_PRESS)
276 ui_pbutton_press(calc->btn_7);
277 else
278 ui_pbutton_release(calc->btn_7);
279 break;
280 case KC_8:
281 if ((event->mods & KM_SHIFT) != 0) {
282 if (event->type == KEY_PRESS)
283 ui_pbutton_press(calc->btn_mul);
284 else
285 ui_pbutton_release(calc->btn_mul);
286 } else {
287 if (event->type == KEY_PRESS)
288 ui_pbutton_press(calc->btn_8);
289 else
290 ui_pbutton_release(calc->btn_8);
291 }
292 break;
293 case KC_9:
294 if (event->type == KEY_PRESS)
295 ui_pbutton_press(calc->btn_9);
296 else
297 ui_pbutton_release(calc->btn_9);
298 break;
299 default:
300 break;
301 }
302}
303
304/** File / Exit menu entry selected.
305 *
306 * @param mentry Menu entry
307 * @param arg Argument (calc_t *)
308 */
309static void calc_file_exit(ui_menu_entry_t *mentry, void *arg)
310{
311 calc_t *calc = (calc_t *) arg;
312
313 ui_quit(calc->ui);
314}
315
316/** Edit / Copy menu entry selected.
317 *
318 * @param mentry Menu entry
319 * @param arg Argument (calc_t *)
320 */
321static void calc_edit_copy(ui_menu_entry_t *mentry, void *arg)
322{
323 const char *str;
324
325 (void) arg;
326 str = (expr != NULL) ? expr : NULL_DISPLAY;
327
328 (void) clipboard_put_str(str);
329}
330
331/** Edit / Paste menu entry selected.
332 *
333 * @param mentry Menu entry
334 * @param arg Argument (calc_t *)
335 */
336static void calc_edit_paste(ui_menu_entry_t *mentry, void *arg)
337{
338 char *str;
339 char *old;
340 char *cp;
341 errno_t rc;
342
343 (void) arg;
344
345 rc = clipboard_get_str(&str);
346 if (rc != EOK)
347 return;
348
349 /* Make sure string only contains allowed characters */
350 cp = str;
351 while (*cp != '\0') {
352 if (!isdigit(*cp) && *cp != '+' && *cp != '-' &&
353 *cp != '*' && *cp != '/')
354 return;
355 ++cp;
356 }
357
358 /* Update expression */
359 old = expr;
360 expr = str;
361 free(old);
362
363 display_update();
364}
365
366static bool is_digit(char c)
367{
368 return ((c >= '0') && (c <= '9'));
369}
370
371static int get_digit(char c)
372{
373 assert(is_digit(c));
374
375 return (c - '0');
376}
377
378static bool is_plus(char c)
379{
380 return (c == '+');
381}
382
383static bool is_minus(char c)
384{
385 return (c == '-');
386}
387
388static bool is_finish(char c)
389{
390 return (c == 0);
391}
392
393static operator_t get_operator(char c)
394{
395 switch (c) {
396 case '+':
397 return OPERATOR_ADD;
398 case '-':
399 return OPERATOR_SUB;
400 case '*':
401 return OPERATOR_MUL;
402 case '/':
403 return OPERATOR_DIV;
404 default:
405 return OPERATOR_NONE;
406 }
407}
408
409static bool is_operator(char c)
410{
411 return (get_operator(c) != OPERATOR_NONE);
412}
413
414static bool stack_push_value(list_t *stack, int64_t value, bool value_neg)
415{
416 stack_item_t *item = malloc(sizeof(stack_item_t));
417 if (!item)
418 return false;
419
420 link_initialize(&item->link);
421 item->type = ITEM_VALUE;
422
423 if (value_neg)
424 item->data.value = -value;
425 else
426 item->data.value = value;
427
428 list_prepend(&item->link, stack);
429
430 return true;
431}
432
433static bool stack_push_operator(list_t *stack, operator_t operator)
434{
435 stack_item_t *item = malloc(sizeof(stack_item_t));
436 if (!item)
437 return false;
438
439 link_initialize(&item->link);
440 item->type = ITEM_OPERATOR;
441 item->data.operator = operator;
442 list_prepend(&item->link, stack);
443
444 return true;
445}
446
447static bool stack_pop_value(list_t *stack, int64_t *value)
448{
449 link_t *link = list_first(stack);
450 if (!link)
451 return false;
452
453 stack_item_t *item = list_get_instance(link, stack_item_t, link);
454 if (item->type != ITEM_VALUE)
455 return false;
456
457 *value = item->data.value;
458
459 list_remove(link);
460 free(item);
461
462 return true;
463}
464
465static bool stack_pop_operator(list_t *stack, operator_t *operator)
466{
467 link_t *link = list_first(stack);
468 if (!link)
469 return false;
470
471 stack_item_t *item = list_get_instance(link, stack_item_t, link);
472 if (item->type != ITEM_OPERATOR)
473 return false;
474
475 *operator = item->data.operator;
476
477 list_remove(link);
478 free(item);
479
480 return true;
481}
482
483static void stack_cleanup(list_t *stack)
484{
485 while (!list_empty(stack)) {
486 link_t *link = list_first(stack);
487 if (link) {
488 stack_item_t *item = list_get_instance(link, stack_item_t,
489 link);
490
491 list_remove(link);
492 free(item);
493 }
494 }
495}
496
497static bool compute(int64_t a, operator_t operator, int64_t b, int64_t *value)
498{
499 switch (operator) {
500 case OPERATOR_ADD:
501 *value = a + b;
502 break;
503 case OPERATOR_SUB:
504 *value = a - b;
505 break;
506 case OPERATOR_MUL:
507 *value = a * b;
508 break;
509 case OPERATOR_DIV:
510 if (b == 0)
511 return false;
512
513 *value = a / b;
514 break;
515 default:
516 return false;
517 }
518
519 return true;
520}
521
522static unsigned int get_priority(operator_t operator)
523{
524 switch (operator) {
525 case OPERATOR_ADD:
526 return 0;
527 case OPERATOR_SUB:
528 return 0;
529 case OPERATOR_MUL:
530 return 1;
531 case OPERATOR_DIV:
532 return 1;
533 default:
534 return 0;
535 }
536}
537
538static void evaluate(list_t *stack, int64_t *value, parser_state_t *state,
539 error_type_t *error_type)
540{
541 while (!list_empty(stack)) {
542 if (!stack_pop_value(stack, value)) {
543 *state = STATE_ERROR;
544 *error_type = ERROR_SYNTAX;
545 break;
546 }
547
548 if (!list_empty(stack)) {
549 operator_t operator;
550 if (!stack_pop_operator(stack, &operator)) {
551 *state = STATE_ERROR;
552 *error_type = ERROR_SYNTAX;
553 break;
554 }
555
556 int64_t value_a;
557 if (!stack_pop_value(stack, &value_a)) {
558 *state = STATE_ERROR;
559 *error_type = ERROR_SYNTAX;
560 break;
561 }
562
563 if (!compute(value_a, operator, *value, value)) {
564 *state = STATE_ERROR;
565 *error_type = ERROR_NUMERIC;
566 break;
567 }
568
569 if (!stack_push_value(stack, *value, false)) {
570 *state = STATE_ERROR;
571 *error_type = ERROR_SYNTAX;
572 break;
573 }
574 }
575 }
576}
577
578static void display_update(void)
579{
580 if (expr != NULL)
581 (void) ui_entry_set_text(display, (void *) expr);
582 else
583 (void) ui_entry_set_text(display, (void *) NULL_DISPLAY);
584
585 ui_entry_paint(display);
586}
587
588static void display_error(error_type_t error_type)
589{
590 if (expr != NULL) {
591 free(expr);
592 expr = NULL;
593 }
594
595 switch (error_type) {
596 case ERROR_SYNTAX:
597 (void) ui_entry_set_text(display,
598 (void *) SYNTAX_ERROR_DISPLAY);
599 break;
600 case ERROR_NUMERIC:
601 (void) ui_entry_set_text(display,
602 (void *) NUMERIC_ERROR_DISPLAY);
603 break;
604 default:
605 (void) ui_entry_set_text(display,
606 (void *) UNKNOWN_ERROR_DISPLAY);
607 break;
608 }
609
610 ui_entry_paint(display);
611}
612
613static void calc_pb_clicked(ui_pbutton_t *pbutton, void *arg)
614{
615 const char *subexpr = (const char *) arg;
616
617 if (expr != NULL) {
618 char *new_expr;
619
620 if (str_length(expr) < EXPR_MAX_LEN) {
621 asprintf(&new_expr, "%s%s", expr, subexpr);
622 free(expr);
623 expr = new_expr;
624 }
625 } else {
626 expr = str_dup(subexpr);
627 }
628
629 display_update();
630}
631
632static void calc_clear_clicked(ui_pbutton_t *pbutton, void *arg)
633{
634 if (expr != NULL) {
635 free(expr);
636 expr = NULL;
637 }
638
639 display_update();
640}
641
642static void calc_eval_clicked(ui_pbutton_t *pbutton, void *arg)
643{
644 if (expr == NULL)
645 return;
646
647 list_t stack;
648 list_initialize(&stack);
649
650 error_type_t error_type = ERROR_SYNTAX;
651 size_t i = 0;
652 parser_state_t state = STATE_INITIAL;
653 int64_t value = 0;
654 bool value_neg = false;
655 operator_t last_operator = OPERATOR_NONE;
656
657 while ((state != STATE_FINISH) && (state != STATE_ERROR)) {
658 switch (state) {
659 case STATE_INITIAL:
660 if (is_digit(expr[i])) {
661 value = get_digit(expr[i]);
662 i++;
663 state = STATE_VALUE;
664 } else if (is_plus(expr[i])) {
665 i++;
666 value_neg = false;
667 state = STATE_DIGIT;
668 } else if (is_minus(expr[i])) {
669 i++;
670 value_neg = true;
671 state = STATE_DIGIT;
672 } else
673 state = STATE_ERROR;
674 break;
675
676 case STATE_DIGIT:
677 if (is_digit(expr[i])) {
678 value = get_digit(expr[i]);
679 i++;
680 state = STATE_VALUE;
681 } else
682 state = STATE_ERROR;
683 break;
684
685 case STATE_VALUE:
686 if (is_digit(expr[i])) {
687 value *= 10;
688 value += get_digit(expr[i]);
689 i++;
690 } else if (is_operator(expr[i])) {
691 if (!stack_push_value(&stack, value, value_neg)) {
692 state = STATE_ERROR;
693 break;
694 }
695
696 value = 0;
697 value_neg = false;
698
699 operator_t operator = get_operator(expr[i]);
700
701 if (get_priority(operator) <= get_priority(last_operator)) {
702 evaluate(&stack, &value, &state, &error_type);
703 if (state == STATE_ERROR)
704 break;
705
706 if (!stack_push_value(&stack, value, value_neg)) {
707 state = STATE_ERROR;
708 break;
709 }
710 }
711
712 if (!stack_push_operator(&stack, operator)) {
713 state = STATE_ERROR;
714 break;
715 }
716
717 last_operator = operator;
718 i++;
719 state = STATE_DIGIT;
720 } else if (is_finish(expr[i])) {
721 if (!stack_push_value(&stack, value, value_neg)) {
722 state = STATE_ERROR;
723 break;
724 }
725
726 state = STATE_FINISH;
727 } else
728 state = STATE_ERROR;
729 break;
730
731 default:
732 state = STATE_ERROR;
733 }
734 }
735
736 evaluate(&stack, &value, &state, &error_type);
737 stack_cleanup(&stack);
738
739 if (state == STATE_ERROR) {
740 display_error(error_type);
741 return;
742 }
743
744 free(expr);
745 asprintf(&expr, "%" PRId64, value);
746 display_update();
747}
748
749static errno_t calc_button_create(calc_t *calc, ui_fixed_t *fixed,
750 int x, int y, const char *text, ui_pbutton_cb_t *cb, void *arg,
751 ui_pbutton_t **rbutton)
752{
753 ui_pbutton_t *pb;
754 gfx_rect_t rect;
755 errno_t rc;
756
757 rc = ui_pbutton_create(calc->ui_res, text, &pb);
758 if (rc != EOK) {
759 printf("Error creating button.\n");
760 return rc;
761 }
762
763 ui_pbutton_set_cb(pb, cb, arg);
764
765 rect.p0.x = calc->geom.btn_orig.x + calc->geom.btn_stride.x * x;
766 rect.p0.y = calc->geom.btn_orig.y + calc->geom.btn_stride.y * y;
767 rect.p1.x = rect.p0.x + calc->geom.btn_dim.x;
768 rect.p1.y = rect.p0.y + calc->geom.btn_dim.y;
769 ui_pbutton_set_rect(pb, &rect);
770
771 rc = ui_fixed_add(fixed, ui_pbutton_ctl(pb));
772 if (rc != EOK) {
773 printf("Error adding control to layout.\n");
774 return rc;
775 }
776
777 if (rbutton != NULL)
778 *rbutton = pb;
779 return EOK;
780}
781
782static void print_syntax(void)
783{
784 printf("Syntax: %s [-d <display-spec>]\n", NAME);
785}
786
787int main(int argc, char *argv[])
788{
789 const char *display_spec = UI_DISPLAY_DEFAULT;
790 ui_t *ui;
791 ui_resource_t *ui_res;
792 ui_fixed_t *fixed;
793 ui_wnd_params_t params;
794 ui_window_t *window;
795 ui_menu_t *mfile;
796 ui_menu_entry_t *mexit;
797 ui_menu_t *medit;
798 ui_menu_entry_t *mcopy;
799 ui_menu_entry_t *mpaste;
800 calc_t calc;
801 errno_t rc;
802 int i;
803
804 i = 1;
805 while (i < argc) {
806 if (str_cmp(argv[i], "-d") == 0) {
807 ++i;
808 if (i >= argc) {
809 printf("Argument missing.\n");
810 print_syntax();
811 return 1;
812 }
813
814 display_spec = argv[i++];
815 } else {
816 printf("Invalid option '%s'.\n", argv[i]);
817 print_syntax();
818 return 1;
819 }
820 }
821
822 rc = ui_create(display_spec, &ui);
823 if (rc != EOK) {
824 printf("Error creating UI on display %s.\n", display_spec);
825 return rc;
826 }
827
828 ui_wnd_params_init(&params);
829 params.caption = "Calculator";
830 params.rect.p0.x = 0;
831 params.rect.p0.y = 0;
832
833 if (ui_is_textmode(ui)) {
834 params.rect.p1.x = 38;
835 params.rect.p1.y = 18;
836
837 calc.geom.menubar_rect.p0.x = 1;
838 calc.geom.menubar_rect.p0.y = 1;
839 calc.geom.menubar_rect.p1.x = params.rect.p1.x - 1;
840 calc.geom.menubar_rect.p1.y = 2;
841 calc.geom.entry_rect.p0.x = 4;
842 calc.geom.entry_rect.p0.y = 3;
843 calc.geom.entry_rect.p1.x = 34;
844 calc.geom.entry_rect.p1.y = 4;
845 calc.geom.btn_orig.x = 4;
846 calc.geom.btn_orig.y = 5;
847 calc.geom.btn_dim.x = 6;
848 calc.geom.btn_dim.y = 2;
849 calc.geom.btn_stride.x = 8;
850 calc.geom.btn_stride.y = 3;
851 } else {
852 params.rect.p1.x = 250;
853 params.rect.p1.y = 270;
854
855 calc.geom.menubar_rect.p0.x = 4;
856 calc.geom.menubar_rect.p0.y = 30;
857 calc.geom.menubar_rect.p1.x = params.rect.p1.x - 4;
858 calc.geom.menubar_rect.p1.y = 52;
859 calc.geom.entry_rect.p0.x = 10;
860 calc.geom.entry_rect.p0.y = 51;
861 calc.geom.entry_rect.p1.x = 240;
862 calc.geom.entry_rect.p1.y = 76;
863 calc.geom.btn_orig.x = 10;
864 calc.geom.btn_orig.y = 90;
865 calc.geom.btn_dim.x = 50;
866 calc.geom.btn_dim.y = 35;
867 calc.geom.btn_stride.x = 60;
868 calc.geom.btn_stride.y = 45;
869 }
870
871 rc = ui_window_create(ui, &params, &window);
872 if (rc != EOK) {
873 printf("Error creating window.\n");
874 return rc;
875 }
876
877 ui_window_set_cb(window, &window_cb, (void *) &calc);
878 calc.ui = ui;
879
880 ui_res = ui_window_get_res(window);
881 calc.ui_res = ui_res;
882
883 rc = ui_fixed_create(&fixed);
884 if (rc != EOK) {
885 printf("Error creating fixed layout.\n");
886 return rc;
887 }
888
889 rc = ui_menu_bar_create(ui, window, &calc.menubar);
890 if (rc != EOK) {
891 printf("Error creating menu bar.\n");
892 return rc;
893 }
894
895 rc = ui_menu_create(calc.menubar, "File", &mfile);
896 if (rc != EOK) {
897 printf("Error creating menu.\n");
898 return rc;
899 }
900
901 rc = ui_menu_entry_create(mfile, "Exit", "Alt-F4", &mexit);
902 if (rc != EOK) {
903 printf("Error creating menu.\n");
904 return rc;
905 }
906
907 ui_menu_entry_set_cb(mexit, calc_file_exit, (void *) &calc);
908
909 rc = ui_menu_create(calc.menubar, "Edit", &medit);
910 if (rc != EOK) {
911 printf("Error creating menu.\n");
912 return rc;
913 }
914
915 rc = ui_menu_entry_create(medit, "Copy", "Ctrl-C", &mcopy);
916 if (rc != EOK) {
917 printf("Error creating menu.\n");
918 return rc;
919 }
920
921 ui_menu_entry_set_cb(mcopy, calc_edit_copy, (void *) &calc);
922
923 rc = ui_menu_entry_create(medit, "Paste", "Ctrl-V", &mpaste);
924 if (rc != EOK) {
925 printf("Error creating menu.\n");
926 return rc;
927 }
928
929 ui_menu_entry_set_cb(mpaste, calc_edit_paste, (void *) &calc);
930
931 ui_menu_bar_set_rect(calc.menubar, &calc.geom.menubar_rect);
932
933 rc = ui_fixed_add(fixed, ui_menu_bar_ctl(calc.menubar));
934 if (rc != EOK) {
935 printf("Error adding control to layout.\n");
936 return rc;
937 }
938
939 rc = ui_entry_create(window, NULL_DISPLAY, &display);
940 if (rc != EOK) {
941 printf("Error creating text lentry.\n");
942 return rc;
943 }
944
945 ui_entry_set_rect(display, &calc.geom.entry_rect);
946 ui_entry_set_halign(display, gfx_halign_right);
947 ui_entry_set_read_only(display, true);
948
949 rc = ui_fixed_add(fixed, ui_entry_ctl(display));
950 if (rc != EOK) {
951 printf("Error adding control to layout.\n");
952 return rc;
953 }
954
955 rc = calc_button_create(&calc, fixed, 0, 0, "7", &calc_pbutton_cb,
956 (void *) "7", &calc.btn_7);
957 if (rc != EOK)
958 return rc;
959
960 rc = calc_button_create(&calc, fixed, 1, 0, "8", &calc_pbutton_cb,
961 (void *) "8", &calc.btn_8);
962 if (rc != EOK)
963 return rc;
964
965 rc = calc_button_create(&calc, fixed, 2, 0, "9", &calc_pbutton_cb,
966 (void *) "9", &calc.btn_9);
967 if (rc != EOK)
968 return rc;
969
970 rc = calc_button_create(&calc, fixed, 3, 0, "/", &calc_pbutton_cb,
971 (void *) "/", &calc.btn_div);
972 if (rc != EOK)
973 return rc;
974
975 rc = calc_button_create(&calc, fixed, 0, 1, "4", &calc_pbutton_cb,
976 (void *) "4", &calc.btn_4);
977 if (rc != EOK)
978 return rc;
979
980 rc = calc_button_create(&calc, fixed, 1, 1, "5", &calc_pbutton_cb,
981 (void *) "5", &calc.btn_5);
982 if (rc != EOK)
983 return rc;
984
985 rc = calc_button_create(&calc, fixed, 2, 1, "6", &calc_pbutton_cb,
986 (void *) "6", &calc.btn_6);
987 if (rc != EOK)
988 return rc;
989
990 rc = calc_button_create(&calc, fixed, 3, 1, "*", &calc_pbutton_cb,
991 (void *) "*", &calc.btn_mul);
992 if (rc != EOK)
993 return rc;
994
995 rc = calc_button_create(&calc, fixed, 0, 2, "1", &calc_pbutton_cb,
996 (void *) "1", &calc.btn_1);
997 if (rc != EOK)
998 return rc;
999
1000 rc = calc_button_create(&calc, fixed, 1, 2, "2", &calc_pbutton_cb,
1001 (void *) "2", &calc.btn_2);
1002 if (rc != EOK)
1003 return rc;
1004
1005 rc = calc_button_create(&calc, fixed, 2, 2, "3", &calc_pbutton_cb,
1006 (void *) "3", &calc.btn_3);
1007 if (rc != EOK)
1008 return rc;
1009
1010 rc = calc_button_create(&calc, fixed, 3, 2, "-", &calc_pbutton_cb,
1011 (void *) "-", &calc.btn_sub);
1012 if (rc != EOK)
1013 return rc;
1014
1015 rc = calc_button_create(&calc, fixed, 0, 3, "0", &calc_pbutton_cb,
1016 (void *) "0", &calc.btn_0);
1017 if (rc != EOK)
1018 return rc;
1019
1020 rc = calc_button_create(&calc, fixed, 1, 3, "C", &calc_clear_cb,
1021 (void *) "C", &calc.btn_clear);
1022 if (rc != EOK)
1023 return rc;
1024
1025 rc = calc_button_create(&calc, fixed, 2, 3, "=", &calc_eval_cb,
1026 (void *) "=", &calc.btn_eval);
1027 if (rc != EOK)
1028 return rc;
1029
1030 rc = calc_button_create(&calc, fixed, 3, 3, "+", &calc_pbutton_cb,
1031 (void *) "+", &calc.btn_add);
1032 if (rc != EOK)
1033 return rc;
1034
1035 ui_pbutton_set_default(calc.btn_eval, true);
1036
1037 ui_window_add(window, ui_fixed_ctl(fixed));
1038
1039 rc = ui_window_paint(window);
1040 if (rc != EOK) {
1041 printf("Error painting window.\n");
1042 return rc;
1043 }
1044
1045 ui_run(ui);
1046 ui_window_destroy(window);
1047 ui_destroy(ui);
1048
1049 return 0;
1050}
Note: See TracBrowser for help on using the repository browser.