diagram.json

#ifndef _UTILS_H_
#define _UTILS_H_

typedef enum {
  none = 0x1FFFF, // basically simulating transparent, just makes any display draw return immediately instead of printing the pixels to the display, leaving the current pixels displayed
	white = 0xFFFF,
  black = 0x0001, // cannot use 0 as it is the default value for uninitialized structs 

  light_grey = 0xBDF7,
  dark_grey = 0x7BEF,
  light_gray = light_grey, // 'mericans
  dark_gray = dark_grey,
  
  red = 0xF800,
  yellow = 0xFFE0,
  orange = 0xFBE0,
  
  brown = 0x79E0,
  
  light_green = 0x7E0,
  dark_green = 0x0603,

  cyan = 0x7FF,
  blue = 0x1F,
  
  beige = 0xe5d6,
  pink = 0xF81F,
  purple = 0xb81f
} color_t;

typedef enum {
  north = 0,
  east = 1,
  south = 2,
  west = 3
} side_t;

#define SIZE_OF(x) sizeof(x)/sizeof(x[0])

#define DEFAULT 0
#define NONE 0

typedef enum return_code {
  hard_fault = 2, // dit. not. work
  soft_fault = 1, // something went wrong, but the main goal of the function was fulfilled
  success = 0// like . . . do I need to explain ?
};

struct rect_one_s { // defined by one point and a height/width
  uint16_t x, y, height, width;
};
struct rect_two_s { // defined by two opposing corners
  uint16_t x1, y1, x2, y2;
};

static inline rect_two_s to_rect_one (rect_one_s rect_one) {
  return rect_two_s {
    rect_one.x,
    rect_one.y,
    rect_one.x + rect_one.width,
    rect_one.y + rect_one.height
  };
}

#endif

utils.h

#ifndef _SETTINGS_H_
#define _SETTINGS_H_

// ================= DISPLAY ================= //

#define DISPLAY_INSTANCE 123 // SPI peripheral adress to use
#define DISPLAY_TRANS_TIMEOUT 1 // ms, timeout before transmission to display is aborted

#define DISPLAY_CS_PORT 123
#define DISPLAY_CS_PIN 10
#define DISPLAY_DC_PORT 123
#define DISPLAY_DC_PIN 9
#define DISPLAY_RST_PORT 123
#define DISPLAY_RST_PIN 8

//#define STRING_WRAP // Comment to disable text wraping when reaching right side of screen

// ================= MAIN MENU ================= //

#define DEFAULT_TILE_HEIGHT       40 // px
#define DEFAULT_TILE_COLOR        white // color_t (see utils.h)
#define DEFAULT_HEADER_COLOR      black // color_t (see utils.h)
#define DEFAULT_TILE_BACKGROUND   light_gray // color_t (see utils.h)

#define TILE_HEADER_FONT          Font_7x10 // font_s (see font.h)
#define TILE_HEADER_OFFSET        1 // px

#define DATA_VIEW_LATERAL_OFFSET  3 //px
#define DATA_VIEW_VERTICAL_OFFSET 3 //px
#define DATA_VIEW_HEIGHT          11 //px, not including bottom line
#define DATA_VIEW_DEFAULT_COLOR   dark_green

// ================= INTERACTABLES ================= //

#define DEFAULT_INTERACTABLES_HEADER_FONT Font_7x10 // font_s (see font.h)
#define CHECKBOX_SIZE                     (interactable -> height -10) // px, lenght of the sides of the box
#define CHECKBOX_LEFT_OFFSET              5
#define CHECKBOX_COLOR                    dark_green
#define INCREMENT_SIGNS_OFFSET            5

// ================= DATA STREAMS ================= //

#define DATA_STREAM_TYPE int16_t // has to be signed !
#define DATA_STREAM_MAX_VALUE 1023 // has to be enough for stuff like servos


#endif

settings.h

#ifndef _DEBUG_H_
#define _DEBUG_H_

// wait a minute . . . is this file CPP instead of C ?

// TODO :
// add line logging to crash
// add fast way to know if logging or displaying is required (implement priorities)

typedef enum{
  crash = -1, // unexpected state that might lead to unintended behaviour. a debug message with this flag reboots the board
  hardware_fault = 2, // could not communicate with an onboard peripheral

  tile_config = 3,

  milestone = 1, // major waypoint in code
  info = 0 // general purpose information
} severity_t;

static String processes[] = {
  "info",
  "WAYPOINT",
  "hardware failure !",
  "UI",
};

void debug(String message, severity_t severity = info){
  String prefix = "";

  switch (severity){
    case hardware_fault :
    case tile_config :
      prefix = "FATAL - ";
      break;

    case crash :
      prefix = "BOARD CRASH !!! ";
      break;
  };

  Serial.println("[DBG] " + prefix + processes[severity] + " : " + message);

  if (severity == crash){
    while(true) {
      Serial.println("restarting...");
      NVIC_SystemReset();
    }
  }
}

#endif

debug.h

#include <Wire.h>
#include <EEPROM.h>
#include <SPI.h>

#include "touch_driver.h"
#include "ILI9341_driver.h"
#include "GFX.h"

#include "settings.h"
#include "utils.h"

#include "main_menu_tiles.h"
#include "outputs.h"
#include "tiles_config.h"

#include "interactables.h"

#include "menu_manager.h"
#include "menu_config.h"

#include "graphics_item.h"

// TODO :

// ============================== urgent ==============================
// data views :
// figure out why bars are not emptied fully from time to time
// figure out why a left offset of 0 is considered incoherent
// implement inverted bars
// implement negative values for progress bars
// implement further data displaying on tiles

// properly finish the debug/trace library (before writing 10 000 lines of code and wondering if it'dve been a good idea to add logging)

// ============================== non-urgent ==============================
// implement frame buffering in the display's driver to enable high speed screen update (when displaying a menu for example)
//      need to check that we're able to screenfill very fast on simething faster than an arduino for it to work (DMA ?)
// implement extended background String drawing, to mask off previous text
// implement text wraping in different orientations (or remove entirely as it is not needed outside text zones)
// implement image displaying
// rounded rectangles ?

// ============================== backlog ==============================
// optimize char draw and String if possible (orientation management is a bit clumsy)
// optimise tile drawing (orientation management once again)




void setup() {
  Serial.begin(115200);
  debug("HAL init done, proceeding ...", milestone);
  SPI.begin();

  pinMode(DISPLAY_DC_PIN, OUTPUT);
  pinMode(DISPLAY_CS_PIN, OUTPUT);
  digitalWrite(DISPLAY_CS_PIN, HIGH);

  displayInit();
  touchInit();
  debug("display init done");

/*
  for (int i = 0; i < SIZE_OF(tiles); i++)
    drawItem(&tiles[i]);
  debug("tiles rendering done");

  for (int i = 0; i < SIZE_OF(interactables); i++)
    drawItem(&interactables[i]);

  drawString(50, 50, south, "345", Font_11x18,red, none);
*/

  drawItem(main_menu,0,2);

  graphics_item_s test_menu;
  box_1.gfx.type = box;
  addToMenu(&box_1, &test_menu);

  debug("User init done, proceeding ...", milestone);
}

