diff --git a/Cargo.lock b/Cargo.lock
index b6648bc..aa06a2c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -571,6 +571,25 @@ dependencies = [
"crossbeam-utils",
]
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
+dependencies = [
+ "crossbeam-utils",
+]
+
[[package]]
name = "crossbeam-utils"
version = "0.8.23"
@@ -1339,11 +1358,20 @@ name = "ghostty-renderer"
version = "0.1.0"
dependencies = [
"bytemuck",
+ "crossbeam-channel",
+ "ghostty-config",
"ghostty-font",
+ "ghostty-input",
+ "ghostty-terminal",
+ "ghostty-unicode",
+ "ghostty-vt",
"glow",
+ "jpeg-decoder",
"khronos-egl",
"log",
"naga",
+ "onig",
+ "png",
"thiserror 2.0.21",
]
@@ -1838,6 +1866,15 @@ dependencies = [
"syn 2.0.119",
]
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
+dependencies = [
+ "rayon",
+]
+
[[package]]
name = "js-sys"
version = "0.3.106"
@@ -2777,6 +2814,26 @@ dependencies = [
"unicode-width",
]
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
[[package]]
name = "redox_syscall"
version = "0.5.18"
diff --git a/Cargo.toml b/Cargo.toml
index 0822470..144a8a9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,6 +38,8 @@ ghostty-os = { path = "crates/ghostty-os" }
ghostty-datastruct = { path = "crates/ghostty-datastruct" }
ghostty-core = { path = "crates/ghostty-core" }
ghostty-apprt-gtk = { path = "crates/ghostty-apprt-gtk" }
+ghostty-apprt = { path = "crates/ghostty-apprt" }
+ghostty-cli = { path = "crates/ghostty-cli" }
[workspace.lints.rust]
unsafe_code = "forbid"
diff --git a/crates/ghostty-apprt-gtk/Cargo.toml b/crates/ghostty-apprt-gtk/Cargo.toml
index 14f8b80..f87b682 100644
--- a/crates/ghostty-apprt-gtk/Cargo.toml
+++ b/crates/ghostty-apprt-gtk/Cargo.toml
@@ -3,11 +3,64 @@ name = "ghostty-apprt-gtk"
version.workspace = true
edition.workspace = true
license.workspace = true
+build = "build.rs"
[dependencies]
-ghostty-core.workspace = true
+ghostty-apprt.workspace = true
ghostty-config.workspace = true
ghostty-input.workspace = true
+ghostty-datastruct.workspace = true
+ghostty-os.workspace = true
+ghostty-vt.workspace = true
+log = "0.4"
+thiserror = "2"
+bitflags = "2"
+gtk = { package = "gtk4", version = "0.11", features = ["v4_14", "gnome_44"] }
+adw = { package = "libadwaita", version = "0.9", features = ["v1_5"] }
+gtk4-layer-shell = "0.8"
+gdk4-x11 = { version = "0.11.5", features = ["x11", "xlib"] }
+gdk4-wayland = { version = "0.11.5", features = ["wayland_crate"] }
+wayland-client = "0.31.15"
+wayland-protocols-plasma = { version = "0.3.12", features = ["client"] }
+wayland-protocols = { version = "0.32.13", features = ["client", "staging"] }
+wayland-backend = { version = "0.3.17", features = ["client_system"] }
+half = "2"
+libc = "0.2.190"
+signal-hook = "0.4.5"
+libloading = "0.9.0"
-[lints]
-workspace = true
+[build-dependencies]
+glib-build-tools = "0.22"
+
+[dev-dependencies]
+env_logger = "0.11"
+glow = "0.18"
+
+[lints.rust]
+unsafe_code = "deny"
+
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+todo = "warn"
+unwrap_used = "warn"
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_sign_loss = "allow"
+cast_precision_loss = "allow"
+cast_lossless = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+similar_names = "allow"
+struct_excessive_bools = "allow"
+fn_params_excessive_bools = "allow"
+match_same_arms = "allow"
+unreadable_literal = "allow"
+many_single_char_names = "allow"
+doc_markdown = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+used_underscore_binding = "allow"
+large_stack_arrays = "allow"
+inline_always = "allow"
diff --git a/crates/ghostty-apprt-gtk/build.rs b/crates/ghostty-apprt-gtk/build.rs
new file mode 100644
index 0000000..ce94ff3
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/build.rs
@@ -0,0 +1,111 @@
+//! Compiles the blueprint UI files with `blueprint-compiler` and bundles them
+//! (plus CSS and icons) into a GResource, mirroring
+//! ZIG/src/apprt/gtk/build/{blueprint,gresource}.zig.
+
+#![allow(clippy::unwrap_used)]
+use std::fmt::Write as _;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const PREFIX: &str = "/com/mitchellh/ghostty";
+const APP_ID: &str = "com.mitchellh.ghostty";
+const ICON_SIZES: &[u32] = &[16, 32, 128, 256, 512, 1024];
+const CSS: &[&str] = &[
+ "style.css",
+ "style-dark.css",
+ "style-hc.css",
+ "style-hc-dark.css",
+];
+// (major, minor, name). The inspector / imgui blueprints are deferred.
+const BLUEPRINTS: &[(u32, u32, &str)] = &[
+ (1, 0, "clipboard-confirmation-dialog"),
+ (1, 4, "clipboard-confirmation-dialog"),
+ (1, 2, "close-confirmation-dialog"),
+ (1, 2, "config-errors-dialog"),
+ (1, 2, "debug-warning"),
+ (1, 3, "debug-warning"),
+ (1, 2, "resize-overlay"),
+ (1, 2, "search-overlay"),
+ (1, 2, "key-state-overlay"),
+ (1, 5, "split-tree"),
+ (1, 5, "split-tree-split"),
+ (1, 2, "surface"),
+ (1, 5, "surface-scrolled-window"),
+ (1, 3, "surface-child-exited"),
+ (1, 5, "tab"),
+ (1, 5, "title-dialog"),
+ (1, 5, "window"),
+ (1, 5, "command-palette"),
+];
+
+fn main() {
+ let manifest = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+ let out = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+ let res = manifest.join("resources");
+ println!("cargo:rerun-if-changed=resources");
+ println!("cargo:rerun-if-changed=build.rs");
+
+ let mut xml = String::new();
+ xml.push_str("\n\n");
+
+ let _ = writeln!(xml, " ");
+ for name in CSS {
+ let _ = writeln!(
+ xml,
+ " css/{name}"
+ );
+ }
+ xml.push_str(" \n");
+
+ let _ = writeln!(xml, " ");
+ for &s in ICON_SIZES {
+ let _ = writeln!(
+ xml,
+ " icons/{s}.png"
+ );
+ let _ = writeln!(
+ xml,
+ " icons/{}.png",
+ s * 2
+ );
+ }
+ xml.push_str(" \n");
+
+ let _ = writeln!(xml, " ");
+ for &(major, minor, name) in BLUEPRINTS {
+ let rel = format!("{major}.{minor}/{name}");
+ let input = res.join(format!("ui/{rel}.blp"));
+ let output = out.join(format!("ui/{rel}.ui"));
+ compile_blueprint(&input, &output);
+ let _ = writeln!(xml, " ui/{rel}.ui");
+ }
+ xml.push_str(" \n\n");
+
+ let xml_path = out.join("ghostty.gresource.xml");
+ std::fs::write(&xml_path, xml).unwrap();
+
+ glib_build_tools::compile_resources(
+ &[out.as_path(), res.as_path()],
+ xml_path.to_str().unwrap(),
+ "ghostty.gresource",
+ );
+}
+
+fn compile_blueprint(input: &Path, output: &Path) {
+ std::fs::create_dir_all(output.parent().unwrap()).unwrap();
+ let st = Command::new("blueprint-compiler")
+ .arg("compile")
+ .arg("--output")
+ .arg(output)
+ .arg(input)
+ .output()
+ .unwrap_or_else(|e| {
+ panic!("`blueprint-compiler` (>= 0.16) is required to build ghostty-apprt-gtk: {e}")
+ });
+ assert!(
+ st.status.success(),
+ "blueprint-compiler failed for {}:\n{}",
+ input.display(),
+ String::from_utf8_lossy(&st.stderr)
+ );
+}
diff --git a/crates/ghostty-apprt-gtk/examples/demo.rs b/crates/ghostty-apprt-gtk/examples/demo.rs
new file mode 100644
index 0000000..fff865c
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/examples/demo.rs
@@ -0,0 +1,347 @@
+//! Demo for the GTK app runtime with a dummy core.
+//!
+//! The dummy `CoreApp`/`CoreSurface` clear the `GLArea` with the configured
+//! background color and implement just enough key handling (keybindings from
+//! the user's config) to exercise windows, tabs, splits, dialogs, the command
+//! palette, fullscreen, etc.
+//!
+//! Environment:
+//! * `DEMO_QUIT_AFTER_MS=`: quit automatically after n milliseconds.
+//! * `DEMO_CONFIRM=1`: make every surface report "needs confirm quit".
+//!
+//! Run: `cargo run -p ghostty-apprt-gtk --example demo`
+
+#![allow(unsafe_code)] // GL calls through glow
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
+
+use ghostty_apprt::action::{self, Action, Target};
+use ghostty_apprt::structs::{
+ ClipboardRequest, ColorScheme, ContentScale, CursorPos, ImePos, SurfaceSize,
+};
+use ghostty_apprt_gtk::app::App;
+use ghostty_apprt_gtk::core::{
+ AppMessage, CellSize, ClipboardError, CoreApp, CoreError, CoreSurface, DesiredFontSize,
+ InputEffect, KeyEvent, RtApp, RtSurface, SurfaceId,
+};
+use ghostty_config::config::Config;
+use ghostty_input::binding::set::Value as BindingValue;
+use ghostty_input::binding::{self, Action as Binding};
+use ghostty_input::{Mods, MouseButton, MouseButtonState, ScrollMods};
+use glow::HasContext;
+
+fn confirm() -> bool {
+ std::env::var("DEMO_CONFIRM").is_ok_and(|v| v == "1")
+}
+
+/// Map the subset of keybinding actions the demo understands to apprt actions.
+fn binding_to_action(b: &Binding) -> Option {
+ use binding::action::{CloseTabMode, SplitDirection, SplitFocusDirection};
+ Some(match b {
+ Binding::NewWindow => Action::NewWindow,
+ Binding::NewTab => Action::NewTab,
+ Binding::PreviousTab => Action::GotoTab(action::GotoTab::Previous),
+ Binding::NextTab => Action::GotoTab(action::GotoTab::Next),
+ Binding::LastTab => Action::GotoTab(action::GotoTab::Last),
+ Binding::GotoTab(n) => Action::GotoTab(action::GotoTab::Index(*n as i32)),
+ Binding::MoveTab(n) => Action::MoveTab(action::MoveTab { amount: *n }),
+ Binding::ToggleTabOverview => Action::ToggleTabOverview,
+ Binding::PromptSurfaceTitle => Action::PromptTitle(action::PromptTitle::Surface),
+ Binding::PromptTabTitle => Action::PromptTitle(action::PromptTitle::Tab),
+ Binding::NewSplit(d) => Action::NewSplit(match d {
+ SplitDirection::Right | SplitDirection::Auto => action::SplitDirection::Right,
+ SplitDirection::Down => action::SplitDirection::Down,
+ SplitDirection::Left => action::SplitDirection::Left,
+ SplitDirection::Up => action::SplitDirection::Up,
+ }),
+ Binding::GotoSplit(d) => Action::GotoSplit(match d {
+ SplitFocusDirection::Previous => action::GotoSplit::Previous,
+ SplitFocusDirection::Next => action::GotoSplit::Next,
+ SplitFocusDirection::Up => action::GotoSplit::Up,
+ SplitFocusDirection::Left => action::GotoSplit::Left,
+ SplitFocusDirection::Down => action::GotoSplit::Down,
+ SplitFocusDirection::Right => action::GotoSplit::Right,
+ }),
+ Binding::ToggleSplitZoom => Action::ToggleSplitZoom,
+ Binding::EqualizeSplits => Action::EqualizeSplits,
+ Binding::OpenConfig => Action::OpenConfig,
+ Binding::ReloadConfig => Action::ReloadConfig(action::ReloadConfig::default()),
+ Binding::CloseTab(m) => Action::CloseTab(match m {
+ CloseTabMode::This => action::CloseTabMode::This,
+ CloseTabMode::Other => action::CloseTabMode::Other,
+ CloseTabMode::Right => action::CloseTabMode::Right,
+ }),
+ Binding::CloseWindow | Binding::CloseSurface => Action::CloseWindow,
+ Binding::ToggleMaximize => Action::ToggleMaximize,
+ Binding::ToggleFullscreen => Action::ToggleFullscreen(action::Fullscreen::Native),
+ Binding::ToggleWindowDecorations => Action::ToggleWindowDecorations,
+ Binding::ToggleCommandPalette => Action::ToggleCommandPalette,
+ Binding::ToggleQuickTerminal => Action::ToggleQuickTerminal,
+ Binding::ShowGtkInspector => Action::ShowGtkInspector,
+ Binding::Quit => Action::Quit,
+ _ => return None,
+ })
+}
+
+// ---------------------------------------------------------------------
+
+struct DemoSurface {
+ id: SurfaceId,
+ config: RefCell>,
+ rt_app: Rc,
+ _rt_surface: Rc,
+ gl: RefCell>,
+ focused: Cell,
+}
+
+impl DemoSurface {
+ fn perform(&self, a: Action) -> bool {
+ self.rt_app.perform_action(Target::Surface(self.id), a)
+ }
+}
+
+impl CoreSurface for DemoSurface {
+ fn config(&self) -> Arc {
+ self.config.borrow().clone()
+ }
+
+ fn key_callback(&self, event: KeyEvent<'_>) -> Result {
+ if event.action == ghostty_input::Action::Release {
+ return Ok(InputEffect::Ignored);
+ }
+ let config = self.config();
+ let Some((_, value)) = config.keybind.set.get_event(&event) else {
+ return Ok(InputEffect::Ignored);
+ };
+ let BindingValue::Leaf(leaf) = value else {
+ return Ok(InputEffect::Ignored);
+ };
+ match binding_to_action(&leaf.action) {
+ Some(a) => {
+ let closes = matches!(a, Action::CloseWindow | Action::CloseTab(_));
+ self.perform(a);
+ Ok(if closes {
+ InputEffect::Closed
+ } else {
+ InputEffect::Consumed
+ })
+ }
+ None => Ok(InputEffect::Ignored),
+ }
+ }
+
+ fn preedit_callback(&self, _text: Option<&str>) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn focus_callback(&self, focused: bool) -> Result<(), CoreError> {
+ self.focused.set(focused);
+ Ok(())
+ }
+ fn mouse_button_callback(
+ &self,
+ _state: MouseButtonState,
+ _button: MouseButton,
+ _mods: Mods,
+ ) -> Result {
+ Ok(false)
+ }
+ fn cursor_pos_callback(&self, _pos: CursorPos, _mods: Option) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn scroll_callback(&self, _x: f64, _y: f64, _mods: ScrollMods) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn size_callback(&self, _size: SurfaceSize) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn content_scale_callback(&self, _scale: ContentScale) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn ime_point(&self) -> ImePos {
+ ImePos {
+ x: 0.0,
+ y: 0.0,
+ width: 10.0,
+ height: 20.0,
+ }
+ }
+ fn has_selection(&self) -> bool {
+ false
+ }
+ fn color_scheme_callback(&self, _scheme: ColorScheme) -> Result<(), CoreError> {
+ Ok(())
+ }
+ fn update_config(&self, config: &Arc) -> Result<(), CoreError> {
+ *self.config.borrow_mut() = config.clone();
+ self.perform(Action::ConfigChange(action::ConfigChange {
+ config: config.clone(),
+ }));
+ Ok(())
+ }
+ fn perform_binding_action(&self, a: &Binding) -> Result {
+ Ok(binding_to_action(a).is_some_and(|a| self.perform(a)))
+ }
+ fn complete_clipboard_request(
+ &self,
+ _req: ClipboardRequest,
+ data: &str,
+ _confirmed: bool,
+ ) -> Result<(), ClipboardError> {
+ log::info!("demo: paste of {} bytes", data.len());
+ Ok(())
+ }
+ fn set_clipboard_read_allowed(&self, _allow: bool) {}
+ fn set_clipboard_write_allowed(&self, _allow: bool) {}
+ fn needs_confirm_quit(&self) -> bool {
+ confirm()
+ }
+ fn child_exited(&self) -> bool {
+ false
+ }
+ fn renderer_realized(&self) -> Result<(), CoreError> {
+ // SAFETY: the GLArea context is current while realizing; the loader
+ // resolves symbols through libepoxy which dispatches to it.
+ let gl = unsafe {
+ glow::Context::from_loader_function(ghostty_apprt_gtk::gl::proc_address)
+ };
+ *self.gl.borrow_mut() = Some(gl);
+ Ok(())
+ }
+ fn renderer_unrealized(&self) {
+ *self.gl.borrow_mut() = None;
+ }
+ fn draw_frame(&self, default_framebuffer: u32) -> Result<(), CoreError> {
+ let gl = self.gl.borrow();
+ let Some(gl) = gl.as_ref() else {
+ return Ok(());
+ };
+ let config = self.config();
+ let bg = config.background;
+ let a = config.background_opacity as f32;
+ let (r, g, b) = (
+ f32::from(bg.r) / 255.0,
+ f32::from(bg.g) / 255.0,
+ f32::from(bg.b) / 255.0,
+ );
+ // SAFETY: GL context is current (GLArea render signal).
+ unsafe {
+ gl.bind_framebuffer(
+ glow::FRAMEBUFFER,
+ std::num::NonZeroU32::new(default_framebuffer).map(glow::NativeFramebuffer),
+ );
+ // Premultiplied alpha.
+ gl.clear_color(r * a, g * a, b * a, a);
+ gl.clear(glow::COLOR_BUFFER_BIT);
+ }
+ Ok(())
+ }
+}
+
+// ---------------------------------------------------------------------
+
+#[derive(Default)]
+struct DemoApp {
+ surfaces: RefCell>,
+ mailbox: RefCell>,
+}
+
+impl CoreApp for DemoApp {
+ fn tick(&self, rt: &dyn RtApp) -> Result<(), CoreError> {
+ let msgs: Vec = self.mailbox.borrow_mut().drain(..).collect();
+ for m in msgs {
+ match m {
+ AppMessage::NewWindow => {
+ rt.perform_action(Target::App, Action::NewWindow);
+ }
+ AppMessage::OpenConfig => {
+ rt.perform_action(Target::App, Action::OpenConfig);
+ }
+ AppMessage::PresentSurface(id) => {
+ if self.surfaces.borrow().contains(&id) {
+ rt.perform_action(Target::Surface(id), Action::PresentTerminal);
+ }
+ }
+ }
+ }
+ Ok(())
+ }
+
+ fn update_config(&self, rt: &dyn RtApp, config: &Arc) -> Result<(), CoreError> {
+ rt.perform_action(
+ Target::App,
+ Action::ConfigChange(action::ConfigChange {
+ config: config.clone(),
+ }),
+ );
+ Ok(())
+ }
+ fn needs_confirm_quit(&self) -> bool {
+ confirm() && !self.surfaces.borrow().is_empty()
+ }
+ fn color_scheme_event(&self, _rt: &dyn RtApp, scheme: ColorScheme) {
+ log::info!("demo: color scheme {scheme:?}");
+ }
+ fn perform_all_action(&self, rt: &dyn RtApp, a: &Binding) -> Result<(), CoreError> {
+ if let Some(a) = binding_to_action(a) {
+ rt.perform_action(Target::App, a);
+ }
+ Ok(())
+ }
+ fn push_message(&self, msg: AppMessage) {
+ self.mailbox.borrow_mut().push(msg);
+ }
+ fn new_surface(
+ &self,
+ id: SurfaceId,
+ config: Config,
+ rt_app: Rc,
+ rt_surface: Rc,
+ ) -> Result, CoreError> {
+ self.surfaces.borrow_mut().push(id);
+ Ok(Rc::new(DemoSurface {
+ id,
+ config: RefCell::new(Arc::new(config)),
+ rt_app,
+ _rt_surface: rt_surface,
+ gl: RefCell::new(None),
+ focused: Cell::new(false),
+ }))
+ }
+ fn delete_surface(&self, id: SurfaceId) {
+ self.surfaces.borrow_mut().retain(|s| *s != id);
+ }
+ fn surface_ids(&self) -> Vec {
+ self.surfaces.borrow().clone()
+ }
+ fn cell_size(&self, _config: &Config, _font_size: DesiredFontSize) -> Option {
+ Some(CellSize {
+ width: 9,
+ height: 18,
+ })
+ }
+}
+
+fn main() {
+ env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+ let core = Rc::new(DemoApp::default());
+ let app = App::new(core);
+
+ if let Some(ms) = std::env::var("DEMO_QUIT_AFTER_MS")
+ .ok()
+ .and_then(|v| v.parse::().ok())
+ {
+ gtk::glib::timeout_add_local_once(Duration::from_millis(ms), || {
+ ghostty_apprt_gtk::class::application::Application::default().quit();
+ });
+ }
+
+ if let Err(err) = app.run() {
+ eprintln!("error: {err}");
+ std::process::exit(1);
+ }
+ app.terminate();
+}
diff --git a/crates/ghostty-apprt-gtk/resources/css/style-dark.css b/crates/ghostty-apprt-gtk/resources/css/style-dark.css
new file mode 100644
index 0000000..f13b4f4
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/css/style-dark.css
@@ -0,0 +1,8 @@
+.transparent {
+ background-color: transparent;
+}
+
+.window .split paned > separator {
+ background-color: rgba(36, 36, 36, 1);
+ background-clip: content-box;
+}
diff --git a/crates/ghostty-apprt-gtk/resources/css/style-hc-dark.css b/crates/ghostty-apprt-gtk/resources/css/style-hc-dark.css
new file mode 100644
index 0000000..a9aa2dc
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/css/style-hc-dark.css
@@ -0,0 +1,3 @@
+.transparent {
+ background-color: transparent;
+}
diff --git a/crates/ghostty-apprt-gtk/resources/css/style-hc.css b/crates/ghostty-apprt-gtk/resources/css/style-hc.css
new file mode 100644
index 0000000..a9aa2dc
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/css/style-hc.css
@@ -0,0 +1,3 @@
+.transparent {
+ background-color: transparent;
+}
diff --git a/crates/ghostty-apprt-gtk/resources/css/style.css b/crates/ghostty-apprt-gtk/resources/css/style.css
new file mode 100644
index 0000000..9c0f115
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/css/style.css
@@ -0,0 +1,183 @@
+/* Application CSS that applies to the entire application.
+ *
+ * This is automatically loaded by AdwApplication:
+ * https://gnome.pages.gitlab.gnome.org/libadwaita/doc/1.3/styles-and-appearance.html#custom-styles
+ */
+
+window.ssd.no-border-radius {
+ /* Without clearing the border radius, at least on Mutter with
+ * gtk-titlebar=true and gtk-adwaita=false, there is some window artifacting
+ * that this will mitigate.
+ */
+ border-radius: 0 0;
+}
+
+/*
+ * GhosttySurface URL overlay
+ */
+label.url-overlay {
+ padding: 4px 8px 4px 8px;
+ outline-style: solid;
+ outline-color: #555555;
+ outline-width: 1px;
+}
+
+label.url-overlay:hover {
+ opacity: 0;
+}
+
+label.url-overlay.left {
+ border-radius: 0px 6px 0px 0px;
+}
+
+label.url-overlay.right {
+ border-radius: 6px 0px 0px 0px;
+}
+
+/*
+ * GhosttySurface search overlay
+ */
+.search-overlay {
+ padding: 6px 8px;
+ margin: 8px;
+ border-radius: 8px;
+ outline-style: solid;
+ outline-color: #555555;
+ outline-width: 1px;
+}
+
+/*
+ * GhosttySurface key state overlay
+ */
+.key-state-overlay {
+ padding: 6px 10px;
+ margin: 8px;
+ border-radius: 8px;
+ outline-style: solid;
+ outline-color: #555555;
+ outline-width: 1px;
+}
+
+/*
+ * GhosttySurface resize overlay
+ */
+label.resize-overlay {
+ padding: 4px 8px 4px 8px;
+ border-radius: 6px 6px 6px 6px;
+ outline-style: solid;
+ outline-color: #555555;
+ outline-width: 1px;
+}
+
+/*
+ * GhosttyClipboardConfirmationDialog
+ *
+ * Based on boxed-list-separate:
+ * https://gitlab.gnome.org/GNOME/libadwaita/-/blob/ad446167acf3e6d1ee693f98ca636268be8592a1/src/stylesheet/widgets/_lists.scss#L548
+ */
+.clipboard-confirmation-dialog list {
+ background: none;
+}
+
+.clipboard-confirmation-dialog list > row {
+ border: none;
+ margin-bottom: 12px;
+}
+
+.clipboard-confirmation-dialog list > row:last-child {
+ margin-bottom: 0;
+}
+
+.clipboard-confirmation-dialog .clipboard-overlay {
+ border-radius: 10px;
+}
+
+.clipboard-confirmation-dialog .clipboard-contents {
+ filter: blur(0px);
+ transition: filter 0.3s ease;
+ border-radius: 10px;
+}
+
+.clipboard-confirmation-dialog .clipboard-contents.blurred {
+ filter: blur(5px);
+}
+
+/*
+ * Child Exited Overlay
+ */
+.child-exited.normal revealer widget {
+ background-color: rgba(38, 162, 105, 0.5);
+ /* after GTK 4.16 is a requirement, switch to the following: */
+ /* background-color: color-mix(in srgb, var(--success-bg-color), transparent 50%); */
+}
+
+.child-exited.abnormal revealer widget {
+ background-color: rgba(192, 28, 40, 0.5);
+ /* after GTK 4.16 is a requirement, switch to the following: */
+ /* background-color: color-mix(in srgb, var(--error-bg-color), transparent 50%); */
+}
+
+/*
+ * Surface
+ */
+.surface progressbar.error trough progress {
+ background-color: rgba(192, 28, 40, 0.5);
+ /* after GTK 4.16 is a requirement, switch to the following: */
+ /* background-color: color-mix(in srgb, var(--error-bg-color), transparent 50%); */
+}
+
+.surface .bell-overlay {
+ border-color: rgba(58, 148, 74, 0.5);
+ /* after GTK 4.16 is a requirement, switch to the following: */
+ /* background-color: color-mix(in srgb, var(--accent-color), transparent 50%); */
+ border-width: 3px;
+ border-style: solid;
+}
+
+.surface .readonly_overlay {
+ /* Should be the equivalent of the following SwiftUI color: */
+ /* Color(hue: 0.08, saturation: 0.5, brightness: 0.8) */
+ color: hsl(25 50 75);
+ padding: 8px 8px 8px 8px;
+ margin: 8px 8px 8px 8px;
+ border-radius: 6px 6px 6px 6px;
+ outline-style: solid;
+ outline-width: 1px;
+}
+/*
+ * Command Palette
+ */
+.command-palette-search > image:first-child {
+ margin-left: 8px;
+ margin-right: 4px;
+}
+
+.command-palette-search > image:last-child {
+ margin-left: 4px;
+ margin-right: 8px;
+}
+
+/*
+ * Splits
+ */
+
+.window .split paned > separator {
+ background-color: rgba(250, 250, 250, 1);
+ /* after GTK 4.16 is a requirement, switch to the following: */
+ /* background-color: color-mix(in srgb, var(--window-bg-color), transparent 0%); */
+ background-clip: content-box;
+
+ /* This works around the oversized drag area for the right side of GtkPaned.
+ *
+ * Upstream Gtk issue:
+ * https://gitlab.gnome.org/GNOME/gtk/-/issues/4484#note_2362002
+ *
+ * Ghostty issue:
+ * https://github.com/ghostty-org/ghostty/issues/3020
+ *
+ * Without this, it's not possible to select the first character on the
+ * right-hand side of a split.
+ */
+ margin: 0;
+ padding: 0;
+}
diff --git a/crates/ghostty-apprt-gtk/resources/icons/1024.png b/crates/ghostty-apprt-gtk/resources/icons/1024.png
new file mode 100644
index 0000000..8accee3
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/1024.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/128.png b/crates/ghostty-apprt-gtk/resources/icons/128.png
new file mode 100644
index 0000000..cab4dcf
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/128.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/16.png b/crates/ghostty-apprt-gtk/resources/icons/16.png
new file mode 100644
index 0000000..0212014
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/16.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/2048.png b/crates/ghostty-apprt-gtk/resources/icons/2048.png
new file mode 100644
index 0000000..1327d46
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/2048.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/256.png b/crates/ghostty-apprt-gtk/resources/icons/256.png
new file mode 100644
index 0000000..423465c
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/256.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/32.png b/crates/ghostty-apprt-gtk/resources/icons/32.png
new file mode 100644
index 0000000..2889131
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/32.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/512.png b/crates/ghostty-apprt-gtk/resources/icons/512.png
new file mode 100644
index 0000000..2045204
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/512.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/icons/64.png b/crates/ghostty-apprt-gtk/resources/icons/64.png
new file mode 100644
index 0000000..fae92b4
Binary files /dev/null and b/crates/ghostty-apprt-gtk/resources/icons/64.png differ
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.0/clipboard-confirmation-dialog.blp b/crates/ghostty-apprt-gtk/resources/ui/1.0/clipboard-confirmation-dialog.blp
new file mode 100644
index 0000000..5f29981
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.0/clipboard-confirmation-dialog.blp
@@ -0,0 +1,86 @@
+using Gtk 4.0;
+// This is unused but if we remove it we get a blueprint-compiler error.
+using Adw 1;
+
+template $GhosttyClipboardConfirmationDialog: $GhosttyDialog {
+ styles [
+ "clipboard-confirmation-dialog",
+ ]
+
+ notify::blur => $notify_blur();
+ notify::request => $notify_request();
+ heading: _("Authorize Clipboard Access");
+ // Not localized because this is a placeholder users never see.
+ body: "If you see this text, there is a bug in Ghostty. Please report it.";
+
+ responses [
+ cancel: _("Deny") suggested,
+ ok: _("Allow") destructive,
+ ]
+
+ default-response: "cancel";
+ close-response: "cancel";
+
+ extra-child: ListBox {
+ selection-mode: none;
+
+ Overlay {
+ styles [
+ "osd",
+ "clipboard-overlay",
+ ]
+
+ ScrolledWindow text_view_scroll {
+ width-request: 500;
+ height-request: 200;
+
+ TextView text_view {
+ styles [
+ "clipboard-contents",
+ ]
+
+ cursor-visible: false;
+ editable: false;
+ monospace: true;
+ top-margin: 8;
+ left-margin: 8;
+ bottom-margin: 8;
+ right-margin: 8;
+ buffer: bind template.clipboard-contents;
+ }
+ }
+
+ [overlay]
+ Button reveal_button {
+ clicked => $reveal_clicked();
+ visible: false;
+ halign: end;
+ valign: start;
+ margin-end: 12;
+ margin-top: 12;
+
+ Image {
+ icon-name: "view-reveal-symbolic";
+ }
+ }
+
+ [overlay]
+ Button hide_button {
+ clicked => $hide_clicked();
+ visible: false;
+ halign: end;
+ valign: start;
+ margin-end: 12;
+ margin-top: 12;
+
+ styles [
+ "opaque",
+ ]
+
+ Image {
+ icon-name: "view-conceal-symbolic";
+ }
+ }
+ }
+ };
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/close-confirmation-dialog.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/close-confirmation-dialog.blp
new file mode 100644
index 0000000..f58ef52
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/close-confirmation-dialog.blp
@@ -0,0 +1,12 @@
+using Gtk 4.0;
+// This is unused but if we remove it we get a blueprint-compiler error.
+using Adw 1;
+
+template $GhosttyCloseConfirmationDialog: $GhosttyDialog {
+ responses [
+ cancel: _("Cancel"),
+ close: _("Close") destructive,
+ ]
+
+ close-response: "cancel";
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/config-errors-dialog.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/config-errors-dialog.blp
new file mode 100644
index 0000000..845909e
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/config-errors-dialog.blp
@@ -0,0 +1,28 @@
+using Gtk 4.0;
+// This is unused but if we remove it we get a blueprint-compiler error.
+using Adw 1;
+
+template $GhosttyConfigErrorsDialog: $GhosttyDialog {
+ heading: _("Configuration Errors");
+ body: _("One or more configuration errors were found. Please review the errors below, and either reload your configuration or ignore these errors.");
+
+ responses [
+ ignore: _("Ignore"),
+ reload: _("Reload Configuration") suggested,
+ ]
+
+ extra-child: ScrolledWindow {
+ min-content-width: 500;
+ min-content-height: 100;
+
+ TextView {
+ editable: false;
+ cursor-visible: false;
+ top-margin: 8;
+ bottom-margin: 8;
+ left-margin: 8;
+ right-margin: 8;
+ buffer: bind (template.config as <$GhosttyConfig>).diagnostics-buffer;
+ }
+ };
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/debug-warning.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/debug-warning.blp
new file mode 100644
index 0000000..34411ce
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/debug-warning.blp
@@ -0,0 +1,11 @@
+using Gtk 4.0;
+
+template $GhosttyDebugWarning: Gtk.Box {
+ orientation: vertical;
+
+ Gtk.Label {
+ label: _("⚠️ You're running a debug build of Ghostty! Performance will be degraded.");
+ margin-top: 10;
+ margin-bottom: 10;
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/key-state-overlay.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/key-state-overlay.blp
new file mode 100644
index 0000000..c8654bf
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/key-state-overlay.blp
@@ -0,0 +1,58 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttyKeyStateOverlay: Adw.Bin {
+ visible: bind $has_state(template.has-tables, template.has-sequence) as ;
+ valign-target: end;
+ halign: center;
+ valign: bind template.valign-target;
+
+ GestureDrag {
+ button: 1;
+ propagation-phase: capture;
+ drag-end => $on_drag_end();
+ }
+
+ Adw.Bin {
+ Box container {
+ styles [
+ "background",
+ "key-state-overlay",
+ ]
+
+ orientation: horizontal;
+ spacing: 6;
+
+ Image {
+ icon-name: "input-keyboard-symbolic";
+ pixel-size: 16;
+ }
+
+ Label tables_label {
+ visible: bind template.has-tables;
+ label: bind $tables_text(template.tables) as ;
+ xalign: 0.0;
+ }
+
+ Label chevron_label {
+ visible: bind $show_chevron(template.has-tables, template.has-sequence) as ;
+ label: "›";
+
+ styles [
+ "dim-label",
+ ]
+ }
+
+ Label sequence_label {
+ visible: bind template.has-sequence;
+ label: bind $sequence_text(template.sequence) as ;
+ xalign: 0.0;
+ }
+
+ Spinner pending_spinner {
+ visible: bind template.has-sequence;
+ spinning: bind template.has-sequence;
+ }
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/resize-overlay.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/resize-overlay.blp
new file mode 100644
index 0000000..5c4a94a
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/resize-overlay.blp
@@ -0,0 +1,27 @@
+using Gtk 4.0;
+using Adw 1;
+// We can't inherit directly from Label because its an opaque
+// type in zig-gobject.
+template $GhosttyResizeOverlay: Adw.Bin {
+ visible: false;
+ duration: 750;
+ first-delay: 250;
+ overlay-halign: center;
+ overlay-valign: center;
+ // See surface.blp for why we need to wrap this.
+ Adw.Bin {
+ Label label {
+ styles [
+ "background",
+ "resize-overlay",
+ ]
+
+ focusable: false;
+ focus-on-click: false;
+ justify: center;
+ selectable: false;
+ halign: bind template.overlay-halign;
+ valign: bind template.overlay-valign;
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/search-overlay.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/search-overlay.blp
new file mode 100644
index 0000000..6523d41
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/search-overlay.blp
@@ -0,0 +1,94 @@
+using Gtk 4.0;
+using Gdk 4.0;
+using Adw 1;
+
+template $GhosttySearchOverlay: Adw.Bin {
+ visible: bind template.active;
+ halign-target: end;
+ valign-target: start;
+ halign: bind template.halign-target;
+ valign: bind template.valign-target;
+
+ GestureDrag {
+ button: 1;
+ propagation-phase: capture;
+ drag-end => $on_drag_end();
+ }
+
+ Adw.Bin {
+ Box container {
+ styles [
+ "background",
+ "search-overlay",
+ ]
+
+ orientation: horizontal;
+ spacing: 6;
+
+ SearchEntry search_entry {
+ placeholder-text: _("Find…");
+ width-chars: 20;
+ hexpand: true;
+ stop-search => $stop_search();
+ search-changed => $search_changed();
+ next-match => $next_match();
+ previous-match => $previous_match();
+
+ EventControllerKey {
+ // We need this so we capture before the SearchEntry.
+ propagation-phase: capture;
+ key-pressed => $search_entry_key_pressed();
+ }
+ }
+
+ Label {
+ styles [
+ "dim-label",
+ ]
+
+ label: bind $match_label_closure(template.has-search-selected, template.search-selected, template.has-search-total, template.search-total) as ;
+ width-chars: 6;
+ xalign: 1.0;
+ }
+
+ Box button_box {
+ orientation: horizontal;
+ spacing: 1;
+
+ styles [
+ "linked",
+ ]
+
+ Button prev_button {
+ icon-name: "go-up-symbolic";
+ tooltip-text: _("Previous Match");
+ clicked => $next_match();
+
+ cursor: Gdk.Cursor {
+ name: "pointer";
+ };
+ }
+
+ Button next_button {
+ icon-name: "go-down-symbolic";
+ tooltip-text: _("Next Match");
+ clicked => $previous_match();
+
+ cursor: Gdk.Cursor {
+ name: "pointer";
+ };
+ }
+ }
+
+ Button close_button {
+ icon-name: "window-close-symbolic";
+ tooltip-text: _("Close");
+ clicked => $stop_search();
+
+ cursor: Gdk.Cursor {
+ name: "pointer";
+ };
+ }
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.2/surface.blp b/crates/ghostty-apprt-gtk/resources/ui/1.2/surface.blp
new file mode 100644
index 0000000..794ea18
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.2/surface.blp
@@ -0,0 +1,371 @@
+using Gtk 4.0;
+using Adw 1;
+
+Adw.StatusPage error_page {
+ icon-name: "computer-fail-symbolic";
+ title: _("Oh, no.");
+ description: _("Unable to acquire an OpenGL context for rendering.");
+
+ child: LinkButton {
+ label: "https://ghostty.org/docs/help/gtk-opengl-context";
+ uri: "https://ghostty.org/docs/help/gtk-opengl-context";
+ };
+}
+
+Overlay terminal_page {
+ focusable: false;
+ focus-on-click: false;
+
+ child: Box {
+ hexpand: true;
+ vexpand: true;
+
+ GLArea gl_area {
+ realize => $gl_realize();
+ unrealize => $gl_unrealize();
+ render => $gl_render();
+ resize => $gl_resize();
+ hexpand: true;
+ vexpand: true;
+ focusable: true;
+ focus-on-click: true;
+ has-stencil-buffer: false;
+ has-depth-buffer: false;
+ allowed-apis: gl;
+ }
+
+ PopoverMenu context_menu {
+ closed => $context_menu_closed();
+ menu-model: context_menu_model;
+ flags: nested;
+ halign: start;
+ has-arrow: false;
+ }
+
+ EventControllerFocus {
+ enter => $focus_enter();
+ leave => $focus_leave();
+ }
+
+ EventControllerKey {
+ key-pressed => $key_pressed();
+ key-released => $key_released();
+ }
+
+ EventControllerScroll {
+ scroll => $scroll_vertical();
+ scroll-begin => $scroll_vertical_begin();
+ scroll-end => $scroll_vertical_end();
+ flags: vertical;
+ }
+
+ EventControllerScroll {
+ scroll => $scroll_horizontal();
+ flags: horizontal;
+ }
+
+ EventControllerMotion {
+ motion => $mouse_motion();
+ leave => $mouse_leave();
+ }
+
+ GestureClick {
+ pressed => $mouse_down();
+ released => $mouse_up();
+ button: 0;
+ }
+ };
+
+ [overlay]
+ Revealer {
+ reveal-child: bind template.readonly;
+ transition-type: crossfade;
+ transition-duration: 500;
+ // Revealers take up the full size, we need this to not capture events.
+ can-focus: false;
+ can-target: false;
+ focusable: false;
+
+ Box readonly_overlay {
+ styles [
+ "readonly_overlay",
+ ]
+
+ // TODO: the tooltip doesn't actually work, but keep it here for now so
+ // that we can get the tooltip text translated.
+ has-tooltip: true;
+ tooltip-text: _("This terminal is in read-only mode. You can still view, select, and scroll through the content, but no input events will be sent to the running application.");
+ halign: end;
+ valign: start;
+ spacing: 6;
+
+ Image {
+ icon-name: "changes-prevent-symbolic";
+ }
+
+ Label {
+ label: _("Read-only");
+ }
+ }
+ }
+
+ [overlay]
+ ProgressBar progress_bar_overlay {
+ styles [
+ "osd",
+ ]
+
+ visible: false;
+ halign: fill;
+ valign: start;
+ }
+
+ [overlay]
+ // The "border" bell feature is implemented here as an overlay rather than
+ // just adding a border to the GLArea or other widget for two reasons.
+ // First, adding a border to an existing widget causes a resize of the
+ // widget which undesirable side effects. Second, we can make it reactive
+ // here in the blueprint with relatively little code.
+ Revealer {
+ reveal-child: bind $should_border_be_shown(template.config, template.bell-ringing) as ;
+ transition-type: crossfade;
+ transition-duration: 500;
+ // Revealers take up the full size, we need this to not capture events.
+ can-focus: false;
+ can-target: false;
+ focusable: false;
+
+ Box bell_overlay {
+ styles [
+ "bell-overlay",
+ ]
+
+ halign: fill;
+ valign: fill;
+ }
+ }
+
+ [overlay]
+ $GhosttySurfaceChildExited child_exited_overlay {
+ visible: bind template.child-exited;
+ close-request => $child_exited_close();
+ }
+
+ [overlay]
+ $GhosttyResizeOverlay resize_overlay {}
+
+ [overlay]
+ Label url_left {
+ styles [
+ "background",
+ "url-overlay",
+ ]
+
+ visible: false;
+ halign: start;
+ valign: end;
+ label: bind template.mouse-hover-url;
+
+ EventControllerMotion url_ec_motion {
+ enter => $url_mouse_enter();
+ leave => $url_mouse_leave();
+ }
+ }
+
+ [overlay]
+ Label url_right {
+ styles [
+ "background",
+ "url-overlay",
+ ]
+
+ visible: false;
+ halign: end;
+ valign: end;
+ label: bind template.mouse-hover-url;
+ }
+
+ [overlay]
+ $GhosttySearchOverlay search_overlay {
+ stop-search => $search_stop();
+ search-changed => $search_changed();
+ next-match => $search_next_match();
+ previous-match => $search_previous_match();
+ }
+
+ [overlay]
+ $GhosttyKeyStateOverlay key_state_overlay {
+ tables: bind template.key-table;
+ sequence: bind template.key-sequence;
+ }
+
+ [overlay]
+ // Apply unfocused-split-fill and unfocused-split-opacity to current surface
+ // this is only applied when a tab has more than one surface
+ Revealer {
+ reveal-child: bind $should_unfocused_split_be_shown(search_overlay.active, template.focused, template.is-split) as ;
+ transition-duration: 0;
+ // This is all necessary so that the Revealer itself doesn't override
+ // any input events from the other overlays. Namely, if you don't have
+ // these then the search overlay won't get mouse events.
+ can-focus: false;
+ can-target: false;
+ focusable: false;
+
+ DrawingArea {
+ styles [
+ "unfocused-split",
+ ]
+ }
+ }
+
+ DropTarget drop_target {
+ drop => $drop();
+ actions: copy | move;
+ }
+}
+
+template $GhosttySurface: Adw.Bin {
+ styles [
+ "surface",
+ ]
+
+ notify::config => $notify_config();
+ notify::error => $notify_error();
+ notify::mouse-hover-url => $notify_mouse_hover_url();
+ notify::mouse-hidden => $notify_mouse_hidden();
+ notify::mouse-shape => $notify_mouse_shape();
+ notify::vadjustment => $notify_vadjustment();
+ // Some history: we used to use a Stack here and swap between the
+ // terminal and error pages as needed. But a Stack doesn't play nice
+ // with our SplitTree and Gtk.Paned usage[^1]. Replacing this with
+ // a manual programmatic child swap fixed this. So if you ever change
+ // this, be sure to test many splits!
+ //
+ // [^1]: https://github.com/ghostty-org/ghostty/issues/8533
+ child: terminal_page;
+}
+
+IMMulticontext im_context {
+ input-purpose: terminal;
+ preedit-start => $im_preedit_start();
+ preedit-changed => $im_preedit_changed();
+ preedit-end => $im_preedit_end();
+ commit => $im_commit();
+}
+
+menu context_menu_model {
+ section {
+ item {
+ label: _("Copy");
+ action: "win.copy";
+ }
+
+ item {
+ label: _("Paste");
+ action: "win.paste";
+ }
+
+ item {
+ label: _("Notify on Next Command Finish");
+ action: "surface.notify-on-next-command-finish";
+ }
+ }
+
+ section {
+ item {
+ label: _("Clear");
+ action: "win.clear";
+ }
+
+ item {
+ label: _("Reset");
+ action: "win.reset";
+ }
+ }
+
+ section {
+ submenu {
+ label: _("Split");
+
+ item {
+ label: _("Change Title…");
+ action: "surface.prompt-title";
+ }
+
+ item {
+ label: _("Split Up");
+ action: "split-tree.new-split";
+ target: "up";
+ }
+
+ item {
+ label: _("Split Down");
+ action: "split-tree.new-split";
+ target: "down";
+ }
+
+ item {
+ label: _("Split Left");
+ action: "split-tree.new-split";
+ target: "left";
+ }
+
+ item {
+ label: _("Split Right");
+ action: "split-tree.new-split";
+ target: "right";
+ }
+ }
+
+ submenu {
+ label: _("Tab");
+
+ item {
+ label: _("Change Tab Title…");
+ action: "tab.prompt-tab-title";
+ }
+
+ item {
+ label: _("New Tab");
+ action: "win.new-tab";
+ }
+
+ item {
+ label: _("Close Tab");
+ action: "tab.close";
+ target: "this";
+ }
+ }
+
+ submenu {
+ label: _("Window");
+
+ item {
+ label: _("New Window");
+ action: "win.new-window";
+ }
+
+ item {
+ label: _("Close Window");
+ action: "win.close";
+ }
+ }
+ }
+
+ section {
+ submenu {
+ label: _("Config");
+
+ item {
+ label: _("Open Configuration");
+ action: "app.open-config";
+ }
+
+ item {
+ label: _("Reload Configuration");
+ action: "app.reload-config";
+ }
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.3/debug-warning.blp b/crates/ghostty-apprt-gtk/resources/ui/1.3/debug-warning.blp
new file mode 100644
index 0000000..ad7246a
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.3/debug-warning.blp
@@ -0,0 +1,9 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttyDebugWarning: Adw.Bin {
+ Adw.Banner {
+ title: _("⚠️ You're running a debug build of Ghostty! Performance will be degraded.");
+ revealed: true;
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.3/surface-child-exited.blp b/crates/ghostty-apprt-gtk/resources/ui/1.3/surface-child-exited.blp
new file mode 100644
index 0000000..6745f0c
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.3/surface-child-exited.blp
@@ -0,0 +1,22 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttySurfaceChildExited: Adw.Bin {
+ styles [
+ "child-exited",
+ ]
+
+ notify::data => $notify_data();
+
+ Adw.Bin {
+ Adw.Banner banner {
+ button-clicked => $clicked();
+ revealed: true;
+ // Not localized on purpose because it should never be seen.
+ title: "This is a bug in Ghostty. Please report it.";
+ button-label: _("Close");
+ halign: fill;
+ valign: end;
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.4/clipboard-confirmation-dialog.blp b/crates/ghostty-apprt-gtk/resources/ui/1.4/clipboard-confirmation-dialog.blp
new file mode 100644
index 0000000..144e3a3
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.4/clipboard-confirmation-dialog.blp
@@ -0,0 +1,96 @@
+using Gtk 4.0;
+// This is unused but if we remove it we get a blueprint-compiler error.
+using Adw 1;
+
+template $GhosttyClipboardConfirmationDialog: $GhosttyDialog {
+ styles [
+ "clipboard-confirmation-dialog",
+ ]
+
+ notify::blur => $notify_blur();
+ notify::request => $notify_request();
+ heading: _("Authorize Clipboard Access");
+ // Not localized because this is a placeholder users never see.
+ body: "If you see this text, there is a bug in Ghostty. Please report it.";
+
+ responses [
+ cancel: _("Deny") suggested,
+ ok: _("Allow") destructive,
+ ]
+
+ default-response: "cancel";
+ close-response: "cancel";
+
+ extra-child: ListBox {
+ selection-mode: none;
+
+ Overlay {
+ styles [
+ "osd",
+ "clipboard-overlay",
+ ]
+
+ ScrolledWindow text_view_scroll {
+ width-request: 500;
+ height-request: 200;
+
+ TextView text_view {
+ styles [
+ "clipboard-contents",
+ ]
+
+ cursor-visible: false;
+ editable: false;
+ monospace: true;
+ top-margin: 8;
+ left-margin: 8;
+ bottom-margin: 8;
+ right-margin: 8;
+ buffer: bind template.clipboard-contents;
+ }
+ }
+
+ [overlay]
+ Button reveal_button {
+ clicked => $reveal_clicked();
+ visible: false;
+ halign: end;
+ valign: start;
+ margin-end: 12;
+ margin-top: 12;
+
+ Image {
+ icon-name: "view-reveal-symbolic";
+ }
+ }
+
+ [overlay]
+ Button hide_button {
+ clicked => $hide_clicked();
+ visible: false;
+ halign: end;
+ valign: start;
+ margin-end: 12;
+ margin-top: 12;
+
+ styles [
+ "opaque",
+ ]
+
+ Image {
+ icon-name: "view-conceal-symbolic";
+ }
+ }
+ }
+
+ Adw.SwitchRow remember_choice {
+ styles [
+ "card",
+ ]
+
+ visible: bind template.can-remember;
+ title: _("Remember choice for this split");
+ subtitle: _("Reload configuration to show this prompt again");
+ }
+ };
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/command-palette.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/command-palette.blp
new file mode 100644
index 0000000..473fb1f
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/command-palette.blp
@@ -0,0 +1,110 @@
+using Gtk 4.0;
+using Gio 2.0;
+using Adw 1;
+
+Adw.Dialog dialog {
+ content-width: 700;
+ closed => $closed();
+
+ Adw.ToolbarView {
+ top-bar-style: flat;
+
+ [top]
+ Adw.HeaderBar {
+ [title]
+ Gtk.SearchEntry search {
+ hexpand: true;
+ placeholder-text: _("Execute a command…");
+ stop-search => $search_stopped();
+ activate => $search_activated();
+
+ styles [
+ "command-palette-search",
+ ]
+ }
+ }
+
+ Gtk.ScrolledWindow {
+ min-content-height: 300;
+
+ Gtk.ListView view {
+ show-separators: true;
+ single-click-activate: true;
+ activate => $row_activated();
+
+ model: Gtk.SingleSelection model {
+ model: Gtk.FilterListModel {
+ incremental: true;
+
+ filter: Gtk.AnyFilter {
+ Gtk.StringFilter {
+ expression: expr item as <$GhosttyCommand>.title;
+ search: bind search.text;
+ }
+
+ Gtk.StringFilter {
+ expression: expr item as <$GhosttyCommand>.action-key;
+ search: bind search.text;
+ }
+ };
+
+ model: Gio.ListStore source {
+ item-type: typeof<$GhosttyCommand>;
+ };
+ };
+ };
+
+ styles [
+ "rich-list",
+ ]
+
+ factory: Gtk.BuilderListItemFactory {
+ template Gtk.ListItem {
+ child: Gtk.Box {
+ orientation: horizontal;
+ spacing: 10;
+ tooltip-text: bind template.item as <$GhosttyCommand>.description;
+
+ Gtk.Box {
+ orientation: vertical;
+ hexpand: true;
+
+ Gtk.Label {
+ ellipsize: end;
+ halign: start;
+ wrap: false;
+ single-line-mode: true;
+
+ styles [
+ "title",
+ ]
+
+ label: bind template.item as <$GhosttyCommand>.title;
+ }
+
+ Gtk.Label {
+ ellipsize: end;
+ halign: start;
+ wrap: false;
+ single-line-mode: true;
+
+ styles [
+ "subtitle",
+ "monospace",
+ ]
+
+ label: bind template.item as <$GhosttyCommand>.action-key;
+ }
+ }
+
+ Gtk.ShortcutLabel {
+ accelerator: bind template.item as <$GhosttyCommand>.action;
+ valign: center;
+ }
+ };
+ }
+ };
+ }
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree-split.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree-split.blp
new file mode 100644
index 0000000..182919f
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree-split.blp
@@ -0,0 +1,20 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttySplitTreeSplit: Adw.Bin {
+ styles [
+ "split",
+ ]
+
+ // The double-nesting is required due to a GTK bug where you can't
+ // bind the first child of a builder layout. If you do, you get a double
+ // dispose. Easiest way to see that is simply remove this and see the
+ // GTK critical errors (and sometimes crashes).
+ Adw.Bin {
+ Paned paned {
+ notify::max-position => $notify_max_position();
+ notify::min-position => $notify_min_position();
+ notify::position => $notify_position();
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree.blp
new file mode 100644
index 0000000..e8c53b6
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/split-tree.blp
@@ -0,0 +1,25 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttySplitTree: Box {
+ notify::tree => $notify_tree();
+ orientation: vertical;
+
+ Adw.Bin tree_bin {
+ visible: bind template.has-surfaces;
+ hexpand: true;
+ vexpand: true;
+ }
+
+ // This could be a lot more visually pleasing but in practice this doesn't
+ // ever happen at the time of writing this comment. A surface-less split
+ // tree always closes its parent.
+ Label {
+ visible: bind template.has-surfaces inverted;
+ // Purposely not localized currently because this shouldn't really
+ // ever appear. When we have a situation it does appear, we may want
+ // to change the styling and text so I don't want to burden localizers
+ // to handle this yet.
+ label: "No surfaces.";
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/surface-scrolled-window.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/surface-scrolled-window.blp
new file mode 100644
index 0000000..722c442
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/surface-scrolled-window.blp
@@ -0,0 +1,11 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhostttySurfaceScrolledWindow: Adw.Bin {
+ notify::surface => $notify_surface();
+
+ Gtk.ScrolledWindow {
+ hscrollbar-policy: never;
+ vscrollbar-policy: bind $scrollbar_policy(template.config) as ;
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/tab.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/tab.blp
new file mode 100644
index 0000000..55f2e7e
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/tab.blp
@@ -0,0 +1,18 @@
+using Gtk 4.0;
+
+template $GhosttyTab: Box {
+ styles [
+ "tab",
+ ]
+
+ orientation: vertical;
+ hexpand: true;
+ vexpand: true;
+ title: bind $computed_title(template.config, split_tree.active-surface as <$GhosttySurface>.title, split_tree.active-surface as <$GhosttySurface>.title-override, template.title-override, split_tree.is-zoomed, split_tree.active-surface as <$GhosttySurface>.bell-ringing) as ;
+ tooltip: bind split_tree.active-surface as <$GhosttySurface>.pwd;
+
+ $GhosttySplitTree split_tree {
+ notify::active-surface => $notify_active_surface();
+ notify::tree => $notify_tree();
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/title-dialog.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/title-dialog.blp
new file mode 100644
index 0000000..737a92b
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/title-dialog.blp
@@ -0,0 +1,18 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttyTitleDialog: Adw.AlertDialog {
+ body: _("Leave blank to restore the default title.");
+
+ responses [
+ cancel: _("Cancel"),
+ ok: _("OK") suggested,
+ ]
+
+ default-response: "ok";
+ focus-widget: entry;
+
+ extra-child: Entry entry {
+ activates-default: true;
+ };
+}
diff --git a/crates/ghostty-apprt-gtk/resources/ui/1.5/window.blp b/crates/ghostty-apprt-gtk/resources/ui/1.5/window.blp
new file mode 100644
index 0000000..b66a930
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/resources/ui/1.5/window.blp
@@ -0,0 +1,323 @@
+using Gtk 4.0;
+using Adw 1;
+
+template $GhosttyWindow: Adw.ApplicationWindow {
+ styles [
+ "window",
+ ]
+
+ close-request => $close_request();
+ realize => $realize();
+ notify::config => $notify_config();
+ notify::fullscreened => $notify_fullscreened();
+ notify::is-active => $notify_is_active();
+ notify::maximized => $notify_maximized();
+ notify::quick-terminal => $notify_quick_terminal();
+ notify::scale-factor => $notify_scale_factor();
+ default-width: 800;
+ default-height: 600;
+ // GTK4 grabs F10 input by default to focus the menubar icon. We want
+ // to disable this so that terminal programs can capture F10 (such as htop)
+ handle-menubar-accel: false;
+
+ content: Adw.TabOverview tab_overview {
+ create-tab => $overview_create_tab();
+ notify::open => $overview_notify_open();
+ view: tab_view;
+ enable-new-tab: true;
+ // Disable the title buttons (close, maximize, minimize, ...)
+ // *inside* the tab overview if CSDs are disabled.
+ // We do spare the search button, though.
+ show-start-title-buttons: bind template.decorated;
+ show-end-title-buttons: bind template.decorated;
+
+ Adw.ToolbarView toolbar {
+ top-bar-style: bind template.toolbar-style;
+ bottom-bar-style: bind template.toolbar-style;
+
+ [top]
+ Adw.HeaderBar {
+ visible: bind template.headerbar-visible;
+
+ title-widget: Adw.WindowTitle {
+ title: bind template.title;
+ // Blueprint auto-formatter won't let me split this into multiple
+ // lines. Let me explain myself. All parameters to a closure are used
+ // as notifications to recompute the value of the closure. All
+ // elements of a property chain are also subscribed to for changes.
+ // This one long, ugly line saves us from manually building up this
+ // massive notify chain in code.
+ subtitle: bind $computed_subtitle(template.config, tab_view.selected-page.child as <$GhosttyTab>.active-surface as <$GhosttySurface>.pwd) as ;
+ };
+
+ [start]
+ Adw.SplitButton {
+ clicked => $new_tab();
+ icon-name: "tab-new-symbolic";
+ tooltip-text: _("New Tab");
+ dropdown-tooltip: _("New Split");
+ menu-model: split_menu;
+ can-focus: false;
+ focus-on-click: false;
+ }
+
+ [end]
+ Gtk.Box {
+ Gtk.ToggleButton {
+ icon-name: "view-grid-symbolic";
+ tooltip-text: _("View Open Tabs");
+ active: bind tab_overview.open bidirectional;
+ can-focus: false;
+ focus-on-click: false;
+ }
+
+ Gtk.MenuButton {
+ notify::active => $notify_menu_active();
+ icon-name: "open-menu-symbolic";
+ menu-model: main_menu;
+ tooltip-text: _("Main Menu");
+ can-focus: false;
+ }
+ }
+ }
+
+ [top]
+ Adw.TabBar tab_bar {
+ autohide: bind template.tabs-autohide;
+ expand-tabs: bind template.tabs-wide;
+ view: tab_view;
+ visible: bind template.tabs-visible;
+
+ [start]
+ Gtk.Box {
+ orientation: horizontal;
+ visible: bind $titlebar_style_is_tabs(template.titlebar-style) as ;
+
+ Gtk.WindowControls {
+ side: start;
+ }
+
+ Adw.SplitButton {
+ styles [
+ "flat",
+ ]
+
+ clicked => $new_tab();
+ icon-name: "tab-new-symbolic";
+ tooltip-text: _("New Tab");
+ dropdown-tooltip: _("New Split");
+ menu-model: split_menu;
+ can-focus: false;
+ focus-on-click: false;
+ }
+ }
+
+ [end]
+ Gtk.Box {
+ orientation: horizontal;
+ visible: bind $titlebar_style_is_tabs(template.titlebar-style) as ;
+
+ Gtk.ToggleButton {
+ styles [
+ "flat",
+ ]
+
+ icon-name: "view-grid-symbolic";
+ tooltip-text: _("View Open Tabs");
+ active: bind tab_overview.open bidirectional;
+ can-focus: false;
+ focus-on-click: false;
+ }
+
+ Gtk.MenuButton {
+ styles [
+ "flat",
+ ]
+
+ notify::active => $notify_menu_active();
+ icon-name: "open-menu-symbolic";
+ menu-model: main_menu;
+ tooltip-text: _("Main Menu");
+ can-focus: false;
+ }
+
+ Gtk.WindowControls {
+ side: end;
+ }
+ }
+ }
+
+ Box {
+ orientation: vertical;
+
+ $GhosttyDebugWarning {
+ visible: bind template.debug;
+ }
+
+ Adw.ToastOverlay toast_overlay {
+ Adw.TabView tab_view {
+ notify::n-pages => $notify_n_pages();
+ notify::selected-page => $notify_selected_page();
+ close-page => $close_page();
+ page-attached => $page_attached();
+ page-detached => $page_detached();
+ create-window => $tab_create_window();
+ setup-menu => $setup_tab_menu();
+ menu-model: tab_context_menu;
+ shortcuts: none;
+ }
+ }
+ }
+ }
+ };
+}
+
+menu split_menu {
+ item {
+ label: _("Split Up");
+ action: "win.split-up";
+ }
+
+ item {
+ label: _("Split Down");
+ action: "win.split-down";
+ }
+
+ item {
+ label: _("Split Left");
+ action: "win.split-left";
+ }
+
+ item {
+ label: _("Split Right");
+ action: "win.split-right";
+ }
+}
+
+menu main_menu {
+ section {
+ item {
+ label: _("Copy");
+ action: "win.copy";
+ }
+
+ item {
+ label: _("Paste");
+ action: "win.paste";
+ }
+ }
+
+ section {
+ item {
+ label: _("New Window");
+ action: "win.new-window";
+ }
+
+ item {
+ label: _("Close Window");
+ action: "win.close";
+ }
+ }
+
+ section {
+ item {
+ label: _("Change Tab Title…");
+ action: "win.prompt-tab-title";
+ }
+
+ item {
+ label: _("New Tab");
+ action: "win.new-tab";
+ }
+
+ item {
+ label: _("Close Tab");
+ action: "win.close-tab";
+ target: "this";
+ }
+ }
+
+ section {
+ submenu {
+ label: _("Split");
+
+ item {
+ label: _("Change Title…");
+ action: "win.prompt-surface-title";
+ }
+
+ item {
+ label: _("Split Up");
+ action: "win.split-up";
+ }
+
+ item {
+ label: _("Split Down");
+ action: "win.split-down";
+ }
+
+ item {
+ label: _("Split Left");
+ action: "win.split-left";
+ }
+
+ item {
+ label: _("Split Right");
+ action: "win.split-right";
+ }
+ }
+ }
+
+ section {
+ item {
+ label: _("Clear");
+ action: "win.clear";
+ }
+
+ item {
+ label: _("Reset");
+ action: "win.reset";
+ }
+ }
+
+ section {
+ item {
+ label: _("Command Palette");
+ action: "win.toggle-command-palette";
+ }
+
+ item {
+ label: _("Terminal Inspector");
+ action: "win.toggle-inspector";
+ }
+
+ item {
+ label: _("Open Configuration");
+ action: "app.open-config";
+ }
+
+ item {
+ label: _("Reload Configuration");
+ action: "app.reload-config";
+ }
+ }
+
+ section {
+ item {
+ label: _("About Ghostty");
+ action: "win.about";
+ }
+
+ item {
+ label: _("Quit");
+ action: "app.quit";
+ }
+ }
+}
+
+menu tab_context_menu {
+ item {
+ label: _("Change Tab Title…");
+ action: "win.prompt-context-tab-title";
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/src/adw_version.rs b/crates/ghostty-apprt-gtk/src/adw_version.rs
new file mode 100644
index 0000000..9c8313f
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/src/adw_version.rs
@@ -0,0 +1,79 @@
+//! libadwaita version helpers (port of `apprt/gtk/adw_version.zig`).
+
+use crate::gtk_version::Version;
+
+/// The libadwaita feature level this crate is compiled against (`v1_5`).
+pub const COMPTIME_VERSION: Version = (1, 5, 0);
+
+/// Returns the runtime libadwaita version.
+pub fn get_runtime_version() -> Version {
+ (
+ adw::major_version(),
+ adw::minor_version(),
+ adw::micro_version(),
+ )
+}
+
+/// Logs the build and runtime libadwaita version.
+pub fn log_version() {
+ let (a, b, c) = COMPTIME_VERSION;
+ let (x, y, z) = get_runtime_version();
+ log::info!("libadwaita version build={a}.{b}.{c} runtime={x}.{y}.{z}");
+}
+
+/// Verifies that the libadwaita version at runtime is at least the given
+/// version (callers needing newer API must also gate on a cargo feature).
+pub fn at_least(major: u32, minor: u32, micro: u32) -> bool {
+ runtime_at_least(major, minor, micro)
+}
+
+/// Verifies that the libadwaita runtime version is at least the given version.
+pub fn runtime_at_least(major: u32, minor: u32, micro: u32) -> bool {
+ get_runtime_version() >= (major, minor, micro)
+}
+
+/// Whether AdwDialog, AdwAlertDialog, etc. are supported (1.5+).
+pub fn supports_dialogs() -> bool {
+ at_least(1, 5, 0)
+}
+
+pub fn supports_tab_overview() -> bool {
+ at_least(1, 4, 0)
+}
+
+pub fn supports_switch_row() -> bool {
+ at_least(1, 4, 0)
+}
+
+pub fn supports_toolbar_view() -> bool {
+ at_least(1, 4, 0)
+}
+
+pub fn supports_banner() -> bool {
+ at_least(1, 3, 0)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn version_at_least() {
+ // libadwaita requires GTK init, which only works on the main thread
+ // with a display; skip otherwise.
+ if adw::init().is_err() {
+ return;
+ }
+ let (a, b, c) = get_runtime_version();
+ for f in [at_least, runtime_at_least] {
+ assert!(f(a, b, c));
+ assert!(!f(a, b, c + 1));
+ assert!(!f(a, b + 1, c));
+ assert!(!f(a + 1, b, c));
+ assert!(f(a - 1, b, c));
+ assert!(f(a - 1, b + 1, c));
+ assert!(f(a - 1, b, c + 1));
+ assert!(f(a, b - 1, c + 1));
+ }
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/src/app.rs b/crates/ghostty-apprt-gtk/src/app.rs
new file mode 100644
index 0000000..9f0bf1d
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/src/app.rs
@@ -0,0 +1,89 @@
+//! Port of `apprt/gtk/App.zig`: the apprt `App` handed to the core. It is a
+//! thin wrapper around the [`Application`] GObject.
+//!
+//! ```ignore
+//! let app = App::new(core_app); // loads config, creates GtkApplication
+//! app.run()?; // main loop (ticks core_app)
+//! app.terminate();
+//! ```
+
+use std::rc::Rc;
+use std::sync::Arc;
+
+use ghostty_apprt::action::{Action, Target};
+use ghostty_apprt::ipc;
+
+use crate::class::application::{Application, RunError};
+use crate::core::{CoreApp, SurfaceId, Waker};
+
+/// This is detected by the Renderer, in which case it sends a
+/// `redraw_surface` message so that we can call `drawFrame` ourselves from
+/// the app thread, because GTK's `GLArea` does not support drawing from a
+/// different thread.
+pub const MUST_DRAW_FROM_APP_THREAD: bool = true;
+
+/// GTK application ID (Zig: `App.application_id`).
+pub use crate::APPLICATION_ID as application_id;
+/// GTK object path (Zig: `App.object_path`).
+pub use crate::OBJECT_PATH as object_path;
+
+/// The [`Waker`] given to core threads: wakes the GLib main context so the
+/// app loop runs `CoreApp::tick`.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct GlibWaker;
+
+impl Waker for GlibWaker {
+ fn wake(&self) {
+ gtk::glib::MainContext::default().wakeup();
+ }
+}
+
+/// A new thread-safe waker (create it before the core app, hand it to core).
+#[must_use]
+pub fn waker() -> Arc {
+ Arc::new(GlibWaker)
+}
+
+/// The apprt App.
+pub struct App {
+ /// The GObject Application instance.
+ pub app: Application,
+}
+
+impl App {
+ /// `App.init`: creates the GTK application (loads the configuration,
+ /// initializes GTK/libadwaita).
+ #[must_use]
+ pub fn new(core_app: Rc) -> Self {
+ Self {
+ app: Application::new(core_app),
+ }
+ }
+
+ /// `App.run`: run until quit.
+ pub fn run(&self) -> Result<(), RunError> {
+ self.app.run_loop()
+ }
+
+ /// `App.terminate`: force deinitialize the app (other things tend to
+ /// still hold references, so this forces the disposal now).
+ pub fn terminate(&self) {
+ self.app.deinit();
+ }
+
+ /// `App.wakeup`: wake up the event loop (thread safe).
+ pub fn wakeup(&self) {
+ self.app.wakeup();
+ }
+
+ /// `App.performAction`.
+ pub fn perform_action(&self, target: Target, action: Action) -> bool {
+ self.app.perform_action(target, action)
+ }
+
+ /// `App.performIpc`: send the IPC to a running Ghostty. Static: it's
+ /// called from a CLI process without a full-featured apprt App.
+ pub fn perform_ipc(target: &ipc::Target, action: &ipc::Action) -> Result {
+ crate::ipc::perform_ipc(target, action)
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/src/cgroup.rs b/crates/ghostty-apprt-gtk/src/cgroup.rs
new file mode 100644
index 0000000..da1d27e
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/src/cgroup.rs
@@ -0,0 +1,86 @@
+//! Transient systemd scope creation over D-Bus (port of `apprt/gtk/cgroup.zig`).
+
+use gtk::gio;
+use gtk::glib;
+use gtk::prelude::*;
+
+/// Properties for the transient scope.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Options {
+ /// `MemoryHigh` in bytes.
+ pub memory_high: Option,
+ /// `TasksMax`.
+ pub tasks_max: Option,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error("D-Bus call failed")]
+ DbusCallFailed,
+}
+
+/// The scope unit name for the given PID.
+pub fn fmt_scope(pid: u32) -> String {
+ format!("app-ghostty-surface-transient-{pid}.scope")
+}
+
+/// Create a transient systemd scope containing `pid` via
+/// `org.freedesktop.systemd1.Manager.StartTransientUnit`.
+pub fn create_scope(dbus: &gio::DBusConnection, pid: u32, options: Options) -> Result<(), Error> {
+ // The unit name needs to be unique. We use the PID for this.
+ let name = fmt_scope(pid);
+
+ // Properties
+ let mut properties: Vec<(String, glib::Variant)> = Vec::new();
+ if let Some(v) = options.memory_high {
+ properties.push(("MemoryHigh".into(), v.to_variant()));
+ }
+ if let Some(v) = options.tasks_max {
+ properties.push(("TasksMax".into(), v.to_variant()));
+ }
+ // https://www.freedesktop.org/software/systemd/man/latest/systemd-oomd.service.html
+ properties.push(("ManagedOOMMemoryPressure".into(), "kill".to_variant()));
+ // PID to move into the unit
+ properties.push(("PIDs".into(), vec![pid].to_variant()));
+
+ // Aux - unused but must be present
+ let aux: Vec<(String, Vec<(String, glib::Variant)>)> = Vec::new();
+
+ let params = (name, "fail".to_owned(), properties, aux).to_variant();
+
+ dbus.call_sync(
+ Some("org.freedesktop.systemd1"),
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "StartTransientUnit",
+ Some(¶ms),
+ Some(glib::VariantTy::new("(o)").map_err(|_| Error::DbusCallFailed)?),
+ gio::DBusCallFlags::NONE,
+ -1,
+ gio::Cancellable::NONE,
+ )
+ .map(|_| ())
+ .map_err(|e| {
+ log::error!("creating transient cgroup scope failed err={e}");
+ Error::DbusCallFailed
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn fmt_scope_test() {
+ assert_eq!(fmt_scope(42), "app-ghostty-surface-transient-42.scope");
+ assert!(fmt_scope(u32::MAX).len() < 256);
+ }
+
+ #[test]
+ fn scope_params_signature() {
+ let props: Vec<(String, glib::Variant)> = vec![("PIDs".into(), vec![1u32].to_variant())];
+ let aux: Vec<(String, Vec<(String, glib::Variant)>)> = Vec::new();
+ let v = ("n".to_owned(), "fail".to_owned(), props, aux).to_variant();
+ assert_eq!(v.type_().as_str(), "(ssa(sv)a(sa(sv)))");
+ }
+}
diff --git a/crates/ghostty-apprt-gtk/src/class/application.rs b/crates/ghostty-apprt-gtk/src/class/application.rs
new file mode 100644
index 0000000..d905ff2
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/src/class/application.rs
@@ -0,0 +1,1841 @@
+//! `GhosttyApplication` (ZIG/src/apprt/gtk/class/application.zig): the
+//! primary entrypoint of the GTK runtime. Wraps an `AdwApplication`, owns the
+//! config, windowing-protocol state, CSS providers and global shortcuts, and
+//! implements the apprt action switch ([`Application::perform_action`]).
+//!
+//! Public API used by the other classes:
+//! * [`Application::default`] -> the running application
+//! * [`Application::core`] / [`Application::rt`] -> `Rc` / `Rc`
+//! * [`Application::get_config`] -> `class::config::Config` object (property `config`)
+//! * [`Application::core_config`] -> `Arc`
+//! * [`Application::winproto`] / [`Application::winproto_mut`]
+//! * [`Application::saved_language`], [`Application::wakeup`], [`Application::quit`]
+
+#![allow(
+ clippy::needless_pass_by_value,
+ clippy::unused_self,
+ clippy::type_complexity,
+ clippy::should_implement_trait
+)]
+
+use std::cell::{Cell, OnceCell, Ref, RefCell, RefMut};
+use std::rc::Rc;
+use std::sync::Arc;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use ghostty_apprt::action::{self, Action, Target};
+use ghostty_apprt::structs::ColorScheme;
+use ghostty_config::cli_args::ConfigField;
+use ghostty_config::command::Command;
+use ghostty_config::config::Config as CoreConfig;
+use ghostty_config::types_b::{GtkSingleInstance, WindowTheme};
+use ghostty_input::binding::Action as BindingAction;
+use gtk::{gdk, gio, glib};
+
+use crate::class::close_confirmation_dialog::{self, CloseConfirmationDialog};
+use crate::class::config::Config;
+use crate::class::config_errors_dialog::ConfigErrorsDialog;
+use crate::class::global_shortcuts::GlobalShortcuts;
+use crate::class::split_tree::SplitTree;
+use crate::class::surface::{Size, Surface};
+use crate::class::tab::Tab;
+use crate::class::window::{SelectTab, TabOverrides, Window};
+use crate::core::{AppMessage, CoreApp, RtApp, SurfaceId};
+use crate::css::CssProviders;
+use crate::winproto;
+
+/// Errors from [`Application::run_loop`].
+#[derive(Debug, thiserror::Error)]
+pub enum RunError {
+ #[error("unable to acquire the default main context")]
+ ContextAcquireFailed,
+ #[error("unable to register the application")]
+ ApplicationRegisterFailed,
+ #[error("core app tick failed: {0}")]
+ Tick(String),
+}
+
+/// State of the quit-after-last-window-closed timer.
+#[derive(Debug, Default)]
+pub enum QuitTimer {
+ #[default]
+ Off,
+ Active(glib::SourceId),
+ Expired,
+}
+
+/// Overrides for a new window (Zig: `newWindow` overrides struct).
+#[derive(Debug, Default, Clone)]
+pub struct WindowOverrides {
+ pub command: Option,
+ pub working_directory: Option,
+ pub title: Option,
+}
+
+// ---------------------------------------------------------------------
+// Process level helpers
+
+/// Set an environment variable.
+#[allow(unsafe_code)]
+fn set_env(key: &str, value: &str) {
+ // SAFETY: only called during application construction on the main
+ // thread, before GTK is initialized and before we spawn any child
+ // processes; no other thread in this crate reads the environment.
+ unsafe { std::env::set_var(key, value) }
+}
+
+/// Funnel GLib/GObject/GTK log messages into the `log` crate rather than
+/// having them dumped directly to stderr.
+fn glib_log_writer(level: glib::LogLevel, fields: &[glib::LogField<'_>]) -> glib::LogWriterOutput {
+ let mut message = None;
+ let mut domain = None;
+ for f in fields {
+ match f.key() {
+ "MESSAGE" => message = f.value_str(),
+ "GLIB_DOMAIN" => domain = f.value_str(),
+ _ => {}
+ }
+ }
+ let Some(message) = message else {
+ return glib::LogWriterOutput::Unhandled;
+ };
+ let domain = domain.unwrap_or("«unknown»");
+ match level {
+ glib::LogLevel::Error => log::error!(target: "glib", "ERROR: {domain}: {message}"),
+ glib::LogLevel::Critical => log::error!(target: "glib", "CRITICAL: {domain}: {message}"),
+ glib::LogLevel::Warning => log::warn!(target: "glib", "WARNING: {domain}: {message}"),
+ glib::LogLevel::Message => log::info!(target: "glib", "MESSAGE: {domain}: {message}"),
+ glib::LogLevel::Info => log::info!(target: "glib", "INFO: {domain}: {message}"),
+ glib::LogLevel::Debug => log::debug!(target: "glib", "DEBUG: {domain}: {message}"),
+ }
+ glib::LogWriterOutput::Handled
+}
+
+fn runtime_at_least(major: u32, minor: u32, micro: u32) -> bool {
+ (
+ gtk::major_version(),
+ gtk::minor_version(),
+ gtk::micro_version(),
+ ) >= (major, minor, micro)
+}
+
+/// Sets various GTK-related environment variables as necessary given the
+/// runtime environment or configuration. Must be called BEFORE GTK
+/// initialization.
+fn set_gtk_env(config: &CoreConfig) {
+ // gdk_debug flags
+ let mut opengl = config.gtk_opengl_debug;
+ let mut gl_disable_gles = false;
+ let mut gl_no_fractional = false;
+ let mut vulkan_disable = false;
+
+ // gdk_disable flags
+ let mut gles_api = false;
+ // current gtk implementation for color management is not good enough.
+ // see: https://bugs.kde.org/show_bug.cgi?id=495647
+ let mut color_mgmt = true;
+ let mut vulkan = false;
+
+ 'environment: {
+ if runtime_at_least(4, 18, 0) {
+ color_mgmt = false;
+ }
+
+ if runtime_at_least(4, 16, 0) {
+ // From gtk 4.16, GDK_DEBUG is split into GDK_DEBUG and GDK_DISABLE.
+ gles_api = true;
+ vulkan = true;
+ break 'environment;
+ }
+ if runtime_at_least(4, 14, 0) {
+ // We need to export GDK_DEBUG to run on Wayland after GTK 4.14.
+ // Upstream issue: https://gitlab.gnome.org/GNOME/gtk/-/issues/6589
+ gl_disable_gles = true;
+ vulkan_disable = true;
+ if !runtime_at_least(4, 17, 5) {
+ // Removed at GTK v4.17.5
+ gl_no_fractional = true;
+ }
+ break 'environment;
+ }
+ // Versions prior to 4.14 are a bit of an unknown for Ghostty.
+ vulkan_disable = true;
+ }
+ // `gtk-opengl-debug` dumps logs directly to stderr.
+ opengl = opengl && std::io::IsTerminal::is_terminal(&std::io::stderr());
+
+ let join = |flags: &[(&str, bool)]| {
+ flags
+ .iter()
+ .filter(|(_, on)| *on)
+ .map(|(name, _)| *name)
+ .collect::>()
+ .join(",")
+ };
+
+ let gdk_debug = join(&[
+ ("opengl", opengl),
+ ("gl-disable-gles", gl_disable_gles),
+ ("gl-no-fractional", gl_no_fractional),
+ ("vulkan-disable", vulkan_disable),
+ ]);
+ log::warn!("setting GDK_DEBUG={gdk_debug}");
+ set_env("GDK_DEBUG", &gdk_debug);
+
+ let gdk_disable = join(&[
+ ("gles-api", gles_api),
+ ("color-mgmt", color_mgmt),
+ ("vulkan", vulkan),
+ ]);
+ log::warn!("setting GDK_DISABLE={gdk_disable}");
+ set_env("GDK_DISABLE", &gdk_disable);
+}
+
+/// Call `setlocale(LC_ALL, "")` like Ghostty's `global.zig` does at startup
+/// (see docs/rewrite/INTEGRATION_TODO.md). Idempotent.
+#[allow(unsafe_code)]
+pub fn init_locale() {
+ static ONCE: std::sync::Once = std::sync::Once::new();
+ ONCE.call_once(|| {
+ // SAFETY: called with a valid NUL-terminated empty string at startup
+ // before other threads depend on the locale.
+ unsafe {
+ libc::setlocale(libc::LC_ALL, c"".as_ptr());
+ }
+ });
+}
+
+// ---------------------------------------------------------------------
+// RtApp
+
+/// The `RtApp` handed to core. Stateless; forwards to the default
+/// application. Core must only call it from the main thread.
+#[derive(Debug, Default)]
+pub struct AppRt;
+
+impl RtApp for AppRt {
+ fn perform_action(&self, target: Target, action: Action) -> bool {
+ Application::default().perform_action(target, action)
+ }
+}
+
+mod imp {
+ use super::{
+ AppMessage, Cell, Config, ConfigErrorsDialog, CoreApp, CssProviders, GlobalShortcuts,
+ OnceCell, QuitTimer, Rc, RefCell, RtApp, glib, winproto,
+ };
+ use adw::prelude::*;
+ use adw::subclass::prelude::*;
+ use gtk::gio;
+
+ #[derive(Default)]
+ pub struct Application {
+ /// The libghostty App instance.
+ pub core_app: OnceCell>,
+ pub rt_app: OnceCell>,
+
+ /// The configuration for the application.
+ pub config: RefCell>,
+
+ /// State and logic for the underlying windowing protocol.
+ pub winproto: RefCell>,
+
+ /// The global shortcut logic.
+ pub global_shortcuts: OnceCell,
+
+ /// Set to true so long as we request a window exactly once. This
+ /// prevents quitting the app before we've shown one window.
+ pub requested_window: Cell,
+
+ /// Set to false internally when the event loop should exit.
+ pub running: Cell,
+
+ pub quit_timer: RefCell,
+
+ /// The config errors dialog (weak: it can close on its own).
+ pub config_errors_dialog: glib::WeakRef,
+
+ pub signal_thread_started: Cell,
+
+ /// CSS providers (runtime + custom).
+ pub css: RefCell>,
+
+ /// Copy of the LANG variable provided by the system, if any.
+ pub saved_language: RefCell>,
+ }
+
+ #[glib::object_subclass]
+ impl ObjectSubclass for Application {
+ const NAME: &'static str = "GhosttyApplication";
+ type Type = super::Application;
+ type ParentType = adw::Application;
+ }
+
+ impl ObjectImpl for Application {
+ fn properties() -> &'static [glib::ParamSpec] {
+ static PROPS: std::sync::OnceLock> = std::sync::OnceLock::new();
+ PROPS.get_or_init(|| {
+ vec![
+ glib::ParamSpecObject::builder::("config")
+ .read_only()
+ .build(),
+ ]
+ })
+ }
+
+ fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+ match pspec.name() {
+ "config" => self.config.borrow().to_value(),
+ name => unimplemented!("unknown property {name}"),
+ }
+ }
+
+ fn dispose(&self) {
+ if let Some(diag) = self.config_errors_dialog.upgrade() {
+ diag.close();
+ }
+ }
+ }
+
+ impl ApplicationImpl for Application {
+ fn startup(&self) {
+ log::debug!("startup");
+ self.parent_startup();
+ let obj = self.obj();
+
+ // Set ourselves as the default application.
+ gio::Application::set_default(obj.upcast_ref::());
+
+ // Setup our style manager (light/dark mode)
+ obj.startup_style_manager();
+ // Setup some signal handlers
+ obj.startup_signals();
+ // Setup our action map
+ obj.startup_action_map();
+ // Setup our global shortcuts
+ obj.startup_global_shortcuts();
+
+ // If we have any config diagnostics from loading, then we show
+ // the diagnostics dialog. We show this one as a general modal
+ // (not to any specific window) because we don't even know if the
+ // window will load.
+ obj.show_config_errors_dialog();
+ }
+
+ fn activate(&self) {
+ log::debug!("activate");
+ // Queue a new window
+ if let Some(core) = self.core_app.get() {
+ core.push_message(AppMessage::NewWindow);
+ }
+ self.parent_activate();
+ }
+ }
+
+ impl GtkApplicationImpl for Application {}
+ impl AdwApplicationImpl for Application {}
+}
+
+glib::wrapper! {
+ pub struct Application(ObjectSubclass)
+ @extends adw::Application, gtk::Application, gio::Application,
+ @implements gio::ActionGroup, gio::ActionMap;
+}
+
+impl Application {
+ /// Get the default (running) application.
+ ///
+ /// Panics if there is no default application or it is not a
+ /// GhosttyApplication.
+ pub fn default() -> Self {
+ gio::Application::default()
+ .and_then(|a| a.downcast::().ok())
+ .expect("no default GhosttyApplication")
+ }
+
+ /// Creates a new Application instance. This does a lot more work than a
+ /// typical class instantiation, because we expect that this is the main
+ /// program entrypoint. Every error is mapped to some degraded state
+ /// where we can at least show a window with an error.
+ pub fn new(core_app: Rc) -> Self {
+ init_locale();
+
+ // Capture GLib/GObject/GTK log messages.
+ glib::log_set_writer_func(glib_log_writer);
+
+ // Load our configuration.
+ let mut config = match CoreConfig::load() {
+ Ok(c) => c,
+ Err(err) => {
+ // If we fail to load the configuration, then we should log
+ // the error in the diagnostics so it can be shown to the user.
+ let mut def = CoreConfig::new_default();
+ def.add_diagnostic(format!("error loading user configuration: {err}"));
+ def
+ }
+ };
+
+ let saved_language = std::env::var("LANG").ok();
+ if let Some(language) = &config.language {
+ set_env("LANG", language);
+ }
+
+ // Set gettext global domain to be our app so that our unqualified
+ // translations map to our translations.
+ if let Err(err) = ghostty_os::i18n::init_global_domain() {
+ // Failures shouldn't stop application startup.
+ log::warn!("i18n initialization failed error={err:?}");
+ }
+
+ // Setup our GTK init env vars
+ set_gtk_env(&config);
+ if let Err(err) = gtk::init() {
+ log::error!("failed to initialize GTK: {err}");
+ std::process::exit(1);
+ }
+ if let Err(err) = adw::init() {
+ log::error!("failed to initialize libadwaita: {err}");
+ }
+
+ // Log our GTK versions (libadwaita requires GTK to be initialized
+ // first in the Rust bindings).
+ crate::gtk_version::log_version();
+ crate::adw_version::log_version();
+
+ let single_instance = match config.gtk_single_instance {
+ GtkSingleInstance::True => true,
+ GtkSingleInstance::False => false,
+ // This should have been resolved to true/false during config loading.
+ GtkSingleInstance::Detect => {
+ log::warn!("gtk-single-instance=detect was not resolved, assuming true");
+ true
+ }
+ };
+
+ // Setup the flags for our application.
+ let mut flags = gio::ApplicationFlags::default();
+ if !single_instance {
+ flags |= gio::ApplicationFlags::NON_UNIQUE;
+ }
+
+ // Our app ID determines uniqueness and maps to our desktop file.
+ let app_id: String = match &config.class {
+ Some(class) if gio::Application::id_is_valid(class) => class.clone(),
+ Some(_) => {
+ log::warn!("invalid 'class' in config, ignoring");
+ crate::APPLICATION_ID.to_owned()
+ }
+ None => crate::APPLICATION_ID.to_owned(),
+ };
+
+ let Some(display) = gdk::Display::default() else {
+ // I'm unsure of any scenario where this happens.
+ log::warn!("gdk display is null, exiting");
+ std::process::exit(1);
+ };
+
+ // Setup our windowing protocol logic
+ let wp = match winproto::App::init(&display, &app_id, &config) {
+ Ok(wp) => wp,
+ Err(err) => {
+ // If we fail to detect or setup the windowing protocol
+ // specifics, we fallback to a noop implementation.
+ log::warn!("error initializing windowing protocol err={err}");
+ winproto::App::None(winproto::noop::App)
+ }
+ };
+ log::debug!("windowing protocol={:?}", wp.protocol());
+
+ log::debug!("creating GTK application id={app_id} single-instance={single_instance}");
+
+ // Wrap our configuration in a GObject.
+ let _ = &mut config;
+ let config_obj = Config::new(&config);
+
+ // Internally, GTK ensures that only one instance of this provider
+ // exists in the provider list for the display.
+ let css = CssProviders::new(&display);
+
+ let obj: Self = glib::Object::builder()
+ .property("application-id", app_id)
+ .property("flags", flags)
+ // Force the resource path to a known value so it doesn't depend
+ // on the app id and force it to load in compiled resources.
+ .property("resource-base-path", crate::RESOURCE_PREFIX)
+ .build();
+
+ let imp = obj.imp();
+ let _ = imp.core_app.set(core_app);
+ let _ = imp.rt_app.set(Rc::new(AppRt));
+ *imp.config.borrow_mut() = Some(config_obj);
+ *imp.winproto.borrow_mut() = Some(wp);
+ *imp.css.borrow_mut() = Some(css);
+ let _ = imp.global_shortcuts.set(GlobalShortcuts::new());
+ *imp.saved_language.borrow_mut() = saved_language;
+
+ // Signals
+ obj.connect_notify_local(Some("config"), |this, _| this.prop_config());
+
+ // Trigger initial config changes
+ obj.notify("config");
+
+ obj
+ }
+
+ /// Force deinitialize the application (Zig: `deinit`). Applications are
+ /// never fully unreferenced so this ensures our state is released.
+ pub fn deinit(&self) {
+ let imp = self.imp();
+ *imp.css.borrow_mut() = None;
+ *imp.winproto.borrow_mut() = None;
+ *imp.config.borrow_mut() = None;
+ if let Some(gs) = imp.global_shortcuts.get() {
+ gs.set_connection(None);
+ }
+ *imp.saved_language.borrow_mut() = None;
+ }
+
+ // -----------------------------------------------------------------
+ // Accessors
+
+ /// The core app. Not reference counted in Zig; here a cheap `Rc` clone.
+ pub fn core(&self) -> Rc {
+ self.imp().core_app.get().expect("core app set").clone()
+ }
+
+ /// The `RtApp` implementation to hand to core.
+ pub fn rt(&self) -> Rc {
+ self.imp().rt_app.get().expect("rt app set").clone()
+ }
+
+ /// The configuration object (property `config`). Increments its refcount.
+ pub fn get_config(&self) -> Config {
+ self.imp()
+ .config
+ .borrow()
+ .clone()
+ .expect("application config")
+ }
+
+ /// The configuration, as a shared core config.
+ pub fn core_config(&self) -> Arc {
+ self.get_config().get()
+ }
+
+ /// The windowing protocol state. Panics if called after `deinit`.
+ pub fn winproto(&self) -> Ref<'_, winproto::App> {
+ Ref::map(self.imp().winproto.borrow(), |v| {
+ v.as_ref().expect("winproto available")
+ })
+ }
+
+ /// Mutable windowing protocol state (needed by `init_quick_terminal`).
+ pub fn winproto_mut(&self) -> RefMut<'_, winproto::App> {
+ RefMut::map(self.imp().winproto.borrow_mut(), |v| {
+ v.as_mut().expect("winproto available")
+ })
+ }
+
+ /// The original `LANG` Ghostty was launched with (None if unset).
+ pub fn saved_language(&self) -> Option {
+ self.imp().saved_language.borrow().clone()
+ }
+
+ /// All live surfaces (Zig: `core_app.surfaces.items` mapped to GObjects).
+ pub fn surfaces(&self) -> Vec {
+ self.core()
+ .surface_ids()
+ .into_iter()
+ .filter_map(Surface::from_id)
+ .collect()
+ }
+
+ /// Wake the main loop (Zig: `wakeup`). Thread safe.
+ pub fn wakeup(&self) {
+ glib::MainContext::default().wakeup();
+ }
+
+ /// Mark that a window was requested at least once.
+ pub fn mark_requested_window(&self) {
+ self.imp().requested_window.set(true);
+ }
+
+ // -----------------------------------------------------------------
+ // Run loop
+
+ /// Run the application. Replacement for `gio::Application::run` because
+ /// we want tighter control over the event loop to integrate with core.
+ pub fn run_loop(&self) -> Result<(), RunError> {
+ // Based on the actual `gio.Application.run` implementation.
+ let ctx = glib::MainContext::default();
+ let _guard = ctx.acquire().map_err(|_| RunError::ContextAcquireFailed)?;
+
+ let result = self.run_loop_inner(&ctx);
+
+ // The final cleanup that is always required at the end of running.
+ self.stop_quit_timer();
+ gio::Settings::sync();
+ // Clear out the event loop, don't block.
+ while ctx.iteration(false) {}
+ result
+ }
+
+ fn run_loop_inner(&self, ctx: &glib::MainContext) -> Result<(), RunError> {
+ let gapp = self.upcast_ref::();
+
+ // Register the application
+ if let Err(err) = gapp.register(gio::Cancellable::NONE) {
+ log::warn!("error registering application: {}", err.message());
+ return Err(RunError::ApplicationRegisterFailed);
+ }
+
+ // This just calls the `activate` signal but its part of the normal
+ // startup routine, but only if the config allows it.
+ if self.core_config().initial_window {
+ gapp.activate();
+ }
+
+ // If we are NOT the primary instance, then we never want to run.
+ if gapp.is_remote() {
+ log::debug!("application is remote, exiting run loop after activation");
+ return Ok(());
+ }
+
+ // Tell systemd that we are ready.
+ ghostty_os::systemd::notify::ready();
+
+ log::debug!("entering runloop");
+ let imp = self.imp();
+ imp.running.set(true);
+ let core = self.core();
+ let rt = self.rt();
+ let mut result = Ok(());
+ while imp.running.get() {
+ ctx.iteration(true);
+
+ // Tick the core Ghostty terminal app
+ if let Err(err) = core.tick(&*rt) {
+ log::error!("core tick failed: {err}");
+ result = Err(RunError::Tick(err.to_string()));
+ break;
+ }
+
+ // Check if we must quit based on the current state.
+ let must_quit = {
+ let config = self.core_config();
+ if !config.quit_after_last_window_closed {
+ // If we are configured to always stay running, don't quit.
+ false
+ } else if matches!(*imp.quit_timer.borrow(), QuitTimer::Expired) {
+ // If the quit timer has expired, quit.
+ log::debug!("must_quit due to quit timer expired");
+ true
+ } else if config.quit_after_last_window_closed_delay.is_none()
+ && imp.requested_window.get()
+ && self.windows().is_empty()
+ {
+ // No windows attached to our app. Only if we don't have
+ // the closed delay set.
+ log::debug!("must_quit due to no app windows");
+ true
+ } else {
+ false
+ }
+ };
+
+ if must_quit {
+ // All must quit scenarios do not need confirmation.
+ self.quit_now();
+ }
+ }
+ log::debug!("exiting runloop");
+ result
+ }
+
+ /// Quit the application. This starts the process to stop the run loop.
+ /// It will not exit the process.
+ pub fn quit(&self) {
+ let imp = self.imp();
+
+ // If our run loop has already exited then we are done.
+ if !imp.running.get() {
+ return;
+ }
+
+ // If our core app doesn't need to confirm quit then we can exit now.
+ if !self.core().needs_confirm_quit() {
+ self.quit_now();
+ return;
+ }
+
+ // Get the parent for our dialog
+ let parent = gtk::Window::list_toplevels().into_iter().find(|w| {
+ w.downcast_ref::()
+ .is_some_and(gtk::Window::is_active)
+ });
+
+ // Show a confirmation dialog
+ let dialog = CloseConfirmationDialog::new(close_confirmation_dialog::Target::App);
+ let this = self.downgrade();
+ dialog.connect_close_request(move |_| {
+ if let Some(this) = this.upgrade() {
+ this.quit_now();
+ }
+ });
+
+ // Show it
+ dialog.present(parent.as_ref());
+ }
+
+ fn quit_now(&self) {
+ // Get all our windows and destroy them, forcing them to free. We
+ // only want to destroy our windows (they own every other type of
+ // window) so this triggers a proper shutdown sequence.
+ for w in gtk::Window::list_toplevels() {
+ if let Ok(window) = w.downcast::() {
+ window.destroy();
+ }
+ }
+
+ // Trigger our runloop exit.
+ self.imp().running.set(false);
+ }
+
+ // -----------------------------------------------------------------
+ // Quit timer
+
+ /// Called when there are no more open surfaces.
+ fn start_quit_timer(&self) {
+ let config = self.core_config();
+
+ // Cancel any previous timer.
+ self.stop_quit_timer();
+
+ // This is a no-op unless we are configured to quit after last window closed.
+ if !config.quit_after_last_window_closed {
+ return;
+ }
+
+ // If a delay is configured, set a timeout function to quit after the delay.
+ let imp = self.imp();
+ if let Some(v) = &config.quit_after_last_window_closed_delay {
+ let this = self.downgrade();
+ let id = glib::timeout_add_local(
+ std::time::Duration::from_millis(u64::from(v.as_milliseconds())),
+ move || {
+ if let Some(this) = this.upgrade() {
+ *this.imp().quit_timer.borrow_mut() = QuitTimer::Expired;
+ }
+ glib::ControlFlow::Break
+ },
+ );
+ *imp.quit_timer.borrow_mut() = QuitTimer::Active(id);
+ } else {
+ // If no delay is configured, treat it as expired.
+ *imp.quit_timer.borrow_mut() = QuitTimer::Expired;
+ }
+ }
+
+ /// Called when a new surface gets opened.
+ fn stop_quit_timer(&self) {
+ let old = std::mem::take(&mut *self.imp().quit_timer.borrow_mut());
+ if let QuitTimer::Active(id) = old {
+ id.remove();
+ }
+ }
+
+ // -----------------------------------------------------------------
+ // Config / CSS / accelerators
+
+ /// Set the configuration for this application. If the config has errors
+ /// this may show the config errors dialog.
+ fn set_config(&self, config: &Config) {
+ *self.imp().config.borrow_mut() = Some(config.clone());
+ self.notify("config");
+
+ // Show our errors if we have any
+ self.show_config_errors_dialog();
+ }
+
+ fn prop_config(&self) {
+ // Sync our accelerators for menu items.
+ self.sync_action_accelerators();
+
+ // Load our runtime and custom CSS.
+ let config = self.core_config();
+ if let Some(css) = self.imp().css.borrow_mut().as_mut() {
+ css.load_all(&config);
+ }
+
+ // Keep global shortcuts in sync with the config (property binding).
+ if let Some(gs) = self.imp().global_shortcuts.get() {
+ gs.set_config(self.imp().config.borrow().as_ref());
+ }
+ }
+
+ fn sync_action_accelerators(&self) {
+ use ghostty_input::binding::action::{
+ CloseTabMode, CopyToClipboard, InspectorMode, SplitDirection,
+ };
+ let a = |name: &str, action: BindingAction| self.sync_action_accelerator(name, &action);
+ a("app.quit", BindingAction::Quit);
+ a("app.open-config", BindingAction::OpenConfig);
+ a("app.reload-config", BindingAction::ReloadConfig);
+ a(
+ "win.toggle-inspector",
+ BindingAction::Inspector(InspectorMode::Toggle),
+ );
+ a("app.show-gtk-inspector", BindingAction::ShowGtkInspector);
+ a(
+ "win.toggle-command-palette",
+ BindingAction::ToggleCommandPalette,
+ );
+ a("win.close", BindingAction::CloseWindow);
+ a("win.new-window", BindingAction::NewWindow);
+ a("win.new-tab", BindingAction::NewTab);
+ a(
+ "win.close-tab::this",
+ BindingAction::CloseTab(CloseTabMode::This),
+ );
+ a(
+ "tab.close::this",
+ BindingAction::CloseTab(CloseTabMode::This),
+ );
+ a(
+ "win.split-right",
+ BindingAction::NewSplit(SplitDirection::Right),
+ );
+ a(
+ "win.split-down",
+ BindingAction::NewSplit(SplitDirection::Down),
+ );
+ a(
+ "win.split-left",
+ BindingAction::NewSplit(SplitDirection::Left),
+ );
+ a("win.split-up", BindingAction::NewSplit(SplitDirection::Up));
+ a(
+ "win.copy",
+ BindingAction::CopyToClipboard(CopyToClipboard::Mixed),
+ );
+ a("win.paste", BindingAction::PasteFromClipboard);
+ a("win.reset", BindingAction::Reset);
+ a("win.clear", BindingAction::ClearScreen);
+ a("win.prompt-title", BindingAction::PromptSurfaceTitle);
+ a(
+ "split-tree.new-split::left",
+ BindingAction::NewSplit(SplitDirection::Left),
+ );
+ a(
+ "split-tree.new-split::right",
+ BindingAction::NewSplit(SplitDirection::Right),
+ );
+ a(
+ "split-tree.new-split::up",
+ BindingAction::NewSplit(SplitDirection::Up),
+ );
+ a(
+ "split-tree.new-split::down",
+ BindingAction::NewSplit(SplitDirection::Down),
+ );
+ }
+
+ fn sync_action_accelerator(&self, gtk_action: &str, action: &BindingAction) {
+ // Reset it initially
+ self.set_accels_for_action(gtk_action, &[]);
+
+ let config = self.core_config();
+ let Some(trigger) = config.keybind.set.get_trigger(action) else {
+ return;
+ };
+ let Some(accel) = crate::key::accel_from_trigger(trigger) else {
+ return;
+ };
+ self.set_accels_for_action(gtk_action, &[accel.as_str()]);
+ }
+
+ // -----------------------------------------------------------------
+ // Startup
+
+ /// Setup the style manager on startup: initial light/dark mode based on
+ /// the configuration, plus change listeners.
+ fn startup_style_manager(&self) {
+ let config = self.core_config();
+
+ // Setup our initial light/dark
+ let style = self.style_manager();
+ style.set_color_scheme(match config.window_theme {
+ WindowTheme::Auto | WindowTheme::Ghostty => {
+ let lum = config.background.to_terminal_rgb().perceived_luminance();
+ if lum > 0.5 {
+ adw::ColorScheme::PreferLight
+ } else {
+ adw::ColorScheme::PreferDark
+ }
+ }
+ WindowTheme::System => adw::ColorScheme::PreferLight,
+ WindowTheme::Dark => adw::ColorScheme::ForceDark,
+ WindowTheme::Light => adw::ColorScheme::ForceLight,
+ });
+
+ // Setup color change notifications
+ let this = self.downgrade();
+ style.connect_dark_notify(move |style| {
+ if let Some(this) = this.upgrade() {
+ this.handle_style_manager_dark(style);
+ }
+ });
+
+ // Do an initial color scheme sync. This is idempotent and does
+ // nothing if our current theme matches what libghostty has.
+ self.handle_style_manager_dark(&style);
+ }
+
+ fn handle_style_manager_dark(&self, style: &adw::StyleManager) {
+ let scheme = if style.is_dark() {
+ ColorScheme::Dark
+ } else {
+ ColorScheme::Light
+ };
+ log::debug!("style manager changed scheme={scheme:?}");
+
+ let core = self.core();
+ core.color_scheme_event(&*self.rt(), scheme);
+ for id in core.surface_ids() {
+ let Some(surface) = Surface::from_id(id) else {
+ continue;
+ };
+ let Some(core_surface) = surface.core() else {
+ continue;
+ };
+ if let Err(err) = core_surface.color_scheme_callback(scheme) {
+ log::warn!("unable to tell surface about color scheme change err={err}");
+ }
+ }
+
+ if let Some(css) = self.imp().css.borrow_mut().as_mut() {
+ css.set_color_scheme(scheme == ColorScheme::Dark);
+ }
+ }
+
+ /// Setup signal handlers (SIGUSR2 reloads the config).
+ fn startup_signals(&self) {
+ let imp = self.imp();
+ if imp.signal_thread_started.replace(true) {
+ return;
+ }
+ // glib-rs doesn't bind `g_unix_signal_add`, so a helper thread waits
+ // for SIGUSR2 and hops to the main context.
+ let mut signals = match signal_hook::iterator::Signals::new([libc::SIGUSR2]) {
+ Ok(s) => s,
+ Err(err) => {
+ log::warn!("unable to register SIGUSR2 handler: {err}");
+ return;
+ }
+ };
+ std::thread::spawn(move || {
+ for _ in signals.forever() {
+ glib::MainContext::default().invoke(|| {
+ log::info!("received SIGUSR2, reloading configuration");
+ Application::default()
+ .reload_config(Target::App, action::ReloadConfig::default());
+ });
+ }
+ });
+ }
+
+ /// Setup our action map.
+ fn startup_action_map(&self) {
+ let add = |name: &str,
+ param: Option<&glib::VariantTy>,
+ f: Box)>| {
+ let action = gio::SimpleAction::new(name, param);
+ let this = self.downgrade();
+ action.connect_activate(move |_, p| {
+ if let Some(this) = this.upgrade() {
+ f(&this, p);
+ }
+ });
+ self.add_action(&action);
+ };
+
+ let as_ty = glib::VariantTy::new("as").expect("valid variant type");
+ add("new-window", None, Box::new(Self::action_new_window));
+ add(
+ "new-window-command",
+ Some(as_ty),
+ Box::new(Self::action_new_window),
+ );
+ add(
+ "open-config",
+ None,
+ Box::new(|this, _| this.action_open_config()),
+ );
+ add(
+ "present-surface",
+ Some(glib::VariantTy::UINT64),
+ Box::new(Self::action_present_surface),
+ );
+ add(
+ "quit",
+ None,
+ Box::new(|this, _| {
+ this.perform_action(Target::App, Action::Quit);
+ }),
+ );
+ add(
+ "reload-config",
+ None,
+ Box::new(|this, _| {
+ this.perform_action(
+ Target::App,
+ Action::ReloadConfig(action::ReloadConfig::default()),
+ );
+ }),
+ );
+ }
+
+ /// Setup our global shortcuts.
+ fn startup_global_shortcuts(&self) {
+ let Some(gs) = self.imp().global_shortcuts.get() else {
+ return;
+ };
+
+ // On startup, our dbus connection should be available.
+ gs.set_connection(self.dbus_connection().as_ref());
+
+ // Keep the shortcut config in sync with the app.
+ gs.set_config(self.imp().config.borrow().as_ref());
+
+ // Setup the signal handler for global shortcut triggers
+ let this = self.downgrade();
+ gs.connect_trigger(move |_, action| {
+ let Some(this) = this.upgrade() else { return };
+ if let Err(err) = this.core().perform_all_action(&*this.rt(), action) {
+ log::warn!("failed to perform action={err}");
+ }
+ });
+ }
+
+ /// Show the config errors dialog if the config on our application has
+ /// diagnostics.
+ fn show_config_errors_dialog(&self) {
+ let imp = self.imp();
+ let config = self.get_config();
+
+ // If we already have a dialog, just update the config.
+ if let Some(diag) = imp.config_errors_dialog.upgrade() {
+ diag.set_property("config", &config);
+ if config.has_diagnostics() {
+ diag.present(None::<>k::Widget>);
+ } else {
+ diag.close();
+ }
+ return;
+ }
+
+ // No diagnostics, do nothing.
+ if !config.has_diagnostics() {
+ return;
+ }
+
+ // No dialog yet, initialize a new one.
+ let dialog = ConfigErrorsDialog::new(&config);
+ imp.config_errors_dialog.set(Some(&dialog));
+
+ // Connect to the reload signal so we know to reload our config.
+ let this = self.downgrade();
+ dialog.connect_reload_config(move |_| {
+ let Some(this) = this.upgrade() else { return };
+ // We clear our dialog reference because it's going to close
+ // after response handling and we don't want to reuse it.
+ this.imp()
+ .config_errors_dialog
+ .set(None::<&ConfigErrorsDialog>);
+ // Reload our config as if the app reloaded.
+ this.reload_config(Target::App, action::ReloadConfig::default());
+ });
+
+ dialog.present(None::<>k::Widget>);
+ }
+
+ // -----------------------------------------------------------------
+ // GActions
+
+ /// `app.new-window` and `app.new-window-command`.
+ fn action_new_window(&self, parameter: Option<&glib::Variant>) {
+ log::debug!("received new window action");
+
+ let mut working_directory: Option = None;
+ let mut title: Option = None;
+ let mut command: Option = None;
+ let mut args: Vec = Vec::new();
+
+ 'overrides: {
+ // were we given a parameter?
+ let Some(parameter) = parameter else {
+ break 'overrides;
+ };
+
+ // ensure that the supplied parameter is an array of strings
+ let Some(values) = parameter.get::>() else {
+ log::warn!("parameter is of type '{}', not 'as'", parameter.type_());
+ break 'overrides;
+ };
+
+ let mut e_seen = false;
+ for (i, s) in values.iter().enumerate() {
+ log::debug!("new-window argument: {i} {s}");
+
+ if e_seen {
+ args.push(s.clone());
+ continue;
+ }
+ if s == "-e" {
+ e_seen = true;
+ continue;
+ }
+ if let Some(v) = s.strip_prefix("--command=") {
+ let mut cmd = Command::default();
+ if let Err(err) = cmd.parse_cli(Some(v)) {
+ log::warn!("unable to parse command: {err:?}");
+ continue;
+ }
+ command = Some(cmd);
+ continue;
+ }
+ if let Some(v) = s.strip_prefix("--working-directory=") {
+ working_directory = Some(v.trim().to_owned());
+ continue;
+ }
+ if let Some(v) = s.strip_prefix("--title=") {
+ title = Some(v.trim().to_owned());
+ }
+ }
+ }
+
+ if !args.is_empty() {
+ command = Some(Command::Direct(args));
+ }
+
+ self.new_window(
+ None,
+ WindowOverrides {
+ command,
+ working_directory,
+ title,
+ },
+ );
+ }
+
+ fn action_open_config(&self) {
+ self.core().push_message(AppMessage::OpenConfig);
+ }
+
+ fn action_present_surface(&self, parameter: Option<&glib::Variant>) {
+ let Some(parameter) = parameter else { return };
+
+ // Make sure that we've received a u64 from the system.
+ let Some(id) = parameter.get::() else {
+ return;
+ };
+
+ // A value of zero means that there was no target surface for the
+ // notification so we don't focus any surface. Send the id through
+ // the core mailbox so core can validate it (a notification may
+ // outlive a Ghostty instance).
+ if id == 0 {
+ return;
+ }
+ self.core().push_message(AppMessage::PresentSurface(id));
+ }
+
+ // -----------------------------------------------------------------
+ // Action implementations
+
+ /// apprt API to perform an action. Returns whether it was performed.
+ pub fn perform_action(&self, target: Target, action: Action) -> bool {
+ // Resolve the surface target (Zig deref'd `*CoreSurface` directly).
+ let surface: Option = match target {
+ Target::App => None,
+ Target::Surface(id) => {
+ let s = Surface::from_id(id);
+ if s.is_none() {
+ log::warn!("action for unknown surface id={id}");
+ }
+ s
+ }
+ };
+ let is_surface_target = matches!(target, Target::Surface(_));
+ // `surface` as the Zig `target` union.
+ let tgt = Tgt {
+ is_surface: is_surface_target,
+ surface,
+ };
+
+ match action {
+ Action::CloseTab(mode) => tgt.with_surface_bool(|s| {
+ let value = match mode {
+ action::CloseTabMode::This => "this",
+ action::CloseTabMode::Other => "other",
+ action::CloseTabMode::Right => "right",
+ };
+ s.activate_action("tab.close", Some(&value.to_variant()))
+ .is_ok()
+ }),
+ Action::CloseWindow => {
+ tgt.with_surface_bool(|s| s.activate_action("win.close", None).is_ok())
+ }
+ Action::CopyTitleToClipboard => tgt.with_surface_bool(Surface::copy_title_to_clipboard),
+ Action::ConfigChange(change) => {
+ // Wrap our config in a GObject (shares the Arc).
+ let config_obj = Config::from_arc(change.config);
+ match &tgt.surface {
+ Some(s) => s.set_config(&config_obj),
+ None => self.set_config(&config_obj),
+ }
+ true
+ }
+ Action::DesktopNotification(n) => {
+ self.desktop_notification(&tgt, &n);
+ true
+ }
+ Action::EqualizeSplits => {
+ if !tgt.is_surface {
+ log::warn!("equalize splits to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| s.activate_action("split-tree.equalize", None).is_ok())
+ }
+ Action::GotoSplit(to) => tgt.with_surface_bool(|s| Self::goto_split(s, to)),
+ Action::GotoWindow(dir) => Self::goto_window(dir),
+ Action::GotoTab(tab) => tgt.with_surface_bool(|s| {
+ let Some(window) = ancestor::(s) else {
+ log::warn!("surface is not in a window, ignoring goto_tab");
+ return false;
+ };
+ window.select_tab(match tab {
+ action::GotoTab::Previous => SelectTab::Previous,
+ action::GotoTab::Next => SelectTab::Next,
+ action::GotoTab::Last => SelectTab::Last,
+ action::GotoTab::Index(n) if n >= 0 => SelectTab::N(n as usize),
+ action::GotoTab::Index(_) => return false,
+ })
+ }),
+ Action::InitialSize(v) => tgt.with_surface_bool(|s| {
+ s.set_default_size(Size {
+ width: v.width,
+ height: v.height,
+ });
+ true
+ }),
+ Action::Inspector(v) => tgt.with_surface_bool(|s| s.control_inspector(v)),
+ Action::KeySequence(v) => {
+ if !tgt.is_surface {
+ log::warn!("key_sequence action to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ s.key_sequence_action(&v);
+ true
+ })
+ }
+ Action::KeyTable(v) => {
+ if !tgt.is_surface {
+ log::warn!("key_table action to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ s.key_table_action(&v);
+ true
+ })
+ }
+ Action::MouseOverLink(v) => {
+ tgt.with_surface_void("mouse over link", |s| {
+ s.set_mouse_hover_url(if v.url.is_empty() { None } else { Some(&v.url) });
+ });
+ true
+ }
+ Action::MouseShape(shape) => {
+ tgt.with_surface_void("mouse shape", |s| s.set_mouse_shape(shape));
+ true
+ }
+ Action::MouseVisibility(v) => {
+ tgt.with_surface_void("mouse visibility", |s| {
+ s.set_mouse_hidden(matches!(v, action::MouseVisibility::Hidden));
+ });
+ true
+ }
+ Action::MoveTab(v) => tgt.with_surface_bool(|s| {
+ let Some(window) = ancestor::(s) else {
+ log::warn!("surface is not in a window, ignoring move_tab");
+ return false;
+ };
+ window.move_tab(s, v.amount)
+ }),
+ Action::NewSplit(dir) => {
+ if !tgt.is_surface {
+ log::warn!("new split to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ let name = match dir {
+ action::SplitDirection::Right => "right",
+ action::SplitDirection::Down => "down",
+ action::SplitDirection::Left => "left",
+ action::SplitDirection::Up => "up",
+ };
+ s.activate_action("split-tree.new-split", Some(&name.to_variant()))
+ .is_ok()
+ })
+ }
+ Action::NewTab => {
+ if !tgt.is_surface {
+ log::warn!("new tab to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ // Get the window ancestor of the surface. Surfaces
+ // shouldn't be aware they might be in windows but at the
+ // app level we can do this.
+ let Some(window) = ancestor::(s) else {
+ log::warn!("surface is not in a window, ignoring new_tab");
+ return false;
+ };
+ window.new_tab(Some(s));
+ true
+ })
+ }
+ Action::NewWindow => {
+ self.new_window(tgt.surface.as_ref(), WindowOverrides::default());
+ true
+ }
+ Action::OpenConfig => self.open_config(),
+ Action::OpenUrl(v) => {
+ self.open_url(&v);
+ true
+ }
+ Action::Pwd(v) => {
+ tgt.with_surface_void("pwd", |s| s.set_pwd(Some(&v.pwd)));
+ true
+ }
+ Action::PresentTerminal => tgt.with_surface_bool(|s| {
+ s.present();
+ true
+ }),
+ Action::ProgressReport(v) => tgt.with_surface_bool(|s| {
+ s.set_progress_report(v);
+ true
+ }),
+ Action::PromptTitle(v) => match v {
+ action::PromptTitle::Surface => tgt.with_surface_bool(|s| {
+ s.prompt_title();
+ true
+ }),
+ action::PromptTitle::Tab => tgt.with_surface_bool(|s| {
+ let Some(tab) = ancestor::(s) else {
+ log::warn!("surface is not in a tab, ignoring prompt_tab_title");
+ return false;
+ };
+ tab.prompt_tab_title();
+ true
+ }),
+ },
+ Action::Quit => {
+ self.quit();
+ true
+ }
+ Action::QuitTimer(mode) => {
+ match mode {
+ action::QuitTimer::Start => self.start_quit_timer(),
+ action::QuitTimer::Stop => self.stop_quit_timer(),
+ }
+ true
+ }
+ Action::ReloadConfig(opts) => {
+ self.reload_config(target, opts);
+ true
+ }
+ Action::Render => {
+ if let Some(s) = &tgt.surface {
+ s.redraw();
+ }
+ true
+ }
+ Action::ResizeSplit(v) => {
+ if !tgt.is_surface {
+ log::warn!("resize_split to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ let Some(tree) = ancestor::(s) else {
+ log::warn!("surface is not in a split tree, ignoring resize_split");
+ return false;
+ };
+ // If the tree has no splits (only one leaf), this action
+ // is not performable. This allows the key event to pass
+ // through to the terminal.
+ if !tree.get_is_split() {
+ return false;
+ }
+ let dir = match v.direction {
+ action::ResizeSplitDirection::Up => {
+ ghostty_datastruct::split_tree::Direction::Up
+ }
+ action::ResizeSplitDirection::Down => {
+ ghostty_datastruct::split_tree::Direction::Down
+ }
+ action::ResizeSplitDirection::Left => {
+ ghostty_datastruct::split_tree::Direction::Left
+ }
+ action::ResizeSplitDirection::Right => {
+ ghostty_datastruct::split_tree::Direction::Right
+ }
+ };
+ match tree.resize(dir, v.amount) {
+ Ok(b) => b,
+ Err(err) => {
+ log::warn!("unable to resize split: {err:?}");
+ false
+ }
+ }
+ })
+ }
+ Action::RingBell => {
+ if let Some(s) = &tgt.surface {
+ s.set_bell_ringing(true);
+ }
+ true
+ }
+ Action::Scrollbar(v) => {
+ if let Some(s) = &tgt.surface {
+ s.set_scrollbar(v);
+ }
+ true
+ }
+ Action::SetTitle(v) => {
+ tgt.with_surface_void("set_title", |s| s.set_title(Some(&v.title)));
+ true
+ }
+ Action::SetTabTitle(v) => {
+ if !tgt.is_surface {
+ log::warn!("set_tab_title to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ let Some(tab) = ancestor::(s) else {
+ log::warn!("surface is not in a tab, ignoring set_tab_title");
+ return false;
+ };
+ tab.set_title_override(if v.title.is_empty() {
+ None
+ } else {
+ Some(&v.title)
+ });
+ true
+ })
+ }
+ Action::ShowChildExited(v) => tgt.with_surface_bool(|s| s.child_exited(&v)),
+ Action::ShowGtkInspector => {
+ gtk::Window::set_interactive_debugging(true);
+ true
+ }
+ Action::SizeLimit(v) => tgt.with_surface_bool(|s| {
+ // Note: we ignore the max size currently because we have
+ // no mechanism to enforce it.
+ s.set_min_size(Size {
+ width: v.min_width,
+ height: v.min_height,
+ });
+ true
+ }),
+ Action::ToggleMaximize => {
+ if let Some(s) = &tgt.surface {
+ s.toggle_maximize();
+ }
+ true
+ }
+ Action::ToggleFullscreen(_) => {
+ if let Some(s) = &tgt.surface {
+ s.toggle_fullscreen();
+ }
+ true
+ }
+ Action::ToggleQuickTerminal => self.toggle_quick_terminal(),
+ Action::ToggleTabOverview => tgt.with_surface_bool(|s| {
+ let Some(window) = ancestor::(s) else {
+ log::warn!("surface is not in a window, ignoring toggle_tab_overview");
+ return false;
+ };
+ window.toggle_tab_overview();
+ true
+ }),
+ Action::ToggleWindowDecorations => tgt.with_surface_bool(|s| {
+ let Some(window) = ancestor::(s) else {
+ log::warn!("surface is not in a window, ignoring toggle_window_decorations");
+ return false;
+ };
+ window.toggle_window_decorations();
+ true
+ }),
+ Action::ToggleCommandPalette => tgt.with_surface_bool(Surface::toggle_command_palette),
+ Action::ToggleSplitZoom => {
+ if !tgt.is_surface {
+ log::warn!("toggle_split_zoom to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(|s| {
+ let Some(tree) = ancestor::(s) else {
+ log::warn!("surface is not in a split tree, ignoring toggle_split_zoom");
+ return false;
+ };
+ // If the tree has no splits (only one leaf), this action
+ // is not performable.
+ if !tree.get_is_split() {
+ return false;
+ }
+ s.activate_action("split-tree.zoom", None).is_ok()
+ })
+ }
+ Action::ShowOnScreenKeyboard => {
+ if !tgt.is_surface {
+ log::warn!("show_on_screen_keyboard to app is unexpected");
+ return false;
+ }
+ tgt.with_surface_bool(Surface::show_on_screen_keyboard)
+ }
+ Action::CommandFinished(v) => tgt.with_surface_bool(|s| s.command_finished(&v)),
+ Action::Readonly(v) => tgt.with_surface_bool(|s| s.set_readonly(v)),
+ Action::StartSearch(v) => {
+ if let Some(s) = &tgt.surface {
+ s.set_search_active(true, &v.needle);
+ }
+ true
+ }
+ Action::EndSearch => {
+ if let Some(s) = &tgt.surface {
+ s.set_search_active(false, "");
+ }
+ true
+ }
+ Action::SearchTotal(v) => {
+ if let Some(s) = &tgt.surface {
+ s.set_search_total(v.total);
+ }
+ true
+ }
+ Action::SearchSelected(v) => {
+ if let Some(s) = &tgt.surface {
+ s.set_search_selected(v.selected);
+ }
+ true
+ }
+
+ // Unimplemented
+ Action::SecureInput(_)
+ | Action::CloseAllWindows
+ | Action::FloatWindow(_)
+ | Action::ToggleVisibility
+ | Action::ToggleBackgroundOpacity
+ | Action::CellSize(_)
+ | Action::RenderInspector
+ | Action::RendererHealth(_)
+ | Action::ColorChange(_)
+ | Action::ResetWindowSize
+ | Action::CheckForUpdates
+ | Action::Undo
+ | Action::Redo => {
+ log::warn!("unimplemented action={:?}", action.key());
+ false
+ }
+ }
+ }
+
+ fn desktop_notification(&self, tgt: &Tgt, n: &action::DesktopNotification) {
+ if let Some(s) = &tgt.surface {
+ s.send_desktop_notification(&n.title, &n.body);
+ return;
+ }
+
+ // Set a default title if we don't already have one
+ let title = if n.title.is_empty() {
+ "Ghostty"
+ } else {
+ n.title.as_str()
+ };
+
+ let notification = gio::Notification::new(title);
+ notification.set_body(Some(&n.body));
+ notification.set_icon(&gio::ThemedIcon::new("com.mitchellh.ghostty"));
+ notification
+ .set_default_action_and_target_value("app.present-surface", Some(&0u64.to_variant()));
+
+ // We set the notification ID to the body content. If the content is
+ // the same, this notification may replace a previous notification.
+ self.send_notification(Some(&n.body), ¬ification);
+ }
+
+ fn goto_split(surface: &Surface, to: action::GotoSplit) -> bool {
+ use ghostty_datastruct::split_tree::{Direction, Goto};
+ // Design note: we can't use widget actions here because we need to
+ // know whether there is a goto target for returning the proper
+ // perform result (boolean).
+ let Some(tree) = ancestor::(surface) else {
+ log::warn!("surface is not in a split tree, ignoring goto_split");
+ return false;
+ };
+ tree.goto(match to {
+ action::GotoSplit::Previous => Goto::PreviousWrapped,
+ action::GotoSplit::Next => Goto::NextWrapped,
+ action::GotoSplit::Up => Goto::Spatial(Direction::Up),
+ action::GotoSplit::Down => Goto::Spatial(Direction::Down),
+ action::GotoSplit::Left => Goto::Spatial(Direction::Left),
+ action::GotoSplit::Right => Goto::Spatial(Direction::Right),
+ })
+ }
+
+ fn goto_window(direction: action::GotoWindow) -> bool {
+ let list: Vec = gtk::Window::list_toplevels()
+ .into_iter()
+ .filter_map(|w| w.downcast::().ok())
+ .collect();
+ if list.is_empty() {
+ return false;
+ }
+
+ // The window we're starting from is typically our active window.
+ let start = list.iter().position(gtk::Window::is_active).unwrap_or(0);
+
+ // Go forward or backwards in the list until we find a valid window
+ // that is visible, wrapping around once.
+ let n = list.len();
+ for step in 0..n {
+ let idx = match direction {
+ action::GotoWindow::Next => (start + step) % n,
+ action::GotoWindow::Previous => (start + n - step) % n,
+ };
+ if Self::goto_window_maybe(&list[idx]) {
+ return true;
+ }
+ }
+ false
+ }
+
+ fn goto_window_maybe(gtk_window: >k::Window) -> bool {
+ // If it is already active skip it.
+ if gtk_window.is_active() {
+ return false;
+ }
+ // If it is hidden, skip it.
+ if !gtk_window.is_visible() {
+ return false;
+ }
+ // If it isn't a Ghostty window, skip it.
+ let Some(window) = gtk_window.downcast_ref::() else {
+ return false;
+ };
+
+ // Focus our active surface
+ let Some(surface) = window.get_active_surface() else {
+ return false;
+ };
+ gtk_window.present();
+ surface.grab_focus();
+ true
+ }
+
+ /// Create a new window (Zig: `Action.newWindow`).
+ pub fn new_window(&self, parent: Option<&Surface>, overrides: WindowOverrides) {
+ // Note that we've requested a window at least once. This is used to
+ // trigger quit on no windows.
+ self.mark_requested_window();
+
+ let win = Window::new(self, overrides.title.as_deref());
+ self.init_and_show_window(&win, parent, &overrides);
+ }
+
+ fn init_and_show_window(
+ &self,
+ win: &Window,
+ parent: Option<&Surface>,
+ overrides: &WindowOverrides,
+ ) {
+ // Setup a binding so that whenever our config changes so does the
+ // window. There's never a time when the window config should be out
+ // of sync with the application config.
+ self.bind_property("config", win, "config").build();
+
+ // Create a new tab with window context (first tab in new window)
+ win.new_tab_for_window(
+ parent,
+ TabOverrides {
+ command: overrides.command.clone(),
+ working_directory: overrides.working_directory.clone(),
+ title: overrides.title.clone(),
+ },
+ );
+
+ // Estimate the initial window size before presenting so the window
+ // manager can position it correctly.
+ if let Some(surface) = win.get_active_surface() {
+ surface.estimate_initial_size();
+ if let Some(size) = surface.get_default_size() {
+ win.set_default_size(size.width as i32, size.height as i32);
+ }
+ }
+
+ // Show the window
+ win.present();
+ }
+
+ fn open_config(&self) -> bool {
+ // Get the config file path
+ let path = match ghostty_config::edit::open_path() {
+ Ok(p) => p,
+ Err(err) => {
+ log::warn!("error getting config file path: {err}");
+ return false;
+ }
+ };
+
+ // Open it using open_url. "path" isn't actually a URL but at the
+ // time of writing that works just fine for GTK.
+ self.open_url(&action::OpenUrl {
+ kind: action::OpenUrlKind::Text,
+ url: path,
+ });
+ true
+ }
+
+ fn open_url(&self, value: &action::OpenUrl) {
+ // TODO: use https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.OpenURI.html
+
+ // Fallback to the minimal cross-platform way of opening a URL.
+ let kind = match value.kind {
+ action::OpenUrlKind::Unknown => ghostty_os::open::OpenUrlKind::Unknown,
+ action::OpenUrlKind::Text => ghostty_os::open::OpenUrlKind::Text,
+ action::OpenUrlKind::Html => ghostty_os::open::OpenUrlKind::Html,
+ };
+ if let Err(err) = ghostty_os::open::open(kind, &value.url) {
+ log::warn!("unable to open url: {err}");
+ }
+ }
+
+ /// Reload the configuration for the application and propagate it across
+ /// the entire application and all terminals.
+ fn reload_config(&self, target: Target, opts: action::ReloadConfig) {
+ // Tell systemd that reloading has started; when we exit this
+ // function tell it that reloading has finished.
+ ghostty_os::systemd::notify::reloading();
+ let _ready = scopeguard_ready();
+
+ // Get our config object.
+ let config: Arc = if opts.soft {
+ // Soft-reloading applies conditional logic to the existing
+ // loaded config so we return that as-is.
+ self.core_config()
+ } else {
+ // Hard reload, load a new config completely.
+ match CoreConfig::load() {
+ Ok(c) => Arc::new(c),
+ Err(err) => {
+ log::warn!("error reloading config: {err}");
+ return;
+ }
+ }
+ };
+
+ // Update the proper target. This will trigger a `config_change`
+ // apprt action which will propagate the config properly to our
+ // property system.
+ match target {
+ Target::App => {
+ if let Err(err) = self.core().update_config(&*self.rt(), &config) {
+ log::warn!("error reloading config: {err}");
+ }
+ }
+ Target::Surface(id) => {
+ let Some(core) = Surface::from_id(id).and_then(|s| s.core()) else {
+ return;
+ };
+ if let Err(err) = core.update_config(&config) {
+ log::warn!("error reloading config: {err}");
+ }
+ }
+ }
+ }
+
+ fn toggle_quick_terminal(&self) -> bool {
+ // If we already have a quick terminal window, we just toggle the
+ // visibility of it.
+ if let Some(win) = Self::quick_terminal_window() {
+ win.toggle_visibility();
+ return true;
+ }
+
+ // If we don't support quick terminals then we do nothing.
+ if !self.winproto().supports_quick_terminal() {
+ return false;
+ }
+
+ // Create our new window as a quick terminal
+ crate::register_resources();
+ let win: Window = glib::Object::builder()
+ .property("application", self)
+ .property("quick-terminal", true)
+ .build();
+ debug_assert!(win.is_quick_terminal());
+ self.init_and_show_window(&win, None, &WindowOverrides::default());
+ true
+ }
+
+ fn quick_terminal_window() -> Option {
+ gtk::Window::list_toplevels()
+ .into_iter()
+ .filter_map(|w| w.downcast::().ok())
+ .find(Window::is_quick_terminal)
+ }
+}
+
+/// The Zig `apprt.Target` as seen by action handlers.
+struct Tgt {
+ is_surface: bool,
+ surface: Option,
+}
+
+impl Tgt {
+ /// Run `f` for surface targets; app targets (or unknown surfaces) are
+ /// `false` (Zig: `.app => return false`).
+ fn with_surface_bool(&self, f: impl FnOnce(&Surface) -> bool) -> bool {
+ match &self.surface {
+ Some(s) => f(s),
+ None => false,
+ }
+ }
+
+ /// Like Zig's void handlers that log a warning for app targets.
+ fn with_surface_void(&self, what: &str, f: impl FnOnce(&Surface)) {
+ match &self.surface {
+ Some(s) => f(s),
+ None if !self.is_surface => log::warn!("{what} to app is unexpected"),
+ None => {}
+ }
+ }
+}
+
+/// Find an ancestor widget of type `T` (Zig: `ext.getAncestor`).
+fn ancestor>(widget: &impl IsA) -> Option {
+ widget.ancestor(T::static_type()).and_downcast::()
+}
+
+/// Guard that tells systemd we're ready again on drop.
+struct ReadyGuard;
+impl Drop for ReadyGuard {
+ fn drop(&mut self) {
+ ghostty_os::systemd::notify::ready();
+ }
+}
+fn scopeguard_ready() -> ReadyGuard {
+ ReadyGuard
+}
diff --git a/crates/ghostty-apprt-gtk/src/class/clipboard_confirmation_dialog.rs b/crates/ghostty-apprt-gtk/src/class/clipboard_confirmation_dialog.rs
new file mode 100644
index 0000000..7f65613
--- /dev/null
+++ b/crates/ghostty-apprt-gtk/src/class/clipboard_confirmation_dialog.rs
@@ -0,0 +1,245 @@
+//! Port of apprt/gtk/class/clipboard_confirmation_dialog.zig
+//! (`GhosttyClipboardConfirmationDialog`).
+//!
+//! Properties: `can-remember`, `request` (boxed [`ClipboardRequestBoxed`]),
+//! `clipboard-contents` (GtkTextBuffer), `blur`. Signals `confirm(bool)` and
+//! `deny(bool)` (bool = "remember choice").
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use ghostty_apprt::structs::ClipboardRequest;
+use ghostty_os::i18n::tr;
+use gtk::glib;
+use gtk::glib::subclass::Signal;
+use std::cell::{Cell, RefCell};
+use std::sync::OnceLock;
+
+use super::dialog::{Dialog, DialogImpl};
+
+/// GBoxed wrapper for [`ClipboardRequest`] (Zig: boxed `apprt.ClipboardRequest`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, glib::Boxed)]
+#[boxed_type(name = "GhosttyClipboardRequest", nullable)]
+pub struct ClipboardRequestBoxed(pub ClipboardRequest);
+
+mod imp {
+ use super::{
+ AdwAlertDialogImpl, AdwDialogImpl, Cell, ClipboardRequest, ClipboardRequestBoxed, Dialog,
+ DialogImpl, ObjectImpl, ObjectSubclass, OnceLock, RefCell, Signal, WidgetImpl, tr,
+ };
+ use adw::prelude::*;
+ use gtk::glib;
+ use gtk::subclass::prelude::*;
+
+ #[derive(Default, glib::Properties, gtk::CompositeTemplate)]
+ #[properties(wrapper_type = super::ClipboardConfirmationDialog)]
+ #[template(resource = "/com/mitchellh/ghostty/ui/1.4/clipboard-confirmation-dialog.ui")]
+ pub struct ClipboardConfirmationDialog {
+ /// The request that this dialog is for.
+ #[property(get, set, nullable)]
+ pub request: RefCell>,
+
+ /// The clipboard contents being read/written.
+ #[property(get, set, nullable, name = "clipboard-contents")]
+ pub clipboard_contents: RefCell>,
+
+ /// Whether the contents should be blurred.
+ #[property(get, set)]
+ pub blur: Cell,
+
+ /// Whether the user can remember the choice.
+ #[property(get, set, name = "can-remember")]
+ pub can_remember: Cell,
+
+ #[template_child]
+ pub text_view_scroll: TemplateChild,
+ #[template_child]
+ pub text_view: TemplateChild,
+ #[template_child]
+ pub reveal_button: TemplateChild,
+ #[template_child]
+ pub hide_button: TemplateChild,
+ #[template_child]
+ pub remember_choice: TemplateChild,
+ }
+
+ #[glib::object_subclass]
+ impl ObjectSubclass for ClipboardConfirmationDialog {
+ const NAME: &'static str = "GhosttyClipboardConfirmationDialog";
+ type Type = super::ClipboardConfirmationDialog;
+ type ParentType = Dialog;
+
+ fn class_init(klass: &mut Self::Class) {
+ Dialog::ensure_type();
+ klass.bind_template();
+ klass.bind_template_callbacks();
+ }
+
+ fn instance_init(obj: &glib::subclass::InitializingObject) {
+ obj.init_template();
+ }
+ }
+
+ #[gtk::template_callbacks]
+ impl ClipboardConfirmationDialog {
+ fn set_blurred(&self, blurred: bool, reveal_visible: bool, hide_visible: bool) {
+ self.text_view_scroll.set_sensitive(!blurred);
+ if blurred {
+ self.text_view.add_css_class("blurred");
+ } else {
+ self.text_view.remove_css_class("blurred");
+ }
+ self.reveal_button.set_visible(reveal_visible);
+ self.hide_button.set_visible(hide_visible);
+ }
+
+ #[template_callback]
+ fn notify_blur(&self, _pspec: &glib::ParamSpec) {
+ if self.blur.get() {
+ self.set_blurred(true, true, false);
+ } else {
+ self.set_blurred(false, false, false);
+ }
+ }
+
+ #[template_callback]
+ fn notify_request(&self, _pspec: &glib::ParamSpec) {
+ self.update_request();
+ }
+
+ pub fn update_request(&self) {
+ let Some(ClipboardRequestBoxed(req)) = *self.request.borrow() else {
+ return;
+ };
+ let obj = self.obj();
+ match req {
+ ClipboardRequest::Osc52Write(_) => {
+ obj.set_heading(Some(&tr("Authorize Clipboard Access")));
+ obj.set_body(&tr("An application is attempting to write to the clipboard. The current clipboard contents are shown below."));
+ }
+ ClipboardRequest::Osc52Read(_) => {
+ obj.set_heading(Some(&tr("Authorize Clipboard Access")));
+ obj.set_body(&tr("An application is attempting to read from the clipboard. The current clipboard contents are shown below."));
+ }
+ ClipboardRequest::Paste => {
+ obj.set_heading(Some(&tr("Warning: Potentially Unsafe Paste")));
+ obj.set_body(&tr("Pasting this text into the terminal may be dangerous as it looks like some commands may be executed."));
+ }
+ }
+ }
+
+ #[template_callback]
+ fn reveal_clicked(&self, _button: >k::Button) {
+ self.set_blurred(false, false, true);
+ }
+
+ #[template_callback]
+ fn hide_clicked(&self, _button: >k::Button) {
+ self.set_blurred(true, true, false);
+ }
+ }
+
+ #[glib::derived_properties]
+ impl ObjectImpl for ClipboardConfirmationDialog {
+ fn constructed(&self) {
+ self.parent_constructed();
+ // Mirrors `self.propBlur(..); self.propRequest(..)` in init.
+ self.notify_blur(&Self::type_pspec_dummy());
+ self.update_request();
+ }
+
+ fn signals() -> &'static [Signal] {
+ static SIGNALS: OnceLock> = OnceLock::new();
+ SIGNALS.get_or_init(|| {
+ vec![
+ Signal::builder("deny")
+ .param_types([bool::static_type()])
+ .build(),
+ Signal::builder("confirm")
+ .param_types([bool::static_type()])
+ .build(),
+ ]
+ })
+ }
+
+ fn dispose(&self) {
+ self.clipboard_contents.replace(None);
+ self.dispose_template();
+ }
+ }
+
+ impl ClipboardConfirmationDialog {
+ fn type_pspec_dummy() -> glib::ParamSpec {
+ glib::ParamSpecBoolean::builder("blur").build()
+ }
+ }
+
+ impl WidgetImpl for ClipboardConfirmationDialog {}
+ impl AdwDialogImpl for ClipboardConfirmationDialog {}
+ impl AdwAlertDialogImpl for ClipboardConfirmationDialog {
+ fn response(&self, response: &str) {
+ let remember = self.remember_choice.is_active();
+ let obj = self.obj();
+ if response == "cancel" {
+ obj.emit_by_name::<()>("deny", &[&remember]);
+ } else if response == "ok" {
+ obj.emit_by_name::<()>("confirm", &[&remember]);
+ }
+ }
+ }
+ impl DialogImpl for ClipboardConfirmationDialog {}
+}
+
+glib::wrapper! {
+ pub struct ClipboardConfirmationDialog(ObjectSubclass)
+ @extends Dialog, adw::AlertDialog, adw::Dialog, gtk::Widget,
+ @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::ShortcutManager;
+}
+
+impl ClipboardConfirmationDialog {
+ pub fn new() -> Self {
+ crate::register_resources();
+ glib::Object::new()
+ }
+
+ pub fn present(&self, parent: Option<&impl IsA>) {
+ self.upcast_ref::