editor.c

// Copyright (c) 2026, Peter Fors
// SPDX-License-Identifier: MIT
// Generated by mkgui-editor -- do not edit by hand

#define MKGUI_MAX_ICONS         32768
#include "mkgui.c"

// ---------------------------------------------------------------------------
// Editor-internal anchor flags (removed from public API, kept for editor design-time layout)
// ---------------------------------------------------------------------------

#define MKGUI_ANCHOR_LEFT          (1u << 0)
#define MKGUI_ANCHOR_TOP           (1u << 1)
#define MKGUI_ANCHOR_RIGHT         (1u << 2)
#define MKGUI_ANCHOR_BOTTOM        (1u << 3)

// ---------------------------------------------------------------------------
// Editor constants
// ---------------------------------------------------------------------------

#define ED_MAX_WIDGETS    4096
#define ED_MAX_UNDO       64
#define ED_GRID_DEFAULT   8
#define ED_CANVAS_DEF_W   640
#define ED_CANVAS_DEF_H   480
#define ED_LEFT_W         200
#define ED_RIGHT_W        320
#define ED_PAL_COLS       3
#define ED_PAL_ROWS       ((ED_WIDGET_COUNT + ED_PAL_COLS - 1) / ED_PAL_COLS)
#define ED_PALETTE_H      (36 + ED_PAL_ROWS * 22 + (ED_PAL_ROWS - 1) * MKGUI_BOX_GAP)
#define ED_CTN_COLS       3
#define ED_CTN_ROWS       ((ED_CONTAINER_COUNT + ED_CTN_COLS - 1) / ED_CTN_COLS)
#define ED_CTN_H          (36 + ED_CTN_ROWS * 22 + (ED_CTN_ROWS - 1) * MKGUI_BOX_GAP)
#define ED_BOT_H          MKGUI_STATUSBAR_HEIGHT
#define ED_PROP_FORM_H    (6 * 24 + 5 * MKGUI_BOX_GAP)
#define ED_PROP_FL_H      (4 * 20 + 3 * MKGUI_BOX_GAP)

// ---------------------------------------------------------------------------
// Editor widget IDs
// ---------------------------------------------------------------------------

enum {
	ED_WINDOW = 0,
	ED_MENU, ED_FILE_MENU, ED_EDIT_MENU,
	ED_MI_NEW, ED_MI_OPEN, ED_MI_SAVE, ED_MI_SAVEAS, ED_MI_RECENT, ED_MI_GENERATE, ED_MI_SNIPPET, ED_MI_EXIT,
	ED_MI_UNDO, ED_MI_REDO, ED_MI_COPY, ED_MI_PASTE, ED_MI_DELETE,
	ED_MI_SEP1, ED_MI_SEP2, ED_MI_SEP3, ED_MI_SEP4,
	ED_TOOLBAR,
	ED_TB_NEW, ED_TB_OPEN, ED_TB_SAVE, ED_TB_SEP1, ED_TB_GEN, ED_TB_TEST,
	ED_TB_SEP2, ED_TB_UNDO, ED_TB_REDO,
	ED_SPLIT_MAIN, ED_SPLIT_RIGHT, ED_TREE, ED_CANVAS_LBL, ED_RIGHT_PANEL,
	ED_PAL_GROUP, ED_PAL_HBOX, ED_PAL_COL0, ED_PAL_COL1, ED_PAL_COL2,
	ED_CTN_GROUP, ED_CTN_HBOX, ED_CTN_COL0, ED_CTN_COL1, ED_CTN_COL2,
	ED_PROP_GROUP,
	ED_PROP_VBOX, ED_PROP_FORM, ED_PROP_ICON_HBOX,
	ED_PROP_POS_HBOX, ED_PROP_SIZE_HBOX, ED_PROP_WEIGHT_HBOX,
	ED_PROP_FL_HBOX, ED_PROP_FL_COL0, ED_PROP_FL_COL1, ED_PROP_FL_COL2, ED_PROP_FL_COL3,
	ED_PROP_BTN_HBOX,
	ED_PROP_TYPE_LBL, ED_PROP_TYPE_VAL,
	ED_PROP_ID_LBL, ED_PROP_ID_INP,
	ED_PROP_LABEL_LBL, ED_PROP_LABEL_INP,
	ED_PROP_ICON_LBL, ED_PROP_ICON_INP, ED_PROP_ICON_BROWSE,
	ED_PROP_PARENT_LBL, ED_PROP_PARENT_DRP,
	ED_PROP_X_LBL, ED_PROP_X_SPN,
	ED_PROP_Y_LBL, ED_PROP_Y_SPN,
	ED_PROP_W_LBL, ED_PROP_W_SPN,
	ED_PROP_H_LBL, ED_PROP_H_SPN,
	ED_PROP_ML_LBL, ED_PROP_ML_SPN,
	ED_PROP_MT_LBL, ED_PROP_MT_SPN,
	ED_PROP_MR_LBL, ED_PROP_MR_SPN,
	ED_PROP_MB_LBL, ED_PROP_MB_SPN,
	ED_PROP_MARGIN_LR_HBOX, ED_PROP_MARGIN_TB_HBOX,
	ED_PROP_TAB_LBL, ED_PROP_TAB_SPN,
	ED_PROP_FLAGS_LBL,
	ED_PROP_FL_LEFT, ED_PROP_FL_TOP, ED_PROP_FL_RIGHT, ED_PROP_FL_BOTTOM,
	ED_PROP_FL_HIDDEN, ED_PROP_FL_DISABLED,
	ED_PROP_FL_CHECKED, ED_PROP_FL_MI_CHECKED, ED_PROP_FL_SEPARATOR,
	ED_PROP_FL_MENUCHECK, ED_PROP_FL_MENURADIO,
	ED_PROP_FL_REGTOP, ED_PROP_FL_REGBOT, ED_PROP_FL_REGLEFT, ED_PROP_FL_REGRIGHT,
	ED_PROP_FL_SCROLL,
	ED_PROP_FL_BORDER, ED_PROP_FL_SUNKEN, ED_PROP_FL_NOPAD,
	ED_PROP_FL_PASSWORD, ED_PROP_FL_READONLY,
	ED_PROP_FL_FIXED,
	ED_PROP_FL_TBSEP,
	ED_PROP_FL_VERTICAL,
	ED_PROP_FL_MIXER,
	ED_PROP_FL_TRUNCATE,
	ED_PROP_FL_METER_TEXT,
	ED_PROP_FL_LINK,
	ED_PROP_FL_WRAP,
	ED_PROP_FL_COLLAPSIBLE,
	ED_PROP_FL_COLLAPSED,
	ED_PROP_FL_NUMERIC,
	ED_PROP_FL_TAB_CLOSABLE,
	ED_PROP_FL_SHIMMER,
	ED_PROP_FL_MULTI_SELECT,
	ED_PROP_FL_IMG_STRETCH,
	ED_PROP_FL_BTN_CHECKED,
	ED_PROP_FL_TOG_CHECKED,
	ED_PROP_FL_LOG_NOWRAP,
	ED_PROP_FL_DP_READONLY,
	ED_PROP_FL_TA_READONLY,
	ED_PROP_FL_LV_EDITABLE,
	ED_PROP_FL_TV_EDITABLE,
	ED_PROP_FL_IV_EDITABLE,
	ED_PROP_FL_WIN_HIDDEN,
	ED_PROP_FL_WIN_HIDE_CLOSE,
	ED_PROP_FL_WIN_UNDECORATED,
	ED_PROP_FL_WIN_CANVAS,
	ED_PROP_TB_MODE_LBL, ED_PROP_TB_MODE_DRP,
	ED_PROP_WEIGHT_LBL, ED_PROP_WEIGHT_SPN,
	ED_PROP_ALIGN_LBL, ED_PROP_ALIGN_DRP,
	ED_PROP_ADD_TAB, ED_PROP_REM_TAB,
	ED_PROP_ADD_ITEM, ED_PROP_REM_ITEM,
	ED_PROP_ADD_TB_BTN, ED_PROP_REM_TB_BTN,
	ED_MENU_TREE,
	ED_PROP_ACCEL_LBL, ED_PROP_ACCEL_HBOX, ED_PROP_ACCEL_BTN, ED_PROP_ACCEL_CLEAR,
	ED_STATUSBAR,
	ED_EVT_GROUP, ED_EVT_VBOX, ED_EVT_LIST,
	ED_DATA_GROUP, ED_DATA_VBOX, ED_DATA_LIST, ED_DATA_ITEM_INP,
	ED_DATA_BTN_HBOX, ED_DATA_ADD_BTN, ED_DATA_REM_BTN, ED_DATA_UP_BTN, ED_DATA_DOWN_BTN,

	ED_PAL_FIRST = 500,
	ED_CTN_FIRST = 600,
	ED_RECENT_FIRST = 700,
	ED_RECENT_LAST = 709,
};

// ---------------------------------------------------------------------------
// Palette entries
// ---------------------------------------------------------------------------

struct ed_palette_entry {
	char *name;
	uint32_t type;
};

static struct ed_palette_entry ed_widgets[] = {
	{ "Button",     MKGUI_BUTTON },
	{ "Canvas",     MKGUI_CANVAS },
	{ "Checkbox",   MKGUI_CHECKBOX },
	{ "Combobox",   MKGUI_COMBOBOX },
	{ "DatePicker", MKGUI_DATEPICKER },
	{ "Divider",    MKGUI_DIVIDER },
	{ "Dropdown",   MKGUI_DROPDOWN },
	{ "GLView",     MKGUI_GLVIEW },
	{ "Gridview",   MKGUI_GRIDVIEW },
	{ "Image",      MKGUI_IMAGE },
	{ "Input",      MKGUI_INPUT },
	{ "IPInput",    MKGUI_IPINPUT },
	{ "ItemView",   MKGUI_ITEMVIEW },
	{ "Label",      MKGUI_LABEL },
	{ "Listview",   MKGUI_LISTVIEW },
	{ "Logview",    MKGUI_LOGVIEW },
	{ "Meter",      MKGUI_METER },
	{ "Pathbar",    MKGUI_PATHBAR },
	{ "Progress",   MKGUI_PROGRESS },
	{ "Radio",      MKGUI_RADIO },
	{ "RichList",   MKGUI_RICHLIST },
	{ "Scrollbar",  MKGUI_SCROLLBAR },
	{ "Slider",     MKGUI_SLIDER },
	{ "Spacer",     MKGUI_SPACER },
	{ "Spinbox",    MKGUI_SPINBOX },
	{ "Spinner",    MKGUI_SPINNER },
	{ "Textarea",   MKGUI_TEXTAREA },
	{ "Toggle",     MKGUI_TOGGLE },
	{ "TreeList",   MKGUI_TREELIST },
	{ "Treeview",   MKGUI_TREEVIEW },
};

static struct ed_palette_entry ed_containers[] = {
	{ "Form",       MKGUI_FORM },
	{ "Group",      MKGUI_GROUP },
	{ "HBox",       MKGUI_HBOX },
	{ "VBox",       MKGUI_VBOX },
	{ "HSplit",     MKGUI_HSPLIT },
	{ "VSplit",     MKGUI_VSPLIT },
	{ "Menu",       MKGUI_MENU },
	{ "Panel",      MKGUI_PANEL },
	{ "Statusbar",  MKGUI_STATUSBAR },
	{ "Tabs",       MKGUI_TABS },
	{ "Toolbar",    MKGUI_TOOLBAR },
};

#define ED_WIDGET_COUNT    (sizeof(ed_widgets) / sizeof(ed_widgets[0]))
#define ED_CONTAINER_COUNT (sizeof(ed_containers) / sizeof(ed_containers[0]))

// ---------------------------------------------------------------------------
// Event-to-widget mapping
// ---------------------------------------------------------------------------

#define ED_MAX_TYPE_EVENTS 16

struct ed_type_event_map {
	uint32_t widget_type;
	uint32_t events[ED_MAX_TYPE_EVENTS];
	uint32_t event_count;
};