void loop() {
  // should not be done, no_output should be left empty, for testing purposes only
  no_output.data1 = (int32_t)(analogRead(A0) * DATA_STREAM_MAX_VALUE) / 1023;

/*
  for (int i = 0; i < SIZE_OF(tiles); i++)
    updateItem(&tiles[i]);
*/
  if(ftTouched()){
    ftReadData();

    if(isInside(&interactables[0], ftGetX(), ftGetY())){
      interactables[0].value = !interactables[0].value;
      updateItem(&interactables[0]);
    }

    updateItem(main_menu,0,2);

    /*
    Serial.print(ftGetX()); Serial.print(" "); Serial.println(ftGetY());
    
    if(isInside(&interactables[0], ftGetX(), ftGetY())){
      interactables[0].value = !interactables[0].value;
      updateItem(&interactables[0]);
    }

    for(int i = 0; i < SIZE_OF(interactables); i++)
      Serial.println(isInside(&interactables[i], ftGetX(), ftGetY()));
    Serial.println();

    for (int i = 0; i < SIZE_OF(tiles); i++)
      Serial.print(isInside(&tiles[i], ftGetX(), ftGetY()));
    Serial.println();
*/
    while(ftTouched());
  }

  delay(5);
}


runtime.ino

font.h

#ifndef _GFX_H_
#define _GFX_H_

#include "settings.h"
#include "utils.h"
#include "font.h"
#include "ILI9341_driver.h"

void drawPixel(uint16_t X, uint16_t Y, color_t color);

void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color);
void drawArbitraryLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color); // if you know your line isn't straight (ie. vertical or horizontal), you can call this function directly, but it'll be called by drawLine anyways

void drawRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color);
void fillRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color);

// with X,Y the circle center
void drawCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color);
void fillCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color);

void drawChar(uint16_t x, uint16_t y, side_t orientation, char c, font_s font, color_t color, color_t background);
void drawString(uint16_t x, uint16_t y, side_t orientation, const char* str, font_s font, color_t color, color_t background);
/*

//USING CONVERTER: http://www.digole.com/tools/PicturetoC_Hex_converter.php
//65K colour (2Bytes / Pixel)
void ILI9341_Draw_Image(const char* Image_Array, uint8_t Orientation);

*/

void drawPixel(uint16_t X, uint16_t Y, color_t color) {
  displayDrawPixel(X, Y, color);
}

// might be from adafruit GFX . . . who knows . . .
void drawArbitraryLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color) {
  int16_t steep = abs(y1 - y0) > abs(x1 - x0);
  if (steep) {
    int16_t z;
    z = x0;
    x0 = y0;
    y0 = z;

    z = x1;
    x1 = y1;
    y1 = z;
  }

  if (x0 > x1) {
    int16_t z;
    z = x0;
    x0 = x1;
    x1 = z;

    z = y0;
    y0 = y1;
    y1 = z;
  }

  int16_t dx, dy;
  dx = x1 - x0;
  dy = abs(y1 - y0);

  int16_t err = dx / 2;
  int16_t ystep;

  if (y0 < y1) {
    ystep = 1;
  } else {
    ystep = -1;
  }

  for (; x0 <= x1; x0++) {
    if (steep) {
      displayDrawPixel(y0, x0, color);
    } else {
      displayDrawPixel(x0, y0, color);
    }
    err -= dy;
    if (err < 0) {
      y0 += ystep;
      err += dx;
    }
  }
}

void drawLine(int16_t X1, int16_t Y1, int16_t X2, int16_t Y2, color_t color) {
  if (X1 == X2 || Y1 == Y2) displayDraw(X1, Y1, X2, Y2, color);
  else drawArbitraryLine(X1, Y1, X2, Y2, color);
}

void drawRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  displayDraw(X1, Y1, X1, Y2, color);
  displayDraw(X2, Y1, X2, Y2, color);
  displayDraw(X1, Y1, X2, Y1, color);
  displayDraw(X1, Y2, X2, Y2, color);
}

void fillRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  displayDraw(X1, Y1, X2, Y2, color);
}

void fillCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color) {
  int x = radius - 1;
  int y = 0;
  int dx = 1;
  int dy = 1;
  int err = dx - (radius << 1);

  while (x >= y) {
    displayDraw(X - y, Y + x, X + y, Y + x, color);
    displayDraw(X - x, Y + y, X + x, Y + y, color);
    displayDraw(X - x, Y - y, X + x, Y - y, color);
    displayDraw(X - y, Y - x, X + y, Y - x, color);

    if (err <= 0) {
      y++;
      err += dy;
      dy += 2;
    }
    if (err > 0) {
      x--;
      dx += 2;
      err += (-radius << 1) + dx;
    }
  }
}

//Draw hollow circle at X,Y location with specified radius and colour. X and Y represent circles center
void drawCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color) {
  int x = radius - 1;
  int y = 0;
  int dx = 1;
  int dy = 1;
  int err = dx - (radius << 1);

  while (x >= y) {
    displayDrawPixel(X + x, Y + y, color);
    displayDrawPixel(X + y, Y + x, color);
    displayDrawPixel(X - y, Y + x, color);
    displayDrawPixel(X - x, Y + y, color);
    displayDrawPixel(X - x, Y - y, color);
    displayDrawPixel(X - y, Y - x, color);
    displayDrawPixel(X + y, Y - x, color);
    displayDrawPixel(X + x, Y - y, color);

    if (err <= 0) {
      y++;
      err += dy;
      dy += 2;
    }
    if (err > 0) {
      x--;
      dx += 2;
      err += (-radius << 1) + dx;
    }
  }
}

void drawChar(uint16_t x, uint16_t y, side_t orientation, char c, font_s font, color_t color, color_t background){
  uint8_t i, j;
  uint16_t b;
  
  if(background != none) // avoid tons of coordinates calculations to pass to the function . . . just not to draw the rectangle
    switch (orientation){
      case south : displayDraw(x,y - 1,x + font.width - 1, y + font.height,background); break;
      case north : displayDraw(x - font.width - 1,y - font.height,x, y + 1,background); break;
      case east : displayDraw(x - 1,y - font.width + 1,x + font.height, y,background); break;
      case west : displayDraw(x - font.height,y,x + 1, y + font.width - 1,background); break;
    }

  for(i = 0; i < font.height; i++) {
    b = font.data[(c - 32) * font.height + i];
    for(j = 0; j < font.width; j++) {
      if((b << j) & 0x8000)  {
        switch (orientation){
          case south : displayDrawPixel(x + j, y + i,color); break;
          case north : displayDrawPixel(x - j, y - i,color); break;
          case east : displayDrawPixel(x + i,y - j,color); break;
          case west : displayDrawPixel(x - i,y + j,color); break;
        }
      }
    }
  }
}

