926 lines
32 KiB
Plaintext
926 lines
32 KiB
Plaintext
package lua
|
|
|
|
import "core:os"
|
|
import "core:fmt"
|
|
import "core:strings"
|
|
import "core:log"
|
|
import "core:path/filepath"
|
|
|
|
import core "../core"
|
|
import plugin "../plugin"
|
|
import ui "../ui"
|
|
|
|
import lua "vendor:lua/5.4"
|
|
|
|
state: ^core.State = nil
|
|
|
|
new_state :: proc(_state: ^core.State) {
|
|
state = _state
|
|
|
|
state.L = lua.L_newstate();
|
|
lua.L_openlibs(state.L);
|
|
|
|
bbb: [^]lua.L_Reg;
|
|
editor_lib := [?]lua.L_Reg {
|
|
lua.L_Reg {
|
|
"quit",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
|
|
state.should_close = true;
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"log",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
text := string(lua.L_checkstring(L, 1));
|
|
log.info("[LUA]:", text);
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"register_hook",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
hook := lua.L_checkinteger(L, 1);
|
|
|
|
lua.L_checktype(L, 2, i32(lua.TFUNCTION));
|
|
lua.pushvalue(L, 2);
|
|
fn_ref := lua.L_ref(L, i32(lua.REGISTRYINDEX));
|
|
|
|
core.add_lua_hook(state, plugin.Hook(hook), fn_ref);
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"register_key_group",
|
|
register_key_group,
|
|
},
|
|
lua.L_Reg {
|
|
"spawn_floating_window",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
core.close_window_and_free(state);
|
|
|
|
window_input_map := core.new_input_actions();
|
|
lua.L_checktype(L, 1, i32(lua.TTABLE));
|
|
table_to_action(L, 1, &window_input_map);
|
|
|
|
lua.L_checktype(L, 2, i32(lua.TFUNCTION));
|
|
lua.pushvalue(L, 2);
|
|
fn_ref := lua.L_ref(L, i32(lua.REGISTRYINDEX));
|
|
|
|
state.new_window = core.NewWindow {
|
|
input_map = window_input_map,
|
|
lua_draw_proc = fn_ref
|
|
}
|
|
state.current_input_map = &(&state.new_window.?).input_map
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"request_window_close",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
core.request_window_close(state);
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"get_current_buffer_index",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.pushinteger(L, lua.Integer(state.current_buffer));
|
|
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"set_current_buffer_from_index",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
buffer_index := int(lua.L_checkinteger(L, 1));
|
|
if buffer_index != -2 && (buffer_index < 0 || buffer_index >= len(state.buffers)) {
|
|
return i32(lua.ERRRUN);
|
|
} else {
|
|
state.current_buffer = buffer_index;
|
|
}
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"buffer_info_from_index",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
buffer_index := int(lua.L_checkinteger(L, 1));
|
|
if buffer_index < 0 || buffer_index >= len(state.buffers) {
|
|
lua.pushnil(L);
|
|
} else {
|
|
push_lua_buffer_info :: proc(L: ^lua.State, buffer: ^core.FileBuffer) {
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushlightuserdata(L, buffer);
|
|
lua.setfield(L, -2, "buffer");
|
|
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushinteger(L, lua.Integer(buffer.cursor.col));
|
|
lua.setfield(L, -2, "col");
|
|
|
|
lua.pushinteger(L, lua.Integer(buffer.cursor.line));
|
|
lua.setfield(L, -2, "line");
|
|
}
|
|
lua.setfield(L, -2, "cursor");
|
|
|
|
lua.pushstring(L, strings.clone_to_cstring(buffer.file_path, context.temp_allocator));
|
|
lua.setfield(L, -2, "full_file_path");
|
|
|
|
relative_file_path, _ := filepath.rel(state.directory, buffer.file_path, context.temp_allocator)
|
|
lua.pushstring(L, strings.clone_to_cstring(relative_file_path, context.temp_allocator));
|
|
lua.setfield(L, -2, "file_path");
|
|
}
|
|
}
|
|
|
|
push_lua_buffer_info(L, core.buffer_from_index(state, buffer_index));
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"query_command_group",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
group := lua.L_checkstring(L, 1);
|
|
cmds := core.query_editor_commands_by_group(&state.commands, string(group), context.temp_allocator);
|
|
|
|
lua.newtable(L);
|
|
{
|
|
for cmd, i in cmds {
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushstring(L, strings.clone_to_cstring(cmd.name, context.temp_allocator));
|
|
lua.setfield(L, -2, "name");
|
|
|
|
lua.pushstring(L, strings.clone_to_cstring(cmd.description, context.temp_allocator));
|
|
lua.setfield(L, -2, "description");
|
|
}
|
|
lua.rawseti(L, -2, lua.Integer(i+1));
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"run_command",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
group := lua.L_checkstring(L, 1);
|
|
name := lua.L_checkstring(L, 2);
|
|
core.run_command(state, string(group), string(name));
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
};
|
|
bbb = raw_data(editor_lib[:]);
|
|
|
|
get_lua_semantic_size :: proc(L: ^lua.State, index: i32) -> ui.SemanticSize {
|
|
if lua.istable(L, index) {
|
|
lua.rawgeti(L, index, 1);
|
|
semantic_kind := ui.SemanticSizeKind(lua.tointeger(L, -1));
|
|
lua.pop(L, 1);
|
|
|
|
lua.rawgeti(L, index, 2);
|
|
semantic_value := int(lua.tointeger(L, -1));
|
|
lua.pop(L, 1);
|
|
|
|
return {semantic_kind, semantic_value};
|
|
} else {
|
|
semantic_kind := ui.SemanticSizeKind(lua.L_checkinteger(L, index));
|
|
return {semantic_kind, 0};
|
|
}
|
|
}
|
|
|
|
push_lua_semantic_size_table :: proc(L: ^lua.State, size: ui.SemanticSize) {
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushinteger(L, lua.Integer(i32(size.kind)));
|
|
lua.rawseti(L, -2, 1);
|
|
|
|
lua.pushinteger(L, lua.Integer(size.value));
|
|
lua.rawseti(L, -2, 2);
|
|
}
|
|
}
|
|
|
|
push_lua_box_interaction :: proc(L: ^lua.State, interaction: ui.Interaction) {
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushboolean(L, b32(interaction.clicked));
|
|
lua.setfield(L, -2, "clicked");
|
|
|
|
lua.pushboolean(L, b32(interaction.hovering));
|
|
lua.setfield(L, -2, "hovering");
|
|
|
|
lua.pushboolean(L, b32(interaction.dragging));
|
|
lua.setfield(L, -2, "dragging");
|
|
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushinteger(L, lua.Integer(interaction.box_pos.x));
|
|
lua.setfield(L, -2, "x");
|
|
|
|
lua.pushinteger(L, lua.Integer(interaction.box_pos.y));
|
|
lua.setfield(L, -2, "y");
|
|
}
|
|
lua.setfield(L, -2, "box_pos");
|
|
|
|
lua.newtable(L);
|
|
{
|
|
lua.pushinteger(L, lua.Integer(interaction.box_size.x));
|
|
lua.setfield(L, -2, "x");
|
|
|
|
lua.pushinteger(L, lua.Integer(interaction.box_size.y));
|
|
lua.setfield(L, -2, "y");
|
|
}
|
|
lua.setfield(L, -2, "box_size");
|
|
}
|
|
}
|
|
|
|
ui_lib := [?]lua.L_Reg {
|
|
lua.L_Reg {
|
|
"get_mouse_pos",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx == nil { return i32(lua.ERRRUN); }
|
|
|
|
lua.pushinteger(L, lua.Integer(ui_ctx.mouse_x));
|
|
lua.pushinteger(L, lua.Integer(ui_ctx.mouse_y));
|
|
|
|
return 2;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"Exact",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
value := lua.L_checknumber(L, 1);
|
|
push_lua_semantic_size_table(L, { ui.SemanticSizeKind.Exact, int(value) });
|
|
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"PercentOfParent",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
value := lua.L_checknumber(L, 1);
|
|
push_lua_semantic_size_table(L, { ui.SemanticSizeKind.PercentOfParent, int(value) });
|
|
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"push_parent",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx == nil { return i32(lua.ERRRUN); }
|
|
|
|
lua.L_checktype(L, 2, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 2);
|
|
box := transmute(^ui.Box)lua.touserdata(L, -1);
|
|
if box == nil { return i32(lua.ERRRUN); }
|
|
|
|
ui.push_parent(ui_ctx, box);
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"pop_parent",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx == nil { return i32(lua.ERRRUN); }
|
|
|
|
ui.pop_parent(ui_ctx);
|
|
return i32(lua.OK);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"push_floating",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
x := int(lua.L_checkinteger(L, 3));
|
|
y := int(lua.L_checkinteger(L, 4));
|
|
|
|
box, interaction := ui.push_floating(ui_ctx, strings.clone(string(label), context.temp_allocator), {x,y});
|
|
lua.pushlightuserdata(L, box);
|
|
push_lua_box_interaction(L, interaction);
|
|
return 2;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"push_box",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
flags, err := ui_flags(L, 3);
|
|
axis := ui.Axis(lua.L_checkinteger(L, 4));
|
|
|
|
semantic_width := get_lua_semantic_size(L, 5);
|
|
semantic_height := get_lua_semantic_size(L, 6);
|
|
|
|
box, interaction := ui.push_box(ui_ctx, strings.clone(string(label), context.temp_allocator), flags, axis, { semantic_width, semantic_height });
|
|
|
|
lua.pushlightuserdata(L, box);
|
|
push_lua_box_interaction(L, interaction)
|
|
return 2;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"_box_interaction",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx == nil { return i32(lua.ERRRUN); }
|
|
|
|
lua.L_checktype(L, 2, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 2);
|
|
box := transmute(^ui.Box)lua.touserdata(L, -1);
|
|
if box == nil { return i32(lua.ERRRUN); }
|
|
|
|
interaction := ui.test_box(ui_ctx, box);
|
|
push_lua_box_interaction(L, interaction)
|
|
return 1;
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"push_box",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
flags, err := ui_flags(L, 3);
|
|
axis := ui.Axis(lua.L_checkinteger(L, 4));
|
|
|
|
semantic_width := get_lua_semantic_size(L, 5);
|
|
semantic_height := get_lua_semantic_size(L, 6);
|
|
|
|
box, interaction := ui.push_box(ui_ctx, strings.clone(string(label), context.temp_allocator), flags, axis, { semantic_width, semantic_height });
|
|
lua.pushlightuserdata(L, box);
|
|
push_lua_box_interaction(L, interaction)
|
|
return 2;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"push_rect",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
background := bool(lua.toboolean(L, 3));
|
|
border := bool(lua.toboolean(L, 4));
|
|
axis := ui.Axis(lua.L_checkinteger(L, 5));
|
|
|
|
semantic_width := get_lua_semantic_size(L, 6);
|
|
semantic_height := get_lua_semantic_size(L, 7);
|
|
|
|
box, interaction := ui.push_rect(ui_ctx, strings.clone(string(label), context.temp_allocator), background, border, axis, { semantic_width, semantic_height });
|
|
lua.pushlightuserdata(L, box);
|
|
push_lua_box_interaction(L, interaction)
|
|
return 2;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"spacer",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
|
|
interaction := ui.spacer(ui_ctx, strings.clone(string(label), context.temp_allocator), semantic_size = {{.Fill, 0}, {.Fill, 0}});
|
|
|
|
push_lua_box_interaction(L, interaction)
|
|
|
|
return 1;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"label",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
|
|
interaction := ui.label(ui_ctx, strings.clone(string(label), context.temp_allocator));
|
|
push_lua_box_interaction(L, interaction)
|
|
|
|
return 1;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"button",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
|
|
interaction := ui.button(ui_ctx, strings.clone(string(label), context.temp_allocator));
|
|
push_lua_box_interaction(L, interaction)
|
|
|
|
return 1;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"advanced_button",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
|
|
if ui_ctx != nil {
|
|
label := lua.L_checkstring(L, 2);
|
|
flags, err := ui_flags(L, 3);
|
|
|
|
semantic_width := get_lua_semantic_size(L, 4);
|
|
semantic_height := get_lua_semantic_size(L, 5);
|
|
|
|
interaction := ui.advanced_button(ui_ctx, strings.clone(string(label), context.temp_allocator), flags, { semantic_width, semantic_height });
|
|
push_lua_box_interaction(L, interaction)
|
|
|
|
return 1;
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"buffer",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
|
|
if ui_ctx != nil {
|
|
buffer_index := int(lua.L_checkinteger(L, 2));
|
|
|
|
if buffer_index != -2 && (buffer_index < 0 || buffer_index >= len(state.buffers)) {
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
|
|
ui_file_buffer(ui_ctx, core.buffer_from_index(state, buffer_index));
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
},
|
|
lua.L_Reg {
|
|
"log_buffer",
|
|
proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA));
|
|
lua.pushvalue(L, 1);
|
|
ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1);
|
|
|
|
if ui_ctx != nil {
|
|
ui_file_buffer(ui_ctx, &state.log_buffer);
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
|
|
return i32(lua.ERRRUN);
|
|
}
|
|
}
|
|
};
|
|
|
|
// TODO: generate this from the plugin.Key enum
|
|
lua.newtable(state.L);
|
|
{
|
|
lua.newtable(state.L);
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.B));
|
|
lua.setfield(state.L, -2, "B");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.F));
|
|
lua.setfield(state.L, -2, "F");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.T));
|
|
lua.setfield(state.L, -2, "T");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.Y));
|
|
lua.setfield(state.L, -2, "Y");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.P));
|
|
lua.setfield(state.L, -2, "P");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.M));
|
|
lua.setfield(state.L, -2, "M");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.K));
|
|
lua.setfield(state.L, -2, "K");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.J));
|
|
lua.setfield(state.L, -2, "J");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.Q));
|
|
lua.setfield(state.L, -2, "Q");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.BACKQUOTE));
|
|
lua.setfield(state.L, -2, "Backtick");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.ESCAPE));
|
|
lua.setfield(state.L, -2, "Escape");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.ENTER));
|
|
lua.setfield(state.L, -2, "Enter");
|
|
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Key.SPACE));
|
|
lua.setfield(state.L, -2, "Space");
|
|
}
|
|
lua.setfield(state.L, -2, "Key");
|
|
|
|
{
|
|
lua.newtable(state.L);
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Hook.BufferInput));
|
|
lua.setfield(state.L, -2, "OnBufferInput");
|
|
lua.pushinteger(state.L, lua.Integer(plugin.Hook.Draw));
|
|
lua.setfield(state.L, -2, "OnDraw");
|
|
}
|
|
lua.setfield(state.L, -2, "Hook");
|
|
|
|
lua.L_setfuncs(state.L, bbb, 0);
|
|
lua.setglobal(state.L, "Editor");
|
|
|
|
lua.newtable(state.L);
|
|
{
|
|
lua.pushinteger(state.L, lua.Integer(ui.Axis.Horizontal));
|
|
lua.setfield(state.L, -2, "Horizontal");
|
|
lua.pushinteger(state.L, lua.Integer(ui.Axis.Vertical));
|
|
lua.setfield(state.L, -2, "Vertical");
|
|
push_lua_semantic_size_table(state.L, { ui.SemanticSizeKind.Fill, 0 });
|
|
lua.setfield(state.L, -2, "Fill");
|
|
push_lua_semantic_size_table(state.L, { ui.SemanticSizeKind.ChildrenSum, 0 });
|
|
lua.setfield(state.L, -2, "ChildrenSum");
|
|
push_lua_semantic_size_table(state.L, { ui.SemanticSizeKind.FitText, 0 });
|
|
lua.setfield(state.L, -2, "FitText");
|
|
|
|
lua.L_setfuncs(state.L, raw_data(&ui_lib), 0);
|
|
lua.setglobal(state.L, "UI");
|
|
}
|
|
}
|
|
|
|
close :: proc(L: ^lua.State) {
|
|
lua.close(L)
|
|
}
|
|
|
|
|
|
@(private)
|
|
register_key_group ::proc "c" (L: ^lua.State) -> i32 {
|
|
context = state.ctx;
|
|
|
|
lua.L_checktype(L, 1, i32(lua.TTABLE));
|
|
table_to_action(L, 1, state.current_input_map);
|
|
|
|
return i32(lua.OK);
|
|
}
|
|
|
|
@(private)
|
|
table_to_action :: proc(L: ^lua.State, index: i32, input_map: ^core.InputActions) {
|
|
lua.len(L, index);
|
|
key_group_len := lua.tointeger(L, -1);
|
|
lua.pop(L, 1);
|
|
|
|
for i in 1..=key_group_len {
|
|
lua.rawgeti(L, index, i);
|
|
defer lua.pop(L, 1);
|
|
|
|
lua.rawgeti(L, -1, 1);
|
|
key:= plugin.Key(lua.tointeger(L, -1));
|
|
lua.pop(L, 1);
|
|
|
|
lua.rawgeti(L, -1, 2);
|
|
desc := strings.clone(string(lua.tostring(L, -1)));
|
|
lua.pop(L, 1);
|
|
|
|
switch lua.rawgeti(L, -1, 3) {
|
|
case i32(lua.TTABLE):
|
|
if action, exists := input_map.key_actions[key]; exists {
|
|
switch value in action.action {
|
|
case core.LuaEditorAction:
|
|
log.warn("Plugin attempted to register input group on existing key action (added from Lua)");
|
|
case core.PluginEditorAction:
|
|
log.warn("Plugin attempted to register input group on existing key action (added from Plugin)");
|
|
case core.EditorAction:
|
|
log.warn("Plugin attempted to register input group on existing key action");
|
|
case core.InputActions:
|
|
input_map := &(&input_map.key_actions[key]).action.(core.InputActions);
|
|
table_to_action(L, lua.gettop(L), input_map);
|
|
}
|
|
} else {
|
|
core.register_key_action(input_map, key, core.new_input_actions(), desc);
|
|
table_to_action(L, lua.gettop(L), &((&input_map.key_actions[key]).action.(core.InputActions)));
|
|
}
|
|
lua.pop(L, 1);
|
|
|
|
case i32(lua.TFUNCTION):
|
|
fn_ref := lua.L_ref(L, i32(lua.REGISTRYINDEX));
|
|
|
|
if lua.rawgeti(L, -1, 4) == i32(lua.TTABLE) {
|
|
maybe_input_map := core.new_input_actions();
|
|
table_to_action(L, lua.gettop(L), &maybe_input_map);
|
|
|
|
core.register_key_action_group(input_map, key, core.LuaEditorAction { fn_ref, maybe_input_map }, desc);
|
|
} else {
|
|
core.register_key_action_group(input_map, key, core.LuaEditorAction { fn_ref, core.InputActions {} }, desc);
|
|
}
|
|
|
|
case:
|
|
lua.pop(L, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
load_plugins :: proc(state: ^core.State, dir: string) {
|
|
filepath.walk(filepath.join({ os.get_current_directory(), dir }), walk_plugins, transmute(rawptr)state);
|
|
log.info("done walking")
|
|
|
|
for plugin in state.new_plugins {
|
|
// FIXME: check if the global actually exists
|
|
lua.getglobal(state.L, fmt.ctprintf("%s_%s", plugin.namespace, plugin.name));
|
|
|
|
lua.getfield(state.L, -1, "OnLoad");
|
|
if (lua.isnil(state.L, -1)) {
|
|
lua.pop(state.L, 2)
|
|
log.warn("plugin", plugin.name, "doesn't have an 'OnLoad' function")
|
|
|
|
continue
|
|
}
|
|
|
|
if lua.pcall(state.L, 0, 0, 0) == i32(lua.OK) {
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
} else {
|
|
err := lua.tostring(state.L, lua.gettop(state.L));
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
lua.pop(state.L, 1);
|
|
|
|
log.error("failed to initialize plugin (OnLoad):", err);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
walk_plugins :: proc(info: os.File_Info, in_err: os.Errno, state: rawptr) -> (err: os.Errno, skip_dir: bool) {
|
|
state := cast(^core.State)state;
|
|
|
|
relative_file_path, rel_error := filepath.rel(state.directory, info.fullpath);
|
|
extension := filepath.ext(info.fullpath);
|
|
|
|
if extension == ".lua" {
|
|
log.info("attempting to load", relative_file_path)
|
|
|
|
if plugin, ok := load_plugin(state, info.fullpath); ok {
|
|
append(&state.new_plugins, plugin);
|
|
|
|
if rel_error == .None {
|
|
log.info("Loaded", relative_file_path);
|
|
} else {
|
|
log.info("Loaded", info.fullpath);
|
|
}
|
|
} else {
|
|
log.error("failed to load")
|
|
}
|
|
}
|
|
|
|
return in_err, skip_dir;
|
|
}
|
|
|
|
load_plugin :: proc(state: ^core.State, path: string) -> (lua_plugin: plugin.NewInterface, ok: bool) {
|
|
if lua.L_dofile(state.L, strings.clone_to_cstring(path, allocator = context.temp_allocator)) != i32(lua.OK) {
|
|
err := lua.tostring(state.L, lua.gettop(state.L))
|
|
lua.pop(state.L, lua.gettop(state.L))
|
|
|
|
log.error("failed to load lua plugin:", err)
|
|
return
|
|
}
|
|
|
|
lua.getfield(state.L, -1, "name");
|
|
if (lua.isnil(state.L, -1)) {
|
|
lua.pop(state.L, 2)
|
|
|
|
log.error("no name for lua plugin")
|
|
return
|
|
}
|
|
name := strings.clone(string(lua.tostring(state.L, -1)))
|
|
lua.pop(state.L, 1)
|
|
|
|
lua.getfield(state.L, -1, "version");
|
|
if (lua.isnil(state.L, -1)) {
|
|
lua.pop(state.L, 2)
|
|
return
|
|
}
|
|
version := strings.clone(string(lua.tostring(state.L, -1)))
|
|
lua.pop(state.L, 1)
|
|
|
|
lua.getfield(state.L, -1, "namespace");
|
|
if (lua.isnil(state.L, -1)) {
|
|
lua.pop(state.L, 2)
|
|
return
|
|
}
|
|
namespace := strings.clone(string(lua.tostring(state.L, -1)))
|
|
lua.pop(state.L, 1)
|
|
|
|
// Add plugin to lua globals
|
|
lua.setglobal(state.L, fmt.caprintf("%s_%s", namespace, name))
|
|
|
|
return plugin.NewInterface {
|
|
name = name,
|
|
version = version,
|
|
namespace = namespace,
|
|
}, true
|
|
}
|
|
|
|
ui_flags :: proc(L: ^lua.State, index: i32) -> (bit_set[ui.Flag], bool) {
|
|
lua.L_checktype(L, index, i32(lua.TTABLE));
|
|
lua.len(L, index);
|
|
array_len := lua.tointeger(L, -1);
|
|
lua.pop(L, 1);
|
|
|
|
flags: bit_set[ui.Flag]
|
|
|
|
for i in 1..=array_len {
|
|
lua.rawgeti(L, index, i);
|
|
defer lua.pop(L, 1);
|
|
|
|
flag := lua.tostring(L, -1);
|
|
switch flag {
|
|
case "Clickable": flags |= {.Clickable}
|
|
case "Hoverable": flags |= {.Hoverable}
|
|
case "Scrollable": flags |= {.Scrollable}
|
|
case "DrawText": flags |= {.DrawText}
|
|
case "DrawBorder": flags |= {.DrawBorder}
|
|
case "DrawBackground": flags |= {.DrawBackground}
|
|
case "RoundedBorder": flags |= {.RoundedBorder}
|
|
case "Floating": flags |= {.Floating}
|
|
case "CustomDrawFunc": flags |= {.CustomDrawFunc}
|
|
}
|
|
}
|
|
|
|
return flags, true
|
|
}
|
|
|
|
run_editor_action :: proc(state: ^core.State, key: plugin.Key, action: core.LuaEditorAction) {
|
|
lua.rawgeti(state.L, lua.REGISTRYINDEX, lua.Integer(action.fn_ref));
|
|
if lua.pcall(state.L, 0, 0, 0) != i32(lua.OK) {
|
|
err := lua.tostring(state.L, lua.gettop(state.L));
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
|
|
log.error(err);
|
|
} else {
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
}
|
|
|
|
if action.maybe_input_map.key_actions != nil {
|
|
ptr_action := &(&state.current_input_map.key_actions[key]).action.(core.LuaEditorAction)
|
|
state.current_input_map = (&ptr_action.maybe_input_map)
|
|
}
|
|
}
|
|
|
|
run_ui_function :: proc(state: ^core.State, ui_context: ^ui.Context, fn_ref: i32) {
|
|
lua.rawgeti(state.L, lua.REGISTRYINDEX, lua.Integer(fn_ref));
|
|
lua.pushlightuserdata(state.L, ui_context);
|
|
if lua.pcall(state.L, 1, 0, 0) != i32(lua.OK) {
|
|
err := lua.tostring(state.L, lua.gettop(state.L));
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
|
|
log.error(err);
|
|
} else {
|
|
lua.pop(state.L, lua.gettop(state.L));
|
|
}
|
|
}
|
|
|
|
// TODO: don't duplicate this procedure
|
|
ui_file_buffer :: proc(ctx: ^ui.Context, buffer: ^core.FileBuffer) -> ui.Interaction {
|
|
draw_func := proc(state: ^core.State, box: ^ui.Box, user_data: rawptr) {
|
|
buffer := transmute(^core.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)
|
|
|
|
buffer_container, _ := ui.push_box(ctx, relative_file_path, {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Fill)});
|
|
ui.push_parent(ctx, buffer_container);
|
|
defer ui.pop_parent(ctx);
|
|
|
|
interaction := ui.custom(ctx, "buffer1", draw_func, transmute(rawptr)buffer);
|
|
|
|
{
|
|
info_box, _ := ui.push_box(ctx, "buffer info", {}, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Exact, state.source_font_height)});
|
|
ui.push_parent(ctx, info_box);
|
|
defer ui.pop_parent(ctx);
|
|
|
|
ui.label(ctx, fmt.tprintf("%s", state.mode))
|
|
if selection, exists := buffer.selection.?; exists {
|
|
ui.label(ctx, fmt.tprintf("sel: %d:%d", selection.end.line, selection.end.col));
|
|
}
|
|
ui.spacer(ctx, "spacer");
|
|
ui.label(ctx, relative_file_path);
|
|
}
|
|
|
|
return interaction;
|
|
}
|