package vendor:microui

Source

Clip :: enum u32 {
	NONE, 
	PART, 
	ALL, 
}

Color :: struct {
	r: u8,
	g: u8,
	b: u8,
	a: u8,
}

Color_Type :: enum u32 {
	TEXT, 
	SELECTION_BG, 
	BORDER, 
	WINDOW_BG, 
	TITLE_BG, 
	TITLE_TEXT, 
	PANEL_BG, 
	BUTTON, 
	BUTTON_HOVER = BUTTON + 1, 
	BUTTON_FOCUS = BUTTON + 2, 
	BASE, 
	BASE_HOVER   = BASE + 1, 
	BASE_FOCUS   = BASE + 2, 
	SCROLL_BASE, 
	SCROLL_THUMB, 
}

Command :: struct {
	variant: Command_Variant,
	size:    i32,
}

Command_Clip :: struct {
	using command: Command,
	rect:    Rect,
}

Command_Icon :: struct {
	using command: Command,
	rect:    Rect,
	id:      Icon,
	color:   Color,
}

Command_Jump :: struct {
	using command: Command,
	dst:     rawptr,
}

Command_Rect :: struct {
	using command: Command,
	rect:    Rect,
	color:   Color,
}

Command_Text :: struct {
	using command: Command,
	font:    Font,
	pos:     Vec2,
	color:   Color,
	str:     string,
}

Command_Variant :: union {
	^Command_Jump, 
	^Command_Clip, 
	^Command_Rect, 
	^Command_Text, 
	^Command_Icon, 
}

Container :: struct {
	head:         ^Command,
	tail:         ^Command,
	rect:         Rect,
	body:         Rect,
	content_size: Vec2,
	scroll:       Vec2,
	zindex:       i32,
	open:         b32,
}

Context :: struct {
	// callbacks 
	text_width:          proc(font: Font, str: string) -> i32,
	text_height:         proc(font: Font) -> i32,
	draw_frame:          proc(ctx: ^Context, rect: Rect, colorid: Color_Type),
	// core state 
	_style:              Style,
	style:               ^Style,
	hover_id:            Id,
	focus_id:            Id,
	last_id:             Id,
	last_rect:           Rect,
	last_zindex:         i32,
	updated_focus:       b32,
	frame:               Frame_Index,
	hover_root:          ^Container,
	next_hover_root:     ^Container,
	scroll_target:       ^Container,
	number_edit_buf:     [127]u8,
	number_edit_len:     int,
	number_edit_id:      Id,
	// stacks 
	command_list:        Stack($T=u8, $N=262144),
	root_list:           Stack($T=^Container, $N=32),
	container_stack:     Stack($T=^Container, $N=32),
	clip_stack:          Stack($T=Rect, $N=32),
	id_stack:            Stack($T=Id, $N=32),
	layout_stack:        Stack($T=Layout, $N=16),
	// retained state pools 
	container_pool:      [48]Pool_Item,
	containers:          [48]Container,
	treenode_pool:       [48]Pool_Item,
	// input state 
	mouse_pos:           Vec2,
	last_mouse_pos:      Vec2,
	mouse_delta:         Vec2,
	scroll_delta:        Vec2,
	mouse_down_bits:     Mouse_Set,
	mouse_pressed_bits:  Mouse_Set,
	mouse_released_bits: Mouse_Set,
	key_down_bits:       Key_Set,
	key_pressed_bits:    Key_Set,
	_text_store:         [1024]u8,
	text_input:          strings.Builder,
	// uses `_text_store` as backing store with nil_allocator.
	textbox_state:       text_edit.State,
	textbox_offset:      i32,
}

Font :: distinct rawptr

Frame_Index :: distinct i32

Icon :: enum u32 {
	NONE, 
	CLOSE, 
	CHECK, 
	COLLAPSED, 
	EXPANDED, 
	RESIZE, 
}

Id :: distinct u32

Key :: enum u32 {
	SHIFT, 
	CTRL, 
	ALT, 
	BACKSPACE, 
	DELETE, 
	RETURN, 
	LEFT, 
	RIGHT, 
	HOME, 
	END, 
	A, 
	X, 
	C, 
	V, 
}

Key_Set :: distinct bit_set[Key; u32]

Layout :: struct {
	body:       Rect,
	next:       Rect,
	position:   Vec2,
	size:       Vec2,
	max:        Vec2,
	widths:     [16]i32,
	items:      i32,
	item_index: i32,
	next_row:   i32,
	next_type:  Layout_Type,
	indent:     i32,
}