void drawString(uint16_t x, uint16_t y, side_t orientation, const char* str, font_s font, color_t color, color_t background) {
  uint8_t lenght = strlen(str);
  for (uint8_t i = 0; i < lenght; i++) {
    #ifdef STRING_WRAP
    if(x + font.width >= DISPLAY_WIDTH) {
      x = 0;
      y += font.height;
      if(y + font.height >= DISPLAY_HEIGHT) {
        break;
      } 

      if(*str == ' ') {
        // skip spaces in the beginning of the new line
        str++;
        continue;
      }
    }
    #endif 

    drawChar(x, y, orientation, str[i], font, color, background);

    switch (orientation){
      case south : x += font.width; break;
      case north : x -= font.width; break;
      case east : y -= font.width; break;
      case west : y += font.width; break;
    }
  }
}

#endif


GFX.h

#ifndef _ILI9341_DRIVER_H_
#define _ILI9341_DRIVER_H_

#include "HAL.h"

#include "settings.h"
#include "utils.h"

#define DISPLAY_WIDTH 240
#define DISPLAY_HEIGHT 320

typedef enum {
  data_mode = GPIO_PIN_SET,
  command_mode = GPIO_PIN_RESET
} display_mode_t;

void displayMode(display_mode_t mode);
void displaySelect(bool state);
void displayReset(void);
void displayInit(void);
void displayDraw(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color);
void displayDrawPixel(uint16_t X, uint16_t Y, color_t color);
void displayFill(color_t color);


static uint8_t buffer[20]; // note : adress 0 is the command, next adresses are the data

// ================================ Hardware abstraction ================================ //

static void displayMode(display_mode_t mode) {
  HAL_GPIO_WritePin(DISPLAY_DC_PORT, DISPLAY_DC_PIN, mode);
}

static void displaySelect(bool state) {
  HAL_GPIO_WritePin(DISPLAY_CS_PORT, DISPLAY_CS_PIN, !state);
}

// ================================ Low level ================================ //

// Send command (char) to LCD
static void displayWrite(uint8_t *data_buffer, uint16_t lenght, display_mode_t mode) {
  displayMode(mode);
  HAL_SPI_Transmit(DISPLAY_INSTANCE, data_buffer, lenght, DISPLAY_TRANS_TIMEOUT);
}
void displaySend(uint8_t *data_buffer, uint16_t lenght) {
  displaySelect(true);
  displayWrite(&data_buffer[0], 1, command_mode);
  if (lenght != 0) displayWrite(&data_buffer[1], lenght, data_mode);
  displaySelect(false);
}
void displayCommand(uint8_t command) {
  displaySelect(true);
  displayWrite(&command, 1, command_mode);
  displaySelect(false);
}

//HARDWARE RESET
static void displayReset(void) {
  HAL_GPIO_WritePin(DISPLAY_RST_PORT, DISPLAY_RST_PIN, GPIO_PIN_RESET);
  //HAL_Delay(200);
  //HAL_GPIO_WritePin(DISPLAY_CS_PORT, DISPLAY_CS_PIN, GPIO_PIN_RESET);
  HAL_Delay(200);
  HAL_GPIO_WritePin(DISPLAY_RST_PORT, DISPLAY_RST_PIN, GPIO_PIN_SET);
}

//Initialize LCD display
static void displayInit(void) {

  displayReset();

  //SOFTWARE RESET
  displayCommand(0x01);
  //HAL_Delay(1000);
  HAL_Delay(200);

  //POWER CONTROL A
  buffer[0] = 0xCB;
  buffer[1] = 0x39;
  buffer[2] = 0x2C;
  buffer[3] = 0x00;
  buffer[4] = 0x34;
  buffer[5] = 0x02;
  displaySend(buffer, 5);

  //POWER CONTROL B
  buffer[0] = 0xCF;
  buffer[1] = 0x00;
  buffer[2] = 0xC1;
  buffer[3] = 0x30;
  displaySend(buffer, 3);

  //DRIVER TIMING CONTROL A
  buffer[0] = 0xE8;
  buffer[1] = 0x85;
  buffer[2] = 0x00;
  buffer[3] = 0x78;
  displaySend(buffer, 3);

  //DRIVER TIMING CONTROL B
  buffer[0] = 0xEA;
  buffer[1] = 0x00;
  buffer[2] = 0x00;
  displaySend(buffer, 2);

  //POWER ON SEQUENCE CONTROL
  buffer[0] = 0xED;
  buffer[1] = 0x64;
  buffer[2] = 0x03;
  buffer[3] = 0x12;
  buffer[4] = 0x81;
  displaySend(buffer, 4);

  //PUMP RATIO CONTROL
  buffer[0] = 0xF7;
  buffer[1] = 0x20;
  displaySend(buffer, 1);

  //POWER CONTROL,VRH[5:0]
  buffer[0] = 0xC0;
  buffer[1] = 0x23;
  displaySend(buffer, 1);

  //POWER CONTROL,SAP[2:0];BT[3:0]
  buffer[0] = 0xC1;
  buffer[1] = 0x10;
  displaySend(buffer, 1);

  //VCM CONTROL
  buffer[0] = 0xC5;
  buffer[1] = 0x3E;
  buffer[2] = 0x28;
  displaySend(buffer, 2);

  //VCM CONTROL 2
  buffer[0] = 0xC7;
  buffer[1] = 0x86;
  displaySend(buffer, 1);

  //MEMORY ACCESS CONTROL
  buffer[0] = 0x36;
  buffer[1] = 0x48;
  displaySend(buffer, 1);

  //PIXEL FORMAT
  buffer[0] = 0x3A;
  buffer[1] = 0x55;
  displaySend(buffer, 1);

  //FRAME RATIO CONTROL, STANDARD RGB COLOR
  buffer[0] = 0xB1;
  buffer[1] = 0x00;
  buffer[2] = 0x18;
  displaySend(buffer, 2);

  //DISPLAY FUNCTION CONTROL
  buffer[0] = 0xB6;
  buffer[1] = 0x08;
  buffer[2] = 0x82;
  buffer[3] = 0x27;
  displaySend(buffer, 3);

  //3GAMMA FUNCTION DISABLE
  buffer[0] = 0xF2;
  buffer[1] = 0x00;
  displaySend(buffer, 1);

  //GAMMA CURVE SELECTED
  buffer[0] = 0x26;
  buffer[1] = 0x01;
  displaySend(buffer, 1);

  //POSITIVE GAMMA CORRECTION
  buffer[0] = 0xE0;
  buffer[1] = 0x0F;
  buffer[2] = 0x31;
  buffer[3] = 0x2B;
  buffer[4] = 0x0C;
  buffer[5] = 0x0E;
  buffer[6] = 0x08;
  buffer[7] = 0x4E;
  buffer[8] = 0xF1;
  buffer[9] = 0x37;
  buffer[10] = 0x07;
  buffer[11] = 0x10;
  buffer[12] = 0x03;
  buffer[13] = 0x0E;
  buffer[14] = 0x09;
  buffer[15] = 0x00;
  displaySend(buffer, 15);

  //NEGATIVE GAMMA CORRECTION
  buffer[0] = 0xE1;
  buffer[1] = 0x00;
  buffer[2] = 0x0E;
  buffer[3] = 0x14;
  buffer[4] = 0x03;
  buffer[5] = 0x11;
  buffer[6] = 0x07;
  buffer[7] = 0x31;
  buffer[8] = 0xC1;
  buffer[9] = 0x48;
  buffer[10] = 0x08;
  buffer[11] = 0x0F;
  buffer[12] = 0x0C;
  buffer[13] = 0x31;
  buffer[14] = 0x36;
  buffer[15] = 0x0F;
  displaySend(buffer, 15);

  //EXIT SLEEP
  displayCommand(0x11);
  HAL_Delay(120);

  //TURN ON DISPLAY
  displayCommand(0x29);

  //SET ROTATION
  buffer[0] = 0x36;
  buffer[1] = 0x40|0x08;
  displaySend(buffer,1);
}

