shithub: neindaw

ref: 798c452b3e1a7cba4b9f1b844cf97064cd06caa8
dir: /microui/microui.c/

View raw version
#include <u.h>
#include <libc.h>
#include <draw.h>
#include <microui.h>

#define MU_REAL_FMT "%g"
#define MU_SLIDER_FMT "%.2f"

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define CLAMP(x, a, b) MIN(b, MAX(a, x))

static mu_Rect unclipped_rect = { 0, 0, 0x1000000, 0x1000000 };

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,
	0x20, 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x33, 0x34, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x32, 0x35, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	0x32, 0x35, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x34, 0x33, 0x39, 0x20, 0x80,
	0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x78, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c,
	0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x34, 0x00, 0x80,
	0x14, 0x00, 0x00, 0x80, 0x5c, 0x00, 0x00, 0x54, 0x1f, 0x04, 0x1b, 0x04, 0x23, 0x24, 0x13, 0x7c,
	0x00, 0x3c, 0x00, 0x80, 0x20, 0x00, 0x00, 0x80, 0xc0, 0x00, 0x00, 0x04, 0x07, 0x44, 0x1f, 0x80,
	0x5e, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00, 0x80, 0x70, 0x00, 0x00, 0x34, 0x1b, 0x04, 0x13, 0x04,
	0x1b, 0x04, 0x23, 0x24, 0x17, 0x7c, 0x00, 0x2c, 0x00, 0x80, 0x21, 0x00, 0x00, 0x80, 0xe0, 0x00,
	0x00, 0x80, 0xea, 0x00, 0x00, 0x80, 0x2c, 0x00, 0x00, 0x54, 0x27, 0x14, 0x6f, 0x24, 0x8b, 0x44,
	0x13, 0x14, 0x00, 0x7c, 0x00, 0x4c, 0x83, 0x80, 0x2d, 0x00, 0x00, 0x74, 0x2f, 0x24, 0x77, 0x74,
	0x83, 0x7c, 0x00, 0x1c, 0x83, 0x80, 0xe1, 0x00, 0x00, 0x80, 0xeb, 0x00, 0x00, 0x7c, 0x83, 0x3c,
	0x8b, 0x74, 0x83, 0x24, 0x00, 0x80, 0x0e, 0x00, 0x00, 0x7c, 0x83, 0x7c, 0x83, 0x7c, 0x87, 0x3c,
	0x00, 0x14, 0x00, 0x80, 0x3d, 0x00, 0x00, 0x80, 0xed, 0x00, 0x00, 0x80, 0x45, 0x00, 0x00, 0x24,
	0x17, 0x80, 0x22, 0x00, 0x00, 0x7c, 0x83, 0x7d, 0x97, 0x75, 0x97, 0x14, 0x00, 0x80, 0x13, 0x00,
	0x00, 0x80, 0xd0, 0x00, 0x00, 0x80, 0xf6, 0x00, 0x00, 0x14, 0x8b, 0x24, 0x83, 0x80, 0x2e, 0x00,
	0x00, 0x7c, 0x79, 0x7e, 0xa7, 0x54, 0x8b, 0x54, 0x8b, 0x80, 0x63, 0x00, 0x00, 0x7c, 0x83, 0x4c,
	0x00, 0x7f, 0xb7, 0x3f, 0xb7, 0x54, 0x8b, 0x04, 0x2b, 0x80, 0xec, 0x00, 0x00, 0x7c, 0x83, 0x3c,
	0x00, 0x80, 0x14, 0x00, 0x00, 0x80, 0x5c, 0x00, 0x00, 0x54, 0x1f, 0x04, 0x1b, 0x04, 0x23, 0x24,
	0x13, 0x54, 0x8b, 0x80, 0xbc, 0x00, 0x00, 0x7c, 0x83, 0x7c, 0x00, 0x7c, 0x00, 0x0c, 0x00, 0x7c,
	0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c,
	0x00, 0x7c, 0x00, 0x64, 0x00, 0x80, 0x5a, 0x00, 0x00, 0x06, 0x6b, 0x14, 0x07, 0x80, 0x8f, 0x00,
	0x00, 0x44, 0x27, 0x7c, 0x00, 0x7c, 0x00, 0x64, 0x00, 0x80, 0x3c, 0x00, 0x00, 0x80, 0xaa, 0x00,
	0x00, 0x04, 0x07, 0x04, 0x83, 0x54, 0x8b, 0x44, 0x17, 0x14, 0x2f, 0x7c, 0x65, 0x7c, 0x00, 0x34,
	0x00, 0x54, 0x8b, 0x34, 0x17, 0x64, 0xb3, 0x7c, 0x00, 0x0c, 0x00, 0x80, 0x6e, 0x00, 0x00, 0x05,
	0x03, 0x35, 0x0f, 0x64, 0x8b, 0x34, 0x17, 0x7c, 0x83, 0x7c, 0x00, 0x80, 0xa5, 0x00, 0x00, 0x15,
	0x4f, 0x26, 0x1f, 0x64, 0x83, 0x74, 0xa3, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x63, 0x81, 0x00, 0x00,
	0x34, 0x27, 0x7c, 0x4d, 0x4c, 0x00, 0x80, 0x55, 0x00, 0x00, 0x80, 0x37, 0x00, 0x00, 0x04, 0x0b,
	0x04, 0x07, 0x04, 0x0f, 0x04, 0x0b, 0x80, 0x1e, 0x00, 0x00, 0x04, 0x0b, 0x04, 0x07, 0x64, 0x83,
	0x7c, 0x00, 0x7c, 0x00, 0x16, 0xef, 0x05, 0x8f, 0x75, 0x97, 0x54, 0x00, 0x7c, 0x00, 0x7c, 0x00,
	0x7d, 0x0f, 0x0d, 0x0f, 0x64, 0x3f,
};

