aboutsummaryrefslogtreecommitdiff
path: root/helix-term/src
diff options
context:
space:
mode:
Diffstat (limited to 'helix-term/src')
-rw-r--r--helix-term/src/application.rs189
-rw-r--r--helix-term/src/commands.rs130
-rw-r--r--helix-term/src/commands/dap.rs834
-rw-r--r--helix-term/src/keymap.rs20
-rw-r--r--helix-term/src/ui/editor.rs115
-rw-r--r--helix-term/src/ui/mod.rs6
-rw-r--r--helix-term/src/ui/picker.rs12
-rw-r--r--helix-term/src/ui/text.rs21
8 files changed, 1272 insertions, 55 deletions
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 8f405ce5..52a5321f 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -1,11 +1,12 @@
use helix_core::{merge_toml_values, pos_at_coords, syntax, Selection};
+use helix_dap::{self as dap, Payload, Request};
use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
-use helix_view::{theme, Editor};
+use helix_view::{editor::Breakpoint, theme, Editor};
use serde_json::json;
use crate::{
args::Args,
- commands::{align_view, apply_workspace_edit, Align},
+ commands::{align_view, apply_workspace_edit, fetch_stack_trace, Align},
compositor::Compositor,
config::Config,
job::Jobs,
@@ -13,7 +14,6 @@ use crate::{
};
use log::{error, warn};
-
use std::{
io::{stdin, stdout, Write},
sync::Arc,
@@ -245,6 +245,9 @@ impl Application {
last_render = Instant::now();
}
}
+ Some(payload) = self.editor.debugger_events.next() => {
+ self.handle_debugger_message(payload).await;
+ }
Some(callback) = self.jobs.futures.next() => {
self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
self.render();
@@ -339,6 +342,186 @@ impl Application {
}
}
+ pub async fn handle_debugger_message(&mut self, payload: helix_dap::Payload) {
+ use crate::commands::dap::{breakpoints_changed, resume_application, select_thread_id};
+ use dap::requests::RunInTerminal;
+ use helix_dap::{events, Event};
+
+ let debugger = match self.editor.debugger.as_mut() {
+ Some(debugger) => debugger,
+ None => return,
+ };
+ match payload {
+ Payload::Event(ev) => match *ev {
+ Event::Stopped(events::Stopped {
+ thread_id,
+ description,
+ text,
+ reason,
+ all_threads_stopped,
+ ..
+ }) => {
+ let all_threads_stopped = all_threads_stopped.unwrap_or_default();
+
+ if all_threads_stopped {
+ if let Ok(response) = debugger.request::<dap::requests::Threads>(()).await {
+ for thread in response.threads {
+ fetch_stack_trace(debugger, thread.id).await;
+ }
+ select_thread_id(
+ &mut self.editor,
+ thread_id.unwrap_or_default(),
+ false,
+ )
+ .await;
+ }
+ } else if let Some(thread_id) = thread_id {
+ debugger.thread_states.insert(thread_id, reason.clone()); // TODO: dap uses "type" || "reason" here
+
+ // whichever thread stops is made "current" (if no previously selected thread).
+ select_thread_id(&mut self.editor, thread_id, false).await;
+ }
+
+ let scope = match thread_id {
+ Some(id) => format!("Thread {}", id),
+ None => "Target".to_owned(),
+ };
+
+ let mut status = format!("{} stopped because of {}", scope, reason);
+ if let Some(desc) = description {
+ status.push_str(&format!(" {}", desc));
+ }
+ if let Some(text) = text {
+ status.push_str(&format!(" {}", text));
+ }
+ if all_threads_stopped {
+ status.push_str(" (all threads stopped)");
+ }
+
+ self.editor.set_status(status);
+ }
+ Event::Continued(events::Continued { thread_id, .. }) => {
+ debugger
+ .thread_states
+ .insert(thread_id, "running".to_owned());
+ if debugger.thread_id == Some(thread_id) {
+ resume_application(debugger)
+ }
+ }
+ Event::Thread(_) => {
+ // TODO: update thread_states, make threads request
+ }
+ Event::Breakpoint(events::Breakpoint { reason, breakpoint }) => {
+ match &reason[..] {
+ "new" => {
+ if let Some(source) = breakpoint.source {
+ self.editor
+ .breakpoints
+ .entry(source.path.unwrap()) // TODO: no unwraps
+ .or_default()
+ .push(Breakpoint {
+ id: breakpoint.id,
+ verified: breakpoint.verified,
+ message: breakpoint.message,
+ line: breakpoint.line.unwrap().saturating_sub(1), // TODO: no unwrap
+ column: breakpoint.column,
+ ..Default::default()
+ });
+ }
+ }
+ "changed" => {
+ for breakpoints in self.editor.breakpoints.values_mut() {
+ if let Some(i) =
+ breakpoints.iter().position(|b| b.id == breakpoint.id)
+ {
+ breakpoints[i].verified = breakpoint.verified;
+ breakpoints[i].message = breakpoint.message.clone();
+ breakpoints[i].line =
+ breakpoint.line.unwrap().saturating_sub(1); // TODO: no unwrap
+ breakpoints[i].column = breakpoint.column;
+ }
+ }
+ }
+ "removed" => {
+ for breakpoints in self.editor.breakpoints.values_mut() {
+ if let Some(i) =
+ breakpoints.iter().position(|b| b.id == breakpoint.id)
+ {
+ breakpoints.remove(i);
+ }
+ }
+ }
+ reason => {
+ warn!("Unknown breakpoint event: {}", reason);
+ }
+ }
+ }
+ Event::Output(events::Output {
+ category, output, ..
+ }) => {
+ let prefix = match category {
+ Some(category) => {
+ if &category == "telemetry" {
+ return;
+ }
+ format!("Debug ({}):", category)
+ }
+ None => "Debug:".to_owned(),
+ };
+
+ log::info!("{}", output);
+ self.editor.set_status(format!("{} {}", prefix, output));
+ }
+ Event::Initialized => {
+ // send existing breakpoints
+ for (path, breakpoints) in &mut self.editor.breakpoints {
+ // TODO: call futures in parallel, await all
+ let _ = breakpoints_changed(debugger, path.clone(), breakpoints);
+ }
+ // TODO: fetch breakpoints (in case we're attaching)
+
+ if debugger.configuration_done().await.is_ok() {
+ self.editor
+ .set_status("Debugged application started".to_owned());
+ }; // TODO: do we need to handle error?
+ }
+ ev => {
+ log::warn!("Unhandled event {:?}", ev);
+ return; // return early to skip render
+ }
+ },
+ Payload::Response(_) => unreachable!(),
+ Payload::Request(request) => match request.command.as_str() {
+ RunInTerminal::COMMAND => {
+ let arguments: dap::requests::RunInTerminalArguments =
+ serde_json::from_value(request.arguments.unwrap_or_default()).unwrap();
+ // TODO: no unwrap
+
+ // TODO: handle cwd
+ let process = std::process::Command::new("tmux")
+ .arg("split-window")
+ .arg(arguments.args.join(" ")) // TODO: first arg is wrong, it uses current dir
+ .spawn()
+ .unwrap();
+
+ let _ = debugger
+ .reply(
+ request.seq,
+ dap::requests::RunInTerminal::COMMAND,
+ serde_json::to_value(dap::requests::RunInTerminalResponse {
+ process_id: Some(process.id()),
+ shell_process_id: None,
+ })
+ .map_err(|e| e.into()),
+ )
+ .await;
+ }
+ _ => log::error!("DAP reverse request not implemented: {:?}", request),
+ },
+ }
+ self.render();
+ }
+
pub async fn handle_language_server_message(
&mut self,
call: helix_lsp::Call,
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index ded5a0e4..677943e8 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -1,3 +1,7 @@
+pub(crate) mod dap;
+
+pub use dap::*;
+
use helix_core::{
comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes,
history::UndoKind,
@@ -45,8 +49,8 @@ use crate::{
use crate::job::{self, Job, Jobs};
use futures_util::{FutureExt, StreamExt};
+use std::{collections::HashMap, fmt, future::Future};
use std::{collections::HashSet, num::NonZeroUsize};
-use std::{fmt, future::Future};
use std::{
borrow::Cow,
@@ -115,13 +119,13 @@ impl<'a> Context<'a> {
}
}
-pub(crate) enum Align {
+pub enum Align {
Top,
Center,
Bottom,
}
-pub(crate) fn align_view(doc: &Document, view: &mut View, align: Align) {
+pub fn align_view(doc: &Document, view: &mut View, align: Align) {
let pos = doc
.selection(view.id)
.primary()
@@ -394,6 +398,21 @@ impl MappableCommand {
surround_delete, "Surround delete",
select_textobject_around, "Select around object",
select_textobject_inner, "Select inside object",
+ dap_launch, "Launch debug target",
+ dap_toggle_breakpoint, "Toggle breakpoint",
+ dap_continue, "Continue program execution",
+ dap_pause, "Pause program execution",
+ dap_step_in, "Step in",
+ dap_step_out, "Step out",
+ dap_next, "Step to next",
+ dap_variables, "List variables",
+ dap_terminate, "End debug session",
+ dap_edit_condition, "Edit condition of the breakpoint on the current line",
+ dap_edit_log, "Edit log message of the breakpoint on the current line",
+ dap_switch_thread, "Switch current thread",
+ dap_switch_stack_frame, "Switch stack frame",
+ dap_enable_exceptions, "Enable exception breakpoints",
+ dap_disable_exceptions, "Disable exception breakpoints",
shell_pipe, "Pipe selections through shell command",
shell_pipe_to, "Pipe selections into shell command, ignoring command output",
shell_insert_output, "Insert output of shell command before each selection",
@@ -1550,7 +1569,6 @@ fn search_completions(cx: &mut Context, reg: Option<char>) -> Vec<String> {
items.into_iter().cloned().collect()
}
-// TODO: use one function for search vs extend
fn search(cx: &mut Context) {
searcher(cx, Direction::Forward)
}
@@ -1558,7 +1576,7 @@ fn search(cx: &mut Context) {
fn rsearch(cx: &mut Context) {
searcher(cx, Direction::Backward)
}
-// TODO: use one function for search vs extend
+
fn searcher(cx: &mut Context, direction: Direction) {
let reg = cx.register.unwrap_or('/');
let scrolloff = cx.editor.config.scrolloff;
@@ -1783,11 +1801,11 @@ fn global_search(cx: &mut Context) {
relative_path.into()
}
},
- move |editor: &mut Editor, (line_num, path), action| {
- match editor.open(path.into(), action) {
+ move |cx, (line_num, path), action| {
+ match cx.editor.open(path.into(), action) {
Ok(_) => {}
Err(e) => {
- editor.set_error(format!(
+ cx.editor.set_error(format!(
"Failed to open file '{}': {}",
path.display(),
e
@@ -1797,7 +1815,7 @@ fn global_search(cx: &mut Context) {
}
let line_num = *line_num;
- let (view, doc) = current!(editor);
+ let (view, doc) = current!(cx.editor);
let text = doc.text();
let start = text.line_to_char(line_num);
let end = text.line_to_char((line_num + 1).min(text.len_lines()));
@@ -2000,7 +2018,6 @@ fn append_mode(cx: &mut Context) {
pub mod cmd {
use super::*;
- use std::collections::HashMap;
use helix_view::editor::Action;
use ui::completers::{self, Completer};
@@ -2680,6 +2697,58 @@ pub mod cmd {
Ok(())
}
+ fn debug_eval(
+ cx: &mut compositor::Context,
+ args: &[Cow<str>],
+ _event: PromptEvent,
+ ) -> anyhow::Result<()> {
+ if let Some(debugger) = cx.editor.debugger.as_mut() {
+ let (frame, thread_id) = match (debugger.active_frame, debugger.thread_id) {
+ (Some(frame), Some(thread_id)) => (frame, thread_id),
+ _ => {
+ bail!("Cannot find current stack frame to access variables")
+ }
+ };
+
+ // TODO: support no frame_id
+
+ let frame_id = debugger.stack_frames[&thread_id][frame].id;
+ let response = block_on(debugger.eval(args.join(" "), Some(frame_id)))?;
+ cx.editor.set_status(response.result);
+ }
+ Ok(())
+ }
+
+ fn debug_start(
+ cx: &mut compositor::Context,
+ args: &[Cow<str>],
+ _event: PromptEvent,
+ ) -> anyhow::Result<()> {
+ let mut args = args.to_owned();
+ let name = match args.len() {
+ 0 => None,
+ _ => Some(args.remove(0)),
+ };
+ dap_start_impl(cx, name.as_deref(), None, Some(args))
+ }
+
+ fn debug_remote(
+ cx: &mut compositor::Context,
+ args: &[Cow<str>],
+ _event: PromptEvent,
+ ) -> anyhow::Result<()> {
+ let mut args = args.to_owned();
+ let address = match args.len() {
+ 0 => None,
+ _ => Some(args.remove(0).parse()?),
+ };
+ let name = match args.len() {
+ 0 => None,
+ _ => Some(args.remove(0)),
+ };
+ dap_start_impl(cx, name.as_deref(), address, Some(args))
+ }
+
fn tutor(
cx: &mut compositor::Context,
_args: &[Cow<str>],
@@ -3095,6 +3164,27 @@ pub mod cmd {
completer: None,
},
TypableCommand {
+ name: "debug-start",
+ aliases: &["dbg"],
+ doc: "Start a debug session from a given template with given parameters.",
+ fun: debug_start,
+ completer: None,
+ },
+ TypableCommand {
+ name: "debug-remote",
+ aliases: &["dbg-tcp"],
+ doc: "Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters.",
+ fun: debug_remote,
+ completer: None,
+ },
+ TypableCommand {
+ name: "debug-eval",
+ aliases: &[],
+ doc: "Evaluate expression in current debug context.",
+ fun: debug_eval,
+ completer: None,
+ },
+ TypableCommand {
name: "vsplit",
aliases: &["vs"],
doc: "Open the file in a vertical split.",
@@ -3325,8 +3415,8 @@ fn buffer_picker(cx: &mut Context) {
.map(|(_, doc)| new_meta(doc))
.collect(),
BufferMeta::format,
- |editor: &mut Editor, meta, action| {
- editor.switch(meta.id, action);
+ |cx, meta, action| {
+ cx.editor.switch(meta.id, action);
},
|editor, meta| {
let doc = &editor.documents.get(&meta.id)?;
@@ -3393,9 +3483,9 @@ fn symbol_picker(cx: &mut Context) {
let mut picker = FilePicker::new(
symbols,
|symbol| (&symbol.name).into(),
- move |editor: &mut Editor, symbol, _action| {
- push_jump(editor);
- let (view, doc) = current!(editor);
+ move |cx, symbol, _action| {
+ push_jump(cx.editor);
+ let (view, doc) = current!(cx.editor);
if let Some(range) =
lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
@@ -3452,10 +3542,10 @@ fn workspace_symbol_picker(cx: &mut Context) {
format!("{} ({})", &symbol.name, relative_path).into()
}
},
- move |editor: &mut Editor, symbol, action| {
+ move |cx, symbol, action| {
let path = symbol.location.uri.to_file_path().unwrap();
- editor.open(path, action).expect("editor.open failed");
- let (view, doc) = current!(editor);
+ cx.editor.open(path, action).expect("editor.open failed");
+ let (view, doc) = current!(cx.editor);
if let Some(range) =
lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
@@ -4127,9 +4217,7 @@ fn goto_impl(
let line = location.range.start.line;
format!("{}:{}", file, line).into()
},
- move |editor: &mut Editor, location, action| {
- jump_to(editor, location, offset_encoding, action)
- },
+ move |cx, location, action| jump_to(cx.editor, location, offset_encoding, action),
|_editor, location| {
let path = location.uri.to_file_path().unwrap();
let line = Some((
diff --git a/helix-term/src/commands/dap.rs b/helix-term/src/commands/dap.rs
new file mode 100644
index 00000000..c73f9611
--- /dev/null
+++ b/helix-term/src/commands/dap.rs
@@ -0,0 +1,834 @@
+use super::{align_view, Align, Context, Editor};
+use crate::{
+ compositor::{self, Compositor},
+ job::{Callback, Jobs},
+ ui::{self, FilePicker, Picker, Popup, Prompt, PromptEvent, Text},
+};
+use helix_core::{
+ syntax::{DebugArgumentValue, DebugConfigCompletion},
+ Selection,
+};
+use helix_dap::{self as dap, Client, ThreadId};
+use helix_lsp::block_on;
+use helix_view::editor::Breakpoint;
+
+use serde_json::{to_value, Value};
+use tokio_stream::wrappers::UnboundedReceiverStream;
+
+use std::collections::HashMap;
+use std::future::Future;
+use std::path::PathBuf;
+
+use anyhow::{anyhow, bail};
+
+#[macro_export]
+macro_rules! debugger {
+ ($editor:expr) => {{
+ match &mut $editor.debugger {
+ Some(debugger) => debugger,
+ None => return,
+ }
+ }};
+}
+
+// general utils:
+pub fn dap_pos_to_pos(doc: &helix_core::Rope, line: usize, column: usize) -> Option<usize> {
+ // 1-indexing to 0 indexing
+ let line = doc.try_line_to_char(line - 1).ok()?;
+ let pos = line + column.saturating_sub(1);
+ // TODO: this is probably utf-16 offsets
+ Some(pos)
+}
+
+pub fn resume_application(debugger: &mut Client) {
+ if let Some(thread_id) = debugger.thread_id {
+ debugger
+ .thread_states
+ .insert(thread_id, "running".to_string());
+ debugger.stack_frames.remove(&thread_id);
+ }
+ debugger.active_frame = None;
+ debugger.thread_id = None;
+}
+
+pub async fn select_thread_id(editor: &mut Editor, thread_id: ThreadId, force: bool) {
+ let debugger = debugger!(editor);
+
+ if !force && debugger.thread_id.is_some() {
+ return;
+ }
+
+ debugger.thread_id = Some(thread_id);
+ fetch_stack_trace(debugger, thread_id).await;
+
+ let frame = debugger.stack_frames[&thread_id].get(0).cloned();
+ if let Some(frame) = &frame {
+ jump_to_stack_frame(editor, frame);
+ }
+}
+
+pub async fn fetch_stack_trace(debugger: &mut Client, thread_id: ThreadId) {
+ let (frames, _) = match debugger.stack_trace(thread_id).await {
+ Ok(frames) => frames,
+ Err(_) => return,
+ };
+ debugger.stack_frames.insert(thread_id, frames);
+ debugger.active_frame = Some(0);
+}
+
+pub fn jump_to_stack_frame(editor: &mut Editor, frame: &helix_dap::StackFrame) {
+ let path = if let Some(helix_dap::Source {
+ path: Some(ref path),
+ ..
+ }) = frame.source
+ {
+ path.clone()
+ } else {
+ return;
+ };
+
+ if let Err(e) = editor.open(path, helix_view::editor::Action::Replace) {
+ editor.set_error(format!("Unable to jump to stack frame: {}", e));
+ return;
+ }
+
+ let (view, doc) = current!(editor);
+
+ let text_end = doc.text().len_chars().saturating_sub(1);
+ let start = dap_pos_to_pos(doc.text(), frame.line, frame.column).unwrap_or(0);
+ let end = frame
+ .end_line
+ .and_then(|end_line| dap_pos_to_pos(doc.text(), end_line, frame.end_column.unwrap_or(0)))
+ .unwrap_or(start);
+
+ let selection = Selection::single(start.min(text_end), end.min(text_end));
+ doc.set_selection(view.id, selection);
+ align_view(doc, view, Align::Center);
+}
+
+fn thread_picker(
+ cx: &mut Context,
+ callback_fn: impl Fn(&mut Editor, &dap::Thread) + Send + 'static,
+) {
+ let debugger = debugger!(cx.editor);
+
+ let future = debugger.threads();
+ dap_callback(
+ cx.jobs,
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: dap::requests::ThreadsResponse| {
+ let threads = response.threads;
+ if threads.len() == 1 {
+ callback_fn(editor, &threads[0]);
+ return;
+ }
+ let debugger = debugger!(editor);
+
+ let thread_states = debugger.thread_states.clone();
+ let picker = FilePicker::new(
+ threads,
+ move |thread| {
+ format!(
+ "{} ({})",
+ thread.name,
+ thread_states
+ .get(&thread.id)
+ .map(|state| state.as_str())
+ .unwrap_or("unknown")
+ )
+ .into()
+ },
+ move |cx, thread, _action| callback_fn(cx.editor, thread),
+ move |editor, thread| {
+ let frames = editor.debugger.as_ref()?.stack_frames.get(&thread.id)?;
+ let frame = frames.get(0)?;
+ let path = frame.source.as_ref()?.path.clone()?;
+ let pos = Some((
+ frame.line.saturating_sub(1),
+ frame.end_line.unwrap_or(frame.line).saturating_sub(1),
+ ));
+ Some((path, pos))
+ },
+ );
+ compositor.push(Box::new(picker));
+ },
+ );
+}
+
+fn get_breakpoint_at_current_line(editor: &mut Editor) -> Option<(usize, Breakpoint)> {
+ let (view, doc) = current!(editor);
+ let text = doc.text().slice(..);
+
+ let line = doc.selection(view.id).primary().cursor_line(text);
+ let path = doc.path()?;
+ editor.breakpoints.get(path).and_then(|breakpoints| {
+ let i = breakpoints.iter().position(|b| b.line == line);
+ i.map(|i| (i, breakpoints[i].clone()))
+ })
+}
+
+// -- DAP
+
+fn dap_callback<T, F>(
+ jobs: &mut Jobs,
+ call: impl Future<Output = helix_dap::Result<serde_json::Value>> + 'static + Send,
+ callback: F,
+) where
+ T: for<'de> serde::Deserialize<'de> + Send + 'static,
+ F: FnOnce(&mut Editor, &mut Compositor, T) + Send + 'static,
+{
+ let callback = Box::pin(async move {
+ let json = call.await?;
+ let response = serde_json::from_value(json)?;
+ let call: Callback = Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {
+ callback(editor, compositor, response)
+ });
+ Ok(call)
+ });
+ jobs.callback(callback);
+}
+
+pub fn dap_start_impl(
+ cx: &mut compositor::Context,
+ name: Option<&str>,
+ socket: Option<std::net::SocketAddr>,
+ params: Option<Vec<std::borrow::Cow<str>>>,
+) -> Result<(), anyhow::Error> {
+ let doc = doc!(cx.editor);
+
+ let config = doc
+ .language_config()
+ .and_then(|config| config.debugger.as_ref())
+ .ok_or(anyhow!("No debug adapter available for language"))?;
+
+ let result = match socket {
+ Some(socket) => block_on(Client::tcp(socket, 0)),
+ None => block_on(Client::process(
+ &config.transport,
+ &config.command,
+ config.args.iter().map(|arg| arg.as_str()).collect(),
+ config.port_arg.as_deref(),
+ 0,
+ )),
+ };
+
+ let (mut debugger, events) = match result {
+ Ok(r) => r,
+ Err(e) => bail!("Failed to start debug session: {}", e),
+ };
+
+ let request = debugger.initialize(config.name.clone());
+ if let Err(e) = block_on(request) {
+ bail!("Failed to initialize debug adapter: {}", e);
+ }
+
+ debugger.quirks = config.quirks.clone();
+
+ // TODO: avoid refetching all of this... pass a config in
+ let template = match name {
+ Some(name) => config.templates.iter().find(|t| t.name == name),
+ None => config.templates.get(0),
+ }
+ .ok_or(anyhow!("No debug config with given name"))?;
+
+ let mut args: HashMap<&str, Value> = HashMap::new();
+
+ if let Some(params) = params {
+ for (k, t) in &template.args {
+ let mut value = t.clone();
+ for (i, x) in params.iter().enumerate() {
+ let mut param = x.to_string();
+ if let Some(DebugConfigCompletion::Advanced(cfg)) = template.completion.get(i) {
+ if matches!(cfg.completion.as_deref(), Some("filename" | "directory")) {
+ param = std::fs::canonicalize(x.as_ref())
+ .ok()
+ .and_then(|pb| pb.into_os_string().into_string().ok())
+ .unwrap_or_else(|| x.to_string());
+ }
+ }
+ // For param #0 replace {0} in args
+ let pattern = format!("{{{}}}", i);
+ value = match value {
+ // TODO: just use toml::Value -> json::Value
+ DebugArgumentValue::String(v) => {
+ DebugArgumentValue::String(v.replace(&pattern, &param))
+ }
+ DebugArgumentValue::Array(arr) => DebugArgumentValue::Array(
+ arr.iter().map(|v| v.replace(&pattern, &param)).collect(),
+ ),
+ DebugArgumentValue::Boolean(_) => value,
+ };
+ }
+
+ match value {
+ DebugArgumentValue::String(string) => {
+ if let Ok(integer) = string.parse::<usize>() {
+ args.insert(k, to_value(integer).unwrap());
+ } else {
+ args.insert(k, to_value(string).unwrap());
+ }
+ }
+ DebugArgumentValue::Array(arr) => {
+ args.insert(k, to_value(arr).unwrap());
+ }
+ DebugArgumentValue::Boolean(bool) => {
+ args.insert(k, to_value(bool).unwrap());
+ }
+ }
+ }
+ }
+
+ let args = to_value(args).unwrap();
+
+ let callback = |_editor: &mut Editor, _compositor: &mut Compositor, _response: Value| {
+ // if let Err(e) = result {
+ // editor.set_error(format!("Failed {} target: {}", template.request, e));
+ // }
+ };
+
+ match &template.request[..] {
+ "launch" => {
+ let call = debugger.launch(args);
+ dap_callback(cx.jobs, call, callback);
+ }
+ "attach" => {
+ let call = debugger.attach(args);
+ dap_callback(cx.jobs, call, callback);
+ }
+ request => bail!("Unsupported request '{}'", request),
+ };
+
+ // TODO: either await "initialized" or buffer commands until event is received
+ cx.editor.debugger = Some(debugger);
+ let stream = UnboundedReceiverStream::new(events);
+ cx.editor.debugger_events.push(stream);
+ Ok(())
+}
+
+pub fn dap_launch(cx: &mut Context) {
+ if cx.editor.debugger.is_some() {
+ cx.editor
+ .set_error("Debugger is already running".to_string());
+ return;
+ }
+
+ let doc = doc!(cx.editor);
+
+ let config = match doc
+ .language_config()
+ .and_then(|config| config.debugger.as_ref())
+ {
+ Some(c) => c,
+ None => {
+ cx.editor
+ .set_error("No debug adapter available for language".to_string());
+ return;
+ }
+ };
+
+ let templates = config.templates.clone();
+
+ cx.push_layer(Box::new(Picker::new(
+ true,
+ templates,
+ |template| template.name.as_str().into(),
+ |cx, template, _action| {
+ let completions = template.completion.clone();
+ let name = template.name.clone();
+ let callback = Box::pin(async move {
+ let call: Callback =
+ Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
+ let prompt = debug_parameter_prompt(completions, name, Vec::new());
+ compositor.push(Box::new(prompt));
+ });
+ Ok(call)
+ });
+ cx.jobs.callback(callback);
+ },
+ ))); // TODO: wrap in popup with fixed size
+}
+
+fn debug_parameter_prompt(
+ completions: Vec<DebugConfigCompletion>,
+ config_name: String,
+ mut params: Vec<String>,
+) -> Prompt {
+ let completion = completions.get(params.len()).unwrap();
+ let field_type = if let DebugConfigCompletion::Advanced(cfg) = completion {
+ cfg.completion.as_deref().unwrap_or("")
+ } else {
+ ""
+ };
+ let name = match completion {
+ DebugConfigCompletion::Advanced(cfg) => cfg.name.as_deref().unwrap_or(field_type),
+ DebugConfigCompletion::Named(name) => name.as_str(),
+ };
+ let default_val = match completion {
+ DebugConfigCompletion::Advanced(cfg) => cfg.default.as_deref().unwrap_or(""),
+ _ => "",
+ }
+ .to_owned();
+
+ let completer = match field_type {
+ "filename" => ui::completers::filename,
+ "directory" => ui::completers::directory,
+ _ => |_input: &str| Vec::new(),
+ };
+ Prompt::new(
+ format!("{}: ", name).into(),
+ None,
+ completer,
+ move |cx, input: &str, event: PromptEvent| {
+ if event != PromptEvent::Validate {
+ return;
+ }
+
+ let mut value = input.to_owned();
+ if value.is_empty() {
+ value = default_val.clone();
+ }
+ params.push(value);
+
+ if params.len() < completions.len() {
+ let completions = completions.clone();
+ let config_name = config_name.clone();
+ let params = params.clone();
+ let callback = Box::pin(async move {
+ let call: Callback =
+ Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
+ let prompt = debug_parameter_prompt(completions, config_name, params);
+ compositor.push(Box::new(prompt));
+ });
+ Ok(call)
+ });
+ cx.jobs.callback(callback);
+ } else if let Err(e) = dap_start_impl(
+ cx,
+ Some(&config_name),
+ None,
+ Some(params.iter().map(|x| x.into()).collect()),
+ ) {
+ cx.editor.set_error(e.to_string());
+ }
+ },
+ )
+}
+
+pub fn dap_toggle_breakpoint(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let path = match doc.path() {
+ Some(path) => path.clone(),
+ None => {
+ cx.editor
+ .set_error("Can't set breakpoint: document has no path".to_string());
+ return;
+ }
+ };
+ let text = doc.text().slice(..);
+ let line = doc.selection(view.id).primary().cursor_line(text);
+ dap_toggle_breakpoint_impl(cx, path, line);
+}
+
+pub fn breakpoints_changed(
+ debugger: &mut dap::Client,
+ path: PathBuf,
+ breakpoints: &mut [Breakpoint],
+) -> Result<(), anyhow::Error> {
+ // TODO: handle capabilities correctly again, by filterin breakpoints when emitting
+ // if breakpoint.condition.is_some()
+ // && !debugger
+ // .caps
+ // .as_ref()
+ // .unwrap()
+ // .supports_conditional_breakpoints
+ // .unwrap_or_default()
+ // {
+ // bail!(
+ // "Can't edit breakpoint: debugger does not support conditional breakpoints"
+ // )
+ // }
+ // if breakpoint.log_message.is_some()
+ // && !debugger
+ // .caps
+ // .as_ref()
+ // .unwrap()
+ // .supports_log_points
+ // .unwrap_or_default()
+ // {
+ // bail!("Can't edit breakpoint: debugger does not support logpoints")
+ // }
+ let source_breakpoints = breakpoints
+ .iter()
+ .map(|breakpoint| helix_dap::SourceBreakpoint {
+ line: breakpoint.line + 1, // convert from 0-indexing to 1-indexing (TODO: could set debugger to 0-indexing on init)
+ ..Default::default()
+ })
+ .collect::<Vec<_>>();
+
+ let request = debugger.set_breakpoints(path, source_breakpoints);
+ match block_on(request) {
+ Ok(Some(dap_breakpoints)) => {
+ for (breakpoint, dap_breakpoint) in breakpoints.iter_mut().zip(dap_breakpoints) {
+ breakpoint.id = dap_breakpoint.id;
+ breakpoint.verified = dap_breakpoint.verified;
+ breakpoint.message = dap_breakpoint.message;
+ // TODO: handle breakpoint.message
+ // TODO: verify source matches
+ breakpoint.line = dap_breakpoint.line.unwrap_or(0).saturating_sub(1); // convert to 0-indexing
+ // TODO: no unwrap
+ breakpoint.column = dap_breakpoint.column;
+ // TODO: verify end_linef/col instruction reference, offset
+ }
+ }
+ Err(e) => anyhow::bail!("Failed to set breakpoints: {}", e),
+ _ => {}
+ };
+ Ok(())
+}
+
+pub fn dap_toggle_breakpoint_impl(cx: &mut Context, path: PathBuf, line: usize) {
+ // TODO: need to map breakpoints over edits and update them?
+ // we shouldn't really allow editing while debug is running though
+
+ let breakpoints = cx.editor.breakpoints.entry(path.clone()).or_default();
+ // TODO: always keep breakpoints sorted and use binary search to determine insertion point
+ if let Some(pos) = breakpoints
+ .iter()
+ .position(|breakpoint| breakpoint.line == line)
+ {
+ breakpoints.remove(pos);
+ } else {
+ breakpoints.push(Breakpoint {
+ line,
+ ..Default::default()
+ });
+ }
+
+ let debugger = debugger!(cx.editor);
+
+ if let Err(e) = breakpoints_changed(debugger, path, breakpoints) {
+ cx.editor
+ .set_error(format!("Failed to set breakpoints: {}", e));
+ }
+}
+
+pub fn dap_continue(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if let Some(thread_id) = debugger.thread_id {
+ let request = debugger.continue_thread(thread_id);
+ if let Err(e) = block_on(request) {
+ cx.editor.set_error(format!("Failed to continue: {}", e));
+ return;
+ }
+ resume_application(debugger);
+ } else {
+ cx.editor
+ .set_error("Currently active thread is not stopped. Switch the thread.".into());
+ }
+}
+
+pub fn dap_pause(cx: &mut Context) {
+ thread_picker(cx, |editor, thread| {
+ let debugger = debugger!(editor);
+ let request = debugger.pause(thread.id);
+ // NOTE: we don't need to set active thread id here because DAP will emit a "stopped" event
+ if let Err(e) = block_on(request) {
+ editor.set_error(format!("Failed to pause: {}", e));
+ }
+ })
+}
+
+pub fn dap_step_in(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if let Some(thread_id) = debugger.thread_id {
+ let request = debugger.step_in(thread_id);
+ if let Err(e) = block_on(request) {
+ cx.editor.set_error(format!("Failed to continue: {}", e));
+ return;
+ }
+ resume_application(debugger);
+ } else {
+ cx.editor
+ .set_error("Currently active thread is not stopped. Switch the thread.".into());
+ }
+}
+
+pub fn dap_step_out(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if let Some(thread_id) = debugger.thread_id {
+ let request = debugger.step_out(thread_id);
+ if let Err(e) = block_on(request) {
+ cx.editor.set_error(format!("Failed to continue: {}", e));
+ return;
+ }
+ resume_application(debugger);
+ } else {
+ cx.editor
+ .set_error("Currently active thread is not stopped. Switch the thread.".into());
+ }
+}
+
+pub fn dap_next(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if let Some(thread_id) = debugger.thread_id {
+ let request = debugger.next(thread_id);
+ if let Err(e) = block_on(request) {
+ cx.editor.set_error(format!("Failed to continue: {}", e));
+ return;
+ }
+ resume_application(debugger);
+ } else {
+ cx.editor
+ .set_error("Currently active thread is not stopped. Switch the thread.".into());
+ }
+}
+
+pub fn dap_variables(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if debugger.thread_id.is_none() {
+ cx.editor
+ .set_status("Cannot access variables while target is running".to_owned());
+ return;
+ }
+ let (frame, thread_id) = match (debugger.active_frame, debugger.thread_id) {
+ (Some(frame), Some(thread_id)) => (frame, thread_id),
+ _ => {
+ cx.editor
+ .set_status("Cannot find current stack frame to access variables".to_owned());
+ return;
+ }
+ };
+
+ let frame_id = debugger.stack_frames[&thread_id][frame].id;
+ let scopes = match block_on(debugger.scopes(frame_id)) {
+ Ok(s) => s,
+ Err(e) => {
+ cx.editor.set_error(format!("Failed to get scopes: {}", e));
+ return;
+ }
+ };
+
+ // TODO: allow expanding variables into sub-fields
+ let mut variables = Vec::new();
+
+ let theme = &cx.editor.theme;
+ let scope_style = theme.get("ui.linenr.selected");
+ let type_style = theme.get("ui.text");
+ let text_style = theme.get("ui.text.focus");
+
+ for scope in scopes.iter() {
+ // use helix_view::graphics::Style;
+ use tui::text::{Span, Spans};
+ let response = block_on(debugger.variables(scope.variables_reference));
+
+ variables.push(Spans::from(Span::styled(
+ format!("▸ {}", scope.name),
+ scope_style,
+ )));
+
+ if let Ok(vars) = response {
+ variables.reserve(vars.len());
+ for var in vars {
+ let mut spans = Vec::with_capacity(5);
+
+ spans.push(Span::styled(var.name.to_owned(), text_style));
+ if let Some(ty) = var.ty {
+ spans.push(Span::raw(": "));
+ spans.push(Span::styled(ty.to_owned(), type_style));
+ }
+ spans.push(Span::raw(" = "));
+ spans.push(Span::styled(var.value.to_owned(), text_style));
+ variables.push(Spans::from(spans));
+ }
+ }
+ }
+
+ let contents = Text::from(tui::text::Text::from(variables));
+ let popup = Popup::new("dap-variables", contents);
+ cx.push_layer(Box::new(popup));
+}
+
+pub fn dap_terminate(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ let request = debugger.disconnect();
+ if let Err(e) = block_on(request) {
+ cx.editor.set_error(format!("Failed to disconnect: {}", e));
+ return;
+ }
+ cx.editor.debugger = None;
+}
+
+pub fn dap_enable_exceptions(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ let filters = match &debugger.capabilities().exception_breakpoint_filters {
+ Some(filters) => filters.iter().map(|f| f.filter.clone()).collect(),
+ None => return,
+ };
+
+ if let Err(e) = block_on(debugger.set_exception_breakpoints(filters)) {
+ cx.editor
+ .set_error(format!("Failed to set up exception breakpoints: {}", e));
+ }
+}
+
+pub fn dap_disable_exceptions(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ if let Err(e) = block_on(debugger.set_exception_breakpoints(Vec::new())) {
+ cx.editor
+ .set_error(format!("Failed to set up exception breakpoints: {}", e));
+ }
+}
+
+// TODO: both edit condition and edit log need to be stable: we might get new breakpoints from the debugger which can change offsets
+pub fn dap_edit_condition(cx: &mut Context) {
+ if let Some((pos, breakpoint)) = get_breakpoint_at_current_line(cx.editor) {
+ let path = match doc!(cx.editor).path() {
+ Some(path) => path.clone(),
+ None => return,
+ };
+ let callback = Box::pin(async move {
+ let call: Callback =
+ Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
+ let mut prompt = Prompt::new(
+ "condition:".into(),
+ None,
+ |_input: &str| Vec::new(),
+ move |cx, input: &str, event: PromptEvent| {
+ if event != PromptEvent::Validate {
+ return;
+ }
+
+ let breakpoints = &mut cx.editor.breakpoints.get_mut(&path).unwrap();
+ breakpoints[pos].condition = match input {
+ "" => None,
+ input => Some(input.to_owned()),
+ };
+
+ let debugger = debugger!(cx.editor);
+
+ if let Err(e) = breakpoints_changed(debugger, path.clone(), breakpoints)
+ {
+ cx.editor
+ .set_error(format!("Failed to set breakpoints: {}", e));
+ }
+ },
+ );
+ if let Some(condition) = breakpoint.condition {
+ prompt.insert_str(&condition)
+ }
+ compositor.push(Box::new(prompt));
+ });
+ Ok(call)
+ });
+ cx.jobs.callback(callback);
+ }
+}
+
+pub fn dap_edit_log(cx: &mut Context) {
+ if let Some((pos, breakpoint)) = get_breakpoint_at_current_line(cx.editor) {
+ let path = match doc!(cx.editor).path() {
+ Some(path) => path.clone(),
+ None => return,
+ };
+ let callback = Box::pin(async move {
+ let call: Callback =
+ Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
+ let mut prompt = Prompt::new(
+ "log-message:".into(),
+ None,
+ |_input: &str| Vec::new(),
+ move |cx, input: &str, event: PromptEvent| {
+ if event != PromptEvent::Validate {
+ return;
+ }
+
+ let breakpoints = &mut cx.editor.breakpoints.get_mut(&path).unwrap();
+ breakpoints[pos].log_message = match input {
+ "" => None,
+ input => Some(input.to_owned()),
+ };
+
+ let debugger = debugger!(cx.editor);
+ if let Err(e) = breakpoints_changed(debugger, path.clone(), breakpoints)
+ {
+ cx.editor
+ .set_error(format!("Failed to set breakpoints: {}", e));
+ }
+ },
+ );
+ if let Some(log_message) = breakpoint.log_message {
+ prompt.insert_str(&log_message);
+ }
+ compositor.push(Box::new(prompt));
+ });
+ Ok(call)
+ });
+ cx.jobs.callback(callback);
+ }
+}
+
+pub fn dap_switch_thread(cx: &mut Context) {
+ thread_picker(cx, |editor, thread| {
+ block_on(select_thread_id(editor, thread.id, true));
+ })
+}
+pub fn dap_switch_stack_frame(cx: &mut Context) {
+ let debugger = debugger!(cx.editor);
+
+ let thread_id = match debugger.thread_id {
+ Some(thread_id) => thread_id,
+ None => {
+ cx.editor
+ .set_error("No thread is currently active".to_owned());
+ return;
+ }
+ };
+
+ let frames = debugger.stack_frames[&thread_id].clone();
+
+ let picker = FilePicker::new(
+ frames,
+ |frame| frame.name.clone().into(), // TODO: include thread_states in the label
+ move |cx, frame, _action| {
+ let debugger = debugger!(cx.editor);
+ // TODO: this should be simpler to find
+ let pos = debugger.stack_frames[&thread_id]
+ .iter()
+ .position(|f| f.id == frame.id);
+ debugger.active_frame = pos;
+
+ let frame = debugger.stack_frames[&thread_id]
+ .get(pos.unwrap_or(0))
+ .cloned();
+ if let Some(frame) = &frame {
+ jump_to_stack_frame(cx.editor, frame);
+ }
+ },
+ move |_editor, frame| {
+ frame
+ .source
+ .as_ref()
+ .and_then(|source| source.path.clone())
+ .map(|path| {
+ (
+ path,
+ Some((
+ frame.line.saturating_sub(1),
+ frame.end_line.unwrap_or(frame.line).saturating_sub(1),
+ )),
+ )
+ })
+ },
+ );
+ cx.push_layer(Box::new(picker))
+}
diff --git a/helix-term/src/keymap.rs b/helix-term/src/keymap.rs
index 212b27a9..e08d7e44 100644
--- a/helix-term/src/keymap.rs
+++ b/helix-term/src/keymap.rs
@@ -659,6 +659,26 @@ impl Default for Keymaps {
"S" => workspace_symbol_picker,
"a" => code_action,
"'" => last_picker,
+ "d" => { "Debug" sticky=true
+ "l" => dap_launch,
+ "b" => dap_toggle_breakpoint,
+ "c" => dap_continue,
+ "h" => dap_pause,
+ "i" => dap_step_in,
+ "o" => dap_step_out,
+ "n" => dap_next,
+ "v" => dap_variables,
+ "t" => dap_terminate,
+ "C-c" => dap_edit_condition,
+ "C-l" => dap_edit_log,
+ "s" => { "Switch"
+ "t" => dap_switch_thread,
+ "f" => dap_switch_stack_frame,
+ // sl, sb
+ },
+ "e" => dap_enable_exceptions,
+ "E" => dap_disable_exceptions,
+ },
"w" => { "Window"
"C-w" | "w" => rotate_view,
"C-s" | "s" => hsplit,
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index e68f5ff0..a2131abe 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -59,33 +59,66 @@ impl EditorView {
&mut self.spinners
}
- #[allow(clippy::too_many_arguments)]
pub fn render_view(
&self,
+ editor: &Editor,
doc: &Document,
view: &View,
viewport: Rect,
surface: &mut Surface,
- theme: &Theme,
is_focused: bool,
- config: &helix_view::editor::Config,
) {
let inner = view.inner_area();
let area = view.area;
+ let theme = &editor.theme;
+
+ // DAP: Highlight current stack frame position
+ let stack_frame = editor.debugger.as_ref().and_then(|debugger| {
+ if let (Some(frame), Some(thread_id)) = (debugger.active_frame, debugger.thread_id) {
+ debugger
+ .stack_frames
+ .get(&thread_id)
+ .and_then(|bt| bt.get(frame))
+ } else {
+ None
+ }
+ });
+ if let Some(frame) = stack_frame {
+ if doc.path().is_some()
+ && frame
+ .source
+ .as_ref()
+ .and_then(|source| source.path.as_ref())
+ == doc.path()
+ {
+ let line = frame.line - 1; // convert to 0-indexing
+ if line >= view.offset.row && line < view.offset.row + area.height as usize {
+ surface.set_style(
+ Rect::new(
+ area.x,
+ area.y + (line - view.offset.row) as u16,
+ area.width,
+ 1,
+ ),
+ theme.get("ui.highlight"),
+ );
+ }
+ }
+ }
let highlights = Self::doc_syntax_highlights(doc, view.offset, inner.height, theme);
let highlights = syntax::merge(highlights, Self::doc_diagnostics_highlights(doc, theme));
let highlights: Box<dyn Iterator<Item = HighlightEvent>> = if is_focused {
Box::new(syntax::merge(
highlights,
- Self::doc_selection_highlights(doc, view, theme, &config.cursor_shape),
+ Self::doc_selection_highlights(doc, view, theme, &editor.config.cursor_shape),
))
} else {
Box::new(highlights)
};
Self::render_text_highlights(doc, view.offset, inner, surface, theme, highlights);
- Self::render_gutter(doc, view, view.area, surface, theme, is_focused, config);
+ Self::render_gutter(editor, doc, view, view.area, surface, theme, is_focused);
if is_focused {
Self::render_focused_view_elements(view, doc, inner, theme, surface);
@@ -404,13 +437,13 @@ impl EditorView {
}
pub fn render_gutter(
+ editor: &Editor,
doc: &Document,
view: &View,
viewport: Rect,
surface: &mut Surface,
theme: &Theme,
is_focused: bool,
- config: &helix_view::editor::Config,
) {
let text = doc.text().slice(..);
let last_line = view.last_line(doc);
@@ -432,7 +465,7 @@ impl EditorView {
let mut text = String::with_capacity(8);
for (constructor, width) in view.gutters() {
- let gutter = constructor(doc, view, theme, config, is_focused, *width);
+ let gutter = constructor(editor, doc, view, theme, is_focused, *width);
text.reserve(*width); // ensure there's enough space for the gutter
for (i, line) in (view.offset.row..(last_line + 1)).enumerate() {
let selected = cursors.contains(&line);
@@ -448,6 +481,7 @@ impl EditorView {
}
text.clear();
}
+
offset += *width as u16;
}
}
@@ -825,6 +859,31 @@ impl EditorView {
return EventResult::Consumed(None);
}
+ let result = editor.tree.views().find_map(|(view, _focus)| {
+ view.gutter_coords_at_screen_coords(row, column)
+ .map(|coords| (coords, view.id))
+ });
+
+ if let Some((coords, view_id)) = result {
+ editor.tree.focus = view_id;
+
+ let view = editor.tree.get(view_id);
+ let doc = editor.documents.get_mut(&view.doc).unwrap();
+
+ let path = match doc.path() {
+ Some(path) => path.clone(),
+ None => {
+ return EventResult::Ignored;
+ }
+ };
+
+ let line = coords.row + view.offset.row;
+ if line < doc.text().len_lines() {
+ commands::dap_toggle_breakpoint_impl(cxt, path, line);
+ return EventResult::Consumed(None);
+ }
+ }
+
EventResult::Ignored
}
@@ -901,6 +960,38 @@ impl EditorView {
}
MouseEvent {
+ kind: MouseEventKind::Up(MouseButton::Right),
+ row,
+ column,
+ modifiers,
+ ..
+ } => {
+ let result = cxt.editor.tree.views().find_map(|(view, _focus)| {
+ view.gutter_coords_at_screen_coords(row, column)
+ .map(|coords| (coords, view.id))
+ });
+
+ if let Some((coords, view_id)) = result {
+ cxt.editor.tree.focus = view_id;
+
+ let view = cxt.editor.tree.get(view_id);
+ let doc = cxt.editor.documents.get_mut(&view.doc).unwrap();
+ let line = coords.row + view.offset.row;
+ if let Ok(pos) = doc.text().try_line_to_char(line) {
+ doc.set_selection(view_id, Selection::point(pos));
+ if modifiers == crossterm::event::KeyModifiers::ALT {
+ commands::MappableCommand::dap_edit_log.execute(cxt);
+ } else {
+ commands::MappableCommand::dap_edit_condition.execute(cxt);
+ }
+
+ return EventResult::Consumed(None);
+ }
+ }
+ EventResult::Ignored
+ }
+
+ MouseEvent {
kind: MouseEventKind::Up(MouseButton::Middle),
row,
column,
@@ -1078,15 +1169,7 @@ impl Component for EditorView {
for (view, is_focused) in cx.editor.tree.views() {
let doc = cx.editor.document(view.doc).unwrap();
- self.render_view(
- doc,
- view,
- area,
- surface,
- &cx.editor.theme,
- is_focused,
- &cx.editor.config,
- );
+ self.render_view(cx.editor, doc, view, area, surface, is_focused);
}
if cx.editor.config.auto_info {
diff --git a/helix-term/src/ui/mod.rs b/helix-term/src/ui/mod.rs
index 7bbd9ced..49f7b2fa 100644
--- a/helix-term/src/ui/mod.rs
+++ b/helix-term/src/ui/mod.rs
@@ -21,7 +21,7 @@ pub use text::Text;
use helix_core::regex::Regex;
use helix_core::regex::RegexBuilder;
-use helix_view::{Document, Editor, View};
+use helix_view::{Document, View};
use std::path::PathBuf;
@@ -161,8 +161,8 @@ pub fn file_picker(root: PathBuf, config: &helix_view::editor::Config) -> FilePi
.unwrap()
.into()
},
- move |editor: &mut Editor, path: &PathBuf, action| {
- editor
+ move |cx, path: &PathBuf, action| {
+ cx.editor
.open(path.into(), action)
.expect("editor.open failed");
},
diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs
index 4068a2d4..2c7db7f2 100644
--- a/helix-term/src/ui/picker.rs
+++ b/helix-term/src/ui/picker.rs
@@ -86,7 +86,7 @@ impl<T> FilePicker<T> {
pub fn new(
options: Vec<T>,
format_fn: impl Fn(&T) -> Cow<str> + 'static,
- callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
+ callback_fn: impl Fn(&mut Context, &T, Action) + 'static,
preview_fn: impl Fn(&Editor, &T) -> Option<FileLocation> + 'static,
) -> Self {
Self {
@@ -280,7 +280,7 @@ pub struct Picker<T> {
pub truncate_start: bool,
format_fn: Box<dyn Fn(&T) -> Cow<str>>,
- callback_fn: Box<dyn Fn(&mut Editor, &T, Action)>,
+ callback_fn: Box<dyn Fn(&mut Context, &T, Action)>,
}
impl<T> Picker<T> {
@@ -288,7 +288,7 @@ impl<T> Picker<T> {
render_centered: bool,
options: Vec<T>,
format_fn: impl Fn(&T) -> Cow<str> + 'static,
- callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
+ callback_fn: impl Fn(&mut Context, &T, Action) + 'static,
) -> Self {
let prompt = Prompt::new(
"".into(),
@@ -427,19 +427,19 @@ impl<T: 'static> Component for Picker<T> {
}
key!(Enter) => {
if let Some(option) = self.selection() {
- (self.callback_fn)(cx.editor, option, Action::Replace);
+ (self.callback_fn)(cx, option, Action::Replace);
}
return close_fn;
}
ctrl!('s') => {
if let Some(option) = self.selection() {
- (self.callback_fn)(cx.editor, option, Action::HorizontalSplit);
+ (self.callback_fn)(cx, option, Action::HorizontalSplit);
}
return close_fn;
}
ctrl!('v') => {
if let Some(option) = self.selection() {
- (self.callback_fn)(cx.editor, option, Action::VerticalSplit);
+ (self.callback_fn)(cx, option, Action::VerticalSplit);
}
return close_fn;
}
diff --git a/helix-term/src/ui/text.rs b/helix-term/src/ui/text.rs
index 4641fae1..caece049 100644
--- a/helix-term/src/ui/text.rs
+++ b/helix-term/src/ui/text.rs
@@ -4,7 +4,7 @@ use tui::buffer::Buffer as Surface;
use helix_view::graphics::Rect;
pub struct Text {
- contents: String,
+ contents: tui::text::Text<'static>,
size: (u16, u16),
viewport: (u16, u16),
}
@@ -12,18 +12,28 @@ pub struct Text {
impl Text {
pub fn new(contents: String) -> Self {
Self {
+ contents: tui::text::Text::from(contents),
+ size: (0, 0),
+ viewport: (0, 0),
+ }
+ }
+}
+
+impl From<tui::text::Text<'static>> for Text {
+ fn from(contents: tui::text::Text<'static>) -> Self {
+ Self {
contents,
size: (0, 0),
viewport: (0, 0),
}
}
}
+
impl Component for Text {
fn render(&mut self, area: Rect, surface: &mut Surface, _cx: &mut Context) {
use tui::widgets::{Paragraph, Widget, Wrap};
- let contents = tui::text::Text::from(self.contents.clone());
- let par = Paragraph::new(contents).wrap(Wrap { trim: false });
+ let par = Paragraph::new(self.contents.clone()).wrap(Wrap { trim: false });
// .scroll(x, y) offsets
par.render(area, surface);
@@ -31,9 +41,8 @@ impl Component for Text {
fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
if viewport != self.viewport {
- let contents = tui::text::Text::from(self.contents.clone());
- let width = std::cmp::min(contents.width() as u16, viewport.0);
- let height = std::cmp::min(contents.height() as u16, viewport.1);
+ let width = std::cmp::min(self.contents.width() as u16, viewport.0);
+ let height = std::cmp::min(self.contents.height() as u16, viewport.1);
self.size = (width, height);
self.viewport = viewport;
}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-10-17 10:27:35 +0000