Momentum-Apps/views/xremote_pause_set.c

#include "xremote_pause_set.h"

struct XRemotePauseSet {
    View* view;
    XRemotePauseSetCallback callback;
    void* context;
};

typedef struct {
    int type;
    const char* name;
    int time;
} XRemotePauseSetModel;

static void xremote_pause_set_model_init(XRemotePauseSetModel* const model) {
    model->type = XRemoteRemoteItemTypePause;
    model->time = 1;
}

void xremote_pause_set_set_callback(
    XRemotePauseSet* instance,
    XRemotePauseSetCallback callback,
    void* context) {
    furi_assert(instance);
    furi_assert(callback);
    instance->callback = callback;
    instance->context = context;
}

void xremote_pause_set_draw(Canvas* canvas, XRemotePauseSetModel* model) {
    char seconds[14];
    snprintf(seconds, SECONDS_LENGHT, SECONDS_FORMAT, model->time);
    canvas_clear(canvas);
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignTop, "Pause duration");
    canvas_set_font(canvas, FontSecondary);
    canvas_draw_icon(canvas, 59, 22, &I_ButtonUp_10x5);
    canvas_draw_icon(canvas, 59, 42, &I_ButtonDown_10x5);
    canvas_draw_str_aligned(canvas, 64, 31, AlignCenter, AlignTop, seconds);
    elements_button_center(canvas, "Add");
}

bool xremote_pause_set_input(InputEvent* event, void* context) {
    furi_assert(context);
    XRemotePauseSet* instance = context;
    if(event->type == InputTypeRelease) {
        switch(event->key) {
        case InputKeyBack:
            instance->callback(XRemoteCustomEventPauseSetBack, instance->context);
            break;
        case InputKeyLeft:
        case InputKeyRight:
            break;
        case InputKeyUp:
            with_view_model(
                instance->view,
                XRemotePauseSetModel * model,
                {
                    model->time++;
                    if(model->time > 9) {
                        model->time = 0;
                    }
                },
                true);
            break;
        case InputKeyDown:
            with_view_model(
                instance->view,
                XRemotePauseSetModel * model,
                {
                    model->time--;
                    if(model->time < 0) {
                        model->time = 9;
                    }
                },
                true);
            break;
        case InputKeyOk:
            with_view_model(
                instance->view,
                XRemotePauseSetModel * model,
                {
                    XRemote* app = instance->context;
                    xremote_cross_remote_add_pause(app->cross_remote, model->time);
                },
                true);

            instance->callback(XRemoteCustomEventPauseSetOk, instance->context);
            break;
        case InputKeyMAX:
            break;
        }
    }
    return true;
}

XRemotePauseSet* xremote_pause_set_alloc() {
    XRemotePauseSet* instance = malloc(sizeof(XRemotePauseSet));
    instance->view = view_alloc();
    view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(XRemotePauseSetModel));
    view_set_context(instance->view, instance);
    view_set_draw_callback(instance->view, (ViewDrawCallback)xremote_pause_set_draw);
    view_set_enter_callback(instance->view, xremote_pause_set_enter);
    view_set_input_callback(instance->view, xremote_pause_set_input);

    with_view_model(
        instance->view,
        XRemotePauseSetModel * model,
        { xremote_pause_set_model_init(model); },
        true);

    return instance;
}

void xremote_pause_set_enter(void* context) {
    furi_assert(context);
    XRemotePauseSet* instance = (XRemotePauseSet*)context;
    with_view_model(
        instance->view,
        XRemotePauseSetModel * model,
        { xremote_pause_set_model_init(model); },
        true);
}

View* xremote_pause_set_get_view(XRemotePauseSet* instance) {
    furi_assert(instance);
    return instance->view;
}

void xremote_pause_set_free(XRemotePauseSet* instance) {
    furi_assert(instance);

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