static struct ed_type_event_map ed_type_events[] = {
	{ MKGUI_WINDOW,    { MKGUI_EVENT_CLOSE, MKGUI_EVENT_RESIZE, MKGUI_EVENT_KEY }, 3 },
	{ MKGUI_BUTTON,    { MKGUI_EVENT_CLICK, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_INPUT,     { MKGUI_EVENT_INPUT_CHANGED, MKGUI_EVENT_INPUT_SUBMIT, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_CHECKBOX,  { MKGUI_EVENT_CHECKBOX_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_DROPDOWN,  { MKGUI_EVENT_DROPDOWN_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_SLIDER,    { MKGUI_EVENT_SLIDER_CHANGED, MKGUI_EVENT_SLIDER_START, MKGUI_EVENT_SLIDER_END, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 9 },
	{ MKGUI_LISTVIEW,  { MKGUI_EVENT_LISTVIEW_SELECT, MKGUI_EVENT_LISTVIEW_DBLCLICK, MKGUI_EVENT_LISTVIEW_SORT, MKGUI_EVENT_LISTVIEW_COL_REORDER, MKGUI_EVENT_LISTVIEW_REORDER, MKGUI_EVENT_DRAG_START, MKGUI_EVENT_DRAG_END, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_CONTEXT_HEADER, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 14 },
	{ MKGUI_TREEVIEW,  { MKGUI_EVENT_TREEVIEW_SELECT, MKGUI_EVENT_TREEVIEW_DBLCLICK, MKGUI_EVENT_TREEVIEW_EXPAND, MKGUI_EVENT_TREEVIEW_COLLAPSE, MKGUI_EVENT_TREEVIEW_MOVE, MKGUI_EVENT_DRAG_START, MKGUI_EVENT_DRAG_END, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 13 },
	{ MKGUI_TREELIST,  { MKGUI_EVENT_TREELIST_SELECT, MKGUI_EVENT_TREELIST_DBLCLICK, MKGUI_EVENT_TREELIST_EXPAND, MKGUI_EVENT_TREELIST_COLLAPSE, MKGUI_EVENT_TREELIST_SORT, MKGUI_EVENT_TREELIST_COL_REORDER, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_CONTEXT_HEADER, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 13 },
	{ MKGUI_TABS,      { MKGUI_EVENT_TAB_CHANGED, MKGUI_EVENT_TAB_CLOSE, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_RADIO,     { MKGUI_EVENT_RADIO_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_TEXTAREA,  { MKGUI_EVENT_TEXTAREA_CHANGED, MKGUI_EVENT_TEXTAREA_CURSOR, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_LOGVIEW,   { MKGUI_EVENT_LOGVIEW_LINE_CLICKED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_SPINBOX,   { MKGUI_EVENT_SPINBOX_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_SCROLLBAR, { MKGUI_EVENT_SCROLL, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_IPINPUT,   { MKGUI_EVENT_IPINPUT_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_TOGGLE,    { MKGUI_EVENT_TOGGLE_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_COMBOBOX,  { MKGUI_EVENT_COMBOBOX_CHANGED, MKGUI_EVENT_COMBOBOX_SUBMIT, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_DATEPICKER,{ MKGUI_EVENT_DATEPICKER_CHANGED, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 7 },
	{ MKGUI_GRIDVIEW,  { MKGUI_EVENT_GRID_CLICK, MKGUI_EVENT_GRID_CHECK, MKGUI_EVENT_GRIDVIEW_SELECT, MKGUI_EVENT_GRIDVIEW_REORDER, MKGUI_EVENT_DRAG_START, MKGUI_EVENT_DRAG_END, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_CONTEXT_HEADER, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 13 },
	{ MKGUI_RICHLIST,  { MKGUI_EVENT_RICHLIST_SELECT, MKGUI_EVENT_RICHLIST_DBLCLICK, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_PATHBAR,   { MKGUI_EVENT_PATHBAR_NAV, MKGUI_EVENT_PATHBAR_SUBMIT, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_ITEMVIEW,  { MKGUI_EVENT_ITEMVIEW_SELECT, MKGUI_EVENT_ITEMVIEW_DBLCLICK, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_FOCUS, MKGUI_EVENT_UNFOCUS, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE, MKGUI_EVENT_KEY }, 8 },
	{ MKGUI_LABEL,     { MKGUI_EVENT_CLICK, MKGUI_EVENT_CONTEXT, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE }, 4 },
	{ MKGUI_GROUP,     { MKGUI_EVENT_CLICK, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE }, 3 },
	{ MKGUI_MENUITEM,  { MKGUI_EVENT_MENU, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE }, 3 },
	{ MKGUI_HSPLIT,    { MKGUI_EVENT_SPLIT_MOVED, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE }, 3 },
	{ MKGUI_VSPLIT,    { MKGUI_EVENT_SPLIT_MOVED, MKGUI_EVENT_HOVER_ENTER, MKGUI_EVENT_HOVER_LEAVE }, 3 },
	{ MKGUI_CANVAS,   { MKGUI_EVENT_CANVAS_PRESS, MKGUI_EVENT_CANVAS_RELEASE, MKGUI_EVENT_CANVAS_MOTION, MKGUI_EVENT_SCROLL, MKGUI_EVENT_KEY }, 5 },
};
#define ED_TYPE_EVENT_COUNT (sizeof(ed_type_events) / sizeof(ed_type_events[0]))

// [=]===^=[ ed_find_type_events ]=================================[=]
static struct ed_type_event_map *ed_find_type_events(uint32_t widget_type) {
	for(uint32_t i = 0; i < ED_TYPE_EVENT_COUNT; ++i) {
		if(ed_type_events[i].widget_type == widget_type) {
			return &ed_type_events[i];
		}
	}
	return NULL;
}

// [=]===^=[ ed_event_name ]=======================================[=]
static char *ed_event_name(uint32_t event_type) {
	switch(event_type) {
		case MKGUI_EVENT_CLICK:              { return "CLICK"; }
		case MKGUI_EVENT_MENU:               { return "MENU"; }
		case MKGUI_EVENT_TAB_CHANGED:        { return "TAB_CHANGED"; }
		case MKGUI_EVENT_TAB_CLOSE:          { return "TAB_CLOSE"; }
		case MKGUI_EVENT_LISTVIEW_SORT:      { return "LISTVIEW_SORT"; }
		case MKGUI_EVENT_LISTVIEW_SELECT:    { return "LISTVIEW_SELECT"; }
		case MKGUI_EVENT_LISTVIEW_DBLCLICK:  { return "LISTVIEW_DBLCLICK"; }
		case MKGUI_EVENT_LISTVIEW_COL_REORDER: { return "LISTVIEW_COL_REORDER"; }
		case MKGUI_EVENT_LISTVIEW_REORDER:   { return "LISTVIEW_REORDER"; }
		case MKGUI_EVENT_INPUT_CHANGED:      { return "INPUT_CHANGED"; }
		case MKGUI_EVENT_INPUT_SUBMIT:       { return "INPUT_SUBMIT"; }
		case MKGUI_EVENT_CHECKBOX_CHANGED:   { return "CHECKBOX_CHANGED"; }
		case MKGUI_EVENT_DROPDOWN_CHANGED:   { return "DROPDOWN_CHANGED"; }
		case MKGUI_EVENT_SLIDER_CHANGED:     { return "SLIDER_CHANGED"; }
		case MKGUI_EVENT_SLIDER_START:       { return "SLIDER_START"; }
		case MKGUI_EVENT_SLIDER_END:         { return "SLIDER_END"; }
		case MKGUI_EVENT_SPLIT_MOVED:        { return "SPLIT_MOVED"; }
		case MKGUI_EVENT_TREEVIEW_SELECT:    { return "TREEVIEW_SELECT"; }
		case MKGUI_EVENT_TREEVIEW_EXPAND:    { return "TREEVIEW_EXPAND"; }
		case MKGUI_EVENT_TREEVIEW_COLLAPSE:  { return "TREEVIEW_COLLAPSE"; }
		case MKGUI_EVENT_TREEVIEW_DBLCLICK:  { return "TREEVIEW_DBLCLICK"; }
		case MKGUI_EVENT_TREEVIEW_MOVE:      { return "TREEVIEW_MOVE"; }
		case MKGUI_EVENT_SPINBOX_CHANGED:    { return "SPINBOX_CHANGED"; }
		case MKGUI_EVENT_RADIO_CHANGED:      { return "RADIO_CHANGED"; }
		case MKGUI_EVENT_TEXTAREA_CHANGED:   { return "TEXTAREA_CHANGED"; }
		case MKGUI_EVENT_TEXTAREA_CURSOR:    { return "TEXTAREA_CURSOR"; }
		case MKGUI_EVENT_CLOSE:              { return "CLOSE"; }
		case MKGUI_EVENT_RESIZE:             { return "RESIZE"; }
		case MKGUI_EVENT_ITEMVIEW_SELECT:    { return "ITEMVIEW_SELECT"; }
		case MKGUI_EVENT_ITEMVIEW_DBLCLICK:  { return "ITEMVIEW_DBLCLICK"; }
		case MKGUI_EVENT_SCROLL:             { return "SCROLL"; }
		case MKGUI_EVENT_IPINPUT_CHANGED:    { return "IPINPUT_CHANGED"; }
		case MKGUI_EVENT_TOGGLE_CHANGED:     { return "TOGGLE_CHANGED"; }
		case MKGUI_EVENT_COMBOBOX_CHANGED:   { return "COMBOBOX_CHANGED"; }
		case MKGUI_EVENT_COMBOBOX_SUBMIT:    { return "COMBOBOX_SUBMIT"; }
		case MKGUI_EVENT_DATEPICKER_CHANGED: { return "DATEPICKER_CHANGED"; }
		case MKGUI_EVENT_GRID_CLICK:         { return "GRID_CLICK"; } break;
		case MKGUI_EVENT_GRID_CHECK:         { return "GRID_CHECK"; } break;
		case MKGUI_EVENT_PATHBAR_NAV:        { return "PATHBAR_NAV"; }
		case MKGUI_EVENT_PATHBAR_SUBMIT:     { return "PATHBAR_SUBMIT"; }
		case MKGUI_EVENT_CONTEXT:            { return "CONTEXT"; }
		case MKGUI_EVENT_CONTEXT_HEADER:     { return "CONTEXT_HEADER"; }
		case MKGUI_EVENT_CONTEXT_MENU:       { return "CONTEXT_MENU"; }
		case MKGUI_EVENT_GRIDVIEW_SELECT:    { return "GRIDVIEW_SELECT"; }
		case MKGUI_EVENT_GRIDVIEW_REORDER:   { return "GRIDVIEW_REORDER"; }
		case MKGUI_EVENT_RICHLIST_SELECT:    { return "RICHLIST_SELECT"; }
		case MKGUI_EVENT_RICHLIST_DBLCLICK:  { return "RICHLIST_DBLCLICK"; }
		case MKGUI_EVENT_DRAG_START:         { return "DRAG_START"; }
		case MKGUI_EVENT_DRAG_END:           { return "DRAG_END"; }
		case MKGUI_EVENT_FOCUS:              { return "FOCUS"; }
		case MKGUI_EVENT_UNFOCUS:            { return "UNFOCUS"; }
		case MKGUI_EVENT_HOVER_ENTER:        { return "HOVER_ENTER"; }
		case MKGUI_EVENT_HOVER_LEAVE:        { return "HOVER_LEAVE"; }
		case MKGUI_EVENT_KEY:                { return "KEY"; }
		case MKGUI_EVENT_CANVAS_PRESS:       { return "CANVAS_PRESS"; }
		case MKGUI_EVENT_CANVAS_RELEASE:     { return "CANVAS_RELEASE"; }
		case MKGUI_EVENT_CANVAS_MOTION:      { return "CANVAS_MOTION"; }
		case MKGUI_EVENT_LOGVIEW_LINE_CLICKED:{ return "LOGVIEW_LINE_CLICKED"; }
		default:                             { return "UNKNOWN"; }
	}
}

// [=]===^=[ ed_event_from_name ]==================================[=]
static uint32_t ed_event_from_name(char *name) {
	struct { char *name; uint32_t type; } map[] = {
		{ "CLICK",              MKGUI_EVENT_CLICK },
		{ "MENU",               MKGUI_EVENT_MENU },
		{ "TAB_CHANGED",        MKGUI_EVENT_TAB_CHANGED },
		{ "TAB_CLOSE",          MKGUI_EVENT_TAB_CLOSE },
		{ "LISTVIEW_SORT",      MKGUI_EVENT_LISTVIEW_SORT },
		{ "LISTVIEW_SELECT",    MKGUI_EVENT_LISTVIEW_SELECT },
		{ "LISTVIEW_DBLCLICK",  MKGUI_EVENT_LISTVIEW_DBLCLICK },
		{ "LISTVIEW_COL_REORDER", MKGUI_EVENT_LISTVIEW_COL_REORDER },
		{ "LISTVIEW_REORDER",   MKGUI_EVENT_LISTVIEW_REORDER },
		{ "INPUT_CHANGED",      MKGUI_EVENT_INPUT_CHANGED },
		{ "INPUT_SUBMIT",       MKGUI_EVENT_INPUT_SUBMIT },
		{ "CHECKBOX_CHANGED",   MKGUI_EVENT_CHECKBOX_CHANGED },
		{ "DROPDOWN_CHANGED",   MKGUI_EVENT_DROPDOWN_CHANGED },
		{ "SLIDER_CHANGED",     MKGUI_EVENT_SLIDER_CHANGED },
		{ "SLIDER_START",       MKGUI_EVENT_SLIDER_START },
		{ "SLIDER_END",         MKGUI_EVENT_SLIDER_END },
		{ "SPLIT_MOVED",        MKGUI_EVENT_SPLIT_MOVED },
		{ "TREEVIEW_SELECT",    MKGUI_EVENT_TREEVIEW_SELECT },
		{ "TREEVIEW_EXPAND",    MKGUI_EVENT_TREEVIEW_EXPAND },
		{ "TREEVIEW_COLLAPSE",  MKGUI_EVENT_TREEVIEW_COLLAPSE },
		{ "TREEVIEW_DBLCLICK",  MKGUI_EVENT_TREEVIEW_DBLCLICK },
		{ "TREEVIEW_MOVE",      MKGUI_EVENT_TREEVIEW_MOVE },
		{ "SPINBOX_CHANGED",    MKGUI_EVENT_SPINBOX_CHANGED },
		{ "RADIO_CHANGED",      MKGUI_EVENT_RADIO_CHANGED },
		{ "TEXTAREA_CHANGED",   MKGUI_EVENT_TEXTAREA_CHANGED },
		{ "TEXTAREA_CURSOR",    MKGUI_EVENT_TEXTAREA_CURSOR },
		{ "LOGVIEW_LINE_CLICKED", MKGUI_EVENT_LOGVIEW_LINE_CLICKED },
		{ "CLOSE",              MKGUI_EVENT_CLOSE },
		{ "RESIZE",             MKGUI_EVENT_RESIZE },
		{ "ITEMVIEW_SELECT",    MKGUI_EVENT_ITEMVIEW_SELECT },
		{ "ITEMVIEW_DBLCLICK",  MKGUI_EVENT_ITEMVIEW_DBLCLICK },
		{ "SCROLL",             MKGUI_EVENT_SCROLL },
		{ "IPINPUT_CHANGED",    MKGUI_EVENT_IPINPUT_CHANGED },
		{ "TOGGLE_CHANGED",     MKGUI_EVENT_TOGGLE_CHANGED },
		{ "COMBOBOX_CHANGED",   MKGUI_EVENT_COMBOBOX_CHANGED },
		{ "COMBOBOX_SUBMIT",    MKGUI_EVENT_COMBOBOX_SUBMIT },
		{ "DATEPICKER_CHANGED", MKGUI_EVENT_DATEPICKER_CHANGED },
		{ "GRID_CLICK",         MKGUI_EVENT_GRID_CLICK },
		{ "GRID_CHECK",         MKGUI_EVENT_GRID_CHECK },
		{ "PATHBAR_NAV",        MKGUI_EVENT_PATHBAR_NAV },
		{ "PATHBAR_SUBMIT",     MKGUI_EVENT_PATHBAR_SUBMIT },
		{ "CONTEXT",            MKGUI_EVENT_CONTEXT },
		{ "CONTEXT_HEADER",     MKGUI_EVENT_CONTEXT_HEADER },
		{ "CONTEXT_MENU",       MKGUI_EVENT_CONTEXT_MENU },
		{ "GRIDVIEW_SELECT",    MKGUI_EVENT_GRIDVIEW_SELECT },
		{ "GRIDVIEW_REORDER",   MKGUI_EVENT_GRIDVIEW_REORDER },
		{ "RICHLIST_SELECT",    MKGUI_EVENT_RICHLIST_SELECT },
		{ "RICHLIST_DBLCLICK",  MKGUI_EVENT_RICHLIST_DBLCLICK },
		{ "DRAG_START",         MKGUI_EVENT_DRAG_START },
		{ "DRAG_END",           MKGUI_EVENT_DRAG_END },
		{ "FOCUS",              MKGUI_EVENT_FOCUS },
		{ "UNFOCUS",            MKGUI_EVENT_UNFOCUS },
		{ "HOVER_ENTER",        MKGUI_EVENT_HOVER_ENTER },
		{ "HOVER_LEAVE",        MKGUI_EVENT_HOVER_LEAVE },
		{ "KEY",                MKGUI_EVENT_KEY },
		{ "CANVAS_PRESS",       MKGUI_EVENT_CANVAS_PRESS },
		{ "CANVAS_RELEASE",     MKGUI_EVENT_CANVAS_RELEASE },
		{ "CANVAS_MOTION",      MKGUI_EVENT_CANVAS_MOTION },
	};
	for(uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); ++i) {
		if(strcmp(map[i].name, name) == 0) {
			return map[i].type;
		}
	}
	return MKGUI_EVENT_NONE;
}

// ---------------------------------------------------------------------------
// Type name lookup
// ---------------------------------------------------------------------------

// [=]===^=[ ed_type_name ]=======================================[=]
static char *ed_type_name(uint32_t type) {
	for(uint32_t i = 0; i < ED_WIDGET_COUNT; ++i) {
		if(ed_widgets[i].type == type) {
			return ed_widgets[i].name;
		}
	}
	for(uint32_t i = 0; i < ED_CONTAINER_COUNT; ++i) {
		if(ed_containers[i].type == type) {
			return ed_containers[i].name;
		}
	}

	if(type == MKGUI_TAB) {
		return "Tab";
	}

	if(type == MKGUI_MENUITEM) {
		return "MenuItem";
	}
	return "Unknown";
}

// ---------------------------------------------------------------------------
// Editor widget (designed widget)
// ---------------------------------------------------------------------------

struct ed_widget {
	uint32_t type;
	uint32_t id;
	uint32_t parent_id;
	int32_t w, h;
	uint32_t flags;
	uint32_t style;
	uint32_t weight;
	int32_t margin_l, margin_r, margin_t, margin_b;
	int32_t label_tw;
	char label[MKGUI_MAX_TEXT];
	char icon[MKGUI_ICON_NAME_LEN];
	char icon_source[1024];
	char id_name[64];
	int32_t x, y;
	uint32_t tab_order;
	uint64_t event_mask;
	uint32_t accel_keymod;
	uint32_t accel_keysym;
};

// ---------------------------------------------------------------------------
// Undo snapshot
// ---------------------------------------------------------------------------

struct ed_snapshot {
	struct ed_widget *widgets;
	uint32_t widget_count;
	uint32_t widget_cap;
};

// ---------------------------------------------------------------------------
// Widget data (dropdown items, etc.)
// ---------------------------------------------------------------------------

#define ED_MAX_DATA_WIDGETS 64
#define ED_MAX_DATA_ITEMS   64

struct ed_widget_data {
	uint32_t widget_id;
	char items[ED_MAX_DATA_ITEMS][MKGUI_MAX_TEXT];
	uint32_t item_count;
};

// ---------------------------------------------------------------------------
// Editor tab state (tracks active tab per Tabs widget)
// ---------------------------------------------------------------------------

struct ed_tab_state {
	uint32_t tabs_id;
	uint32_t active_id;
};

// ---------------------------------------------------------------------------
// Editor state
// ---------------------------------------------------------------------------

struct ed_state {
	struct ed_widget widgets[ED_MAX_WIDGETS];
	uint32_t widget_count;

	int32_t selected;
	uint32_t placement_type;
	uint32_t next_id;

	int32_t canvas_w, canvas_h;
	int32_t grid_size;

	int32_t drag_active;
	int32_t drag_ox, drag_oy;
	int32_t resize_handle;
	int32_t resize_start_x, resize_start_y, resize_start_w, resize_start_h;
	uint32_t canvas_resize_edge;

	struct ed_snapshot undo[ED_MAX_UNDO];
	uint32_t undo_pos;
	uint32_t undo_count;

	char project_path[FD_PATH_SIZE + 260];

	struct ed_tab_state tab_states[32];
	uint32_t tab_state_count;

	struct ed_widget_data widget_data[ED_MAX_DATA_WIDGETS];
	uint32_t widget_data_count;

	uint32_t accel_capture;
};

static struct ed_state ed;
static union {
	struct mkgui_widget test_widgets[ED_MAX_WIDGETS];
	struct ed_widget reorder[ED_MAX_WIDGETS];
	struct { char name[MKGUI_ICON_NAME_LEN]; char source[1024]; } seen_icons[256];
} ed_scratch;

// ---------------------------------------------------------------------------
// Editor config (recent files, settings)
// ---------------------------------------------------------------------------

#define ED_MAX_RECENT     10
#define ED_CONFIG_PATH_LEN 512

struct ed_config {
	char recent[ED_MAX_RECENT][ED_CONFIG_PATH_LEN];
	uint32_t recent_count;
	char last_dir[ED_CONFIG_PATH_LEN];
	int32_t window_w, window_h;
};

static struct ed_config ed_cfg;

// [=]===^=[ ed_config_dir ]=======================================[=]
static void ed_config_dir(char *buf, uint32_t buf_size) {
	char *xdg = getenv("XDG_CONFIG_HOME");
	if(xdg && xdg[0]) {
		snprintf(buf, buf_size, "%s/mkgui-editor", xdg);
	} else {
		char *home = getenv("HOME");
		if(!home) {
			home = "/tmp";
		}
		snprintf(buf, buf_size, "%s/.config/mkgui-editor", home);
	}
}

// [=]===^=[ ed_config_path ]======================================[=]
static void ed_config_path(char *buf, uint32_t buf_size) {
	char dir[ED_CONFIG_PATH_LEN];
	ed_config_dir(dir, sizeof(dir));
	snprintf(buf, buf_size, "%.504s/config", dir);
}

// [=]===^=[ ed_config_ensure_dir ]================================[=]
static void ed_config_ensure_dir(void) {
	char dir[ED_CONFIG_PATH_LEN];
	ed_config_dir(dir, sizeof(dir));

	char parent[ED_CONFIG_PATH_LEN];
	char *xdg = getenv("XDG_CONFIG_HOME");
	if(xdg && xdg[0]) {
		snprintf(parent, sizeof(parent), "%s", xdg);
	} else {
		char *home = getenv("HOME");
		if(!home) {
			home = "/tmp";
		}
		snprintf(parent, sizeof(parent), "%s/.config", home);
	}
#ifdef _WIN32
	CreateDirectoryA(parent, NULL);
	CreateDirectoryA(dir, NULL);
#else
	mkdir(parent, 0755);
	mkdir(dir, 0755);
#endif
}

// [=]===^=[ ed_config_load ]======================================[=]
static void ed_config_load(void) {
	memset(&ed_cfg, 0, sizeof(ed_cfg));

	char path[ED_CONFIG_PATH_LEN];
	ed_config_path(path, sizeof(path));

	FILE *f = fopen(path, "r");
	if(!f) {
		return;
	}

	char line[1024];
	while(fgets(line, (int32_t)sizeof(line), f)) {
		size_t len = strlen(line);
		while(len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
			line[--len] = '\0';
		}

		if(len == 0) {
			continue;
		}

		if(strncmp(line, "file ", 5) == 0 && ed_cfg.recent_count < ED_MAX_RECENT) {
			snprintf(ed_cfg.recent[ed_cfg.recent_count], ED_CONFIG_PATH_LEN, "%.511s", line + 5);
			++ed_cfg.recent_count;

		} else if(strncmp(line, "last_dir ", 9) == 0) {
			snprintf(ed_cfg.last_dir, ED_CONFIG_PATH_LEN, "%.511s", line + 9);

		} else if(strncmp(line, "window_size ", 12) == 0) {
			sscanf(line + 12, "%d %d", &ed_cfg.window_w, &ed_cfg.window_h);
		}
	}

	fclose(f);
}

// [=]===^=[ ed_config_save ]======================================[=]
static void ed_config_save(void) {
	ed_config_ensure_dir();

	char path[ED_CONFIG_PATH_LEN];
	ed_config_path(path, sizeof(path));

	FILE *f = fopen(path, "w");
	if(!f) {
		return;
	}

	fprintf(f, "[recent]\n");
	for(uint32_t i = 0; i < ed_cfg.recent_count; ++i) {
		fprintf(f, "file %s\n", ed_cfg.recent[i]);
	}
	fprintf(f, "\n[settings]\n");
	if(ed_cfg.last_dir[0]) {
		fprintf(f, "last_dir %s\n", ed_cfg.last_dir);
	}

	if(ed_cfg.window_w > 0 && ed_cfg.window_h > 0) {
		fprintf(f, "window_size %d %d\n", ed_cfg.window_w, ed_cfg.window_h);
	}

	fclose(f);
}

// [=]===^=[ ed_config_add_recent ]================================[=]
static void ed_config_add_recent(const char *filepath) {
	for(uint32_t i = 0; i < ed_cfg.recent_count; ++i) {
		if(strcmp(ed_cfg.recent[i], filepath) == 0) {
			for(uint32_t j = i; j > 0; --j) {
				memcpy(ed_cfg.recent[j], ed_cfg.recent[j - 1], ED_CONFIG_PATH_LEN);
			}
			snprintf(ed_cfg.recent[0], ED_CONFIG_PATH_LEN, "%s", filepath);
			ed_config_save();
			return;
		}
	}

	uint32_t count = ed_cfg.recent_count;
	if(count >= ED_MAX_RECENT) {
		count = ED_MAX_RECENT - 1;
	}
	for(uint32_t j = count; j > 0; --j) {
		memcpy(ed_cfg.recent[j], ed_cfg.recent[j - 1], ED_CONFIG_PATH_LEN);
	}
	snprintf(ed_cfg.recent[0], ED_CONFIG_PATH_LEN, "%s", filepath);
	if(ed_cfg.recent_count < ED_MAX_RECENT) {
		++ed_cfg.recent_count;
	}

	const char *slash = strrchr(filepath, '/');
	if(slash) {
		size_t dir_len = (size_t)(slash - filepath);
		if(dir_len >= ED_CONFIG_PATH_LEN) {
			dir_len = ED_CONFIG_PATH_LEN - 1;
		}
		memcpy(ed_cfg.last_dir, filepath, dir_len);
		ed_cfg.last_dir[dir_len] = '\0';
	}

	ed_config_save();
}

// [=]===^=[ ed_sync_recent_menu ]=================================[=]
static void ed_sync_recent_menu(struct mkgui_window *win) {
	for(uint32_t i = 0; i < ED_MAX_RECENT; ++i) {
		uint32_t id = ED_RECENT_FIRST + i;
		struct mkgui_widget *w = find_widget(win, id);
		if(!w) {
			continue;
		}

		if(i < ed_cfg.recent_count) {
			w->flags &= ~MKGUI_HIDDEN;
			char *path = ed_cfg.recent[i];
			char *fname = strrchr(path, '/');
			if(fname) {
				++fname;
			} else {
				fname = path;
			}
			snprintf(w->label, MKGUI_MAX_TEXT, "%.255s", fname);
			w->label_tw = -1;
		} else {
			w->flags |= MKGUI_HIDDEN;
		}
	}
}

// ---------------------------------------------------------------------------
// Help popup
// ---------------------------------------------------------------------------

struct ed_help_entry {
	uint32_t type;
	char *text;
};

static struct ed_help_entry ed_help[] = {
	{ MKGUI_BUTTON,    "Push button. Emits a click event when pressed. Set label for text, icon for an icon." },
	{ MKGUI_CANVAS,    "Custom drawing area. Set a callback to draw into the widget's pixel buffer. Clipping is automatic." },
	{ MKGUI_CHECKBOX,  "Toggle checkbox with a label. Checked state is a flag on the widget. Emits a change event on click." },
	{ MKGUI_DROPDOWN,  "Drop-down selector. Set up items with mkgui_dropdown_setup(). Opens a popup list on click." },
	{ MKGUI_GLVIEW,    "OpenGL viewport. Creates a native child window for GL rendering. You create and manage the GL context." },
	{ MKGUI_IMAGE,     "Displays ARGB pixel data. Centered and scaled down to fit. Use PANEL_BORDER for a frame, IMAGE_STRETCH to fill." },
	{ MKGUI_INPUT,     "Single-line text input. Supports clipboard, cursor movement, and selection. PASSWORD flag hides text." },
	{ MKGUI_IPINPUT,   "IPv4 address input. Four 0-255 fields separated by dots. Tab/dot advances fields. Emits IPINPUT_CHANGED." },
	{ MKGUI_TOGGLE,    "On/off toggle switch. Click or spacebar toggles. Visual pill-shaped track with sliding knob." },
	{ MKGUI_COMBOBOX,  "Editable dropdown. Type to filter items, arrow keys to navigate, Enter to select. Supports freeform text." },
	{ MKGUI_DATEPICKER,"Date picker. Shows YYYY-MM-DD. Click calendar button for a popup calendar. Editable text field." },
	{ MKGUI_GRIDVIEW,  "Multi-column grid with checkboxes. Virtual data via callback. Per-cell checkbox state, grid lines, vertical scrolling." },
	{ MKGUI_RICHLIST,  "Rich list with thumbnail, title, subtitle, and right-aligned text per row. Virtual data via callback. Vertical scrolling." },
	{ MKGUI_ITEMVIEW,  "Multi-mode item view: icons, thumbnails, compact list, or detail. Uses callbacks for labels and icons." },
	{ MKGUI_LABEL,     "Static text display. Not interactive. Use mkgui_label_set() to change text at runtime." },
	{ MKGUI_LISTVIEW,  "Scrollable multi-column list. Fully virtual (callback provides data). Supports sorting, column reorder, row drag." },
	{ MKGUI_METER,     "Level meter with colored zones (green/yellow/red). MKGUI_VERTICAL for vertical, MKGUI_METER_TEXT for percentage. Set zones with mkgui_meter_set_zones()." },
	{ MKGUI_PROGRESS,  "Progress bar with animated shimmer. Set value/max with mkgui_progress_set(). No user interaction." },
	{ MKGUI_RADIO,     "Radio button. Mutually exclusive within the same parent container. Clicking one unchecks siblings." },
	{ MKGUI_SCROLLBAR, "Standalone scrollbar. Horizontal by default, set MKGUI_VERTICAL for vertical. Emits scroll events." },
	{ MKGUI_DIVIDER,   "Visual separator line. Horizontal by default, MKGUI_VERTICAL for vertical. Draws an etched line in the parent container." },
	{ MKGUI_SPACER,    "Invisible spacer. Use w=0 or h=0 for flex fill inside HBox/VBox. Pushes siblings to the opposite edge." },
	{ MKGUI_SLIDER,    "Slider with draggable thumb. MKGUI_VERTICAL for vertical, MKGUI_SLIDER_MIXER for tapered volume style with meter support. Set range with mkgui_slider_setup()." },
	{ MKGUI_SPINBOX,   "Numeric input with +/- buttons. Click text to type, use arrows or mouse wheel to step. Enter confirms." },
	{ MKGUI_SPINNER,   "Animated spinning arc. Place it as a loading indicator. Animates automatically when visible, zero CPU when hidden." },
	{ MKGUI_STATUSBAR, "Status bar with multiple sections. Set section widths (positive=fixed, negative=flex) and text per section." },
	{ MKGUI_TEXTAREA,  "Multi-line text editor. Supports clipboard, selection, and scrolling. READONLY flag disables editing." },
	{ MKGUI_LOGVIEW,   "Append-only scrolling log view with ANSI color parsing, word wrap, and selection. Configure capacity with mkgui_logview_setup() before appending. NOWRAP flag disables wrapping." },
	{ MKGUI_TREEVIEW,  "Hierarchical tree with expand/collapse. Supports drag-and-drop reordering of nodes." },
	{ MKGUI_TREELIST,  "Columned tree (tree-table). Multi-column rows that nest into an expandable hierarchy; twisty and indent live in column 0. Sorting a header reorders siblings within each parent. Populate with mkgui_treelist_setup()/mkgui_treelist_add()." },
	{ MKGUI_FORM,      "Two-column form layout. Children are paired: label on the left, control on the right. Label column auto-sizes." },
	{ MKGUI_GROUP,     "Bordered container with a title label. Children are inset inside the frame. Useful for grouping related controls." },
	{ MKGUI_HBOX,      "Horizontal box layout. Stacks children left-to-right with 6px gap. Children with w=0 flex to fill remaining space. SCROLL flag enables horizontal scrolling." },
	{ MKGUI_VBOX,      "Vertical box layout. Stacks children top-to-bottom with 6px gap. Children with h=0 flex to fill remaining space. SCROLL flag enables scrolling." },
	{ MKGUI_HSPLIT,    "Horizontal splitter. Divides area into top and bottom regions with a draggable divider. Children use REGION_TOP/BOTTOM flags." },
	{ MKGUI_VSPLIT,    "Vertical splitter. Divides area into left and right regions with a draggable divider. Children use REGION_LEFT/RIGHT flags." },
	{ MKGUI_MENU,      "Menu bar. Add MENUITEM children for top-level entries. Submenus are menuitems parented to other menuitems." },
	{ MKGUI_PANEL,     "Plain container. No border by default. Use PANEL_BORDER for a visible border, PANEL_SUNKEN for a recessed look." },
	{ MKGUI_TABS,      "Tab container. Children must be TAB widgets. Only the active tab's contents are visible and consume CPU." },
	{ MKGUI_TOOLBAR,   "Toolbar bar. Children are buttons rendered as icon-only toolbar buttons. Labels become tooltips on hover." },
};
#define ED_HELP_COUNT (sizeof(ed_help) / sizeof(ed_help[0]))

static char *ed_help_text;
static uint32_t ed_help_widget_id;

// [=]===^=[ ed_find_help ]========================================[=]
static char *ed_find_help(uint32_t type) {
	for(uint32_t i = 0; i < ED_HELP_COUNT; ++i) {
		if(ed_help[i].type == type) {
			return ed_help[i].text;
		}
	}
	return NULL;
}

// [=]===^=[ ed_render_help_popup ]================================[=]
static void ed_render_help_popup(struct mkgui_window *win, void *userdata) {
	(void)userdata;
	if(!ed_help_text || !ed_help_widget_id) {
		return;
	}

	int32_t widx = find_widget_idx(win, ed_help_widget_id);
	if(widx < 0) {
		return;
	}

	int32_t bx = win->rects[widx].x;
	int32_t by = win->rects[widx].y + win->rects[widx].h + 4;
	int32_t max_w = 300;
	int32_t pad = 8;
	int32_t line_h = win->font_height + 2;

	char *src = ed_help_text;
	int32_t lines = 0;
	int32_t actual_w = 0;
	while(*src) {
		int32_t line_w = 0;
		char *line_start = src;
		char *last_break = NULL;
		while(*src && *src != '\n') {
			char tmp[2] = { *src, 0 };
			int32_t cw = text_width(win, tmp);
			if(line_w + cw > max_w - pad * 2) {
				if(last_break) {
					src = last_break + 1;
				}
				break;
			}

			if(*src == ' ') {
				last_break = src;
			}
			line_w += cw;
			++src;
		}

		if(*src == '\n') {
			++src;
		}

		if(src == line_start && *src) {
			++src;
		}

		if(line_w > actual_w) {
			actual_w = line_w;
		}
		++lines;
	}

	int32_t pw = actual_w + pad * 2;
	int32_t ph = lines * line_h + pad * 2;

	if(bx + pw > win->win_w) {
		bx = win->win_w - pw;
	}

	if(by + ph > win->win_h) {
		by = win->rects[widx].y - ph - 4;
	}

	if(bx < 0) {
		bx = 0;
	}

	if(by < 0) {
		by = 0;
	}

	draw_rounded_rect(win->pixels, win->win_w, win->win_h, bx, by, pw, ph, win->theme.menu_bg, win->theme.highlight, win->theme.corner_radius);

	src = ed_help_text;
	int32_t ty = by + pad;
	while(*src) {
		int32_t line_w = 0;
		char *line_start = src;
		char *last_break = NULL;
		char *line_end = src;
		while(*src && *src != '\n') {
			char tmp[2] = { *src, 0 };
			int32_t cw = text_width(win, tmp);
			if(line_w + cw > max_w - pad * 2) {
				if(last_break) {
					line_end = last_break;
					src = last_break + 1;
				} else {
					line_end = src;
				}
				break;
			}

			if(*src == ' ') {
				last_break = src;
			}
			line_w += cw;
			++src;
			line_end = src;
		}

		if(*src == '\n') {
			++src;
		}

		if(src == line_start && *src) {
			++src;
			line_end = src;
		}

		char line_buf[256];
		uint32_t len = (uint32_t)(line_end - line_start);
		if(len >= sizeof(line_buf)) {
			len = sizeof(line_buf) - 1;
		}
		memcpy(line_buf, line_start, len);
		line_buf[len] = '\0';
		push_text_clip(bx + pad, ty, line_buf, win->theme.text, bx, by, bx + pw, by + ph);
		ty += line_h;
	}
}

// ---------------------------------------------------------------------------
// Property descriptor system
// ---------------------------------------------------------------------------

enum {
	ED_PK_LABEL,
	ED_PK_STRING,
	ED_PK_STRING_BROWSE,
	ED_PK_INT32,
	ED_PK_INT32_PAIR,
	ED_PK_FLAG,
	ED_PK_PARENT,
	ED_PK_ACTION,
	ED_PK_MENU_TREE,
	ED_PK_SECTION,
	ED_PK_ALIGN,
	ED_PK_ACCEL,
	ED_PK_TB_MODE,
};

enum {
	ED_VIS_ALWAYS    = 0,
	ED_VIS_HAS_CHECK = (1 << 0),
	ED_VIS_MENUITEM  = (1 << 1),
	ED_VIS_IN_SPLIT  = (1 << 2),
	ED_VIS_TABS      = (1 << 3),
	ED_VIS_MENU      = (1 << 4),
	ED_VIS_BOX       = (1 << 5),
	ED_VIS_BORDERABLE = (1 << 6),
	ED_VIS_INPUT     = (1 << 7),
	ED_VIS_IN_BOX    = (1 << 8),
	ED_VIS_TOOLBAR   = (1 << 9),
	ED_VIS_IN_TOOLBAR = (1 << 10),
	ED_VIS_SLIDER      = (1 << 11),
	ED_VIS_SLIDER_ONLY = (1 << 12),
	ED_VIS_LABEL       = (1 << 13),
	ED_VIS_METER       = (1 << 14),
	ED_VIS_GROUP       = (1 << 15),
	ED_VIS_ACCELABLE   = (1 << 16),
	ED_VIS_INPUT_ONLY  = (1 << 17),
	ED_VIS_TAB_CHILD   = (1 << 18),
	ED_VIS_HAS_MULTI   = (1 << 19),
	ED_VIS_IMAGE       = (1 << 20),
	ED_VIS_PROGRESS    = (1 << 21),
	ED_VIS_WINDOW      = (1 << 22),
	ED_VIS_BUTTON      = (1 << 23),
	ED_VIS_TOGGLE      = (1 << 24),
	ED_VIS_LOGVIEW     = (1 << 25),
	ED_VIS_DATEPICKER  = (1 << 26),
	ED_VIS_TEXTAREA_ONLY = (1 << 27),
	ED_VIS_LV_EDITABLE = (1 << 28),
	ED_VIS_TV_EDITABLE = (1 << 29),
	ED_VIS_IV_EDITABLE = (1 << 30),
};

enum {
	ED_ACT_NONE = 0,
	ED_ACT_ICON_BROWSE,
	ED_ACT_ADD_TAB,
	ED_ACT_REM_TAB,
	ED_ACT_ADD_ITEM,
	ED_ACT_REM_ITEM,
	ED_ACT_ADD_TB_BTN,
	ED_ACT_REM_TB_BTN,
};

struct ed_prop_desc {
	uint32_t kind;
	char *label;
	uint32_t offset;
	uint32_t flag_bit;
	int32_t min_val, max_val;
	uint32_t vis_mask;
	uint32_t action;
	uint32_t widget_id;
	uint32_t label_id;
	uint32_t widget_id2;
	uint32_t label_id2;
};

static struct ed_prop_desc ed_props[] = {
	{ ED_PK_LABEL,         "Type:",           0,                                        0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_TYPE_VAL,     ED_PROP_TYPE_LBL,    0,                 0 },
	{ ED_PK_STRING,        "ID:",             offsetof(struct ed_widget, id_name),       0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_ID_INP,       ED_PROP_ID_LBL,      0,                 0 },
	{ ED_PK_STRING,        "Label:",          offsetof(struct ed_widget, label),         0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_LABEL_INP,    ED_PROP_LABEL_LBL,   0,                 0 },
	{ ED_PK_STRING_BROWSE, "Icon:",           offsetof(struct ed_widget, icon),          0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_ICON_BROWSE,  ED_PROP_ICON_INP,     ED_PROP_ICON_LBL,    ED_PROP_ICON_BROWSE, ED_PROP_ICON_HBOX },
	{ ED_PK_PARENT,        "Parent:",         offsetof(struct ed_widget, parent_id),     0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_PARENT_DRP,   ED_PROP_PARENT_LBL,  0,                 0 },
	{ ED_PK_INT32,         "Tab#:",           offsetof(struct ed_widget, tab_order),     0,                  0,      999,  ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_TAB_SPN,      ED_PROP_TAB_LBL,     0,                 0 },
	{ ED_PK_INT32_PAIR,    "W:",              offsetof(struct ed_widget, w),             0,                  0,      9999, ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_W_SPN,        ED_PROP_W_LBL,       ED_PROP_H_SPN,     ED_PROP_H_LBL },
	{ ED_PK_INT32_PAIR,    "ML:",             offsetof(struct ed_widget, margin_l),      0,                  0,      9999, ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_ML_SPN,       ED_PROP_ML_LBL,      ED_PROP_MR_SPN,    ED_PROP_MR_LBL },
	{ ED_PK_INT32_PAIR,    "MT:",             offsetof(struct ed_widget, margin_t),      0,                  0,      9999, ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_MT_SPN,       ED_PROP_MT_LBL,      ED_PROP_MB_SPN,    ED_PROP_MB_LBL },
	{ ED_PK_SECTION,       "Flags:",           0,                                        0,                  0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_FLAGS_LBL,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "Hidden",          offsetof(struct ed_widget, flags),         MKGUI_HIDDEN,       0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_FL_HIDDEN,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "Disabled",        offsetof(struct ed_widget, flags),         MKGUI_DISABLED,     0,      0,    ED_VIS_ALWAYS,    ED_ACT_NONE,         ED_PROP_FL_DISABLED,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Checked",         offsetof(struct ed_widget, style),         MKGUI_CHECKBOX_CHECKED,  0,   0,    ED_VIS_HAS_CHECK, ED_ACT_NONE,         ED_PROP_FL_CHECKED,   0,                   0,                 0 },
	{ ED_PK_FLAG,          "Checked",         offsetof(struct ed_widget, style),         MKGUI_MENUITEM_CHECKED,  0,   0,    ED_VIS_MENUITEM,  ED_ACT_NONE,         ED_PROP_FL_MI_CHECKED, 0,                  0,                 0 },
	{ ED_PK_FLAG,          "Sep",             offsetof(struct ed_widget, style),         MKGUI_MENUITEM_SEPARATOR, 0,  0,    ED_VIS_MENUITEM,  ED_ACT_NONE,         ED_PROP_FL_SEPARATOR, 0,                   0,                 0 },
	{ ED_PK_FLAG,          "MChk",            offsetof(struct ed_widget, style),         MKGUI_MENUITEM_CHECK, 0,      0,    ED_VIS_MENUITEM,  ED_ACT_NONE,         ED_PROP_FL_MENUCHECK, 0,                   0,                 0 },
	{ ED_PK_FLAG,          "MRad",            offsetof(struct ed_widget, style),         MKGUI_MENUITEM_RADIO, 0,      0,    ED_VIS_MENUITEM,  ED_ACT_NONE,         ED_PROP_FL_MENURADIO, 0,                   0,                 0 },
	{ ED_PK_FLAG,          "RgnTop",          offsetof(struct ed_widget, flags),         MKGUI_REGION_TOP,   0,      0,    ED_VIS_IN_SPLIT,  ED_ACT_NONE,         ED_PROP_FL_REGTOP,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "RgnBot",          offsetof(struct ed_widget, flags),         MKGUI_REGION_BOTTOM,0,      0,    ED_VIS_IN_SPLIT,  ED_ACT_NONE,         ED_PROP_FL_REGBOT,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "RgnLeft",         offsetof(struct ed_widget, flags),         MKGUI_REGION_LEFT,  0,      0,    ED_VIS_IN_SPLIT,  ED_ACT_NONE,         ED_PROP_FL_REGLEFT,   0,                   0,                 0 },
	{ ED_PK_FLAG,          "RgnRight",        offsetof(struct ed_widget, flags),         MKGUI_REGION_RIGHT, 0,      0,    ED_VIS_IN_SPLIT,  ED_ACT_NONE,         ED_PROP_FL_REGRIGHT,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Scroll",          offsetof(struct ed_widget, flags),         MKGUI_SCROLL,       0,      0,    ED_VIS_BOX,       ED_ACT_NONE,         ED_PROP_FL_SCROLL,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "Border",          offsetof(struct ed_widget, style),         MKGUI_PANEL_BORDER, 0,      0,    ED_VIS_BORDERABLE,ED_ACT_NONE,         ED_PROP_FL_BORDER,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "Sunken",          offsetof(struct ed_widget, style),         MKGUI_PANEL_SUNKEN, 0,      0,    ED_VIS_BORDERABLE,ED_ACT_NONE,         ED_PROP_FL_SUNKEN,    0,                   0,                 0 },
	{ ED_PK_FLAG,          "No Pad",          offsetof(struct ed_widget, flags),         MKGUI_NO_PAD,       0,      0,    ED_VIS_BOX,       ED_ACT_NONE,         ED_PROP_FL_NOPAD,     0,                   0,                 0 },
	{ ED_PK_FLAG,          "Password",        offsetof(struct ed_widget, style),         MKGUI_INPUT_PASSWORD, 0,     0,    ED_VIS_INPUT_ONLY, ED_ACT_NONE,         ED_PROP_FL_PASSWORD,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Readonly",        offsetof(struct ed_widget, style),         MKGUI_INPUT_READONLY, 0,     0,    ED_VIS_INPUT_ONLY, ED_ACT_NONE,        ED_PROP_FL_READONLY,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Readonly",        offsetof(struct ed_widget, style),         MKGUI_TEXTAREA_READONLY, 0,  0,    ED_VIS_TEXTAREA_ONLY, ED_ACT_NONE,     ED_PROP_FL_TA_READONLY, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Fixed",          offsetof(struct ed_widget, flags),         MKGUI_FIXED,        0,      0,    ED_VIS_IN_BOX,    ED_ACT_NONE,         ED_PROP_FL_FIXED,     0,                   0,                 0 },
	{ ED_PK_INT32,         "Weight:",        offsetof(struct ed_widget, weight),        0,                  0,    999,    ED_VIS_IN_BOX,    ED_ACT_NONE,         ED_PROP_WEIGHT_SPN,   ED_PROP_WEIGHT_LBL,  0,                 ED_PROP_WEIGHT_HBOX },
	{ ED_PK_ALIGN,         "Align:",         0,                                        0,                  0,      0,    ED_VIS_IN_BOX,    ED_ACT_NONE,         ED_PROP_ALIGN_DRP,    ED_PROP_ALIGN_LBL,   0,                 0 },
	{ ED_PK_ACTION,        "Add Tab",         0,                                        0,                  0,      0,    ED_VIS_TABS,      ED_ACT_ADD_TAB,      ED_PROP_ADD_TAB,      0,                   0,                 0 },
	{ ED_PK_ACTION,        "Remove Tab",      0,                                        0,                  0,      0,    ED_VIS_TABS,      ED_ACT_REM_TAB,      ED_PROP_REM_TAB,      0,                   0,                 0 },
	{ ED_PK_ACTION,        "Add Item",        0,                                        0,                  0,      0,    ED_VIS_MENU,      ED_ACT_ADD_ITEM,     ED_PROP_ADD_ITEM,     0,                   0,                 0 },
	{ ED_PK_ACTION,        "Remove Item",     0,                                        0,                  0,      0,    ED_VIS_MENU,      ED_ACT_REM_ITEM,     ED_PROP_REM_ITEM,     0,                   0,                 0 },
	{ ED_PK_ACTION,        "Add Button",      0,                                        0,                  0,      0,    ED_VIS_TOOLBAR,   ED_ACT_ADD_TB_BTN,   ED_PROP_ADD_TB_BTN,   0,                   0,                 0 },
	{ ED_PK_ACTION,        "Remove Button",   0,                                        0,                  0,      0,    ED_VIS_TOOLBAR,   ED_ACT_REM_TB_BTN,   ED_PROP_REM_TB_BTN,   0,                   0,                 0 },
	{ ED_PK_TB_MODE,       "Mode:",           0,                                        0,                  0,      0,    ED_VIS_TOOLBAR,   ED_ACT_NONE,         ED_PROP_TB_MODE_DRP,  ED_PROP_TB_MODE_LBL, 0,                 0 },
	{ ED_PK_FLAG,          "Sep",             offsetof(struct ed_widget, style),         MKGUI_BUTTON_SEPARATOR, 0,   0,    ED_VIS_IN_TOOLBAR,ED_ACT_NONE,         ED_PROP_FL_TBSEP,     0,                   0,                 0 },
	{ ED_PK_FLAG,          "Vertical",       offsetof(struct ed_widget, flags),         MKGUI_VERTICAL,     0,      0,    ED_VIS_SLIDER,    ED_ACT_NONE,         ED_PROP_FL_VERTICAL,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Mixer",          offsetof(struct ed_widget, style),         MKGUI_SLIDER_MIXER, 0,      0,    ED_VIS_SLIDER_ONLY,ED_ACT_NONE,        ED_PROP_FL_MIXER,     0,                   0,                 0 },
	{ ED_PK_FLAG,          "Truncate",       offsetof(struct ed_widget, style),         MKGUI_LABEL_TRUNCATE, 0,     0,    ED_VIS_LABEL,      ED_ACT_NONE,        ED_PROP_FL_TRUNCATE,  0,                   0,                 0 },
	{ ED_PK_FLAG,          "Show %",         offsetof(struct ed_widget, style),         MKGUI_METER_TEXT,   0,      0,    ED_VIS_METER,      ED_ACT_NONE,        ED_PROP_FL_METER_TEXT, 0,                   0,                 0 },
	{ ED_PK_FLAG,          "Link",           offsetof(struct ed_widget, style),         MKGUI_LABEL_LINK,   0,      0,    ED_VIS_LABEL,      ED_ACT_NONE,        ED_PROP_FL_LINK,      0,                   0,                 0 },
	{ ED_PK_FLAG,          "Wrap",           offsetof(struct ed_widget, style),         MKGUI_LABEL_WRAP,   0,      0,    ED_VIS_LABEL,      ED_ACT_NONE,        ED_PROP_FL_WRAP,      0,                   0,                 0 },
	{ ED_PK_FLAG,          "Collapsible",    offsetof(struct ed_widget, style),         MKGUI_GROUP_COLLAPSIBLE, 0,  0,    ED_VIS_GROUP,      ED_ACT_NONE,        ED_PROP_FL_COLLAPSIBLE, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Collapsed",      offsetof(struct ed_widget, style),         MKGUI_GROUP_COLLAPSED, 0,    0,    ED_VIS_GROUP,      ED_ACT_NONE,        ED_PROP_FL_COLLAPSED, 0,                   0,                 0 },
	{ ED_PK_FLAG,          "Numeric",        offsetof(struct ed_widget, style),         MKGUI_INPUT_NUMERIC, 0,      0,    ED_VIS_INPUT_ONLY, ED_ACT_NONE,        ED_PROP_FL_NUMERIC,   0,                   0,                 0 },
	{ ED_PK_FLAG,          "Closable",      offsetof(struct ed_widget, style),         MKGUI_TAB_CLOSABLE, 0,      0,    ED_VIS_TAB_CHILD,  ED_ACT_NONE,        ED_PROP_FL_TAB_CLOSABLE, 0,                0,                 0 },
	{ ED_PK_FLAG,          "Shimmer",       offsetof(struct ed_widget, style),         MKGUI_PROGRESS_SHIMMER, 0,  0,    ED_VIS_PROGRESS,   ED_ACT_NONE,        ED_PROP_FL_SHIMMER,   0,                   0,                 0 },
	{ ED_PK_FLAG,          "MultiSel",      offsetof(struct ed_widget, style),         MKGUI_LISTVIEW_MULTI_SELECT, 0, 0, ED_VIS_HAS_MULTI, ED_ACT_NONE,        ED_PROP_FL_MULTI_SELECT, 0,                0,                 0 },
	{ ED_PK_FLAG,          "Stretch",       offsetof(struct ed_widget, style),         MKGUI_IMAGE_STRETCH, 0,     0,    ED_VIS_IMAGE,      ED_ACT_NONE,        ED_PROP_FL_IMG_STRETCH, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Checked",       offsetof(struct ed_widget, style),         MKGUI_BUTTON_CHECKED, 0,    0,    ED_VIS_BUTTON,     ED_ACT_NONE,        ED_PROP_FL_BTN_CHECKED, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Checked",       offsetof(struct ed_widget, style),         MKGUI_TOGGLE_CHECKED, 0,    0,    ED_VIS_TOGGLE,     ED_ACT_NONE,        ED_PROP_FL_TOG_CHECKED, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "NoWrap",        offsetof(struct ed_widget, style),         MKGUI_LOGVIEW_NOWRAP, 0,    0,    ED_VIS_LOGVIEW,    ED_ACT_NONE,        ED_PROP_FL_LOG_NOWRAP, 0,                  0,                 0 },
	{ ED_PK_FLAG,          "Readonly",      offsetof(struct ed_widget, style),         MKGUI_DATEPICKER_READONLY, 0, 0,  ED_VIS_DATEPICKER, ED_ACT_NONE,        ED_PROP_FL_DP_READONLY, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Editable",      offsetof(struct ed_widget, style),         MKGUI_LISTVIEW_EDITABLE, 0, 0,    ED_VIS_LV_EDITABLE,ED_ACT_NONE,        ED_PROP_FL_LV_EDITABLE, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Editable",      offsetof(struct ed_widget, style),         MKGUI_TREEVIEW_EDITABLE, 0, 0,    ED_VIS_TV_EDITABLE,ED_ACT_NONE,        ED_PROP_FL_TV_EDITABLE, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "Editable",      offsetof(struct ed_widget, style),         MKGUI_ITEMVIEW_EDITABLE, 0, 0,    ED_VIS_IV_EDITABLE,ED_ACT_NONE,        ED_PROP_FL_IV_EDITABLE, 0,                 0,                 0 },
	{ ED_PK_FLAG,          "WinHidden",    offsetof(struct ed_widget, style),         MKGUI_WINDOW_HIDDEN, 0,     0,    ED_VIS_WINDOW,     ED_ACT_NONE,        ED_PROP_FL_WIN_HIDDEN, 0,                  0,                 0 },
	{ ED_PK_FLAG,          "HideClose",    offsetof(struct ed_widget, style),         MKGUI_WINDOW_HIDE_ON_CLOSE, 0, 0, ED_VIS_WINDOW,     ED_ACT_NONE,        ED_PROP_FL_WIN_HIDE_CLOSE, 0,              0,                 0 },
	{ ED_PK_FLAG,          "NoDeco",       offsetof(struct ed_widget, style),         MKGUI_WINDOW_UNDECORATED, 0, 0,   ED_VIS_WINDOW,     ED_ACT_NONE,        ED_PROP_FL_WIN_UNDECORATED, 0,             0,                 0 },
	{ ED_PK_FLAG,          "CanvasWin",    offsetof(struct ed_widget, style),         MKGUI_WINDOW_CANVAS, 0,     0,    ED_VIS_WINDOW,     ED_ACT_NONE,        ED_PROP_FL_WIN_CANVAS, 0,                  0,                 0 },
	{ ED_PK_ACCEL,         "Accel:",         0,                                        0,                  0,      0,    ED_VIS_ACCELABLE,  ED_ACT_NONE,        ED_PROP_ACCEL_BTN,    ED_PROP_ACCEL_LBL,   ED_PROP_ACCEL_CLEAR, ED_PROP_ACCEL_HBOX },
	{ ED_PK_MENU_TREE,     "",                0,                                        0,                  0,      0,    ED_VIS_MENU,      ED_ACT_NONE,         ED_MENU_TREE,         0,                   0,                 0 },
};
#define ED_PROP_COUNT (sizeof(ed_props) / sizeof(ed_props[0]))

// [=]===^=[ ed_compute_vis_mask ]=================================[=]
static uint32_t ed_compute_vis_mask(struct ed_widget *w) {
	uint32_t mask = 0;
	if(w->type == MKGUI_WINDOW) {
		mask |= ED_VIS_WINDOW;
	}

	if(w->type == MKGUI_CHECKBOX || w->type == MKGUI_RADIO) {
		mask |= ED_VIS_HAS_CHECK;
	}

	if(w->type == MKGUI_MENUITEM) {
		mask |= ED_VIS_MENUITEM;
	}

	if(w->type == MKGUI_TABS) {
		mask |= ED_VIS_TABS;
	}

	if(w->type == MKGUI_TOOLBAR) {
		mask |= ED_VIS_TOOLBAR;
	}

	if(w->type == MKGUI_VBOX || w->type == MKGUI_HBOX) {
		mask |= ED_VIS_BOX;
	}

	if(w->type == MKGUI_VBOX || w->type == MKGUI_HBOX || w->type == MKGUI_FORM || w->type == MKGUI_PANEL || w->type == MKGUI_IMAGE || w->type == MKGUI_GLVIEW || w->type == MKGUI_CANVAS) {
		mask |= ED_VIS_BORDERABLE;
	}

	if(w->type == MKGUI_INPUT || w->type == MKGUI_TEXTAREA) {
		mask |= ED_VIS_INPUT;
	}

	if(w->type == MKGUI_INPUT) {
		mask |= ED_VIS_INPUT_ONLY;
	}

	if(w->type == MKGUI_LISTVIEW || w->type == MKGUI_GRIDVIEW || w->type == MKGUI_TREEVIEW || w->type == MKGUI_TREELIST) {
		mask |= ED_VIS_HAS_MULTI;
	}

	if(w->type == MKGUI_IMAGE) {
		mask |= ED_VIS_IMAGE;
	}

	if(w->type == MKGUI_PROGRESS) {
		mask |= ED_VIS_PROGRESS;
	}

	if(w->type == MKGUI_SLIDER || w->type == MKGUI_SCROLLBAR || w->type == MKGUI_METER) {
		mask |= ED_VIS_SLIDER;
	}

	if(w->type == MKGUI_SLIDER) {
		mask |= ED_VIS_SLIDER_ONLY;
	}

	if(w->type == MKGUI_METER) {
		mask |= ED_VIS_METER;
	}

	if(w->type == MKGUI_LABEL) {
		mask |= ED_VIS_LABEL;
	}

	if(w->type == MKGUI_GROUP) {
		mask |= ED_VIS_GROUP;
	}

	if(w->type == MKGUI_BUTTON || w->type == MKGUI_MENUITEM) {
		mask |= ED_VIS_ACCELABLE;
	}

	if(w->type == MKGUI_MENU || w->type == MKGUI_MENUITEM) {
		mask |= ED_VIS_MENU;
	}

	if(w->type == MKGUI_BUTTON) {
		mask |= ED_VIS_BUTTON;
	}

	if(w->type == MKGUI_TOGGLE) {
		mask |= ED_VIS_TOGGLE;
	}

	if(w->type == MKGUI_LOGVIEW) {
		mask |= ED_VIS_LOGVIEW;
	}

	if(w->type == MKGUI_DATEPICKER) {
		mask |= ED_VIS_DATEPICKER;
	}

	if(w->type == MKGUI_TEXTAREA) {
		mask |= ED_VIS_TEXTAREA_ONLY;
	}

	if(w->type == MKGUI_LISTVIEW) {
		mask |= ED_VIS_LV_EDITABLE;
	}

	if(w->type == MKGUI_TREEVIEW) {
		mask |= ED_VIS_TV_EDITABLE;
	}

	if(w->type == MKGUI_ITEMVIEW) {
		mask |= ED_VIS_IV_EDITABLE;
	}
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].id == w->parent_id) {
			uint32_t pt = ed.widgets[i].type;
			if(pt == MKGUI_HSPLIT || pt == MKGUI_VSPLIT) {
				mask |= ED_VIS_IN_SPLIT;
			}

			if(pt == MKGUI_VBOX || pt == MKGUI_HBOX) {
				mask |= ED_VIS_IN_BOX;
			}

			if(pt == MKGUI_TOOLBAR) {
				mask |= ED_VIS_IN_TOOLBAR;
			}

			if(pt == MKGUI_TABS) {
				mask |= ED_VIS_TAB_CHILD;
			}
			break;
		}
	}
	return mask;
}

// [=]===^=[ ed_prop_visible ]=====================================[=]
static uint32_t ed_prop_visible(struct ed_prop_desc *p, uint32_t vis_mask) {
	return p->vis_mask == ED_VIS_ALWAYS || (vis_mask & p->vis_mask);
}

// [=]===^=[ ed_set_widget_vis ]===================================[=]
static void ed_set_widget_vis(struct mkgui_window *win, uint32_t id, uint32_t visible) {
	if(!id) {
		return;
	}
	struct mkgui_widget *w = find_widget(win, id);
	if(w) {
		if(visible) {
			w->flags &= ~MKGUI_HIDDEN;
		} else {
			w->flags |= MKGUI_HIDDEN;
		}
	}
}

// [=]===^=[ ed_sync_prop_value ]==================================[=]
static void ed_sync_prop_value(struct mkgui_window *win, struct ed_prop_desc *p, struct ed_widget *w) {
	switch(p->kind) {
		case ED_PK_LABEL: {
			mkgui_label_set(win, p->widget_id, ed_type_name(w->type));
		} break;

		case ED_PK_STRING:
		case ED_PK_STRING_BROWSE: {
			char *val = (char *)((char *)w + p->offset);
			mkgui_input_set(win, p->widget_id, val);
		} break;

		case ED_PK_INT32: {
			int32_t val = *(int32_t *)((char *)w + p->offset);
			mkgui_spinbox_set(win, p->widget_id, val);
		} break;

		case ED_PK_INT32_PAIR: {
			int32_t *vals = (int32_t *)((char *)w + p->offset);
			mkgui_spinbox_set(win, p->widget_id, vals[0]);
			mkgui_spinbox_set(win, p->widget_id2, vals[1]);
		} break;

		case ED_PK_FLAG: {
			struct mkgui_widget *fl = find_widget(win, p->widget_id);
			if(fl) {
				uint32_t *fld = (uint32_t *)((char *)w + p->offset);
				if(*fld & p->flag_bit) {
					fl->flags |= MKGUI_CHECKBOX_CHECKED;
				} else {
					fl->flags &= ~MKGUI_CHECKBOX_CHECKED;
				}
			}
		} break;

		case ED_PK_ALIGN: {
			uint32_t av = (w->flags & MKGUI_ALIGN_MASK) >> 25;
			struct mkgui_widget *drp = find_widget(win, p->widget_id);
			if(drp) {
				struct mkgui_dropdown_data *dd = find_dropdown_data(win, p->widget_id);
				if(dd) {
					dd->selected = (int32_t)av;
				}
			}
		} break;

		case ED_PK_TB_MODE: {
			uint32_t mode = w->style & MKGUI_TOOLBAR_MODE_MASK;
			struct mkgui_dropdown_data *dd = find_dropdown_data(win, p->widget_id);
			if(dd) {
				dd->selected = (int32_t)mode;
			}
		} break;

		case ED_PK_ACCEL: {
			if(w->accel_keysym) {
				char buf[64];
				accel_format_text(w->accel_keymod, w->accel_keysym, buf, sizeof(buf));
				mkgui_button_set_text(win, p->widget_id, buf);
			} else {
				mkgui_button_set_text(win, p->widget_id, "None");
			}
		} break;

		default: break;
	}
}

// [=]===^=[ ed_read_prop_value ]==================================[=]
static void ed_read_prop_value(struct mkgui_window *win, struct ed_prop_desc *p, struct ed_widget *w) {
	switch(p->kind) {
		case ED_PK_STRING:
		case ED_PK_STRING_BROWSE: {
			const char *val = mkgui_input_get(win, p->widget_id);
			if(val) {
				char *dst = (char *)w + p->offset;
				size_t cap;
				if(p->offset == offsetof(struct ed_widget, id_name)) {
					cap = sizeof(w->id_name);
				} else if(p->offset == offsetof(struct ed_widget, label)) {
					cap = sizeof(w->label);
				} else {
					cap = sizeof(w->icon);
				}
				size_t slen = strlen(val);
				if(slen >= cap) {
					slen = cap - 1;
				}
				memcpy(dst, val, slen);
				dst[slen] = '\0';
				if(p->offset == offsetof(struct ed_widget, label)) {
					w->label_tw = -1;
				}
			}
		} break;

		case ED_PK_INT32: {
			int32_t *dst = (int32_t *)((char *)w + p->offset);
			*dst = mkgui_spinbox_get(win, p->widget_id);
		} break;

		case ED_PK_INT32_PAIR: {
			int32_t *vals = (int32_t *)((char *)w + p->offset);
			vals[0] = mkgui_spinbox_get(win, p->widget_id);
			vals[1] = mkgui_spinbox_get(win, p->widget_id2);
		} break;

		case ED_PK_FLAG: {
			uint32_t *fld = (uint32_t *)((char *)w + p->offset);
			if(mkgui_checkbox_get(win, p->widget_id)) {
				*fld |= p->flag_bit;
			} else {
				*fld &= ~p->flag_bit;
			}
		} break;

		case ED_PK_ALIGN: {
			int32_t sel = mkgui_dropdown_get(win, p->widget_id);
			if(sel < 0) {
				sel = 0;
			}
			w->flags = (w->flags & ~MKGUI_ALIGN_MASK) | ((uint32_t)sel << 25);
		} break;

		case ED_PK_TB_MODE: {
			int32_t sel = mkgui_dropdown_get(win, p->widget_id);
			if(sel < 0) {
				sel = 0;
			}
			w->style = (w->style & ~MKGUI_TOOLBAR_MODE_MASK) | ((uint32_t)sel & MKGUI_TOOLBAR_MODE_MASK);
		} break;

		default: break;
	}
}

// ---------------------------------------------------------------------------
// Tab state helpers
// ---------------------------------------------------------------------------

// [=]===^=[ ed_get_active_tab ]===================================[=]
static uint32_t ed_get_active_tab(uint32_t tabs_id) {
	for(uint32_t i = 0; i < ed.tab_state_count; ++i) {
		if(ed.tab_states[i].tabs_id == tabs_id) {
			return ed.tab_states[i].active_id;
		}
	}
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_TAB && ed.widgets[i].parent_id == tabs_id) {
			return ed.widgets[i].id;
		}
	}
	return 0;
}

// [=]===^=[ ed_set_active_tab ]===================================[=]
static void ed_set_active_tab(uint32_t tabs_id, uint32_t tab_id) {
	for(uint32_t i = 0; i < ed.tab_state_count; ++i) {
		if(ed.tab_states[i].tabs_id == tabs_id) {
			ed.tab_states[i].active_id = tab_id;
			return;
		}
	}

	if(ed.tab_state_count < 32) {
		ed.tab_states[ed.tab_state_count].tabs_id = tabs_id;
		ed.tab_states[ed.tab_state_count].active_id = tab_id;
		++ed.tab_state_count;
	}
}

// [=]===^=[ ed_is_tab_child_visible ]=============================[=]
static uint32_t ed_is_tab_child_visible(uint32_t idx) {
	uint32_t pid = ed.widgets[idx].parent_id;
	for(uint32_t depth = 0; depth < ED_MAX_WIDGETS && pid != 0; ++depth) {
		uint32_t found = 0;
		for(uint32_t j = 0; j < ed.widget_count; ++j) {
			if(ed.widgets[j].id != pid) {
				continue;
			}
			if(ed.widgets[j].type == MKGUI_TAB && ed_get_active_tab(ed.widgets[j].parent_id) != ed.widgets[j].id) {
				return 0;
			}
			pid = ed.widgets[j].parent_id;
			found = 1;
			break;
		}
		if(!found) {
			break;
		}
	}
	return 1;
}

// ---------------------------------------------------------------------------
// Widget data helpers
// ---------------------------------------------------------------------------

// [=]===^=[ ed_find_widget_data ]=================================[=]
static struct ed_widget_data *ed_find_widget_data(uint32_t widget_id) {
	for(uint32_t i = 0; i < ed.widget_data_count; ++i) {
		if(ed.widget_data[i].widget_id == widget_id) {
			return &ed.widget_data[i];
		}
	}
	return NULL;
}

// [=]===^=[ ed_get_or_create_widget_data ]========================[=]
static struct ed_widget_data *ed_get_or_create_widget_data(uint32_t widget_id) {
	struct ed_widget_data *d = ed_find_widget_data(widget_id);
	if(d) {
		return d;
	}

	if(ed.widget_data_count >= ED_MAX_DATA_WIDGETS) {
		return NULL;
	}
	d = &ed.widget_data[ed.widget_data_count++];
	memset(d, 0, sizeof(*d));
	d->widget_id = widget_id;
	return d;
}

// [=]===^=[ ed_remove_widget_data ]===============================[=]
static void ed_remove_widget_data(uint32_t widget_id) {
	for(uint32_t i = 0; i < ed.widget_data_count; ++i) {
		if(ed.widget_data[i].widget_id == widget_id) {
			if(i + 1 < ed.widget_data_count) {
				memmove(&ed.widget_data[i], &ed.widget_data[i + 1], (ed.widget_data_count - i - 1) * sizeof(struct ed_widget_data));
			}
			--ed.widget_data_count;
			return;
		}
	}
}

// ---------------------------------------------------------------------------
// Undo / redo
// ---------------------------------------------------------------------------

// [=]===^=[ ed_push_undo ]=======================================[=]
static void ed_push_undo(void) {
	struct ed_snapshot *snap = &ed.undo[ed.undo_pos % ED_MAX_UNDO];
	if(ed.widget_count > snap->widget_cap) {
		struct ed_widget *widgets = (struct ed_widget *)malloc((size_t)ed.widget_count * sizeof(struct ed_widget));
		if(!widgets) {
			return;
		}
		free(snap->widgets);
		snap->widgets = widgets;
		snap->widget_cap = ed.widget_count;
	}
	if(ed.widget_count > 0) {
		memcpy(snap->widgets, ed.widgets, sizeof(struct ed_widget) * ed.widget_count);
	}
	snap->widget_count = ed.widget_count;
	++ed.undo_pos;
	ed.undo_count = ed.undo_pos;
}

// [=]===^=[ ed_undo ]============================================[=]
static void ed_undo(void) {
	if(ed.undo_pos == 0) {
		return;
	}
	--ed.undo_pos;
	struct ed_snapshot *snap = &ed.undo[ed.undo_pos % ED_MAX_UNDO];
	memcpy(ed.widgets, snap->widgets, sizeof(struct ed_widget) * snap->widget_count);
	ed.widget_count = snap->widget_count;
	ed.selected = -1;
}

// [=]===^=[ ed_redo ]============================================[=]
static void ed_redo(void) {
	if(ed.undo_pos >= ed.undo_count) {
		return;
	}
	++ed.undo_pos;
	if(ed.undo_pos < ed.undo_count) {
		struct ed_snapshot *snap = &ed.undo[ed.undo_pos % ED_MAX_UNDO];
		memcpy(ed.widgets, snap->widgets, sizeof(struct ed_widget) * snap->widget_count);
		ed.widget_count = snap->widget_count;
	}
	ed.selected = -1;
}

// ---------------------------------------------------------------------------
// Editor helpers
// ---------------------------------------------------------------------------

// [=]===^=[ ed_find_widget ]=====================================[=]
static int32_t ed_find_widget(uint32_t id) {
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].id == id) {
			return (int32_t)i;
		}
	}
	return -1;
}

// [=]===^=[ ed_gen_id_name ]=====================================[=]
static void ed_gen_id_name(struct ed_widget *w) {
	char *prefix = "ID";
	switch(w->type) {
		case MKGUI_WINDOW:     { prefix = "ID_WINDOW"; } break;
		case MKGUI_BUTTON:     { prefix = "ID_BUTTON"; } break;
		case MKGUI_LABEL:      { prefix = "ID_LABEL"; } break;
		case MKGUI_INPUT:      { prefix = "ID_INPUT"; } break;
		case MKGUI_CHECKBOX:   { prefix = "ID_CHECK"; } break;
		case MKGUI_DROPDOWN:   { prefix = "ID_DROPDOWN"; } break;
		case MKGUI_SLIDER:     { prefix = "ID_SLIDER"; } break;
		case MKGUI_LISTVIEW:   { prefix = "ID_LISTVIEW"; } break;
		case MKGUI_TABS:       { prefix = "ID_TABS"; } break;
		case MKGUI_TAB:        { prefix = "ID_TAB"; } break;
		case MKGUI_HSPLIT: { prefix = "ID_SPLITH"; } break;
		case MKGUI_VSPLIT: { prefix = "ID_SPLITV"; } break;
		case MKGUI_TREEVIEW:   { prefix = "ID_TREEVIEW"; } break;
		case MKGUI_TREELIST:   { prefix = "ID_TREELIST"; } break;
		case MKGUI_MENU:       { prefix = "ID_MENU"; } break;
		case MKGUI_MENUITEM:   { prefix = "ID_MENUITEM"; } break;
		case MKGUI_STATUSBAR:  { prefix = "ID_STATUSBAR"; } break;
		case MKGUI_TOOLBAR:    { prefix = "ID_TOOLBAR"; } break;
		case MKGUI_RADIO:      { prefix = "ID_RADIO"; } break;
		case MKGUI_PROGRESS:   { prefix = "ID_PROGRESS"; } break;
		case MKGUI_METER:      { prefix = "ID_METER"; } break;
		case MKGUI_TEXTAREA:   { prefix = "ID_TEXTAREA"; } break;
		case MKGUI_LOGVIEW:    { prefix = "ID_LOGVIEW"; } break;
		case MKGUI_SPINBOX:    { prefix = "ID_SPINBOX"; } break;
		case MKGUI_GROUP:      { prefix = "ID_GROUP"; } break;
		case MKGUI_SPINNER:    { prefix = "ID_SPINNER"; } break;
		case MKGUI_ITEMVIEW:   { prefix = "ID_ITEMVIEW"; } break;
		case MKGUI_PANEL:      { prefix = "ID_PANEL"; } break;
		case MKGUI_GRIDVIEW:   { prefix = "ID_GRIDVIEW"; } break;
		case MKGUI_RICHLIST:   { prefix = "ID_RICHLIST"; } break;
		case MKGUI_SCROLLBAR:  { prefix = "ID_SCROLLBAR"; } break;
		case MKGUI_IMAGE:      { prefix = "ID_IMAGE"; } break;
		case MKGUI_GLVIEW:     { prefix = "ID_GLVIEW"; } break;
		case MKGUI_CANVAS:     { prefix = "ID_CANVAS"; } break;
		case MKGUI_SPACER:     { prefix = "ID_SPACER"; } break;
		case MKGUI_DIVIDER:    { prefix = "ID_DIVIDER"; } break;
		case MKGUI_IPINPUT:    { prefix = "ID_IPINPUT"; } break;
		case MKGUI_TOGGLE:     { prefix = "ID_TOGGLE"; } break;
		case MKGUI_COMBOBOX:   { prefix = "ID_COMBOBOX"; } break;
		case MKGUI_DATEPICKER: { prefix = "ID_DATEPICKER"; } break;
		case MKGUI_PATHBAR:    { prefix = "ID_PATHBAR"; } break;
		case MKGUI_VBOX:       { prefix = "ID_VBOX"; } break;
		case MKGUI_HBOX:       { prefix = "ID_HBOX"; } break;
		case MKGUI_FORM:       { prefix = "ID_FORM"; } break;
		default: break;
	}
	snprintf(w->id_name, sizeof(w->id_name), "%s_%u", prefix, w->id);
}

// [=]===^=[ ed_add_widget ]======================================[=]
static int32_t ed_add_widget(uint32_t type, int32_t x, int32_t y) {
	if(ed.widget_count >= ED_MAX_WIDGETS) {
		return -1;
	}

	ed_push_undo();

	struct ed_widget *w = &ed.widgets[ed.widget_count];
	memset(w, 0, sizeof(*w));
	w->label_tw = -1;
	w->type = type;
	w->id = ed.next_id++;
	w->x = x;
	w->y = y;

	switch(type) {
		case MKGUI_WINDOW: {
			w->w = ED_CANVAS_DEF_W;
			w->h = ED_CANVAS_DEF_H;
			snprintf(w->label, sizeof(w->label), "Window");
		} break;

		case MKGUI_BUTTON: {
			w->w = 80;
			w->h = 28;
			snprintf(w->label, sizeof(w->label), "Button");
		} break;

		case MKGUI_LABEL: {
			w->w = 80;
			w->h = 20;
			snprintf(w->label, sizeof(w->label), "Label");
		} break;

		case MKGUI_INPUT: {
			w->w = 150;
			w->h = 24;
		} break;

		case MKGUI_IPINPUT: {
			w->w = 180;
			w->h = 24;
		} break;

		case MKGUI_TOGGLE: {
			w->w = 80;
			w->h = 24;
		} break;

		case MKGUI_COMBOBOX: {
			w->w = 180;
			w->h = 24;
		} break;

		case MKGUI_DATEPICKER: {
			w->w = 150;
			w->h = 24;
		} break;

		case MKGUI_PATHBAR: {
			w->w = 0;
			w->h = 0;
		} break;

		case MKGUI_CHECKBOX: {
			w->w = 120;
			w->h = 20;
			snprintf(w->label, sizeof(w->label), "Checkbox");
		} break;

		case MKGUI_DROPDOWN: {
			w->w = 150;
			w->h = 24;
		} break;

		case MKGUI_SLIDER: {
			w->w = 200;
			w->h = 20;
			snprintf(w->label, sizeof(w->label), "Slider");
		} break;

		case MKGUI_LISTVIEW: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_TABS: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_TAB: {
			w->w = 0;
			w->h = 0;
			snprintf(w->label, sizeof(w->label), "Tab");
		} break;

		case MKGUI_HSPLIT:
		case MKGUI_VSPLIT: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_TREEVIEW: {
			w->w = 200;
			w->h = 200;
		} break;

		case MKGUI_TREELIST: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_MENU: {
			w->x = 0;
			w->y = 0;
		} break;

		case MKGUI_MENUITEM: {
			snprintf(w->label, sizeof(w->label), "Item");
		} break;

		case MKGUI_STATUSBAR: {
			w->x = 0;
			w->y = 0;
		} break;

		case MKGUI_TOOLBAR: {
			w->x = 0;
			w->y = 0;
		} break;

		case MKGUI_RADIO: {
			w->w = 120;
			w->h = 20;
			snprintf(w->label, sizeof(w->label), "Radio");
		} break;

		case MKGUI_PROGRESS: {
			w->w = 200;
			w->h = 20;
		} break;

		case MKGUI_METER: {
			w->w = 200;
			w->h = 20;
		} break;

		case MKGUI_TEXTAREA: {
			w->w = 200;
			w->h = 100;
		} break;

		case MKGUI_LOGVIEW: {
			w->w = 320;
			w->h = 200;
		} break;

		case MKGUI_SPINBOX: {
			w->w = 100;
			w->h = 24;
		} break;

		case MKGUI_GROUP: {
			w->w = 300;
			w->h = 150;
			snprintf(w->label, sizeof(w->label), "Group");
		} break;

		case MKGUI_SPINNER: {
			w->w = 28;
			w->h = 28;
		} break;

		case MKGUI_ITEMVIEW: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_PANEL: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_GRIDVIEW: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_RICHLIST: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_SCROLLBAR: {
			w->w = MKGUI_SCROLLBAR_W;
			w->h = 200;
		} break;

		case MKGUI_IMAGE: {
			w->w = 200;
			w->h = 150;
		} break;

		case MKGUI_GLVIEW: {
			w->w = 300;
			w->h = 200;
		} break;

		case MKGUI_CANVAS: {
			w->w = 200;
			w->h = 150;
		} break;

		case MKGUI_SPACER: {
			w->w = 0;
			w->h = 0;
		} break;

		case MKGUI_DIVIDER: {
			w->w = 0;
			w->h = 0;
		} break;

		case MKGUI_HBOX:
		case MKGUI_VBOX:
		case MKGUI_FORM: {
			w->w = 0;
			w->h = 0;
		} break;

		default: {
			w->w = 100;
			w->h = 30;
		} break;
	}

	w->tab_order = ed.widget_count;
	ed_gen_id_name(w);

	if(ed.widget_count > 0 && type != MKGUI_WINDOW) {
		w->parent_id = ed.widgets[0].id;
	}

	++ed.widget_count;
	int32_t result = (int32_t)(ed.widget_count - 1);

	if(type == MKGUI_TABS && ed.widget_count < ED_MAX_WIDGETS) {
		uint32_t tabs_id = w->id;
		struct ed_widget *tab = &ed.widgets[ed.widget_count];
		memset(tab, 0, sizeof(*tab));
		tab->type = MKGUI_TAB;
		tab->id = ed.next_id++;
		tab->parent_id = tabs_id;
		snprintf(tab->label, sizeof(tab->label), "Tab 1");
		tab->tab_order = ed.widget_count;
		ed_gen_id_name(tab);
		++ed.widget_count;
		ed_set_active_tab(tabs_id, tab->id);
	}

	if(type == MKGUI_MENU && ed.widget_count < ED_MAX_WIDGETS) {
		uint32_t menu_id = w->id;
		struct ed_widget *item = &ed.widgets[ed.widget_count];
		memset(item, 0, sizeof(*item));
		item->type = MKGUI_MENUITEM;
		item->id = ed.next_id++;
		item->parent_id = menu_id;
		snprintf(item->label, sizeof(item->label), "File");
		item->tab_order = ed.widget_count;
		ed_gen_id_name(item);
		++ed.widget_count;
	}

	return result;
}

// [=]===^=[ ed_is_descendant ]====================================[=]
static uint32_t ed_is_descendant(uint32_t widget_idx, uint32_t ancestor_id) {
	uint32_t pid = ed.widgets[widget_idx].parent_id;
	for(uint32_t depth = 0; depth < 32; ++depth) {
		if(pid == ancestor_id) {
			return 1;
		}

		if(pid == 0) {
			return 0;
		}
		uint32_t found = 0;
		for(uint32_t j = 0; j < ed.widget_count; ++j) {
			if(ed.widgets[j].id == pid) {
				pid = ed.widgets[j].parent_id;
				found = 1;
				break;
			}
		}

		if(!found) {
			return 0;
		}
	}
	return 0;
}

// [=]===^=[ ed_is_layout_managed ]================================[=]
static uint32_t ed_is_layout_managed(uint32_t widget_idx) {
	struct ed_widget *w = &ed.widgets[widget_idx];
	uint32_t anchors = w->flags & (MKGUI_ANCHOR_LEFT | MKGUI_ANCHOR_TOP | MKGUI_ANCHOR_RIGHT | MKGUI_ANCHOR_BOTTOM);
	if(anchors) {
		return 1;
	}
	for(uint32_t j = 0; j < ed.widget_count; ++j) {
		if(ed.widgets[j].id == w->parent_id) {
			uint32_t pt = ed.widgets[j].type;
			if(pt == MKGUI_VBOX || pt == MKGUI_HBOX || pt == MKGUI_FORM) {
				return 1;
			}
			break;
		}
	}
	return 0;
}

// [=]===^=[ ed_delete_widget_tree ]===============================[=]
static void ed_delete_widget_tree(uint32_t id) {
	for(uint32_t i = ed.widget_count; i > 0; --i) {
		uint32_t idx = i - 1;
		if(ed_is_descendant(idx, id)) {
			ed_remove_widget_data(ed.widgets[idx].id);
			memmove(&ed.widgets[idx], &ed.widgets[idx + 1], (ed.widget_count - idx - 1) * sizeof(struct ed_widget));
			--ed.widget_count;
		}
	}
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].id == id) {
			ed_remove_widget_data(ed.widgets[i].id);
			memmove(&ed.widgets[i], &ed.widgets[i + 1], (ed.widget_count - i - 1) * sizeof(struct ed_widget));
			--ed.widget_count;
			break;
		}
	}
}

// [=]===^=[ ed_delete_selected ]=================================[=]
static void ed_delete_selected(void) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}

	if(ed.widgets[ed.selected].type == MKGUI_WINDOW) {
		return;
	}
	ed_push_undo();
	uint32_t del_id = ed.widgets[ed.selected].id;
	uint32_t del_parent = ed.widgets[ed.selected].parent_id;
	int32_t next_sel = -1;
	for(int32_t i = ed.selected + 1; (uint32_t)i < ed.widget_count; ++i) {
		if(ed.widgets[i].parent_id == del_parent && !ed_is_descendant((uint32_t)i, del_id)) {
			next_sel = (int32_t)ed.widgets[i].id;
			break;
		}
	}

	if(next_sel < 0) {
		for(int32_t i = ed.selected - 1; i >= 0; --i) {
			if(ed.widgets[i].parent_id == del_parent && ed.widgets[i].id != del_id) {
				next_sel = (int32_t)ed.widgets[i].id;
				break;
			}
		}
	}

	if(next_sel < 0) {
		next_sel = (int32_t)del_parent;
	}
	ed_delete_widget_tree(del_id);
	ed.selected = ed_find_widget((uint32_t)next_sel);
}

// [=]===^=[ ed_insert_child_after ]================================[=]
static uint32_t ed_insert_child_after(uint32_t parent_id) {
	if(ed.widget_count >= ED_MAX_WIDGETS) {
		return ed.widget_count;
	}
	uint32_t insert_at = ed.widget_count;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].id == parent_id) {
			insert_at = i + 1;
			for(uint32_t j = insert_at; j < ed.widget_count; ++j) {
				if(ed_is_descendant(j, parent_id)) {
					insert_at = j + 1;
				}
			}
			break;
		}
	}

	if(insert_at < ed.widget_count) {
		memmove(&ed.widgets[insert_at + 1], &ed.widgets[insert_at], (ed.widget_count - insert_at) * sizeof(struct ed_widget));
	}
	memset(&ed.widgets[insert_at], 0, sizeof(struct ed_widget));
	++ed.widget_count;
	return insert_at;
}

// [=]===^=[ ed_widget_canvas_pos ]================================[=]
static void ed_widget_canvas_pos(uint32_t idx, int32_t *out_x, int32_t *out_y) {
	struct ed_widget *w = &ed.widgets[idx];
	if(w->type == MKGUI_TAB) {
		for(uint32_t j = 0; j < ed.widget_count; ++j) {
			if(ed.widgets[j].id == w->parent_id) {
				*out_x = ed.widgets[j].x;
				*out_y = ed.widgets[j].y + MKGUI_TAB_HEIGHT;
				return;
			}
		}
	}
	*out_x = w->x;
	*out_y = w->y;
}

// [=]===^=[ ed_convert_to_layout ]================================[=]
static void ed_convert_to_layout(uint32_t idx, int32_t *lx, int32_t *ly, int32_t *lw, int32_t *lh) {
	struct ed_widget *ew = &ed.widgets[idx];
	*lx = 0;
	*ly = 0;

	uint32_t t = ew->type;
	if(t == MKGUI_MENU || t == MKGUI_TOOLBAR || t == MKGUI_STATUSBAR || t == MKGUI_PATHBAR || t == MKGUI_VBOX || t == MKGUI_HBOX || t == MKGUI_FORM || t == MKGUI_TAB || t == MKGUI_PANEL || t == MKGUI_GROUP || t == MKGUI_TABS) {
		*lw = 0;
		*lh = 0;
		return;
	}

	if(ew->flags & MKGUI_FIXED) {
		*lw = ew->w;
		*lh = ew->h;
	} else {
		*lw = 0;
		*lh = 0;
	}
}

// ---------------------------------------------------------------------------
// Design-time widget rects (computed each frame by ed_render_canvas)
// ---------------------------------------------------------------------------

static struct { int32_t x, y, w, h; } ed_rects[ED_MAX_WIDGETS];
static int32_t ed_win_x, ed_win_y;

// [=]===^=[ ed_tab_header_hit ]===================================[=]
static uint32_t ed_tab_header_hit(struct mkgui_window *win, int32_t tabs_idx, int32_t lx, int32_t ly) {
	int32_t sx = lx + ed_win_x;
	int32_t sy = ly + ed_win_y;
	int32_t rel_x = sx - ed_rects[tabs_idx].x;
	int32_t rel_y = sy - ed_rects[tabs_idx].y;
	if(rel_y < 0 || rel_y >= win->tab_height) {
		return 0;
	}
	struct ed_widget *tabs_w = &ed.widgets[tabs_idx];
	int32_t tab_x = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_TAB && ed.widgets[i].parent_id == tabs_w->id) {
			int32_t tw = text_width(win, ed.widgets[i].label) + 20;
			if(rel_x >= tab_x && rel_x < tab_x + tw) {
				return ed.widgets[i].id;
			}
			tab_x += tw;
		}
	}
	return 0;
}

// [=]===^=[ ed_snap ]============================================[=]
static int32_t ed_snap(int32_t v) {
	if(ed.grid_size <= 1) {
		return v;
	}
	return ((v + ed.grid_size / 2) / ed.grid_size) * ed.grid_size;
}

// [=]===^=[ ed_canvas_hit ]======================================[=]
static int32_t ed_canvas_hit(int32_t lx, int32_t ly) {
	int32_t sx = lx + ed_win_x;
	int32_t sy = ly + ed_win_y;
	for(int32_t i = (int32_t)ed.widget_count - 1; i >= 0; --i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->type == MKGUI_WINDOW || w->type == MKGUI_TAB || w->type == MKGUI_MENUITEM) {
			continue;
		}

		if(!ed_is_tab_child_visible((uint32_t)i)) {
			continue;
		}

		if(ed_rects[i].w <= 0 || ed_rects[i].h <= 0) {
			continue;
		}

		if(sx >= ed_rects[i].x && sx < ed_rects[i].x + ed_rects[i].w && sy >= ed_rects[i].y && sy < ed_rects[i].y + ed_rects[i].h) {
			return i;
		}
	}
	return -1;
}

// [=]===^=[ ed_handle_hit ]======================================[=]
static int32_t ed_handle_hit(int32_t lx, int32_t ly) {
	if(ed.selected < 0) {
		return -1;
	}
	int32_t sx = lx + ed_win_x;
	int32_t sy = ly + ed_win_y;
	int32_t wx = ed_rects[ed.selected].x;
	int32_t wy = ed_rects[ed.selected].y;
	int32_t ww = ed_rects[ed.selected].w;
	int32_t wh = ed_rects[ed.selected].h;
	int32_t hx[] = { wx, wx + ww / 2, wx + ww, wx + ww, wx + ww, wx + ww / 2, wx, wx };
	int32_t hy[] = { wy, wy, wy, wy + wh / 2, wy + wh, wy + wh, wy + wh, wy + wh / 2 };
	for(uint32_t i = 0; i < 8; ++i) {
		if(sx >= hx[i] - 4 && sx <= hx[i] + 4 && sy >= hy[i] - 4 && sy <= hy[i] + 4) {
			return (int32_t)i;
		}
	}
	return -1;
}

#define ED_EDGE_LEFT   1
#define ED_EDGE_TOP    2
#define ED_EDGE_RIGHT  4
#define ED_EDGE_BOTTOM 8
#define ED_CANVAS_MIN  64
#define ED_EDGE_THRESH 5

// [=]===^=[ ed_canvas_edge_hit ]==================================[=]
static uint32_t ed_canvas_edge_hit(int32_t lx, int32_t ly) {
	uint32_t edges = 0;
	int32_t cw = ed.canvas_w;
	int32_t ch = ed.canvas_h;
	int32_t t = ED_EDGE_THRESH;

	if(lx >= -t && lx <= t && ly >= -t && ly <= ch + t) {
		edges |= ED_EDGE_LEFT;
	}

	if(lx >= cw - t && lx <= cw + t && ly >= -t && ly <= ch + t) {
		edges |= ED_EDGE_RIGHT;
	}

	if(ly >= -t && ly <= t && lx >= -t && lx <= cw + t) {
		edges |= ED_EDGE_TOP;
	}

	if(ly >= ch - t && ly <= ch + t && lx >= -t && lx <= cw + t) {
		edges |= ED_EDGE_BOTTOM;
	}
	return edges;
}

// ---------------------------------------------------------------------------
// Design-time widget drawing (inert visual representations)
// ---------------------------------------------------------------------------

// [=]===^=[ ed_draw_widget_fallback ]==============================[=]
static void ed_draw_widget_fallback(struct mkgui_window *win, uint32_t idx) {
	struct ed_widget *ew = &ed.widgets[idx];
	int32_t rx = ed_rects[idx].x;
	int32_t ry = ed_rects[idx].y;
	int32_t rw = ed_rects[idx].w;
	int32_t rh = ed_rects[idx].h;
	uint32_t *buf = win->pixels;
	int32_t bw = win->win_w;
	int32_t bh = win->win_h;

	switch(ew->type) {
		case MKGUI_INPUT: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			if(ew->label[0]) {
				int32_t ty = ry + (rh - win->font_height) / 2;
				push_text_clip(rx + 4, ty, ew->label, win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
			}
		} break;

		case MKGUI_IPINPUT: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, "0.0.0.0", win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
		} break;

		case MKGUI_TOGGLE: {
			int32_t track_h = 20;
			int32_t track_w = 38;
			int32_t track_y = ry + (rh - track_h) / 2;
			int32_t track_r = track_h / 2;
			draw_rounded_rect(win->pixels, win->win_w, win->win_h, rx, track_y, track_w, track_h, win->theme.bg, win->theme.widget_border, track_r);
			int32_t knob_pad = 3;
			int32_t knob_sz = track_h - knob_pad * 2;
			int32_t knob_r = knob_sz / 2;
			draw_rounded_rect_fill(win->pixels, win->win_w, win->win_h, rx + knob_pad, track_y + knob_pad, knob_sz, knob_sz, win->theme.widget_border, knob_r);
			if(ew->label[0]) {
				int32_t lty = ry + (rh - win->font_height) / 2;
				push_text_clip(rx + track_w + 6, lty, ew->label, win->theme.text, rx, ry, rx + rw, ry + rh);
			}
		} break;

		case MKGUI_COMBOBOX: {
			int32_t text_w = rw - 20;
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, text_w, rh, win->theme.input_bg, win->theme.widget_border);
			draw_patch(win, MKGUI_STYLE_RAISED, rx + text_w, ry, 20, rh, win->theme.widget_bg, win->theme.widget_border);
			int32_t as = 4;
			int32_t acx = rx + text_w + 10;
			int32_t acy = ry + rh / 2;
			draw_triangle_aa(win->pixels, win->win_w, win->win_h, acx - as, acy - as / 2, acx + as, acy - as / 2, acx, acy + as / 2, win->theme.text);
			if(ew->label[0]) {
				int32_t cty = ry + (rh - win->font_height) / 2;
				push_text_clip(rx + 4, cty, ew->label, win->theme.text_disabled, rx + 1, ry + 1, rx + text_w - 1, ry + rh - 1);
			}
		} break;

		case MKGUI_DATEPICKER: {
			int32_t text_w = rw - 24;
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, text_w, rh, win->theme.input_bg, win->theme.widget_border);
			draw_patch(win, MKGUI_STYLE_RAISED, rx + text_w, ry, 24, rh, win->theme.widget_bg, win->theme.widget_border);
			int32_t dty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, dty, "2026-01-01", win->theme.text_disabled, rx + 1, ry + 1, rx + text_w - 1, ry + rh - 1);
		} break;

		case MKGUI_SLIDER: {
			if(ew->flags & MKGUI_VERTICAL) {
				int32_t track_x = rx + rw / 2 - 2;
				draw_rounded_rect_fill(buf, bw, bh, track_x, ry, 4, rh, win->theme.widget_border, 2);
				if(ew->style & MKGUI_SLIDER_MIXER) {
					slider_draw_wedge_v(buf, bw, bh, track_x + 4, ry, rh, 0, rh, MKGUI_SLIDER_WEDGE_MAX_W, win->theme.widget_border);
				}
				int32_t thumb_y = ry + rh / 3;
				draw_patch(win, MKGUI_STYLE_RAISED, rx + 2, thumb_y, rw - 4, 10, win->theme.highlight, win->theme.highlight);

			} else {
				int32_t track_y = ry + rh / 2 - 2;
				draw_rounded_rect_fill(buf, bw, bh, rx, track_y, rw, 4, win->theme.widget_border, 2);
				if(ew->style & MKGUI_SLIDER_MIXER) {
					slider_draw_wedge_h(buf, bw, bh, rx, track_y + 4, rw, 0, rw, MKGUI_SLIDER_WEDGE_MAX_W, win->theme.widget_border);
				}
				int32_t thumb_x = rx + rw / 3;
				draw_patch(win, MKGUI_STYLE_RAISED, thumb_x, ry + 2, 10, rh - 4, win->theme.highlight, win->theme.highlight);
			}
		} break;

		case MKGUI_DROPDOWN: {
			draw_patch(win, MKGUI_STYLE_RAISED, rx, ry, rw, rh, win->theme.widget_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label, win->theme.text, rx + 1, ry + 1, rx + rw - 16, ry + rh - 1);
			int32_t as2 = 4;
			int32_t acx2 = rx + rw - 10;
			int32_t acy2 = ry + rh / 2;
			draw_triangle_aa(buf, bw, bh, acx2 - as2, acy2 - as2 / 2, acx2 + as2, acy2 - as2 / 2, acx2, acy2 + as2 / 2, win->theme.text);
		} break;

		case MKGUI_SPINBOX: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			if(ew->label[0]) {
				int32_t ty = ry + (rh - win->font_height) / 2;
				push_text_clip(rx + 4, ty, ew->label, win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 20, ry + rh - 1);
			}
			int32_t bx = rx + rw - 20;
			int32_t half = rh / 2;
			draw_patch(win, MKGUI_STYLE_RAISED, bx, ry, 20, half, win->theme.widget_bg, win->theme.widget_border);
			draw_patch(win, MKGUI_STYLE_RAISED, bx, ry + half, 20, rh - half, win->theme.widget_bg, win->theme.widget_border);
			int32_t ac = bx + 10;
			int32_t sas = 3;
			draw_triangle_aa(buf, bw, bh, ac, ry + half / 2 - sas, ac - sas, ry + half / 2 + sas / 2, ac + sas, ry + half / 2 + sas / 2, win->theme.text);
			draw_triangle_aa(buf, bw, bh, ac - sas, ry + half + (rh - half) / 2 - sas / 2, ac + sas, ry + half + (rh - half) / 2 - sas / 2, ac, ry + half + (rh - half) / 2 + sas, win->theme.text);
		} break;

		case MKGUI_PROGRESS: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t fill_w = (rw - 2) / 2;
			int32_t fill_r = win->theme.corner_radius > 1 ? win->theme.corner_radius - 1 : 0;
			draw_rounded_rect_fill(buf, bw, bh, rx + 1, ry + 1, fill_w, rh - 2, win->theme.accent, fill_r);
		} break;

		case MKGUI_METER: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t iw = rw - 2;
			int32_t ih = rh - 2;
			int32_t z1 = iw * 75 / 100;
			int32_t z2 = iw * 90 / 100;
			draw_rect_fill(buf, bw, bh, rx + 1, ry + 1, z1, ih, 0xff44cc44);
			draw_rect_fill(buf, bw, bh, rx + 1 + z1, ry + 1, z2 - z1, ih, 0xffffcc00);
			draw_rect_fill(buf, bw, bh, rx + 1 + z2, ry + 1, iw - z2, ih, 0xffff4444);
			int32_t bar_h = ih * 6 / 10;
			if(bar_h < 3) {
				bar_h = 3;
			}
			int32_t bar_y = ry + 1 + (ih - bar_h) / 2;
			int32_t fill_w_m = iw / 2;
			draw_rect_fill(buf, bw, bh, rx + 1, bar_y, fill_w_m, bar_h, 0xff44cc44);
		} break;

