
Part of - #28238 This PR refactors `Event::NewNavigationTarget` and `Event::Open` handling of `PathLikeTarget` and associated code in `terminal_view.rs` into its own file, `terminal_path_like_target.rs` for improved testability, and adds tests which cover cases from: - #28339 - #28407 - #33498 - #34027 - #34078 Release Notes: - N/A
1883 lines
65 KiB
Rust
1883 lines
65 KiB
Rust
mod color_contrast;
|
|
mod persistence;
|
|
pub mod terminal_element;
|
|
pub mod terminal_panel;
|
|
mod terminal_path_like_target;
|
|
pub mod terminal_scrollbar;
|
|
mod terminal_slash_command;
|
|
pub mod terminal_tab_tooltip;
|
|
|
|
use assistant_slash_command::SlashCommandRegistry;
|
|
use editor::{EditorSettings, actions::SelectAll, scroll::ScrollbarAutoHide};
|
|
use gpui::{
|
|
Action, AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
|
|
KeyContext, KeyDownEvent, Keystroke, MouseButton, MouseDownEvent, Pixels, Render,
|
|
ScrollWheelEvent, Stateful, Styled, Subscription, Task, WeakEntity, actions, anchored,
|
|
deferred, div,
|
|
};
|
|
use persistence::TERMINAL_DB;
|
|
use project::{Project, search::SearchQuery, terminals::TerminalKind};
|
|
use schemars::JsonSchema;
|
|
use task::TaskId;
|
|
use terminal::{
|
|
Clear, Copy, Event, HoveredWord, MaybeNavigationTarget, Paste, ScrollLineDown, ScrollLineUp,
|
|
ScrollPageDown, ScrollPageUp, ScrollToBottom, ScrollToTop, ShowCharacterPalette, TaskState,
|
|
TaskStatus, Terminal, TerminalBounds, ToggleViMode,
|
|
alacritty_terminal::{
|
|
index::Point,
|
|
term::{TermMode, point_to_viewport, search::RegexSearch},
|
|
},
|
|
terminal_settings::{self, CursorShape, TerminalBlink, TerminalSettings, WorkingDirectory},
|
|
};
|
|
use terminal_element::TerminalElement;
|
|
use terminal_panel::TerminalPanel;
|
|
use terminal_path_like_target::{hover_path_like_target, open_path_like_target};
|
|
use terminal_scrollbar::TerminalScrollHandle;
|
|
use terminal_slash_command::TerminalSlashCommand;
|
|
use terminal_tab_tooltip::TerminalTooltip;
|
|
use ui::{
|
|
ContextMenu, Icon, IconName, Label, Scrollbar, ScrollbarState, Tooltip, h_flex, prelude::*,
|
|
};
|
|
use util::ResultExt;
|
|
use workspace::{
|
|
CloseActiveItem, NewCenterTerminal, NewTerminal, ToolbarItemLocation, Workspace, WorkspaceId,
|
|
delete_unloaded_items,
|
|
item::{
|
|
BreadcrumbText, Item, ItemEvent, SerializableItem, TabContentParams, TabTooltipContent,
|
|
},
|
|
register_serializable_item,
|
|
searchable::{Direction, SearchEvent, SearchOptions, SearchableItem, SearchableItemHandle},
|
|
};
|
|
|
|
use serde::Deserialize;
|
|
use settings::{Settings, SettingsStore};
|
|
use smol::Timer;
|
|
use zed_actions::assistant::InlineAssist;
|
|
|
|
use std::{
|
|
cmp,
|
|
ops::{Range, RangeInclusive},
|
|
path::{Path, PathBuf},
|
|
rc::Rc,
|
|
sync::Arc,
|
|
time::Duration,
|
|
};
|
|
|
|
const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
|
|
const TERMINAL_SCROLLBAR_WIDTH: Pixels = px(12.);
|
|
|
|
/// Event to transmit the scroll from the element to the view
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct ScrollTerminal(pub i32);
|
|
|
|
/// Sends the specified text directly to the terminal.
|
|
#[derive(Clone, Debug, Default, Deserialize, JsonSchema, PartialEq, Action)]
|
|
#[action(namespace = terminal)]
|
|
pub struct SendText(String);
|
|
|
|
/// Sends a keystroke sequence to the terminal.
|
|
#[derive(Clone, Debug, Default, Deserialize, JsonSchema, PartialEq, Action)]
|
|
#[action(namespace = terminal)]
|
|
pub struct SendKeystroke(String);
|
|
|
|
actions!(
|
|
terminal,
|
|
[
|
|
/// Reruns the last executed task in the terminal.
|
|
RerunTask
|
|
]
|
|
);
|
|
|
|
pub fn init(cx: &mut App) {
|
|
assistant_slash_command::init(cx);
|
|
terminal_panel::init(cx);
|
|
terminal::init(cx);
|
|
|
|
register_serializable_item::<TerminalView>(cx);
|
|
|
|
cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
|
|
workspace.register_action(TerminalView::deploy);
|
|
})
|
|
.detach();
|
|
SlashCommandRegistry::global(cx).register_command(TerminalSlashCommand, true);
|
|
}
|
|
|
|
pub struct BlockProperties {
|
|
pub height: u8,
|
|
pub render: Box<dyn Send + Fn(&mut BlockContext) -> AnyElement>,
|
|
}
|
|
|
|
pub struct BlockContext<'a, 'b> {
|
|
pub window: &'a mut Window,
|
|
pub context: &'b mut App,
|
|
pub dimensions: TerminalBounds,
|
|
}
|
|
|
|
///A terminal view, maintains the PTY's file handles and communicates with the terminal
|
|
pub struct TerminalView {
|
|
terminal: Entity<Terminal>,
|
|
workspace: WeakEntity<Workspace>,
|
|
project: WeakEntity<Project>,
|
|
focus_handle: FocusHandle,
|
|
//Currently using iTerm bell, show bell emoji in tab until input is received
|
|
has_bell: bool,
|
|
context_menu: Option<(Entity<ContextMenu>, gpui::Point<Pixels>, Subscription)>,
|
|
cursor_shape: CursorShape,
|
|
blink_state: bool,
|
|
mode: TerminalMode,
|
|
blinking_terminal_enabled: bool,
|
|
cwd_serialized: bool,
|
|
blinking_paused: bool,
|
|
blink_epoch: usize,
|
|
hover: Option<HoverTarget>,
|
|
hover_tooltip_update: Task<()>,
|
|
workspace_id: Option<WorkspaceId>,
|
|
show_breadcrumbs: bool,
|
|
block_below_cursor: Option<Rc<BlockProperties>>,
|
|
scroll_top: Pixels,
|
|
scrollbar_state: ScrollbarState,
|
|
scroll_handle: TerminalScrollHandle,
|
|
show_scrollbar: bool,
|
|
hide_scrollbar_task: Option<Task<()>>,
|
|
marked_text: Option<String>,
|
|
marked_range_utf16: Option<Range<usize>>,
|
|
_subscriptions: Vec<Subscription>,
|
|
_terminal_subscriptions: Vec<Subscription>,
|
|
}
|
|
|
|
#[derive(Default, Clone)]
|
|
pub enum TerminalMode {
|
|
#[default]
|
|
Standalone,
|
|
Embedded {
|
|
max_lines_when_unfocused: Option<usize>,
|
|
},
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum ContentMode {
|
|
Scrollable,
|
|
Inline {
|
|
displayed_lines: usize,
|
|
total_lines: usize,
|
|
},
|
|
}
|
|
|
|
impl ContentMode {
|
|
pub fn is_limited(&self) -> bool {
|
|
match self {
|
|
ContentMode::Scrollable => false,
|
|
ContentMode::Inline {
|
|
displayed_lines,
|
|
total_lines,
|
|
} => displayed_lines < total_lines,
|
|
}
|
|
}
|
|
|
|
pub fn is_scrollable(&self) -> bool {
|
|
matches!(self, ContentMode::Scrollable)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[cfg_attr(test, derive(Clone, Eq, PartialEq))]
|
|
struct HoverTarget {
|
|
tooltip: String,
|
|
hovered_word: HoveredWord,
|
|
}
|
|
|
|
impl EventEmitter<Event> for TerminalView {}
|
|
impl EventEmitter<ItemEvent> for TerminalView {}
|
|
impl EventEmitter<SearchEvent> for TerminalView {}
|
|
|
|
impl Focusable for TerminalView {
|
|
fn focus_handle(&self, _cx: &App) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl TerminalView {
|
|
///Create a new Terminal in the current working directory or the user's home directory
|
|
pub fn deploy(
|
|
workspace: &mut Workspace,
|
|
_: &NewCenterTerminal,
|
|
window: &mut Window,
|
|
cx: &mut Context<Workspace>,
|
|
) {
|
|
let working_directory = default_working_directory(workspace, cx);
|
|
TerminalPanel::add_center_terminal(
|
|
workspace,
|
|
TerminalKind::Shell(working_directory),
|
|
window,
|
|
cx,
|
|
)
|
|
.detach_and_log_err(cx);
|
|
}
|
|
|
|
pub fn new(
|
|
terminal: Entity<Terminal>,
|
|
workspace: WeakEntity<Workspace>,
|
|
workspace_id: Option<WorkspaceId>,
|
|
project: WeakEntity<Project>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Self {
|
|
let workspace_handle = workspace.clone();
|
|
let terminal_subscriptions =
|
|
subscribe_for_terminal_events(&terminal, workspace, window, cx);
|
|
|
|
let focus_handle = cx.focus_handle();
|
|
let focus_in = cx.on_focus_in(&focus_handle, window, |terminal_view, window, cx| {
|
|
terminal_view.focus_in(window, cx);
|
|
});
|
|
let focus_out = cx.on_focus_out(
|
|
&focus_handle,
|
|
window,
|
|
|terminal_view, _event, window, cx| {
|
|
terminal_view.focus_out(window, cx);
|
|
},
|
|
);
|
|
let cursor_shape = TerminalSettings::get_global(cx)
|
|
.cursor_shape
|
|
.unwrap_or_default();
|
|
|
|
let scroll_handle = TerminalScrollHandle::new(terminal.read(cx));
|
|
|
|
Self {
|
|
terminal,
|
|
workspace: workspace_handle,
|
|
project,
|
|
has_bell: false,
|
|
focus_handle,
|
|
context_menu: None,
|
|
cursor_shape,
|
|
blink_state: true,
|
|
blinking_terminal_enabled: false,
|
|
blinking_paused: false,
|
|
blink_epoch: 0,
|
|
hover: None,
|
|
hover_tooltip_update: Task::ready(()),
|
|
mode: TerminalMode::Standalone,
|
|
workspace_id,
|
|
show_breadcrumbs: TerminalSettings::get_global(cx).toolbar.breadcrumbs,
|
|
block_below_cursor: None,
|
|
scroll_top: Pixels::ZERO,
|
|
scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
|
|
scroll_handle,
|
|
show_scrollbar: !Self::should_autohide_scrollbar(cx),
|
|
hide_scrollbar_task: None,
|
|
cwd_serialized: false,
|
|
marked_text: None,
|
|
marked_range_utf16: None,
|
|
_subscriptions: vec![
|
|
focus_in,
|
|
focus_out,
|
|
cx.observe_global::<SettingsStore>(Self::settings_changed),
|
|
],
|
|
_terminal_subscriptions: terminal_subscriptions,
|
|
}
|
|
}
|
|
|
|
/// Enable 'embedded' mode where the terminal displays the full content with an optional limit of lines.
|
|
pub fn set_embedded_mode(
|
|
&mut self,
|
|
max_lines_when_unfocused: Option<usize>,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.mode = TerminalMode::Embedded {
|
|
max_lines_when_unfocused,
|
|
};
|
|
cx.notify();
|
|
}
|
|
|
|
const MAX_EMBEDDED_LINES: usize = 1_000;
|
|
|
|
/// Returns the current `ContentMode` depending on the set `TerminalMode` and the current number of lines
|
|
///
|
|
/// Note: Even in embedded mode, the terminal will fallback to scrollable when its content exceeds `MAX_EMBEDDED_LINES`
|
|
pub fn content_mode(&self, window: &Window, cx: &App) -> ContentMode {
|
|
match &self.mode {
|
|
TerminalMode::Standalone => ContentMode::Scrollable,
|
|
TerminalMode::Embedded {
|
|
max_lines_when_unfocused,
|
|
} => {
|
|
let total_lines = self.terminal.read(cx).total_lines();
|
|
|
|
if total_lines > Self::MAX_EMBEDDED_LINES {
|
|
ContentMode::Scrollable
|
|
} else {
|
|
let mut displayed_lines = total_lines;
|
|
|
|
if !self.focus_handle.is_focused(window)
|
|
&& let Some(max_lines) = max_lines_when_unfocused
|
|
{
|
|
displayed_lines = displayed_lines.min(*max_lines)
|
|
}
|
|
|
|
ContentMode::Inline {
|
|
displayed_lines,
|
|
total_lines,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Sets the marked (pre-edit) text from the IME.
|
|
pub(crate) fn set_marked_text(
|
|
&mut self,
|
|
text: String,
|
|
range: Range<usize>,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.marked_text = Some(text);
|
|
self.marked_range_utf16 = Some(range);
|
|
cx.notify();
|
|
}
|
|
|
|
/// Gets the current marked range (UTF-16).
|
|
pub(crate) fn marked_text_range(&self) -> Option<Range<usize>> {
|
|
self.marked_range_utf16.clone()
|
|
}
|
|
|
|
/// Clears the marked (pre-edit) text state.
|
|
pub(crate) fn clear_marked_text(&mut self, cx: &mut Context<Self>) {
|
|
if self.marked_text.is_some() {
|
|
self.marked_text = None;
|
|
self.marked_range_utf16 = None;
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
/// Commits (sends) the given text to the PTY. Called by InputHandler::replace_text_in_range.
|
|
pub(crate) fn commit_text(&mut self, text: &str, cx: &mut Context<Self>) {
|
|
if !text.is_empty() {
|
|
self.terminal.update(cx, |term, _| {
|
|
term.input(text.to_string().into_bytes());
|
|
});
|
|
}
|
|
}
|
|
|
|
pub(crate) fn terminal_bounds(&self, cx: &App) -> TerminalBounds {
|
|
self.terminal.read(cx).last_content().terminal_bounds
|
|
}
|
|
|
|
pub fn entity(&self) -> &Entity<Terminal> {
|
|
&self.terminal
|
|
}
|
|
|
|
pub fn has_bell(&self) -> bool {
|
|
self.has_bell
|
|
}
|
|
|
|
pub fn clear_bell(&mut self, cx: &mut Context<TerminalView>) {
|
|
self.has_bell = false;
|
|
cx.emit(Event::Wakeup);
|
|
}
|
|
|
|
pub fn deploy_context_menu(
|
|
&mut self,
|
|
position: gpui::Point<Pixels>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let assistant_enabled = self
|
|
.workspace
|
|
.upgrade()
|
|
.and_then(|workspace| workspace.read(cx).panel::<TerminalPanel>(cx))
|
|
.is_some_and(|terminal_panel| terminal_panel.read(cx).assistant_enabled());
|
|
let context_menu = ContextMenu::build(window, cx, |menu, _, _| {
|
|
menu.context(self.focus_handle.clone())
|
|
.action("New Terminal", Box::new(NewTerminal))
|
|
.separator()
|
|
.action("Copy", Box::new(Copy))
|
|
.action("Paste", Box::new(Paste))
|
|
.action("Select All", Box::new(SelectAll))
|
|
.action("Clear", Box::new(Clear))
|
|
.when(assistant_enabled, |menu| {
|
|
menu.separator()
|
|
.action("Inline Assist", Box::new(InlineAssist::default()))
|
|
})
|
|
.separator()
|
|
.action(
|
|
"Close Terminal Tab",
|
|
Box::new(CloseActiveItem {
|
|
save_intent: None,
|
|
close_pinned: true,
|
|
}),
|
|
)
|
|
});
|
|
|
|
window.focus(&context_menu.focus_handle(cx));
|
|
let subscription = cx.subscribe_in(
|
|
&context_menu,
|
|
window,
|
|
|this, _, _: &DismissEvent, window, cx| {
|
|
if this.context_menu.as_ref().is_some_and(|context_menu| {
|
|
context_menu.0.focus_handle(cx).contains_focused(window, cx)
|
|
}) {
|
|
cx.focus_self(window);
|
|
}
|
|
this.context_menu.take();
|
|
cx.notify();
|
|
},
|
|
);
|
|
|
|
self.context_menu = Some((context_menu, position, subscription));
|
|
}
|
|
|
|
fn settings_changed(&mut self, cx: &mut Context<Self>) {
|
|
let settings = TerminalSettings::get_global(cx);
|
|
let breadcrumb_visibility_changed = self.show_breadcrumbs != settings.toolbar.breadcrumbs;
|
|
self.show_breadcrumbs = settings.toolbar.breadcrumbs;
|
|
|
|
let new_cursor_shape = settings.cursor_shape.unwrap_or_default();
|
|
let old_cursor_shape = self.cursor_shape;
|
|
if old_cursor_shape != new_cursor_shape {
|
|
self.cursor_shape = new_cursor_shape;
|
|
self.terminal.update(cx, |term, _| {
|
|
term.set_cursor_shape(self.cursor_shape);
|
|
});
|
|
}
|
|
|
|
if breadcrumb_visibility_changed {
|
|
cx.emit(ItemEvent::UpdateBreadcrumbs);
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
fn show_character_palette(
|
|
&mut self,
|
|
_: &ShowCharacterPalette,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if self
|
|
.terminal
|
|
.read(cx)
|
|
.last_content
|
|
.mode
|
|
.contains(TermMode::ALT_SCREEN)
|
|
{
|
|
self.terminal.update(cx, |term, cx| {
|
|
term.try_keystroke(
|
|
&Keystroke::parse("ctrl-cmd-space").unwrap(),
|
|
TerminalSettings::get_global(cx).option_as_meta,
|
|
)
|
|
});
|
|
} else {
|
|
window.show_character_palette();
|
|
}
|
|
}
|
|
|
|
fn select_all(&mut self, _: &SelectAll, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.select_all());
|
|
cx.notify();
|
|
}
|
|
|
|
fn rerun_task(&mut self, _: &RerunTask, window: &mut Window, cx: &mut Context<Self>) {
|
|
let task = self
|
|
.terminal
|
|
.read(cx)
|
|
.task()
|
|
.map(|task| terminal_rerun_override(&task.id))
|
|
.unwrap_or_default();
|
|
window.dispatch_action(Box::new(task), cx);
|
|
}
|
|
|
|
fn clear(&mut self, _: &Clear, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.scroll_top = px(0.);
|
|
self.terminal.update(cx, |term, _| term.clear());
|
|
cx.notify();
|
|
}
|
|
|
|
fn max_scroll_top(&self, cx: &App) -> Pixels {
|
|
let terminal = self.terminal.read(cx);
|
|
|
|
let Some(block) = self.block_below_cursor.as_ref() else {
|
|
return Pixels::ZERO;
|
|
};
|
|
|
|
let line_height = terminal.last_content().terminal_bounds.line_height;
|
|
let viewport_lines = terminal.viewport_lines();
|
|
let cursor = point_to_viewport(
|
|
terminal.last_content.display_offset,
|
|
terminal.last_content.cursor.point,
|
|
)
|
|
.unwrap_or_default();
|
|
let max_scroll_top_in_lines =
|
|
(block.height as usize).saturating_sub(viewport_lines.saturating_sub(cursor.line + 1));
|
|
|
|
max_scroll_top_in_lines as f32 * line_height
|
|
}
|
|
|
|
fn scroll_wheel(&mut self, event: &ScrollWheelEvent, cx: &mut Context<Self>) {
|
|
let terminal_content = self.terminal.read(cx).last_content();
|
|
|
|
if self.block_below_cursor.is_some() && terminal_content.display_offset == 0 {
|
|
let line_height = terminal_content.terminal_bounds.line_height;
|
|
let y_delta = event.delta.pixel_delta(line_height).y;
|
|
if y_delta < Pixels::ZERO || self.scroll_top > Pixels::ZERO {
|
|
self.scroll_top = cmp::max(
|
|
Pixels::ZERO,
|
|
cmp::min(self.scroll_top - y_delta, self.max_scroll_top(cx)),
|
|
);
|
|
cx.notify();
|
|
return;
|
|
}
|
|
}
|
|
self.terminal.update(cx, |term, _| term.scroll_wheel(event));
|
|
}
|
|
|
|
fn scroll_line_up(&mut self, _: &ScrollLineUp, _: &mut Window, cx: &mut Context<Self>) {
|
|
let terminal_content = self.terminal.read(cx).last_content();
|
|
if self.block_below_cursor.is_some()
|
|
&& terminal_content.display_offset == 0
|
|
&& self.scroll_top > Pixels::ZERO
|
|
{
|
|
let line_height = terminal_content.terminal_bounds.line_height;
|
|
self.scroll_top = cmp::max(self.scroll_top - line_height, Pixels::ZERO);
|
|
return;
|
|
}
|
|
|
|
self.terminal.update(cx, |term, _| term.scroll_line_up());
|
|
cx.notify();
|
|
}
|
|
|
|
fn scroll_line_down(&mut self, _: &ScrollLineDown, _: &mut Window, cx: &mut Context<Self>) {
|
|
let terminal_content = self.terminal.read(cx).last_content();
|
|
if self.block_below_cursor.is_some() && terminal_content.display_offset == 0 {
|
|
let max_scroll_top = self.max_scroll_top(cx);
|
|
if self.scroll_top < max_scroll_top {
|
|
let line_height = terminal_content.terminal_bounds.line_height;
|
|
self.scroll_top = cmp::min(self.scroll_top + line_height, max_scroll_top);
|
|
}
|
|
return;
|
|
}
|
|
|
|
self.terminal.update(cx, |term, _| term.scroll_line_down());
|
|
cx.notify();
|
|
}
|
|
|
|
fn scroll_page_up(&mut self, _: &ScrollPageUp, _: &mut Window, cx: &mut Context<Self>) {
|
|
if self.scroll_top == Pixels::ZERO {
|
|
self.terminal.update(cx, |term, _| term.scroll_page_up());
|
|
} else {
|
|
let line_height = self
|
|
.terminal
|
|
.read(cx)
|
|
.last_content
|
|
.terminal_bounds
|
|
.line_height();
|
|
let visible_block_lines = (self.scroll_top / line_height) as usize;
|
|
let viewport_lines = self.terminal.read(cx).viewport_lines();
|
|
let visible_content_lines = viewport_lines - visible_block_lines;
|
|
|
|
if visible_block_lines >= viewport_lines {
|
|
self.scroll_top = ((visible_block_lines - viewport_lines) as f32) * line_height;
|
|
} else {
|
|
self.scroll_top = px(0.);
|
|
self.terminal
|
|
.update(cx, |term, _| term.scroll_up_by(visible_content_lines));
|
|
}
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
fn scroll_page_down(&mut self, _: &ScrollPageDown, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.scroll_page_down());
|
|
let terminal = self.terminal.read(cx);
|
|
if terminal.last_content().display_offset < terminal.viewport_lines() {
|
|
self.scroll_top = self.max_scroll_top(cx);
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
fn scroll_to_top(&mut self, _: &ScrollToTop, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.scroll_to_top());
|
|
cx.notify();
|
|
}
|
|
|
|
fn scroll_to_bottom(&mut self, _: &ScrollToBottom, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.scroll_to_bottom());
|
|
if self.block_below_cursor.is_some() {
|
|
self.scroll_top = self.max_scroll_top(cx);
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
fn toggle_vi_mode(&mut self, _: &ToggleViMode, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.toggle_vi_mode());
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn should_show_cursor(&self, focused: bool, cx: &mut Context<Self>) -> bool {
|
|
//Don't blink the cursor when not focused, blinking is disabled, or paused
|
|
if !focused
|
|
|| self.blinking_paused
|
|
|| self
|
|
.terminal
|
|
.read(cx)
|
|
.last_content
|
|
.mode
|
|
.contains(TermMode::ALT_SCREEN)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
match TerminalSettings::get_global(cx).blinking {
|
|
//If the user requested to never blink, don't blink it.
|
|
TerminalBlink::Off => true,
|
|
//If the terminal is controlling it, check terminal mode
|
|
TerminalBlink::TerminalControlled => {
|
|
!self.blinking_terminal_enabled || self.blink_state
|
|
}
|
|
TerminalBlink::On => self.blink_state,
|
|
}
|
|
}
|
|
|
|
fn blink_cursors(&mut self, epoch: usize, window: &mut Window, cx: &mut Context<Self>) {
|
|
if epoch == self.blink_epoch && !self.blinking_paused {
|
|
self.blink_state = !self.blink_state;
|
|
cx.notify();
|
|
|
|
let epoch = self.next_blink_epoch();
|
|
cx.spawn_in(window, async move |this, cx| {
|
|
Timer::after(CURSOR_BLINK_INTERVAL).await;
|
|
this.update_in(cx, |this, window, cx| this.blink_cursors(epoch, window, cx))
|
|
.ok();
|
|
})
|
|
.detach();
|
|
}
|
|
}
|
|
|
|
pub fn pause_cursor_blinking(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.blink_state = true;
|
|
cx.notify();
|
|
|
|
let epoch = self.next_blink_epoch();
|
|
cx.spawn_in(window, async move |this, cx| {
|
|
Timer::after(CURSOR_BLINK_INTERVAL).await;
|
|
this.update_in(cx, |this, window, cx| {
|
|
this.resume_cursor_blinking(epoch, window, cx)
|
|
})
|
|
.ok();
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
pub fn terminal(&self) -> &Entity<Terminal> {
|
|
&self.terminal
|
|
}
|
|
|
|
pub fn set_block_below_cursor(
|
|
&mut self,
|
|
block: BlockProperties,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.block_below_cursor = Some(Rc::new(block));
|
|
self.scroll_to_bottom(&ScrollToBottom, window, cx);
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn clear_block_below_cursor(&mut self, cx: &mut Context<Self>) {
|
|
self.block_below_cursor = None;
|
|
self.scroll_top = Pixels::ZERO;
|
|
cx.notify();
|
|
}
|
|
|
|
fn next_blink_epoch(&mut self) -> usize {
|
|
self.blink_epoch += 1;
|
|
self.blink_epoch
|
|
}
|
|
|
|
fn resume_cursor_blinking(
|
|
&mut self,
|
|
epoch: usize,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if epoch == self.blink_epoch {
|
|
self.blinking_paused = false;
|
|
self.blink_cursors(epoch, window, cx);
|
|
}
|
|
}
|
|
|
|
///Attempt to paste the clipboard into the terminal
|
|
fn copy(&mut self, _: &Copy, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |term, _| term.copy(None));
|
|
cx.notify();
|
|
}
|
|
|
|
///Attempt to paste the clipboard into the terminal
|
|
fn paste(&mut self, _: &Paste, _: &mut Window, cx: &mut Context<Self>) {
|
|
if let Some(clipboard_string) = cx.read_from_clipboard().and_then(|item| item.text()) {
|
|
self.terminal
|
|
.update(cx, |terminal, _cx| terminal.paste(&clipboard_string));
|
|
}
|
|
}
|
|
|
|
fn send_text(&mut self, text: &SendText, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.clear_bell(cx);
|
|
self.terminal.update(cx, |term, _| {
|
|
term.input(text.0.to_string().into_bytes());
|
|
});
|
|
}
|
|
|
|
fn send_keystroke(&mut self, text: &SendKeystroke, _: &mut Window, cx: &mut Context<Self>) {
|
|
if let Some(keystroke) = Keystroke::parse(&text.0).log_err() {
|
|
self.clear_bell(cx);
|
|
self.terminal.update(cx, |term, cx| {
|
|
let processed =
|
|
term.try_keystroke(&keystroke, TerminalSettings::get_global(cx).option_as_meta);
|
|
if processed && term.vi_mode_enabled() {
|
|
cx.notify();
|
|
}
|
|
processed
|
|
});
|
|
}
|
|
}
|
|
|
|
fn dispatch_context(&self, cx: &App) -> KeyContext {
|
|
let mut dispatch_context = KeyContext::new_with_defaults();
|
|
dispatch_context.add("Terminal");
|
|
|
|
if self.terminal.read(cx).vi_mode_enabled() {
|
|
dispatch_context.add("vi_mode");
|
|
}
|
|
|
|
let mode = self.terminal.read(cx).last_content.mode;
|
|
dispatch_context.set(
|
|
"screen",
|
|
if mode.contains(TermMode::ALT_SCREEN) {
|
|
"alt"
|
|
} else {
|
|
"normal"
|
|
},
|
|
);
|
|
|
|
if mode.contains(TermMode::APP_CURSOR) {
|
|
dispatch_context.add("DECCKM");
|
|
}
|
|
if mode.contains(TermMode::APP_KEYPAD) {
|
|
dispatch_context.add("DECPAM");
|
|
} else {
|
|
dispatch_context.add("DECPNM");
|
|
}
|
|
if mode.contains(TermMode::SHOW_CURSOR) {
|
|
dispatch_context.add("DECTCEM");
|
|
}
|
|
if mode.contains(TermMode::LINE_WRAP) {
|
|
dispatch_context.add("DECAWM");
|
|
}
|
|
if mode.contains(TermMode::ORIGIN) {
|
|
dispatch_context.add("DECOM");
|
|
}
|
|
if mode.contains(TermMode::INSERT) {
|
|
dispatch_context.add("IRM");
|
|
}
|
|
//LNM is apparently the name for this. https://vt100.net/docs/vt510-rm/LNM.html
|
|
if mode.contains(TermMode::LINE_FEED_NEW_LINE) {
|
|
dispatch_context.add("LNM");
|
|
}
|
|
if mode.contains(TermMode::FOCUS_IN_OUT) {
|
|
dispatch_context.add("report_focus");
|
|
}
|
|
if mode.contains(TermMode::ALTERNATE_SCROLL) {
|
|
dispatch_context.add("alternate_scroll");
|
|
}
|
|
if mode.contains(TermMode::BRACKETED_PASTE) {
|
|
dispatch_context.add("bracketed_paste");
|
|
}
|
|
if mode.intersects(TermMode::MOUSE_MODE) {
|
|
dispatch_context.add("any_mouse_reporting");
|
|
}
|
|
{
|
|
let mouse_reporting = if mode.contains(TermMode::MOUSE_REPORT_CLICK) {
|
|
"click"
|
|
} else if mode.contains(TermMode::MOUSE_DRAG) {
|
|
"drag"
|
|
} else if mode.contains(TermMode::MOUSE_MOTION) {
|
|
"motion"
|
|
} else {
|
|
"off"
|
|
};
|
|
dispatch_context.set("mouse_reporting", mouse_reporting);
|
|
}
|
|
{
|
|
let format = if mode.contains(TermMode::SGR_MOUSE) {
|
|
"sgr"
|
|
} else if mode.contains(TermMode::UTF8_MOUSE) {
|
|
"utf8"
|
|
} else {
|
|
"normal"
|
|
};
|
|
dispatch_context.set("mouse_format", format);
|
|
};
|
|
|
|
if self.terminal.read(cx).last_content.selection.is_some() {
|
|
dispatch_context.add("selection");
|
|
}
|
|
|
|
dispatch_context
|
|
}
|
|
|
|
fn set_terminal(
|
|
&mut self,
|
|
terminal: Entity<Terminal>,
|
|
window: &mut Window,
|
|
cx: &mut Context<TerminalView>,
|
|
) {
|
|
self._terminal_subscriptions =
|
|
subscribe_for_terminal_events(&terminal, self.workspace.clone(), window, cx);
|
|
self.terminal = terminal;
|
|
}
|
|
|
|
// Hack: Using editor in terminal causes cyclic dependency i.e. editor -> terminal -> project -> editor.
|
|
fn map_show_scrollbar_from_editor_to_terminal(
|
|
show_scrollbar: editor::ShowScrollbar,
|
|
) -> terminal_settings::ShowScrollbar {
|
|
match show_scrollbar {
|
|
editor::ShowScrollbar::Auto => terminal_settings::ShowScrollbar::Auto,
|
|
editor::ShowScrollbar::System => terminal_settings::ShowScrollbar::System,
|
|
editor::ShowScrollbar::Always => terminal_settings::ShowScrollbar::Always,
|
|
editor::ShowScrollbar::Never => terminal_settings::ShowScrollbar::Never,
|
|
}
|
|
}
|
|
|
|
fn should_show_scrollbar(cx: &App) -> bool {
|
|
let show = TerminalSettings::get_global(cx)
|
|
.scrollbar
|
|
.show
|
|
.unwrap_or_else(|| {
|
|
Self::map_show_scrollbar_from_editor_to_terminal(
|
|
EditorSettings::get_global(cx).scrollbar.show,
|
|
)
|
|
});
|
|
match show {
|
|
terminal_settings::ShowScrollbar::Auto => true,
|
|
terminal_settings::ShowScrollbar::System => true,
|
|
terminal_settings::ShowScrollbar::Always => true,
|
|
terminal_settings::ShowScrollbar::Never => false,
|
|
}
|
|
}
|
|
|
|
fn should_autohide_scrollbar(cx: &App) -> bool {
|
|
let show = TerminalSettings::get_global(cx)
|
|
.scrollbar
|
|
.show
|
|
.unwrap_or_else(|| {
|
|
Self::map_show_scrollbar_from_editor_to_terminal(
|
|
EditorSettings::get_global(cx).scrollbar.show,
|
|
)
|
|
});
|
|
match show {
|
|
terminal_settings::ShowScrollbar::Auto => true,
|
|
terminal_settings::ShowScrollbar::System => cx
|
|
.try_global::<ScrollbarAutoHide>()
|
|
.map_or_else(|| cx.should_auto_hide_scrollbars(), |autohide| autohide.0),
|
|
terminal_settings::ShowScrollbar::Always => false,
|
|
terminal_settings::ShowScrollbar::Never => true,
|
|
}
|
|
}
|
|
|
|
fn hide_scrollbar(&mut self, cx: &mut Context<Self>) {
|
|
const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
|
|
if !Self::should_autohide_scrollbar(cx) {
|
|
return;
|
|
}
|
|
self.hide_scrollbar_task = Some(cx.spawn(async move |panel, cx| {
|
|
cx.background_executor()
|
|
.timer(SCROLLBAR_SHOW_INTERVAL)
|
|
.await;
|
|
panel
|
|
.update(cx, |panel, cx| {
|
|
panel.show_scrollbar = false;
|
|
cx.notify();
|
|
})
|
|
.log_err();
|
|
}))
|
|
}
|
|
|
|
fn render_scrollbar(&self, window: &Window, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
|
|
if !Self::should_show_scrollbar(cx)
|
|
|| !(self.show_scrollbar || self.scrollbar_state.is_dragging())
|
|
|| !self.content_mode(window, cx).is_scrollable()
|
|
{
|
|
return None;
|
|
}
|
|
|
|
if self.terminal.read(cx).total_lines() == self.terminal.read(cx).viewport_lines() {
|
|
return None;
|
|
}
|
|
|
|
self.scroll_handle.update(self.terminal.read(cx));
|
|
|
|
if let Some(new_display_offset) = self.scroll_handle.future_display_offset.take() {
|
|
self.terminal.update(cx, |term, _| {
|
|
let delta = new_display_offset as i32 - term.last_content.display_offset as i32;
|
|
match delta.cmp(&0) {
|
|
std::cmp::Ordering::Greater => term.scroll_up_by(delta as usize),
|
|
std::cmp::Ordering::Less => term.scroll_down_by(-delta as usize),
|
|
std::cmp::Ordering::Equal => {}
|
|
}
|
|
});
|
|
}
|
|
|
|
Some(
|
|
div()
|
|
.occlude()
|
|
.id("terminal-view-scroll")
|
|
.on_mouse_move(cx.listener(|_, _, _window, cx| {
|
|
cx.notify();
|
|
cx.stop_propagation()
|
|
}))
|
|
.on_hover(|_, _window, cx| {
|
|
cx.stop_propagation();
|
|
})
|
|
.on_any_mouse_down(|_, _window, cx| {
|
|
cx.stop_propagation();
|
|
})
|
|
.on_mouse_up(
|
|
MouseButton::Left,
|
|
cx.listener(|terminal_view, _, window, cx| {
|
|
if !terminal_view.scrollbar_state.is_dragging()
|
|
&& !terminal_view.focus_handle.contains_focused(window, cx)
|
|
{
|
|
terminal_view.hide_scrollbar(cx);
|
|
cx.notify();
|
|
}
|
|
cx.stop_propagation();
|
|
}),
|
|
)
|
|
.on_scroll_wheel(cx.listener(|_, _, _window, cx| {
|
|
cx.notify();
|
|
}))
|
|
.absolute()
|
|
.top_0()
|
|
.bottom_0()
|
|
.right_0()
|
|
.h_full()
|
|
.w(TERMINAL_SCROLLBAR_WIDTH)
|
|
.children(Scrollbar::vertical(self.scrollbar_state.clone())),
|
|
)
|
|
}
|
|
|
|
fn rerun_button(task: &TaskState) -> Option<IconButton> {
|
|
if !task.show_rerun {
|
|
return None;
|
|
}
|
|
|
|
let task_id = task.id.clone();
|
|
Some(
|
|
IconButton::new("rerun-icon", IconName::Rerun)
|
|
.icon_size(IconSize::Small)
|
|
.size(ButtonSize::Compact)
|
|
.icon_color(Color::Default)
|
|
.shape(ui::IconButtonShape::Square)
|
|
.tooltip(move |window, cx| {
|
|
Tooltip::for_action("Rerun task", &RerunTask, window, cx)
|
|
})
|
|
.on_click(move |_, window, cx| {
|
|
window.dispatch_action(Box::new(terminal_rerun_override(&task_id)), cx);
|
|
}),
|
|
)
|
|
}
|
|
}
|
|
|
|
fn terminal_rerun_override(task: &TaskId) -> zed_actions::Rerun {
|
|
zed_actions::Rerun {
|
|
task_id: Some(task.0.clone()),
|
|
allow_concurrent_runs: Some(true),
|
|
use_new_terminal: Some(false),
|
|
reevaluate_context: false,
|
|
}
|
|
}
|
|
|
|
fn subscribe_for_terminal_events(
|
|
terminal: &Entity<Terminal>,
|
|
workspace: WeakEntity<Workspace>,
|
|
window: &mut Window,
|
|
cx: &mut Context<TerminalView>,
|
|
) -> Vec<Subscription> {
|
|
let terminal_subscription = cx.observe(terminal, |_, _, cx| cx.notify());
|
|
let mut previous_cwd = None;
|
|
let terminal_events_subscription = cx.subscribe_in(
|
|
terminal,
|
|
window,
|
|
move |terminal_view, terminal, event, window, cx| {
|
|
let current_cwd = terminal.read(cx).working_directory();
|
|
if current_cwd != previous_cwd {
|
|
previous_cwd = current_cwd;
|
|
terminal_view.cwd_serialized = false;
|
|
}
|
|
|
|
match event {
|
|
Event::Wakeup => {
|
|
cx.notify();
|
|
cx.emit(Event::Wakeup);
|
|
cx.emit(ItemEvent::UpdateTab);
|
|
cx.emit(SearchEvent::MatchesInvalidated);
|
|
}
|
|
|
|
Event::Bell => {
|
|
terminal_view.has_bell = true;
|
|
cx.emit(Event::Wakeup);
|
|
}
|
|
|
|
Event::BlinkChanged(blinking) => {
|
|
if matches!(
|
|
TerminalSettings::get_global(cx).blinking,
|
|
TerminalBlink::TerminalControlled
|
|
) {
|
|
terminal_view.blinking_terminal_enabled = *blinking;
|
|
}
|
|
}
|
|
|
|
Event::TitleChanged => {
|
|
cx.emit(ItemEvent::UpdateTab);
|
|
}
|
|
|
|
Event::NewNavigationTarget(maybe_navigation_target) => {
|
|
match maybe_navigation_target
|
|
.as_ref()
|
|
.zip(terminal.read(cx).last_content.last_hovered_word.as_ref())
|
|
{
|
|
Some((MaybeNavigationTarget::Url(url), hovered_word)) => {
|
|
if Some(hovered_word)
|
|
!= terminal_view
|
|
.hover
|
|
.as_ref()
|
|
.map(|hover| &hover.hovered_word)
|
|
{
|
|
terminal_view.hover = Some(HoverTarget {
|
|
tooltip: url.clone(),
|
|
hovered_word: hovered_word.clone(),
|
|
});
|
|
terminal_view.hover_tooltip_update = Task::ready(());
|
|
cx.notify();
|
|
}
|
|
}
|
|
Some((MaybeNavigationTarget::PathLike(path_like_target), hovered_word)) => {
|
|
if Some(hovered_word)
|
|
!= terminal_view
|
|
.hover
|
|
.as_ref()
|
|
.map(|hover| &hover.hovered_word)
|
|
{
|
|
terminal_view.hover = None;
|
|
terminal_view.hover_tooltip_update = hover_path_like_target(
|
|
&workspace,
|
|
hovered_word.clone(),
|
|
path_like_target,
|
|
cx,
|
|
);
|
|
cx.notify();
|
|
}
|
|
}
|
|
None => {
|
|
terminal_view.hover = None;
|
|
terminal_view.hover_tooltip_update = Task::ready(());
|
|
cx.notify();
|
|
}
|
|
}
|
|
}
|
|
|
|
Event::Open(maybe_navigation_target) => match maybe_navigation_target {
|
|
MaybeNavigationTarget::Url(url) => cx.open_url(url),
|
|
MaybeNavigationTarget::PathLike(path_like_target) => open_path_like_target(
|
|
&workspace,
|
|
terminal_view,
|
|
path_like_target,
|
|
window,
|
|
cx,
|
|
),
|
|
},
|
|
Event::BreadcrumbsChanged => cx.emit(ItemEvent::UpdateBreadcrumbs),
|
|
Event::CloseTerminal => cx.emit(ItemEvent::CloseItem),
|
|
Event::SelectionsChanged => {
|
|
window.invalidate_character_coordinates();
|
|
cx.emit(SearchEvent::ActiveMatchChanged)
|
|
}
|
|
}
|
|
},
|
|
);
|
|
vec![terminal_subscription, terminal_events_subscription]
|
|
}
|
|
|
|
fn regex_search_for_query(query: &project::search::SearchQuery) -> Option<RegexSearch> {
|
|
let str = query.as_str();
|
|
if query.is_regex() {
|
|
if str == "." {
|
|
return None;
|
|
}
|
|
RegexSearch::new(str).ok()
|
|
} else {
|
|
RegexSearch::new(®ex::escape(str)).ok()
|
|
}
|
|
}
|
|
|
|
impl TerminalView {
|
|
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.clear_bell(cx);
|
|
self.pause_cursor_blinking(window, cx);
|
|
|
|
self.terminal.update(cx, |term, cx| {
|
|
let handled = term.try_keystroke(
|
|
&event.keystroke,
|
|
TerminalSettings::get_global(cx).option_as_meta,
|
|
);
|
|
if handled {
|
|
cx.stop_propagation();
|
|
}
|
|
});
|
|
}
|
|
|
|
fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |terminal, _| {
|
|
terminal.set_cursor_shape(self.cursor_shape);
|
|
terminal.focus_in();
|
|
});
|
|
self.blink_cursors(self.blink_epoch, window, cx);
|
|
window.invalidate_character_coordinates();
|
|
cx.notify();
|
|
}
|
|
|
|
fn focus_out(&mut self, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal.update(cx, |terminal, _| {
|
|
terminal.focus_out();
|
|
terminal.set_cursor_shape(CursorShape::Hollow);
|
|
});
|
|
self.hide_scrollbar(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
impl Render for TerminalView {
|
|
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let terminal_handle = self.terminal.clone();
|
|
let terminal_view_handle = cx.entity();
|
|
|
|
let focused = self.focus_handle.is_focused(window);
|
|
|
|
// Always calculate scrollbar width to prevent layout shift
|
|
let scrollbar_width = if Self::should_show_scrollbar(cx)
|
|
&& self.content_mode(window, cx).is_scrollable()
|
|
&& self.terminal.read(cx).total_lines() > self.terminal.read(cx).viewport_lines()
|
|
{
|
|
TERMINAL_SCROLLBAR_WIDTH
|
|
} else {
|
|
px(0.)
|
|
};
|
|
|
|
div()
|
|
.id("terminal-view")
|
|
.size_full()
|
|
.relative()
|
|
.track_focus(&self.focus_handle(cx))
|
|
.key_context(self.dispatch_context(cx))
|
|
.on_action(cx.listener(TerminalView::send_text))
|
|
.on_action(cx.listener(TerminalView::send_keystroke))
|
|
.on_action(cx.listener(TerminalView::copy))
|
|
.on_action(cx.listener(TerminalView::paste))
|
|
.on_action(cx.listener(TerminalView::clear))
|
|
.on_action(cx.listener(TerminalView::scroll_line_up))
|
|
.on_action(cx.listener(TerminalView::scroll_line_down))
|
|
.on_action(cx.listener(TerminalView::scroll_page_up))
|
|
.on_action(cx.listener(TerminalView::scroll_page_down))
|
|
.on_action(cx.listener(TerminalView::scroll_to_top))
|
|
.on_action(cx.listener(TerminalView::scroll_to_bottom))
|
|
.on_action(cx.listener(TerminalView::toggle_vi_mode))
|
|
.on_action(cx.listener(TerminalView::show_character_palette))
|
|
.on_action(cx.listener(TerminalView::select_all))
|
|
.on_action(cx.listener(TerminalView::rerun_task))
|
|
.on_key_down(cx.listener(Self::key_down))
|
|
.on_mouse_down(
|
|
MouseButton::Right,
|
|
cx.listener(|this, event: &MouseDownEvent, window, cx| {
|
|
if !this.terminal.read(cx).mouse_mode(event.modifiers.shift) {
|
|
if this.terminal.read(cx).last_content.selection.is_none() {
|
|
this.terminal.update(cx, |terminal, _| {
|
|
terminal.select_word_at_event_position(event);
|
|
});
|
|
};
|
|
this.deploy_context_menu(event.position, window, cx);
|
|
cx.notify();
|
|
}
|
|
}),
|
|
)
|
|
.on_hover(cx.listener(|this, hovered, window, cx| {
|
|
if *hovered {
|
|
this.show_scrollbar = true;
|
|
this.hide_scrollbar_task.take();
|
|
cx.notify();
|
|
} else if !this.focus_handle.contains_focused(window, cx) {
|
|
this.hide_scrollbar(cx);
|
|
}
|
|
}))
|
|
.child(
|
|
// TODO: Oddly this wrapper div is needed for TerminalElement to not steal events from the context menu
|
|
div()
|
|
.size_full()
|
|
.bg(cx.theme().colors().editor_background)
|
|
.when(scrollbar_width > px(0.), |div| div.pr(scrollbar_width))
|
|
.child(TerminalElement::new(
|
|
terminal_handle,
|
|
terminal_view_handle,
|
|
self.workspace.clone(),
|
|
self.focus_handle.clone(),
|
|
focused,
|
|
self.should_show_cursor(focused, cx),
|
|
self.block_below_cursor.clone(),
|
|
self.mode.clone(),
|
|
))
|
|
.when_some(self.render_scrollbar(window, cx), |div, scrollbar| {
|
|
div.child(scrollbar)
|
|
}),
|
|
)
|
|
.children(self.context_menu.as_ref().map(|(menu, position, _)| {
|
|
deferred(
|
|
anchored()
|
|
.position(*position)
|
|
.anchor(gpui::Corner::TopLeft)
|
|
.child(menu.clone()),
|
|
)
|
|
.with_priority(1)
|
|
}))
|
|
}
|
|
}
|
|
|
|
impl Item for TerminalView {
|
|
type Event = ItemEvent;
|
|
|
|
fn tab_tooltip_content(&self, cx: &App) -> Option<TabTooltipContent> {
|
|
let terminal = self.terminal().read(cx);
|
|
let title = terminal.title(false);
|
|
let pid = terminal.pty_info.pid_getter().fallback_pid();
|
|
|
|
Some(TabTooltipContent::Custom(Box::new(move |_window, cx| {
|
|
cx.new(|_| TerminalTooltip::new(title.clone(), pid)).into()
|
|
})))
|
|
}
|
|
|
|
fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement {
|
|
let terminal = self.terminal().read(cx);
|
|
let title = terminal.title(true);
|
|
|
|
let (icon, icon_color, rerun_button) = match terminal.task() {
|
|
Some(terminal_task) => match &terminal_task.status {
|
|
TaskStatus::Running => (
|
|
IconName::PlayFilled,
|
|
Color::Disabled,
|
|
TerminalView::rerun_button(terminal_task),
|
|
),
|
|
TaskStatus::Unknown => (
|
|
IconName::Warning,
|
|
Color::Warning,
|
|
TerminalView::rerun_button(terminal_task),
|
|
),
|
|
TaskStatus::Completed { success } => {
|
|
let rerun_button = TerminalView::rerun_button(terminal_task);
|
|
|
|
if *success {
|
|
(IconName::Check, Color::Success, rerun_button)
|
|
} else {
|
|
(IconName::XCircle, Color::Error, rerun_button)
|
|
}
|
|
}
|
|
},
|
|
None => (IconName::Terminal, Color::Muted, None),
|
|
};
|
|
|
|
h_flex()
|
|
.gap_1()
|
|
.group("term-tab-icon")
|
|
.child(
|
|
h_flex()
|
|
.group("term-tab-icon")
|
|
.child(
|
|
div()
|
|
.when(rerun_button.is_some(), |this| {
|
|
this.hover(|style| style.invisible().w_0())
|
|
})
|
|
.child(Icon::new(icon).color(icon_color)),
|
|
)
|
|
.when_some(rerun_button, |this, rerun_button| {
|
|
this.child(
|
|
div()
|
|
.absolute()
|
|
.visible_on_hover("term-tab-icon")
|
|
.child(rerun_button),
|
|
)
|
|
}),
|
|
)
|
|
.child(Label::new(title).color(params.text_color()))
|
|
.into_any()
|
|
}
|
|
|
|
fn tab_content_text(&self, detail: usize, cx: &App) -> SharedString {
|
|
let terminal = self.terminal().read(cx);
|
|
terminal.title(detail == 0).into()
|
|
}
|
|
|
|
fn telemetry_event_text(&self) -> Option<&'static str> {
|
|
None
|
|
}
|
|
|
|
fn clone_on_split(
|
|
&self,
|
|
workspace_id: Option<WorkspaceId>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<Entity<Self>> {
|
|
let terminal = self
|
|
.project
|
|
.update(cx, |project, cx| {
|
|
let terminal = self.terminal().read(cx);
|
|
let working_directory = terminal
|
|
.working_directory()
|
|
.or_else(|| Some(project.active_project_directory(cx)?.to_path_buf()));
|
|
let python_venv_directory = terminal.python_venv_directory.clone();
|
|
project.create_terminal_with_venv(
|
|
TerminalKind::Shell(working_directory),
|
|
python_venv_directory,
|
|
cx,
|
|
)
|
|
})
|
|
.ok()?
|
|
.log_err()?;
|
|
|
|
Some(cx.new(|cx| {
|
|
TerminalView::new(
|
|
terminal,
|
|
self.workspace.clone(),
|
|
workspace_id,
|
|
self.project.clone(),
|
|
window,
|
|
cx,
|
|
)
|
|
}))
|
|
}
|
|
|
|
fn is_dirty(&self, cx: &gpui::App) -> bool {
|
|
match self.terminal.read(cx).task() {
|
|
Some(task) => task.status == TaskStatus::Running,
|
|
None => self.has_bell(),
|
|
}
|
|
}
|
|
|
|
fn has_conflict(&self, _cx: &App) -> bool {
|
|
false
|
|
}
|
|
|
|
fn can_save_as(&self, _cx: &App) -> bool {
|
|
false
|
|
}
|
|
|
|
fn is_singleton(&self, _cx: &App) -> bool {
|
|
true
|
|
}
|
|
|
|
fn as_searchable(&self, handle: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
|
|
Some(Box::new(handle.clone()))
|
|
}
|
|
|
|
fn breadcrumb_location(&self, cx: &App) -> ToolbarItemLocation {
|
|
if self.show_breadcrumbs && !self.terminal().read(cx).breadcrumb_text.trim().is_empty() {
|
|
ToolbarItemLocation::PrimaryLeft
|
|
} else {
|
|
ToolbarItemLocation::Hidden
|
|
}
|
|
}
|
|
|
|
fn breadcrumbs(&self, _: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
|
|
Some(vec![BreadcrumbText {
|
|
text: self.terminal().read(cx).breadcrumb_text.clone(),
|
|
highlights: None,
|
|
font: None,
|
|
}])
|
|
}
|
|
|
|
fn added_to_workspace(
|
|
&mut self,
|
|
workspace: &mut Workspace,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if self.terminal().read(cx).task().is_none() {
|
|
if let Some((new_id, old_id)) = workspace.database_id().zip(self.workspace_id) {
|
|
log::debug!(
|
|
"Updating workspace id for the terminal, old: {old_id:?}, new: {new_id:?}",
|
|
);
|
|
cx.background_spawn(TERMINAL_DB.update_workspace_id(
|
|
new_id,
|
|
old_id,
|
|
cx.entity_id().as_u64(),
|
|
))
|
|
.detach();
|
|
}
|
|
self.workspace_id = workspace.database_id();
|
|
}
|
|
}
|
|
|
|
fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) {
|
|
f(*event)
|
|
}
|
|
}
|
|
|
|
impl SerializableItem for TerminalView {
|
|
fn serialized_item_kind() -> &'static str {
|
|
"Terminal"
|
|
}
|
|
|
|
fn cleanup(
|
|
workspace_id: WorkspaceId,
|
|
alive_items: Vec<workspace::ItemId>,
|
|
_window: &mut Window,
|
|
cx: &mut App,
|
|
) -> Task<anyhow::Result<()>> {
|
|
delete_unloaded_items(alive_items, workspace_id, "terminals", &TERMINAL_DB, cx)
|
|
}
|
|
|
|
fn serialize(
|
|
&mut self,
|
|
_workspace: &mut Workspace,
|
|
item_id: workspace::ItemId,
|
|
_closing: bool,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<Task<anyhow::Result<()>>> {
|
|
let terminal = self.terminal().read(cx);
|
|
if terminal.task().is_some() {
|
|
return None;
|
|
}
|
|
|
|
if let Some((cwd, workspace_id)) = terminal.working_directory().zip(self.workspace_id) {
|
|
self.cwd_serialized = true;
|
|
Some(cx.background_spawn(async move {
|
|
TERMINAL_DB
|
|
.save_working_directory(item_id, workspace_id, cwd)
|
|
.await
|
|
}))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn should_serialize(&self, _: &Self::Event) -> bool {
|
|
!self.cwd_serialized
|
|
}
|
|
|
|
fn deserialize(
|
|
project: Entity<Project>,
|
|
workspace: WeakEntity<Workspace>,
|
|
workspace_id: workspace::WorkspaceId,
|
|
item_id: workspace::ItemId,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> Task<anyhow::Result<Entity<Self>>> {
|
|
window.spawn(cx, async move |cx| {
|
|
let cwd = cx
|
|
.update(|_window, cx| {
|
|
let from_db = TERMINAL_DB
|
|
.get_working_directory(item_id, workspace_id)
|
|
.log_err()
|
|
.flatten();
|
|
if from_db
|
|
.as_ref()
|
|
.is_some_and(|from_db| !from_db.as_os_str().is_empty())
|
|
{
|
|
from_db
|
|
} else {
|
|
workspace
|
|
.upgrade()
|
|
.and_then(|workspace| default_working_directory(workspace.read(cx), cx))
|
|
}
|
|
})
|
|
.ok()
|
|
.flatten();
|
|
|
|
let terminal = project
|
|
.update(cx, |project, cx| {
|
|
project.create_terminal(TerminalKind::Shell(cwd), cx)
|
|
})?
|
|
.await?;
|
|
cx.update(|window, cx| {
|
|
cx.new(|cx| {
|
|
TerminalView::new(
|
|
terminal,
|
|
workspace,
|
|
Some(workspace_id),
|
|
project.downgrade(),
|
|
window,
|
|
cx,
|
|
)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
impl SearchableItem for TerminalView {
|
|
type Match = RangeInclusive<Point>;
|
|
|
|
fn supported_options(&self) -> SearchOptions {
|
|
SearchOptions {
|
|
case: false,
|
|
word: false,
|
|
regex: true,
|
|
replacement: false,
|
|
selection: false,
|
|
find_in_results: false,
|
|
}
|
|
}
|
|
|
|
/// Clear stored matches
|
|
fn clear_matches(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal().update(cx, |term, _| term.clear_matches())
|
|
}
|
|
|
|
/// Store matches returned from find_matches somewhere for rendering
|
|
fn update_matches(
|
|
&mut self,
|
|
matches: &[Self::Match],
|
|
_window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.terminal()
|
|
.update(cx, |term, _| term.matches = matches.to_vec())
|
|
}
|
|
|
|
/// Returns the selection content to pre-load into this search
|
|
fn query_suggestion(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> String {
|
|
self.terminal()
|
|
.read(cx)
|
|
.last_content
|
|
.selection_text
|
|
.clone()
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
/// Focus match at given index into the Vec of matches
|
|
fn activate_match(
|
|
&mut self,
|
|
index: usize,
|
|
_: &[Self::Match],
|
|
_window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.terminal()
|
|
.update(cx, |term, _| term.activate_match(index));
|
|
cx.notify();
|
|
}
|
|
|
|
/// Add selections for all matches given.
|
|
fn select_matches(&mut self, matches: &[Self::Match], _: &mut Window, cx: &mut Context<Self>) {
|
|
self.terminal()
|
|
.update(cx, |term, _| term.select_matches(matches));
|
|
cx.notify();
|
|
}
|
|
|
|
/// Get all of the matches for this query, should be done on the background
|
|
fn find_matches(
|
|
&mut self,
|
|
query: Arc<SearchQuery>,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Task<Vec<Self::Match>> {
|
|
if let Some(s) = regex_search_for_query(&query) {
|
|
self.terminal()
|
|
.update(cx, |term, cx| term.find_matches(s, cx))
|
|
} else {
|
|
Task::ready(vec![])
|
|
}
|
|
}
|
|
|
|
/// Reports back to the search toolbar what the active match should be (the selection)
|
|
fn active_match_index(
|
|
&mut self,
|
|
direction: Direction,
|
|
matches: &[Self::Match],
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<usize> {
|
|
// Selection head might have a value if there's a selection that isn't
|
|
// associated with a match. Therefore, if there are no matches, we should
|
|
// report None, no matter the state of the terminal
|
|
|
|
if !matches.is_empty() {
|
|
if let Some(selection_head) = self.terminal().read(cx).selection_head {
|
|
// If selection head is contained in a match. Return that match
|
|
match direction {
|
|
Direction::Prev => {
|
|
// If no selection before selection head, return the first match
|
|
Some(
|
|
matches
|
|
.iter()
|
|
.enumerate()
|
|
.rev()
|
|
.find(|(_, search_match)| {
|
|
search_match.contains(&selection_head)
|
|
|| search_match.start() < &selection_head
|
|
})
|
|
.map(|(ix, _)| ix)
|
|
.unwrap_or(0),
|
|
)
|
|
}
|
|
Direction::Next => {
|
|
// If no selection after selection head, return the last match
|
|
Some(
|
|
matches
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, search_match)| {
|
|
search_match.contains(&selection_head)
|
|
|| search_match.start() > &selection_head
|
|
})
|
|
.map(|(ix, _)| ix)
|
|
.unwrap_or(matches.len().saturating_sub(1)),
|
|
)
|
|
}
|
|
}
|
|
} else {
|
|
// Matches found but no active selection, return the first last one (closest to cursor)
|
|
Some(matches.len().saturating_sub(1))
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
fn replace(
|
|
&mut self,
|
|
_: &Self::Match,
|
|
_: &SearchQuery,
|
|
_window: &mut Window,
|
|
_: &mut Context<Self>,
|
|
) {
|
|
// Replacement is not supported in terminal view, so this is a no-op.
|
|
}
|
|
}
|
|
|
|
///Gets the working directory for the given workspace, respecting the user's settings.
|
|
/// None implies "~" on whichever machine we end up on.
|
|
pub(crate) fn default_working_directory(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
|
|
match &TerminalSettings::get_global(cx).working_directory {
|
|
WorkingDirectory::CurrentProjectDirectory => workspace
|
|
.project()
|
|
.read(cx)
|
|
.active_project_directory(cx)
|
|
.as_deref()
|
|
.map(Path::to_path_buf),
|
|
WorkingDirectory::FirstProjectDirectory => first_project_directory(workspace, cx),
|
|
WorkingDirectory::AlwaysHome => None,
|
|
WorkingDirectory::Always { directory } => {
|
|
shellexpand::full(&directory) //TODO handle this better
|
|
.ok()
|
|
.map(|dir| Path::new(&dir.to_string()).to_path_buf())
|
|
.filter(|dir| dir.is_dir())
|
|
}
|
|
}
|
|
}
|
|
///Gets the first project's home directory, or the home directory
|
|
fn first_project_directory(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
|
|
let worktree = workspace.worktrees(cx).next()?.read(cx);
|
|
if !worktree.root_entry()?.is_dir() {
|
|
return None;
|
|
}
|
|
Some(worktree.abs_path().to_path_buf())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use gpui::TestAppContext;
|
|
use project::{Entry, Project, ProjectPath, Worktree};
|
|
use std::path::Path;
|
|
use workspace::AppState;
|
|
|
|
// Working directory calculation tests
|
|
|
|
// No Worktrees in project -> home_dir()
|
|
#[gpui::test]
|
|
async fn no_worktree(cx: &mut TestAppContext) {
|
|
let (project, workspace) = init_test(cx).await;
|
|
cx.read(|cx| {
|
|
let workspace = workspace.read(cx);
|
|
let active_entry = project.read(cx).active_entry();
|
|
|
|
//Make sure environment is as expected
|
|
assert!(active_entry.is_none());
|
|
assert!(workspace.worktrees(cx).next().is_none());
|
|
|
|
let res = default_working_directory(workspace, cx);
|
|
assert_eq!(res, None);
|
|
let res = first_project_directory(workspace, cx);
|
|
assert_eq!(res, None);
|
|
});
|
|
}
|
|
|
|
// No active entry, but a worktree, worktree is a file -> home_dir()
|
|
#[gpui::test]
|
|
async fn no_active_entry_worktree_is_file(cx: &mut TestAppContext) {
|
|
let (project, workspace) = init_test(cx).await;
|
|
|
|
create_file_wt(project.clone(), "/root.txt", cx).await;
|
|
cx.read(|cx| {
|
|
let workspace = workspace.read(cx);
|
|
let active_entry = project.read(cx).active_entry();
|
|
|
|
//Make sure environment is as expected
|
|
assert!(active_entry.is_none());
|
|
assert!(workspace.worktrees(cx).next().is_some());
|
|
|
|
let res = default_working_directory(workspace, cx);
|
|
assert_eq!(res, None);
|
|
let res = first_project_directory(workspace, cx);
|
|
assert_eq!(res, None);
|
|
});
|
|
}
|
|
|
|
// No active entry, but a worktree, worktree is a folder -> worktree_folder
|
|
#[gpui::test]
|
|
async fn no_active_entry_worktree_is_dir(cx: &mut TestAppContext) {
|
|
let (project, workspace) = init_test(cx).await;
|
|
|
|
let (_wt, _entry) = create_folder_wt(project.clone(), "/root/", cx).await;
|
|
cx.update(|cx| {
|
|
let workspace = workspace.read(cx);
|
|
let active_entry = project.read(cx).active_entry();
|
|
|
|
assert!(active_entry.is_none());
|
|
assert!(workspace.worktrees(cx).next().is_some());
|
|
|
|
let res = default_working_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root/")).to_path_buf()));
|
|
let res = first_project_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root/")).to_path_buf()));
|
|
});
|
|
}
|
|
|
|
// Active entry with a work tree, worktree is a file -> worktree_folder()
|
|
#[gpui::test]
|
|
async fn active_entry_worktree_is_file(cx: &mut TestAppContext) {
|
|
let (project, workspace) = init_test(cx).await;
|
|
|
|
let (_wt, _entry) = create_folder_wt(project.clone(), "/root1/", cx).await;
|
|
let (wt2, entry2) = create_file_wt(project.clone(), "/root2.txt", cx).await;
|
|
insert_active_entry_for(wt2, entry2, project.clone(), cx);
|
|
|
|
cx.update(|cx| {
|
|
let workspace = workspace.read(cx);
|
|
let active_entry = project.read(cx).active_entry();
|
|
|
|
assert!(active_entry.is_some());
|
|
|
|
let res = default_working_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root1/")).to_path_buf()));
|
|
let res = first_project_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root1/")).to_path_buf()));
|
|
});
|
|
}
|
|
|
|
// Active entry, with a worktree, worktree is a folder -> worktree_folder
|
|
#[gpui::test]
|
|
async fn active_entry_worktree_is_dir(cx: &mut TestAppContext) {
|
|
let (project, workspace) = init_test(cx).await;
|
|
|
|
let (_wt, _entry) = create_folder_wt(project.clone(), "/root1/", cx).await;
|
|
let (wt2, entry2) = create_folder_wt(project.clone(), "/root2/", cx).await;
|
|
insert_active_entry_for(wt2, entry2, project.clone(), cx);
|
|
|
|
cx.update(|cx| {
|
|
let workspace = workspace.read(cx);
|
|
let active_entry = project.read(cx).active_entry();
|
|
|
|
assert!(active_entry.is_some());
|
|
|
|
let res = default_working_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root2/")).to_path_buf()));
|
|
let res = first_project_directory(workspace, cx);
|
|
assert_eq!(res, Some((Path::new("/root1/")).to_path_buf()));
|
|
});
|
|
}
|
|
|
|
/// Creates a worktree with 1 file: /root.txt
|
|
pub async fn init_test(cx: &mut TestAppContext) -> (Entity<Project>, Entity<Workspace>) {
|
|
let params = cx.update(AppState::test);
|
|
cx.update(|cx| {
|
|
terminal::init(cx);
|
|
theme::init(theme::LoadThemes::JustBase, cx);
|
|
Project::init_settings(cx);
|
|
language::init(cx);
|
|
});
|
|
|
|
let project = Project::test(params.fs.clone(), [], cx).await;
|
|
let workspace = cx
|
|
.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx))
|
|
.root(cx)
|
|
.unwrap();
|
|
|
|
(project, workspace)
|
|
}
|
|
|
|
/// Creates a worktree with 1 folder: /root{suffix}/
|
|
async fn create_folder_wt(
|
|
project: Entity<Project>,
|
|
path: impl AsRef<Path>,
|
|
cx: &mut TestAppContext,
|
|
) -> (Entity<Worktree>, Entry) {
|
|
create_wt(project, true, path, cx).await
|
|
}
|
|
|
|
/// Creates a worktree with 1 file: /root{suffix}.txt
|
|
async fn create_file_wt(
|
|
project: Entity<Project>,
|
|
path: impl AsRef<Path>,
|
|
cx: &mut TestAppContext,
|
|
) -> (Entity<Worktree>, Entry) {
|
|
create_wt(project, false, path, cx).await
|
|
}
|
|
|
|
async fn create_wt(
|
|
project: Entity<Project>,
|
|
is_dir: bool,
|
|
path: impl AsRef<Path>,
|
|
cx: &mut TestAppContext,
|
|
) -> (Entity<Worktree>, Entry) {
|
|
let (wt, _) = project
|
|
.update(cx, |project, cx| {
|
|
project.find_or_create_worktree(path, true, cx)
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let entry = cx
|
|
.update(|cx| {
|
|
wt.update(cx, |wt, cx| {
|
|
wt.create_entry(Path::new(""), is_dir, None, cx)
|
|
})
|
|
})
|
|
.await
|
|
.unwrap()
|
|
.into_included()
|
|
.unwrap();
|
|
|
|
(wt, entry)
|
|
}
|
|
|
|
pub fn insert_active_entry_for(
|
|
wt: Entity<Worktree>,
|
|
entry: Entry,
|
|
project: Entity<Project>,
|
|
cx: &mut TestAppContext,
|
|
) {
|
|
cx.update(|cx| {
|
|
let p = ProjectPath {
|
|
worktree_id: wt.read(cx).id(),
|
|
path: entry.path,
|
|
};
|
|
project.update(cx, |project, cx| project.set_active_path(Some(p), cx));
|
|
});
|
|
}
|
|
}
|