leyoda/cosmic-terminal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into jellywx/fix-pageup-pagedown-binds

Browse source
This commit is contained in:
Levi Portenier 2026-05-14 14:32:25 -06:00 • committed by GitHub
commit 77114d0320
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
39 changed files with 1917 additions and 1609 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/config.rs
View file

@ -235,6 +235,8 @@ pub struct Config {
pub syntax_theme_dark: String,
pub syntax_theme_light: String,
pub focus_follow_mouse: bool,
#[serde(default)]
pub tab_new_inherit_working_directory: bool,
pub default_profile: Option<ProfileId>,
#[serde(default)]
pub shortcuts_custom: Shortcuts,
@ -249,6 +251,7 @@ impl Default for Config {
color_schemes_light: BTreeMap::new(),
dim_font_weight: Weight::NORMAL.0,
focus_follow_mouse: false,
tab_new_inherit_working_directory: false,
font_name: "Noto Sans Mono".to_string(),
font_size: 14,
font_size_zoom_step_mul_100: 100,

581
src/main.rs
View file

@ -3,7 +3,7 @@
use alacritty_terminal::{event::Event as TermEvent, term, term::color::Colors as TermColors, tty};
use cosmic::iced::clipboard::dnd::DndAction;
use cosmic::iced_core::keyboard::key::Named;
use cosmic::iced::core::keyboard::key::Named;
use cosmic::widget::menu::action::MenuAction;
use cosmic::widget::menu::key_bind::KeyBind;
use cosmic::widget::pane_grid::Pane;
@ -177,11 +177,7 @@ fn main() -> Result<(), Box<dyn Error>> {
let shortcuts_config = shortcuts::ShortcutsConfig::new(config.shortcuts_custom.clone());
let shell = if let Some(shell_program) = shell_program_opt {
Some(tty::Shell::new(shell_program, shell_args))
} else {
None
};
let shell = shell_program_opt.map(|shell_program| tty::Shell::new(shell_program, shell_args));
let startup_options = Some(tty::Options {
shell,
working_directory,
@ -367,7 +363,7 @@ pub enum Message {
ColorSchemeRename(ColorSchemeKind, ColorSchemeId, String),
ColorSchemeRenameSubmit,
ColorSchemeTabActivate(widget::segmented_button::Entity),
Config(Config),
Config(Box<Config>),
Copy(Option<segmented_button::Entity>),
CopyOrSigint(Option<segmented_button::Entity>),
CopyPrimary(Option<segmented_button::Entity>),
@ -379,7 +375,7 @@ pub enum Message {
DefaultFontStretch(usize),
DefaultFontWeight(usize),
DefaultZoomStep(usize),
DialogMessage(DialogMessage),
DialogMessage(Box<DialogMessage>), // DialogMessage is huge, so we use a box to make the size of this enum smaller on the stack
Drop(Option<(pane_grid::Pane, segmented_button::Entity, DndDrop)>),
Find(bool),
FindNext,
@ -431,6 +427,7 @@ pub enum Message {
ShowHeaderBar(bool),
SyntaxTheme(ColorSchemeKind, usize),
SystemThemeChange,
TabNewInheritWorkingDirectory(bool),
TabActivate(segmented_button::Entity),
TabActivateJump(usize),
TabClose(Option<segmented_button::Entity>),
@ -453,6 +450,7 @@ pub enum Message {
ZoomIn,
ZoomOut,
ZoomReset,
ContextMenuPopupClosed(window::Id),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
@ -523,6 +521,14 @@ pub struct App {
shortcut_search_regex: Option<regex::Regex>,
shortcut_search_value: String,
modifiers: Modifiers,
context_menu_popup: Option<(
window::Id,
pane_grid::Pane,
segmented_button::Entity,
Option<String>,
widget::Id,
cosmic::iced::Point,
)>,
#[cfg(feature = "password_manager")]
password_mgr: password_manager::PasswordManager,
}
@ -545,21 +551,19 @@ impl App {
.config
.color_schemes(color_scheme_kind)
.get(&color_scheme_id)
{
if self
&& self
.themes
.insert(
(color_scheme_name.clone(), color_scheme_kind),
color_scheme.into(),
)
.is_some()
{
log::warn!(
"custom {:?} color scheme {:?} replaces builtin one",
color_scheme_kind,
color_scheme_name
);
}
{
log::warn!(
"custom {:?} color scheme {:?} replaces builtin one",
color_scheme_kind,
color_scheme_name
);
}
}
}
@ -593,6 +597,18 @@ impl App {
}
}
fn reset_active_pane_zoom(&mut self) {
if let Some(tab_model) = self.pane_model.active() {
for entity in tab_model.iter() {
if tab_model.is_active(entity)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
terminal.lock().unwrap().set_zoom_adj(0);
}
}
}
}
fn save_shortcuts_custom(&mut self) {
self.config.shortcuts_custom = self.shortcuts_config.custom.clone();
match &self.config_handler {
@ -690,21 +706,21 @@ impl App {
// but only for the active pane/tab
if let Some(tab_model) = self.pane_model.active() {
for entity in tab_model.iter() {
if tab_model.is_active(entity) {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
let current_zoom_adj = terminal.zoom_adj();
match zoom_message {
Message::ZoomIn => {
terminal.set_zoom_adj(current_zoom_adj.saturating_add(1))
}
Message::ZoomOut => {
terminal.set_zoom_adj(current_zoom_adj.saturating_sub(1))
}
_ => {}
if tab_model.is_active(entity)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let mut terminal = terminal.lock().unwrap();
let current_zoom_adj = terminal.zoom_adj();
match zoom_message {
Message::ZoomIn => {
terminal.set_zoom_adj(current_zoom_adj.saturating_add(1))
}
terminal.set_config(&self.config, &self.themes);
Message::ZoomOut => {
terminal.set_zoom_adj(current_zoom_adj.saturating_sub(1))
}
_ => {}
}
terminal.set_config(&self.config, &self.themes);
}
}
}
@ -713,16 +729,16 @@ impl App {
fn save_color_schemes(&mut self, color_scheme_kind: ColorSchemeKind) -> Task<Message> {
// Optimized for just saving color_schemes
if let Some(ref config_handler) = self.config_handler {
if let Err(err) = config_handler.set(
if let Some(ref config_handler) = self.config_handler
&& let Err(err) = config_handler.set(
match color_scheme_kind {
ColorSchemeKind::Dark => "color_schemes_dark",
ColorSchemeKind::Light => "color_schemes_light",
},
self.config.color_schemes(color_scheme_kind),
) {
log::error!("failed to save config: {}", err);
}
)
{
log::error!("failed to save config: {}", err);
}
self.update_color_schemes();
Task::none()
@ -745,16 +761,16 @@ impl App {
if self.find {
widget::text_input::focus(self.find_search_id.clone())
} else if self.core.window.show_context {
match self.context_page {
ContextPage::KeyboardShortcuts => {
if self.shortcut_search_focus.get() {
self.shortcut_search_focus.set(false);
return widget::text_input::focus(self.shortcut_search_id.clone());
}
}
// TODO focus for other context pages?
_ => {}
// Right now we only care about the KeyboardShortcuts context page, so we use a simple if.
// In the future if we are to care about other conext pages, we could switch this to a match
// statement instead to be cleaner.
if self.context_page == ContextPage::KeyboardShortcuts
&& self.shortcut_search_focus.get()
{
self.shortcut_search_focus.set(false);
return widget::text_input::focus(self.shortcut_search_id.clone());
}
Task::none()
} else if let Some(terminal_id) = self.terminal_ids.get(&self.pane_model.focused()).cloned()
{
@ -1017,10 +1033,10 @@ impl App {
let mut found_actions = false;
for action in group.actions {
let action_label = shortcuts::action_label(action);
if let Some(regex) = &self.shortcut_search_regex {
if regex.find(&action_label).is_none() {
continue;
}
if let Some(regex) = &self.shortcut_search_regex
&& regex.find(&action_label).is_none()
{
continue;
}
found_actions = true;
@ -1483,11 +1499,21 @@ impl App {
.toggler(self.config.focus_follow_mouse, Message::FocusFollowMouse),
);
let advanced_section = widget::settings::section().title(fl!("advanced")).add(
widget::settings::item::builder(fl!("show-headerbar"))
.description(fl!("show-header-description"))
.toggler(self.config.show_headerbar, Message::ShowHeaderBar),
);
let advanced_section = widget::settings::section()
.title(fl!("advanced"))
.add(
widget::settings::item::builder(fl!("show-headerbar"))
.description(fl!("show-header-description"))
.toggler(self.config.show_headerbar, Message::ShowHeaderBar),
)
.add(
widget::settings::item::builder(fl!("tab-new-inherit-working-directory"))
.description(fl!("tab-new-inherit-working-directory-description"))
.toggler(
self.config.tab_new_inherit_working_directory,
Message::TabNewInheritWorkingDirectory,
),
);
widget::settings::view_column(vec![
appearance_section.into(),
@ -1501,11 +1527,23 @@ impl App {
self.config.default_profile
}
fn active_terminal_working_directory(&self) -> Option<PathBuf> {
let tab_model = self.pane_model.active()?;
let entity = tab_model.active();
let terminal = tab_model.data::<Mutex<Terminal>>(entity)?;
let terminal = terminal.lock().unwrap();
terminal.working_directory()
}
fn create_and_focus_new_terminal(
&mut self,
pane: pane_grid::Pane,
profile_id_opt: Option<ProfileId>,
inherit_working_directory: bool,
) -> Task<Message> {
let inherited_working_directory = inherit_working_directory
.then(|| self.active_terminal_working_directory())
.flatten();
self.pane_model.set_focus(pane);
match &self.term_event_tx_opt {
Some(term_event_tx) => {
@ -1534,20 +1572,21 @@ impl App {
self.startup_options.take().unwrap_or_default();
let options = tty::Options {
shell: startup_options.shell.or_else(|| {
if let Some(mut args) = shlex::split(&profile.command) {
if !args.is_empty() {
let command = args.remove(0);
return Some(tty::Shell::new(command, args));
}
if let Some(mut args) = shlex::split(&profile.command)
&& !args.is_empty()
{
let command = args.remove(0);
return Some(tty::Shell::new(command, args));
}
return None;
None
}),
working_directory: startup_options.working_directory.or_else(
|| {
working_directory: startup_options
.working_directory
.or_else(|| inherited_working_directory.clone())
.or_else(|| {
(!profile.working_directory.is_empty())
.then(|| profile.working_directory.clone().into())
},
),
}),
drain_on_exit: startup_options.drain_on_exit
|| profile.drain_on_exit,
..startup_options
@ -1559,7 +1598,11 @@ impl App {
};
(options, tab_title_override)
} else {
(self.startup_options.take().unwrap_or_default(), None)
let mut options = self.startup_options.take().unwrap_or_default();
if options.working_directory.is_none() {
options.working_directory = inherited_working_directory.clone();
}
(options, None)
};
let entity = tab_model
@ -1840,6 +1883,7 @@ impl Application for App {
shortcut_search_regex: None,
shortcut_search_value: String::new(),
modifiers: Modifiers::empty(),
context_menu_popup: None,
#[cfg(feature = "password_manager")]
password_mgr: Default::default(),
};
@ -1946,24 +1990,23 @@ impl Application for App {
.get(&color_scheme_id)
.map(|color_scheme| color_scheme.name.clone()),
None => Some(format!("COSMIC {:?}", color_scheme_kind)),
} {
if self.dialog_opt.is_none() {
let (dialog, command) = Dialog::new(
DialogSettings::new().kind(DialogKind::SaveFile {
filename: format!("{}.ron", color_scheme_name),
}),
Message::DialogMessage,
move |result| {
Message::ColorSchemeExportResult(
color_scheme_kind,
color_scheme_id_opt,
result,
)
},
);
self.dialog_opt = Some(dialog);
return command;
}
} && self.dialog_opt.is_none()
{
let (dialog, command) = Dialog::new(
DialogSettings::new().kind(DialogKind::SaveFile {
filename: format!("{}.ron", color_scheme_name),
}),
|msg| Message::DialogMessage(Box::new(msg)),
move |result| {
Message::ColorSchemeExportResult(
color_scheme_kind,
color_scheme_id_opt,
result,
)
},
);
self.dialog_opt = Some(dialog);
return command;
}
}
Message::ColorSchemeExportResult(color_scheme_kind, color_scheme_id_opt, result) => {
@ -2051,7 +2094,7 @@ impl Application for App {
self.color_scheme_errors.clear();
let (dialog, command) = Dialog::new(
DialogSettings::new().kind(DialogKind::OpenMultipleFiles),
Message::DialogMessage,
|msg| Message::DialogMessage(Box::new(msg)),
move |result| Message::ColorSchemeImportResult(color_scheme_kind, result),
);
self.dialog_opt = Some(dialog);
@ -2105,15 +2148,13 @@ impl Application for App {
Message::ColorSchemeRenameSubmit => {
if let Some((color_scheme_kind, color_scheme_id, color_scheme_name)) =
self.color_scheme_renaming.take()
{
if let Some(color_scheme) = self
&& let Some(color_scheme) = self
.config
.color_schemes_mut(color_scheme_kind)
.get_mut(&color_scheme_id)
{
color_scheme.name = color_scheme_name;
return self.save_color_schemes(color_scheme_kind);
}
{
color_scheme.name = color_scheme_name;
return self.save_color_schemes(color_scheme_kind);
}
}
Message::ColorSchemeTabActivate(entity) => {
@ -2127,11 +2168,11 @@ impl Application for App {
}
}
Message::Config(config) => {
if config != self.config {
if *config != self.config {
let shortcuts_changed = config.shortcuts_custom != self.config.shortcuts_custom;
log::info!("update config");
//TODO: update syntax theme by clearing tabs, only if needed
self.config = config;
self.config = *config;
if shortcuts_changed {
self.shortcuts_config =
shortcuts::ShortcutsConfig::new(self.config.shortcuts_custom.clone());
@ -2295,7 +2336,8 @@ impl Application for App {
},
Message::DialogMessage(dialog_message) => {
if let Some(dialog) = &mut self.dialog_opt {
return dialog.update(dialog_message);
// DialogMessage is boxed, so we need to dereference it before updating
return dialog.update(*dialog_message);
}
}
Message::Drop(Some((pane, entity, data))) => {
@ -2334,13 +2376,13 @@ impl Application for App {
return self.update_focus();
}
Message::FindNext => {
if !self.find_search_value.is_empty() {
if let Some(tab_model) = self.pane_model.active() {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.search(&self.find_search_value, true);
}
if !self.find_search_value.is_empty()
&& let Some(tab_model) = self.pane_model.active()
{
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.search(&self.find_search_value, true);
}
}
@ -2348,13 +2390,13 @@ impl Application for App {
return self.update_focus();
}
Message::FindPrevious => {
if !self.find_search_value.is_empty() {
if let Some(tab_model) = self.pane_model.active() {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.search(&self.find_search_value, false);
}
if !self.find_search_value.is_empty()
&& let Some(tab_model) = self.pane_model.active()
{
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.search(&self.find_search_value, false);
}
}
@ -2431,7 +2473,6 @@ impl Application for App {
if let Some(tab_model) = self.pane_model.active() {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
// Update context menu position
let mut terminal = terminal.lock().unwrap();
if let Some(url) =
terminal.context_menu.as_ref().and_then(|m| m.link.as_ref())
@ -2450,14 +2491,12 @@ impl Application for App {
if let Some(tab_model) = self.pane_model.active() {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
// Update context menu position
let mut terminal = terminal.lock().unwrap();
if let Some(url) =
terminal.context_menu.as_ref().and_then(|m| m.link.as_ref())
&& let Err(err) = open::that_detached(url)
{
if let Err(err) = open::that_detached(url) {
log::warn!("failed to open {:?}: {}", url, err);
}
log::warn!("failed to open {:?}: {}", url, err);
}
terminal.context_menu = None;
terminal.active_regex_match = None;
@ -2541,7 +2580,7 @@ impl Application for App {
if let Some((pane, _)) = result {
self.terminal_ids.insert(pane, widget::Id::unique());
let command =
self.create_and_focus_new_terminal(pane, self.get_default_profile());
self.create_and_focus_new_terminal(pane, self.get_default_profile(), false);
self.pane_model.panes_created += 1;
return command;
}
@ -2653,8 +2692,11 @@ impl Application for App {
return self.save_profiles();
}
Message::ProfileOpen(profile_id) => {
return self
.create_and_focus_new_terminal(self.pane_model.focused(), Some(profile_id));
return self.create_and_focus_new_terminal(
self.pane_model.focused(),
Some(profile_id),
false,
);
}
Message::ProfileRemove(profile_id) => {
// Reset matching terminals to default profile
@ -2720,6 +2762,12 @@ impl Application for App {
return self.update_config();
}
}
Message::TabNewInheritWorkingDirectory(tab_new_inherit_working_directory) => {
config_set!(
tab_new_inherit_working_directory,
tab_new_inherit_working_directory
);
}
Message::UseBrightBold(use_bright_bold) => {
if use_bright_bold != self.config.use_bright_bold {
config_set!(use_bright_bold, use_bright_bold);
@ -2810,63 +2858,138 @@ impl Application for App {
return self.update_title(None);
}
Message::TabContextAction(entity, action) => {
if let Some(tab_model) = self.pane_model.active() {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
// Close context menu
{
let mut terminal = terminal.lock().unwrap();
//Some actions need the menu_state,
//so only clear the position for them.
match action {
Action::LaunchUrlByMenu | Action::CopyUrlByMenu => {
if let Some(context_menu) = terminal.context_menu.as_mut() {
context_menu.position = None;
}
}
_ => {
terminal.context_menu = None;
}
// Close context menu popup
let mut tasks = Vec::new();
if let Some((_popup_id, _, _, _, _, _)) = self.context_menu_popup.take() {
#[cfg(feature = "wayland")]
if is_wayland() {
tasks.push(cosmic::task::message(Message::Surface(
cosmic::surface::action::destroy_popup(_popup_id),
)));
}
}
// Close terminal context menu state
if let Some(tab_model) = self.pane_model.active()
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let mut terminal = terminal.lock().unwrap();
//Some actions need the menu_state,
//so only clear the position for them.
match action {
Action::LaunchUrlByMenu | Action::CopyUrlByMenu => {
if let Some(context_menu) = terminal.context_menu.as_mut() {
context_menu.position = None;
}
}
// Run action's message
return self.update(action.message(Some(entity)));
_ => {
terminal.context_menu = None;
}
}
}
tasks.push(self.update(action.message(Some(entity))));
return cosmic::Task::batch(tasks);
}
Message::TabContextMenu(pane, menu_state) => {
// Close any existing context menues
let panes: Vec<_> = self.pane_model.panes.iter().collect();
for (_pane, tab_model) in panes {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.context_menu = None;
#[allow(unused_mut)]
let mut tasks = Vec::new();
// Close existing context menu popup if any
if let Some((_popup_id, _, _, _, _, _)) = self.context_menu_popup.take() {
#[cfg(feature = "wayland")]
if is_wayland() {
tasks.push(cosmic::task::message(Message::Surface(
cosmic::surface::action::destroy_popup(_popup_id),
)));
}
}
// Show the context menu on the correct pane / terminal
if let Some(tab_model) = self.pane_model.panes.get(pane) {
let entity = tab_model.active();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
// Update context menu position
let mut terminal = terminal.lock().unwrap();
terminal.context_menu = menu_state;
// Clear all terminal context_menu state
for (_, tab_model) in self.pane_model.panes.iter() {
for entity in tab_model.iter() {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.context_menu = None;
}
}
}
// Shift focus to the pane / terminal
// with the context menu
self.pane_model.set_focus(pane);
return self.update_title(Some(pane));
if let Some(menu_state) = menu_state {
if let Some(_position) = menu_state.position {
let local_position = menu_state.local_position.unwrap_or(_position);
if let Some(tab_model) = self.pane_model.panes.get(pane) {
let entity = tab_model.active();
let link = menu_state.link.clone();
let popup_id = window::Id::unique();
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.context_menu = Some(menu_state);
}
self.context_menu_popup = Some((
popup_id,
pane,
entity,
link,
widget::Id::unique(),
local_position,
));
#[cfg(feature = "wayland")]
if is_wayland() {
let main_window = self.core.main_window_id().unwrap();
let pos_x = _position.x as i32;
let pos_y = _position.y as i32;
tasks.push(cosmic::task::message(Message::Surface(
cosmic::surface::action::app_popup(move |_app: &mut Self| {
use cosmic::cctk::wayland_protocols::xdg::shell::client::xdg_positioner::{Anchor, Gravity};
use cosmic::iced::runtime::platform_specific::wayland::popup::{SctkPopupSettings, SctkPositioner};
SctkPopupSettings {
parent: main_window,
id: popup_id,
positioner: SctkPositioner {
size: None,
anchor_rect: cosmic::iced::Rectangle {
x: pos_x,
y: pos_y,
width: 1,
height: 1,
},
anchor: Anchor::None,
gravity: Gravity::BottomRight,
reactive: true,
..Default::default()
},
parent_size: None,
grab: true,
close_with_children: false,
input_zone: None,
}
}, None),
)));
}
}
}
self.pane_model.set_focus(pane);
}
return cosmic::Task::batch(tasks);
}
Message::TabNew => {
return self.create_and_focus_new_terminal(
self.pane_model.focused(),
self.get_default_profile(),
self.config.tab_new_inherit_working_directory,
);
}
Message::TabNewNoProfile => {
return self.create_and_focus_new_terminal(self.pane_model.focused(), None);
return self.create_and_focus_new_terminal(
self.pane_model.focused(),
None,
self.config.tab_new_inherit_working_directory,
);
}
Message::TabNext => {
if let Some(tab_model) = self.pane_model.active() {
@ -2888,9 +3011,7 @@ impl Application for App {
let pos = tab_model
.position(tab_model.active())
.and_then(|i| (i as usize).checked_sub(1))
.unwrap_or_else(|| {
tab_model.iter().count().checked_sub(1).unwrap_or_default()
});
.unwrap_or_else(|| tab_model.iter().count().saturating_sub(1));
let entity = tab_model.iter().nth(pos);
if let Some(entity) = entity {
@ -2929,13 +3050,13 @@ impl Application for App {
}
},
TermEvent::ColorRequest(index, f) => {
if let Some(tab_model) = self.pane_model.panes.get(pane) {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let terminal = terminal.lock().unwrap();
let rgb = terminal.colors()[index].unwrap_or_default();
let text = f(rgb);
terminal.input_no_scroll(text.into_bytes());
}
if let Some(tab_model) = self.pane_model.panes.get(pane)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let terminal = terminal.lock().unwrap();
let rgb = terminal.colors()[index].unwrap_or_default();
let text = f(rgb);
terminal.input_no_scroll(text.into_bytes());
}
}
TermEvent::CursorBlinkingChange => {
@ -2945,11 +3066,11 @@ impl Application for App {
return self.update(Message::TabClose(Some(entity)));
}
TermEvent::PtyWrite(text) => {
if let Some(tab_model) = self.pane_model.panes.get(pane) {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let terminal = terminal.lock().unwrap();
terminal.input_no_scroll(text.into_bytes());
}
if let Some(tab_model) = self.pane_model.panes.get(pane)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let terminal = terminal.lock().unwrap();
terminal.input_no_scroll(text.into_bytes());
}
}
TermEvent::ResetTitle => {
@ -2969,12 +3090,12 @@ impl Application for App {
return self.update_title(Some(pane));
}
TermEvent::TextAreaSizeRequest(f) => {
if let Some(tab_model) = self.pane_model.panes.get(pane) {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let terminal = terminal.lock().unwrap();
let text = f(terminal.size().into());
terminal.input_no_scroll(text.into_bytes());
}
if let Some(tab_model) = self.pane_model.panes.get(pane)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let terminal = terminal.lock().unwrap();
let text = f(terminal.size().into());
terminal.input_no_scroll(text.into_bytes());
}
}
TermEvent::Title(title) => {
@ -2993,11 +3114,11 @@ impl Application for App {
return self.update_title(Some(pane));
}
TermEvent::MouseCursorDirty | TermEvent::Wakeup => {
if let Some(tab_model) = self.pane_model.panes.get(pane) {
if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
let mut terminal = terminal.lock().unwrap();
terminal.needs_update = true;
}
if let Some(tab_model) = self.pane_model.panes.get(pane)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity)
{
let mut terminal = terminal.lock().unwrap();
terminal.needs_update = true;
}
}
TermEvent::ChildExit(_error_code) => {
@ -3130,9 +3251,25 @@ impl Application for App {
return self.update_render_active_pane_zoom(message);
}
Message::ZoomReset => {
self.reset_terminal_panes_zoom();
self.reset_active_pane_zoom();
return self.update_config();
}
Message::ContextMenuPopupClosed(id) => {
if let Some((popup_id, pane, entity, _, _, _)) = &self.context_menu_popup
&& id == *popup_id
{
// Clear link underline on the terminal
if let Some(tab_model) = self.pane_model.panes.get(*pane)
&& let Some(terminal) = tab_model.data::<Mutex<Terminal>>(*entity)
{
let mut terminal = terminal.lock().unwrap();
terminal.context_menu = None;
terminal.active_regex_match = None;
terminal.needs_update = true;
}
self.context_menu_popup = None;
}
}
Message::Surface(a) => {
return cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(a),
@ -3239,7 +3376,26 @@ impl Application for App {
]
}
fn on_close_requested(&self, id: window::Id) -> Option<Self::Message> {
if let Some((popup_id, _, _, _, _, _)) = &self.context_menu_popup
&& id == *popup_id
{
return Some(Message::ContextMenuPopupClosed(id));
}
None
}
fn view_window(&self, window_id: window::Id) -> Element<'_, Message> {
if let Some((popup_id, _pane, entity, ref link, ref autosize_id, _)) =
self.context_menu_popup
&& window_id == popup_id
{
return widget::autosize::autosize(
menu::context_menu(&self.config, &self.key_binds, entity, link.clone()),
autosize_id.clone(),
)
.into();
}
match &self.dialog_opt {
Some(dialog) => dialog.view(window_id),
None => widget::text("Unknown window ID").into(),
@ -3267,7 +3423,7 @@ impl Application for App {
)
.class(style::Container::Custom(Box::new(|theme| {
let cosmic = theme.cosmic();
cosmic::iced_widget::container::Style {
cosmic::iced::widget::container::Style {
icon_color: Some(Color::from(cosmic.background.on)),
text_color: Some(Color::from(cosmic.background.on)),
background: Some(iced::Background::Color(
@ -3307,25 +3463,48 @@ impl Application for App {
terminal_box = terminal_box.on_mouse_enter(move || Message::MouseEnter(pane));
}
let context_menu = {
let terminal = terminal.lock().unwrap();
terminal.context_menu.clone()
// If a context menu popup is active for this pane, inform the
// terminal_box so it will emit on_context_menu(None) on click
// to dismiss the popup.
if self.context_menu_popup.is_some() {
terminal_box = terminal_box.context_menu(cosmic::iced::Point::ORIGIN);
}
let use_wayland_popup = {
#[cfg(feature = "wayland")]
{
is_wayland()
}
#[cfg(not(feature = "wayland"))]
{
false
}
};
let tab_element: Element<'_, Message> = match context_menu {
Some(menu_state) => match menu_state.position {
Some(point) => widget::popover(terminal_box.context_menu(point))
.popup(menu::context_menu(
&self.config,
&self.key_binds,
entity,
menu_state.link,
))
.position(widget::popover::Position::Point(point))
.into(),
None => terminal_box.into(),
},
None => terminal_box.into(),
let tab_element: Element<'_, Message> = if !use_wayland_popup {
// Fallback: render context menu as an inline popover
if let Some((_, popup_pane, popup_entity, ref link, _, point)) =
self.context_menu_popup
{
if pane == popup_pane {
let mut popover = widget::popover(terminal_box.context_menu(point));
popover = popover
.popup(menu::context_menu(
&self.config,
&self.key_binds,
popup_entity,
link.clone(),
))
.position(widget::popover::Position::Point(point));
popover.into()
} else {
terminal_box.into()
}
} else {
terminal_box.into()
}
} else {
terminal_box.into()
};
tab_column = tab_column.push(tab_element);
}
@ -3471,7 +3650,7 @@ impl Application for App {
update.errors
);
}
Message::Config(update.config)
Message::Config(Box::new(update.config))
}),
match &self.dialog_opt {
Some(dialog) => dialog.subscription(),
@ -3480,3 +3659,11 @@ impl Application for App {
])
}
}
#[cfg(feature = "wayland")]
fn is_wayland() -> bool {
matches!(
cosmic::app::cosmic::windowing_system(),
Some(cosmic::app::cosmic::WindowingSystem::Wayland)
)
}

3
src/menu.rs
View file

@ -7,8 +7,8 @@ use cosmic::widget::{Column, space};
use cosmic::{
Element,
app::Core,
iced::core::Border,
iced::{Background, Length, advanced::widget::text::Style as TextStyle},
iced_core::Border,
theme,
widget::{
self, divider,
@ -26,6 +26,7 @@ static MENU_ID: LazyLock<cosmic::widget::Id> =
#[derive(Debug, Clone)]
pub struct MenuState {
pub position: Option<Point>,
pub local_position: Option<Point>,
pub link: Option<String>,
}

127
src/password_manager.rs
View file

@ -234,10 +234,10 @@ impl PasswordManager {
}
// Don't do anything if nothing have changed
if let Some(original) = &original {
if original == &input_state.input {
return Task::none();
}
if let Some(original) = &original
&& original == &input_state.input
{
return Task::none();
}
cosmic::task::future(async move {
@ -246,19 +246,14 @@ impl PasswordManager {
"Failed to add password {identifier}: {err}"
)))
} else {
if let Some(original) = original {
if original.identifier != identifier {
if let Err(err) =
store::delete_password(original.identifier.clone()).await
{
return Message::PasswordManager(PasswordManagerMessage::Error(
format!(
"Failed to delete password {}: {err}",
original.identifier
),
));
}
}
if let Some(original) = original
&& original.identifier != identifier
&& let Err(err) = store::delete_password(original.identifier.clone()).await
{
return Message::PasswordManager(PasswordManagerMessage::Error(format!(
"Failed to delete password {}: {err}",
original.identifier
)));
}
Message::PasswordManager(PasswordManagerMessage::None)
}
@ -315,72 +310,68 @@ impl PasswordManager {
.spacing(space_xxs),
);
if expanded {
if let Some(input_state) = &self.input_state {
let expanded_section: Section<'_, Message> = widget::settings::section().add(
if expanded && let Some(input_state) = &self.input_state {
let expanded_section: Section<'_, Message> = widget::settings::section().add(
widget::column::with_children(vec![
widget::column::with_children(vec![
widget::column::with_children(vec![
widget::text(fl!("password-input-description")).into(),
widget::text_input("", input_state.input.identifier.clone())
.on_input(move |text| {
Message::PasswordManager(
PasswordManagerMessage::DescriptionInput(text),
)
})
.on_submit(move |text| {
Message::PasswordManager(
PasswordManagerMessage::DescriptionInputAndUpdate(text),
)
})
.on_unfocus(Message::PasswordManager(
PasswordManagerMessage::Update,
))
.into(),
])
.spacing(space_xxxs)
.into(),
widget::column::with_children(vec![
widget::text(fl!("password-input")).into(),
widget::secure_input(
"",
input_state.input.password.clone(),
Some(Message::PasswordManager(
PasswordManagerMessage::ToggleShowPassword,
)),
!input_state.show_password,
)
widget::text(fl!("password-input-description")).into(),
widget::text_input("", input_state.input.identifier.clone())
.on_input(move |text| {
Message::PasswordManager(PasswordManagerMessage::PasswordInput(
text,
))
Message::PasswordManager(
PasswordManagerMessage::DescriptionInput(text),
)
})
.on_submit(move |text| {
Message::PasswordManager(
PasswordManagerMessage::PasswordInputAndUpdate(text),
PasswordManagerMessage::DescriptionInputAndUpdate(text),
)
})
.on_unfocus(Message::PasswordManager(
PasswordManagerMessage::Update,
))
.into(),
])
.spacing(space_xxxs)
])
.spacing(space_xxxs)
.into(),
widget::column::with_children(vec![
widget::text(fl!("password-input")).into(),
widget::secure_input(
"",
input_state.input.password.clone(),
Some(Message::PasswordManager(
PasswordManagerMessage::ToggleShowPassword,
)),
!input_state.show_password,
)
.on_input(move |text| {
Message::PasswordManager(PasswordManagerMessage::PasswordInput(
text,
))
})
.on_submit(move |text| {
Message::PasswordManager(
PasswordManagerMessage::PasswordInputAndUpdate(text),
)
})
.on_unfocus(Message::PasswordManager(PasswordManagerMessage::Update))
.into(),
])
.padding([0, space_s])
.spacing(space_xs),
);
.spacing(space_xxxs)
.into(),
])
.padding([0, space_s])
.spacing(space_xs),
);
let padding = Padding {
top: 0.0,
bottom: 0.0,
left: space_s.into(),
right: space_s.into(),
};
let padding = Padding {
top: 0.0,
bottom: 0.0,
left: space_s.into(),
right: space_s.into(),
};
passwords_section =
passwords_section.add(widget::container(expanded_section).padding(padding))
}
passwords_section =
passwords_section.add(widget::container(expanded_section).padding(padding))
}
}
sections.push(passwords_section.into());

12
src/shortcuts.rs
View file

@ -2,8 +2,8 @@
use cosmic::widget::menu::key_bind::{KeyBind, Modifier};
use cosmic::{
iced::core::keyboard::key::Named,
iced::keyboard::{Key, Modifiers},
iced_core::keyboard::key::Named,
};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
@ -245,11 +245,11 @@ impl ShortcutsConfig {
// Remove any matching bindings
return false;
}
if let Some(default_action) = self.defaults.0.get(binding) {
if *default_action == reset_action {
// Remove binding that overrode a default
return false;
}
if let Some(default_action) = self.defaults.0.get(binding)
&& *default_action == reset_action
{
// Remove binding that overrode a default
return false;
}
true
});

79
src/terminal.rs
View file

@ -28,7 +28,8 @@ use indexmap::IndexSet;
use std::{
borrow::Cow,
collections::HashMap,
io, mem,
fs, io, mem,
path::PathBuf,
sync::{
Arc, Mutex, Weak,
atomic::{AtomicU32, Ordering},
@ -257,6 +258,7 @@ pub struct Terminal {
notifier: Notifier,
search_regex_opt: Option<RegexSearch>,
search_value: String,
shell_pid: Option<u32>,
size: Size,
use_bright_bold: bool,
zoom_adj: i8,
@ -264,6 +266,7 @@ pub struct Terminal {
impl Terminal {
//TODO: error handling
#[allow(clippy::too_many_arguments)]
pub fn new(
pane: pane_grid::Pane,
entity: segmented_button::Entity,
@ -303,13 +306,13 @@ impl Terminal {
let (cell_width, cell_height) = {
let mut font_system = font_system().write().unwrap();
let font_system = font_system.raw();
buffer.set_wrap(font_system, Wrap::None);
buffer.set_wrap(Wrap::None);
// Use size of space to determine cell size
buffer.set_text(font_system, " ", &default_attrs, Shaping::Advanced, None);
buffer.set_text(" ", &default_attrs, Shaping::Advanced, None);
let layout = buffer.line_layout(font_system, 0).unwrap();
let w = layout[0].w;
buffer.set_monospace_width(font_system, Some(w));
buffer.set_monospace_width(Some(w));
(w, metrics.line_height)
};
@ -328,6 +331,10 @@ impl Terminal {
let window_id = 0;
let pty = tty::new(&options, size.into(), window_id)?;
#[cfg(not(windows))]
let shell_pid = Some(pty.child().id());
#[cfg(windows)]
let shell_pid = pty.child_watcher().pid().map(|pid| pid.get());
let pty_event_loop =
EventLoop::new(term.clone(), event_proxy, pty, options.drain_on_exit, false)?;
@ -352,6 +359,7 @@ impl Terminal {
profile_id_opt,
search_regex_opt: None,
search_value: String::new(),
shell_pid,
size,
tab_title_override,
term,
@ -407,6 +415,19 @@ impl Terminal {
self.notifier.notify(input);
}
pub fn working_directory(&self) -> Option<PathBuf> {
#[cfg(target_os = "linux")]
{
let shell_pid = self.shell_pid?;
fs::read_link(format!("/proc/{shell_pid}/cwd")).ok()
}
#[cfg(not(target_os = "linux"))]
{
None
}
}
pub fn input_scroll<I: Into<Cow<'static, [u8]>>>(&self, input: I) {
self.input_no_scroll(input);
self.scroll(TerminalScroll::Bottom);
@ -448,8 +469,7 @@ impl Terminal {
self.term.lock().resize(self.size);
self.with_buffer_mut(|buffer| {
let mut font_system = font_system().write().unwrap();
buffer.set_size(font_system.raw(), Some(width as f32), Some(height as f32));
buffer.set_size(Some(width as f32), Some(height as f32));
});
self.needs_update = true;
@ -632,10 +652,7 @@ impl Terminal {
let metrics = config.metrics(zoom_adj);
if metrics != self.buffer.metrics() {
{
let mut font_system = font_system().write().unwrap();
self.with_buffer_mut(|buffer| buffer.set_metrics(font_system.raw(), metrics));
}
self.with_buffer_mut(|buffer| buffer.set_metrics(metrics));
update_cell_size = true;
}
@ -692,19 +709,13 @@ impl Terminal {
let (cell_width, cell_height) = {
let mut font_system = font_system().write().unwrap();
self.with_buffer_mut(|buffer| {
buffer.set_wrap(font_system.raw(), Wrap::None);
buffer.set_wrap(Wrap::None);
// Use size of space to determine cell size
buffer.set_text(
font_system.raw(),
" ",
&default_attrs,
Shaping::Advanced,
None,
);
buffer.set_text(" ", &default_attrs, Shaping::Advanced, None);
let layout = buffer.line_layout(font_system.raw(), 0).unwrap();
let w = layout[0].w;
buffer.set_monospace_width(font_system.raw(), Some(w));
buffer.set_monospace_width(Some(w));
(w, buffer.metrics().line_height)
})
};
@ -868,13 +879,12 @@ impl Terminal {
}
// Change color if selected
if let Some(selection) = &term.selection {
if let Some(range) = selection.to_range(&term) {
if range.contains(indexed.point) {
//TODO: better handling of selection
mem::swap(&mut fg, &mut bg);
}
}
if let Some(selection) = &term.selection
&& let Some(range) = selection.to_range(&term)
&& range.contains(indexed.point)
{
//TODO: better handling of selection
mem::swap(&mut fg, &mut bg);
}
// Convert foreground to linear
@ -888,10 +898,10 @@ impl Terminal {
let mut flags = indexed.cell.flags;
if let Some(active_match) = &self.active_regex_match {
if active_match.contains(&indexed.point) {
flags |= Flags::UNDERLINE;
}
if let Some(active_match) = &self.active_regex_match
&& active_match.contains(&indexed.point)
{
flags |= Flags::UNDERLINE;
}
if let Some(active_id) = &self.active_hyperlink_id {
let mut matches_active = indexed
@ -1200,13 +1210,12 @@ impl<'a, T> Iterator for HintPostProcessor<'a, T> {
fn next(&mut self) -> Option<Self::Item> {
let next_match = self.next_match.take()?;
if self.start <= self.end {
if let Some(rm) = self
if self.start <= self.end
&& let Some(rm) = self
.term
.regex_search_right(self.regex, self.start, self.end)
{
self.next_processed_match(rm);
}
{
self.next_processed_match(rm);
}
Some(next_match)

75
src/terminal_box.rs
View file

@ -10,15 +10,7 @@ use alacritty_terminal::{
use cosmic::{
Renderer,
cosmic_theme::palette::{WithAlpha, blend::Compose},
iced::{
Color, Element, Length, Padding, Point, Rectangle, Size, Vector,
advanced::graphics::text::Raw,
event::{Event, Status},
keyboard::{Event as KeyEvent, Key, Modifiers},
mouse::{self, Button, Event as MouseEvent, ScrollDelta},
window::RedrawRequest,
},
iced_core::{
iced::core::{
Border, Shell,
clipboard::Clipboard,
keyboard::key::Named,
@ -31,9 +23,16 @@ use cosmic::{
tree,
},
},
iced::{
Color, Element, Length, Padding, Point, Rectangle, Size, Vector,
advanced::graphics::text::Raw,
event::Event,
keyboard::{Event as KeyEvent, Key, Modifiers},
mouse::{self, Button, Event as MouseEvent, ScrollDelta},
},
theme::Theme,
};
use cosmic::{iced_core::SmolStr, widget::menu::key_bind::KeyBind};
use cosmic::{iced::core::SmolStr, widget::menu::key_bind::KeyBind};
use cosmic_text::LayoutGlyph;
use indexmap::IndexSet;
use std::{
@ -863,8 +862,8 @@ where
if is_mouse_mode {
state.autoscroll.stop();
} else {
if let Some((pointer, multiplier)) = state.autoscroll.next_due() {
if update_buffer_drag(
if let Some((pointer, multiplier)) = state.autoscroll.next_due()
&& update_buffer_drag(
state,
&mut terminal,
buffer_size,
@ -872,9 +871,9 @@ where
layout.bounds(),
self.padding,
multiplier,
) {
shell.capture_event();
}
)
{
shell.capture_event();
}
if state.autoscroll.is_active() {
shell.request_redraw();
@ -1300,8 +1299,13 @@ where
None,
);
let link = get_hyperlink(&terminal, location);
let abs = cosmic::iced::Point::new(
layout.bounds().x + p.x,
layout.bounds().y + p.y,
);
shell.publish(on_context_menu(Some(MenuState {
position: Some(p),
position: Some(abs),
local_position: Some(p),
link,
})));
}
@ -1314,21 +1318,20 @@ where
}
Event::Mouse(MouseEvent::ButtonReleased(Button::Left)) => {
state.autoscroll.stop();
if let Some(dragging) = state.dragging.take() {
if let Dragging::Buffer {
if let Some(dragging) = state.dragging.take()
&& let Dragging::Buffer {
last_point,
last_side,
..
} = dragging
{
{
{
let mut term = terminal.term.lock();
if let Some(selection) = &mut term.selection {
selection.update(last_point, last_side);
}
let mut term = terminal.term.lock();
if let Some(selection) = &mut term.selection {
selection.update(last_point, last_side);
}
terminal.needs_update = true;
}
terminal.needs_update = true;
}
if let Some(p) = cursor_position.position_in(layout.bounds()) {
let x = p.x - self.padding.left;
@ -1339,13 +1342,12 @@ where
let location = terminal
.viewport_to_point(TermPoint::new(row as usize, TermColumn(col as usize)));
if state.modifiers.control() {
if let Some(on_open_hyperlink) = &self.on_open_hyperlink {
if let Some(hyperlink) = get_hyperlink(&terminal, location) {
shell.publish(on_open_hyperlink(hyperlink));
shell.capture_event();
}
}
if state.modifiers.control()
&& let Some(on_open_hyperlink) = &self.on_open_hyperlink
&& let Some(hyperlink) = get_hyperlink(&terminal, location)
{
shell.publish(on_open_hyperlink(hyperlink));
shell.capture_event();
}
if is_mouse_mode {
@ -1358,8 +1360,6 @@ where
} else {
shell.capture_event();
}
} else {
shell.capture_event();
}
}
Event::Mouse(MouseEvent::ButtonReleased(_button)) => {
@ -1650,10 +1650,10 @@ fn update_active_regex_match(
.find(|bounds| bounds.contains(&location))
{
'update: {
if let Some(active_match) = &terminal.active_regex_match {
if active_match == match_ {
break 'update;
}
if let Some(active_match) = &terminal.active_regex_match
&& active_match == match_
{
break 'update;
}
terminal.active_regex_match = Some(match_.clone());
terminal.needs_update = true;
@ -1714,6 +1714,7 @@ enum EdgeScrollDirection {
Bottom,
}
#[allow(clippy::too_many_arguments)]
fn edge_scroll_adjustment(
y: f32,
buffer_height: f32,