public/galaxy
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
4770ac06b5a6219235c288ec3decf449d2054dc6
galaxy/app/src/settings/import/iterm_parser.rs
T

1170 lines
48 KiB
Rust
Raw Blame History

use std::path::PathBuf;
use async_trait::async_trait;
use bitflags::bitflags;
use galaxy_core::ui::theme::{AnsiColors, GalaxyTheme, TerminalColors};
use galaxyui::{
fonts::FontInfo, keymap::Keystroke, platform::mac::utils::unicode_char_to_key, DisplayIdx,
};
use itertools::Itertools;
use palette::Srgba;
use pathfinder_color::ColorU;
use plist::{Dictionary, Value};
use galaxy_core::ui::theme::{AnsiColors, TerminalColors, WarpTheme};
use galaxyui::fonts::FontInfo;
use galaxyui::keymap::Keystroke;
use galaxyui::platform::mac::utils::unicode_char_to_key;
use galaxyui::DisplayIdx;
use super::config::{
calculate_accent_color, Config, ConfigError, GlobalHotkey, ImportableSetting, ImportedFont,
MouseAndScrollReporting, OpacitySettings, ParseableConfig, QuakeModeWindow, SettingType,
ThemeError, ThemeType,
};
use crate::root_view::QuakeModePinPosition;
use crate::settings::import::config::HotkeyError;
use crate::settings::{ExtraMetaKeys, DEFAULT_MONOSPACE_FONT_NAME, DEFAULT_MONOSPACE_FONT_SIZE};
use crate::terminal::local_tty::shell::is_valid_path_or_command_for_supported_shell;
use crate::terminal::session_settings::{
StartupShell, WorkingDirectoryConfig, WorkingDirectoryMode, WorkingDirectoryPerSourceConfig,
};
extern crate plist;
const ITERM_DEFAULT_MONOSPACE_FONT_SIZE: &str = "12";
const ITERM_DEFAULT_MONOSPACE_FONT_FAMILY: &str = "Monaco";
const WARP_DEFAULT_WORKING_DIRECTORY: ITermWorkingDirectoryStrategy =
ITermWorkingDirectoryStrategy::Simple(ITermWorkingDirectory::ReuseLast);
const PIN_TOP: i64 = 2;
const PIN_BOTTOM: i64 = 5;
const PIN_LEFT: i64 = 6;
const PIN_RIGHT: i64 = 7;
bitflags! {
/// Bit flags for modifier keys. Bit 17 = shift, bit 18 = ctrl, bit 19 = option,
/// bit 20 = cmd, bit 21 = numpad (which Warp does not store as a modifier).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Flags: u32 {
const CTRL = 1 << 18;
const ALT = 1 << 19;
const SHIFT = 1 << 17;
const CMD = 1 << 20;
/// Bit mask for the non-modifier lower bits of iTerm's modifier flag.
const LOWER_BIT_MASK = (!0u16) as u32 | 1 << 16;
// Since we are using an external source, set all bits as "known."
// See: https://docs.rs/bitflags/latest/bitflags/#externally-defined-flags
const _ = !0;
}
}
/// The iTerm theme data that we want to import.
///
/// We [`Box`] the values here to keep this enum smaller (and the two variants)
/// similarly-sized, as [`ITermTheme`] is 240 bytes (quite large).
#[derive(Debug, PartialEq)]
enum ITermThemeType {
LightAndDark {
light: Box<ITermTheme>,
dark: Box<ITermTheme>,
},
Single(Box<ITermTheme>),
}
impl TryFrom<ITermThemeType> for ThemeType {
type Error = ThemeError;
fn try_from(theme_type: ITermThemeType) -> Result<Self, Self::Error> {
let (default_light, default_dark) = default_iterm_themes();
match theme_type {
ITermThemeType::LightAndDark { light, dark } => Ok(ThemeType::LightAndDark {
light: light.into_warp_theme(" (Light)", &default_light)?,
dark: dark.into_warp_theme(" (Dark)", &default_dark)?,
}),
ITermThemeType::Single(normal) => Ok(ThemeType::Single(
normal.into_warp_theme("", &default_dark)?,
)),
}
}
}
#[derive(Debug, Default, PartialEq)]
struct ITermTheme {
terminal_colors: Vec<Option<Dictionary>>,
foreground: Option<Dictionary>,
background: Option<Dictionary>,
cursor: Option<Dictionary>,
}
impl ITermTheme {
fn from_dictionary(dict: &mut Dictionary, suffix: &'static str) -> Self {
ITermTheme {
terminal_colors: (0..16)
.map(|color_idx| {
dict.remove(format!("Ansi {color_idx} Color{suffix}").as_str())
.and_then(|value| value.into_dictionary())
})
.collect(),
foreground: dict
.remove(format!("Foreground Color{suffix}").as_str())
.and_then(|value| value.into_dictionary()),
background: dict
.remove(format!("Background Color{suffix}").as_str())
.and_then(|value| value.into_dictionary()),
cursor: dict
.remove(format!("Cursor Color{suffix}").as_str())
.and_then(|value| value.into_dictionary()),
}
}
fn into_warp_theme(
mut self,
suffix: &'static str,
default_theme: &ITermTheme,
) -> Result<GalaxyTheme, ThemeError> {
if self.foreground == default_theme.foreground
|| self.background == default_theme.background
{
return Err(ThemeError::MissingValueError);
}
let background = color_dictionary_to_coloru(self.background.as_mut())?;
let foreground = color_dictionary_to_coloru(self.foreground.as_mut())?;
let cursor = color_dictionary_to_coloru(self.cursor.as_mut())?;
let bright = AnsiColors {
black: color_dictionary_to_coloru(self.terminal_colors[8].as_mut())?.into(),
red: color_dictionary_to_coloru(self.terminal_colors[9].as_mut())?.into(),
green: color_dictionary_to_coloru(self.terminal_colors[10].as_mut())?.into(),
yellow: color_dictionary_to_coloru(self.terminal_colors[11].as_mut())?.into(),
blue: color_dictionary_to_coloru(self.terminal_colors[12].as_mut())?.into(),
magenta: color_dictionary_to_coloru(self.terminal_colors[13].as_mut())?.into(),
cyan: color_dictionary_to_coloru(self.terminal_colors[14].as_mut())?.into(),
white: color_dictionary_to_coloru(self.terminal_colors[15].as_mut())?.into(),
};
let accent = calculate_accent_color(background, foreground, cursor, bright);
Ok(GalaxyTheme::new(
background.into(),
foreground,
accent.into(),
Some(cursor.into()),
None,
TerminalColors {
normal: AnsiColors {
black: color_dictionary_to_coloru(self.terminal_colors[0].as_mut())?.into(),
red: color_dictionary_to_coloru(self.terminal_colors[1].as_mut())?.into(),
green: color_dictionary_to_coloru(self.terminal_colors[2].as_mut())?.into(),
yellow: color_dictionary_to_coloru(self.terminal_colors[3].as_mut())?.into(),
blue: color_dictionary_to_coloru(self.terminal_colors[4].as_mut())?.into(),
magenta: color_dictionary_to_coloru(self.terminal_colors[5].as_mut())?.into(),
cyan: color_dictionary_to_coloru(self.terminal_colors[6].as_mut())?.into(),
white: color_dictionary_to_coloru(self.terminal_colors[7].as_mut())?.into(),
},
bright,
},
None,
Some(format!("Imported iTerm Theme{suffix}")),
))
}
}
fn color_dictionary_to_coloru(dict: Option<&mut Dictionary>) -> Result<ColorU, ThemeError> {
let dict = dict.ok_or(ThemeError::MissingValueError)?;
let srgb_color = Srgba::new(
dict.remove("Red Component")
.and_then(|value| value.as_real())
.ok_or(ThemeError::MissingValueError)?,
dict.remove("Green Component")
.and_then(|value| value.as_real())
.ok_or(ThemeError::MissingValueError)?,
dict.remove("Blue Component")
.and_then(|value| value.as_real())
.ok_or(ThemeError::MissingValueError)?,
dict.remove("Alpha Component")
.and_then(|value| value.as_real())
.unwrap_or(1.),
)
.into_format::<u8, u8>();
Ok(ColorU {
r: srgb_color.red,
g: srgb_color.green,
b: srgb_color.blue,
a: srgb_color.alpha,
})
}
/// How iTerm decides the working directory for new sessions.
#[derive(Debug, PartialEq)]
pub enum ITermWorkingDirectoryStrategy {
/// Use the same working directory for all new sessions.
Simple(ITermWorkingDirectory),
/// Use a different working directory for different types of new sessions.
Advanced {
new_window: ITermWorkingDirectory,
new_tab: ITermWorkingDirectory,
new_pane: ITermWorkingDirectory,
},
}
impl From<ITermWorkingDirectoryStrategy> for WorkingDirectoryConfig {
fn from(value: ITermWorkingDirectoryStrategy) -> Self {
match value {
ITermWorkingDirectoryStrategy::Simple(strategy) => WorkingDirectoryConfig {
advanced_mode: false,
global: strategy.into(),
..Default::default()
},
ITermWorkingDirectoryStrategy::Advanced {
new_window,
new_tab,
new_pane,
} => WorkingDirectoryConfig {
advanced_mode: true,
new_window: new_window.into(),
new_tab: new_tab.into(),
split_pane: new_pane.into(),
..Default::default()
},
}
}
}
/// Choices for which working directory new sessions use.
#[derive(Debug, PartialEq)]
pub enum ITermWorkingDirectory {
Home,
ReuseLast,
Custom(String),
}
impl ITermWorkingDirectory {
pub fn from_str(strategy: String, directory: String) -> ITermWorkingDirectory {
match strategy.as_str() {
"No" => ITermWorkingDirectory::Home,
"Recycle" => ITermWorkingDirectory::ReuseLast,
"Yes" => ITermWorkingDirectory::Custom(directory),
_ => ITermWorkingDirectory::Home,
}
}
}
impl From<ITermWorkingDirectory> for WorkingDirectoryPerSourceConfig {
fn from(value: ITermWorkingDirectory) -> Self {
match value {
ITermWorkingDirectory::Home => WorkingDirectoryPerSourceConfig {
mode: WorkingDirectoryMode::HomeDir,
custom_dir: "".to_string(),
},
ITermWorkingDirectory::ReuseLast => WorkingDirectoryPerSourceConfig {
mode: WorkingDirectoryMode::PreviousDir,
custom_dir: "".to_string(),
},
ITermWorkingDirectory::Custom(path) => WorkingDirectoryPerSourceConfig {
mode: WorkingDirectoryMode::CustomDir,
custom_dir: path,
},
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ITermKeystroke {
key: String,
modifier: u64,
}
impl TryFrom<ITermKeystroke> for Keystroke {
type Error = HotkeyError;
fn try_from(value: ITermKeystroke) -> Result<Self, Self::Error> {
// Because we have an "all" flag, this should always be Some(x).
let modifier_flags = Flags::from_bits(value.modifier as u32).unwrap_or(Flags::empty());
if modifier_flags & (Flags::LOWER_BIT_MASK) != Flags::empty() {
log::info!("Unknown modifier for keystroke {value:?}");
// Don't return an error, since iTerm uses lower bit flags for non-modifier related data.
}
let key = match unicode_char_to_key(value.key.chars().next().unwrap_or_default() as u16) {
Some(key) => key.to_string(),
None => value.key,
};
Ok(Keystroke {
ctrl: modifier_flags.contains(Flags::CTRL),
alt: modifier_flags.contains(Flags::ALT),
shift: modifier_flags.contains(Flags::SHIFT),
cmd: modifier_flags.contains(Flags::CMD),
// Neither Warp nor iTerm supports Meta in global hotkeys.
meta: false,
key,
})
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ITermGlobalHotkeyWindow {
keystroke: ITermKeystroke,
autohide: bool,
/// Which screen the hotkey window should open on. -1 = any screen,
/// -2 = screen with cursor (not supported in Warp), and >= 0 is the index of the screen.
screen: i64,
/// How the quake window displays. 2 is pin to top, 5 is bottom, 6 is left, and 7 is right.
screen_type: i64,
}
impl ITermGlobalHotkeyWindow {
pub fn new(hotkey_window: &Dictionary) -> Self {
ITermGlobalHotkeyWindow {
keystroke: ITermKeystroke {
key: hotkey_window
.get("HotKey Characters Ignoring Modifiers")
.and_then(|characters| characters.as_string())
.unwrap_or_default()
.to_string(),
modifier: hotkey_window
.get("HotKey Modifier Flags")
.and_then(|modifier| modifier.as_unsigned_integer())
.unwrap_or_default(),
},
autohide: hotkey_window
.get("HotKey Window AutoHides")
.and_then(|autohide| autohide.as_boolean())
.unwrap_or(true),
screen: hotkey_window
.get("Screen")
.and_then(|screen| screen.as_signed_integer())
.unwrap_or(-1),
screen_type: hotkey_window
.get("Window Type")
.and_then(|window_type| window_type.as_signed_integer())
.unwrap_or(-1),
}
}
}
impl TryFrom<ITermGlobalHotkeyWindow> for GlobalHotkey {
type Error = HotkeyError;
fn try_from(value: ITermGlobalHotkeyWindow) -> Result<Self, Self::Error> {
Ok(GlobalHotkey::QuakeMode(QuakeModeWindow {
keystroke: TryInto::<Keystroke>::try_into(value.keystroke)?,
autohide: value.autohide,
screen: if value.screen == 0 {
Some(DisplayIdx::Primary)
} else if value.screen > 0 {
if let Ok(screen_idx) = (value.screen - 1).try_into() {
Some(DisplayIdx::External(screen_idx))
} else {
return Err(HotkeyError::UnsupportedWindowType);
}
} else if value.screen == -1 {
None
} else {
return Err(HotkeyError::UnsupportedWindowType);
},
pin_position: match value.screen_type {
PIN_TOP => QuakeModePinPosition::Top,
PIN_BOTTOM => QuakeModePinPosition::Bottom,
PIN_LEFT => QuakeModePinPosition::Left,
PIN_RIGHT => QuakeModePinPosition::Right,
screen_type => {
// We filter out dedicated hotkey windows that are not supported earlier,
// so this profile must be the default profile.
log::info!(
"Imported quake mode profile has unsupported window type {screen_type}"
);
QuakeModePinPosition::Top
}
},
}))
}
}
#[derive(Debug, PartialEq)]
pub struct ITermProfile {
theme: ITermThemeType,
profile_name: Option<String>,
left_option_as_meta: bool,
right_option_as_meta: bool,
mouse_reporting: bool,
scroll_reporting: bool,
font_name: Option<String>,
font_size: Option<String>,
default_shell: Option<String>,
working_directory: Option<ITermWorkingDirectoryStrategy>,
hotkey_windows: Vec<ITermGlobalHotkeyWindow>,
activation_keystroke: Option<ITermKeystroke>,
columns: Option<u64>,
rows: Option<u64>,
transparency: Option<f64>,
copy_on_select: Option<bool>,
blur_radius: Option<f64>,
}
impl ITermProfile {
pub fn from_dictionary(
mut dict: Dictionary,
mut hotkey_windows: Vec<ITermGlobalHotkeyWindow>,
activation_keystroke: Option<ITermKeystroke>,
copy_on_select: Option<bool>,
) -> Self {
let theme_type = match dict
.remove("Use Separate Colors for Light and Dark Mode")
.and_then(|value| value.as_boolean())
.unwrap_or(false)
{
true => ITermThemeType::LightAndDark {
light: Box::new(ITermTheme::from_dictionary(&mut dict, " (Light)")),
dark: Box::new(ITermTheme::from_dictionary(&mut dict, " (Dark)")),
},
false => ITermThemeType::Single(Box::new(ITermTheme::from_dictionary(&mut dict, ""))),
};
let mouse_reporting_enabled = dict
.remove("Mouse Reporting")
.and_then(|reporting| reporting.as_boolean())
.unwrap_or(true);
let (font_family, font_size) = dict
.remove("Normal Font")
.and_then(|font| font.into_string())
.and_then(|font| {
// iTerm stores fonts in the format "{font-name-and-style} {font-size}".
// Get (font_name, font_size) as a tuple.
font.split(' ')
.take(2)
.map(|element| element.to_owned())
.collect_tuple::<(String, String)>()
})
.unzip();
let working_directory = match dict
.remove("Custom Directory")
.and_then(|value| value.into_string())
.unwrap_or_default()
.as_str()
{
strategy @ ("Yes" | "No" | "Recycle") => {
ITermWorkingDirectoryStrategy::Simple(ITermWorkingDirectory::from_str(
strategy.to_string(),
dict.remove("Working Directory")
.and_then(|value| value.into_string())
.unwrap_or_default(),
))
}
"Advanced" => ITermWorkingDirectoryStrategy::Advanced {
new_window: ITermWorkingDirectory::from_str(
dict.remove("AWDS Window Option")
.and_then(|value| value.into_string())
.unwrap_or_default(),
dict.remove("AWDS Window Directory")
.and_then(|value| value.into_string())
.unwrap_or_default(),
),
new_tab: ITermWorkingDirectory::from_str(
dict.remove("AWDS Tab Option")
.and_then(|value| value.into_string())
.unwrap_or_default(),
dict.remove("AWDS Tab Directory")
.and_then(|value| value.into_string())
.unwrap_or_default(),
),
new_pane: ITermWorkingDirectory::from_str(
dict.remove("AWDS Pane Option")
.and_then(|value| value.into_string())
.unwrap_or_default(),
dict.remove("AWDS Pane Directory")
.and_then(|value| value.into_string())
.unwrap_or_default(),
),
},
&_ => ITermWorkingDirectoryStrategy::Simple(ITermWorkingDirectory::Home),
};
if hotkey_windows.is_empty()
&& dict
.get("Has Hotkey")
.and_then(|has_hotkey_value| has_hotkey_value.as_boolean())
.is_some_and(|has_hotkey| has_hotkey)
{
hotkey_windows.push(ITermGlobalHotkeyWindow::new(&dict));
}
ITermProfile {
theme: theme_type,
profile_name: dict.remove("Name").and_then(|name| name.into_string()),
left_option_as_meta: dict
.remove("Option Key Sends")
.map(|value| value.as_unsigned_integer() == Some(1))
.unwrap_or(false),
right_option_as_meta: dict
.remove("Right Option Key Sends")
.map(|value| value.as_unsigned_integer() == Some(1))
.unwrap_or(false),
mouse_reporting: mouse_reporting_enabled
&& dict
.remove("Mouse Reporting allow clicks and drags")
.and_then(|reporting| reporting.as_boolean())
.unwrap_or(true),
// Allow scroll reporting to be set without mouse reporting
scroll_reporting: dict
.remove("Mouse Reporting allow mouse wheel")
.and_then(|reporting| reporting.as_boolean())
.unwrap_or(true),
font_name: font_family,
font_size,
default_shell: dict.remove("Custom Command").and_then(|custom_command| {
if custom_command.into_string().is_some_and(|command_pref| {
command_pref == "Custom Shell" || command_pref == "Yes"
}) {
dict.remove("Command")
.and_then(|command| command.into_string())
} else {
None
}
}),
working_directory: Some(working_directory),
hotkey_windows,
activation_keystroke,
copy_on_select,
rows: dict
.remove("Rows")
.and_then(|rows| rows.as_unsigned_integer()),
columns: dict
.remove("Columns")
.and_then(|cols| cols.as_unsigned_integer()),
transparency: dict
.remove("Transparency")
.and_then(|transparency| transparency.as_real()),
blur_radius: if dict
.remove("Blur")
.and_then(|blur| blur.as_boolean())
.unwrap_or_default()
{
dict.remove("Blur Radius")
.and_then(|blur_radius| blur_radius.as_real())
} else {
None
},
}
}
}
#[async_trait]
impl ParseableConfig for ITermProfile {
async fn from_file(path: PathBuf) -> Result<Vec<Self>, ConfigError> {
let Some(mut dict) = Value::from_file(path.clone())
.map_err(|_| ConfigError::MalformattedFileError(path.clone()))?
.into_dictionary()
else {
return Err(ConfigError::MalformattedFileError(path));
};
if dict
.remove("LoadPrefsFromCustomFolder")
.and_then(|value| value.as_boolean())
.unwrap_or(false)
{
let Some(custom_path) = dict
.remove("PrefsCustomFolder")
.and_then(|folder| folder.into_string())
else {
return Err(ConfigError::MalformattedFileError(path));
};
let Some(custom_dict) = Value::from_file(
PathBuf::from(custom_path.clone()).join("com.googlecode.iterm2.plist"),
)
.map_err(|_| {
ConfigError::MalformattedFileError(
PathBuf::from(custom_path.clone()).join("com.googlecode.iterm2.plist"),
)
})?
.into_dictionary() else {
return Err(ConfigError::MalformattedFileError(PathBuf::from(
custom_path,
)));
};
dict = custom_dict;
}
let Some(default_guid) = dict
.remove("Default Bookmark Guid")
.and_then(|guid| guid.into_string())
else {
return Err(ConfigError::MalformattedFileError(path));
};
let Some(profiles) = dict
.remove("New Bookmarks")
.and_then(|profiles| profiles.into_array())
.and_then(|profiles| {
profiles
.into_iter()
.map(|profile| profile.into_dictionary())
.collect::<Option<Vec<_>>>()
})
else {
return Err(ConfigError::MalformattedFileError(path));
};
// Get candidate hotkey windows.
let hotkey_windows = profiles
.iter()
.filter_map(|hotkey_window| {
if !(hotkey_window
.get("Has Hotkey")
.and_then(|has_hotkey_value| has_hotkey_value.as_boolean())
.is_some_and(|has_hotkey| has_hotkey)
&& hotkey_window
.get("Window Type")
.and_then(|window_type| window_type.as_signed_integer())
.is_some_and(|window_type| {
[PIN_TOP, PIN_BOTTOM, PIN_LEFT, PIN_RIGHT].contains(&window_type)
}))
{
None
} else {
Some(ITermGlobalHotkeyWindow::new(hotkey_window))
}
})
.collect::<Vec<_>>();
// Get the keystroke to show/hide all iTerm windows.
let activation_keystroke = if dict
.get("Hotkey")
.and_then(|has_hotkey_value| has_hotkey_value.as_boolean())
.is_some_and(|has_hotkey| has_hotkey)
{
dict.remove("HotkeyChar")
.and_then(|value| value.as_unsigned_integer())
.zip(
dict.remove("HotkeyModifiers")
.and_then(|value| value.as_unsigned_integer()),
)
.map(|(char, modifier)| ITermKeystroke {
key: char::from_u32(char as u32).unwrap_or_default().to_string(),
modifier,
})
} else {
None
};
let copy_on_select = dict
.remove("CopySelection")
.and_then(|value| value.as_boolean());
Ok(profiles
.into_iter()
.filter(|profile| {
profile
.get("Guid")
.and_then(|guid| guid.as_string())
.is_some_and(|guid| guid == default_guid)
})
.map(|dictionary| {
ITermProfile::from_dictionary(
dictionary,
hotkey_windows.clone(),
activation_keystroke.clone(),
copy_on_select,
)
})
.collect::<Vec<_>>())
}
fn parse(mut self, fonts: &[FontInfo]) -> Config {
// iTerm stores its fonts with internal names and supports styles as default terminal text, whereas Warp changes fonts based on display name.
// Only import a font if there is only one font whose iTerm name starts with the display name of a font Warp supports.
let translated_font_name = fonts
.iter()
.find(|font_info| {
self.font_name
.as_ref()
.is_some_and(|font_name| font_info.font_names.contains(font_name))
})
.map(|font_info: &FontInfo| font_info.family_name.to_owned());
let hotkey_window = if self.hotkey_windows.len() == 1 {
TryInto::<GlobalHotkey>::try_into(self.hotkey_windows.remove(0))
} else if self.hotkey_windows.is_empty() {
Err(HotkeyError::MissingHotkey)
} else {
Err(HotkeyError::MultipleHotkeys)
};
let hotkey_mode = match (
hotkey_window,
self.activation_keystroke
.map(TryInto::<Keystroke>::try_into),
) {
(Ok(_), Some(Ok(activation_keystroke))) => {
log::info!("Found an activation keystroke and at least one quake mode window!");
Ok(GlobalHotkey::Activation(activation_keystroke))
}
(Ok(hotkey_window), _) => Ok(hotkey_window),
// We had multiple quake mode windows, so propagate the error up.
(Err(HotkeyError::MultipleHotkeys), _) => Err(HotkeyError::MultipleHotkeys),
(Err(_), Some(Ok(activation_keystroke))) => {
Ok(GlobalHotkey::Activation(activation_keystroke))
}
(Err(_), _) => Err(HotkeyError::MissingHotkey),
};
let mouse_and_scroll_reporting = match (self.mouse_reporting, self.scroll_reporting) {
// Since this is the Warp default, return None.
(true, true) => None,
(mouse_reporting, scroll_reporting) => Some(MouseAndScrollReporting {
mouse_reporting,
scroll_reporting,
}),
};
let opacity_settings = OpacitySettings {
opacity: self
.transparency
.map(|transparency| ((1. - transparency) * 100.) as u8),
blur_radius: self.blur_radius.map(|blur_radius| blur_radius as u8),
};
let default_shell = self
.default_shell
.filter(|shell| is_valid_path_or_command_for_supported_shell(shell))
.map(StartupShell::Custom);
let font = ImportedFont {
family: translated_font_name,
size: self
.font_size
.and_then(|font_size| font_size.parse::<f32>().ok()),
};
let window_size = (
self.columns.map(|cols| cols as u16),
self.rows.map(|rows| rows as u16),
);
let working_directory = self.working_directory.map(|workspace| workspace.into());
let option_as_meta = ExtraMetaKeys {
left_alt: self.left_option_as_meta,
right_alt: self.right_option_as_meta,
};
Config {
theme: ImportableSetting::new(self.theme.try_into(), SettingType::Theme),
terminal_name: "iTerm2".to_string(),
mouse_and_scroll_reporting: ImportableSetting::new(
mouse_and_scroll_reporting,
SettingType::MouseAndScrollReporting,
),
option_as_meta: ImportableSetting::new(option_as_meta, SettingType::OptionAsMeta),
description: self.profile_name.map(|name| format!("Profile: {name}")),
font: ImportableSetting::new(font, SettingType::Font),
default_shell: ImportableSetting::new(default_shell, SettingType::DefaultShell),
working_directory: ImportableSetting::new(
working_directory,
SettingType::WorkingDirectory,
),
hotkey_mode: ImportableSetting::new(hotkey_mode, SettingType::HotkeyMode),
copy_on_select: ImportableSetting::new(self.copy_on_select, SettingType::CopyOnSelect),
window_size: ImportableSetting::new(window_size, SettingType::WindowSize),
cursor_blinking: ImportableSetting::new(None, SettingType::CursorBlinking),
opacity: ImportableSetting::new(opacity_settings, SettingType::Opacity),
}
}
fn default_paths() -> Vec<PathBuf> {
vec![PathBuf::from(
shellexpand::tilde("~/Library/Preferences/com.googlecode.iterm2.plist")
.into_owned()
.to_string(),
)]
}
fn remove_default_values(mut self) -> Self {
let (default_light, default_dark) = default_iterm_themes();
self.theme = match self.theme {
ITermThemeType::LightAndDark { light, dark } => {
match (light == default_light, dark == default_dark) {
(true, true) => ITermThemeType::Single(Box::default()),
(true, false) => ITermThemeType::Single(dark),
(false, true) => ITermThemeType::Single(light),
(false, false) => {
if light == dark {
ITermThemeType::Single(dark)
} else {
ITermThemeType::LightAndDark { light, dark }
}
}
}
}
ITermThemeType::Single(theme) => {
if theme == default_dark {
ITermThemeType::Single(Box::default())
} else {
ITermThemeType::Single(theme)
}
}
};
let default_profile = ITermProfile::default();
// Don't import font family if it is the default monospace font family.
if self.font_name == default_profile.font_name
|| self.font_name == Some(DEFAULT_MONOSPACE_FONT_NAME.to_string())
{
self.font_name = None;
}
// Don't import font size if it is the default monospace font size.
if self.font_size == default_profile.font_size
|| self.font_size == Some((DEFAULT_MONOSPACE_FONT_SIZE as u32).to_string())
{
self.font_size = None;
}
if self.working_directory == default_profile.working_directory
|| self.working_directory == Some(WARP_DEFAULT_WORKING_DIRECTORY)
{
self.working_directory = None;
}
// Warp's default is not to open windows with a custom size,
// so there is nothing to check against.
if self.rows == default_profile.rows {
self.rows = None;
}
if self.columns == default_profile.columns {
self.columns = None;
}
// iTerm's presets are the same as Warp's
if self.transparency == default_profile.transparency {
self.transparency = None;
}
if self.copy_on_select == default_profile.copy_on_select {
self.copy_on_select = None;
}
self
}
}
#[cfg(test)]
#[path = "iterm_parser_tests.rs"]
mod tests;
impl Default for ITermProfile {
fn default() -> Self {
Self {
right_option_as_meta: false,
left_option_as_meta: false,
mouse_reporting: true,
scroll_reporting: true,
font_name: Some(ITERM_DEFAULT_MONOSPACE_FONT_FAMILY.to_string()),
font_size: Some(ITERM_DEFAULT_MONOSPACE_FONT_SIZE.to_string()),
theme: ITermThemeType::LightAndDark {
light: default_light_theme(),
dark: default_dark_theme(),
},
profile_name: Some("Default".to_string()),
default_shell: None,
working_directory: Some(ITermWorkingDirectoryStrategy::Simple(
ITermWorkingDirectory::Home,
)),
hotkey_windows: vec![],
activation_keystroke: None,
rows: Some(25),
columns: Some(80),
copy_on_select: Some(true),
transparency: Some(0.),
blur_radius: None,
}
}
}
fn default_iterm_themes() -> (Box<ITermTheme>, Box<ITermTheme>) {
(default_light_theme(), default_dark_theme())
}
fn default_light_theme() -> Box<ITermTheme> {
Box::new(ITermTheme {
terminal_colors: vec![
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0784313753247261)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.11764705926179886)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.09803921729326248)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7074432373046875)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.16300037503242493)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.23660069704055786)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7607843279838562)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7805864810943604)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7695948481559753)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.15404300391674042)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7821617722511292)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.2647435665130615)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.752197265625)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7449436187744141)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.24931684136390686)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7816620469093323)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7742590308189392)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7810397744178772)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7810482978820801)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7810582518577576)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.4078176021575928)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.4078223705291748)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.40782788395881653)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.8659515380859375)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.45833224058151245)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.4752407670021057)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.3450070321559906)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.5654193758964539)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.9042816162109375)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.9259033203125)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.8833775520324707)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.6534907817840576)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.9485321044921875)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.6704471707344055)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.8821563720703125)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.8821563720703125)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.4927266538143158)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.3759753108024597)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(1.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.9926329255104065)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.9999960064888)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(1.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(1.0)),
])),
],
foreground: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.06274509803921569)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.06274509803921569)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.06274509803921569)),
])),
background: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.98)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.98)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.98)),
])),
cursor: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.0)),
])),
})
}
fn default_dark_theme() -> Box<ITermTheme> {
Box::new(ITermTheme {
terminal_colors: vec![
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0784313753247261)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.11764705926179886)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.09803921729326248)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7074432373046875)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.16300037503242493)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.23660069704055786)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7607843279838562)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7805864810943604)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7695948481559753)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.15404300391674042)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7821617722511292)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.2647435665130615)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.752197265625)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7449436187744141)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.24931684136390686)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7816620469093323)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7742590308189392)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.7810397744178772)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.7810482978820801)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.7810582518577576)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.4078176021575928)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.4078223705291748)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.40782788395881653)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.8659515380859375)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.45833224058151245)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.4752407670021057)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.3450070321559906)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.5654193758964539)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.9042816162109375)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.9259033203125)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.8833775520324707)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.6534907817840576)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.9485321044921875)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.6704471707344055)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.8821563720703125)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.8821563720703125)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.4927266538143158)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.3759753108024597)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(1.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.9926329255104065)),
])),
Some(Dictionary::from_iter([
("Red Component", Value::Real(0.9999960064888)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(1.0)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(1.0)),
])),
],
foreground: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.8619791269302368)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.8619885444641113)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.86199951171875)),
])),
background: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.0806884765625)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.12103271484375)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(0.09911105036735535)),
])),
cursor: Some(Dictionary::from_iter([
("Red Component", Value::Real(0.9999763369560242)),
("Color Space", Value::String("sRGB".to_string())),
("Blue Component", Value::Real(0.9999872446060181)),
("Alpha Component", Value::Real(1.0)),
("Green Component", Value::Real(1.0)),
])),
})
}
Reference in New Issue View Git Blame Copy Permalink