shell.cpp

#include <stddef.h>
#include <stdint.h>

struct Time {
  uint8_t hour;
  uint8_t minute;
  uint8_t second;
};

extern "C" {
void put_pixel(int x, int y, uint32_t color);
void memset(void *ptr, uint8_t value, uint32_t size);
void memcpy(void *dest, const void *src, uint32_t size);
uint8_t get_keyboard_input_nonblock();
Time get_time();
uint32_t get_total_ram_mb();
void string_copy(char *dest, const char *src);
int string_length(const char *str);
int get_shell_file_count();
void get_shell_file_name(int index, char *out);
uint32_t get_shell_file_size(int index);
bool get_shell_file_is_dir(int index);
void shell_refresh_files();
bool shell_is_fs_mounted();
void *malloc(uint32_t size);
char shell_scancode_to_ascii(uint8_t scancode, bool shift);
void shell_set_language(int lang);
bool shell_read_file(const char *filename, char *buffer, uint32_t max_size);
bool shell_write_file(const char *filename, const char *data, uint32_t size);
bool shell_delete_file(const char *filename);
bool shell_mkdir(const char *name);
bool shell_rmdir(const char *name);
bool shell_move_file(const char *src, const char *dest);
bool shell_change_dir(const char *path);
const char *shell_get_current_path();
bool shell_format_disk(int disk_id);
bool shell_mount_disk(int disk_id);
void shell_unmount_disk();
int shell_get_active_disk();
bool shell_is_hdd_present();
// MPra Interpreter API
bool mpra_is_running();
const char *mpra_get_window_title();
int mpra_get_window_w();
int mpra_get_window_h();
void mpra_run_file(const char *filename);
void mpra_draw_content(int x, int y, int w, int h);
void mpra_handle_click(int x, int y);
void mpra_handle_key(uint8_t scancode);
void mpra_close();
}

bool string_starts_with(const char *str, const char *prefix) {
  while (*prefix)
    if (*str++ != *prefix++)
      return false;
  return true;
}

void itoa_light(int n, char *s) {
  if (n == 0) {
    s[0] = '0';
    s[1] = '\0';
    return;
  }
  int i = 0;
  bool neg = false;
  if (n < 0) {
    neg = true;
    n = -n;
  }
  while (n > 0) {
    s[i++] = (n % 10) + '0';
    n /= 10;
  }
  if (neg)
    s[i++] = '-';
  s[i] = '\0';
  for (int j = 0; j < i / 2; j++) {
    char t = s[j];
    s[j] = s[i - 1 - j];
    s[i - 1 - j] = t;
  }
}

extern int mouse_x;
extern int mouse_y;
extern bool mouse_left;

struct Graphics {
  uint32_t *framebuffer;
  uint32_t width;
  uint32_t height;
  uint32_t pitch;
  bool active;
};

extern Graphics screen;

int global_wallpaper = 0;
int global_start_color_idx = 0;
int global_menu_style = 0;
int global_bar_position = 0; // 0=Top, 1=Bottom
extern int global_mouse_speed;

// ============================================================================
// PERSISTENT SETTINGS  (set.con on the mounted volume)
// Format: one key=value pair per line, terminated by '\n'
//   wallpaper=N  color=N  menustyle=N  barpos=N  mousespeed=N  language=N
// Implementations are defined after the static SettingsState ss declaration.
// ============================================================================

// Helper: append a small integer to a char buffer, return new length
static int settings_append_int(char *buf, int pos, int val) {
  char tmp[12];
  itoa_light(val, tmp);
  for (int i = 0; tmp[i]; i++)
    buf[pos++] = tmp[i];
  return pos;
}

// Helper: parse integer from string pointer
static int settings_parse_int(const char *p) {
  int v = 0;
  bool neg = false;
  if (*p == '-') {
    neg = true;
    p++;
  }
  while (*p >= '0' && *p <= '9') {
    v = v * 10 + (*p++ - '0');
  }
  return neg ? -v : v;
}

// Forward declarations — bodies defined after static ss is in scope
void save_settings();
void load_settings();

extern uint8_t _binary_wp1_raw_start[];
extern uint8_t _binary_logo1_raw_start[];
extern uint8_t _binary_logo2_raw_start[];

static uint32_t active_wallpaper[800 * 600];
static int loaded_wallpaper_idx = -1;
static bool wallpaper_file_load_failed = false;
static bool last_fs_mounted = false;

uint32_t *ui_buffer = nullptr;
uint32_t *frontbuffer = nullptr;

void my_put_pixel(int x, int y, uint32_t color) {
  if (x < 0 || (uint32_t)x >= screen.width || y < 0 ||
      (uint32_t)y >= screen.height)
    return;
  ui_buffer[y * screen.width + x] = color;
}

// Alpha blending: (src * alpha + dest * (255 - alpha)) / 255
uint32_t blend(uint32_t src, uint32_t dest, uint8_t alpha) {
  if (get_total_ram_mb() <= 128) {
    return src;
  }
  uint32_t rb = (src & 0xFF00FF) * alpha + (dest & 0xFF00FF) * (256 - alpha);
  uint32_t g = (src & 0x00FF00) * alpha + (dest & 0x00FF00) * (256 - alpha);
  return ((rb >> 8) & 0xFF00FF) | ((g >> 8) & 0x00FF00);
}

void draw_rect_alpha(int x, int y, int w, int h, uint32_t color,
                     uint8_t alpha) {
  if (get_total_ram_mb() <= 128) {
    // Drop shadows (black with alpha < 128) are transparent shadows;
    // without transparency they would appear as solid black boxes, so skip them.
    if (color == 0x000000 && alpha < 128) {
      return;
    }
    // No transparency: treat all other elements as fully opaque
    alpha = 255;
  }

  if (alpha == 255) {
    for (int i = y; i < y + h; i++) {
      if (i < 0 || (uint32_t)i >= screen.height)
        continue;
      for (int j = x; j < x + w; j++) {
        if (j < 0 || (uint32_t)j >= screen.width)
          continue;
        my_put_pixel(j, i, color);
      }
    }
    return;
  }

  for (int i = y; i < y + h; i++) {
    if (i < 0 || (uint32_t)i >= screen.height)
      continue;
    for (int j = x; j < x + w; j++) {
      if (j < 0 || (uint32_t)j >= screen.width)
        continue;
      uint32_t dest = ui_buffer[i * screen.width + j];
      my_put_pixel(j, i, blend(color, dest, alpha));
    }
  }
}

// Simple 8x8 font
uint8_t font8x8_basic[128][8] = {0};

void init_minimal_font() {
  // Very basic 8x8 bitmap font data for the used strings
  struct CharDef {
    char c;
    uint8_t data[8];
  };
  CharDef chars[] = {{'A', {0x18, 0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00}},
                     {'B', {0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00}},
                     {'C', {0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00}},
                     {'D', {0x78, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0x78, 0x00}},
                     {'E', {0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00}},
                     {'F', {0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x00}},
                     {'G', {0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00}},
                     {'H', {0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00}},
                     {'I', {0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00}},
                     {'L', {0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00}},
                     {'M', {0x63, 0x77, 0x7F, 0x6B, 0x63, 0x63, 0x63, 0x00}},
                     {'N', {0x66, 0x76, 0x7E, 0x7E, 0x6E, 0x66, 0x66, 0x00}},
                     {'O', {0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}},
                     {'P', {0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x00}},
                     {'R', {0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66, 0x00}},
                     {'S', {0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C, 0x00}},
                     {'T', {0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}},
                     {'U', {0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}},
                     {'W', {0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}},
                     {'X', {0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00}},
                     {'Y', {0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00}},
                     {'a', {0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3E, 0x00}},
                     {'b', {0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x00}},
                     {'c', {0x00, 0x00, 0x3C, 0x60, 0x60, 0x66, 0x3C, 0x00}},
                     {'d', {0x06, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x00}},
                     {'e', {0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00}},
                     {'f', {0x1C, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x30, 0x00}},
                     {'g', {0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C}},
                     {'i', {0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}},
                     {'l', {0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x1C, 0x00}},
                     {'m', {0x00, 0x00, 0x76, 0x7F, 0x6B, 0x6B, 0x6B, 0x00}},
                     {'n', {0x00, 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00}},
                     {'o', {0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00}},
                     {'p', {0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60}},
                     {'r', {0x00, 0x00, 0x3E, 0x60, 0x60, 0x60, 0x60, 0x00}},
                     {'s', {0x00, 0x00, 0x3E, 0x60, 0x3C, 0x06, 0x7C, 0x00}},
                     {'t', {0x30, 0x30, 0x7C, 0x30, 0x30, 0x30, 0x1C, 0x00}},
                     {'u', {0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3E, 0x00}},
                     {'v', {0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00}},
                     {'w', {0x00, 0x00, 0x63, 0x6B, 0x7F, 0x3E, 0x36, 0x00}},
                     {'x', {0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00}},
                     {'y', {0x00, 0x00, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x3C}},
                     {'0', {0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x3C, 0x00}},
                     {'1', {0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00}},
                     {'2', {0x3C, 0x66, 0x06, 0x0C, 0x30, 0x60, 0x7E, 0x00}},
                     {'3', {0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00}},
                     {'4', {0x06, 0x0E, 0x1E, 0x36, 0x7F, 0x06, 0x06, 0x00}},
                     {'5', {0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C, 0x00}},
                     {'6', {0x3C, 0x66, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00}},
                     {'7', {0x7E, 0x66, 0x06, 0x0C, 0x18, 0x18, 0x18, 0x00}},
                     {'8', {0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00}},
                     {'9', {0x3C, 0x66, 0x66, 0x3E, 0x06, 0x66, 0x3C, 0x00}},
                     {'.', {0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00}},
                     {':', {0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00}},
                     {' ', {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
                     {'-', {0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}},
                     {'(', {0x0C, 0x18, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00}},
                     {')', {0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00}},
                     {'@', {0x3C, 0x66, 0x6E, 0x6E, 0x60, 0x66, 0x3C, 0x00}},
                     {',', {0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30}},
                     {'+', {0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00}},
                     {'K', {0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00}},
                     {'J', {0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x6C, 0x38, 0x00}},
                     {'Q', {0x3C, 0x66, 0x66, 0x66, 0x6A, 0x3C, 0x06, 0x00}},
                     {'V', {0x66, 0x66, 0x66, 0x66, 0x3C, 0x3C, 0x18, 0x00}},
                     {'Z', {0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E, 0x00}},
                     {'h', {0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00}},
                     {'k', {0x60, 0x60, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0x00}},
                     {'j', {0x06, 0x00, 0x06, 0x06, 0x06, 0x66, 0x3C, 0x00}},
                     {'z', {0x00, 0x00, 0x7E, 0x0C, 0x18, 0x30, 0x7E, 0x00}},
                     {'/', {0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00, 0x00}},
                     {'_', {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00}},
                     {'>', {0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00}},
                     {'<', {0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00}},
                     {'|', {0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}},
                     {'*', {0x00, 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x00}},
                     {'=', {0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00}}};
  for (unsigned i = 0; i < sizeof(chars) / sizeof(chars[0]); i++) {
    for (int j = 0; j < 8; j++)
      font8x8_basic[(uint8_t)chars[i].c][j] = chars[i].data[j];
  }
}

void draw_char(int x, int y, char c, uint32_t color) {
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      if (font8x8_basic[(uint8_t)c][i] & (1 << (7 - j))) {
        my_put_pixel(x + j, y + i, color);
      }
    }
  }
}

void draw_string(int x, int y, const char *str, uint32_t color) {
  while (*str) {
    draw_char(x, y, *str, color);
    x += 8;
    str++;
  }
}

void draw_image(int x, int y, int w, int h, uint8_t *data) {
  if (get_total_ram_mb() <= 128)
    return;
  uint32_t *pixels = (uint32_t *)data;
  for (int i = 0; i < h; i++) {
    for (int j = 0; j < w; j++) {
      if (x + j >= (int)screen.width || y + i >= (int)screen.height ||
          x + j < 0 || y + i < 0)
        continue;
      uint32_t col = pixels[i * w + j];
      uint8_t r = col & 0xFF;
      uint8_t g = (col >> 8) & 0xFF;
      uint8_t b = (col >> 16) & 0xFF;
      uint8_t a = (col >> 24) & 0xFF;
      if (a > 128)
        my_put_pixel(x + j, y + i, (r << 16) | (g << 8) | b);
    }
  }
}

void draw_image_scaled(int x, int y, int w, int h, uint8_t *data, int src_w,
                       int src_h) {
  if (get_total_ram_mb() <= 128)
    return;
  uint32_t *pixels = (uint32_t *)data;
  for (int i = 0; i < h; i++) {
    for (int j = 0; j < w; j++) {
      if (x + j >= (int)screen.width || y + i >= (int)screen.height ||
          x + j < 0 || y + i < 0)
        continue;
      int src_x = (j * src_w) / w;
      int src_y = (i * src_h) / h;
      uint32_t col = pixels[src_y * src_w + src_x];
      uint8_t r = col & 0xFF;
      uint8_t g = (col >> 8) & 0xFF;
      uint8_t b = (col >> 16) & 0xFF;
      uint8_t a = (col >> 24) & 0xFF;
      if (a > 128)
        my_put_pixel(x + j, y + i, (r << 16) | (g << 8) | b);
    }
  }
}