// ================================ Display primitives ================================ //

// TODO : optimize color sending (make less calls to HAL's function, using proper array dimensions)
//Set Address - Location block - to draw into
static void displayDraw(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  if(color == none) return;

  uint16_t Z;
  if(X1 > X2){
    Z = X2;
    X2 = X1;
    X1 = Z;
  }
  if(Y1 > Y2){
    Z = Y2;
    Y2 = Y1;
    Y1 = Z;
  }

  if(X1 >= DISPLAY_WIDTH || Y1 >= DISPLAY_HEIGHT || X2 < 0 || Y2 < 0) return; // trying to display outside of the screen

  if(X2 > DISPLAY_WIDTH -1) X2 = DISPLAY_WIDTH -1;
  if(Y2 > DISPLAY_HEIGHT -1) Y2 = DISPLAY_HEIGHT -1;
  if(X1 < 0) X1 = 0;
  if(Y1 < 0) Y1 = 0;
 
  buffer[0] = 0x2A;
  buffer[1] = X1 >> 8;
  buffer[2] = X1;
  buffer[3] = X2 >> 8;
  buffer[4] = X2;
  displaySend(buffer, 4);

  buffer[0] = 0x2B;
  buffer[1] = Y1 >> 8;
  buffer[2] = Y1;
  buffer[3] = Y2 >> 8;
  buffer[4] = Y2;
  displaySend(buffer, 4);

  uint32_t size = (uint32_t)(X2 - X1 +1) * (uint32_t)(Y2 - Y1 +1);

  // cannot use standard displaySend function due to the absolutely absurt amount of data sent out
  displaySelect(true);
  buffer[0] = 0x2C;
  displayWrite(buffer,1,command_mode);
  for(; size > 0; size--){  
    uint8_t data[] = {color >> 8,color & 0xFF};
    displayWrite(data,2,data_mode);
  }
  displaySelect(false);
}

//DRAW PIXEL AT XY POSITION WITH SELECTED COLOUR
//Using pixels to draw big simple structures is not recommended as it is really slow
//Try using either rectangles or lines if possible
static void displayDrawPixel(uint16_t X, uint16_t Y, color_t color) {
  if (color == none) return;
  if (X >= DISPLAY_WIDTH || Y >= DISPLAY_HEIGHT || X < 0 || Y < 0) return;	// Out of screen

  //XDATA
  buffer[0] = 0x2A;
  buffer[1] = X >> 8;
  buffer[2] = X;
  buffer[3] = (X) >> 8;
  buffer[4] = (X);
  displaySend(buffer, 4);

  //YDATA
  buffer[0] = 0x2B;
  buffer[1] = Y >> 8;
  buffer[2] = Y;
  buffer[3] = (Y) >> 8;
  buffer[4] = (Y);
  displaySend(buffer, 4);

  //COLOR
  buffer[0] = 0x2C;
  buffer[1] = color >> 8;
  buffer[2] = color;
  displaySend(buffer, 2);
}

// ================================ Graphics primitives ================================ //

// fill the entire screen with selected color (no effect if using "none" color obviously)
static void displayFill(color_t color) {
  displayDraw(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1, color);
}

#endif



ILI9341_driver.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries



libraries.txt

#ifndef _HAL_H_
#define _HAL_H_

#define GPIO_PIN_SET 1
#define GPIO_PIN_RESET 0

#define HAL_MAX_DELAY 0xFFFF

void NVIC_SystemReset(void);
void HAL_GPIO_WritePin(uint8_t port, uint8_t pin, bool value);
void HAL_SPI_Transmit(void *instance, uint8_t *data, uint16_t lenght, uint32_t timeout);
void HAL_Delay(uint16_t ms);
void HAL_I2C_Master_Transmit (void* instance, uint16_t addr, uint8_t *data, uint16_t lenght, uint32_t Timeout);
void HAL_I2C_Master_Receive (void* instance, uint16_t addr, uint8_t *data, uint16_t size, uint32_t Timeout);

#endif

HAL.h

#include <Arduino.h>
#include <SPI.h>
#include <Wire.h>

#include <avr/wdt.h>
void NVIC_SystemReset() {
  wdt_enable(WDTO_15MS);
  while (true);
}

void HAL_GPIO_WritePin(uint8_t port, uint8_t pin, bool value) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, value);
}

void HAL_SPI_Transmit(void *instance, uint8_t *data, uint16_t lenght, uint32_t timeout) {
  SPI.beginTransaction(SPISettings(20000000, MSBFIRST, SPI_MODE0));
  SPI.transfer(data, lenght);
  SPI.endTransaction();
}

void HAL_Delay(uint16_t ms) {
  delay(ms);
}

void HAL_I2C_Master_Transmit (void* instance, uint16_t addr, uint8_t *data, uint16_t lenght, uint32_t Timeout){
  Wire.beginTransmission((uint8_t)addr);
  Wire.write(data,lenght);
  Wire.endTransmission();
}

void HAL_I2C_Master_Receive (void* instance, uint16_t addr, uint8_t *data, uint16_t size, uint32_t Timeout){
  Wire.requestFrom((uint8_t)addr, size);
  for (uint16_t i = 0; i < size; i++)
    data[i] = Wire.read();
  Wire.endTransmission();
}


HAL.cpp

#ifndef _MAIN_MENU_TILES_H_
#define _MAIN_MENU_TILES_H_

#include "utils.h"
#include "GFX.h"
#include "outputs.h"
#include "debug.h"
#include "data_view.h"

struct menu_tile_s {
  char* header;
  output_s* output;
  tile_view_t view_type;
  uint16_t left_offset;
  side_t side;
  uint16_t width;