Layout_Type :: enum int {
	NONE     = 0, 
	RELATIVE = 1, 
	ABSOLUTE = 2, 
}

Mouse :: enum u32 {
	LEFT, 
	RIGHT, 
	MIDDLE, 
}

Mouse_Set :: distinct bit_set[Mouse; u32]

Opt :: enum u32 {
	ALIGN_CENTER, 
	ALIGN_RIGHT, 
	NO_INTERACT, 
	NO_FRAME, 
	NO_RESIZE, 
	NO_SCROLL, 
	NO_CLOSE, 
	NO_TITLE, 
	HOLD_FOCUS, 
	AUTO_SIZE, 
	POPUP, 
	CLOSED, 
	EXPANDED, 
}

Options :: distinct bit_set[Opt; u32]

Pool_Item :: struct {
	id:          Id,
	last_update: Frame_Index,
}

Real :: f32

Rect :: struct {
	x: i32,
	y: i32,
	w: i32,
	h: i32,
}

Result :: enum u32 {
	ACTIVE, 
	SUBMIT, 
	CHANGE, 
}

Result_Set :: bit_set[Result; u32]

Stack :: struct($T: typeid, $N: int) {
	… // See source for fields
}

Style :: struct {
	font:           Font,
	size:           Vec2,
	padding:        i32,
	spacing:        i32,
	indent:         i32,
	title_height:   i32,
	footer_height:  i32,
	scrollbar_size: i32,
	thumb_size:     i32,
	colors:         [Color_Type]Color,
}

Vec2 :: distinct [2]i32

CLIP_STACK_SIZE :: #config(MICROUI_CLIP_STACK_SIZE, 32)

-define:MICROUI_CLIP_STACK_SIZE=32

COMMAND_LIST_SIZE :: #config(MICROUI_COMMAND_LIST_SIZE, 256 * 1024)

-define:MICROUI_COMMAND_LIST_SIZE=<value>

CONTAINER_POOL_SIZE :: #config(MICROUI_CONTAINER_POOL_SIZE, 48)

-define:MICROUI_CONTAINER_POOL_SIZE=48

CONTAINER_STACK_SIZE :: #config(MICROUI_CONTAINER_STACK_SIZE, 32)

-define:MICROUI_CONTAINER_STACK_SIZE=32

DEFAULT_ATLAS_FONT :: int(len(Icon) + 2)

DEFAULT_ATLAS_HEIGHT :: 128

DEFAULT_ATLAS_ICON_CHECK :: int(Icon.CHECK)

DEFAULT_ATLAS_ICON_CLOSE :: int(Icon.CLOSE)

DEFAULT_ATLAS_ICON_COLLAPSED :: int(Icon.COLLAPSED)

DEFAULT_ATLAS_ICON_EXPANDED :: int(Icon.EXPANDED)

DEFAULT_ATLAS_ICON_RESIZE :: int(Icon.RESIZE)

DEFAULT_ATLAS_WHITE :: int(len(Icon) + 1)

DEFAULT_ATLAS_WIDTH :: 128

ID_STACK_SIZE :: #config(MICROUI_ID_STACK_SIZE, 32)

-define:MICROUI_ID_STACK_SIZE=32

LAYOUT_STACK_SIZE :: #config(MICROUI_LAYOUT_STACK_SIZE, 16)

-define:MICROUI_LAYOUT_STACK_SIZE=16

MAX_FMT :: #config(MICROUI_MAX_FMT, 127)

-define:MICROUI_MAX_FMT=127

MAX_TEXT_STORE :: #config(MICROUI_MAX_TEXT_STORE, 1024)

-define:MICROUI_MAX_TEXT_STORE=1024

MAX_WIDTHS :: #config(MICROUI_MAX_WIDTHS, 16)

-define:MICROUI_MAX_WIDTHS=16

ROOT_LIST_SIZE :: #config(MICROUI_ROOT_LIST_SIZE, 32)

-define:MICROUI_ROOT_LIST_SIZE=32

SLIDER_FMT :: #config(MICROUI_SLIDER_FMT, "%.2f")

-define:MICROUI_SLIDER_FMT="%.2f"

TREENODE_POOL_SIZE :: #config(MICROUI_TREENODE_POOL_SIZE, 48)

-define:MICROUI_TREENODE_POOL_SIZE=48

default_atlas: [136]Rect = …

default_atlas_alpha: [16384]u8 = …

default_style: Style = …

unclipped_rect: Rect = …

begin :: proc(ctx: ^Context) {…}