		case MKGUI_TABS: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, win->tab_height, win->theme.tab_inactive);
			uint32_t active_id = ed_get_active_tab(ew->id);
			int32_t tx = rx;
			for(uint32_t i = 0; i < ed.widget_count; ++i) {
				struct ed_widget *child = &ed.widgets[i];
				if(child->type != MKGUI_TAB || child->parent_id != ew->id) {
					continue;
				}
				int32_t tab_ii = child->icon[0] ? icon_resolve(win, child->icon) : -1;
				int32_t tab_iw = (tab_ii >= 0) ? icons[tab_ii].w : 0;
				int32_t tw = text_width(win, child->label) + 20 + (tab_ii >= 0 ? tab_iw + 4 : 0);
				uint32_t active = (child->id == active_id);
				uint32_t tab_bg = active ? win->theme.tab_active : win->theme.tab_inactive;
				uint32_t bd = active ? win->theme.widget_border : win->theme.tab_inactive;
				draw_rounded_rect(buf, bw, bh, tx, ry, tw, win->tab_height, tab_bg, bd, win->theme.corner_radius);
				if(active) {
					draw_hline(buf, bw, bh, tx, ry, tw, win->theme.highlight);
				}
				int32_t cx = tx + 10;
				if(tab_ii >= 0) {
					int32_t tab_iy = ry + (win->tab_height - icons[tab_ii].h) / 2;
					draw_icon(buf, bw, bh, &icons[tab_ii], cx, tab_iy, tx + 1, ry + 1, tx + tw - 1, ry + win->tab_height - 1);
					cx += tab_iw + 4;
				}
				int32_t tty = ry + (win->tab_height - win->font_height) / 2;
				push_text_clip(cx, tty, child->label, win->theme.text, tx, ry, tx + tw, ry + win->tab_height);
				tx += tw;
			}
			draw_hline(buf, bw, bh, rx, ry + win->tab_height - 1, rw, win->theme.widget_border);
		} break;

		case MKGUI_LISTVIEW: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			draw_rect_fill(buf, bw, bh, rx + 1, ry + 1, rw - 2, win->row_height, win->theme.header_bg);
			draw_hline(buf, bw, bh, rx + 1, ry + win->row_height, rw - 2, win->theme.widget_border);
			int32_t ty = ry + (win->row_height - win->font_height) / 2 + 1;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "ListView", win->theme.text, rx + 1, ry + 1, rx + rw - 1, ry + win->row_height);
		} break;

		case MKGUI_GRIDVIEW: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			draw_rect_fill(buf, bw, bh, rx + 1, ry + 1, rw - 2, win->row_height, win->theme.header_bg);
			draw_hline(buf, bw, bh, rx + 1, ry + win->row_height, rw - 2, win->theme.widget_border);
			int32_t ty = ry + (win->row_height - win->font_height) / 2 + 1;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "GridView", win->theme.text, rx + 1, ry + 1, rx + rw - 1, ry + win->row_height);
			uint32_t glc = blend_pixel(win->theme.input_bg, win->theme.widget_border, 80);
			int32_t gy = ry + win->row_height + win->row_height;
			while(gy < ry + rh - 2) {
				draw_hline(buf, bw, bh, rx + 1, gy, rw - 2, glc);
				gy += win->row_height;
			}
			int32_t gx = rx + 1 + rw / 3;
			draw_vline(buf, bw, bh, gx, ry + 1, rh - 2, glc);
			gx += rw / 3;
			draw_vline(buf, bw, bh, gx, ry + 1, rh - 2, glc);
		} break;

		case MKGUI_RICHLIST: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t rl_rh = 56;
			uint32_t rl_sep = blend_pixel(win->theme.input_bg, win->theme.widget_border, 60);
			int32_t rl_cx1 = rx + 1;
			int32_t rl_cy1 = ry + 1;
			int32_t rl_cx2 = rx + rw - 1;
			int32_t rl_cy2 = ry + rh - 1;
			int32_t prev_cx1 = render_clip_x1;
			int32_t prev_cy1 = render_clip_y1;
			int32_t prev_cx2 = render_clip_x2;
			int32_t prev_cy2 = render_clip_y2;
			if(rl_cx1 > render_clip_x1) {
				render_clip_x1 = rl_cx1;
			}
			if(rl_cy1 > render_clip_y1) {
				render_clip_y1 = rl_cy1;
			}
			if(rl_cx2 < render_clip_x2) {
				render_clip_x2 = rl_cx2;
			}
			if(rl_cy2 < render_clip_y2) {
				render_clip_y2 = rl_cy2;
			}
			for(int32_t row_y = ry + 1; row_y < ry + rh - 2; row_y += rl_rh) {
				int32_t thumb_sz = rl_rh - 8;
				draw_rect_fill(buf, bw, bh, rx + 5, row_y + 4, thumb_sz, thumb_sz, win->theme.listview_alt);
				draw_rect_border(buf, bw, bh, rx + 5, row_y + 4, thumb_sz, thumb_sz, win->theme.widget_border);
				int32_t txt_x = rx + 5 + thumb_sz + 6;
				push_text_clip(txt_x, row_y + rl_rh / 2 - win->font_height - 1, "Title", win->theme.text, rl_cx1, rl_cy1, rl_cx2, rl_cy2);
				push_text_clip(txt_x, row_y + rl_rh / 2 + 2, "Subtitle", win->theme.text_disabled, rl_cx1, rl_cy1, rl_cx2, rl_cy2);
				int32_t sep_y = row_y + rl_rh - 1;
				if(sep_y < ry + rh - 2) {
					draw_hline(buf, bw, bh, rx + 1, sep_y, rw - 2, rl_sep);
				}
			}
			render_clip_x1 = prev_cx1;
			render_clip_y1 = prev_cy1;
			render_clip_x2 = prev_cx2;
			render_clip_y2 = prev_cy2;
		} break;

		case MKGUI_TREEVIEW: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "TreeView", win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
		} break;

		case MKGUI_TREELIST: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			draw_rect_fill(buf, bw, bh, rx + 1, ry + 1, rw - 2, win->row_height, win->theme.header_bg);
			draw_hline(buf, bw, bh, rx + 1, ry + win->row_height, rw - 2, win->theme.widget_border);
			int32_t ty = ry + (win->row_height - win->font_height) / 2 + 1;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "TreeList", win->theme.text, rx + 1, ry + 1, rx + rw - 1, ry + win->row_height);
			int32_t gx = rx + 1 + rw / 3;
			draw_vline(buf, bw, bh, gx, ry + 1, rh - 2, blend_pixel(win->theme.input_bg, win->theme.widget_border, 80));
		} break;

		case MKGUI_TEXTAREA: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			if(ew->label[0]) {
				int32_t ty = ry + 2;
				push_text_clip(rx + 4, ty, ew->label, win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
			}
		} break;

		case MKGUI_LOGVIEW: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "LogView", win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
		} break;

		case MKGUI_ITEMVIEW: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "ItemView", win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
		} break;

		case MKGUI_TOOLBAR: {
			uint32_t ed_tb_mode = ew->style & MKGUI_TOOLBAR_MODE_MASK;
			uint32_t ed_show_icons = (ed_tb_mode != MKGUI_TOOLBAR_TEXT_ONLY);
			uint32_t ed_show_text = (ed_tb_mode != MKGUI_TOOLBAR_ICONS_ONLY);
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, win->theme.bg);
			draw_hline(buf, bw, bh, rx, ry + rh - 1, rw, win->theme.widget_border);
			int32_t bx = rx + 2;
			for(uint32_t i = 0; i < ed.widget_count; ++i) {
				struct ed_widget *btn = &ed.widgets[i];
				if(btn->type != MKGUI_BUTTON || btn->parent_id != ew->id) {
					continue;
				}

				if(btn->style & MKGUI_BUTTON_SEPARATOR) {
					int32_t sx = bx + win->toolbar_sep_w / 2;
					draw_vline(buf, bw, bh, sx, ry + 4, rh - 8, win->theme.widget_border);
					bx += win->toolbar_sep_w;
					continue;
				}
				int32_t icon_idx = ed_show_icons && btn->icon[0] ? icon_resolve(win, btn->icon) : -1;
				int32_t tw = ed_show_text ? text_width(win, btn->label) : 0;
				int32_t icon_iw = icon_idx >= 0 ? icons[icon_idx].w + 4 : 0;
				int32_t content_w = icon_iw + tw;
				int32_t btn_w = content_w + 12;
				if(btn_w < win->toolbar_btn_w) {
					btn_w = win->toolbar_btn_w;
				}
				int32_t btn_y = ry + 2;
				int32_t btn_h = rh - 4;
				int32_t ccx = bx + (btn_w - content_w) / 2;
				if(icon_idx >= 0) {
					int32_t iy = btn_y + (btn_h - icons[icon_idx].h) / 2;
					draw_icon(buf, bw, bh, &icons[icon_idx], ccx, iy, bx, btn_y, bx + btn_w, btn_y + btn_h);
					ccx += icons[icon_idx].w + 4;
				}

				if(ed_show_text && btn->label[0]) {
					int32_t ty = btn_y + (btn_h - win->font_height) / 2;
					push_text_clip(ccx, ty, btn->label, win->theme.text, bx, btn_y, bx + btn_w, btn_y + btn_h);
				}
				bx += btn_w + 2;
			}
		} break;

		case MKGUI_STATUSBAR: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, win->theme.header_bg);
			draw_hline(buf, bw, bh, rx, ry, rw, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "Status", win->theme.text, rx, ry, rx + rw, ry + rh);
		} break;

		case MKGUI_PATHBAR: {
			draw_patch(win, MKGUI_STYLE_SUNKEN, rx, ry, rw, rh, win->theme.input_bg, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, ew->label[0] ? ew->label : "/path/bar", win->theme.text_disabled, rx + 1, ry + 1, rx + rw - 1, ry + rh - 1);
		} break;

		case MKGUI_MENU: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, win->theme.menu_bg);
			int32_t mx = rx;
			for(uint32_t i = 0; i < ed.widget_count; ++i) {
				struct ed_widget *mi = &ed.widgets[i];
				if(mi->type != MKGUI_MENUITEM || mi->parent_id != ew->id) {
					continue;
				}
				int32_t iw = text_width(win, mi->label) + 16;
				draw_rect_fill(buf, bw, bh, mx, ry, iw, rh, win->theme.menu_bg);
				int32_t ty = ry + (rh - win->font_height) / 2;
				push_text_clip(mx + 8, ty, mi->label, win->theme.text, mx, ry, mx + iw, ry + rh);
				mx += iw;
			}
		} break;

		case MKGUI_HSPLIT: {
			int32_t split_y = ry + rh / 2;
			draw_rect_fill(buf, bw, bh, rx, split_y, rw, win->split_thick, win->theme.highlight);
		} break;

		case MKGUI_VSPLIT: {
			int32_t split_x = rx + rw / 2;
			draw_rect_fill(buf, bw, bh, split_x, ry, win->split_thick, rh, win->theme.highlight);
		} break;

		case MKGUI_SCROLLBAR: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, win->theme.scrollbar_bg);
			if(rw > rh) {
				int32_t thumb_w = rw / 3;
				draw_rounded_rect_fill(buf, bw, bh, rx + thumb_w / 2, ry + 2, thumb_w, rh - 4, win->theme.scrollbar_thumb, 3);
			} else {
				int32_t thumb_h = rh / 3;
				draw_rounded_rect_fill(buf, bw, bh, rx + 2, ry + thumb_h / 2, rw - 4, thumb_h, win->theme.scrollbar_thumb, 3);
			}
		} break;

		case MKGUI_SPINNER: {
			int32_t sz = rw < rh ? rw : rh;
			int32_t cx = rx + rw / 2;
			int32_t cy = ry + rh / 2;
			int32_t outer_r = sz / 2 - 1;
			int32_t inner_r = outer_r * 6 / 10;
			if(outer_r > 0) {
				draw_aa_circle_ring(buf, bw, bh, cx, cy, outer_r, inner_r, win->theme.bg, win->theme.widget_border);
				int32_t dot_r = (outer_r - inner_r) / 2;
				if(dot_r < 2) {
					dot_r = 2;
				}
				draw_aa_circle_fill(buf, bw, bh, cx, cy - outer_r + (outer_r - inner_r) / 2, dot_r, win->theme.accent);
			}
		} break;

		case MKGUI_IMAGE: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, win->theme.input_bg);
			draw_rect_border(buf, bw, bh, rx, ry, rw, rh, win->theme.widget_border);
			draw_aa_line(buf, bw, bh, rx, ry, rx + rw - 1, ry + rh - 1, win->theme.widget_border, 1);
			draw_aa_line(buf, bw, bh, rx + rw - 1, ry, rx, ry + rh - 1, win->theme.widget_border, 1);
		} break;

		case MKGUI_GLVIEW: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, 0xFF1A1A2E);
			draw_rect_border(buf, bw, bh, rx, ry, rw, rh, win->theme.widget_border);
			int32_t ty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, ty, "GLView", win->theme.text_disabled, rx, ry, rx + rw, ry + rh);
		} break;

		case MKGUI_CANVAS: {
			draw_rect_fill(buf, bw, bh, rx, ry, rw, rh, 0xFF2A2A2A);
			draw_rect_border(buf, bw, bh, rx, ry, rw, rh, win->theme.widget_border);
			int32_t cty = ry + (rh - win->font_height) / 2;
			push_text_clip(rx + 4, cty, "Canvas", win->theme.text_disabled, rx, ry, rx + rw, ry + rh);
		} break;

		default: break;
	}
}