void draw_wallpaper() {
  if (get_total_ram_mb() <= 128) {
    // Low memory mode: no wallpaper loaded or drawn
    uint32_t total = screen.width * screen.height;
    for (uint32_t i = 0; i < total; i++) {
      ui_buffer[i] = 0x1A1A1A;
    }
    return;
  }

  bool current_fs_mounted = shell_is_fs_mounted();
  if (current_fs_mounted != last_fs_mounted) {
    loaded_wallpaper_idx = -1;
    last_fs_mounted = current_fs_mounted;
  }

  uint32_t *wallpaper = nullptr;

  if (global_wallpaper == 0) {
    wallpaper = (uint32_t *)_binary_wp1_raw_start;
  } else {
    if (loaded_wallpaper_idx != global_wallpaper) {
      char filename[16];
      string_copy(filename, "WP");
      char num_str[4];
      itoa_light(global_wallpaper + 1, num_str);
      int len = string_length(filename);
      string_copy(filename + len, num_str);
      len = string_length(filename);
      string_copy(filename + len, ".RAW");

      if (shell_read_file(filename, (char *)active_wallpaper,
                          sizeof(active_wallpaper))) {
        loaded_wallpaper_idx = global_wallpaper;
        wallpaper_file_load_failed = false;
      } else {
        loaded_wallpaper_idx = global_wallpaper;
        wallpaper_file_load_failed = true;
      }
    }

    if (!wallpaper_file_load_failed &&
        loaded_wallpaper_idx == global_wallpaper) {
      wallpaper = active_wallpaper;
    } else {
      wallpaper = (uint32_t *)_binary_wp1_raw_start;
    }
  }

  for (uint32_t y = 0; y < screen.height; y++) {
    for (uint32_t x = 0; x < screen.width; x++) {
      // Tile 800x600 wallpaper safely
      uint32_t col = wallpaper[(y % 600) * 800 + (x % 800)];
      uint8_t r = col & 0xFF;
      uint8_t g = (col >> 8) & 0xFF;
      uint8_t b = (col >> 16) & 0xFF;
      my_put_pixel(x, y, (r << 16) | (g << 8) | b);
    }
  }
}

int last_mouse_x = -1;
int last_mouse_y = -1;

void uint_to_string(uint32_t value, char *str) {
  if (value == 0) {
    str[0] = '0';
    str[1] = '\0';
    return;
  }
  char buf[16];
  int i = 0;
  while (value > 0) {
    buf[i++] = '0' + (value % 10);
    value /= 10;
  }
  int j = 0;
  while (i > 0) {
    str[j++] = buf[--i];
  }
  str[j] = '\0';
}

void draw_top_bar() {
  int bar_y = 0;
  if (global_bar_position == 1)
    bar_y = screen.height - 25;

  draw_rect_alpha(0, bar_y, screen.width, 25, 0x000000, 160);

  // Red menu button - top right
  int btn_x = screen.width - 70;
  uint32_t start_colors[] = {0xCC2222, 0x005A9E, 0x22CC22, 0x333333};
  uint32_t btn_color = start_colors[global_start_color_idx];
  draw_rect_alpha(btn_x, bar_y + 2, 60, 21, btn_color, 230);
  draw_string(btn_x + 10, bar_y + 8, "Menu", 0xFFFFFF);

  uint32_t ram = get_total_ram_mb();
  Time t = get_time();

  char bar_text[40];
  string_copy(bar_text, "RAM: ");
  char ram_str[10];
  uint_to_string(ram, ram_str);
  string_copy(bar_text + 5, ram_str);
  int len = string_length(bar_text);
  string_copy(bar_text + len, "MB   ");
  len = string_length(bar_text);

  bar_text[len++] = '0' + (t.hour / 10);
  bar_text[len++] = '0' + (t.hour % 10);
  bar_text[len++] = ':';
  bar_text[len++] = '0' + (t.minute / 10);
  bar_text[len++] = '0' + (t.minute % 10);
  bar_text[len++] = ':';
  bar_text[len++] = '0' + (t.second / 10);
  bar_text[len++] = '0' + (t.second % 10);
  bar_text[len] = '\0';

  draw_string(10, bar_y + 8, bar_text, 0xDDDDDD);
}

void draw_window(int x, int y, int w, int h, const char *title, bool active) {
  draw_rect_alpha(x + 4, y + 4, w, h, 0x000000, 80); // Shadow
  draw_rect_alpha(x, y, w, h, 0x1E1E1E, 250);
  draw_rect_alpha(x, y, w, 28, active ? 0x005A9E : 0x333333, 255);
  draw_string(x + 10, y + 10, title, 0xFFFFFF);
  draw_string(x + w - 40, y + 10, "- x", 0xFFFFFF);

  if (h > 28) {
    // Outer border outline
    draw_rect_alpha(x, y, w, 1, 0x444444, 255);
    draw_rect_alpha(x, y, 1, h, 0x444444, 255);
    draw_rect_alpha(x + w - 1, y, 1, h, 0x444444, 255);
    draw_rect_alpha(x, y + h - 1, w, 1, 0x444444, 255);

    // Resize grip handle in bottom-right corner
    int rx = x + w - 12;
    int ry = y + h - 12;
    draw_rect_alpha(rx + 8, ry + 2, 2, 2, 0x888888, 255);
    draw_rect_alpha(rx + 5, ry + 5, 2, 2, 0x888888, 255);
    draw_rect_alpha(rx + 2, ry + 8, 2, 2, 0x888888, 255);
    draw_rect_alpha(rx + 8, ry + 5, 2, 2, 0x888888, 255);
    draw_rect_alpha(rx + 5, ry + 8, 2, 2, 0x888888, 255);
    draw_rect_alpha(rx + 8, ry + 8, 2, 2, 0x888888, 255);
  }
}

// ============================================================================
// FILE MANAGER WINDOW
// ============================================================================

void size_to_string(uint32_t size, char *out) {
  if (size == 0) {
    out[0] = '0';
    out[1] = ' ';
    out[2] = 'B';
    out[3] = '\0';
    return;
  }
  // Show in B, KB, or MB
  const char *suffix = "B";
  uint32_t display = size;
  if (size >= 1024 * 1024) {
    display = size / (1024 * 1024);
    suffix = "MB";
  } else if (size >= 1024) {
    display = size / 1024;
    suffix = "KB";
  }
  // Convert number to string
  char tmp[12];
  int len = 0;
  uint32_t n = display;
  if (n == 0) {
    tmp[len++] = '0';
  } else {
    while (n > 0) {
      tmp[len++] = '0' + (n % 10);
      n /= 10;
    }
  }
  int pos = 0;
  for (int i = len - 1; i >= 0; i--)
    out[pos++] = tmp[i];
  out[pos++] = ' ';
  for (int i = 0; suffix[i]; i++)
    out[pos++] = suffix[i];
  out[pos] = '\0';
}

// FM dialog state — defined here so draw_file_manager_content can access them
// 0=none, 1=move/rename dialog, 2=new folder dialog
static int  fm_dialog_type = 0;
static char fm_input_buf[32] = {0};
static int  fm_input_len = 0;
static bool fm_shift = false;

void draw_file_manager_content(int x, int y, int w, int h, int selected,
                               int scroll_offset) {
  // Background area below title bar
  int content_y = y + 28;
  int content_h = h - 28;

  // --- Path bar (height 18) ---
  draw_rect_alpha(x, content_y, w, 18, 0x1A1A1A, 255);
  const char *cur_path = shell_get_current_path();
  // Build "Path: /FOO/" string
  char path_str[64];
  path_str[0] = 'P'; path_str[1] = 'a'; path_str[2] = 't';
  path_str[3] = 'h'; path_str[4] = ':'; path_str[5] = ' ';
  int ps = 6;
  for (int i = 0; cur_path[i] && ps < 62; i++)
    path_str[ps++] = cur_path[i];
  path_str[ps] = '\0';
  draw_string(x + 6, content_y + 5, path_str, 0x88CCFF);

  // --- Toolbar area (height 30) ---
  int toolbar_y = content_y + 18;
  draw_rect_alpha(x, toolbar_y, w, 30, 0x252526, 255);

  bool has_selection = (shell_is_fs_mounted() && get_shell_file_count() > 0 &&
                        selected >= 0 && selected < get_shell_file_count());
  // Check if selection is a real dir (not "..")
  bool sel_is_navigable_dir = false;
  if (has_selection) {
    char _tn[16]; get_shell_file_name(selected, _tn);
    sel_is_navigable_dir = get_shell_file_is_dir(selected) &&
                           !(_tn[0]=='.' && _tn[1]=='.' && _tn[2]=='\0');
  }

  // [Delete] – red when selection exists
  uint32_t del_bg = has_selection ? 0xC42B1C : 0x3A3A3C;
  uint32_t del_fg = has_selection ? 0xFFFFFF : 0x888888;
  draw_rect_alpha(x + 4, toolbar_y + 5, 54, 20, del_bg, 255);
  draw_string(x + 11, toolbar_y + 11, "Delete", del_fg);

  // [Move] – green when selection is a file (not a dir)
  bool can_move = has_selection && !sel_is_navigable_dir;
  uint32_t mov_bg = can_move ? 0x1F6F28 : 0x3A3A3C;
  uint32_t mov_fg = can_move ? 0xFFFFFF : 0x888888;
  draw_rect_alpha(x + 62, toolbar_y + 5, 44, 20, mov_bg, 255);
  draw_string(x + 70, toolbar_y + 11, "Move", mov_fg);

  // [New Folder]
  draw_rect_alpha(x + 110, toolbar_y + 5, 76, 20, 0x005A9E, 255);
  draw_string(x + 113, toolbar_y + 11, "New Folder", 0xFFFFFF);

  // [Up] – navigate to parent directory
  draw_rect_alpha(x + 190, toolbar_y + 5, 28, 20, 0x3A3A3C, 255);
  draw_string(x + 196, toolbar_y + 11, "Up", 0xCCCCCC);

  // [Refresh]
  draw_rect_alpha(x + 222, toolbar_y + 5, 60, 20, 0x3A3A3C, 255);
  draw_string(x + 228, toolbar_y + 11, "Refresh", 0xCCCCCC);

  // Separator line below toolbar
  draw_rect_alpha(x, toolbar_y + 29, w, 1, 0x3F3F46, 255);

  // --- Header bar (height 20) ---
  int header_y = toolbar_y + 30;
  draw_rect_alpha(x, header_y, w, 20, 0x2D2D2D, 255);
  draw_string(x + 10, header_y + 6, "Name", 0xDDDDDD);
  draw_string(x + w / 2, header_y + 6, "Size", 0xDDDDDD);
  draw_string(x + w - 80, header_y + 6, "Type", 0xDDDDDD);
  draw_rect_alpha(x, header_y + 20, w, 1, 0x444444, 255);

  int row_height = 20;
  int list_y = header_y + 22;
  // content_h includes path bar (18) + toolbar (30) + header (20) + sep (1) = 69 + separator pixels
  int used = (toolbar_y - content_y) + 30 + 20 + 2; // path_bar_h + toolbar_h + header + seps
  int max_visible = (content_h - used) / row_height;
  if (max_visible < 0) max_visible = 0;

  if (!shell_is_fs_mounted()) {
    draw_string(x + 20, list_y + 20, "No filesystem mounted.", 0x888888);
    goto draw_dialog;
  }

  {
    int count = get_shell_file_count();
    if (count == 0) {
      draw_string(x + 20, list_y + 20, "No files found.", 0x888888);
      goto draw_dialog;
    }

    for (int i = 0; i < max_visible && (i + scroll_offset) < count; i++) {
      int file_idx = i + scroll_offset;
      bool is_selected = (file_idx == selected);
      bool is_dir = get_shell_file_is_dir(file_idx);

      uint32_t row_bg =
          is_selected ? 0x005A9E : ((file_idx % 2 == 0) ? 0x252526 : 0x1E1E1E);
      // Directories: yellow tint; files: normal; selected: always white
      uint32_t text_color = is_selected ? 0xFFFFFF : (is_dir ? 0xFFE082 : 0xDDDDDD);
      draw_rect_alpha(x + 1, list_y + i * row_height, w - 2, row_height, row_bg,
                      is_selected ? 255 : 240);

      char name[16];
      get_shell_file_name(file_idx, name);
      draw_string(x + 10, list_y + i * row_height + 6, name, text_color);

      if (!is_dir) {
        char size_str[16];
        size_to_string(get_shell_file_size(file_idx), size_str);
        draw_string(x + w / 2, list_y + i * row_height + 6, size_str, text_color);
      }

      draw_string(x + w - 80, list_y + i * row_height + 6,
                  is_dir ? "DIR" : "FILE", text_color);
    }

    // Scroll indicator
    if (count > max_visible && max_visible > 0) {
      int bar_h = content_h - used;
      int thumb_h = (max_visible * bar_h) / count;
      if (thumb_h < 10) thumb_h = 10;
      int thumb_y =
          list_y + (scroll_offset * (bar_h - thumb_h)) / (count - max_visible);
      draw_rect_alpha(x + w - 6, list_y, 4, bar_h, 0x333333, 200);
      draw_rect_alpha(x + w - 6, thumb_y, 4, thumb_h, 0x666666, 255);
    }
  }

draw_dialog:
  // --- Input dialog overlay for Move / New Folder ---
  if (fm_dialog_type != 0) {
    const char *dlg_title = (fm_dialog_type == 1) ? "Move / Rename to:" : "New Folder name:";
    // Dialog box
    int dx = x + w / 2 - 110;
    int dy = y + h / 2 - 35;
    draw_rect_alpha(dx, dy, 220, 70, 0x1E1E2E, 245);
    draw_rect_alpha(dx, dy, 220, 1, 0x005A9E, 255);
    draw_rect_alpha(dx, dy + 69, 220, 1, 0x005A9E, 255);
    draw_rect_alpha(dx, dy, 1, 70, 0x005A9E, 255);
    draw_rect_alpha(dx + 219, dy, 1, 70, 0x005A9E, 255);
    draw_string(dx + 8, dy + 8, dlg_title, 0xCCCCCC);
    // Input field
    draw_rect_alpha(dx + 6, dy + 22, 208, 18, 0x111111, 255);
    draw_string(dx + 10, dy + 26, fm_input_buf, 0xFFFFFF);
    // Blinking cursor placeholder
    int cur_x = dx + 10 + fm_input_len * 8;
    draw_rect_alpha(cur_x, dy + 26, 2, 12, 0xFFFFFF, 200);
    // Buttons
    draw_rect_alpha(dx + 6,   dy + 46, 80, 18, 0x1F6F28, 255);
    draw_string(dx + 22,  dy + 51, "OK", 0xFFFFFF);
    draw_rect_alpha(dx + 94, dy + 46, 80, 18, 0x3A3A3C, 255);
    draw_string(dx + 104, dy + 51, "Cancel", 0xCCCCCC);
  }
}


// ============================================================================
// CALCULATOR WINDOW
// ============================================================================

struct CalcState {
  char display[16];
  int first_val;
  char last_op;
  bool next_clears;
};