static mu_Rect default_atlas_icons[] = {
	[MU_ICON_CHECK] = {0, 0, 18, 18},
	[MU_ICON_CLOSE] = {18, 0, 16, 16},
	[MU_ICON_COLLAPSED] = {27, 16, 5, 7},
	[MU_ICON_EXPANDED] = {0, 18, 7, 5},
	[MU_ICON_RESIZE] = {18, 16, 9, 9},
	[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] = {
	[MU_COLOR_BG] = {119, 119, 119, 255},
	[MU_COLOR_TEXT] = {230, 230, 230, 255},
	[MU_COLOR_BORDER] = {25, 25, 25, 255},
	[MU_COLOR_WINDOWBG] = {50, 50, 50, 255},
	[MU_COLOR_TITLEBG] = {25, 25, 25, 255},
	[MU_COLOR_TITLETEXT] = {240, 240, 240, 255},
	[MU_COLOR_PANELBG] = {0, 0, 0, 0},
	[MU_COLOR_BUTTON] = {75, 75, 75, 255},
	[MU_COLOR_BUTTONHOVER] = {95, 95, 95, 255},
	[MU_COLOR_BUTTONFOCUS] = {115, 115, 115, 255},
	[MU_COLOR_BASE] = {30, 30, 30, 255},
	[MU_COLOR_BASEHOVER] = {35, 35, 35, 255},
	[MU_COLOR_BASEFOCUS] = {40, 40, 40, 255},
	[MU_COLOR_SCROLLBASE] = {43, 43, 43, 255},
	[MU_COLOR_SCROLLTHUMB] = {30, 30, 30, 255},
};

static void
buffer_grow(void **buf, int onesz, int *bufmax, int bufnum)
{
	while (*bufmax <= bufnum) {
		*bufmax = MAX(16, *bufmax) * 2;
		if ((*buf = realloc(*buf, *bufmax*onesz)) == nil)
			sysfatal("not enough memory for %d items (%d bytes)", *bufmax, *bufmax*onesz);
	}
}

mu_Rect
mu_rect(int x, int y, int w, int h)
{
	mu_Rect res;
	res.x = x, res.y = y, res.w = w, res.h = h;
	return res;
}

Image *
mu_color(u8int r, u8int g, u8int b, u8int a)
{
	Image *c;
	if ((c = allocimage(display, Rect(0, 0, 1, 1), RGBA32, 1, setalpha(r<<24 | g<<16 | b<<8, a))) == nil)
		sysfatal("couldn't allocate color");
	return c;
}

static Rectangle
screenrect(mu_Rect r)
{
	Rectangle rect;
	rect.min = screen->r.min;
	rect.min.x += r.x;
	rect.min.y += r.y;
	rect.max = rect.min;
	rect.max.x += r.w;
	rect.max.y += r.h;
	return rect;
}

static mu_Rect
expand_rect(mu_Rect rect, int n) {
	return mu_rect(rect.x - n, rect.y - n, rect.w + n * 2, rect.h + n * 2);
}


static mu_Rect
clip_rect(mu_Rect r1, mu_Rect r2)
{
	int x1 = MAX(r1.x, r2.x);
	int y1 = MAX(r1.y, r2.y);
	int x2 = MAX(MIN(r1.x + r1.w, r2.x + r2.w), x1);
	int y2 = MAX(MIN(r1.y + r1.h, r2.y + r2.h), y1);
	return mu_rect(x1, y1, x2 - x1, y2 - y1);
}


static int
rect_overlaps_vec2(mu_Rect r, Point p)
{
	return p.x >= r.x && p.x < r.x + r.w && p.y >= r.y && p.y < r.y + r.h;
}

static void
draw_frame(mu_Rect rect, int 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(expand_rect(rect, 1), mu_style.colors[MU_COLOR_BORDER]);
}

static int
text_width(Font *font, const char *text, int len)
{
	return stringnwidth(font, text, len >= 0 ? len : strlen(text));
}

void
mu_init(void)
{
	Rectangle r;
	int res, i;

	if (atlasimage == nil) {
		r = Rect(0, 0, atlasicons[ATLAS_DIMENSIONS].w, atlasicons[ATLAS_DIMENSIONS].h);
		atlasimage = allocimage(display, r, RGBA32, 1, DTransparent);
		if (memcmp(atlasraw, "compressed\n", 11) == 0)
			res = cloadimage(atlasimage, r, atlasraw+11+5*12, sizeof(atlasraw)-11-5*12);
		else
			res = loadimage(atlasimage, r, atlasraw, sizeof(atlasraw));
		if (res < 0)
			sysfatal("failed to load atlas: %r");
	}

	if (mu_style.colors[0] == nil) {
		for (i = 0; i < MU_COLOR_MAX; i++) {
			mu_style.colors[i] = mu_color(
				defaultcolors[i][0],
				defaultcolors[i][1],
				defaultcolors[i][2],
				defaultcolors[i][3]
			);
		}
	}
}

void
mu_begin(void)
{
	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;
}

void
mu_end(void)
{
	int i, n;
	/* check stacks */
	assert(mu_ctx.cntnum == 0);
	assert(mu_ctx.clipnum == 0);
	assert(mu_ctx.idsnum == 0);
	assert(mu_ctx.layoutsnum == 0);

	/* handle scroll input */
	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 (!mu_ctx.updated_focus)
		mu_ctx.focus = 0;
	mu_ctx.updated_focus = 0;

	/* bring hover root to front if mouse was pressed */
	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 */
	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 = 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 = 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)
			mu_ctx.cmds[0].jump.dst = cnt->head + 1;
		else
			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)
			mu_ctx.cmds[cnt->tail].jump.dst = mu_ctx.cmdsnum;
	}
}