// ---------------------------------------------------------------------------
// Editor layout engine (mirrors layout_node tree walk from mkgui.c)
// ---------------------------------------------------------------------------

#define ED_LAYOUT_HASH_SIZE 8192
#define ED_LAYOUT_HASH_MASK (ED_LAYOUT_HASH_SIZE - 1)

static struct {
	uint32_t id;
	uint32_t idx;
} ed_layout_id_map[ED_LAYOUT_HASH_SIZE];

static uint32_t ed_layout_parent[ED_MAX_WIDGETS];
static uint32_t ed_layout_first_child[ED_MAX_WIDGETS];
static uint32_t ed_layout_next_sibling[ED_MAX_WIDGETS];

// [=]===^=[ ed_layout_build_index ]==============================[=]
static void ed_layout_build_index(void) {
	struct layout_ctx lc = {
		.widgets = (struct mkgui_widget *)ed.widgets,
		.first_child = ed_layout_first_child, .next_sibling = ed_layout_next_sibling,
		.parent = ed_layout_parent, .id_map = (struct mkgui_layout_hash_entry *)ed_layout_id_map,
		.hash_mask = ED_LAYOUT_HASH_MASK,
		.widget_count = ed.widget_count, .widget_stride = sizeof(struct ed_widget)
	};
	lc_build_index(&lc);
}

// ---------------------------------------------------------------------------
// Canvas rendering (render callback)
// ---------------------------------------------------------------------------

// [=]===^=[ ed_render_canvas ]===================================[=]
static void ed_render_canvas(struct mkgui_window *win, uint32_t id, uint32_t *pixels, int32_t cx, int32_t cy, int32_t cw, int32_t ch, void *userdata) {
	(void)id;
	(void)pixels;
	(void)userdata;

	uint32_t workspace_bg = blend_pixel(win->theme.bg, win->theme.text, 30);
	uint32_t grid_color = blend_pixel(win->theme.bg, win->theme.text, 60);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, cx, cy, cw, ch, workspace_bg);

	int32_t win_x = cx + (cw - ed.canvas_w) / 2;
	int32_t win_y = cy + (ch - ed.canvas_h) / 2;
	ed_win_x = win_x;
	ed_win_y = win_y;

	draw_rect_fill(win->pixels, win->win_w, win->win_h, win_x, win_y, ed.canvas_w, ed.canvas_h, win->theme.bg);
	draw_rect_border(win->pixels, win->win_w, win->win_h, win_x, win_y, ed.canvas_w, ed.canvas_h, win->theme.widget_border);

	if(ed.grid_size >= 4) {
		for(uint32_t gy = 0; gy < (uint32_t)ed.canvas_h; gy += (uint32_t)ed.grid_size) {
			for(uint32_t gx = 0; gx < (uint32_t)ed.canvas_w; gx += (uint32_t)ed.grid_size) {
				int32_t px = win_x + (int32_t)gx;
				int32_t py = win_y + (int32_t)gy;
				if(px >= cx && px < cx + cw && py >= cy && py < cy + ch) {
					if(px >= 0 && px < win->win_w && py >= 0 && py < win->win_h) {
						win->pixels[py * win->win_w + px] = grid_color;
					}
				}
			}
		}
	}

	// Layout using tree-walk algorithm (mirrors layout_node in mkgui.c)
	ed_layout_build_index();
	uint32_t ed_win_idx = UINT32_MAX;
	int32_t ed_win_save_y = 0, ed_win_save_h = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_WINDOW) {
			ed_win_idx = i;
			ed_rects[i].x = win_x;
			ed_rects[i].y = win_y;
			ed_rects[i].w = ed.canvas_w;
			ed_rects[i].h = ed.canvas_h;
			ed_win_save_y = win_y;
			ed_win_save_h = ed.canvas_h;
			{
				struct layout_ctx elc = {
					.widgets = (struct mkgui_widget *)ed.widgets,
					.rects = (void *)ed_rects,
					.first_child = ed_layout_first_child,
					.next_sibling = ed_layout_next_sibling,
					.parent = ed_layout_parent,
					.widget_count = ed.widget_count,
					.has_scroll = 0,
					.widget_stride = sizeof(struct ed_widget)
				};
				lc_layout_node(win, &elc, i);
			}
			break;
		}
	}

	// Restore window rect for rendering (chrome reservation shrinks it)
	if(ed_win_idx < ed.widget_count) {
		ed_rects[ed_win_idx].y = ed_win_save_y;
		ed_rects[ed_win_idx].h = ed_win_save_h;
	}

	// Simple widgets render for real via staging slot 0; complex ones use fallback previews.
	struct mkgui_widget save_w0 = win->widgets[0];
	struct mkgui_rect save_r0 = win->rects[0];
	uint32_t save_hover = win->hover_id;
	uint32_t save_press = win->press_id;
	uint32_t save_focus = win->focus_id;
	win->hover_id = 0;
	win->press_id = 0;
	win->focus_id = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_WINDOW || ed.widgets[i].type == MKGUI_TAB || ed.widgets[i].type == MKGUI_MENUITEM) {
			continue;
		}

		if(ed.widgets[i].type == MKGUI_BUTTON && ed_layout_parent[i] < ed.widget_count && ed.widgets[ed_layout_parent[i]].type == MKGUI_TOOLBAR) {
			continue;
		}

		if(!ed_is_tab_child_visible(i)) {
			continue;
		}

		if(ed_rects[i].w <= 0 || ed_rects[i].h <= 0) {
			continue;
		}
		uint32_t t = ed.widgets[i].type;
		static uint64_t ed_real_render =
			(1ull << MKGUI_BUTTON) | (1ull << MKGUI_LABEL) |
			(1ull << MKGUI_CHECKBOX) | (1ull << MKGUI_RADIO) |
			(1ull << MKGUI_GROUP) | (1ull << MKGUI_PANEL) |
			(1ull << MKGUI_DIVIDER);
		if(t < 64 && (ed_real_render & (1ull << t))) {
			memcpy(&win->widgets[0], &ed.widgets[i], sizeof(struct mkgui_widget));
			memcpy(&win->rects[0], &ed_rects[i], sizeof(struct mkgui_rect));
			render_widget(win, 0);
		} else {
			ed_draw_widget_fallback(win, i);
		}
		flush_text(win);
	}
	win->widgets[0] = save_w0;
	win->rects[0] = save_r0;
	win->hover_id = save_hover;
	win->press_id = save_press;
	win->focus_id = save_focus;

	// Draw dashed outlines for invisible containers
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(!ed_is_tab_child_visible(i)) {
			continue;
		}

		uint32_t t = ed.widgets[i].type;
		uint32_t st = ed.widgets[i].style;
		uint32_t needs_outline = 0;
		if(t == MKGUI_VBOX || t == MKGUI_HBOX || t == MKGUI_FORM || t == MKGUI_SPACER || t == MKGUI_DIVIDER) {
			if(!(st & MKGUI_PANEL_BORDER)) {
				needs_outline = 1;
			}
		} else if(t == MKGUI_TABS || t == MKGUI_HSPLIT || t == MKGUI_VSPLIT) {
			needs_outline = 1;
		} else if(t == MKGUI_PANEL) {
			if(!(st & (MKGUI_PANEL_BORDER | MKGUI_PANEL_SUNKEN))) {
				needs_outline = 1;
			}
		}

		if(needs_outline) {
			draw_rect_dashed(win->pixels, win->win_w, win->win_h, ed_rects[i].x, ed_rects[i].y, ed_rects[i].w, ed_rects[i].h, 0xFF666666, 4);
		}
	}

	// Selection handles on top
	if(ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
		int32_t wx = ed_rects[ed.selected].x;
		int32_t wy = ed_rects[ed.selected].y;
		int32_t ww = ed_rects[ed.selected].w;
		int32_t wh = ed_rects[ed.selected].h;

		draw_rect_border(win->pixels, win->win_w, win->win_h, wx - 1, wy - 1, ww + 2, wh + 2, 0xFF007ACC);

		int32_t hx[] = { wx, wx + ww / 2, wx + ww, wx + ww, wx + ww, wx + ww / 2, wx, wx };
		int32_t hy[] = { wy, wy, wy, wy + wh / 2, wy + wh, wy + wh, wy + wh, wy + wh / 2 };
		for(uint32_t j = 0; j < 8; ++j) {
			draw_rect_fill(win->pixels, win->win_w, win->win_h, hx[j] - 3, hy[j] - 3, 6, 6, 0xFF007ACC);
		}
	}

	uint32_t hc = 0xFF888888;
	int32_t hs = 4;
	int32_t mx = win_x + ed.canvas_w / 2;
	int32_t my = win_y + ed.canvas_h / 2;
	int32_t rx = win_x + ed.canvas_w;
	int32_t by = win_y + ed.canvas_h;
	draw_rect_fill(win->pixels, win->win_w, win->win_h, mx - hs, win_y - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, mx - hs, by - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, win_x - hs, my - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, rx - hs, my - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, win_x - hs, win_y - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, rx - hs, win_y - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, win_x - hs, by - hs, hs * 2, hs * 2, hc);
	draw_rect_fill(win->pixels, win->win_w, win->win_h, rx - hs, by - hs, hs * 2, hs * 2, hc);

	if(ed.placement_type) {
		char *placing = ed_type_name(ed.placement_type);
		char buf[64];
		snprintf(buf, sizeof(buf), "Placing: %s (click canvas, Esc to cancel)", placing);
		push_text(cx + 4, cy + 4, buf, 0xFFFFFF00);
	}

	char size_buf[32];
	snprintf(size_buf, sizeof(size_buf), "%dx%d", ed.canvas_w, ed.canvas_h);
	push_text(win_x + 2, by + 4, size_buf, 0xFF888888);
}