  // optional
  uint8_t height;
  color_t view_color;
  color_t color;
  color_t header_color;
  color_t background;

  // do not populate
  uint16_t x1, y1, x2, y2; // absolute to screen coordinates, will be populated when the tile is drawn for the first time
  uint16_t header_x, header_y;
  data_view_s view1, view2;
  bool initialized;
  bool incoherent;
};

// approch here is that, since we have loads of ram, calculate all attributes in advance and store them, only retrieving them at drawing time, limiting CPU usage
// in a nutshell : trading ram for performance
static void initItem(menu_tile_s *tile){ 
  // initializes all missing parameters for a tile
  if(tile -> height == 0) tile -> height = DEFAULT_TILE_HEIGHT;
  if(tile -> color == 0) tile -> color = DEFAULT_TILE_COLOR;
  if(tile -> header_color == 0) tile -> header_color = DEFAULT_HEADER_COLOR;
  if(tile -> background == 0) tile -> background = DEFAULT_TILE_BACKGROUND;
  if(tile -> view_color == 0) tile -> view_color = DATA_VIEW_DEFAULT_COLOR;

  tile -> view1.color = tile -> view_color;
  tile -> view1.background = &(tile -> background);
  tile -> view2.color = tile -> view_color;
  tile -> view2.background = &(tile -> background);

  // initializes all relevant coordinates (kinda ugly to do it this way, but don't really have the choice)
  switch (tile -> side){
    case north :
      // calculate tile coordinates
      tile -> x1 = DISPLAY_WIDTH - tile -> left_offset - tile -> width;
      tile -> y1 = 0;
      tile -> x2 = DISPLAY_WIDTH - tile -> left_offset;
      tile -> y2 = tile -> height;

      // calculate header coordinates
      tile -> header_x = tile->x1 + tile->width/2 + strlen(tile->header)*TILE_HEADER_FONT.width/2 -1;
      tile -> header_y = TILE_HEADER_FONT.height + TILE_HEADER_OFFSET;

      // calculate data view coordinates
      tile -> view1.x1 = tile -> x1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_VERTICAL_OFFSET -1;
      tile -> view1.y1 = tile -> view1.y2 - DATA_VIEW_HEIGHT +1; 

      if(tile -> view_type == progress_bars){ // need to divide the space in two bars in this case
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x2 = tile -> view1.x2;
        
        tile -> view1.y1 += DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.y2 = tile -> view1.y1 -2;
      }

      // add data view attributes
      tile -> view1.invert = true;
      tile -> view2.invert = true;
      break;
    case south :
      tile -> x1 = tile -> left_offset;
      tile -> y1 = DISPLAY_HEIGHT -1 - tile -> height;
      tile -> x2 = tile -> left_offset + tile -> width;
      tile -> y2 = DISPLAY_HEIGHT -1;

      tile -> header_x = tile->x1 + tile->width/2 - strlen(tile->header)*TILE_HEADER_FONT.width/2 +1;
      tile -> header_y = DISPLAY_HEIGHT -1 - TILE_HEADER_FONT.height - TILE_HEADER_OFFSET;

      tile -> view1.x1 = tile -> x1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_VERTICAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.y2 = tile -> view1.y1 + DATA_VIEW_HEIGHT -1;

      if(tile -> view_type == progress_bars){
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y2 = tile -> view1.y2;
        tile -> view2.x2 = tile -> view1.x2;
        
        tile -> view1.y2 -= DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.y1 = tile -> view1.y2 +2;
      }

      break;
    case east :
      tile -> x1 = DISPLAY_WIDTH -1 - tile -> height;
      tile -> y1 = DISPLAY_HEIGHT - (tile -> left_offset + tile -> width);
      tile -> x2 = DISPLAY_WIDTH -1;
      tile -> y2 = DISPLAY_HEIGHT - tile -> left_offset -1;

      tile -> header_x = DISPLAY_WIDTH -1 - TILE_HEADER_FONT.height - TILE_HEADER_OFFSET;
      tile -> header_y = tile->y1 + tile->width/2 + strlen(tile->header)*TILE_HEADER_FONT.width/2 -1;
      
      tile -> view1.x1 = tile -> x1 + DATA_VIEW_VERTICAL_OFFSET +1;
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> view1.x1 + DATA_VIEW_HEIGHT -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_LATERAL_OFFSET -1;

      if(tile -> view_type == progress_bars){
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x2 = tile -> view1.x2;
        tile -> view2.y2 = tile -> view1.y2;
        
        tile -> view1.x2 -= DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.x1 = tile -> view1.x2 +2;
      }

      tile -> view1.vertical = true;
      tile -> view1.invert = true;
      tile -> view2.vertical = true;
      tile -> view2.invert = true;
      break;
    case west :
      tile -> x1 = 0;
      tile -> y1 = tile -> left_offset;
      tile -> x2 = tile -> height;
      tile -> y2 = tile -> left_offset + tile -> width;

      tile -> header_x = TILE_HEADER_FONT.height + TILE_HEADER_OFFSET;
      tile -> header_y = tile->y1 + tile->width/2 - strlen(tile->header)*TILE_HEADER_FONT.width/2 +1;
      
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_VERTICAL_OFFSET -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.x1 = tile -> view1.x2 - DATA_VIEW_HEIGHT +1;
      
      if(tile -> view_type == progress_bars){
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y2 = tile -> view1.y2;
        
        tile -> view1.x1 += DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.x2 = tile -> view1.x1 -2;
      }
      
      tile -> view1.vertical = true;
      tile -> view2.vertical = true;
      break;
  }

  // determine if tile config is coherent (mostly if it is in screen)
  if (  tile -> x1 < 0 ||
        tile -> y1 < 0 ||
        tile -> x2 >= DISPLAY_WIDTH || 
        tile -> y2 >= DISPLAY_HEIGHT
  ){
    debug("tile config incoherent, cannot display", tile_config);
    debug(tile -> header, tile_config);
    tile -> incoherent = true;
  } else {
    tile -> incoherent = false; // might do dynamic tile modifications at some point, so we want to be able to clear this flag if we run init again
  }

  tile -> initialized = true;
}

static void updateItem(menu_tile_s *tile){
  if(tile -> incoherent) return;
    
  switch (tile -> view_type){
    case progress_bars :
      updateItem(&(tile -> view2), tile -> output -> data2);    
    case progress_bar :
      updateItem(&(tile -> view1), tile -> output -> data1);    
      break;
  }
}

