add debug panel, don't open same file twice

src/core/core.odin

@@ -51,6 +51,7 @@ State :: struct {
 
     current_panel: Maybe(int),
     panels: util.StaticList(Panel),
+    buffers: util.StaticList(FileBuffer),
 }
 
 Register :: struct {
@@ -95,12 +96,16 @@ Panel_VTable :: struct {
 }
 
 PanelType :: union {
+    DebugPanel,
     FileBufferPanel,
     GrepPanel,
 }
 
+DebugPanel :: struct {
+}
+
 FileBufferPanel :: struct {
-    buffer: FileBuffer,
+    buffer_id: int,
     viewed_symbol: Maybe(string),
 
     search_buffer: FileBuffer,
@@ -135,14 +140,69 @@ GrepQueryResult :: struct {
 current_buffer :: proc(state: ^State) -> ^FileBuffer {
     if current_panel, ok := state.current_panel.?; ok {
         if panel, ok := util.get(&state.panels, current_panel).?; ok {
-            buffer, _ := panel->buffer(state)
-            return buffer
+            if panel.buffer != nil {
+                buffer, _ := panel->buffer(state)
+                return buffer
+            }
         }
     }
 
     return nil
 }
 
+new_buffer_virtual :: proc(state: ^State) -> (id: int, buffer: ^FileBuffer, ok: bool) {
+    return util.append(&state.buffers, new_virtual_file_buffer(context.allocator))
+}
+
+new_buffer_file :: proc(state: ^State, file_path: string, line: int = 0, col: int = 0) -> (id: int, buffer: ^FileBuffer, ok: bool) {
+    for i in 0..<len(state.buffers.data) {
+        if buffer, ok := util.get(&state.buffers, i).?; ok {
+            if buffer.file_path == file_path {
+                move_cursor_to_location(buffer, line, col)
+                return i, buffer, true
+            }
+        }
+    }
+
+    new_buffer, err := make_file_buffer(context.allocator, file_path, state.directory)
+    if err.type != .None {
+        ok = false
+        return
+    }
+
+    move_cursor_to_location(&new_buffer, line, col)
+
+    return util.append(&state.buffers, new_buffer)
+}
+
+new_buffer :: proc{new_buffer_file, new_buffer_virtual}
+
+open_buffer_file :: proc(state: ^State, file_path: string, line: int = 0, col: int = 0) {
+    next_id := 0
+    for {
+        if panel, ok := util.get(&state.panels, next_id).?; ok {
+            if type, ok := &panel.type.(FileBufferPanel); ok {
+                buffer_id, _, ok := new_buffer_file(state, file_path, line, col)
+                if ok {
+                    type.buffer_id = buffer_id
+                    state.current_panel = panel.id
+                }
+
+                break
+            } else {
+                next_id := util.get_next(&state.panels, next_id)
+                continue
+            }
+        }
+
+        break
+    }
+}
+
+get_buffer :: proc(state: ^State, buffer_id: int) -> Maybe(^FileBuffer) {
+    return util.get(&state.buffers, buffer_id)
+}
+
 yank_whole_line :: proc(state: ^State, buffer: ^FileBuffer) {
     if state.yank_register.data != nil {
         delete(state.yank_register.data)

src/core/file_buffer.odin

@@ -749,10 +749,12 @@ new_virtual_file_buffer :: proc(allocator := context.allocator) -> FileBuffer {
         glyphs = make_glyph_buffer(width, height),
     };
 
+    push_new_snapshot(&buffer.history)
+
     return buffer;
 }
 
-new_file_buffer :: proc(allocator: mem.Allocator, file_path: string, base_dir: string = "") -> (FileBuffer, Error) {
+make_file_buffer :: proc(allocator: mem.Allocator, file_path: string, base_dir: string = "") -> (FileBuffer, Error) {
     context.allocator = allocator;
 
     fmt.eprintln("attempting to open", file_path);
@@ -812,6 +814,7 @@ new_file_buffer :: proc(allocator: mem.Allocator, file_path: string, base_dir: s
             glyphs = make_glyph_buffer(width, height),
         };
 
+        push_new_snapshot(&buffer.history)
         ts.parse_buffer(&buffer.tree, tree_sitter_file_buffer_input(&buffer))
 
         return buffer, error();
@@ -905,8 +908,8 @@ color_character :: proc(buffer: ^FileBuffer, start: Cursor, end: Cursor, palette
 }
 
 draw_file_buffer :: proc(state: ^State, buffer: ^FileBuffer, x, y, w, h: int, show_line_numbers: bool = true, show_cursor: bool = true) {
-    glyph_width := math.min(256, int(w / state.source_font_width));
-    glyph_height := math.min(256, int(h / state.source_font_height)) + 1;
+    glyph_width := math.max(math.min(256, int(w / state.source_font_width)), 1);
+    glyph_height := math.max(math.min(256, int(h / state.source_font_height)) + 1, 1);
 
     update_glyph_buffer(buffer, glyph_width, glyph_height);
 
@@ -996,7 +999,7 @@ update_file_buffer_scroll :: proc(buffer: ^FileBuffer, cursor: Maybe(^Cursor) =
         cursor = &buffer.history.cursor;
     }
 
-    if buffer.glyphs.height < 5 {
+    if buffer.glyphs.height <= 5 {
         buffer.top_line = cursor.?.line
     } else if cursor.?.line > (buffer.top_line + buffer.glyphs.height - 5) {
         buffer.top_line = math.max(cursor.?.line - buffer.glyphs.height + 5, 0);

src/main.odin

@@ -160,6 +160,7 @@ main :: proc() {
         command_arena = mem.arena_allocator(&_command_arena),
 
         panels = util.make_static_list(core.Panel, 128),
+        buffers = util.make_static_list(core.FileBuffer, 64),
 
         directory = os.get_current_directory(),
         log_buffer = core.new_virtual_file_buffer(context.allocator),
@@ -264,6 +265,10 @@ main :: proc() {
         panels.open(&state, panels.make_file_buffer_panel(""))
     }
 
+
+    panels.open(&state, panels.make_debug_panel())
+    panels.open(&state, panels.make_debug_panel())
+
     if sdl2.Init({.VIDEO}) < 0 {
         log.error("SDL failed to initialize:", sdl2.GetError());
         return;
@@ -330,8 +335,6 @@ main :: proc() {
 
     sdl2.AddEventWatch(expose_event_watcher, &state);
 
-    core.push_new_snapshot(&core.current_buffer(&state).history)
-
     control_key_pressed: bool;
     for !state.should_close {
         {

src/panels/debug.odin

@@ -0,0 +1,140 @@
+package panels
+
+import "base:runtime"
+import "core:mem"
+import "core:fmt"
+import "core:strings"
+import "core:log"
+
+import "vendor:sdl2"
+
+import "../core"
+import "../util"
+import "../ui"
+
+make_debug_panel :: proc() -> core.Panel {
+    return core.Panel {
+        type = core.DebugPanel {},
+        create = proc(panel: ^core.Panel, state: ^core.State) {
+            context.allocator = panel.allocator
+
+            panel_state := &panel.type.(core.DebugPanel)
+            panel.input_map = core.new_input_map(show_help = true)
+
+            panel_actions := core.new_input_actions(show_help = true)
+            register_default_panel_actions(&panel_actions)
+            core.register_ctrl_key_action(&panel.input_map.mode[.Normal], .W, panel_actions, "Panel Navigation") 
+        },
+        render = proc(panel: ^core.Panel, state: ^core.State) -> (ok: bool) {
+            if panel_state, ok := &panel.type.(core.DebugPanel); ok {
+                s := transmute(^ui.State)state.ui
+
+                ui.open_element(s, nil,
+                    {
+                        dir = .TopToBottom,
+                        kind = {ui.Fit{}, ui.Grow{}},
+                    },
+                    style = {
+                        background_color = .Background1,
+                    },
+                )
+                {
+                    render_buffer_list(state, s)
+
+                    ui.open_element(s, nil, {
+                        kind = {ui.Fit{}, ui.Exact(8)},
+                    })
+                    ui.close_element(s)
+
+                    render_panel_list(state, s)
+                }
+                ui.close_element(s)
+            }
+
+            return true
+        }
+    }
+}
+
+render_buffer_list :: proc(state: ^core.State, s: ^ui.State) {
+    ui.open_element(s, nil,
+        {
+            dir = .TopToBottom,
+            kind = {ui.Fit{}, ui.Fit{}},
+        },
+        style = {
+            background_color = .Background1,
+        },
+    )
+    {
+        ui.open_element(s, "Open Buffers", 
+            {
+                kind = {ui.Grow{}, ui.Fit{}},
+            },
+            style = {
+                border = {.Bottom},
+                border_color = .Background4,
+            }
+        )
+        ui.close_element(s)
+
+        ui.open_element(s, nil, {
+            kind = {ui.Fit{}, ui.Exact(8)},
+        })
+        ui.close_element(s)
+
+        for i in 0..<len(state.buffers.data) {
+            if buffer, ok := util.get(&state.buffers, i).?; ok {
+                buffer_label := fmt.tprintf("buf '%v' - %v", i, buffer.file_path[len(state.directory):])
+                ui.open_element(s, buffer_label, {})
+                ui.close_element(s)
+            }
+        }
+    }
+    ui.close_element(s)
+}
+
+render_panel_list :: proc(state: ^core.State, s: ^ui.State) {
+    ui.open_element(s, nil,
+        {
+            dir = .TopToBottom,
+            kind = {ui.Fit{}, ui.Fit{}},
+        },
+        style = {
+            background_color = .Background1,
+        },
+    )
+    {
+        ui.open_element(s, "Open Panels", 
+            {
+                kind = {ui.Grow{}, ui.Fit{}},
+            },
+            style = {
+                border = {.Bottom},
+                border_color = .Background4,
+            }
+        )
+        ui.close_element(s)
+
+        ui.open_element(s, nil, {
+            kind = {ui.Fit{}, ui.Exact(8)},
+        })
+        ui.close_element(s)
+
+        for i in 0..<len(state.panels.data) {
+            if panel, ok := util.get(&state.panels, i).?; ok {
+                info: string
+                switch v in &panel.type {
+                    case core.DebugPanel:      info = "DebugPanel"
+                    case core.FileBufferPanel: info = "FileBufferPanel"
+                    case core.GrepPanel:       info = "GrepPanel"
+                }
+
+                panel_label := fmt.tprintf("panel id '%v' - %v", i, info)
+                ui.open_element(s, panel_label, {})
+                ui.close_element(s)
+            }
+        }
+    }
+    ui.close_element(s)
+}

src/panels/file_buffer.odin

@@ -41,9 +41,6 @@ make_file_buffer_panel :: proc(file_path: string, line: int = 0, col: int = 0) -
             col = col,
         },
         drop = proc(panel: ^core.Panel, state: ^core.State) {
-            panel_state := &panel.type.(core.FileBufferPanel)
-
-            ts.delete_state(&panel_state.buffer.tree)
         },
         create = proc(panel: ^core.Panel, state: ^core.State) {
             context.allocator = panel.allocator
@@ -61,20 +58,18 @@ make_file_buffer_panel :: proc(file_path: string, line: int = 0, col: int = 0) -
             panel_state.search_buffer = core.new_virtual_file_buffer(panel.allocator)
 
             if len(panel_state.file_path) == 0 {
-                panel_state.buffer = core.new_virtual_file_buffer(panel.allocator)
-            } else {
-                buffer, err := core.new_file_buffer(panel.allocator, panel_state.file_path, state.directory)
-                if err.type != .None {
-                    log.error("Failed to create file buffer:", err);
-                    return;
+                if buffer_id, _, ok := core.new_buffer(state); ok {
+                    panel_state.buffer_id = buffer_id
+                } else {
+                    log.error("failed to create buffer")
+                }
+            } else {
+                if buffer_id, buffer, ok := core.new_buffer(state, panel_state.file_path); ok {
+                    core.move_cursor_to_location(buffer, panel_state.line, panel_state.col)
+                    panel_state.buffer_id = buffer_id
+                } else {
+                    log.error("failed to create buffer")
                 }
-
-                buffer.history.cursor.line = panel_state.line
-                buffer.history.cursor.col = panel_state.col
-                buffer.top_line = buffer.history.cursor.line
-                core.update_file_buffer_index_from_cursor(&buffer)
-
-                panel_state.buffer = buffer
             }
 
             leader_actions := core.new_input_actions(show_help = true)
@@ -96,31 +91,37 @@ make_file_buffer_panel :: proc(file_path: string, line: int = 0, col: int = 0) -
             if panel_state.is_searching {
                 return &panel_state.search_buffer, true
             } else {
-                return &panel_state.buffer, true
+                buffer, ok = core.get_buffer(state, panel_state.buffer_id).?
+                return
             }
         },
         on_buffer_input = proc(panel: ^core.Panel, state: ^core.State) {
             panel_state := &panel.type.(core.FileBufferPanel)
-            run_query(panel_state, &panel_state.buffer)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
-            if len(panel_state.query_results) > 0 {
-                for result, i in panel_state.query_results {
-                    cursor := panel_state.buffer.history.cursor
+            run_query(panel_state, buffer)
 
-                    if result.line >= cursor.line || (result.line == cursor.line && result.col >= cursor.col) {
-                        core.move_cursor_to_location(&panel_state.buffer, result.line, result.col)
-                        break
-                    }
+            if panel_state.is_searching {
+                if len(panel_state.query_results) > 0 {
+                    for result, i in panel_state.query_results {
+                        cursor := buffer.history.cursor
 
-                    if i == len(panel_state.query_results)-1 {
-                        result := panel_state.query_results[0]
-                        core.move_cursor_to_location(&panel_state.buffer, result.line, result.col)
+                        if result.line >= cursor.line || (result.line == cursor.line && result.col >= cursor.col) {
+                            core.move_cursor_to_location(buffer, result.line, result.col)
+                            break
+                        }
+
+                        if i == len(panel_state.query_results)-1 {
+                            result := panel_state.query_results[0]
+                            core.move_cursor_to_location(buffer, result.line, result.col)
+                        }
                     }
                 }
             }
         },
         render = proc(panel: ^core.Panel, state: ^core.State) -> (ok: bool) {
             panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             s := transmute(^ui.State)state.ui
 
@@ -131,7 +132,7 @@ make_file_buffer_panel :: proc(file_path: string, line: int = 0, col: int = 0) -
                 },
             )
             {
-                render_file_buffer(state, s, &panel_state.buffer)
+                render_file_buffer(state, s, buffer)
                 if panel_state.is_searching {
                     ui.open_element(s, nil,
                         {
@@ -246,7 +247,7 @@ file_buffer_leader_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .K, proc(state: ^core.State, user_data: rawptr) {
         panel := transmute(^core.Panel)user_data
         panel_state := &panel.type.(core.FileBufferPanel)
-        buffer := &panel_state.buffer
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         ts.update_cursor(&buffer.tree, buffer.history.cursor.line, buffer.history.cursor.col)
         panel_state.viewed_symbol = ts.print_node_type(&buffer.tree)
@@ -257,13 +258,17 @@ file_buffer_leader_actions :: proc(input_map: ^core.InputActions) {
 
 file_buffer_go_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .H, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.move_cursor_start_of_line(buffer);
         core.reset_input_map(state)
     }, "move to beginning of line");
     core.register_key_action(input_map, .L, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.move_cursor_end_of_line(buffer);
         core.reset_input_map(state)
@@ -272,7 +277,9 @@ file_buffer_go_actions :: proc(input_map: ^core.InputActions) {
 
 file_buffer_delete_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .D, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.push_new_snapshot(&buffer.history)
 
@@ -293,50 +300,68 @@ file_buffer_input_actions :: proc(input_map: ^core.InputActions) {
     // Cursor Movement
     {
         core.register_key_action(input_map, .W, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_forward_start_of_word(buffer);
         }, "move forward one word");
         core.register_key_action(input_map, .E, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_forward_end_of_word(buffer);
         }, "move forward to end of word");
 
         core.register_key_action(input_map, .B, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_backward_start_of_word(buffer);
         }, "move backward one word");
 
         core.register_key_action(input_map, .K, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_up(buffer);
         }, "move up one line");
         core.register_key_action(input_map, .J, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_down(buffer);
         }, "move down one line");
         core.register_key_action(input_map, .H, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_left(buffer);
         }, "move left one char");
         core.register_key_action(input_map, .L, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.move_cursor_right(buffer);
         }, "move right one char");
 
         core.register_ctrl_key_action(input_map, .U, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.scroll_file_buffer(buffer, .Up);
         }, "scroll buffer up");
         core.register_ctrl_key_action(input_map, .D, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.scroll_file_buffer(buffer, .Down);
         }, "scroll buffer up");
@@ -363,7 +388,9 @@ file_buffer_input_actions :: proc(input_map: ^core.InputActions) {
 
     // Save file
     core.register_ctrl_key_action(input_map, .S, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         if err := core.save_buffer_to_disk(state, buffer); err != nil {
             log.errorf("failed to save buffer to disk: %v", err)
@@ -393,7 +420,9 @@ file_buffer_input_actions :: proc(input_map: ^core.InputActions) {
     }, "search buffer")
 
     core.register_key_action(input_map, .V, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         state.mode = .Visual;
         core.reset_input_map(state)
@@ -416,19 +445,20 @@ file_buffer_input_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .N, proc(state: ^core.State, user_data: rawptr) {
         panel := transmute(^core.Panel)user_data
         panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         if len(panel_state.query_results) > 0 {
             for result, i in panel_state.query_results {
-                cursor := panel_state.buffer.history.cursor
+                cursor := buffer.history.cursor
 
                 if result.line > cursor.line || (result.line == cursor.line && result.col > cursor.col) {
-                    core.move_cursor_to_location(&panel_state.buffer, result.line, result.col)
+                    core.move_cursor_to_location(buffer, result.line, result.col)
                     break
                 }
 
                 if i == len(panel_state.query_results)-1 {
                     result := panel_state.query_results[0]
-                    core.move_cursor_to_location(&panel_state.buffer, result.line, result.col)
+                    core.move_cursor_to_location(buffer, result.line, result.col)
                 }
             }
         }
@@ -437,7 +467,9 @@ file_buffer_input_actions :: proc(input_map: ^core.InputActions) {
 
 file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .ESCAPE, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         state.mode = .Normal;
         core.reset_input_map(state)
@@ -449,14 +481,18 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
     // Cursor Movement
     {
         core.register_key_action(input_map, .W, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
             core.move_cursor_forward_start_of_word(buffer, cursor = &sel_cur.end);
         }, "move forward one word");
         core.register_key_action(input_map, .E, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
@@ -464,7 +500,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
         }, "move forward to end of word");
 
         core.register_key_action(input_map, .B, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
@@ -472,28 +510,36 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
         }, "move backward one word");
 
         core.register_key_action(input_map, .K, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
             core.move_cursor_up(buffer, cursor = &sel_cur.end);
         }, "move up one line");
         core.register_key_action(input_map, .J, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
             core.move_cursor_down(buffer, cursor = &sel_cur.end);
         }, "move down one line");
         core.register_key_action(input_map, .H, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
             core.move_cursor_left(buffer, cursor = &sel_cur.end);
         }, "move left one char");
         core.register_key_action(input_map, .L, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
@@ -501,14 +547,18 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
         }, "move right one char");
 
         core.register_ctrl_key_action(input_map, .U, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
             core.scroll_file_buffer(buffer, .Up, cursor = &sel_cur.end);
         }, "scroll buffer up");
         core.register_ctrl_key_action(input_map, .D, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             sel_cur := &(buffer.selection.?);
 
@@ -519,7 +569,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
     // Text Modification
     {
         core.register_key_action(input_map, .D, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.push_new_snapshot(&buffer.history)
 
@@ -534,7 +586,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
         }, "delete selection");
 
         core.register_key_action(input_map, .C, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.push_new_snapshot(&buffer.history)
 
@@ -553,7 +607,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
     // Copy-Paste
     {
         core.register_key_action(input_map, .Y, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.yank_selection(state, buffer)
 
@@ -565,7 +621,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
         }, "Yank Line");
 
         core.register_key_action(input_map, .P, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.push_new_snapshot(&buffer.history)
 
@@ -584,7 +642,9 @@ file_buffer_visual_actions :: proc(input_map: ^core.InputActions) {
 
 file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
     core.register_key_action(input_map, .I, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.push_new_snapshot(&buffer.history)
 
@@ -592,7 +652,9 @@ file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
         sdl2.StartTextInput();
     }, "enter insert mode");
     core.register_key_action(input_map, .A, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.push_new_snapshot(&buffer.history)
 
@@ -602,14 +664,18 @@ file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
     }, "enter insert mode after character (append)");
 
     core.register_key_action(input_map, .U, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.pop_snapshot(&buffer.history, true)
         ts.parse_buffer(&buffer.tree, core.tree_sitter_file_buffer_input(buffer))
     }, "Undo");
 
     core.register_ctrl_key_action(input_map, .R, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.recover_snapshot(&buffer.history)
         ts.parse_buffer(&buffer.tree, core.tree_sitter_file_buffer_input(buffer))
@@ -618,33 +684,33 @@ file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
     // TODO: add shift+o to insert newline above current one
 
     core.register_key_action(input_map, .O, proc(state: ^core.State, user_data: rawptr) {
-        buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+        panel := transmute(^core.Panel)user_data
+        panel_state := &panel.type.(core.FileBufferPanel)
+        buffer := core.get_buffer(state, panel_state.buffer_id).?
 
         core.push_new_snapshot(&buffer.history)
 
-        if buffer := buffer; buffer != nil {
-            core.move_cursor_end_of_line(buffer);
-            
-            char := core.get_character_at_piece_table_index(core.buffer_piece_table(buffer), buffer.history.cursor.index)
-            indent := core.get_buffer_indent(buffer)
-            if char == '{' {
-                // TODO: update tab to be configurable
-                indent += 4
-            }
-
-            if char != '\n' {
-                core.move_cursor_right(buffer, stop_at_end = false)
-            }
-
-            core.insert_content(buffer, []u8{'\n'})
-            for i in 0..<indent {
-                core.insert_content(buffer, []u8{' '})
-            }
-
-            state.mode = .Insert;
-
-            sdl2.StartTextInput();
+        core.move_cursor_end_of_line(buffer);
+        
+        char := core.get_character_at_piece_table_index(core.buffer_piece_table(buffer), buffer.history.cursor.index)
+        indent := core.get_buffer_indent(buffer)
+        if char == '{' {
+            // TODO: update tab to be configurable
+            indent += 4
         }
+
+        if char != '\n' {
+            core.move_cursor_right(buffer, stop_at_end = false)
+        }
+
+        core.insert_content(buffer, []u8{'\n'})
+        for i in 0..<indent {
+            core.insert_content(buffer, []u8{' '})
+        }
+
+        state.mode = .Insert;
+
+        sdl2.StartTextInput();
     }, "insert mode on newline");
 
     // Copy-Paste
@@ -654,7 +720,9 @@ file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
             defer core.register_key_action(input_map, .Y, yank_actions)
 
             core.register_key_action(&yank_actions, .Y, proc(state: ^core.State, user_data: rawptr) {
-                buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+                panel := transmute(^core.Panel)user_data
+                panel_state := &panel.type.(core.FileBufferPanel)
+                buffer := core.get_buffer(state, panel_state.buffer_id).?
 
                 core.yank_whole_line(state, buffer)
 
@@ -663,7 +731,9 @@ file_buffer_text_input_actions :: proc(input_map: ^core.InputActions) {
         }
 
         core.register_key_action(input_map, .P, proc(state: ^core.State, user_data: rawptr) {
-            buffer := &(&(transmute(^core.Panel)user_data).type.(core.FileBufferPanel)).buffer
+            panel := transmute(^core.Panel)user_data
+            panel_state := &panel.type.(core.FileBufferPanel)
+            buffer := core.get_buffer(state, panel_state.buffer_id).?
 
             core.push_new_snapshot(&buffer.history)
 

src/panels/grep.odin

@@ -87,13 +87,8 @@ make_grep_panel :: proc() -> core.Panel {
                     if panel_state.query_results != nil {
                         selected_result := &panel_state.query_results[panel_state.selected_result]
 
-                        if panel_id, ok := open(state, make_file_buffer_panel(selected_result.file_path, selected_result.line, selected_result.col)); ok {
-                            close(state, this_panel.id)
-
-                            state.current_panel = panel_id
-                        } else {
-                            log.error("failed to open file buffer in new panel")
-                        }
+                        core.open_buffer_file(state, selected_result.file_path, selected_result.line, selected_result.col)
+                        close(state, this_panel.id)
                     }
                 }
             }, "Open File");

src/pkg/grep_lib/src/lib.rs

@@ -298,7 +298,7 @@ extern "C" fn grep_buffer(
 #[unsafe(no_mangle)]
 extern "C" fn free_grep_results(results: GrepResults) {
     unsafe {
-        let mut array = std::slice::from_raw_parts_mut(
+        let array = std::slice::from_raw_parts_mut(
             results.results as *mut GrepResult,
             results.len as usize,
         );

src/tests/tests.odin

@@ -19,6 +19,7 @@ new_test_editor :: proc() -> core.State {
         source_font_height = 16,
 
         panels = util.make_static_list(core.Panel, 128),
+        buffers = util.make_static_list(core.FileBuffer, 64),
 
         directory = "test_directory",
     };

src/ui/ui.odin

@@ -136,20 +136,34 @@ close_element :: proc(state: ^State, loc := #caller_location) -> UI_Layout {
             case Exact: { e.layout.size.x = int(v) }
             case Fit: {
                 it := e.first
-                for child in iterate_siblings(state, &it) {
-                    if child.layout.floating { continue }
 
-                    switch e.layout.dir {
-                        case .RightToLeft: fallthrough
-                        case .LeftToRight: {
-                            e.layout.size.x += child.layout.size.x
-                        }
+                if it != nil {
+                    for child in iterate_siblings(state, &it) {
+                        if child.layout.floating { continue }
 
-                        case .BottomToTop: fallthrough
-                        case .TopToBottom: {
-                            e.layout.size.x = math.max(e.layout.size.x, child.layout.size.x)
+                        switch e.layout.dir {
+                            case .RightToLeft: fallthrough
+                            case .LeftToRight: {
+                                e.layout.size.x += child.layout.size.x
+                            }
+
+                            case .BottomToTop: fallthrough
+                            case .TopToBottom: {
+                                e.layout.size.x = math.max(e.layout.size.x, child.layout.size.x)
+                            }
                         }
                     }
+                } else {
+                    switch v in e.kind {
+                        case UI_Element_Kind_Text: {
+                            // FIXME: properly use font size
+                            e.layout.size.x = len(v) * 12
+                        }
+                        case UI_Element_Kind_Image: {
+                            // TODO
+                        }
+                        case UI_Element_Kind_Custom: { }
+                    }
                 }
             }
             case Grow: {
@@ -177,20 +191,35 @@ close_element :: proc(state: ^State, loc := #caller_location) -> UI_Layout {
             case Exact: { e.layout.size.y = int(v) }
             case Fit: {
                 it := e.first
-                for child in iterate_siblings(state, &it) {
-                    if child.layout.floating { continue }
 
-                    switch e.layout.dir {
-                        case .RightToLeft: fallthrough
-                        case .LeftToRight: {
-                            e.layout.size.y = math.max(e.layout.size.y, child.layout.size.y)
-                        }
+                if it != nil {
+                    for child in iterate_siblings(state, &it) {
+                        if child.layout.floating { continue }
 
-                        case .BottomToTop: fallthrough
-                        case .TopToBottom: {
-                            e.layout.size.y += child.layout.size.y
+                        switch e.layout.dir {
+                            case .RightToLeft: fallthrough
+                            case .LeftToRight: {
+                                e.layout.size.y = math.max(e.layout.size.y, child.layout.size.y)
+                            }
+
+                            case .BottomToTop: fallthrough
+                            case .TopToBottom: {
+                                e.layout.size.y += child.layout.size.y
+                            }
                         }
                     }
+                } else {
+                    switch v in e.kind {
+                        case UI_Element_Kind_Text: {
+                            // TODO: wrap text
+                            // FIXME: properly use font size
+                            e.layout.size.y = 16
+                        }
+                        case UI_Element_Kind_Image: {
+                            // TODO
+                        }
+                        case UI_Element_Kind_Custom: { }
+                    }
                 }
             }
             case Grow: {
@@ -316,7 +345,7 @@ grow_children :: proc(state: ^State, index: int) {
         }
     }
 
-    if num_growing.x > 0 || num_growing.y > 0 {
+    if true || num_growing.x > 0 || num_growing.y > 0 {
         remaining_size := [2]int{ x_e, y_e } - children_size
         to_grow: [2]int
         to_grow.x = 0 if num_growing.x < 1 else remaining_size.x/num_growing.x
@@ -348,9 +377,9 @@ grow_children :: proc(state: ^State, index: int) {
             _, x_growing := child.layout.kind.x.(Grow)
             _, y_growing := child.layout.kind.y.(Grow)
 
-            if x_growing || y_growing || child.layout.floating {
+            // if x_growing || y_growing || child.layout.floating {
                 grow_children(state, child_index)
-            }
+            // }
         }
     }
 }