void
mu_set_focus(mu_Id id)
{
	mu_ctx.focus = id;
	mu_ctx.updated_focus = 1;
}

/* 32bit fnv-1a hash */
#define HASH_INITIAL 2166136261

static void
hash(mu_Id *hash, const void *data, int size)
{
	const unsigned char *p = data;
	while (size--) {
		*hash = (*hash ^ *p++) * 16777619;
	}
}


mu_Id
mu_get_id(const void *data, int size)
{
	int idx = mu_ctx.idsnum;
	mu_Id res = (idx > 0) ? mu_ctx.ids[idx - 1] : HASH_INITIAL;
	hash(&res, data, size);
	mu_ctx.last_id = res;
	return res;
}


void
mu_push_id(const void *data, int 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(void)
{
	mu_ctx.idsnum--;
}

void
mu_push_clip_rect(mu_Rect rect)
{
	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(void)
{
	mu_ctx.clipnum--;
}


mu_Rect
mu_get_clip_rect(void)
{
	assert(mu_ctx.clipnum > 0);
	return mu_ctx.clip[mu_ctx.clipnum - 1];
}


int
mu_check_clip(mu_Rect r)
{
	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)
		return MU_CLIP_NONE;
	return MU_CLIP_PART;
}


static void
push_layout(mu_Rect body, Point scroll)
{
	mu_Layout layout;
	int width = 0;
	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(&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(void)
{
	return &mu_ctx.layouts[mu_ctx.layoutsnum - 1];
}


static void
push_container(mu_Container *cnt)
{
	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(void)
{
	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;
	mu_ctx.cntnum--;
	mu_ctx.layoutsnum--;
	mu_pop_id();
}


mu_Container *
mu_get_container(void)
{
	assert(mu_ctx.cntnum > 0);
	return mu_ctx.cnt[mu_ctx.cntnum - 1];
}


void
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(cnt);
}


void
mu_bring_to_front(mu_Container *cnt)
{
	cnt->zindex = ++mu_ctx.last_zindex;
}


/*============================================================================
** input handlers
**============================================================================*/

void
mu_input_mousemove(int x, int y)
{
	mu_ctx.mouse_pos = Pt(x, y);
}


void
mu_input_mousedown(int x, int y, int btn)
{
	mu_input_mousemove(x, y);
	mu_ctx.mouse_down |= btn;
	mu_ctx.mouse_pressed |= btn;
}


void
mu_input_mouseup(int x, int y, int btn)
{
	mu_input_mousemove(x, y);
	mu_ctx.mouse_down &= ~btn;
}


void
mu_input_scroll(int x, int y)
{
	mu_ctx.scroll_delta.x += x;
	mu_ctx.scroll_delta.y += y;
}


void
mu_input_keydown(int key)
{
	mu_ctx.key_pressed |= key;
	mu_ctx.key_down |= key;
}


void
mu_input_keyup(int key)
{
	mu_ctx.key_down &= ~key;
}


void
mu_input_text(const char *text)
{
	int len = strlen(mu_ctx.text_input);
	int size = strlen(text) + 1;
	assert(len + size <= (int) sizeof(mu_ctx.text_input));
	memcpy(mu_ctx.text_input + len, text, size);
}

/*============================================================================
** commandlist
**============================================================================*/

mu_Command *
mu_push_command(int type)
{
	mu_Command *cmd;

	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;

	return cmd;
}

static int
push_jump(int dst)
{
	mu_Command *cmd;
	cmd = mu_push_command(MU_COMMAND_JUMP);
	cmd->jump.dst = dst;
	return mu_ctx.cmdsnum-1;
}

void
mu_set_clip(mu_Rect rect)
{
	mu_Command *cmd;
	cmd = mu_push_command(MU_COMMAND_CLIP);
	cmd->clip.rect = rect;
}

void
mu_draw_rect(mu_Rect rect, Image *color)
{
	mu_Command *cmd;
	rect = clip_rect(rect, mu_get_clip_rect());
	if (rect.w > 0 && rect.h > 0) {
		cmd = mu_push_command(MU_COMMAND_RECT);
		cmd->rect.rect = rect;
		cmd->rect.color = color;
	}
}

void
mu_draw_box(mu_Rect rect, Image *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(Font *font, const char *s, int len, Point pos, Image *color)
{
	mu_Command *cmd;
	mu_Rect rect;
	int clipped;

	if (len < 0)
		len = strlen(s);
	rect = mu_rect(pos.x, pos.y, text_width(font, s, len), font->height);
	clipped = mu_check_clip(rect);

	if (clipped == MU_CLIP_ALL )
		return;
	if (clipped == MU_CLIP_PART)
		mu_set_clip(mu_get_clip_rect());

	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(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;

	/* reset clipping if it was set */
	if (clipped)
		mu_set_clip(unclipped_rect);
}


void
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(rect);
	if (clipped == MU_CLIP_ALL )
		return;
	if (clipped == MU_CLIP_PART)
		mu_set_clip(mu_get_clip_rect());
	/* do icon command */
	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(unclipped_rect);
}


/*============================================================================
** layout
**============================================================================*/

enum
{
	RELATIVE = 1,
	ABSOLUTE,
};


void
mu_layout_begin_column(void)
{
	push_layout(mu_layout_next(), ZP);
}


void
mu_layout_end_column(void)
{
	mu_Layout *a, *b;
	b = get_layout();
	mu_ctx.layoutsnum--;
	/* inherit position/next_row/max from child layout if they are greater */
	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);
	a->max.y = MAX(a->max.y, b->max.y);
}


void
mu_layout_row(int items, const int *widths, int height)
{
	mu_Layout *layout = get_layout();
	if (widths) {
		assert(items <= MU_MAX_WIDTHS);
		memcpy(layout->widths, widths, items * sizeof(widths[0]));
	}
	layout->items = items;
	layout->position = Pt(layout->indent, layout->next_row);
	layout->size.y = height;
	layout->row_index = 0;
}


void
mu_layout_width(int width)
{
	get_layout()->size.x = width;
}


void
mu_layout_height(int height)
{
	get_layout()->size.y = height;
}


void
mu_layout_set_next(mu_Rect r, int relative)
{
	mu_Layout *layout = get_layout();
	layout->next = r;
	layout->next_type = relative ? RELATIVE : ABSOLUTE;
}


mu_Rect
mu_layout_next(void)
{
	mu_Layout *layout = get_layout();
	mu_Rect res;

	if (layout->next_type) {
		/* handle rect set by `mu_layout_set_next` */
		int type = layout->next_type;
		layout->next_type = 0;
		res = layout->next;
		if (type == ABSOLUTE) {
			mu_ctx.last_rect = res;
			return res;
		}

	} else {
		/* handle next row */
		if (layout->row_index == layout->items)
			mu_layout_row(layout->items, nil, layout->size.y);

		/* position */
		res.x = layout->position.x;
		res.y = layout->position.y;

		/* size */
		res.w = layout->items > -1 ? layout->widths[layout->row_index] : layout->size.x;
		res.h = layout->size.y;
		if (res.w == 0)
			res.w = mu_style.size.x + mu_style.padding * 2;
		if (res.h == 0)
			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)
			res.h += layout->body.h - res.y + 1;

		layout->row_index++;
	}

	/* update position */
	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;
	res.y += layout->body.y;

	/* update max position */
	layout->max.x = MAX(layout->max.x, res.x + res.w);
	layout->max.y = MAX(layout->max.y, res.y + res.h);

	mu_ctx.last_rect = res;
	return res;
}


/*============================================================================
** controls
**============================================================================*/

static int
in_hover_root(void)
{
	int i = mu_ctx.cntnum;
	while (i--) {
		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 (mu_ctx.cnt[i]->head >= 0)
			break;
	}
	return 0;
}


void
mu_draw_control_frame(mu_Id id, mu_Rect rect, int colorid, int opt)
{
	if (opt & MU_OPT_NOFRAME)
		return;
	colorid += (mu_ctx.focus == id) ? 2 : (mu_ctx.hover == id) ? 1 : 0;
	draw_frame(rect, colorid);
}


void
mu_draw_control_text(const char *str, mu_Rect rect, int colorid, int opt)
{
	Point pos;
	Font *font = mu_style.font;
	int tw = text_width(font, str, -1);
	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 - mu_style.padding;
	else
		pos.x = rect.x + mu_style.padding;

	mu_draw_text(font, str, -1, pos, mu_style.colors[colorid]);
	mu_pop_clip_rect();
}


int
mu_mouse_over(mu_Rect rect)
{
	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_Id id, mu_Rect rect, int opt)
{
	int mouseover = mu_mouse_over(rect);

	if (mu_ctx.focus == id)
		mu_ctx.updated_focus = 1;
	if (opt & MU_OPT_NOINTERACT)
		return;
	if (mouseover && !mu_ctx.mouse_down)
		mu_ctx.hover = id;

	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 (mu_ctx.hover == id) {
		if (!mouseover)
			mu_ctx.hover = 0;
		else if (mu_ctx.mouse_pressed)
			mu_set_focus(id);
	}
}


void
mu_text(const char *text)
{
	const char *start, *end, *p = text;
	int width = -1;
	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();
		int w = 0;
		start = end = p;
		do {
			const char* word = p;
			while (*p && *p != ' ' && *p != '\n')
				p++;
			w += text_width(font, word, p - word);
			if (w > r.w && end != start)
				break;
			w += text_width(font, p, 1);
			end = p++;
		} while (*end && *end != '\n');
		mu_draw_text(font, start, end - start, Pt(r.x, r.y), color);
		p = end + 1;
	} while (*end);
	mu_layout_end_column();
}


void
mu_label(const char *text)
{
	mu_draw_control_text(text, mu_layout_next(), MU_COLOR_TEXT, 0);
}


int
mu_button_ex(const char *label, int icon, int opt) {
	int res = 0;
	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 (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id)
		res |= MU_RES_SUBMIT;

	/* draw */
	mu_draw_control_frame(id, r, MU_COLOR_BUTTON, opt);
	if (label)
		mu_draw_control_text(label, r, MU_COLOR_TEXT, opt);
	if (icon)
		mu_draw_icon(icon, r);
	return res;
}


int
mu_button(const char *label)
{
	return mu_button_ex(label, 0, MU_OPT_ALIGNCENTER);
}


int
mu_checkbox(int *state, const char *label)
{
	int res = 0;
	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(id, r, 0);
	/* handle click */
	if (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id) {
		res |= MU_RES_CHANGE;
		*state = !*state;
	}
	/* draw */
	mu_draw_control_frame(id, box, MU_COLOR_BASE, 0);
	if (*state)
		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(label, r, MU_COLOR_TEXT, 0);
	return res;
}


int
mu_textbox_raw(char *buf, int bufsz, mu_Id id, mu_Rect r, int opt)
{
	int res = 0;
	mu_update_control(id, r, opt | MU_OPT_HOLDFOCUS);

	if (mu_ctx.focus == id) {
		/* handle text input */
		int len = strlen(buf);
		int n = MIN(bufsz - len - 1, (int)strlen(mu_ctx.text_input));
		if (n > 0) {
			memcpy(buf + len, mu_ctx.text_input, n);
			len += n;
			buf[len] = '\0';
			res |= MU_RES_CHANGE;
		}
		/* handle backspace */
		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 (mu_ctx.key_pressed & MU_KEY_NACK && len > 0) {
			buf[0] = '\0';
			res |= MU_RES_CHANGE;
		}
		/* handle return */
		if (mu_ctx.key_pressed & MU_KEY_RETURN) {
			mu_set_focus(0);
			res |= MU_RES_SUBMIT;
		}
	}

	/* draw */
	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 - 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(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(buf, r, MU_COLOR_TEXT, opt);
	}

	return res;
}


static int
number_textbox(double *value, mu_Rect r, mu_Id id)
{
	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 (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;
		}
	}
	return 0;
}