static void drawItem(menu_tile_s *tile){ // display a tile in absolute coordinates on a specified side
  if(!tile->initialized) initItem(tile);
  if(tile -> incoherent) return;

  // tile itself and background
  fillRectangle(tile -> x1,tile -> y1,tile -> x2,tile -> y2,tile -> background);
  drawRectangle(tile -> x1,tile -> y1,tile -> x2,tile -> y2,tile -> color);

  //header
  drawString(tile -> header_x, tile -> header_y, tile -> side, tile -> header, TILE_HEADER_FONT, tile -> header_color, none);
  
  // data view outline
  switch (tile -> view_type){
    case progress_bars :
      drawRectangle(tile -> view2.x1 -1, tile -> view2.y1 -1, tile -> view2.x2 +1, tile -> view2.y2 +1,tile -> color);
    case progress_bar:
      drawRectangle(tile -> view1.x1 -1, tile -> view1.y1 -1, tile -> view1.x2 +1, tile -> view1.y2 +1,tile -> color);
      break;
  }
}

static bool isInside(menu_tile_s *tile, uint16_t x, uint16_t y){
  return (x >= tile -> x1 && x <= tile -> x2 && y >= tile -> y1 && y <= tile -> y2);
}


#endif

main_menu_tiles.h

#ifndef _OUTPUTS_H_
#define _OUTPUTS_H_

typedef enum{
  not_output_type = 0,
  servo,
  pwm,
  analog,

} output_types_t;

struct output_s {
  output_types_t type;
  DATA_STREAM_TYPE data1;
  DATA_STREAM_TYPE data2;

  bool can_reverse;
};

output_s no_output; // used as a placeholder for items that aren't linked to an output just yet

#endif

outputs.h

#ifndef _PROGRESS_BAR_H_
#define _PROGRESS_BAR_H_

#include "utils.h"
#include "settings.h"

typedef enum tile_view_t {
  no_tile_view = 0,
  progress_bar,
  progress_bars,
  gauge
};

struct data_view_s {
  uint16_t x1, y1, x2, y2;
  tile_view_t type;
  color_t color;
  color_t* background;

  // optionnal (defaults to left ot right, horizontal to allow for easy general progress bar implementation)
  bool vertical;
  bool invert;
  bool can_reverse;

  // do not populate
  DATA_STREAM_TYPE old_data;
  int16_t old_value;
};

static void updateItem(data_view_s *view, DATA_STREAM_TYPE new_data){
  if(new_data == view -> old_data) return;
  view -> old_data = new_data;

  int16_t lower_bound = view -> can_reverse ? -DATA_STREAM_MAX_VALUE : 0;
  int16_t upper_bound = DATA_STREAM_MAX_VALUE;
/*
  if(view -> invert){
    int16_t third;

    third = upper_bound;
    upper_bound = lower_bound;
    lower_bound = third;
  }
*/
  int16_t value = map(
    new_data,
    lower_bound,
    upper_bound,
    0,
    (view -> vertical ? view -> y2 - view -> y1 : view -> x2 - view -> x1) //full infill and no infill are reserved for absolute max and 0
  );

  if (value == view -> old_value) return;
  view -> old_value = value;

  if (view -> vertical){
    // mask off previous bar
    if (new_data != DATA_STREAM_MAX_VALUE) fillRectangle(view -> x1, view -> y1 + value, view -> x2, view -> y2,*(view -> background));
    // fill new bar
    if (new_data != 0) fillRectangle(view -> x1, view -> y1, view -> x2, view -> y1 + value,view -> color);
  } else {
    if (new_data != DATA_STREAM_MAX_VALUE) fillRectangle(view -> x1 + value, view -> y1, view -> x2, view -> y2,*(view -> background));
    if (new_data != 0) fillRectangle(view -> x1, view -> y1, view -> x1 + value, view -> y2,view -> color);
  }
}

#endif

data_view.h

#ifndef _TILE_CONFIG_H_
#define _TILE_CONFIG_H_

#include "main_menu_tiles.h"

/*
tile definition :
{
  // mendatory :
  header (char*)
  pointer to output struct (only no_output for now)
  data view type (no_data_view, progress_bar, progress_bars, gauge)
  tile offset (from left wall)
  tile side (north, south, east, west)
  tile width
 
  //optionnal : (for colors, see color_t in utils.h) (NO_DATA for default value as defined in settings.h)
  tile height 
  data view color 
  tile outline color 
  tile header color 
  tile infill color 
  tile height
}
*/

menu_tile_s tiles[] = {
{
  "@@",
  &no_output,
  progress_bars, 
  100,
  east,
  50,
  
  30,
  purple,
  blue,
  light_green,
  dark_gray
},{
  "tile example 2",
  &no_output,
  progress_bars,
  120,
  west,
  160
},{
  "ex4",
  &no_output,
  progress_bars,
  40,
  south,
  50,

  DEFAULT,
  blue
},{
  "ex5",
  &no_output,
  progress_bars,
  40,
  east,
  50
},{
  "A",
  &no_output,
  progress_bars,
  1,
  north,
  30
},{
  "B",
  &no_output,
  progress_bars,
  30,
  north,
  30
},{
  "C",
  &no_output,
  progress_bar,
  60,
  north,
  30
},{
  "D",
  &no_output,
  progress_bars,
  90,
  north,
  30
},{
  "E",
  &no_output,
  progress_bars,
  120,
  north,
  30
},{
  "F",
  &no_output,
  progress_bars,
  150,
  north,
  30
},{
  "G",
  &no_output,
  progress_bars,
  180,
  north,
  30
},{
  "H",
  &no_output,
  progress_bars,
  210,
  north,
  30
}
};

#endif

tiles_config.h

#ifndef _TOUCH_C_
#define _TOUCH_C_

// Quick and dirty driver for the touch driver, intended to be replaced on final hardware

#include "HAL.h"

#define FT62XX_DEFAULT_ADDR 0x38   //!< I2C address
#define FT62XX_G_FT5201ID 0xA8     //!< FocalTech's panel ID
#define FT62XX_REG_NUMTOUCHES 0x02 //!< Number of touch points

#define FT62XX_NUM_X 0x33 //!< Touch X position
#define FT62XX_NUM_Y 0x34 //!< Touch Y position

#define FT62XX_REG_MODE 0x00        //!< Device mode, either WORKING or FACTORY
#define FT62XX_REG_CALIBRATE 0x02   //!< Calibrate mode
#define FT62XX_REG_WORKMODE 0x00    //!< Work mode
#define FT62XX_REG_FACTORYMODE 0x40 //!< Factory mode
#define FT62XX_REG_THRESHHOLD 0x80  //!< Threshold for touch detection
#define FT62XX_REG_POINTRATE 0x88   //!< Point rate
#define FT62XX_REG_FIRMVERS 0xA6    //!< Firmware version
#define FT62XX_REG_CHIPID 0xA3      //!< Chip selecting
#define FT62XX_REG_VENDID 0xA8      //!< FocalTech's panel ID

#define FT62XX_VENDID 0x11  //!< FocalTech's panel ID
#define FT6206_CHIPID 0x06  //!< Chip selecting
#define FT6236_CHIPID 0x36  //!< Chip selecting
#define FT6236U_CHIPID 0x64 //!< Chip selecting
#define FT6336U_CHIPID 0x64 //!< Chip selecting

