mirror of
https://github.com/wez/wezterm.git
synced 2024-12-24 22:01:47 +03:00
2f4266cb6a
* WIP resize pane from CLI * fix response types * fix: remove unneeded `import std::usize;` Co-authored-by: Wez Furlong <wez@wezfurlong.org> * fix: update derived files * fix: update codec version * chore: update changelog.md * fix: remove unneeded `import std::usize;` Co-authored-by: Wez Furlong <wez@wezfurlong.org> * chore: update changelog.md * remove erroneous changelog.md change * remove erroneous changelog.md change * remove whitespace changes --------- Co-authored-by: Wez Furlong <wez@wezfurlong.org>
1086 lines
41 KiB
Rust
1086 lines
41 KiB
Rust
use crate::PKI;
|
|
use anyhow::{anyhow, Context};
|
|
use codec::*;
|
|
use config::TermConfig;
|
|
use mux::client::ClientId;
|
|
use mux::domain::SplitSource;
|
|
use mux::pane::{Pane, PaneId};
|
|
use mux::renderable::{RenderableDimensions, StableCursorPosition};
|
|
use mux::tab::TabId;
|
|
use mux::{Mux, MuxNotification};
|
|
use promise::spawn::spawn_into_main_thread;
|
|
use std::collections::HashMap;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::time::Instant;
|
|
use termwiz::surface::SequenceNo;
|
|
use url::Url;
|
|
use wezterm_term::terminal::Alert;
|
|
use wezterm_term::StableRowIndex;
|
|
|
|
#[derive(Clone)]
|
|
pub struct PduSender {
|
|
func: Arc<dyn Fn(DecodedPdu) -> anyhow::Result<()> + Send + Sync>,
|
|
}
|
|
|
|
impl PduSender {
|
|
pub fn send(&self, pdu: DecodedPdu) -> anyhow::Result<()> {
|
|
(self.func)(pdu)
|
|
}
|
|
|
|
pub fn new<T>(f: T) -> Self
|
|
where
|
|
T: Fn(DecodedPdu) -> anyhow::Result<()> + Send + Sync + 'static,
|
|
{
|
|
Self { func: Arc::new(f) }
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Debug)]
|
|
pub(crate) struct PerPane {
|
|
cursor_position: StableCursorPosition,
|
|
title: String,
|
|
working_dir: Option<Url>,
|
|
dimensions: RenderableDimensions,
|
|
mouse_grabbed: bool,
|
|
sent_initial_palette: bool,
|
|
seqno: SequenceNo,
|
|
config_generation: usize,
|
|
pub(crate) notifications: Vec<Alert>,
|
|
}
|
|
|
|
impl PerPane {
|
|
fn compute_changes(
|
|
&mut self,
|
|
pane: &Arc<dyn Pane>,
|
|
force_with_input_serial: Option<InputSerial>,
|
|
) -> Option<GetPaneRenderChangesResponse> {
|
|
let mut changed = false;
|
|
let mouse_grabbed = pane.is_mouse_grabbed();
|
|
if mouse_grabbed != self.mouse_grabbed {
|
|
changed = true;
|
|
}
|
|
|
|
let dims = pane.get_dimensions();
|
|
if dims != self.dimensions {
|
|
changed = true;
|
|
}
|
|
|
|
let cursor_position = pane.get_cursor_position();
|
|
if cursor_position != self.cursor_position {
|
|
changed = true;
|
|
}
|
|
|
|
let title = pane.get_title();
|
|
if title != self.title {
|
|
changed = true;
|
|
}
|
|
|
|
let working_dir = pane.get_current_working_dir();
|
|
if working_dir != self.working_dir {
|
|
changed = true;
|
|
}
|
|
|
|
let mut all_dirty_lines = pane.get_changed_since(
|
|
0..dims.physical_top + dims.viewport_rows as StableRowIndex,
|
|
self.seqno,
|
|
);
|
|
if !all_dirty_lines.is_empty() {
|
|
changed = true;
|
|
}
|
|
|
|
if !changed && !force_with_input_serial.is_some() {
|
|
return None;
|
|
}
|
|
|
|
// Figure out what we're going to send as dirty lines vs bonus lines
|
|
let viewport_range =
|
|
dims.physical_top..dims.physical_top + dims.viewport_rows as StableRowIndex;
|
|
|
|
let (first_line, lines) = pane.get_lines(viewport_range);
|
|
let mut bonus_lines = lines
|
|
.into_iter()
|
|
.enumerate()
|
|
.filter_map(|(idx, mut line)| {
|
|
let stable_row = first_line + idx as StableRowIndex;
|
|
if all_dirty_lines.contains(stable_row) {
|
|
all_dirty_lines.remove(stable_row);
|
|
line.compress_for_scrollback();
|
|
Some((stable_row, line))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
// Always send the cursor's row, as that tends to the busiest and we don't
|
|
// have a sequencing concept for our idea of the remote state.
|
|
let (cursor_line_idx, mut lines) = pane.get_lines(cursor_position.y..cursor_position.y + 1);
|
|
let mut cursor_line = lines.remove(0);
|
|
cursor_line.compress_for_scrollback();
|
|
bonus_lines.push((cursor_line_idx, cursor_line));
|
|
|
|
self.cursor_position = cursor_position;
|
|
self.title = title.clone();
|
|
self.working_dir = working_dir.clone();
|
|
self.dimensions = dims;
|
|
self.mouse_grabbed = mouse_grabbed;
|
|
self.seqno = pane.get_current_seqno();
|
|
|
|
let bonus_lines = bonus_lines.into();
|
|
Some(GetPaneRenderChangesResponse {
|
|
pane_id: pane.pane_id(),
|
|
mouse_grabbed,
|
|
dirty_lines: all_dirty_lines.iter().cloned().collect(),
|
|
dimensions: dims,
|
|
cursor_position,
|
|
title,
|
|
bonus_lines,
|
|
working_dir: working_dir.map(Into::into),
|
|
input_serial: force_with_input_serial,
|
|
seqno: self.seqno,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn maybe_push_pane_changes(
|
|
pane: &Arc<dyn Pane>,
|
|
sender: PduSender,
|
|
per_pane: Arc<Mutex<PerPane>>,
|
|
) -> anyhow::Result<()> {
|
|
let mut per_pane = per_pane.lock().unwrap();
|
|
if let Some(resp) = per_pane.compute_changes(pane, None) {
|
|
sender.send(DecodedPdu {
|
|
pdu: Pdu::GetPaneRenderChangesResponse(resp),
|
|
serial: 0,
|
|
})?;
|
|
}
|
|
|
|
let config = config::configuration();
|
|
if per_pane.config_generation != config.generation() {
|
|
per_pane.config_generation = config.generation();
|
|
// If the config changed, it may have changed colors
|
|
// in the palette that we need to push down, so we
|
|
// synthesize a palette change notification to let
|
|
// the client know
|
|
per_pane.notifications.push(Alert::PaletteChanged);
|
|
per_pane.sent_initial_palette = true;
|
|
}
|
|
|
|
if !per_pane.sent_initial_palette {
|
|
per_pane.notifications.push(Alert::PaletteChanged);
|
|
per_pane.sent_initial_palette = true;
|
|
}
|
|
for alert in per_pane.notifications.drain(..) {
|
|
match alert {
|
|
Alert::PaletteChanged => {
|
|
sender.send(DecodedPdu {
|
|
pdu: Pdu::SetPalette(SetPalette {
|
|
pane_id: pane.pane_id(),
|
|
palette: pane.palette(),
|
|
}),
|
|
serial: 0,
|
|
})?;
|
|
}
|
|
alert => {
|
|
sender.send(DecodedPdu {
|
|
pdu: Pdu::NotifyAlert(NotifyAlert {
|
|
pane_id: pane.pane_id(),
|
|
alert,
|
|
}),
|
|
serial: 0,
|
|
})?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub struct SessionHandler {
|
|
to_write_tx: PduSender,
|
|
per_pane: HashMap<TabId, Arc<Mutex<PerPane>>>,
|
|
client_id: Option<Arc<ClientId>>,
|
|
}
|
|
|
|
impl Drop for SessionHandler {
|
|
fn drop(&mut self) {
|
|
if let Some(client_id) = self.client_id.take() {
|
|
let mux = Mux::get();
|
|
mux.unregister_client(&client_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SessionHandler {
|
|
pub fn new(to_write_tx: PduSender) -> Self {
|
|
Self {
|
|
to_write_tx,
|
|
per_pane: HashMap::new(),
|
|
client_id: None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn per_pane(&mut self, pane_id: PaneId) -> Arc<Mutex<PerPane>> {
|
|
Arc::clone(
|
|
self.per_pane
|
|
.entry(pane_id)
|
|
.or_insert_with(|| Arc::new(Mutex::new(PerPane::default()))),
|
|
)
|
|
}
|
|
|
|
pub fn schedule_pane_push(&mut self, pane_id: PaneId) {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
Ok::<(), anyhow::Error>(())
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
pub fn process_one(&mut self, decoded: DecodedPdu) {
|
|
let start = Instant::now();
|
|
let sender = self.to_write_tx.clone();
|
|
let serial = decoded.serial;
|
|
|
|
if let Some(client_id) = &self.client_id {
|
|
if decoded.pdu.is_user_input() {
|
|
Mux::get().client_had_input(client_id);
|
|
}
|
|
}
|
|
|
|
let send_response = move |result: anyhow::Result<Pdu>| {
|
|
let pdu = match result {
|
|
Ok(pdu) => pdu,
|
|
Err(err) => Pdu::ErrorResponse(ErrorResponse {
|
|
reason: format!("Error: {err:#}"),
|
|
}),
|
|
};
|
|
log::trace!("{} processing time {:?}", serial, start.elapsed());
|
|
sender.send(DecodedPdu { pdu, serial }).ok();
|
|
};
|
|
|
|
fn catch<F, SND>(f: F, send_response: SND)
|
|
where
|
|
F: FnOnce() -> anyhow::Result<Pdu>,
|
|
SND: Fn(anyhow::Result<Pdu>),
|
|
{
|
|
send_response(f());
|
|
}
|
|
|
|
match decoded.pdu {
|
|
Pdu::Ping(Ping {}) => send_response(Ok(Pdu::Pong(Pong {}))),
|
|
Pdu::SetWindowWorkspace(SetWindowWorkspace {
|
|
window_id,
|
|
workspace,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let mut window = mux
|
|
.get_window_mut(window_id)
|
|
.ok_or_else(|| anyhow!("window {} is invalid", window_id))?;
|
|
window.set_workspace(&workspace);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::SetClientId(SetClientId { client_id }) => {
|
|
let client_id = Arc::new(client_id);
|
|
self.client_id.replace(client_id.clone());
|
|
spawn_into_main_thread(async move {
|
|
let mux = Mux::get();
|
|
mux.register_client(client_id);
|
|
})
|
|
.detach();
|
|
send_response(Ok(Pdu::UnitResponse(UnitResponse {})))
|
|
}
|
|
Pdu::SetFocusedPane(SetFocusedPane { pane_id }) => {
|
|
let client_id = self.client_id.clone();
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let _identity = mux.with_identity(client_id);
|
|
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow::anyhow!("pane {pane_id} not found"))?;
|
|
|
|
let (_domain_id, window_id, tab_id) = mux
|
|
.resolve_pane_id(pane_id)
|
|
.ok_or_else(|| anyhow::anyhow!("pane {pane_id} not found"))?;
|
|
{
|
|
let mut window =
|
|
mux.get_window_mut(window_id).ok_or_else(|| {
|
|
anyhow::anyhow!("window {window_id} not found")
|
|
})?;
|
|
let tab_idx = window.idx_by_id(tab_id).ok_or_else(|| {
|
|
anyhow::anyhow!(
|
|
"tab {tab_id} isn't really in window {window_id}!?"
|
|
)
|
|
})?;
|
|
window.save_and_then_set_active(tab_idx);
|
|
}
|
|
let tab = mux
|
|
.get_tab(tab_id)
|
|
.ok_or_else(|| anyhow::anyhow!("tab {tab_id} not found"))?;
|
|
tab.set_active_pane(&pane);
|
|
|
|
mux.record_focus_for_current_identity(pane_id);
|
|
mux.notify(mux::MuxNotification::PaneFocused(pane_id));
|
|
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::GetClientList(GetClientList) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let clients = mux.iter_clients();
|
|
Ok(Pdu::GetClientListResponse(GetClientListResponse {
|
|
clients,
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::ListPanes(ListPanes {}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let mut tabs = vec![];
|
|
let mut tab_titles = vec![];
|
|
let mut window_titles = HashMap::new();
|
|
for window_id in mux.iter_windows().into_iter() {
|
|
let window = mux.get_window(window_id).unwrap();
|
|
window_titles.insert(window_id, window.get_title().to_string());
|
|
for tab in window.iter() {
|
|
tabs.push(tab.codec_pane_tree());
|
|
tab_titles.push(tab.get_title());
|
|
}
|
|
}
|
|
log::trace!("ListPanes {tabs:#?} {tab_titles:?}");
|
|
Ok(Pdu::ListPanesResponse(ListPanesResponse {
|
|
tabs,
|
|
tab_titles,
|
|
window_titles,
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::RenameWorkspace(RenameWorkspace {
|
|
old_workspace,
|
|
new_workspace,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
mux.rename_workspace(&old_workspace, &new_workspace);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
);
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::WriteToPane(WriteToPane { pane_id, data }) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.writer().write_all(&data)?;
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
);
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::EraseScrollbackRequest(EraseScrollbackRequest {
|
|
pane_id,
|
|
erase_mode,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.erase_scrollback(erase_mode);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
);
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::KillPane(KillPane { pane_id }) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.kill();
|
|
mux.remove_pane(pane_id);
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
);
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::SendPaste(SendPaste { pane_id, data }) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.send_paste(&data)?;
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::SearchScrollbackRequest(SearchScrollbackRequest {
|
|
pane_id,
|
|
pattern,
|
|
range,
|
|
limit,
|
|
}) => {
|
|
use mux::pane::Pattern;
|
|
|
|
async fn do_search(
|
|
pane_id: TabId,
|
|
pattern: Pattern,
|
|
range: std::ops::Range<StableRowIndex>,
|
|
limit: Option<u32>,
|
|
) -> anyhow::Result<Pdu> {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
|
|
pane.search(pattern, range, limit).await.map(|results| {
|
|
Pdu::SearchScrollbackResponse(SearchScrollbackResponse { results })
|
|
})
|
|
}
|
|
|
|
spawn_into_main_thread(async move {
|
|
promise::spawn::spawn(async move {
|
|
let result = do_search(pane_id, pattern, range, limit).await;
|
|
send_response(result);
|
|
})
|
|
.detach();
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::SetPaneZoomed(SetPaneZoomed {
|
|
containing_tab_id,
|
|
pane_id,
|
|
zoomed,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
let tab = mux
|
|
.get_tab(containing_tab_id)
|
|
.ok_or_else(|| anyhow!("no such tab {}", containing_tab_id))?;
|
|
tab.set_active_pane(&pane);
|
|
tab.set_zoomed(zoomed);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetPaneDirection(GetPaneDirection { pane_id, direction }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let (_domain_id, _window_id, tab_id) = mux
|
|
.resolve_pane_id(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
let tab = mux
|
|
.get_tab(tab_id)
|
|
.ok_or_else(|| anyhow!("no such tab {}", tab_id))?;
|
|
let panes = tab.iter_panes_ignoring_zoom();
|
|
let pane_id = tab
|
|
.get_pane_direction(direction, true)
|
|
.map(|pane_index| panes[pane_index].pane.pane_id());
|
|
|
|
Ok(Pdu::GetPaneDirectionResponse(GetPaneDirectionResponse {
|
|
pane_id,
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::ActivatePaneDirection(ActivatePaneDirection { pane_id, direction }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let (_domain_id, _window_id, tab_id) = mux
|
|
.resolve_pane_id(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
let tab = mux
|
|
.get_tab(tab_id)
|
|
.ok_or_else(|| anyhow!("no such tab {}", tab_id))?;
|
|
tab.activate_pane_direction(direction);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::Resize(Resize {
|
|
containing_tab_id,
|
|
pane_id,
|
|
size,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.resize(size)?;
|
|
let tab = mux
|
|
.get_tab(containing_tab_id)
|
|
.ok_or_else(|| anyhow!("no such tab {}", containing_tab_id))?;
|
|
tab.rebuild_splits_sizes_from_contained_panes();
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::SendKeyDown(SendKeyDown {
|
|
pane_id,
|
|
event,
|
|
input_serial,
|
|
}) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.key_down(event.key, event.modifiers)?;
|
|
|
|
// For a key press, we want to always send back the
|
|
// cursor position so that the predictive echo doesn't
|
|
// leave the cursor in the wrong place
|
|
let mut per_pane = per_pane.lock().unwrap();
|
|
if let Some(resp) = per_pane.compute_changes(&pane, Some(input_serial))
|
|
{
|
|
sender.send(DecodedPdu {
|
|
pdu: Pdu::GetPaneRenderChangesResponse(resp),
|
|
serial: 0,
|
|
})?;
|
|
}
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::SendMouseEvent(SendMouseEvent { pane_id, event }) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
pane.mouse_event(event)?;
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::SpawnV2(spawn) => {
|
|
let client_id = self.client_id.clone();
|
|
spawn_into_main_thread(async move {
|
|
schedule_domain_spawn_v2(spawn, send_response, client_id);
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::SplitPane(split) => {
|
|
let client_id = self.client_id.clone();
|
|
spawn_into_main_thread(async move {
|
|
schedule_split_pane(split, send_response, client_id);
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::MovePaneToNewTab(request) => {
|
|
let client_id = self.client_id.clone();
|
|
spawn_into_main_thread(async move {
|
|
schedule_move_pane(request, send_response, client_id);
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetPaneRenderableDimensions(GetPaneRenderableDimensions { pane_id }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
let cursor_position = pane.get_cursor_position();
|
|
let dimensions = pane.get_dimensions();
|
|
Ok(Pdu::GetPaneRenderableDimensionsResponse(
|
|
GetPaneRenderableDimensionsResponse {
|
|
pane_id,
|
|
cursor_position,
|
|
dimensions,
|
|
},
|
|
))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetPaneRenderChanges(GetPaneRenderChanges { pane_id, .. }) => {
|
|
let sender = self.to_write_tx.clone();
|
|
let per_pane = self.per_pane(pane_id);
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let is_alive = match mux.get_pane(pane_id) {
|
|
Some(pane) => {
|
|
maybe_push_pane_changes(&pane, sender, per_pane)?;
|
|
true
|
|
}
|
|
None => false,
|
|
};
|
|
Ok(Pdu::LivenessResponse(LivenessResponse {
|
|
pane_id,
|
|
is_alive,
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetLines(GetLines { pane_id, lines }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
let mut lines_and_indices = vec![];
|
|
|
|
for range in lines {
|
|
let (first_row, lines) = pane.get_lines(range);
|
|
for (idx, mut line) in lines.into_iter().enumerate() {
|
|
let stable_row = first_row + idx as StableRowIndex;
|
|
line.compress_for_scrollback();
|
|
lines_and_indices.push((stable_row, line));
|
|
}
|
|
}
|
|
Ok(Pdu::GetLinesResponse(GetLinesResponse {
|
|
pane_id,
|
|
lines: lines_and_indices.into(),
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetImageCell(GetImageCell {
|
|
pane_id,
|
|
line_idx,
|
|
cell_idx,
|
|
data_hash,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let mut data = None;
|
|
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
|
|
let (_, lines) = pane.get_lines(line_idx..line_idx + 1);
|
|
'found_data: for line in lines {
|
|
if let Some(cell) = line.get_cell(cell_idx) {
|
|
if let Some(images) = cell.attrs().images() {
|
|
for im in images {
|
|
if im.image_data().hash() == data_hash {
|
|
data.replace(im.image_data().clone());
|
|
break 'found_data;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(Pdu::GetImageCellResponse(GetImageCellResponse {
|
|
pane_id,
|
|
data,
|
|
}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::GetCodecVersion(_) => {
|
|
match std::env::current_exe().context("resolving current_exe") {
|
|
Err(err) => send_response(Err(err)),
|
|
Ok(executable_path) => {
|
|
send_response(Ok(Pdu::GetCodecVersionResponse(GetCodecVersionResponse {
|
|
codec_vers: CODEC_VERSION,
|
|
version_string: config::wezterm_version().to_owned(),
|
|
executable_path,
|
|
config_file_path: std::env::var_os("WEZTERM_CONFIG_FILE")
|
|
.map(Into::into),
|
|
})))
|
|
}
|
|
}
|
|
}
|
|
|
|
Pdu::GetTlsCreds(_) => {
|
|
catch(
|
|
move || {
|
|
let client_cert_pem = PKI.generate_client_cert()?;
|
|
let ca_cert_pem = PKI.ca_pem_string()?;
|
|
Ok(Pdu::GetTlsCredsResponse(GetTlsCredsResponse {
|
|
client_cert_pem,
|
|
ca_cert_pem,
|
|
}))
|
|
},
|
|
send_response,
|
|
);
|
|
}
|
|
Pdu::WindowTitleChanged(WindowTitleChanged { window_id, title }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let mut window = mux
|
|
.get_window_mut(window_id)
|
|
.ok_or_else(|| anyhow!("no such window {window_id}"))?;
|
|
|
|
window.set_title(&title);
|
|
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::TabTitleChanged(TabTitleChanged { tab_id, title }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let tab = mux
|
|
.get_tab(tab_id)
|
|
.ok_or_else(|| anyhow!("no such tab {tab_id}"))?;
|
|
|
|
tab.set_title(&title);
|
|
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
Pdu::SetPalette(SetPalette { pane_id, palette }) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let pane = mux
|
|
.get_pane(pane_id)
|
|
.ok_or_else(|| anyhow!("no such pane {}", pane_id))?;
|
|
|
|
match pane.get_config() {
|
|
Some(config) => match config.downcast_ref::<TermConfig>() {
|
|
Some(tc) => tc.set_client_palette(palette),
|
|
None => {
|
|
log::error!(
|
|
"pane {pane_id} doesn't \
|
|
have TermConfig as its config! \
|
|
Ignoring client palette update"
|
|
);
|
|
}
|
|
},
|
|
None => {
|
|
let config = TermConfig::new();
|
|
config.set_client_palette(palette);
|
|
pane.set_config(Arc::new(config));
|
|
}
|
|
}
|
|
|
|
mux.notify(MuxNotification::Alert {
|
|
pane_id,
|
|
alert: Alert::PaletteChanged,
|
|
});
|
|
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::AdjustPaneSize(AdjustPaneSize {
|
|
pane_id,
|
|
direction,
|
|
amount,
|
|
}) => {
|
|
spawn_into_main_thread(async move {
|
|
catch(
|
|
move || {
|
|
let mux = Mux::get();
|
|
let (_pane_domain_id, _window_id, tab_id) = mux
|
|
.resolve_pane_id(pane_id)
|
|
.ok_or_else(|| anyhow!("pane_id {} invalid", pane_id))?;
|
|
|
|
let tab = match mux.get_tab(tab_id) {
|
|
Some(tab) => tab,
|
|
None => {
|
|
return Err(anyhow!(
|
|
"Failed to retrieve tab with ID {}",
|
|
tab_id
|
|
))
|
|
}
|
|
};
|
|
|
|
tab.adjust_pane_size(direction, amount);
|
|
Ok(Pdu::UnitResponse(UnitResponse {}))
|
|
},
|
|
send_response,
|
|
)
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
Pdu::Invalid { .. } => send_response(Err(anyhow!("invalid PDU {:?}", decoded.pdu))),
|
|
Pdu::Pong { .. }
|
|
| Pdu::ListPanesResponse { .. }
|
|
| Pdu::SetClipboard { .. }
|
|
| Pdu::NotifyAlert { .. }
|
|
| Pdu::SpawnResponse { .. }
|
|
| Pdu::GetPaneRenderChangesResponse { .. }
|
|
| Pdu::UnitResponse { .. }
|
|
| Pdu::LivenessResponse { .. }
|
|
| Pdu::GetPaneDirectionResponse { .. }
|
|
| Pdu::SearchScrollbackResponse { .. }
|
|
| Pdu::GetLinesResponse { .. }
|
|
| Pdu::GetCodecVersionResponse { .. }
|
|
| Pdu::WindowWorkspaceChanged { .. }
|
|
| Pdu::GetTlsCredsResponse { .. }
|
|
| Pdu::GetClientListResponse { .. }
|
|
| Pdu::PaneRemoved { .. }
|
|
| Pdu::PaneFocused { .. }
|
|
| Pdu::TabResized { .. }
|
|
| Pdu::GetImageCellResponse { .. }
|
|
| Pdu::MovePaneToNewTabResponse { .. }
|
|
| Pdu::TabAddedToWindow { .. }
|
|
| Pdu::GetPaneRenderableDimensionsResponse { .. }
|
|
| Pdu::ErrorResponse { .. } => {
|
|
send_response(Err(anyhow!("expected a request, got {:?}", decoded.pdu)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dancing around a little bit here; we can't directly spawn_into_main_thread the domain_spawn
|
|
// function below because the compiler thinks that all of its locals then need to be Send.
|
|
// We need to shimmy through this helper to break that aspect of the compiler flow
|
|
// analysis and allow things to compile.
|
|
fn schedule_domain_spawn_v2<SND>(
|
|
spawn: SpawnV2,
|
|
send_response: SND,
|
|
client_id: Option<Arc<ClientId>>,
|
|
) where
|
|
SND: Fn(anyhow::Result<Pdu>) + 'static,
|
|
{
|
|
promise::spawn::spawn(async move { send_response(domain_spawn_v2(spawn, client_id).await) })
|
|
.detach();
|
|
}
|
|
|
|
fn schedule_split_pane<SND>(split: SplitPane, send_response: SND, client_id: Option<Arc<ClientId>>)
|
|
where
|
|
SND: Fn(anyhow::Result<Pdu>) + 'static,
|
|
{
|
|
promise::spawn::spawn(async move { send_response(split_pane(split, client_id).await) })
|
|
.detach();
|
|
}
|
|
|
|
async fn split_pane(split: SplitPane, client_id: Option<Arc<ClientId>>) -> anyhow::Result<Pdu> {
|
|
let mux = Mux::get();
|
|
let _identity = mux.with_identity(client_id);
|
|
|
|
let (_pane_domain_id, window_id, tab_id) = mux
|
|
.resolve_pane_id(split.pane_id)
|
|
.ok_or_else(|| anyhow!("pane_id {} invalid", split.pane_id))?;
|
|
|
|
let source = if let Some(move_pane_id) = split.move_pane_id {
|
|
SplitSource::MovePane(move_pane_id)
|
|
} else {
|
|
SplitSource::Spawn {
|
|
command: split.command,
|
|
command_dir: split.command_dir,
|
|
}
|
|
};
|
|
|
|
let (pane, size) = mux
|
|
.split_pane(split.pane_id, split.split_request, source, split.domain)
|
|
.await?;
|
|
|
|
Ok::<Pdu, anyhow::Error>(Pdu::SpawnResponse(SpawnResponse {
|
|
pane_id: pane.pane_id(),
|
|
tab_id: tab_id,
|
|
window_id,
|
|
size,
|
|
}))
|
|
}
|
|
|
|
async fn domain_spawn_v2(spawn: SpawnV2, client_id: Option<Arc<ClientId>>) -> anyhow::Result<Pdu> {
|
|
let mux = Mux::get();
|
|
let _identity = mux.with_identity(client_id);
|
|
|
|
let (tab, pane, window_id) = mux
|
|
.spawn_tab_or_window(
|
|
spawn.window_id,
|
|
spawn.domain,
|
|
spawn.command,
|
|
spawn.command_dir,
|
|
spawn.size,
|
|
None, // optional current pane_id
|
|
spawn.workspace,
|
|
None, // optional gui window position
|
|
)
|
|
.await?;
|
|
|
|
Ok::<Pdu, anyhow::Error>(Pdu::SpawnResponse(SpawnResponse {
|
|
pane_id: pane.pane_id(),
|
|
tab_id: tab.tab_id(),
|
|
window_id,
|
|
size: tab.get_size(),
|
|
}))
|
|
}
|
|
|
|
fn schedule_move_pane<SND>(
|
|
request: MovePaneToNewTab,
|
|
send_response: SND,
|
|
client_id: Option<Arc<ClientId>>,
|
|
) where
|
|
SND: Fn(anyhow::Result<Pdu>) + 'static,
|
|
{
|
|
promise::spawn::spawn(async move { send_response(move_pane(request, client_id).await) })
|
|
.detach();
|
|
}
|
|
|
|
async fn move_pane(
|
|
request: MovePaneToNewTab,
|
|
client_id: Option<Arc<ClientId>>,
|
|
) -> anyhow::Result<Pdu> {
|
|
let mux = Mux::get();
|
|
let _identity = mux.with_identity(client_id);
|
|
|
|
let (tab, window_id) = mux
|
|
.move_pane_to_new_tab(
|
|
request.pane_id,
|
|
request.window_id,
|
|
request.workspace_for_new_window,
|
|
)
|
|
.await?;
|
|
|
|
Ok::<Pdu, anyhow::Error>(Pdu::MovePaneToNewTabResponse(MovePaneToNewTabResponse {
|
|
tab_id: tab.tab_id(),
|
|
window_id,
|
|
}))
|
|
}
|