mod document; mod preview; mod provider; use document::Answers; use gpui_kit::component::Root; use gpui_kit::component::input::{ Editor, EditorState, Input, InputEvent, InputState, TextDecoration, TextDecorationCollection, }; use gpui_kit::component::scroll::ScrollableElement; use gpui_kit::component::text::{TextView, TextViewStyle}; use gpui_kit::prelude::FluentBuilder; use gpui_kit::*; use std::{ collections::HashMap, fs, io::Write, path::PathBuf, process::{Command, Stdio}, }; const BG: u32 = 0x151a1e; const PAPER: u32 = 0x1b2126; const EDGE: u32 = 0x37414a; const TEXT: u32 = 0xe8eaed; const MUTED: u32 = 0x9da7af; const ACCENT: u32 = 0xf3b84b; #[derive(Clone, Copy, PartialEq)] enum Mode { Normal, Insert, Visual, } #[derive(Clone, Copy, PartialEq)] enum Provider { Codex, OpenRouter, } struct Vool { editor: Entity, active_answer: Option, rendered_answer: String, render_seq: u64, suppress_save: bool, answer_styles: TextDecorationCollection, markdown_styles: TextDecorationCollection, model_input: Entity, key_input: Entity, note_input: Entity, settings_open: bool, mode: Mode, anchor: usize, visual_head: usize, path: PathBuf, notes_dir: PathBuf, saved_text: String, answers: Answers, model: String, provider: Provider, status: String, pending: HashMap, request_seq: u64, _subscription: Subscription, } impl Vool { fn sidecar(&self) -> PathBuf { self.path.with_extension("vool.json") } fn files(dir: &PathBuf) -> Vec { let mut files: Vec<_> = fs::read_dir(dir) .into_iter() .flatten() .flatten() .map(|entry| entry.path()) .filter(|p| p.extension().is_some_and(|e| e == "md")) .collect(); files.sort(); files } fn new(window: &mut Window, cx: &mut Context) -> Self { let notes_dir = std::env::current_dir().unwrap().join("notes"); fs::create_dir_all(¬es_dir).expect("create notes directory"); let path = Self::files(¬es_dir) .first() .cloned() .unwrap_or_else(|| notes_dir.join("Welcome.md")); let saved_text = fs::read_to_string(&path).unwrap_or_else(|_| String::from( "# A place to follow your curiosity\n\nWrite a question here. Press Esc, move with h/j/k/l, then v to select a thought. Press a to ask.\n\nThe answer appears beside your note.\n" )); let answers = Answers::load(&path.with_extension("vool.json")); let active_answer = answers.items.last().map(|answer| answer.id); let editor = cx.new(|cx| { EditorState::new(window, cx) .line_number(false) .soft_wrap(true) .default_value(saved_text.clone()) }); editor.update(cx, |state, cx| state.set_readonly(true, cx)); let answer_styles = editor.update(cx, |state, cx| { state.create_decorations_collection( Self::answer_decorations(&answers, &saved_text, active_answer), cx, ) }); let markdown_styles = editor.update(cx, |state, cx| { state.create_decorations_collection(Self::markdown_decorations(&saved_text), cx) }); let model_input = cx.new(|cx| InputState::new(window, cx).placeholder("Default model")); let key_input = cx.new(|cx| { InputState::new(window, cx) .masked(true) .placeholder("Use environment key") }); let note_input = cx.new(|cx| InputState::new(window, cx).placeholder("New note name")); let _subscription = cx.subscribe(&editor, |this, _, event, cx| { if matches!(event, InputEvent::Change) && !this.suppress_save { this.save(cx); } }); let focus = editor.focus_handle(cx); window.defer(cx, move |window, cx| focus.focus(window, cx)); Self { editor, active_answer, rendered_answer: String::new(), render_seq: 0, suppress_save: false, answer_styles, markdown_styles, model_input, key_input, note_input, settings_open: false, mode: Mode::Normal, anchor: 0, visual_head: 0, path, notes_dir, saved_text, answers, model: String::new(), provider: Provider::Codex, status: "i insert · v select · a ask".into(), pending: HashMap::new(), request_seq: 0, _subscription, } } fn save(&mut self, cx: &mut Context) { let value = self.editor.read(cx).value().to_string(); self.answers.reconcile(&self.saved_text, &value); self.saved_text = value.clone(); self.refresh_answer_styles(cx); self.markdown_styles .set(Self::markdown_decorations(&value), cx); if let Err(error) = fs::write(&self.path, &self.saved_text).and_then(|_| self.answers.save(&self.sidecar())) { self.status = format!("Could not save: {error}"); } cx.notify(); } fn refresh_render(&mut self, cx: &mut Context) { self.render_seq += 1; let seq = self.render_seq; let source = self .answers .items .iter() .find(|answer| Some(answer.id) == self.active_answer) .map(|answer| answer.text.clone()) .unwrap_or_default(); let path = self.path.clone(); self.rendered_answer = source.clone(); if source.is_empty() { cx.notify(); return; } cx.spawn(async move |this, cx| { cx.background_executor() .timer(std::time::Duration::from_millis(180)) .await; let still_current = this .read_with(cx, |state, _| state.render_seq == seq) .unwrap_or(false); if !still_current { return; } let task = cx.background_spawn(async move { preview::render(&source, &path).0 }); let rendered = task.await; _ = this.update(cx, |state, cx| { if state.render_seq == seq { state.rendered_answer = rendered; cx.notify(); } }); }) .detach(); } fn answer_decorations( answers: &Answers, text: &str, active_id: Option, ) -> Vec { answers .items .iter() .filter_map(|answer| { if Some(answer.id) != active_id { return None; } text.get(answer.start..answer.end)?; Some(TextDecoration::new( answer.start..answer.end, HighlightStyle { background_color: Some(rgba(0xf3b84b44).into()), ..Default::default() }, )) }) .collect() } fn refresh_answer_styles(&self, cx: &mut Context) { self.answer_styles.set( Self::answer_decorations(&self.answers, &self.saved_text, self.active_answer), cx, ); } fn markdown_decorations(text: &str) -> Vec { use regex::Regex; use std::sync::OnceLock; static HEADINGS: OnceLock = OnceLock::new(); static BOLD: OnceLock = OnceLock::new(); static ITALIC: OnceLock = OnceLock::new(); let mut styles = Vec::new(); for capture in HEADINGS .get_or_init(|| Regex::new(r"(?m)^(#{1,6})[ \t]+([^\n]+)").unwrap()) .captures_iter(text) { styles.push(TextDecoration::new( capture.get(1).unwrap().range(), HighlightStyle { color: Some(rgb(EDGE).into()), ..Default::default() }, )); styles.push(TextDecoration::new( capture.get(2).unwrap().range(), HighlightStyle { color: Some(rgb(TEXT).into()), font_weight: Some(FontWeight::BOLD), ..Default::default() }, )); } for capture in BOLD .get_or_init(|| Regex::new(r"\*\*([^*\n]+)\*\*").unwrap()) .captures_iter(text) { styles.push(TextDecoration::new( capture.get(1).unwrap().range(), HighlightStyle { font_weight: Some(FontWeight::BOLD), ..Default::default() }, )); for marker in [ capture.get(0).unwrap().start()..capture.get(1).unwrap().start(), capture.get(1).unwrap().end()..capture.get(0).unwrap().end(), ] { styles.push(TextDecoration::new( marker, HighlightStyle { color: Some(rgb(EDGE).into()), ..Default::default() }, )); } } for capture in ITALIC .get_or_init(|| Regex::new(r"(?:^|[^*])\*([^*\n]+)\*").unwrap()) .captures_iter(text) { if text[capture.get(0).unwrap().end()..].starts_with('*') { continue; } styles.push(TextDecoration::new( capture.get(1).unwrap().range(), HighlightStyle { font_style: Some(FontStyle::Italic), ..Default::default() }, )); } styles } fn open(&mut self, path: PathBuf, window: &mut Window, cx: &mut Context) { self.save(cx); let text = fs::read_to_string(&path).unwrap_or_default(); self.answers = Answers::load(&path.with_extension("vool.json")); self.saved_text = text.clone(); self.path = path; self.pending.clear(); self.active_answer = self.answers.items.last().map(|answer| answer.id); self.settings_open = false; self.mode = Mode::Normal; self.status = "i insert · v select · a ask".into(); self.suppress_save = true; self.editor.update(cx, |state, cx| { state.set_value(text.clone(), window, cx); state.set_readonly(true, cx); state.focus(window, cx); }); self.suppress_save = false; self.refresh_answer_styles(cx); self.markdown_styles .set(Self::markdown_decorations(&text), cx); self.refresh_render(cx); cx.notify(); } fn new_note( &mut self, name: &str, window: &mut Window, cx: &mut Context, ) -> Result<(), String> { let path = if name.is_empty() { let mut n = 1; loop { let path = self.notes_dir.join(format!("Untitled {n}.md")); if !path.exists() { break path; } n += 1; } } else { if !valid_name(name) { return Err("Use a file name without slashes or dots at the start".into()); } self.notes_dir .join(format!("{}.md", name.trim_end_matches(".md"))) }; if path.exists() { return Err("That note already exists. Choose it from Notes below.".into()); } fs::write(&path, "").map_err(|error| format!("Could not create note: {error}"))?; self.open(path, window, cx); self.mode = Mode::Insert; self.editor .update(cx, |state, cx| state.set_readonly(false, cx)); self.status = "Esc normal".into(); cx.notify(); Ok(()) } fn toggle_settings(&mut self, window: &mut Window, cx: &mut Context) { self.settings_open = !self.settings_open; if self.settings_open { self.model_input .update(cx, |state, cx| state.focus(window, cx)); } else { self.editor.update(cx, |state, cx| state.focus(window, cx)); } cx.notify(); } fn create_note(&mut self, window: &mut Window, cx: &mut Context) { let name = self.note_input.read(cx).value().to_string(); if let Err(error) = self.new_note(name.trim(), window, cx) { self.status = error; } else { self.note_input .update(cx, |state, cx| state.set_value("", window, cx)); } cx.notify(); } fn set_mode(&mut self, mode: Mode, cx: &mut Context) { self.mode = mode; self.editor .update(cx, |state, cx| state.set_readonly(mode != Mode::Insert, cx)); self.status = match mode { Mode::Normal => "i insert · v select · a ask", Mode::Insert => "Esc normal", Mode::Visual => "h/j/k/l select · a ask · Esc cancel", } .into(); cx.notify(); } fn move_cursor(&mut self, key: &str, cx: &mut Context) { let text = self.editor.read(cx).value().to_string(); let range = self.editor.read(cx).selected_range(); let cursor = if self.mode == Mode::Visual { self.visual_head } else { range.start } .min(text.len()); let cursor = text.floor_char_boundary(cursor); let next = match key { "h" => text[..cursor].char_indices().last().map_or(0, |(i, _)| i), "l" => cursor + text[cursor..].chars().next().map_or(0, char::len_utf8), "0" => text[..cursor].rfind('\n').map_or(0, |i| i + 1), "$" => text[cursor..].find('\n').map_or(text.len(), |i| cursor + i), "j" | "k" => { let start = text[..cursor].rfind('\n').map_or(0, |i| i + 1); let col = cursor - start; let line = if key == "j" { let Some(i) = text[cursor..].find('\n') else { return; }; cursor + i + 1 } else { if start == 0 { return; } text[..start - 1].rfind('\n').map_or(0, |i| i + 1) }; let end = text[line..].find('\n').map_or(text.len(), |i| line + i); (line + col.min(end - line)).min(text.len()) } _ => return, }; let next = text.floor_char_boundary(next); let range = if self.mode == Mode::Visual { self.visual_head = next; self.anchor.min(next)..self.anchor.max(next) } else { next..next }; self.editor .update(cx, |state, cx| state.set_selected_range(range, cx)); cx.notify(); } fn on_key(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context) { let key = event.keystroke.key.as_str(); if key == "escape" { cx.stop_propagation(); self.settings_open = false; self.set_mode(Mode::Normal, cx); self.editor.update(cx, |state, cx| state.focus(window, cx)); return; } if self.settings_open || self.mode == Mode::Insert { return; } match key { "s" if self.mode == Mode::Normal => { cx.stop_propagation(); self.toggle_settings(window, cx); } "i" if self.mode == Mode::Normal => { cx.stop_propagation(); self.set_mode(Mode::Insert, cx); } "v" if self.mode == Mode::Normal => { cx.stop_propagation(); self.anchor = self.editor.read(cx).selected_range().start; self.visual_head = self.anchor; self.set_mode(Mode::Visual, cx); } "a" if self.mode == Mode::Visual => { cx.stop_propagation(); self.ask(window, cx); } "h" | "j" | "k" | "l" | "0" | "$" => { cx.stop_propagation(); self.move_cursor(key, cx); } _ => {} } } fn write_answer(&mut self, id: u64, body: &str, cx: &mut Context) { let Some(answer) = self.answers.items.iter_mut().find(|a| a.id == id) else { return; }; answer.text = body.into(); if let Err(error) = self.answers.save(&self.sidecar()) { self.status = format!("Could not save: {error}"); } if self.active_answer == Some(id) { self.refresh_render(cx); } cx.notify(); } fn ask(&mut self, window: &mut Window, cx: &mut Context) { let range = self.editor.read(cx).selected_range(); let prompt = self.editor.read(cx).selected_value().to_string(); if prompt.trim().is_empty() { return; } let model = self.model.clone(); let selected_model = if model.is_empty() && self.provider == Provider::OpenRouter { provider::OPENROUTER_MODEL } else if model.is_empty() { "codex default" } else { &model }; let id = self.answers.ask(range, &prompt, selected_model); self.active_answer = Some(id); self.refresh_answer_styles(cx); self.request_seq += 1; let request = self.request_seq; self.pending.insert(id, request); let path = self.path.clone(); self.write_answer(id, "Thinking…", cx); self.set_mode(Mode::Normal, cx); self.status = if self.provider == Provider::Codex { "Asking Codex…" } else { "Asking OpenRouter…" } .into(); let model = self.model.clone(); let provider = self.provider; let key = self.key_input.read(cx).value().to_string(); let task = cx.background_spawn(async move { match provider { Provider::Codex => codex_answer(&prompt, &model), Provider::OpenRouter => provider::openrouter_answer( &prompt, if model.is_empty() { provider::OPENROUTER_MODEL } else { &model }, if key.is_empty() { None } else { Some(&key) }, ), } }); cx.spawn_in(window, async move |this, window| { let result = task.await; _ = window.update(|_, cx| { _ = this.update(cx, |this, cx| { if this.path != path || this.pending.get(&id) != Some(&request) { return; } this.pending.remove(&id); let failed = result.is_err(); let body = result.unwrap_or_else(|err| format!("Answer unavailable: {err}")); this.write_answer(id, &body, cx); this.status = if failed { "Answer failed · check the answer pane and retry".into() } else { "Answer ready · reselect question and press a to regenerate".into() }; cx.notify(); }); }); }) .detach(); } } fn codex_answer(prompt: &str, model: &str) -> Result { let mut command = Command::new("codex"); command.args(["exec", "--sandbox", "read-only", "--skip-git-repo-check"]); if !model.is_empty() { command.args(["--model", model]); } let mut child = command .arg("-") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .spawn() .map_err(|e| format!("{e}. Install Codex CLI and run `codex login`"))?; let instruction = format!( "You are a thoughtful tutor in a learning notebook. Answer the selected question directly and clearly. Use Markdown. Do not edit files or run tools.\n\nSelected question:\n{prompt}" ); child .stdin .take() .unwrap() .write_all(instruction.as_bytes()) .map_err(|e| e.to_string())?; let output = child.wait_with_output().map_err(|e| e.to_string())?; if output.status.success() { Ok(String::from_utf8_lossy(&output.stdout).trim().to_string()) } else { Err(String::from_utf8_lossy(&output.stderr) .chars() .take(500) .collect()) } } fn valid_name(name: &str) -> bool { !name.is_empty() && !name.starts_with('.') && !name.contains(['/', '\\', '\0']) && name != "." && name != ".." } #[cfg(test)] mod command_tests { use super::{Vool, valid_name}; #[test] fn note_names_cannot_escape_notes_directory() { assert!(valid_name("Thermodynamics")); assert!(valid_name("Question 1.md")); assert!(!valid_name("../secrets")); assert!(!valid_name(".hidden")); assert!(!valid_name("folder/note")); } #[test] fn markdown_styles_use_utf8_byte_ranges() { let source = "# Café\nA **bold** and *italic* idea"; let decorations = Vool::markdown_decorations(source); let styled: Vec<_> = decorations .iter() .map(|decoration| &source[decoration.range.clone()]) .collect(); assert!(styled.contains(&"Café")); assert!(styled.contains(&"bold")); assert!(styled.contains(&"italic")); assert!(styled.contains(&"**")); } } impl Render for Vool { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { let title = self .path .file_stem() .unwrap_or_default() .to_string_lossy() .to_string(); let selected = self.editor.read(cx).selected_range().len() > 0; let header = div() .h(px(44.)) .px_6() .flex() .items_center() .justify_between() .border_b_1() .border_color(rgb(EDGE)) .text_sm() .child( div() .flex() .items_center() .gap_5() .child(format!("{title}.md")) .child(div().text_color(rgb(EDGE)).child("│")) .child( div() .text_color(rgb(MUTED)) .child(if self.model.is_empty() { if self.provider == Provider::Codex { "Codex default".to_string() } else { provider::OPENROUTER_MODEL.to_string() } } else { self.model.clone() }), ), ) .child( div() .flex() .items_center() .gap_6() .child(div().text_xs().text_color(rgb(MUTED)).child(format!( "{} words", self.saved_text.split_whitespace().count() ))) .child( div() .id("settings-button") .cursor_pointer() .text_color(rgb(TEXT)) .child(if self.settings_open { "Back" } else { "☰" }) .on_click( cx.listener(|this, _, window, cx| this.toggle_settings(window, cx)), ), ), ); let answer = self .answers .items .iter() .find(|answer| Some(answer.id) == self.active_answer); let answer_pane = div() .w(px(410.)) .h_full() .min_h_0() .border_l_1() .border_color(rgb(EDGE)) .bg(rgb(BG)) .font_family("Noto Sans Mono") .child( div() .id("answer-scroll") .size_full() .overflow_y_scrollbar() .child( div() .px_6() .py_7() .flex() .flex_col() .gap_5() .child( div() .flex() .justify_between() .items_center() .child(div().font_weight(FontWeight::SEMIBOLD).child("Answer")) .child( div() .id("close-answer") .cursor_pointer() .text_color(rgb(MUTED)) .child("×") .on_click(cx.listener(|this, _, _, cx| { this.active_answer = None; this.refresh_answer_styles(cx); this.refresh_render(cx); })), ), ) .when_some(answer, |this, answer| { this.child(div().text_sm().child(answer.prompt.clone())) .child( div() .p_4() .rounded_md() .border_1() .border_color(rgb(EDGE)) .bg(rgb(PAPER)) .child( TextView::markdown( format!("answer-{}", answer.id), self.rendered_answer.clone(), ) .style(TextViewStyle { heading_base_font_size: px(20.), ..Default::default() }) .text_color(rgb(TEXT)) .text_size(px(14.)) .w_full(), ), ) }) .when(answer.is_none(), |this| { this.child( div().text_sm().text_color(rgb(MUTED)).child( "Select a question in your note, then press a to ask.", ), ) }) .when(self.answers.items.len() > 1, |this| { this.child(div().pt_4().text_color(rgb(MUTED)).child("Related")) .children( self.answers .items .iter() .filter(|item| Some(item.id) != self.active_answer) .map(|item| { let id = item.id; div() .id(format!("related-{id}")) .cursor_pointer() .text_sm() .child(item.prompt.clone()) .on_click(cx.listener(move |this, _, _, cx| { this.active_answer = Some(id); this.refresh_answer_styles(cx); this.refresh_render(cx); })) }), ) }), ), ); let center = div() .flex_1() .min_h_0() .min_w_0() .flex() .bg(rgb(PAPER)) .child( div() .flex_1() .min_h_0() .min_w_0() .px(px(66.)) .py(px(42.)) .child( Editor::new(&self.editor) .appearance(false) .bordered(false) .readonly(self.mode != Mode::Insert) .font_family("Noto Sans Mono") .text_color(rgb(TEXT)) .text_size(px(17.)) .size_full(), ), ) .child(answer_pane); let settings = div().flex_1().min_h_0().bg(rgb(PAPER)) .child(div().id("settings-scroll").size_full().px(px(120.)).py(px(46.)).overflow_y_scrollbar() .child(div().flex().flex_col().gap_6().w_full() .child(div().text_3xl().font_weight(FontWeight::SEMIBOLD).child("Settings")) .child(div().text_sm().text_color(rgb(MUTED)).child("Notes save locally. AI choices apply for this session.")) .child(div().flex().gap_10().pt_6() .child(div().flex().flex_col().gap_5().w(px(540.)) .child(div().text_lg().font_weight(FontWeight::SEMIBOLD).child("AI provider")) .child(div().flex().gap_3() .child(div().id("provider-codex").px_4().py_2().rounded_md().cursor_pointer() .bg(rgb(if self.provider == Provider::Codex { ACCENT } else { BG })) .text_color(rgb(if self.provider == Provider::Codex { PAPER } else { TEXT })) .child("Codex") .on_click(cx.listener(|this, _, _, cx| { this.provider = Provider::Codex; this.model.clear(); cx.notify(); }))) .child(div().id("provider-openrouter").px_4().py_2().rounded_md().cursor_pointer() .bg(rgb(if self.provider == Provider::OpenRouter { ACCENT } else { BG })) .text_color(rgb(if self.provider == Provider::OpenRouter { PAPER } else { TEXT })) .child("OpenRouter") .on_click(cx.listener(|this, _, _, cx| { this.provider = Provider::OpenRouter; this.model.clear(); cx.notify(); })))) .child(div().text_sm().text_color(rgb(MUTED)).child(format!("Default model: {}", if self.provider == Provider::Codex { "Codex CLI default" } else { provider::OPENROUTER_MODEL }))) .child(div().flex().gap_3().items_center() .child(Input::new(&self.model_input).w(px(440.))) .child(div().id("use-model").px_4().py_2().rounded_md().bg(rgb(ACCENT)).text_color(rgb(PAPER)).cursor_pointer().child("Use model") .on_click(cx.listener(|this, _, _, cx| { this.model = this.model_input.read(cx).value().trim().to_string(); cx.notify(); }))) .child(div().id("default-model").px_3().py_2().cursor_pointer().child("Default") .on_click(cx.listener(|this, _, _, cx| { this.model.clear(); cx.notify(); })))) .child(div().text_sm().text_color(rgb(MUTED)).child(format!("Selected: {}", if self.model.is_empty() { "provider default" } else { &self.model }))) .child(div().pt_4().text_lg().font_weight(FontWeight::SEMIBOLD).child("OpenRouter key")) .child(Input::new(&self.key_input).w(px(540.))) .child(div().text_sm().text_color(rgb(MUTED)).child(if std::env::var_os("OPENROUTER_API_KEY").is_some() { "Environment key available. A key typed here overrides it for this session only." } else { "No environment key found. A key typed here is used for this session only." })) ) .child(div().flex().flex_col().gap_4().flex_1() .child(div().text_lg().font_weight(FontWeight::SEMIBOLD).child("Notes")) .child(div().flex().gap_3().items_center() .child(Input::new(&self.note_input).flex_1()) .child(div().id("create-note").px_4().py_2().rounded_md().bg(rgb(ACCENT)).text_color(rgb(PAPER)).cursor_pointer().child("Create note") .on_click(cx.listener(|this, _, window, cx| this.create_note(window, cx))))) .children(Self::files(&self.notes_dir).into_iter().map(|path| { let label = path.file_stem().unwrap_or_default().to_string_lossy().to_string(); div().id(format!("note-{label}")).px_3().py_2().rounded_sm().cursor_pointer().bg(rgb(BG)) .child(label).on_click(cx.listener(move |this, _, window, cx| this.open(path.clone(), window, cx))) })))))); let mode = match self.mode { Mode::Normal => "NORMAL", Mode::Insert => "INSERT", Mode::Visual => "VISUAL", }; let cursor = self .editor .read(cx) .selected_range() .start .min(self.saved_text.len()); let before_cursor = &self.saved_text[..self.saved_text.floor_char_boundary(cursor)]; let line = before_cursor.bytes().filter(|byte| *byte == b'\n').count() + 1; let column = before_cursor .rsplit('\n') .next() .unwrap_or("") .chars() .count() + 1; let footer = div() .h(px(42.)) .px_8() .flex() .items_center() .gap_4() .border_t_1() .border_color(rgb(EDGE)) .font_family("Noto Sans Mono") .text_xs() .child( div() .text_color(rgb(ACCENT)) .font_weight(FontWeight::BOLD) .child(mode), ) .child(div().text_color(rgb(MUTED)).child(self.status.clone())) .child(div().flex_1()) .when(selected && !self.settings_open, |this| { this.child( div() .id("ask-selection") .px_3() .py_1() .rounded_sm() .bg(rgb(ACCENT)) .text_color(rgb(PAPER)) .cursor_pointer() .child("Ask selection ↗") .on_click(cx.listener(|this, _, window, cx| this.ask(window, cx))), ) }) .child( div() .text_color(rgb(MUTED)) .child(format!("Ln {line}, Col {column} 100%")), ); let block_cursor = if !self.settings_open && self.mode == Mode::Normal && !selected && self.editor.focus_handle(cx).is_focused(_window) { self.editor.read(cx).cursor_layout().map(|(bounds, _)| { div() .absolute() .left(bounds.origin.x) .top(bounds.origin.y) .w(px(10.)) .h(bounds.size.height) .bg(rgba(0xf3b84b99)) }) } else { None }; div() .size_full() .flex() .flex_col() .bg(rgb(BG)) .text_color(rgb(TEXT)) .font_family("Noto Sans") .capture_key_down(cx.listener(Self::on_key)) .child(header) .child(if self.settings_open { settings } else { center }) .child(footer) .when_some(block_cursor, |this, cursor| this.child(cursor)) } } fn main() { gpui_kit::application().run(|cx| { gpui_kit::init(cx); gpui_kit::component::theme::Theme::change( gpui_kit::component::theme::ThemeMode::Dark, None, cx, ); let bounds = WindowBounds::centered(size(px(1320.), px(820.)), cx); cx.spawn(async move |cx| { cx.open_window( WindowOptions { window_bounds: Some(bounds), ..Default::default() }, |window, cx| { let view = cx.new(|cx| Vool::new(window, cx)); view.update(cx, |this, cx| this.refresh_render(cx)); cx.new(|cx| Root::new(view, window, cx)) }, ) .expect("open Vool window"); }) .detach(); }); }