ui_core.h

Go to the documentation of this file.

#pragma once
 
#include "pico/stdlib.h"
#include "sw/ui_core/ui_control_event.h"
#include "sw/display_device/display_device.h"
#include "sw/widget/widget.h"
 
#include <vector>
#include <map>
#include <string>
#include <set>

#define UI_MODEL_OBJECT_STATUS_TIME_OUT_us 3000000

enum class ControlledObjectStatus
{
    IS_WAITING,

    HAS_FOCUS,

    IS_ACTIVE
};

enum class ControlledObjectStatusTimeOutReason
{
    NO_TIME_OUT,
    MANAGER_INACTIVE,
    MANAGED_OBJECT_INACTIVE
};
 
class UIController;
class Widget;

class Model
{
private:
    uint32_t last_change_time;

    int change_flag;
 
protected:
    std::set<Widget *> attached_widgets;
 
public:
    Model();

    ~Model();

    void update_attached_widgets(Widget *new_widget);

    int get_number_of_attached_widget();

    bool has_changed();

    void set_change_flag();

    void draw_widget_done();

    uint32_t get_time_since_last_change();

    virtual void draw_refresh_all_attached_widgets();
};

class UIControlledModel : public Model
{
private:
    ControlledObjectStatus status{ControlledObjectStatus::IS_WAITING};

    UIController *current_controller{nullptr};
 
public:
    UIControlledModel(/* args */);
    ~UIControlledModel();
    void update_status(ControlledObjectStatus _new_status);
    void update_current_controller(UIController *_new_controller);
    ControlledObjectStatus get_status();

    UIController *get_current_controller();

    virtual void process_control_event(UIControlEvent _event) = 0;
};

class UIControlledIncrementalValue : public UIControlledModel
{
private:
protected:
    int value;
    int max_value;
    int min_value;
    int increment;
    bool is_wrappable;
 
public:
    UIControlledIncrementalValue(int min_value = 0, int max_value = 10, bool is_wrappable = false, int increment = 1);
    ~UIControlledIncrementalValue();
    virtual void increment_value();
    virtual void decrement_value();
    void set_clipped_value(int _new_value);
    int get_value();
    int get_min_value();
    int get_max_value();
};

class UIModelManager : public UIControlledIncrementalValue
{
protected:
    ControlledObjectStatusTimeOutReason check_time_out(uint32_t managed_object_status_time_out_us = UI_MODEL_OBJECT_STATUS_TIME_OUT_us);
    std::vector<UIControlledModel *> managed_models;
    UIControlledModel *current_active_model;
    void make_managed_model_active();
    void make_manager_active();
    virtual void increment_focus();
    virtual void decrement_focus();
 
public:
    UIModelManager(bool is_wrappable = false);
    ~UIModelManager();
    void add_managed_model(UIControlledModel *_new_model);
};

class UIController
{
protected:
public:
    UIControlledModel *current_controlled_model{nullptr};
    UIController(/* args */);
    ~UIController();
    void update_current_controlled_object(UIControlledModel *_new_controlled_object);
};