widget.h

Go to the documentation of this file.

 
#pragma once
 
#include "sw/display_device/display_device.h"
#include "sw/ui_core/ui_core.h"
#include "sw/widget/canvas.h"
 
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
 
#include <vector>
#include <string>
 
#include "pico/stdlib.h"
#define SSD1306_ASCII_FULL
 
#include "font/5x8_font.h"
#include "font/8x8_font.h"
#include "font/12x16_font.h"
#include "font/16x32_font.h"

#define BACKSPACE '\b'
#define HORIZONTAL_TAB '\t'
#define LINE_FEED '\n'
#define VERTICAL_TAB '\v'
#define FORM_FEED '\f'
#define CARRIAGE_RETURN '\r'
 
class Model;
class DisplayDevice;

class Blinker
{
private:
    int8_t previous_blinking_phase;

    uint32_t blink_period_us{1000000};

    bool blink_phase_changed;
 
protected:
public:
    Blinker();
    ~Blinker();
    void set_blink_us(uint32_t blink_period = 1000000);

    bool has_blinking_changed();

    void clear_blinking_phase_change();

    virtual void compute_blinking_phase();
};

class Widget
{
protected:
    DisplayDevice *display_device{nullptr};

    Model *actual_displayed_model{nullptr};

    std::vector<Widget *> widgets;
 
public:
    Widget(Model *actual_displayed_model,
           DisplayDevice *graphic_display_device = nullptr);
 
    virtual ~Widget();

    void add_widget(Widget *_sub_widget);

    void set_display_device(DisplayDevice *_new_display_device);

    virtual void draw() = 0;
};

class GraphicWidget : public Widget
{
private:
    void ellipse(uint8_t x_center, uint8_t y_center, uint8_t x_radius, uint8_t y_radius, bool fill, uint8_t quadrant, ColorIndex color);
 
protected:
    bool widget_with_border{false};

    size_t widget_width{128};

    size_t widget_height{8};

    uint8_t widget_start_x;

    uint8_t widget_start_y;

    uint8_t widget_border_width;

    void clear_widget();

    virtual void get_value_of_interest() = 0;
 
public:
    Canvas *canvas;

    uint8_t widget_anchor_x;
    uint8_t widget_anchor_y;

    struct_DataToShow data_to_display;

    void update_widget_anchor(uint8_t x, uint8_t y);

    virtual void draw_border(ColorIndex color = ColorIndex::WHITE);

    void show();
 
    
    void send_image_to_DisplayGateKeeper(QueueHandle_t display_queue,SemaphoreHandle_t sending_done);
 
 
 

    GraphicWidget(GraphicDisplayDevice *graphic_display_screen,
                  struct_ConfigGraphicWidget graph_cfg,
                  CanvasFormat canvas_format,
                  Model *displayed_object = nullptr);

    GraphicWidget(GraphicDisplayDevice *graphic_display_screen,
                  struct_ConfigTextWidget text_cfg,
                  CanvasFormat canvas_format,
                  Model *displayed_object = nullptr);

    GraphicWidget(GraphicDisplayDevice *graphic_display_screen,
                  struct_ConfigTextWidget text_cfg,
                  CanvasFormat canvas_format,
                  size_t frame_width, size_t frame_height,
                  Model *displayed_object = nullptr);

    virtual ~GraphicWidget();

    struct_ConfigGraphicWidget get_graph_frame_config();

    void hline(uint8_t x, uint8_t y, size_t w, ColorIndex color = ColorIndex::WHITE);

    void vline(uint8_t x, uint8_t y, size_t h, ColorIndex color = ColorIndex::WHITE);

    void line(int x0, int y0, int x1, int y1, ColorIndex color = ColorIndex::WHITE);

    void rect(uint8_t start_x, uint8_t start_y, size_t w, size_t h, bool fill = false, ColorIndex color = ColorIndex::WHITE);
    void circle(int radius, int x_center, int y_center, bool fill = false, ColorIndex color = ColorIndex::WHITE);
};

class TextWidget : public GraphicWidget
{
private:
    uint8_t current_char_line{0};

    uint8_t current_char_column{0};

    void write(char character, uint8_t char_column, uint8_t char_line);

    void clear_line();

    const unsigned char *font{nullptr};

    uint8_t tab_size{2};

    bool wrap{true};

    bool auto_next_char{true};

    void draw_glyph(const char character,
                    const uint8_t anchor_x, const uint8_t anchor_y);
 
protected:
    void create_text_buffer();
 
public:
    uint8_t number_of_column{0};
    uint8_t number_of_line{0};

    struct_ConfigTextWidget get_text_frame_config();

    size_t text_buffer_size;
    char *text_buffer = nullptr;

    TextWidget(GraphicDisplayDevice *graphic_display_screen,
               struct_ConfigTextWidget text_cfg,
               CanvasFormat canvas_format,
               Model *displayed_object = nullptr);

    TextWidget(GraphicDisplayDevice *graphic_display_screen,
               struct_ConfigTextWidget text_cfg,
               CanvasFormat canvas_format,
               size_t frame_width,
               size_t frame_height,
               Model *displayed_object = nullptr);

    virtual ~TextWidget();

    void update_text_frame_size(const unsigned char *font);

    void clear_text_buffer();

    void update_canvas_buffer_size(const unsigned char *font);

    void write();

    void write(const char *c_str);

    void process_char(char character);

    void next_line();

    void next_char();

    void draw();

    void draw_border(ColorIndex color = ColorIndex::WHITE);
};

class PrintWidget : public Widget
{
private:
protected:
public:
    PrintWidget(PrinterDevice *display_device, Model *actual_displayed_model = nullptr);
    virtual ~PrintWidget();
};