begin_panel :: proc(ctx: ^Context, name: string, opt: Options = Options{}) {…}

begin_popup :: proc(ctx: ^Context, name: string) -> bool {…}

begin_treenode :: proc(
	ctx:   ^Context, 
	label: string, 
	opt:   Options = Options{}, 
) -> bit_set[Result; u32] {…}

begin_window :: proc(
	ctx:   ^Context, 
	title: string, 
	rect:  Rect, 
	opt:   Options = Options{}, 
) -> bool {…}

bring_to_front :: proc(ctx: ^Context, cnt: ^Container) {…}

button :: proc(
	ctx:   ^Context, 
	label: string, 
	icon:  Icon = .NONE, 
	opt:   Options = {.ALIGN_CENTER}, 
) -> (res: bit_set[Result; u32]) {…}

check_clip :: proc(ctx: ^Context, r: Rect) -> Clip {…}

checkbox :: proc(ctx: ^Context, label: string, state: ^bool) -> (res: bit_set[Result; u32]) {…}

default_atlas_text_height :: proc(font: Font) -> i32 {…}

default_atlas_text_width :: proc(font: Font, text: string) -> (width: i32) {…}

draw_box :: proc(ctx: ^Context, rect: Rect, color: Color) {…}

draw_control_frame :: proc(
	ctx:     ^Context, 
	id:      Id, 
	rect:    Rect, 
	colorid: Color_Type, 
	opt:     Options = Options{}, 
) {…}

draw_control_text :: proc(
	ctx:     ^Context, 
	str:     string, 
	rect:    Rect, 
	colorid: Color_Type, 
	opt:     Options = Options{}, 
) {…}

draw_icon :: proc(ctx: ^Context, id: Icon, rect: Rect, color: Color) {…}

draw_rect :: proc(ctx: ^Context, rect: Rect, color: Color) {…}

draw_text :: proc(ctx: ^Context, font: Font, str: string, pos: Vec2, color: Color) {…}

end :: proc(ctx: ^Context) {…}

end_panel :: proc(ctx: ^Context) {…}

end_popup :: proc(ctx: ^Context) {…}

end_treenode :: proc(ctx: ^Context) {…}

end_window :: proc(ctx: ^Context) {…}

expand_rect :: proc(rect: Rect, n: i32) -> Rect {…}

get_clip_rect :: proc(ctx: ^Context) -> Rect {…}

get_container :: proc(ctx: ^Context, name: string, opt: Options = Options{}) -> ^Container {…}

get_current_container :: proc(ctx: ^Context) -> ^Container {…}

get_id_bytes :: proc(ctx: ^Context, bytes: []u8) -> Id {…}

get_id_rawptr :: proc(ctx: ^Context, data: rawptr, size: int) -> Id {…}

get_id_string :: proc(ctx: ^Context, str: string) -> Id {…}

get_id_uintptr :: proc(ctx: ^Context, ptr: uintptr) -> Id {…}

get_layout :: proc(ctx: ^Context) -> ^Layout {…}

header :: proc(ctx: ^Context, label: string, opt: Options = Options{}) -> bit_set[Result; u32] {…}

init :: proc(
	ctx:                 ^Context, 
	set_clipboard:       proc(user_data: rawptr, text: string) -> (ok: bool) = nil, 
	get_clipboard:       proc(user_data: rawptr) -> (text: string, ok: bool) = nil, 
	clipboard_user_data: rawptr = nil, 
) {…}

input_key_down :: proc(ctx: ^Context, key: Key) {…}

input_key_up :: proc(ctx: ^Context, key: Key) {…}

input_mouse_down :: proc(ctx: ^Context, x, y: i32, btn: Mouse) {…}

input_mouse_move :: proc(ctx: ^Context, x, y: i32) {…}

input_mouse_up :: proc(ctx: ^Context, x, y: i32, btn: Mouse) {…}

input_scroll :: proc(ctx: ^Context, x, y: i32) {…}

input_text :: proc(ctx: ^Context, text: string) {…}

intersect_rects :: proc(r1, r2: Rect) -> Rect {…}

label :: proc(ctx: ^Context, text: string) {…}

layout_begin_column :: proc(ctx: ^Context) {…}

@(deferred_in=layout_end_column)
layout_column :: proc(ctx: ^Context) -> bool {…}

layout_end_column :: proc(ctx: ^Context) {…}

layout_height :: proc(ctx: ^Context, height: i32) {…}

layout_next :: proc(ctx: ^Context) -> (res: Rect) {…}

layout_row :: proc(ctx: ^Context, widths: []i32, height: i32 = 0) {…}

