ref: c8aacac864e10c3979d290655648b6c980c52e60
parent: 9ce84fa876bb8f788aa0770895c4117bbe9164aa
author: Sigrid Haflínudóttir <ftrvxmtrx@gmail.com>
date: Tue Jan 7 18:01:45 EST 2020
make mu context and style global variables to keep it simple
--- a/demo/frame.c
+++ b/demo/frame.c
@@ -15,18 +15,18 @@
logbuf_updated = 1;
}
-#define text_width(s) (stringwidth(ctx->style->font, s) + 6)
-#define text_height() ctx->style->font->height
+#define text_width(s) (stringwidth(mu_style.font, s) + 6)
+#define text_height() mu_style.font->height
#define max(a, b) ((a) > (b) ? (a) : (b))
static void
-test_window(mu_Context *ctx)
+test_window(void)
{static mu_Container window;
/* init window manually so we can set its position and size */
if (!window.inited) {- mu_init_window(ctx, &window, 0);
+ mu_init_window(&window, 0);
window.rect = mu_rect(40, 40, 320, 500);
}
@@ -35,107 +35,107 @@
window.rect.h = max(window.rect.h, 300);
/* do window */
- if (mu_begin_window(ctx, &window, "Demo Window")) {+ if (mu_begin_window(&window, "Demo Window")) {/* window info */
static int show_info = 0;
- if (mu_header(ctx, &show_info, "Window Info")) {+ if (mu_header(&show_info, "Window Info")) {char buf[64];
const int widths[] = { text_width("Position:"), -1 };- mu_layout_row(ctx, 2, widths, 0);
- mu_label(ctx, "Position:");
- sprint(buf, "%d, %d", window.rect.x, window.rect.y); mu_label(ctx, buf);
- mu_label(ctx, "Size:");
- sprint(buf, "%d, %d", window.rect.w, window.rect.h); mu_label(ctx, buf);
+ mu_layout_row(2, widths, 0);
+ mu_label("Position:");+ sprint(buf, "%d, %d", window.rect.x, window.rect.y); mu_label(buf);
+ mu_label("Size:");+ sprint(buf, "%d, %d", window.rect.w, window.rect.h); mu_label(buf);
}
/* labels + buttons */
static int show_buttons = 1;
- if (mu_header(ctx, &show_buttons, "Test Buttons")) {+ if (mu_header(&show_buttons, "Test Buttons")) { const int widths[] = { text_width("Test buttons 2:"), -text_width("Button 2 "), -1 };- mu_layout_row(ctx, 3, widths, 0);
- mu_label(ctx, "Test buttons 1:");
- if (mu_button(ctx, "Button 1")) { write_log("Pressed button 1"); }- if (mu_button(ctx, "Button 2")) { write_log("Pressed button 2"); }- mu_label(ctx, "Test buttons 2:");
- if (mu_button(ctx, "Button 3")) { write_log("Pressed button 3"); }- if (mu_button(ctx, "Button 4")) { write_log("Pressed button 4"); }+ mu_layout_row(3, widths, 0);
+ mu_label("Test buttons 1:");+ if (mu_button("Button 1")) { write_log("Pressed button 1"); }+ if (mu_button("Button 2")) { write_log("Pressed button 2"); }+ mu_label("Test buttons 2:");+ if (mu_button("Button 3")) { write_log("Pressed button 3"); }+ if (mu_button("Button 4")) { write_log("Pressed button 4"); }}
/* tree */
static int show_tree = 1;
- if (mu_header(ctx, &show_tree, "Tree and Text")) {+ if (mu_header(&show_tree, "Tree and Text")) { int widths[] = { text_width("Test 1a")+text_height()*2+text_width("Button 3")+6, -1 };- mu_layout_row(ctx, 2, widths, 0);
- mu_layout_begin_column(ctx);
+ mu_layout_row(2, widths, 0);
+ mu_layout_begin_column();
static int states[8];
- if (mu_begin_treenode(ctx, &states[0], "Test 1")) {- if (mu_begin_treenode(ctx, &states[1], "Test 1a")) {- mu_label(ctx, "Hello");
- mu_label(ctx, "world");
- mu_end_treenode(ctx);
+ if (mu_begin_treenode(&states[0], "Test 1")) {+ if (mu_begin_treenode(&states[1], "Test 1a")) {+ mu_label("Hello");+ mu_label("world");+ mu_end_treenode();
}
- if (mu_begin_treenode(ctx, &states[2], "Test 1b")) {- if (mu_button(ctx, "Button 1")) { write_log("Pressed button 1"); }- if (mu_button(ctx, "Button 2")) { write_log("Pressed button 2"); }- mu_end_treenode(ctx);
+ if (mu_begin_treenode(&states[2], "Test 1b")) {+ if (mu_button("Button 1")) { write_log("Pressed button 1"); }+ if (mu_button("Button 2")) { write_log("Pressed button 2"); }+ mu_end_treenode();
}
- mu_end_treenode(ctx);
+ mu_end_treenode();
}
- if (mu_begin_treenode(ctx, &states[3], "Test 2")) {+ if (mu_begin_treenode(&states[3], "Test 2")) {int widths[2];
widths[0] = widths[1] = text_width("Button 3");- mu_layout_row(ctx, 2, widths, 0);
- if (mu_button(ctx, "Button 3")) { write_log("Pressed button 3"); }- if (mu_button(ctx, "Button 4")) { write_log("Pressed button 4"); }- if (mu_button(ctx, "Button 5")) { write_log("Pressed button 5"); }- if (mu_button(ctx, "Button 6")) { write_log("Pressed button 6"); }- mu_end_treenode(ctx);
+ mu_layout_row(2, widths, 0);
+ if (mu_button("Button 3")) { write_log("Pressed button 3"); }+ if (mu_button("Button 4")) { write_log("Pressed button 4"); }+ if (mu_button("Button 5")) { write_log("Pressed button 5"); }+ if (mu_button("Button 6")) { write_log("Pressed button 6"); }+ mu_end_treenode();
}
- if (mu_begin_treenode(ctx, &states[4], "Test 3")) {+ if (mu_begin_treenode(&states[4], "Test 3")) { static int checks[3] = { 1, 0, 1 };- mu_checkbox(ctx, &checks[0], "Checkbox 1");
- mu_checkbox(ctx, &checks[1], "Checkbox 2");
- mu_checkbox(ctx, &checks[2], "Checkbox 3");
- mu_end_treenode(ctx);
+ mu_checkbox(&checks[0], "Checkbox 1");
+ mu_checkbox(&checks[1], "Checkbox 2");
+ mu_checkbox(&checks[2], "Checkbox 3");
+ mu_end_treenode();
}
- mu_layout_end_column(ctx);
+ mu_layout_end_column();
- mu_layout_begin_column(ctx);
+ mu_layout_begin_column();
widths[0] = -1;
- mu_layout_row(ctx, 1, widths, 0);
- mu_text(ctx, "Lorem ipsum dolor sit amet, consectetur adipiscing "
+ mu_layout_row(1, widths, 0);
+ mu_text("Lorem ipsum dolor sit amet, consectetur adipiscing ""elit. Maecenas lacinia, sem eu lacinia molestie, mi risus faucibus "
"ipsum, eu varius magna felis a nulla.");
- mu_layout_end_column(ctx);
+ mu_layout_end_column();
}
- mu_end_window(ctx);
+ mu_end_window();
}
}
static void
-log_window(mu_Context *ctx)
+log_window(void)
{static mu_Container window;
/* init window manually so we can set its position and size */
if (!window.inited) {- mu_init_window(ctx, &window, 0);
+ mu_init_window(&window, 0);
window.rect = mu_rect(370, 40, 340, 200);
}
- if (mu_begin_window(ctx, &window, "Log Window")) {+ if (mu_begin_window(&window, "Log Window")) { int widths[] = { -1, -1 };/* output text panel */
static mu_Container panel;
- mu_layout_row(ctx, 1, widths, -28);
- mu_begin_panel(ctx, &panel);
- mu_layout_row(ctx, 1, widths, -1);
- mu_text(ctx, logbuf);
- mu_end_panel(ctx);
+ mu_layout_row(1, widths, -28);
+ mu_begin_panel(&panel);
+ mu_layout_row(1, widths, -1);
+ mu_text(logbuf);
+ mu_end_panel();
if (logbuf_updated) {panel.scroll.y = panel.content_size.y;
logbuf_updated = 0;
@@ -145,36 +145,36 @@
static char buf[128];
int submitted = 0;
widths[0] = -text_width("Submit")-8;- mu_layout_row(ctx, 2, widths, -1);
- if (mu_textbox(ctx, buf, sizeof(buf)) & MU_RES_SUBMIT) {- mu_set_focus(ctx, ctx->last_id);
+ mu_layout_row(2, widths, -1);
+ if (mu_textbox(buf, sizeof(buf)) & MU_RES_SUBMIT) {+ mu_set_focus(mu_ctx.last_id);
submitted = 1;
}
- if (mu_button(ctx, "Submit")) { submitted = 1; }+ if (mu_button("Submit")) { submitted = 1; } if (submitted) {write_log(buf);
buf[0] = '\0';
}
- mu_end_window(ctx);
+ mu_end_window();
}
}
static int
-uint8_slider(mu_Context *ctx, unsigned char *value, int low, int high)
+uint8_slider(unsigned char *value, int low, int high)
{static float tmp;
- mu_push_id(ctx, &value, sizeof(value));
+ mu_push_id(&value, sizeof(value));
tmp = *value;
- int res = mu_slider_ex(ctx, &tmp, low, high, 0, "%.0f", MU_OPT_ALIGNCENTER);
+ int res = mu_slider_ex(&tmp, low, high, 0, "%.0f", MU_OPT_ALIGNCENTER);
*value = tmp;
- mu_pop_id(ctx);
+ mu_pop_id();
return res;
}
static void
-style_window(mu_Context *ctx)
+style_window(void)
{static mu_Container window;
static u8int cur[MU_COLOR_MAX][4], old[MU_COLOR_MAX][4];
@@ -199,39 +199,39 @@
/* init window manually so we can set its position and size */
if (!window.inited) {- mu_init_window(ctx, &window, 0);
+ mu_init_window(&window, 0);
window.rect = mu_rect(370, 250, 340, 290);
memmove(cur, defaultcolors, sizeof(cur));
memmove(old, defaultcolors, sizeof(old));
}
- if (mu_begin_window(ctx, &window, "Style Editor")) {- int sw = max(text_width("255"), mu_get_container(ctx)->body.w * 0.14);+ if (mu_begin_window(&window, "Style Editor")) {+ int sw = max(text_width("255"), mu_get_container()->body.w * 0.14); const int widths[] = { text_width("scrollthumb:"), sw, sw, sw, sw, -1 };- mu_layout_row(ctx, 6, widths, 0);
+ mu_layout_row(6, widths, 0);
for (int i = 0; colors[i].label; i++) {- mu_label(ctx, colors[i].label);
- uint8_slider(ctx, &cur[i][0], 0, 255);
- uint8_slider(ctx, &cur[i][1], 0, 255);
- uint8_slider(ctx, &cur[i][2], 0, 255);
- uint8_slider(ctx, &cur[i][3], 0, 255);
+ mu_label(colors[i].label);
+ uint8_slider(&cur[i][0], 0, 255);
+ uint8_slider(&cur[i][1], 0, 255);
+ uint8_slider(&cur[i][2], 0, 255);
+ uint8_slider(&cur[i][3], 0, 255);
if (memcmp(cur[i], old[i], 4) != 0) {- freeimage(ctx->style->colors[i]);
- ctx->style->colors[i] = mu_color(cur[i][0], cur[i][1], cur[i][2], cur[i][3]);
+ freeimage(mu_style.colors[i]);
+ mu_style.colors[i] = mu_color(cur[i][0], cur[i][1], cur[i][2], cur[i][3]);
memmove(old[i], cur[i], 4);
}
- mu_draw_rect(ctx, mu_layout_next(ctx), ctx->style->colors[i]);
+ mu_draw_rect(mu_layout_next(), mu_style.colors[i]);
}
- mu_end_window(ctx);
+ mu_end_window();
}
}
void
-process_frame(mu_Context *ctx)
+process_frame(void)
{- mu_begin(ctx);
- test_window(ctx);
- log_window(ctx);
- style_window(ctx);
- mu_end(ctx);
+ mu_begin();
+ test_window();
+ log_window();
+ style_window();
+ mu_end();
}
--- a/demo/plan9.c
+++ b/demo/plan9.c
@@ -7,7 +7,7 @@
#include <bio.h>
#include <microui.h>
-void process_frame(mu_Context *ctx);
+void process_frame(void);
void
threadmain(int argc, char **argv)
@@ -14,7 +14,6 @@
{Mousectl *mctl;
char *s;
- mu_Context *ctx;
Biobuf *snarf;
Keyboardctl *kctl;
Rune key;
@@ -44,17 +43,16 @@
srand(time(0));
threadsetname("microui demo");- ctx = malloc(sizeof(mu_Context));
- mu_init(ctx);
- ctx->style->font = font;
- ctx->style->size.y = font->height;
- ctx->style->title_height = ctx->style->size.y + 6;
- process_frame(ctx);
+ mu_init();
+ mu_style.font = font;
+ mu_style.size.y = font->height;
+ mu_style.title_height = mu_style.size.y + 6;
+ process_frame();
oldbuttons = 0;
for (;;) {- process_frame(ctx);
- if (mu_render(ctx))
+ process_frame();
+ if (mu_render())
flushimage(display, 1);
gotevent = 1;
@@ -62,16 +60,16 @@
case 0: /* mouse */
m.xy.x -= screen->r.min.x;
m.xy.y -= screen->r.min.y;
- mu_input_mousemove(ctx, m.xy.x, m.xy.y);
+ mu_input_mousemove(m.xy.x, m.xy.y);
if ((b = (m.buttons & 1)) != (oldbuttons & 1))
- (b ? mu_input_mousedown : mu_input_mouseup)(ctx, m.xy.x, m.xy.y, MU_MOUSE_LEFT);
+ (b ? mu_input_mousedown : mu_input_mouseup)(m.xy.x, m.xy.y, MU_MOUSE_LEFT);
else if ((b = (m.buttons & 2)) != (oldbuttons & 2))
- (b ? mu_input_mousedown : mu_input_mouseup)(ctx, m.xy.x, m.xy.y, MU_MOUSE_MIDDLE);
+ (b ? mu_input_mousedown : mu_input_mouseup)(m.xy.x, m.xy.y, MU_MOUSE_MIDDLE);
else if ((b = (m.buttons & 4)) != (oldbuttons & 4))
- (b ? mu_input_mousedown : mu_input_mouseup)(ctx, m.xy.x, m.xy.y, MU_MOUSE_RIGHT);
+ (b ? mu_input_mousedown : mu_input_mouseup)(m.xy.x, m.xy.y, MU_MOUSE_RIGHT);
if (m.buttons == 5 && (snarf = Bopen("/dev/snarf", OREAD)) != nil) { if ((s = Brdstr(snarf, 0, 1)) != nil) {- mu_input_text(ctx, s);
+ mu_input_text(s);
free(s);
}
Bterm(snarf);
@@ -93,18 +91,18 @@
case Knack: nkey = MU_KEY_NACK; break;
case Kleft: nkey = MU_KEY_LEFT; break;
case Kright: nkey = MU_KEY_RIGHT; break;
- case Kesc: mu_set_focus(ctx, 0); break;
+ case Kesc: mu_set_focus(0); break;
default:
if (key < 0xf000 || key > 0xffff) {memset(text, 0, sizeof(text));
if (runetochar(text, &key) > 0)
- mu_input_text(ctx, text);
+ mu_input_text(text);
}
break;
}
if (nkey >= 0) {- mu_input_keydown(ctx, nkey);
- mu_input_keyup(ctx, nkey);
+ mu_input_keydown(nkey);
+ mu_input_keyup(nkey);
}
break;
@@ -114,7 +112,7 @@
}
if (gotevent)
- process_frame(ctx);
+ process_frame();
}
end:
--- a/microui.c
+++ b/microui.c
@@ -9,18 +9,6 @@
static mu_Rect unclipped_rect = { 0, 0, 0x1000000, 0x1000000 };-static mu_Style default_style = {- .font = nil,
- .size = { 68, 10 },- .padding = 6,
- .spacing = 4,
- .indent = 24,
- .title_height = 26,
- .scrollbar_size = 12,
- .thumb_size = 8,
- .colors = {nil},-};
-
static u8int atlasraw[] = {0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x72, 0x38,
0x67, 0x38, 0x62, 0x38, 0x61, 0x38, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
@@ -67,6 +55,19 @@
[ATLAS_DIMENSIONS] = {0, 0, 34, 25},};
+mu_Context mu_ctx;
+mu_Style mu_style = {+ .font = nil,
+ .size = { 68, 10 },+ .padding = 6,
+ .spacing = 4,
+ .indent = 24,
+ .title_height = 26,
+ .scrollbar_size = 12,
+ .thumb_size = 8,
+ .colors = {nil},+};
+
Image *atlasimage = nil;
mu_Rect *atlasicons = default_atlas_icons;
u8int defaultcolors[MU_COLOR_MAX][4] = {@@ -151,13 +152,13 @@
}
static void
-draw_frame(mu_Context *ctx, mu_Rect rect, int colorid)
+draw_frame(mu_Rect rect, int colorid)
{- mu_draw_rect(ctx, rect, ctx->style->colors[colorid]);
+ mu_draw_rect(rect, mu_style.colors[colorid]);
if (colorid == MU_COLOR_SCROLLBASE || colorid == MU_COLOR_SCROLLTHUMB || colorid == MU_COLOR_TITLEBG)
return;
/* draw border */
- mu_draw_box(ctx, expand_rect(rect, 1), ctx->style->colors[MU_COLOR_BORDER]);
+ mu_draw_box(expand_rect(rect, 1), mu_style.colors[MU_COLOR_BORDER]);
}
static int
@@ -167,7 +168,7 @@
}
void
-mu_init(mu_Context *ctx)
+mu_init(void)
{Rectangle r;
int res, i;
@@ -183,9 +184,9 @@
sysfatal("failed to load atlas: %r");}
- if (default_style.colors[0] == nil) {+ if (mu_style.colors[0] == nil) { for (i = 0; i < MU_COLOR_MAX; i++) {- default_style.colors[i] = mu_color(
+ mu_style.colors[i] = mu_color(
defaultcolors[i][0],
defaultcolors[i][1],
defaultcolors[i][2],
@@ -193,88 +194,84 @@
);
}
}
-
- memset(ctx, 0, sizeof(*ctx));
- memmove(&ctx->_style, &default_style, sizeof(default_style));
- ctx->style = &ctx->_style;
}
void
-mu_begin(mu_Context *ctx)
+mu_begin(void)
{- ctx->cmdsnum = ctx->rootnum = 0;
- ctx->strnum = 0;
- ctx->scroll_target = nil;
- ctx->last_hover_root = ctx->hover_root;
- ctx->hover_root = nil;
- ctx->mouse_delta.x = ctx->mouse_pos.x - ctx->last_mouse_pos.x;
- ctx->mouse_delta.y = ctx->mouse_pos.y - ctx->last_mouse_pos.y;
+ mu_ctx.cmdsnum = mu_ctx.rootnum = 0;
+ mu_ctx.strnum = 0;
+ mu_ctx.scroll_target = nil;
+ mu_ctx.last_hover_root = mu_ctx.hover_root;
+ mu_ctx.hover_root = nil;
+ mu_ctx.mouse_delta.x = mu_ctx.mouse_pos.x - mu_ctx.last_mouse_pos.x;
+ mu_ctx.mouse_delta.y = mu_ctx.mouse_pos.y - mu_ctx.last_mouse_pos.y;
}
static int
compare_zindex(const void *a, const void *b)
{- return (*(mu_Container**) a)->zindex - (*(mu_Container**) b)->zindex;
+ return (*(mu_Container**)a)->zindex - (*(mu_Container**)b)->zindex;
}
void
-mu_end(mu_Context *ctx)
+mu_end(void)
{int i, n;
/* check stacks */
- assert(ctx->cntnum == 0);
- assert(ctx->clipnum == 0);
- assert(ctx->idsnum == 0);
- assert(ctx->layoutsnum == 0);
+ assert(mu_ctx.cntnum == 0);
+ assert(mu_ctx.clipnum == 0);
+ assert(mu_ctx.idsnum == 0);
+ assert(mu_ctx.layoutsnum == 0);
/* handle scroll input */
- if (ctx->scroll_target) {- ctx->scroll_target->scroll.x += ctx->scroll_delta.x;
- ctx->scroll_target->scroll.y += ctx->scroll_delta.y;
+ if (mu_ctx.scroll_target) {+ mu_ctx.scroll_target->scroll.x += mu_ctx.scroll_delta.x;
+ mu_ctx.scroll_target->scroll.y += mu_ctx.scroll_delta.y;
}
/* unset focus if focus id was not touched this frame */
- if (!ctx->updated_focus)
- ctx->focus = 0;
- ctx->updated_focus = 0;
+ if (!mu_ctx.updated_focus)
+ mu_ctx.focus = 0;
+ mu_ctx.updated_focus = 0;
/* bring hover root to front if mouse was pressed */
- if (ctx->mouse_pressed && ctx->hover_root && ctx->hover_root->zindex < ctx->last_zindex)
- mu_bring_to_front(ctx, ctx->hover_root);
+ if (mu_ctx.mouse_pressed && mu_ctx.hover_root && mu_ctx.hover_root->zindex < mu_ctx.last_zindex)
+ mu_bring_to_front(mu_ctx.hover_root);
/* reset input state */
- ctx->key_pressed = 0;
- ctx->text_input[0] = 0;
- ctx->mouse_pressed = 0;
- ctx->scroll_delta = ZP;
- ctx->last_mouse_pos = ctx->mouse_pos;
+ mu_ctx.key_pressed = 0;
+ mu_ctx.text_input[0] = 0;
+ mu_ctx.mouse_pressed = 0;
+ mu_ctx.scroll_delta = ZP;
+ mu_ctx.last_mouse_pos = mu_ctx.mouse_pos;
/* sort root containers by zindex */
- n = ctx->rootnum;
- qsort(ctx->root, n, sizeof(*ctx->root), compare_zindex);
+ n = mu_ctx.rootnum;
+ qsort(mu_ctx.root, n, sizeof(*mu_ctx.root), compare_zindex);
/* set root container jump commands */
for (i = 0; i < n; i++) {- mu_Container *cnt = ctx->root[i];
+ mu_Container *cnt = mu_ctx.root[i];
/* if this is the first container then make the first command jump to it.
** otherwise set the previous container's tail to jump to this one */
if (i == 0)
- ctx->cmds[0].jump.dst = cnt->head + 1;
+ mu_ctx.cmds[0].jump.dst = cnt->head + 1;
else
- ctx->cmds[ctx->root[i - 1]->tail].jump.dst = cnt->head + 1;
+ mu_ctx.cmds[mu_ctx.root[i - 1]->tail].jump.dst = cnt->head + 1;
/* make the last container's tail jump to the end of command list */
if (i == n - 1)
- ctx->cmds[cnt->tail].jump.dst = ctx->cmdsnum;
+ mu_ctx.cmds[cnt->tail].jump.dst = mu_ctx.cmdsnum;
}
}
void
-mu_set_focus(mu_Context *ctx, mu_Id id)
+mu_set_focus(mu_Id id)
{- ctx->focus = id;
- ctx->updated_focus = 1;
+ mu_ctx.focus = id;
+ mu_ctx.updated_focus = 1;
}
/* 32bit fnv-1a hash */
@@ -291,57 +288,57 @@
mu_Id
-mu_get_id(mu_Context *ctx, const void *data, int size)
+mu_get_id(const void *data, int size)
{- int idx = ctx->idsnum;
- mu_Id res = (idx > 0) ? ctx->ids[idx - 1] : HASH_INITIAL;
+ int idx = mu_ctx.idsnum;
+ mu_Id res = (idx > 0) ? mu_ctx.ids[idx - 1] : HASH_INITIAL;
hash(&res, data, size);
- ctx->last_id = res;
+ mu_ctx.last_id = res;
return res;
}
void
-mu_push_id(mu_Context *ctx, const void *data, int size)
+mu_push_id(const void *data, int size)
{- buffer_grow(&ctx->ids, sizeof(*ctx->ids), &ctx->idsmax, ctx->idsnum);
- ctx->ids[ctx->idsnum++] = mu_get_id(ctx, data, size);
+ buffer_grow(&mu_ctx.ids, sizeof(*mu_ctx.ids), &mu_ctx.idsmax, mu_ctx.idsnum);
+ mu_ctx.ids[mu_ctx.idsnum++] = mu_get_id(data, size);
}
void
-mu_pop_id(mu_Context *ctx)
+mu_pop_id(void)
{- ctx->idsnum--;
+ mu_ctx.idsnum--;
}
void
-mu_push_clip_rect(mu_Context *ctx, mu_Rect rect)
+mu_push_clip_rect(mu_Rect rect)
{- mu_Rect last = mu_get_clip_rect(ctx);
- buffer_grow(&ctx->clip, sizeof(*ctx->clip), &ctx->clipmax, ctx->clipnum);
- ctx->clip[ctx->clipnum++] = clip_rect(rect, last);
+ mu_Rect last = mu_get_clip_rect();
+ buffer_grow(&mu_ctx.clip, sizeof(*mu_ctx.clip), &mu_ctx.clipmax, mu_ctx.clipnum);
+ mu_ctx.clip[mu_ctx.clipnum++] = clip_rect(rect, last);
}
void
-mu_pop_clip_rect(mu_Context *ctx)
+mu_pop_clip_rect(void)
{- ctx->clipnum--;
+ mu_ctx.clipnum--;
}
mu_Rect
-mu_get_clip_rect(mu_Context *ctx)
+mu_get_clip_rect(void)
{- assert(ctx->clipnum > 0);
- return ctx->clip[ctx->clipnum - 1];
+ assert(mu_ctx.clipnum > 0);
+ return mu_ctx.clip[mu_ctx.clipnum - 1];
}
int
-mu_check_clip(mu_Context *ctx, mu_Rect r)
+mu_check_clip(mu_Rect r)
{- mu_Rect cr = mu_get_clip_rect(ctx);
+ mu_Rect cr = mu_get_clip_rect();
if (r.x > cr.x + cr.w || r.x + r.w < cr.x || r.y > cr.y + cr.h || r.y + r.h < cr.y)
return MU_CLIP_ALL;
if (r.x >= cr.x && r.x + r.w <= cr.x + cr.w && r.y >= cr.y && r.y + r.h <= cr.y + cr.h)
@@ -351,7 +348,7 @@
static void
-push_layout(mu_Context *ctx, mu_Rect body, Point scroll)
+push_layout(mu_Rect body, Point scroll)
{mu_Layout layout;
int width = 0;
@@ -358,63 +355,63 @@
memset(&layout, 0, sizeof(mu_Layout));
layout.body = mu_rect(body.x - scroll.x, body.y - scroll.y, body.w, body.h);
layout.max = Pt(-0x1000000, -0x1000000);
- buffer_grow(&ctx->layouts, sizeof(*ctx->layouts), &ctx->layoutsmax, ctx->layoutsnum);
- ctx->layouts[ctx->layoutsnum++] = layout;
- mu_layout_row(ctx, 1, &width, 0);
+ buffer_grow(&mu_ctx.layouts, sizeof(*mu_ctx.layouts), &mu_ctx.layoutsmax, mu_ctx.layoutsnum);
+ mu_ctx.layouts[mu_ctx.layoutsnum++] = layout;
+ mu_layout_row(1, &width, 0);
}
static mu_Layout *
-get_layout(mu_Context *ctx)
+get_layout(void)
{- return &ctx->layouts[ctx->layoutsnum - 1];
+ return &mu_ctx.layouts[mu_ctx.layoutsnum - 1];
}
static void
-push_container(mu_Context *ctx, mu_Container *cnt)
+push_container(mu_Container *cnt)
{- buffer_grow(&ctx->cnt, sizeof(*ctx->cnt), &ctx->cntmax, ctx->cntnum);
- ctx->cnt[ctx->cntnum++] = cnt;
- mu_push_id(ctx, &cnt, sizeof(mu_Container*));
+ buffer_grow(&mu_ctx.cnt, sizeof(*mu_ctx.cnt), &mu_ctx.cntmax, mu_ctx.cntnum);
+ mu_ctx.cnt[mu_ctx.cntnum++] = cnt;
+ mu_push_id(&cnt, sizeof(mu_Container*));
}
static void
-pop_container(mu_Context *ctx)
+pop_container(void)
{- mu_Container *cnt = mu_get_container(ctx);
- mu_Layout *layout = get_layout(ctx);
+ mu_Container *cnt = mu_get_container();
+ mu_Layout *layout = get_layout();
cnt->content_size.x = layout->max.x - layout->body.x;
cnt->content_size.y = layout->max.y - layout->body.y;
- ctx->cntnum--;
- ctx->layoutsnum--;
- mu_pop_id(ctx);
+ mu_ctx.cntnum--;
+ mu_ctx.layoutsnum--;
+ mu_pop_id();
}
mu_Container *
-mu_get_container(mu_Context *ctx)
+mu_get_container(void)
{- assert(ctx->cntnum > 0);
- return ctx->cnt[ctx->cntnum - 1];
+ assert(mu_ctx.cntnum > 0);
+ return mu_ctx.cnt[mu_ctx.cntnum - 1];
}
void
-mu_init_window(mu_Context *ctx, mu_Container *cnt, int opt)
+mu_init_window(mu_Container *cnt, int opt)
{memset(cnt, 0, sizeof(*cnt));
cnt->inited = 1;
cnt->open = opt & MU_OPT_CLOSED ? 0 : 1;
cnt->rect = mu_rect(100, 100, 300, 300);
- mu_bring_to_front(ctx, cnt);
+ mu_bring_to_front(cnt);
}
void
-mu_bring_to_front(mu_Context *ctx, mu_Container *cnt)
+mu_bring_to_front(mu_Container *cnt)
{- cnt->zindex = ++ctx->last_zindex;
+ cnt->zindex = ++mu_ctx.last_zindex;
}
@@ -423,59 +420,59 @@
**============================================================================*/
void
-mu_input_mousemove(mu_Context *ctx, int x, int y)
+mu_input_mousemove(int x, int y)
{- ctx->mouse_pos = Pt(x, y);
+ mu_ctx.mouse_pos = Pt(x, y);
}
void
-mu_input_mousedown(mu_Context *ctx, int x, int y, int btn)
+mu_input_mousedown(int x, int y, int btn)
{- mu_input_mousemove(ctx, x, y);
- ctx->mouse_down |= btn;
- ctx->mouse_pressed |= btn;
+ mu_input_mousemove(x, y);
+ mu_ctx.mouse_down |= btn;
+ mu_ctx.mouse_pressed |= btn;
}
void
-mu_input_mouseup(mu_Context *ctx, int x, int y, int btn)
+mu_input_mouseup(int x, int y, int btn)
{- mu_input_mousemove(ctx, x, y);
- ctx->mouse_down &= ~btn;
+ mu_input_mousemove(x, y);
+ mu_ctx.mouse_down &= ~btn;
}
void
-mu_input_scroll(mu_Context *ctx, int x, int y)
+mu_input_scroll(int x, int y)
{- ctx->scroll_delta.x += x;
- ctx->scroll_delta.y += y;
+ mu_ctx.scroll_delta.x += x;
+ mu_ctx.scroll_delta.y += y;
}
void
-mu_input_keydown(mu_Context *ctx, int key)
+mu_input_keydown(int key)
{- ctx->key_pressed |= key;
- ctx->key_down |= key;
+ mu_ctx.key_pressed |= key;
+ mu_ctx.key_down |= key;
}
void
-mu_input_keyup(mu_Context *ctx, int key)
+mu_input_keyup(int key)
{- ctx->key_down &= ~key;
+ mu_ctx.key_down &= ~key;
}
void
-mu_input_text(mu_Context *ctx, const char *text)
+mu_input_text(const char *text)
{- int len = strlen(ctx->text_input);
+ int len = strlen(mu_ctx.text_input);
int size = strlen(text) + 1;
- assert(len + size <= (int) sizeof(ctx->text_input));
- memcpy(ctx->text_input + len, text, size);
+ assert(len + size <= (int) sizeof(mu_ctx.text_input));
+ memcpy(mu_ctx.text_input + len, text, size);
}
/*============================================================================
@@ -483,12 +480,12 @@
**============================================================================*/
mu_Command *
-mu_push_command(mu_Context *ctx, int type)
+mu_push_command(int type)
{mu_Command *cmd;
- buffer_grow(&ctx->cmds, sizeof(mu_Command), &ctx->cmdsmax, ctx->cmdsnum);
- cmd = &ctx->cmds[ctx->cmdsnum++];
+ buffer_grow(&mu_ctx.cmds, sizeof(mu_Command), &mu_ctx.cmdsmax, mu_ctx.cmdsnum);
+ cmd = &mu_ctx.cmds[mu_ctx.cmdsnum++];
memset(cmd, 0, sizeof(*cmd));
cmd->type = type;
@@ -496,29 +493,29 @@
}
static int
-push_jump(mu_Context *ctx, int dst)
+push_jump(int dst)
{mu_Command *cmd;
- cmd = mu_push_command(ctx, MU_COMMAND_JUMP);
+ cmd = mu_push_command(MU_COMMAND_JUMP);
cmd->jump.dst = dst;
- return ctx->cmdsnum-1;
+ return mu_ctx.cmdsnum-1;
}
void
-mu_set_clip(mu_Context *ctx, mu_Rect rect)
+mu_set_clip(mu_Rect rect)
{mu_Command *cmd;
- cmd = mu_push_command(ctx, MU_COMMAND_CLIP);
+ cmd = mu_push_command(MU_COMMAND_CLIP);
cmd->clip.rect = rect;
}
void
-mu_draw_rect(mu_Context *ctx, mu_Rect rect, Image *color)
+mu_draw_rect(mu_Rect rect, Image *color)
{mu_Command *cmd;
- rect = clip_rect(rect, mu_get_clip_rect(ctx));
+ rect = clip_rect(rect, mu_get_clip_rect());
if (rect.w > 0 && rect.h > 0) {- cmd = mu_push_command(ctx, MU_COMMAND_RECT);
+ cmd = mu_push_command(MU_COMMAND_RECT);
cmd->rect.rect = rect;
cmd->rect.color = color;
}
@@ -525,17 +522,17 @@
}
void
-mu_draw_box(mu_Context *ctx, mu_Rect rect, Image *color)
+mu_draw_box(mu_Rect rect, Image *color)
{- mu_draw_rect(ctx, mu_rect(rect.x + 1, rect.y, rect.w - 2, 1), color);
- mu_draw_rect(ctx, mu_rect(rect.x+1, rect.y + rect.h-1, rect.w-2, 1), color);
- mu_draw_rect(ctx, mu_rect(rect.x, rect.y, 1, rect.h), color);
- mu_draw_rect(ctx, mu_rect(rect.x + rect.w - 1, rect.y, 1, rect.h), color);
+ mu_draw_rect(mu_rect(rect.x + 1, rect.y, rect.w - 2, 1), color);
+ mu_draw_rect(mu_rect(rect.x+1, rect.y + rect.h-1, rect.w-2, 1), color);
+ mu_draw_rect(mu_rect(rect.x, rect.y, 1, rect.h), color);
+ mu_draw_rect(mu_rect(rect.x + rect.w - 1, rect.y, 1, rect.h), color);
}
void
-mu_draw_text(mu_Context *ctx, Font *font, const char *s, int len, Point pos, Image *color)
+mu_draw_text(Font *font, const char *s, int len, Point pos, Image *color)
{mu_Command *cmd;
mu_Rect rect;
@@ -544,23 +541,23 @@
if (len < 0)
len = strlen(s);
rect = mu_rect(pos.x, pos.y, text_width(font, s, len), font->height);
- clipped = mu_check_clip(ctx, rect);
+ clipped = mu_check_clip(rect);
if (clipped == MU_CLIP_ALL )
return;
if (clipped == MU_CLIP_PART)
- mu_set_clip(ctx, mu_get_clip_rect(ctx));
+ mu_set_clip(mu_get_clip_rect());
- if (ctx->strmax <= ctx->strnum+len+1) {- ctx->strmax = MAX(ctx->strmax, ctx->strnum+len+1) * 2;
- if ((ctx->str = realloc(ctx->str, ctx->strmax)) == nil)
- sysfatal("not enough memory for %d chars", ctx->strmax);+ if (mu_ctx.strmax <= mu_ctx.strnum+len+1) {+ mu_ctx.strmax = MAX(mu_ctx.strmax, mu_ctx.strnum+len+1) * 2;
+ if ((mu_ctx.str = realloc(mu_ctx.str, mu_ctx.strmax)) == nil)
+ sysfatal("not enough memory for %d chars", mu_ctx.strmax);}
- cmd = mu_push_command(ctx, MU_COMMAND_TEXT);
- cmd->text.s = ctx->strnum;
- memmove(ctx->str+ctx->strnum, s, len);
- ctx->strnum += len;
- ctx->str[ctx->strnum++] = 0;
+ cmd = mu_push_command(MU_COMMAND_TEXT);
+ cmd->text.s = mu_ctx.strnum;
+ memmove(mu_ctx.str+mu_ctx.strnum, s, len);
+ mu_ctx.strnum += len;
+ mu_ctx.str[mu_ctx.strnum++] = 0;
cmd->text.pos = pos;
cmd->text.color = color;
cmd->text.font = font;
@@ -567,27 +564,27 @@
/* reset clipping if it was set */
if (clipped)
- mu_set_clip(ctx, unclipped_rect);
+ mu_set_clip(unclipped_rect);
}
void
-mu_draw_icon(mu_Context *ctx, int id, mu_Rect rect)
+mu_draw_icon(int id, mu_Rect rect)
{mu_Command *cmd;
/* do clip command if the rect isn't fully contained within the cliprect */
- int clipped = mu_check_clip(ctx, rect);
+ int clipped = mu_check_clip(rect);
if (clipped == MU_CLIP_ALL )
return;
if (clipped == MU_CLIP_PART)
- mu_set_clip(ctx, mu_get_clip_rect(ctx));
+ mu_set_clip(mu_get_clip_rect());
/* do icon command */
- cmd = mu_push_command(ctx, MU_COMMAND_ICON);
+ cmd = mu_push_command(MU_COMMAND_ICON);
cmd->icon.id = id;
cmd->icon.rect = rect;
/* reset clipping if it was set */
if (clipped)
- mu_set_clip(ctx, unclipped_rect);
+ mu_set_clip(unclipped_rect);
}
@@ -603,20 +600,20 @@
void
-mu_layout_begin_column(mu_Context *ctx)
+mu_layout_begin_column(void)
{- push_layout(ctx, mu_layout_next(ctx), ZP);
+ push_layout(mu_layout_next(), ZP);
}
void
-mu_layout_end_column(mu_Context *ctx)
+mu_layout_end_column(void)
{mu_Layout *a, *b;
- b = get_layout(ctx);
- ctx->layoutsnum--;
+ b = get_layout();
+ mu_ctx.layoutsnum--;
/* inherit position/next_row/max from child layout if they are greater */
- a = get_layout(ctx);
+ a = get_layout();
a->position.x = MAX(a->position.x, b->position.x + b->body.x - a->body.x);
a->next_row = MAX(a->next_row, b->next_row + b->body.y - a->body.y);
a->max.x = MAX(a->max.x, b->max.x);
@@ -625,9 +622,9 @@
void
-mu_layout_row(mu_Context *ctx, int items, const int *widths, int height)
+mu_layout_row(int items, const int *widths, int height)
{- mu_Layout *layout = get_layout(ctx);
+ mu_Layout *layout = get_layout();
if (widths) {assert(items <= MU_MAX_WIDTHS);
memcpy(layout->widths, widths, items * sizeof(widths[0]));
@@ -640,23 +637,23 @@
void
-mu_layout_width(mu_Context *ctx, int width)
+mu_layout_width(int width)
{- get_layout(ctx)->size.x = width;
+ get_layout()->size.x = width;
}
void
-mu_layout_height(mu_Context *ctx, int height)
+mu_layout_height(int height)
{- get_layout(ctx)->size.y = height;
+ get_layout()->size.y = height;
}
void
-mu_layout_set_next(mu_Context *ctx, mu_Rect r, int relative)
+mu_layout_set_next(mu_Rect r, int relative)
{- mu_Layout *layout = get_layout(ctx);
+ mu_Layout *layout = get_layout();
layout->next = r;
layout->next_type = relative ? RELATIVE : ABSOLUTE;
}
@@ -663,10 +660,9 @@
mu_Rect
-mu_layout_next(mu_Context *ctx)
+mu_layout_next(void)
{- mu_Layout *layout = get_layout(ctx);
- mu_Style *style = ctx->style;
+ mu_Layout *layout = get_layout();
mu_Rect res;
if (layout->next_type) {@@ -675,7 +671,7 @@
layout->next_type = 0;
res = layout->next;
if (type == ABSOLUTE) {- ctx->last_rect = res;
+ mu_ctx.last_rect = res;
return res;
}
@@ -682,7 +678,7 @@
} else {/* handle next row */
if (layout->row_index == layout->items)
- mu_layout_row(ctx, layout->items, nil, layout->size.y);
+ mu_layout_row(layout->items, nil, layout->size.y);
/* position */
res.x = layout->position.x;
@@ -692,9 +688,9 @@
res.w = layout->items > -1 ? layout->widths[layout->row_index] : layout->size.x;
res.h = layout->size.y;
if (res.w == 0)
- res.w = style->size.x + style->padding * 2;
+ res.w = mu_style.size.x + mu_style.padding * 2;
if (res.h == 0)
- res.h = style->size.y + style->padding * 2;
+ res.h = mu_style.size.y + mu_style.padding * 2;
if (res.w < 0)
res.w += layout->body.w - res.x + 1;
if (res.h < 0)
@@ -704,8 +700,8 @@
}
/* update position */
- layout->position.x += res.w + style->spacing;
- layout->next_row = MAX(layout->next_row, res.y + res.h + style->spacing);
+ layout->position.x += res.w + mu_style.spacing;
+ layout->next_row = MAX(layout->next_row, res.y + res.h + mu_style.spacing);
/* apply body offset */
res.x += layout->body.x;
@@ -715,7 +711,7 @@
layout->max.x = MAX(layout->max.x, res.x + res.w);
layout->max.y = MAX(layout->max.y, res.y + res.h);
- ctx->last_rect = res;
+ mu_ctx.last_rect = res;
return res;
}
@@ -725,15 +721,15 @@
**============================================================================*/
static int
-in_hover_root(mu_Context *ctx)
+in_hover_root(void)
{- int i = ctx->cntnum;
+ int i = mu_ctx.cntnum;
while (i--) {- if (ctx->cnt[i] == ctx->last_hover_root)
+ if (mu_ctx.cnt[i] == mu_ctx.last_hover_root)
return 1;
/* only root containers have their `head` field set; stop searching if we've
** reached the current root container */
- if (ctx->cnt[i]->head >= 0)
+ if (mu_ctx.cnt[i]->head >= 0)
break;
}
return 0;
@@ -741,83 +737,83 @@
void
-mu_draw_control_frame(mu_Context *ctx, mu_Id id, mu_Rect rect, int colorid, int opt)
+mu_draw_control_frame(mu_Id id, mu_Rect rect, int colorid, int opt)
{if (opt & MU_OPT_NOFRAME)
return;
- colorid += (ctx->focus == id) ? 2 : (ctx->hover == id) ? 1 : 0;
- draw_frame(ctx, rect, colorid);
+ colorid += (mu_ctx.focus == id) ? 2 : (mu_ctx.hover == id) ? 1 : 0;
+ draw_frame(rect, colorid);
}
void
-mu_draw_control_text(mu_Context *ctx, const char *str, mu_Rect rect, int colorid, int opt)
+mu_draw_control_text(const char *str, mu_Rect rect, int colorid, int opt)
{Point pos;
- Font *font = ctx->style->font;
+ Font *font = mu_style.font;
int tw = text_width(font, str, -1);
- mu_push_clip_rect(ctx, rect);
+ mu_push_clip_rect(rect);
pos.y = rect.y + (rect.h - font->height) / 2;
if (opt & MU_OPT_ALIGNCENTER)
pos.x = rect.x + (rect.w - tw) / 2;
else if (opt & MU_OPT_ALIGNRIGHT)
- pos.x = rect.x + rect.w - tw - ctx->style->padding;
+ pos.x = rect.x + rect.w - tw - mu_style.padding;
else
- pos.x = rect.x + ctx->style->padding;
+ pos.x = rect.x + mu_style.padding;
- mu_draw_text(ctx, font, str, -1, pos, ctx->style->colors[colorid]);
- mu_pop_clip_rect(ctx);
+ mu_draw_text(font, str, -1, pos, mu_style.colors[colorid]);
+ mu_pop_clip_rect();
}
int
-mu_mouse_over(mu_Context *ctx, mu_Rect rect)
+mu_mouse_over(mu_Rect rect)
{- return rect_overlaps_vec2(rect, ctx->mouse_pos) &&
- rect_overlaps_vec2(mu_get_clip_rect(ctx), ctx->mouse_pos) &&
- in_hover_root(ctx);
+ return rect_overlaps_vec2(rect, mu_ctx.mouse_pos) &&
+ rect_overlaps_vec2(mu_get_clip_rect(), mu_ctx.mouse_pos) &&
+ in_hover_root();
}
void
-mu_update_control(mu_Context *ctx, mu_Id id, mu_Rect rect, int opt)
+mu_update_control(mu_Id id, mu_Rect rect, int opt)
{- int mouseover = mu_mouse_over(ctx, rect);
+ int mouseover = mu_mouse_over(rect);
- if (ctx->focus == id)
- ctx->updated_focus = 1;
+ if (mu_ctx.focus == id)
+ mu_ctx.updated_focus = 1;
if (opt & MU_OPT_NOINTERACT)
return;
- if (mouseover && !ctx->mouse_down)
- ctx->hover = id;
+ if (mouseover && !mu_ctx.mouse_down)
+ mu_ctx.hover = id;
- if (ctx->focus == id) {- if (ctx->mouse_pressed && !mouseover)
- mu_set_focus(ctx, 0);
- if (!ctx->mouse_down && ~opt & MU_OPT_HOLDFOCUS)
- mu_set_focus(ctx, 0);
+ if (mu_ctx.focus == id) {+ if (mu_ctx.mouse_pressed && !mouseover)
+ mu_set_focus(0);
+ if (!mu_ctx.mouse_down && ~opt & MU_OPT_HOLDFOCUS)
+ mu_set_focus(0);
}
- if (ctx->hover == id) {+ if (mu_ctx.hover == id) {if (!mouseover)
- ctx->hover = 0;
- else if (ctx->mouse_pressed)
- mu_set_focus(ctx, id);
+ mu_ctx.hover = 0;
+ else if (mu_ctx.mouse_pressed)
+ mu_set_focus(id);
}
}
void
-mu_text(mu_Context *ctx, const char *text)
+mu_text(const char *text)
{const char *start, *end, *p = text;
int width = -1;
- Font *font = ctx->style->font;
- Image *color = ctx->style->colors[MU_COLOR_TEXT];
- mu_layout_begin_column(ctx);
- mu_layout_row(ctx, 1, &width, font->height);
+ Font *font = mu_style.font;
+ Image *color = mu_style.colors[MU_COLOR_TEXT];
+ mu_layout_begin_column();
+ mu_layout_row(1, &width, font->height);
do {- mu_Rect r = mu_layout_next(ctx);
+ mu_Rect r = mu_layout_next();
int w = 0;
start = end = p;
do {@@ -830,121 +826,121 @@
w += text_width(font, p, 1);
end = p++;
} while (*end && *end != '\n');
- mu_draw_text(ctx, font, start, end - start, Pt(r.x, r.y), color);
+ mu_draw_text(font, start, end - start, Pt(r.x, r.y), color);
p = end + 1;
} while (*end);
- mu_layout_end_column(ctx);
+ mu_layout_end_column();
}
void
-mu_label(mu_Context *ctx, const char *text)
+mu_label(const char *text)
{- mu_draw_control_text(ctx, text, mu_layout_next(ctx), MU_COLOR_TEXT, 0);
+ mu_draw_control_text(text, mu_layout_next(), MU_COLOR_TEXT, 0);
}
int
-mu_button_ex(mu_Context *ctx, const char *label, int icon, int opt) {+mu_button_ex(const char *label, int icon, int opt) {int res = 0;
- mu_Id id = label ? mu_get_id(ctx, label, strlen(label)) : mu_get_id(ctx, &icon, sizeof(icon));
- mu_Rect r = mu_layout_next(ctx);
- mu_update_control(ctx, id, r, opt);
+ mu_Id id = label ? mu_get_id(label, strlen(label)) : mu_get_id(&icon, sizeof(icon));
+ mu_Rect r = mu_layout_next();
+ mu_update_control(id, r, opt);
/* handle click */
- if (ctx->mouse_pressed == MU_MOUSE_LEFT && ctx->focus == id)
+ if (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id)
res |= MU_RES_SUBMIT;
/* draw */
- mu_draw_control_frame(ctx, id, r, MU_COLOR_BUTTON, opt);
+ mu_draw_control_frame(id, r, MU_COLOR_BUTTON, opt);
if (label)
- mu_draw_control_text(ctx, label, r, MU_COLOR_TEXT, opt);
+ mu_draw_control_text(label, r, MU_COLOR_TEXT, opt);
if (icon)
- mu_draw_icon(ctx, icon, r);
+ mu_draw_icon(icon, r);
return res;
}
int
-mu_button(mu_Context *ctx, const char *label)
+mu_button(const char *label)
{- return mu_button_ex(ctx, label, 0, MU_OPT_ALIGNCENTER);
+ return mu_button_ex(label, 0, MU_OPT_ALIGNCENTER);
}
int
-mu_checkbox(mu_Context *ctx, int *state, const char *label)
+mu_checkbox(int *state, const char *label)
{int res = 0;
- mu_Id id = mu_get_id(ctx, &state, sizeof(state));
- mu_Rect r = mu_layout_next(ctx);
+ mu_Id id = mu_get_id(&state, sizeof(state));
+ mu_Rect r = mu_layout_next();
mu_Rect box = mu_rect(r.x, r.y, r.h, r.h);
- mu_update_control(ctx, id, r, 0);
+ mu_update_control(id, r, 0);
/* handle click */
- if (ctx->mouse_pressed == MU_MOUSE_LEFT && ctx->focus == id) {+ if (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id) {res |= MU_RES_CHANGE;
*state = !*state;
}
/* draw */
- mu_draw_control_frame(ctx, id, box, MU_COLOR_BASE, 0);
+ mu_draw_control_frame(id, box, MU_COLOR_BASE, 0);
if (*state)
- mu_draw_icon(ctx, MU_ICON_CHECK, box);
+ mu_draw_icon(MU_ICON_CHECK, box);
r = mu_rect(r.x + box.w, r.y, r.w - box.w, r.h);
- mu_draw_control_text(ctx, label, r, MU_COLOR_TEXT, 0);
+ mu_draw_control_text(label, r, MU_COLOR_TEXT, 0);
return res;
}
int
-mu_textbox_raw(mu_Context *ctx, char *buf, int bufsz, mu_Id id, mu_Rect r, int opt)
+mu_textbox_raw(char *buf, int bufsz, mu_Id id, mu_Rect r, int opt)
{int res = 0;
- mu_update_control(ctx, id, r, opt | MU_OPT_HOLDFOCUS);
+ mu_update_control(id, r, opt | MU_OPT_HOLDFOCUS);
- if (ctx->focus == id) {+ if (mu_ctx.focus == id) {/* handle text input */
int len = strlen(buf);
- int n = MIN(bufsz - len - 1, (int) strlen(ctx->text_input));
+ int n = MIN(bufsz - len - 1, (int)strlen(mu_ctx.text_input));
if (n > 0) {- memcpy(buf + len, ctx->text_input, n);
+ memcpy(buf + len, mu_ctx.text_input, n);
len += n;
buf[len] = '\0';
res |= MU_RES_CHANGE;
}
/* handle backspace */
- if (ctx->key_pressed & MU_KEY_BACKSPACE && len > 0) {+ if (mu_ctx.key_pressed & MU_KEY_BACKSPACE && len > 0) {/* skip utf-8 continuation bytes */
while ((buf[--len] & 0xc0) == 0x80 && len > 0);
buf[len] = '\0';
res |= MU_RES_CHANGE;
}
- if (ctx->key_pressed & MU_KEY_NACK && len > 0) {+ if (mu_ctx.key_pressed & MU_KEY_NACK && len > 0) {buf[0] = '\0';
res |= MU_RES_CHANGE;
}
/* handle return */
- if (ctx->key_pressed & MU_KEY_RETURN) {- mu_set_focus(ctx, 0);
+ if (mu_ctx.key_pressed & MU_KEY_RETURN) {+ mu_set_focus(0);
res |= MU_RES_SUBMIT;
}
}
/* draw */
- mu_draw_control_frame(ctx, id, r, MU_COLOR_BASE, opt);
- if (ctx->focus == id) {- Image *color = ctx->style->colors[MU_COLOR_TEXT];
- Font *font = ctx->style->font;
+ mu_draw_control_frame(id, r, MU_COLOR_BASE, opt);
+ if (mu_ctx.focus == id) {+ Image *color = mu_style.colors[MU_COLOR_TEXT];
+ Font *font = mu_style.font;
int textw = text_width(font, buf, -1);
int texth = font->height;
- int ofx = r.w - ctx->style->padding - textw - 1;
- int textx = r.x + MIN(ofx, ctx->style->padding);
+ int ofx = r.w - mu_style.padding - textw - 1;
+ int textx = r.x + MIN(ofx, mu_style.padding);
int texty = r.y + (r.h - texth) / 2;
- mu_push_clip_rect(ctx, r);
- mu_draw_text(ctx, font, buf, -1, Pt(textx, texty), color);
- mu_draw_rect(ctx, mu_rect(textx + textw, texty, 1, texth), color);
- mu_pop_clip_rect(ctx);
+ mu_push_clip_rect(r);
+ mu_draw_text(font, buf, -1, Pt(textx, texty), color);
+ mu_draw_rect(mu_rect(textx + textw, texty, 1, texth), color);
+ mu_pop_clip_rect();
} else {- mu_draw_control_text(ctx, buf, r, MU_COLOR_TEXT, opt);
+ mu_draw_control_text(buf, r, MU_COLOR_TEXT, opt);
}
return res;
@@ -952,17 +948,17 @@
static int
-number_textbox(mu_Context *ctx, float *value, mu_Rect r, mu_Id id)
+number_textbox(float *value, mu_Rect r, mu_Id id)
{- if (((ctx->mouse_pressed == MU_MOUSE_LEFT && ctx->key_down & MU_KEY_SHIFT) || ctx->mouse_pressed == MU_MOUSE_RIGHT) && ctx->hover == id) {- ctx->number_editing = id;
- sprint(ctx->number_buf, MU_REAL_FMT, *value);
+ if (((mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.key_down & MU_KEY_SHIFT) || mu_ctx.mouse_pressed == MU_MOUSE_RIGHT) && mu_ctx.hover == id) {+ mu_ctx.number_editing = id;
+ sprint(mu_ctx.number_buf, MU_REAL_FMT, *value);
}
- if (ctx->number_editing == id) {- int res = mu_textbox_raw(ctx, ctx->number_buf, sizeof(ctx->number_buf), id, r, 0);
- if (res & MU_RES_SUBMIT || ctx->focus != id) {- *value = strtod(ctx->number_buf, nil);
- ctx->number_editing = 0;
+ if (mu_ctx.number_editing == id) {+ int res = mu_textbox_raw(mu_ctx.number_buf, sizeof(mu_ctx.number_buf), id, r, 0);
+ if (res & MU_RES_SUBMIT || mu_ctx.focus != id) {+ *value = strtod(mu_ctx.number_buf, nil);
+ mu_ctx.number_editing = 0;
} else {return 1;
}
@@ -972,54 +968,56 @@
int
-mu_textbox_ex(mu_Context *ctx, char *buf, int bufsz, int opt)
+mu_textbox_ex(char *buf, int bufsz, int opt)
{- mu_Id id = mu_get_id(ctx, &buf, sizeof(buf));
- mu_Rect r = mu_layout_next(ctx);
- return mu_textbox_raw(ctx, buf, bufsz, id, r, opt);
+ mu_Id id = mu_get_id(&buf, sizeof(buf));
+ mu_Rect r = mu_layout_next();
+ return mu_textbox_raw(buf, bufsz, id, r, opt);
}
int
-mu_textbox(mu_Context *ctx, char *buf, int bufsz)
+mu_textbox(char *buf, int bufsz)
{- return mu_textbox_ex(ctx, buf, bufsz, 0);
+ return mu_textbox_ex(buf, bufsz, 0);
}
int
-mu_slider_ex(mu_Context *ctx, float *value, float low, float high, float step, const char *fmt, int opt)
+mu_slider_ex(float *value, float low, float high, float step, const char *fmt, int opt)
{char buf[MU_MAX_FMT + 1];
mu_Rect thumb;
int w, res = 0;
float normalized, last = *value, v = last;
- mu_Id id = mu_get_id(ctx, &value, sizeof(value));
- mu_Rect base = mu_layout_next(ctx);
+ mu_Id id = mu_get_id(&value, sizeof(value));
+ mu_Rect base = mu_layout_next();
/* handle text input mode */
- if (number_textbox(ctx, &v, base, id))
+ if (number_textbox(&v, base, id))
return res;
/* handle normal mode */
- mu_update_control(ctx, id, base, opt);
+ mu_update_control(id, base, opt);
/* handle input */
- if (ctx->focus == id) {- if (ctx->mouse_down == MU_MOUSE_LEFT)
- v = low + ((float) (ctx->mouse_pos.x - base.x) / base.w) * (high - low);
- } else if (ctx->hover == id) {- if ((ctx->key_pressed & (MU_KEY_LEFT | MU_KEY_RIGHT)) == MU_KEY_LEFT) {+ if (mu_ctx.focus == id) {+ if (mu_ctx.mouse_down == MU_MOUSE_LEFT)
+ v = low + ((float)(mu_ctx.mouse_pos.x - base.x) / base.w) * (high - low);
+ } else if (mu_ctx.hover == id) {+ if ((mu_ctx.key_pressed & (MU_KEY_LEFT | MU_KEY_RIGHT)) == MU_KEY_LEFT) {v -= step ? step : 1;
- if (v < low) v = low;
- } else if ((ctx->key_pressed & (MU_KEY_LEFT | MU_KEY_RIGHT)) == MU_KEY_RIGHT) {+ if (v < low)
+ v = low;
+ } else if ((mu_ctx.key_pressed & (MU_KEY_LEFT | MU_KEY_RIGHT)) == MU_KEY_RIGHT) {v += step ? step : 1;
- if (v > high) v = high;
+ if (v > high)
+ v = high;
}
}
if (step)
- v = ((long) ((v + step/2) / step)) * step;
+ v = ((long)((v + step/2) / step)) * step;
/* clamp and store value, update res */
*value = v = CLAMP(v, low, high);
if (last != v)
@@ -1026,15 +1024,15 @@
res |= MU_RES_CHANGE;
/* draw base */
- mu_draw_control_frame(ctx, id, base, MU_COLOR_BASE, opt);
+ mu_draw_control_frame(id, base, MU_COLOR_BASE, opt);
/* draw thumb */
- w = ctx->style->thumb_size;
+ w = mu_style.thumb_size;
normalized = (v - low) / (high - low);
thumb = mu_rect(base.x + normalized * (base.w - w), base.y, w, base.h);
- mu_draw_control_frame(ctx, id, thumb, MU_COLOR_BUTTON, opt);
+ mu_draw_control_frame(id, thumb, MU_COLOR_BUTTON, opt);
/* draw text */
sprint(buf, fmt, v);
- mu_draw_control_text(ctx, buf, base, MU_COLOR_TEXT, opt);
+ mu_draw_control_text(buf, base, MU_COLOR_TEXT, opt);
return res;
}
@@ -1041,31 +1039,31 @@
int
-mu_slider(mu_Context *ctx, float *value, float low, float high)
+mu_slider(float *value, float low, float high)
{- return mu_slider_ex(ctx, value, low, high, 0, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
+ return mu_slider_ex(value, low, high, 0, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
}
int
-mu_number_ex(mu_Context *ctx, float *value, float step, const char *fmt, int opt)
+mu_number_ex(float *value, float step, const char *fmt, int opt)
{char buf[MU_MAX_FMT + 1];
int res = 0;
- mu_Id id = mu_get_id(ctx, &value, sizeof(value));
- mu_Rect base = mu_layout_next(ctx);
+ mu_Id id = mu_get_id(&value, sizeof(value));
+ mu_Rect base = mu_layout_next();
float last = *value;
/* handle text input mode */
- if (number_textbox(ctx, value, base, id))
+ if (number_textbox(value, base, id))
return res;
/* handle normal mode */
- mu_update_control(ctx, id, base, opt);
+ mu_update_control(id, base, opt);
/* handle input */
- if (ctx->focus == id && ctx->mouse_down == MU_MOUSE_LEFT)
- *value += ctx->mouse_delta.x * step;
+ if (mu_ctx.focus == id && mu_ctx.mouse_down == MU_MOUSE_LEFT)
+ *value += mu_ctx.mouse_delta.x * step;
/* set flag if value changed */
if (*value != last)
@@ -1072,10 +1070,10 @@
res |= MU_RES_CHANGE;
/* draw base */
- mu_draw_control_frame(ctx, id, base, MU_COLOR_BASE, opt);
+ mu_draw_control_frame(id, base, MU_COLOR_BASE, opt);
/* draw text */
sprint(buf, fmt, *value);
- mu_draw_control_text(ctx, buf, base, MU_COLOR_TEXT, opt);
+ mu_draw_control_text(buf, base, MU_COLOR_TEXT, opt);
return res;
}
@@ -1082,57 +1080,58 @@
int
-mu_number(mu_Context *ctx, float *value, float step)
+mu_number(float *value, float step)
{- return mu_number_ex(ctx, value, step, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
+ return mu_number_ex(value, step, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
}
static int
-header(mu_Context *ctx, int *state, const char *label, int istreenode)
+header(int *state, const char *label, int istreenode)
{mu_Rect r;
mu_Id id;
int width = -1;
- mu_layout_row(ctx, 1, &width, 0);
- r = mu_layout_next(ctx);
- id = mu_get_id(ctx, &state, sizeof(state));
- mu_update_control(ctx, id, r, 0);
+ mu_layout_row(1, &width, 0);
+ r = mu_layout_next();
+ id = mu_get_id(&state, sizeof(state));
+ mu_update_control(id, r, 0);
/* handle click */
- if (ctx->mouse_pressed == MU_MOUSE_LEFT && ctx->focus == id)
+ if (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id)
*state = !(*state);
/* draw */
if (istreenode) {- if (ctx->hover == id)
- draw_frame(ctx, r, MU_COLOR_BUTTONHOVER);
+ if (mu_ctx.hover == id)
+ draw_frame(r, MU_COLOR_BUTTONHOVER);
} else {- mu_draw_control_frame(ctx, id, r, MU_COLOR_BUTTON, 0);
+ mu_draw_control_frame(id, r, MU_COLOR_BUTTON, 0);
}
mu_draw_icon(
- ctx, *state ? MU_ICON_EXPANDED : MU_ICON_COLLAPSED,
- mu_rect(r.x, r.y, r.h, r.h));
- r.x += r.h - ctx->style->padding;
- r.w -= r.h - ctx->style->padding;
- mu_draw_control_text(ctx, label, r, MU_COLOR_TEXT, 0);
+ *state ? MU_ICON_EXPANDED : MU_ICON_COLLAPSED,
+ mu_rect(r.x, r.y, r.h, r.h)
+ );
+ r.x += r.h - mu_style.padding;
+ r.w -= r.h - mu_style.padding;
+ mu_draw_control_text(label, r, MU_COLOR_TEXT, 0);
return *state ? MU_RES_ACTIVE : 0;
}
int
-mu_header(mu_Context *ctx, int *state, const char *label)
+mu_header(int *state, const char *label)
{- return header(ctx, state, label, 0);
+ return header(state, label, 0);
}
int
-mu_begin_treenode(mu_Context *ctx, int *state, const char *label)
+mu_begin_treenode(int *state, const char *label)
{- int res = header(ctx, state, label, 1);
+ int res = header(state, label, 1);
if (res & MU_RES_ACTIVE) {- get_layout(ctx)->indent += ctx->style->indent;
- mu_push_id(ctx, &state, sizeof(void*));
+ get_layout()->indent += mu_style.indent;
+ mu_push_id(&state, sizeof(void*));
}
return res;
}
@@ -1139,14 +1138,14 @@
void
-mu_end_treenode(mu_Context *ctx)
+mu_end_treenode(void)
{- get_layout(ctx)->indent -= ctx->style->indent;
- mu_pop_id(ctx);
+ get_layout()->indent -= mu_style.indent;
+ mu_pop_id();
}
static void
-scrollbar(mu_Context *ctx, mu_Container *cnt, mu_Rect *b, Point cs, int v)
+scrollbar(mu_Container *cnt, mu_Rect *b, Point cs, int v)
{/* only add scrollbar if content size is larger than body */
int maxscroll = v ? cs.y - b->h : cs.x - b->w;
@@ -1153,25 +1152,25 @@
if (maxscroll > 0 && (v ? b->h : b->x) > 0) {mu_Rect base, thumb;
- mu_Id id = mu_get_id(ctx, v ? "!scrollbary" : "!scrollbarx", 11);
+ mu_Id id = mu_get_id(v ? "!scrollbary" : "!scrollbarx", 11);
/* get sizing / positioning */
base = *b;
if (v) {base.x = b->x + b->w;
- base.w = ctx->style->scrollbar_size;
+ base.w = mu_style.scrollbar_size;
} else {base.y = b->y + b->h;
- base.h = ctx->style->scrollbar_size;
+ base.h = mu_style.scrollbar_size;
}
/* handle input */
- mu_update_control(ctx, id, base, 0);
- if (ctx->focus == id && ctx->mouse_down == MU_MOUSE_LEFT) {+ mu_update_control(id, base, 0);
+ if (mu_ctx.focus == id && mu_ctx.mouse_down == MU_MOUSE_LEFT) {if (v)
- cnt->scroll.y += ctx->mouse_delta.y * cs.y / base.h;
+ cnt->scroll.y += mu_ctx.mouse_delta.y * cs.y / base.h;
else
- cnt->scroll.x += ctx->mouse_delta.x * cs.x / base.w;
+ cnt->scroll.x += mu_ctx.mouse_delta.x * cs.x / base.w;
}
/* clamp scroll to limits */
if (v)
@@ -1180,21 +1179,21 @@
cnt->scroll.x = CLAMP(cnt->scroll.x, 0, maxscroll);
/* draw base and thumb */
- draw_frame(ctx, base, MU_COLOR_SCROLLBASE);
+ draw_frame(base, MU_COLOR_SCROLLBASE);
thumb = base;
if (v) {- thumb.h = MAX(ctx->style->thumb_size, base.h * b->h / cs.y);
+ thumb.h = MAX(mu_style.thumb_size, base.h * b->h / cs.y);
thumb.y += cnt->scroll.y * (base.h - thumb.h) / maxscroll;
} else {- thumb.w = MAX(ctx->style->thumb_size, base.w * b->w / cs.x);
+ thumb.w = MAX(mu_style.thumb_size, base.w * b->w / cs.x);
thumb.x += cnt->scroll.x * (base.w - thumb.w) / maxscroll;
}
- draw_frame(ctx, thumb, MU_COLOR_SCROLLTHUMB);
+ draw_frame(thumb, MU_COLOR_SCROLLTHUMB);
/* set this as the scroll_target (will get scrolled on mousewheel) */
/* if the mouse is over it */
- if (mu_mouse_over(ctx, *b))
- ctx->scroll_target = cnt;
+ if (mu_mouse_over(*b))
+ mu_ctx.scroll_target = cnt;
} else if (v) {cnt->scroll.y = 0;
} else {@@ -1203,13 +1202,13 @@
}
static void
-scrollbars(mu_Context *ctx, mu_Container *cnt, mu_Rect *body)
+scrollbars(mu_Container *cnt, mu_Rect *body)
{- int sz = ctx->style->scrollbar_size;
+ int sz = mu_style.scrollbar_size;
Point cs = cnt->content_size;
- cs.x += ctx->style->padding * 2;
- cs.y += ctx->style->padding * 2;
- mu_push_clip_rect(ctx, *body);
+ cs.x += mu_style.padding * 2;
+ cs.y += mu_style.padding * 2;
+ mu_push_clip_rect(*body);
/* resize body to make room for scrollbars */
if (cs.y > cnt->body.h)
body->w -= sz;
@@ -1217,89 +1216,89 @@
body->h -= sz;
/* to create a horizontal or vertical scrollbar almost-identical code is
** used; only the references to `x|y` `w|h` need to be switched */
- scrollbar(ctx, cnt, body, cs, 1);
- scrollbar(ctx, cnt, body, cs, 0);
- mu_pop_clip_rect(ctx);
+ scrollbar(cnt, body, cs, 1);
+ scrollbar(cnt, body, cs, 0);
+ mu_pop_clip_rect();
}
static void
-push_container_body(mu_Context *ctx, mu_Container *cnt, mu_Rect body, int opt)
+push_container_body(mu_Container *cnt, mu_Rect body, int opt)
{if (~opt & MU_OPT_NOSCROLL)
- scrollbars(ctx, cnt, &body);
- push_layout(ctx, expand_rect(body, -ctx->style->padding), cnt->scroll);
+ scrollbars(cnt, &body);
+ push_layout(expand_rect(body, -mu_style.padding), cnt->scroll);
cnt->body = body;
}
static void
-begin_root_container(mu_Context *ctx, mu_Container *cnt)
+begin_root_container(mu_Container *cnt)
{- push_container(ctx, cnt);
+ push_container(cnt);
/* push container to roots list and push head command */
- buffer_grow(&ctx->root, sizeof(*ctx->root), &ctx->rootmax, ctx->rootnum);
- ctx->root[ctx->rootnum++] = cnt;
- cnt->head = push_jump(ctx, -1);
+ buffer_grow(&mu_ctx.root, sizeof(*mu_ctx.root), &mu_ctx.rootmax, mu_ctx.rootnum);
+ mu_ctx.root[mu_ctx.rootnum++] = cnt;
+ cnt->head = push_jump(-1);
/* set as hover root if the mouse is overlapping this container and it has a
** higher zindex than the current hover root */
- if (rect_overlaps_vec2(cnt->rect, ctx->mouse_pos) && (!ctx->hover_root || cnt->zindex > ctx->hover_root->zindex))
- ctx->hover_root = cnt;
+ if (rect_overlaps_vec2(cnt->rect, mu_ctx.mouse_pos) && (!mu_ctx.hover_root || cnt->zindex > mu_ctx.hover_root->zindex))
+ mu_ctx.hover_root = cnt;
/* clipping is reset here in case a root-container is made within
** another root-containers's begin/end block; this prevents the inner
** root-container being clipped to the outer */
- buffer_grow(&ctx->clip, sizeof(*ctx->clip), &ctx->clipmax, ctx->clipnum);
- ctx->clip[ctx->clipnum++] = unclipped_rect;
+ buffer_grow(&mu_ctx.clip, sizeof(*mu_ctx.clip), &mu_ctx.clipmax, mu_ctx.clipnum);
+ mu_ctx.clip[mu_ctx.clipnum++] = unclipped_rect;
}
static void
-end_root_container(mu_Context *ctx)
+end_root_container(void)
{/* push tail 'goto' jump command and set head 'skip' command. the final steps
** on initing these are done in mu_end() */
- mu_Container *cnt = mu_get_container(ctx);
- cnt->tail = push_jump(ctx, -1);
- ctx->cmds[cnt->head].jump.dst = ctx->cmdsnum;
+ mu_Container *cnt = mu_get_container();
+ cnt->tail = push_jump(-1);
+ mu_ctx.cmds[cnt->head].jump.dst = mu_ctx.cmdsnum;
/* pop base clip rect and container */
- mu_pop_clip_rect(ctx);
- pop_container(ctx);
+ mu_pop_clip_rect();
+ pop_container();
}
int
-mu_begin_window_ex(mu_Context *ctx, mu_Container *cnt, const char *title, int opt)
+mu_begin_window_ex(mu_Container *cnt, const char *title, int opt)
{mu_Rect rect, body, titlerect;
if (!cnt->inited)
- mu_init_window(ctx, cnt, opt);
+ mu_init_window(cnt, opt);
if (!cnt->open)
return 0;
- begin_root_container(ctx, cnt);
+ begin_root_container(cnt);
rect = cnt->rect;
body = rect;
/* draw frame */
if (~opt & MU_OPT_NOFRAME)
- draw_frame(ctx, rect, MU_COLOR_WINDOWBG);
+ draw_frame(rect, MU_COLOR_WINDOWBG);
/* do title bar */
titlerect = rect;
- titlerect.h = ctx->style->title_height;
+ titlerect.h = mu_style.title_height;
if (~opt & MU_OPT_NOTITLE) {- draw_frame(ctx, titlerect, MU_COLOR_TITLEBG);
+ draw_frame(titlerect, MU_COLOR_TITLEBG);
/* do title text */
if (~opt & MU_OPT_NOTITLE) {- mu_Id id = mu_get_id(ctx, "!title", 6);
- mu_update_control(ctx, id, titlerect, opt);
- mu_draw_control_text(ctx, title, titlerect, MU_COLOR_TITLETEXT, opt);
- if (id == ctx->focus && ctx->mouse_down == MU_MOUSE_LEFT) {- cnt->rect.x += ctx->mouse_delta.x;
- cnt->rect.y += ctx->mouse_delta.y;
+ mu_Id id = mu_get_id("!title", 6);+ mu_update_control(id, titlerect, opt);
+ mu_draw_control_text(title, titlerect, MU_COLOR_TITLETEXT, opt);
+ if (id == mu_ctx.focus && mu_ctx.mouse_down == MU_MOUSE_LEFT) {+ cnt->rect.x += mu_ctx.mouse_delta.x;
+ cnt->rect.y += mu_ctx.mouse_delta.y;
}
body.y += titlerect.h;
body.h -= titlerect.h;
@@ -1307,151 +1306,145 @@
/* do `close` button */
if (~opt & MU_OPT_NOCLOSE) {- mu_Id id = mu_get_id(ctx, "!close", 6);
+ mu_Id id = mu_get_id("!close", 6);mu_Rect r = mu_rect(
titlerect.x + titlerect.w - titlerect.h,
titlerect.y, titlerect.h, titlerect.h
);
titlerect.w -= r.w;
- mu_draw_icon(ctx, MU_ICON_CLOSE, r);
- mu_update_control(ctx, id, r, opt);
- if (ctx->mouse_pressed == MU_MOUSE_LEFT && id == ctx->focus)
+ mu_draw_icon(MU_ICON_CLOSE, r);
+ mu_update_control(id, r, opt);
+ if (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && id == mu_ctx.focus)
cnt->open = 0;
}
}
- push_container_body(ctx, cnt, body, opt);
+ push_container_body(cnt, body, opt);
/* do `resize` handle */
if (~opt & MU_OPT_NORESIZE) {- int sz = ctx->style->scrollbar_size;
- mu_Id id = mu_get_id(ctx, "!resize", 7);
+ int sz = mu_style.scrollbar_size;
+ mu_Id id = mu_get_id("!resize", 7);mu_Rect r = mu_rect(rect.x + rect.w - sz, rect.y + rect.h - sz, sz, sz);
- mu_update_control(ctx, id, r, opt);
- mu_draw_icon(ctx, MU_ICON_RESIZE, r);
- if (id == ctx->focus && ctx->mouse_down == MU_MOUSE_LEFT) {- cnt->rect.w = MAX(96, cnt->rect.w + ctx->mouse_delta.x);
- cnt->rect.h = MAX(64, cnt->rect.h + ctx->mouse_delta.y);
+ mu_update_control(id, r, opt);
+ mu_draw_icon(MU_ICON_RESIZE, r);
+ if (id == mu_ctx.focus && mu_ctx.mouse_down == MU_MOUSE_LEFT) {+ cnt->rect.w = MAX(96, cnt->rect.w + mu_ctx.mouse_delta.x);
+ cnt->rect.h = MAX(64, cnt->rect.h + mu_ctx.mouse_delta.y);
}
}
/* resize to content size */
if (opt & MU_OPT_AUTOSIZE) {- mu_Rect r = get_layout(ctx)->body;
+ mu_Rect r = get_layout()->body;
cnt->rect.w = cnt->content_size.x + (cnt->rect.w - r.w);
cnt->rect.h = cnt->content_size.y + (cnt->rect.h - r.h);
}
/* close if this is a popup window and elsewhere was clicked */
- if (opt & MU_OPT_POPUP && ctx->mouse_pressed && ctx->last_hover_root != cnt)
+ if (opt & MU_OPT_POPUP && mu_ctx.mouse_pressed && mu_ctx.last_hover_root != cnt)
cnt->open = 0;
- mu_push_clip_rect(ctx, cnt->body);
+ mu_push_clip_rect(cnt->body);
return MU_RES_ACTIVE;
}
int
-mu_begin_window(mu_Context *ctx, mu_Container *cnt, const char *title)
+mu_begin_window(mu_Container *cnt, const char *title)
{- return mu_begin_window_ex(ctx, cnt, title, 0);
+ return mu_begin_window_ex(cnt, title, 0);
}
void
-mu_end_window(mu_Context *ctx)
+mu_end_window(void)
{- mu_pop_clip_rect(ctx);
- end_root_container(ctx);
+ mu_pop_clip_rect();
+ end_root_container();
}
void
-mu_open_popup(mu_Context *ctx, mu_Container *cnt)
+mu_open_popup(mu_Container *cnt)
{/* set as hover root so popup isn't closed in begin_window_ex() */
- ctx->last_hover_root = ctx->hover_root = cnt;
+ mu_ctx.last_hover_root = mu_ctx.hover_root = cnt;
/* init container if not inited */
if (!cnt->inited)
- mu_init_window(ctx, cnt, 0);
+ mu_init_window(cnt, 0);
/* position at mouse cursor, open and bring-to-front */
- cnt->rect = mu_rect(ctx->mouse_pos.x, ctx->mouse_pos.y, 0, 0);
+ cnt->rect = mu_rect(mu_ctx.mouse_pos.x, mu_ctx.mouse_pos.y, 0, 0);
cnt->open = 1;
- mu_bring_to_front(ctx, cnt);
+ mu_bring_to_front(cnt);
}
int
-mu_begin_popup(mu_Context *ctx, mu_Container *cnt)
+mu_begin_popup(mu_Container *cnt)
{- return mu_begin_window_ex(
- ctx,
- cnt,
- "",
- MU_OPT_POPUP | MU_OPT_AUTOSIZE | MU_OPT_NORESIZE | MU_OPT_NOSCROLL | MU_OPT_NOTITLE | MU_OPT_CLOSED
- );
+ return mu_begin_window_ex(cnt, "", MU_OPT_POPUP | MU_OPT_AUTOSIZE | MU_OPT_NORESIZE | MU_OPT_NOSCROLL | MU_OPT_NOTITLE | MU_OPT_CLOSED);
}
void
-mu_end_popup(mu_Context *ctx)
+mu_end_popup(void)
{- mu_end_window(ctx);
+ mu_end_window();
}
void
-mu_begin_panel_ex(mu_Context *ctx, mu_Container *cnt, int opt)
+mu_begin_panel_ex(mu_Container *cnt, int opt)
{- cnt->rect = mu_layout_next(ctx);
+ cnt->rect = mu_layout_next();
if (~opt & MU_OPT_NOFRAME)
- draw_frame(ctx, cnt->rect, MU_COLOR_PANELBG);
+ draw_frame(cnt->rect, MU_COLOR_PANELBG);
- push_container(ctx, cnt);
- push_container_body(ctx, cnt, cnt->rect, opt);
- mu_push_clip_rect(ctx, cnt->body);
+ push_container(cnt);
+ push_container_body(cnt, cnt->rect, opt);
+ mu_push_clip_rect(cnt->body);
}
void
-mu_begin_panel(mu_Context *ctx, mu_Container *cnt)
+mu_begin_panel(mu_Container *cnt)
{- mu_begin_panel_ex(ctx, cnt, 0);
+ mu_begin_panel_ex(cnt, 0);
}
void
-mu_end_panel(mu_Context *ctx)
+mu_end_panel(void)
{- mu_pop_clip_rect(ctx);
- pop_container(ctx);
+ mu_pop_clip_rect();
+ pop_container();
}
int
-mu_render(mu_Context *ctx)
+mu_render(void)
{mu_Command *cmd;
mu_Rect r, iconr;
- if (memcmp(&ctx->screen, &screen->r, sizeof(ctx->screen)) != 0)
- ctx->screen = screen->r;
- else if (ctx->oldcmdsnum == ctx->cmdsnum && memcmp(ctx->oldcmds, ctx->cmds, ctx->cmdsnum*sizeof(mu_Command)) == 0)
+ if (memcmp(&mu_ctx.screen, &screen->r, sizeof(mu_ctx.screen)) != 0)
+ mu_ctx.screen = screen->r;
+ else if (mu_ctx.oldcmdsnum == mu_ctx.cmdsnum && memcmp(mu_ctx.oldcmds, mu_ctx.cmds, mu_ctx.cmdsnum*sizeof(mu_Command)) == 0)
return 0;
- if (ctx->oldcmdsmax != ctx->cmdsmax && (ctx->oldcmds = realloc(ctx->oldcmds, ctx->cmdsmax*sizeof(mu_Command))) == nil)
+ if (mu_ctx.oldcmdsmax != mu_ctx.cmdsmax && (mu_ctx.oldcmds = realloc(mu_ctx.oldcmds, mu_ctx.cmdsmax*sizeof(mu_Command))) == nil)
sysfatal("couldn't allocate memory for old cmds");- ctx->oldcmdsmax = ctx->cmdsmax;
- ctx->oldcmdsnum = ctx->cmdsnum;
- memmove(ctx->oldcmds, ctx->cmds, ctx->cmdsnum*sizeof(mu_Command));
+ mu_ctx.oldcmdsmax = mu_ctx.cmdsmax;
+ mu_ctx.oldcmdsnum = mu_ctx.cmdsnum;
+ memmove(mu_ctx.oldcmds, mu_ctx.cmds, mu_ctx.cmdsnum*sizeof(mu_Command));
- if (ctx->style->colors[MU_COLOR_BG] != nil)
- draw(screen, screen->r, ctx->style->colors[MU_COLOR_BG], nil, ZP);
+ draw(screen, screen->r, mu_style.colors[MU_COLOR_BG], nil, ZP);
- for (cmd = ctx->cmds; cmd < ctx->cmds + ctx->cmdsnum;) {+ for (cmd = mu_ctx.cmds; cmd < mu_ctx.cmds + mu_ctx.cmdsnum;) { switch (cmd->type) {case MU_COMMAND_TEXT:
if (cmd->text.color != nil)
- string(screen, addpt(screen->r.min, cmd->text.pos), cmd->text.color, ZP, ctx->style->font, ctx->str+cmd->text.s);
+ string(screen, addpt(screen->r.min, cmd->text.pos), cmd->text.color, ZP, mu_style.font, mu_ctx.str+cmd->text.s);
break;
case MU_COMMAND_RECT:
@@ -1476,7 +1469,7 @@
case MU_COMMAND_JUMP:
if (cmd->jump.dst < 0)
return 1;
- cmd = &ctx->cmds[cmd->jump.dst];
+ cmd = &mu_ctx.cmds[cmd->jump.dst];
continue;
}
--- a/microui.h
+++ b/microui.h
@@ -196,8 +196,6 @@
struct mu_Context
{/* core state */
- mu_Style _style;
- mu_Style *style;
mu_Id hover;
mu_Id focus;
mu_Id last_id;
@@ -248,75 +246,77 @@
extern Image *atlasimage;
extern mu_Rect *atlasicons;
extern u8int defaultcolors[MU_COLOR_MAX][4];
+extern mu_Context mu_ctx;
+extern mu_Style mu_style;
mu_Rect mu_rect(int x, int y, int w, int h);
Image *mu_color(u8int r, u8int g, u8int b, u8int a);
-void mu_init(mu_Context *ctx);
-int mu_render(mu_Context *ctx);
-void mu_begin(mu_Context *ctx);
-void mu_end(mu_Context *ctx);
-void mu_set_focus(mu_Context *ctx, mu_Id id);
-mu_Id mu_get_id(mu_Context *ctx, const void *data, int size);
-void mu_push_id(mu_Context *ctx, const void *data, int size);
-void mu_pop_id(mu_Context *ctx);
-void mu_push_clip_rect(mu_Context *ctx, mu_Rect rect);
-void mu_pop_clip_rect(mu_Context *ctx);
-mu_Rect mu_get_clip_rect(mu_Context *ctx);
-int mu_check_clip(mu_Context *ctx, mu_Rect r);
-mu_Container* mu_get_container(mu_Context *ctx);
-void mu_init_window(mu_Context *ctx, mu_Container *cnt, int opt);
-void mu_bring_to_front(mu_Context *ctx, mu_Container *cnt);
+void mu_init(void);
+int mu_render(void);
+void mu_begin(void);
+void mu_end(void);
+void mu_set_focus(mu_Id id);
+mu_Id mu_get_id(const void *data, int size);
+void mu_push_id(const void *data, int size);
+void mu_pop_id(void);
+void mu_push_clip_rect(mu_Rect rect);
+void mu_pop_clip_rect(void);
+mu_Rect mu_get_clip_rect(void);
+int mu_check_clip(mu_Rect r);
+mu_Container *mu_get_container(void);
+void mu_init_window(mu_Container *cnt, int opt);
+void mu_bring_to_front(mu_Container *cnt);
-void mu_input_mousemove(mu_Context *ctx, int x, int y);
-void mu_input_mousedown(mu_Context *ctx, int x, int y, int btn);
-void mu_input_mouseup(mu_Context *ctx, int x, int y, int btn);
-void mu_input_scroll(mu_Context *ctx, int x, int y);
-void mu_input_keydown(mu_Context *ctx, int key);
-void mu_input_keyup(mu_Context *ctx, int key);
-void mu_input_text(mu_Context *ctx, const char *text);
+void mu_input_mousemove(int x, int y);
+void mu_input_mousedown(int x, int y, int btn);
+void mu_input_mouseup(int x, int y, int btn);
+void mu_input_scroll(int x, int y);
+void mu_input_keydown(int key);
+void mu_input_keyup(int key);
+void mu_input_text(const char *text);
-mu_Command *mu_push_command(mu_Context *ctx, int type);
-void mu_set_clip(mu_Context *ctx, mu_Rect rect);
-void mu_draw_rect(mu_Context *ctx, mu_Rect rect, Image *color);
-void mu_draw_box(mu_Context *ctx, mu_Rect rect, Image *color);
-void mu_draw_text(mu_Context *ctx, Font *font, const char *str, int len, Point pos, Image *color);
-void mu_draw_icon(mu_Context *ctx, int id, mu_Rect rect);
+mu_Command *mu_push_command(int type);
+void mu_set_clip(mu_Rect rect);
+void mu_draw_rect(mu_Rect rect, Image *color);
+void mu_draw_box(mu_Rect rect, Image *color);
+void mu_draw_text(Font *font, const char *str, int len, Point pos, Image *color);
+void mu_draw_icon(int id, mu_Rect rect);
-void mu_layout_row(mu_Context *ctx, int items, const int *widths, int height);
-void mu_layout_width(mu_Context *ctx, int width);
-void mu_layout_height(mu_Context *ctx, int height);
-void mu_layout_begin_column(mu_Context *ctx);
-void mu_layout_end_column(mu_Context *ctx);
-void mu_layout_set_next(mu_Context *ctx, mu_Rect r, int relative);
-mu_Rect mu_layout_next(mu_Context *ctx);
+void mu_layout_row(int items, const int *widths, int height);
+void mu_layout_width(int width);
+void mu_layout_height(int height);
+void mu_layout_begin_column(void);
+void mu_layout_end_column(void);
+void mu_layout_set_next(mu_Rect r, int relative);
+mu_Rect mu_layout_next(void);
-void mu_draw_control_frame(mu_Context *ctx, mu_Id id, mu_Rect rect, int colorid, int opt);
-void mu_draw_control_text(mu_Context *ctx, const char *str, mu_Rect rect, int colorid, int opt);
-int mu_mouse_over(mu_Context *ctx, mu_Rect rect);
-void mu_update_control(mu_Context *ctx, mu_Id id, mu_Rect rect, int opt);
+void mu_draw_control_frame(mu_Id id, mu_Rect rect, int colorid, int opt);
+void mu_draw_control_text(const char *str, mu_Rect rect, int colorid, int opt);
+int mu_mouse_over(mu_Rect rect);
+void mu_update_control(mu_Id id, mu_Rect rect, int opt);
-void mu_text(mu_Context *ctx, const char *text);
-void mu_label(mu_Context *ctx, const char *text);
-int mu_button_ex(mu_Context *ctx, const char *label, int icon, int opt);
-int mu_button(mu_Context *ctx, const char *label);
-int mu_checkbox(mu_Context *ctx, int *state, const char *label);
-int mu_textbox_raw(mu_Context *ctx, char *buf, int bufsz, mu_Id id, mu_Rect r, int opt);
-int mu_textbox_ex(mu_Context *ctx, char *buf, int bufsz, int opt);
-int mu_textbox(mu_Context *ctx, char *buf, int bufsz);
-int mu_slider_ex(mu_Context *ctx, float *value, float low, float high, float step, const char *fmt, int opt);
-int mu_slider(mu_Context *ctx, float *value, float low, float high);
-int mu_number_ex(mu_Context *ctx, float *value, float step, const char *fmt, int opt);
-int mu_number(mu_Context *ctx, float *value, float step);
-int mu_header(mu_Context *ctx, int *state, const char *label);
-int mu_begin_treenode(mu_Context *ctx, int *state, const char *label);
-void mu_end_treenode(mu_Context *ctx);
-int mu_begin_window_ex(mu_Context *ctx, mu_Container *cnt, const char *title, int opt);
-int mu_begin_window(mu_Context *ctx, mu_Container *cnt, const char *title);
-void mu_end_window(mu_Context *ctx);
-void mu_open_popup(mu_Context *ctx, mu_Container *cnt);
-int mu_begin_popup(mu_Context *ctx, mu_Container *cnt);
-void mu_end_popup(mu_Context *ctx);
-void mu_begin_panel_ex(mu_Context *ctx, mu_Container *cnt, int opt);
-void mu_begin_panel(mu_Context *ctx, mu_Container *cnt);
-void mu_end_panel(mu_Context *ctx);
+void mu_text(const char *text);
+void mu_label(const char *text);
+int mu_button_ex(const char *label, int icon, int opt);
+int mu_button(const char *label);
+int mu_checkbox(int *state, const char *label);
+int mu_textbox_raw(char *buf, int bufsz, mu_Id id, mu_Rect r, int opt);
+int mu_textbox_ex(char *buf, int bufsz, int opt);
+int mu_textbox(char *buf, int bufsz);
+int mu_slider_ex(float *value, float low, float high, float step, const char *fmt, int opt);
+int mu_slider(float *value, float low, float high);
+int mu_number_ex(float *value, float step, const char *fmt, int opt);
+int mu_number(float *value, float step);
+int mu_header(int *state, const char *label);
+int mu_begin_treenode(int *state, const char *label);
+void mu_end_treenode(void);
+int mu_begin_window_ex(mu_Container *cnt, const char *title, int opt);
+int mu_begin_window(mu_Container *cnt, const char *title);
+void mu_end_window(void);
+void mu_open_popup(mu_Container *cnt);
+int mu_begin_popup(mu_Container *cnt);
+void mu_end_popup(void);
+void mu_begin_panel_ex(mu_Container *cnt, int opt);
+void mu_begin_panel(mu_Container *cnt);
+void mu_end_panel(void);