void draw_calculator_content(int x, int y, int w, int h, CalcState &cs) {
  int cy = y + 28;
  // Display area
  draw_rect_alpha(x + 10, cy + 10, w - 20, 30, 0x111111, 255);
  draw_rect_alpha(x + 10, cy + 10, w - 20, 1, 0x444444, 255); // Top border
  draw_rect_alpha(x + 10, cy + 10, 1, 30, 0x444444, 255);     // Left border

  draw_string(x + 20, cy + 20, cs.display, 0xFFFFFF);

  const char *btns[4][4] = {{"7", "8", "9", "/"},
                            {"4", "5", "6", "*"},
                            {"1", "2", "3", "-"},
                            {"C", "0", "=", "+"}};

  int bx = x + 10;
  int by = cy + 50;
  int bw = (w - 30) / 4;
  int bh = (h - 28 - 60) / 4;

  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      int cur_x = bx + j * (bw + 3);
      int cur_y = by + i * (bh + 3);

      // Hover effect
      bool hover = (mouse_x >= cur_x && mouse_x < cur_x + bw &&
                    mouse_y >= cur_y && mouse_y < cur_y + bh);
      uint32_t btn_col = hover ? 0x444444 : 0x333333;
      if (btns[i][j][0] == '=' || btns[i][j][0] == '+' ||
          btns[i][j][0] == '-' || btns[i][j][0] == '*' ||
          btns[i][j][0] == '/') {
        btn_col = hover ? 0x0078D7 : 0x005A9E;
      } else if (btns[i][j][0] == 'C') {
        btn_col = hover ? 0xEE3333 : 0xCC2222;
      }

      draw_rect_alpha(cur_x, cur_y, bw, bh, btn_col, 255);
      draw_string(cur_x + (bw / 2) - 4, cur_y + (bh / 2) - 4, btns[i][j],
                  0xFFFFFF);
    }
  }
}

void handle_calculator_click(CalcState &cs, int x, int y, int w, int h) {
  int cy = y + 28;
  int bx = x + 10;
  int by = cy + 50;
  int bw = (w - 30) / 4;
  int bh = (h - 28 - 60) / 4;

  const char *btns[4][4] = {{"7", "8", "9", "/"},
                            {"4", "5", "6", "*"},
                            {"1", "2", "3", "-"},
                            {"C", "0", "=", "+"}};

  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      int cur_x = bx + j * (bw + 3);
      int cur_y = by + i * (bh + 3);

      if (mouse_x >= cur_x && mouse_x < cur_x + bw && mouse_y >= cur_y &&
          mouse_y < cur_y + bh) {
        char c = btns[i][j][0];
        if (c >= '0' && c <= '9') {
          if (cs.next_clears) {
            cs.display[0] = c;
            cs.display[1] = '\0';
            cs.next_clears = false;
          } else {
            int len = string_length(cs.display);
            if (len < 10) {
              if (len == 1 && cs.display[0] == '0') {
                cs.display[0] = c;
              } else {
                cs.display[len] = c;
                cs.display[len + 1] = '\0';
              }
            }
          }
        } else if (c == 'C') {
          string_copy(cs.display, "0");
          cs.first_val = 0;
          cs.last_op = 0;
          cs.next_clears = true;
        } else if (c == '=') {
          int second_val = 0;
          char *p = cs.display;
          while (*p) {
            second_val = second_val * 10 + (*p - '0');
            p++;
          }

          int result = 0;
          if (cs.last_op == '+')
            result = cs.first_val + second_val;
          else if (cs.last_op == '-')
            result = cs.first_val - second_val;
          else if (cs.last_op == '*')
            result = cs.first_val * second_val;
          else if (cs.last_op == '/') {
            if (second_val != 0)
              result = cs.first_val / second_val;
          } else
            result = second_val;

          uint_to_string(result, cs.display);
          cs.next_clears = true;
          cs.last_op = 0;
        } else {
          int val = 0;
          char *p = cs.display;
          while (*p) {
            val = val * 10 + (*p - '0');
            p++;
          }
          cs.first_val = val;
          cs.last_op = c;
          cs.next_clears = true;
        }
      }
    }
  }
}

// ============================================================================
// SETTINGS APP
// ============================================================================

struct SettingsState {
  int language;    // 0=EN, 1=DE, 2=FR
  int current_tab; // 0=Keyboard, 1=Customizing
};

void draw_settings_content(int x, int y, int w, int h, SettingsState &ss) {
  int cy = y + 28;

  // Tabs
  draw_rect_alpha(x + 10, cy + 10, 120, 25,
                  ss.current_tab == 0 ? 0x005A9E : 0x333333, 255);
  draw_string(x + 30, cy + 18, "Keyboard", 0xFFFFFF);
  draw_rect_alpha(x + 140, cy + 10, 120, 25,
                  ss.current_tab == 1 ? 0x005A9E : 0x333333, 255);
  draw_string(x + 150, cy + 18, "Customizing", 0xFFFFFF);

  if (ss.current_tab == 0) {
    draw_string(x + 10, cy + 50, "Language Settings", 0xDDDDDD);

    // Buttons for language
    draw_rect_alpha(x + 10, cy + 70, 80, 25,
                    ss.language == 0 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 25, cy + 78, "English", 0xFFFFFF);

    draw_rect_alpha(x + 100, cy + 70, 80, 25,
                    ss.language == 1 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 115, cy + 78, "German", 0xFFFFFF);

    draw_rect_alpha(x + 190, cy + 70, 80, 25,
                    ss.language == 2 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 205, cy + 78, "French", 0xFFFFFF);

    draw_string(x + 10, cy + 110, "Cursor Speed", 0xDDDDDD);
    draw_rect_alpha(x + 10, cy + 130, 60, 25,
                    global_mouse_speed == 0 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 20, cy + 138, "Slow", 0xFFFFFF);

    draw_rect_alpha(x + 80, cy + 130, 60, 25,
                    global_mouse_speed == 1 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 95, cy + 138, "Mid", 0xFFFFFF);

    draw_rect_alpha(x + 150, cy + 130, 60, 25,
                    global_mouse_speed == 2 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 160, cy + 138, "Norm", 0xFFFFFF);

    draw_rect_alpha(x + 220, cy + 130, 60, 25,
                    global_mouse_speed == 3 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 230, cy + 138, "Fast", 0xFFFFFF);
  } else {
    if (get_total_ram_mb() > 128) {
      draw_string(x + 10, cy + 50, "Wallpaper", 0xDDDDDD);
      draw_rect_alpha(x + 10, cy + 70, 80, 25,
                      global_wallpaper == 0 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 25, cy + 78, "Simple", 0xFFFFFF);
      draw_rect_alpha(x + 100, cy + 70, 80, 25,
                      global_wallpaper == 1 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 120, cy + 78, "Field", 0xFFFFFF);
      draw_rect_alpha(x + 190, cy + 70, 80, 25,
                      global_wallpaper == 2 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 215, cy + 78, "Devs", 0xFFFFFF);

      draw_rect_alpha(x + 10, cy + 100, 80, 25,
                      global_wallpaper == 3 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 30, cy + 108, "Way", 0xFFFFFF);
      draw_rect_alpha(x + 100, cy + 100, 80, 25,
                      global_wallpaper == 4 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 115, cy + 108, "Wonne", 0xFFFFFF);
      draw_rect_alpha(x + 190, cy + 100, 80, 25,
                      global_wallpaper == 5 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 205, cy + 108, "Forest", 0xFFFFFF);

      draw_rect_alpha(x + 10, cy + 130, 80, 25,
                      global_wallpaper == 6 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 25, cy + 138, "Sea 1", 0xFFFFFF);
      draw_rect_alpha(x + 100, cy + 130, 80, 25,
                      global_wallpaper == 7 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 115, cy + 138, "Sea 2", 0xFFFFFF);
      draw_rect_alpha(x + 190, cy + 130, 80, 25,
                      global_wallpaper == 8 ? 0x005A9E : 0x333333, 255);
      draw_string(x + 205, cy + 138, "solarset", 0xFFFFFF);
    } else {
      draw_string(x + 10, cy + 50, "Wallpaper (Disabled: RAM <= 128MB)", 0x888888);
      draw_string(x + 10, cy + 80, "Wallpapers and effects require > 128MB RAM", 0x666666);
    }

    draw_string(x + 10, cy + 165, "Start Color", 0xDDDDDD);
    draw_rect_alpha(x + 10, cy + 185, 60, 25,
                    global_start_color_idx == 0 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 25, cy + 193, "Red", 0xFFFFFF);
    draw_rect_alpha(x + 80, cy + 185, 60, 25,
                    global_start_color_idx == 1 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 90, cy + 193, "Blue", 0xFFFFFF);
    draw_rect_alpha(x + 150, cy + 185, 60, 25,
                    global_start_color_idx == 2 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 155, cy + 193, "Green", 0xFFFFFF);
    draw_rect_alpha(x + 220, cy + 185, 60, 25,
                    global_start_color_idx == 3 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 230, cy + 193, "Dark", 0xFFFFFF);

    draw_string(x + 10, cy + 225, "Menu Style", 0xDDDDDD);
    draw_rect_alpha(x + 10, cy + 245, 80, 25,
                    global_menu_style == 0 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 15, cy + 253, "Centered", 0xFFFFFF);
    draw_rect_alpha(x + 100, cy + 245, 80, 25,
                    global_menu_style == 1 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 105, cy + 253, "Right Edge", 0xFFFFFF);

    draw_string(x + 10, cy + 275, "Bar Position", 0xDDDDDD);
    draw_rect_alpha(x + 10, cy + 295, 80, 25,
                    global_bar_position == 0 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 30, cy + 303, "Top", 0xFFFFFF);
    draw_rect_alpha(x + 100, cy + 295, 80, 25,
                    global_bar_position == 1 ? 0x005A9E : 0x333333, 255);
    draw_string(x + 115, cy + 303, "Bottom", 0xFFFFFF);
  }
}

// ============================================================================
// DISK MANAGER APP
// ============================================================================

void draw_disk_manager_content(int x, int y, int w, int h) {
  int cy = y + 28;
  draw_string(x + 10, cy + 10, "Disk Manager", 0xDDDDDD);

  int active_disk = shell_get_active_disk();
  bool hdd_present = shell_is_hdd_present();
  bool mounted = shell_is_fs_mounted();

  char disk_info[50];
  if (active_disk == 1) {
    string_copy(disk_info, "[MRD0] RAM Disk - ");
  } else if (active_disk == 2) {
    string_copy(disk_info, "[HDD0] Hard Disk - ");
  } else {
    string_copy(disk_info, "[---] No active disk - ");
  }

  if (active_disk > 0 && mounted) {
    string_copy(disk_info + string_length(disk_info), "FAT16 (Ready)");
  } else if (active_disk > 0) {
    string_copy(disk_info + string_length(disk_info), "Not mounted");
  }

  draw_string(x + 10, cy + 35, disk_info, 0xFFFFFF);

  draw_rect_alpha(x, cy + 55, w, 1, 0x444444, 255);

  // RAM Disk Buttons
  draw_string(x + 10, cy + 65, "RAM Disk:", 0xDDDDDD);
  draw_rect_alpha(x + 10, cy + 85, 120, 25, 0x005A9E, 255);
  draw_string(x + 20, cy + 93, "Mount RAM", 0xFFFFFF);
  draw_rect_alpha(x + 140, cy + 85, 120, 25, 0xEE7700, 255);
  draw_string(x + 150, cy + 93, "Format RAM", 0xFFFFFF);

  // HDD Buttons
  draw_string(x + 10, cy + 125,
              hdd_present ? "Hard Disk:" : "Hard Disk: Not Found", 0xDDDDDD);
  if (hdd_present) {
    draw_rect_alpha(x + 10, cy + 145, 120, 25, 0x005A9E, 255);
    draw_string(x + 20, cy + 153, "Mount HDD", 0xFFFFFF);
    draw_rect_alpha(x + 140, cy + 145, 120, 25, 0xEE7700, 255);
    draw_string(x + 150, cy + 153, "Format HDD", 0xFFFFFF);
  }

  // Global Unmount
  draw_rect_alpha(x + 10, cy + 185, w - 20, 25, 0xCC2222, 255);
  draw_string(x + (w / 2) - 30, cy + 193, "Unmount", 0xFFFFFF);
}

bool handle_disk_manager_click(int x, int y, int w) {
  int cy = y + 28;
  bool disk_changed = false;
  bool mounted_new = false;

  if (mouse_y >= cy + 85 && mouse_y <= cy + 110) {
    if (mouse_x >= x + 10 && mouse_x <= x + 130) {
      if (shell_mount_disk(1))
        mounted_new = true;
      disk_changed = true;
    } // Mount RAM
    else if (mouse_x >= x + 140 && mouse_x <= x + 260) {
      shell_format_disk(1);
      disk_changed = true;
    } // Format RAM
  }

  bool hdd_present = shell_is_hdd_present();
  if (hdd_present && mouse_y >= cy + 145 && mouse_y <= cy + 170) {
    if (mouse_x >= x + 10 && mouse_x <= x + 130) {
      if (shell_mount_disk(2))
        mounted_new = true;
      disk_changed = true;
    } // Mount HDD
    else if (mouse_x >= x + 140 && mouse_x <= x + 260) {
      shell_format_disk(2);
      disk_changed = true;
    } // Format HDD
  }

  if (mouse_y >= cy + 185 && mouse_y <= cy + 210) {
    if (mouse_x >= x + 10 && mouse_x <= x + w - 10) {
      shell_unmount_disk();
      disk_changed = true;
    }
  }

  // After mounting a new volume, load settings from set.con (if present)
  if (mounted_new)
    load_settings();

  return disk_changed;
}

