mirror of
https://github.com/ghostty-org/ghostty.git
synced 2025-07-14 07:46:12 +03:00
d1e45ef768
Fixes #3567 ibus 1.5.29 doesn't trigger a preedit end state when text is committed. This is fixed in ibus 1.5.30, but we need to handle this case for older versions which are shipped on LTS distributions such as Ubuntu. Every other input method engine I've tried thus far also triggers a preedit end state when text is committed, and none would expect preedit to continue after text is committed. So I think it's safe to assume that this is the expected behavior.
2226 lines
76 KiB
Zig
2226 lines
76 KiB
Zig
/// A surface represents one drawable terminal surface. The surface may be
|
||
/// attached to a window or it may be some other kind of surface. This struct
|
||
/// is meant to be generic to all scenarios.
|
||
const Surface = @This();
|
||
|
||
const std = @import("std");
|
||
const Allocator = std.mem.Allocator;
|
||
const build_config = @import("../../build_config.zig");
|
||
const build_options = @import("build_options");
|
||
const configpkg = @import("../../config.zig");
|
||
const apprt = @import("../../apprt.zig");
|
||
const font = @import("../../font/main.zig");
|
||
const input = @import("../../input.zig");
|
||
const renderer = @import("../../renderer.zig");
|
||
const terminal = @import("../../terminal/main.zig");
|
||
const CoreSurface = @import("../../Surface.zig");
|
||
const internal_os = @import("../../os/main.zig");
|
||
|
||
const App = @import("App.zig");
|
||
const Split = @import("Split.zig");
|
||
const Tab = @import("Tab.zig");
|
||
const Window = @import("Window.zig");
|
||
const ClipboardConfirmationWindow = @import("ClipboardConfirmationWindow.zig");
|
||
const ResizeOverlay = @import("ResizeOverlay.zig");
|
||
const inspector = @import("inspector.zig");
|
||
const gtk_key = @import("key.zig");
|
||
const c = @import("c.zig").c;
|
||
|
||
const log = std.log.scoped(.gtk_surface);
|
||
|
||
/// This is detected by the OpenGL renderer to move to a single-threaded
|
||
/// draw operation. This basically puts locks around our draw path.
|
||
pub const opengl_single_threaded_draw = true;
|
||
|
||
pub const Options = struct {
|
||
/// The parent surface to inherit settings such as font size, working
|
||
/// directory, etc. from.
|
||
parent: ?*CoreSurface = null,
|
||
};
|
||
|
||
/// The container that this surface is directly attached to.
|
||
pub const Container = union(enum) {
|
||
/// The surface is not currently attached to anything. This means
|
||
/// that the GLArea has been created and potentially initialized
|
||
/// but the widget is currently floating and not part of any parent.
|
||
none: void,
|
||
|
||
/// Directly attached to a tab. (i.e. no splits)
|
||
tab_: *Tab,
|
||
|
||
/// A split within a split hierarchy. The key determines the
|
||
/// position of the split within the parent split.
|
||
split_tl: *Elem,
|
||
split_br: *Elem,
|
||
|
||
/// The side of the split.
|
||
pub const SplitSide = enum { top_left, bottom_right };
|
||
|
||
/// Elem is the possible element of any container. A container can
|
||
/// hold both a surface and a split. Any valid container should
|
||
/// have an Elem value so that it can be properly used with
|
||
/// splits.
|
||
pub const Elem = union(enum) {
|
||
/// A surface is a leaf element of the split -- a terminal
|
||
/// surface.
|
||
surface: *Surface,
|
||
|
||
/// A split is a nested split within a split. This lets you
|
||
/// for example have a horizontal split with a vertical split
|
||
/// on the left side (amongst all other possible
|
||
/// combinations).
|
||
split: *Split,
|
||
|
||
/// Returns the GTK widget to add to the paned for the given
|
||
/// element
|
||
pub fn widget(self: Elem) *c.GtkWidget {
|
||
return switch (self) {
|
||
.surface => |s| s.primaryWidget(),
|
||
.split => |s| @ptrCast(@alignCast(s.paned)),
|
||
};
|
||
}
|
||
|
||
pub fn containerPtr(self: Elem) *Container {
|
||
return switch (self) {
|
||
.surface => |s| &s.container,
|
||
.split => |s| &s.container,
|
||
};
|
||
}
|
||
|
||
pub fn deinit(self: Elem, alloc: Allocator) void {
|
||
switch (self) {
|
||
.surface => |s| s.unref(),
|
||
.split => |s| s.destroy(alloc),
|
||
}
|
||
}
|
||
|
||
pub fn grabFocus(self: Elem) void {
|
||
switch (self) {
|
||
.surface => |s| s.grabFocus(),
|
||
.split => |s| s.grabFocus(),
|
||
}
|
||
}
|
||
|
||
pub fn equalize(self: Elem) f64 {
|
||
return switch (self) {
|
||
.surface => 1,
|
||
.split => |s| s.equalize(),
|
||
};
|
||
}
|
||
|
||
/// The last surface in this container in the direction specified.
|
||
/// Direction must be "top_left" or "bottom_right".
|
||
pub fn deepestSurface(self: Elem, side: SplitSide) ?*Surface {
|
||
return switch (self) {
|
||
.surface => |s| s,
|
||
.split => |s| (switch (side) {
|
||
.top_left => s.top_left,
|
||
.bottom_right => s.bottom_right,
|
||
}).deepestSurface(side),
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Returns the window that this surface is attached to.
|
||
pub fn window(self: Container) ?*Window {
|
||
return switch (self) {
|
||
.none => null,
|
||
.tab_ => |v| v.window,
|
||
.split_tl, .split_br => split: {
|
||
const s = self.split() orelse break :split null;
|
||
break :split s.container.window();
|
||
},
|
||
};
|
||
}
|
||
|
||
/// Returns the tab container if it exists.
|
||
pub fn tab(self: Container) ?*Tab {
|
||
return switch (self) {
|
||
.none => null,
|
||
.tab_ => |v| v,
|
||
.split_tl, .split_br => split: {
|
||
const s = self.split() orelse break :split null;
|
||
break :split s.container.tab();
|
||
},
|
||
};
|
||
}
|
||
|
||
/// Returns the split containing this surface (if any).
|
||
pub fn split(self: Container) ?*Split {
|
||
return switch (self) {
|
||
.none, .tab_ => null,
|
||
.split_tl => |ptr| @fieldParentPtr("top_left", ptr),
|
||
.split_br => |ptr| @fieldParentPtr("bottom_right", ptr),
|
||
};
|
||
}
|
||
|
||
/// The side that we are in the split.
|
||
pub fn splitSide(self: Container) ?SplitSide {
|
||
return switch (self) {
|
||
.none, .tab_ => null,
|
||
.split_tl => .top_left,
|
||
.split_br => .bottom_right,
|
||
};
|
||
}
|
||
|
||
/// Returns the first split with the given orientation, walking upwards in
|
||
/// the tree.
|
||
pub fn firstSplitWithOrientation(
|
||
self: Container,
|
||
orientation: Split.Orientation,
|
||
) ?*Split {
|
||
return switch (self) {
|
||
.none, .tab_ => null,
|
||
.split_tl, .split_br => split: {
|
||
const s = self.split() orelse break :split null;
|
||
if (s.orientation == orientation) break :split s;
|
||
break :split s.container.firstSplitWithOrientation(orientation);
|
||
},
|
||
};
|
||
}
|
||
|
||
/// Replace the container's element with this element. This is
|
||
/// used by children to modify their parents to for example change
|
||
/// from a surface to a split or a split back to a surface or
|
||
/// a split to a nested split and so on.
|
||
pub fn replace(self: Container, elem: Elem) void {
|
||
// Move the element into the container
|
||
switch (self) {
|
||
.none => {},
|
||
.tab_ => |t| t.replaceElem(elem),
|
||
inline .split_tl, .split_br => |ptr| {
|
||
const s = self.split().?;
|
||
s.replace(ptr, elem);
|
||
},
|
||
}
|
||
|
||
// Update the reverse reference to the container
|
||
elem.containerPtr().* = self;
|
||
}
|
||
|
||
/// Remove ourselves from the container. This is used by
|
||
/// children to effectively notify they're container that
|
||
/// all children at this level are exiting.
|
||
pub fn remove(self: Container) void {
|
||
switch (self) {
|
||
.none => {},
|
||
.tab_ => |t| t.remove(),
|
||
.split_tl => self.split().?.removeTopLeft(),
|
||
.split_br => self.split().?.removeBottomRight(),
|
||
}
|
||
}
|
||
};
|
||
|
||
/// Represents the URL hover widgets that show the hovered URL.
|
||
/// To explain a bit how this all works since its split across a few places:
|
||
/// We create a left/right pair of labels. The left label is shown by default,
|
||
/// and the right label is hidden. When the mouse enters the left label, we
|
||
/// show the right label. When the mouse leaves the left label, we hide the
|
||
/// right label.
|
||
///
|
||
/// The hover and styling is done with a combination of GTK event controllers
|
||
/// and CSS in style.css.
|
||
pub const URLWidget = struct {
|
||
left: *c.GtkWidget,
|
||
right: *c.GtkWidget,
|
||
|
||
pub fn init(surface: *const Surface, str: [:0]const u8) URLWidget {
|
||
// Create the left
|
||
const left = c.gtk_label_new(str.ptr);
|
||
c.gtk_label_set_ellipsize(@ptrCast(left), c.PANGO_ELLIPSIZE_MIDDLE);
|
||
c.gtk_widget_add_css_class(@ptrCast(left), "view");
|
||
c.gtk_widget_add_css_class(@ptrCast(left), "url-overlay");
|
||
c.gtk_widget_add_css_class(@ptrCast(left), "left");
|
||
c.gtk_widget_set_halign(left, c.GTK_ALIGN_START);
|
||
c.gtk_widget_set_valign(left, c.GTK_ALIGN_END);
|
||
|
||
// Create the right
|
||
const right = c.gtk_label_new(str.ptr);
|
||
c.gtk_label_set_ellipsize(@ptrCast(right), c.PANGO_ELLIPSIZE_MIDDLE);
|
||
c.gtk_widget_add_css_class(@ptrCast(right), "hidden");
|
||
c.gtk_widget_add_css_class(@ptrCast(right), "view");
|
||
c.gtk_widget_add_css_class(@ptrCast(right), "url-overlay");
|
||
c.gtk_widget_add_css_class(@ptrCast(right), "right");
|
||
c.gtk_widget_set_halign(right, c.GTK_ALIGN_END);
|
||
c.gtk_widget_set_valign(right, c.GTK_ALIGN_END);
|
||
|
||
// Setup our mouse hover event for the left
|
||
const ec_motion = c.gtk_event_controller_motion_new();
|
||
errdefer c.g_object_unref(ec_motion);
|
||
c.gtk_widget_add_controller(@ptrCast(left), ec_motion);
|
||
_ = c.g_signal_connect_data(
|
||
ec_motion,
|
||
"enter",
|
||
c.G_CALLBACK(>kLeftEnter),
|
||
right,
|
||
null,
|
||
c.G_CONNECT_DEFAULT,
|
||
);
|
||
_ = c.g_signal_connect_data(
|
||
ec_motion,
|
||
"leave",
|
||
c.G_CALLBACK(>kLeftLeave),
|
||
right,
|
||
null,
|
||
c.G_CONNECT_DEFAULT,
|
||
);
|
||
|
||
// Show it
|
||
c.gtk_overlay_add_overlay(@ptrCast(surface.overlay), left);
|
||
c.gtk_overlay_add_overlay(@ptrCast(surface.overlay), right);
|
||
|
||
return .{
|
||
.left = left,
|
||
.right = right,
|
||
};
|
||
}
|
||
|
||
pub fn deinit(self: *URLWidget, overlay: *c.GtkOverlay) void {
|
||
c.gtk_overlay_remove_overlay(@ptrCast(overlay), @ptrCast(self.left));
|
||
c.gtk_overlay_remove_overlay(@ptrCast(overlay), @ptrCast(self.right));
|
||
}
|
||
|
||
pub fn setText(self: *const URLWidget, str: [:0]const u8) void {
|
||
c.gtk_label_set_text(@ptrCast(self.left), str.ptr);
|
||
c.gtk_label_set_text(@ptrCast(self.right), str.ptr);
|
||
}
|
||
|
||
fn gtkLeftEnter(
|
||
_: *c.GtkEventControllerMotion,
|
||
_: c.gdouble,
|
||
_: c.gdouble,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const right: *c.GtkWidget = @ptrCast(@alignCast(ud orelse return));
|
||
c.gtk_widget_remove_css_class(@ptrCast(right), "hidden");
|
||
}
|
||
|
||
fn gtkLeftLeave(
|
||
_: *c.GtkEventControllerMotion,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const right: *c.GtkWidget = @ptrCast(@alignCast(ud orelse return));
|
||
c.gtk_widget_add_css_class(@ptrCast(right), "hidden");
|
||
}
|
||
};
|
||
|
||
/// Whether the surface has been realized or not yet. When a surface is
|
||
/// "realized" it means that the OpenGL context is ready and the core
|
||
/// surface has been initialized.
|
||
realized: bool = false,
|
||
|
||
/// The config to use to initialize a surface.
|
||
init_config: InitConfig,
|
||
|
||
/// The GUI container that this surface has been attached to. This
|
||
/// dictates some behaviors such as new splits, etc.
|
||
container: Container = .{ .none = {} },
|
||
|
||
/// The app we're part of
|
||
app: *App,
|
||
|
||
/// The overlay, this is the primary widget
|
||
overlay: *c.GtkOverlay,
|
||
|
||
/// Our GTK area
|
||
gl_area: *c.GtkGLArea,
|
||
|
||
/// If non-null this is the widget on the overlay that shows the URL.
|
||
url_widget: ?URLWidget = null,
|
||
|
||
/// The overlay that shows resizing information.
|
||
resize_overlay: ResizeOverlay = .{},
|
||
|
||
/// Whether or not the current surface is zoomed in (see `toggle_split_zoom`).
|
||
zoomed_in: bool = false,
|
||
|
||
/// If non-null this is the widget on the overlay which dims the surface when it is unfocused
|
||
unfocused_widget: ?*c.GtkWidget = null,
|
||
|
||
/// Any active cursor we may have
|
||
cursor: ?*c.GdkCursor = null,
|
||
|
||
/// Our title. The raw value of the title. This will be kept up to date and
|
||
/// .title will be updated if we have focus.
|
||
/// When set the text in this buf will be null-terminated, because we need to
|
||
/// pass it to GTK.
|
||
title_text: ?[:0]const u8 = null,
|
||
|
||
/// Our current working directory. We use this value for setting tooltips in
|
||
/// the headerbar subtitle if we have focus. When set, the text in this buf
|
||
/// will be null-terminated because we need to pass it to GTK.
|
||
pwd: ?[:0]const u8 = null,
|
||
|
||
/// The timer used to delay title updates in order to prevent flickering.
|
||
update_title_timer: ?c.guint = null,
|
||
|
||
/// The core surface backing this surface
|
||
core_surface: CoreSurface,
|
||
|
||
/// The font size to use for this surface once realized.
|
||
font_size: ?font.face.DesiredSize = null,
|
||
|
||
/// Cached metrics about the surface from GTK callbacks.
|
||
size: apprt.SurfaceSize,
|
||
cursor_pos: apprt.CursorPos,
|
||
|
||
/// Inspector state.
|
||
inspector: ?*inspector.Inspector = null,
|
||
|
||
/// Key input states. See gtkKeyPressed for detailed descriptions.
|
||
in_keyevent: bool = false,
|
||
im_context: *c.GtkIMContext,
|
||
im_composing: bool = false,
|
||
im_buf: [128]u8 = undefined,
|
||
im_len: u7 = 0,
|
||
|
||
/// The surface-specific cgroup path. See App.transient_cgroup_path for
|
||
/// details on what this is.
|
||
cgroup_path: ?[]const u8 = null,
|
||
|
||
/// Configuration used for initializing the surface. We have to copy some
|
||
/// data since initialization is delayed with GTK (on realize).
|
||
pub const InitConfig = struct {
|
||
parent: bool = false,
|
||
pwd: ?[]const u8 = null,
|
||
|
||
pub fn init(
|
||
alloc: Allocator,
|
||
app: *App,
|
||
opts: Options,
|
||
) Allocator.Error!InitConfig {
|
||
const parent = opts.parent orelse return .{};
|
||
|
||
const pwd: ?[]const u8 = if (app.config.@"window-inherit-working-directory")
|
||
try parent.pwd(alloc)
|
||
else
|
||
null;
|
||
errdefer if (pwd) |p| alloc.free(p);
|
||
|
||
return .{
|
||
.parent = true,
|
||
.pwd = pwd,
|
||
};
|
||
}
|
||
|
||
pub fn deinit(self: *InitConfig, alloc: Allocator) void {
|
||
if (self.pwd) |pwd| alloc.free(pwd);
|
||
}
|
||
};
|
||
|
||
pub fn create(alloc: Allocator, app: *App, opts: Options) !*Surface {
|
||
var surface = try alloc.create(Surface);
|
||
errdefer alloc.destroy(surface);
|
||
try surface.init(app, opts);
|
||
return surface;
|
||
}
|
||
|
||
pub fn init(self: *Surface, app: *App, opts: Options) !void {
|
||
const gl_area = c.gtk_gl_area_new();
|
||
|
||
// Create an overlay so we can layer the GL area with other widgets.
|
||
const overlay = c.gtk_overlay_new();
|
||
c.gtk_overlay_set_child(@ptrCast(overlay), gl_area);
|
||
|
||
// Overlay is not focusable, but the GL area is.
|
||
c.gtk_widget_set_focusable(@ptrCast(overlay), 0);
|
||
c.gtk_widget_set_focus_on_click(@ptrCast(overlay), 0);
|
||
|
||
// We grab the floating reference to the primary widget. This allows the
|
||
// widget tree to be moved around i.e. between a split, a tab, etc.
|
||
// without having to be really careful about ordering to
|
||
// prevent a destroy.
|
||
//
|
||
// This is unref'd in the unref() method that's called by the
|
||
// self.container through Elem.deinit.
|
||
_ = c.g_object_ref_sink(@ptrCast(overlay));
|
||
errdefer c.g_object_unref(@ptrCast(overlay));
|
||
|
||
// We want the gl area to expand to fill the parent container.
|
||
c.gtk_widget_set_hexpand(gl_area, 1);
|
||
c.gtk_widget_set_vexpand(gl_area, 1);
|
||
|
||
// Various other GL properties
|
||
c.gtk_widget_set_cursor_from_name(@ptrCast(gl_area), "text");
|
||
c.gtk_gl_area_set_required_version(@ptrCast(gl_area), 3, 3);
|
||
c.gtk_gl_area_set_has_stencil_buffer(@ptrCast(gl_area), 0);
|
||
c.gtk_gl_area_set_has_depth_buffer(@ptrCast(gl_area), 0);
|
||
c.gtk_gl_area_set_use_es(@ptrCast(gl_area), 0);
|
||
|
||
// Key event controller will tell us about raw keypress events.
|
||
const ec_key = c.gtk_event_controller_key_new();
|
||
errdefer c.g_object_unref(ec_key);
|
||
c.gtk_widget_add_controller(@ptrCast(overlay), ec_key);
|
||
errdefer c.gtk_widget_remove_controller(@ptrCast(overlay), ec_key);
|
||
|
||
// Focus controller will tell us about focus enter/exit events
|
||
const ec_focus = c.gtk_event_controller_focus_new();
|
||
errdefer c.g_object_unref(ec_focus);
|
||
c.gtk_widget_add_controller(@ptrCast(overlay), ec_focus);
|
||
errdefer c.gtk_widget_remove_controller(@ptrCast(overlay), ec_focus);
|
||
|
||
// Create a second key controller so we can receive the raw
|
||
// key-press events BEFORE the input method gets them.
|
||
const ec_key_press = c.gtk_event_controller_key_new();
|
||
errdefer c.g_object_unref(ec_key_press);
|
||
c.gtk_widget_add_controller(@ptrCast(overlay), ec_key_press);
|
||
errdefer c.gtk_widget_remove_controller(@ptrCast(overlay), ec_key_press);
|
||
|
||
// Clicks
|
||
const gesture_click = c.gtk_gesture_click_new();
|
||
errdefer c.g_object_unref(gesture_click);
|
||
c.gtk_gesture_single_set_button(@ptrCast(gesture_click), 0);
|
||
c.gtk_widget_add_controller(@ptrCast(@alignCast(overlay)), @ptrCast(gesture_click));
|
||
|
||
// Mouse movement
|
||
const ec_motion = c.gtk_event_controller_motion_new();
|
||
errdefer c.g_object_unref(ec_motion);
|
||
c.gtk_widget_add_controller(@ptrCast(@alignCast(overlay)), ec_motion);
|
||
|
||
// Scroll events
|
||
const ec_scroll = c.gtk_event_controller_scroll_new(
|
||
c.GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES |
|
||
c.GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
|
||
);
|
||
errdefer c.g_object_unref(ec_scroll);
|
||
c.gtk_widget_add_controller(@ptrCast(overlay), ec_scroll);
|
||
|
||
// The input method context that we use to translate key events into
|
||
// characters. This doesn't have an event key controller attached because
|
||
// we call it manually from our own key controller.
|
||
const im_context = c.gtk_im_multicontext_new();
|
||
errdefer c.g_object_unref(im_context);
|
||
|
||
// The GL area has to be focusable so that it can receive events
|
||
c.gtk_widget_set_focusable(gl_area, 1);
|
||
c.gtk_widget_set_focus_on_click(gl_area, 1);
|
||
|
||
// Set up to handle items being dropped on our surface. Files can be dropped
|
||
// from Nautilus and strings can be dropped from many programs.
|
||
const drop_target = c.gtk_drop_target_new(c.G_TYPE_INVALID, c.GDK_ACTION_COPY);
|
||
errdefer c.g_object_unref(drop_target);
|
||
var drop_target_types = [_]c.GType{
|
||
c.gdk_file_list_get_type(),
|
||
c.G_TYPE_STRING,
|
||
};
|
||
c.gtk_drop_target_set_gtypes(drop_target, @ptrCast(&drop_target_types), drop_target_types.len);
|
||
c.gtk_widget_add_controller(@ptrCast(overlay), @ptrCast(drop_target));
|
||
|
||
// Inherit the parent's font size if we have a parent.
|
||
const font_size: ?font.face.DesiredSize = font_size: {
|
||
if (!app.config.@"window-inherit-font-size") break :font_size null;
|
||
const parent = opts.parent orelse break :font_size null;
|
||
break :font_size parent.font_size;
|
||
};
|
||
|
||
// If the parent has a transient cgroup, then we're creating cgroups
|
||
// for each surface if we can. We need to create a child cgroup.
|
||
const cgroup_path: ?[]const u8 = cgroup: {
|
||
const base = app.transient_cgroup_base orelse break :cgroup null;
|
||
|
||
// For the unique group name we use the self pointer. This may
|
||
// not be a good idea for security reasons but not sure yet. We
|
||
// may want to change this to something else eventually to be safe.
|
||
var buf: [256]u8 = undefined;
|
||
const name = std.fmt.bufPrint(
|
||
&buf,
|
||
"surfaces/{X}.scope",
|
||
.{@intFromPtr(self)},
|
||
) catch unreachable;
|
||
|
||
// Create the cgroup. If it fails, no big deal... just ignore.
|
||
internal_os.cgroup.create(base, name, null) catch |err| {
|
||
log.err("failed to create surface cgroup err={}", .{err});
|
||
break :cgroup null;
|
||
};
|
||
|
||
// Success, save the cgroup path.
|
||
break :cgroup std.fmt.allocPrint(
|
||
app.core_app.alloc,
|
||
"{s}/{s}",
|
||
.{ base, name },
|
||
) catch null;
|
||
};
|
||
errdefer if (cgroup_path) |path| app.core_app.alloc.free(path);
|
||
|
||
// Build our initialization config
|
||
const init_config = try InitConfig.init(app.core_app.alloc, app, opts);
|
||
errdefer init_config.deinit(app.core_app.alloc);
|
||
|
||
// Build our result
|
||
self.* = .{
|
||
.app = app,
|
||
.container = .{ .none = {} },
|
||
.overlay = @ptrCast(overlay),
|
||
.gl_area = @ptrCast(gl_area),
|
||
.resize_overlay = ResizeOverlay.init(self),
|
||
.title_text = null,
|
||
.core_surface = undefined,
|
||
.font_size = font_size,
|
||
.init_config = init_config,
|
||
.size = .{ .width = 800, .height = 600 },
|
||
.cursor_pos = .{ .x = 0, .y = 0 },
|
||
.im_context = im_context,
|
||
.cgroup_path = cgroup_path,
|
||
};
|
||
errdefer self.* = undefined;
|
||
|
||
// Set our default mouse shape
|
||
try self.setMouseShape(.text);
|
||
|
||
// GL events
|
||
_ = c.g_signal_connect_data(gl_area, "realize", c.G_CALLBACK(>kRealize), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gl_area, "unrealize", c.G_CALLBACK(>kUnrealize), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gl_area, "destroy", c.G_CALLBACK(>kDestroy), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gl_area, "render", c.G_CALLBACK(>kRender), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gl_area, "resize", c.G_CALLBACK(>kResize), self, null, c.G_CONNECT_DEFAULT);
|
||
|
||
_ = c.g_signal_connect_data(ec_key_press, "key-pressed", c.G_CALLBACK(>kKeyPressed), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_key_press, "key-released", c.G_CALLBACK(>kKeyReleased), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_focus, "enter", c.G_CALLBACK(>kFocusEnter), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_focus, "leave", c.G_CALLBACK(>kFocusLeave), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gesture_click, "pressed", c.G_CALLBACK(>kMouseDown), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(gesture_click, "released", c.G_CALLBACK(>kMouseUp), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_motion, "motion", c.G_CALLBACK(>kMouseMotion), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_motion, "leave", c.G_CALLBACK(>kMouseLeave), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(ec_scroll, "scroll", c.G_CALLBACK(>kMouseScroll), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(im_context, "preedit-start", c.G_CALLBACK(>kInputPreeditStart), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(im_context, "preedit-changed", c.G_CALLBACK(>kInputPreeditChanged), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(im_context, "preedit-end", c.G_CALLBACK(>kInputPreeditEnd), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(im_context, "commit", c.G_CALLBACK(>kInputCommit), self, null, c.G_CONNECT_DEFAULT);
|
||
_ = c.g_signal_connect_data(drop_target, "drop", c.G_CALLBACK(>kDrop), self, null, c.G_CONNECT_DEFAULT);
|
||
}
|
||
|
||
fn realize(self: *Surface) !void {
|
||
// If this surface has already been realized, then we don't need to
|
||
// reinitialize. This can happen if a surface is moved from one GDK surface
|
||
// to another (i.e. a tab is pulled out into a window).
|
||
if (self.realized) {
|
||
// If we have no OpenGL state though, we do need to reinitialize.
|
||
// We allow the renderer to figure that out
|
||
try self.core_surface.renderer.displayRealize();
|
||
return;
|
||
}
|
||
|
||
// Add ourselves to the list of surfaces on the app.
|
||
try self.app.core_app.addSurface(self);
|
||
errdefer self.app.core_app.deleteSurface(self);
|
||
|
||
// Get our new surface config
|
||
var config = try apprt.surface.newConfig(self.app.core_app, &self.app.config);
|
||
defer config.deinit();
|
||
|
||
if (self.init_config.pwd) |pwd| {
|
||
// If we have a working directory we want, then we force that.
|
||
config.@"working-directory" = pwd;
|
||
} else if (!self.init_config.parent) {
|
||
// A hack, see the "parent_surface" field for more information.
|
||
config.@"working-directory" = self.app.config.@"working-directory";
|
||
}
|
||
|
||
// Initialize our surface now that we have the stable pointer.
|
||
try self.core_surface.init(
|
||
self.app.core_app.alloc,
|
||
&config,
|
||
self.app.core_app,
|
||
self.app,
|
||
self,
|
||
);
|
||
errdefer self.core_surface.deinit();
|
||
|
||
// If we have a font size we want, set that now
|
||
if (self.font_size) |size| {
|
||
try self.core_surface.setFontSize(size);
|
||
}
|
||
|
||
// Set the initial color scheme
|
||
try self.core_surface.colorSchemeCallback(self.app.getColorScheme());
|
||
|
||
// Note we're realized
|
||
self.realized = true;
|
||
}
|
||
|
||
pub fn deinit(self: *Surface) void {
|
||
self.init_config.deinit(self.app.core_app.alloc);
|
||
if (self.title_text) |title| self.app.core_app.alloc.free(title);
|
||
if (self.pwd) |pwd| self.app.core_app.alloc.free(pwd);
|
||
|
||
// We don't allocate anything if we aren't realized.
|
||
if (!self.realized) return;
|
||
|
||
// Delete our inspector if we have one
|
||
self.controlInspector(.hide);
|
||
|
||
// Remove ourselves from the list of known surfaces in the app.
|
||
self.app.core_app.deleteSurface(self);
|
||
|
||
// Clean up our core surface so that all the rendering and IO stop.
|
||
self.core_surface.deinit();
|
||
self.core_surface = undefined;
|
||
|
||
if (self.cgroup_path) |path| self.app.core_app.alloc.free(path);
|
||
|
||
// Free all our GTK stuff
|
||
//
|
||
// Note we don't do anything with the "unfocused_overlay" because
|
||
// it is attached to the overlay which by this point has been destroyed
|
||
// and therefore the unfocused_overlay has been destroyed as well.
|
||
c.g_object_unref(self.im_context);
|
||
if (self.cursor) |cursor| c.g_object_unref(cursor);
|
||
if (self.update_title_timer) |timer| _ = c.g_source_remove(timer);
|
||
self.resize_overlay.deinit();
|
||
}
|
||
|
||
// unref removes the long-held reference to the gl_area and kicks off the
|
||
// deinit/destroy process for this surface.
|
||
pub fn unref(self: *Surface) void {
|
||
c.g_object_unref(self.overlay);
|
||
}
|
||
|
||
pub fn destroy(self: *Surface, alloc: Allocator) void {
|
||
self.deinit();
|
||
alloc.destroy(self);
|
||
}
|
||
|
||
pub fn primaryWidget(self: *Surface) *c.GtkWidget {
|
||
return @ptrCast(@alignCast(self.overlay));
|
||
}
|
||
|
||
fn render(self: *Surface) !void {
|
||
try self.core_surface.renderer.drawFrame(self);
|
||
}
|
||
|
||
/// Called by core surface to get the cgroup.
|
||
pub fn cgroup(self: *const Surface) ?[]const u8 {
|
||
return self.cgroup_path;
|
||
}
|
||
|
||
/// Queue the inspector to render if we have one.
|
||
pub fn queueInspectorRender(self: *Surface) void {
|
||
if (self.inspector) |v| v.queueRender();
|
||
}
|
||
|
||
/// Invalidate the surface so that it forces a redraw on the next tick.
|
||
pub fn redraw(self: *Surface) void {
|
||
c.gtk_gl_area_queue_render(self.gl_area);
|
||
}
|
||
|
||
/// Close this surface.
|
||
pub fn close(self: *Surface, processActive: bool) void {
|
||
self.setSplitZoom(false);
|
||
|
||
// If we're not part of a window hierarchy, we never confirm
|
||
// so we can just directly remove ourselves and exit.
|
||
const window = self.container.window() orelse {
|
||
self.container.remove();
|
||
return;
|
||
};
|
||
|
||
// If we have no process active we can just exit immediately.
|
||
if (!processActive) {
|
||
self.container.remove();
|
||
return;
|
||
}
|
||
|
||
// Setup our basic message
|
||
const alert = c.gtk_message_dialog_new(
|
||
window.window,
|
||
c.GTK_DIALOG_MODAL,
|
||
c.GTK_MESSAGE_QUESTION,
|
||
c.GTK_BUTTONS_YES_NO,
|
||
"Close this terminal?",
|
||
);
|
||
c.gtk_message_dialog_format_secondary_text(
|
||
@ptrCast(alert),
|
||
"There is still a running process in the terminal. " ++
|
||
"Closing the terminal will kill this process. " ++
|
||
"Are you sure you want to close the terminal?\n\n" ++
|
||
"Click 'No' to cancel and return to your terminal.",
|
||
);
|
||
|
||
// We want the "yes" to appear destructive.
|
||
const yes_widget = c.gtk_dialog_get_widget_for_response(
|
||
@ptrCast(alert),
|
||
c.GTK_RESPONSE_YES,
|
||
);
|
||
c.gtk_widget_add_css_class(yes_widget, "destructive-action");
|
||
|
||
// We want the "no" to be the default action
|
||
c.gtk_dialog_set_default_response(
|
||
@ptrCast(alert),
|
||
c.GTK_RESPONSE_NO,
|
||
);
|
||
|
||
_ = c.g_signal_connect_data(alert, "response", c.G_CALLBACK(>kCloseConfirmation), self, null, c.G_CONNECT_DEFAULT);
|
||
|
||
c.gtk_widget_show(alert);
|
||
}
|
||
|
||
pub fn controlInspector(
|
||
self: *Surface,
|
||
mode: apprt.action.Inspector,
|
||
) void {
|
||
const show = switch (mode) {
|
||
.toggle => self.inspector == null,
|
||
.show => true,
|
||
.hide => false,
|
||
};
|
||
|
||
if (!show) {
|
||
if (self.inspector) |v| {
|
||
v.close();
|
||
self.inspector = null;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
// If we already have an inspector, we don't need to show anything.
|
||
if (self.inspector != null) return;
|
||
self.inspector = inspector.Inspector.create(
|
||
self,
|
||
.{ .window = {} },
|
||
) catch |err| {
|
||
log.err("failed to control inspector err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
pub fn getTitleLabel(self: *Surface) ?*c.GtkWidget {
|
||
switch (self.title) {
|
||
.none => return null,
|
||
.label => |label| {
|
||
const widget = @as(*c.GtkWidget, @ptrCast(@alignCast(label)));
|
||
return widget;
|
||
},
|
||
}
|
||
}
|
||
|
||
pub fn setShouldClose(self: *Surface) void {
|
||
_ = self;
|
||
}
|
||
|
||
pub fn shouldClose(self: *const Surface) bool {
|
||
_ = self;
|
||
return false;
|
||
}
|
||
|
||
pub fn getContentScale(self: *const Surface) !apprt.ContentScale {
|
||
// Future: detect GTK version 4.12+ and use gdk_surface_get_scale so we
|
||
// can support fractional scaling.
|
||
const gtk_scale: f32 = @floatFromInt(c.gtk_widget_get_scale_factor(@ptrCast(self.gl_area)));
|
||
|
||
// Also scale using font-specific DPI, which is often exposed to the user
|
||
// via DE accessibility settings (see https://docs.gtk.org/gtk4/class.Settings.html).
|
||
const xft_dpi_scale = xft_scale: {
|
||
// gtk-xft-dpi is font DPI multiplied by 1024. See
|
||
// https://docs.gtk.org/gtk4/property.Settings.gtk-xft-dpi.html
|
||
const settings = c.gtk_settings_get_default();
|
||
|
||
var value: c.GValue = std.mem.zeroes(c.GValue);
|
||
defer c.g_value_unset(&value);
|
||
_ = c.g_value_init(&value, c.G_TYPE_INT);
|
||
c.g_object_get_property(@ptrCast(@alignCast(settings)), "gtk-xft-dpi", &value);
|
||
const gtk_xft_dpi = c.g_value_get_int(&value);
|
||
|
||
// As noted above gtk-xft-dpi is multiplied by 1024, so we divide by
|
||
// 1024, then divide by the default value (96) to derive a scale. Note
|
||
// gtk-xft-dpi can be fractional, so we use floating point math here.
|
||
const xft_dpi: f32 = @as(f32, @floatFromInt(gtk_xft_dpi)) / 1024;
|
||
break :xft_scale xft_dpi / 96;
|
||
};
|
||
|
||
const scale = gtk_scale * xft_dpi_scale;
|
||
return .{ .x = scale, .y = scale };
|
||
}
|
||
|
||
pub fn getSize(self: *const Surface) !apprt.SurfaceSize {
|
||
return self.size;
|
||
}
|
||
|
||
pub fn setInitialWindowSize(self: *const Surface, width: u32, height: u32) !void {
|
||
// If we are within a split, do not set the size.
|
||
if (self.container.split() != null) return;
|
||
|
||
// This operation only makes sense if we're within a window view
|
||
// hierarchy and we're the first tab in the window.
|
||
const window = self.container.window() orelse return;
|
||
if (window.notebook.nPages() > 1) return;
|
||
|
||
// Note: this doesn't properly take into account the window decorations.
|
||
// I'm not currently sure how to do that.
|
||
c.gtk_window_set_default_size(
|
||
@ptrCast(window.window),
|
||
@intCast(width),
|
||
@intCast(height),
|
||
);
|
||
}
|
||
|
||
pub fn setSizeLimits(self: *const Surface, min: apprt.SurfaceSize, max_: ?apprt.SurfaceSize) !void {
|
||
|
||
// There's no support for setting max size at the moment.
|
||
_ = max_;
|
||
|
||
// If we are within a split, do not set the size.
|
||
if (self.container.split() != null) return;
|
||
|
||
// This operation only makes sense if we're within a window view
|
||
// hierarchy and we're the first tab in the window.
|
||
const window = self.container.window() orelse return;
|
||
if (window.notebook.nPages() > 1) return;
|
||
|
||
// Note: this doesn't properly take into account the window decorations.
|
||
// I'm not currently sure how to do that.
|
||
c.gtk_widget_set_size_request(
|
||
@ptrCast(window.window),
|
||
@intCast(min.width),
|
||
@intCast(min.height),
|
||
);
|
||
}
|
||
|
||
pub fn grabFocus(self: *Surface) void {
|
||
if (self.container.tab()) |tab| {
|
||
// If any other surface was focused and zoomed in, set it to non zoomed in
|
||
// so that self can grab focus.
|
||
if (tab.focus_child) |focus_child| {
|
||
if (focus_child.zoomed_in and focus_child != self) {
|
||
focus_child.setSplitZoom(false);
|
||
}
|
||
}
|
||
tab.focus_child = self;
|
||
}
|
||
|
||
const widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
||
_ = c.gtk_widget_grab_focus(widget);
|
||
|
||
self.updateTitleLabels();
|
||
}
|
||
|
||
fn updateTitleLabels(self: *Surface) void {
|
||
// If we have no title, then we have nothing to update.
|
||
const title = self.getTitle() orelse return;
|
||
|
||
// If we have a tab and are the focused child, then we have to update the tab
|
||
if (self.container.tab()) |tab| {
|
||
if (tab.focus_child == self) tab.setLabelText(title);
|
||
}
|
||
|
||
// If we have a window and are focused, then we have to update the window title.
|
||
if (self.container.window()) |window| {
|
||
const widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
||
if (c.gtk_widget_is_focus(widget) == 1) {
|
||
// Changing the title somehow unhides our cursor.
|
||
// https://github.com/ghostty-org/ghostty/issues/1419
|
||
// I don't know a way around this yet. I've tried re-hiding the
|
||
// cursor after setting the title but it doesn't work, I think
|
||
// due to some gtk event loop things...
|
||
window.setTitle(title);
|
||
}
|
||
}
|
||
}
|
||
|
||
const zoom_title_prefix = "🔍 ";
|
||
|
||
pub fn setTitle(self: *Surface, slice: [:0]const u8) !void {
|
||
const alloc = self.app.core_app.alloc;
|
||
|
||
// Always allocate with the "🔍 " at the beginning and slice accordingly
|
||
// is the surface is zoomed in or not.
|
||
const copy: [:0]const u8 = copy: {
|
||
const new_title = try alloc.allocSentinel(u8, zoom_title_prefix.len + slice.len, 0);
|
||
@memcpy(new_title[0..zoom_title_prefix.len], zoom_title_prefix);
|
||
@memcpy(new_title[zoom_title_prefix.len..], slice);
|
||
break :copy new_title;
|
||
};
|
||
errdefer alloc.free(copy);
|
||
|
||
if (self.title_text) |old| alloc.free(old);
|
||
self.title_text = copy;
|
||
|
||
// delay the title update to prevent flickering
|
||
if (self.update_title_timer) |timer| {
|
||
if (c.g_source_remove(timer) == c.FALSE) {
|
||
log.warn("unable to remove update title timer", .{});
|
||
}
|
||
self.update_title_timer = null;
|
||
}
|
||
self.update_title_timer = c.g_timeout_add(75, updateTitleTimerExpired, self);
|
||
}
|
||
|
||
fn updateTitleTimerExpired(ctx: ?*anyopaque) callconv(.C) c.gboolean {
|
||
const self: *Surface = @ptrCast(@alignCast(ctx));
|
||
|
||
self.updateTitleLabels();
|
||
self.update_title_timer = null;
|
||
|
||
return c.FALSE;
|
||
}
|
||
|
||
pub fn getTitle(self: *Surface) ?[:0]const u8 {
|
||
if (self.title_text) |title_text| {
|
||
return if (self.zoomed_in)
|
||
title_text
|
||
else
|
||
title_text[zoom_title_prefix.len..];
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/// Set the current working directory of the surface.
|
||
///
|
||
/// In addition, update the tab's tooltip text, and if we are the focused child,
|
||
/// update the subtitle of the containing window.
|
||
pub fn setPwd(self: *Surface, pwd: [:0]const u8) !void {
|
||
if (self.container.tab()) |tab| {
|
||
tab.setTooltipText(pwd);
|
||
|
||
if (tab.focus_child == self) {
|
||
if (self.container.window()) |window| {
|
||
if (self.app.config.@"window-subtitle" == .@"working-directory") window.setSubtitle(pwd);
|
||
}
|
||
}
|
||
}
|
||
|
||
const alloc = self.app.core_app.alloc;
|
||
|
||
// Failing to set the surface's current working directory is not a big
|
||
// deal since we just used our slice parameter which is the same value.
|
||
if (self.pwd) |old| alloc.free(old);
|
||
self.pwd = alloc.dupeZ(u8, pwd) catch null;
|
||
}
|
||
|
||
pub fn setMouseShape(
|
||
self: *Surface,
|
||
shape: terminal.MouseShape,
|
||
) !void {
|
||
const name: [:0]const u8 = switch (shape) {
|
||
.default => "default",
|
||
.help => "help",
|
||
.pointer => "pointer",
|
||
.context_menu => "context-menu",
|
||
.progress => "progress",
|
||
.wait => "wait",
|
||
.cell => "cell",
|
||
.crosshair => "crosshair",
|
||
.text => "text",
|
||
.vertical_text => "vertical-text",
|
||
.alias => "alias",
|
||
.copy => "copy",
|
||
.no_drop => "no-drop",
|
||
.move => "move",
|
||
.not_allowed => "not-allowed",
|
||
.grab => "grab",
|
||
.grabbing => "grabbing",
|
||
.all_scroll => "all-scroll",
|
||
.col_resize => "col-resize",
|
||
.row_resize => "row-resize",
|
||
.n_resize => "n-resize",
|
||
.e_resize => "e-resize",
|
||
.s_resize => "s-resize",
|
||
.w_resize => "w-resize",
|
||
.ne_resize => "ne-resize",
|
||
.nw_resize => "nw-resize",
|
||
.se_resize => "se-resize",
|
||
.sw_resize => "sw-resize",
|
||
.ew_resize => "ew-resize",
|
||
.ns_resize => "ns-resize",
|
||
.nesw_resize => "nesw-resize",
|
||
.nwse_resize => "nwse-resize",
|
||
.zoom_in => "zoom-in",
|
||
.zoom_out => "zoom-out",
|
||
};
|
||
|
||
const cursor = c.gdk_cursor_new_from_name(name.ptr, null) orelse {
|
||
log.warn("unsupported cursor name={s}", .{name});
|
||
return;
|
||
};
|
||
errdefer c.g_object_unref(cursor);
|
||
|
||
// Set our new cursor. We only do this if the cursor we currently
|
||
// have is NOT set to "none" because setting the cursor causes it
|
||
// to become visible again.
|
||
const gl_area_widget: *c.GtkWidget = @ptrCast(@alignCast(self.gl_area));
|
||
if (c.gtk_widget_get_cursor(gl_area_widget) != self.app.cursor_none) {
|
||
c.gtk_widget_set_cursor(gl_area_widget, cursor);
|
||
}
|
||
|
||
// Free our existing cursor
|
||
if (self.cursor) |old| c.g_object_unref(old);
|
||
self.cursor = cursor;
|
||
}
|
||
|
||
/// Set the visibility of the mouse cursor.
|
||
pub fn setMouseVisibility(self: *Surface, visible: bool) void {
|
||
// Note in there that self.cursor or cursor_none may be null. That's
|
||
// not a problem because NULL is a valid argument for set cursor
|
||
// which means to just use the parent value.
|
||
const gl_area_widget: *c.GtkWidget = @ptrCast(@alignCast(self.gl_area));
|
||
|
||
if (visible) {
|
||
c.gtk_widget_set_cursor(gl_area_widget, self.cursor);
|
||
return;
|
||
}
|
||
|
||
// Set our new cursor to the app "none" cursor
|
||
c.gtk_widget_set_cursor(gl_area_widget, self.app.cursor_none);
|
||
}
|
||
|
||
pub fn mouseOverLink(self: *Surface, uri_: ?[]const u8) void {
|
||
const uri = uri_ orelse {
|
||
if (self.url_widget) |*widget| {
|
||
widget.deinit(self.overlay);
|
||
self.url_widget = null;
|
||
}
|
||
|
||
return;
|
||
};
|
||
|
||
// We need a null-terminated string
|
||
const alloc = self.app.core_app.alloc;
|
||
const uriZ = alloc.dupeZ(u8, uri) catch return;
|
||
defer alloc.free(uriZ);
|
||
|
||
// If we have a URL widget already just change the text.
|
||
if (self.url_widget) |widget| {
|
||
widget.setText(uriZ);
|
||
return;
|
||
}
|
||
|
||
self.url_widget = URLWidget.init(self, uriZ);
|
||
}
|
||
|
||
pub fn supportsClipboard(
|
||
self: *const Surface,
|
||
clipboard_type: apprt.Clipboard,
|
||
) bool {
|
||
_ = self;
|
||
return switch (clipboard_type) {
|
||
.standard,
|
||
.selection,
|
||
.primary,
|
||
=> true,
|
||
};
|
||
}
|
||
|
||
pub fn clipboardRequest(
|
||
self: *Surface,
|
||
clipboard_type: apprt.Clipboard,
|
||
state: apprt.ClipboardRequest,
|
||
) !void {
|
||
// We allocate for userdata for the clipboard request. Not ideal but
|
||
// clipboard requests aren't common so probably not a big deal.
|
||
const alloc = self.app.core_app.alloc;
|
||
const ud_ptr = try alloc.create(ClipboardRequest);
|
||
errdefer alloc.destroy(ud_ptr);
|
||
ud_ptr.* = .{ .self = self, .state = state };
|
||
|
||
// Start our async request
|
||
const clipboard = getClipboard(@ptrCast(self.gl_area), clipboard_type);
|
||
c.gdk_clipboard_read_text_async(
|
||
clipboard,
|
||
null,
|
||
>kClipboardRead,
|
||
ud_ptr,
|
||
);
|
||
}
|
||
|
||
pub fn setClipboardString(
|
||
self: *Surface,
|
||
val: [:0]const u8,
|
||
clipboard_type: apprt.Clipboard,
|
||
confirm: bool,
|
||
) !void {
|
||
if (!confirm) {
|
||
const clipboard = getClipboard(@ptrCast(self.gl_area), clipboard_type);
|
||
c.gdk_clipboard_set_text(clipboard, val.ptr);
|
||
// We only toast if we are copying to the standard clipboard.
|
||
if (clipboard_type == .standard and
|
||
self.app.config.@"adw-toast".@"clipboard-copy")
|
||
{
|
||
if (self.container.window()) |window|
|
||
window.sendToast("Copied to clipboard");
|
||
}
|
||
return;
|
||
}
|
||
|
||
ClipboardConfirmationWindow.create(
|
||
self.app,
|
||
val,
|
||
&self.core_surface,
|
||
.{ .osc_52_write = clipboard_type },
|
||
) catch |window_err| {
|
||
log.err("failed to create clipboard confirmation window err={}", .{window_err});
|
||
};
|
||
}
|
||
|
||
const ClipboardRequest = struct {
|
||
self: *Surface,
|
||
state: apprt.ClipboardRequest,
|
||
};
|
||
|
||
fn gtkClipboardRead(
|
||
source: ?*c.GObject,
|
||
res: ?*c.GAsyncResult,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const req: *ClipboardRequest = @ptrCast(@alignCast(ud orelse return));
|
||
const self = req.self;
|
||
const alloc = self.app.core_app.alloc;
|
||
defer alloc.destroy(req);
|
||
|
||
var gerr: ?*c.GError = null;
|
||
const cstr = c.gdk_clipboard_read_text_finish(
|
||
@ptrCast(source orelse return),
|
||
res,
|
||
&gerr,
|
||
);
|
||
if (gerr) |err| {
|
||
defer c.g_error_free(err);
|
||
log.warn("failed to read clipboard err={s}", .{err.message});
|
||
return;
|
||
}
|
||
defer c.g_free(cstr);
|
||
const str = std.mem.sliceTo(cstr, 0);
|
||
|
||
self.core_surface.completeClipboardRequest(
|
||
req.state,
|
||
str,
|
||
false,
|
||
) catch |err| switch (err) {
|
||
error.UnsafePaste,
|
||
error.UnauthorizedPaste,
|
||
=> {
|
||
// Create a dialog and ask the user if they want to paste anyway.
|
||
ClipboardConfirmationWindow.create(
|
||
self.app,
|
||
str,
|
||
&self.core_surface,
|
||
req.state,
|
||
) catch |window_err| {
|
||
log.err("failed to create clipboard confirmation window err={}", .{window_err});
|
||
};
|
||
return;
|
||
},
|
||
|
||
else => log.err("failed to complete clipboard request err={}", .{err}),
|
||
};
|
||
}
|
||
|
||
fn getClipboard(widget: *c.GtkWidget, clipboard: apprt.Clipboard) ?*c.GdkClipboard {
|
||
return switch (clipboard) {
|
||
.standard => c.gtk_widget_get_clipboard(widget),
|
||
.selection, .primary => c.gtk_widget_get_primary_clipboard(widget),
|
||
};
|
||
}
|
||
pub fn getCursorPos(self: *const Surface) !apprt.CursorPos {
|
||
return self.cursor_pos;
|
||
}
|
||
|
||
pub fn showDesktopNotification(
|
||
self: *Surface,
|
||
title: []const u8,
|
||
body: []const u8,
|
||
) !void {
|
||
// Set a default title if we don't already have one
|
||
const t = switch (title.len) {
|
||
0 => "Ghostty",
|
||
else => title,
|
||
};
|
||
|
||
const notification = c.g_notification_new(t.ptr);
|
||
defer c.g_object_unref(notification);
|
||
c.g_notification_set_body(notification, body.ptr);
|
||
|
||
const icon = c.g_themed_icon_new(build_config.bundle_id);
|
||
defer c.g_object_unref(icon);
|
||
c.g_notification_set_icon(notification, icon);
|
||
|
||
const pointer = c.g_variant_new_uint64(@intFromPtr(&self.core_surface));
|
||
c.g_notification_set_default_action_and_target_value(
|
||
notification,
|
||
"app.present-surface",
|
||
pointer,
|
||
);
|
||
|
||
const g_app: *c.GApplication = @ptrCast(self.app.app);
|
||
|
||
// We set the notification ID to the body content. If the content is the
|
||
// same, this notification may replace a previous notification
|
||
c.g_application_send_notification(g_app, body.ptr, notification);
|
||
}
|
||
|
||
fn showContextMenu(self: *Surface, x: f32, y: f32) void {
|
||
const window: *Window = self.container.window() orelse {
|
||
log.info(
|
||
"showContextMenu invalid for container={s}",
|
||
.{@tagName(self.container)},
|
||
);
|
||
return;
|
||
};
|
||
|
||
var point: c.graphene_point_t = .{ .x = x, .y = y };
|
||
if (c.gtk_widget_compute_point(
|
||
self.primaryWidget(),
|
||
@ptrCast(window.window),
|
||
&c.GRAPHENE_POINT_INIT(point.x, point.y),
|
||
@ptrCast(&point),
|
||
) == 0) {
|
||
log.warn("failed computing point for context menu", .{});
|
||
return;
|
||
}
|
||
|
||
const rect: c.GdkRectangle = .{
|
||
.x = @intFromFloat(point.x),
|
||
.y = @intFromFloat(point.y),
|
||
.width = 1,
|
||
.height = 1,
|
||
};
|
||
|
||
c.gtk_popover_set_pointing_to(@ptrCast(@alignCast(window.context_menu)), &rect);
|
||
self.app.refreshContextMenu(window.window, self.core_surface.hasSelection());
|
||
c.gtk_popover_popup(@ptrCast(@alignCast(window.context_menu)));
|
||
}
|
||
|
||
fn gtkRealize(area: *c.GtkGLArea, ud: ?*anyopaque) callconv(.C) void {
|
||
log.debug("gl surface realized", .{});
|
||
|
||
// We need to make the context current so we can call GL functions.
|
||
c.gtk_gl_area_make_current(area);
|
||
if (c.gtk_gl_area_get_error(area)) |err| {
|
||
log.err("surface failed to realize: {s}", .{err.*.message});
|
||
log.warn("this error is usually due to a driver or gtk bug", .{});
|
||
log.warn("this is a common cause of this issue: https://gitlab.gnome.org/GNOME/gtk/-/issues/4950", .{});
|
||
return;
|
||
}
|
||
|
||
// realize means that our OpenGL context is ready, so we can now
|
||
// initialize the core surface which will setup the renderer.
|
||
const self = userdataSelf(ud.?);
|
||
self.realize() catch |err| {
|
||
// TODO: we need to destroy the GL area here.
|
||
log.err("surface failed to realize: {}", .{err});
|
||
return;
|
||
};
|
||
|
||
// When we have a realized surface, we also attach our input method context.
|
||
// We do this here instead of init because this allows us to release the ref
|
||
// to the GLArea when we unrealized.
|
||
c.gtk_im_context_set_client_widget(self.im_context, @ptrCast(@alignCast(self.overlay)));
|
||
}
|
||
|
||
/// This is called when the underlying OpenGL resources must be released.
|
||
/// This is usually due to the OpenGL area changing GDK surfaces.
|
||
fn gtkUnrealize(area: *c.GtkGLArea, ud: ?*anyopaque) callconv(.C) void {
|
||
_ = area;
|
||
|
||
log.debug("gl surface unrealized", .{});
|
||
const self = userdataSelf(ud.?);
|
||
self.core_surface.renderer.displayUnrealized();
|
||
|
||
// See gtkRealize for why we do this here.
|
||
c.gtk_im_context_set_client_widget(self.im_context, null);
|
||
}
|
||
|
||
/// render signal
|
||
fn gtkRender(area: *c.GtkGLArea, ctx: *c.GdkGLContext, ud: ?*anyopaque) callconv(.C) c.gboolean {
|
||
_ = area;
|
||
_ = ctx;
|
||
|
||
const self = userdataSelf(ud.?);
|
||
self.render() catch |err| {
|
||
log.err("surface failed to render: {}", .{err});
|
||
return 0;
|
||
};
|
||
|
||
return 1;
|
||
}
|
||
|
||
/// render signal
|
||
fn gtkResize(area: *c.GtkGLArea, width: c.gint, height: c.gint, ud: ?*anyopaque) callconv(.C) void {
|
||
const self = userdataSelf(ud.?);
|
||
|
||
// Some debug output to help understand what GTK is telling us.
|
||
{
|
||
const scale_factor = scale: {
|
||
const widget = @as(*c.GtkWidget, @ptrCast(area));
|
||
break :scale c.gtk_widget_get_scale_factor(widget);
|
||
};
|
||
|
||
const window_scale_factor = scale: {
|
||
const window = self.container.window() orelse break :scale 0;
|
||
const gdk_surface = c.gtk_native_get_surface(@ptrCast(window.window));
|
||
break :scale c.gdk_surface_get_scale_factor(gdk_surface);
|
||
};
|
||
|
||
log.debug("gl resize width={} height={} scale={} window_scale={}", .{
|
||
width,
|
||
height,
|
||
scale_factor,
|
||
window_scale_factor,
|
||
});
|
||
}
|
||
|
||
self.size = .{
|
||
.width = @intCast(width),
|
||
.height = @intCast(height),
|
||
};
|
||
|
||
// We also update the content scale because there is no signal for
|
||
// content scale change and it seems to trigger a resize event.
|
||
if (self.getContentScale()) |scale| {
|
||
self.core_surface.contentScaleCallback(scale) catch |err| {
|
||
log.err("error in content scale callback err={}", .{err});
|
||
return;
|
||
};
|
||
} else |_| {}
|
||
|
||
// Call the primary callback.
|
||
if (self.realized) {
|
||
self.core_surface.sizeCallback(self.size) catch |err| {
|
||
log.err("error in size callback err={}", .{err});
|
||
return;
|
||
};
|
||
|
||
if (self.container.window()) |window| {
|
||
window.winproto.resizeEvent() catch |err| {
|
||
log.warn("failed to notify window protocol of resize={}", .{err});
|
||
};
|
||
}
|
||
|
||
self.resize_overlay.maybeShow();
|
||
}
|
||
}
|
||
|
||
/// "destroy" signal for surface
|
||
fn gtkDestroy(v: *c.GtkWidget, ud: ?*anyopaque) callconv(.C) void {
|
||
_ = v;
|
||
log.debug("gl destroy", .{});
|
||
|
||
const self = userdataSelf(ud.?);
|
||
const alloc = self.app.core_app.alloc;
|
||
self.deinit();
|
||
alloc.destroy(self);
|
||
}
|
||
|
||
/// Scale x/y by the GDK device scale.
|
||
fn scaledCoordinates(
|
||
self: *const Surface,
|
||
x: c.gdouble,
|
||
y: c.gdouble,
|
||
) struct {
|
||
x: c.gdouble,
|
||
y: c.gdouble,
|
||
} {
|
||
const scale_factor: f64 = @floatFromInt(
|
||
c.gtk_widget_get_scale_factor(@ptrCast(self.gl_area)),
|
||
);
|
||
|
||
return .{
|
||
.x = x * scale_factor,
|
||
.y = y * scale_factor,
|
||
};
|
||
}
|
||
|
||
fn gtkMouseDown(
|
||
gesture: *c.GtkGestureClick,
|
||
_: c.gint,
|
||
x: c.gdouble,
|
||
y: c.gdouble,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const event = c.gtk_event_controller_get_current_event(@ptrCast(gesture)) orelse return;
|
||
|
||
const self = userdataSelf(ud.?);
|
||
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
||
|
||
const button = translateMouseButton(c.gtk_gesture_single_get_current_button(@ptrCast(gesture)));
|
||
const mods = gtk_key.translateMods(gtk_mods);
|
||
|
||
// If we don't have focus, grab it.
|
||
const gl_widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
||
if (c.gtk_widget_has_focus(gl_widget) == 0) {
|
||
self.grabFocus();
|
||
}
|
||
|
||
const consumed = self.core_surface.mouseButtonCallback(.press, button, mods) catch |err| {
|
||
log.err("error in key callback err={}", .{err});
|
||
return;
|
||
};
|
||
|
||
// If a right click isn't consumed, mouseButtonCallback selects the hovered
|
||
// word and returns false. We can use this to handle the context menu
|
||
// opening under normal scenarios.
|
||
if (!consumed and button == .right) {
|
||
self.showContextMenu(@floatCast(x), @floatCast(y));
|
||
}
|
||
}
|
||
|
||
fn gtkMouseUp(
|
||
gesture: *c.GtkGestureClick,
|
||
_: c.gint,
|
||
_: c.gdouble,
|
||
_: c.gdouble,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const event = c.gtk_event_controller_get_current_event(@ptrCast(gesture)) orelse return;
|
||
|
||
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
||
|
||
const button = translateMouseButton(c.gtk_gesture_single_get_current_button(@ptrCast(gesture)));
|
||
const mods = gtk_key.translateMods(gtk_mods);
|
||
|
||
const self = userdataSelf(ud.?);
|
||
_ = self.core_surface.mouseButtonCallback(.release, button, mods) catch |err| {
|
||
log.err("error in key callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
fn gtkMouseMotion(
|
||
ec: *c.GtkEventControllerMotion,
|
||
x: c.gdouble,
|
||
y: c.gdouble,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const event = c.gtk_event_controller_get_current_event(@ptrCast(ec)) orelse return;
|
||
|
||
const self = userdataSelf(ud.?);
|
||
const scaled = self.scaledCoordinates(x, y);
|
||
|
||
const pos: apprt.CursorPos = .{
|
||
.x = @floatCast(@max(0, scaled.x)),
|
||
.y = @floatCast(scaled.y),
|
||
};
|
||
|
||
// There seem to be at least two cases where GTK issues a mouse motion
|
||
// event without the cursor actually moving:
|
||
// 1. GLArea is resized under the mouse. This has the unfortunate
|
||
// side effect of causing focus to potentially change when
|
||
// `focus-follows-mouse` is enabled.
|
||
// 2. The window title is updated. This can cause the mouse to unhide
|
||
// incorrectly when hide-mouse-when-typing is enabled.
|
||
// To prevent incorrect behavior, we'll only grab focus and
|
||
// continue with callback logic if the cursor has actually moved.
|
||
const is_cursor_still = @abs(self.cursor_pos.x - pos.x) < 1 and
|
||
@abs(self.cursor_pos.y - pos.y) < 1;
|
||
|
||
if (!is_cursor_still) {
|
||
// If we don't have focus, and we want it, grab it.
|
||
const gl_widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
||
if (c.gtk_widget_has_focus(gl_widget) == 0 and self.app.config.@"focus-follows-mouse") {
|
||
self.grabFocus();
|
||
}
|
||
|
||
// Our pos changed, update
|
||
self.cursor_pos = pos;
|
||
|
||
// Get our modifiers
|
||
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
||
const mods = gtk_key.translateMods(gtk_mods);
|
||
|
||
self.core_surface.cursorPosCallback(self.cursor_pos, mods) catch |err| {
|
||
log.err("error in cursor pos callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
}
|
||
|
||
fn gtkMouseLeave(
|
||
ec: *c.GtkEventControllerMotion,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const event = c.gtk_event_controller_get_current_event(@ptrCast(ec)) orelse return;
|
||
|
||
const self = userdataSelf(ud.?);
|
||
|
||
// Get our modifiers
|
||
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
||
const mods = gtk_key.translateMods(gtk_mods);
|
||
self.core_surface.cursorPosCallback(.{ .x = -1, .y = -1 }, mods) catch |err| {
|
||
log.err("error in cursor pos callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
fn gtkMouseScroll(
|
||
_: *c.GtkEventControllerScroll,
|
||
x: c.gdouble,
|
||
y: c.gdouble,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
const self = userdataSelf(ud.?);
|
||
const scaled = self.scaledCoordinates(x, y);
|
||
|
||
// GTK doesn't support any of the scroll mods.
|
||
const scroll_mods: input.ScrollMods = .{};
|
||
|
||
self.core_surface.scrollCallback(
|
||
// We invert because we apply natural scrolling to the values.
|
||
// This behavior has existed for years without Linux users complaining
|
||
// but I suspect we'll have to make this configurable in the future
|
||
// or read a system setting.
|
||
scaled.x * -1,
|
||
scaled.y * -1,
|
||
scroll_mods,
|
||
) catch |err| {
|
||
log.err("error in scroll callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
fn gtkKeyPressed(
|
||
ec_key: *c.GtkEventControllerKey,
|
||
keyval: c.guint,
|
||
keycode: c.guint,
|
||
gtk_mods: c.GdkModifierType,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) c.gboolean {
|
||
const self = userdataSelf(ud.?);
|
||
return if (self.keyEvent(
|
||
.press,
|
||
ec_key,
|
||
keyval,
|
||
keycode,
|
||
gtk_mods,
|
||
)) 1 else 0;
|
||
}
|
||
|
||
fn gtkKeyReleased(
|
||
ec_key: *c.GtkEventControllerKey,
|
||
keyval: c.guint,
|
||
keycode: c.guint,
|
||
state: c.GdkModifierType,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) c.gboolean {
|
||
const self = userdataSelf(ud.?);
|
||
return if (self.keyEvent(
|
||
.release,
|
||
ec_key,
|
||
keyval,
|
||
keycode,
|
||
state,
|
||
)) 1 else 0;
|
||
}
|
||
|
||
/// Key press event (press or release).
|
||
///
|
||
/// At a high level, we want to construct an `input.KeyEvent` and
|
||
/// pass that to `keyCallback`. At a low level, this is more complicated
|
||
/// than it appears because we need to construct all of this information
|
||
/// and its not given to us.
|
||
///
|
||
/// For all events, we run the GdkEvent through the input method context.
|
||
/// This allows the input method to capture the event and trigger
|
||
/// callbacks such as preedit, commit, etc.
|
||
///
|
||
/// There are a couple important aspects to the prior paragraph: we must
|
||
/// send ALL events through the input method context. This is because
|
||
/// input methods use both key press and key release events to determine
|
||
/// the state of the input method. For example, fcitx uses key release
|
||
/// events on modifiers (i.e. ctrl+shift) to switch the input method.
|
||
///
|
||
/// We set some state to note we're in a key event (self.in_keyevent)
|
||
/// because some of the input method callbacks change behavior based on
|
||
/// this state. For example, we don't want to send character events
|
||
/// like "a" via the input "commit" event if we're actively processing
|
||
/// a keypress because we'd lose access to the keycode information.
|
||
/// However, a "commit" event may still happen outside of a keypress
|
||
/// event from e.g. a tablet or on-screen keyboard.
|
||
///
|
||
/// Finally, we take all of the information in order to determine if we have
|
||
/// a unicode character or if we have to map the keyval to a code to
|
||
/// get the underlying logical key, etc.
|
||
///
|
||
/// Then we can emit the keyCallback.
|
||
pub fn keyEvent(
|
||
self: *Surface,
|
||
action: input.Action,
|
||
ec_key: *c.GtkEventControllerKey,
|
||
keyval: c.guint,
|
||
keycode: c.guint,
|
||
gtk_mods: c.GdkModifierType,
|
||
) bool {
|
||
// log.warn("GTKIM: keyEvent action={}", .{action});
|
||
const event = c.gtk_event_controller_get_current_event(
|
||
@ptrCast(ec_key),
|
||
) orelse return false;
|
||
|
||
// The block below is all related to input method handling. See the function
|
||
// comment for some high level details and then the comments within
|
||
// the block for more specifics.
|
||
{
|
||
// This can trigger an input method so we need to notify the im context
|
||
// where the cursor is so it can render the dropdowns in the correct
|
||
// place.
|
||
const ime_point = self.core_surface.imePoint();
|
||
c.gtk_im_context_set_cursor_location(self.im_context, &.{
|
||
.x = @intFromFloat(ime_point.x),
|
||
.y = @intFromFloat(ime_point.y),
|
||
.width = 1,
|
||
.height = 1,
|
||
});
|
||
|
||
// Pass the event through the IM controller. This will return true
|
||
// if the input method handled the event.
|
||
//
|
||
// Confusingly, not all events handled by the input method result
|
||
// in this returning true so we have to maintain some local state to
|
||
// find those and in one case we simply lose information.
|
||
//
|
||
// - If we change the input method via keypress while we have preedit
|
||
// text, the input method will commit the pending text but will not
|
||
// mark it as handled. We use the `was_composing` variable to detect
|
||
// this case.
|
||
//
|
||
// - If we switch input methods (i.e. via ctrl+shift with fcitx),
|
||
// the input method will handle the key release event but will not
|
||
// mark it as handled. I don't know any way to detect this case so
|
||
// it will result in a key event being sent to the key callback.
|
||
// For Kitty text encoding, this will result in modifiers being
|
||
// triggered despite being technically consumed. At the time of
|
||
// writing, both Kitty and Alacritty have the same behavior. I
|
||
// know of no way to fix this.
|
||
const was_composing = self.im_composing;
|
||
const im_handled = filter: {
|
||
// We note that we're in a keypress because we want some logic to
|
||
// depend on this. For example, we don't want to send character events
|
||
// like "a" via the input "commit" event if we're actively processing
|
||
// a keypress because we'd lose access to the keycode information.
|
||
self.in_keyevent = true;
|
||
defer self.in_keyevent = false;
|
||
break :filter c.gtk_im_context_filter_keypress(
|
||
self.im_context,
|
||
event,
|
||
) != 0;
|
||
};
|
||
// log.warn("GTKIM: im_handled={} im_len={} im_composing={}", .{
|
||
// im_handled,
|
||
// self.im_len,
|
||
// self.im_composing,
|
||
// });
|
||
|
||
// If the input method handled the event, you would think we would
|
||
// never proceed with key encoding for Ghostty but that is not the
|
||
// case. Input methods will handle basic character encoding like
|
||
// typing "a" and we want to associate that with the key event.
|
||
// So we have to check additional state to determine if we exit.
|
||
if (im_handled) {
|
||
// If we are composing then we're in a preedit state and do
|
||
// not want to encode any keys. For example: type a deadkey
|
||
// such as single quote on a US international keyboard layout.
|
||
if (self.im_composing) return true;
|
||
|
||
// If we were composing and now we're not it means that we committed
|
||
// the text. We also don't want to encode a key event for this.
|
||
// Example: enable Japanese input method, press "konn" and then
|
||
// press enter. The final enter should not be encoded and "konn"
|
||
// (in hiragana) should be written as "こん".
|
||
if (was_composing) return true;
|
||
|
||
// Not composing and our input method buffer is empty. This could
|
||
// mean that the input method reacted to this event by activating
|
||
// an onscreen keyboard or something equivalent. We don't know.
|
||
// But the input method handled it and didn't give us text so
|
||
// we will just assume we should not encode this. This handles a
|
||
// real scenario when ibus starts the emoji input method
|
||
// (super+.).
|
||
if (self.im_len == 0) return true;
|
||
}
|
||
|
||
// At this point, for the sake of explanation of internal state:
|
||
// it is possible that im_len > 0 and im_composing == false. This
|
||
// means that we received a commit event from the input method that
|
||
// we want associated with the key event. This is common: its how
|
||
// basic character translation for simple inputs like "a" work.
|
||
}
|
||
|
||
// We always reset the length of the im buffer. There's only one scenario
|
||
// we reach this point with im_len > 0 and that's if we received a commit
|
||
// event from the input method. We don't want to keep that state around
|
||
// since we've handled it here.
|
||
defer self.im_len = 0;
|
||
|
||
// Get the keyvals for this event.
|
||
const keyval_unicode = c.gdk_keyval_to_unicode(keyval);
|
||
const keyval_unicode_unshifted: u21 = gtk_key.keyvalUnicodeUnshifted(
|
||
@ptrCast(self.gl_area),
|
||
event,
|
||
keycode,
|
||
);
|
||
|
||
// We want to get the physical unmapped key to process physical keybinds.
|
||
// (These are keybinds explicitly marked as requesting physical mapping).
|
||
const physical_key = keycode: for (input.keycodes.entries) |entry| {
|
||
if (entry.native == keycode) break :keycode entry.key;
|
||
} else .invalid;
|
||
|
||
// Get our modifier for the event
|
||
const mods: input.Mods = gtk_key.eventMods(
|
||
event,
|
||
physical_key,
|
||
gtk_mods,
|
||
&self.app.winproto,
|
||
);
|
||
|
||
// Get our consumed modifiers
|
||
const consumed_mods: input.Mods = consumed: {
|
||
const raw = c.gdk_key_event_get_consumed_modifiers(event);
|
||
const masked = raw & c.GDK_MODIFIER_MASK;
|
||
break :consumed gtk_key.translateMods(masked);
|
||
};
|
||
|
||
// If we're not in a dead key state, we want to translate our text
|
||
// to some input.Key.
|
||
const key = if (!self.im_composing) key: {
|
||
// First, try to convert the keyval directly to a key. This allows the
|
||
// use of key remapping and identification of keypad numerics (as
|
||
// opposed to their ASCII counterparts)
|
||
if (gtk_key.keyFromKeyval(keyval)) |key| {
|
||
break :key key;
|
||
}
|
||
|
||
// A completed key. If the length of the key is one then we can
|
||
// attempt to translate it to a key enum and call the key
|
||
// callback. First try plain ASCII.
|
||
if (self.im_len > 0) {
|
||
if (input.Key.fromASCII(self.im_buf[0])) |key| {
|
||
break :key key;
|
||
}
|
||
}
|
||
|
||
// If that doesn't work then we try to translate the kevval..
|
||
if (keyval_unicode != 0) {
|
||
if (std.math.cast(u8, keyval_unicode)) |byte| {
|
||
if (input.Key.fromASCII(byte)) |key| {
|
||
break :key key;
|
||
}
|
||
}
|
||
}
|
||
|
||
// If that doesn't work we use the unshifted value...
|
||
if (std.math.cast(u8, keyval_unicode_unshifted)) |ascii| {
|
||
if (input.Key.fromASCII(ascii)) |key| {
|
||
break :key key;
|
||
}
|
||
}
|
||
|
||
// If we have im text then this is invalid. This means that
|
||
// the keypress generated some character that we don't know about
|
||
// in our key enum. We don't want to use the physical key because
|
||
// it can be simply wrong. For example on "Turkish Q" the "i" key
|
||
// on a US layout results in "ı" which is not the same as "i" so
|
||
// we shouldn't use the physical key.
|
||
if (self.im_len > 0 or keyval_unicode_unshifted != 0) break :key .invalid;
|
||
|
||
break :key physical_key;
|
||
} else .invalid;
|
||
|
||
// log.debug("key pressed key={} keyval={x} physical_key={} composing={} text_len={} mods={}", .{
|
||
// key,
|
||
// keyval,
|
||
// physical_key,
|
||
// self.im_composing,
|
||
// self.im_len,
|
||
// mods,
|
||
// });
|
||
|
||
// If we have no UTF-8 text, we try to convert our keyval to
|
||
// a text value. We have to do this because GTK will not process
|
||
// "Ctrl+Shift+1" (on US keyboards) as "Ctrl+!" but instead as "".
|
||
// But the keyval is set correctly so we can at least extract that.
|
||
if (self.im_len == 0 and keyval_unicode > 0) im: {
|
||
if (std.math.cast(u21, keyval_unicode)) |cp| {
|
||
// We don't want to send control characters as IM
|
||
// text. Control characters are handled already by
|
||
// the encoder directly.
|
||
if (cp < 0x20) break :im;
|
||
|
||
if (std.unicode.utf8Encode(cp, &self.im_buf)) |len| {
|
||
self.im_len = len;
|
||
} else |_| {}
|
||
}
|
||
}
|
||
|
||
// Invoke the core Ghostty logic to handle this input.
|
||
const effect = self.core_surface.keyCallback(.{
|
||
.action = action,
|
||
.key = key,
|
||
.physical_key = physical_key,
|
||
.mods = mods,
|
||
.consumed_mods = consumed_mods,
|
||
.composing = self.im_composing,
|
||
.utf8 = self.im_buf[0..self.im_len],
|
||
.unshifted_codepoint = keyval_unicode_unshifted,
|
||
}) catch |err| {
|
||
log.err("error in key callback err={}", .{err});
|
||
return false;
|
||
};
|
||
|
||
switch (effect) {
|
||
.closed => return true,
|
||
.ignored => {},
|
||
.consumed => if (action == .press or action == .repeat) {
|
||
// If we were in the composing state then we reset our context.
|
||
// We do NOT want to reset if we're not in the composing state
|
||
// because there is other IME state that we want to preserve,
|
||
// such as quotation mark ordering for Chinese input.
|
||
if (self.im_composing) {
|
||
c.gtk_im_context_reset(self.im_context);
|
||
self.core_surface.preeditCallback(null) catch {};
|
||
}
|
||
|
||
return true;
|
||
},
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
fn gtkInputPreeditStart(
|
||
_: *c.GtkIMContext,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
// log.warn("GTKIM: preedit start", .{});
|
||
const self = userdataSelf(ud.?);
|
||
|
||
// Start our composing state for the input method and reset our
|
||
// input buffer to empty.
|
||
self.im_composing = true;
|
||
self.im_len = 0;
|
||
}
|
||
|
||
fn gtkInputPreeditChanged(
|
||
ctx: *c.GtkIMContext,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
// log.warn("GTKIM: preedit change", .{});
|
||
const self = userdataSelf(ud.?);
|
||
|
||
// Get our pre-edit string that we'll use to show the user.
|
||
var buf: [*c]u8 = undefined;
|
||
_ = c.gtk_im_context_get_preedit_string(ctx, &buf, null, null);
|
||
defer c.g_free(buf);
|
||
const str = std.mem.sliceTo(buf, 0);
|
||
|
||
// Update our preedit state in Ghostty core
|
||
self.core_surface.preeditCallback(str) catch |err| {
|
||
log.err("error in preedit callback err={}", .{err});
|
||
};
|
||
}
|
||
|
||
fn gtkInputPreeditEnd(
|
||
_: *c.GtkIMContext,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
// log.warn("GTKIM: preedit end", .{});
|
||
const self = userdataSelf(ud.?);
|
||
|
||
// End our composing state for GTK, allowing us to commit the text.
|
||
self.im_composing = false;
|
||
|
||
// End our preedit state in Ghostty core
|
||
self.core_surface.preeditCallback(null) catch |err| {
|
||
log.err("error in preedit callback err={}", .{err});
|
||
};
|
||
}
|
||
|
||
fn gtkInputCommit(
|
||
_: *c.GtkIMContext,
|
||
bytes: [*:0]u8,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
// log.warn("GTKIM: input commit", .{});
|
||
const self = userdataSelf(ud.?);
|
||
const str = std.mem.sliceTo(bytes, 0);
|
||
|
||
// If we're in a keyEvent (i.e. a keyboard event) and we're not composing,
|
||
// then this is just a normal key press resulting in UTF-8 text. We
|
||
// want the keyEvent to handle this so that the UTF-8 text can be associated
|
||
// with a keyboard event.
|
||
if (!self.im_composing and self.in_keyevent) {
|
||
if (str.len > self.im_buf.len) {
|
||
log.warn("not enough buffer space for input method commit", .{});
|
||
return;
|
||
}
|
||
|
||
// Copy our committed text to the buffer
|
||
@memcpy(self.im_buf[0..str.len], str);
|
||
self.im_len = @intCast(str.len);
|
||
|
||
// log.debug("input commit len={}", .{self.im_len});
|
||
return;
|
||
}
|
||
|
||
// If we reach this point from above it means we're composing OR
|
||
// not in a keypress. In either case, we want to commit the text
|
||
// given to us because that's what GTK is asking us to do. If we're
|
||
// not in a keypress it means that this commit came via a non-keyboard
|
||
// event (i.e. on-screen keyboard, tablet of some kind, etc.).
|
||
|
||
// Committing ends composing state
|
||
self.im_composing = false;
|
||
|
||
// End our preedit state. Well-behaved input methods do this for us
|
||
// by triggering a preedit-end event but some do not (ibus 1.5.29).
|
||
self.core_surface.preeditCallback(null) catch |err| {
|
||
log.err("error in preedit callback err={}", .{err});
|
||
};
|
||
|
||
// Send the text to the core surface, associated with no key (an
|
||
// invalid key, which should produce no PTY encoding).
|
||
_ = self.core_surface.keyCallback(.{
|
||
.action = .press,
|
||
.key = .invalid,
|
||
.physical_key = .invalid,
|
||
.mods = .{},
|
||
.consumed_mods = .{},
|
||
.composing = false,
|
||
.utf8 = str,
|
||
}) catch |err| {
|
||
log.warn("error in key callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
fn gtkFocusEnter(_: *c.GtkEventControllerFocus, ud: ?*anyopaque) callconv(.C) void {
|
||
const self = userdataSelf(ud.?);
|
||
if (!self.realized) return;
|
||
|
||
// Notify our IM context
|
||
c.gtk_im_context_focus_in(self.im_context);
|
||
|
||
// Remove the unfocused widget overlay, if we have one
|
||
if (self.unfocused_widget) |widget| {
|
||
c.gtk_overlay_remove_overlay(self.overlay, widget);
|
||
self.unfocused_widget = null;
|
||
}
|
||
|
||
if (self.pwd) |pwd| {
|
||
if (self.container.window()) |window| {
|
||
if (self.app.config.@"window-subtitle" == .@"working-directory") window.setSubtitle(pwd);
|
||
}
|
||
}
|
||
|
||
// Notify our surface
|
||
self.core_surface.focusCallback(true) catch |err| {
|
||
log.err("error in focus callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
fn gtkFocusLeave(_: *c.GtkEventControllerFocus, ud: ?*anyopaque) callconv(.C) void {
|
||
const self = userdataSelf(ud.?);
|
||
if (!self.realized) return;
|
||
|
||
// Notify our IM context
|
||
c.gtk_im_context_focus_out(self.im_context);
|
||
|
||
// We only try dimming the surface if we are a split
|
||
switch (self.container) {
|
||
.split_br,
|
||
.split_tl,
|
||
=> self.dimSurface(),
|
||
else => {},
|
||
}
|
||
|
||
self.core_surface.focusCallback(false) catch |err| {
|
||
log.err("error in focus callback err={}", .{err});
|
||
return;
|
||
};
|
||
}
|
||
|
||
/// Adds the unfocused_widget to the overlay. If the unfocused_widget has already been added, this
|
||
/// is a no-op
|
||
pub fn dimSurface(self: *Surface) void {
|
||
const window = self.container.window() orelse {
|
||
log.warn("dimSurface invalid for container={}", .{self.container});
|
||
return;
|
||
};
|
||
|
||
// Don't dim surface if context menu is open.
|
||
// This means we got unfocused due to it opening.
|
||
const context_menu_open = c.gtk_widget_get_visible(window.context_menu);
|
||
if (context_menu_open == 1) return;
|
||
|
||
if (self.unfocused_widget != null) return;
|
||
self.unfocused_widget = c.gtk_drawing_area_new();
|
||
c.gtk_widget_add_css_class(self.unfocused_widget.?, "unfocused-split");
|
||
c.gtk_overlay_add_overlay(self.overlay, self.unfocused_widget.?);
|
||
}
|
||
|
||
fn gtkCloseConfirmation(
|
||
alert: *c.GtkMessageDialog,
|
||
response: c.gint,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) void {
|
||
c.gtk_window_destroy(@ptrCast(alert));
|
||
if (response == c.GTK_RESPONSE_YES) {
|
||
const self = userdataSelf(ud.?);
|
||
self.container.remove();
|
||
}
|
||
}
|
||
|
||
fn userdataSelf(ud: *anyopaque) *Surface {
|
||
return @ptrCast(@alignCast(ud));
|
||
}
|
||
|
||
fn translateMouseButton(button: c.guint) input.MouseButton {
|
||
return switch (button) {
|
||
1 => .left,
|
||
2 => .middle,
|
||
3 => .right,
|
||
4 => .four,
|
||
5 => .five,
|
||
6 => .six,
|
||
7 => .seven,
|
||
8 => .eight,
|
||
9 => .nine,
|
||
10 => .ten,
|
||
11 => .eleven,
|
||
else => .unknown,
|
||
};
|
||
}
|
||
|
||
pub fn present(self: *Surface) void {
|
||
if (self.container.window()) |window| {
|
||
if (self.container.tab()) |tab| {
|
||
if (window.notebook.getTabPosition(tab)) |position|
|
||
window.notebook.gotoNthTab(position);
|
||
}
|
||
c.gtk_window_present(window.window);
|
||
}
|
||
|
||
self.grabFocus();
|
||
}
|
||
|
||
fn detachFromSplit(self: *Surface) void {
|
||
const split = self.container.split() orelse return;
|
||
switch (self.container.splitSide() orelse unreachable) {
|
||
.top_left => split.detachTopLeft(),
|
||
.bottom_right => split.detachBottomRight(),
|
||
}
|
||
}
|
||
|
||
fn attachToSplit(self: *Surface) void {
|
||
const split = self.container.split() orelse return;
|
||
split.updateChildren();
|
||
}
|
||
|
||
pub fn setSplitZoom(self: *Surface, new_split_zoom: bool) void {
|
||
if (new_split_zoom == self.zoomed_in) return;
|
||
const tab = self.container.tab() orelse return;
|
||
|
||
const tab_widget = tab.elem.widget();
|
||
const surface_widget = self.primaryWidget();
|
||
|
||
if (new_split_zoom) {
|
||
self.detachFromSplit();
|
||
c.gtk_box_remove(tab.box, tab_widget);
|
||
c.gtk_box_append(tab.box, surface_widget);
|
||
} else {
|
||
c.gtk_box_remove(tab.box, surface_widget);
|
||
self.attachToSplit();
|
||
c.gtk_box_append(tab.box, tab_widget);
|
||
}
|
||
|
||
self.zoomed_in = new_split_zoom;
|
||
self.grabFocus();
|
||
}
|
||
|
||
pub fn toggleSplitZoom(self: *Surface) void {
|
||
self.setSplitZoom(!self.zoomed_in);
|
||
}
|
||
|
||
/// Handle items being dropped on our surface.
|
||
fn gtkDrop(
|
||
_: *c.GtkDropTarget,
|
||
value: *c.GValue,
|
||
x: f64,
|
||
y: f64,
|
||
ud: ?*anyopaque,
|
||
) callconv(.C) c.gboolean {
|
||
_ = x;
|
||
_ = y;
|
||
const self = userdataSelf(ud.?);
|
||
const alloc = self.app.core_app.alloc;
|
||
|
||
if (g_value_holds(value, c.G_TYPE_BOXED)) {
|
||
var data = std.ArrayList(u8).init(alloc);
|
||
defer data.deinit();
|
||
|
||
var shell_escape_writer: internal_os.ShellEscapeWriter(std.ArrayList(u8).Writer) = .{
|
||
.child_writer = data.writer(),
|
||
};
|
||
const writer = shell_escape_writer.writer();
|
||
|
||
const fl: *c.GdkFileList = @ptrCast(c.g_value_get_boxed(value));
|
||
var l = c.gdk_file_list_get_files(fl);
|
||
|
||
while (l != null) : (l = l.*.next) {
|
||
const file: *c.GFile = @ptrCast(l.*.data);
|
||
const path = c.g_file_get_path(file) orelse continue;
|
||
|
||
writer.writeAll(std.mem.span(path)) catch |err| {
|
||
log.err("unable to write path to buffer: {}", .{err});
|
||
continue;
|
||
};
|
||
writer.writeAll("\n") catch |err| {
|
||
log.err("unable to write to buffer: {}", .{err});
|
||
continue;
|
||
};
|
||
}
|
||
|
||
const string = data.toOwnedSliceSentinel(0) catch |err| {
|
||
log.err("unable to convert to a slice: {}", .{err});
|
||
return 1;
|
||
};
|
||
defer alloc.free(string);
|
||
|
||
self.doPaste(string);
|
||
|
||
return 1;
|
||
}
|
||
|
||
if (g_value_holds(value, c.G_TYPE_STRING)) {
|
||
if (c.g_value_get_string(value)) |string| {
|
||
self.doPaste(std.mem.span(string));
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
fn doPaste(self: *Surface, data: [:0]const u8) void {
|
||
if (data.len == 0) return;
|
||
|
||
self.core_surface.completeClipboardRequest(.paste, data, false) catch |err| switch (err) {
|
||
error.UnsafePaste,
|
||
error.UnauthorizedPaste,
|
||
=> {
|
||
ClipboardConfirmationWindow.create(
|
||
self.app,
|
||
data,
|
||
&self.core_surface,
|
||
.paste,
|
||
) catch |window_err| {
|
||
log.err("failed to create clipboard confirmation window err={}", .{window_err});
|
||
};
|
||
},
|
||
error.OutOfMemory,
|
||
error.NoSpaceLeft,
|
||
=> log.err("failed to complete clipboard request err={}", .{err}),
|
||
};
|
||
}
|
||
|
||
/// Check a GValue to see what's type its wrapping. This is equivalent to GTK's
|
||
/// `G_VALUE_HOLDS` macro but Zig's C translator does not like it.
|
||
fn g_value_holds(value_: ?*c.GValue, g_type: c.GType) bool {
|
||
if (value_) |value| {
|
||
if (value.*.g_type == g_type) return true;
|
||
return c.g_type_check_value_holds(value, g_type) != 0;
|
||
}
|
||
return false;
|
||
}
|