[bdfdc51c] | 1 | /*
|
---|
[46bd63c9] | 2 | * Copyright (c) 2023 Jiri Svoboda
|
---|
[bdfdc51c] | 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 |
|
---|
[6dca10f] | 30 | /** @addtogroup calculator
|
---|
[bdfdc51c] | 31 | * @{
|
---|
| 32 | */
|
---|
| 33 | /** @file
|
---|
| 34 | *
|
---|
| 35 | * Inspired by the code released at https://github.com/osgroup/HelenOSProject
|
---|
| 36 | *
|
---|
| 37 | */
|
---|
| 38 |
|
---|
[1746ede] | 39 | #include <clipboard.h>
|
---|
[b41564c] | 40 | #include <ctype.h>
|
---|
[d942ca4] | 41 | #include <io/kbd_event.h>
|
---|
[bdfdc51c] | 42 | #include <stdbool.h>
|
---|
| 43 | #include <stdio.h>
|
---|
[38d150e] | 44 | #include <stdlib.h>
|
---|
[bdfdc51c] | 45 | #include <str.h>
|
---|
[03145ee] | 46 | #include <ui/entry.h>
|
---|
[b41564c] | 47 | #include <ui/fixed.h>
|
---|
[1746ede] | 48 | #include <ui/menu.h>
|
---|
[46bd63c9] | 49 | #include <ui/menubar.h>
|
---|
| 50 | #include <ui/menudd.h>
|
---|
[1746ede] | 51 | #include <ui/menuentry.h>
|
---|
[b41564c] | 52 | #include <ui/pbutton.h>
|
---|
| 53 | #include <ui/ui.h>
|
---|
| 54 | #include <ui/window.h>
|
---|
[bdfdc51c] | 55 |
|
---|
[6dca10f] | 56 | #define NAME "calculator"
|
---|
[bdfdc51c] | 57 |
|
---|
[b41564c] | 58 | #define NULL_DISPLAY "0"
|
---|
[bdfdc51c] | 59 |
|
---|
[b41564c] | 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
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 94 |
|
---|
[bdfdc51c] | 95 | stack_item_type_t type;
|
---|
| 96 | union {
|
---|
| 97 | int64_t value;
|
---|
| 98 | operator_t operator;
|
---|
| 99 | } data;
|
---|
| 100 | } stack_item_t;
|
---|
| 101 |
|
---|
[9c7dc8e] | 102 | /** Dimensions. Most of this should not be needed with auto layout */
|
---|
| 103 | typedef struct {
|
---|
[1746ede] | 104 | gfx_rect_t menubar_rect;
|
---|
[9c7dc8e] | 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 |
|
---|
[b41564c] | 111 | typedef struct {
|
---|
| 112 | ui_t *ui;
|
---|
[9c7dc8e] | 113 | ui_resource_t *ui_res;
|
---|
[d942ca4] | 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;
|
---|
[1746ede] | 130 | ui_menu_bar_t *menubar;
|
---|
[9c7dc8e] | 131 | calc_geom_t geom;
|
---|
[b41564c] | 132 | } calc_t;
|
---|
| 133 |
|
---|
[1746ede] | 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 |
|
---|
[b41564c] | 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 *);
|
---|
[d942ca4] | 157 | static void wnd_kbd_event(ui_window_t *, void *, kbd_event_t *);
|
---|
[b41564c] | 158 |
|
---|
| 159 | static ui_window_cb_t window_cb = {
|
---|
[d942ca4] | 160 | .close = wnd_close,
|
---|
| 161 | .kbd = wnd_kbd_event
|
---|
[b41564c] | 162 | };
|
---|
| 163 |
|
---|
[1746ede] | 164 | static char *expr = NULL;
|
---|
| 165 | static ui_entry_t *display;
|
---|
| 166 |
|
---|
[d942ca4] | 167 | /** Window close request
|
---|
[b41564c] | 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 |
|
---|
[d942ca4] | 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 |
|
---|
[5de852c] | 189 | if (ui_window_def_kbd(window, event) == ui_claimed)
|
---|
| 190 | return;
|
---|
| 191 |
|
---|
[1746ede] | 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 |
|
---|
[d942ca4] | 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 |
|
---|
[1746ede] | 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 | }
|
---|
[bdfdc51c] | 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));
|
---|
[a35b458] | 378 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 423 |
|
---|
[bdfdc51c] | 424 | link_initialize(&item->link);
|
---|
| 425 | item->type = ITEM_VALUE;
|
---|
[a35b458] | 426 |
|
---|
[bdfdc51c] | 427 | if (value_neg)
|
---|
| 428 | item->data.value = -value;
|
---|
| 429 | else
|
---|
| 430 | item->data.value = value;
|
---|
[a35b458] | 431 |
|
---|
[bdfdc51c] | 432 | list_prepend(&item->link, stack);
|
---|
[a35b458] | 433 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 442 |
|
---|
[bdfdc51c] | 443 | link_initialize(&item->link);
|
---|
| 444 | item->type = ITEM_OPERATOR;
|
---|
| 445 | item->data.operator = operator;
|
---|
| 446 | list_prepend(&item->link, stack);
|
---|
[a35b458] | 447 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 456 |
|
---|
[bdfdc51c] | 457 | stack_item_t *item = list_get_instance(link, stack_item_t, link);
|
---|
| 458 | if (item->type != ITEM_VALUE)
|
---|
| 459 | return false;
|
---|
[a35b458] | 460 |
|
---|
[bdfdc51c] | 461 | *value = item->data.value;
|
---|
[a35b458] | 462 |
|
---|
[bdfdc51c] | 463 | list_remove(link);
|
---|
| 464 | free(item);
|
---|
[a35b458] | 465 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 474 |
|
---|
[bdfdc51c] | 475 | stack_item_t *item = list_get_instance(link, stack_item_t, link);
|
---|
| 476 | if (item->type != ITEM_OPERATOR)
|
---|
| 477 | return false;
|
---|
[a35b458] | 478 |
|
---|
[bdfdc51c] | 479 | *operator = item->data.operator;
|
---|
[a35b458] | 480 |
|
---|
[bdfdc51c] | 481 | list_remove(link);
|
---|
| 482 | free(item);
|
---|
[a35b458] | 483 |
|
---|
[bdfdc51c] | 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);
|
---|
[a35b458] | 494 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 516 |
|
---|
[bdfdc51c] | 517 | *value = a / b;
|
---|
| 518 | break;
|
---|
| 519 | default:
|
---|
| 520 | return false;
|
---|
| 521 | }
|
---|
[a35b458] | 522 |
|
---|
[bdfdc51c] | 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 | }
|
---|
[a35b458] | 551 |
|
---|
[bdfdc51c] | 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 | }
|
---|
[a35b458] | 559 |
|
---|
[bdfdc51c] | 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 | }
|
---|
[a35b458] | 566 |
|
---|
[bdfdc51c] | 567 | if (!compute(value_a, operator, *value, value)) {
|
---|
| 568 | *state = STATE_ERROR;
|
---|
| 569 | *error_type = ERROR_NUMERIC;
|
---|
| 570 | break;
|
---|
| 571 | }
|
---|
[a35b458] | 572 |
|
---|
[bdfdc51c] | 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)
|
---|
[03145ee] | 585 | (void) ui_entry_set_text(display, (void *) expr);
|
---|
[bdfdc51c] | 586 | else
|
---|
[03145ee] | 587 | (void) ui_entry_set_text(display, (void *) NULL_DISPLAY);
|
---|
[b41564c] | 588 |
|
---|
[03145ee] | 589 | ui_entry_paint(display);
|
---|
[bdfdc51c] | 590 | }
|
---|
| 591 |
|
---|
| 592 | static void display_error(error_type_t error_type)
|
---|
| 593 | {
|
---|
| 594 | if (expr != NULL) {
|
---|
| 595 | free(expr);
|
---|
| 596 | expr = NULL;
|
---|
| 597 | }
|
---|
[a35b458] | 598 |
|
---|
[bdfdc51c] | 599 | switch (error_type) {
|
---|
| 600 | case ERROR_SYNTAX:
|
---|
[03145ee] | 601 | (void) ui_entry_set_text(display,
|
---|
[b41564c] | 602 | (void *) SYNTAX_ERROR_DISPLAY);
|
---|
[bdfdc51c] | 603 | break;
|
---|
| 604 | case ERROR_NUMERIC:
|
---|
[03145ee] | 605 | (void) ui_entry_set_text(display,
|
---|
[b41564c] | 606 | (void *) NUMERIC_ERROR_DISPLAY);
|
---|
[bdfdc51c] | 607 | break;
|
---|
| 608 | default:
|
---|
[03145ee] | 609 | (void) ui_entry_set_text(display,
|
---|
[b41564c] | 610 | (void *) UNKNOWN_ERROR_DISPLAY);
|
---|
| 611 | break;
|
---|
[bdfdc51c] | 612 | }
|
---|
[b41564c] | 613 |
|
---|
[03145ee] | 614 | ui_entry_paint(display);
|
---|
[bdfdc51c] | 615 | }
|
---|
| 616 |
|
---|
[b41564c] | 617 | static void calc_pb_clicked(ui_pbutton_t *pbutton, void *arg)
|
---|
[bdfdc51c] | 618 | {
|
---|
[b41564c] | 619 | const char *subexpr = (const char *) arg;
|
---|
[a35b458] | 620 |
|
---|
[bdfdc51c] | 621 | if (expr != NULL) {
|
---|
| 622 | char *new_expr;
|
---|
[a35b458] | 623 |
|
---|
[b41564c] | 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 {
|
---|
[bdfdc51c] | 630 | expr = str_dup(subexpr);
|
---|
[b41564c] | 631 | }
|
---|
[a35b458] | 632 |
|
---|
[bdfdc51c] | 633 | display_update();
|
---|
| 634 | }
|
---|
| 635 |
|
---|
[b41564c] | 636 | static void calc_clear_clicked(ui_pbutton_t *pbutton, void *arg)
|
---|
[bdfdc51c] | 637 | {
|
---|
| 638 | if (expr != NULL) {
|
---|
| 639 | free(expr);
|
---|
| 640 | expr = NULL;
|
---|
| 641 | }
|
---|
[a35b458] | 642 |
|
---|
[bdfdc51c] | 643 | display_update();
|
---|
| 644 | }
|
---|
| 645 |
|
---|
[b41564c] | 646 | static void calc_eval_clicked(ui_pbutton_t *pbutton, void *arg)
|
---|
[bdfdc51c] | 647 | {
|
---|
| 648 | if (expr == NULL)
|
---|
| 649 | return;
|
---|
[a35b458] | 650 |
|
---|
[bdfdc51c] | 651 | list_t stack;
|
---|
| 652 | list_initialize(&stack);
|
---|
[a35b458] | 653 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 660 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 679 |
|
---|
[bdfdc51c] | 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;
|
---|
[a35b458] | 688 |
|
---|
[bdfdc51c] | 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 | }
|
---|
[a35b458] | 699 |
|
---|
[bdfdc51c] | 700 | value = 0;
|
---|
| 701 | value_neg = false;
|
---|
[a35b458] | 702 |
|
---|
[bdfdc51c] | 703 | operator_t operator = get_operator(expr[i]);
|
---|
[a35b458] | 704 |
|
---|
[bdfdc51c] | 705 | if (get_priority(operator) <= get_priority(last_operator)) {
|
---|
| 706 | evaluate(&stack, &value, &state, &error_type);
|
---|
| 707 | if (state == STATE_ERROR)
|
---|
| 708 | break;
|
---|
[a35b458] | 709 |
|
---|
[bdfdc51c] | 710 | if (!stack_push_value(&stack, value, value_neg)) {
|
---|
| 711 | state = STATE_ERROR;
|
---|
| 712 | break;
|
---|
| 713 | }
|
---|
| 714 | }
|
---|
[a35b458] | 715 |
|
---|
[bdfdc51c] | 716 | if (!stack_push_operator(&stack, operator)) {
|
---|
| 717 | state = STATE_ERROR;
|
---|
| 718 | break;
|
---|
| 719 | }
|
---|
[a35b458] | 720 |
|
---|
[bdfdc51c] | 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 | }
|
---|
[a35b458] | 729 |
|
---|
[bdfdc51c] | 730 | state = STATE_FINISH;
|
---|
| 731 | } else
|
---|
| 732 | state = STATE_ERROR;
|
---|
| 733 | break;
|
---|
[a35b458] | 734 |
|
---|
[bdfdc51c] | 735 | default:
|
---|
| 736 | state = STATE_ERROR;
|
---|
| 737 | }
|
---|
| 738 | }
|
---|
[a35b458] | 739 |
|
---|
[bdfdc51c] | 740 | evaluate(&stack, &value, &state, &error_type);
|
---|
| 741 | stack_cleanup(&stack);
|
---|
[a35b458] | 742 |
|
---|
[bdfdc51c] | 743 | if (state == STATE_ERROR) {
|
---|
| 744 | display_error(error_type);
|
---|
| 745 | return;
|
---|
| 746 | }
|
---|
[a35b458] | 747 |
|
---|
[bdfdc51c] | 748 | free(expr);
|
---|
| 749 | asprintf(&expr, "%" PRId64, value);
|
---|
| 750 | display_update();
|
---|
| 751 | }
|
---|
| 752 |
|
---|
[9c7dc8e] | 753 | static errno_t calc_button_create(calc_t *calc, ui_fixed_t *fixed,
|
---|
[b41564c] | 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 |
|
---|
[9c7dc8e] | 761 | rc = ui_pbutton_create(calc->ui_res, text, &pb);
|
---|
[b41564c] | 762 | if (rc != EOK) {
|
---|
| 763 | printf("Error creating button.\n");
|
---|
| 764 | return rc;
|
---|
| 765 | }
|
---|
| 766 |
|
---|
| 767 | ui_pbutton_set_cb(pb, cb, arg);
|
---|
| 768 |
|
---|
[9c7dc8e] | 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;
|
---|
[b41564c] | 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 |
|
---|
[fd11144] | 786 | static void print_syntax(void)
|
---|
| 787 | {
|
---|
[b41564c] | 788 | printf("Syntax: %s [-d <display-spec>]\n", NAME);
|
---|
[fd11144] | 789 | }
|
---|
| 790 |
|
---|
[bdfdc51c] | 791 | int main(int argc, char *argv[])
|
---|
| 792 | {
|
---|
[552b69f] | 793 | const char *display_spec = UI_ANY_DEFAULT;
|
---|
[b41564c] | 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;
|
---|
[1746ede] | 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;
|
---|
[b41564c] | 804 | calc_t calc;
|
---|
| 805 | errno_t rc;
|
---|
[fd11144] | 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 |
|
---|
[b41564c] | 818 | display_spec = argv[i++];
|
---|
[fd11144] | 819 | } else {
|
---|
| 820 | printf("Invalid option '%s'.\n", argv[i]);
|
---|
| 821 | print_syntax();
|
---|
| 822 | return 1;
|
---|
| 823 | }
|
---|
[bdfdc51c] | 824 | }
|
---|
[a35b458] | 825 |
|
---|
[b41564c] | 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(¶ms);
|
---|
| 833 | params.caption = "Calculator";
|
---|
| 834 | params.rect.p0.x = 0;
|
---|
| 835 | params.rect.p0.y = 0;
|
---|
| 836 |
|
---|
[9c7dc8e] | 837 | if (ui_is_textmode(ui)) {
|
---|
[cd74fa8] | 838 | params.rect.p1.x = 38;
|
---|
[45004f3] | 839 | params.rect.p1.y = 18;
|
---|
[cd74fa8] | 840 |
|
---|
[1746ede] | 841 | calc.geom.menubar_rect.p0.x = 1;
|
---|
[45004f3] | 842 | calc.geom.menubar_rect.p0.y = 1;
|
---|
[1746ede] | 843 | calc.geom.menubar_rect.p1.x = params.rect.p1.x - 1;
|
---|
[45004f3] | 844 | calc.geom.menubar_rect.p1.y = 2;
|
---|
[9c7dc8e] | 845 | calc.geom.entry_rect.p0.x = 4;
|
---|
[45004f3] | 846 | calc.geom.entry_rect.p0.y = 3;
|
---|
[cd74fa8] | 847 | calc.geom.entry_rect.p1.x = 34;
|
---|
[45004f3] | 848 | calc.geom.entry_rect.p1.y = 4;
|
---|
[9c7dc8e] | 849 | calc.geom.btn_orig.x = 4;
|
---|
[45004f3] | 850 | calc.geom.btn_orig.y = 5;
|
---|
[cd74fa8] | 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;
|
---|
[9c7dc8e] | 855 | } else {
|
---|
[cd74fa8] | 856 | params.rect.p1.x = 250;
|
---|
| 857 | params.rect.p1.y = 270;
|
---|
| 858 |
|
---|
[1746ede] | 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;
|
---|
[d65accb] | 864 | calc.geom.entry_rect.p0.y = 51;
|
---|
[1746ede] | 865 | calc.geom.entry_rect.p1.x = 240;
|
---|
[d65accb] | 866 | calc.geom.entry_rect.p1.y = 76;
|
---|
[9c7dc8e] | 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 |
|
---|
[b41564c] | 875 | rc = ui_window_create(ui, ¶ms, &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);
|
---|
[9c7dc8e] | 885 | calc.ui_res = ui_res;
|
---|
[b41564c] | 886 |
|
---|
| 887 | rc = ui_fixed_create(&fixed);
|
---|
| 888 | if (rc != EOK) {
|
---|
| 889 | printf("Error creating fixed layout.\n");
|
---|
| 890 | return rc;
|
---|
| 891 | }
|
---|
| 892 |
|
---|
[c68c18b9] | 893 | rc = ui_menu_bar_create(ui, window, &calc.menubar);
|
---|
[1746ede] | 894 | if (rc != EOK) {
|
---|
| 895 | printf("Error creating menu bar.\n");
|
---|
| 896 | return rc;
|
---|
| 897 | }
|
---|
| 898 |
|
---|
[46bd63c9] | 899 | rc = ui_menu_dd_create(calc.menubar, "~F~ile", NULL, &mfile);
|
---|
[1746ede] | 900 | if (rc != EOK) {
|
---|
| 901 | printf("Error creating menu.\n");
|
---|
| 902 | return rc;
|
---|
| 903 | }
|
---|
| 904 |
|
---|
[c88d7f99] | 905 | rc = ui_menu_entry_create(mfile, "E~x~it", "Alt-F4", &mexit);
|
---|
[1746ede] | 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 |
|
---|
[46bd63c9] | 913 | rc = ui_menu_dd_create(calc.menubar, "~E~dit", NULL, &medit);
|
---|
[1746ede] | 914 | if (rc != EOK) {
|
---|
| 915 | printf("Error creating menu.\n");
|
---|
| 916 | return rc;
|
---|
| 917 | }
|
---|
| 918 |
|
---|
[c88d7f99] | 919 | rc = ui_menu_entry_create(medit, "~C~opy", "Ctrl-C", &mcopy);
|
---|
[1746ede] | 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 |
|
---|
[c88d7f99] | 927 | rc = ui_menu_entry_create(medit, "~P~aste", "Ctrl-V", &mpaste);
|
---|
[1746ede] | 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 |
|
---|
[db3895d] | 943 | rc = ui_entry_create(window, NULL_DISPLAY, &display);
|
---|
[b41564c] | 944 | if (rc != EOK) {
|
---|
[03145ee] | 945 | printf("Error creating text lentry.\n");
|
---|
[b41564c] | 946 | return rc;
|
---|
| 947 | }
|
---|
| 948 |
|
---|
[9c7dc8e] | 949 | ui_entry_set_rect(display, &calc.geom.entry_rect);
|
---|
[03145ee] | 950 | ui_entry_set_halign(display, gfx_halign_right);
|
---|
[7481ee19] | 951 | ui_entry_set_read_only(display, true);
|
---|
[b41564c] | 952 |
|
---|
[03145ee] | 953 | rc = ui_fixed_add(fixed, ui_entry_ctl(display));
|
---|
[b41564c] | 954 | if (rc != EOK) {
|
---|
| 955 | printf("Error adding control to layout.\n");
|
---|
| 956 | return rc;
|
---|
[bdfdc51c] | 957 | }
|
---|
[a35b458] | 958 |
|
---|
[9c7dc8e] | 959 | rc = calc_button_create(&calc, fixed, 0, 0, "7", &calc_pbutton_cb,
|
---|
[d942ca4] | 960 | (void *) "7", &calc.btn_7);
|
---|
[b41564c] | 961 | if (rc != EOK)
|
---|
| 962 | return rc;
|
---|
| 963 |
|
---|
[9c7dc8e] | 964 | rc = calc_button_create(&calc, fixed, 1, 0, "8", &calc_pbutton_cb,
|
---|
[d942ca4] | 965 | (void *) "8", &calc.btn_8);
|
---|
[b41564c] | 966 | if (rc != EOK)
|
---|
| 967 | return rc;
|
---|
| 968 |
|
---|
[9c7dc8e] | 969 | rc = calc_button_create(&calc, fixed, 2, 0, "9", &calc_pbutton_cb,
|
---|
[d942ca4] | 970 | (void *) "9", &calc.btn_9);
|
---|
[b41564c] | 971 | if (rc != EOK)
|
---|
| 972 | return rc;
|
---|
| 973 |
|
---|
[9c7dc8e] | 974 | rc = calc_button_create(&calc, fixed, 3, 0, "/", &calc_pbutton_cb,
|
---|
[d942ca4] | 975 | (void *) "/", &calc.btn_div);
|
---|
[b41564c] | 976 | if (rc != EOK)
|
---|
| 977 | return rc;
|
---|
| 978 |
|
---|
[9c7dc8e] | 979 | rc = calc_button_create(&calc, fixed, 0, 1, "4", &calc_pbutton_cb,
|
---|
[d942ca4] | 980 | (void *) "4", &calc.btn_4);
|
---|
[b41564c] | 981 | if (rc != EOK)
|
---|
| 982 | return rc;
|
---|
| 983 |
|
---|
[9c7dc8e] | 984 | rc = calc_button_create(&calc, fixed, 1, 1, "5", &calc_pbutton_cb,
|
---|
[d942ca4] | 985 | (void *) "5", &calc.btn_5);
|
---|
[b41564c] | 986 | if (rc != EOK)
|
---|
| 987 | return rc;
|
---|
| 988 |
|
---|
[9c7dc8e] | 989 | rc = calc_button_create(&calc, fixed, 2, 1, "6", &calc_pbutton_cb,
|
---|
[d942ca4] | 990 | (void *) "6", &calc.btn_6);
|
---|
[b41564c] | 991 | if (rc != EOK)
|
---|
| 992 | return rc;
|
---|
| 993 |
|
---|
[9c7dc8e] | 994 | rc = calc_button_create(&calc, fixed, 3, 1, "*", &calc_pbutton_cb,
|
---|
[d942ca4] | 995 | (void *) "*", &calc.btn_mul);
|
---|
[b41564c] | 996 | if (rc != EOK)
|
---|
| 997 | return rc;
|
---|
| 998 |
|
---|
[9c7dc8e] | 999 | rc = calc_button_create(&calc, fixed, 0, 2, "1", &calc_pbutton_cb,
|
---|
[d942ca4] | 1000 | (void *) "1", &calc.btn_1);
|
---|
[b41564c] | 1001 | if (rc != EOK)
|
---|
| 1002 | return rc;
|
---|
| 1003 |
|
---|
[9c7dc8e] | 1004 | rc = calc_button_create(&calc, fixed, 1, 2, "2", &calc_pbutton_cb,
|
---|
[d942ca4] | 1005 | (void *) "2", &calc.btn_2);
|
---|
[b41564c] | 1006 | if (rc != EOK)
|
---|
| 1007 | return rc;
|
---|
| 1008 |
|
---|
[9c7dc8e] | 1009 | rc = calc_button_create(&calc, fixed, 2, 2, "3", &calc_pbutton_cb,
|
---|
[d942ca4] | 1010 | (void *) "3", &calc.btn_3);
|
---|
[b41564c] | 1011 | if (rc != EOK)
|
---|
| 1012 | return rc;
|
---|
| 1013 |
|
---|
[9c7dc8e] | 1014 | rc = calc_button_create(&calc, fixed, 3, 2, "-", &calc_pbutton_cb,
|
---|
[d942ca4] | 1015 | (void *) "-", &calc.btn_sub);
|
---|
[b41564c] | 1016 | if (rc != EOK)
|
---|
| 1017 | return rc;
|
---|
| 1018 |
|
---|
[9c7dc8e] | 1019 | rc = calc_button_create(&calc, fixed, 0, 3, "0", &calc_pbutton_cb,
|
---|
[d942ca4] | 1020 | (void *) "0", &calc.btn_0);
|
---|
[b41564c] | 1021 | if (rc != EOK)
|
---|
| 1022 | return rc;
|
---|
| 1023 |
|
---|
[9c7dc8e] | 1024 | rc = calc_button_create(&calc, fixed, 1, 3, "C", &calc_clear_cb,
|
---|
[d942ca4] | 1025 | (void *) "C", &calc.btn_clear);
|
---|
[b41564c] | 1026 | if (rc != EOK)
|
---|
| 1027 | return rc;
|
---|
| 1028 |
|
---|
[9c7dc8e] | 1029 | rc = calc_button_create(&calc, fixed, 2, 3, "=", &calc_eval_cb,
|
---|
[d942ca4] | 1030 | (void *) "=", &calc.btn_eval);
|
---|
[b41564c] | 1031 | if (rc != EOK)
|
---|
| 1032 | return rc;
|
---|
| 1033 |
|
---|
[9c7dc8e] | 1034 | rc = calc_button_create(&calc, fixed, 3, 3, "+", &calc_pbutton_cb,
|
---|
[d942ca4] | 1035 | (void *) "+", &calc.btn_add);
|
---|
[b41564c] | 1036 | if (rc != EOK)
|
---|
| 1037 | return rc;
|
---|
| 1038 |
|
---|
[d942ca4] | 1039 | ui_pbutton_set_default(calc.btn_eval, true);
|
---|
[b41564c] | 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;
|
---|
[bdfdc51c] | 1047 | }
|
---|
[a35b458] | 1048 |
|
---|
[b41564c] | 1049 | ui_run(ui);
|
---|
| 1050 | ui_window_destroy(window);
|
---|
| 1051 | ui_destroy(ui);
|
---|
[a35b458] | 1052 |
|
---|
[bdfdc51c] | 1053 | return 0;
|
---|
| 1054 | }
|
---|