// ---------------------------------------------------------------------------
// Treeview sync
// ---------------------------------------------------------------------------

// [=]===^=[ ed_sync_tree ]=======================================[=]
static void ed_sync_tree(struct mkgui_window *win) {
	mkgui_treeview_setup(win, ED_TREE);
	char buf[128];
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		snprintf(buf, sizeof(buf), "%s: %s", ed_type_name(w->type), w->id_name);
		uint32_t parent_node = 0;
		if(w->parent_id != 0) {
			parent_node = w->parent_id;
		}
		mkgui_treeview_add(win, ED_TREE, w->id, parent_node, buf);
	}

	struct mkgui_treeview_data *tv = find_treeview_data(win, ED_TREE);
	if(tv) {
		for(uint32_t j = 0; j < tv->node_count; ++j) {
			tv->nodes[j].expanded = 1;
		}

		if(ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
			tv->selected_node = (int32_t)ed.widgets[ed.selected].id;
		}
	}

	dirty_all(win);
}

// [=]===^=[ ed_find_menu_root ]===================================[=]
static uint32_t ed_find_menu_root(uint32_t widget_idx) {
	struct ed_widget *w = &ed.widgets[widget_idx];
	if(w->type == MKGUI_MENU) {
		return w->id;
	}
	uint32_t pid = w->parent_id;
	for(uint32_t depth = 0; depth < 32; ++depth) {
		int32_t idx = ed_find_widget(pid);
		if(idx < 0) {
			break;
		}

		if(ed.widgets[idx].type == MKGUI_MENU) {
			return ed.widgets[idx].id;
		}
		pid = ed.widgets[idx].parent_id;
	}
	return 0;
}

// [=]===^=[ ed_sync_menu_tree ]===================================[=]
static void ed_sync_menu_tree(struct mkgui_window *win) {
	struct mkgui_widget *tw = find_widget(win, ED_MENU_TREE);
	if(!tw) {
		return;
	}

	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		tw->flags |= MKGUI_HIDDEN;
		return;
	}

	struct ed_widget *sel = &ed.widgets[ed.selected];
	if(sel->type != MKGUI_MENU && sel->type != MKGUI_MENUITEM) {
		tw->flags |= MKGUI_HIDDEN;
		return;
	}

	uint32_t menu_id = ed_find_menu_root((uint32_t)ed.selected);
	if(!menu_id) {
		tw->flags |= MKGUI_HIDDEN;
		return;
	}

	tw->flags &= ~MKGUI_HIDDEN;

	mkgui_treeview_setup(win, ED_MENU_TREE);

	char buf[MKGUI_MAX_TEXT + 64];
	int32_t menu_idx = ed_find_widget(menu_id);
	if(menu_idx >= 0) {
		struct ed_widget *mw = &ed.widgets[menu_idx];
		snprintf(buf, sizeof(buf), "%s: %s", ed_type_name(mw->type), mw->id_name);
		mkgui_treeview_add(win, ED_MENU_TREE, mw->id, 0, buf);
	}

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->type == MKGUI_MENUITEM && ed_is_descendant(i, menu_id)) {
			snprintf(buf, sizeof(buf), "%s: %s", ed_type_name(w->type), w->label[0] ? w->label : w->id_name);
			mkgui_treeview_add(win, ED_MENU_TREE, w->id, w->parent_id, buf);
		}
	}

	struct mkgui_treeview_data *tv = find_treeview_data(win, ED_MENU_TREE);
	if(tv) {
		for(uint32_t j = 0; j < tv->node_count; ++j) {
			tv->nodes[j].expanded = 1;
		}
		tv->selected_node = (int32_t)sel->id;
	}

	dirty_all(win);
}

// ---------------------------------------------------------------------------
// Property panel sync
// ---------------------------------------------------------------------------

// [=]===^=[ ed_is_container_type ]=================================[=]
static uint32_t ed_is_container_type(uint32_t type) {
	return type == MKGUI_WINDOW || type == MKGUI_TABS || type == MKGUI_TAB ||
	       type == MKGUI_HSPLIT || type == MKGUI_VSPLIT || type == MKGUI_GROUP ||
	       type == MKGUI_PANEL || type == MKGUI_VBOX || type == MKGUI_HBOX ||
	       type == MKGUI_FORM || type == MKGUI_TOOLBAR;
}

// [=]===^=[ ed_sync_parent_dropdown ]=============================[=]
static void ed_sync_parent_dropdown(struct mkgui_window *win) {
	const char *items[ED_MAX_WIDGETS];
	static char item_bufs[ED_MAX_WIDGETS][MKGUI_MAX_TEXT + 80];
	uint32_t count = 0;

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *ew = &ed.widgets[i];
		if(ed_is_container_type(ew->type)) {
			snprintf(item_bufs[count], sizeof(item_bufs[count]), "%u: %s (%s)", ew->id, ew->id_name[0] ? ew->id_name : ew->label, ed_type_name(ew->type));
			items[count] = item_bufs[count];
			++count;
		}
	}

	if(count == 0) {
		return;
	}

	mkgui_dropdown_setup(win, ED_PROP_PARENT_DRP, items, count);

	if(ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
		uint32_t pid = ed.widgets[ed.selected].parent_id;
		uint32_t sel_idx = 0;
		uint32_t j = 0;
		for(uint32_t i = 0; i < ed.widget_count; ++i) {
			struct ed_widget *ew = &ed.widgets[i];
			if(ed_is_container_type(ew->type) || ew->type == MKGUI_MENU || ew->type == MKGUI_MENUITEM) {
				if(ew->id == pid) {
					sel_idx = j;
				}
				++j;
			}
		}
		struct mkgui_dropdown_data *dd = find_dropdown_data(win, ED_PROP_PARENT_DRP);
		if(dd) {
			dd->selected = (int32_t)sel_idx;
		}
	}
}

// [=]===^=[ ed_apply_parent_dropdown ]============================[=]
static void ed_apply_parent_dropdown(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}

	struct mkgui_dropdown_data *dd = find_dropdown_data(win, ED_PROP_PARENT_DRP);
	if(!dd || dd->selected < 0) {
		return;
	}

	uint32_t j = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *ew = &ed.widgets[i];
		if(ed_is_container_type(ew->type)) {
			if(j == (uint32_t)dd->selected) {
				ed.widgets[ed.selected].parent_id = ew->id;
				ed_sync_tree(win);
				dirty_all(win);
				return;
			}
			++j;
		}
	}
}

// ---------------------------------------------------------------------------
// Events panel sync
// ---------------------------------------------------------------------------

static uint32_t ed_cur_events[40];
static uint32_t ed_cur_event_count;

// [=]===^=[ ed_event_row_cb ]=====================================[=]
static void ed_event_row_cb(uint32_t row, uint32_t col, char *buf, uint32_t buf_size, void *userdata) {
	(void)col;
	(void)userdata;
	if(row < ed_cur_event_count) {
		snprintf(buf, buf_size, "%s", ed_event_name(ed_cur_events[row]));
	} else {
		buf[0] = '\0';
	}
}

// [=]===^=[ ed_sync_events ]======================================[=]
static void ed_sync_events(struct mkgui_window *win) {
	ed_cur_event_count = 0;

	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		ed_set_widget_vis(win, ED_EVT_GROUP, 0);
		mkgui_listview_set_rows(win, ED_EVT_LIST, 0);
		return;
	}

	struct ed_widget *w = &ed.widgets[ed.selected];
	struct ed_type_event_map *map = ed_find_type_events(w->type);
	if(!map || map->event_count == 0) {
		ed_set_widget_vis(win, ED_EVT_GROUP, 0);
		mkgui_listview_set_rows(win, ED_EVT_LIST, 0);
		return;
	}

	ed_set_widget_vis(win, ED_EVT_GROUP, 1);
	for(uint32_t i = 0; i < map->event_count && i < 40; ++i) {
		ed_cur_events[ed_cur_event_count++] = map->events[i];
	}
	mkgui_listview_set_rows(win, ED_EVT_LIST, ed_cur_event_count);

	struct mkgui_listview_data *lv = find_listv_data(win, ED_EVT_LIST);
	if(lv) {
		lv->multi_sel_count = 0;
		lv->selected_row = -1;
		for(uint32_t i = 0; i < ed_cur_event_count; ++i) {
			if(w->event_mask & (1ULL << ed_cur_events[i])) {
				if(lv->multi_sel_count < MKGUI_MAX_MULTI_SEL) {
					lv->multi_sel[lv->multi_sel_count++] = (int32_t)i;
				}
			}
		}
	}

	struct mkgui_widget *grp = find_widget(win, ED_EVT_GROUP);
	if(grp) {
		int32_t rows = (int32_t)ed_cur_event_count;
		if(rows > 8) {
			rows = 8;
		}
		grp->h = 36 + rows * win->row_height + 20;
	}
}

// ---------------------------------------------------------------------------
// Data panel sync
// ---------------------------------------------------------------------------

static uint32_t ed_data_widget_id;

// [=]===^=[ ed_data_row_cb ]======================================[=]
static void ed_data_row_cb(uint32_t row, uint32_t col, char *buf, uint32_t buf_size, void *userdata) {
	(void)col;
	(void)userdata;
	struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
	if(d && row < d->item_count) {
		snprintf(buf, buf_size, "%s", d->items[row]);
	} else {
		buf[0] = '\0';
	}
}

// [=]===^=[ ed_sync_data ]========================================[=]
static void ed_sync_data(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		ed_set_widget_vis(win, ED_DATA_GROUP, 0);
		mkgui_listview_set_rows(win, ED_DATA_LIST, 0);
		return;
	}

	struct ed_widget *w = &ed.widgets[ed.selected];
	if(w->type != MKGUI_DROPDOWN && w->type != MKGUI_COMBOBOX && w->type != MKGUI_STATUSBAR) {
		ed_set_widget_vis(win, ED_DATA_GROUP, 0);
		mkgui_listview_set_rows(win, ED_DATA_LIST, 0);
		return;
	}

	ed_set_widget_vis(win, ED_DATA_GROUP, 1);
	char *group_label = (w->type == MKGUI_STATUSBAR) ? "Sections" : "Data";
	struct mkgui_widget *dg = find_widget(win, ED_DATA_GROUP);
	if(dg) {
		strncpy(dg->label, group_label, MKGUI_MAX_TEXT - 1);
	}
	ed_data_widget_id = w->id;
	struct ed_widget_data *d = ed_get_or_create_widget_data(w->id);
	if(d) {
		mkgui_listview_set_rows(win, ED_DATA_LIST, d->item_count);
	} else {
		mkgui_listview_set_rows(win, ED_DATA_LIST, 0);
	}

	int32_t sel = mkgui_listview_get_selected(win, ED_DATA_LIST);
	if(d && sel >= 0 && (uint32_t)sel < d->item_count) {
		mkgui_input_set(win, ED_DATA_ITEM_INP, d->items[sel]);
	} else {
		mkgui_input_set(win, ED_DATA_ITEM_INP, "");
	}
}


// [=]===^=[ ed_sync_props ]======================================[=]
static void ed_sync_props(struct mkgui_window *win) {
	struct ed_widget *w = NULL;
	uint32_t vis = 0;
	if(ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
		w = &ed.widgets[ed.selected];
		vis = ed_compute_vis_mask(w);
	}

	uint32_t btn_hbox_visible = 0;
	for(uint32_t i = 0; i < ED_PROP_COUNT; ++i) {
		struct ed_prop_desc *p = &ed_props[i];
		uint32_t show = w && ed_prop_visible(p, vis);
		ed_set_widget_vis(win, p->widget_id, show);
		ed_set_widget_vis(win, p->label_id, show);
		ed_set_widget_vis(win, p->widget_id2, show);
		ed_set_widget_vis(win, p->label_id2, show);
		if(show && w) {
			ed_sync_prop_value(win, p, w);
			if(p->kind == ED_PK_ACTION) {
				btn_hbox_visible = 1;
			}
		}
	}
	ed_set_widget_vis(win, ED_PROP_BTN_HBOX, btn_hbox_visible);

	if(!w) {
		mkgui_label_set(win, ED_PROP_TYPE_VAL, "(none)");
	}

	ed_sync_parent_dropdown(win);
	ed_sync_menu_tree(win);
	ed_sync_events(win);
	ed_sync_data(win);
	dirty_all(win);
}

// [=]===^=[ ed_read_props ]======================================[=]
static void ed_read_props(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *w = &ed.widgets[ed.selected];
	uint32_t old_flags = w->flags;
	w->flags = 0;
	for(uint32_t i = 0; i < ED_PROP_COUNT; ++i) {
		ed_read_prop_value(win, &ed_props[i], w);
	}

	if((w->type == MKGUI_SLIDER || w->type == MKGUI_SCROLLBAR) && ((old_flags ^ w->flags) & MKGUI_VERTICAL)) {
		int32_t tmp = w->w;
		w->w = w->h;
		w->h = tmp;
	}
	dirty_all(win);
}

// ---------------------------------------------------------------------------
// Tab / menu management
// ---------------------------------------------------------------------------

// [=]===^=[ ed_add_tab_to_tabs ]==================================[=]
static void ed_add_tab_to_tabs(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *tabs_w = &ed.widgets[ed.selected];
	if(tabs_w->type != MKGUI_TABS || ed.widget_count >= ED_MAX_WIDGETS) {
		return;
	}

	ed_push_undo();

	uint32_t tabs_id = tabs_w->id;
	uint32_t tab_num = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_TAB && ed.widgets[i].parent_id == tabs_id) {
			++tab_num;
		}
	}

	uint32_t pos = ed_insert_child_after(tabs_id);
	struct ed_widget *tab = &ed.widgets[pos];
	tab->type = MKGUI_TAB;
	tab->id = ed.next_id++;
	tab->parent_id = tabs_id;
	snprintf(tab->label, sizeof(tab->label), "Tab %u", tab_num + 1);
	tab->tab_order = pos;
	ed_gen_id_name(tab);

	ed_set_active_tab(tabs_id, tab->id);
	ed.selected = ed_find_widget(tabs_id);
	ed_sync_tree(win);
	ed_sync_props(win);
}

// [=]===^=[ ed_remove_tab_from_tabs ]=============================[=]
static void ed_remove_tab_from_tabs(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *tabs_w = &ed.widgets[ed.selected];
	if(tabs_w->type != MKGUI_TABS) {
		return;
	}

	uint32_t active = ed_get_active_tab(tabs_w->id);
	if(!active) {
		return;
	}

	uint32_t tab_count = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_TAB && ed.widgets[i].parent_id == tabs_w->id) {
			++tab_count;
		}
	}

	if(tab_count <= 1) {
		return;
	}

	ed_push_undo();

	ed_delete_widget_tree(active);

	uint32_t new_active = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_TAB && ed.widgets[i].parent_id == tabs_w->id) {
			new_active = ed.widgets[i].id;
			break;
		}
	}
	ed_set_active_tab(tabs_w->id, new_active);

	ed.selected = ed_find_widget(tabs_w->id);
	ed_sync_tree(win);
	ed_sync_props(win);
}

// [=]===^=[ ed_add_menu_item ]====================================[=]
static void ed_add_menu_item(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *parent_w = &ed.widgets[ed.selected];
	if((parent_w->type != MKGUI_MENU && parent_w->type != MKGUI_MENUITEM) || ed.widget_count >= ED_MAX_WIDGETS) {
		return;
	}

	ed_push_undo();

	uint32_t parent_id = parent_w->id;
	uint32_t pos = ed_insert_child_after(parent_id);
	struct ed_widget *item = &ed.widgets[pos];
	item->type = MKGUI_MENUITEM;
	item->id = ed.next_id++;
	item->parent_id = parent_id;
	snprintf(item->label, sizeof(item->label), "Item");
	item->tab_order = pos;
	ed_gen_id_name(item);

	ed.selected = ed_find_widget(parent_id);
	ed_sync_tree(win);
	ed_sync_props(win);
}

// [=]===^=[ ed_remove_menu_item ]=================================[=]
static void ed_remove_menu_item(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *sel = &ed.widgets[ed.selected];
	if(sel->type != MKGUI_MENU && sel->type != MKGUI_MENUITEM) {
		return;
	}

	if(sel->type == MKGUI_MENUITEM) {
		ed_push_undo();
		uint32_t parent_id = sel->parent_id;
		ed_delete_widget_tree(sel->id);
		ed.selected = ed_find_widget(parent_id);
		ed_sync_tree(win);
		ed_sync_props(win);
		return;
	}

	int32_t last_item = -1;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_MENUITEM && ed.widgets[i].parent_id == sel->id) {
			last_item = (int32_t)i;
		}
	}

	if(last_item < 0) {
		return;
	}

	ed_push_undo();

	uint32_t del_id = ed.widgets[last_item].id;
	ed_delete_widget_tree(del_id);

	ed.selected = ed_find_widget(sel->id);
	ed_sync_tree(win);
	ed_sync_props(win);
}

// [=]===^=[ ed_add_toolbar_btn ]==================================[=]
static void ed_add_toolbar_btn(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *tb = &ed.widgets[ed.selected];
	if(tb->type != MKGUI_TOOLBAR || ed.widget_count >= ED_MAX_WIDGETS) {
		return;
	}

	ed_push_undo();

	uint32_t tb_id = tb->id;
	uint32_t btn_num = 0;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_BUTTON && ed.widgets[i].parent_id == tb_id) {
			++btn_num;
		}
	}

	uint32_t pos = ed_insert_child_after(tb_id);
	struct ed_widget *btn = &ed.widgets[pos];
	btn->type = MKGUI_BUTTON;
	btn->id = ed.next_id++;
	btn->parent_id = tb_id;
	snprintf(btn->label, sizeof(btn->label), "Button %u", btn_num + 1);
	btn->tab_order = pos;
	ed_gen_id_name(btn);

	ed.selected = ed_find_widget(tb_id);
	ed_sync_tree(win);
	dirty_all(win);
}

// [=]===^=[ ed_remove_toolbar_btn ]===============================[=]
static void ed_remove_toolbar_btn(struct mkgui_window *win) {
	if(ed.selected < 0 || (uint32_t)ed.selected >= ed.widget_count) {
		return;
	}
	struct ed_widget *tb = &ed.widgets[ed.selected];
	if(tb->type != MKGUI_TOOLBAR) {
		return;
	}

	int32_t last_btn = -1;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_BUTTON && ed.widgets[i].parent_id == tb->id) {
			last_btn = (int32_t)i;
		}
	}

	if(last_btn < 0) {
		return;
	}

	ed_push_undo();

	uint32_t del_id = ed.widgets[last_btn].id;
	ed_delete_widget_tree(del_id);

	ed.selected = ed_find_widget(tb->id);
	ed_sync_tree(win);
	ed_sync_props(win);
}

// ---------------------------------------------------------------------------
// Project save / load
// ---------------------------------------------------------------------------

// [=]===^=[ ed_save_project ]=====================================[=]
static void ed_save_project(struct mkgui_window *win, uint32_t save_as) {
	if(save_as || ed.project_path[0] == '\0') {
		struct mkgui_file_filter save_filters[] = {
			{ "mkgui files", "*.mkgui" },
			{ "All files", "*" },
		};
		struct mkgui_file_dialog_opts save_opts = {0};
		save_opts.default_name = "untitled.mkgui";
		save_opts.filters = save_filters;
		save_opts.filter_count = 2;
		if(!mkgui_dialog_save(win, &save_opts)) {
			return;
		}
		const char *path = mkgui_dialog_get_path(win, 0);
		snprintf(ed.project_path, sizeof(ed.project_path), "%s", path);
	}

	FILE *f = fopen(ed.project_path, "w");
	if(!f) {
		return;
	}

	fprintf(f, "[mkgui 1]\n");
	fprintf(f, "canvas %d %d\n", ed.canvas_w, ed.canvas_h);
	fprintf(f, "grid %d\n", ed.grid_size);
	fprintf(f, "next_id %u\n", ed.next_id);
	fprintf(f, "\n");

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		fprintf(f, "[widget %u]\n", i);
		fprintf(f, "type %u\n", w->type);
		fprintf(f, "id %u\n", w->id);
		fprintf(f, "id_name %s\n", w->id_name);
		fprintf(f, "label %s\n", w->label);
		fprintf(f, "icon %s\n", w->icon);
		if(w->icon_source[0]) {
			fprintf(f, "icon_source %s\n", w->icon_source);
		}
		fprintf(f, "parent %u\n", w->parent_id);
		fprintf(f, "size %d %d\n", w->w, w->h);
		fprintf(f, "flags 0x%08x\n", w->flags);
		fprintf(f, "style 0x%08x\n", w->style);
		fprintf(f, "weight %u\n", w->weight);
		fprintf(f, "tab_order %u\n", w->tab_order);
		fprintf(f, "event_mask 0x%016llx\n", (unsigned long long)w->event_mask);
		if(w->margin_l || w->margin_t || w->margin_r || w->margin_b) {
			fprintf(f, "margins %d %d %d %d\n", w->margin_l, w->margin_t, w->margin_r, w->margin_b);
		}

		if(w->accel_keysym) {
			fprintf(f, "accel_mod 0x%08x\n", w->accel_keymod);
			fprintf(f, "accel_key 0x%08x\n", w->accel_keysym);
		}

		struct ed_widget_data *d = ed_find_widget_data(w->id);
		if(d) {
			for(uint32_t j = 0; j < d->item_count; ++j) {
				fprintf(f, "item %s\n", d->items[j]);
			}
		}

		fprintf(f, "\n");
	}

	for(uint32_t i = 0; i < ed.tab_state_count; ++i) {
		fprintf(f, "[tab_state]\n");
		fprintf(f, "tabs %u %u\n", ed.tab_states[i].tabs_id, ed.tab_states[i].active_id);
		fprintf(f, "\n");
	}

	fclose(f);

	char buf[FD_PATH_SIZE + 320];
	char *fname = strrchr(ed.project_path, '/');
	if(!fname) {
		fname = ed.project_path;
	} else {
		++fname;
	}
	snprintf(buf, sizeof(buf), "Saved: %s", fname);
	mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);

	ed_config_add_recent(ed.project_path);
	ed_sync_recent_menu(win);
}

// [=]===^=[ ed_load_file ]========================================[=]
static void ed_load_file(struct mkgui_window *win, const char *path) {
	FILE *f = fopen(path, "r");
	if(!f) {
		return;
	}

	snprintf(ed.project_path, sizeof(ed.project_path), "%s", path);

	memset(ed.widgets, 0, sizeof(ed.widgets));
	ed.widget_count = 0;
	ed.selected = -1;
	ed.placement_type = 0;
	ed.next_id = 1;
	ed.canvas_w = ED_CANVAS_DEF_W;
	ed.canvas_h = ED_CANVAS_DEF_H;
	ed.grid_size = ED_GRID_DEFAULT;
	ed.drag_active = 0;
	ed.tab_state_count = 0;
	ed.widget_data_count = 0;

	char line[1024];
	int32_t cur_widget = -1;
	uint32_t cur_data_id = 0;

	while(fgets(line, (int32_t)sizeof(line), f)) {
		size_t len = strlen(line);
		while(len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
			line[--len] = '\0';
		}

		if(len == 0) {
			continue;
		}

		if(line[0] == '[') {
			uint32_t idx;
			if(sscanf(line, "[mkgui %*d]") == 0 && strncmp(line, "[mkgui ", 7) == 0) {
				cur_widget = -1;
				cur_data_id = 0;

			} else if(sscanf(line, "[widget %u]", &idx) == 1) {
				if(ed.widget_count < ED_MAX_WIDGETS) {
					cur_widget = (int32_t)ed.widget_count;
					memset(&ed.widgets[cur_widget], 0, sizeof(struct ed_widget));
					ed.widgets[cur_widget].label_tw = -1;
					++ed.widget_count;
					cur_data_id = 0;
				}

			} else if(strncmp(line, "[tab_state]", 11) == 0) {
				cur_widget = -1;
				cur_data_id = 0;
				if(ed.tab_state_count < 32) {
					char next_line[1024];
					if(fgets(next_line, (int32_t)sizeof(next_line), f)) {
						uint32_t tid, aid;
						if(sscanf(next_line, "tabs %u %u", &tid, &aid) == 2) {
							ed.tab_states[ed.tab_state_count].tabs_id = tid;
							ed.tab_states[ed.tab_state_count].active_id = aid;
							++ed.tab_state_count;
						}
					}
				}
			}
			continue;
		}

		if(strncmp(line, "canvas ", 7) == 0) {
			sscanf(line + 7, "%d %d", &ed.canvas_w, &ed.canvas_h);

		} else if(strncmp(line, "grid ", 5) == 0) {
			sscanf(line + 5, "%d", &ed.grid_size);

		} else if(strncmp(line, "next_id ", 8) == 0) {
			sscanf(line + 8, "%u", &ed.next_id);

		} else if(cur_widget >= 0 && (uint32_t)cur_widget < ed.widget_count) {
			struct ed_widget *w = &ed.widgets[cur_widget];

			if(strncmp(line, "type ", 5) == 0) {
				sscanf(line + 5, "%u", &w->type);

			} else if(strncmp(line, "id_name ", 8) == 0) {
				snprintf(w->id_name, sizeof(w->id_name), "%.63s", line + 8);

			} else if(strncmp(line, "id ", 3) == 0) {
				sscanf(line + 3, "%u", &w->id);

			} else if(strncmp(line, "label ", 6) == 0) {
				snprintf(w->label, sizeof(w->label), "%.255s", line + 6);

			} else if(strncmp(line, "label", 5) == 0 && line[5] == '\0') {
				w->label[0] = '\0';

			} else if(strncmp(line, "icon ", 5) == 0) {
				snprintf(w->icon, sizeof(w->icon), "%.63s", line + 5);

			} else if(strncmp(line, "icon", 4) == 0 && line[4] == '\0') {
				w->icon[0] = '\0';

			} else if(strncmp(line, "icon_source ", 12) == 0) {
				snprintf(w->icon_source, sizeof(w->icon_source), "%s", line + 12);

			} else if(strncmp(line, "parent ", 7) == 0) {
				sscanf(line + 7, "%u", &w->parent_id);

			} else if(strncmp(line, "pos ", 4) == 0) {
				sscanf(line + 4, "%d %d", &w->x, &w->y);

			} else if(strncmp(line, "size ", 5) == 0) {
				sscanf(line + 5, "%d %d", &w->w, &w->h);

			} else if(strncmp(line, "flags ", 6) == 0) {
				uint32_t fl;
				sscanf(line + 6, "%x", &fl);
				w->flags = fl;

			} else if(strncmp(line, "style ", 6) == 0) {
				uint32_t st;
				sscanf(line + 6, "%x", &st);
				w->style = st;

			} else if(strncmp(line, "weight ", 7) == 0) {
				sscanf(line + 7, "%u", &w->weight);

			} else if(strncmp(line, "tab_order ", 10) == 0) {
				sscanf(line + 10, "%u", &w->tab_order);

			} else if(strncmp(line, "event_mask ", 11) == 0) {
				unsigned long long em;
				sscanf(line + 11, "%llx", &em);
				w->event_mask = (uint64_t)em;

			} else if(strncmp(line, "margins ", 8) == 0) {
				sscanf(line + 8, "%d %d %d %d", &w->margin_l, &w->margin_t, &w->margin_r, &w->margin_b);

			} else if(strncmp(line, "accel_mod ", 10) == 0) {
				w->accel_keymod = (uint32_t)strtoul(line + 10, NULL, 0);

			} else if(strncmp(line, "accel_key ", 10) == 0) {
				w->accel_keysym = (uint32_t)strtoul(line + 10, NULL, 0);

			} else if(strncmp(line, "item ", 5) == 0) {
				if(!cur_data_id) {
					cur_data_id = w->id;
				}
				struct ed_widget_data *d = ed_get_or_create_widget_data(cur_data_id);
				if(d && d->item_count < ED_MAX_DATA_ITEMS) {
					snprintf(d->items[d->item_count], MKGUI_MAX_TEXT, "%.255s", line + 5);
					++d->item_count;
				}
			}
		}
	}

	fclose(f);

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->icon[0] && w->icon_source[0]) {
			mkgui_icon_load_svg(win, w->icon, w->icon_source);
		}
	}

	ed.undo_pos = 0;
	ed.undo_count = 0;

	ed_sync_tree(win);
	ed_sync_props(win);

	ed_config_add_recent(path);
	ed_sync_recent_menu(win);

	char buf[256];
	const char *fname = strrchr(path, '/');
	if(!fname) {
		fname = path;
	} else {
		++fname;
	}
	snprintf(buf, sizeof(buf), "Loaded: %s", fname);
	mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);
}

// [=]===^=[ ed_load_project ]=====================================[=]
static void ed_load_project(struct mkgui_window *win) {
	struct mkgui_file_filter open_filters[] = {
		{ "mkgui files", "*.mkgui" },
		{ "All files", "*" },
	};
	struct mkgui_file_dialog_opts open_opts = {0};
	open_opts.filters = open_filters;
	open_opts.filter_count = 2;
	if(!mkgui_dialog_open(win, &open_opts)) {
		return;
	}
	ed_load_file(win, mkgui_dialog_get_path(win, 0));
}

// [=]===^=[ ed_load_recent ]======================================[=]
static void ed_load_recent(struct mkgui_window *win, uint32_t index) {
	if(index >= ed_cfg.recent_count) {
		return;
	}
	ed_load_file(win, ed_cfg.recent[index]);
}

// ---------------------------------------------------------------------------
// Code generation
// ---------------------------------------------------------------------------