int
mu_textbox_ex(char *buf, int bufsz, int 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(char *buf, int bufsz)
{
	return mu_textbox_ex(buf, bufsz, 0);
}


int
mu_slider_ex(double *value, double low, double high, double step, const char *fmt, int opt)
{
	char buf[MU_MAX_FMT + 1];
	mu_Rect thumb;
	int w, res = 0;
	double normalized, last = *value, v = last;
	mu_Id id = mu_get_id(&value, sizeof(value));
	mu_Rect base = mu_layout_next();

	/* handle text input mode */
	if (number_textbox(&v, base, id))
		return res;

	/* handle normal mode */
	mu_update_control(id, base, opt);

	/* handle input */
	if (mu_ctx.focus == id) {
		if (mu_ctx.mouse_down == MU_MOUSE_LEFT)
			v = low + ((double)(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 ((mu_ctx.key_pressed & (MU_KEY_LEFT | MU_KEY_RIGHT)) == MU_KEY_RIGHT) {
			v += step ? step : 1;
			if (v > high)
				v = high;
		}
	}

	if (step)
		v = ((long)((v + (v > 0 ? step/2 : (-step/2))) / step)) * step;
	/* clamp and store value, update res */
	*value = v = CLAMP(v, low, high);
	if (last != v)
		res |= MU_RES_CHANGE;

	/* draw base */
	mu_draw_control_frame(id, base, MU_COLOR_BASE, opt);
	/* draw thumb */
	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(id, thumb, MU_COLOR_BUTTON, opt);
	/* draw text	*/
	sprint(buf, fmt, v);
	mu_draw_control_text(buf, base, MU_COLOR_TEXT, opt);

	return res;
}


int
mu_slider(double *value, double low, double high)
{
	return mu_slider_ex(value, low, high, 0, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
}


int
mu_number_ex(double *value, double step, const char *fmt, int opt)
{
	char buf[MU_MAX_FMT + 1];
	int res = 0;
	mu_Id id = mu_get_id(&value, sizeof(value));
	mu_Rect base = mu_layout_next();
	double last = *value;

	/* handle text input mode */
	if (number_textbox(value, base, id))
		return res;

	/* handle normal mode */
	mu_update_control(id, base, opt);

	/* handle input */
	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)
		res |= MU_RES_CHANGE;

	/* draw base */
	mu_draw_control_frame(id, base, MU_COLOR_BASE, opt);
	/* draw text	*/
	sprint(buf, fmt, *value);
	mu_draw_control_text(buf, base, MU_COLOR_TEXT, opt);

	return res;
}


int
mu_number(double *value, double step)
{
	return mu_number_ex(value, step, MU_SLIDER_FMT, MU_OPT_ALIGNCENTER);
}


static int
header(int *state, const char *label, int istreenode)
{
	mu_Rect r;
	mu_Id id;
	int width = -1;
	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 (mu_ctx.mouse_pressed == MU_MOUSE_LEFT && mu_ctx.focus == id)
		*state = !(*state);

	/* draw */
	if (istreenode) {
		if (mu_ctx.hover == id)
			draw_frame(r, MU_COLOR_BUTTONHOVER);
	} else {
		mu_draw_control_frame(id, r, MU_COLOR_BUTTON, 0);
	}
	mu_draw_icon(
		*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(int *state, const char *label)
{
	return header(state, label, 0);
}


int
mu_begin_treenode(int *state, const char *label)
{
	int res = header(state, label, 1);
	if (res & MU_RES_ACTIVE) {
		get_layout()->indent += mu_style.indent;
		mu_push_id(&state, sizeof(void*));
	}
	return res;
}


void
mu_end_treenode(void)
{
	get_layout()->indent -= mu_style.indent;
	mu_pop_id();
}

static void
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;

	if (maxscroll > 0 && (v ? b->h : b->x) > 0) {
		mu_Rect base, thumb;
		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 = mu_style.scrollbar_size;
		} else {
			base.y = b->y + b->h;
			base.h = mu_style.scrollbar_size;
		}

		/* handle input */
		mu_update_control(id, base, 0);
		if (mu_ctx.focus == id && mu_ctx.mouse_down == MU_MOUSE_LEFT) {
			if (v)
				cnt->scroll.y += mu_ctx.mouse_delta.y * cs.y / base.h;
			else
				cnt->scroll.x += mu_ctx.mouse_delta.x * cs.x / base.w;
		}
		/* clamp scroll to limits */
		if (v)
			cnt->scroll.y = CLAMP(cnt->scroll.y, 0, maxscroll);
		else
			cnt->scroll.x = CLAMP(cnt->scroll.x, 0, maxscroll);

		/* draw base and thumb */
		draw_frame(base, MU_COLOR_SCROLLBASE);
		thumb = base;
		if (v) {
			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(mu_style.thumb_size, base.w * b->w / cs.x);
			thumb.x += cnt->scroll.x * (base.w - thumb.w) / maxscroll;
		}
		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(*b))
			mu_ctx.scroll_target = cnt;
	} else if (v) {
		cnt->scroll.y = 0;
	} else {
		cnt->scroll.x = 0;
	}
}

static void
scrollbars(mu_Container *cnt, mu_Rect *body)
{
	int sz = mu_style.scrollbar_size;
	Point cs = cnt->content_size;
	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;
	if (cs.x > cnt->body.w)
		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(cnt, body, cs, 1);
	scrollbar(cnt, body, cs, 0);
	mu_pop_clip_rect();
}

static void
push_container_body(mu_Container *cnt, mu_Rect body, int opt)
{
	if (~opt & MU_OPT_NOSCROLL)
		scrollbars(cnt, &body);
	push_layout(expand_rect(body, -mu_style.padding), cnt->scroll);
	cnt->body = body;
}

static void
begin_root_container(mu_Container *cnt)
{
	push_container(cnt);

	/* push container to roots list and push head command */
	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, 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(&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(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();
	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();
	pop_container();
}


int
mu_begin_window_ex(mu_Container *cnt, const char *title, int opt)
{
	mu_Rect rect, body, titlerect;

	if (!cnt->inited)
		mu_init_window(cnt, opt);
	if (!cnt->open)
		return 0;

	begin_root_container(cnt);
	rect = cnt->rect;
	body = rect;

	/* draw frame */
	if (~opt & MU_OPT_NOFRAME)
		draw_frame(rect, MU_COLOR_WINDOWBG);

	/* moving all windows by "dragging" background */
	if (mu_ctx.last_hover_root == nil && mu_ctx.hover_root == nil && mu_ctx.mouse_pressed == MU_MOUSE_LEFT)
		mu_ctx.moving = 1;
	else if (mu_ctx.mouse_down != MU_MOUSE_LEFT)
		mu_ctx.moving = 0;
	if (mu_ctx.moving) {
		cnt->rect.x += mu_ctx.mouse_delta.x;
		cnt->rect.y += mu_ctx.mouse_delta.y;
	}

	/* do title bar */
	titlerect = rect;
	titlerect.h = mu_style.title_height;
	if (~opt & MU_OPT_NOTITLE) {
		mu_Id id = mu_get_id("!title", 6);

		draw_frame(titlerect, MU_COLOR_TITLEBG);

		/* do title text */
		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;

		/* do `close` button */
		if (~opt & MU_OPT_NOCLOSE) {
			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(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(cnt, body, opt);

	/* do `resize` handle */
	if (~opt & MU_OPT_NORESIZE) {
		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(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()->body;
		if (opt & MU_OPT_AUTOSIZE_W)
			cnt->rect.w = cnt->content_size.x + (cnt->rect.w - r.w);
		if (opt & MU_OPT_AUTOSIZE_H)
			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 && mu_ctx.mouse_pressed && mu_ctx.last_hover_root != cnt)
		cnt->open = 0;

	mu_push_clip_rect(cnt->body);
	return MU_RES_ACTIVE;
}


int
mu_begin_window(mu_Container *cnt, const char *title)
{
	return mu_begin_window_ex(cnt, title, 0);
}


void
mu_end_window(void)
{
	mu_pop_clip_rect();
	end_root_container();
}


void
mu_open_popup(mu_Container *cnt)
{
	/* set as hover root so popup isn't closed in begin_window_ex() */
	mu_ctx.last_hover_root = mu_ctx.hover_root = cnt;
	/* init container if not inited */
	if (!cnt->inited)
		mu_init_window(cnt, 0);
	/* position at mouse cursor, open and bring-to-front */
	cnt->rect = mu_rect(mu_ctx.mouse_pos.x, mu_ctx.mouse_pos.y, 0, 0);
	cnt->open = 1;
	mu_bring_to_front(cnt);
}


int
mu_begin_popup(mu_Container *cnt)
{
	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(void)
{
	mu_end_window();
}


void
mu_begin_panel_ex(mu_Container *cnt, int opt)
{
	cnt->rect = mu_layout_next();
	if (~opt & MU_OPT_NOFRAME)
		draw_frame(cnt->rect, MU_COLOR_PANELBG);

	push_container(cnt);
	push_container_body(cnt, cnt->rect, opt);
	mu_push_clip_rect(cnt->body);
}


void
mu_begin_panel(mu_Container *cnt)
{
	mu_begin_panel_ex(cnt, 0);
}


void
mu_end_panel(void)
{
	mu_pop_clip_rect();
	pop_container();
}

int
mu_render(void)
{
	mu_Command *cmd;
	mu_Rect r, iconr;

	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)
		if (mu_ctx.oldstrnum == mu_ctx.strnum && memcmp(mu_ctx.oldstr, mu_ctx.str, mu_ctx.strnum) == 0)
			return 0;

	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");
	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 (mu_ctx.oldstrmax != mu_ctx.strmax && (mu_ctx.oldstr = realloc(mu_ctx.oldstr, mu_ctx.strmax)) == nil)
		sysfatal("couldn't allocate memory for old strings");
	mu_ctx.oldstrmax = mu_ctx.strmax;
	mu_ctx.oldstrnum = mu_ctx.strnum;
	memmove(mu_ctx.oldstr, mu_ctx.str, mu_ctx.strnum);

	draw(screen, screen->r, mu_style.colors[MU_COLOR_BG], nil, ZP);

	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, mu_style.font, mu_ctx.str+cmd->text.s);
			break;

		case MU_COMMAND_RECT:
			if (cmd->rect.color != nil)
				draw(screen, screenrect(cmd->rect.rect), cmd->rect.color, nil, ZP);
			break;

		case MU_COMMAND_ICON:
			r = cmd->icon.rect;
			iconr = atlasicons[cmd->icon.id];
			r.x += (r.w - iconr.w) / 2;
			r.y += (r.h - iconr.h) / 2;
			r.w = iconr.w;
			r.h = iconr.h;
			draw(screen, screenrect(r), atlasimage, nil, Pt(iconr.x, iconr.y));
			break;

		case MU_COMMAND_CLIP:
			replclipr(screen, 0, screenrect(cmd->clip.rect));
			break;

		case MU_COMMAND_JUMP:
			if (cmd->jump.dst < 0)
				return 1;
			cmd = &mu_ctx.cmds[cmd->jump.dst];
			continue;
		}

		cmd++;
	}

	return 1;
}