Correct keyboard events now work, as well as unsubscriping from even manager

Desktop_Test/GLOBALS.h

@@ -17,7 +17,8 @@ enum CLICK_EVENTS : uint8_t {
   NONE = 0,
   LEFT_CLICK = 1,
   RIGHT_CLICK = 2,
-  KEYBOARD = 3,
+  ENTER = 3,
+  KEYBOARD = 4,
 };
 
 struct CLICK_EVENT {

Desktop_Test/example_programs.h

@@ -1,3 +1,4 @@
+#include <cstring>
 #include "esp32-hal.h"
 #pragma once
 #include "program.h"
@@ -11,6 +12,10 @@ private:
   int counter = 0;
 
 public:
+  ~CounterProgram() {
+    EventManager::getInstance().unsubscribe(this);
+  }
+
   void run() override {
     Serial.println("Counter program started!");
 
@@ -46,11 +51,54 @@ public:
 
 class TextEditorProgram : public Program {
 public:
-  void run() override {
+  ~TextEditorProgram() {
-    Serial.println("Text editor started!");
+    EventManager::getInstance().unsubscribe(this);
+  }
+
+  void on_click_event(CLICK_EVENT event) {
+    if (_window->minimized) return;
+
+    for (WindowContentText& text : _window->window_content_text) {
+      if (event.x >= text.x && event.x <= (text.x + text.width) && event.y >= text.y && event.y <= (text.y + text.height) && (event.event == CLICK_EVENTS::LEFT_CLICK || event.event == CLICK_EVENTS::ENTER)) {
+        if (text.selectable && !text.selected) {
+          for (WindowContentText& temp : _window->window_content_text) temp.selected = false;
+          text.selected = true;
+        }
+      } else if (event.event == CLICK_EVENTS::LEFT_CLICK || event.event == CLICK_EVENTS::ENTER) {
+        if (text.selected) text.selected = false;
+      }
+
+      if (text.selected && event.event == CLICK_EVENTS::KEYBOARD) {
+        text.text += event.character;
+      }
+    }
+  }
+
+  void run() override {
+    EventManager::getInstance().subscribe(this);
+
+    _window->x += 100;
+    _window->width -= 50;
+
+    WindowContentText text;
+    text.x = _window->x + 5;
+    text.y = _window->y + 60;
+    text.width = 50;
+    text.height = 10;
+    text.size = 2;
+    text.selectable = true;
+    text.selected = false;
+    text.text = "asddsa";
+
+    _window->window_content_text.push_back(text);
 
-    // You have full access to the window and can draw to it
     while (_running) {
+      for (WindowContentText text : _window->window_content_text) {
+        if (text.selected) {
+
+        }
+      }
+
       vTaskDelay(pdMS_TO_TICKS(1));
     }
   }
@@ -58,9 +106,11 @@ public:
 
 class InternetTester : public Program {
 public:
-  void run() override {
+  ~InternetTester() {
-    Serial.println("Text editor started!");
+    EventManager::getInstance().unsubscribe(this);
+  }
 
+  void run() override {
     // You have full access to the window and can draw to it
     while (_running) {
       vTaskDelay(pdMS_TO_TICKS(1));
@@ -70,9 +120,11 @@ public:
 
 class CalculatorProgram : public Program {
 public:
-  void run() override {
+  ~CalculatorProgram() {
-    Serial.println("Calculator started!");
+    EventManager::getInstance().unsubscribe(this);
+  }
 
+  void run() override {
     while (_running) {
       // Calculator logic here
       vTaskDelay(pdMS_TO_TICKS(1));
@@ -82,6 +134,10 @@ public:
 
 class Chatty : public Program {
 public:
+  ~Chatty() {
+    EventManager::getInstance().unsubscribe(this);
+  }
+
   void run() override {
     Serial.println("Chatty started!");
     
@@ -98,6 +154,10 @@ private:
   bool showing_buttons = false;
 
 public:
+  ~SettingsProgram() {
+    EventManager::getInstance().unsubscribe(this);
+  }
+
   void on_click_event(CLICK_EVENT event) {
     if (_window->minimized) return;
 

Desktop_Test/input_manager.cpp

@@ -57,77 +57,197 @@ void InputManager::update() {
 }
 
 void InputManager::handle_keyboard_input(char key) {
-  bool needs_redraw = false;
+  bool needs_redraw = true;
 
-  Serial.printf("key: %x\n", key & 0xff);
+  //Serial.printf("key: %x\n", key & 0xff);
   CLICK_EVENT event;
   
   switch(key) {
-    case 'd':  // Right arrow alternative
+    case 'a': [[fallthrough]];
-    case 'D':
-      mi.x = (mi.x + 5 > 476) ? 476 : mi.x + 5;
-      needs_redraw = true;
-      break;
-      
-    case 's':  // Down arrow alternative
-    case 'S':
-      mi.y = (mi.y + 5 > 316) ? 316 : mi.y + 5;
-      needs_redraw = true;
-      break;
-      
-    case 'w':  // Up arrow alternative
-    case 'W':
-      mi.y = (mi.y - 5 < 0) ? 0 : mi.y - 5;
-      needs_redraw = true;
-      break;
-      
-    case 'a':  // Left arrow alternative
     case 'A':
-      mi.x = (mi.x - 5 < 0) ? 0 : mi.x - 5;
+    event.character = key;
-      needs_redraw = true;
+    event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'b': [[fallthrough]];
+    case 'B':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'c': [[fallthrough]];
+    case 'C':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'd': [[fallthrough]];
+    case 'D':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'e': [[fallthrough]];
+    case 'E':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'f': [[fallthrough]];
+    case 'F':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'g': [[fallthrough]];
+    case 'G':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'h': [[fallthrough]];
+    case 'H':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'i': [[fallthrough]];
+    case 'I':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'j': [[fallthrough]];
+    case 'J':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'k': [[fallthrough]];
+    case 'K':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'l': [[fallthrough]];
+    case 'L':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'm': [[fallthrough]];
+    case 'M':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'n': [[fallthrough]];
+    case 'N':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'o': [[fallthrough]];
+    case 'O':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'p': [[fallthrough]];
+    case 'P':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'q': [[fallthrough]];
+    case 'Q':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'r': [[fallthrough]];
+    case 'R':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 's': [[fallthrough]];
+    case 'S':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 't': [[fallthrough]];
+    case 'T':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'u': [[fallthrough]];
+    case 'U':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'v': [[fallthrough]];
+    case 'V':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'w': [[fallthrough]];
+    case 'W':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+
+    case 'x': [[fallthrough]];
+    case 'X':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'y': [[fallthrough]];
+    case 'Y':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
+      break;
+    
+    case 'z': [[fallthrough]];
+    case 'Z':
+      event.character = key;
+      event.event = CLICK_EVENTS::KEYBOARD;
       break;
       
     case 0xB4:  // Left arrow key (CardKB sends special codes)
       mi.x = (mi.x - 5 < 0) ? 0 : mi.x - 5;
-      needs_redraw = true;
       break;
       
     case 0xB7:  // Right arrow key
       mi.x = (mi.x + 5 > 476) ? 476 : mi.x + 5;
-      needs_redraw = true;
       break;
       
     case 0xB5:  // Up arrow key
       mi.y = (mi.y - 5 < 0) ? 0 : mi.y - 5;
-      needs_redraw = true;
       break;
       
     case 0xB6:  // Down arrow key
       mi.y = (mi.y + 5 > 316) ? 316 : mi.y + 5;
-      needs_redraw = true;
       break;
       
-    case 0xD:   // Enter key - left click
+    case 0xD:   // Enter key
-    case ' ':
       event.x = mi.x;
       event.y = mi.y;
       event.event = CLICK_EVENTS::LEFT_CLICK;
       break;
       
-    case 'r':   // 'R' key - right click
-    case 'R':
-      event.x = mi.x;
-      event.y = mi.y;
-      event.event = CLICK_EVENTS::RIGHT_CLICK;
-      break;
-      
     default:
+      needs_redraw = false;
       break;
   }
   
-  EventManager::getInstance().publish(event);
-  
   if (needs_redraw) {
+    EventManager::getInstance().publish(event);
     _display_state->update_display.store(true);
   }
 }

Desktop_Test/program.h

@@ -53,6 +53,8 @@ struct WindowContentText {
   std::string text;
   short x;
   short y;
+  short width;
+  short height;
   char size;
   bool selectable = false;
   bool selected = false;

Desktop_Test/shell.cpp

@@ -236,7 +236,12 @@ void Shell::draw_window(const Window& window) {
   tft->draw_box(window.x + 3, window.y + 35, window.width - 6, window.height - 38, COL_WHITE);
 
   for (WindowContentText text : window.window_content_text) {
+    if (text.selected) {
       tft->draw_text(text.x, text.y, text.text, COL_BLACK, text.size);
+      tft->draw_rect(text.x, text.y, text.width, text.height, 2, COL_BLACK);
+    } else {
+      tft->draw_text(text.x, text.y, text.text, COL_BLACK, text.size);
+    }
   }
 
   for (ContentButton button : window.content_buttons) {

Desktop_Test/tft_handler.cpp

@@ -1,5 +1,6 @@
 #include "GLOBALS.h"
 #include "tft_handler.h"
+#include <Arduino.h>
 
 void TFT_Handler::init(DISPLAY_STATE* display_state) {
   _display_state = display_state;