From b679d383a850bc9b9f672d3342a23b5cb867372c Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 6 Nov 2026 07:40:03 +0000 Subject: [PATCH] tui: select text with the mouse and copy it on release Mouse capture (for wheel scrolling) keeps the terminal from selecting text, so dragging did nothing. A left-button drag now marks a span inside the chat or the prompt box, draws it reversed, and on release copies its text (read back from the frame, wide characters kept whole) through the native clipboard tool or OSC 52. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_014BrrmWMes5EESLagmFZYrD --- docs/learning-rust.md | 1 + src/tui/app.rs | 97 +++++++++++++++++++++-- src/tui/mod.rs | 11 +++ src/tui/select.rs | 174 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 275 insertions(+), 8 deletions(-) create mode 100644 src/tui/select.rs diff --git a/docs/learning-rust.md b/docs/learning-rust.md index 4fce939..6d545d4 100644 --- a/docs/learning-rust.md +++ b/docs/learning-rust.md @@ -28,6 +28,7 @@ cargo test # 跑测试 | Enter / Shift+Enter(或 Ctrl+J) | 发送 / 换行 | | Alt+Enter | 排进队列,当前任务完成后再发(follow-up) | | Ctrl+V / Ctrl+Y | 从剪贴板粘贴(图片、文件路径或文本)/ 复制最后一条回复 | +| 鼠标拖动 | 选中文字,松开即复制到剪贴板(终端原生选择:按住 Shift 拖动,或 `/mouse` 关闭鼠标捕获) | | Ctrl+G | 子代理面板(任务板 + 选中任务的记录) | | Esc、Ctrl+C | 打断当前回合;空闲时连按两次 Ctrl+C 退出 | | agent 忙时按 Enter | 把消息排进队列,作为“插话”发给 agent | diff --git a/src/tui/app.rs b/src/tui/app.rs index 9a80571..512edb8 100644 --- a/src/tui/app.rs +++ b/src/tui/app.rs @@ -4,7 +4,10 @@ use crate::integrations::{Reporters, State, TurnOutcome}; use std::sync::Arc; use std::time::Instant; -use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseEvent, MouseEventKind}; +use crossterm::event::{ + KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent, MouseEventKind, +}; +use ratatui::layout::{Margin, Position, Rect}; use tokio::sync::mpsc; use tokio::task::JoinHandle; use tokio_util::sync::CancellationToken; @@ -15,6 +18,7 @@ use super::fx::Fx; use super::game2048::{Dir, Game}; use super::input::Input; use super::paste::{self, PasteStore}; +use super::select::Selection; use super::theme::{self, THEMES, Theme}; use crate::agent::{Agent, AgentEvent, EventTx, FOLLOW_UP, STEER, SteerQueue}; use crate::background::BackgroundEvent; @@ -236,7 +240,7 @@ pub const COMMANDS: &[SlashCommand] = &[ SlashCommand { name: "mouse", args: "", - help: "切换鼠标捕获(关闭后可用终端原生选择复制)", + help: "切换鼠标捕获(开:拖动选择自动复制;关:终端原生选择)", }, SlashCommand { name: "clear", @@ -279,6 +283,12 @@ pub struct App { last_ctrl_c: Option, pub mouse_capture: bool, pub mouse_changed: bool, + /// Mouse text selection (drawn reversed; copied on release). + pub selection: Option, + /// A drag is in progress. + selecting: bool, + /// The next frame reads the selection's text back for copying. + pub copy_selection: bool, pub toast: Option<(String, Instant)>, pub skills: Vec, /// Workdir and daily flag the skills were discovered for (the agent is @@ -375,6 +385,9 @@ impl App { last_ctrl_c: None, mouse_capture: true, mouse_changed: false, + selection: None, + selecting: false, + copy_selection: false, toast: None, skills, skills_scope, @@ -1058,18 +1071,83 @@ impl App { self.toast("还没有可复制的回复"); return; }; - if clipboard::write_text(&text) { - self.toast("已复制最后一条回复"); + self.copy_text(&text, "已复制最后一条回复"); + } + + /// Copy text with the native tool, else OSC 52. + fn copy_text(&mut self, text: &str, done: &str) { + if clipboard::write_text(text) { + self.toast(done.to_string()); } else { - self.pending_osc52 = Some(clipboard::osc52(&text)); - self.toast("已通过终端(OSC 52)复制"); + self.pending_osc52 = Some(clipboard::osc52(text)); + self.toast(format!("{done}(通过终端 OSC 52)")); + } + } + + /// The text of a finished mouse selection, read back from the frame. + pub fn copy_selected(&mut self, text: String) { + if text.trim().is_empty() { + return; + } + let n = text.chars().count(); + self.copy_text(&text, &format!("已复制 {n} 个字符")); + } + + /// The screen region a selection starting at `p` stays within. + fn selection_region(&self, p: Position) -> Rect { + let a = self.fx.areas; + if self.popup.is_some() { + return a.screen; + } + if a.input.contains(p) { + return a.input.inner(Margin { + horizontal: 1, + vertical: 1, + }); } + if a.chat.contains(p) { + // The chat text sits inside a two-column margin; the scrollbar + // is on the last column. + return a.chat.inner(Margin { + horizontal: 2, + vertical: 0, + }); + } + a.screen } pub fn on_mouse(&mut self, m: MouseEvent) { + let p = Position::new(m.column, m.row); match m.kind { - MouseEventKind::ScrollUp => self.scroll_by(3), - MouseEventKind::ScrollDown => self.scroll_by(-3), + MouseEventKind::ScrollUp => { + self.selection = None; + self.scroll_by(3); + } + MouseEventKind::ScrollDown => { + self.selection = None; + self.scroll_by(-3); + } + MouseEventKind::Down(MouseButton::Left) => { + self.selection = Some(Selection::new(self.selection_region(p), p)); + self.selecting = true; + } + MouseEventKind::Drag(MouseButton::Left) if self.selecting => { + if let Some(sel) = &mut self.selection { + sel.extend(p); + } + } + MouseEventKind::Up(MouseButton::Left) if self.selecting => { + self.selecting = false; + if let Some(sel) = &mut self.selection { + sel.extend(p); + if sel.is_empty() { + // A plain click clears the selection. + self.selection = None; + } else { + self.copy_selection = true; + } + } + } _ => return, } self.dirty = true; @@ -1084,6 +1162,9 @@ impl App { return; } self.dirty = true; + if !self.selecting { + self.selection = None; + } let ctrl = key.modifiers.contains(KeyModifiers::CONTROL); let alt = key.modifiers.contains(KeyModifiers::ALT); let shift = key.modifiers.contains(KeyModifiers::SHIFT); diff --git a/src/tui/mod.rs b/src/tui/mod.rs index 89a18f1..775a7d9 100644 --- a/src/tui/mod.rs +++ b/src/tui/mod.rs @@ -13,6 +13,7 @@ mod game2048; mod input; mod markdown; mod paste; +mod select; mod text; mod theme; mod ui; @@ -115,10 +116,17 @@ async fn event_loop( // Synchronized update: terminals that support it show the frame // all at once instead of cell by cell (others ignore it). execute!(stdout(), BeginSynchronizedUpdate)?; + let mut copied = None; terminal.draw(|f| { ui::draw(f, &mut app); let theme = app.theme; app.fx.process(elapsed, f.buffer_mut(), &theme); + if let Some(sel) = &app.selection { + if std::mem::take(&mut app.copy_selection) { + copied = Some(select::extract(f.buffer_mut(), sel)); + } + select::highlight(f.buffer_mut(), sel); + } })?; // The caret is drawn as a cell (ui::draw_input); the terminal // cursor stays hidden (ratatui hides it when the frame sets no @@ -128,6 +136,9 @@ async fn event_loop( } execute!(stdout(), EndSynchronizedUpdate)?; app.dirty = false; + if let Some(text) = copied { + app.copy_selected(text); + } } if app.quit { break; diff --git a/src/tui/select.rs b/src/tui/select.rs new file mode 100644 index 0000000..5de37d9 --- /dev/null +++ b/src/tui/select.rs @@ -0,0 +1,174 @@ +//! Mouse text selection. Mouse capture (needed for wheel scrolling) stops the +//! terminal from selecting text itself, so we do it: a left-button drag marks +//! a span of screen cells inside the region where it started (the chat or the +//! prompt box), the span is drawn reversed, and on release its text is read +//! back from the rendered buffer and copied to the clipboard. + +use ratatui::buffer::Buffer; +use ratatui::layout::{Position, Rect}; +use ratatui::style::Modifier; +use unicode_width::UnicodeWidthStr; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Selection { + /// The region the drag started in; both ends are clamped to it. + pub region: Rect, + pub anchor: Position, + pub head: Position, +} + +impl Selection { + pub fn new(region: Rect, at: Position) -> Self { + let p = clamp(region, at); + Self { + region, + anchor: p, + head: p, + } + } + + pub fn extend(&mut self, to: Position) { + self.head = clamp(self.region, to); + } + + pub fn is_empty(&self) -> bool { + self.anchor == self.head + } + + /// Start and end in reading order (row first, then column). + fn ordered(&self) -> (Position, Position) { + let (a, b) = (self.anchor, self.head); + if (a.y, a.x) <= (b.y, b.x) { + (a, b) + } else { + (b, a) + } + } + + /// Selected column range (inclusive) of each selected row. + fn rows(&self) -> impl Iterator + '_ { + let (s, e) = self.ordered(); + let r = self.region; + let last = r.right().saturating_sub(1); + (s.y..=e.y).map(move |y| { + let x0 = if y == s.y { s.x } else { r.x }; + let x1 = if y == e.y { e.x } else { last }; + (y, x0, x1) + }) + } +} + +fn clamp(r: Rect, p: Position) -> Position { + Position { + x: p.x.clamp(r.x, r.right().saturating_sub(1).max(r.x)), + y: p.y.clamp(r.y, r.bottom().saturating_sub(1).max(r.y)), + } +} + +/// Draw the selection reversed. +pub fn highlight(buf: &mut Buffer, sel: &Selection) { + if sel.is_empty() { + return; + } + let area = buf.area; + for (y, x0, x1) in sel.rows() { + for x in x0..=x1 { + if area.contains(Position { x, y }) { + buf[(x, y)].modifier.toggle(Modifier::REVERSED); + } + } + } +} + +/// The selected text, one line per row, trailing blanks trimmed. +pub fn extract(buf: &Buffer, sel: &Selection) -> String { + let area = buf.area; + let mut lines: Vec = Vec::new(); + for (y, x0, x1) in sel.rows() { + if y < area.top() || y >= area.bottom() { + continue; + } + let mut line = String::new(); + // Walk from the row start so a wide character's hidden second cell + // (reset to a blank by ratatui) is skipped, not copied as a space. + let mut x = sel.region.x.max(area.left()); + let end = x1.min(area.right().saturating_sub(1)); + while x <= end { + let sym = buf[(x, y)].symbol(); + let w = sym.width().max(1) as u16; + // Take a cell that starts in the range, or a wide one covering + // its first column. + if x >= x0 || x + w > x0 { + line.push_str(sym); + } + x += w; + } + lines.push(line.trim_end().to_string()); + } + while lines.last().is_some_and(|l| l.is_empty()) { + lines.pop(); + } + lines.join("\n") +} + +#[cfg(test)] +mod tests { + use super::*; + use ratatui::style::Style; + + fn buf(rows: &[&str]) -> Buffer { + let mut b = Buffer::empty(Rect::new(0, 0, 10, rows.len() as u16)); + for (y, r) in rows.iter().enumerate() { + b.set_string(0, y as u16, r, Style::default()); + } + b + } + + #[test] + fn single_row() { + let b = buf(&["hello world"]); + let mut s = Selection::new(b.area, Position::new(0, 0)); + s.extend(Position::new(4, 0)); + assert_eq!(extract(&b, &s), "hello"); + } + + #[test] + fn backwards_multi_row() { + let b = buf(&["abc", "defgh", "ijk"]); + let mut s = Selection::new(b.area, Position::new(1, 2)); + s.extend(Position::new(1, 0)); + assert_eq!(extract(&b, &s), "bc\ndefgh\nij"); + } + + #[test] + fn wide_chars_not_padded() { + let b = buf(&["你好世界"]); + let mut s = Selection::new(b.area, Position::new(0, 0)); + s.extend(Position::new(9, 0)); + assert_eq!(extract(&b, &s), "你好世界"); + // Starting on the hidden half still takes the whole character. + let mut s = Selection::new(b.area, Position::new(3, 0)); + s.extend(Position::new(5, 0)); + assert_eq!(extract(&b, &s), "好世"); + } + + #[test] + fn clamped_to_region() { + let b = buf(&["|abcdef|", "|ghijkl|"]); + let region = Rect::new(1, 0, 6, 2); + let mut s = Selection::new(region, Position::new(0, 0)); + s.extend(Position::new(9, 1)); + assert_eq!(extract(&b, &s), "abcdef\nghijkl"); + } + + #[test] + fn highlight_toggles_reversed() { + let mut b = buf(&["abc"]); + let mut s = Selection::new(b.area, Position::new(0, 0)); + s.extend(Position::new(1, 0)); + highlight(&mut b, &s); + assert!(b[(0, 0)].modifier.contains(Modifier::REVERSED)); + assert!(b[(1, 0)].modifier.contains(Modifier::REVERSED)); + assert!(!b[(2, 0)].modifier.contains(Modifier::REVERSED)); + } +}