mr4th-public
/
splink
1
Fork 0
Code Issues Releases Activity
splink/source/app.c

1255 lines
44 KiB
C
Raw Blame History

#include "language_layer.h"
#include "app_memory.h"
#include "os.h"
#include "opengl.h"
#include "render.h"
#include "string_hash.h"
#include "ui.h"
#include "compute.h"
#include "token_buffer.h"
#include "definition.h"
#include "app.h"
#include "operations.h"
#include "language_layer.c"
#include "app_memory.c"
#include "os.c"
#include "app_core.c"
#include "string_hash.c"
#include "render.c"
#include "ui.c"
#include "compute.c"
#include "token_buffer.c"
#include "definition.c"
#include "operations.c"
////////////////////////////////
internal b32
APP_FuzzyMatch(String8 name, String8_List *filter_pattern){
b32 result = 1;
for (String8_Node *node = filter_pattern->first;
node != 0;
node = node->next){
if (StringFindSubstringStart(name, node->string, StringMatchFlag_CaseInsensitive) == ~(u64)0){
result = 0;
break;
}
}
return(result);
}
internal void
APP_TopLevelNavigate(Dimension dimension, Side side){
if (dimension == Dimension_Y){
E_EditorState *new_editor = vars->neighbor_editors[side];
if (new_editor != 0){
f32 x = vars->active_editor?vars->active_editor->preferred_x:0;
E_EditorEnterFrom(new_editor, Dimension_Y, side^1, x);
vars->active_editor = new_editor;
MemoryZeroArray(vars->neighbor_editors);
}
}
else{
NotImplemented;
}
}
internal void
APP_ApplyViewChange(E_View *view){
if (vars->change_view != 0){
E_ViewDeriveFromSource(view);
vars->active_view = view;
}
vars->change_view = 0;
}
internal void
APP_SpaceHandleDeleteSignal(E_Space *space){
space->delete_signal = 0;
for (E_Definition *node = space->first_definition_ordered, *next = 0;
node != 0;
node = next){
next = node->ordered_next;
if (node->delete_me){
_E_DeleteDefinition(node);
space->dirty = 1;
}
}
}
internal void
APP_CloseSpace(E_Space *space){
b32 deleted_active_view = 0;
E_View *active_view = vars->active_view;
for (E_View *view = vars->first_view, *next = 0;
view != 0;
view = next){
next = view->next;
if (view->space == space){
if (view == active_view){
deleted_active_view = 1;
}
E_DeleteView(view);
}
}
E_DeleteSpace(space);
if (deleted_active_view){
vars->active_view = 0;
if (vars->first_view != 0){
APP_SignalViewChange(vars->first_view);
}
}
}
internal E_Space*
APP_ReloadSpace(E_Space *space, String8 serialized){
E_Space *result = E_DeserializeSpace(serialized);
if (result == 0){
result = space;
}
else{
E_View *active_view = vars->active_view;
b32 deleted_active_view = 0;
b32 effected_active_view = 0;
for (E_View *view = vars->first_view, *next = 0;
view != 0;
view = next){
next = view->next;
if (view->space == space){
E_Definition *definition = view->definition;
E_Definition *replacement_definition = 0;
if (definition != 0){
replacement_definition = E_GetDefinitionByID(result, definition->id, 0);
}
if (definition != 0 && replacement_definition == 0){
if (view == active_view){
deleted_active_view = 1;
effected_active_view = 1;
}
E_DeleteView(view);
}
else{
if (view == active_view){
effected_active_view = 1;
}
view->space = result;
view->definition = replacement_definition;
}
}
}
E_View *global_view = APP_GetGlobalView(result);
if (global_view == 0){
global_view = E_NewView();
E_InitGlobalView(global_view, &vars->font, result);
}
if (deleted_active_view){
active_view = global_view;
}
if (effected_active_view){
vars->active_view = 0;
APP_SignalViewChange(active_view);
}
E_DeleteSpace(space);
}
return(result);
}
////////////////////////////////
APP_PERMANENT_LOAD
{
os = os_;
#if 1
_STR_Test();
_E_TokenBuffer_Test();
#endif
{
M_Arena arena_ = M_ArenaInitialize();
vars = PushArray(&arena_, APP_Variables, 1);
MemoryCopyStruct(&vars->arena_, &arena_);
}
M_Arena *arena = vars->arena = &vars->arena_;
////////////////////////////////
// NOTE(allen): Init rendering
R_Init(arena);
R_InitFont(&vars->font, S8Lit("liberation-mono.ttf"), 20);
R_SelectFont(&vars->font);
////////////////////////////////
// NOTE(allen): Init splink engine
for (u64 i = 0; i < ArrayCount(vars->frame_arena); i += 1){
vars->frame_arena[i] = M_ArenaInitialize();
}
vars->string_hash = STR_InitHash();
vars->cells = C_InitCellMemory();
vars->static_bucket = C_InitCellBucket(&vars->cells);
vars->statics = C_InitStatics(&vars->static_bucket);
vars->global_defines_bucket = C_InitCellBucket(&vars->cells);
vars->eval_bucket = C_InitCellBucket(&vars->cells);
for (u64 i = 0; i < C_BuiltInIndex_COUNT; i += 1){
vars->keyword_table[i] = STR_Save(&vars->string_hash, C_GetBuiltInKeyword(i));
}
////////////////////////////////
// NOTE(allen): UI State
vars->lister_flags = ~0;
vars->panel_filter_buffer = E_InitTextFieldTokenBuffer(&vars->panel_filter_memory);
vars->panel_filter = E_InitEditorState(&vars->panel_filter_buffer, &vars->font);
}
APP_HOT_LOAD
{
os = os_;
}
APP_HOT_UNLOAD {}
////////////////////////////////
APP_UPDATE
{
////////////////////////////////
// NOTE(allen): Frame setup
vars->frame_time = os->GetTime();
vars->window_dim = v2(os->window_size.x, os->window_size.y);
R_Begin(vars->window_dim, cl_black);
M_ArenaClear(APP_GetFrameArena());
////////////////////////////////
// NOTE(allen): Cleanup deleted definitions
if (vars->active_view != 0){
E_View *view = vars->active_view;
E_Space *space = view->space;
if (space->delete_signal){
APP_SpaceHandleDeleteSignal(space);
vars->active_view = 0;
APP_SignalViewChange(view);
}
}
for (E_Space *space = vars->first_space;
space != 0;
space = space->next){
if (space->delete_signal){
APP_SpaceHandleDeleteSignal(space);
}
}
////////////////////////////////
// NOTE(allen): Cleanup closed tiles
for (E_View *view = vars->first_view;
view != 0;
view = view->next){
E_ViewCleanup(view);
}
////////////////////////////////
// NOTE(allen): Auto-Save
{
M_Arena *scratch = OS_GetScratch();
M_Temp restore = M_BeginTemp(scratch);
for (E_Space *space = vars->first_space_ordered;
space != 0;
space = space->ordered_next){
if (space->dirty && space->save_path != 0){
if (space->last_save_time + 3.f <= vars->frame_time){
space->last_save_time = vars->frame_time;
String8 path = STR_Read(APP_GetStringHash(), space->save_path);
String8 serialized = E_SerializeSpace(scratch, space);
space->dirty = os->SaveToFile(path, serialized.str, serialized.size);
M_EndTemp(restore);
}
}
}
OS_ReleaseScratch(scratch);
}
////////////////////////////////
// NOTE(allen): Set Mouse Position
UI_Id main_mouse_layer = UI_IdV(APP_MouseLayer_Main);
UI_Id floating_window_mouse_layer = UI_IdV(APP_MouseLayer_FloatingWindow);
vars->active_mouse_layer = main_mouse_layer;
MemoryZeroStruct(&vars->tool_tip_string);
{
OS_Event *event = 0;
for (;OS_GetNextEvent(&event);){
switch (event->type){
case OS_EventType_MouseMove:
{
vars->mouse_p = event->position;
OS_EatEvent(event);
}break;
}
}
}
////////////////////////////////
// NOTE(allen): Floating Window Pre-Update
vars->last_frame_owner_of_floating_window = vars->owner_of_floating_window;
vars->last_frame_floating_window_ptr = vars->floating_window_ptr;
vars->floating_window_ptr = 0;
vars->floating_window_callback = 0;
if (!UI_IdEq(vars->owner_of_floating_window, UI_IdZero())){
APP_SetMouseLayer(floating_window_mouse_layer);
vars->active_mouse_layer = floating_window_mouse_layer;
if (UI_TryEatKeyPress(Key_Esc)){
MemoryZeroStruct(&vars->owner_of_floating_window);
}
if (!UI_MouseInRect(vars->floating_window_last_frame_rect)){
if (UI_TryEatLeftClick()){
MemoryZeroStruct(&vars->owner_of_floating_window);
}
}
}
if (UI_IdEq(vars->owner_of_floating_window, UI_IdZero())){
vars->active_mouse_layer = main_mouse_layer;
}
////////////////////////////////
// NOTE(allen): Top Level UI Layout
APP_SetMouseLayer(main_mouse_layer);
v2 space_dim = R_StringDimWithFont(&vars->font, 1.f, S8Lit(" "));
f32 outline_t = 2.f;
f32 bar_h = space_dim.y + outline_t*2.f;
v2 btn_dim = {space_dim.x*3.f};
btn_dim.y = btn_dim.x;
Range y_free = MakeRange(0, vars->window_dim.y);
Range x_free = MakeRange(0, vars->window_dim.x);
Range panel_x = RangeSplit(&x_free, Side_Min, space_dim.x*21.f);
x_free.min += outline_t;
Range y_free_panel = y_free;
Range tool_box_y = RangeSplit(&y_free_panel, Side_Min, btn_dim.y);
Range lister_toggles_y = RangeSplit(&y_free_panel, Side_Min, btn_dim.y);
y_free_panel.min += outline_t;
Range filter_field_y = RangeSplit(&y_free_panel, Side_Min, bar_h);
y_free_panel.min += outline_t;
Range lister_y = y_free_panel;
Range code_x = x_free;
Range view_buttons_y = RangeSplit(&y_free, Side_Min, btn_dim.y);
y_free_panel.min += outline_t;
Range tabs_y = RangeSplit(&y_free, Side_Min, bar_h);
Range code_y = y_free;
////////////////////////////////
// NOTE(allen): Tool Box
{
Rect rect = MakeRectRanges(panel_x, tool_box_y);
R_Rect(rect, cl_back_unimportant, 1.f);
UI_ButtonCtx btn_ctx = UI_InitButtonCtx(rect, btn_dim, &vars->font, UI_IdV(APP_BtnCtx_ToolBox));
btn_ctx.outline_t = outline_t;
btn_ctx.enable_drop_down = 1;
btn_ctx.enable_hot_keys = 1;
UI_NextHotkey(&btn_ctx, Key_N, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("new definition"));
if (UI_Button(&btn_ctx, '+', 'n')){
if (vars->active_view != 0){
E_ViewCreateNewDefinition(vars->active_view);
}
else{
E_Space *empty_space = E_NewSpace();
E_View *global_view = E_NewView();
E_InitGlobalView(global_view, &vars->font, empty_space);
APP_SetActiveView(global_view);
E_ViewCreateNewDefinition(global_view);
}
}
UI_NextHotkey(&btn_ctx, Key_T, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("new page"));
if (UI_Button(&btn_ctx, '+', 't')){
if (vars->active_view != 0){
E_Definition *definition = E_ViewCreateNewDefinition(vars->active_view);
E_View *view = E_NewView();
E_InitPageView(view, vars->active_view->font, definition);
APP_SignalViewChange(view);
}
else{
E_Space *empty_space = E_NewSpace();
E_View *global_view = E_NewView();
E_InitGlobalView(global_view, &vars->font, empty_space);
APP_SetActiveView(global_view);
E_ViewCreateNewDefinition(global_view);
}
}
String8 ext[2];
ext[0] = S8Lit("Splink");
ext[1] = S8Lit("splink");
E_Space *space = APP_GetActiveSpace();
UI_NextCondition(&btn_ctx, space != 0);
UI_NextHotkey(&btn_ctx, Key_S, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("set save path"));
if (UI_Button(&btn_ctx, 'v', 'S')){
M_Arena *scratch = OS_GetScratch();
Assert(space != 0);
String8 string = os->DialogueSavePath(scratch, ext);
if (string.size > 0){
if (!StringMatch(StringPostfix(string, 7),
S8Lit(".splink"))){
string = PushStringCat(scratch, string, S8Lit(".splink"));
}
space->dirty = 1;
space->last_save_time = 0.f;
space->save_path = STR_Save(APP_GetStringHash(), string);
E_SpaceUpdateValidation(space);
}
OS_ReleaseScratch(scratch);
}
UI_NextHotkey(&btn_ctx, Key_O, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("open space"));
if (UI_Button(&btn_ctx, '^', 'O')){
M_Arena *scratch = OS_GetScratch();
String8 string = os->DialogueLoadPath(scratch, ext);
if (string.size > 0){
String8 serialized = {0};
os->LoadEntireFile(scratch, string, (void**)&serialized.str, &serialized.size);
STR_Index path = STR_Save(APP_GetStringHash(), string);
E_Space *new_space = E_GetSpaceByPath(path, 0);
if (new_space != 0){
new_space = APP_ReloadSpace(new_space, serialized);
}
else{
new_space = E_DeserializeSpace(serialized);
E_View *global_view = E_NewView();
E_InitGlobalView(global_view, &vars->font, new_space);
APP_SetActiveView(global_view);
}
if (new_space->init_error){
new_space->save_path = 0;
}
else{
new_space->save_path = path;
}
E_SpaceUpdateValidation(new_space);
}
OS_ReleaseScratch(scratch);
}
UI_NextHotkey(&btn_ctx, Key_N, KeyModifier_Ctrl|KeyModifier_Shift);
UI_NextTooltip(&btn_ctx, S8Lit("new space"));
if (UI_Button(&btn_ctx, '^', 'N')){
E_Space *empty_space = E_NewSpace();
E_View *global_view = E_NewView();
E_InitGlobalView(global_view, &vars->font, empty_space);
APP_SetActiveView(global_view);
}
}
////////////////////////////////
// NOTE(allen): Panel Buttons
{
Rect rect = MakeRectRanges(panel_x, lister_toggles_y);
R_Rect(rect, cl_back_unimportant, 1.f);
UI_ButtonCtx btn_ctx = UI_InitButtonCtx(rect, btn_dim, &vars->font, UI_IdV(APP_BtnCtx_ListerOptions));
btn_ctx.outline_t = outline_t;
btn_ctx.enable_drop_down = 1;
btn_ctx.enable_hot_keys = 1;
UI_NextActive(&btn_ctx, vars->lister_flags & APP_ListerFlag_Spaces);
UI_NextHotkey(&btn_ctx, Key_1, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("list spaces"));
if (UI_Button(&btn_ctx, 'L', 's')){
vars->lister_flags ^= APP_ListerFlag_Spaces;
}
UI_NextActive(&btn_ctx, vars->lister_flags & APP_ListerFlag_Pages);
UI_NextHotkey(&btn_ctx, Key_2, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("list pages"));
if (UI_Button(&btn_ctx, 'L', 'p')){
vars->lister_flags ^= APP_ListerFlag_Pages;
}
UI_NextActive(&btn_ctx, vars->lister_flags & APP_ListerFlag_Invalids);
UI_NextHotkey(&btn_ctx, Key_3, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("list invalid definitions"));
if (UI_Button(&btn_ctx, 'L', 'e')){
vars->lister_flags ^= APP_ListerFlag_Invalids;
}
UI_NextActive(&btn_ctx, vars->lister_flags & APP_ListerFlag_Definitions);
UI_NextHotkey(&btn_ctx, Key_4, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("list definitions"));
if (UI_Button(&btn_ctx, 'L', 'd')){
vars->lister_flags ^= APP_ListerFlag_Definitions;
}
UI_NextActive(&btn_ctx, vars->lister_flags & APP_ListerFlag_Tests);
UI_NextHotkey(&btn_ctx, Key_5, KeyModifier_Ctrl);
UI_NextTooltip(&btn_ctx, S8Lit("list tests"));
if (UI_Button(&btn_ctx, 'L', 't')){
vars->lister_flags ^= APP_ListerFlag_Tests;
}
}
////////////////////////////////
// NOTE(allen): Panel Text Field
{
Rect rect = MakeRectRanges(panel_x, filter_field_y);
Rect inner = RectShrink(rect, outline_t);
UI_ColorProfile *cl = UI_ColorsDefault();
UI_ActionLevel actlvl = UI_ActionLevel_None;
if (UI_MouseInRect(rect)){
actlvl = UI_ActionLevel_Hover;
OS_Event *event = 0;
if (UI_TryGetLeftClick(&event)){
APP_SetActiveEditor(&vars->panel_filter);
E_EditorHandleMousePressEvent(&vars->panel_filter, event, inner.p0);
}
}
else if (vars->active_editor == &vars->panel_filter){
actlvl = UI_ActionLevel_Active;
}
R_Rect(rect, cl->back[actlvl], 1.f);
R_RectOutline(rect, outline_t, cl->outline[actlvl], 1.f);
Rect clip_restore = R_PushClip(inner);
E_EditorUpdateLayout(&vars->panel_filter, &vars->font);
E_EditorRender(&vars->panel_filter, &vars->font, inner.p0);
if (vars->active_editor != &vars->panel_filter && vars->panel_filter.buffer->count == 0){
R_String(inner.p0, 1.f, S8Lit("filter"), cl->front[0], 0.15f);
}
R_SetClip(clip_restore);
}
////////////////////////////////
// NOTE(allen): Panel Definitions List
{
M_Arena *scratch = OS_GetScratch();
STR_Hash *string_hash = APP_GetStringHash();
Rect rect = MakeRectRanges(panel_x, lister_y);
R_Rect(rect, cl_back_unimportant, 1.f);
Rect clip_restore = R_PushClip(rect);
Rect scrolled_rect = rect;
scrolled_rect.y0 -= vars->panel_scroll_y;
char split_chars[] = " *";
String8 filter_key = {0};
if (vars->panel_filter_buffer.count > 0){
filter_key = STR_Read(string_hash, vars->panel_filter_memory.string);
}
String8_List filter_pattern = StringSplit(scratch, filter_key, (u8*)split_chars, ArrayCount(split_chars));
StringListRemoveEmpties(&filter_pattern);
UI_ButtonCtx btn_ctx = UI_InitButtonCtx(scrolled_rect, v2(RangeSize(panel_x), bar_h), &vars->font, UI_IdV(APP_BtnCtx_Lister));
btn_ctx.outline_t = outline_t;
UI_ColorProfile *cl_prof[2];
cl_prof[0] = UI_ColorsProblem();
cl_prof[1] = UI_ColorsDefault();
// NOTE(allen): Spaces
if (vars->lister_flags & APP_ListerFlag_Spaces){
UI_NextCondition(&btn_ctx, 0);
UI_ButtonLabel(&btn_ctx, S8Lit("<Spaces>"));
E_Space *first[2];
first[0] = vars->first_invalid_space;
first[1] = vars->first_space;
for (u64 i = 0; i < 2; i += 1){
UI_SetColorProfile(&btn_ctx, cl_prof[i]);
for (E_Space *space = first[i];
space != 0;
space = space->next){
String8 path = STR_Read(string_hash, space->save_path);
String8 name = STR_NameFromPath(path);
if (APP_FuzzyMatch(name, &filter_pattern)){
if (UI_ButtonLabel(&btn_ctx, name)){
E_View *view = APP_GetGlobalView(space);
if (view == 0){
view = E_NewView();
E_InitGlobalView(view, &vars->font, space);
}
APP_SignalViewChange(view);
}
}
}
}
}
// NOTE(allen): Various types of definitions
E_Space *space = APP_GetActiveSpace();
if (space != 0){
typedef struct APP_DefinitionGroup APP_DefinitionGroup;
struct APP_DefinitionGroup{
char *label;
APP_ListerFlags lister_flag;
E_DefinitionFlags filter_positive;
E_DefinitionFlags filter_negative;
UI_ColorProfile *cl;
};
APP_DefinitionGroup groups[4] = {
{"<Pages>" , APP_ListerFlag_Pages ,
E_DefinitionFlag_Page, 0,
UI_ColorsPage(), },
{"<Invalids>" , APP_ListerFlag_Invalids ,
E_DefinitionFlag_Invalid, E_DefinitionFlag_Page|E_DefinitionFlag_Test,
UI_ColorsProblem(), },
{"<Definitions>", APP_ListerFlag_Definitions,
0, E_DefinitionFlag_Page|E_DefinitionFlag_Invalid|E_DefinitionFlag_Test,
UI_ColorsDefault(), },
{"<Tests>" , APP_ListerFlag_Tests ,
E_DefinitionFlag_Test, E_DefinitionFlag_Page,
UI_ColorsTest(), },
};
APP_DefinitionGroup *group = groups;
for (u64 j = 0; j < ArrayCount(groups); j += 1, group += 1){
if (vars->lister_flags & group->lister_flag){
Assert((group->filter_positive & group->filter_negative) == 0);
E_DefinitionFlags filter_positive = group->filter_positive;
E_DefinitionFlags filter_negative = group->filter_negative;
UI_SetColorProfile(&btn_ctx, group->cl);
UI_NextCondition(&btn_ctx, 0);
UI_ButtonLabel(&btn_ctx, String8FromCString(group->label));
for (E_Definition *node = space->first_definition_ordered;
node != 0;
node = node->ordered_next){
if ((node->flags & filter_positive) != filter_positive){
continue;
}
if ((node->flags & filter_negative) != 0){
continue;
}
String8 name = E_DefinitionName(node);
if (!APP_FuzzyMatch(name, &filter_pattern)){
continue;
}
if (name.size == 0){
name = S8Lit("<unnamed>");
}
if (UI_ButtonLabel(&btn_ctx, name)){
switch (group->lister_flag){
case APP_ListerFlag_Pages:
{
OP_ViewPageFromDefinition(node);
}break;
default:
{
OP_LookAtDefinition(node);
}break;
}
}
}
}
}
// NOTE(allen): Scrolling
if (UI_MouseInRect(rect)){
v2 delta = {0};
if (UI_TryEatScroll(&delta)){
vars->panel_scroll_y -= delta.y;
}
}
f32 h = UI_ButtonCtxGetTraversedY(&btn_ctx);;
f32 max_scroll = h - RangeSize(lister_y)*0.5f;
max_scroll = ClampBot(0.f, max_scroll);
vars->panel_scroll_y = Clamp(0.f, vars->panel_scroll_y, max_scroll);
}
R_SetClip(clip_restore);
OS_ReleaseScratch(scratch);
}
////////////////////////////////
// NOTE(allen): View Buttons
{
Rect rect = MakeRectRanges(code_x, view_buttons_y);
R_Rect(rect, cl_back_unimportant, 1.f);
UI_ButtonCtx btn_ctx = UI_InitButtonCtx(rect, btn_dim, &vars->font, UI_IdV(APP_BtnCtx_ViewButtons));
btn_ctx.outline_t = outline_t;
btn_ctx.enable_drop_down = 1;
btn_ctx.enable_hot_keys = 1;
UI_SetColorProfile(&btn_ctx, UI_ColorsProblem());
UI_SetRedText(&btn_ctx.cl);
UI_NextActive(&btn_ctx, vars->active_view != 0);
UI_NextHotkey(&btn_ctx, Key_K, KeyModifier_Ctrl|KeyModifier_Shift);
UI_NextTooltip(&btn_ctx, S8Lit("close current tab"));
if (UI_Button(&btn_ctx, 'X', 't')){
E_View *view = vars->active_view;
E_View *switch_to_view = view->next;
if (switch_to_view == 0){
switch_to_view = view->prev;
}
E_DeleteView(view);
vars->active_view = 0;
if (switch_to_view != 0){
APP_SignalViewChange(switch_to_view);
}
}
UI_NextActive(&btn_ctx, APP_GetActiveSpace() != 0);
UI_NextTooltip(&btn_ctx, S8Lit("close current splink file"));
if (UI_Button(&btn_ctx, 'X', 'f')){
E_Space *space = APP_GetActiveSpace();
APP_CloseSpace(space);
}
}
////////////////////////////////
// NOTE(allen): Page Tabs
{
E_View *view = vars->active_view;
if (UI_TryEatKeyPressModified(Key_Tab, KeyModifier_Ctrl)){
APP_SignalViewChange((view != 0 && view->next != 0)?
view->next:vars->first_view);
}
if (UI_TryEatKeyPressModified(Key_Tab, KeyModifier_Ctrl|KeyModifier_Shift)){
APP_SignalViewChange((view != 0 && view->prev != 0)?
view->prev:vars->last_view);
}
}
{
Rect rect = MakeRectRanges(code_x, tabs_y);
R_Rect(rect, cl_back_unimportant, 1.f);
f32 w = R_StringDimWithFont(&vars->font, 1.f, S8Lit(" ")).x*10.f;
UI_ButtonCtx btn_ctx = UI_InitButtonCtx(rect, v2(w, RangeSize(tabs_y)), &vars->font, UI_IdV(APP_BtnCtx_Tabs));
btn_ctx.outline_t = outline_t;
btn_ctx.text_scale = 0.70f;
btn_ctx.enable_flexible_x_advance = 1;
UI_SetColorProfile(&btn_ctx, UI_ColorsTabs());
for (E_View *view = vars->first_view;
view != 0;
view = view->next){
if (view == vars->active_view){
UI_NextActive(&btn_ctx, 1);
}
String8 name = E_ViewGetName(view);
if (UI_ButtonLabel(&btn_ctx, name)){
APP_SignalViewChange(view);
}
}
}
////////////////////////////////
// NOTE(allen): Update token editor layouts
if (vars->active_view != 0){
MemoryZeroArray(vars->neighbor_editors);
E_EditorState *prev_editor = 0;
b32 save_next = 0;
E_EditorState *active_editor = vars->active_editor;
for (E_Tile *tile = vars->active_view->first_tile;
tile != 0;
tile = tile->next){
E_TileUpdateLayout(tile, &vars->font);
if (active_editor != 0){
E_EditorState *editor = tile->editors;
for (u64 i = 0; i < ArrayCount(tile->editors); i += 1, editor += 1){
if (save_next){
vars->neighbor_editors[Side_Max] = editor;
save_next = 0;
active_editor = 0;
break;
}
if (active_editor == editor){
save_next = 1;
vars->neighbor_editors[Side_Min] = prev_editor;
}
prev_editor = editor;
}
}
}
}
////////////////////////////////
// NOTE(allen): Handle events
{
OS_Event *event = 0;
for (;OS_GetNextEvent(&event);){
switch (event->type){
case OS_EventType_CharacterInput:
{
// NOTE(allen): Does the active editor use this key?
if (vars->active_editor != 0 && E_EditorHandleCharacterEvent(vars->active_editor, event)){
goto finished_event;
}
}break;
case OS_EventType_KeyPress:
{
// NOTE(allen): Universal rules
if (event->key == Key_Esc){
vars->active_editor = 0;
OS_EatEvent(event);
goto finished_event;
}
if (vars->active_editor != 0){
// NOTE(allen): Editor override rules
if (((event->modifiers & KeyModifier_Shift) != 0)){
if (event->key == Key_Enter){
APP_TopLevelNavigate(Dimension_Y, Side_Max);
OS_EatEvent(event);
goto finished_event;
}
}
// NOTE(allen): Does the active editor use this key?
if (E_EditorHandleKeyPressEvent(vars->active_editor, event)){
OS_EatEvent(event);
goto finished_event;
}
// NOTE(allen): Navigate between active editors
if (event->key == Key_Up || event->key == Key_Down){
Side side = Side_Min;
if (event->key == Key_Down){
side = Side_Max;
}
APP_TopLevelNavigate(Dimension_Y, side);
OS_EatEvent(event);
goto finished_event;
}
}
}break;
case OS_EventType_MouseMove:
{
vars->mouse_p = event->position;
}break;
}
finished_event:;
}
}
////////////////////////////////
// NOTE(allen): Check for change notifications
if (vars->active_view != 0){
M_Arena *scratch = OS_GetScratch();
M_Temp restore = M_BeginTemp(scratch);
E_View *view = vars->active_view;
for (E_Space *space = vars->first_space_ordered;
space != 0;
space = space->ordered_next){
for (E_Definition *node = space->first_definition_ordered;
node != 0;
node = node->ordered_next){
// NOTE(allen): Check for a change
b32 has_change = 0;
{
E_TokenBuffer *buffer = node->buffers;
for (u64 i = 0; i < ArrayCount(node->buffers); i += 1, buffer += 1){
if (E_TokenBufferHasChange(buffer)){
has_change = 1;
}
}
}
if (has_change){
// NOTE(allen): State Update
if (E_TokenBufferHasChange(&node->name)){
E_DefinitionUpdateValidation(node);
}
// NOTE(allen): Collect tiles that view this definition
E_Tile **tile_ptrs = PushArray(scratch, E_Tile*, 0);
for (E_Tile *tile = view->first_tile;
tile != 0;
tile = tile->next){
if (tile->definition == node){
E_Tile **new_tile_ptr = PushArray(scratch, E_Tile*, 1);
*new_tile_ptr = tile;
}
}
u64 tile_count = (PushArray(scratch, E_Tile*, 0) - tile_ptrs);
// NOTE(allen): Update Buffers
u64 *cursor_array = PushArray(scratch, u64, tile_count);
E_TokenBuffer *buffer = node->buffers;
for (u64 i = 0; i < ArrayCount(node->buffers); i += 1, buffer += 1){
if (E_TokenBufferHasChange(buffer)){
for (u64 j = 0; j < tile_count; j += 1){
cursor_array[j] = tile_ptrs[j]->editors[i].cursor.pos;
}
E_TokenBufferScrub(buffer, cursor_array, tile_count);
E_TokenBufferChangeHandled(buffer);
// NOTE(allen): Update Editors
for (u64 j = 0; j < tile_count; j += 1){
E_EditorState *editor = &tile_ptrs[j]->editors[i];
E_EditorUpdateLayout(editor, tile_ptrs[j]->font);
editor->mark = editor->cursor;
E_EditorUpdatePreferredXToCursor(editor);
}
}
}
// NOTE(allen): Compute Update
E_DefinitionUpdateCompute(node);
// NOTE(allen): Space Dirty
space->dirty = 1;
M_EndTemp(restore);
}
}
}
OS_ReleaseScratch(scratch);
}
////////////////////////////////
// NOTE(allen): Update space validations from available identifiers
for (u64 lim = 0; vars->identifier_available_count > 0 && lim < 2; lim += 1){
u64 count = vars->identifier_available_count;
vars->identifier_available_count = 0;
if (count <= ArrayCount(vars->identifier_available)){
// NOTE(allen): Grab a copy of available so that E_SpaceUpdateValidation can
// signal more available identifiers.
STR_Index available[ArrayCount(vars->identifier_available)];
MemoryCopy(available, vars->identifier_available, sizeof(*available)*count);
for (u64 i = 0; i < count; i += 1){
STR_Index check = available[i];
E_Space *space = E_GetInvalidSpace(check, 0);
if (space != 0){
E_SpaceUpdateValidation(space);
}
}
}
else{
for (E_Space *space = vars->first_invalid_space;
space != 0;
space = space->next){
E_SpaceUpdateValidation(space);
}
}
}
////////////////////////////////
// NOTE(allen): Update definition validations from available identifiers
for (E_Space *space = vars->first_space_ordered;
space != 0;
space = space->ordered_next){
for (u64 lim = 0; space->identifier_available_count > 0 && lim < 2; lim += 1){
u64 count = space->identifier_available_count;
space->identifier_available_count = 0;
if (count <= ArrayCount(space->identifier_available)){
// NOTE(allen): Grab a copy of available so that E_DefinitionUpdateValidation can
// signal more available identifiers.
STR_Index available[ArrayCount(space->identifier_available)];
MemoryCopy(available, space->identifier_available, sizeof(*available)*count);
for (u64 i = 0; i < count; i += 1){
STR_Index check = available[i];
E_Definition *definition = E_GetInvalidDefinition(space, check, 0);
if (definition != 0){
E_DefinitionUpdateValidation(definition);
}
}
}
else{
for (E_Definition *node = space->first_invalid_definition;
node != 0;
node = node->next){
E_DefinitionUpdateValidation(node);
}
}
}
}
////////////////////////////////
// NOTE(allen): Init defers & Populate global defines
{
STR_Hash *string_hash = APP_GetStringHash();
M_Arena *scratch = OS_GetScratch();
C_CellBucket *bucket = &vars->global_defines_bucket;
C_ClearBucket(bucket);
C_Cell *spaces_env = vars->statics.env;
for (E_Space *space = vars->first_space_ordered;
space != 0;
space = space->ordered_next){
if (!space->invalid){
String8 name = E_SpaceName(space);
String8 space_identifier = PushStringCat(scratch, S8Lit("$"), name);
STR_Index space_name = STR_Save(string_hash, space_identifier);
C_Cell *space_cell = C_NewSpaceCell(bucket, space);
spaces_env = C_ExtendEnvironment(bucket, space_name, space_cell, spaces_env);
}
}
vars->spaces_env = spaces_env;
for (E_Space *space = vars->first_space_ordered;
space != 0;
space = space->ordered_next){
C_Cell *env = spaces_env;
C_Cell *id_env = vars->statics.Nil;
C_Cell *id_list = 0;
C_ListBuilder builder = C_InitListBuilder(id_list);
for (E_Definition *node = space->first_definition_ordered;
node != 0;
node = node->ordered_next){
MemoryZeroStruct(&node->deferred);
node->deferred.user_ptr = node;
C_Cell *defer_cell = C_NewDeferredCell(bucket, &node->deferred, node->body_cell);
C_Cell *id_cell = C_NewIdCell(bucket, node->id);
if (!(node->flags & E_DefinitionFlag_Invalid) && E_DefinitionCanEval(node)){
STR_Index name = C_GetIdentifierFromCell(node->name_cell);
env = C_ExtendEnvironment(bucket, name, defer_cell, env);
}
id_env = C_ExtendEnvironment(bucket, node->id, defer_cell, id_env);
C_ListBuilderPush(bucket, builder, id_cell);
}
C_ListBuilderTerminate(&vars->statics, builder);
space->defines_env = env;
space->id_env = id_env;
space->id_list = id_list;
for (E_Definition *node = space->first_definition_ordered;
node != 0;
node = node->ordered_next){
node->deferred.env = env;
}
}
OS_ReleaseScratch(scratch);
}
////////////////////////////////
// NOTE(allen): Render and update editor
{
C_ClearBucket(&vars->eval_bucket);
Rect rect = MakeRectRanges(code_x, code_y);
R_Rect(rect, cl_back_editor, 1.f);
E_Tile *snap_to_tile = vars->snap_to_tile;
b32 found_snap_y = 0;
f32 snap_y = 0;
E_View *view = vars->active_view;
if (view != 0){
Rect restore_clip = R_PushClip(rect);
// NOTE(allen): Height pass
E_Tile *first_tile_crossover = 0;
f32 first_tile_crossover_y = 0;
f32 top = rect.y0 - view->scroll_y;
f32 y = top;
for (E_Tile *tile = view->first_tile;
tile != 0;
tile = tile->next){
f32 h = E_TileUIGetHeight(view, tile, y, code_x);
if (tile == snap_to_tile){
found_snap_y = 1;
snap_y = y + h*0.5f;
}
y += h;
if (first_tile_crossover == 0 && y > rect.y0){
first_tile_crossover = tile;
first_tile_crossover_y = y - h;
}
}
f32 h = y - top;
// NOTE(allen): Scrolling
if (UI_MouseInRect(rect)){
v2 delta = {0};
if (UI_TryEatScroll(&delta)){
view->scroll_y -= delta.y;
}
}
if (found_snap_y){
f32 snap_y_document_space = snap_y - top;
// align the snap with 33% of the way down the view
// solve for scroll_y in: scroll_y + 0.33*view_h = snap_y
view->scroll_y = snap_y_document_space - 0.33f*RangeSize(code_y);
}
f32 max_scroll = h - RangeSize(code_y)*0.5f;
max_scroll = ClampBot(0.f, max_scroll);
view->scroll_y = Clamp(0.f, view->scroll_y, max_scroll);
// NOTE(allen): Action pass
y = first_tile_crossover_y;
for (E_Tile *tile = first_tile_crossover;
tile != 0;
tile = tile->next){
f32 h = E_TileUIUpdateAndRender(view, tile, y, code_x);
y += h;
if (y >= rect.y1 + 500.f){
break;
}
}
R_SetClip(restore_clip);
}
vars->snap_to_tile = 0;
}
////////////////////////////////
// NOTE(allen): Delayed view change
APP_ApplyViewChange(vars->change_view);
////////////////////////////////
// NOTE(allen): Floating Window Post-Update
if (!UI_IdEq(vars->owner_of_floating_window, UI_IdZero())){
APP_SetMouseLayer(floating_window_mouse_layer);
if (vars->floating_window_callback != 0){
R_Rect(MakeRect(0, 0, V2Expand(vars->window_dim)), cl_gray(0.1f), 0.25f);
APP_FloatingWindowResult result = {0};
vars->floating_window_callback(vars->floating_window_ptr, &result);
vars->floating_window_last_frame_rect = result.rect;
}
else{
MemoryZeroStruct(&vars->owner_of_floating_window);
}
}
////////////////////////////////
// NOTE(allen): Tool Tip
if (vars->tool_tip_string.size > 0){
f32 padding = 2.f;
f32 y_skirt[2] = {6.f, 18.f};
f32 dbl_padding = padding*2.f;
String8 str = vars->tool_tip_string;
R_SelectFont(&vars->font);
v2 str_dim = R_StringDim(1.f, str);
v2 str_dim_padded = V2Add(str_dim, v2(dbl_padding, dbl_padding));
f32 y_base = vars->mouse_p.y + y_skirt[Side_Max];
Range y = MakeRange(y_base, y_base + str_dim_padded.y);
if (y.max > vars->window_dim.y){
y_base = vars->mouse_p.y - y_skirt[Side_Min];
y = MakeRange(y_base, y_base - str_dim_padded.y);
}
Range x;
// solve for x in: (x + 0.2*w = mx)
x.min = vars->mouse_p.x - 0.2f*str_dim_padded.x;
x.min = ClampBot(0.f, x.min);
x.max = x.min + str_dim_padded.x;
Rect rect = MakeRectRanges(x, y);
R_Rect(rect, cl_gray(0.1f), 0.66f);
v2 p = V2Add(rect.p0, v2(padding, padding));
R_String(p, 1.f, str, cl_white, 0.66f);
}
////////////////////////////////
// NOTE(allen): End the frame
vars->frame_indx += 1;
{
// NOTE(allen): Why does the layer even keep events from previous frames?
// Anyway, just clear those out.
OS_Event *event = 0;
for (;OS_GetNextEvent(&event);){
OS_EatEvent(event);
}
}
R_End();
AssertIff(vars->active_view == 0, vars->first_view == 0);
_E_AssertGlobalEngineInvariants();
}
Reference in New Issue View Git Blame Copy Permalink