void handle_settings_click(SettingsState &ss, int x, int y) {
  int cy = y + 28;
  bool setting_changed = false;

  // Tab clicks
  if (mouse_y >= cy + 10 && mouse_y <= cy + 35) {
    if (mouse_x >= x + 10 && mouse_x <= x + 130)
      ss.current_tab = 0;
    else if (mouse_x >= x + 140 && mouse_x <= x + 260)
      ss.current_tab = 1;
  }

  if (ss.current_tab == 0) {
    // Language clicks
    if (mouse_y >= cy + 70 && mouse_y <= cy + 95) {
      if (mouse_x >= x + 10 && mouse_x <= x + 90)
        ss.language = 0;
      else if (mouse_x >= x + 100 && mouse_x <= x + 180)
        ss.language = 1;
      else if (mouse_x >= x + 190 && mouse_x <= x + 270)
        ss.language = 2;
      shell_set_language(ss.language);
      setting_changed = true;
    }
    // Mouse speed clicks
    if (mouse_y >= cy + 130 && mouse_y <= cy + 155) {
      if (mouse_x >= x + 10 && mouse_x <= x + 70)
        global_mouse_speed = 0;
      else if (mouse_x >= x + 80 && mouse_x <= x + 140)
        global_mouse_speed = 1;
      else if (mouse_x >= x + 150 && mouse_x <= x + 210)
        global_mouse_speed = 2;
      else if (mouse_x >= x + 220 && mouse_x <= x + 280)
        global_mouse_speed = 3;
      setting_changed = true;
    }
  } else {
    // Wallpaper clicks
    if (get_total_ram_mb() > 128) {
      if (mouse_y >= cy + 70 && mouse_y <= cy + 95) {
        if (mouse_x >= x + 10 && mouse_x <= x + 90)
          global_wallpaper = 0;
        else if (mouse_x >= x + 100 && mouse_x <= x + 180)
          global_wallpaper = 1;
        else if (mouse_x >= x + 190 && mouse_x <= x + 270)
          global_wallpaper = 2;
        setting_changed = true;
      }
      if (mouse_y >= cy + 100 && mouse_y <= cy + 125) {
        if (mouse_x >= x + 10 && mouse_x <= x + 90)
          global_wallpaper = 3;
        else if (mouse_x >= x + 100 && mouse_x <= x + 180)
          global_wallpaper = 4;
        else if (mouse_x >= x + 190 && mouse_x <= x + 270)
          global_wallpaper = 5;
        setting_changed = true;
      }
      if (mouse_y >= cy + 130 && mouse_y <= cy + 155) {
        if (mouse_x >= x + 10 && mouse_x <= x + 90)
          global_wallpaper = 6;
        else if (mouse_x >= x + 100 && mouse_x <= x + 180)
          global_wallpaper = 7;
        else if (mouse_x >= x + 190 && mouse_x <= x + 270)
          global_wallpaper = 8;
        setting_changed = true;
      }
    }
    // Start color clicks
    if (mouse_y >= cy + 185 && mouse_y <= cy + 210) {
      if (mouse_x >= x + 10 && mouse_x <= x + 70)
        global_start_color_idx = 0;
      else if (mouse_x >= x + 80 && mouse_x <= x + 140)
        global_start_color_idx = 1;
      else if (mouse_x >= x + 150 && mouse_x <= x + 210)
        global_start_color_idx = 2;
      else if (mouse_x >= x + 220 && mouse_x <= x + 280)
        global_start_color_idx = 3;
      setting_changed = true;
    }
    // Menu style clicks
    if (mouse_y >= cy + 245 && mouse_y <= cy + 270) {
      if (mouse_x >= x + 10 && mouse_x <= x + 90)
        global_menu_style = 0;
      else if (mouse_x >= x + 100 && mouse_x <= x + 180)
        global_menu_style = 1;
      setting_changed = true;
    }
    // Bar position clicks
    if (mouse_y >= cy + 295 && mouse_y <= cy + 320) {
      if (mouse_x >= x + 10 && mouse_x <= x + 90)
        global_bar_position = 0;
      else if (mouse_x >= x + 100 && mouse_x <= x + 180)
        global_bar_position = 1;
      setting_changed = true;
    }
  }

  // Persist any changed setting immediately to set.con
  if (setting_changed)
    save_settings();
}

// ============================================================================
// WORD APP
// ============================================================================

struct WordState {
  char buffer[4096];
  int cursor_pos;
  char filename[13];
  int filename_len;
  bool shift_pressed;
  bool editing_filename;
  bool show_open_dialog;
};

// ============================================================================
// tabels (SPREADSHEET) APP
// ============================================================================

const int SHEET_COLS = 40;
const int SHEET_ROWS = 100;

struct SheetState {
  char cells[SHEET_COLS][SHEET_ROWS][32]; // larger for formulas
  int sel_x, sel_y;
  int scroll_x, scroll_y; // scroll offsets
  char filename[13];
  int filename_len;
  bool shift_pressed;
  bool show_open_dialog;
};

// Helper to convert column index to name (e.g., 0->A, 25->Z, 26->AA)
void col_to_name(int col, char *out) {
  int i = 0;
  if (col >= 26) {
    out[i++] = 'A' + (col / 26) - 1;
    out[i++] = 'A' + (col % 26);
  } else {
    out[i++] = 'A' + col;
  }
  out[i] = '\0';
}

// Helper for formulas
int get_cell_int(SheetState &ss, int col, int row, int depth);

int resolve_ref(SheetState &ss, const char *ref, int depth) {
  if (depth > 5)
    return 0;
  if (ref[0] >= 'A' && ref[0] <= 'Z') {
    int c = -1;
    int r = -1;
    int i = 0;
    if (ref[1] >= 'A' && ref[1] <= 'Z') {
      c = (ref[0] - 'A' + 1) * 26 + (ref[1] - 'A');
      i = 2;
    } else {
      c = ref[0] - 'A';
      i = 1;
    }
    if (c >= 0 && ref[i] >= '0' && ref[i] <= '9') {
      r = 0;
      while (ref[i] >= '0' && ref[i] <= '9') {
        r = r * 10 + (ref[i] - '0');
        i++;
      }
      r--; // 0-indexed row
      return get_cell_int(ss, c, r, depth + 1);
    }
  }
  // Is it just a number?
  bool num = true;
  for (int i = 0; ref[i]; i++)
    if (!(ref[i] >= '0' && ref[i] <= '9') && ref[i] != '-')
      num = false;
  if (num) {
    int res = 0;
    bool neg = false;
    int i = 0;
    if (ref[i] == '-') {
      neg = true;
      i++;
    }
    while (ref[i] >= '0' && ref[i] <= '9')
      res = res * 10 + (ref[i++] - '0');
    return neg ? -res : res;
  }
  return 0;
}

int get_cell_int(SheetState &ss, int col, int row, int depth) {
  if (col < 0 || col >= SHEET_COLS || row < 0 || row >= SHEET_ROWS)
    return 0;
  const char *v = ss.cells[col][row];
  if (v[0] == '\0')
    return 0;
  if (v[0] == '=') {
    // Formula!
    if (string_starts_with(v + 1, "SUM(")) {
      // Parse SUM(start_ref:end_ref)
      char start_ref[8] = {0};
      char end_ref[8] = {0};
      int i = 5; // skip "=SUM("
      int j = 0;
      while (v[i] && v[i] != ':') {
        if (j < 7)
          start_ref[j++] = v[i];
        i++;
      }
      if (v[i] == ':') {
        i++; // skip ':'
        j = 0;
        while (v[i] && v[i] != ')') {
          if (j < 7)
            end_ref[j++] = v[i];
          i++;
        }
      }
      // Parse start_ref coordinates
      int sc = -1, sr = -1;
      int idx = 0;
      if (start_ref[0] >= 'A' && start_ref[0] <= 'Z') {
        if (start_ref[1] >= 'A' && start_ref[1] <= 'Z') {
          sc = (start_ref[0] - 'A' + 1) * 26 + (start_ref[1] - 'A');
          idx = 2;
        } else {
          sc = start_ref[0] - 'A';
          idx = 1;
        }
        sr = 0;
        while (start_ref[idx] >= '0' && start_ref[idx] <= '9') {
          sr = sr * 10 + (start_ref[idx] - '0');
          idx++;
        }
        sr--;
      }

      // Parse end_ref coordinates
      int ec = -1, er = -1;
      idx = 0;
      if (end_ref[0] >= 'A' && end_ref[0] <= 'Z') {
        if (end_ref[1] >= 'A' && end_ref[1] <= 'Z') {
          ec = (end_ref[0] - 'A' + 1) * 26 + (end_ref[1] - 'A');
          idx = 2;
        } else {
          ec = end_ref[0] - 'A';
          idx = 1;
        }
        er = 0;
        while (end_ref[idx] >= '0' && end_ref[idx] <= '9') {
          er = er * 10 + (end_ref[idx] - '0');
          idx++;
        }
        er--;
      }

      int sum = 0;
      if (sc >= 0 && sr >= 0 && ec >= 0 && er >= 0) {
        for (int r = sr; r <= er; r++) {
          for (int c = sc; c <= ec; c++) {
            sum += get_cell_int(ss, c, r, depth + 1);
          }
        }
      }
      return sum;
    }
    // Basic A1+B2
    char r1[8] = {0}, r2[8] = {0};
    char op = 0;
    int i = 1, j = 0;
    while (v[i] && v[i] != '+' && v[i] != '-' && v[i] != '*' && v[i] != '/')
      r1[j++] = v[i++];
    if (v[i]) {
      op = v[i++];
      j = 0;
      while (v[i])
        r2[j++] = v[i++];
      int v1 = resolve_ref(ss, r1, depth);
      int v2 = resolve_ref(ss, r2, depth);
      if (op == '+')
        return v1 + v2;
      if (op == '-')
        return v1 - v2;
      if (op == '*')
        return v1 * v2;
      if (op == '/')
        return v2 ? v1 / v2 : 0;
    }
    return resolve_ref(ss, r1, depth);
  }
  // Raw number
  int res = 0;
  bool neg = false;
  int i = 0;
  if (v[i] == '-') {
    neg = true;
    i++;
  }
  while (v[i] >= '0' && v[i] <= '9')
    res = res * 10 + (v[i++] - '0');
  return neg ? -res : res;
}

void draw_sheet_content(int x, int y, int w, int h, SheetState &ss) {
  int cy = y + 28;
  // Toolbar
  draw_rect_alpha(x, cy, w, 30, 0x2D2D2D, 255);

  // Save/Load buttons
  draw_rect_alpha(x + 10, cy + 5, 50, 20, 0x107C10, 255); // tabels green
  draw_string(x + 15, cy + 11, "Save", 0xFFFFFF);

  draw_rect_alpha(x + 70, cy + 5, 50, 20, 0x107C10, 255);
  draw_string(x + 75, cy + 11, "Load", 0xFFFFFF);

  draw_string(x + 130, cy + 11, ss.filename, 0xDDDDDD);

  int grid_y = cy + 30;
  int row_header_w = 30;
  int col_header_h = 20;
  int cell_w = 70;
  int cell_h = 20;
  int scrollbar_size = 12;

  int y_start = grid_y + col_header_h;
  int scrollbar_y = y + h - scrollbar_size;
  int scrollbar_x = x + w - scrollbar_size;
  int grid_w = scrollbar_x - (x + row_header_w);
  int grid_h = scrollbar_y - y_start;

  int visible_cols = grid_w / cell_w;
  int visible_rows = grid_h / cell_h;

  // Clamp scroll offsets
  int max_scroll_x = SHEET_COLS - visible_cols;
  if (max_scroll_x < 0)
    max_scroll_x = 0;
  if (ss.scroll_x > max_scroll_x)
    ss.scroll_x = max_scroll_x;
  if (ss.scroll_x < 0)
    ss.scroll_x = 0;

  int max_scroll_y = SHEET_ROWS - visible_rows;
  if (max_scroll_y < 0)
    max_scroll_y = 0;
  if (ss.scroll_y > max_scroll_y)
    ss.scroll_y = max_scroll_y;
  if (ss.scroll_y < 0)
    ss.scroll_y = 0;

  // Draw Top-Left Corner
  draw_rect_alpha(x, grid_y, row_header_w, col_header_h, 0x333333, 255);

  // Draw Column Headers
  for (int c = 0; c < visible_cols; c++) {
    int col_idx = ss.scroll_x + c;
    if (col_idx >= SHEET_COLS)
      break;
    int cx = x + row_header_w + c * cell_w;
    draw_rect_alpha(cx, grid_y, cell_w, col_header_h, 0x333333, 255);
    char label[4];
    col_to_name(col_idx, label);
    draw_string(cx + (cell_w / 2) - string_length(label) * 4, grid_y + 6, label,
                0xFFFFFF);
  }

  // Draw Row Headers and Grid
  for (int r = 0; r < visible_rows; r++) {
    int row_idx = ss.scroll_y + r;
    if (row_idx >= SHEET_ROWS)
      break;
    int cy_cell = y_start + r * cell_h;

    // Draw Row Header
    draw_rect_alpha(x, cy_cell, row_header_w, cell_h, 0x333333, 255);
    char row_lbl[8];
    itoa_light(row_idx + 1, row_lbl);
    draw_string(x + 4, cy_cell + (cell_h / 2) - 4, row_lbl, 0xFFFFFF);

    // Draw cells in this row
    for (int c = 0; c < visible_cols; c++) {
      int col_idx = ss.scroll_x + c;
      if (col_idx >= SHEET_COLS)
        break;
      int cx = x + row_header_w + c * cell_w;

      bool is_selected = (ss.sel_x == col_idx && ss.sel_y == row_idx);
      uint32_t bg = is_selected ? 0x0E5A0E : 0x1E1E1E;
      draw_rect_alpha(cx, cy_cell, cell_w, cell_h, bg, 255);

      // Border
      draw_rect_alpha(cx, cy_cell, cell_w, 1, 0x3A3A3C, 255);
      draw_rect_alpha(cx, cy_cell, 1, cell_h, 0x3A3A3C, 255);

      if (is_selected) {
        // Show formula while editing
        draw_string(cx + 4, cy_cell + (cell_h / 2) - 4,
                    ss.cells[col_idx][row_idx], 0xFFFFFF);
      } else {
        // Show result
        if (ss.cells[col_idx][row_idx][0] == '=') {
          int val = get_cell_int(ss, col_idx, row_idx, 0);
          char buf[16];
          itoa_light(val, buf);
          draw_string(cx + 4, cy_cell + (cell_h / 2) - 4, buf,
                      0x4CAF50); // Bright green for formulas
        } else {
          draw_string(cx + 4, cy_cell + (cell_h / 2) - 4,
                      ss.cells[col_idx][row_idx], 0xFFFFFF);
        }
      }
    }
  }

  // Draw vertical scrollbar
  draw_rect_alpha(scrollbar_x, y_start, scrollbar_size, grid_h, 0x2D2D2D,
                  255); // Track
  if (visible_rows < SHEET_ROWS) {
    int thumb_h = (visible_rows * grid_h) / SHEET_ROWS;
    if (thumb_h < 15)
      thumb_h = 15;
    int thumb_y = y_start;
    if (max_scroll_y > 0) {
      thumb_y += (ss.scroll_y * (grid_h - thumb_h)) / max_scroll_y;
    }
    draw_rect_alpha(scrollbar_x + 2, thumb_y, scrollbar_size - 4, thumb_h,
                    0x666666, 255); // Thumb
  }

  // Draw horizontal scrollbar
  draw_rect_alpha(x + row_header_w, scrollbar_y, grid_w, scrollbar_size,
                  0x2D2D2D, 255); // Track
  if (visible_cols < SHEET_COLS) {
    int thumb_w = (visible_cols * grid_w) / SHEET_COLS;
    if (thumb_w < 15)
      thumb_w = 15;
    int thumb_x = x + row_header_w;
    if (max_scroll_x > 0) {
      thumb_x += (ss.scroll_x * (grid_w - thumb_w)) / max_scroll_x;
    }
    draw_rect_alpha(thumb_x, scrollbar_y + 2, thumb_w, scrollbar_size - 4,
                    0x666666, 255); // Thumb
  }

  // Scroll corner
  draw_rect_alpha(scrollbar_x, scrollbar_y, scrollbar_size, scrollbar_size,
                  0x1E1E1E, 255);

  if (ss.show_open_dialog) {
    draw_rect_alpha(x + 20, y + 60, w - 40, h - 100, 0x252526, 255);
    draw_rect_alpha(x + 20, y + 60, w - 40, 25, 0x107C10, 255);
    draw_string(x + 30, y + 68, "Select File (.SHT)", 0xFFFFFF);

    int count = get_shell_file_count();
    int visible = 0;
    for (int i = 0; i < count && visible < 8; i++) {
      char name[16];
      get_shell_file_name(i, name);
      if (!get_shell_file_is_dir(i)) {
        draw_string(x + 30, y + 95 + visible * 20, name, 0xFFFFFF);
        visible++;
      }
    }
  }
}

