Momentum-Apps/views/hex_viewer_startscreen.c

#include "../hex_viewer.h"
#include <furi.h>
#include <furi_hal.h>
#include <input/input.h>
#include <gui/elements.h>

struct HexViewerStartscreen {
    View* view;
    HexViewerStartscreenCallback callback;
    void* context;
};


typedef struct {
    uint8_t file_bytes[HEX_VIEWER_LINES_ON_SCREEN][HEX_VIEWER_BYTES_PER_LINE];
    uint32_t file_offset;
    uint32_t file_read_bytes;
    uint32_t file_size;
    bool mode; // Print address or content
} HexViewerStartscreenModel;

void hex_viewer_startscreen_set_callback(
    HexViewerStartscreen* instance,
    HexViewerStartscreenCallback callback,
    void* context) {
    furi_assert(instance);
    furi_assert(callback);
    instance->callback = callback;
    instance->context = context;
}

void hex_viewer_startscreen_draw(Canvas* canvas, HexViewerStartscreenModel* model) {
    UNUSED(model);
    canvas_clear(canvas);

    if (!model->file_size) {
        canvas_set_color(canvas, ColorBlack);
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignTop, "HexViewer v2.0"); 
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str_aligned(canvas, 64, 22, AlignCenter, AlignTop, "Basic hex viewer"); 
        canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignTop, "for your Flipper");
        elements_button_center(canvas, "Open");
    } else {
        canvas_set_color(canvas, ColorBlack);

        elements_button_left(canvas, model->mode ? "Addr" : "Text");
        elements_button_right(canvas, "Info");
        elements_button_center(canvas, "Menu");

        int ROW_HEIGHT = 12;
        int TOP_OFFSET = 10;
        int LEFT_OFFSET = 3;

        uint32_t line_count = model->file_size / HEX_VIEWER_BYTES_PER_LINE;
        if(model->file_size % HEX_VIEWER_BYTES_PER_LINE != 0) line_count += 1;
        uint32_t first_line_on_screen = model->file_offset / HEX_VIEWER_BYTES_PER_LINE;
        if(line_count > HEX_VIEWER_LINES_ON_SCREEN) {
            uint8_t width = canvas_width(canvas);
            elements_scrollbar_pos(
                canvas,
                width,
                0,
                ROW_HEIGHT * HEX_VIEWER_LINES_ON_SCREEN,
                first_line_on_screen, // TODO
                line_count - (HEX_VIEWER_LINES_ON_SCREEN - 1));
        }

        char temp_buf[32];
        uint32_t row_iters = model->file_read_bytes / HEX_VIEWER_BYTES_PER_LINE;
        if(model->file_read_bytes % HEX_VIEWER_BYTES_PER_LINE != 0) row_iters += 1;

        for(uint32_t i = 0; i < row_iters; ++i) {
            uint32_t bytes_left_per_row =
                model->file_read_bytes - i * HEX_VIEWER_BYTES_PER_LINE;
            bytes_left_per_row = MIN(bytes_left_per_row, HEX_VIEWER_BYTES_PER_LINE);

            if(model->mode) {
                memcpy(temp_buf, model->file_bytes[i], bytes_left_per_row);
                temp_buf[bytes_left_per_row] = '\0';
                for(uint32_t j = 0; j < bytes_left_per_row; ++j)
                    if(!isprint((int)temp_buf[j])) temp_buf[j] = '.';

                canvas_set_font(canvas, FontKeyboard);
                canvas_draw_str(canvas, LEFT_OFFSET, TOP_OFFSET + i * ROW_HEIGHT, temp_buf);
            } else {
                uint32_t addr = model->file_offset + i * HEX_VIEWER_BYTES_PER_LINE;
                snprintf(temp_buf, 32, "%04lX", addr);

                canvas_set_font(canvas, FontKeyboard);
                canvas_draw_str(canvas, LEFT_OFFSET, TOP_OFFSET + i * ROW_HEIGHT, temp_buf);
            }

            char* p = temp_buf;
            for(uint32_t j = 0; j < bytes_left_per_row; ++j)
                p += snprintf(p, 32, "%02X ", model->file_bytes[i][j]);

            canvas_set_font(canvas, FontKeyboard);
            canvas_draw_str(canvas, LEFT_OFFSET + 41, TOP_OFFSET + i * ROW_HEIGHT, temp_buf);
        }
    }
    
}

