Tree Explorer

helix-term/src/commands.rs

@@ -445,6 +445,9 @@ impl MappableCommand {
         record_macro, "Record macro",
         replay_macro, "Replay macro",
         command_palette, "Open command palette",
+        toggle_or_focus_explorer, "toggle or focus explorer",
+        open_explorer_recursion, "open explorer recursion",
+        close_explorer, "close explorer",
     );
 }
 
@@ -2300,6 +2303,43 @@ fn file_picker_in_current_directory(cx: &mut Context) {
     cx.push_layer(Box::new(overlayed(picker)));
 }
 
+fn toggle_or_focus_explorer(cx: &mut Context) {
+    cx.callback = Some(Box::new(
+        |compositor: &mut Compositor, cx: &mut compositor::Context| {
+            if let Some(editor) = compositor.find::<ui::EditorView>() {
+                match editor.explorer.as_mut() {
+                    Some(explore) => explore.content.focus(),
+                    None => match ui::Explorer::new(cx) {
+                        Ok(explore) => editor.explorer = Some(overlayed(explore)),
+                        Err(err) => cx.editor.set_error(format!("{}", err)),
+                    },
+                }
+            }
+        },
+    ));
+}
+
+fn open_explorer_recursion(cx: &mut Context) {
+    cx.callback = Some(Box::new(
+        |compositor: &mut Compositor, cx: &mut compositor::Context| {
+            if let Some(editor) = compositor.find::<ui::EditorView>() {
+                match ui::Explorer::new_explorer_recursion() {
+                    Ok(explore) => editor.explorer = Some(overlayed(explore)),
+                    Err(err) => cx.editor.set_error(format!("{}", err)),
+                }
+            }
+        },
+    ));
+} 
+
+fn close_explorer(cx: &mut Context) {
+    cx.callback = Some(Box::new(|compositor: &mut Compositor, _| {
+        if let Some(editor) = compositor.find::<ui::EditorView>() {
+            editor.explorer.take();
+        }
+    }));
+}
+
 fn buffer_picker(cx: &mut Context) {
     let current = view!(cx.editor).doc;
 

helix-term/src/keymap/default.rs

@@ -270,6 +270,8 @@ pub fn default() -> HashMap<Mode, Keymap> {
             "r" => rename_symbol,
             "h" => select_references_to_symbol_under_cursor,
             "?" => command_palette,
+            "e" => toggle_or_focus_explorer,
+            "E" => open_explorer_recursion,
         },
         "z" => { "View"
             "z" | "c" => align_view_center,

helix-term/src/ui/editor.rs

@@ -4,7 +4,7 @@ use crate::{
     job::{self, Callback},
     key,
     keymap::{KeymapResult, Keymaps},
-    ui::{Completion, ProgressSpinners},
+    ui::{overlay::Overlay,Completion, Explorer, ProgressSpinners},
 };
 
 use helix_core::{
@@ -39,6 +39,7 @@ pub struct EditorView {
     last_insert: (commands::MappableCommand, Vec<InsertEvent>),
     pub(crate) completion: Option<Completion>,
     spinners: ProgressSpinners,
+    pub(crate) explorer: Option<Overlay<Explorer>>,
 }
 
 #[derive(Debug, Clone)]
@@ -63,6 +64,7 @@ impl EditorView {
             last_insert: (commands::MappableCommand::normal_mode, Vec::new()),
             completion: None,
             spinners: ProgressSpinners::default(),
+            explorer: None,
         }
     }
 
@@ -1299,6 +1301,11 @@ impl Component for EditorView {
         event: &Event,
         context: &mut crate::compositor::Context,
     ) -> EventResult {
+        if let Some(explore) = self.explorer.as_mut() {
+            if let EventResult::Consumed(callback) = explore.handle_event(event, context) {
+                return EventResult::Consumed(callback);
+            }
+        }
         let mut cx = commands::Context {
             editor: context.editor,
             count: None,
@@ -1457,6 +1464,18 @@ impl Component for EditorView {
 
         // -1 for commandline and -1 for bufferline
         let mut editor_area = area.clip_bottom(1);
+
+        if self.explorer.is_some() && (config.explorer.is_embed()) {
+            editor_area = editor_area.clip_left(config.explorer.column_width as u16 + 2);
+        }
+        cx.editor.resize(editor_area); // -1 from bottom for commandline
+
+        if let Some(explore) = self.explorer.as_mut() {
+            if !explore.content.is_focus() && config.explorer.is_embed() {
+                explore.content.render(area, surface, cx);
+            }
+        }
+
         if use_bufferline {
             editor_area = editor_area.clip_top(1);
         }
@@ -1542,9 +1561,30 @@ impl Component for EditorView {
         if let Some(completion) = self.completion.as_mut() {
             completion.render(area, surface, cx);
         }
+
+        if let Some(explore) = self.explorer.as_mut() {
+            if explore.content.is_focus() {
+                if config.explorer.is_embed() {
+                    explore.content.render(area, surface, cx);
+                } else {
+                    explore.render(area, surface, cx);
+                }
+            }
+        }
     }
 
     fn cursor(&self, _area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
+        if let Some(explore) = &self.explorer {
+            if explore.content.is_focus() {
+                if editor.config().explorer.is_overlay() {
+                    return explore.cursor(_area, editor);
+                }
+                let cursor = explore.content.cursor(_area, editor);
+                if cursor.0.is_some() {
+                    return cursor;
+                }
+            }
+        }
         match editor.cursor() {
             // All block cursors are drawn manually
             (pos, CursorKind::Block) => (pos, CursorKind::Hidden),