apps/display-demo/app_calc.c

Go to the documentation of this file.

#include <led.h>
#include <board.h>
#include <string.h>

#include <gfx/gfx.h>
#include <gfx/win.h>
#include <gfx/wtk.h>
#include <gfx/sysfont.h>
#include <membag.h>
#include <debug.h>
#include <stream.h>
#include <mainloop.h>

#include "app_desktop.h"
#include "app_calc.h"


#define POS_X        10

#define POS_Y        50

#define SIZE_X       45

#define SIZE_Y       35

#define SPACE_X      (SIZE_X + 10)

#define SPACE_Y      (SIZE_Y + 10)

#define KEYS_PR_ROW  4



#define MAX_VALUE    999999

#define MAX_DIGITS   (10+1)


enum command_id {
        RADIO_DEC_ID = 123,
        RADIO_HEX_ID,
        BUTTON_EXIT_ID,
};

enum calc_mode {
        CALC_DEC,
        CALC_HEX,
};

struct calc_context {
        struct wtk_basic_frame *frame;
        struct wtk_label       *display_lbl;
        struct font            old_sysfont;
        struct gfx_bitmap      background;
        struct gfx_bitmap      label_background;

        char                   text[MAX_DIGITS];
        int32_t                stack_value;
        int32_t                disp_value;
        char                   operator;
        enum calc_mode         mode;
};

static void calc_update_display(struct calc_context *calc)
{
        assert(calc);

        // Generate string according to the selected number base.
        switch (calc->mode) {
        case CALC_HEX:
                snprintf(calc->text, MAX_DIGITS, "0x%lx", calc->disp_value);
                break;
        default:
                snprintf(calc->text, MAX_DIGITS, "%ld", calc->disp_value);
                break;
        }

        wtk_label_change(calc->display_lbl, calc->text);
}

static bool calc_frame_command_handler(struct wtk_basic_frame *frame,
                win_command_t command_data)
{
        struct calc_context *calc;
        char command;

        calc = wtk_basic_frame_get_custom_data(frame);

        command = (char)(uintptr_t)command_data;
        switch (command) {
        // Multiply current display value by 10, and add new number.
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
                if (calc->disp_value < MAX_VALUE) {
                        calc->disp_value *= 10;
                        calc->disp_value += command - '0';
                        calc_update_display(calc);
                }

                break;

        // Change the arithmetic operator to use when '=' is pressed.
        case '+':
        case '-':
        case '/':
        case '*':
                if (calc->disp_value) {
                        calc->stack_value = calc->disp_value;
                        calc->disp_value = 0;
                        calc->operator = command;

                        calc_update_display(calc);
                }
                break;

        // Compute according to selected operator, display the result.
        case '=':
                switch (calc->operator) {
                case '+':
                        calc->disp_value = calc->stack_value + calc->disp_value;
                        break;

                case '-':
                        calc->disp_value = calc->stack_value - calc->disp_value;
                        break;

                case '*':
                        calc->disp_value = calc->stack_value * calc->disp_value;
                        break;

                case '/':
                        if (calc->disp_value != 0) {
                                calc->disp_value = calc->stack_value / calc->disp_value;
                        }
                        break;

                default:
                        break;
                }
                calc->operator = 0;
                // Saturate value
                if (calc->disp_value > 0 ) {
                        calc->disp_value = min_s(MAX_VALUE, calc->disp_value);
                } else {
                        calc->disp_value = max_s(-MAX_VALUE, calc->disp_value);
                }
                calc_update_display(calc);
                break;

        // Clear all entered values.
        case 'C':
                calc->disp_value = 0;
                calc->stack_value = 0;
                calc_update_display(calc);
                break;

        // Switch to base 10 (decimal) number representation.
        case RADIO_DEC_ID:
                calc->mode = CALC_DEC;
                calc_update_display(calc);
                break;

        // Switch to base 16 (hexdecimal) number representation.
        case RADIO_HEX_ID:
                calc->mode = CALC_HEX;
                calc_update_display(calc);
                break;

        // Exit the application.
        case BUTTON_EXIT_ID:
                // Restore sysfont
                memcpy(&sysfont, &calc->old_sysfont, sizeof(struct font));
                // Restart desktop
                app_desktop_restart();
                // Free memory
                membag_free(calc);
                // Close the application
                return true;
        }

        return false;
}