// calibrated for Adafruit 2.8" ctp screen
#define FT62XX_DEFAULT_THRESHOLD 0 //!< Default threshold for touch detection

uint16_t touchX, touchY;
uint16_t max_x, max_y;

// ================================ Low level ================================ //

uint8_t ftReadRegister8(uint8_t reg) {
  uint8_t buffer[1] = {reg};
  HAL_I2C_Master_Transmit(123, FT62XX_DEFAULT_ADDR, buffer, 1, 123);
  HAL_I2C_Master_Receive(123, FT62XX_DEFAULT_ADDR, buffer, 1, 123);
  return buffer[0];
}

void ftWriteRegister8(uint8_t reg, uint8_t val) {
  uint8_t buffer[2] = {reg, val};
  HAL_I2C_Master_Transmit(123, FT62XX_DEFAULT_ADDR, buffer, 2, 123);
}

void ftReadData(void) {
  uint8_t data[16];
  uint8_t addr = 0;
  
  HAL_I2C_Master_Transmit (123, FT62XX_DEFAULT_ADDR, addr, 1, 123);
  HAL_I2C_Master_Receive (123, FT62XX_DEFAULT_ADDR, data, 16, 123);

  touchX = data[2] & 0x0F;
  touchX <<= 8;
  touchX |= data[3];
  touchY = data[4] & 0x0F;
  touchY <<= 8;
  touchY |= data[5];
/*
  for(int i = 0; i<16; i++){
    Serial.print(data[i],HEX);
    Serial.print(" ");
  }

  Serial.println();
*/
}
// ================================ High level ================================ //

bool touchInit() {
  // change threshhold to be higher/lower if desired
  ftWriteRegister8(FT62XX_REG_THRESHHOLD, FT62XX_DEFAULT_THRESHOLD);

  if (ftReadRegister8(FT62XX_REG_VENDID) != FT62XX_VENDID) {
    return false;
  }
  
  uint8_t id = ftReadRegister8(FT62XX_REG_CHIPID);
  if ((id != FT6206_CHIPID) && (id != FT6236_CHIPID) && (id != FT6236U_CHIPID) && (id != FT6336U_CHIPID)) {
    return false;
  }

  return true;
}

uint8_t ftTouched(void) {
  return ftReadRegister8(FT62XX_REG_NUMTOUCHES);
}

uint16_t ftGetX(void){
  return 240 - touchX;
}

uint16_t ftGetY(void){
  return 320 - touchY;
}

#endif

touch_driver.h

#ifndef _TILE_CONFIG_H_
#define _TILE_CONFIG_H_

#include "submenus.h"

submenu_s menus[] = {

};

#endif

menus_config.h

#ifndef _INTERACTABLES_H_
#define _INTERACTABLES_H_

typedef enum interactable_t {
  no_interactable = 0,
  checkbox,
  yesno,
  list,
  button,
  slider,
  increment
};

struct checkbox_s {
  uint16_t box_x1, box_y1, box_x2, box_y2;
};

struct increment_s {
  uint16_t  line1_x, line2_x, line1_y, line2_y, // actually, y is the second point while x is the first (needed because coordinates for interactables are represented by height/width)
            minus_x1, minus_x2, minus_y, 
            plus_x1, plus_y1, plus_y2, 
            plus_x2, plus_x3, plus_y3,
            value_x, value_y;
};

struct interactable_s {
  char* header;
  interactable_t type;
  uint16_t x;
  uint16_t y;
  uint16_t width;
  uint16_t height;
  font_s font;

  // optional
  DATA_STREAM_TYPE value;
  bool can_reverse;
  // TODO : pointeur sur fonction lors de l'update
  color_t color;
  color_t header_color;
  color_t background;

  // do not populate
  union {
    checkbox_s checkbox;
    increment_s increment;
  };
  uint16_t header_x, header_y;
  DATA_STREAM_TYPE old_value;
  bool initialized;
  bool incoherent;
};

// approch here is that, since we have loads of ram, calculate all attributes in advance and store them, only retrieving them at drawing time, limiting CPU usage
// in a nutshell : trading ram for performance
static void initItem(interactable_s *interactable){ 
  // initializes all missing parameters for the interactable
  if(interactable -> color == 0) interactable -> color = DEFAULT_TILE_COLOR;
  if(interactable -> header_color == 0) interactable -> header_color = DEFAULT_HEADER_COLOR;
  if(interactable -> background == 0) interactable -> background = DEFAULT_TILE_BACKGROUND;
  
  interactable -> header_x = interactable->x + interactable->width/2 - strlen(interactable->header)*interactable -> font.width/2 +1;
  
  switch (interactable -> type){
    case checkbox:
      //interactable -> header_x += CHECKBOX_LEFT_OFFSET + CHECKBOX_SIZE; // actually looks better without it
      interactable -> header_y = interactable ->y + interactable -> height/2 - interactable -> font.height/2;
      interactable -> checkbox.box_x1 = interactable -> x + CHECKBOX_LEFT_OFFSET;
      interactable -> checkbox.box_y1 = interactable -> y + interactable -> height/2 - CHECKBOX_SIZE/2;
      interactable -> checkbox.box_x2 = interactable -> checkbox.box_x1 + CHECKBOX_SIZE;
      interactable -> checkbox.box_y2 = interactable -> checkbox.box_y1 + CHECKBOX_SIZE;
      break;
    case increment :
      interactable -> increment.value_x = interactable->x + interactable->width/2 - 4*interactable -> font.width/2 +1;
      interactable -> increment.value_y = interactable ->y + interactable -> height/2 - interactable -> font.height/2;

      interactable -> increment.line1_x = interactable -> x + interactable -> height;
      interactable -> increment.line1_y = interactable -> y + interactable -> height;
      interactable -> increment.line2_x = interactable -> x + interactable -> width - interactable -> height;
      interactable -> increment.line2_y = interactable -> y + interactable -> height;

      interactable -> increment.minus_x1 = interactable -> x + INCREMENT_SIGNS_OFFSET;
      interactable -> increment.minus_x2 = interactable -> increment.line1_x - INCREMENT_SIGNS_OFFSET;
      interactable -> increment.minus_y = interactable -> y + interactable -> height/2; 

      interactable -> increment.plus_x1 = interactable -> increment.line2_x + (interactable -> x + interactable -> width - interactable -> increment.line2_x)/2;
      interactable -> increment.plus_y1 = interactable -> y + INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_y2 = interactable -> y + interactable -> height - INCREMENT_SIGNS_OFFSET;

      interactable -> increment.plus_x2 = interactable -> x + interactable -> width - INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_x3 = interactable -> increment.line2_x + INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_y3 = interactable -> y + interactable -> height/2;
      //interactable -> header_x = interactable->x + interactable->width/2 - 4*interactable -> font.width/2 +1;
      break;
  }

  // determine if tile config is coherent (mostly if it is in screen)
  if (  interactable -> x < 0 ||
        interactable -> y < 0 ||
        interactable -> x + interactable -> width >= DISPLAY_WIDTH || 
        interactable -> y + interactable -> height >= DISPLAY_HEIGHT
  ){
    debug("interactable config incoherent, cannot display", tile_config);
    debug(interactable -> header, tile_config);
    interactable -> incoherent = true;
  } else {
    interactable -> incoherent = false; // might do dynamic tile modifications at some point, so we want to be able to clear this flag if we run init again
  }

  interactable -> initialized = true;
}

