1343 lines
56 KiB
Plaintext
1343 lines
56 KiB
Plaintext
package main
|
|
|
|
import "core:os"
|
|
import "core:path/filepath"
|
|
import "core:math"
|
|
import "core:strings"
|
|
import "core:runtime"
|
|
import "core:fmt"
|
|
import "core:mem"
|
|
import "core:slice"
|
|
import "vendor:sdl2"
|
|
import "vendor:sdl2/ttf"
|
|
|
|
import "core"
|
|
import "theme"
|
|
import "ui"
|
|
import "plugin"
|
|
|
|
State :: core.State;
|
|
FileBuffer :: core.FileBuffer;
|
|
|
|
state := core.State {};
|
|
|
|
StateWithUi :: struct {
|
|
state: ^State,
|
|
ui_context: ^ui.Context,
|
|
}
|
|
|
|
// TODO: use buffer list in state
|
|
do_normal_mode :: proc(state: ^State, buffer: ^FileBuffer) {
|
|
if state.current_input_map != nil {
|
|
// if raylib.IsKeyPressed(.ESCAPE) {
|
|
// core.request_window_close(state);
|
|
// } else if raylib.IsKeyDown(.LEFT_CONTROL) {
|
|
// for key, action in &state.current_input_map.ctrl_key_actions {
|
|
// if raylib.IsKeyPressed(key) {
|
|
// switch value in action.action {
|
|
// case core.PluginEditorAction:
|
|
// value(state.plugin_vtable);
|
|
// case core.EditorAction:
|
|
// value(state);
|
|
// case core.InputMap:
|
|
// state.current_input_map = &(&state.current_input_map.ctrl_key_actions[key]).action.(core.InputMap)
|
|
// }
|
|
// }
|
|
// }
|
|
// } else {
|
|
// for key, action in state.current_input_map.key_actions {
|
|
// if raylib.IsKeyPressed(key) {
|
|
// switch value in action.action {
|
|
// case core.PluginEditorAction:
|
|
// value(state.plugin_vtable);
|
|
// case core.EditorAction:
|
|
// value(state);
|
|
// case core.InputMap:
|
|
// state.current_input_map = &(&state.current_input_map.key_actions[key]).action.(core.InputMap)
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
|
|
// TODO: use buffer list in state
|
|
do_insert_mode :: proc(state: ^State, buffer: ^FileBuffer) {
|
|
key := 0; // raylib.GetCharPressed();
|
|
|
|
for key > 0 {
|
|
if key >= 32 && key <= 125 && len(buffer.input_buffer) < 1024-1 {
|
|
append(&buffer.input_buffer, u8(key));
|
|
|
|
for hook_proc in state.hooks[plugin.Hook.BufferInput] {
|
|
hook_proc(state.plugin_vtable, buffer);
|
|
}
|
|
}
|
|
|
|
key = 0; // raylib.GetCharPressed();
|
|
}
|
|
|
|
// if raylib.IsKeyPressed(.ENTER) {
|
|
// append(&buffer.input_buffer, '\n');
|
|
// }
|
|
|
|
// if raylib.IsKeyPressed(.ESCAPE) {
|
|
// state.mode = .Normal;
|
|
|
|
// core.insert_content(buffer, buffer.input_buffer[:]);
|
|
// runtime.clear(&buffer.input_buffer);
|
|
// return;
|
|
// }
|
|
|
|
// if raylib.IsKeyPressed(.BACKSPACE) {
|
|
// core.delete_content(buffer, 1);
|
|
|
|
// for hook_proc in state.hooks[plugin.Hook.BufferInput] {
|
|
// hook_proc(state.plugin_vtable, buffer);
|
|
// }
|
|
// }
|
|
}
|
|
|
|
// switch_to_buffer :: proc(state: ^State, item: ^ui.MenuBarItem) {
|
|
// for buffer, index in state.buffers {
|
|
// if strings.compare(buffer.file_path, item.text) == 0 {
|
|
// state.current_buffer = index;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
register_default_leader_actions :: proc(input_map: ^core.InputMap) {
|
|
core.register_key_action(input_map, .Q, proc(state: ^State) {
|
|
state.current_input_map = &state.input_map;
|
|
}, "close this help");
|
|
}
|
|
|
|
register_default_go_actions :: proc(input_map: ^core.InputMap) {
|
|
core.register_key_action(input_map, .H, proc(state: ^State) {
|
|
core.move_cursor_start_of_line(&state.buffers[state.current_buffer]);
|
|
state.current_input_map = &state.input_map;
|
|
}, "move to beginning of line");
|
|
core.register_key_action(input_map, .L, proc(state: ^State) {
|
|
core.move_cursor_end_of_line(&state.buffers[state.current_buffer]);
|
|
state.current_input_map = &state.input_map;
|
|
}, "move to end of line");
|
|
}
|
|
|
|
register_default_input_actions :: proc(input_map: ^core.InputMap) {
|
|
// Cursor Movement
|
|
{
|
|
core.register_key_action(input_map, .W, proc(state: ^State) {
|
|
core.move_cursor_forward_start_of_word(&state.buffers[state.current_buffer]);
|
|
}, "move forward one word");
|
|
core.register_key_action(input_map, .E, proc(state: ^State) {
|
|
core.move_cursor_forward_end_of_word(&state.buffers[state.current_buffer]);
|
|
}, "move forward to end of word");
|
|
|
|
core.register_key_action(input_map, .B, proc(state: ^State) {
|
|
core.move_cursor_backward_start_of_word(&state.buffers[state.current_buffer]);
|
|
}, "move backward one word");
|
|
|
|
core.register_key_action(input_map, .K, proc(state: ^State) {
|
|
core.move_cursor_up(&state.buffers[state.current_buffer]);
|
|
}, "move up one line");
|
|
core.register_key_action(input_map, .J, proc(state: ^State) {
|
|
core.move_cursor_down(&state.buffers[state.current_buffer]);
|
|
}, "move down one line");
|
|
core.register_key_action(input_map, .H, proc(state: ^State) {
|
|
core.move_cursor_left(&state.buffers[state.current_buffer]);
|
|
}, "move left one char");
|
|
core.register_key_action(input_map, .L, proc(state: ^State) {
|
|
core.move_cursor_right(&state.buffers[state.current_buffer]);
|
|
}, "move right one char");
|
|
|
|
core.register_ctrl_key_action(input_map, .U, proc(state: ^State) {
|
|
core.scroll_file_buffer(&state.buffers[state.current_buffer], .Up);
|
|
}, "scroll buffer up");
|
|
core.register_ctrl_key_action(input_map, .D, proc(state: ^State) {
|
|
core.scroll_file_buffer(&state.buffers[state.current_buffer], .Down);
|
|
}, "scroll buffer up");
|
|
}
|
|
|
|
// Scale font size
|
|
{
|
|
core.register_ctrl_key_action(input_map, .MINUS, proc(state: ^State) {
|
|
fmt.print("You pressed <C>-MINUS", state.source_font_height, " ");
|
|
if state.source_font_height > 16 {
|
|
state.source_font_height -= 2;
|
|
state.source_font_width = state.source_font_height / 2;
|
|
|
|
state.font_atlas = core.gen_font_atlas(state, "/System/Library/Fonts/Supplemental/Andale Mono.ttf");
|
|
//state.font = raylib.LoadFontEx("/System/Library/Fonts/Supplemental/Andale Mono.ttf", i32(state.source_font_height*2), nil, 0);
|
|
//raylib.SetTextureFilter(state.font.texture, .BILINEAR);
|
|
}
|
|
fmt.println(state.source_font_height);
|
|
}, "increase font size");
|
|
core.register_ctrl_key_action(input_map, .EQUAL, proc(state: ^State) {
|
|
fmt.println("You pressed <C>-EQUAL");
|
|
|
|
state.source_font_height += 2;
|
|
state.source_font_width = state.source_font_height / 2;
|
|
|
|
state.font_atlas = core.gen_font_atlas(state, "/System/Library/Fonts/Supplemental/Andale Mono.ttf");
|
|
//state.font = raylib.LoadFontEx("/System/Library/Fonts/Supplemental/Andale Mono.ttf", i32(state.source_font_height*2), nil, 0);
|
|
//raylib.SetTextureFilter(state.font.texture, .BILINEAR);
|
|
}, "decrease font size");
|
|
}
|
|
|
|
// Inserting Text
|
|
{
|
|
core.register_key_action(input_map, .I, proc(state: ^State) {
|
|
state.mode = .Insert;
|
|
sdl2.StartTextInput();
|
|
}, "enter insert mode");
|
|
core.register_key_action(input_map, .A, proc(state: ^State) {
|
|
core.move_cursor_right(&state.buffers[state.current_buffer], false);
|
|
state.mode = .Insert;
|
|
sdl2.StartTextInput();
|
|
}, "enter insert mode after character (append)");
|
|
}
|
|
|
|
core.register_key_action(input_map, .SPACE, core.new_input_map(), "leader commands");
|
|
register_default_leader_actions(&(&input_map.key_actions[.SPACE]).action.(core.InputMap));
|
|
|
|
core.register_key_action(input_map, .G, core.new_input_map(), "Go commands");
|
|
register_default_go_actions(&(&input_map.key_actions[.G]).action.(core.InputMap));
|
|
}
|
|
|
|
load_plugin :: proc(info: os.File_Info, in_err: os.Errno, state: rawptr) -> (err: os.Errno, skip_dir: bool) {
|
|
state := cast(^State)state;
|
|
|
|
relative_file_path, rel_error := filepath.rel(state.directory, info.fullpath);
|
|
extension := filepath.ext(info.fullpath);
|
|
|
|
if extension == ".dylib" || extension == ".dll" || extension == ".so" {
|
|
if loaded_plugin, succ := plugin.try_load_plugin(info.fullpath); succ {
|
|
append(&state.plugins, loaded_plugin);
|
|
|
|
if rel_error == .None {
|
|
fmt.println("Loaded", relative_file_path);
|
|
} else {
|
|
fmt.println("Loaded", info.fullpath);
|
|
}
|
|
}
|
|
}
|
|
|
|
return in_err, skip_dir;
|
|
}
|
|
|
|
ui_font_width :: proc() -> i32 {
|
|
return i32(state.source_font_width);
|
|
}
|
|
ui_font_height :: proc() -> i32 {
|
|
return i32(state.source_font_height);
|
|
}
|
|
|
|
draw :: proc(state_with_ui: ^StateWithUi) {
|
|
buffer := &state_with_ui.state.buffers[state_with_ui.state.current_buffer];
|
|
|
|
buffer.glyph_buffer_height = math.min(256, int((state_with_ui.state.screen_height - state_with_ui.state.source_font_height*2) / state_with_ui.state.source_font_height)) + 1;
|
|
buffer.glyph_buffer_width = math.min(256, int((state_with_ui.state.screen_width - state_with_ui.state.source_font_width) / state_with_ui.state.source_font_width));
|
|
|
|
// raylib.BeginDrawing();
|
|
// defer raylib.EndDrawing();
|
|
|
|
render_color := theme.get_palette_color(.Background);
|
|
sdl2.SetRenderDrawColor(state_with_ui.state.sdl_renderer, render_color.r, render_color.g, render_color.b, render_color.a);
|
|
sdl2.RenderClear(state_with_ui.state.sdl_renderer);
|
|
|
|
// if state_with_ui.state.window != nil && state_with_ui.state.window.draw != nil {
|
|
// state_with_ui.state.window.draw(state_with_ui.state.plugin_vtable, state_with_ui.state.window.user_data);
|
|
// }
|
|
|
|
ui.compute_layout(state_with_ui.ui_context, { state_with_ui.state.screen_width, state_with_ui.state.screen_height }, state_with_ui.state.source_font_width, state_with_ui.state.source_font_height, state_with_ui.ui_context.root);
|
|
ui.draw(state_with_ui.ui_context, state_with_ui.state, state_with_ui.state.source_font_width, state_with_ui.state.source_font_height, state_with_ui.ui_context.root);
|
|
|
|
if state_with_ui.state.current_input_map != &state_with_ui.state.input_map {
|
|
longest_description := 0;
|
|
for key, action in state_with_ui.state.current_input_map.key_actions {
|
|
if len(action.description) > longest_description {
|
|
longest_description = len(action.description);
|
|
}
|
|
}
|
|
for key, action in state_with_ui.state.current_input_map.ctrl_key_actions {
|
|
if len(action.description) > longest_description {
|
|
longest_description = len(action.description);
|
|
}
|
|
}
|
|
longest_description += 8;
|
|
|
|
helper_height := state_with_ui.state.source_font_height * (len(state_with_ui.state.current_input_map.key_actions) + len(state_with_ui.state.current_input_map.ctrl_key_actions));
|
|
offset_from_bottom := state_with_ui.state.source_font_height * 2;
|
|
|
|
core.draw_rect(
|
|
state_with_ui.state,
|
|
state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width,
|
|
state_with_ui.state.screen_height - helper_height - offset_from_bottom,
|
|
longest_description*state_with_ui.state.source_font_width,
|
|
helper_height,
|
|
.Background2
|
|
);
|
|
//raylib.DrawRectangle(
|
|
// i32(state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width),
|
|
// i32(state_with_ui.state.screen_height - helper_height - offset_from_bottom),
|
|
// i32(longest_description*state_with_ui.state.source_font_width),
|
|
// i32(helper_height),
|
|
// theme.get_palette_raylib_color(.Background2)
|
|
//);
|
|
|
|
index := 0;
|
|
for key, action in state_with_ui.state.current_input_map.key_actions {
|
|
core.draw_text(
|
|
state_with_ui.state,
|
|
fmt.tprintf("%s - %s", key, action.description),
|
|
state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width,
|
|
state_with_ui.state.screen_height - helper_height + index * state_with_ui.state.source_font_height - offset_from_bottom
|
|
);
|
|
|
|
// raylib.DrawTextEx(
|
|
// state_with_ui.state.font,
|
|
// raylib.TextFormat("%s - %s", key, action.description),
|
|
// raylib.Vector2 { f32(state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width), f32(state_with_ui.state.screen_height - helper_height + index * state_with_ui.state.source_font_height - offset_from_bottom) },
|
|
// f32(state_with_ui.state.source_font_height),
|
|
// 0,
|
|
// theme.get_palette_raylib_color(.Foreground1)
|
|
// );
|
|
index += 1;
|
|
}
|
|
for key, action in state_with_ui.state.current_input_map.ctrl_key_actions {
|
|
core.draw_text(
|
|
state_with_ui.state,
|
|
fmt.tprintf("<C>-%s - %s", key, action.description),
|
|
state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width,
|
|
state_with_ui.state.screen_height - helper_height + index * state_with_ui.state.source_font_height - offset_from_bottom
|
|
);
|
|
// raylib.DrawTextEx(
|
|
// state_with_ui.state.font,
|
|
// raylib.TextFormat("<C>-%s - %s", key, action.description),
|
|
// raylib.Vector2 { f32(state_with_ui.state.screen_width - longest_description * state_with_ui.state.source_font_width), f32(state_with_ui.state.screen_height - helper_height + index * state_with_ui.state.source_font_height - offset_from_bottom) },
|
|
// f32(state_with_ui.state.source_font_height),
|
|
// 0,
|
|
// theme.get_palette_raylib_color(.Foreground1)
|
|
// );
|
|
index += 1;
|
|
}
|
|
}
|
|
|
|
sdl2.RenderPresent(state_with_ui.state.sdl_renderer);
|
|
}
|
|
|
|
// TODO: need to wrap state and ui context into one structure so that it can be used in this function
|
|
expose_event_watcher :: proc "c" (state: rawptr, event: ^sdl2.Event) -> i32 {
|
|
if event.type == .WINDOWEVENT {
|
|
state := transmute(^StateWithUi)state;
|
|
context = state.state.ctx;
|
|
|
|
if event.window.event == .EXPOSED {
|
|
//draw(state);
|
|
} else if event.window.event == .SIZE_CHANGED {
|
|
w,h: i32;
|
|
|
|
sdl2.GetRendererOutputSize(state.state.sdl_renderer, &w, &h);
|
|
|
|
state.state.screen_width = int(w);
|
|
state.state.screen_height = int(h);
|
|
state.state.width_dpi_ratio = f32(w) / f32(event.window.data1);
|
|
state.state.height_dpi_ratio = f32(h) / f32(event.window.data2);
|
|
|
|
draw(state);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ui_file_buffer :: proc(ctx: ^ui.Context, buffer: ^FileBuffer) -> ui.Interaction {
|
|
draw_func := proc(state: ^State, box: ^ui.Box, user_data: rawptr) {
|
|
buffer := transmute(^FileBuffer)user_data;
|
|
buffer.glyph_buffer_width = box.computed_size.x / state.source_font_width;
|
|
buffer.glyph_buffer_height = box.computed_size.y / state.source_font_height + 1;
|
|
|
|
core.draw_file_buffer(state, buffer, box.computed_pos.x, box.computed_pos.y);
|
|
};
|
|
|
|
relative_file_path, _ := filepath.rel(state.directory, buffer.file_path, context.temp_allocator)
|
|
ui.push_parent(ctx, ui.push_box(ctx, relative_file_path, {}, .Vertical, semantic_size = {ui.make_semantic_size(.PercentOfParent, 100), ui.make_semantic_size(.Fill, 0)}));
|
|
defer ui.pop_parent(ctx);
|
|
|
|
interaction := ui.custom(ctx, "buffer1", draw_func, transmute(rawptr)buffer);
|
|
|
|
{
|
|
ui.push_parent(ctx, ui.push_box(ctx, "buffer info", {}, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Exact, state.source_font_height)}));
|
|
defer ui.pop_parent(ctx);
|
|
|
|
ui.label(ctx, relative_file_path);
|
|
}
|
|
|
|
return interaction;
|
|
}
|
|
|
|
init_plugin_vtable :: proc(ui_context: ^ui.Context) -> plugin.Plugin {
|
|
return plugin.Plugin {
|
|
state = cast(rawptr)&state,
|
|
register_hook = proc "c" (hook: plugin.Hook, on_hook: plugin.OnHookProc) {
|
|
context = state.ctx;
|
|
|
|
core.add_hook(&state, hook, on_hook);
|
|
},
|
|
register_highlighter = proc "c" (extension: cstring, on_color_buffer: plugin.OnColorBufferProc) {
|
|
context = state.ctx;
|
|
|
|
extension := strings.clone(string(extension));
|
|
|
|
if _, exists := state.highlighters[extension]; exists {
|
|
fmt.eprintln("Highlighter already registered for", extension, "files");
|
|
} else {
|
|
state.highlighters[extension] = on_color_buffer;
|
|
}
|
|
},
|
|
register_input_group = proc "c" (input_map: rawptr, key: plugin.Key, register_group: plugin.InputGroupProc) {
|
|
context = state.ctx;
|
|
|
|
to_be_edited_map: ^core.InputMap = nil;
|
|
|
|
if input_map != nil {
|
|
to_be_edited_map = transmute(^core.InputMap)input_map;
|
|
} else {
|
|
to_be_edited_map = state.current_input_map;
|
|
}
|
|
|
|
if action, exists := to_be_edited_map.key_actions[key]; exists {
|
|
switch value in action.action {
|
|
case core.PluginEditorAction:
|
|
fmt.eprintln("Plugin attempted to register input group on existing key action (added from Plugin)");
|
|
case core.EditorAction:
|
|
fmt.eprintln("Plugin attempted to register input group on existing key action");
|
|
case core.InputMap:
|
|
input_map := &(&to_be_edited_map.key_actions[key]).action.(core.InputMap);
|
|
register_group(state.plugin_vtable, transmute(rawptr)input_map);
|
|
}
|
|
} else {
|
|
core.register_key_action(to_be_edited_map, key, core.new_input_map(), "PLUGIN INPUT GROUP");
|
|
register_group(state.plugin_vtable, &(&to_be_edited_map.key_actions[key]).action.(core.InputMap));
|
|
}
|
|
},
|
|
register_input = proc "c" (input_map: rawptr, key: plugin.Key, input_action: plugin.InputActionProc, description: cstring) {
|
|
context = state.ctx;
|
|
|
|
to_be_edited_map: ^core.InputMap = nil;
|
|
description := strings.clone(string(description));
|
|
|
|
if input_map != nil {
|
|
to_be_edited_map = transmute(^core.InputMap)input_map;
|
|
} else {
|
|
to_be_edited_map = state.current_input_map;
|
|
}
|
|
|
|
if action, exists := to_be_edited_map.key_actions[key]; exists {
|
|
switch value in action.action {
|
|
case core.PluginEditorAction:
|
|
fmt.eprintln("Plugin attempted to register key action on existing key action (added from Plugin)");
|
|
case core.EditorAction:
|
|
fmt.eprintln("Plugin attempted to register input key action on existing key action");
|
|
case core.InputMap:
|
|
fmt.eprintln("Plugin attempted to register input key action on existing input group");
|
|
}
|
|
} else {
|
|
core.register_key_action(to_be_edited_map, key, input_action, description);
|
|
}
|
|
},
|
|
create_window = proc "c" (user_data: rawptr, register_group: plugin.InputGroupProc, draw_proc: plugin.WindowDrawProc, free_window_proc: plugin.WindowFreeProc, get_buffer_proc: plugin.WindowGetBufferProc) -> rawptr {
|
|
context = state.ctx;
|
|
window := new(core.Window);
|
|
window^ = core.Window {
|
|
input_map = core.new_input_map(),
|
|
draw = draw_proc,
|
|
get_buffer = get_buffer_proc,
|
|
free_user_data = free_window_proc,
|
|
|
|
user_data = user_data,
|
|
};
|
|
|
|
register_group(state.plugin_vtable, transmute(rawptr)&window.input_map);
|
|
|
|
state.window = window;
|
|
state.current_input_map = &window.input_map;
|
|
|
|
return window;
|
|
},
|
|
get_window = proc "c" () -> rawptr {
|
|
if state.window != nil {
|
|
return state.window.user_data;
|
|
}
|
|
|
|
return nil;
|
|
},
|
|
request_window_close = proc "c" () {
|
|
context = state.ctx;
|
|
|
|
core.request_window_close(&state);
|
|
},
|
|
get_screen_width = proc "c" () -> int {
|
|
return state.screen_width;
|
|
},
|
|
get_screen_height = proc "c" () -> int {
|
|
return state.screen_height;
|
|
},
|
|
get_font_width = proc "c" () -> int {
|
|
return state.source_font_width;
|
|
},
|
|
get_font_height = proc "c" () -> int {
|
|
return state.source_font_height;
|
|
},
|
|
get_current_directory = proc "c" () -> cstring {
|
|
context = state.ctx;
|
|
|
|
return strings.clone_to_cstring(state.directory, context.temp_allocator);
|
|
},
|
|
enter_insert_mode = proc "c" () {
|
|
state.mode = .Insert;
|
|
sdl2.StartTextInput();
|
|
},
|
|
draw_rect = proc "c" (x: i32, y: i32, width: i32, height: i32, color: theme.PaletteColor) {
|
|
context = state.ctx;
|
|
|
|
core.draw_rect(&state, int(x), int(y), int(width), int(height), color);
|
|
//raylib.DrawRectangle(x, y, width, height, theme.get_palette_raylib_color(color));
|
|
},
|
|
draw_text = proc "c" (text: cstring, x: f32, y: f32, color: theme.PaletteColor) {
|
|
context = state.ctx;
|
|
|
|
core.draw_text(&state, string(text), int(x), int(y), color);
|
|
// for codepoint, index in text {
|
|
// raylib.DrawTextCodepoint(
|
|
// state.font,
|
|
// rune(codepoint),
|
|
// raylib.Vector2 { x + f32(index * state.source_font_width), y },
|
|
// f32(state.source_font_height),
|
|
// theme.get_palette_raylib_color(color)
|
|
// );
|
|
// }
|
|
},
|
|
draw_buffer_from_index = proc "c" (buffer_index: int, x: int, y: int, glyph_buffer_width: int, glyph_buffer_height: int, show_line_numbers: bool) {
|
|
context = state.ctx;
|
|
state.buffers[buffer_index].glyph_buffer_width = glyph_buffer_width;
|
|
state.buffers[buffer_index].glyph_buffer_height = glyph_buffer_height;
|
|
|
|
core.draw_file_buffer(
|
|
&state,
|
|
&state.buffers[buffer_index],
|
|
x,
|
|
y,
|
|
show_line_numbers);
|
|
},
|
|
draw_buffer = proc "c" (buffer: rawptr, x: int, y: int, glyph_buffer_width: int, glyph_buffer_height: int, show_line_numbers: bool) {
|
|
context = state.ctx;
|
|
|
|
buffer := transmute(^core.FileBuffer)buffer;
|
|
buffer.glyph_buffer_width = glyph_buffer_width;
|
|
buffer.glyph_buffer_height = glyph_buffer_height;
|
|
|
|
core.draw_file_buffer(
|
|
&state,
|
|
buffer,
|
|
x,
|
|
y,
|
|
show_line_numbers);
|
|
},
|
|
iter = plugin.Iterator {
|
|
get_current_buffer_iterator = proc "c" () -> plugin.BufferIter {
|
|
context = state.ctx;
|
|
|
|
it := core.new_file_buffer_iter(&state.buffers[state.current_buffer]);
|
|
|
|
// TODO: make this into a function
|
|
return plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
},
|
|
get_buffer_iterator = proc "c" (buffer: rawptr) -> plugin.BufferIter {
|
|
buffer := cast(^core.FileBuffer)buffer;
|
|
context = state.ctx;
|
|
|
|
it := core.new_file_buffer_iter(buffer);
|
|
|
|
// TODO: make this into a function
|
|
return plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
},
|
|
get_char_at_iter = proc "c" (it: ^plugin.BufferIter) -> u8 {
|
|
context = state.ctx;
|
|
|
|
internal_it := core.FileBufferIter {
|
|
cursor = core.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(^core.FileBuffer)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
|
|
return core.get_character_at_iter(internal_it);
|
|
},
|
|
get_buffer_list_iter = proc "c" (prev_buffer: ^int) -> int {
|
|
context = state.ctx;
|
|
|
|
return core.next_buffer(&state, prev_buffer);
|
|
},
|
|
iterate_buffer = proc "c" (it: ^plugin.BufferIter) -> plugin.IterateResult {
|
|
context = state.ctx;
|
|
|
|
// TODO: make this into a function
|
|
internal_it := core.FileBufferIter {
|
|
cursor = core.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(^core.FileBuffer)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
|
|
char, _, cond := core.iterate_file_buffer(&internal_it);
|
|
|
|
it^ = plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = internal_it.cursor.col,
|
|
line = internal_it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = internal_it.cursor.index.slice_index,
|
|
content_index = internal_it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)internal_it.buffer,
|
|
hit_end = internal_it.hit_end,
|
|
};
|
|
|
|
return plugin.IterateResult {
|
|
char = char,
|
|
should_continue = cond,
|
|
};
|
|
},
|
|
iterate_buffer_reverse = proc "c" (it: ^plugin.BufferIter) -> plugin.IterateResult {
|
|
context = state.ctx;
|
|
|
|
// TODO: make this into a function
|
|
internal_it := core.FileBufferIter {
|
|
cursor = core.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(^core.FileBuffer)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
|
|
char, _, cond := core.iterate_file_buffer_reverse(&internal_it);
|
|
|
|
it^ = plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = internal_it.cursor.col,
|
|
line = internal_it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = internal_it.cursor.index.slice_index,
|
|
content_index = internal_it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)internal_it.buffer,
|
|
hit_end = internal_it.hit_end,
|
|
};
|
|
|
|
return plugin.IterateResult {
|
|
char = char,
|
|
should_continue = cond,
|
|
};
|
|
},
|
|
iterate_buffer_until = proc "c" (it: ^plugin.BufferIter, until_proc: rawptr) {
|
|
context = state.ctx;
|
|
|
|
// TODO: make this into a function
|
|
internal_it := core.FileBufferIter {
|
|
cursor = core.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(^core.FileBuffer)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
|
|
core.iterate_file_buffer_until(&internal_it, transmute(core.UntilProc)until_proc);
|
|
|
|
it^ = plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = internal_it.cursor.col,
|
|
line = internal_it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = internal_it.cursor.index.slice_index,
|
|
content_index = internal_it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)internal_it.buffer,
|
|
hit_end = internal_it.hit_end,
|
|
};
|
|
},
|
|
iterate_buffer_peek = proc "c" (it: ^plugin.BufferIter) -> plugin.IterateResult {
|
|
context = state.ctx;
|
|
|
|
// TODO: make this into a function
|
|
internal_it := core.FileBufferIter {
|
|
cursor = core.Cursor {
|
|
col = it.cursor.col,
|
|
line = it.cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = it.cursor.index.slice_index,
|
|
content_index = it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(^core.FileBuffer)it.buffer,
|
|
hit_end = it.hit_end,
|
|
}
|
|
|
|
char, _, cond := core.iterate_peek(&internal_it, core.iterate_file_buffer);
|
|
|
|
it^ = plugin.BufferIter {
|
|
cursor = plugin.Cursor {
|
|
col = internal_it.cursor.col,
|
|
line = internal_it.cursor.line,
|
|
index = plugin.BufferIndex {
|
|
slice_index = internal_it.cursor.index.slice_index,
|
|
content_index = internal_it.cursor.index.content_index,
|
|
}
|
|
},
|
|
buffer = cast(rawptr)internal_it.buffer,
|
|
hit_end = internal_it.hit_end,
|
|
};
|
|
|
|
return plugin.IterateResult {
|
|
char = char,
|
|
should_continue = cond,
|
|
};
|
|
},
|
|
until_line_break = transmute(rawptr)core.until_line_break,
|
|
until_single_quote = transmute(rawptr)core.until_single_quote,
|
|
until_double_quote = transmute(rawptr)core.until_double_quote,
|
|
until_end_of_word = transmute(rawptr)core.until_end_of_word,
|
|
},
|
|
buffer = plugin.Buffer {
|
|
get_num_buffers = proc "c" () -> int {
|
|
context = state.ctx;
|
|
|
|
return len(state.buffers);
|
|
},
|
|
get_buffer_info = proc "c" (buffer: rawptr) -> plugin.BufferInfo {
|
|
context = state.ctx;
|
|
buffer := cast(^core.FileBuffer)buffer;
|
|
|
|
return core.into_buffer_info(&state, buffer);
|
|
},
|
|
get_buffer_info_from_index = proc "c" (buffer_index: int) -> plugin.BufferInfo {
|
|
context = state.ctx;
|
|
buffer := &state.buffers[buffer_index];
|
|
|
|
return core.into_buffer_info(&state, buffer);
|
|
},
|
|
color_char_at = proc "c" (buffer: rawptr, start_cursor: plugin.Cursor, end_cursor: plugin.Cursor, palette_index: i32) {
|
|
buffer := cast(^core.FileBuffer)buffer;
|
|
context = state.ctx;
|
|
|
|
start_cursor := core.Cursor {
|
|
col = start_cursor.col,
|
|
line = start_cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = start_cursor.index.slice_index,
|
|
content_index = start_cursor.index.content_index,
|
|
}
|
|
};
|
|
end_cursor := core.Cursor {
|
|
col = end_cursor.col,
|
|
line = end_cursor.line,
|
|
index = core.FileBufferIndex {
|
|
slice_index = end_cursor.index.slice_index,
|
|
content_index = end_cursor.index.content_index,
|
|
}
|
|
};
|
|
|
|
core.color_character(buffer, start_cursor, end_cursor, cast(theme.PaletteColor)palette_index);
|
|
},
|
|
set_current_buffer = proc "c" (buffer_index: int) {
|
|
state.current_buffer = buffer_index;
|
|
},
|
|
open_buffer = proc "c" (path: cstring, line: int, col: int) {
|
|
context = state.ctx;
|
|
|
|
path := string(path);
|
|
should_create_buffer := true;
|
|
for buffer, index in state.buffers {
|
|
if strings.compare(buffer.file_path, path) == 0 {
|
|
state.current_buffer = index;
|
|
should_create_buffer = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
buffer: ^core.FileBuffer = nil;
|
|
err := core.no_error();
|
|
|
|
if should_create_buffer {
|
|
new_buffer, err := core.new_file_buffer(context.allocator, strings.clone(path));
|
|
if err.type != .None {
|
|
fmt.println("Failed to open/create file buffer:", err);
|
|
} else {
|
|
runtime.append(&state.buffers, new_buffer);
|
|
state.current_buffer = len(state.buffers)-1;
|
|
buffer = &state.buffers[state.current_buffer];
|
|
}
|
|
} else {
|
|
buffer = &state.buffers[state.current_buffer];
|
|
}
|
|
|
|
if buffer != nil {
|
|
buffer.cursor.line = line;
|
|
buffer.cursor.col = col;
|
|
buffer.glyph_buffer_height = math.min(256, int((state.screen_height - state.source_font_height*2) / state.source_font_height)) + 1;
|
|
buffer.glyph_buffer_width = math.min(256, int((state.screen_width - state.source_font_width) / state.source_font_width));
|
|
core.update_file_buffer_index_from_cursor(buffer);
|
|
}
|
|
},
|
|
open_virtual_buffer = proc "c" () -> rawptr {
|
|
context = state.ctx;
|
|
|
|
buffer := new(FileBuffer);
|
|
buffer^ = core.new_virtual_file_buffer(context.allocator);
|
|
|
|
return buffer;
|
|
},
|
|
free_virtual_buffer = proc "c" (buffer: rawptr) {
|
|
context = state.ctx;
|
|
|
|
if buffer != nil {
|
|
buffer := cast(^core.FileBuffer)buffer;
|
|
|
|
core.free_file_buffer(buffer);
|
|
free(buffer);
|
|
}
|
|
},
|
|
},
|
|
ui = plugin.Ui {
|
|
ui_context = ui_context,
|
|
|
|
push_parent = proc "c" (ui_context: rawptr, box: plugin.UiBox) {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
box := transmute(^ui.Box)box;
|
|
|
|
ui.push_parent(ui_context, box);
|
|
},
|
|
|
|
pop_parent = proc "c" (ui_context: rawptr) {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
|
|
ui.pop_parent(ui_context);
|
|
},
|
|
|
|
spacer = proc "c" (ui_context: rawptr, label: cstring) -> plugin.UiInteraction {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
label := strings.clone(string(label), context.temp_allocator);
|
|
|
|
interaction := ui.spacer(ui_context, label);
|
|
|
|
return plugin.UiInteraction {
|
|
hovering = interaction.hovering,
|
|
clicked = interaction.clicked,
|
|
};
|
|
},
|
|
// TODO: allow this to have more flags sent to it
|
|
floating = proc "c" (ui_context: rawptr, label: cstring, pos: [2]int) -> plugin.UiBox {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
label := strings.clone(string(label), context.temp_allocator);
|
|
|
|
return ui.push_floating(ui_context, label, pos);
|
|
},
|
|
rect = proc "c" (ui_context: rawptr, label: cstring, background: bool, border: bool, axis: plugin.UiAxis, size: [2]plugin.UiSemanticSize) -> plugin.UiBox {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
label := strings.clone(string(label), context.temp_allocator);
|
|
|
|
size := [2]ui.SemanticSize {
|
|
ui.SemanticSize {
|
|
kind = ui.SemanticSizeKind(size.x.kind),
|
|
value = size.x.value,
|
|
},
|
|
ui.SemanticSize {
|
|
kind = ui.SemanticSizeKind(size.y.kind),
|
|
value = size.y.value,
|
|
},
|
|
};
|
|
|
|
return ui.push_rect(ui_context, label, background, border, ui.Axis(axis), size);
|
|
},
|
|
|
|
label = proc "c" (ui_context: rawptr, label: cstring) -> plugin.UiInteraction {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
label := strings.clone(string(label), context.temp_allocator);
|
|
|
|
interaction := ui.label(ui_context, label);
|
|
|
|
return plugin.UiInteraction {
|
|
hovering = interaction.hovering,
|
|
clicked = interaction.clicked,
|
|
};
|
|
},
|
|
button = proc "c" (ui_context: rawptr, label: cstring) -> plugin.UiInteraction {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
label := strings.clone(string(label), context.temp_allocator);
|
|
|
|
interaction := ui.button(ui_context, label);
|
|
|
|
return plugin.UiInteraction {
|
|
hovering = interaction.hovering,
|
|
clicked = interaction.clicked,
|
|
};
|
|
},
|
|
buffer = proc "c" (ui_context: rawptr, buffer: rawptr, show_line_numbers: bool) {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
buffer := transmute(^FileBuffer)buffer;
|
|
|
|
ui_file_buffer(ui_context, buffer);
|
|
},
|
|
|
|
buffer_from_index = proc "c" (ui_context: rawptr, buffer: int, show_line_numbers: bool) {
|
|
context = state.ctx;
|
|
ui_context := transmute(^ui.Context)ui_context;
|
|
|
|
buffer := &state.buffers[buffer];
|
|
|
|
ui_file_buffer(ui_context, buffer);
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
main :: proc() {
|
|
state = State {
|
|
ctx = context,
|
|
screen_width = 640,
|
|
screen_height = 480,
|
|
source_font_width = 8,
|
|
source_font_height = 16,
|
|
input_map = core.new_input_map(),
|
|
window = nil,
|
|
directory = os.get_current_directory(),
|
|
plugins = make([dynamic]plugin.Interface),
|
|
highlighters = make(map[string]plugin.OnColorBufferProc),
|
|
hooks = make(map[plugin.Hook][dynamic]plugin.OnHookProc),
|
|
};
|
|
|
|
state.current_input_map = &state.input_map;
|
|
register_default_input_actions(&state.input_map);
|
|
|
|
for arg in os.args[1:] {
|
|
buffer, err := core.new_file_buffer(context.allocator, arg, state.directory);
|
|
if err.type != .None {
|
|
fmt.println("Failed to create file buffer:", err);
|
|
continue;
|
|
}
|
|
|
|
runtime.append(&state.buffers, buffer);
|
|
}
|
|
|
|
if sdl2.Init({.VIDEO}) < 0 {
|
|
fmt.eprintln("SDL failed to initialize:", sdl2.GetError());
|
|
return;
|
|
}
|
|
|
|
if ttf.Init() < 0 {
|
|
fmt.eprintln("SDL_TTF failed to initialize:", ttf.GetError());
|
|
return;
|
|
}
|
|
defer ttf.Quit();
|
|
|
|
sdl_window := sdl2.CreateWindow(
|
|
"odin_editor - [now with more ui]",
|
|
sdl2.WINDOWPOS_UNDEFINED,
|
|
0,
|
|
640,
|
|
480,
|
|
{.SHOWN, .RESIZABLE, .ALLOW_HIGHDPI}
|
|
);
|
|
defer if sdl_window != nil {
|
|
sdl2.DestroyWindow(sdl_window);
|
|
}
|
|
|
|
if sdl_window == nil {
|
|
fmt.eprintln("Failed to create window:", sdl2.GetError());
|
|
return;
|
|
}
|
|
|
|
state.sdl_renderer = sdl2.CreateRenderer(sdl_window, -1, {.ACCELERATED, .PRESENTVSYNC});
|
|
defer if state.sdl_renderer != nil {
|
|
sdl2.DestroyRenderer(state.sdl_renderer);
|
|
}
|
|
|
|
if state.sdl_renderer == nil {
|
|
fmt.eprintln("Failed to create renderer:", sdl2.GetError());
|
|
return;
|
|
}
|
|
state.font_atlas = core.gen_font_atlas(&state, "/System/Library/Fonts/Supplemental/Andale Mono.ttf");
|
|
defer {
|
|
if state.font_atlas.font != nil {
|
|
ttf.CloseFont(state.font_atlas.font);
|
|
}
|
|
if state.font_atlas.texture != nil {
|
|
sdl2.DestroyTexture(state.font_atlas.texture);
|
|
}
|
|
}
|
|
|
|
{
|
|
w,h: i32;
|
|
sdl2.GetRendererOutputSize(state.sdl_renderer, &w, &h);
|
|
|
|
state.width_dpi_ratio = f32(w) / f32(state.screen_width);
|
|
state.height_dpi_ratio = f32(h) / f32(state.screen_height);
|
|
state.screen_width = int(w);
|
|
state.screen_height = int(h);
|
|
}
|
|
|
|
// Done to clear the buffer
|
|
sdl2.StartTextInput();
|
|
sdl2.StopTextInput();
|
|
|
|
ui_context := ui.init(state.sdl_renderer);
|
|
sdl2.AddEventWatch(expose_event_watcher, &StateWithUi { &state, &ui_context });
|
|
state.plugin_vtable = init_plugin_vtable(&ui_context);
|
|
|
|
// Load plugins
|
|
// TODO(pcleavelin): Get directory of binary instead of shells current working directory
|
|
filepath.walk(filepath.join({ os.get_current_directory(), "bin" }), load_plugin, transmute(rawptr)&state);
|
|
|
|
for plugin in state.plugins {
|
|
if plugin.on_initialize != nil {
|
|
plugin.on_initialize(state.plugin_vtable);
|
|
}
|
|
}
|
|
|
|
control_key_pressed: bool;
|
|
for !state.should_close {
|
|
{
|
|
buffer := &state.buffers[state.current_buffer];
|
|
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "main", {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill, 100), ui.make_semantic_size(.Fill, 100)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "top_nav", {.DrawBackground}, semantic_size = {ui.make_semantic_size(.PercentOfParent, 100), ui.make_semantic_size(.Exact, state.source_font_height)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
if ui.label(&ui_context, "Editor").clicked {
|
|
fmt.println("you clicked the button");
|
|
}
|
|
|
|
ui.push_box(
|
|
&ui_context,
|
|
"nav spacer",
|
|
{.DrawBackground},
|
|
semantic_size = {
|
|
ui.make_semantic_size(.Exact, 16),
|
|
ui.make_semantic_size(.Exact, state.source_font_height)
|
|
}
|
|
);
|
|
|
|
if ui.label(&ui_context, "Buffers").clicked {
|
|
fmt.println("you clicked the button");
|
|
}
|
|
}
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "deezbuffer", {}, .Horizontal, semantic_size = {ui.make_semantic_size(.PercentOfParent, 100), ui.make_semantic_size(.Fill, 0)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "left side", {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Fill, 0)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
{
|
|
if ui_file_buffer(&ui_context, &state.buffers[0]).clicked {
|
|
state.current_buffer = 0;
|
|
}
|
|
}
|
|
{
|
|
if ui_file_buffer(&ui_context, &state.buffers[0+1]).clicked {
|
|
state.current_buffer = 1;
|
|
}
|
|
}
|
|
{
|
|
if ui_file_buffer(&ui_context, &state.buffers[0+2]).clicked {
|
|
state.current_buffer = 2;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "right side", {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Fill, 0)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
{
|
|
if ui_file_buffer(&ui_context, &state.buffers[state.current_buffer]).clicked {
|
|
state.current_buffer = 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "bottom stats", {.DrawBackground}, semantic_size = {ui.make_semantic_size(.PercentOfParent, 100), ui.make_semantic_size(.Exact, state.source_font_height)}));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
label := "";
|
|
if state.mode == .Insert {
|
|
label = "INSERT";
|
|
} else if state.mode == .Normal {
|
|
label = "NORMAL";
|
|
}
|
|
|
|
if ui.label(&ui_context, label).clicked {
|
|
fmt.println("you clicked the button");
|
|
}
|
|
ui.spacer(&ui_context, "mode spacer", semantic_size = {ui.make_semantic_size(.Exact, 16), ui.make_semantic_size(.Fill)});
|
|
|
|
relative_file_path, _ := filepath.rel(state.directory, buffer.file_path, context.temp_allocator)
|
|
ui.label(&ui_context, relative_file_path);
|
|
|
|
ui.spacer(&ui_context, "stats inbetween");
|
|
|
|
{
|
|
ui.push_parent(&ui_context, ui.push_box(&ui_context, "center info", {}, semantic_size = ui.ChildrenSum));
|
|
defer ui.pop_parent(&ui_context);
|
|
|
|
line_info_text := fmt.tprintf(
|
|
//"Line: %d, Col: %d, Len: %d --- Slice Index: %d, Content Index: %d",
|
|
"Line: %d, Col: %d",
|
|
buffer.cursor.line + 1,
|
|
buffer.cursor.col + 1,
|
|
//core.file_buffer_line_length(buffer, buffer.cursor.index),
|
|
// buffer.cursor.index.slice_index,
|
|
// buffer.cursor.index.content_index,
|
|
);
|
|
ui.label(&ui_context, line_info_text);
|
|
|
|
mouse_pos_str := fmt.tprintf("x,y: [%d,%d]", ui_context.mouse_x, ui_context.mouse_y);
|
|
ui.label(&ui_context, mouse_pos_str);
|
|
}
|
|
|
|
//ui.spacer(&ui_context, "frame time spacer");
|
|
//frame_time := (60.0/f32(raylib.GetFPS())) * 10;
|
|
//frame_time_text := raylib.TextFormat("frame time: %fms", frame_time);
|
|
//ui.label(&ui_context, "lol have to figure out how to get the frame time");
|
|
}
|
|
}
|
|
|
|
if state.window != nil && state.window.draw != nil {
|
|
state.window.draw(state.plugin_vtable, state.window.user_data);
|
|
}
|
|
|
|
{
|
|
ui_context.last_mouse_left_down = ui_context.mouse_left_down;
|
|
ui_context.last_mouse_right_down = ui_context.mouse_right_down;
|
|
|
|
sdl_event: sdl2.Event;
|
|
for(sdl2.PollEvent(&sdl_event)) {
|
|
if sdl_event.type == .QUIT {
|
|
state.should_close = true;
|
|
}
|
|
|
|
if sdl_event.type == .MOUSEMOTION {
|
|
ui_context.mouse_x = int(f32(sdl_event.motion.x) * state.width_dpi_ratio);
|
|
ui_context.mouse_y = int(f32(sdl_event.motion.y) * state.height_dpi_ratio);
|
|
}
|
|
|
|
if sdl_event.type == .MOUSEBUTTONDOWN || sdl_event.type == .MOUSEBUTTONUP {
|
|
event := sdl_event.button;
|
|
|
|
if event.button == sdl2.BUTTON_LEFT {
|
|
ui_context.mouse_left_down = sdl_event.type == .MOUSEBUTTONDOWN;
|
|
}
|
|
if event.button == sdl2.BUTTON_RIGHT {
|
|
ui_context.mouse_left_down = sdl_event.type == .MOUSEBUTTONDOWN;
|
|
}
|
|
}
|
|
|
|
switch state.mode {
|
|
case .Normal: {
|
|
if sdl_event.type == .KEYDOWN {
|
|
key := plugin.Key(sdl_event.key.keysym.sym);
|
|
if key == .ESCAPE {
|
|
core.request_window_close(&state);
|
|
}
|
|
|
|
if key == .LCTRL {
|
|
control_key_pressed = true;
|
|
} else if state.current_input_map != nil {
|
|
if control_key_pressed {
|
|
if action, exists := state.current_input_map.ctrl_key_actions[key]; exists {
|
|
switch value in action.action {
|
|
case core.PluginEditorAction:
|
|
value(state.plugin_vtable);
|
|
case core.EditorAction:
|
|
value(&state);
|
|
case core.InputMap:
|
|
state.current_input_map = &(&state.current_input_map.ctrl_key_actions[key]).action.(core.InputMap)
|
|
}
|
|
}
|
|
} else {
|
|
if action, exists := state.current_input_map.key_actions[key]; exists {
|
|
switch value in action.action {
|
|
case core.PluginEditorAction:
|
|
value(state.plugin_vtable);
|
|
case core.EditorAction:
|
|
value(&state);
|
|
case core.InputMap:
|
|
state.current_input_map = &(&state.current_input_map.key_actions[key]).action.(core.InputMap)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if sdl_event.type == .KEYUP {
|
|
key := plugin.Key(sdl_event.key.keysym.sym);
|
|
if key == .LCTRL {
|
|
control_key_pressed = false;
|
|
}
|
|
}
|
|
}
|
|
case .Insert: {
|
|
buffer: ^FileBuffer;
|
|
|
|
if state.window != nil && state.window.get_buffer != nil {
|
|
buffer = transmute(^core.FileBuffer)(state.window.get_buffer(state.plugin_vtable, state.window.user_data));
|
|
} else {
|
|
buffer = &state.buffers[state.current_buffer];
|
|
}
|
|
|
|
if sdl_event.type == .KEYDOWN {
|
|
key := plugin.Key(sdl_event.key.keysym.sym);
|
|
|
|
#partial switch key {
|
|
case .ESCAPE: {
|
|
state.mode = .Normal;
|
|
|
|
core.insert_content(buffer, buffer.input_buffer[:]);
|
|
runtime.clear(&buffer.input_buffer);
|
|
|
|
sdl2.StopTextInput();
|
|
}
|
|
case .BACKSPACE: {
|
|
core.delete_content(buffer, 1);
|
|
|
|
for hook_proc in state.hooks[plugin.Hook.BufferInput] {
|
|
hook_proc(state.plugin_vtable, buffer);
|
|
}
|
|
}
|
|
case .ENTER: {
|
|
append(&buffer.input_buffer, '\n');
|
|
}
|
|
}
|
|
}
|
|
|
|
if sdl_event.type == .TEXTINPUT {
|
|
for char in sdl_event.text.text {
|
|
if char < 1 {
|
|
break;
|
|
}
|
|
|
|
if char >= 32 && char <= 125 && len(buffer.input_buffer) < 1024-1 {
|
|
append(&buffer.input_buffer, u8(char));
|
|
|
|
for hook_proc in state.hooks[plugin.Hook.BufferInput] {
|
|
hook_proc(state.plugin_vtable, buffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ui.debug_print();
|
|
|
|
draw(&StateWithUi { &state, &ui_context });
|
|
|
|
ui.prune(&ui_context);
|
|
|
|
switch state.mode {
|
|
case .Normal:
|
|
if state.window != nil && state.window.get_buffer != nil {
|
|
buffer := transmute(^core.FileBuffer)(state.window.get_buffer(state.plugin_vtable, state.window.user_data));
|
|
do_normal_mode(&state, buffer);
|
|
} else {
|
|
buffer := &state.buffers[state.current_buffer];
|
|
do_normal_mode(&state, buffer);
|
|
}
|
|
case .Insert:
|
|
if state.window != nil && state.window.get_buffer != nil {
|
|
buffer := transmute(^core.FileBuffer)(state.window.get_buffer(state.plugin_vtable, state.window.user_data));
|
|
do_insert_mode(&state, buffer);
|
|
} else {
|
|
buffer := &state.buffers[state.current_buffer];
|
|
do_insert_mode(&state, buffer);
|
|
}
|
|
}
|
|
|
|
if state.should_close_window {
|
|
state.should_close_window = false;
|
|
core.close_window_and_free(&state);
|
|
}
|
|
|
|
runtime.free_all(context.temp_allocator);
|
|
}
|
|
|
|
for plugin in state.plugins {
|
|
if plugin.on_exit != nil {
|
|
plugin.on_exit();
|
|
}
|
|
}
|
|
|
|
sdl2.Quit();
|
|
}
|