// [=]===^=[ ed_type_name_upper ]==================================[=]
static char *ed_type_name_upper(uint32_t type) {
	switch(type) {
		case MKGUI_WINDOW:     { return "MKGUI_WINDOW"; }
		case MKGUI_BUTTON:     { return "MKGUI_BUTTON"; }
		case MKGUI_LABEL:      { return "MKGUI_LABEL"; }
		case MKGUI_INPUT:      { return "MKGUI_INPUT"; }
		case MKGUI_CHECKBOX:   { return "MKGUI_CHECKBOX"; }
		case MKGUI_DROPDOWN:   { return "MKGUI_DROPDOWN"; }
		case MKGUI_SLIDER:     { return "MKGUI_SLIDER"; }
		case MKGUI_LISTVIEW:   { return "MKGUI_LISTVIEW"; }
		case MKGUI_MENU:       { return "MKGUI_MENU"; }
		case MKGUI_MENUITEM:   { return "MKGUI_MENUITEM"; }
		case MKGUI_TABS:       { return "MKGUI_TABS"; }
		case MKGUI_TAB:        { return "MKGUI_TAB"; }
		case MKGUI_HSPLIT:     { return "MKGUI_HSPLIT"; }
		case MKGUI_VSPLIT:     { return "MKGUI_VSPLIT"; }
		case MKGUI_TREEVIEW:   { return "MKGUI_TREEVIEW"; }
		case MKGUI_TREELIST:   { return "MKGUI_TREELIST"; }
		case MKGUI_STATUSBAR:  { return "MKGUI_STATUSBAR"; }
		case MKGUI_TOOLBAR:    { return "MKGUI_TOOLBAR"; }
		case MKGUI_SPINBOX:    { return "MKGUI_SPINBOX"; }
		case MKGUI_RADIO:      { return "MKGUI_RADIO"; }
		case MKGUI_PROGRESS:   { return "MKGUI_PROGRESS"; }
		case MKGUI_METER:      { return "MKGUI_METER"; }
		case MKGUI_TEXTAREA:   { return "MKGUI_TEXTAREA"; }
		case MKGUI_LOGVIEW:    { return "MKGUI_LOGVIEW"; }
		case MKGUI_GROUP:      { return "MKGUI_GROUP"; }
		case MKGUI_SPINNER:    { return "MKGUI_SPINNER"; }
		case MKGUI_ITEMVIEW:   { return "MKGUI_ITEMVIEW"; }
		case MKGUI_PANEL:      { return "MKGUI_PANEL"; }
		case MKGUI_GRIDVIEW:   { return "MKGUI_GRIDVIEW"; }
		case MKGUI_RICHLIST:   { return "MKGUI_RICHLIST"; }
		case MKGUI_SCROLLBAR:  { return "MKGUI_SCROLLBAR"; }
		case MKGUI_IMAGE:      { return "MKGUI_IMAGE"; }
		case MKGUI_GLVIEW:     { return "MKGUI_GLVIEW"; }
		case MKGUI_CANVAS:     { return "MKGUI_CANVAS"; }
		case MKGUI_SPACER:     { return "MKGUI_SPACER"; }
		case MKGUI_DIVIDER:    { return "MKGUI_DIVIDER"; }
		case MKGUI_IPINPUT:    { return "MKGUI_IPINPUT"; }
		case MKGUI_TOGGLE:     { return "MKGUI_TOGGLE"; }
		case MKGUI_COMBOBOX:   { return "MKGUI_COMBOBOX"; }
		case MKGUI_DATEPICKER: { return "MKGUI_DATEPICKER"; }
		case MKGUI_PATHBAR:    { return "MKGUI_PATHBAR"; }
		case MKGUI_VBOX:       { return "MKGUI_VBOX"; }
		case MKGUI_HBOX:       { return "MKGUI_HBOX"; }
		case MKGUI_FORM:       { return "MKGUI_FORM"; }
		default:               { return "0"; }
	}
}

// [=]===^=[ ed_flags_to_str ]=====================================[=]
static char *ed_flags_to_str(uint32_t flags, char *buf, uint32_t buf_size) {
	if(flags == 0) {
		return "0";
	}

	static struct { uint32_t bit; char *name; } single_bits[] = {
		{ MKGUI_REGION_TOP,      "MKGUI_REGION_TOP" },
		{ MKGUI_REGION_BOTTOM,   "MKGUI_REGION_BOTTOM" },
		{ MKGUI_REGION_LEFT,     "MKGUI_REGION_LEFT" },
		{ MKGUI_REGION_RIGHT,    "MKGUI_REGION_RIGHT" },
		{ MKGUI_HIDDEN,          "MKGUI_HIDDEN" },
		{ MKGUI_DISABLED,        "MKGUI_DISABLED" },
		{ MKGUI_SCROLL,          "MKGUI_SCROLL" },
		{ MKGUI_NO_PAD,          "MKGUI_NO_PAD" },
		{ MKGUI_FIXED,           "MKGUI_FIXED" },
		{ MKGUI_VERTICAL,        "MKGUI_VERTICAL" },
	};

	buf[0] = '\0';
	uint32_t pos = 0;
	uint32_t remaining = flags;

	for(uint32_t i = 0; i < sizeof(single_bits) / sizeof(single_bits[0]); ++i) {
		if(flags & single_bits[i].bit) {
			if(pos > 0) {
				pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
			}
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, "%s", single_bits[i].name);
			remaining &= ~single_bits[i].bit;
		}
	}

	uint32_t align = flags & MKGUI_ALIGN_MASK;
	if(align) {
		char *name = NULL;
		if(align == MKGUI_ALIGN_START) {
			name = "MKGUI_ALIGN_START";
		}
		else if(align == MKGUI_ALIGN_CENTER) { name = "MKGUI_ALIGN_CENTER"; }
		else if(align == MKGUI_ALIGN_END)    { name = "MKGUI_ALIGN_END"; }
		if(name) {
			if(pos > 0) {
				pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
			}
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, "%s", name);
			remaining &= ~MKGUI_ALIGN_MASK;
		}
	}

	remaining &= ~MKGUI_ALIGN_MASK;
	if(remaining) {
		if(pos > 0) {
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
		}
		snprintf(buf + pos, buf_size - pos, "0x%x", remaining);
	}

	return buf;
}

// [=]===^=[ ed_style_to_str ]=====================================[=]
static char *ed_style_to_str(uint32_t style, uint32_t widget_type, char *buf, uint32_t buf_size) {
	if(style == 0) {
		return "0";
	}

	struct ed_bit_name { uint32_t bit; char *name; };

	static struct ed_bit_name bits_checkbox[] = {
		{ MKGUI_CHECKBOX_CHECKED,    "MKGUI_CHECKBOX_CHECKED" },
	};
	static struct ed_bit_name bits_radio[] = {
		{ MKGUI_RADIO_CHECKED,       "MKGUI_RADIO_CHECKED" },
	};
	static struct ed_bit_name bits_toggle[] = {
		{ MKGUI_TOGGLE_CHECKED,      "MKGUI_TOGGLE_CHECKED" },
	};
	static struct ed_bit_name bits_button[] = {
		{ MKGUI_BUTTON_CHECKED,      "MKGUI_BUTTON_CHECKED" },
		{ MKGUI_BUTTON_SEPARATOR,    "MKGUI_BUTTON_SEPARATOR" },
	};
	static struct ed_bit_name bits_input[] = {
		{ MKGUI_INPUT_PASSWORD,      "MKGUI_INPUT_PASSWORD" },
		{ MKGUI_INPUT_READONLY,      "MKGUI_INPUT_READONLY" },
		{ MKGUI_INPUT_NUMERIC,       "MKGUI_INPUT_NUMERIC" },
	};
	static struct ed_bit_name bits_textarea[] = {
		{ MKGUI_TEXTAREA_READONLY,   "MKGUI_TEXTAREA_READONLY" },
	};
	static struct ed_bit_name bits_logview[] = {
		{ MKGUI_LOGVIEW_NOWRAP,      "MKGUI_LOGVIEW_NOWRAP" },
	};
	static struct ed_bit_name bits_datepicker[] = {
		{ MKGUI_DATEPICKER_READONLY, "MKGUI_DATEPICKER_READONLY" },
	};
	static struct ed_bit_name bits_menuitem[] = {
		{ MKGUI_MENUITEM_SEPARATOR,  "MKGUI_MENUITEM_SEPARATOR" },
		{ MKGUI_MENUITEM_CHECK,      "MKGUI_MENUITEM_CHECK" },
		{ MKGUI_MENUITEM_RADIO,      "MKGUI_MENUITEM_RADIO" },
		{ MKGUI_MENUITEM_CHECKED,    "MKGUI_MENUITEM_CHECKED" },
	};
	static struct ed_bit_name bits_panel[] = {
		{ MKGUI_PANEL_BORDER,        "MKGUI_PANEL_BORDER" },
		{ MKGUI_PANEL_SUNKEN,        "MKGUI_PANEL_SUNKEN" },
	};
	static struct ed_bit_name bits_vbox[] = {
		{ MKGUI_VBOX_BORDER,         "MKGUI_VBOX_BORDER" },
	};
	static struct ed_bit_name bits_hbox[] = {
		{ MKGUI_HBOX_BORDER,         "MKGUI_HBOX_BORDER" },
	};
	static struct ed_bit_name bits_form[] = {
		{ MKGUI_FORM_BORDER,         "MKGUI_FORM_BORDER" },
	};
	static struct ed_bit_name bits_canvas[] = {
		{ MKGUI_CANVAS_BORDER,       "MKGUI_CANVAS_BORDER" },
		{ MKGUI_CANVAS_SUNKEN,       "MKGUI_CANVAS_SUNKEN" },
	};
	static struct ed_bit_name bits_glview[] = {
		{ MKGUI_GLVIEW_BORDER,       "MKGUI_GLVIEW_BORDER" },
	};
	static struct ed_bit_name bits_image[] = {
		{ MKGUI_IMAGE_BORDER,        "MKGUI_IMAGE_BORDER" },
		{ MKGUI_IMAGE_STRETCH,       "MKGUI_IMAGE_STRETCH" },
	};
	static struct ed_bit_name bits_tab[] = {
		{ MKGUI_TAB_CLOSABLE,        "MKGUI_TAB_CLOSABLE" },
	};
	static struct ed_bit_name bits_listview[] = {
		{ MKGUI_LISTVIEW_MULTI_SELECT, "MKGUI_LISTVIEW_MULTI_SELECT" },
		{ MKGUI_LISTVIEW_EDITABLE,   "MKGUI_LISTVIEW_EDITABLE" },
	};
	static struct ed_bit_name bits_gridview[] = {
		{ MKGUI_GRIDVIEW_MULTI_SELECT, "MKGUI_GRIDVIEW_MULTI_SELECT" },
	};
	static struct ed_bit_name bits_treeview[] = {
		{ MKGUI_TREEVIEW_MULTI_SELECT, "MKGUI_TREEVIEW_MULTI_SELECT" },
		{ MKGUI_TREEVIEW_EDITABLE,   "MKGUI_TREEVIEW_EDITABLE" },
	};
	static struct ed_bit_name bits_treelist[] = {
		{ MKGUI_TREELIST_MULTI_SELECT, "MKGUI_TREELIST_MULTI_SELECT" },
	};
	static struct ed_bit_name bits_itemview[] = {
		{ MKGUI_ITEMVIEW_EDITABLE,   "MKGUI_ITEMVIEW_EDITABLE" },
	};
	static struct ed_bit_name bits_label[] = {
		{ MKGUI_LABEL_TRUNCATE,      "MKGUI_LABEL_TRUNCATE" },
		{ MKGUI_LABEL_LINK,          "MKGUI_LABEL_LINK" },
		{ MKGUI_LABEL_WRAP,          "MKGUI_LABEL_WRAP" },
	};
	static struct ed_bit_name bits_group[] = {
		{ MKGUI_GROUP_COLLAPSIBLE,   "MKGUI_GROUP_COLLAPSIBLE" },
		{ MKGUI_GROUP_COLLAPSED,     "MKGUI_GROUP_COLLAPSED" },
	};
	static struct ed_bit_name bits_progress[] = {
		{ MKGUI_PROGRESS_SHIMMER,    "MKGUI_PROGRESS_SHIMMER" },
	};
	static struct ed_bit_name bits_window[] = {
		{ MKGUI_WINDOW_HIDDEN,       "MKGUI_WINDOW_HIDDEN" },
		{ MKGUI_WINDOW_HIDE_ON_CLOSE, "MKGUI_WINDOW_HIDE_ON_CLOSE" },
		{ MKGUI_WINDOW_UNDECORATED,  "MKGUI_WINDOW_UNDECORATED" },
		{ MKGUI_WINDOW_CANVAS,       "MKGUI_WINDOW_CANVAS" },
	};

	struct ed_bit_name *bits = NULL;
	uint32_t bits_count = 0;

	switch(widget_type) {
		case MKGUI_WINDOW: {
			bits = bits_window;
			bits_count = sizeof(bits_window) / sizeof(bits_window[0]);
		} break;

		case MKGUI_CHECKBOX: {
			bits = bits_checkbox;
			bits_count = sizeof(bits_checkbox) / sizeof(bits_checkbox[0]);
		} break;

		case MKGUI_RADIO: {
			bits = bits_radio;
			bits_count = sizeof(bits_radio) / sizeof(bits_radio[0]);
		} break;

		case MKGUI_TOGGLE: {
			bits = bits_toggle;
			bits_count = sizeof(bits_toggle) / sizeof(bits_toggle[0]);
		} break;

		case MKGUI_BUTTON: {
			bits = bits_button;
			bits_count = sizeof(bits_button) / sizeof(bits_button[0]);
		} break;

		case MKGUI_INPUT: {
			bits = bits_input;
			bits_count = sizeof(bits_input) / sizeof(bits_input[0]);
		} break;

		case MKGUI_TEXTAREA: {
			bits = bits_textarea;
			bits_count = sizeof(bits_textarea) / sizeof(bits_textarea[0]);
		} break;

		case MKGUI_LOGVIEW: {
			bits = bits_logview;
			bits_count = sizeof(bits_logview) / sizeof(bits_logview[0]);
		} break;

		case MKGUI_DATEPICKER: {
			bits = bits_datepicker;
			bits_count = sizeof(bits_datepicker) / sizeof(bits_datepicker[0]);
		} break;

		case MKGUI_MENUITEM: {
			bits = bits_menuitem;
			bits_count = sizeof(bits_menuitem) / sizeof(bits_menuitem[0]);
		} break;

		case MKGUI_PANEL: {
			bits = bits_panel;
			bits_count = sizeof(bits_panel) / sizeof(bits_panel[0]);
		} break;

		case MKGUI_VBOX: {
			bits = bits_vbox;
			bits_count = sizeof(bits_vbox) / sizeof(bits_vbox[0]);
		} break;

		case MKGUI_HBOX: {
			bits = bits_hbox;
			bits_count = sizeof(bits_hbox) / sizeof(bits_hbox[0]);
		} break;

		case MKGUI_FORM: {
			bits = bits_form;
			bits_count = sizeof(bits_form) / sizeof(bits_form[0]);
		} break;

		case MKGUI_CANVAS: {
			bits = bits_canvas;
			bits_count = sizeof(bits_canvas) / sizeof(bits_canvas[0]);
		} break;

		case MKGUI_GLVIEW: {
			bits = bits_glview;
			bits_count = sizeof(bits_glview) / sizeof(bits_glview[0]);
		} break;

		case MKGUI_IMAGE: {
			bits = bits_image;
			bits_count = sizeof(bits_image) / sizeof(bits_image[0]);
		} break;

		case MKGUI_TAB: {
			bits = bits_tab;
			bits_count = sizeof(bits_tab) / sizeof(bits_tab[0]);
		} break;

		case MKGUI_LISTVIEW: {
			bits = bits_listview;
			bits_count = sizeof(bits_listview) / sizeof(bits_listview[0]);
		} break;

		case MKGUI_GRIDVIEW: {
			bits = bits_gridview;
			bits_count = sizeof(bits_gridview) / sizeof(bits_gridview[0]);
		} break;

		case MKGUI_TREEVIEW: {
			bits = bits_treeview;
			bits_count = sizeof(bits_treeview) / sizeof(bits_treeview[0]);
		} break;

		case MKGUI_TREELIST: {
			bits = bits_treelist;
			bits_count = sizeof(bits_treelist) / sizeof(bits_treelist[0]);
		} break;

		case MKGUI_ITEMVIEW: {
			bits = bits_itemview;
			bits_count = sizeof(bits_itemview) / sizeof(bits_itemview[0]);
		} break;

		case MKGUI_LABEL: {
			bits = bits_label;
			bits_count = sizeof(bits_label) / sizeof(bits_label[0]);
		} break;

		case MKGUI_GROUP: {
			bits = bits_group;
			bits_count = sizeof(bits_group) / sizeof(bits_group[0]);
		} break;

		case MKGUI_PROGRESS: {
			bits = bits_progress;
			bits_count = sizeof(bits_progress) / sizeof(bits_progress[0]);
		} break;
	}

	buf[0] = '\0';
	uint32_t pos = 0;
	uint32_t remaining = style;

	for(uint32_t i = 0; i < bits_count; ++i) {
		if(style & bits[i].bit) {
			if(pos > 0) {
				pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
			}
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, "%s", bits[i].name);
			remaining &= ~bits[i].bit;
		}
	}

	if(style & MKGUI_SLIDER_MIXER) {
		char *name = (widget_type == MKGUI_METER) ? "MKGUI_METER_TEXT" : "MKGUI_SLIDER_MIXER";
		if(pos > 0) {
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
		}
		pos += (uint32_t)snprintf(buf + pos, buf_size - pos, "%s", name);
		remaining &= ~MKGUI_SLIDER_MIXER;
	}

	uint32_t tbmode = style & MKGUI_TOOLBAR_MODE_MASK;
	if(tbmode) {
		char *name = NULL;
		if(tbmode == MKGUI_TOOLBAR_ICONS_ONLY) {
			name = "MKGUI_TOOLBAR_ICONS_ONLY";
		}
		else if(tbmode == MKGUI_TOOLBAR_TEXT_ONLY)   { name = "MKGUI_TOOLBAR_TEXT_ONLY"; }
		if(name) {
			if(pos > 0) {
				pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
			}
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, "%s", name);
			remaining &= ~MKGUI_TOOLBAR_MODE_MASK;
		}
	}

	remaining &= ~MKGUI_TOOLBAR_MODE_MASK;
	if(remaining) {
		if(pos > 0) {
			pos += (uint32_t)snprintf(buf + pos, buf_size - pos, " | ");
		}
		snprintf(buf + pos, buf_size - pos, "0x%x", remaining);
	}

	return buf;
}

// [=]===^=[ ed_generate_code ]===================================[=]
static void ed_generate_code(struct mkgui_window *win) {
	struct mkgui_file_filter gen_filters[] = {
		{ "C source", "*.c" },
		{ "All files", "*" },
	};
	struct mkgui_file_dialog_opts gen_opts = {0};
	gen_opts.default_name = "gui_app.c";
	gen_opts.filters = gen_filters;
	gen_opts.filter_count = 2;
	if(!mkgui_dialog_save(win, &gen_opts)) {
		return;
	}
	const char *out_path = mkgui_dialog_get_path(win, 0);
	FILE *f = fopen(out_path, "w");
	if(!f) {
		return;
	}

	fprintf(f, "// Copyright (c) 2026\n");
	fprintf(f, "// SPDX-License-Identifier: MIT\n\n");
	fprintf(f, "#pragma GCC diagnostic ignored \"-Wunused-function\"\n");
	fprintf(f, "#include \"mkgui.c\"\n\n");

	fprintf(f, "enum {\n");
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		fprintf(f, "\t%s = %u,\n", ed.widgets[i].id_name, ed.widgets[i].id);
	}
	fprintf(f, "};\n\n");

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].type == MKGUI_LISTVIEW) {
			fprintf(f, "// [=]===^=[ %s_row_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_row_cb(uint32_t row, uint32_t col, char *buf, uint32_t buf_size, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)row; (void)col; (void)userdata;\n");
			fprintf(f, "\tbuf[0] = '\\0';\n");
			fprintf(f, "}\n\n");
		}

		if(ed.widgets[i].type == MKGUI_ITEMVIEW) {
			fprintf(f, "// [=]===^=[ %s_label_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_label_cb(uint32_t item, char *buf, uint32_t buf_size, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)userdata;\n");
			fprintf(f, "\tsnprintf(buf, buf_size, \"Item %%u\", item);\n");
			fprintf(f, "}\n\n");
			fprintf(f, "// [=]===^=[ %s_icon_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_icon_cb(uint32_t item, char *buf, uint32_t buf_size, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)item; (void)userdata;\n");
			fprintf(f, "\tbuf[0] = '\\0';\n");
			fprintf(f, "}\n\n");
		}

		if(ed.widgets[i].type == MKGUI_GRIDVIEW) {
			fprintf(f, "// [=]===^=[ %s_cell_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_cell_cb(uint32_t row, uint32_t col, char *buf, uint32_t buf_size, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)row; (void)col; (void)userdata;\n");
			fprintf(f, "\tbuf[0] = '\\0';\n");
			fprintf(f, "}\n\n");
		}

		if(ed.widgets[i].type == MKGUI_RICHLIST) {
			fprintf(f, "// [=]===^=[ %s_row_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_row_cb(uint32_t row, struct mkgui_richlist_row *out, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)userdata;\n");
			fprintf(f, "\tsnprintf(out->title, sizeof(out->title), \"Item %%u\", row + 1);\n");
			fprintf(f, "\tsnprintf(out->subtitle, sizeof(out->subtitle), \"Description %%u\", row + 1);\n");
			fprintf(f, "}\n\n");
		}

		if(ed.widgets[i].type == MKGUI_CANVAS) {
			fprintf(f, "// [=]===^=[ %s_draw_cb ]===\n", ed.widgets[i].id_name);
			fprintf(f, "static void %s_draw_cb(struct mkgui_window *win, uint32_t id, uint32_t *pixels, int32_t x, int32_t y, int32_t w, int32_t h, void *userdata) {\n", ed.widgets[i].id_name);
			fprintf(f, "\t(void)win; (void)id; (void)x; (void)y; (void)userdata;\n");
			fprintf(f, "\tfor(int32_t py = 0; py < h; ++py) {\n");
			fprintf(f, "\t\tfor(int32_t px = 0; px < w; ++px) {\n");
			fprintf(f, "\t\t\tpixels[py * w + px] = 0xff202020;\n");
			fprintf(f, "\t\t}\n");
			fprintf(f, "\t}\n");
			fprintf(f, "}\n\n");
		}
	}

	uint32_t events_used[64];
	uint32_t events_used_count = 0;

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(ed.widgets[i].event_mask == 0) {
			continue;
		}
		for(uint32_t bit = 1; bit < 40; ++bit) {
			if(!(ed.widgets[i].event_mask & (1ULL << bit))) {
				continue;
			}
			uint32_t found = 0;
			for(uint32_t j = 0; j < events_used_count; ++j) {
				if(events_used[j] == bit) {
					found = 1;
					break;
				}
			}

			if(!found && events_used_count < 64) {
				events_used[events_used_count++] = bit;
			}
		}
	}

	fprintf(f, "// [=]===^=[ on_event ]===\n");
	fprintf(f, "static void on_event(struct mkgui_window *win, struct mkgui_event *ev, void *userdata) {\n");
	fprintf(f, "\t(void)userdata;\n");
	fprintf(f, "\tswitch(ev->type) {\n");

	for(uint32_t ei = 0; ei < events_used_count; ++ei) {
		uint32_t evt = events_used[ei];
		fprintf(f, "\t\tcase MKGUI_EVENT_%s: {\n", ed_event_name(evt));

		if(evt == MKGUI_EVENT_CLOSE) {
			fprintf(f, "\t\t\tmkgui_ctx_quit(mkgui_window_get_ctx(win));\n");
		} else {
			for(uint32_t i = 0; i < ed.widget_count; ++i) {
				if(ed.widgets[i].event_mask & (1ULL << evt)) {
					fprintf(f, "\t\t\tif(ev->id == %s) {\n", ed.widgets[i].id_name);
					fprintf(f, "\t\t\t\t// TODO: handle %s for %s\n", ed_event_name(evt), ed.widgets[i].id_name);
					fprintf(f, "\t\t\t}\n");
				}
			}
		}

		fprintf(f, "\t\t} break;\n\n");
	}

	uint32_t has_close = 0;
	for(uint32_t j = 0; j < events_used_count; ++j) {
		if(events_used[j] == MKGUI_EVENT_CLOSE) {
			has_close = 1;
			break;
		}
	}

	if(!has_close) {
		fprintf(f, "\t\tcase MKGUI_EVENT_CLOSE: {\n");
		fprintf(f, "\t\t\tmkgui_ctx_quit(mkgui_window_get_ctx(win));\n");
		fprintf(f, "\t\t} break;\n\n");
	}

	fprintf(f, "\t\tdefault: break;\n");
	fprintf(f, "\t}\n");
	fprintf(f, "}\n\n");

	fprintf(f, "// [=]===^=[ main ]===\n");
	fprintf(f, "int main(void) {\n");
	fprintf(f, "\tstruct mkgui_widget widgets[] = {\n");
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		int32_t lx, ly, lw, lh;
		ed_convert_to_layout(i, &lx, &ly, &lw, &lh);
		char *parent_name = "0";
		if(w->parent_id != 0) {
			int32_t pidx = ed_find_widget(w->parent_id);
			if(pidx >= 0) {
				parent_name = ed.widgets[pidx].id_name;
			}
		}
		char flag_buf[512];
		char style_buf[512];
		uint32_t out_flags = w->flags & ~0xfu;
		uint32_t out_style = w->style;
		fprintf(f, "\t\tMKGUI_W(%s, %s, \"%s\", \"%s\", %s, %d, %d, %s, %s, %u),\n", ed_type_name_upper(w->type), w->id_name, w->label, w->icon, parent_name, lw, lh, ed_flags_to_str(out_flags, flag_buf, sizeof(flag_buf)), ed_style_to_str(out_style, w->type, style_buf, sizeof(style_buf)), w->weight);
	}
	fprintf(f, "\t};\n\n");

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->margin_l || w->margin_t || w->margin_r || w->margin_b) {
			fprintf(f, "\twidgets[%u].margin_l = %d; widgets[%u].margin_r = %d; widgets[%u].margin_t = %d; widgets[%u].margin_b = %d;\n", i, w->margin_l, i, w->margin_r, i, w->margin_t, i, w->margin_b);
		}
	}

	{
		fprintf(f, "\tuint32_t widget_count = sizeof(widgets) / sizeof(widgets[0]);\n");
		fprintf(f, "\tstruct mkgui_ctx *ctx = mkgui_ctx_create();\n");
		fprintf(f, "\tif(!ctx) {\n\t\treturn 1;\n\t}\n");
		fprintf(f, "\tstruct mkgui_window *win = mkgui_window_create(ctx, NULL, widgets, widget_count, NULL, 0, 0);\n");
		fprintf(f, "\tif(!win) {\n\t\tmkgui_ctx_destroy(ctx);\n\t\treturn 1;\n\t}\n");
		fprintf(f, "\tmkgui_icon_load_svg_dir(win, \"icons\");\n\n");
	}

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->type == MKGUI_DROPDOWN) {
			struct ed_widget_data *d = ed_find_widget_data(w->id);
			if(d && d->item_count > 0) {
				fprintf(f, "\t{\n");
				fprintf(f, "\t\tconst char *%s_items[] = {", w->id_name);
				for(uint32_t j = 0; j < d->item_count; ++j) {
					fprintf(f, "%s\"%s\"", j ? ", " : " ", d->items[j]);
				}
				fprintf(f, " };\n");
				fprintf(f, "\t\tmkgui_dropdown_setup(win, %s, %s_items, %u);\n", w->id_name, w->id_name, d->item_count);
				fprintf(f, "\t}\n");
			}

		} else if(w->type == MKGUI_COMBOBOX) {
			struct ed_widget_data *d = ed_find_widget_data(w->id);
			if(d && d->item_count > 0) {
				fprintf(f, "\t{\n");
				fprintf(f, "\t\tconst char *%s_items[] = {", w->id_name);
				for(uint32_t j = 0; j < d->item_count; ++j) {
					fprintf(f, "%s\"%s\"", j ? ", " : " ", d->items[j]);
				}
				fprintf(f, " };\n");
				fprintf(f, "\t\tmkgui_combobox_setup(win, %s, %s_items, %u);\n", w->id_name, w->id_name, d->item_count);
				fprintf(f, "\t}\n");
			}

		} else if(w->type == MKGUI_SLIDER) {
			fprintf(f, "\tmkgui_slider_setup(win, %s, 0, 100, 50);\n", w->id_name);

		} else if(w->type == MKGUI_SPINBOX) {
			fprintf(f, "\tmkgui_spinbox_setup(win, %s, 0, 100, 0, 1);\n", w->id_name);

		} else if(w->type == MKGUI_LISTVIEW) {
			fprintf(f, "\t{\n");
			fprintf(f, "\t\tstruct mkgui_column %s_cols[] = {\n", w->id_name);
			fprintf(f, "\t\t\t{ \"Column\", 200, MKGUI_CELL_TEXT },\n");
			fprintf(f, "\t\t};\n");
			fprintf(f, "\t\tmkgui_listview_setup(win, %s, 0, 1, %s_cols, %s_row_cb, NULL);\n", w->id_name, w->id_name, w->id_name);
			fprintf(f, "\t}\n");

		} else if(w->type == MKGUI_STATUSBAR) {
			struct ed_widget_data *d = ed_find_widget_data(w->id);
			uint32_t sc = (d && d->item_count > 0) ? d->item_count : 1;
			fprintf(f, "\t{\n");
			fprintf(f, "\t\tint32_t %s_widths[] = {", w->id_name);
			if(d && d->item_count > 0) {
				for(uint32_t j = 0; j < d->item_count; ++j) {
					int32_t wv = atoi(d->items[j]);
					fprintf(f, "%s %d", j ? "," : "", wv);
				}
			} else {
				fprintf(f, " -1");
			}
			fprintf(f, " };\n");
			fprintf(f, "\t\tmkgui_statusbar_setup(win, %s, %u, %s_widths);\n", w->id_name, sc, w->id_name);
			for(uint32_t j = 0; j < sc; ++j) {
				fprintf(f, "\t\tmkgui_statusbar_set(win, %s, %u, \"%s\");\n", w->id_name, j, j == 0 ? "Ready" : "");
			}
			fprintf(f, "\t}\n");

		} else if(w->type == MKGUI_PROGRESS) {
			fprintf(f, "\tmkgui_progress_setup(win, %s, 100);\n", w->id_name);

		} else if(w->type == MKGUI_METER) {
			fprintf(f, "\tmkgui_meter_setup(win, %s, 100);\n", w->id_name);

		} else if(w->type == MKGUI_ITEMVIEW) {
			fprintf(f, "\tmkgui_itemview_setup(win, %s, 0, MKGUI_VIEW_ICON, %s_label_cb, %s_icon_cb, NULL);\n", w->id_name, w->id_name, w->id_name);

		} else if(w->type == MKGUI_GRIDVIEW) {
			fprintf(f, "\tstruct mkgui_grid_column %s_cols[] = {\n", w->id_name);
			fprintf(f, "\t\t{ \"Column 1\", 100, MKGUI_GRID_TEXT },\n");
			fprintf(f, "\t\t{ \"Check\", 60, MKGUI_GRID_CHECK },\n");
			fprintf(f, "\t};\n");
			fprintf(f, "\tmkgui_gridview_setup(win, %s, 10, 2, %s_cols, %s_cell_cb, NULL);\n", w->id_name, w->id_name, w->id_name);

		} else if(w->type == MKGUI_RICHLIST) {
			fprintf(f, "\tmkgui_richlist_setup(win, %s, 10, 56, %s_row_cb, NULL);\n", w->id_name, w->id_name);

		} else if(w->type == MKGUI_SCROLLBAR) {
			fprintf(f, "\tmkgui_scrollbar_setup(win, %s, 100, 10);\n", w->id_name);

		} else if(w->type == MKGUI_TREEVIEW) {
			fprintf(f, "\tmkgui_treeview_setup(win, %s);\n", w->id_name);

		} else if(w->type == MKGUI_PATHBAR) {
			fprintf(f, "\tmkgui_pathbar_set(win, %s, \"/home\");\n", w->id_name);

		} else if(w->type == MKGUI_LOGVIEW) {
			fprintf(f, "\tmkgui_logview_setup(win, %s, 1024, 65536);\n", w->id_name);

		} else if(w->type == MKGUI_CANVAS) {
			fprintf(f, "\tmkgui_canvas_set_callback(win, %s, %s_draw_cb, NULL);\n", w->id_name, w->id_name);

		} else if(w->type == MKGUI_GLVIEW) {
			fprintf(f, "\tmkgui_glview_init(win, %s);\n", w->id_name);
		}
	}

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->accel_keysym) {
			fprintf(f, "\tmkgui_accel_add(win, %s, 0x%02x, 0x%04x);\n", w->id_name, w->accel_keymod, w->accel_keysym);
		}
	}

	fprintf(f, "\n\tmkgui_ctx_run(ctx, on_event, NULL);\n");
	fprintf(f, "\tmkgui_window_destroy(win);\n");
	fprintf(f, "\tmkgui_ctx_destroy(ctx);\n");
	fprintf(f, "\treturn 0;\n");
	fprintf(f, "}\n");

	fclose(f);

	char icon_list_path[FD_PATH_SIZE];
	{
		size_t plen = strlen(out_path);
		const char *dot = strrchr(out_path, '.');
		size_t base_len = dot ? (size_t)(dot - out_path) : plen;
		snprintf(icon_list_path, sizeof(icon_list_path), "%.*s_icons.txt", (int32_t)base_len, out_path);
	}

	uint32_t seen_count = 0;

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->icon[0] == '\0') {
			continue;
		}
		uint32_t dup = 0;
		for(uint32_t j = 0; j < seen_count; ++j) {
			if(strcmp(ed_scratch.seen_icons[j].name, w->icon) == 0) {
				if(w->icon_source[0] && ed_scratch.seen_icons[j].source[0] && strcmp(ed_scratch.seen_icons[j].source, w->icon_source) != 0) {
					fprintf(stderr, "mkgui editor: warning: icon '%s' used from multiple sources, keeping first\n", w->icon);
				}
				dup = 1;
				break;
			}
		}

		if(!dup && seen_count < 256) {
			snprintf(ed_scratch.seen_icons[seen_count].name, MKGUI_ICON_NAME_LEN, "%s", w->icon);
			snprintf(ed_scratch.seen_icons[seen_count].source, sizeof(ed_scratch.seen_icons[seen_count].source), "%s", w->icon_source);
			++seen_count;
		}
	}

	if(seen_count > 0) {
		FILE *fi = fopen(icon_list_path, "w");
		if(fi) {
			fprintf(fi, "# Icon list generated by mkgui editor\n");
			fprintf(fi, "# Format: source_path<tab>icon_name\n");
			fprintf(fi, "# Icons without a source path need manual resolution\n\n");
			for(uint32_t i = 0; i < seen_count; ++i) {
				if(ed_scratch.seen_icons[i].source[0]) {
					fprintf(fi, "%s\t%s\n", ed_scratch.seen_icons[i].source, ed_scratch.seen_icons[i].name);
				} else {
					fprintf(fi, "\t%s\n", ed_scratch.seen_icons[i].name);
				}
			}
			fclose(fi);
		}
	}

	char buf[FD_PATH_SIZE + 320];
	const char *fname = strrchr(out_path, '/');
	if(!fname) {
		fname = out_path;
	} else {
		++fname;
	}
	snprintf(buf, sizeof(buf), "Generated: %s + icon lists", fname);
	mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);
}

