Table user input.

1 files changed, 286 insertions, 43 deletions

diff --git a/src/ui.c b/src/ui.c
index a5ab8d3..e8c8ee2 100644
--- a/src/ui.c
+++ b/src/ui.c
@@ -7,6 +7,10 @@
 
 #include <stdlib.h>
 
+#define Max(a, b) ((a) > (b) ? (a) : (b))
+
+#define MaxWidgetEvents 8
+
 static void* uiAlloc(size_t count, size_t size) {
   void* mem = calloc(count, size);
   ASSERT(mem);
@@ -60,13 +64,17 @@ typedef struct uiTable {
   uiWidget widget;
   int      rows;
   int      cols;
-  int*     widths; /// Width, in pixels, for each each column.
-  uiCell*  header; /// If non-null, row of 'cols' header cells.
-  uiCell*  cells;  /// Array of 'rows * cols' cells.
+  int*     widths; // Width, in pixels, for each column.
+  uiCell*  header; // If non-null, row of 'cols' header cells.
+  uiCell** cells;  // Array of 'rows' rows, each of 'cols' cells.
+  int      offset; // Offset into the rows of the table. Units: rows.
 } uiTable;
 
 typedef struct uiLibrary {
-  FontAtlas* font;
+  FontAtlas*         font;
+  uiMouseButtonState mouse_button_state[uiMouseButtonMax];
+  uiWidgetEvent      widget_events[MaxWidgetEvents];
+  int                num_widget_events;
 } uiLibrary;
 
 // -----------------------------------------------------------------------------
@@ -99,32 +107,65 @@ bool uiInit(void) {
 void uiShutdown(void) {}
 
 // -----------------------------------------------------------------------------
-// Widget.
+// Widget pointers.
+
+uiPtr uiMakeButtonPtr(uiButton* button) {
+  assert(button);
+  return (uiPtr){.type = uiTypeButton, .button = button};
+}
+
+uiPtr uiMakeFramePtr(uiFrame* frame) {
+  assert(frame);
+  return (uiPtr){.type = uiTypeFrame, .frame = frame};
+}
+
+uiPtr uiMakeLabelPtr(uiLabel* label) {
+  assert(label);
+  return (uiPtr){.type = uiTypeLabel, .label = label};
+}
+
+uiPtr uiMakeTablePtr(uiTable* table) {
+  assert(table);
+  return (uiPtr){.type = uiTypeTable, .table = table};
+}
+
+static uiPtr uiMakeWidgetPtr(uiWidget* widget) {
+  assert(widget);
+  return (uiPtr){.type = widget->type, .widget = widget};
+}
 
-static uiButton* uiGetButtonPtr(uiWidgetPtr ptr) {
+uiButton* uiGetButtonPtr(uiPtr ptr) {
   assert(ptr.type == uiTypeButton);
   assert(ptr.button);
   return ptr.button;
 }
 
-static uiFrame* uiGetFramePtr(uiWidgetPtr ptr) {
+uiFrame* uiGetFramePtr(uiPtr ptr) {
   assert(ptr.type == uiTypeFrame);
   assert(ptr.frame);
   return ptr.frame;
 }
 
-static uiLabel* uiGetLabelPtr(uiWidgetPtr ptr) {
+uiLabel* uiGetLabelPtr(uiPtr ptr) {
   assert(ptr.type == uiTypeLabel);
   assert(ptr.label);
   return ptr.label;
 }
 
-static uiTable* uiGetTablePtr(uiWidgetPtr ptr) {
+uiTable* uiGetTablePtr(uiPtr ptr) {
   assert(ptr.type == uiTypeTable);
   assert(ptr.table);
   return ptr.table;
 }
 
+// -----------------------------------------------------------------------------
+// Widget.
+
+uiWidgetType uiWidgetGetType(const uiWidget* widget) {
+  assert(widget);
+  return widget->type;
+}
+
 static void DestroyWidget(uiWidget** ppWidget) {
   assert(ppWidget);
 
@@ -135,27 +176,7 @@ static void DestroyWidget(uiWidget** ppWidget) {
   UI_DEL(ppWidget);
 }
 
-uiWidgetPtr uiMakeButtonPtr(uiButton* button) {
-  assert(button);
-  return (uiWidgetPtr){.type = uiTypeButton, .button = button};
-}
-
-uiWidgetPtr uiMakeFramePtr(uiFrame* frame) {
-  assert(frame);
-  return (uiWidgetPtr){.type = uiTypeFrame, .frame = frame};
-}
-
-uiWidgetPtr uiMakeLabelPtr(uiLabel* label) {
-  assert(label);
-  return (uiWidgetPtr){.type = uiTypeLabel, .label = label};
-}
-
-uiWidgetPtr uiMakeTablePtr(uiTable* table) {
-  assert(table);
-  return (uiWidgetPtr){.type = uiTypeTable, .table = table};
-}
-
-void uiWidgetSetParent(uiWidgetPtr child_, uiWidgetPtr parent_) {
+void uiWidgetSetParent(uiPtr child_, uiPtr parent_) {
   uiWidget* child  = child_.widget;
   uiWidget* parent = parent_.widget;
 
@@ -196,12 +217,21 @@ uiLabel* uiMakeLabel(const char* text) {
       .widget =
           (uiWidget){
                      .type = uiTypeLabel,
-                     },
+                     .rect =
+                  (uiRect){
+                      .width =
+                          (int)strlen(text) * g_ui.font->header.glyph_width,
+                      .height = g_ui.font->header.glyph_height}},
       .text = string_new(text),
   };
   return label;
 }
 
+const char* uiLabelGetText(const uiLabel* label) {
+  assert(label);
+  return string_data(label->text);
+}
+
 // -----------------------------------------------------------------------------
 // Frame.
 
@@ -226,7 +256,7 @@ uiSize uiGetFrameSize(const uiFrame* frame) {
 
 static const uiCell* GetCell(const uiTable* table, int row, int col) {
   assert(table);
-  return table->cells + (row * table->cols) + col;
+  return &table->cells[row][col];
 }
 
 static uiCell* GetCellMut(uiTable* table, int row, int col) {
@@ -234,10 +264,10 @@ static uiCell* GetCellMut(uiTable* table, int row, int col) {
   return (uiCell*)GetCell(table, row, col);
 }
 
-static uiCell* GetLastRow(uiTable* table) {
+static uiCell** GetLastRow(uiTable* table) {
   assert(table);
   assert(table->rows > 0);
-  return &table->cells[table->cols * (table->rows - 1)];
+  return &table->cells[table->rows - 1];
 }
 
 uiTable* uiMakeTable(int rows, int cols, const char** header) {
@@ -249,7 +279,7 @@ uiTable* uiMakeTable(int rows, int cols, const char** header) {
       .cols   = cols,
       .widths = (cols > 0) ? calloc(cols, sizeof(int)) : 0,
       .header = header ? calloc(cols, sizeof(uiCell)) : 0,
-      .cells  = (rows * cols > 0) ? calloc(rows * cols, sizeof(uiCell)) : 0,
+      .cells  = (rows * cols > 0) ? calloc(rows, sizeof(uiCell*)) : 0,
   };
 
   if (header) {
@@ -261,23 +291,50 @@ uiTable* uiMakeTable(int rows, int cols, const char** header) {
   return table;
 }
 
+void uiTableClear(uiTable* table) {
+  assert(table);
+
+  // Free row data.
+  if (table->cells) {
+    for (int row = 0; row < table->rows; ++row) {
+      for (int col = 0; col < table->cols; ++col) {
+        DestroyWidget(&table->cells[row][col].child);
+      }
+      free(table->cells[row]);
+    }
+    free(table->cells);
+    table->cells = 0;
+  }
+  table->rows = 0;
+
+  // Clear row widths.
+  for (int i = 0; i < table->cols; ++i) {
+    table->widths[i] = 0;
+  }
+
+  table->offset = 0;
+}
+
 void uiTableAddRow(uiTable* table, const char** row) {
   assert(table);
 
   table->rows++;
 
-  uiCell* cells =
-      realloc(table->cells, table->rows * table->cols * sizeof(uiCell));
-  assert(cells);
+  uiCell** cells = realloc(table->cells, table->rows * sizeof(uiCell*));
+  ASSERT(cells);
   table->cells = cells;
 
-  uiCell* cell = GetLastRow(table);
-  for (int col = 0; col < table->cols; ++col, ++cell) {
-    cell->child = (uiWidget*)uiMakeLabel(row[col]);
+  uiCell** pLastRow = GetLastRow(table);
+  *pLastRow         = calloc(table->cols, sizeof(uiCell));
+  ASSERT(*pLastRow);
+  uiCell* lastRow = *pLastRow;
+
+  for (int col = 0; col < table->cols; ++col) {
+    lastRow[col].child = (uiWidget*)uiMakeLabel(row[col]);
   }
 }
 
-void uiTableSet(uiTable* table, int row, int col, uiWidgetPtr child) {
+void uiTableSet(uiTable* table, int row, int col, uiPtr child) {
   assert(table);
   assert(child.widget);
 
@@ -618,7 +675,8 @@ static void RenderTable(const uiTable* table, RenderState* state) {
   state->pen.y += g_ui.font->header.glyph_height;
 
   // Render rows.
-  for (int row = 0; (row < table->rows) && PenInSurface(state, 0, 0); ++row) {
+  for (int row = table->offset;
+       (row < table->rows) && PenInSurface(state, 0, 0); ++row) {
     for (int col = 0; (col < table->cols) && PenInSurface(state, 0, 0); ++col) {
       // Crop the column contents to the column width so that one column does
       // not spill into the next.
@@ -688,3 +746,188 @@ void uiRender(const uiFrame* frame, uiSurface* surface) {
   },
       (const uiWidget*)frame);
 }
+
+// -----------------------------------------------------------------------------
+// UI Events.
+
+static void PushWidgetEvent(uiWidgetEvent* event) {
+  assert(event);
+  assert(g_ui.num_widget_events < MaxWidgetEvents);
+
+  g_ui.widget_events[g_ui.num_widget_events++] = *event;
+}
+
+int uiGetEvents(uiWidgetEvent const** ppWidgetEvents) {
+  assert(ppWidgetEvents);
+
+  const int count        = g_ui.num_widget_events;
+  g_ui.num_widget_events = 0;
+
+  *ppWidgetEvents = g_ui.widget_events;
+  return count;
+}
+
+// -----------------------------------------------------------------------------
+// User input.
+
+static bool RectContains(uiRect rect, uiPoint point) {
+  return (rect.x <= point.x) && (point.x <= (rect.x + rect.width)) &&
+         (rect.y <= point.y) && (point.y <= (rect.y + rect.height));
+}
+
+static uiWidget* GetWidgetUnderMouse(uiWidget* parent, uiPoint mouse) {
+  assert(parent);
+
+  // First check the children so that the selection is from "most specific" to
+  // "less specific" from the user's perspective.
+  list_foreach(parent->children, child, {
+    uiWidget* target = GetWidgetUnderMouse(child, mouse);
+    if (target != 0) {
+      return target;
+    }
+  });
+
+  if (RectContains(parent->rect, mouse)) {
+    return parent;
+  }
+
+  return 0;
+}
+
+static void GetTableRowColAtXy(
+    const uiTable* table, uiPoint p, int* out_row, int* out_col) {
+  assert(table);
+  assert(out_row);
+  assert(out_col);
+
+  const uiWidget* widget = (uiWidget*)table;
+
+  int col = -1;
+  int row = -1;
+
+  if (RectContains(widget->rect, p)) {
+    int x = p.x - widget->rect.x;
+    for (col = 0; (col < table->cols) && (x > table->widths[col]); ++col) {
+      x -= table->widths[col];
+    }
+    // 0 is the header and we want to map the first row to 0, so -1.
+    row = table->offset +
+          ((p.y - widget->rect.y) / g_ui.font->header.glyph_height) - 1;
+    // Out-of-bounds check.
+    if ((col >= table->cols) || (row >= table->rows)) {
+      col = row = -1;
+    }
+  }
+
+  *out_col = col;
+  *out_row = row;
+}
+
+static void ClickTable(uiTable* table, const uiMouseClickEvent* event) {
+  assert(table);
+  assert(event);
+
+  int row, col;
+  GetTableRowColAtXy(table, event->mouse_position, &row, &col);
+
+  if ((row != -1) && (col != -1)) {
+    PushWidgetEvent(&(uiWidgetEvent){
+        .type        = uiWidgetEventClick,
+        .widget      = uiMakeTablePtr(table),
+        .table_click = (uiTableClickEvent){.row = row, .col = col}
+    });
+  }
+}
+
+static void ScrollTable(uiTable* table, const uiMouseScrollEvent* event) {
+  assert(table);
+  assert(event);
+  table->offset = Max(0, table->offset - event->scroll_offset);
+}
+
+static bool ProcessScrollEvent(
+    uiWidget* widget, const uiMouseScrollEvent* event) {
+  assert(widget);
+  assert(event);
+
+  bool processed = false;
+
+  switch (widget->type) {
+  case uiTypeTable:
+    ScrollTable((uiTable*)widget, event);
+    processed = true;
+    break;
+  default:
+    break;
+  }
+
+  return processed;
+}
+
+static bool ProcessClickEvent(
+    uiWidget* widget, const uiMouseClickEvent* event) {
+  assert(widget);
+  assert(event);
+
+  bool processed = false;
+
+  switch (widget->type) {
+  case uiTypeTable:
+    ClickTable((uiTable*)widget, event);
+    processed = true;
+    break;
+  default:
+    break;
+  }
+
+  return processed;
+}
+
+bool uiSendEvent(uiFrame* frame, const uiInputEvent* event) {
+  assert(frame);
+  assert(event);
+
+  uiWidget* widget = (uiWidget*)frame;
+
+  bool processed = false;
+
+  switch (event->type) {
+  case uiEventMouseButton: {
+    const uiMouseButtonEvent* ev = &event->mouse_button;
+
+    uiMouseButtonState* prev_state = &g_ui.mouse_button_state[ev->button];
+
+    if ((*prev_state == uiMouseDown) && (ev->state == uiMouseUp)) {
+      // Click.
+      uiSendEvent(
+          frame,
+          &(uiInputEvent){
+              .type        = uiEventMouseClick,
+              .mouse_click = (uiMouseClickEvent){
+                                                 .button = ev->button, .mouse_position = ev->mouse_position}
+      });
+    }
+
+    *prev_state = ev->state;
+    break;
+  }
+  case uiEventMouseClick: {
+    const uiMouseClickEvent* ev = &event->mouse_click;
+    uiWidget* target = GetWidgetUnderMouse(widget, ev->mouse_position);
+    if (target) {
+      processed = ProcessClickEvent(target, ev);
+    }
+    break;
+  }
+  case uiEventMouseScroll: {
+    const uiMouseScrollEvent* ev = &event->mouse_scroll;
+    uiWidget* target = GetWidgetUnderMouse(widget, ev->mouse_position);
+    if (target) {
+      processed = ProcessScrollEvent(target, ev);
+    }
+    break;
+  }
+  }
+
+  return processed;
+}