#include <ui.h>
#include <cassert.h>
#include <cstring.h>
#include <font.h>
#include <list.h>
#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);
return mem;
}
#define UI_NEW(TYPE) (TYPE*)uiAlloc(1, sizeof(TYPE))
#define UI_DEL(ppWidget) \
{ \
assert(ppWidget); \
void* widget_ = *ppWidget; \
if (widget_) { \
free(widget_); \
*ppWidget = 0; \
} \
}
DEF_LIST(Widget, uiWidget*)
/// Base widget type.
typedef struct uiWidget {
uiWidgetType type;
uiRect rect;
Widget_list children;
} uiWidget;
/// Button.
typedef struct uiButton {
uiWidget widget;
string text;
} uiButton;
/// Frame.
typedef struct uiFrame {
uiWidget widget;
} uiFrame;
/// Label.
typedef struct uiLabel {
uiWidget widget;
string text;
} uiLabel;
/// Table cell.
typedef struct uiCell {
uiWidget* child;
} uiCell;
/// Table.
typedef struct uiTable {
uiWidget widget;
int rows;
int cols;
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;
uiMouseButtonState mouse_button_state[uiMouseButtonMax];
uiWidgetEvent widget_events[MaxWidgetEvents];
int num_widget_events;
} uiLibrary;
// -----------------------------------------------------------------------------
// Library.
uiLibrary g_ui = {0};
bool uiInit(void) {
// TODO: Embed the font into the library instead.
const char* font_path = "../ui/fontbaker/NK57.bin";
if (!(g_ui.font = LoadFontAtlas(font_path))) {
return false;
}
// TODO: Remove.
const FontHeader* header = &g_ui.font->header;
const int glyph_size = header->glyph_width * header->glyph_height;
const int atlas_size = header->num_glyphs * glyph_size;
printf("Loaded font: %s\n", font_path);
printf(
"Glyph: %dx%d (%d bytes)\n", header->glyph_width, header->glyph_height,
glyph_size);
printf(
"Atlas: %dx%d (%d bytes)\n", header->num_glyphs * header->glyph_width,
header->glyph_height, atlas_size);
return true;
}
void uiShutdown(void) {}
// -----------------------------------------------------------------------------
// 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};
}
uiButton* uiGetButtonPtr(uiPtr ptr) {
assert(ptr.type == uiTypeButton);
assert(ptr.button);
return ptr.button;
}
uiFrame* uiGetFramePtr(uiPtr ptr) {
assert(ptr.type == uiTypeFrame);
assert(ptr.frame);
return ptr.frame;
}
uiLabel* uiGetLabelPtr(uiPtr ptr) {
assert(ptr.type == uiTypeLabel);
assert(ptr.label);
return ptr.label;
}
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);
uiWidget* widget = *ppWidget;
if (widget) {
list_foreach_mut(widget->children, child, { DestroyWidget(&child); });
}
UI_DEL(ppWidget);
}
void uiWidgetSetParent(uiPtr child_, uiPtr parent_) {
uiWidget* child = child_.widget;
uiWidget* parent = parent_.widget;
assert(child);
assert(parent);
list_add(parent->children, child);
}
// -----------------------------------------------------------------------------
// Button.
uiButton* uiMakeButton(const char* text) {
assert(text);
uiButton* button = UI_NEW(uiButton);
*button = (uiButton){
.widget =
(uiWidget){
.type = uiTypeButton,
.rect = {0},
},
.text = string_new(text),
};
return button;
}
// -----------------------------------------------------------------------------
// Label.
uiLabel* uiMakeLabel(const char* text) {
assert(text);
uiLabel* label = UI_NEW(uiLabel);
*label = (uiLabel){
.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.
uiFrame* uiMakeFrame(void) {
uiFrame* frame = UI_NEW(uiFrame);
frame->widget.type = uiTypeFrame;
return frame;
}
void uiDestroyFrame(uiFrame** ppFrame) { DestroyWidget((uiWidget**)ppFrame); }
uiSize uiGetFrameSize(const uiFrame* frame) {
assert(frame);
return (uiSize){
.width = frame->widget.rect.width,
.height = frame->widget.rect.height,
};
}
// -----------------------------------------------------------------------------
// Table.
static const uiCell* GetCell(const uiTable* table, int row, int col) {
assert(table);
return &table->cells[row][col];
}
static uiCell* GetCellMut(uiTable* table, int row, int col) {
assert(table);
return (uiCell*)GetCell(table, row, col);
}
static uiCell** GetLastRow(uiTable* table) {
assert(table);
assert(table->rows > 0);
return &table->cells[table->rows - 1];
}
uiTable* uiMakeTable(int rows, int cols, const char** header) {
uiTable* table = UI_NEW(uiTable);
*table = (uiTable){
.widget = (uiWidget){.type = uiTypeTable},
.rows = rows,
.cols = cols,
.widths = (cols > 0) ? calloc(cols, sizeof(int)) : 0,
.header = header ? calloc(cols, sizeof(uiCell)) : 0,
.cells = (rows * cols > 0) ? calloc(rows, sizeof(uiCell*)) : 0,
};
if (header) {
for (int col = 0; col < cols; ++col) {
table->header[col].child = (uiWidget*)uiMakeLabel(header[col]);
}
}
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 * sizeof(uiCell*));
ASSERT(cells);
table->cells = cells;
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, uiPtr child) {
assert(table);
assert(child.widget);
GetCellMut(table, row, col)->child = child.widget;
}
const uiWidget* uiTableGet(const uiTable* table, int row, int col) {
assert(table);
return GetCell(table, row, col)->child;
}
uiWidget* uiTableGetMut(uiTable* table, int row, int col) {
assert(table);
return GetCellMut(table, row, col)->child;
}
// -----------------------------------------------------------------------------
// Layout and resizing.
static void ResizeTable(uiTable* table, int width, int height) {
assert(table);
if (table->cols == 0) {
return;
}
// Surface width: W.
// Columns: N
//
// First, find the minimum width of each column based on their contents.
//
// If the sum of column widths < N, then distribute the extra space first
// among the smallest columns and building up towards the larger.
//
// If the sum of column widths > N, subtract from the largest column first and
// move towards the smaller ones to distribute the space as evenly as
// possible.
// Find the minimum width for each column.
int* widths = table->widths;
// Header.
for (int col = 0; col < table->cols; ++col) {
const uiCell* cell = &table->header[col];
const uiLabel* label = (uiLabel*)cell->child;
const int length = (int)string_length(label->text);
widths[col] = length;
}
// Table contents.
for (int row = 0; row < table->rows; ++row) {
for (int col = 0; col < table->cols; ++col) {
const uiCell* cell = GetCell(table, row, col);
if (cell->child) {
const uiLabel* label = (uiLabel*)cell->child;
const int length = (int)string_length(label->text);
widths[col] = length > widths[col] ? length : widths[col];
}
}
}
// Multiply string lengths times glyph width to compute pixel size.
for (int col = 0; col < table->cols; ++col) {
widths[col] *= g_ui.font->header.glyph_width;
}
// Find the sum of widths.
int used_width = 0;
for (int col = 0; col < table->cols; ++col) {
used_width += widths[col];
}
// Pad if available width is larger than sum of widths.
if (used_width < width) {
// Divide evenly among columns.
// const int extra = width - used_width;
// const int pad = extra / table->cols;
// const int mod = extra % table->cols;
// for (int col = 0; col < table->cols; ++col) {
// table->widths[col] += pad + (col < mod ? 1 : 0);
// }
int extra = width - used_width;
while (extra > 0) {
// Find smallest column.
int smallest = 0;
for (int col = 1; col < table->cols; ++col) {
if (widths[col] < widths[smallest]) {
smallest = col;
}
}
// Pad it and subtract from the budget.
widths[smallest] += 1;
extra--;
}
}
// Shrink if available width is smaller than the sum of widths.
else if (used_width > width) {
int deficit = used_width - width;
while (deficit > 0) {
// Find largest column.
int largest = 0;
for (int col = 1; col < table->cols; ++col) {
if (widths[col] > widths[largest]) {
largest = col;
}
}
// Shrink it and subtract from the deficit.
widths[largest] -= 1;
deficit--;
}
}
}
static void ResizeWidget(uiWidget* widget, int width, int height) {
assert(widget);
widget->rect.width = width;
widget->rect.height = height;
switch (widget->type) {
case uiTypeButton:
break;
case uiTypeFrame:
list_foreach_mut(
widget->children, child, { ResizeWidget(child, width, height); });
break;
case uiTypeLabel:
break;
case uiTypeTable:
ResizeTable((uiTable*)widget, width, height);
break;
case uiTypeMax:
TRAP();
break;
}
}
void uiResizeFrame(uiFrame* frame, int width, int height) {
assert(frame);
ResizeWidget(&frame->widget, width, height);
}
// -----------------------------------------------------------------------------
// Rendering.
static const uiPixel uiBlack = {40, 40, 40, 255};
static const uiPixel uiWhite = {255, 255, 255, 255};
static const uiPixel uiPink = {128, 0, 128, 255};
/// Render state.
///
/// Render functions are allowed to manipulate the state internally (e.g., the
/// subsurface), but must leave the state intact before returning, except, of
/// course, for the rendered pixels.
///
/// We store a subsurface separate from the surface so that we can always check
/// whether a given coordinate is within the bounds of the physical surface.
typedef struct RenderState {
uiSurface surface; /// Surface of pixels on which the UI is rendered.
uiRect subsurface; /// Subregion where the current UI widget is rendered.
uiPoint pen; /// Current pen position relative to subsurface.
} RenderState;
static void RenderWidget(RenderState* state, const uiWidget* widget);
void PushSubsurface(
RenderState* state, int width, int height, uiRect* original_subsurface,
uiPoint* original_pen) {
assert(state);
assert(original_subsurface);
assert(original_pen);
*original_subsurface = state->subsurface;
*original_pen = state->pen;
state->subsurface.x = state->subsurface.x + state->pen.x;
state->subsurface.width = width;
state->subsurface.height = height;
state->pen.x = 0;
}
void PopSubsurface(
RenderState* state, const uiRect* original_subsurface,
const uiPoint* original_pen) {
assert(state);
assert(original_subsurface);
assert(original_pen);
state->subsurface = *original_subsurface;
state->pen = *original_pen;
}
/// Checks whether pen + (w,h) is within the surface and subsurface.
static bool PenInSurface(const RenderState* state, int w, int h) {
assert(state);
// Surface.
const bool in_surface =
((state->subsurface.x + state->pen.x + w) < state->surface.width) &&
((state->subsurface.y + state->pen.y + h) < state->surface.height);
// Subsurface.
const bool in_subsurface = ((state->pen.x + w) < state->subsurface.width) &&
((state->pen.y + h) < state->subsurface.height);
return in_surface && in_subsurface;
}
/// Get the pixel at (x,y).
static uiPixel* SurfaceXy(uiSurface* surface, int x, int y) {
assert(surface);
assert(x >= 0);
assert(y >= 0);
assert(x < surface->width);
assert(y < surface->height);
return surface->pixels + (surface->width * y) + x;
}
/// Get the pixel at pen + (x,y).
static uiPixel* PixelXy(RenderState* state, int x, int y) {
assert(state);
return SurfaceXy(
&state->surface, state->subsurface.x + state->pen.x + x,
state->subsurface.y + state->pen.y + y);
}
static void FillRect(const uiRect* rect, uiPixel colour, RenderState* state) {
assert(rect);
assert(state);
assert(rect->width <= state->subsurface.width);
assert(rect->height <= state->subsurface.height);
for (int y = rect->y; y < rect->y + rect->height; ++y) {
uiPixel* pixel = PixelXy(state, rect->x, y);
for (int x = rect->x; x < rect->x + rect->width; ++x) {
*pixel++ = colour;
}
}
}
/// Render a glyph.
/// The glyph is clamped to the surface's bounds.
static void RenderGlyph(
const FontAtlas* atlas, unsigned char c, RenderState* state) {
assert(atlas);
assert(state);
assert(atlas->header.glyph_width <= state->subsurface.width);
assert(atlas->header.glyph_height <= state->subsurface.height);
const int glyph_width = atlas->header.glyph_width;
const int glyph_height = atlas->header.glyph_height;
const unsigned char* glyph = FontGetGlyph(atlas, c);
for (int y = 0; (y < atlas->header.glyph_height) &&
PenInSurface(state, glyph_width - 1, glyph_height - 1);
++y) {
for (int x = 0; (x < atlas->header.glyph_width) &&
PenInSurface(state, glyph_width - 1, glyph_height - 1);
++x, ++glyph) {
uiPixel* pixel = PixelXy(state, x, y);
if (*glyph > 0) {
pixel->r = *glyph;
pixel->g = *glyph;
pixel->b = *glyph;
pixel->a = 255;
}
}
}
}
static void RenderText(const char* text, size_t length, RenderState* state) {
assert(text);
assert(state);
const FontAtlas* atlas = g_ui.font;
const int glyph_width = atlas->header.glyph_width;
const int glyph_height = atlas->header.glyph_height;
// Save the x-pen so that we can restore it after rendering the text.
const int x0 = state->pen.x;
// Truncate the text rendering if it exceeds the subsurface's width or height.
const char* c = text;
for (size_t i = 0;
(i < length) && PenInSurface(state, glyph_width - 1, glyph_height - 1);
++i, ++c, state->pen.x += glyph_width) {
RenderGlyph(atlas, *c, state);
}
state->pen.x = x0;
}
static void RenderFrame(const uiFrame* frame, RenderState* state) {
assert(frame);
FillRect(&frame->widget.rect, uiBlack, state);
}
static void RenderLabel(const uiLabel* label, RenderState* state) {
assert(label);
assert(state);
RenderText(string_data(label->text), string_length(label->text), state);
}
static void RenderTable(const uiTable* table, RenderState* state) {
assert(table);
assert(state);
const int x0 = state->pen.x;
const int y0 = state->pen.y;
uiRect original_subsurface = {0};
uiPoint original_pen = {0};
// Render header.
if (table->header) {
for (int col = 0; col < table->cols; ++col) {
// Crop the column contents to the column width so that one column does
// not spill into the next.
PushSubsurface(
state, table->widths[col], state->subsurface.height,
&original_subsurface, &original_pen);
const uiCell* cell = &table->header[col];
RenderWidget(state, cell->child);
// Reset the original subsurface and pen for subsequent columns.
PopSubsurface(state, &original_subsurface, &original_pen);
// Next column.
state->pen.x += table->widths[col];
}
}
state->pen.x = x0;
state->pen.y += g_ui.font->header.glyph_height;
// Render rows.
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.
PushSubsurface(
state, table->widths[col], state->subsurface.height,
&original_subsurface, &original_pen);
state->subsurface.x = state->subsurface.x + state->pen.x;
state->subsurface.width = table->widths[col];
state->pen.x = 0;
const uiCell* cell = GetCell(table, row, col);
RenderWidget(state, cell->child);
// Reset the original subsurface and pen for subsequent columns.
PopSubsurface(state, &original_subsurface, &original_pen);
// Next column.
state->pen.x += table->widths[col];
}
state->pen.x = x0;
state->pen.y += g_ui.font->header.glyph_height;
}
state->pen.y = y0;
}
static void RenderWidget(RenderState* state, const uiWidget* widget) {
assert(state);
assert(widget);
// Render this widget.
switch (widget->type) {
case uiTypeButton:
break;
case uiTypeFrame:
RenderFrame((const uiFrame*)widget, state);
break;
case uiTypeLabel:
RenderLabel((const uiLabel*)widget, state);
break;
case uiTypeTable:
RenderTable((const uiTable*)widget, state);
break;
case uiTypeMax:
TRAP();
break;
}
// Render children.
list_foreach(widget->children, child, { RenderWidget(state, child); });
}
void uiRender(const uiFrame* frame, uiSurface* surface) {
assert(frame);
assert(surface);
RenderWidget(
&(RenderState){
.surface = *surface,
.subsurface =
(uiRect){
.x = 0,
.y = 0,
.width = surface->width,
.height = surface->height},
.pen = {.x = 0, .y = 0},
},
(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;
}