Extract idle timeout code into ui/editor.rs

helix-term/src/application.rs

@@ -187,17 +187,13 @@ impl Application {
     }
 
     fn render(&mut self) {
-        let editor = &mut self.editor;
-        let compositor = &mut self.compositor;
-        let jobs = &mut self.jobs;
-
         let mut cx = crate::compositor::Context {
-            editor,
+            editor: &mut self.editor,
-            jobs,
+            jobs: &mut self.jobs,
             scroll: None,
         };
 
-        compositor.render(&mut cx);
+        self.compositor.render(&mut cx);
     }
 
     pub async fn event_loop(&mut self) {
@@ -278,32 +274,21 @@ impl Application {
     }
 
     pub fn handle_idle_timeout(&mut self) {
-        use crate::commands::{insert::idle_completion, Context};
+        use crate::compositor::EventResult;
-        use helix_view::document::Mode;
-
-        if doc!(self.editor).mode != Mode::Insert || !self.config.editor.auto_completion {
-            return;
-        }
         let editor_view = self
             .compositor
             .find::<ui::EditorView>()
             .expect("expected at least one EditorView");
 
-        if editor_view.completion.is_some() {
+        let mut cx = crate::compositor::Context {
-            return;
-        }
-
-        let mut cx = Context {
-            register: None,
             editor: &mut self.editor,
             jobs: &mut self.jobs,
-            count: None,
+            scroll: None,
-            callback: None,
-            on_next_key_callback: None,
         };
-        idle_completion(&mut cx);
+        if let EventResult::Consumed(_) = editor_view.handle_idle_timeout(&mut cx) {
             self.render();
         }
+    }
 
     pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {
         let mut cx = crate::compositor::Context {

helix-term/src/ui/editor.rs

@@ -856,6 +856,27 @@ impl EditorView {
         doc.savepoint = None;
         editor.clear_idle_timer(); // don't retrigger
     }
+
+    pub fn handle_idle_timeout(&mut self, cx: &mut crate::compositor::Context) -> EventResult {
+        if self.completion.is_some()
+            || !cx.editor.config.auto_completion
+            || doc!(cx.editor).mode != Mode::Insert
+        {
+            return EventResult::Ignored(None);
+        }
+
+        let mut cx = commands::Context {
+            register: None,
+            editor: cx.editor,
+            jobs: cx.jobs,
+            count: None,
+            callback: None,
+            on_next_key_callback: None,
+        };
+        crate::commands::insert::idle_completion(&mut cx);
+
+        EventResult::Consumed(None)
+    }
 }
 
 impl EditorView {