Files
psyTerm/src/terminal.rs
T

1384 lines
52 KiB
Rust

//! Display-only workspace and panes. All terminal and multiplexer state is remote.
use crate::{
chrome,
client::{Client, Updates},
colors,
commands::{self, CommandAction},
cursor::CursorAnimator,
fonts::{self, TerminalFont},
input,
label::middle_label,
palette::CommandPalette,
pane_name::RenameField,
protocol::{
ClientMessage, Direction, PaneSnapshot, ScrollKind, SelectionCommand, SelectionKind,
SelectionSide, Snapshot, StackPaneInfo, VerticalDirection,
},
render::{RenderCell, Renderer},
transition::Slide,
};
use alacritty_terminal::{
term::{TermMode, color::Colors},
vte::ansi::{Color, CursorShape, NamedColor},
};
use gpui::{prelude::*, *};
use std::{
collections::HashMap,
ops::Range,
sync::Arc,
time::{Duration, Instant},
};
const PADDING: f32 = 6.;
struct TabRename {
tab: u64,
editor: Entity<RenameField>,
_blur: Subscription,
}
pub struct Workspace {
client: Client,
font: TerminalFont,
snapshot: Option<Arc<Snapshot>>,
panes: HashMap<u64, Entity<TerminalPane>>,
error: Option<String>,
focus: FocusHandle,
palette: Option<Entity<CommandPalette>>,
tab_rename: Option<TabRename>,
outgoing: HashMap<u64, Entity<TerminalPane>>,
outgoing_snapshot: Option<Arc<Snapshot>>,
transition: Option<Slide>,
transition_frame_pending: bool,
_updates: Task<()>,
}
impl Drop for Workspace {
fn drop(&mut self) {
// GPUI drops each window's root on close, including during app shutdown.
if self.client.remote().is_some()
&& let Err(error) = self.client.remember_remote_detach()
{
log::warn!("Could not remember detached SSH session: {error:#}");
}
}
}
impl Workspace {
fn begin_tab_rename(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let Some(tab) = self
.snapshot
.as_deref()
.and_then(Snapshot::active_tab)
.filter(|tab| !tab.is_connecting())
else {
return;
};
let id = tab.id;
let initial = tab.title.clone();
let owner = cx.weak_entity();
let editor = cx.new(|cx| {
RenameField::new(
initial,
move |name, window, cx| {
let _ = owner.update(cx, |view, cx| {
view.tab_rename = None;
if let Some(name) = name
&& let Err(error) = view.client.send(ClientMessage::RenameTab {
tab: id,
name: Some(name),
})
{
view.error = Some(error.to_string());
}
view.restore_focus(window, cx);
cx.notify();
});
},
window,
cx,
)
});
let focus = editor.read(cx).focus_handle(cx);
let blur = cx.on_blur(&focus, window, |view, _, cx| {
// Clicking elsewhere cancels the edit and keeps the clicked focus.
view.tab_rename = None;
cx.notify();
});
self.tab_rename = Some(TabRename {
tab: id,
editor,
_blur: blur,
});
cx.notify();
}
fn focused_pane(&self) -> Option<Entity<TerminalPane>> {
let snapshot = self.snapshot.as_ref()?;
let tab = snapshot
.tabs
.iter()
.find(|tab| tab.id == snapshot.active_tab)?;
self.panes.get(&tab.active_pane).cloned()
}
fn restore_focus(&self, window: &mut Window, cx: &mut Context<Self>) {
if let Some(pane) = self.focused_pane() {
window.focus(&pane.read(cx).focus);
} else {
window.focus(&self.focus);
}
}
fn close_palette(&mut self, window: &mut Window, cx: &mut Context<Self>) {
self.palette = None;
self.restore_focus(window, cx);
cx.notify();
}
fn open_palette(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if self.palette.is_some() {
self.close_palette(window, cx);
return;
}
self.tab_rename = None;
for pane in self.panes.values() {
pane.update(cx, |pane, cx| {
pane.rename = None;
pane.selecting = false;
pane.preedit.clear();
cx.notify();
});
}
let items = commands::root_items(self.snapshot.as_deref(), self.client.remote().is_some());
let owner = cx.weak_entity();
self.palette = Some(cx.new(|cx| {
CommandPalette::new(
items,
move |action, window, cx| {
let _ = owner.update(cx, |view, cx| {
view.close_palette(window, cx);
if let Some(action) = action {
view.execute(action, window, cx);
}
});
},
window,
cx,
)
}));
cx.notify();
}
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
let Some(action) = crate::bindings::action_for_key(&event.keystroke) else {
return;
};
// Window commands remain available while a text field has focus.
if !matches!(
action,
CommandAction::TogglePalette
| CommandAction::NewWindow
| CommandAction::IncreaseFontSize
| CommandAction::DecreaseFontSize
) && (self.palette.is_some()
|| self.tab_rename.is_some()
|| self
.focused_pane()
.is_some_and(|pane| pane.read(cx).rename.is_some()))
{
return;
}
self.execute(action, window, cx);
cx.stop_propagation();
}
fn open_window(&self, cx: &mut Context<Self>) {
let client = self.client.clone();
let cwd = self
.focused_pane()
.map(|pane| pane.read(cx).data().cwd.clone());
let active_tab = self.snapshot.as_deref().and_then(Snapshot::active_tab);
let remote = active_tab.and_then(|tab| tab.remote.clone().map(|host| (tab.id, host)));
let launch = cx
.background_executor()
.spawn(async move { client.open_window(remote, cwd) });
cx.spawn(async move |view, cx| {
if let Err(error) = launch.await {
let _ = view.update(cx, |view, cx| {
view.error = Some(format!("Could not open a new window: {error:#}"));
cx.notify();
});
}
})
.detach();
}
fn close_tab(&mut self, id: u64, window: &mut Window, cx: &mut Context<Self>) {
let Some(tab) = self
.snapshot
.as_ref()
.and_then(|s| s.tabs.iter().find(|tab| tab.id == id))
else {
return;
};
let message = if tab.remote.is_some() {
ClientMessage::DetachRemote { tab: id }
} else if self.client.remote().is_some() {
window.remove_window();
return;
} else {
ClientMessage::Close { id }
};
if let Err(error) = self.client.send(message) {
self.error = Some(error.to_string());
cx.notify();
}
}
fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context<Self>) {
use CommandAction::*;
let pane = self.focused_pane();
let pane_id = pane.as_ref().map(|pane| pane.read(cx).data().id);
let message = match action {
TogglePalette => {
self.open_palette(window, cx);
None
}
NewWindow => {
self.open_window(cx);
None
}
IncreaseFontSize | DecreaseFontSize => {
let delta = if matches!(action, IncreaseFontSize) {
1.
} else {
-1.
};
if self.font.adjust_size(delta, window.text_system()) {
for pane in self.panes.values().chain(self.outgoing.values()) {
pane.update(cx, |pane, cx| {
pane.renderer = Renderer::new(self.font.clone());
pane.prepared_revision = None;
pane.requested_size = None;
cx.notify();
});
}
}
None
}
NewTab => Some(ClientMessage::NewTab { cwd: None }),
SplitPane => pane_id.map(|pane| ClientMessage::Split { pane, cwd: None }),
StackAbove | StackBelow => Some(ClientMessage::NewStackPane {
pane: None,
direction: if matches!(action, StackAbove) {
VerticalDirection::Up
} else {
VerticalDirection::Down
},
cwd: None,
}),
FocusAbove | FocusBelow => Some(ClientMessage::FocusDirection {
direction: if matches!(action, FocusAbove) {
Direction::Up
} else {
Direction::Down
},
}),
ClosePane => pane_id.map(|id| ClientMessage::Close { id }).or_else(|| {
let tab = self.snapshot.as_deref()?.active_tab()?;
tab.is_connecting()
.then_some(ClientMessage::DetachRemote { tab: tab.id })
}),
ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }),
ResetTabName => self
.snapshot
.as_ref()
.map(|snapshot| ClientMessage::RenameTab {
tab: snapshot.active_tab,
name: None,
}),
RenameTab => {
self.begin_tab_rename(window, cx);
None
}
Copy => pane_id.map(|pane| ClientMessage::Copy { pane }),
Scroll(kind) => pane_id.map(|pane| ClientMessage::Scroll { pane, kind }),
FocusTab(tab) => Some(ClientMessage::FocusTab { tab }),
FocusPane(pane) => Some(ClientMessage::FocusPane { pane }),
PreviousTab | NextTab => Some(ClientMessage::CycleTab {
forward: matches!(action, NextTab),
}),
PreviousPane | NextPane => Some(ClientMessage::CyclePane {
forward: matches!(action, NextPane),
}),
FocusLeft | FocusRight => Some(ClientMessage::FocusDirection {
direction: if matches!(action, FocusLeft) {
Direction::Left
} else {
Direction::Right
},
}),
RenamePane => {
if let Some(pane) = pane {
pane.update(cx, |pane, cx| pane.begin_rename(window, cx));
}
None
}
Paste => {
if let Some(pane) = pane
&& let Some(text) = cx.read_from_clipboard().and_then(|item| item.text())
{
pane.update(cx, |pane, cx| {
pane.send(
input::paste_text(
&text,
pane.mode().contains(TermMode::BRACKETED_PASTE),
),
cx,
);
});
}
None
}
DetachRemote => {
let tab = self.snapshot.as_deref().and_then(Snapshot::active_tab);
if let Some(tab) = tab.filter(|tab| tab.remote.is_some()) {
Some(ClientMessage::DetachRemote { tab: tab.id })
} else {
if self.client.remote().is_some() {
window.remove_window();
}
None
}
}
Detach => {
window.remove_window();
None
}
};
if let Some(message) = message
&& let Err(error) = self.client.send(message)
{
self.error = Some(error.to_string());
cx.notify();
}
}
pub fn new(
client: Client,
updates: Updates,
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let focus = cx.focus_handle();
window.focus(&focus);
// Scene transitions rebuild pane views. Keep system font discovery and
// cell measurement outside that path, once per workspace.
let font = fonts::terminal_font(window.text_system());
let task = cx.spawn_in(window, async move |view, cx| {
while let Some(update) = updates.recv().await {
if cx
.update(|window, cx| {
view.update(cx, |view, cx| {
for text in update.clipboard.into_iter().filter(|text| !text.is_empty())
{
cx.write_to_clipboard(ClipboardItem::new_string(text));
}
if let Some(error) = update.error {
view.error = Some(error);
}
if let Some(snapshot) = update.snapshot {
let metadata_changed = view.snapshot.as_ref().is_none_or(|old| {
old.active_tab != snapshot.active_tab
|| old.tabs != snapshot.tabs
});
let cancelled_tab_rename =
view.tab_rename.as_ref().is_some_and(|rename| {
snapshot.active_tab != rename.tab
|| !snapshot.tabs.iter().any(|tab| tab.id == rename.tab)
});
if cancelled_tab_rename {
view.tab_rename = None;
}
let focus_allowed =
view.palette.is_none() && view.tab_rename.is_none();
if let Some(direction) = view
.snapshot
.as_ref()
.and_then(|old| scene_direction(old, &snapshot))
{
view.outgoing_snapshot = view.snapshot.clone();
view.outgoing = view
.snapshot
.as_ref()
.unwrap()
.panes
.iter()
.filter_map(|data| {
view.panes
.get(&data.id)
.map(|pane| (data.id, pane.clone()))
})
.collect();
for pane in view.outgoing.values() {
pane.update(cx, |pane, cx| {
pane.read_only = true;
pane.transitioning = true;
pane.rename = None;
pane.selecting = false;
pane.preedit.clear();
pane.blink_timer = None;
cx.notify();
});
}
view.panes.clear();
view.transition = Some(Slide::new(direction, Instant::now()));
}
let active = snapshot
.tabs
.iter()
.find(|t| t.id == snapshot.active_tab)
.map(|t| t.active_pane);
view.panes
.retain(|id, _| snapshot.panes.iter().any(|p| p.id == *id));
for (index, data) in snapshot.panes.iter().enumerate() {
if let Some(pane) = view.panes.get(&data.id) {
pane.update(cx, |pane, cx| {
let was_active = pane.active;
pane.active = active == Some(data.id);
pane.snapshot = snapshot.clone();
pane.index = index;
if pane.active && !was_active && focus_allowed {
if let Some(editor) = &pane.rename {
editor.read(cx).focus(window);
} else {
window.focus(&pane.focus);
}
}
// A stale snapshot can precede the FocusPane
// acknowledgement when renaming an inactive
// pane. Cancel only when focus leaves it.
if was_active && !pane.active {
pane.rename = None;
}
cx.notify();
});
} else {
let client = view.client.clone();
let frame = snapshot.clone();
let pane = cx.new(|cx| {
let mut pane = TerminalPane::new(
client,
frame,
index,
active == Some(data.id),
view.font.clone(),
window,
cx,
);
if pane.active && focus_allowed {
window.focus(&pane.focus);
}
pane.transitioning = view.transition.is_some();
pane
});
view.panes.insert(data.id, pane);
}
}
let title = snapshot
.tabs
.iter()
.find(|t| t.id == snapshot.active_tab)
.map(|t| t.title.as_str())
.unwrap_or("Terminal");
window.set_window_title(&format!("psyTerm — {title}"));
view.snapshot = Some(snapshot);
if let Some(palette) = &view.palette {
if metadata_changed {
let items = commands::root_items(
view.snapshot.as_deref(),
view.client.remote().is_some(),
);
palette
.update(cx, |palette, cx| palette.set_items(items, cx));
}
} else if cancelled_tab_rename {
view.restore_focus(window, cx);
} else if view.panes.is_empty() {
window.focus(&view.focus);
}
}
cx.notify();
})
})
.is_err()
{
break;
}
futures_lite::future::yield_now().await;
}
});
Self {
client,
font,
snapshot: None,
panes: HashMap::new(),
error: None,
focus,
palette: None,
tab_rename: None,
outgoing: HashMap::new(),
outgoing_snapshot: None,
transition: None,
transition_frame_pending: false,
_updates: task,
}
}
}
impl Render for Workspace {
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let now = Instant::now();
if self
.transition
.as_ref()
.is_some_and(|transition| transition.finished(now))
{
self.transition = None;
self.outgoing.clear();
self.outgoing_snapshot = None;
for pane in self.panes.values() {
pane.update(cx, |pane, cx| {
pane.transitioning = false;
cx.notify();
});
}
}
if self.transition.is_some() && !self.transition_frame_pending {
self.transition_frame_pending = true;
cx.on_next_frame(window, |view, _, cx| {
view.transition_frame_pending = false;
cx.notify();
});
}
let tabs = self
.snapshot
.as_ref()
.map(|s| {
s.tabs
.iter()
.map(|tab| chrome::ChromeTab {
id: tab.id,
label: tab.title.clone().into(),
remote: tab
.remote
.as_deref()
.or(self.client.remote())
.map(str::to_owned),
active: tab.id == s.active_tab,
editor: self
.tab_rename
.as_ref()
.filter(|rename| rename.tab == tab.id)
.map(|rename| rename.editor.clone()),
})
.collect()
})
.unwrap_or_default();
let client = self.client.clone();
let new_client = self.client.clone();
let owner = cx.weak_entity();
let header = chrome::header(
tabs,
cfg!(target_os = "macos") && !window.is_fullscreen(),
move |tab, _, _| {
let _ = client.send(ClientMessage::FocusTab { tab });
},
move |tab, window, cx| {
let _ = owner.update(cx, |view, cx| view.close_tab(tab, window, cx));
},
move |_, _| {
let _ = new_client.send(ClientMessage::NewTab { cwd: None });
},
move |window, _| window.remove_window(),
);
let (incoming_offset, outgoing_offset) = self
.transition
.as_ref()
.map(|transition| transition.offsets(now))
.unwrap_or(([0., 0.], [0., 0.]));
let mut body = div()
.relative()
.flex_1()
.min_h_0()
.overflow_hidden()
.bg(rgb(chrome::APP_BACKGROUND));
if let Some(snapshot) = &self.outgoing_snapshot {
body = body.child(pane_scene(snapshot, &self.outgoing, outgoing_offset, None));
}
let mut incoming = scene(incoming_offset).id("incoming-scene");
if let Some(snapshot) = &self.snapshot {
incoming = pane_scene(snapshot, &self.panes, incoming_offset, Some(&self.client));
if snapshot.panes.is_empty() {
let status = match snapshot.active_tab() {
Some(tab) if tab.is_connecting() => tab
.remote
.as_ref()
.map(|host| format!("Connecting to {host}…")),
Some(_) => None, // The selected tab's grid is still in transit.
None => Some("No sessions. Use + to open a terminal.".to_owned()),
};
if let Some(status) = status {
incoming =
incoming.child(div().p_4().text_color(rgb(chrome::MUTED)).child(status));
}
}
} else {
incoming = incoming.child(
div()
.p_4()
.text_color(rgb(chrome::MUTED))
.child("Connecting…"),
);
}
body = body.child(incoming);
let mut root = div()
.relative()
.track_focus(&self.focus)
.capture_key_down(cx.listener(Self::key_down))
.size_full()
.flex()
.flex_col()
.bg(rgb(chrome::APP_BACKGROUND))
.child(header)
.child(body);
#[cfg(target_os = "macos")]
{
root = root.on_action(cx.listener(|view, _: &crate::NewWindow, _, cx| {
view.open_window(cx);
}));
}
if let Some(error) = &self.error {
root = root.child(
div()
.flex()
.items_center()
.px_3()
.py_1()
.text_size(px(12.))
.text_color(rgb(chrome::TEXT))
.bg(rgb(chrome::BORDER))
.child(div().flex_1().min_w_0().child(error.clone()))
.child(
div()
.id("dismiss-error")
.px_2()
.cursor_pointer()
.child("Dismiss")
.on_click(cx.listener(|view, _, _, cx| {
view.error = None;
cx.notify();
})),
),
);
}
if let Some(palette) = &self.palette {
root = root.child(palette.clone());
}
root
}
}
/// Absolute positioning translates the scene without changing its layout size.
fn scene(offset: [f32; 2]) -> Div {
div()
.absolute()
.left(relative(offset[0]))
.top(relative(offset[1]))
.size_full()
.flex()
.gap(px(6.))
.p(px(chrome::CONTENT_INSET))
.bg(rgb(chrome::APP_BACKGROUND))
}
fn pane_scene(
snapshot: &Snapshot,
panes: &HashMap<u64, Entity<TerminalPane>>,
offset: [f32; 2],
client: Option<&Client>,
) -> Stateful<Div> {
// The frozen scene can contain the same collapsed headers as the live
// scene. Keep their hover, scroll, and click state in separate namespaces.
let mut content = scene(offset).id(if client.is_some() {
"incoming-scene"
} else {
"outgoing-scene"
});
if let Some(tab) = snapshot
.tabs
.iter()
.find(|tab| tab.id == snapshot.active_tab)
{
for stack in &tab.stacks {
let Some(index) = stack
.panes
.iter()
.position(|pane| pane.id == stack.active_pane)
else {
continue;
};
let mut column = div()
.flex_1()
.min_w_0()
.h_full()
.flex()
.flex_col()
.gap(px(2.))
.overflow_hidden();
if index > 0 {
column = column.child(stack_headers(
&stack.panes[..index],
format!("stack-above-{}", stack.active_pane),
client,
));
}
if let Some(pane) = panes.get(&stack.active_pane) {
column = column.child(pane.clone());
}
if index + 1 < stack.panes.len() {
column = column.child(stack_headers(
&stack.panes[index + 1..],
format!("stack-below-{}", stack.active_pane),
client,
));
}
content = content.child(column);
}
}
content
}
fn stack_headers(entries: &[StackPaneInfo], id: String, client: Option<&Client>) -> Stateful<Div> {
let mut headers = div()
.id(ElementId::Name(id.into()))
.flex()
.flex_col()
.w_full()
.flex_shrink_0()
.max_h(relative(0.25))
.overflow_y_scroll();
for entry in entries {
let pane = entry.id;
let client = client.cloned();
headers = headers.child(
chrome::pane_title_bar(false)
.id(ElementId::Name(format!("collapsed-pane-{pane}").into()))
.border_1()
.border_color(rgb(chrome::PANE_INACTIVE_BORDER))
.cursor_pointer()
.hover(|style| style.border_color(rgb(0xbdbdbd)))
.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
.on_click(move |_, _, cx| {
cx.stop_propagation();
if let Some(client) = &client {
let _ = client.send(ClientMessage::FocusPane { pane });
}
})
.child(middle_label(entry.title.clone().into())),
);
}
headers
}
fn scene_direction(old: &Snapshot, next: &Snapshot) -> Option<[f32; 2]> {
if old.panes.is_empty() || next.panes.is_empty() {
return None;
}
if old.active_tab != next.active_tab {
let previous = old
.tabs
.iter()
.position(|tab| tab.id == old.active_tab)
.unwrap_or(0);
let next_index = next
.tabs
.iter()
.position(|tab| tab.id == next.active_tab)
.unwrap_or(0);
return Some([if next_index > previous { 1. } else { -1. }, 0.]);
}
if let (Some(old_tab), Some(next_tab)) = (
old.tabs.iter().find(|tab| tab.id == old.active_tab),
next.tabs.iter().find(|tab| tab.id == next.active_tab),
) && let Some(direction) = crate::transition::stack_direction(old_tab, next_tab)
{
return Some([0., direction]);
}
next.panes
.iter()
.any(|pane| !old.panes.iter().any(|old| old.id == pane.id))
.then_some([1., 0.])
}
struct TerminalPane {
client: Client,
snapshot: Arc<Snapshot>,
index: usize,
active: bool,
// Frozen outgoing scenes are display-only; no PTY resize, focus or input.
read_only: bool,
transitioning: bool,
focus: FocusHandle,
bounds: Bounds<Pixels>,
selecting: bool,
scroll_remainder: f32,
preedit: String,
cursor_bounds: Bounds<Pixels>,
cursor: CursorAnimator,
renderer: Renderer,
rename: Option<Entity<RenameField>>,
prepared_revision: Option<u64>,
requested_size: Option<(u16, u16)>,
next_frame_pending: bool,
blink_timer: Option<Task<()>>,
_activation: Subscription,
}
impl TerminalPane {
fn new(
client: Client,
snapshot: Arc<Snapshot>,
index: usize,
active: bool,
font: TerminalFont,
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let focus = cx.focus_handle();
let activation = cx.observe_window_activation(window, |pane, window, cx| {
if window.is_window_active() {
// Each attached window has its own zoom and viewport. The focused
// window sets the shared PTY dimensions.
pane.requested_size = None;
}
pane.blink_timer = None;
cx.notify();
});
Self {
client,
snapshot,
index,
active,
read_only: false,
transitioning: false,
focus,
bounds: Bounds::default(),
selecting: false,
scroll_remainder: 0.,
preedit: String::new(),
cursor_bounds: Bounds::default(),
cursor: CursorAnimator::new(),
renderer: Renderer::new(font),
rename: None,
prepared_revision: None,
requested_size: None,
next_frame_pending: false,
blink_timer: None,
_activation: activation,
}
}
fn data(&self) -> &PaneSnapshot {
&self.snapshot.panes[self.index]
}
fn command(&self, command: ClientMessage) {
if self.read_only {
return;
}
if let Err(error) = self.client.send(command) {
log::warn!("{error:#}");
}
}
fn mode(&self) -> TermMode {
TermMode::from_bits_truncate(self.data().mode)
}
fn activity(&mut self, cx: &mut Context<Self>) {
self.cursor.activity(Instant::now());
self.blink_timer = None;
cx.notify();
}
fn send(&mut self, bytes: Vec<u8>, cx: &mut Context<Self>) {
if self.read_only || bytes.is_empty() {
return;
}
self.preedit.clear();
self.activity(cx);
if let Err(error) = self.client.input(self.data().id, bytes) {
log::warn!("{error:#}");
}
}
fn begin_rename(&mut self, window: &mut Window, cx: &mut Context<Self>) {
self.command(ClientMessage::FocusPane {
pane: self.data().id,
});
self.preedit.clear();
self.selecting = false;
let initial = self.data().title.clone();
let owner = cx.weak_entity();
let field = cx.new(|cx| {
RenameField::new(
initial,
move |name, window, cx| {
let _ = owner.update(cx, |pane, cx| {
pane.rename = None;
if let Some(name) = name {
pane.command(ClientMessage::RenamePane {
pane: pane.data().id,
name: Some(name),
});
}
window.focus(&pane.focus);
pane.activity(cx);
});
},
window,
cx,
)
});
self.rename = Some(field);
cx.notify();
}
fn pane_header(&mut self, cx: &mut Context<Self>) -> Div {
let mut header = chrome::pane_title_bar(self.active)
.flex()
.items_center()
.gap(px(8.))
.on_mouse_down(
MouseButton::Left,
cx.listener(|pane, _, window, cx| {
cx.stop_propagation();
if pane.read_only {
return;
}
if pane.rename.is_none() {
window.focus(&pane.focus);
}
pane.command(ClientMessage::FocusPane {
pane: pane.data().id,
});
}),
);
if let Some(editor) = &self.rename {
header = header
.child(div().flex_1().min_w_0().child(editor.clone()))
.child(
div()
.flex_shrink_0()
.text_size(px(11.))
.font_weight(FontWeight::NORMAL)
.child("Enter to save · Esc to cancel"),
);
} else {
header = header.child(
div()
.flex_1()
.min_w_0()
.h_full()
.overflow_hidden()
.child(middle_label(self.data().title.clone().into())),
);
}
header
}
fn key_down(&mut self, event: &KeyDownEvent, _: &mut Window, cx: &mut Context<Self>) {
if self.read_only || self.rename.is_some() {
return;
}
let key = &event.keystroke;
let pane = self.data().id;
self.activity(cx);
if key.modifiers.shift
&& !key.modifiers.control
&& !key.modifiers.alt
&& !key.modifiers.platform
&& !self.mode().contains(TermMode::ALT_SCREEN)
{
let kind = match key.key.as_str() {
"pageup" => Some(ScrollKind::PageUp),
"pagedown" => Some(ScrollKind::PageDown),
"home" => Some(ScrollKind::Top),
"end" => Some(ScrollKind::Bottom),
_ => None,
};
if let Some(kind) = kind {
self.command(ClientMessage::Scroll { pane, kind });
cx.stop_propagation();
return;
}
}
if let Some(bytes) = input::encode_key(key, self.mode()) {
self.send(bytes, cx);
cx.stop_propagation();
}
}
fn grid_point(&self, position: Point<Pixels>) -> (u16, u16, SelectionSide) {
let x = ((f32::from(position.x - self.bounds.left()) - PADDING).max(0.)
/ self.renderer.font.cell_width)
.min(f32::from(self.data().columns - 1));
let y = ((f32::from(position.y - self.bounds.top()) - PADDING).max(0.)
/ self.renderer.font.line_height)
.min(f32::from(self.data().lines - 1));
(
x as u16,
y as u16,
if x.fract() < 0.5 {
SelectionSide::Left
} else {
SelectionSide::Right
},
)
}
fn mouse_down(&mut self, event: &MouseDownEvent, window: &mut Window, cx: &mut Context<Self>) {
if self.read_only {
return;
}
window.focus(&self.focus);
self.activity(cx);
let pane = self.data().id;
self.command(ClientMessage::FocusPane { pane });
let (column, row, side) = self.grid_point(event.position);
let kind = match event.click_count {
2 => SelectionKind::Word,
3.. => SelectionKind::Line,
_ => SelectionKind::Simple,
};
self.command(ClientMessage::Selection {
pane,
selection: SelectionCommand::Start {
column,
row,
side,
kind,
},
});
self.selecting = true;
}
fn mouse_move(&mut self, event: &MouseMoveEvent, _: &mut Window, _: &mut Context<Self>) {
if self.selecting && event.dragging() {
let (column, row, side) = self.grid_point(event.position);
self.command(ClientMessage::Selection {
pane: self.data().id,
selection: SelectionCommand::Update { column, row, side },
});
}
}
fn scroll(&mut self, event: &ScrollWheelEvent, _: &mut Window, cx: &mut Context<Self>) {
if self.read_only {
return;
}
self.scroll_remainder += match event.delta {
ScrollDelta::Lines(d) => d.y * 3.,
ScrollDelta::Pixels(d) => f32::from(d.y) / self.renderer.font.line_height,
};
let lines = self.scroll_remainder.trunc() as i32;
self.scroll_remainder -= lines as f32;
if lines == 0 {
return;
}
let mode = self.mode();
if mode.contains(TermMode::ALT_SCREEN | TermMode::ALTERNATE_SCROLL)
&& !event.modifiers.shift
{
let arrow = match (mode.contains(TermMode::APP_CURSOR), lines > 0) {
(true, true) => b"\x1bOA",
(true, false) => b"\x1bOB",
(false, true) => b"\x1b[A",
(false, false) => b"\x1b[B",
};
self.send(arrow.repeat(lines.unsigned_abs().min(100) as usize), cx);
} else {
self.command(ClientMessage::Scroll {
pane: self.data().id,
kind: ScrollKind::Delta(lines),
});
}
}
fn prepare(&mut self, bounds: Bounds<Pixels>, window: &mut Window) {
let font = &self.renderer.font;
let columns = ((f32::from(bounds.size.width) - 2. * PADDING) / font.cell_width)
.floor()
.clamp(2., 1000.) as u16;
let lines = ((f32::from(bounds.size.height) - 2. * PADDING) / font.line_height)
.floor()
.clamp(1., 500.) as u16;
if !self.read_only
&& window.is_window_active()
&& self.requested_size != Some((columns, lines))
{
self.requested_size = Some((columns, lines));
self.command(ClientMessage::Resize {
pane: self.data().id,
columns,
lines,
cell_width: font.cell_width.round() as u16,
cell_height: font.line_height as u16,
});
}
let prepare_rows = self.prepared_revision != Some(self.snapshot.revision)
|| self.bounds.size != bounds.size;
if !prepare_rows && self.bounds.origin == bounds.origin {
return;
}
let started = Instant::now();
self.bounds = bounds;
let data = self.data();
let mut palette = Colors::default();
for (i, color) in data.colors.iter().enumerate() {
palette[i] = *color;
}
let cursor = data.cursor;
let hidden = data.exited || cursor.row < 0 || cursor.row >= i32::from(data.lines);
let wide = data
.cells
.get(
cursor.row.max(0) as usize * usize::from(data.columns) + usize::from(cursor.column),
)
.is_some_and(|cell| {
cell.flags
.contains(alacritty_terminal::term::cell::Flags::WIDE_CHAR)
});
let cursor_bounds = Bounds::new(
bounds.origin
+ point(
px(PADDING + f32::from(cursor.column) * font.cell_width),
px(PADDING + cursor.row as f32 * font.line_height),
),
size(
px(font.cell_width * if wide { 2. } else { 1. }),
px(font.line_height),
),
);
let mut cursor_color = colors::resolve(Color::Named(NamedColor::Cursor), &palette);
cursor_color.a = 0.55;
self.cursor_bounds = cursor_bounds;
self.cursor.set_target(
cursor_bounds,
if hidden {
CursorShape::Hidden
} else {
cursor.shape.into()
},
cursor_color,
Instant::now(),
);
if !prepare_rows {
return;
}
let data = self.data();
let rows = data
.cells
.chunks(usize::from(data.columns))
.enumerate()
.map(|(row, cells)| {
cells
.iter()
.enumerate()
.map(|(col, cell)| {
let (mut foreground, mut background) = colors::cell_colors(cell, &palette);
if data.selected[row * usize::from(data.columns) + col] {
foreground = rgb(chrome::TEXT).into();
background = rgb(chrome::BORDER).into();
}
RenderCell {
cell: cell.clone(),
foreground,
background,
cursor: CursorShape::Hidden,
}
})
.collect()
})
.collect();
self.renderer.prepare(rows, window);
self.prepared_revision = Some(self.snapshot.revision);
log::debug!(target:"psyterm::timing","prepare_us={}",started.elapsed().as_micros());
}
fn schedule_cursor(
&mut self,
delay: Option<Duration>,
window: &mut Window,
cx: &mut Context<Self>,
) {
self.blink_timer = None;
match delay {
Some(delay) if delay.is_zero() => {
if !self.next_frame_pending {
self.next_frame_pending = true;
cx.on_next_frame(window, |pane, _, cx| {
pane.next_frame_pending = false;
cx.notify();
});
}
}
Some(delay) => {
self.blink_timer = Some(cx.spawn_in(window, async move |pane, cx| {
cx.background_executor().timer(delay).await;
let _ = pane.update(cx, |_, cx| cx.notify());
}));
}
None => {}
}
}
}
impl Render for TerminalPane {
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let prepare = cx.entity();
let paint = cx.entity();
let header = self.pane_header(cx);
let content = div().flex_1().min_h_0().min_w_0().overflow_hidden().cursor(CursorStyle::IBeam)
.on_mouse_down(MouseButton::Left,cx.listener(|pane, event, window, cx| {
pane.rename = None;
pane.mouse_down(event, window, cx);
}))
.on_mouse_move(cx.listener(Self::mouse_move))
.on_mouse_up(MouseButton::Left,cx.listener(|pane,_,_,_|pane.selecting=false))
.on_mouse_up_out(MouseButton::Left,cx.listener(|pane,_,_,_|pane.selecting=false))
.on_scroll_wheel(cx.listener(Self::scroll))
.child(canvas(move |bounds,window,cx|prepare.update(cx,|pane,_|pane.prepare(bounds,window)),
move |bounds,(),window,cx| {
paint.update(cx,|pane,cx| {
let started=Instant::now();
if !pane.read_only && pane.rename.is_none() {
window.handle_input(&pane.focus,ElementInputHandler::new(bounds,paint.clone()),cx);
}
let mut delay=None;
window.with_content_mask(Some(ContentMask{bounds}),|window| {
let origin=bounds.origin+point(px(PADDING),px(PADDING));
let focused=window.is_window_active() && pane.active && pane.focus.is_focused(window) && pane.rename.is_none();
pane.renderer.paint_with_cursor(origin,window,cx,|window| {
if !pane.transitioning {
delay=pane.cursor.paint(Instant::now(),focused,window);
}
});
if !pane.preedit.is_empty() {
let font = &pane.renderer.font;
let run = TextRun {
len: pane.preedit.len(),
font: font.face.clone(),
color: rgb(chrome::TEXT).into(),
background_color: Some(rgb(chrome::TERMINAL_BACKGROUND).into()),
underline: Some(UnderlineStyle {
thickness: px(1.),
color: None,
wavy: false,
}),
strikethrough: None,
};
let line = window.text_system().shape_line(
pane.preedit.clone().into(), px(font.size), &[run], None,
);
let origin = pane.cursor_bounds.origin;
let height = px(font.line_height);
let _ = line.paint_background(origin, height, window, cx);
let _ = line.paint(origin, height, window, cx);
}
});
pane.schedule_cursor(delay,window,cx);
log::debug!(target:"psyterm::timing","paint_us={}",started.elapsed().as_micros());
});
}).size_full());
div()
.flex_1()
.min_w_0()
.min_h_0()
.h_full()
.flex()
.flex_col()
.bg(rgb(chrome::TERMINAL_BACKGROUND))
.border_1()
.border_color(rgb(if self.active {
chrome::PANE_FOCUS
} else {
chrome::PANE_INACTIVE_BORDER
}))
.overflow_hidden()
.track_focus(&self.focus)
.on_key_down(cx.listener(Self::key_down))
.child(header)
.child(content)
}
}
impl EntityInputHandler for TerminalPane {
fn text_for_range(
&mut self,
_: Range<usize>,
_: &mut Option<Range<usize>>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<String> {
None
}
fn selected_text_range(
&mut self,
_: bool,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<UTF16Selection> {
Some(UTF16Selection {
range: 0..0,
reversed: false,
})
}
fn marked_text_range(&self, _: &mut Window, _: &mut Context<Self>) -> Option<Range<usize>> {
(!self.preedit.is_empty()).then(|| 0..self.preedit.encode_utf16().count())
}
fn unmark_text(&mut self, _: &mut Window, cx: &mut Context<Self>) {
self.preedit.clear();
cx.notify();
}
fn replace_text_in_range(
&mut self,
_: Option<Range<usize>>,
text: &str,
_: &mut Window,
cx: &mut Context<Self>,
) {
if text.is_empty() {
if !self.preedit.is_empty() {
self.preedit.clear();
cx.notify();
}
} else {
self.send(text.as_bytes().to_vec(), cx);
}
}
fn replace_and_mark_text_in_range(
&mut self,
_: Option<Range<usize>>,
text: &str,
_: Option<Range<usize>>,
_: &mut Window,
cx: &mut Context<Self>,
) {
self.preedit = text.to_owned();
self.activity(cx);
}
fn bounds_for_range(
&mut self,
_: Range<usize>,
_: Bounds<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<Bounds<Pixels>> {
Some(self.cursor_bounds)
}
fn character_index_for_point(
&mut self,
_: Point<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<usize> {
None
}
}