static void updateItem(interactable_s *interactable){
  if(interactable -> incoherent) return;
  if(interactable -> value == interactable -> old_value) return;
  interactable -> old_value = interactable -> value;

  switch (interactable -> type){
    case checkbox :
      fillRectangle(interactable -> checkbox.box_x1 +1,interactable -> checkbox.box_y1 +1,interactable -> checkbox.box_x2 -1,interactable -> checkbox.box_y2 -1,(interactable -> value != 0 ? CHECKBOX_COLOR : black));
      break;
  }
}


static void drawItem(interactable_s *interactable){ // display a tile in absolute coordinates on a specified side
  if(!interactable->initialized) initItem(interactable);
  if(interactable -> incoherent) return;

  // interactable itself and background
  fillRectangle(interactable -> x +1,interactable -> y +1,interactable -> x + interactable -> width -1,interactable -> y + interactable -> height -1,interactable -> background);
  drawRectangle(interactable -> x,interactable -> y,interactable -> x + interactable -> width,interactable -> y + interactable -> height,interactable -> color);

  //header
  drawString(interactable -> header_x, interactable -> header_y, south, interactable -> header, interactable -> font, interactable -> header_color, none); 

  switch (interactable -> type){
    case checkbox:
      drawRectangle(interactable -> checkbox.box_x1,interactable -> checkbox.box_y1,interactable -> checkbox.box_x2,interactable -> checkbox.box_y2,interactable -> color);
      break;
    case increment :
      char text[4];
      sprintf(text, "%03d%%", map(interactable -> value,
                                  (interactable -> can_reverse ? -DATA_STREAM_MAX_VALUE : 0),
                                  DATA_STREAM_MAX_VALUE,
                                  (interactable -> can_reverse ? -100 : 0),
                                  100)
              );
      drawString(interactable -> increment.value_x, interactable -> increment.value_y, south, text, interactable -> font, interactable -> header_color, none); 

      drawLine(interactable -> increment.line1_x, interactable -> y, interactable -> increment.line1_x, interactable -> increment.line1_y, interactable -> color);
      drawLine(interactable -> increment.line2_x, interactable -> y, interactable -> increment.line2_x, interactable -> increment.line2_y, interactable -> color);

      drawLine(interactable -> increment.minus_x1, interactable -> increment.minus_y, interactable -> increment.minus_x2, interactable -> increment.minus_y, interactable -> color);

      drawLine(interactable -> increment.plus_x1, interactable -> increment.plus_y1, interactable -> increment.plus_x1, interactable -> increment.plus_y2, interactable -> color);
      drawLine(interactable -> increment.plus_x2, interactable -> increment.plus_y3, interactable -> increment.plus_x3, interactable -> increment.plus_y3, interactable -> color);
      break;
  }

  interactable -> old_value = -1; // force update
  updateItem(interactable);
}

static uint8_t isInside(interactable_s *interactable, uint16_t x, uint16_t y){
  uint8_t to_return = 0;
  // first, check if we are even inside the interactable's hitbox
  if(x >= interactable -> x && x <= interactable -> x + interactable -> width && y >= interactable -> y && y <= interactable -> y + interactable -> height) to_return = 1;
  else return false;

  switch(interactable -> type){
    case (increment):
      if(x < interactable -> increment.line1_x) to_return = 2;
      else if (x > interactable -> increment.line2_x) to_return = 3;
      break;
  }

  return to_return;
}

#endif

interactables.h

#ifndef _GRAPHICS_ITEMS_H_
#define _GRAPHICS_ITEMS_H_

#include "data_view.h"
#include "main_menu_tiles.h"
#include "interactables.h"

#include "utils.h"

typedef enum {
  data_view,
  menu_tile,
  interactable
} menu_item_t;

struct menu_item_s {
  menu_item_t type;
  void* item;
  uint8_t position;
  bool visible; // partly or entirely (wether or not it should be refreshed)
  bool active; // set to 0 to delete the item
};

static void initItem(menu_item_s* menu){
   
}

static void drawItem(menu_item_s* menu, uint16_t start_from_id, uint16_t end_at_it){
  for (uint16_t i = start_from_id; i < end_at_it; i++)
    drawItem((interactable_s*)(menu[i].item));
}

static void updateItem(menu_item_s* menu, uint16_t start_from_id, uint16_t end_at_it){
  for (uint16_t i = start_from_id; i < end_at_it; i++)
    updateItem((interactable_s*)(menu[i].item));
}





#endif

menu_manager.h

#ifndef _GRAPHICS_ITEMS_CONFIG_H_
#define _GRAPHICS_ITEMS_CONFIG_H_

#include "menu_manager.h"

interactable_s interactables[] = {
 {
  "Salut",
  checkbox,
  70,
  100,
  150,
  30,
  Font_11x18
},{
  "test",
  increment,
  70,
  130,
  150,
  30,
  Font_11x18
}
};



static menu_item_s main_menu[] = {
  {interactable,&interactables[0]},
  {interactable,&interactables[1]},
};

#endif

menu_config.h

#ifndef _GRAPHICS_ITEM_H_
#define _GRAPHICS_ITEM_H_



//TODO : find a way to get rid of this
// testing purposes for now
typedef enum { 
  box = 1,
  box_but_bigger = 2,
} item_type_t;

struct graphics_attributes_s { // shall be added to every item IN FIRST POSITION as a standardized way to access important data (first position is important as we do pointer arithmetics on it afterwards)
  item_type_t type;

  rect_two_s bounds;

  color_t color;
  color_t background;

  bool initialized;
  bool incoherent;
};

//TODO : remove, testing purposes
struct box_s{
  graphics_attributes_s gfx;
};
void initItem(box_s* salut){}
box_s box_1;

struct graphics_item_s { // wrapper for any item in a menu, items are automatically wrapper during addToMenu
  void* item_ptr;

};

// give it a pointer to an item and a menu array, and the item will be initialized and linked to that menu
static return_code addToMenu (void *item, graphics_item_s *menu) {
  item_type_t type = *((item_type_t*) item); // close your eyes . . .  you didn't see anything . . . 

  switch (type) {
    case box :
      initItem((box_s*)item);
      //if(((box_s*)item) -> gfx.initialized);
      break;
  }
  
};













#endif