// [=]===^=[ ed_generate_snippet ]=================================[=]
static void ed_generate_snippet(struct mkgui_window *win) {
	struct mkgui_file_filter gen_filters[] = {
		{ "C header", "*.h" },
		{ "C source", "*.c" },
		{ "All files", "*" },
	};
	struct mkgui_file_dialog_opts gen_opts = {0};
	gen_opts.default_name = "gui_widgets.h";
	gen_opts.filters = gen_filters;
	gen_opts.filter_count = 3;
	if(!mkgui_dialog_save(win, &gen_opts)) {
		return;
	}
	const char *out_path = mkgui_dialog_get_path(win, 0);
	FILE *f = fopen(out_path, "w");
	if(!f) {
		return;
	}

	fprintf(f, "// Generated by mkgui editor\n");
	fprintf(f, "// Widget IDs and widget array snippet\n\n");

	fprintf(f, "enum {\n");
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		fprintf(f, "\t%s = %u,\n", ed.widgets[i].id_name, ed.widgets[i].id);
	}
	fprintf(f, "};\n\n");

	fprintf(f, "static struct mkgui_widget widgets[] = {\n");
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		int32_t lx, ly, lw, lh;
		ed_convert_to_layout(i, &lx, &ly, &lw, &lh);
		char *parent_name = "0";
		if(w->parent_id != 0) {
			int32_t pidx = ed_find_widget(w->parent_id);
			if(pidx >= 0) {
				parent_name = ed.widgets[pidx].id_name;
			}
		}
		char flag_buf[512];
		char style_buf[512];
		uint32_t out_flags = w->flags & ~0xfu;
		uint32_t out_style = w->style;
		fprintf(f, "\tMKGUI_W(%s, %s, \"%s\", \"%s\", %s, %d, %d, %s, %s, %u),\n", ed_type_name_upper(w->type), w->id_name, w->label, w->icon, parent_name, lw, lh, ed_flags_to_str(out_flags, flag_buf, sizeof(flag_buf)), ed_style_to_str(out_style, w->type, style_buf, sizeof(style_buf)), w->weight);
	}
	fprintf(f, "};\n");

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *w = &ed.widgets[i];
		if(w->margin_l || w->margin_t || w->margin_r || w->margin_b) {
			fprintf(f, "widgets[%u].margin_l = %d; widgets[%u].margin_r = %d; widgets[%u].margin_t = %d; widgets[%u].margin_b = %d;\n", i, w->margin_l, i, w->margin_r, i, w->margin_t, i, w->margin_b);
		}
	}

	fclose(f);

	char buf[FD_PATH_SIZE + 320];
	const char *fname = strrchr(out_path, '/');
	if(!fname) {
		fname = out_path;
	} else {
		++fname;
	}
	snprintf(buf, sizeof(buf), "Snippet generated: %s", fname);
	mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);
}

// ---------------------------------------------------------------------------
// Test GUI
// ---------------------------------------------------------------------------

// [=]===^=[ ed_test_row_cb ]======================================[=]
static void ed_test_row_cb(uint32_t row, uint32_t col, char *buf, uint32_t buf_size, void *userdata) {
	(void)userdata;
	snprintf(buf, buf_size, "Row %u Col %u", row, col);
}

// [=]===^=[ ed_test_item_label_cb ]===============================[=]
static void ed_test_item_label_cb(uint32_t item, char *buf, uint32_t buf_size, void *userdata) {
	(void)userdata;
	snprintf(buf, buf_size, "Item %u", item);
}

// [=]===^=[ ed_test_item_icon_cb ]================================[=]
static void ed_test_item_icon_cb(uint32_t item, char *buf, uint32_t buf_size, void *userdata) {
	(void)item; (void)userdata;
	buf[0] = '\0';
}

// [=]===^=[ ed_test_richlist_cb ]==================================[=]
static void ed_test_richlist_cb(uint32_t row, struct mkgui_richlist_row *out, void *userdata) {
	(void)userdata;
	snprintf(out->title, sizeof(out->title), "Item %u", row + 1);
	snprintf(out->subtitle, sizeof(out->subtitle), "Description for item %u", row + 1);
	snprintf(out->right_text, sizeof(out->right_text), "%u:00", row + 1);
	out->thumbnail = NULL;
}

// [=]===^=[ ed_test_gui ]========================================[=]
static void ed_test_gui(struct mkgui_window *editor_ctx) {
	if(ed.widget_count == 0) {
		return;
	}

	struct mkgui_widget *test_widgets = ed_scratch.test_widgets;
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *ew = &ed.widgets[i];
		struct mkgui_widget *tw = &test_widgets[i];
		tw->type = ew->type;
		tw->id = ew->id;
		size_t slen = strlen(ew->label);
		if(slen >= MKGUI_MAX_TEXT) {
			slen = MKGUI_MAX_TEXT - 1;
		}
		memcpy(tw->label, ew->label, slen);
		tw->label[slen] = '\0';
		tw->parent_id = ew->parent_id;
		memcpy(tw->icon, ew->icon, MKGUI_ICON_NAME_LEN);
		{
			int32_t lx, ly;
			ed_convert_to_layout(i, &lx, &ly, &tw->w, &tw->h);
		}
		tw->flags = ew->flags;
		tw->style = ew->style;
		tw->weight = ew->weight;
		tw->margin_l = ew->margin_l;
		tw->margin_t = ew->margin_t;
		tw->margin_r = ew->margin_r;
		tw->margin_b = ew->margin_b;
		tw->label_tw = -1;
	}

	int32_t test_w = 800, test_h = 600;
	char *test_title = "Test";
	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		if(test_widgets[i].type == MKGUI_WINDOW) {
			if(test_widgets[i].w > 0) {
				test_w = test_widgets[i].w;
			}

			if(test_widgets[i].h > 0) {
				test_h = test_widgets[i].h;
			}

			if(test_widgets[i].label[0]) {
				test_title = test_widgets[i].label;
			}
			break;
		}
	}
	struct mkgui_window *test = mkgui_window_create(mkgui_window_get_ctx(editor_ctx), editor_ctx, test_widgets, ed.widget_count, test_title, test_w, test_h);
	if(!test) {
		return;
	}

	for(uint32_t i = 0; i < ed.widget_count; ++i) {
		struct ed_widget *ew = &ed.widgets[i];
		struct ed_widget_data *d = ed_find_widget_data(ew->id);

		switch(ew->type) {
			case MKGUI_DROPDOWN: {
				if(d && d->item_count > 0) {
					const char *items[ED_MAX_DATA_ITEMS];
					for(uint32_t j = 0; j < d->item_count; ++j) {
						items[j] = d->items[j];
					}
					mkgui_dropdown_setup(test, ew->id, items, d->item_count);
				}
			} break;

			case MKGUI_COMBOBOX: {
				if(d && d->item_count > 0) {
					const char *items[ED_MAX_DATA_ITEMS];
					for(uint32_t j = 0; j < d->item_count; ++j) {
						items[j] = d->items[j];
					}
					mkgui_combobox_setup(test, ew->id, items, d->item_count);
				}
			} break;

			case MKGUI_LISTVIEW: {
				struct mkgui_column cols[] = {
					{ "Column", 200, MKGUI_CELL_TEXT },
				};
				mkgui_listview_setup(test, ew->id, 5, 1, cols, ed_test_row_cb, NULL);
			} break;

			case MKGUI_TREEVIEW: {
				mkgui_treeview_setup(test, ew->id);
				mkgui_treeview_add(test, ew->id, 1, 0, "Node 1");
				mkgui_treeview_add(test, ew->id, 2, 1, "Child 1");
				mkgui_treeview_add(test, ew->id, 3, 1, "Child 2");
				mkgui_treeview_add(test, ew->id, 4, 0, "Node 2");
			} break;

			case MKGUI_ITEMVIEW: {
				mkgui_itemview_setup(test, ew->id, 5, MKGUI_VIEW_ICON, ed_test_item_label_cb, ed_test_item_icon_cb, NULL);
			} break;

			case MKGUI_GRIDVIEW: {
				struct mkgui_grid_column gcols[] = {
					{ "Column 1", 100, MKGUI_GRID_TEXT },
					{ "Check", 60, MKGUI_GRID_CHECK },
				};
				mkgui_gridview_setup(test, ew->id, 10, 2, gcols, (mkgui_grid_cell_cb)ed_test_row_cb, NULL);
			} break;

			case MKGUI_RICHLIST: {
				mkgui_richlist_setup(test, ew->id, 20, 56, ed_test_richlist_cb, NULL);
			} break;

			case MKGUI_SLIDER: {
				mkgui_slider_setup(test, ew->id, 0, 100, 50);
			} break;

			case MKGUI_SPINBOX: {
				mkgui_spinbox_setup(test, ew->id, 0, 100, 0, 1);
			} break;

			case MKGUI_SCROLLBAR: {
				mkgui_scrollbar_setup(test, ew->id, 100, 10);
			} break;

			case MKGUI_STATUSBAR: {
				uint32_t sc = (d && d->item_count > 0) ? d->item_count : 1;
				int32_t widths[ED_MAX_DATA_ITEMS];
				if(d && d->item_count > 0) {
					for(uint32_t j = 0; j < d->item_count; ++j) {
						widths[j] = atoi(d->items[j]);
					}
				} else {
					widths[0] = -1;
				}
				mkgui_statusbar_setup(test, ew->id, sc, widths);
				mkgui_statusbar_set(test, ew->id, 0, "Ready");
			} break;

			case MKGUI_PROGRESS: {
				mkgui_progress_setup(test, ew->id, 100);
				mkgui_progress_set(test, ew->id, 50);
			} break;

			case MKGUI_METER: {
				mkgui_meter_setup(test, ew->id, 100);
				mkgui_meter_set(test, ew->id, 50);
			} break;

			case MKGUI_PATHBAR: {
				mkgui_pathbar_set(test, ew->id, "/home/user/documents");
			} break;

			case MKGUI_LOGVIEW: {
				mkgui_logview_setup(test, ew->id, 1024, 65536);
			} break;

			default: {
			} break;
		}
	}

	struct mkgui_event ev;
	uint32_t running = 1;
	while(running) {
		while(mkgui_window_poll(test, &ev)) {
			if(ev.type == MKGUI_EVENT_CLOSE) {
				running = 0;
			}
		}
		mkgui_ctx_wait(mkgui_window_get_ctx(test));
	}

	mkgui_window_destroy(test);
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