bool handle_sheet_click(SheetState &ss, int x, int y, int w, int h) {
  int cy = y + 28;
  int grid_y = cy + 30;

  int row_header_w = 30;
  int col_header_h = 20;
  int cell_w = 70;
  int cell_h = 20;
  int scrollbar_size = 12;

  int y_start = grid_y + col_header_h;
  int scrollbar_y = y + h - scrollbar_size;
  int scrollbar_x = x + w - scrollbar_size;
  int grid_w = scrollbar_x - (x + row_header_w);
  int grid_h = scrollbar_y - y_start;

  int visible_cols = grid_w / cell_w;
  int visible_rows = grid_h / cell_h;

  if (ss.show_open_dialog) {
    if (mouse_y >= y + 90 && mouse_y < y + 90 + 160) {
      int idx = (mouse_y - (y + 90)) / 20;
      // Find the idx-th non-directory file
      int found = -1;
      int current = 0;
      for (int i = 0; i < get_shell_file_count(); i++) {
        if (!get_shell_file_is_dir(i)) {
          if (current == idx) {
            found = i;
            break;
          }
          current++;
        }
      }
      if (found != -1) {
        get_shell_file_name(found, ss.filename);
        ss.filename_len = string_length(ss.filename);
        shell_read_file(ss.filename, (char *)ss.cells, sizeof(ss.cells));
        ss.show_open_dialog = false;
        ss.scroll_x = 0;
        ss.scroll_y = 0;
        return true;
      }
    }
    if (mouse_x < x + 20 || mouse_x > x + w - 20 || mouse_y < y + 60 ||
        mouse_y > y + h - 40) {
      ss.show_open_dialog = false;
      return true;
    }
    return false;
  }

  // Save/Load
  if (mouse_y >= cy + 5 && mouse_y <= cy + 25) {
    if (mouse_x >= x + 10 && mouse_x <= x + 60) {
      shell_write_file(ss.filename, (char *)ss.cells, sizeof(ss.cells));
      shell_refresh_files();
      return true;
    }
    if (mouse_x >= x + 70 && mouse_x <= x + 120) {
      ss.show_open_dialog = true;
      return true;
    }
  }

  // Vertical scrollbar click
  if (mouse_x >= scrollbar_x && mouse_x < x + w && mouse_y >= y_start &&
      mouse_y < scrollbar_y) {
    int click_y = mouse_y - y_start;
    int max_scroll_y = SHEET_ROWS - visible_rows;
    if (max_scroll_y > 0) {
      ss.scroll_y = (click_y * max_scroll_y) / grid_h;
      if (ss.scroll_y < 0)
        ss.scroll_y = 0;
      if (ss.scroll_y > max_scroll_y)
        ss.scroll_y = max_scroll_y;
    }
    return true;
  }

  // Horizontal scrollbar click
  if (mouse_y >= scrollbar_y && mouse_y < y + h &&
      mouse_x >= x + row_header_w && mouse_x < scrollbar_x) {
    int click_x = mouse_x - (x + row_header_w);
    int max_scroll_x = SHEET_COLS - visible_cols;
    if (max_scroll_x > 0) {
      ss.scroll_x = (click_x * max_scroll_x) / grid_w;
      if (ss.scroll_x < 0)
        ss.scroll_x = 0;
      if (ss.scroll_x > max_scroll_x)
        ss.scroll_x = max_scroll_x;
    }
    return true;
  }

  // Grid selection
  int x_start = x + row_header_w;
  if (mouse_x >= x_start && mouse_x < scrollbar_x && mouse_y >= y_start &&
      mouse_y < scrollbar_y) {
    ss.sel_x = ss.scroll_x + (mouse_x - x_start) / cell_w;
    ss.sel_y = ss.scroll_y + (mouse_y - y_start) / cell_h;
    if (ss.sel_x < 0)
      ss.sel_x = 0;
    if (ss.sel_x >= SHEET_COLS)
      ss.sel_x = SHEET_COLS - 1;
    if (ss.sel_y < 0)
      ss.sel_y = 0;
    if (ss.sel_y >= SHEET_ROWS)
      ss.sel_y = SHEET_ROWS - 1;
    return true;
  }

  return false;
}

void draw_word_content(int x, int y, int w, int h, WordState &ws) {
  int cy = y + 28;
  // Toolbar
  draw_rect_alpha(x, cy, w, 30, 0x2D2D2D, 255);

  // Save/Load buttons
  draw_rect_alpha(x + 10, cy + 5, 60, 20, 0x005A9E, 255);
  draw_string(x + 20, cy + 11, "Save", 0xFFFFFF);

  draw_rect_alpha(x + 80, cy + 5, 60, 20, 0x005A9E, 255);
  draw_string(x + 90, cy + 11, "Load", 0xFFFFFF);

  draw_string(x + 150, cy + 11, "File:", 0xDDDDDD);

  draw_rect_alpha(x + 190, cy + 5, 100, 20,
                  ws.editing_filename ? 0x444444 : 0x1E1E1E, 255);
  draw_string(x + 195, cy + 11, ws.filename, 0xFFFFFF);

  if (ws.show_open_dialog) {
    draw_rect_alpha(x + 10, cy + 40, w - 20, h - 75, 0x252526, 255);
    int list_y = cy + 45;
    int count = get_shell_file_count();
    draw_string(x + 15, list_y, "Select a file to load:", 0xFFFFFF);
    for (int i = 0; i < count && i < 10; i++) {
      char name[16];
      get_shell_file_name(i, name);
      draw_rect_alpha(x + 15, list_y + 20 + i * 20, w - 30, 18, 0x333333, 255);
      draw_string(x + 20, list_y + 25 + i * 20, name, 0xFFFFFF);
    }
    return; // Don't draw text area behind
  }

  // Text area
  draw_rect_alpha(x + 10, cy + 40, w - 20, h - 75, 0x1E1E1E, 255);
  // Just draw a thin outline manually:
  draw_rect_alpha(x + 10, cy + 40, w - 20, 1, 0x444444, 255);
  draw_rect_alpha(x + 10, cy + 40, 1, h - 75, 0x444444, 255);

  // Draw text
  int tx = x + 15;
  int ty = cy + 45;
  int len = string_length(ws.buffer);

  // Track cursor position coordinates
  int cursor_x = tx;
  int cursor_y = ty;

  for (int i = 0; i < len; i++) {
    if (i == ws.cursor_pos) {
      cursor_x = tx;
      cursor_y = ty;
    }

    char c = ws.buffer[i];
    if (c == '\n') {
      tx = x + 15;
      ty += 14;
    } else {
      draw_char(tx, ty, c, 0xFFFFFF);
      tx += 8;
      if (tx > x + w - 25) {
        tx = x + 15;
        ty += 14;
      }
    }
  }

  // If cursor is at the end of the text
  if (ws.cursor_pos == len) {
    cursor_x = tx;
    cursor_y = ty;
  }

  // Draw the blinking cursor
  if (!ws.editing_filename) {
    Time t = get_time();
    if (t.second % 2 == 0) {
      draw_rect_alpha(cursor_x, cursor_y, 2, 12, 0xFFFFFF, 255);
    }
  }
}

void handle_word_click(WordState &ws, int x, int y, int w, int h) {
  int cy = y + 28;

  if (ws.show_open_dialog) {
    int list_y = cy + 45;
    int count = get_shell_file_count();
    for (int i = 0; i < count && i < 10; i++) {
      if (mouse_y >= list_y + 20 + i * 20 && mouse_y <= list_y + 38 + i * 20) {
        // picked a file
        char name[16];
        get_shell_file_name(i, name);
        string_copy(ws.filename, name);
        ws.filename_len = string_length(name);
        if (shell_read_file(ws.filename, ws.buffer, 4096)) {
          ws.cursor_pos = 0;
          while (ws.buffer[ws.cursor_pos] != '\0' && ws.cursor_pos < 4096)
            ws.cursor_pos++;
        } else {
          ws.buffer[0] = '\0';
          ws.cursor_pos = 0;
        }
        ws.show_open_dialog = false;
        return;
      }
    }
    ws.show_open_dialog = false;
    return;
  }

  // buttons
  if (mouse_y >= cy + 5 && mouse_y <= cy + 25) {
    if (mouse_x >= x + 10 && mouse_x <= x + 70) {
      shell_write_file(ws.filename, ws.buffer, string_length(ws.buffer));
      shell_refresh_files();
    } else if (mouse_x >= x + 80 && mouse_x <= x + 140) {
      ws.show_open_dialog = true;
    } else if (mouse_x >= x + 190 && mouse_x <= x + 290) {
      ws.editing_filename = true;
      return;
    }
  }
  ws.editing_filename = false;

  // Text area click to move cursor
  if (mouse_x >= x + 10 && mouse_x < x + w - 10 && mouse_y >= cy + 40 &&
      mouse_y < cy + 40 + h - 75) {
    int target_cursor = -1;
    int min_dist = 99999999;
    int tx = x + 15;
    int ty = cy + 45;
    int len = string_length(ws.buffer);

    for (int i = 0; i <= len; i++) {
      int dy_diff = mouse_y - (ty + 7);
      int dx_diff = mouse_x - (tx + 4);
      int dist = dy_diff * dy_diff + dx_diff * dx_diff;
      if (dist < min_dist) {
        min_dist = dist;
        target_cursor = i;
      }
      if (i == len)
        break;

      char c = ws.buffer[i];
      if (c == '\n') {
        tx = x + 15;
        ty += 14;
      } else {
        tx += 8;
        if (tx > x + w - 25) {
          tx = x + 15;
          ty += 14;
        }
      }
    }
    if (target_cursor != -1) {
      ws.cursor_pos = target_cursor;
    }
  }
}

void handle_word_key(WordState &ws, uint8_t scancode) {
  if (scancode == 0x2A || scancode == 0x36)
    ws.shift_pressed = true;
  else if (scancode == 0xAA || scancode == 0xB6)
    ws.shift_pressed = false;
  else if ((scancode & 0x80) == 0) { // key press
    if (ws.editing_filename) {
      if (scancode == 0x0E && ws.filename_len > 0) { // Backspace
        ws.filename[--ws.filename_len] = '\0';
      } else if (scancode == 0x1C) { // Enter
        ws.editing_filename = false;
      } else {
        char ch = shell_scancode_to_ascii(scancode, ws.shift_pressed);
        if (ch && ws.filename_len < 12) {
          ws.filename[ws.filename_len++] = ch;
          ws.filename[ws.filename_len] = '\0';
        }
      }
    } else {
      if (scancode == 0x0E && ws.cursor_pos > 0) { // Backspace
        int len = string_length(ws.buffer);
        for (int i = ws.cursor_pos - 1; i < len; i++) {
          ws.buffer[i] = ws.buffer[i + 1];
        }
        ws.cursor_pos--;
      } else if (scancode == 0x1C && ws.cursor_pos < 4095) { // Enter
        int len = string_length(ws.buffer);
        if (len < 4095) {
          for (int i = len; i >= ws.cursor_pos; i--) {
            ws.buffer[i + 1] = ws.buffer[i];
          }
          ws.buffer[ws.cursor_pos++] = '\n';
        }
      } else if (scancode == 0x4B) { // Left arrow
        if (ws.cursor_pos > 0) {
          ws.cursor_pos--;
        }
      } else if (scancode == 0x4D) { // Right arrow
        int len = string_length(ws.buffer);
        if (ws.cursor_pos < len) {
          ws.cursor_pos++;
        }
      } else {
        char ch = shell_scancode_to_ascii(scancode, ws.shift_pressed);
        // Simple printable ascii
        if (ch >= 32 && ch <= 126 && ws.cursor_pos < 4095) {
          int len = string_length(ws.buffer);
          if (len < 4095) {
            for (int i = len; i >= ws.cursor_pos; i--) {
              ws.buffer[i + 1] = ws.buffer[i];
            }
            ws.buffer[ws.cursor_pos++] = ch;
          }
        }
      }
    }
  }
}

// ============================================================================
// UI COMPOSITION
// ============================================================================

#define RESIZE_NONE 0
#define RESIZE_RIGHT 1
#define RESIZE_BOTTOM 2
#define RESIZE_LEFT 4
#define RESIZE_TOP 8

