mirror of
https://github.com/ghostty-org/ghostty.git
synced 2025-07-21 11:16:08 +03:00
7e9dce054f
We don't need to update the titles, etc. since that's done by `grabFocus` and that then makes the method not that useful. Removing for now.
1525 lines
49 KiB
Zig
1525 lines
49 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 configpkg = @import("../../config.zig");
|
|
const apprt = @import("../../apprt.zig");
|
|
const font = @import("../../font/main.zig");
|
|
const input = @import("../../input.zig");
|
|
const terminal = @import("../../terminal/main.zig");
|
|
const CoreSurface = @import("../../Surface.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 inspector = @import("inspector.zig");
|
|
const gtk_key = @import("key.zig");
|
|
const c = @import("c.zig");
|
|
|
|
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.
|
|
parent2: ?*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,
|
|
|
|
/// 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| @ptrCast(s.gl_area),
|
|
.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(),
|
|
}
|
|
}
|
|
};
|
|
|
|
/// 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(Split, "top_left", ptr),
|
|
.split_br => |ptr| @fieldParentPtr(Split, "bottom_right", ptr),
|
|
};
|
|
}
|
|
|
|
/// 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 containing that
|
|
/// all children at this level are exiting.
|
|
pub fn remove(self: Container) void {
|
|
switch (self) {
|
|
.none => {},
|
|
.tab_ => |t| t.closeElem(),
|
|
.split_tl => self.split().?.removeTopLeft(),
|
|
.split_br => self.split().?.removeBottomRight(),
|
|
}
|
|
}
|
|
};
|
|
|
|
/// 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,
|
|
|
|
/// See Options.parentSurface
|
|
parentSurface: bool = false,
|
|
|
|
/// 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,
|
|
|
|
/// Our GTK area
|
|
gl_area: *c.GtkGLArea,
|
|
|
|
/// 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.
|
|
/// TODO: what's a big enough value?
|
|
title_text_buf: [4096]u8,
|
|
title_text_buf_len: u13,
|
|
|
|
/// 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_keypress: bool = false,
|
|
im_context: *c.GtkIMContext,
|
|
im_composing: bool = false,
|
|
im_buf: [128]u8 = undefined,
|
|
im_len: u7 = 0,
|
|
|
|
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 widget: *c.GtkWidget = c.gtk_gl_area_new();
|
|
const gl_area: *c.GtkGLArea = @ptrCast(widget);
|
|
|
|
// We grab the floating reference to GL area. This lets the
|
|
// GL area 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(gl_area));
|
|
errdefer c.g_object_unref(@ptrCast(gl_area));
|
|
|
|
// We want the gl area to expand to fill the parent container.
|
|
c.gtk_widget_set_hexpand(widget, 1);
|
|
c.gtk_widget_set_vexpand(widget, 1);
|
|
|
|
// Various other GL properties
|
|
c.gtk_widget_set_cursor_from_name(@ptrCast(gl_area), "text");
|
|
c.gtk_gl_area_set_required_version(gl_area, 3, 3);
|
|
c.gtk_gl_area_set_has_stencil_buffer(gl_area, 0);
|
|
c.gtk_gl_area_set_has_depth_buffer(gl_area, 0);
|
|
c.gtk_gl_area_set_use_es(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(widget, ec_key);
|
|
errdefer c.gtk_widget_remove_controller(widget, 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(widget, ec_focus);
|
|
errdefer c.gtk_widget_remove_controller(widget, 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(widget, ec_key_press);
|
|
errdefer c.gtk_widget_remove_controller(widget, 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(widget, @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(widget, 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(widget, 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(widget, 1);
|
|
c.gtk_widget_set_focus_on_click(widget, 1);
|
|
|
|
// 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.parent2 orelse break :font_size null;
|
|
break :font_size parent.font_size;
|
|
};
|
|
|
|
// Build our result
|
|
self.* = .{
|
|
.app = app,
|
|
.container = .{ .none = {} },
|
|
.gl_area = gl_area,
|
|
.title_text_buf = undefined,
|
|
.title_text_buf_len = 0,
|
|
.core_surface = undefined,
|
|
.font_size = font_size,
|
|
.parentSurface = opts.parent2 != null,
|
|
.size = .{ .width = 800, .height = 600 },
|
|
.cursor_pos = .{ .x = 0, .y = 0 },
|
|
.im_context = im_context,
|
|
};
|
|
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_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);
|
|
}
|
|
|
|
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.parentSurface) {
|
|
// A hack, see the "parentSurface" 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| {
|
|
self.core_surface.setFontSize(size);
|
|
}
|
|
|
|
// Note we're realized
|
|
self.realized = true;
|
|
}
|
|
|
|
pub fn deinit(self: *Surface) void {
|
|
// 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;
|
|
|
|
// Free all our GTK stuff
|
|
c.g_object_unref(self.im_context);
|
|
|
|
if (self.cursor) |cursor| c.g_object_unref(cursor);
|
|
}
|
|
|
|
// 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.gl_area);
|
|
}
|
|
|
|
pub fn destroy(self: *Surface, alloc: Allocator) void {
|
|
self.deinit();
|
|
alloc.destroy(self);
|
|
}
|
|
|
|
fn render(self: *Surface) !void {
|
|
try self.core_surface.renderer.drawFrame(self);
|
|
}
|
|
|
|
/// 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 {
|
|
// 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: input.InspectorMode) 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 toggleFullscreen(self: *Surface, mac_non_native: configpkg.NonNativeFullscreen) void {
|
|
const window = self.container.window() orelse {
|
|
log.info(
|
|
"toggleFullscreen invalid for container={s}",
|
|
.{@tagName(self.container)},
|
|
);
|
|
return;
|
|
};
|
|
|
|
window.toggleFullscreen(mac_non_native);
|
|
}
|
|
|
|
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 newSplit(self: *Surface, direction: input.SplitDirection) !void {
|
|
const alloc = self.app.core_app.alloc;
|
|
_ = try Split.create(alloc, self, direction);
|
|
}
|
|
|
|
pub fn newTab(self: *Surface) !void {
|
|
const window = self.container.window() orelse {
|
|
log.info("surface cannot create new tab when not attached to a window", .{});
|
|
return;
|
|
};
|
|
|
|
try window.newTab(&self.core_surface);
|
|
}
|
|
|
|
pub fn hasTabs(self: *const Surface) bool {
|
|
const window = self.container.window() orelse return false;
|
|
return window.hasTabs();
|
|
}
|
|
|
|
pub fn gotoPreviousTab(self: *Surface) void {
|
|
const window = self.container.window() orelse {
|
|
log.info(
|
|
"gotoPreviousTab invalid for container={s}",
|
|
.{@tagName(self.container)},
|
|
);
|
|
return;
|
|
};
|
|
|
|
window.gotoPreviousTab(self);
|
|
}
|
|
|
|
pub fn gotoNextTab(self: *Surface) void {
|
|
const window = self.container.window() orelse {
|
|
log.info(
|
|
"gotoNextTab invalid for container={s}",
|
|
.{@tagName(self.container)},
|
|
);
|
|
return;
|
|
};
|
|
|
|
window.gotoNextTab(self);
|
|
}
|
|
|
|
pub fn gotoTab(self: *Surface, n: usize) void {
|
|
const window = self.container.window() orelse {
|
|
log.info(
|
|
"gotoTab invalid for container={s}",
|
|
.{@tagName(self.container)},
|
|
);
|
|
return;
|
|
};
|
|
|
|
window.gotoTab(n);
|
|
}
|
|
|
|
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 scale = c.gtk_widget_get_scale_factor(@ptrCast(self.gl_area));
|
|
return .{ .x = @floatFromInt(scale), .y = @floatFromInt(scale) };
|
|
}
|
|
|
|
pub fn getSize(self: *const Surface) !apprt.SurfaceSize {
|
|
return self.size;
|
|
}
|
|
|
|
pub fn setInitialWindowSize(self: *const Surface, width: u32, height: u32) !void {
|
|
// This operation only makes sense if we're within a window view hierarchy.
|
|
const window = self.container.window() orelse 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 setCellSize(self: *const Surface, width: u32, height: u32) !void {
|
|
_ = self;
|
|
_ = width;
|
|
_ = height;
|
|
}
|
|
|
|
pub fn setSizeLimits(self: *Surface, min: apprt.SurfaceSize, max_: ?apprt.SurfaceSize) !void {
|
|
_ = self;
|
|
_ = min;
|
|
_ = max_;
|
|
}
|
|
|
|
pub fn grabFocus(self: *Surface) void {
|
|
if (self.container.tab()) |tab| tab.focus_child = self;
|
|
|
|
self.updateTitleLabels();
|
|
const widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
|
_ = c.gtk_widget_grab_focus(widget);
|
|
}
|
|
|
|
fn updateTitleLabels(self: *Surface) void {
|
|
// If we have no title, then we have nothing to update.
|
|
if (self.title_text_buf_len == 0) return;
|
|
const slice: []u8 = self.title_text_buf[0..self.title_text_buf_len];
|
|
|
|
// If we have a tab, then we have to update the tab
|
|
if (self.container.tab()) |tab| {
|
|
c.gtk_label_set_text(tab.label_text, slice.ptr);
|
|
}
|
|
|
|
// If we have a window, then we have to update the window title.
|
|
if (self.container.window()) |window| {
|
|
c.gtk_window_set_title(window.window, slice.ptr);
|
|
}
|
|
}
|
|
|
|
pub fn setTitle(self: *Surface, slice: [:0]const u8) !void {
|
|
const len = @min(self.title_text_buf.len - 1, slice.len);
|
|
@memcpy(self.title_text_buf[0..len], slice[0..]);
|
|
// Null-terminate this because we then need to pass it to GTK.
|
|
self.title_text_buf[len] = 0;
|
|
self.title_text_buf_len = len;
|
|
|
|
const widget = @as(*c.GtkWidget, @ptrCast(self.gl_area));
|
|
if (c.gtk_widget_is_focus(widget) == 1) {
|
|
self.updateTitleLabels();
|
|
}
|
|
}
|
|
|
|
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
|
|
c.gtk_widget_set_cursor(@ptrCast(self.gl_area), 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.
|
|
|
|
if (visible) {
|
|
c.gtk_widget_set_cursor(@ptrCast(self.gl_area), self.cursor);
|
|
return;
|
|
}
|
|
|
|
// Set our new cursor to the app "none" cursor
|
|
c.gtk_widget_set_cursor(@ptrCast(self.gl_area), self.app.cursor_none);
|
|
}
|
|
|
|
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: *const 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);
|
|
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 notif = c.g_notification_new(t.ptr);
|
|
defer c.g_object_unref(notif);
|
|
c.g_notification_set_body(notif, body.ptr);
|
|
|
|
// Find our icon in the current icon theme. Not pretty, but the builtin GIO
|
|
// method "g_themed_icon_new" doesn't search XDG_DATA_DIRS, so any install
|
|
// not in /usr/share will be unable to find an icon
|
|
const display = c.gdk_display_get_default();
|
|
const theme = c.gtk_icon_theme_get_for_display(display);
|
|
const icon = c.gtk_icon_theme_lookup_icon(
|
|
theme,
|
|
"com.mitchellh.ghostty",
|
|
null,
|
|
48,
|
|
1, // Window scale
|
|
c.GTK_TEXT_DIR_LTR,
|
|
0,
|
|
);
|
|
defer c.g_object_unref(icon);
|
|
// Get the filepath of the icon we found
|
|
const file = c.gtk_icon_paintable_get_file(icon);
|
|
defer c.g_object_unref(file);
|
|
// Create a GIO icon
|
|
const gicon = c.g_file_icon_new(file);
|
|
defer c.g_object_unref(gicon);
|
|
c.g_notification_set_icon(notif, gicon);
|
|
|
|
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, notif);
|
|
}
|
|
|
|
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});
|
|
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 relase the ref
|
|
// to the GLArea when we unrealized.
|
|
c.gtk_im_context_set_client_widget(self.im_context, @ptrCast(self.gl_area));
|
|
}
|
|
|
|
/// 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;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// "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,
|
|
_: c.gdouble,
|
|
_: c.gdouble,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) void {
|
|
const self = userdataSelf(ud.?);
|
|
const event = c.gtk_event_controller_get_current_event(@ptrCast(gesture));
|
|
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
|
|
|
const button = translateMouseButton(c.gtk_gesture_single_get_current_button(@ptrCast(gesture)));
|
|
const mods = 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();
|
|
}
|
|
|
|
self.core_surface.mouseButtonCallback(.press, button, mods) catch |err| {
|
|
log.err("error in key callback err={}", .{err});
|
|
return;
|
|
};
|
|
}
|
|
|
|
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));
|
|
const gtk_mods = c.gdk_event_get_modifier_state(event);
|
|
|
|
const button = translateMouseButton(c.gtk_gesture_single_get_current_button(@ptrCast(gesture)));
|
|
const mods = 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(
|
|
_: *c.GtkEventControllerMotion,
|
|
x: c.gdouble,
|
|
y: c.gdouble,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) void {
|
|
const self = userdataSelf(ud.?);
|
|
const scaled = self.scaledCoordinates(x, y);
|
|
|
|
self.cursor_pos = .{
|
|
.x = @floatCast(@max(0, scaled.x)),
|
|
.y = @floatCast(scaled.y),
|
|
};
|
|
|
|
self.core_surface.cursorPosCallback(self.cursor_pos) 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(
|
|
scaled.x,
|
|
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 {
|
|
return if (keyEvent(.press, ec_key, keyval, keycode, gtk_mods, ud)) 1 else 0;
|
|
}
|
|
|
|
fn gtkKeyReleased(
|
|
ec_key: *c.GtkEventControllerKey,
|
|
keyval: c.guint,
|
|
keycode: c.guint,
|
|
state: c.GdkModifierType,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) c.gboolean {
|
|
return if (keyEvent(.release, ec_key, keyval, keycode, state, ud)) 1 else 0;
|
|
}
|
|
|
|
/// Key press event. This is where we do ALL of our key handling,
|
|
/// translation to keyboard layouts, dead key handling, etc. Key handling
|
|
/// is complicated so this comment will explain what's going on.
|
|
///
|
|
/// 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 press events, we run the keypress through the input method context
|
|
/// in order to determine if we're in a dead key state, completed unicode
|
|
/// char, etc. This all happens through various callbacks: preedit, commit,
|
|
/// etc. These inspect "in_keypress" if they have to and set some instance
|
|
/// state.
|
|
///
|
|
/// We then 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.
|
|
///
|
|
/// Finally, we can emit the keyCallback.
|
|
///
|
|
/// Note we ALSO have an IMContext attached directly to the widget
|
|
/// which can emit preedit and commit callbacks. But, if we're not
|
|
/// in a keypress, we let those automatically work.
|
|
fn keyEvent(
|
|
action: input.Action,
|
|
ec_key: *c.GtkEventControllerKey,
|
|
keyval: c.guint,
|
|
keycode: c.guint,
|
|
gtk_mods: c.GdkModifierType,
|
|
ud: ?*anyopaque,
|
|
) bool {
|
|
const self = userdataSelf(ud.?);
|
|
const keyval_unicode = c.gdk_keyval_to_unicode(keyval);
|
|
const event = c.gtk_event_controller_get_current_event(@ptrCast(ec_key));
|
|
|
|
// Get the unshifted unicode value of the keyval. This is used
|
|
// by the Kitty keyboard protocol.
|
|
const keyval_unicode_unshifted: u21 = unshifted: {
|
|
// Note: this can't possibly always be right, specifically in the
|
|
// case of multi-level/group keyboards. But, this works for Dvorak,
|
|
// Norwegian, and French layouts and thats what we have real users for
|
|
// right now.
|
|
const lower = c.gdk_keyval_to_lower(keyval);
|
|
const lower_unicode = c.gdk_keyval_to_unicode(lower);
|
|
break :unshifted std.math.cast(u21, lower_unicode) orelse 0;
|
|
};
|
|
|
|
// We always reset our committed text when ending a keypress so that
|
|
// future keypresses don't think we have a commit event.
|
|
defer self.im_len = 0;
|
|
|
|
// We only want to send the event through the IM context if we're a press
|
|
if (action == .press or action == .repeat) {
|
|
// 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,
|
|
});
|
|
|
|
// We mark that we're in a keypress event. We use this in our
|
|
// IM commit callback to determine if we need to send a char callback
|
|
// to the core surface or not.
|
|
self.in_keypress = true;
|
|
defer self.in_keypress = false;
|
|
|
|
// Pass the event through the IM controller to handle dead key states.
|
|
// Filter is true if the event was handled by the IM controller.
|
|
const im_handled = c.gtk_im_context_filter_keypress(self.im_context, event) != 0;
|
|
// log.warn("im_handled={} im_len={} im_composing={}", .{ im_handled, self.im_len, self.im_composing });
|
|
|
|
// If this is a dead key, then we're composing a character and
|
|
// we need to set our proper preedit state.
|
|
if (self.im_composing) preedit: {
|
|
const text = self.im_buf[0..self.im_len];
|
|
self.core_surface.preeditCallback(text) catch |err| {
|
|
log.err("error in preedit callback err={}", .{err});
|
|
break :preedit;
|
|
};
|
|
|
|
// If we're composing then we don't want to send the key
|
|
// event to the core surface so we always return immediately.
|
|
if (im_handled) return true;
|
|
} else {
|
|
// If we aren't composing, then we set our preedit to
|
|
// empty no matter what.
|
|
self.core_surface.preeditCallback(null) catch {};
|
|
|
|
// If the IM handled this and we have no text, then we just
|
|
// return because this probably just changed the input method
|
|
// or something.
|
|
if (im_handled and self.im_len == 0) return true;
|
|
}
|
|
}
|
|
|
|
// 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 modifiers. We have to translate modifier-only presses here
|
|
// to state in the mods manually because GTK only does it AFTER the press
|
|
// event.
|
|
const mods = mods: {
|
|
var mods = translateMods(gtk_mods);
|
|
switch (physical_key) {
|
|
.left_shift => {
|
|
mods.shift = action == .press;
|
|
if (mods.shift) mods.sides.shift = .left;
|
|
},
|
|
|
|
.right_shift => {
|
|
mods.shift = action == .press;
|
|
if (mods.shift) mods.sides.shift = .right;
|
|
},
|
|
|
|
.left_control => {
|
|
mods.ctrl = action == .press;
|
|
if (mods.ctrl) mods.sides.ctrl = .left;
|
|
},
|
|
|
|
.right_control => {
|
|
mods.ctrl = action == .press;
|
|
if (mods.ctrl) mods.sides.ctrl = .right;
|
|
},
|
|
|
|
.left_alt => {
|
|
mods.alt = action == .press;
|
|
if (mods.alt) mods.sides.alt = .left;
|
|
},
|
|
|
|
.right_alt => {
|
|
mods.alt = action == .press;
|
|
if (mods.alt) mods.sides.alt = .right;
|
|
},
|
|
|
|
.left_super => {
|
|
mods.super = action == .press;
|
|
if (mods.super) mods.sides.super = .left;
|
|
},
|
|
|
|
.right_super => {
|
|
mods.super = action == .press;
|
|
if (mods.super) mods.sides.super = .right;
|
|
},
|
|
|
|
else => {},
|
|
}
|
|
break :mods mods;
|
|
};
|
|
|
|
// 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 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: {
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
// Before using the physical key, try to convert the keyval
|
|
// directly to a key. This allows the use of key remapping.
|
|
if (gtk_key.keyFromKeyval(keyval)) |key| {
|
|
break :key key;
|
|
}
|
|
|
|
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) {
|
|
if (std.math.cast(u21, keyval_unicode)) |cp| {
|
|
if (std.unicode.utf8Encode(cp, &self.im_buf)) |len| {
|
|
self.im_len = len;
|
|
} else |_| {}
|
|
}
|
|
}
|
|
|
|
// Invoke the core Ghostty logic to handle this input.
|
|
const consumed = 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;
|
|
};
|
|
|
|
// If we consume the key then we want to reset the dead key state.
|
|
if (consumed and (action == .press or action == .repeat)) {
|
|
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.debug("preedit start", .{});
|
|
const self = userdataSelf(ud.?);
|
|
if (!self.in_keypress) return;
|
|
|
|
// Mark that we are now composing a string with a dead key state.
|
|
// We'll record the string in the preedit-changed callback.
|
|
self.im_composing = true;
|
|
self.im_len = 0;
|
|
}
|
|
|
|
fn gtkInputPreeditChanged(
|
|
ctx: *c.GtkIMContext,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) void {
|
|
const self = userdataSelf(ud.?);
|
|
if (!self.in_keypress) return;
|
|
|
|
// 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);
|
|
|
|
// If our string becomes empty we ignore this. This can happen after
|
|
// a commit event when the preedit is being cleared and we don't want
|
|
// to set im_len to zero. This is safe because preeditstart always sets
|
|
// im_len to zero.
|
|
if (str.len == 0) return;
|
|
|
|
// Copy the preedit string into the im_buf. This is safe because
|
|
// commit will always overwrite this.
|
|
self.im_len = @intCast(@min(self.im_buf.len, str.len));
|
|
@memcpy(self.im_buf[0..self.im_len], str);
|
|
}
|
|
|
|
fn gtkInputPreeditEnd(
|
|
_: *c.GtkIMContext,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) void {
|
|
//log.debug("preedit end", .{});
|
|
const self = userdataSelf(ud.?);
|
|
if (!self.in_keypress) return;
|
|
self.im_composing = false;
|
|
}
|
|
|
|
fn gtkInputCommit(
|
|
_: *c.GtkIMContext,
|
|
bytes: [*:0]u8,
|
|
ud: ?*anyopaque,
|
|
) callconv(.C) void {
|
|
const self = userdataSelf(ud.?);
|
|
const str = std.mem.sliceTo(bytes, 0);
|
|
|
|
// If we're in a key event, then we want to buffer the commit so
|
|
// that we can send the proper keycallback followed by the char
|
|
// callback.
|
|
if (self.in_keypress) {
|
|
if (str.len <= self.im_buf.len) {
|
|
@memcpy(self.im_buf[0..str.len], str);
|
|
self.im_len = @intCast(str.len);
|
|
|
|
// log.debug("input commit len={}", .{self.im_len});
|
|
} else {
|
|
log.warn("not enough buffer space for input method commit", .{});
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// We're not in a keypress, so this was sent from an on-screen emoji
|
|
// keyboard or someting like that. Send the characters directly to
|
|
// the surface.
|
|
_ = self.core_surface.keyCallback(.{
|
|
.action = .press,
|
|
.key = .invalid,
|
|
.physical_key = .invalid,
|
|
.mods = .{},
|
|
.consumed_mods = .{},
|
|
.composing = false,
|
|
.utf8 = str,
|
|
}) catch |err| {
|
|
log.err("error in key callback err={}", .{err});
|
|
return;
|
|
};
|
|
}
|
|
|
|
fn gtkFocusEnter(_: *c.GtkEventControllerFocus, ud: ?*anyopaque) callconv(.C) void {
|
|
const self = userdataSelf(ud.?);
|
|
|
|
// Notify our IM context
|
|
c.gtk_im_context_focus_in(self.im_context);
|
|
|
|
// 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.?);
|
|
|
|
// Notify our IM context
|
|
c.gtk_im_context_focus_out(self.im_context);
|
|
|
|
self.core_surface.focusCallback(false) catch |err| {
|
|
log.err("error in focus callback err={}", .{err});
|
|
return;
|
|
};
|
|
}
|
|
|
|
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,
|
|
};
|
|
}
|
|
|
|
fn translateMods(state: c.GdkModifierType) input.Mods {
|
|
var mods: input.Mods = .{};
|
|
if (state & c.GDK_SHIFT_MASK != 0) mods.shift = true;
|
|
if (state & c.GDK_CONTROL_MASK != 0) mods.ctrl = true;
|
|
if (state & c.GDK_ALT_MASK != 0) mods.alt = true;
|
|
if (state & c.GDK_SUPER_MASK != 0) mods.super = true;
|
|
|
|
// Lock is dependent on the X settings but we just assume caps lock.
|
|
if (state & c.GDK_LOCK_MASK != 0) mods.caps_lock = true;
|
|
return mods;
|
|
}
|