4coder/4ed_gui.cpp

645 lines
15 KiB
C++
Raw Normal View History

2016-02-21 17:44:23 +00:00
/*
* Mr. 4th Dimention - Allen Webster
*
* 20.02.2016
*
* GUI system for 4coder
*
*/
// TOP
2016-02-27 07:44:17 +00:00
struct Query_Slot{
Query_Slot *next;
Query_Bar *query_bar;
};
struct Query_Set{
Query_Slot slots[8];
Query_Slot *free_slot;
Query_Slot *used_slot;
};
internal void
init_query_set(Query_Set *set){
Query_Slot *slot = set->slots;
int i;
set->free_slot = slot;
set->used_slot = 0;
for (i = 0; i+1 < ArrayCount(set->slots); ++i, ++slot){
slot->next = slot + 1;
}
}
internal Query_Slot*
alloc_query_slot(Query_Set *set){
Query_Slot *slot = set->free_slot;
if (slot != 0){
set->free_slot = slot->next;
slot->next = set->used_slot;
set->used_slot = slot;
}
return(slot);
}
internal void
free_query_slot(Query_Set *set, Query_Bar *match_bar){
Query_Slot *slot = 0, *prev = 0;
for (slot = set->used_slot; slot != 0; slot = slot->next){
if (slot->query_bar == match_bar) break;
prev = slot;
}
if (slot){
if (prev){
prev->next = slot->next;
}
else{
set->used_slot = slot->next;
}
slot->next = set->free_slot;
set->free_slot = slot;
}
}
struct Super_Color{
Vec4 hsla;
Vec4 rgba;
u32 *out;
};
2016-03-31 04:05:47 +00:00
struct GUI_id{
u64 id[1];
};
2016-03-26 08:06:41 +00:00
struct GUI_Target{
Partition push;
2016-03-31 04:05:47 +00:00
GUI_id active;
GUI_id hot;
GUI_id hover;
f32 scroll_v;
f32 scroll_delta;
2016-03-31 17:13:40 +00:00
u32 scroll_id;
i32_Rect scrollable_area;
};
2016-03-26 08:06:41 +00:00
struct GUI_Header{
i32 type;
i32 size;
};
2016-03-31 04:05:47 +00:00
struct GUI_Interactive{
GUI_Header h;
GUI_id id;
};
2016-03-26 08:06:41 +00:00
enum GUI_Command_Type{
guicom_null,
guicom_begin_overlap,
guicom_end_overlap,
guicom_begin_serial,
guicom_end_serial,
guicom_top_bar,
guicom_file,
2016-03-31 04:05:47 +00:00
guicom_text_field,
guicom_file_option,
guicom_scrollable,
guicom_scrollable_top,
guicom_scrollable_slider,
guicom_scrollable_bottom,
};
2016-03-31 04:05:47 +00:00
internal b32
gui_id_eq(GUI_id id1, GUI_id id2){
b32 result = (id1.id[0] == id2.id[0]);
return(result);
}
internal b32
gui_id_is_null(GUI_id id){
b32 result = (id.id[0] == 0);
return(result);
}
internal i32
gui_active_level(GUI_Target *target, GUI_id id){
i32 level = 0;
if (gui_id_eq(target->active, id)){
level = 4;
}
else if (gui_id_eq(target->hot, id)){
if (gui_id_eq(target->hover, id)){
level = 3;
}
else{
level = 2;
}
}
else if (gui_id_eq(target->hover, id) && gui_id_is_null(target->hot)){
level = 1;
}
return(level);
}
2016-03-26 23:13:58 +00:00
internal void*
2016-03-31 04:05:47 +00:00
gui_push_item(GUI_Target *target, void *item, i32 size){
2016-03-26 08:06:41 +00:00
void *dest = partition_allocate(&target->push, size);
2016-03-31 04:05:47 +00:00
if (dest && item){
2016-03-26 08:06:41 +00:00
memcpy(dest, item, size);
}
2016-03-26 23:13:58 +00:00
return(dest);
}
2016-03-26 23:13:58 +00:00
internal void*
gui_align(GUI_Target *target){
void *ptr;
partition_align(&target->push, 8);
ptr = partition_current(&target->push);
return(ptr);
}
2016-03-31 17:13:40 +00:00
internal void*
advance_to_alignment(void *ptr){
u64 p = (u64)ptr;
p = (p + 7) & (~7);
return (void*)p;
}
2016-03-31 04:05:47 +00:00
internal void*
gui_push_aligned_item(GUI_Target *target, GUI_Header *h, void *item, i32 size){
char *start, *end;
start = (char*)partition_allocate(&target->push, size);
if (start){
memcpy(start, item, size);
}
end = (char*)gui_align(target);
size = (i32)(end - start);
h->size += size;
return(start);
}
internal void*
gui_push_item(GUI_Target *target, GUI_Header *h, void *item, i32 size){
void *ptr;
ptr = (char*)partition_allocate(&target->push, size);
if (ptr){
memcpy(ptr, item, size);
}
h->size += size;
return(ptr);
}
2016-03-26 23:13:58 +00:00
internal GUI_Header*
2016-03-26 08:06:41 +00:00
gui_push_simple_command(GUI_Target *target, i32 type){
2016-03-26 23:13:58 +00:00
GUI_Header *result = 0;
2016-03-26 08:06:41 +00:00
GUI_Header item;
item.type = type;
item.size = sizeof(item);
2016-03-31 04:05:47 +00:00
result = (GUI_Header*)gui_push_item(target, &item, sizeof(item));
return(result);
}
internal GUI_Interactive*
gui_push_button_command(GUI_Target *target, i32 type, GUI_id id){
GUI_Interactive *result = 0;
GUI_Interactive item;
item.h.type = type;
item.h.size = sizeof(item);
item.id = id;
result = (GUI_Interactive*)gui_push_item(target, &item, sizeof(item));
2016-03-26 08:06:41 +00:00
return(result);
}
2016-03-26 23:13:58 +00:00
internal void
2016-03-31 17:13:40 +00:00
gui_push_string(GUI_Target *target, GUI_Header *h, String s, i32 extra){
u8 *start, *end, *str_start;
2016-03-26 23:13:58 +00:00
i32 size;
2016-03-31 17:13:40 +00:00
i32 *cap;
2016-03-31 04:05:47 +00:00
start = (u8*)gui_push_item(target, &s.size, sizeof(s.size));
2016-03-31 17:13:40 +00:00
cap = (i32*)gui_push_item(target, 0, sizeof(i32));
str_start = (u8*)gui_push_item(target, s.str, s.size);
if (extra) gui_push_item(target, 0, extra);
2016-03-31 04:05:47 +00:00
end = (u8*)gui_align(target);
size = (i32)(end - start);
2016-03-31 17:13:40 +00:00
*cap = (i32)(end - str_start);
2016-03-31 04:05:47 +00:00
h->size += size;
}
internal void
2016-03-31 17:13:40 +00:00
gui_push_string(GUI_Target *target, GUI_Header *h, String s){
gui_push_string(target, h, s, 0);
2016-03-26 23:13:58 +00:00
}
internal void
2016-03-26 08:06:41 +00:00
gui_begin_top_level(GUI_Target *target){
2016-03-26 23:13:58 +00:00
target->push.pos = 0;
2016-03-31 04:05:47 +00:00
target->scroll_delta = 0;
}
internal void
2016-03-26 08:06:41 +00:00
gui_end_top_level(GUI_Target *target){
gui_push_simple_command(target, guicom_null);
}
internal void
2016-03-26 08:06:41 +00:00
gui_begin_overlap(GUI_Target *target){
gui_push_simple_command(target, guicom_begin_overlap);
}
2016-03-26 08:06:41 +00:00
internal void
gui_end_overlap(GUI_Target *target){
gui_push_simple_command(target, guicom_end_overlap);
}
internal void
2016-03-26 08:06:41 +00:00
gui_begin_serial_section(GUI_Target *target){
gui_push_simple_command(target, guicom_begin_serial);
}
internal void
2016-03-26 08:06:41 +00:00
gui_end_serial_section(GUI_Target *target){
gui_push_simple_command(target, guicom_end_serial);
}
internal void
2016-03-26 08:06:41 +00:00
gui_do_top_bar(GUI_Target *target){
gui_push_simple_command(target, guicom_top_bar);
}
internal void
2016-03-26 08:06:41 +00:00
gui_do_file(GUI_Target *target){
gui_push_simple_command(target, guicom_file);
}
2016-03-26 23:13:58 +00:00
internal void
2016-03-31 04:05:47 +00:00
gui_do_text_field(GUI_Target *target, String prompt, String text){
2016-03-26 23:13:58 +00:00
GUI_Header *h = gui_push_simple_command(target, guicom_text_field);
2016-03-31 04:05:47 +00:00
gui_push_string(target, h, prompt);
gui_push_string(target, h, text);
}
internal b32
gui_do_file_option(GUI_Target *target, GUI_id file_id, String filename, b32 is_folder, String message){
b32 result = 0;
GUI_Interactive *b = gui_push_button_command(target, guicom_file_option, file_id);
GUI_Header *h = (GUI_Header*)b;
gui_push_item(target, h, &is_folder, sizeof(is_folder));
gui_push_string(target, h, filename, 1);
gui_push_string(target, h, message);
if (gui_id_eq(file_id, target->active)){
result = 1;
}
return(result);
}
internal GUI_id
gui_id_scrollbar(){
GUI_id id;
id.id[0] = max_u64;
return(id);
}
internal GUI_id
gui_id_scrollbar_top(){
GUI_id id;
id.id[0] = max_u64 - 1;
return(id);
}
internal GUI_id
gui_id_scrollbar_slider(){
GUI_id id;
id.id[0] = max_u64 - 2;
return(id);
}
internal GUI_id
gui_id_scrollbar_bottom(){
GUI_id id;
id.id[0] = max_u64 - 3;
return(id);
}
internal b32
2016-03-31 17:13:40 +00:00
gui_start_scrollable(GUI_Target *target, u32 scroll_id, f32 *v, f32 d, i32_Rect *rect){
2016-03-31 04:05:47 +00:00
b32 result = 0;
GUI_Header *h;
target->scroll_delta = d;
h = gui_push_simple_command(target, guicom_scrollable);
2016-03-31 17:13:40 +00:00
if (gui_id_eq(gui_id_scrollbar(), target->active) && target->scroll_id == scroll_id){
2016-03-31 04:05:47 +00:00
if (v) *v = target->scroll_v;
result = 1;
}
else{
if (v) target->scroll_v = *v;
}
2016-03-31 17:13:40 +00:00
if (target->scroll_id == scroll_id){
*rect = target->scrollable_area;
}
target->scroll_id = scroll_id;
2016-03-31 04:05:47 +00:00
gui_push_simple_command(target, guicom_scrollable_top);
gui_push_simple_command(target, guicom_scrollable_slider);
gui_push_simple_command(target, guicom_scrollable_bottom);
return(result);
2016-03-26 23:13:58 +00:00
}
2016-03-26 08:06:41 +00:00
struct GUI_Section{
b32 overlapped;
2016-03-31 04:05:47 +00:00
i32 max_v, v;
2016-03-26 08:06:41 +00:00
};
2016-03-26 08:06:41 +00:00
struct GUI_Session{
i32_Rect full_rect;
i32_Rect clip_rect;
2016-03-31 04:05:47 +00:00
i32_Rect rect;
2016-03-26 08:06:41 +00:00
i32 line_height;
2016-03-31 04:05:47 +00:00
i32 scroll_bar_w;
b32 is_scrollable;
i32_Rect scroll_rect;
f32 scroll_top, scroll_bottom;
2016-03-26 08:06:41 +00:00
GUI_Section sections[64];
i32 t;
};
2016-03-31 04:05:47 +00:00
#define GUIScrollbarWidth 16
internal void
2016-03-26 08:06:41 +00:00
gui_session_init(GUI_Session *session, i32_Rect full_rect, i32 line_height){
GUI_Section *section;
2016-03-26 08:06:41 +00:00
*session = {0};
session->full_rect = full_rect;
session->line_height = line_height;
2016-03-31 04:05:47 +00:00
session->scroll_bar_w = GUIScrollbarWidth;
2016-03-26 08:06:41 +00:00
section = &session->sections[0];
section->v = full_rect.y0;
section->max_v = full_rect.y0;
}
internal void
gui_section_end_item(GUI_Section *section, i32 v){
if (!section->overlapped){
section->v = v;
}
section->max_v = v;
}
2016-03-31 04:05:47 +00:00
inline i32_Rect
gui_layout_top_bottom(GUI_Session *session, i32 y0, i32 y1){
i32_Rect rect;
i32_Rect full_rect = session->full_rect;
rect.y0 = y0;
rect.y1 = y1;
rect.x0 = full_rect.x0;
rect.x1 = full_rect.x1;
if (session->is_scrollable){
rect.x1 -= session->scroll_bar_w;
}
return(rect);
}
inline i32_Rect
gui_layout_fixed_h(GUI_Session *session, i32 y, i32 h){
i32_Rect rect;
rect = gui_layout_top_bottom(session, y, y + h);
return(rect);
}
internal void
gui_scrollbar_top(i32_Rect bar, i32_Rect *top){
i32 w = (bar.x1 - bar.x0);
top->x0 = bar.x0;
top->x1 = bar.x1;
top->y0 = bar.y0;
top->y1 = top->y0 + w;
}
internal void
gui_scrollbar_slider(i32_Rect bar, i32_Rect *slider, f32 s, f32 *min_out, f32 *max_out){
i32 w = (bar.x1 - bar.x0);
i32 min, max, pos;
slider->x0 = bar.x0;
slider->x1 = bar.x1;
min = bar.y0 + w + w/2;
max = bar.y1 - w - w/2;
pos = lerp(min, s, max);
slider->y0 = pos - w/2;
slider->y1 = slider->y0 + w;
*min_out = (f32)min;
*max_out = (f32)max;
}
internal void
gui_scrollbar_bottom(i32_Rect bar, i32_Rect *bottom){
i32 w = (bar.x1 - bar.x0);
bottom->x0 = bar.x0;
bottom->x1 = bar.x1;
bottom->y1 = bar.y1;
bottom->y0 = bottom->y1 - w;
}
internal b32
2016-03-31 04:05:47 +00:00
gui_interpret(GUI_Target *target, GUI_Session *session, GUI_Header *h){
2016-03-26 08:06:41 +00:00
GUI_Section *section = 0;
GUI_Section *new_section = 0;
GUI_Section *prev_section = 0;
GUI_Section *end_section = 0;
b32 give_to_user = 0;
i32_Rect rect = {0};
i32 y = 0;
i32 end_v = -1;
Assert(session->t < ArrayCount(session->sections));
section = session->sections + session->t;
y = section->v;
if (y < session->full_rect.y1){
switch (h->type){
case guicom_null: Assert(0); break;
case guicom_begin_overlap:
++session->t;
Assert(session->t < ArrayCount(session->sections));
new_section = &session->sections[session->t];
new_section->overlapped = 1;
new_section->v = y;
2016-03-31 04:05:47 +00:00
new_section->max_v = y;
2016-03-26 08:06:41 +00:00
break;
case guicom_end_overlap:
Assert(session->t > 0);
Assert(section->overlapped);
prev_section = &session->sections[--session->t];
end_v = section->max_v;
end_section = prev_section;
break;
case guicom_begin_serial:
++session->t;
Assert(session->t < ArrayCount(session->sections));
new_section = &session->sections[session->t];
new_section->overlapped = 0;
new_section->v = y;
2016-03-31 04:05:47 +00:00
new_section->max_v = y;
2016-03-26 08:06:41 +00:00
break;
case guicom_end_serial:
Assert(session->t > 0);
Assert(!section->overlapped);
prev_section = &session->sections[--session->t];
end_v = section->max_v;
end_section = prev_section;
break;
case guicom_top_bar:
give_to_user = 1;
2016-03-31 04:05:47 +00:00
rect = gui_layout_fixed_h(session, y, session->line_height + 2);
2016-03-26 08:06:41 +00:00
end_v = rect.y1;
end_section = section;
break;
2016-03-31 04:05:47 +00:00
2016-03-26 08:06:41 +00:00
case guicom_file:
give_to_user = 1;
2016-03-31 04:05:47 +00:00
rect = gui_layout_top_bottom(session, y, session->full_rect.y1);
2016-03-26 08:06:41 +00:00
end_v = rect.y1;
end_section = section;
break;
2016-03-26 23:13:58 +00:00
case guicom_text_field:
give_to_user = 1;
2016-03-31 04:05:47 +00:00
rect = gui_layout_fixed_h(session, y, session->line_height + 2);
2016-03-26 23:13:58 +00:00
end_v = rect.y1;
end_section = section;
break;
2016-03-31 04:05:47 +00:00
case guicom_file_option:
give_to_user = 1;
rect = gui_layout_fixed_h(session, y, session->line_height * 2);
end_v = rect.y1;
end_section = section;
break;
case guicom_scrollable:
Assert(session->is_scrollable == 0);
Assert(!section->overlapped);
give_to_user = 1;
rect.x1 = session->full_rect.x1;
rect.x0 = rect.x1 - session->scroll_bar_w;
rect.y0 = y;
rect.y1 = session->full_rect.y1;
session->scroll_rect = rect;
session->is_scrollable = 1;
2016-03-31 17:13:40 +00:00
target->scrollable_area.x0 = session->full_rect.x0;
target->scrollable_area.x1 = rect.x0;
target->scrollable_area.y0 = rect.y0;
target->scrollable_area.y1 = rect.y1;
2016-03-31 04:05:47 +00:00
break;
case guicom_scrollable_top:
Assert(session->is_scrollable);
Assert(!section->overlapped);
give_to_user = 1;
gui_scrollbar_top(session->scroll_rect, &rect);
break;
case guicom_scrollable_slider:
Assert(session->is_scrollable);
Assert(!section->overlapped);
give_to_user = 1;
gui_scrollbar_slider(session->scroll_rect, &rect, target->scroll_v, &session->scroll_top, &session->scroll_bottom);
break;
case guicom_scrollable_bottom:
Assert(session->is_scrollable);
Assert(!section->overlapped);
give_to_user = 1;
gui_scrollbar_bottom(session->scroll_rect, &rect);
break;
}
2016-03-26 08:06:41 +00:00
if (give_to_user){
GUI_Section *section = session->sections;
i32 max_v = 0;
i32 i = 0;
2016-03-26 08:06:41 +00:00
for (i = 0; i <= session->t; ++i, ++section){
if (section->overlapped){
max_v = Max(max_v, section->max_v);
2016-03-31 04:05:47 +00:00
}
}
2016-03-26 08:06:41 +00:00
session->rect = rect;
if (rect.y0 < max_v){
rect.y0 = max_v;
2016-03-31 04:05:47 +00:00
}
2016-03-26 08:06:41 +00:00
session->clip_rect = rect;
}
2016-03-26 08:06:41 +00:00
if (end_section){
gui_section_end_item(end_section, end_v);
2016-03-31 04:05:47 +00:00
}
}
2016-03-26 08:06:41 +00:00
return(give_to_user);
}
2016-02-21 17:44:23 +00:00
2016-03-26 23:13:58 +00:00
#define NextHeader(h) ((GUI_Header*)((char*)(h) + (h)->size))
2016-03-31 04:05:47 +00:00
internal i32
gui_read_integer(void **ptr){
i32 result;
result = *(i32*)*ptr;
*ptr = ((char*)*ptr) + 4;
return(result);
}
internal f32
gui_read_float(void **ptr){
f32 result;
result = *(f32*)*ptr;
*ptr = ((char*)*ptr) + 4;
return(result);
}
2016-03-26 23:13:58 +00:00
internal String
gui_read_string(void **ptr){
String result;
result.size = *(i32*)*ptr;
*ptr = ((i32*)*ptr) + 1;
2016-03-31 17:13:40 +00:00
result.memory_size = *(i32*)*ptr;
*ptr = ((i32*)*ptr) + 1;
2016-03-26 23:13:58 +00:00
2016-03-31 17:13:40 +00:00
result.str = (char*)*ptr;
*ptr = result.str + result.memory_size;
2016-03-26 23:13:58 +00:00
return(result);
}
2016-02-21 17:44:23 +00:00
2016-03-26 08:06:41 +00:00
2016-02-21 17:44:23 +00:00
// BOTTOM