void app_calc_launch(struct workqueue_task *task)
{
        struct wtk_radio_group  *rg;
        struct wtk_radio_button *rb;
        struct wtk_basic_frame  *lframe;
        struct win_window       *parent;
        struct win_area         area;
        struct wtk_button       *btn;
        struct calc_context     *calc;
        uint8_t                 i;
        char                    caption[2] = "0";
        char                    keys[] = {
                '7','8','9','+',
                '4','5','6','-',
                '3','2','1','*',
                '0','C','=','/',
        };

        calc = membag_alloc(sizeof(struct calc_context));
        if (!calc) {
                goto error_ctx;
        }

        // Use larger sysfont for this app
        memcpy(&calc->old_sysfont, &sysfont, sizeof(struct font));
        sysfont.scale = 2;

        calc->mode = CALC_DEC;
        calc->disp_value = 0;
        calc->stack_value = 0;

        // Create main calculator window
        calc->background.type = BITMAP_SOLID;
        calc->background.data.color = GFX_COLOR(0, 0, 0);

        area.pos.x = 0;
        area.pos.y = 0;
        area.size.x = gfx_get_width();
        area.size.y = gfx_get_height();

        calc->frame = wtk_basic_frame_create(win_get_root(), &area,
                        &calc->background, NULL, calc_frame_command_handler,
                        calc);
        if (!calc->frame) {
                goto error_frame;
        }

        parent = wtk_basic_frame_as_child(calc->frame);
        win_show(parent);

        // Create background for label
        calc->label_background.type = BITMAP_SOLID;
        calc->label_background.data.color = WTK_BUTTON_BACKGROUND_COLOR;

        area.pos.x = POS_X;
        area.pos.y = 10;
        area.size.x = SPACE_X * KEYS_PR_ROW - 10;
        area.size.y = 30;

        lframe = wtk_basic_frame_create(parent, &area, &calc->label_background,
                        NULL, NULL, NULL);
        if (!lframe) {
                goto error_widget;
        }
        win_show(wtk_basic_frame_as_child(lframe));

        // Create label for result
        area.pos.x = 5;
        area.pos.y = 10;
        area.size.x -= area.pos.x + 20;
        area.size.x -= area.pos.y;
        calc->display_lbl = wtk_label_create(wtk_basic_frame_as_child(lframe),
                        &area, "0", true);
        if (!calc->display_lbl) {
                goto error_widget;
        }
        win_show(wtk_label_as_child(calc->display_lbl));

        // Create buttons
        area.pos.x = POS_X;
        area.pos.y = POS_Y;
        area.size.x = SIZE_X;
        area.size.y = SIZE_Y;
        for (i = 0; i < ARRAY_LEN(keys); i++) {
                caption[0] = keys[i];
                btn = wtk_button_create(parent, &area, caption,
                                (win_command_t)(uintptr_t)caption[0]);
                if (!btn) {
                        goto error_widget;
                }
                win_show(wtk_button_as_child(btn));

                if (((i + 1) % KEYS_PR_ROW) == 0) {
                        area.pos.x = POS_X;
                        area.pos.y += SPACE_Y;
                } else {
                        area.pos.x += SPACE_X;
                }
        }

        // Create value mode radio buttons
        rg = wtk_radio_group_create();

        area.pos.x = SPACE_X * KEYS_PR_ROW + 10;
        area.pos.y = POS_Y + 20;
        area.size.x = 60;
        area.size.y = 30;

        rb = wtk_radio_button_create(parent, &area, "Dec", true, rg,
                        (win_command_t)RADIO_DEC_ID);
        if (!rb) {
                goto error_widget;
        }
        win_show(wtk_radio_button_as_child(rb));

        area.pos.y += area.size.y + 10;
        rb = wtk_radio_button_create(parent, &area, "Hex", false, rg,
                        (win_command_t)RADIO_HEX_ID);
        if (!rb) {
                goto error_widget;
        }
        win_show(wtk_radio_button_as_child(rb));

        // Create exit button
        area.size.x = APP_EXIT_BUTTON_SIZE_X;
        area.size.y = APP_EXIT_BUTTON_SIZE_Y;
        area.pos.x  = APP_EXIT_BUTTON_POS_X;
        area.pos.y  = APP_EXIT_BUTTON_POS_Y;

        btn = wtk_button_create(parent, &area, APP_EXIT_BUTTON_TEXT,
                        (win_command_t)BUTTON_EXIT_ID);
        if (!btn) {
                goto error_widget;
        }
        win_show(wtk_button_as_child(btn));

        return;

error_widget:
        win_destroy(wtk_basic_frame_as_child(calc->frame));
error_frame:
        memcpy(&sysfont, &calc->old_sysfont, sizeof(struct font));
        membag_free(calc);
error_ctx:
        app_desktop_restart();
}

---