struct WinState {
  int x, y, w, h;
  bool open;
  bool minimized;
  bool dragging;
  int drag_ox, drag_oy;
  bool resizing;
  int resize_mode;
  int resize_start_x, resize_start_y;
  int resize_start_w, resize_start_h;
  int resize_start_win_x, resize_start_win_y;
};

static WinState welcome = {80, 60, 640, 340, true, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState fm = {120, 80, 500, 380, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState calc = {200, 100, 200, 280, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState word = {50, 50, 500, 400, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState tabels = {100, 100, 500, 300, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState settings = {300, 100, 300, 370, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState disk_manager = {350, 150, 300, 250, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};
static WinState mpra_win = {150, 80, 400, 400, false, false, false, 0, 0, false, 0, 0, 0, 0, 0, 0, 0};

static CalcState cs;
static WordState ws;
static SheetState sss;
static SettingsState ss = {0}; // 0 = EN

// ============================================================================
// PERSISTENT SETTINGS - implementation (ss is now in scope)
// ============================================================================

void save_settings() {
  if (!shell_is_fs_mounted())
    return;

  char buf[256];
  int pos = 0;

  const char *k0 = "wallpaper=";
  for (int i = 0; k0[i]; i++)
    buf[pos++] = k0[i];
  pos = settings_append_int(buf, pos, global_wallpaper);
  buf[pos++] = '\n';

  const char *k1 = "color=";
  for (int i = 0; k1[i]; i++)
    buf[pos++] = k1[i];
  pos = settings_append_int(buf, pos, global_start_color_idx);
  buf[pos++] = '\n';

  const char *k2 = "menustyle=";
  for (int i = 0; k2[i]; i++)
    buf[pos++] = k2[i];
  pos = settings_append_int(buf, pos, global_menu_style);
  buf[pos++] = '\n';

  const char *k3 = "barpos=";
  for (int i = 0; k3[i]; i++)
    buf[pos++] = k3[i];
  pos = settings_append_int(buf, pos, global_bar_position);
  buf[pos++] = '\n';

  const char *k4 = "mousespeed=";
  for (int i = 0; k4[i]; i++)
    buf[pos++] = k4[i];
  pos = settings_append_int(buf, pos, global_mouse_speed);
  buf[pos++] = '\n';

  const char *k5 = "language=";
  for (int i = 0; k5[i]; i++)
    buf[pos++] = k5[i];
  pos = settings_append_int(buf, pos, ss.language);
  buf[pos++] = '\n';

  buf[pos] = '\0';
  shell_write_file("set.con", buf, pos);
}

void load_settings() {
  if (!shell_is_fs_mounted())
    return;

  char buf[256];
  buf[0] = '\0';
  if (!shell_read_file("SET.CON", buf, 255))
    return;
  buf[255] = '\0';

  const char *p = buf;
  while (*p) {
    const char *line_start = p;
    while (*p && *p != '=' && *p != '\n')
      p++;
    if (*p != '=') {
      while (*p && *p != '\n')
        p++;
      if (*p == '\n')
        p++;
      continue;
    }
    int key_len = (int)(p - line_start);
    p++; // skip '='
    int val = settings_parse_int(p);
    while (*p && *p != '\n')
      p++;
    if (*p == '\n')
      p++;

    // Match known keys by length + content
    if (key_len == 9 && line_start[0] == 'w' && line_start[1] == 'a' &&
        line_start[2] == 'l' && line_start[3] == 'l' && line_start[4] == 'p' &&
        line_start[5] == 'a' && line_start[6] == 'p' && line_start[7] == 'e' &&
        line_start[8] == 'r') {
      if (val >= 0 && val <= 8)
        global_wallpaper = val;
    } else if (key_len == 5 && line_start[0] == 'c' && line_start[1] == 'o' &&
               line_start[2] == 'l' && line_start[3] == 'o' &&
               line_start[4] == 'r') {
      if (val >= 0 && val <= 3)
        global_start_color_idx = val;
    } else if (key_len == 9 && line_start[0] == 'm' && line_start[1] == 'e' &&
               line_start[2] == 'n' && line_start[3] == 'u' &&
               line_start[4] == 's' && line_start[5] == 't' &&
               line_start[6] == 'y' && line_start[7] == 'l' &&
               line_start[8] == 'e') {
      if (val >= 0 && val <= 1)
        global_menu_style = val;
    } else if (key_len == 6 && line_start[0] == 'b' && line_start[1] == 'a' &&
               line_start[2] == 'r' && line_start[3] == 'p' &&
               line_start[4] == 'o' && line_start[5] == 's') {
      if (val >= 0 && val <= 1)
        global_bar_position = val;
    } else if (key_len == 10 && line_start[0] == 'm' && line_start[1] == 'o' &&
               line_start[2] == 'u' && line_start[3] == 's' &&
               line_start[4] == 'e' && line_start[5] == 's' &&
               line_start[6] == 'p' && line_start[7] == 'e' &&
               line_start[8] == 'e' && line_start[9] == 'd') {
      if (val >= 0 && val <= 3)
        global_mouse_speed = val;
    } else if (key_len == 8 && line_start[0] == 'l' && line_start[1] == 'a' &&
               line_start[2] == 'n' && line_start[3] == 'g' &&
               line_start[4] == 'u' && line_start[5] == 'a' &&
               line_start[6] == 'g' && line_start[7] == 'e') {
      if (val >= 0 && val <= 2) {
        ss.language = val;
        shell_set_language(val);
      }
    }
  }
}

static int fm_selected = 0;
static int fm_scroll = 0;
static bool fm_files_loaded = false;
static bool menu_open = false;

void draw_all_ui(WinState &welcome, WinState &fm, WinState &calc,
                 WinState &word, WinState &tabels, WinState &settings,
                 WinState &disk_manager, CalcState &cs, WordState &ws,
                 SheetState &sss, SettingsState &ss, int fm_selected,
                 int fm_scroll) {
  load_settings();
  draw_wallpaper();

  // Draw Welcome window
  if (welcome.open) {
    if (!welcome.minimized) {
      draw_window(welcome.x, welcome.y, welcome.w, welcome.h,
                  "Welcome to 2.1.3 Appril", true);
      draw_string(welcome.x + 20, welcome.y + 50,
                  "Welcome to Milla OS 2.1.3 Appril", 0xFFFFFF);
      if (get_total_ram_mb() > 128) {
        draw_image(welcome.x + 20, welcome.y + 80, 100, 100,
                   _binary_logo1_raw_start);
        draw_string(welcome.x + 140, welcome.y + 80,
                    "Milla OS 2.1.3 Appril is a FOSS Operating System.",
                    0xDDDDDD);
        draw_string(welcome.x + 140, welcome.y + 100,
                    "Written in C++ in Germany.", 0xDDDDDD);
        draw_rect_alpha(welcome.x + 20, welcome.y + 200, 500, 1, 0x444444, 255);
        draw_image(welcome.x + 20, welcome.y + 220, 80, 80,
                   _binary_logo2_raw_start);
        draw_string(welcome.x + 120, welcome.y + 220,
                    "(c) 2025 - 2026 codeberg.orgFloriDevs", 0xAAAAAA);
      } else {
        draw_string(welcome.x + 20, welcome.y + 80,
                    "Milla OS 2.1.3 Appril is a FOSS Operating System.",
                    0xDDDDDD);
        draw_string(welcome.x + 20, welcome.y + 100,
                    "Written in C++ in Germany.", 0xDDDDDD);
        draw_rect_alpha(welcome.x + 20, welcome.y + 130, 500, 1, 0x444444, 255);
        draw_string(welcome.x + 20, welcome.y + 150,
                    "(c) 2025 - 2026 codeberg.orgFloriDevs", 0xAAAAAA);
      }
    } else {
      draw_window(welcome.x, welcome.y, welcome.w, 28, "Milla Welcome", true);
    }
  }

  // Draw File Manager window
  if (fm.open) {
    if (!fm.minimized) {
      draw_window(fm.x, fm.y, fm.w, fm.h, "File Manager", true);
      draw_file_manager_content(fm.x, fm.y, fm.w, fm.h, fm_selected, fm_scroll);
    } else {
      draw_window(fm.x, fm.y, fm.w, 28, "File Manager", true);
    }
  }

  // Draw Calculator window
  if (calc.open) {
    if (!calc.minimized) {
      draw_window(calc.x, calc.y, calc.w, calc.h, "Calculator", true);
      draw_calculator_content(calc.x, calc.y, calc.w, calc.h, cs);
    } else {
      draw_window(calc.x, calc.y, calc.w, 28, "Calculator", true);
    }
  }

  // Draw Word window (Documents)
  if (word.open) {
    if (!word.minimized) {
      draw_window(word.x, word.y, word.w, word.h, "Documents", true);
      draw_word_content(word.x, word.y, word.w, word.h, ws);
    } else {
      draw_window(word.x, word.y, word.w, 28, "Documents", true);
    }
  }

  // Draw tabels window (tabels)
  if (tabels.open) {
    if (!tabels.minimized) {
      draw_window(tabels.x, tabels.y, tabels.w, tabels.h, "tabels", true);
      draw_sheet_content(tabels.x, tabels.y, tabels.w, tabels.h, sss);
    } else {
      draw_window(tabels.x, tabels.y, tabels.w, 28, "tabels", true);
    }
  }

  // Draw Settings window
  if (settings.open) {
    if (!settings.minimized) {
      draw_window(settings.x, settings.y, settings.w, settings.h, "Settings",
                  true);
      draw_settings_content(settings.x, settings.y, settings.w, settings.h, ss);
    } else {
      draw_window(settings.x, settings.y, settings.w, 28, "Settings", true);
    }
  }

  // Draw Disk Manager window
  if (disk_manager.open) {
    if (!disk_manager.minimized) {
      draw_window(disk_manager.x, disk_manager.y, disk_manager.w,
                  disk_manager.h, "Disk Manager", true);
      draw_disk_manager_content(disk_manager.x, disk_manager.y, disk_manager.w,
                                disk_manager.h);
    } else {
      draw_window(disk_manager.x, disk_manager.y, disk_manager.w, 28,
                  "Disk Manager", true);
    }
  }

  // Draw MPra window
  if (mpra_win.open) {
    if (!mpra_win.minimized) {
      draw_window(mpra_win.x, mpra_win.y, mpra_win.w, mpra_win.h,
                  mpra_get_window_title(), true);
      mpra_draw_content(mpra_win.x, mpra_win.y, mpra_win.w, mpra_win.h);
    } else {
      draw_window(mpra_win.x, mpra_win.y, mpra_win.w, 28,
                  mpra_get_window_title(), true);
    }
  }

  draw_top_bar();
}

void draw_menu_dropdown() {
  int mw = 180;
  int item_h = 30;
  int item_count = 7;
  int mh = item_count * item_h + 10;
  int mx = (screen.width - mw) / 2;
  int my = (screen.height - mh) / 2;

  if (global_menu_style == 1) {
    mx = screen.width - mw;
    my = (global_bar_position == 0) ? 25 : 0;
    mh = screen.height - 25;
  }

  // Drop shadow + transparent dark background (like top bar)
  draw_rect_alpha(mx + 4, my + 4, mw, mh, 0x000000, 80);
  draw_rect_alpha(mx, my, mw, mh, 0x000000, 180);

  const char *labels[7] = {"Welcome",     "File Manager", "Calculator",
                           "Documents",   "Spreadsheet",  "Settings",
                           "Disk Manager"};
  for (int i = 0; i < item_count; i++) {
    int iy = my + 5 + i * item_h;
    // Hover highlight
    if (mouse_x >= mx && mouse_x <= mx + mw && mouse_y >= iy &&
        mouse_y < iy + item_h) {
      draw_rect_alpha(mx + 5, iy, mw - 10, item_h, 0xCC2222, 200);
      draw_string(mx + 20, iy + 10, labels[i], 0xFFFFFF);
    } else {
      draw_string(mx + 20, iy + 10, labels[i], 0xDDDDDD);
    }
  }
}

void update_window_resize(WinState &win, int mx, int my) {
  if (!win.resizing)
    return;

  int min_w = 160;
  int min_h = 100;
  int scr_w = screen.width;
  int scr_h = screen.height;

  // Handle Right (East)
  if (win.resize_mode & RESIZE_RIGHT) {
    int dx = mx - win.resize_start_x;
    int new_w = win.resize_start_w + dx;
    if (new_w < min_w) new_w = min_w;
    if (win.x + new_w > scr_w) new_w = scr_w - win.x;
    win.w = new_w;
  }

  // Handle Bottom (South)
  if (win.resize_mode & RESIZE_BOTTOM) {
    int dy = my - win.resize_start_y;
    int new_h = win.resize_start_h + dy;
    if (new_h < min_h) new_h = min_h;
    if (win.y + new_h > scr_h) new_h = scr_h - win.y;
    win.h = new_h;
  }

  // Handle Left (West)
  if (win.resize_mode & RESIZE_LEFT) {
    int dx = mx - win.resize_start_x;
    int new_w = win.resize_start_w - dx;
    int new_x = win.resize_start_win_x + dx;
    if (new_w < min_w) {
      new_x = win.resize_start_win_x + (win.resize_start_w - min_w);
      new_w = min_w;
    }
    if (new_x < 0) {
      new_w += new_x;
      new_x = 0;
    }
    win.x = new_x;
    win.w = new_w;
  }

  // Handle Top (North)
  if (win.resize_mode & RESIZE_TOP) {
    int dy = my - win.resize_start_y;
    int new_h = win.resize_start_h - dy;
    int new_y = win.resize_start_win_y + dy;
    if (new_h < min_h) {
      new_y = win.resize_start_win_y + (win.resize_start_h - min_h);
      new_h = min_h;
    }
    if (new_y < 0) {
      new_h += new_y;
      new_y = 0;
    }
    win.y = new_y;
    win.h = new_h;
  }
}

// Handle title-bar clicks (minimize, close, drag) and window resizing
bool handle_window_titlebar(WinState &win, int mx, int my, bool clicked) {
  if (!win.open || !clicked)
    return false;

  int margin = 8;

  // Title-bar hit (top 28 pixels)
  if (my >= win.y && my <= win.y + 28 && mx >= win.x && mx <= win.x + win.w) {
    if (mx >= win.x + win.w - 28 && mx <= win.x + win.w - 8) {
      win.open = false;
      return true;
    } else if (mx >= win.x + win.w - 48 && mx <= win.x + win.w - 28) {
      win.minimized = !win.minimized;
      return true;
    } else if (!win.minimized && my <= win.y + margin) {
      // Top resize border
      win.resizing = true;
      win.resize_mode = RESIZE_TOP;
      if (mx <= win.x + margin) win.resize_mode |= RESIZE_LEFT;
      if (mx >= win.x + win.w - margin) win.resize_mode |= RESIZE_RIGHT;
      win.resize_start_x = mx;
      win.resize_start_y = my;
      win.resize_start_w = win.w;
      win.resize_start_h = win.h;
      win.resize_start_win_x = win.x;
      win.resize_start_win_y = win.y;
      return true;
    } else {
      win.dragging = true;
      win.minimized = true; // Minimize while dragging
      win.drag_ox = mx - win.x;
      win.drag_oy = my - win.y;
      return true;
    }
  }

  // Check resize borders for non-minimized windows
  if (!win.minimized) {
    bool on_left = (mx >= win.x - margin && mx <= win.x + margin);
    bool on_right = (mx >= win.x + win.w - margin && mx <= win.x + win.w + margin);
    bool on_top = (my >= win.y - margin && my <= win.y + margin);
    bool on_bottom = (my >= win.y + win.h - margin && my <= win.y + win.h + margin);

    bool inside_x = (mx >= win.x - margin && mx <= win.x + win.w + margin);
    bool inside_y = (my >= win.y - margin && my <= win.y + win.h + margin);

    if (inside_x && inside_y && (on_left || on_right || on_top || on_bottom)) {
      int mode = RESIZE_NONE;
      if (on_left) mode |= RESIZE_LEFT;
      if (on_right) mode |= RESIZE_RIGHT;
      if (on_top) mode |= RESIZE_TOP;
      if (on_bottom) mode |= RESIZE_BOTTOM;

      if (mode != RESIZE_NONE) {
        win.resizing = true;
        win.resize_mode = mode;
        win.resize_start_x = mx;
        win.resize_start_y = my;
        win.resize_start_w = win.w;
        win.resize_start_h = win.h;
        win.resize_start_win_x = win.x;
        win.resize_start_win_y = win.y;
        return true;
      }
    }
  }

  return false;
}

extern "C" void mpra_trigger_redraw() {
  draw_all_ui(welcome, fm, calc, word, tabels, settings, disk_manager, cs, ws,
              sss, ss, fm_selected, fm_scroll);
  if (menu_open)
    draw_menu_dropdown();

  // Draw the mouse cursor and swap buffers
  for (int y = 0; y < (int)screen.height; y++) {
    for (int x = 0; x < (int)screen.width; x++) {
      uint32_t pixel = ui_buffer[y * screen.width + x];
      if (x == mouse_x && y >= mouse_y - 5 && y <= mouse_y + 5)
        pixel = 0xFFFFFF;
      if (y == mouse_y && x >= mouse_x - 5 && x <= mouse_x + 5)
        pixel = 0xFFFFFF;
      if (frontbuffer[y * screen.width + x] != pixel) {
        frontbuffer[y * screen.width + x] = pixel;
        put_pixel(x, y, pixel);
      }
    }
  }
}

extern "C" void mpra_delay(int seconds) {
  Time start = get_time();
  int start_sec = start.hour * 3600 + start.minute * 60 + start.second;
  while (1) {
    Time now = get_time();
    int now_sec = now.hour * 3600 + now.minute * 60 + now.second;
    int diff = now_sec - start_sec;
    if (diff < 0)
      diff += 24 * 3600;
    if (diff >= seconds)
      break;

    mpra_trigger_redraw();

    for (int k = 0; k < 10000; k++)
      asm volatile("nop");
  }
}

extern "C" void start_graphical_shell() {
  ui_buffer = (uint32_t *)malloc(screen.width * screen.height * 4);
  frontbuffer = (uint32_t *)malloc(screen.width * screen.height * 4);

  if (!ui_buffer || !frontbuffer) {
    // Emergency fallback if heap fails
    return;
  }

  // Initialize buffers
  for (uint32_t i = 0; i < screen.width * screen.height; i++) {
    ui_buffer[i] = 0;
    frontbuffer[i] = 0x00000001; // Distinct value
  }

  init_minimal_font();

  // Initialize states
  string_copy(cs.display, "0");
  cs.first_val = 0;
  cs.last_op = 0;
  cs.next_clears = true;

  string_copy(ws.filename, "DOC.TXT");
  ws.filename_len = 7;
  ws.buffer[0] = '\0';
  ws.cursor_pos = 0;
  ws.shift_pressed = false;
  ws.editing_filename = false;
  ws.show_open_dialog = false;

  static bool sss_init = false;
  if (!sss_init) {
    for (int r = 0; r < SHEET_ROWS; r++) {
      for (int c = 0; c < SHEET_COLS; c++) {
        sss.cells[c][r][0] = '\0';
      }
    }
    sss.sel_x = 0;
    sss.sel_y = 0;
    sss.scroll_x = 0;
    sss.scroll_y = 0;
    string_copy(sss.filename, "BOOK.SHT");
    sss.filename_len = 8;
    sss.shift_pressed = false;
    sss.show_open_dialog = false;
    sss_init = true;
  }

  ss.language = 0;
  ss.current_tab = 0;

  fm_selected = 0;
  fm_scroll = 0;
  fm_files_loaded = false;
  menu_open = false;

  // Load persistent settings from set.con if a volume is already mounted
  load_settings();
  // Apply the potentially-loaded language to the kernel scancode mapper
  shell_set_language(ss.language);

  bool last_mouse_left_state = false;

  int menu_btn_x = screen.width - 70;

  bool first_frame = true;

  while (1) {
    uint8_t scancode = get_keyboard_input_nonblock();

    bool needs_redraw = first_frame;
    first_frame = false;

    if (scancode == 0x3B) { // F1 - Global Super Key for Milla OS
      menu_open = !menu_open;
      needs_redraw = true;
    }

    if (scancode == 0x58) { // F12 - Switch to CLI
      break;
    }

    // Shift tracking for FM dialog
    if (scancode == 0x2A || scancode == 0x36)
      fm_shift = true;
    else if (scancode == (0x2A | 0x80) || scancode == (0x36 | 0x80))
      fm_shift = false;

    // Keyboard for FM input dialog
    if (fm_dialog_type != 0 && fm.open && !fm.minimized && scancode != 0 && !(scancode & 0x80)) {
      if (scancode == 0x01) { // Escape -> cancel
        fm_dialog_type = 0;
        fm_input_len = 0;
        fm_input_buf[0] = '\0';
        needs_redraw = true;
      } else if (scancode == 0x1C) { // Enter -> commit
        if (fm_input_len > 0) {
          fm_input_buf[fm_input_len] = '\0';
          if (fm_dialog_type == 1) {
            char src[16];
            get_shell_file_name(fm_selected, src);
            shell_move_file(src, fm_input_buf);
          } else {
            shell_mkdir(fm_input_buf);
          }
          shell_refresh_files();
          int new_count = get_shell_file_count();
          if (fm_selected >= new_count)
            fm_selected = new_count > 0 ? new_count - 1 : 0;
        }
        fm_dialog_type = 0;
        fm_input_len = 0;
        fm_input_buf[0] = '\0';
        needs_redraw = true;
      } else if (scancode == 0x0E) { // Backspace
        if (fm_input_len > 0) {
          fm_input_buf[--fm_input_len] = '\0';
          needs_redraw = true;
        }
      } else {
        char c = shell_scancode_to_ascii(scancode, fm_shift);
        if (c >= 32 && c <= 126 && fm_input_len < 30) {
          fm_input_buf[fm_input_len++] = c;
          fm_input_buf[fm_input_len] = '\0';
          needs_redraw = true;
        }
      }
    }
    // Delete key (0x53) for File Manager (only when no dialog is open)
    else if (scancode == 0x53 && fm.open && !fm.minimized && fm_dialog_type == 0 &&
        (!word.open || word.minimized || (!ws.editing_filename && !ws.show_open_dialog)) &&
        (!tabels.open || tabels.minimized || !sss.show_open_dialog)) {
      int count = get_shell_file_count();
      if (shell_is_fs_mounted() && count > 0 &&
          fm_selected >= 0 && fm_selected < count) {
        char name[16];
        get_shell_file_name(fm_selected, name);
        shell_delete_file(name);
        shell_refresh_files();
        int new_count = get_shell_file_count();
        if (fm_selected >= new_count) {
          fm_selected = new_count > 0 ? new_count - 1 : 0;
        }
        needs_redraw = true;
      }
    }


    if (scancode != 0 && word.open && !word.minimized) {
      handle_word_key(ws, scancode);
      needs_redraw = true;
    }

    if (scancode != 0 && mpra_win.open && !mpra_win.minimized &&
        !mpra_win.dragging) {
      mpra_handle_key(scancode);
      needs_redraw = true;
    }

    // Keyboard in tabels
    if (scancode != 0 && tabels.open && !tabels.minimized && !tabels.dragging) {
      if (scancode == 0x2A || scancode == 0x36)
        sss.shift_pressed = true;
      else if (scancode == (0x2A | 0x80) || scancode == (0x36 | 0x80))
        sss.shift_pressed = false;
      else if (!(scancode & 0x80)) {
        if (scancode == 0x0E) { // Backspace
          int len = string_length(sss.cells[sss.sel_x][sss.sel_y]);
          if (len > 0)
            sss.cells[sss.sel_x][sss.sel_y][len - 1] = '\0';
          needs_redraw = true;
        } else if (scancode == 0x1C) { // Enter moves down
          sss.sel_y = (sss.sel_y + 1) % SHEET_ROWS;
          needs_redraw = true;
        } else if (scancode == 0x48) { // Up
          sss.sel_y = (sss.sel_y + SHEET_ROWS - 1) % SHEET_ROWS;
          needs_redraw = true;
        } else if (scancode == 0x50) { // Down
          sss.sel_y = (sss.sel_y + 1) % SHEET_ROWS;
          needs_redraw = true;
        } else if (scancode == 0x4B) { // Left
          sss.sel_x = (sss.sel_x + SHEET_COLS - 1) % SHEET_COLS;
          needs_redraw = true;
        } else if (scancode == 0x4D) { // Right
          sss.sel_x = (sss.sel_x + 1) % SHEET_COLS;
          needs_redraw = true;
        } else {
          char c = shell_scancode_to_ascii(scancode, sss.shift_pressed);
          if (c >= 32 && c <= 126) {
            int len = string_length(sss.cells[sss.sel_x][sss.sel_y]);
            if (len < 31) {
              sss.cells[sss.sel_x][sss.sel_y][len] = c;
              sss.cells[sss.sel_x][sss.sel_y][len + 1] = '\0';
              needs_redraw = true;
            }
          }
        }

        // Ensure selection is visible
        int cy = tabels.y + 28;
        int grid_y = cy + 30;
        int row_header_w = 30;
        int col_header_h = 20;
        int cell_w = 70;
        int cell_h = 20;
        int scrollbar_size = 12;
        int scrollbar_y = tabels.y + tabels.h - scrollbar_size;
        int scrollbar_x = tabels.x + tabels.w - scrollbar_size;
        int grid_w = scrollbar_x - (tabels.x + row_header_w);
        int grid_h = scrollbar_y - (grid_y + col_header_h);
        int visible_cols = grid_w / cell_w;
        int visible_rows = grid_h / cell_h;

        if (sss.sel_x < sss.scroll_x) {
          sss.scroll_x = sss.sel_x;
        } else if (sss.sel_x >= sss.scroll_x + visible_cols) {
          sss.scroll_x = sss.sel_x - visible_cols + 1;
        }
        if (sss.sel_y < sss.scroll_y) {
          sss.scroll_y = sss.sel_y;
        } else if (sss.sel_y >= sss.scroll_y + visible_rows) {
          sss.scroll_y = sss.sel_y - visible_rows + 1;
        }
      }
    }

    bool mouse_clicked = mouse_left && !last_mouse_left_state;
    bool mouse_released = !mouse_left && last_mouse_left_state;

    // --- Menu button click ---
    if (mouse_clicked) {
      int bar_y = 0;
      if (global_bar_position == 1)
        bar_y = screen.height - 25;

      // Red menu button in top-right
      if (mouse_y >= bar_y + 2 && mouse_y <= bar_y + 23 &&
          mouse_x >= menu_btn_x && mouse_x <= menu_btn_x + 60) {
        menu_open = !menu_open;
        needs_redraw = true;
      }
      // Menu dropdown item clicks
      else if (menu_open) {
        int mw = 180;
        int item_h = 30;
        int item_count = 7;
        int mh = item_count * item_h + 10;
        int mx_menu = (screen.width - mw) / 2;
        int my_menu = (screen.height - mh) / 2;

        if (global_menu_style == 1) {
          mx_menu = screen.width - mw;
          my_menu = (global_bar_position == 0) ? 25 : 0;
          mh = screen.height - 25;
        }

        if (mouse_x >= mx_menu && mouse_x <= mx_menu + mw &&
            mouse_y >= my_menu + 5 &&
            mouse_y < my_menu + 5 + item_count * item_h) {
          int item = (mouse_y - my_menu - 5) / item_h;
          if (item == 0) { // Welcome
            welcome.open = true;
            welcome.minimized = false;
          } else if (item == 1) { // File Manager
            fm.open = true;
            fm.minimized = false;
            if (!fm_files_loaded) {
              shell_refresh_files();
              fm_files_loaded = true;
              fm_selected = 0;
              fm_scroll = 0;
            }
          } else if (item == 2) { // Calculator
            calc.open = true;
            calc.minimized = false;
          } else if (item == 3) { // Documents
            word.open = true;
            word.minimized = false;
          } else if (item == 4) { // tabels
            tabels.open = true;
            tabels.minimized = false;
          } else if (item == 5) { // Settings
            settings.open = true;
            settings.minimized = false;
          } else if (item == 6) { // Disk Manager
            disk_manager.open = true;
            disk_manager.minimized = false;
          }
        }
        menu_open = false;
        needs_redraw = true;
      }
    }

    // --- Calculator content clicks ---
    if (mouse_clicked && calc.open && !calc.minimized) {
      handle_calculator_click(cs, calc.x, calc.y, calc.w, calc.h);
      needs_redraw = true;
    }

    // --- Word content clicks ---
    if (mouse_clicked && word.open && !word.minimized) {
      handle_word_click(ws, word.x, word.y, word.w, word.h);
      needs_redraw = true;
    }

    // --- tabels content clicks ---
    if (mouse_clicked && tabels.open && !tabels.minimized) {
      handle_sheet_click(sss, tabels.x, tabels.y, tabels.w, tabels.h);
      needs_redraw = true;
    }

    // --- Settings content clicks ---
    if (mouse_clicked && settings.open && !settings.minimized) {
      handle_settings_click(ss, settings.x, settings.y);
      needs_redraw = true;
    }

    // --- Disk Manager content clicks ---
    if (mouse_clicked && disk_manager.open && !disk_manager.minimized) {
      if (handle_disk_manager_click(disk_manager.x, disk_manager.y,
                                    disk_manager.w)) {
        fm_files_loaded = false; // force fm refresh
      }
      needs_redraw = true;
    }

    // --- MPra content clicks ---
    if (mouse_clicked && mpra_win.open && !mpra_win.minimized) {
      int content_y = mpra_win.y + 28;
      if (mouse_x >= mpra_win.x && mouse_x < mpra_win.x + mpra_win.w &&
          mouse_y >= content_y && mouse_y < content_y + mpra_win.h - 28) {
        mpra_handle_click(mouse_x - mpra_win.x, mouse_y - content_y);
        needs_redraw = true;
      }
    }

    // --- File Manager content clicks ---
    if (mouse_clicked && fm.open && !fm.minimized) {
      int cy = fm.y + 28;
      int toolbar_y = cy + 18; // path bar is 18px tall

      // If a dialog is open, handle OK/Cancel buttons and nothing else
      if (fm_dialog_type != 0) {
        int dx = fm.x + fm.w / 2 - 110;
        int dy = fm.y + fm.h / 2 - 35;
        // OK button: dx+6, dy+46, 80x18
        if (mouse_x >= dx + 6 && mouse_x < dx + 86 &&
            mouse_y >= dy + 46 && mouse_y < dy + 64) {
          if (fm_input_len > 0) {
            fm_input_buf[fm_input_len] = '\0';
            if (fm_dialog_type == 1) {
              // Move/Rename selected file
              char src[16];
              get_shell_file_name(fm_selected, src);
              shell_move_file(src, fm_input_buf);
            } else {
              // New Folder
              shell_mkdir(fm_input_buf);
            }
            shell_refresh_files();
            int new_count = get_shell_file_count();
            if (fm_selected >= new_count)
              fm_selected = new_count > 0 ? new_count - 1 : 0;
          }
          fm_dialog_type = 0;
          fm_input_len = 0;
          fm_input_buf[0] = '\0';
          needs_redraw = true;
        }
        // Cancel button: dx+94, dy+46, 80x18
        else if (mouse_x >= dx + 94 && mouse_x < dx + 174 &&
                 mouse_y >= dy + 46 && mouse_y < dy + 64) {
          fm_dialog_type = 0;
          fm_input_len = 0;
          fm_input_buf[0] = '\0';
          needs_redraw = true;
        }
        // Swallow all other clicks while dialog is open
        goto fm_click_done;
      }

      // 1. Toolbar clicks (toolbar_y+5 to toolbar_y+25)
      if (mouse_y >= toolbar_y + 5 && mouse_y <= toolbar_y + 25) {
        // [Delete] x+4 .. x+58
        if (mouse_x >= fm.x + 4 && mouse_x <= fm.x + 58) {
          int count = get_shell_file_count();
          if (shell_is_fs_mounted() && count > 0 &&
              fm_selected >= 0 && fm_selected < count) {
            char name[16];
            get_shell_file_name(fm_selected, name);
            shell_delete_file(name);
            shell_refresh_files();
            int new_count = get_shell_file_count();
            if (fm_selected >= new_count)
              fm_selected = new_count > 0 ? new_count - 1 : 0;
            needs_redraw = true;
          }
        }
        // [Move] x+62 .. x+106
        else if (mouse_x >= fm.x + 62 && mouse_x <= fm.x + 106) {
          int count = get_shell_file_count();
          if (shell_is_fs_mounted() && count > 0 &&
              fm_selected >= 0 && fm_selected < count &&
              !get_shell_file_is_dir(fm_selected)) {
            // Pre-fill with selected file name
            char src[16];
            get_shell_file_name(fm_selected, src);
            fm_input_len = 0;
            for (int _i = 0; src[_i] && fm_input_len < 30; _i++)
              fm_input_buf[fm_input_len++] = src[_i];
            fm_input_buf[fm_input_len] = '\0';
            fm_dialog_type = 1;
            needs_redraw = true;
          }
        }
        // [New Folder] x+110 .. x+186
        else if (mouse_x >= fm.x + 110 && mouse_x <= fm.x + 186) {
          fm_input_len = 0;
          fm_input_buf[0] = '\0';
          fm_dialog_type = 2;
          needs_redraw = true;
        }
        // [Up] x+190 .. x+218
        else if (mouse_x >= fm.x + 190 && mouse_x <= fm.x + 218) {
          shell_change_dir("..");
          shell_refresh_files();
          fm_selected = 0;
          fm_scroll = 0;
          needs_redraw = true;
        }
        // [Refresh] x+222 .. x+282
        else if (mouse_x >= fm.x + 222 && mouse_x <= fm.x + 282) {
          if (shell_is_fs_mounted()) {
            shell_refresh_files();
            int new_count = get_shell_file_count();
            if (fm_selected >= new_count)
              fm_selected = new_count > 0 ? new_count - 1 : 0;
            needs_redraw = true;
          }
        }
      }

      // 2. File list clicks
      {
        int list_y = toolbar_y + 52; // toolbar(30) + header(20) + sep(2)
        int row_height = 20;
        int used = 18 + 30 + 20 + 2;
        int max_visible = (fm.h - 28 - used) / row_height;
        if (max_visible > 0 && mouse_x >= fm.x && mouse_x <= fm.x + fm.w &&
            mouse_y >= list_y && mouse_y < list_y + max_visible * row_height) {
          int clicked_row = (mouse_y - list_y) / row_height;
          int new_sel = clicked_row + fm_scroll;
          if (new_sel >= 0 && new_sel < get_shell_file_count()) {
            bool is_dir = get_shell_file_is_dir(new_sel);
            char name[16];
            get_shell_file_name(new_sel, name);

            if (fm_selected == new_sel) {
              // Double-click action
              if (is_dir) {
                // Navigate into directory (including "..")
                shell_change_dir(name);
                shell_refresh_files();
                fm_selected = 0;
                fm_scroll = 0;
              } else {
                // Check if .mru file
                int name_len = string_length(name);
                bool is_mpra = false;
                if (name_len > 4) {
                  if (name[name_len - 4] == '.' &&
                      (name[name_len - 3] == 'm' || name[name_len - 3] == 'M') &&
                      (name[name_len - 2] == 'r' || name[name_len - 2] == 'R') &&
                      (name[name_len - 1] == 'u' || name[name_len - 1] == 'U')) {
                    is_mpra = true;
                  }
                }
                if (is_mpra) {
                  mpra_run_file(name);
                  if (mpra_is_running()) {
                    mpra_win.w = mpra_get_window_w();
                    mpra_win.h = mpra_get_window_h();
                    mpra_win.open = true;
                    mpra_win.minimized = false;
                  }
                } else {
                  string_copy(ws.filename, name);
                  ws.filename_len = string_length(name);
                  if (shell_read_file(ws.filename, ws.buffer, 4096)) {
                    ws.cursor_pos = 0;
                    while (ws.buffer[ws.cursor_pos] != '\0' && ws.cursor_pos < 4096)
                      ws.cursor_pos++;
                  } else {
                    ws.buffer[0] = '\0';
                    ws.cursor_pos = 0;
                  }
                  word.open = true;
                  word.minimized = false;
                }
              }
            }
            fm_selected = new_sel;
            needs_redraw = true;
          }
        }
      }
      fm_click_done:;
    }

    // --- Title bar interactions ---
    if (mouse_clicked) {
      // Priority: Disk Manager > Settings > tabels > Word > Calculator > FM >
      // MPra > Welcome
      if (!handle_window_titlebar(disk_manager, mouse_x, mouse_y, true)) {
        if (!handle_window_titlebar(settings, mouse_x, mouse_y, true)) {
          if (!handle_window_titlebar(tabels, mouse_x, mouse_y, true)) {
            if (!handle_window_titlebar(word, mouse_x, mouse_y, true)) {
              if (!handle_window_titlebar(calc, mouse_x, mouse_y, true)) {
                if (!handle_window_titlebar(fm, mouse_x, mouse_y, true)) {
                  if (!handle_window_titlebar(mpra_win, mouse_x, mouse_y,
                                              true)) {
                    handle_window_titlebar(welcome, mouse_x, mouse_y, true);
                  }
                }
              }
            }
          }
        }
      }
      if (!mpra_win.open && mpra_is_running()) {
        mpra_close();
      }
      needs_redraw = true;
    }

    // --- Release drag / resize ---
    if (mouse_released) {
      if (welcome.dragging || fm.dragging || calc.dragging || word.dragging ||
          tabels.dragging || settings.dragging || disk_manager.dragging ||
          mpra_win.dragging || welcome.resizing || fm.resizing ||
          calc.resizing || word.resizing || tabels.resizing ||
          settings.resizing || disk_manager.resizing || mpra_win.resizing) {
        if (welcome.dragging)
          welcome.minimized = false;
        if (fm.dragging)
          fm.minimized = false;
        if (calc.dragging)
          calc.minimized = false;
        if (word.dragging)
          word.minimized = false;
        if (tabels.dragging)
          tabels.minimized = false;
        if (settings.dragging)
          settings.minimized = false;
        if (disk_manager.dragging)
          disk_manager.minimized = false;
        if (mpra_win.dragging)
          mpra_win.minimized = false;
        needs_redraw = true;
      }
      welcome.dragging = false; welcome.resizing = false;
      fm.dragging = false; fm.resizing = false;
      calc.dragging = false; calc.resizing = false;
      word.dragging = false; word.resizing = false;
      tabels.dragging = false; tabels.resizing = false;
      settings.dragging = false; settings.resizing = false;
      disk_manager.dragging = false; disk_manager.resizing = false;
      mpra_win.dragging = false; mpra_win.resizing = false;
    }

    // --- Dragging & Resizing ---
    if (mouse_x != last_mouse_x || mouse_y != last_mouse_y) {
      if (welcome.dragging) {
        welcome.x = mouse_x - welcome.drag_ox;
        welcome.y = mouse_y - welcome.drag_oy;
        needs_redraw = true;
      }
      if (fm.dragging) {
        fm.x = mouse_x - fm.drag_ox;
        fm.y = mouse_y - fm.drag_oy;
        needs_redraw = true;
      }
      if (calc.dragging) {
        calc.x = mouse_x - calc.drag_ox;
        calc.y = mouse_y - calc.drag_oy;
        needs_redraw = true;
      }
      if (word.dragging) {
        word.x = mouse_x - word.drag_ox;
        word.y = mouse_y - word.drag_oy;
        needs_redraw = true;
      }
      if (settings.dragging) {
        settings.x = mouse_x - settings.drag_ox;
        settings.y = mouse_y - settings.drag_oy;
        needs_redraw = true;
      }
      if (tabels.dragging) {
        tabels.x = mouse_x - tabels.drag_ox;
        tabels.y = mouse_y - tabels.drag_oy;
        needs_redraw = true;
      }
      if (disk_manager.dragging) {
        disk_manager.x = mouse_x - disk_manager.drag_ox;
        disk_manager.y = mouse_y - disk_manager.drag_oy;
        needs_redraw = true;
      }
      if (mpra_win.dragging) {
        mpra_win.x = mouse_x - mpra_win.drag_ox;
        mpra_win.y = mouse_y - mpra_win.drag_oy;
        needs_redraw = true;
      }

      if (welcome.resizing) { update_window_resize(welcome, mouse_x, mouse_y); needs_redraw = true; }
      if (fm.resizing) { update_window_resize(fm, mouse_x, mouse_y); needs_redraw = true; }
      if (calc.resizing) { update_window_resize(calc, mouse_x, mouse_y); needs_redraw = true; }
      if (word.resizing) { update_window_resize(word, mouse_x, mouse_y); needs_redraw = true; }
      if (tabels.resizing) { update_window_resize(tabels, mouse_x, mouse_y); needs_redraw = true; }
      if (settings.resizing) { update_window_resize(settings, mouse_x, mouse_y); needs_redraw = true; }
      if (disk_manager.resizing) { update_window_resize(disk_manager, mouse_x, mouse_y); needs_redraw = true; }
      if (mpra_win.resizing) { update_window_resize(mpra_win, mouse_x, mouse_y); needs_redraw = true; }
    }

    // --- Redraw ---
    if (needs_redraw) {
      draw_all_ui(welcome, fm, calc, word, tabels, settings, disk_manager, cs,
                  ws, sss, ss, fm_selected, fm_scroll);
      if (menu_open)
        draw_menu_dropdown();
    }

    if (needs_redraw || mouse_x != last_mouse_x || mouse_y != last_mouse_y) {
      for (int y = 0; y < (int)screen.height; y++) {
        for (int x = 0; x < (int)screen.width; x++) {
          uint32_t pixel = ui_buffer[y * screen.width + x];

          bool is_mouse = false;
          if (x == mouse_x && y >= mouse_y - 5 && y <= mouse_y + 5)
            is_mouse = true;
          if (y == mouse_y && x >= mouse_x - 5 && x <= mouse_x + 5)
            is_mouse = true;

          if (is_mouse) {
            pixel = 0xFFFFFF;
          }

          if (frontbuffer[y * screen.width + x] != pixel) {
            frontbuffer[y * screen.width + x] = pixel;
            put_pixel(x, y, pixel);
          }
        }
      }
      last_mouse_x = mouse_x;
      last_mouse_y = mouse_y;
    }

    last_mouse_left_state = mouse_left;

    for (int i = 0; i < 5000; i++)
      asm volatile("nop");
  }
}