// [=]===^=[ main ]==============================================[=]
int main(void) {
	memset(&ed, 0, sizeof(ed));
	ed.canvas_w = ED_CANVAS_DEF_W;
	ed.canvas_h = ED_CANVAS_DEF_H;
	ed.grid_size = ED_GRID_DEFAULT;
	ed.selected = -1;
	ed.next_id = 1;

	ed_config_load();

	ed_add_widget(MKGUI_WINDOW, 0, 0);
	ed.undo_pos = 0;
	ed.undo_count = 0;

	uint32_t widget_pal_count = ED_WIDGET_COUNT;
	uint32_t ctn_pal_count = ED_CONTAINER_COUNT;

	int32_t win_w = (ed_cfg.window_w > 0) ? ed_cfg.window_w : 1280;
	int32_t win_h = (ed_cfg.window_h > 0) ? ed_cfg.window_h : 800;

	struct mkgui_widget widgets[] = {
		MKGUI_W(MKGUI_WINDOW,   ED_WINDOW,      "mkgui editor",    "", 0,          win_w, win_h, 0, 0, 0 ),

		MKGUI_W(MKGUI_MENU,     ED_MENU,        "",                 "", ED_WINDOW,  0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_FILE_MENU,   "File",             "", ED_MENU,    0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_EDIT_MENU,   "Edit",             "", ED_MENU,    0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_NEW,      "New",              "document-new",  ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_OPEN,     "Open",             "document-open", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SAVE,     "Save",             "document-save", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SAVEAS,   "Save As...",       "", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SEP1,     "",                 "", ED_FILE_MENU, 0, 0, 0, MKGUI_MENUITEM_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_RECENT,   "Recent Files",     "", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 0, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 1, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 2, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 3, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 4, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 5, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 6, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 7, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 8, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_RECENT_FIRST + 9, "", "", ED_MI_RECENT, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SEP2,     "",                 "", ED_FILE_MENU, 0, 0, 0, MKGUI_MENUITEM_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_GENERATE, "Generate Code",    "", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SNIPPET,  "Generate Snippet", "", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SEP3,     "",                 "", ED_FILE_MENU, 0, 0, 0, MKGUI_MENUITEM_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_EXIT,     "Exit",             "application-exit", ED_FILE_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_UNDO,     "Undo",             "edit-undo", ED_EDIT_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_REDO,     "Redo",             "edit-redo", ED_EDIT_MENU, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_SEP4,     "",                 "", ED_EDIT_MENU, 0, 0, 0, MKGUI_MENUITEM_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_MENUITEM, ED_MI_DELETE,   "Delete",           "edit-delete", ED_EDIT_MENU, 0, 0, 0, 0, 0 ),

		MKGUI_W(MKGUI_TOOLBAR,  ED_TOOLBAR,     "",                 "", ED_WINDOW,  0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_NEW,      "New",              "document-new",  ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_OPEN,     "Open",             "document-open", ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_SAVE,     "Save",             "document-save", ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_SEP1,     "",                 "", ED_TOOLBAR, 0, 0, 0, MKGUI_BUTTON_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_GEN,      "Gen",              "system-run", ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_TEST,     "Test",             "media-playback-start", ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_SEP2,     "",                 "", ED_TOOLBAR, 0, 0, 0, MKGUI_BUTTON_SEPARATOR, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_UNDO,     "Undo",             "edit-undo", ED_TOOLBAR, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_TB_REDO,     "Redo",             "edit-redo", ED_TOOLBAR, 0, 0, 0, 0, 0 ),

		MKGUI_W(MKGUI_VSPLIT, ED_SPLIT_MAIN, "",              "", ED_WINDOW,  0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_TREEVIEW, ED_TREE,        "",                 "", ED_SPLIT_MAIN, 0, 0, MKGUI_REGION_LEFT, 0, 0 ),
		MKGUI_W(MKGUI_VSPLIT, ED_SPLIT_RIGHT, "",              "", ED_SPLIT_MAIN, 0, 0, MKGUI_REGION_RIGHT, 0, 0 ),
		MKGUI_W(MKGUI_CANVAS,   ED_CANVAS_LBL,  "",                 "", ED_SPLIT_RIGHT, 0, 0, MKGUI_REGION_LEFT, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_RIGHT_PANEL, "",                 "", ED_SPLIT_RIGHT, 0, 0, MKGUI_REGION_RIGHT | MKGUI_SCROLL, 0, 0 ),

		MKGUI_W(MKGUI_GROUP,    ED_PAL_GROUP,   "Widgets",          "", ED_RIGHT_PANEL, 0, ED_PALETTE_H, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,     ED_PAL_HBOX,   "",                 "", ED_PAL_GROUP,   0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_PAL_COL0,   "",                 "", ED_PAL_HBOX,    0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_PAL_COL1,   "",                 "", ED_PAL_HBOX,    0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_PAL_COL2,   "",                 "", ED_PAL_HBOX,    0, 0, 0, 0, 1 ),

		MKGUI_W(MKGUI_GROUP,    ED_CTN_GROUP,   "Containers",       "", ED_RIGHT_PANEL, 0, ED_CTN_H, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,     ED_CTN_HBOX,   "",                 "", ED_CTN_GROUP,   0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_CTN_COL0,   "",                 "", ED_CTN_HBOX,    0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_CTN_COL1,   "",                 "", ED_CTN_HBOX,    0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_CTN_COL2,   "",                 "", ED_CTN_HBOX,    0, 0, 0, 0, 1 ),

		/* Palette buttons generated below */

		/* Properties section */
		MKGUI_W(MKGUI_GROUP,    ED_PROP_GROUP,     "Properties",      "", ED_RIGHT_PANEL, 0, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_PROP_VBOX,      "",                "", ED_PROP_GROUP, 0, 0, 0, 0, 0 ),

		/* Form: label+control pairs */
		MKGUI_W(MKGUI_FORM,     ED_PROP_FORM,      "",                "", ED_PROP_VBOX, 0, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_TYPE_LBL,  "Type:",           "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_TYPE_VAL,  "(none)",          "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_ID_LBL,    "ID:",             "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_INPUT,    ED_PROP_ID_INP,    "",                "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_LABEL_LBL, "Label:",          "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_INPUT,    ED_PROP_LABEL_INP, "",                "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_ICON_LBL,  "Icon:",           "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,     ED_PROP_ICON_HBOX, "",                "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_INPUT,    ED_PROP_ICON_INP,  "",                "", ED_PROP_ICON_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_ICON_BROWSE, "...",           "", ED_PROP_ICON_HBOX, 26, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_PARENT_LBL, "Parent:",        "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_DROPDOWN, ED_PROP_PARENT_DRP, "",               "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_TAB_LBL,   "Tab#:",           "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_TAB_SPN,   "",                "", ED_PROP_FORM, 0, 0, 0, 0, 0 ),

		/* Size row: W/H */
		MKGUI_W(MKGUI_HBOX,     ED_PROP_SIZE_HBOX, "",                "", ED_PROP_VBOX, 0, 22, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_W_LBL,     "W:",              "", ED_PROP_SIZE_HBOX, 22, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_W_SPN,     "",                "", ED_PROP_SIZE_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_H_LBL,     "H:",              "", ED_PROP_SIZE_HBOX, 22, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_H_SPN,     "",                "", ED_PROP_SIZE_HBOX, 0, 0, 0, 0, 1 ),

		/* Margin rows: ML/MR and MT/MB */
		MKGUI_W(MKGUI_HBOX,     ED_PROP_MARGIN_LR_HBOX, "",            "", ED_PROP_VBOX, 0, 22, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_ML_LBL,    "ML:",             "", ED_PROP_MARGIN_LR_HBOX, 26, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_ML_SPN,    "",                "", ED_PROP_MARGIN_LR_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_MR_LBL,    "MR:",             "", ED_PROP_MARGIN_LR_HBOX, 26, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_MR_SPN,    "",                "", ED_PROP_MARGIN_LR_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_HBOX,     ED_PROP_MARGIN_TB_HBOX, "",            "", ED_PROP_VBOX, 0, 22, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_MT_LBL,    "MT:",             "", ED_PROP_MARGIN_TB_HBOX, 26, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_MT_SPN,    "",                "", ED_PROP_MARGIN_TB_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_MB_LBL,    "MB:",             "", ED_PROP_MARGIN_TB_HBOX, 26, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_MB_SPN,    "",                "", ED_PROP_MARGIN_TB_HBOX, 0, 0, 0, 0, 1 ),

		/* Weight (visible when parent is HBOX/VBOX) */
		MKGUI_W(MKGUI_HBOX,     ED_PROP_WEIGHT_HBOX, "",               "", ED_PROP_VBOX, 0, 22, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_LABEL,    ED_PROP_WEIGHT_LBL, "Weight:",         "", ED_PROP_WEIGHT_HBOX, 50, 0, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_SPINBOX,  ED_PROP_WEIGHT_SPN, "",                "", ED_PROP_WEIGHT_HBOX, 0, 0, 0, 0, 1 ),

		/* Flags */
		MKGUI_W(MKGUI_LABEL,    ED_PROP_FLAGS_LBL, "Flags:",           "", ED_PROP_VBOX, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,     ED_PROP_FL_HBOX,   "",                "", ED_PROP_VBOX, 0, ED_PROP_FL_H, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_PROP_FL_COL0,   "",                "", ED_PROP_FL_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_PROP_FL_COL1,   "",                "", ED_PROP_FL_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_PROP_FL_COL2,   "",                "", ED_PROP_FL_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_VBOX,     ED_PROP_FL_COL3,   "",                "", ED_PROP_FL_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_REGTOP,  "RgnTop",         "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_CHECKED, "Checked",        "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_MI_CHECKED, "Checked",    "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_REGBOT,  "RgnBot",         "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_HIDDEN,  "Hidden",         "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_SEPARATOR,"Sep",            "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_REGLEFT, "RgnLeft",        "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_DISABLED,"Disabled",       "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_MENUCHECK,"MChk",          "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_REGRIGHT,"RgnRight",       "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_MENURADIO,"MRad",          "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_SCROLL,  "Scroll",         "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_BORDER,  "Border",         "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_SUNKEN,  "Sunken",         "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_NOPAD,   "No Pad",         "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_PASSWORD, "Password",      "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_READONLY, "Readonly",      "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_FIXED,    "Fixed",         "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TBSEP,    "TbSep",         "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_VERTICAL, "Vertical",      "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_MIXER,    "Mixer",         "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TRUNCATE, "Truncate",      "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_METER_TEXT,"Show %",       "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_LINK,     "Link",          "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_WRAP,     "Wrap",          "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_COLLAPSIBLE,"Collapsible", "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_COLLAPSED,"Collapsed",     "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_NUMERIC,  "Numeric",       "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TAB_CLOSABLE, "Closable", "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_SHIMMER, "Shimmer",      "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_MULTI_SELECT, "MultiSel", "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_IMG_STRETCH, "Stretch",  "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_BTN_CHECKED, "Checked",  "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TOG_CHECKED, "Checked",  "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_LOG_NOWRAP,  "NoWrap",   "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_DP_READONLY, "Readonly", "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TA_READONLY, "Readonly", "", ED_PROP_FL_COL1, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_LV_EDITABLE, "Editable", "", ED_PROP_FL_COL2, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_TV_EDITABLE, "Editable", "", ED_PROP_FL_COL3, 0, 20, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_CHECKBOX, ED_PROP_FL_IV_EDITABLE, "Editable", "", ED_PROP_FL_COL0, 0, 20, MKGUI_FIXED, 0, 0 ),

		/* Accelerator capture */
		MKGUI_W(MKGUI_LABEL,   ED_PROP_ACCEL_LBL,   "Accel:",        "", ED_PROP_FORM, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,    ED_PROP_ACCEL_HBOX,  "",              "", ED_PROP_FORM, 0, 0, MKGUI_HIDDEN, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,  ED_PROP_ACCEL_BTN,   "None",          "", ED_PROP_ACCEL_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,  ED_PROP_ACCEL_CLEAR, "X",             "", ED_PROP_ACCEL_HBOX, 22, 0, MKGUI_FIXED, 0, 0 ),

		/* Cross-axis alignment (visible when parent is HBOX/VBOX) */
		MKGUI_W(MKGUI_LABEL,    ED_PROP_ALIGN_LBL,  "Align:",         "", ED_PROP_VBOX, 0, 24, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_DROPDOWN, ED_PROP_ALIGN_DRP,  "",               "", ED_PROP_VBOX, 0, 24, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),

		/* Toolbar display mode */
		MKGUI_W(MKGUI_LABEL,    ED_PROP_TB_MODE_LBL, "Mode:",         "", ED_PROP_VBOX, 0, 24, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_DROPDOWN, ED_PROP_TB_MODE_DRP, "",              "", ED_PROP_VBOX, 0, 24, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),

		/* Add/Remove buttons */
		MKGUI_W(MKGUI_HBOX,     ED_PROP_BTN_HBOX,  "",                "", ED_PROP_VBOX, 0, 22, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_ADD_TAB,   "Add Tab",         "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_REM_TAB,   "Remove Tab",      "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_ADD_ITEM,  "Add Item",        "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_REM_ITEM,  "Remove Item",     "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_ADD_TB_BTN, "Add Button",     "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_PROP_REM_TB_BTN, "Remove Button",  "", ED_PROP_BTN_HBOX, 0, 0, MKGUI_HIDDEN, 0, 1 ),

		/* Menu tree */
		MKGUI_W(MKGUI_TREEVIEW, ED_MENU_TREE,      "",                "", ED_PROP_VBOX, 0, 200, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),

		/* Events section */
		MKGUI_W(MKGUI_GROUP,    ED_EVT_GROUP,      "Events",          "", ED_RIGHT_PANEL, 0, 200, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_EVT_VBOX,       "",                "", ED_EVT_GROUP,   0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LISTVIEW, ED_EVT_LIST,       "",                "", ED_EVT_VBOX,    0, 0, 0, MKGUI_LISTVIEW_MULTI_SELECT, 1 ),

		/* Data section */
		MKGUI_W(MKGUI_GROUP,    ED_DATA_GROUP,     "Data",            "", ED_RIGHT_PANEL, 0, 250, MKGUI_HIDDEN | MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_VBOX,     ED_DATA_VBOX,      "",                "", ED_DATA_GROUP,  0, 0, 0, 0, 0 ),
		MKGUI_W(MKGUI_LISTVIEW, ED_DATA_LIST,      "",                "", ED_DATA_VBOX,   0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_INPUT,    ED_DATA_ITEM_INP,  "",                "", ED_DATA_VBOX,   0, 24, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_HBOX,     ED_DATA_BTN_HBOX,  "",                "", ED_DATA_VBOX,   0, 22, MKGUI_FIXED, 0, 0 ),
		MKGUI_W(MKGUI_BUTTON,   ED_DATA_ADD_BTN,   "Add",             "", ED_DATA_BTN_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_DATA_REM_BTN,   "Remove",          "", ED_DATA_BTN_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_DATA_UP_BTN,    "Up",              "", ED_DATA_BTN_HBOX, 0, 0, 0, 0, 1 ),
		MKGUI_W(MKGUI_BUTTON,   ED_DATA_DOWN_BTN,  "Down",            "", ED_DATA_BTN_HBOX, 0, 0, 0, 0, 1 ),

		MKGUI_W(MKGUI_STATUSBAR, ED_STATUSBAR,   "",                 "", ED_WINDOW,  0, 0, 0, 0, 0 ),
	};

	uint32_t base_count = sizeof(widgets) / sizeof(widgets[0]);

	struct mkgui_widget all_widgets[256];
	memcpy(all_widgets, widgets, base_count * sizeof(struct mkgui_widget));
	uint32_t total = base_count;

	for(uint32_t i = 0; i < widget_pal_count && total < 256; ++i) {
		struct mkgui_widget *pw = &all_widgets[total++];
		pw->type = MKGUI_BUTTON;
		pw->id = ED_PAL_FIRST + i;
		size_t slen = strlen(ed_widgets[i].name);
		if(slen >= MKGUI_MAX_TEXT) {
			slen = MKGUI_MAX_TEXT - 1;
		}
		memcpy(pw->label, ed_widgets[i].name, slen);
		pw->label[slen] = '\0';
		pw->icon[0] = '\0';
		uint32_t col = i % ED_PAL_COLS;
		pw->parent_id = (col == 0) ? ED_PAL_COL0 : (col == 1) ? ED_PAL_COL1 : ED_PAL_COL2;
		pw->w = 0;
		pw->h = 22;
		pw->flags = MKGUI_FIXED;
		pw->style = 0;
		pw->weight = 0;
	}

	for(uint32_t i = 0; i < ctn_pal_count && total < 256; ++i) {
		struct mkgui_widget *pw = &all_widgets[total++];
		pw->type = MKGUI_BUTTON;
		pw->id = ED_CTN_FIRST + i;
		size_t slen = strlen(ed_containers[i].name);
		if(slen >= MKGUI_MAX_TEXT) {
			slen = MKGUI_MAX_TEXT - 1;
		}
		memcpy(pw->label, ed_containers[i].name, slen);
		pw->label[slen] = '\0';
		pw->icon[0] = '\0';
		uint32_t col = i % ED_CTN_COLS;
		pw->parent_id = (col == 0) ? ED_CTN_COL0 : (col == 1) ? ED_CTN_COL1 : ED_CTN_COL2;
		pw->w = 0;
		pw->h = 22;
		pw->flags = MKGUI_FIXED;
		pw->style = 0;
		pw->weight = 0;
	}

	struct mkgui_ctx *ctx = mkgui_ctx_create();
	if(!ctx) {
		return 1;
	}
	struct mkgui_window *win = mkgui_window_create(ctx, NULL, all_widgets, total, NULL, 0, 0);
	if(!win) {
		mkgui_ctx_destroy(ctx);
		return 1;
	}
	mkgui_icon_load_svg_dir(win, "icons");

	struct mkgui_split_data *sd_main = find_split_data(win, ED_SPLIT_MAIN);
	if(sd_main) {
		sd_main->ratio = (float)ED_LEFT_W / 1280.0f;
	}
	struct mkgui_split_data *sd_right = find_split_data(win, ED_SPLIT_RIGHT);
	if(sd_right) {
		sd_right->ratio = 1.0f - (float)ED_RIGHT_W / (1280.0f - ED_LEFT_W - win->split_thick);
	}

	mkgui_toolbar_set_mode(win, ED_TOOLBAR, MKGUI_TOOLBAR_ICONS_ONLY);
	mkgui_canvas_set_callback(win, ED_CANVAS_LBL, ed_render_canvas, NULL);
	win->render_cb = ed_render_help_popup;

	int32_t sb_widths[] = { -1, 120 };
	mkgui_statusbar_setup(win, ED_STATUSBAR, 2, sb_widths);
	mkgui_statusbar_set(win, ED_STATUSBAR, 0, "Ready");
	mkgui_statusbar_set(win, ED_STATUSBAR, 1, "Grid: 8px");

	for(uint32_t pi = 0; pi < ED_PROP_COUNT; ++pi) {
		struct ed_prop_desc *p = &ed_props[pi];
		if(p->kind == ED_PK_INT32) {
			mkgui_spinbox_setup(win, p->widget_id, p->min_val, p->max_val, 0, 1);
		} else if(p->kind == ED_PK_INT32_PAIR) {
			mkgui_spinbox_setup(win, p->widget_id, p->min_val, p->max_val, 0, 1);
			mkgui_spinbox_setup(win, p->widget_id2, p->min_val, p->max_val, 0, 1);
		}
	}

	{
		const char *align_items[] = { "Stretch", "Start", "Center", "End" };
		mkgui_dropdown_setup(win, ED_PROP_ALIGN_DRP, align_items, 4);
	}

	{
		const char *tb_mode_items[] = { "Icons + Text", "Icons Only", "Text Only" };
		mkgui_dropdown_setup(win, ED_PROP_TB_MODE_DRP, tb_mode_items, 3);
	}

	{
		struct mkgui_column evt_cols[] = {
			{ "Event", 200, MKGUI_CELL_TEXT },
		};
		mkgui_listview_setup(win, ED_EVT_LIST, 0, 1, evt_cols, ed_event_row_cb, NULL);
	}
	{
		struct mkgui_column data_cols[] = {
			{ "Item", 200, MKGUI_CELL_TEXT },
		};
		mkgui_listview_setup(win, ED_DATA_LIST, 0, 1, data_cols, ed_data_row_cb, NULL);
	}

	ed_sync_tree(win);
	ed_sync_props(win);
	ed_sync_recent_menu(win);

	struct mkgui_event ev;
	uint32_t running = 1;
	uint32_t prev_press = 0;

	while(running) {
		char buf[128];
		while(mkgui_window_poll(win, &ev)) {
			switch(ev.type) {
				case MKGUI_EVENT_CLOSE: {
					ed_cfg.window_w = win->win_w;
					ed_cfg.window_h = win->win_h;
					ed_config_save();
					running = 0;
				} break;

				case MKGUI_EVENT_CLICK: {
					if(ev.id == ED_TB_NEW || ev.id == ED_MI_NEW) {
						memset(&ed, 0, sizeof(ed));
						ed.canvas_w = ED_CANVAS_DEF_W;
						ed.canvas_h = ED_CANVAS_DEF_H;
						ed.grid_size = ED_GRID_DEFAULT;
						ed.selected = -1;
						ed.next_id = 1;
						ed_add_widget(MKGUI_WINDOW, 0, 0);
						ed.undo_pos = 0;
						ed.undo_count = 0;
						ed_sync_tree(win);
						ed_sync_props(win);
						mkgui_statusbar_set(win, ED_STATUSBAR, 0, "New project");

					} else if(ev.id == ED_TB_SAVE || ev.id == ED_MI_SAVE) {
						ed_save_project(win, 0);

					} else if(ev.id == ED_MI_SAVEAS) {
						ed_save_project(win, 1);

					} else if(ev.id == ED_TB_OPEN || ev.id == ED_MI_OPEN) {
						ed_load_project(win);

					} else if(ev.id == ED_TB_GEN || ev.id == ED_MI_GENERATE) {
						ed_generate_code(win);

					} else if(ev.id == ED_MI_SNIPPET) {
						ed_generate_snippet(win);

					} else if(ev.id == ED_TB_TEST) {
						ed_test_gui(win);
						dirty_all(win);

					} else if(ev.id == ED_TB_UNDO || ev.id == ED_MI_UNDO) {
						ed_undo();
						ed_sync_tree(win);
						ed_sync_props(win);

					} else if(ev.id == ED_TB_REDO || ev.id == ED_MI_REDO) {
						ed_redo();
						ed_sync_tree(win);
						ed_sync_props(win);

					} else if(ev.id == ED_MI_DELETE) {
						ed_delete_selected();
						ed_sync_tree(win);
						ed_sync_props(win);

					} else if(ev.id == ED_MI_EXIT) {
						running = 0;

					} else if(ev.id == ED_PROP_ACCEL_BTN) {
						ed.accel_capture = 1;
						mkgui_button_set_text(win, ED_PROP_ACCEL_BTN, "Press shortcut...");

					} else if(ev.id == ED_PROP_ACCEL_CLEAR) {
						if(ed.selected >= 0) {
							ed_push_undo();
							ed.widgets[ed.selected].accel_keymod = 0;
							ed.widgets[ed.selected].accel_keysym = 0;
							ed.accel_capture = 0;
							ed_sync_props(win);
						}

					} else {
						uint32_t handled = 0;
						for(uint32_t pi = 0; pi < ED_PROP_COUNT && !handled; ++pi) {
							if(ed_props[pi].widget_id != ev.id && ed_props[pi].widget_id2 != ev.id) {
								continue;
							}

							if(ed_props[pi].kind == ED_PK_ACTION || ed_props[pi].kind == ED_PK_STRING_BROWSE) {
								switch(ed_props[pi].action) {
									case ED_ACT_ICON_BROWSE: {
										char icon_name[64];
										char icon_path[1024];
										if(mkgui_icon_browser(win, 16, icon_name, sizeof(icon_name), icon_path, sizeof(icon_path))) {
											icon_resolve(win, icon_name);
											mkgui_input_set(win, ED_PROP_ICON_INP, icon_name);
											if(ed.selected >= 0) {
												strncpy(ed.widgets[ed.selected].icon, icon_name, MKGUI_ICON_NAME_LEN - 1);
												ed.widgets[ed.selected].icon[MKGUI_ICON_NAME_LEN - 1] = '\0';
												strncpy(ed.widgets[ed.selected].icon_source, icon_path, sizeof(ed.widgets[ed.selected].icon_source) - 1);
												ed.widgets[ed.selected].icon_source[sizeof(ed.widgets[ed.selected].icon_source) - 1] = '\0';
												ed_push_undo();
											}
										}
									} break;

									case ED_ACT_ADD_TAB: {
										ed_add_tab_to_tabs(win);
									} break;

									case ED_ACT_REM_TAB: {
										ed_remove_tab_from_tabs(win);
									} break;

									case ED_ACT_ADD_ITEM: {
										ed_add_menu_item(win);
									} break;

									case ED_ACT_REM_ITEM: {
										ed_remove_menu_item(win);
									} break;

									case ED_ACT_ADD_TB_BTN: {
										ed_add_toolbar_btn(win);
									} break;

									case ED_ACT_REM_TB_BTN: {
										ed_remove_toolbar_btn(win);
									} break;
								}
								handled = 1;
							}
						}

						if(!handled) {
						if(ev.id == ED_DATA_ADD_BTN) {
							struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
							if(d && d->item_count < ED_MAX_DATA_ITEMS) {
								int32_t data_wf = ed_find_widget(ed_data_widget_id);
								uint32_t is_sb = (data_wf >= 0 && ed.widgets[data_wf].type == MKGUI_STATUSBAR);
								if(is_sb) {
									snprintf(d->items[d->item_count], MKGUI_MAX_TEXT, "-1");
								} else {
									snprintf(d->items[d->item_count], MKGUI_MAX_TEXT, "Item %u", d->item_count + 1);
								}
								++d->item_count;
								mkgui_listview_set_rows(win, ED_DATA_LIST, d->item_count);
								dirty_all(win);
							}
							handled = 1;

						} else if(ev.id == ED_DATA_REM_BTN) {
							struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
							int32_t dsel = mkgui_listview_get_selected(win, ED_DATA_LIST);
							if(d && dsel >= 0 && (uint32_t)dsel < d->item_count) {
								for(uint32_t si = (uint32_t)dsel; si + 1 < d->item_count; ++si) {
									memcpy(d->items[si], d->items[si + 1], MKGUI_MAX_TEXT);
								}
								--d->item_count;
								mkgui_listview_set_rows(win, ED_DATA_LIST, d->item_count);
								mkgui_input_set(win, ED_DATA_ITEM_INP, "");
								dirty_all(win);
							}
							handled = 1;

						} else if(ev.id == ED_DATA_UP_BTN) {
							struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
							int32_t dsel = mkgui_listview_get_selected(win, ED_DATA_LIST);
							if(d && dsel > 0 && (uint32_t)dsel < d->item_count) {
								char tmp[MKGUI_MAX_TEXT];
								memcpy(tmp, d->items[dsel], MKGUI_MAX_TEXT);
								memcpy(d->items[dsel], d->items[dsel - 1], MKGUI_MAX_TEXT);
								memcpy(d->items[dsel - 1], tmp, MKGUI_MAX_TEXT);
								struct mkgui_listview_data *lv = find_listv_data(win, ED_DATA_LIST);
								if(lv) {
									lv->selected_row = dsel - 1;
								}
								dirty_all(win);
							}
							handled = 1;

						} else if(ev.id == ED_DATA_DOWN_BTN) {
							struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
							int32_t dsel = mkgui_listview_get_selected(win, ED_DATA_LIST);
							if(d && dsel >= 0 && (uint32_t)dsel + 1 < d->item_count) {
								char tmp[MKGUI_MAX_TEXT];
								memcpy(tmp, d->items[dsel], MKGUI_MAX_TEXT);
								memcpy(d->items[dsel], d->items[dsel + 1], MKGUI_MAX_TEXT);
								memcpy(d->items[dsel + 1], tmp, MKGUI_MAX_TEXT);
								struct mkgui_listview_data *lv = find_listv_data(win, ED_DATA_LIST);
								if(lv) {
									lv->selected_row = dsel + 1;
								}
								dirty_all(win);
							}
							handled = 1;
						}
						}

						if(!handled) {
						for(uint32_t pi = 0; pi < widget_pal_count; ++pi) {
							if(ev.id == ED_PAL_FIRST + pi) {
								ed.placement_type = ed_widgets[pi].type;
								dirty_all(win);
								snprintf(buf, sizeof(buf), "Place: %s", ed_widgets[pi].name);
								mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);
								break;
							}
						}
						for(uint32_t pi = 0; pi < ctn_pal_count; ++pi) {
							if(ev.id == ED_CTN_FIRST + pi) {
								ed.placement_type = ed_containers[pi].type;
								dirty_all(win);
								snprintf(buf, sizeof(buf), "Place: %s", ed_containers[pi].name);
								mkgui_statusbar_set(win, ED_STATUSBAR, 0, buf);
								break;
							}
						}
						}
					}
				} break;

				case MKGUI_EVENT_MENU: {
					if(ev.id == ED_MI_EXIT) {
						ed_cfg.window_w = win->win_w;
						ed_cfg.window_h = win->win_h;
						ed_config_save();
						running = 0;
					} else if(ev.id == ED_MI_SAVE) {
						ed_save_project(win, 0);
					} else if(ev.id == ED_MI_SAVEAS) {
						ed_save_project(win, 1);
					} else if(ev.id == ED_MI_OPEN) {
						ed_load_project(win);
					} else if(ev.id == ED_MI_GENERATE) {
						ed_generate_code(win);
					} else if(ev.id == ED_MI_SNIPPET) {
						ed_generate_snippet(win);
					} else if(ev.id == ED_MI_UNDO) {
						ed_undo();
						ed_sync_tree(win);
						ed_sync_props(win);
					} else if(ev.id == ED_MI_REDO) {
						ed_redo();
						ed_sync_tree(win);
						ed_sync_props(win);
					} else if(ev.id == ED_MI_DELETE) {
						ed_delete_selected();
						ed_sync_tree(win);
						ed_sync_props(win);
					} else if(ev.id == ED_MI_NEW) {
						memset(&ed, 0, sizeof(ed));
						ed.canvas_w = ED_CANVAS_DEF_W;
						ed.canvas_h = ED_CANVAS_DEF_H;
						ed.grid_size = ED_GRID_DEFAULT;
						ed.selected = -1;
						ed.next_id = 1;
						ed_add_widget(MKGUI_WINDOW, 0, 0);
						ed.undo_pos = 0;
						ed.undo_count = 0;
						ed_sync_tree(win);
						ed_sync_props(win);

					} else if(ev.id >= ED_RECENT_FIRST && ev.id <= ED_RECENT_LAST) {
						ed_load_recent(win, ev.id - ED_RECENT_FIRST);
					}
				} break;

				case MKGUI_EVENT_TREEVIEW_SELECT: {
					if(ev.id == ED_TREE) {
						int32_t idx = ed_find_widget((uint32_t)ev.value);
						if(idx >= 0) {
							ed.selected = idx;
							ed_sync_props(win);
						}
					} else if(ev.id == ED_MENU_TREE) {
						int32_t idx = ed_find_widget((uint32_t)ev.value);
						if(idx >= 0) {
							ed.selected = idx;
							struct mkgui_treeview_data *mt = find_treeview_data(win, ED_MENU_TREE);
							int32_t saved_scroll = mt ? mt->scroll_y : 0;
							ed_sync_props(win);
							mt = find_treeview_data(win, ED_MENU_TREE);
							if(mt) {
								mt->scroll_y = saved_scroll;
							}
							struct mkgui_treeview_data *mtv = find_treeview_data(win, ED_TREE);
							if(mtv) {
								mtv->selected_node = (int32_t)ev.value;
							}
						}
					}
				} break;

				case MKGUI_EVENT_TREEVIEW_MOVE: {
					if(ev.id == ED_TREE || ev.id == ED_MENU_TREE) {
						int32_t src_idx = ed_find_widget((uint32_t)ev.value);
						int32_t tgt_idx = ed_find_widget((uint32_t)ev.col);
						uint32_t pos = ev.keysym;
						if(src_idx < 0 || tgt_idx < 0) {
							break;
						}

						if(ed.widgets[src_idx].type == MKGUI_WINDOW) {
							break;
						}

						if(ed_is_descendant((uint32_t)tgt_idx, ed.widgets[src_idx].id)) {
							break;
						}
						ed_push_undo();
						uint32_t src_id = ed.widgets[src_idx].id;
						struct ed_widget *block = ed_scratch.reorder;
						uint32_t block_count = 0;
						block[block_count++] = ed.widgets[src_idx];
						for(uint32_t k = (uint32_t)src_idx + 1; k < ed.widget_count; ++k) {
							if(ed_is_descendant(k, src_id)) {
								block[block_count++] = ed.widgets[k];
							}
						}
						for(uint32_t k = ed.widget_count; k > 0; --k) {
							uint32_t ki = k - 1;
							if(ki == (uint32_t)src_idx || ed_is_descendant(ki, src_id)) {
								memmove(&ed.widgets[ki], &ed.widgets[ki + 1], (ed.widget_count - ki - 1) * sizeof(struct ed_widget));
								--ed.widget_count;
							}
						}
						tgt_idx = ed_find_widget((uint32_t)ev.col);
						if(tgt_idx < 0) {
							break;
						}
						uint32_t insert_at;
						if(pos == 2) {
							block[0].parent_id = ed.widgets[tgt_idx].id;
							insert_at = (uint32_t)tgt_idx + 1;
						} else if(pos == 0) {
							block[0].parent_id = ed.widgets[tgt_idx].parent_id;
							insert_at = (uint32_t)tgt_idx;
						} else {
							block[0].parent_id = ed.widgets[tgt_idx].parent_id;
							insert_at = (uint32_t)tgt_idx + 1;
							for(uint32_t k = insert_at; k < ed.widget_count; ++k) {
								if(ed_is_descendant(k, ed.widgets[tgt_idx].id)) {
									insert_at = k + 1;
								}
							}
						}

						if(insert_at > ed.widget_count) {
							insert_at = ed.widget_count;
						}

						if(ed.widget_count + block_count <= ED_MAX_WIDGETS) {
							memmove(&ed.widgets[insert_at + block_count], &ed.widgets[insert_at], (ed.widget_count - insert_at) * sizeof(struct ed_widget));
							memcpy(&ed.widgets[insert_at], block, block_count * sizeof(struct ed_widget));
							ed.widget_count += block_count;
						}
						int32_t new_pidx = ed_find_widget(ed.widgets[insert_at].parent_id);
						if(new_pidx >= 0) {
							uint32_t pt = ed.widgets[new_pidx].type;
							if(pt == MKGUI_HBOX || pt == MKGUI_VBOX) {
								ed.widgets[insert_at].w = 0;
								ed.widgets[insert_at].h = 0;
								ed.widgets[insert_at].flags &= ~(MKGUI_ANCHOR_LEFT | MKGUI_ANCHOR_TOP | MKGUI_ANCHOR_RIGHT | MKGUI_ANCHOR_BOTTOM);
							} else if(pt == MKGUI_FORM) {
								ed.widgets[insert_at].w = 0;
								ed.widgets[insert_at].h = 24;
								ed.widgets[insert_at].flags &= ~(MKGUI_ANCHOR_LEFT | MKGUI_ANCHOR_TOP | MKGUI_ANCHOR_RIGHT | MKGUI_ANCHOR_BOTTOM);
							}
						}
						ed.selected = (int32_t)insert_at;
						ed_sync_tree(win);
						ed_sync_props(win);
					}
				} break;

				case MKGUI_EVENT_SPINBOX_CHANGED:
				case MKGUI_EVENT_INPUT_CHANGED:
				case MKGUI_EVENT_INPUT_SUBMIT: {
					if(ev.id == ED_DATA_ITEM_INP) {
						struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
						int32_t dsel = mkgui_listview_get_selected(win, ED_DATA_LIST);
						if(d && dsel >= 0 && (uint32_t)dsel < d->item_count) {
							const char *val = mkgui_input_get(win, ED_DATA_ITEM_INP);
							if(val) {
								snprintf(d->items[dsel], MKGUI_MAX_TEXT, "%s", val);
								dirty_all(win);
							}
						}
					} else {
						for(uint32_t pi = 0; pi < ED_PROP_COUNT; ++pi) {
							struct ed_prop_desc *p = &ed_props[pi];
							if(p->widget_id == ev.id || p->widget_id2 == ev.id) {
								ed_read_props(win);
								if(p->offset == offsetof(struct ed_widget, id_name) || p->offset == offsetof(struct ed_widget, label)) {
									ed_sync_tree(win);
									ed_sync_menu_tree(win);
								}
								break;
							}
						}
					}
				} break;

				case MKGUI_EVENT_CHECKBOX_CHANGED: {
					for(uint32_t pi = 0; pi < ED_PROP_COUNT; ++pi) {
						if(ed_props[pi].widget_id == ev.id && ed_props[pi].kind == ED_PK_FLAG) {
							ed_read_props(win);
							break;
						}
					}
				} break;

				case MKGUI_EVENT_DROPDOWN_CHANGED: {
					if(ev.id == ED_PROP_PARENT_DRP) {
						ed_apply_parent_dropdown(win);
					} else if(ev.id == ED_PROP_ALIGN_DRP || ev.id == ED_PROP_TB_MODE_DRP) {
						ed_read_props(win);
					}
				} break;

				case MKGUI_EVENT_LISTVIEW_SELECT: {
					if(ev.id == ED_EVT_LIST && ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
						int32_t *sel;
						uint32_t sel_count = mkgui_listview_get_multi_sel(win, ED_EVT_LIST, &sel);
						uint64_t mask = 0;
						for(uint32_t si = 0; si < sel_count; ++si) {
							if(sel[si] >= 0 && (uint32_t)sel[si] < ed_cur_event_count) {
								mask |= (1ULL << ed_cur_events[sel[si]]);
							}
						}
						ed.widgets[ed.selected].event_mask = mask;

					} else if(ev.id == ED_DATA_LIST) {
						struct ed_widget_data *d = ed_find_widget_data(ed_data_widget_id);
						if(d && ev.value >= 0 && (uint32_t)ev.value < d->item_count) {
							mkgui_input_set(win, ED_DATA_ITEM_INP, d->items[ev.value]);
						} else {
							mkgui_input_set(win, ED_DATA_ITEM_INP, "");
						}
					}
				} break;

				case MKGUI_EVENT_KEY: {
					if(ed.accel_capture) {
						if(ev.keysym == MKGUI_KEY_ESCAPE) {
							ed.accel_capture = 0;
							ed_sync_props(win);
							break;
						}
						uint32_t mod = ev.keymod & (MKGUI_MOD_CONTROL | MKGUI_MOD_ALT | MKGUI_MOD_SHIFT);
						if(mod && ev.keysym != 0 && ed.selected >= 0) {
							ed_push_undo();
							struct ed_widget *sw = &ed.widgets[ed.selected];
							sw->accel_keymod = mod;
							uint32_t ks = ev.keysym;
							if(ks >= 'A' && ks <= 'Z') {
								ks += 32;
							}
							sw->accel_keysym = ks;
							ed.accel_capture = 0;
							ed_sync_props(win);
						}
						break;
					}

					if(ev.keysym == MKGUI_KEY_F1) {
						uint32_t hover = win->hover_id;
						uint32_t help_type = 0;
						for(uint32_t pi = 0; pi < widget_pal_count; ++pi) {
							if(hover == ED_PAL_FIRST + pi) {
								help_type = ed_widgets[pi].type;
								break;
							}
						}
						for(uint32_t pi = 0; pi < ctn_pal_count; ++pi) {
							if(hover == ED_CTN_FIRST + pi) {
								help_type = ed_containers[pi].type;
								break;
							}
						}

						if(help_type) {
							ed_help_text = ed_find_help(help_type);
							ed_help_widget_id = hover;
							dirty_all(win);
						} else {
							if(ed_help_text) {
								ed_help_text = NULL;
								ed_help_widget_id = 0;
								dirty_all(win);
							}
						}
					}

					if(ev.keysym == MKGUI_KEY_ESCAPE) {
						if(ed_help_text) {
							ed_help_text = NULL;
							ed_help_widget_id = 0;
							dirty_all(win);
						}
						ed.placement_type = 0;
						mkgui_statusbar_set(win, ED_STATUSBAR, 0, "Ready");
						dirty_all(win);
					}

					if(ev.keysym == MKGUI_KEY_DELETE) {
						if(ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count && ed.widgets[ed.selected].type == MKGUI_MENUITEM) {
							ed_remove_menu_item(win);
						} else {
							ed_delete_selected();
							ed_sync_tree(win);
							ed_sync_props(win);
						}
					}

					if(ed.selected >= 0 && !(ev.keymod & MKGUI_MOD_CONTROL)) {
						uint32_t focus_id = 0;
						switch(ev.keysym) {
							case 'x': { focus_id = ED_PROP_X_SPN; } break;
							case 'y': { focus_id = ED_PROP_Y_SPN; } break;
							case 'w': { focus_id = ED_PROP_W_SPN; } break;
							case 'h': { focus_id = ED_PROP_H_SPN; } break;
							case 'l': { focus_id = ED_PROP_LABEL_INP; } break;
							case 'i': { focus_id = ED_PROP_ID_INP; } break;
							default: break;
						}

						if(focus_id) {
							win->focus_id = focus_id;
							dirty_all(win);
						}
					}

					if((ev.keymod & MKGUI_MOD_CONTROL) && ev.keysym == 'z') {
						ed_undo();
						ed_sync_tree(win);
						ed_sync_props(win);
					}

					if((ev.keymod & MKGUI_MOD_CONTROL) && (ev.keysym == 'Z' || ev.keysym == 'y')) {
						ed_redo();
						ed_sync_tree(win);
						ed_sync_props(win);
					}

					if((ev.keymod & MKGUI_MOD_CONTROL) && ev.keysym == 's') {
						ed_save_project(win, 0);
					}
				} break;

				default: break;
			}
		}

		int32_t ci = find_widget_idx(win, ED_CANVAS_LBL);
		if(ci >= 0) {
			int32_t crx = win->rects[ci].x;
			int32_t cry = win->rects[ci].y;
			int32_t crw = win->rects[ci].w;
			int32_t crh = win->rects[ci].h;

			int32_t win_x = crx + (crw - ed.canvas_w) / 2;
			int32_t win_y = cry + (crh - ed.canvas_h) / 2;

			if(win->press_id == ED_CANVAS_LBL && !prev_press) {
				int32_t local_x = win->mouse_x - win_x;
				int32_t local_y = win->mouse_y - win_y;

				if(ed.placement_type) {
					int32_t sx = ed_snap(local_x);
					int32_t sy = ed_snap(local_y);
					uint32_t is_chrome = (ed.placement_type == MKGUI_MENU || ed.placement_type == MKGUI_TOOLBAR || ed.placement_type == MKGUI_STATUSBAR);
					int32_t new_idx = ed_add_widget(ed.placement_type, sx, sy);
					if(new_idx >= 0) {
						int32_t screen_x = local_x + ed_win_x;
						int32_t screen_y = local_y + ed_win_y;
						uint32_t new_parent = 0;
						uint32_t ctrl_target = 0;
						if(!is_chrome && (win->press_mod & MKGUI_MOD_CONTROL) && ed.selected >= 0 && (uint32_t)ed.selected < ed.widget_count) {
							uint32_t st = ed.widgets[ed.selected].type;
							if(st == MKGUI_VBOX || st == MKGUI_HBOX || st == MKGUI_FORM || st == MKGUI_GROUP || st == MKGUI_PANEL || st == MKGUI_WINDOW || st == MKGUI_TABS || st == MKGUI_TAB) {
								ctrl_target = ed.widgets[ed.selected].id;
								new_parent = ctrl_target;
								if(st == MKGUI_TABS) {
									uint32_t active = ed_get_active_tab(new_parent);
									if(active) {
										new_parent = active;
									}
								}
							}
						}

						if(!new_parent && is_chrome) {
							for(uint32_t j = 0; j < ed.widget_count; ++j) {
								if(ed.widgets[j].type == MKGUI_WINDOW) {
									new_parent = ed.widgets[j].id;
									break;
								}
							}
						}

						if(!new_parent) for(int32_t j = (int32_t)ed.widget_count - 2; j >= 0; --j) {
							struct ed_widget *c = &ed.widgets[j];
							if(c->type == MKGUI_TABS) {
								if(screen_x >= ed_rects[j].x && screen_x < ed_rects[j].x + ed_rects[j].w && screen_y >= ed_rects[j].y + win->tab_height && screen_y < ed_rects[j].y + ed_rects[j].h) {
									uint32_t active = ed_get_active_tab(c->id);
									if(active) {
										new_parent = active;
									}
									break;
								}

							} else if(c->type == MKGUI_HSPLIT || c->type == MKGUI_VSPLIT) {
								if(screen_x >= ed_rects[j].x && screen_x < ed_rects[j].x + ed_rects[j].w && screen_y >= ed_rects[j].y && screen_y < ed_rects[j].y + ed_rects[j].h) {
									new_parent = c->id;
									break;
								}

							} else if(c->type == MKGUI_MENU) {
								if(screen_x >= ed_rects[j].x && screen_x < ed_rects[j].x + ed_rects[j].w && screen_y >= ed_rects[j].y && screen_y < ed_rects[j].y + ed_rects[j].h) {
									new_parent = c->id;
									break;
								}

							} else if(c->type == MKGUI_VBOX || c->type == MKGUI_HBOX || c->type == MKGUI_FORM || c->type == MKGUI_GROUP || c->type == MKGUI_PANEL) {
								if(screen_x >= ed_rects[j].x && screen_x < ed_rects[j].x + ed_rects[j].w && screen_y >= ed_rects[j].y && screen_y < ed_rects[j].y + ed_rects[j].h) {
									new_parent = c->id;
									break;
								}
							}
						}

						if(new_parent) {
							struct ed_widget tmp = ed.widgets[new_idx];
							tmp.parent_id = new_parent;
							int32_t pidx = ed_find_widget(new_parent);
							if(pidx >= 0) {
								uint32_t pt = ed.widgets[pidx].type;
								if(pt == MKGUI_HBOX || pt == MKGUI_VBOX) {
									tmp.w = 0;
									tmp.h = 0;
									tmp.flags &= ~(MKGUI_ANCHOR_LEFT | MKGUI_ANCHOR_TOP | MKGUI_ANCHOR_RIGHT | MKGUI_ANCHOR_BOTTOM);
								} else if(pt == MKGUI_FORM) {
									tmp.w = 0;
									tmp.h = 24;
									tmp.flags &= ~(MKGUI_ANCHOR_LEFT | MKGUI_ANCHOR_TOP | MKGUI_ANCHOR_RIGHT | MKGUI_ANCHOR_BOTTOM);
								}
							}
							memmove(&ed.widgets[new_idx], &ed.widgets[new_idx + 1], (ed.widget_count - (uint32_t)new_idx - 1) * sizeof(struct ed_widget));
							--ed.widget_count;

							if(pidx >= 0 && ed.widgets[pidx].type == MKGUI_FORM && tmp.type != MKGUI_LABEL && ed.widget_count + 1 < ED_MAX_WIDGETS) {
								uint32_t lbl_pos = ed_insert_child_after(new_parent);
								struct ed_widget *lbl = &ed.widgets[lbl_pos];
								memset(lbl, 0, sizeof(*lbl));
								lbl->type = MKGUI_LABEL;
								lbl->id = ed.next_id++;
								lbl->parent_id = new_parent;
								snprintf(lbl->label, sizeof(lbl->label), "Label:");
								snprintf(lbl->id_name, sizeof(lbl->id_name), "ID_LABEL_%u", lbl->id);
							}

							uint32_t pos = ed_insert_child_after(new_parent);
							ed.widgets[pos] = tmp;
							new_idx = (int32_t)pos;
						}

						if(ctrl_target) {
							ed.selected = ed_find_widget(ctrl_target);
						} else {
							ed.selected = new_idx;
						}
						ed_sync_tree(win);
						ed_sync_props(win);
					}
					dirty_all(win);

				} else {
					uint32_t tab_switched = 0;
					for(uint32_t ti = 0; ti < ed.widget_count; ++ti) {
						if(ed.widgets[ti].type == MKGUI_TABS) {
							uint32_t tab_id = ed_tab_header_hit(win, (int32_t)ti, local_x, local_y);
							if(tab_id) {
								ed_set_active_tab(ed.widgets[ti].id, tab_id);
								ed.selected = (int32_t)ti;
								ed_sync_props(win);
								dirty_all(win);
								tab_switched = 1;
								break;
							}
						}
					}

					if(tab_switched) {

					} else {
					int32_t handle = ed_handle_hit(local_x, local_y);
					if(handle >= 0) {
						ed.resize_handle = handle;
						ed.drag_active = 2;
						ed.drag_ox = local_x;
						ed.drag_oy = local_y;
						ed.resize_start_x = ed_rects[ed.selected].x - ed_win_x;
						ed.resize_start_y = ed_rects[ed.selected].y - ed_win_y;
						ed.resize_start_w = ed_rects[ed.selected].w;
						ed.resize_start_h = ed_rects[ed.selected].h;

					} else {
						uint32_t cedge = ed_canvas_edge_hit(local_x, local_y);
						if(cedge) {
							ed.canvas_resize_edge = cedge;
							ed.drag_active = 3;
							ed.drag_ox = win->mouse_x;
							ed.drag_oy = win->mouse_y;
							ed.selected = -1;
							ed_sync_props(win);

						} else {
							int32_t hit = ed_canvas_hit(local_x, local_y);
							if(hit >= 0) {
								ed.selected = hit;
								ed.drag_active = 1;
								ed.drag_ox = local_x - (ed_rects[hit].x - ed_win_x);
								ed.drag_oy = local_y - (ed_rects[hit].y - ed_win_y);
								mkgui_treeview_select(win, ED_TREE, (int32_t)ed.widgets[hit].id);
								ed_sync_props(win);

							} else {
								ed.selected = -1;
								mkgui_treeview_select(win, ED_TREE, -1);
								ed_sync_props(win);
							}
						}
					}
					}
					dirty_all(win);
				}
			}

			if(ed.drag_active && win->press_id == ED_CANVAS_LBL) {
				int32_t local_x = win->mouse_x - win_x;
				int32_t local_y = win->mouse_y - win_y;

				if(ed.drag_active == 1 && ed.selected >= 0) {
					int32_t new_x = ed_snap(local_x - ed.drag_ox);
					int32_t new_y = ed_snap(local_y - ed.drag_oy);
					int32_t dx = new_x - ed.widgets[ed.selected].x;
					int32_t dy = new_y - ed.widgets[ed.selected].y;
					ed.widgets[ed.selected].x = new_x;
					ed.widgets[ed.selected].y = new_y;
					uint32_t sel_id = ed.widgets[ed.selected].id;
					for(uint32_t mi = 0; mi < ed.widget_count; ++mi) {
						if((int32_t)mi != ed.selected && ed_is_descendant(mi, sel_id) && !ed_is_layout_managed(mi)) {
							ed.widgets[mi].x += dx;
							ed.widgets[mi].y += dy;
						}
					}
					ed_sync_props(win);
					dirty_all(win);

				} else if(ed.drag_active == 2 && ed.selected >= 0) {
					struct ed_widget *w = &ed.widgets[ed.selected];
					int32_t prev_x = w->x;
					int32_t prev_y = w->y;
					int32_t dx = local_x - ed.drag_ox;
					int32_t dy = local_y - ed.drag_oy;
					int32_t sx = ed.resize_start_x;
					int32_t sy = ed.resize_start_y;
					int32_t sw = ed.resize_start_w;
					int32_t sh = ed.resize_start_h;
					int32_t right = sx + sw;
					int32_t bottom = sy + sh;

					switch(ed.resize_handle) {
						case 0: {
							w->x = ed_snap(sx + dx);
							w->y = ed_snap(sy + dy);
							w->w = right - w->x;
							w->h = bottom - w->y;
						} break;

						case 1: {
							w->y = ed_snap(sy + dy);
							w->h = bottom - w->y;
						} break;

						case 2: {
							w->y = ed_snap(sy + dy);
							w->w = ed_snap(sw + dx);
							w->h = bottom - w->y;
						} break;

						case 3: {
							w->w = ed_snap(sw + dx);
						} break;

						case 4: {
							w->w = ed_snap(sw + dx);
							w->h = ed_snap(sh + dy);
						} break;

						case 5: {
							w->h = ed_snap(sh + dy);
						} break;

						case 6: {
							w->x = ed_snap(sx + dx);
							w->w = right - w->x;
							w->h = ed_snap(sh + dy);
						} break;

						case 7: {
							w->x = ed_snap(sx + dx);
							w->w = right - w->x;
						} break;

						default: break;
					}

					if(w->w < 4) {
						w->w = 4;
					}

					if(w->h < 4) {
						w->h = 4;
					}
					int32_t child_dx = w->x - prev_x;
					int32_t child_dy = w->y - prev_y;
					if(child_dx || child_dy) {
						uint32_t sel_id = w->id;
						for(uint32_t mi = 0; mi < ed.widget_count; ++mi) {
							if((int32_t)mi != ed.selected && ed_is_descendant(mi, sel_id) && !ed_is_layout_managed(mi)) {
								ed.widgets[mi].x += child_dx;
								ed.widgets[mi].y += child_dy;
							}
						}
					}
					ed_sync_props(win);
					dirty_all(win);

				} else if(ed.drag_active == 3) {
					int32_t adx = win->mouse_x - ed.drag_ox;
					int32_t ady = win->mouse_y - ed.drag_oy;

					int32_t old_cw = ed.canvas_w;
					int32_t old_ch = ed.canvas_h;

					if(ed.canvas_resize_edge & ED_EDGE_RIGHT) {
						ed.canvas_w += adx;
					}

					if(ed.canvas_resize_edge & ED_EDGE_BOTTOM) {
						ed.canvas_h += ady;
					}

					if(ed.canvas_resize_edge & ED_EDGE_LEFT) {
						ed.canvas_w -= adx;
					}

					if(ed.canvas_resize_edge & ED_EDGE_TOP) {
						ed.canvas_h -= ady;
					}

					if(ed.canvas_w < ED_CANVAS_MIN) {
						ed.canvas_w = ED_CANVAS_MIN;
					}

					if(ed.canvas_h < ED_CANVAS_MIN) {
						ed.canvas_h = ED_CANVAS_MIN;
					}

					int32_t dx = ed.canvas_w - old_cw;
					int32_t dy = ed.canvas_h - old_ch;
					if(dx != 0 || dy != 0) {
						uint32_t win_id = ed.widgets[0].id;
						ed.widgets[0].w = ed.canvas_w;
						ed.widgets[0].h = ed.canvas_h;
						for(uint32_t i = 1; i < ed.widget_count; ++i) {
							struct ed_widget *aw = &ed.widgets[i];
							if(aw->parent_id != win_id) {
								continue;
							}
							uint32_t af = aw->flags;
							if(!(af & MKGUI_ANCHOR_LEFT) && (af & MKGUI_ANCHOR_RIGHT)) {
								aw->x += dx;
							}

							if(!(af & MKGUI_ANCHOR_TOP) && (af & MKGUI_ANCHOR_BOTTOM)) {
								aw->y += dy;
							}
						}
					}

					ed.drag_ox = win->mouse_x;
					ed.drag_oy = win->mouse_y;
					dirty_all(win);
				}
			}

			if(!win->press_id && ed.drag_active) {
				if(ed.drag_active && ed.selected >= 0) {
					ed_push_undo();
				}
				ed.drag_active = 0;
			}

			if(ed_help_text && ed_help_widget_id && win->hover_id != ed_help_widget_id) {
				ed_help_text = NULL;
				ed_help_widget_id = 0;
				dirty_all(win);
			}

			prev_press = win->press_id;
		}

		mkgui_ctx_wait(ctx);
	}

	for(uint32_t i = 0; i < ED_MAX_UNDO; ++i) {
		free(ed.undo[i].widgets);
	}
	mkgui_window_destroy(win);
	mkgui_ctx_destroy(ctx);
	return 0;
}