uspace/app/calculator/calculator.c

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