layout_row_items :: proc(ctx: ^Context, items: i32, height: i32 = 0) {…}

layout_set_next :: proc(ctx: ^Context, r: Rect, relative: bool) {…}

layout_width :: proc(ctx: ^Context, width: i32) {…}

mouse_over :: proc(ctx: ^Context, rect: Rect) -> bool {…}

next_command :: proc "contextless" (ctx: ^Context, pcmd: ^^Command) -> bool {…}

next_command_iterator :: proc "contextless" (
	ctx: ^Context, 
	pcm: ^^Command, 
) -> (Command_Variant, bool) {…}

number :: proc(
	ctx:        ^Context, 
	value:      ^f32, 
	step:       f32, 
	fmt_string: string = SLIDER_FMT, 
	opt:        Options = {.ALIGN_CENTER}, 
) -> (res: bit_set[Result; u32]) {…}

number_textbox :: proc(
	ctx:        ^Context, 
	value:      ^f32, 
	r:          Rect, 
	id:         Id, 
	fmt_string: string, 
) -> bool {…}

open_popup :: proc(ctx: ^Context, name: string) {…}

pool_get :: proc(ctx: ^Context, items: []Pool_Item, id: Id) -> (int, bool) {…}

pool_init :: proc(ctx: ^Context, items: []Pool_Item, id: Id) -> int {…}

pool_update :: proc(ctx: ^Context, item: ^Pool_Item) {…}

pop :: proc(stk: ^$T/Stack($T, $N)) {…}

pop_clip_rect :: proc(ctx: ^Context) {…}

pop_id :: proc(ctx: ^Context) {…}

@(deferred_in_out=scoped_end_popup)
popup :: proc(ctx: ^Context, name: string) -> bool {…}

push :: proc(stk: ^$T/Stack($T, $N), val: $V) {…}

push_clip_rect :: proc(ctx: ^Context, rect: Rect) {…}

push_command :: proc(ctx: ^Context, $Type: typeid, extra_size: int = 0) -> ^Type {…}

push_id_bytes :: proc(ctx: ^Context, bytes: []u8) {…}

push_id_rawptr :: proc(ctx: ^Context, data: rawptr, size: int) {…}

push_id_string :: proc(ctx: ^Context, str: string) {…}

push_id_uintptr :: proc(ctx: ^Context, ptr: uintptr) {…}

rect_overlaps_vec2 :: proc(r: Rect, p: Vec2) -> bool {…}

scoped_end_popup :: proc(ctx: ^Context, _: string, ok: bool) {…}

scoped_end_treenode :: proc(
	ctx:        ^Context, 
	_:          string, 
	_:          Options, 
	result_set: bit_set[Result; u32], 
) {…}

scoped_end_window :: proc(ctx: ^Context, _: string, _: Rect, _: Options, ok: bool) {…}

set_clip :: proc(ctx: ^Context, rect: Rect) {…}

set_focus :: proc(ctx: ^Context, id: Id) {…}

slider :: proc(
	ctx:        ^Context, 
	value:      ^f32, 
	low, high:  f32, 
	step:       f32 = 0.0, 
	fmt_string: string = SLIDER_FMT, 
	opt:        Options = {.ALIGN_CENTER}, 
) -> (res: bit_set[Result; u32]) {…}

text :: proc(ctx: ^Context, text: string) {…}

textbox :: proc(
	ctx:     ^Context, 
	buf:     []u8, 
	textlen: ^int, 
	opt:     Options = Options{}, 
) -> bit_set[Result; u32] {…}

textbox_raw :: proc(
	ctx:     ^Context, 
	textbuf: []u8, 
	textlen: ^int, 
	id:      Id, 
	r:       Rect, 
	opt:     Options = Options{}, 
) -> (res: bit_set[Result; u32]) {…}

@(deferred_in_out=scoped_end_treenode)
treenode :: proc(
	ctx:   ^Context, 
	label: string, 
	opt:   Options = Options{}, 
) -> bit_set[Result; u32] {…}

update_control :: proc(ctx: ^Context, id: Id, rect: Rect, opt: Options = Options{}) {…}

@(deferred_in_out=scoped_end_window)
window :: proc(ctx: ^Context, title: string, rect: Rect, opt: Options = Options{}) -> bool {…}

get_id :: proc{
	get_id_string,
	get_id_bytes,
	get_id_rawptr,
	get_id_uintptr,
}

push_id :: proc{
	push_id_string,
	push_id_bytes,
	push_id_rawptr,
	push_id_uintptr,
}