Start refactoring the UI code into an immediate mode style

include/button.h

@@ -1,16 +0,0 @@
-#ifndef BUTTON_H
-#define BUTTON_H
-
-#include "window.h"
-
-#define BUTTON_WIDTH 100
-#define BUTTON_HEIGHT 40
-
-typedef struct button button_t;
-struct button {
-  rect_t rect;
-};
-
-void draw_button(const window_t *wnd, const button_t *button);
-
-#endif // !BUTTON_H

include/nodes.h

@@ -6,14 +6,6 @@
 
 #define MAX_NODES 1024
 
-#define NODE_WIDTH 70
-#define NODE_HEIGHT 20
-
-#define IO_NODE_FILL_COLOUR ((colour_t){.abgr = 0xff2c84b7})
-#define IO_NODE_BORDER_COLOUR ((colour_t){.abgr = 0xff315c89})
-#define OP_NODE_FILL_COLOUR ((colour_t){.abgr = 0xffad6c3a})
-#define OP_NODE_BORDER_COLOUR ((colour_t){.abgr = 0xff8e4a33})
-
 typedef i32 (*node_func_t)(i32 a, i32 b);
 typedef enum node_type node_type_t;
 typedef union node_data node_data_t;
@@ -32,11 +24,8 @@ union node_data {
 };
 
 struct node {
-  rect_t rect;
   node_type_t type;
   node_data_t data;
 };
 
-void draw_node(const window_t *wnd, const node_t *node);
-
 #endif // !NODES_H

include/ui.h

@@ -1,10 +1,51 @@
 #ifndef UI_H
 #define UI_H
 
+#include "SDL_events.h"
 #include "aliases/aliases.h"
 #include "window.h"
 #include <stdbool.h>
 
-bool aabb(const rect_t *rect, i32 x, i32 y);
+#define MAX_UI_ELEMENTS 4096
+
+#define BUTTON_WIDTH 100
+#define BUTTON_HEIGHT 40
+
+#define NODE_WIDTH 70
+#define NODE_HEIGHT 20
+
+typedef enum ui_elem_type ui_elem_type_t;
+typedef struct ui_elem ui_elem_t;
+typedef struct ui_ctx ui_ctx_t;
+
+enum ui_elem_type {
+  UI_ELEM_NODE,
+  UI_ELEM_BUTTON,
+
+  COUNT_UI_ELEM,
+};
+
+struct ui_elem {
+  u64 id;
+  rect_t rect;
+  ui_elem_type_t type;
+};
+
+struct ui_ctx {
+  u64 count;
+  i64 hovered;
+  i64 active;
+  i64 mouse_x;
+  i64 mouse_y;
+  bool mouse_down;
+  bool mouse_up;
+  const window_t *wnd;
+  ui_elem_t elements[MAX_UI_ELEMENTS];
+};
+
+void reset_ui_ctx(ui_ctx_t *ctx);
+void handle_ui_events(const window_t *wnd, ui_ctx_t *ctx,
+                      const SDL_Event *event);
+bool button(const window_t *wnd, ui_ctx_t *ctx, rect_t rect);
 
 #endif // !UI_H

include/window.h

@@ -63,7 +63,7 @@ void draw_point(const window_t *wnd, point_t p, colour_t colour);
 void draw_line(const window_t *wnd, const line_t *ln, colour_t colour);
 void draw_triangle(const window_t *wnd, const triangle_t *triangle,
                    colour_t colour);
-void draw_rect(const window_t *wnd, const rect_t *rect, colour_t colour);
+void draw_rect(const window_t *wnd, rect_t rect, colour_t colour);
-void fill_rect(const window_t *wnd, const rect_t *rect, colour_t colour);
+void fill_rect(const window_t *wnd, rect_t rect, colour_t colour);
 
 #endif // !WINDOW_H

src/button.c

@@ -1,10 +0,0 @@
-#include "button.h"
-#include "window.h"
-
-#define BUTTON_FILL_COLOUR ((colour_t){.abgr = 0xff89a83c})
-#define BUTTON_BORDER_COLOUR ((colour_t){.abgr = 0xff768432})
-
-void draw_button(const window_t *wnd, const button_t *button) {
-  fill_rect(wnd, &(button->rect), BUTTON_FILL_COLOUR);
-  draw_rect(wnd, &(button->rect), BUTTON_BORDER_COLOUR);
-}

src/compositor.c

@@ -1,5 +1,4 @@
 #include "aliases/aliases.h"
-#include "button.h"
 #include "nodes.h"
 #include "ops.h"
 #include "ui.h"