static void hex_viewer_startscreen_model_init(HexViewerStartscreenModel* const model) {
    memset(model->file_bytes, 0, sizeof(model->file_bytes));
    model->file_offset = 0;
    model->file_read_bytes = 0;
    model->file_size = 0;
    model->mode = false;
}

static void update_local_model_from_app(HexViewer* const app, HexViewerStartscreenModel* const model)
{
    memcpy(model->file_bytes, app->model->file_bytes, sizeof(model->file_bytes));
    model->file_offset = app->model->file_offset;
    model->file_read_bytes = app->model->file_read_bytes;
    model->file_size = app->model->file_size;
    model->mode = app->model->mode;
}

bool hex_viewer_startscreen_input(InputEvent* event, void* context) {
    furi_assert(context); 
    HexViewerStartscreen* instance = context;
    if (event->type == InputTypeRelease) {
        switch(event->key) {
            case InputKeyBack:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel * model,
                    {
                        instance->callback(HexViewerCustomEventStartscreenBack, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                break;
            case InputKeyLeft:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel * model,
                    {
                        UNUSED(model);
                        instance->callback(HexViewerCustomEventStartscreenLeft, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                    break;
            case InputKeyRight:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel * model,
                    {
                        UNUSED(model);
                        instance->callback(HexViewerCustomEventStartscreenRight, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                break;
            case InputKeyUp:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel * model,
                    {
                        UNUSED(model);
                        instance->callback(HexViewerCustomEventStartscreenUp, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                break;
            case InputKeyDown:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel * model,
                    {
                        UNUSED(model);
                        instance->callback(HexViewerCustomEventStartscreenDown, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                break;
            case InputKeyOk:
                with_view_model(
                    instance->view,
                    HexViewerStartscreenModel* model,
                    {
                        UNUSED(model);
                        instance->callback(HexViewerCustomEventStartscreenOk, instance->context);
                        update_local_model_from_app(instance->context, model);
                    },
                    true);
                break;
            case InputKeyMAX:
                break;
        }
    }
    return true;
}

void hex_viewer_startscreen_exit(void* context) {
    furi_assert(context);
}

void hex_viewer_startscreen_enter(void* context) {
    furi_assert(context);
    HexViewerStartscreen* instance = (HexViewerStartscreen*)context;
    with_view_model(
        instance->view,
        HexViewerStartscreenModel * model,
        {
            hex_viewer_startscreen_model_init(model); 
            // TODO update_local_model_from_app(instance->context, model);
        },
        true
    );
}

HexViewerStartscreen* hex_viewer_startscreen_alloc() {
    HexViewerStartscreen* instance = malloc(sizeof(HexViewerStartscreen));
    instance->view = view_alloc();
    view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(HexViewerStartscreenModel));
    view_set_context(instance->view, instance); // furi_assert crashes in events without this
    view_set_draw_callback(instance->view, (ViewDrawCallback)hex_viewer_startscreen_draw);
    view_set_input_callback(instance->view, hex_viewer_startscreen_input);
    //view_set_enter_callback(instance->view, hex_viewer_startscreen_enter);
    //view_set_exit_callback(instance->view, hex_viewer_startscreen_exit);

    with_view_model(
        instance->view,
        HexViewerStartscreenModel * model,
        {
            hex_viewer_startscreen_model_init(model);
        },
        true
    );
    
    return instance;
}

void hex_viewer_startscreen_free(HexViewerStartscreen* instance) {
    furi_assert(instance);

    with_view_model(
        instance->view,
        HexViewerStartscreenModel * model,
        {
            UNUSED(model);
        },
        true);
    view_free(instance->view);
    free(instance);
}

View* hex_viewer_startscreen_get_view(HexViewerStartscreen* instance) {
    furi_assert(instance);
    return instance->view;
}