@@ -9,6 +8,7 @@
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_video.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 #define MAX_WINDOWS 2
@@ -29,9 +29,7 @@ struct compositor {
   u64 count;
   node_t *nodes;
   bool move_node;
-  button_t buttons[COUNT_COMP_OPS];
+  ui_ctx_t ctx;
-  i64 button_hovered;
-  i64 button_clicked;
 };
 
 void add_node(compositor_t *comp, node_type_t type, node_data_t data, i32 x,
@@ -65,6 +63,76 @@ i32 run_main_loop(void) {
 
   colour_t bg_colour = {.abgr = 0xffffffff};
 
+  while (comp.running) {
+    while (SDL_PollEvent(&(comp.event))) {
+      for (u64 i = 0; i < MAX_WINDOWS; ++i) {
+        handle_ui_events(&(comp.windows[i]), &(comp.ctx), &(comp.event));
+      }
+
+      switch (comp.event.type) {
+      case SDL_QUIT:
+        comp.running = false;
+        break;
+      case SDL_WINDOWEVENT:
+        switch (comp.event.window.event) {
+        case SDL_WINDOWEVENT_CLOSE:
+          comp.running = false;
+          break;
+        case SDL_WINDOWEVENT_ENTER: {
+          u32 id = comp.event.window.windowID;
+          window_t *wnd = NULL;
+
+          for (u64 i = 0; i < MAX_WINDOWS; ++i) {
+            window_t *window = &(comp.windows[i]);
+
+            if (id == window->id) {
+              wnd = window;
+              break;
+            }
+          }
+
+          if (!wnd) {
+            break;
+          }
+
+          SDL_RaiseWindow(wnd->window);
+
+          break;
+        }
+        }
+
+        break;
+      }
+    }
+
+    for (u64 i = 0; i < MAX_WINDOWS; ++i) {
+      clear_window(&(comp.windows[i]), bg_colour);
+    }
+
+    if (button(main_window, &(comp.ctx),
+               (rect_t){.topleft.x = 10,
+                        .topleft.y = 10,
+                        .w = BUTTON_WIDTH,
+                        .h = BUTTON_HEIGHT})) {
+      printf("Button 1 pressed\n");
+    }
+
+    if (button(main_window, &(comp.ctx),
+               (rect_t){.topleft.x = 50,
+                        .topleft.y = 50,
+                        .w = BUTTON_WIDTH,
+                        .h = BUTTON_HEIGHT})) {
+      printf("Button 2 pressed\n");
+    }
+
+    for (u64 i = 0; i < MAX_WINDOWS; ++i) {
+      swap_buffers(&(comp.windows[i]));
+    }
+
+    reset_ui_ctx(&(comp.ctx));
+  }
+
+#if 0
   i32 button_x = (toolbox->width - BUTTON_WIDTH) / 2;
   for (u64 i = 0; i < COUNT_COMP_OPS; ++i) {
     comp.buttons[i] = (button_t){.rect = (rect_t){
@@ -212,15 +280,18 @@ i32 run_main_loop(void) {
       swap_buffers(&(comp.windows[i]));
     }
   }
+#endif
 
-  cleanup_window(toolbox);
+  for (u64 i = 0; i < MAX_WINDOWS; ++i) {
-  cleanup_window(main_window);
+    cleanup_window(&(comp.windows[i]));
+  }
 
   SDL_Quit();
 
   return EXIT_SUCCESS;
 }
 
+#if 0
 void add_node(compositor_t *comp, node_type_t type, node_data_t data, i32 x,
               i32 y) {
   if (comp->count + 1 >= MAX_NODES) {
@@ -239,3 +310,4 @@ void add_node(compositor_t *comp, node_type_t type, node_data_t data, i32 x,
       .data.path = data.path,
   };
 }
+#endif

src/nodes.c

@@ -2,27 +2,3 @@
 #include "aliases/aliases.h"
 #include "window.h"
 #include <stdbool.h>
-
-typedef struct node_colours node_colours_t;
-struct node_colours {
-  colour_t fill;
-  colour_t border;
-};
-
-INTERNAL node_colours_t colours[COUNT_NODE_TYPES] = {
-    [NODE_TYPE_IO] =
-        (node_colours_t){
-            .fill = IO_NODE_FILL_COLOUR,
-            .border = IO_NODE_BORDER_COLOUR,
-        },
-    [NODE_TYPE_OP] =
-        (node_colours_t){
-            .fill = OP_NODE_FILL_COLOUR,
-            .border = OP_NODE_BORDER_COLOUR,
-        },
-};
-
-void draw_node(const window_t *wnd, const node_t *node) {
-  fill_rect(wnd, &(node->rect), colours[node->type].fill);
-  draw_rect(wnd, &(node->rect), colours[node->type].border);
-}

src/ui.c

@@ -1,6 +1,104 @@
 #include "ui.h"
+#include "SDL_events.h"
+#include "aliases/aliases.h"
+#include "window.h"
+#include <stdio.h>
 
-bool aabb(const rect_t *rect, i32 x, i32 y) {
+typedef struct ui_elem_colours ui_elem_colours_t;
-  return x > rect->topleft.x && x <= rect->topleft.x + rect->w &&
+struct ui_elem_colours {
-         y > rect->topleft.y && y <= rect->topleft.y + rect->h;
+  colour_t fill;
+  colour_t border;
+};
+
+INTERNAL ui_elem_colours_t colours[COUNT_UI_ELEM] = {
+    [UI_ELEM_NODE] =
+        (ui_elem_colours_t){
+            .fill = (colour_t){.abgr = 0xff2c84b7},
+            .border = (colour_t){.abgr = 0xff315c89},
+        },
+    [UI_ELEM_BUTTON] =
+        (ui_elem_colours_t){
+            .fill = (colour_t){.abgr = 0xff89a83c},
+            .border = (colour_t){.abgr = 0xff768432},
+        },
+};
+
+bool aabb(const ui_elem_t *elem, i32 x, i32 y) {
+  return x > elem->rect.topleft.x && x <= elem->rect.topleft.x + elem->rect.w &&
+         y > elem->rect.topleft.y && y <= elem->rect.topleft.y + elem->rect.h;
+}
+
+void reset_ui_ctx(ui_ctx_t *ctx) {
+  ctx->count = 0;
+  ctx->mouse_down = false;
+  ctx->mouse_up = false;
+}
+
+void handle_ui_events(const window_t *wnd, ui_ctx_t *ctx,
+                      const SDL_Event *event) {
+  switch (event->type) {
+  case SDL_MOUSEMOTION:
+    if (wnd->id == event->motion.windowID) {
+      ctx->mouse_x = event->motion.x;
+      ctx->mouse_y = event->motion.y;
+      ctx->wnd = wnd;
+
+      break;
+    }
+
+  case SDL_MOUSEBUTTONDOWN:
+    if (wnd->id == event->button.windowID) {
+      ctx->mouse_x = event->button.x;
+      ctx->mouse_y = event->button.y;
+      ctx->mouse_down = true;
+      ctx->wnd = wnd;
+    }
+
+    break;
+  case SDL_MOUSEBUTTONUP:
+    if (wnd->id == event->button.windowID) {
+      ctx->mouse_x = event->button.x;
+      ctx->mouse_y = event->button.y;
+      ctx->mouse_up = true;
+      ctx->wnd = wnd;
+    }
+
+    break;
+  }
+}
+
+bool button(const window_t *wnd, ui_ctx_t *ctx, rect_t rect) {
+  if (ctx->count + 1 >= MAX_UI_ELEMENTS) {
+    return false;
+  }
+
+  ui_elem_t elem = (ui_elem_t){
+      .id = (ctx->count)++,
+      .rect = rect,
+      .type = UI_ELEM_BUTTON,
+  };
+
+  fill_rect(wnd, rect, colours[UI_ELEM_BUTTON].fill);
+  draw_rect(wnd, rect, colours[UI_ELEM_BUTTON].border);
+
+  if (wnd != ctx->wnd) {
+    return false;
+  }
+
+  if (!aabb(&elem, ctx->mouse_x, ctx->mouse_y)) {
+    return false;
+  }
+
+  ctx->hovered = elem.id;
+
+  if (ctx->mouse_down) {
+    ctx->active = elem.id;
+  }
+
+  if (ctx->mouse_up && ctx->hovered == elem.id && ctx->active == elem.id) {
+    ctx->hovered = ctx->active = -1;
+    return true;
+  }
+
+  return false;
 }

src/window.c

@@ -90,18 +90,18 @@ void draw_triangle(const window_t *wnd, const triangle_t *triangle,
   draw_line(wnd, &ln2, colour);
 }
 
-void draw_rect(const window_t *wnd, const rect_t *rect, colour_t colour) {
+void draw_rect(const window_t *wnd, rect_t rect, colour_t colour) {
   set_colour(wnd, colour);
 
-  SDL_Rect dst = {rect->topleft.x, rect->topleft.y, rect->w, rect->h};
+  SDL_Rect dst = {rect.topleft.x, rect.topleft.y, rect.w, rect.h};
 
   SDL_RenderDrawRect(wnd->renderer, &dst);
 }
 
-void fill_rect(const window_t *wnd, const rect_t *rect, colour_t colour) {
+void fill_rect(const window_t *wnd, rect_t rect, colour_t colour) {
   set_colour(wnd, colour);
 
-  SDL_Rect dst = {rect->topleft.x, rect->topleft.y, rect->w, rect->h};
+  SDL_Rect dst = {rect.topleft.x, rect.topleft.y, rect.w, rect.h};
 
   SDL_RenderFillRect(wnd->renderer, &dst);
 }